src/mips/lithium-codegen-mips.cc - Issue 430503007: Rename ASSERT* to DCHECK*.

Unified Diff: src/mips/lithium-codegen-mips.cc

Issue 430503007: Rename ASSERT* to DCHECK*. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: REBASE and fixes Created 6 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/mips/lithium-codegen-mips.cc

diff --git a/src/mips/lithium-codegen-mips.cc b/src/mips/lithium-codegen-mips.cc

index 141466e8f8ad6e65b809bcf8df2b5de8de4b6f01..8cf77607ad06ea7074ed16992ed8f93ab1a66b05 100644

--- a/src/mips/lithium-codegen-mips.cc

+++ b/src/mips/lithium-codegen-mips.cc

@@ -64,7 +64,7 @@ class SafepointGenerator V8_FINAL : public CallWrapper {

bool LCodeGen::GenerateCode() {

LPhase phase("Z_Code generation", chunk());

- ASSERT(is_unused());

+ DCHECK(is_unused());

status_ = GENERATING;

// Open a frame scope to indicate that there is a frame on the stack. The

@@ -81,7 +81,7 @@ bool LCodeGen::GenerateCode() {

void LCodeGen::FinishCode(Handle<Code> code) {

- ASSERT(is_done());

+ DCHECK(is_done());

code->set_stack_slots(GetStackSlotCount());

code->set_safepoint_table_offset(safepoints_.GetCodeOffset());

if (code->is_optimized_code()) RegisterWeakObjectsInOptimizedCode(code);

@@ -90,8 +90,8 @@ void LCodeGen::FinishCode(Handle<Code> code) {

void LCodeGen::SaveCallerDoubles() {

- ASSERT(info()->saves_caller_doubles());

- ASSERT(NeedsEagerFrame());

+ DCHECK(info()->saves_caller_doubles());

+ DCHECK(NeedsEagerFrame());

Comment(";;; Save clobbered callee double registers");

int count = 0;

BitVector* doubles = chunk()->allocated_double_registers();

@@ -106,8 +106,8 @@ void LCodeGen::SaveCallerDoubles() {

void LCodeGen::RestoreCallerDoubles() {

- ASSERT(info()->saves_caller_doubles());

- ASSERT(NeedsEagerFrame());

+ DCHECK(info()->saves_caller_doubles());

+ DCHECK(NeedsEagerFrame());

Comment(";;; Restore clobbered callee double registers");

BitVector* doubles = chunk()->allocated_double_registers();

BitVector::Iterator save_iterator(doubles);

@@ -122,7 +122,7 @@ void LCodeGen::RestoreCallerDoubles() {

bool LCodeGen::GeneratePrologue() {

- ASSERT(is_generating());

+ DCHECK(is_generating());

if (info()->IsOptimizing()) {

ProfileEntryHookStub::MaybeCallEntryHook(masm_);

@@ -261,7 +261,7 @@ void LCodeGen::GenerateOsrPrologue() {

// Adjust the frame size, subsuming the unoptimized frame into the

// optimized frame.

int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();

- ASSERT(slots >= 0);

+ DCHECK(slots >= 0);

__ Subu(sp, sp, Operand(slots * kPointerSize));

}

@@ -277,7 +277,7 @@ void LCodeGen::GenerateBodyInstructionPre(LInstruction* instr) {

bool LCodeGen::GenerateDeferredCode() {

- ASSERT(is_generating());

+ DCHECK(is_generating());

if (deferred_.length() > 0) {

for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {

LDeferredCode* code = deferred_[i];

@@ -295,8 +295,8 @@ bool LCodeGen::GenerateDeferredCode() {

__ bind(code->entry());

if (NeedsDeferredFrame()) {

Comment(";;; Build frame");

- ASSERT(!frame_is_built_);

- ASSERT(info()->IsStub());

+ DCHECK(!frame_is_built_);

+ DCHECK(info()->IsStub());

frame_is_built_ = true;

__ MultiPush(cp.bit() | fp.bit() | ra.bit());

__ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));

@@ -307,7 +307,7 @@ bool LCodeGen::GenerateDeferredCode() {

code->Generate();

if (NeedsDeferredFrame()) {

Comment(";;; Destroy frame");

- ASSERT(frame_is_built_);

+ DCHECK(frame_is_built_);

__ pop(at);

__ MultiPop(cp.bit() | fp.bit() | ra.bit());

frame_is_built_ = false;

@@ -336,10 +336,10 @@ bool LCodeGen::GenerateDeoptJumpTable() {

__ bind(&deopt_jump_table_[i].label);

Deoptimizer::BailoutType type = deopt_jump_table_[i].bailout_type;

- ASSERT(type == deopt_jump_table_[0].bailout_type);

+ DCHECK(type == deopt_jump_table_[0].bailout_type);

Address entry = deopt_jump_table_[i].address;

int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);

- ASSERT(id != Deoptimizer::kNotDeoptimizationEntry);

+ DCHECK(id != Deoptimizer::kNotDeoptimizationEntry);

Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);

// Second-level deopt table entries are contiguous and small, so instead

@@ -348,7 +348,7 @@ bool LCodeGen::GenerateDeoptJumpTable() {

__ li(entry_offset, Operand(entry - base));

if (deopt_jump_table_[i].needs_frame) {

- ASSERT(!info()->saves_caller_doubles());

+ DCHECK(!info()->saves_caller_doubles());

if (needs_frame.is_bound()) {

__ Branch(&needs_frame);

} else {

@@ -358,7 +358,7 @@ bool LCodeGen::GenerateDeoptJumpTable() {

// This variant of deopt can only be used with stubs. Since we don't

// have a function pointer to install in the stack frame that we're

// building, install a special marker there instead.

- ASSERT(info()->IsStub());

+ DCHECK(info()->IsStub());

__ li(at, Operand(Smi::FromInt(StackFrame::STUB)));

__ push(at);

__ Addu(fp, sp,

@@ -384,7 +384,7 @@ bool LCodeGen::GenerateDeoptJumpTable() {

__ bind(&call_deopt_entry);

if (info()->saves_caller_doubles()) {

- ASSERT(info()->IsStub());

+ DCHECK(info()->IsStub());

RestoreCallerDoubles();

}

@@ -404,7 +404,7 @@ bool LCodeGen::GenerateDeoptJumpTable() {

bool LCodeGen::GenerateSafepointTable() {

- ASSERT(is_done());

+ DCHECK(is_done());

safepoints_.Emit(masm(), GetStackSlotCount());

return !is_aborted();

}

@@ -421,7 +421,7 @@ DoubleRegister LCodeGen::ToDoubleRegister(int index) const {

- ASSERT(op->IsRegister());

+ DCHECK(op->IsRegister());

return ToRegister(op->index());

}

@@ -435,15 +435,15 @@ Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {

Handle<Object> literal = constant->handle(isolate());

Representation r = chunk_->LookupLiteralRepresentation(const_op);

if (r.IsInteger32()) {

- ASSERT(literal->IsNumber());

+ DCHECK(literal->IsNumber());

__ li(scratch, Operand(static_cast<int32_t>(literal->Number())));

} else if (r.IsSmi()) {

- ASSERT(constant->HasSmiValue());

+ DCHECK(constant->HasSmiValue());

__ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));

} else if (r.IsDouble()) {

Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);

} else {

- ASSERT(r.IsSmiOrTagged());

+ DCHECK(r.IsSmiOrTagged());

__ li(scratch, literal);

}

return scratch;

@@ -457,7 +457,7 @@ Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {

DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {

- ASSERT(op->IsDoubleRegister());

+ DCHECK(op->IsDoubleRegister());

return ToDoubleRegister(op->index());

}

@@ -473,7 +473,7 @@ DoubleRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,

Handle<Object> literal = constant->handle(isolate());

Representation r = chunk_->LookupLiteralRepresentation(const_op);

if (r.IsInteger32()) {

- ASSERT(literal->IsNumber());

+ DCHECK(literal->IsNumber());

__ li(at, Operand(static_cast<int32_t>(literal->Number())));

__ mtc1(at, flt_scratch);

__ cvt_d_w(dbl_scratch, flt_scratch);

@@ -495,7 +495,7 @@ DoubleRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,

Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {

HConstant* constant = chunk_->LookupConstant(op);

- ASSERT(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());

+ DCHECK(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());

return constant->handle(isolate());

}

@@ -520,7 +520,7 @@ int32_t LCodeGen::ToRepresentation(LConstantOperand* op,

HConstant* constant = chunk_->LookupConstant(op);

int32_t value = constant->Integer32Value();

if (r.IsInteger32()) return value;

- ASSERT(r.IsSmiOrTagged());

+ DCHECK(r.IsSmiOrTagged());

return reinterpret_cast<int32_t>(Smi::FromInt(value));

}

@@ -533,7 +533,7 @@ Smi* LCodeGen::ToSmi(LConstantOperand* op) const {

double LCodeGen::ToDouble(LConstantOperand* op) const {

HConstant* constant = chunk_->LookupConstant(op);

- ASSERT(constant->HasDoubleValue());

+ DCHECK(constant->HasDoubleValue());

return constant->DoubleValue();

}

@@ -544,15 +544,15 @@ Operand LCodeGen::ToOperand(LOperand* op) {

HConstant* constant = chunk()->LookupConstant(const_op);

Representation r = chunk_->LookupLiteralRepresentation(const_op);

if (r.IsSmi()) {

- ASSERT(constant->HasSmiValue());

+ DCHECK(constant->HasSmiValue());

return Operand(Smi::FromInt(constant->Integer32Value()));

} else if (r.IsInteger32()) {

- ASSERT(constant->HasInteger32Value());

+ DCHECK(constant->HasInteger32Value());

return Operand(constant->Integer32Value());

} else if (r.IsDouble()) {

Abort(kToOperandUnsupportedDoubleImmediate);

}

- ASSERT(r.IsTagged());

+ DCHECK(r.IsTagged());

return Operand(constant->handle(isolate()));

} else if (op->IsRegister()) {

return Operand(ToRegister(op));

@@ -567,15 +567,15 @@ Operand LCodeGen::ToOperand(LOperand* op) {

static int ArgumentsOffsetWithoutFrame(int index) {

- ASSERT(index < 0);

+ DCHECK(index < 0);

return -(index + 1) * kPointerSize;

}

MemOperand LCodeGen::ToMemOperand(LOperand* op) const {

- ASSERT(!op->IsRegister());

- ASSERT(!op->IsDoubleRegister());

- ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());

+ DCHECK(!op->IsRegister());

+ DCHECK(!op->IsDoubleRegister());

+ DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());

if (NeedsEagerFrame()) {

return MemOperand(fp, StackSlotOffset(op->index()));

} else {

@@ -587,7 +587,7 @@ MemOperand LCodeGen::ToMemOperand(LOperand* op) const {

MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {

- ASSERT(op->IsDoubleStackSlot());

+ DCHECK(op->IsDoubleStackSlot());

if (NeedsEagerFrame()) {

return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);

} else {

@@ -623,13 +623,13 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

translation->BeginConstructStubFrame(closure_id, translation_size);

break;

case JS_GETTER:

- ASSERT(translation_size == 1);

- ASSERT(height == 0);

+ DCHECK(translation_size == 1);

+ DCHECK(height == 0);

translation->BeginGetterStubFrame(closure_id);

break;

case JS_SETTER:

- ASSERT(translation_size == 2);

- ASSERT(height == 0);

+ DCHECK(translation_size == 2);

+ DCHECK(height == 0);

translation->BeginSetterStubFrame(closure_id);

break;

case STUB:

@@ -734,7 +734,7 @@ void LCodeGen::CallCodeGeneric(Handle<Code> code,

RelocInfo::Mode mode,

LInstruction* instr,

SafepointMode safepoint_mode) {

- ASSERT(instr != NULL);

+ DCHECK(instr != NULL);

__ Call(code, mode);

RecordSafepointWithLazyDeopt(instr, safepoint_mode);

}

@@ -744,7 +744,7 @@ void LCodeGen::CallRuntime(const Runtime::Function* function,

int num_arguments,

LInstruction* instr,

SaveFPRegsMode save_doubles) {

- ASSERT(instr != NULL);

+ DCHECK(instr != NULL);

__ CallRuntime(function, num_arguments, save_doubles);

@@ -821,9 +821,9 @@ void LCodeGen::DeoptimizeIf(Condition condition,

const Operand& src2) {

RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);

- ASSERT(environment->HasBeenRegistered());

+ DCHECK(environment->HasBeenRegistered());

int id = environment->deoptimization_index();

- ASSERT(info()->IsOptimizing() || info()->IsStub());

+ DCHECK(info()->IsOptimizing() || info()->IsStub());

Address entry =

Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);

if (entry == NULL) {

@@ -859,7 +859,7 @@ void LCodeGen::DeoptimizeIf(Condition condition,

__ bind(&skip);

}

- ASSERT(info()->IsStub() || frame_is_built_);

+ DCHECK(info()->IsStub() || frame_is_built_);

// Go through jump table if we need to handle condition, build frame, or

// restore caller doubles.

if (condition == al && frame_is_built_ &&

@@ -948,7 +948,7 @@ int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {

void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {

- ASSERT(deoptimization_literals_.length() == 0);

+ DCHECK(deoptimization_literals_.length() == 0);

const ZoneList<Handle<JSFunction> >* inlined_closures =

chunk()->inlined_closures();

@@ -968,7 +968,7 @@ void LCodeGen::RecordSafepointWithLazyDeopt(

if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {

RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);

} else {

- ASSERT(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);

+ DCHECK(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);

RecordSafepointWithRegisters(

instr->pointer_map(), 0, Safepoint::kLazyDeopt);

}

@@ -980,7 +980,7 @@ void LCodeGen::RecordSafepoint(

Safepoint::Kind kind,

int arguments,

Safepoint::DeoptMode deopt_mode) {

- ASSERT(expected_safepoint_kind_ == kind);

+ DCHECK(expected_safepoint_kind_ == kind);

const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();

Safepoint safepoint = safepoints_.DefineSafepoint(masm(),

@@ -1069,8 +1069,8 @@ void LCodeGen::DoParameter(LParameter* instr) {

void LCodeGen::DoCallStub(LCallStub* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->result()).is(v0));

switch (instr->hydrogen()->major_key()) {

case CodeStub::RegExpExec: {

RegExpExecStub stub(isolate());

@@ -1101,7 +1101,7 @@ void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {

void LCodeGen::DoModByPowerOf2I(LModByPowerOf2I* instr) {

int32_t divisor = instr->divisor();

- ASSERT(dividend.is(ToRegister(instr->result())));

+ DCHECK(dividend.is(ToRegister(instr->result())));

// Theoretically, a variation of the branch-free code for integer division by

// a power of 2 (calculating the remainder via an additional multiplication

@@ -1135,7 +1135,7 @@ void LCodeGen::DoModByConstI(LModByConstI* instr) {

int32_t divisor = instr->divisor();

- ASSERT(!dividend.is(result));

+ DCHECK(!dividend.is(result));

if (divisor == 0) {

DeoptimizeIf(al, instr->environment());

@@ -1202,8 +1202,8 @@ void LCodeGen::DoDivByPowerOf2I(LDivByPowerOf2I* instr) {

int32_t divisor = instr->divisor();

- ASSERT(divisor == kMinInt || IsPowerOf2(Abs(divisor)));

- ASSERT(!result.is(dividend));

+ DCHECK(divisor == kMinInt || IsPowerOf2(Abs(divisor)));

+ DCHECK(!result.is(dividend));

// Check for (0 / -x) that will produce negative zero.

HDiv* hdiv = instr->hydrogen();

@@ -1246,7 +1246,7 @@ void LCodeGen::DoDivByConstI(LDivByConstI* instr) {

int32_t divisor = instr->divisor();

- ASSERT(!dividend.is(result));

+ DCHECK(!dividend.is(result));

if (divisor == 0) {

DeoptimizeIf(al, instr->environment());

@@ -1319,7 +1319,7 @@ void LCodeGen::DoMultiplyAddD(LMultiplyAddD* instr) {

DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());

// This is computed in-place.

- ASSERT(addend.is(ToDoubleRegister(instr->result())));

+ DCHECK(addend.is(ToDoubleRegister(instr->result())));

__ madd_d(addend, addend, multiplier, multiplicand);

}

@@ -1330,7 +1330,7 @@ void LCodeGen::DoFlooringDivByPowerOf2I(LFlooringDivByPowerOf2I* instr) {

int32_t divisor = instr->divisor();

- ASSERT(!result.is(dividend) || !scratch.is(dividend));

+ DCHECK(!result.is(dividend) || !scratch.is(dividend));

// If the divisor is 1, return the dividend.

if (divisor == 1) {

@@ -1386,7 +1386,7 @@ void LCodeGen::DoFlooringDivByConstI(LFlooringDivByConstI* instr) {

int32_t divisor = instr->divisor();

- ASSERT(!dividend.is(result));

+ DCHECK(!dividend.is(result));

if (divisor == 0) {

DeoptimizeIf(al, instr->environment());

@@ -1411,7 +1411,7 @@ void LCodeGen::DoFlooringDivByConstI(LFlooringDivByConstI* instr) {

// In the general case we may need to adjust before and after the truncating

// division to get a flooring division.

- ASSERT(!temp.is(dividend) && !temp.is(result));

+ DCHECK(!temp.is(dividend) && !temp.is(result));

Label needs_adjustment, done;

__ Branch(&needs_adjustment, divisor > 0 ? lt : gt,

dividend, Operand(zero_reg));

@@ -1546,7 +1546,7 @@ void LCodeGen::DoMulI(LMulI* instr) {

}

} else {

- ASSERT(right_op->IsRegister());

+ DCHECK(right_op->IsRegister());

if (overflow) {

@@ -1590,7 +1590,7 @@ void LCodeGen::DoMulI(LMulI* instr) {

void LCodeGen::DoBitI(LBitI* instr) {

LOperand* left_op = instr->left();

LOperand* right_op = instr->right();

- ASSERT(left_op->IsRegister());

+ DCHECK(left_op->IsRegister());

Operand right(no_reg);

@@ -1598,7 +1598,7 @@ void LCodeGen::DoBitI(LBitI* instr) {

if (right_op->IsStackSlot()) {

right = Operand(EmitLoadRegister(right_op, at));

} else {

- ASSERT(right_op->IsRegister() || right_op->IsConstantOperand());

+ DCHECK(right_op->IsRegister() || right_op->IsConstantOperand());

right = ToOperand(right_op);

}

@@ -1721,7 +1721,7 @@ void LCodeGen::DoSubI(LSubI* instr) {

__ Subu(ToRegister(result), ToRegister(left), Operand(right_reg));

} else {

- ASSERT(right->IsRegister() || right->IsConstantOperand());

+ DCHECK(right->IsRegister() || right->IsConstantOperand());

__ Subu(ToRegister(result), ToRegister(left), ToOperand(right));

}

} else { // can_overflow.

@@ -1734,7 +1734,7 @@ void LCodeGen::DoSubI(LSubI* instr) {

right_reg,

overflow); // Reg at also used as scratch.

} else {

- ASSERT(right->IsRegister());

+ DCHECK(right->IsRegister());

// Due to overflow check macros not supporting constant operands,

// handling the IsConstantOperand case was moved to prev if clause.

__ SubuAndCheckForOverflow(ToRegister(result),

@@ -1758,7 +1758,7 @@ void LCodeGen::DoConstantS(LConstantS* instr) {

void LCodeGen::DoConstantD(LConstantD* instr) {

- ASSERT(instr->result()->IsDoubleRegister());

+ DCHECK(instr->result()->IsDoubleRegister());

DoubleRegister result = ToDoubleRegister(instr->result());

double v = instr->value();

__ Move(result, v);

@@ -1790,10 +1790,10 @@ void LCodeGen::DoDateField(LDateField* instr) {

Smi* index = instr->index();

Label runtime, done;

- ASSERT(object.is(a0));

- ASSERT(result.is(v0));

- ASSERT(!scratch.is(scratch0()));

- ASSERT(!scratch.is(object));

+ DCHECK(object.is(a0));

+ DCHECK(result.is(v0));

+ DCHECK(!scratch.is(scratch0()));

+ DCHECK(!scratch.is(object));

__ SmiTst(object, at);

DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));

@@ -1834,8 +1834,8 @@ MemOperand LCodeGen::BuildSeqStringOperand(Register string,

return FieldMemOperand(string, SeqString::kHeaderSize + offset);

}

- ASSERT(!scratch.is(string));

- ASSERT(!scratch.is(ToRegister(index)));

+ DCHECK(!scratch.is(string));

+ DCHECK(!scratch.is(ToRegister(index)));

if (encoding == String::ONE_BYTE_ENCODING) {

__ Addu(scratch, string, ToRegister(index));

} else {

@@ -1911,7 +1911,7 @@ void LCodeGen::DoAddI(LAddI* instr) {

__ Addu(ToRegister(result), ToRegister(left), Operand(right_reg));

} else {

- ASSERT(right->IsRegister() || right->IsConstantOperand());

+ DCHECK(right->IsRegister() || right->IsConstantOperand());

__ Addu(ToRegister(result), ToRegister(left), ToOperand(right));

}

} else { // can_overflow.

@@ -1925,7 +1925,7 @@ void LCodeGen::DoAddI(LAddI* instr) {

right_reg,

overflow); // Reg at also used as scratch.

} else {

- ASSERT(right->IsRegister());

+ DCHECK(right->IsRegister());

// Due to overflow check macros not supporting constant operands,

// handling the IsConstantOperand case was moved to prev if clause.

__ AdduAndCheckForOverflow(ToRegister(result),

@@ -1954,12 +1954,12 @@ void LCodeGen::DoMathMinMax(LMathMinMax* instr) {

__ Movz(result_reg, left_reg, scratch);

__ Movn(result_reg, right_reg, scratch);

} else {

- ASSERT(condition == le);

+ DCHECK(condition == le);

__ Movn(result_reg, left_reg, scratch);

__ Movz(result_reg, right_reg, scratch);

}

} else {

- ASSERT(instr->hydrogen()->representation().IsDouble());

+ DCHECK(instr->hydrogen()->representation().IsDouble());

FPURegister left_reg = ToDoubleRegister(left);

FPURegister right_reg = ToDoubleRegister(right);

FPURegister result_reg = ToDoubleRegister(instr->result());

@@ -2041,10 +2041,10 @@ void LCodeGen::DoArithmeticD(LArithmeticD* instr) {

void LCodeGen::DoArithmeticT(LArithmeticT* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->left()).is(a1));

- ASSERT(ToRegister(instr->right()).is(a0));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->left()).is(a1));

+ DCHECK(ToRegister(instr->right()).is(a0));

+ DCHECK(ToRegister(instr->result()).is(v0));

BinaryOpICStub stub(isolate(), instr->op(), NO_OVERWRITE);

CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);

@@ -2131,36 +2131,36 @@ void LCodeGen::DoDebugBreak(LDebugBreak* instr) {

void LCodeGen::DoBranch(LBranch* instr) {

Representation r = instr->hydrogen()->value()->representation();

if (r.IsInteger32() || r.IsSmi()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

EmitBranch(instr, ne, reg, Operand(zero_reg));

} else if (r.IsDouble()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

DoubleRegister reg = ToDoubleRegister(instr->value());

// Test the double value. Zero and NaN are false.

EmitBranchF(instr, nue, reg, kDoubleRegZero);

} else {

- ASSERT(r.IsTagged());

+ DCHECK(r.IsTagged());

HType type = instr->hydrogen()->value()->type();

if (type.IsBoolean()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

__ LoadRoot(at, Heap::kTrueValueRootIndex);

EmitBranch(instr, eq, reg, Operand(at));

} else if (type.IsSmi()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

EmitBranch(instr, ne, reg, Operand(zero_reg));

} else if (type.IsJSArray()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

EmitBranch(instr, al, zero_reg, Operand(zero_reg));

} else if (type.IsHeapNumber()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

DoubleRegister dbl_scratch = double_scratch0();

__ ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));

// Test the double value. Zero and NaN are false.

EmitBranchF(instr, nue, dbl_scratch, kDoubleRegZero);

} else if (type.IsString()) {

- ASSERT(!info()->IsStub());

+ DCHECK(!info()->IsStub());

__ lw(at, FieldMemOperand(reg, String::kLengthOffset));

EmitBranch(instr, ne, at, Operand(zero_reg));

} else {

@@ -2390,7 +2390,7 @@ void LCodeGen::DoCmpHoleAndBranch(LCmpHoleAndBranch* instr) {

void LCodeGen::DoCompareMinusZeroAndBranch(LCompareMinusZeroAndBranch* instr) {

Representation rep = instr->hydrogen()->value()->representation();

- ASSERT(!rep.IsInteger32());

+ DCHECK(!rep.IsInteger32());

if (rep.IsDouble()) {

@@ -2524,7 +2524,7 @@ static Condition ComputeCompareCondition(Token::Value op) {

void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

Token::Value op = instr->op();

Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);

@@ -2540,7 +2540,7 @@ static InstanceType TestType(HHasInstanceTypeAndBranch* instr) {

InstanceType from = instr->from();

InstanceType to = instr->to();

if (from == FIRST_TYPE) return to;

- ASSERT(from == to || to == LAST_TYPE);

+ DCHECK(from == to || to == LAST_TYPE);

return from;

}

@@ -2603,9 +2603,9 @@ void LCodeGen::EmitClassOfTest(Label* is_true,

- ASSERT(!input.is(temp));

- ASSERT(!input.is(temp2));

- ASSERT(!temp.is(temp2));

+ DCHECK(!input.is(temp));

+ DCHECK(!input.is(temp2));

+ DCHECK(!temp.is(temp2));

__ JumpIfSmi(input, is_false);

@@ -2684,12 +2684,12 @@ void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {

void LCodeGen::DoInstanceOf(LInstanceOf* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

Label true_label, done;

- ASSERT(ToRegister(instr->left()).is(a0)); // Object is in a0.

- ASSERT(ToRegister(instr->right()).is(a1)); // Function is in a1.

+ DCHECK(ToRegister(instr->left()).is(a0)); // Object is in a0.

+ DCHECK(ToRegister(instr->right()).is(a1)); // Function is in a1.

- ASSERT(result.is(v0));

+ DCHECK(result.is(v0));

InstanceofStub stub(isolate(), InstanceofStub::kArgsInRegisters);

CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);

@@ -2728,8 +2728,8 @@ void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {

- ASSERT(object.is(a0));

- ASSERT(result.is(v0));

+ DCHECK(object.is(a0));

+ DCHECK(result.is(v0));

// A Smi is not instance of anything.

__ JumpIfSmi(object, &false_result);

@@ -2783,7 +2783,7 @@ void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {

void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,

Label* map_check) {

- ASSERT(result.is(v0));

+ DCHECK(result.is(v0));

InstanceofStub::Flags flags = InstanceofStub::kNoFlags;

flags = static_cast<InstanceofStub::Flags>(

@@ -2801,7 +2801,7 @@ void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,

// its slot of the pushing of safepoint registers is used to communicate the

// offset to the location of the map check.

- ASSERT(temp.is(t0));

+ DCHECK(temp.is(t0));

__ li(InstanceofStub::right(), instr->function());

static const int kAdditionalDelta = 7;

int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta;

@@ -2825,7 +2825,7 @@ void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,

void LCodeGen::DoCmpT(LCmpT* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

Token::Value op = instr->op();

Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);

@@ -2840,7 +2840,7 @@ void LCodeGen::DoCmpT(LCmpT* instr) {

__ Branch(USE_DELAY_SLOT, &done, condition, v0, Operand(zero_reg));

__ bind(&check);

__ LoadRoot(ToRegister(instr->result()), Heap::kTrueValueRootIndex);

- ASSERT_EQ(1, masm()->InstructionsGeneratedSince(&check));

+ DCHECK_EQ(1, masm()->InstructionsGeneratedSince(&check));

__ LoadRoot(ToRegister(instr->result()), Heap::kFalseValueRootIndex);

__ bind(&done);

}

@@ -2899,17 +2899,17 @@ void LCodeGen::DoLoadGlobalCell(LLoadGlobalCell* instr) {

void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->global_object()).is(LoadIC::ReceiverRegister()));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->global_object()).is(LoadIC::ReceiverRegister()));

+ DCHECK(ToRegister(instr->result()).is(v0));

__ li(LoadIC::NameRegister(), Operand(instr->name()));

if (FLAG_vector_ics) {

- ASSERT(vector.is(LoadIC::VectorRegister()));

+ DCHECK(vector.is(LoadIC::VectorRegister()));

__ li(vector, instr->hydrogen()->feedback_vector());

// No need to allocate this register.

- ASSERT(LoadIC::SlotRegister().is(a0));

+ DCHECK(LoadIC::SlotRegister().is(a0));

__ li(LoadIC::SlotRegister(),

Operand(Smi::FromInt(instr->hydrogen()->slot())));

}

@@ -3032,18 +3032,18 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {

void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->object()).is(LoadIC::ReceiverRegister()));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->object()).is(LoadIC::ReceiverRegister()));

+ DCHECK(ToRegister(instr->result()).is(v0));

// Name is always in a2.

__ li(LoadIC::NameRegister(), Operand(instr->name()));

if (FLAG_vector_ics) {

- ASSERT(vector.is(LoadIC::VectorRegister()));

+ DCHECK(vector.is(LoadIC::VectorRegister()));

__ li(vector, instr->hydrogen()->feedback_vector());

// No need to allocate this register.

- ASSERT(LoadIC::SlotRegister().is(a0));

+ DCHECK(LoadIC::SlotRegister().is(a0));

__ li(LoadIC::SlotRegister(),

Operand(Smi::FromInt(instr->hydrogen()->slot())));

}

@@ -3326,7 +3326,7 @@ MemOperand LCodeGen::PrepareKeyedOperand(Register key,

__ Addu(scratch0(), base, scratch0());

return MemOperand(scratch0());

} else {

- ASSERT_EQ(-1, shift_size);

+ DCHECK_EQ(-1, shift_size);

__ srl(scratch0(), key, 1);

__ Addu(scratch0(), base, scratch0());

return MemOperand(scratch0());

@@ -3338,7 +3338,7 @@ MemOperand LCodeGen::PrepareKeyedOperand(Register key,

__ Addu(scratch0(), base, scratch0());

return MemOperand(scratch0(), base_offset);

} else {

- ASSERT_EQ(-1, shift_size);

+ DCHECK_EQ(-1, shift_size);

__ sra(scratch0(), key, 1);

__ Addu(scratch0(), base, scratch0());

return MemOperand(scratch0(), base_offset);

@@ -3347,16 +3347,16 @@ MemOperand LCodeGen::PrepareKeyedOperand(Register key,

void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->object()).is(LoadIC::ReceiverRegister()));

- ASSERT(ToRegister(instr->key()).is(LoadIC::NameRegister()));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->object()).is(LoadIC::ReceiverRegister()));

+ DCHECK(ToRegister(instr->key()).is(LoadIC::NameRegister()));

if (FLAG_vector_ics) {

- ASSERT(vector.is(LoadIC::VectorRegister()));

+ DCHECK(vector.is(LoadIC::VectorRegister()));

__ li(vector, instr->hydrogen()->feedback_vector());

// No need to allocate this register.

- ASSERT(LoadIC::SlotRegister().is(a0));

+ DCHECK(LoadIC::SlotRegister().is(a0));

__ li(LoadIC::SlotRegister(),

Operand(Smi::FromInt(instr->hydrogen()->slot())));

}

@@ -3476,9 +3476,9 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) {

- ASSERT(receiver.is(a0)); // Used for parameter count.

- ASSERT(function.is(a1)); // Required by InvokeFunction.

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(receiver.is(a0)); // Used for parameter count.

+ DCHECK(function.is(a1)); // Required by InvokeFunction.

+ DCHECK(ToRegister(instr->result()).is(v0));

// Copy the arguments to this function possibly from the

// adaptor frame below it.

@@ -3507,7 +3507,7 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) {

__ sll(scratch, length, 2);

__ bind(&invoke);

- ASSERT(instr->HasPointerMap());

+ DCHECK(instr->HasPointerMap());

LPointerMap* pointers = instr->pointer_map();

SafepointGenerator safepoint_generator(

this, pointers, Safepoint::kLazyDeopt);

@@ -3547,13 +3547,13 @@ void LCodeGen::DoContext(LContext* instr) {

__ lw(result, MemOperand(fp, StandardFrameConstants::kContextOffset));

} else {

// If there is no frame, the context must be in cp.

- ASSERT(result.is(cp));

+ DCHECK(result.is(cp));

}

void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

__ li(scratch0(), instr->hydrogen()->pairs());

__ li(scratch1(), Operand(Smi::FromInt(instr->hydrogen()->flags())));

// The context is the first argument.

@@ -3604,8 +3604,8 @@ void LCodeGen::CallKnownFunction(Handle<JSFunction> function,

void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr) {

- ASSERT(instr->context() != NULL);

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(instr->context() != NULL);

+ DCHECK(ToRegister(instr->context()).is(cp));

@@ -3844,7 +3844,7 @@ void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {

DoubleRegister result = ToDoubleRegister(instr->result());

DoubleRegister temp = ToDoubleRegister(instr->temp());

- ASSERT(!input.is(result));

+ DCHECK(!input.is(result));

// Note that according to ECMA-262 15.8.2.13:

// Math.pow(-Infinity, 0.5) == Infinity

@@ -3867,12 +3867,12 @@ void LCodeGen::DoPower(LPower* instr) {

Representation exponent_type = instr->hydrogen()->right()->representation();

// Having marked this as a call, we can use any registers.

// Just make sure that the input/output registers are the expected ones.

- ASSERT(!instr->right()->IsDoubleRegister() ||

+ DCHECK(!instr->right()->IsDoubleRegister() ||

ToDoubleRegister(instr->right()).is(f4));

- ASSERT(!instr->right()->IsRegister() ||

+ DCHECK(!instr->right()->IsRegister() ||

ToRegister(instr->right()).is(a2));

- ASSERT(ToDoubleRegister(instr->left()).is(f2));

- ASSERT(ToDoubleRegister(instr->result()).is(f0));

+ DCHECK(ToDoubleRegister(instr->left()).is(f2));

+ DCHECK(ToDoubleRegister(instr->result()).is(f0));

if (exponent_type.IsSmi()) {

MathPowStub stub(isolate(), MathPowStub::TAGGED);

@@ -3890,7 +3890,7 @@ void LCodeGen::DoPower(LPower* instr) {

MathPowStub stub(isolate(), MathPowStub::INTEGER);

__ CallStub(&stub);

} else {

- ASSERT(exponent_type.IsDouble());

+ DCHECK(exponent_type.IsDouble());

MathPowStub stub(isolate(), MathPowStub::DOUBLE);

__ CallStub(&stub);

}

@@ -3928,9 +3928,9 @@ void LCodeGen::DoMathClz32(LMathClz32* instr) {

void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->function()).is(a1));

- ASSERT(instr->HasPointerMap());

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->function()).is(a1));

+ DCHECK(instr->HasPointerMap());

Handle<JSFunction> known_function = instr->hydrogen()->known_function();

if (known_function.is_null()) {

@@ -3949,7 +3949,7 @@ void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {

void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->result()).is(v0));

LPointerMap* pointers = instr->pointer_map();

SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);

@@ -3960,7 +3960,7 @@ void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {

generator.BeforeCall(__ CallSize(code, RelocInfo::CODE_TARGET));

__ Call(code, RelocInfo::CODE_TARGET);

} else {

- ASSERT(instr->target()->IsRegister());

+ DCHECK(instr->target()->IsRegister());

generator.BeforeCall(__ CallSize(target));

__ Addu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));

@@ -3971,8 +3971,8 @@ void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {

void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) {

- ASSERT(ToRegister(instr->function()).is(a1));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->function()).is(a1));

+ DCHECK(ToRegister(instr->result()).is(v0));

if (instr->hydrogen()->pass_argument_count()) {

__ li(a0, Operand(instr->arity()));

@@ -3990,9 +3990,9 @@ void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) {

void LCodeGen::DoCallFunction(LCallFunction* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->function()).is(a1));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->function()).is(a1));

+ DCHECK(ToRegister(instr->result()).is(v0));

int arity = instr->arity();

CallFunctionStub stub(isolate(), arity, instr->hydrogen()->function_flags());

@@ -4001,9 +4001,9 @@ void LCodeGen::DoCallFunction(LCallFunction* instr) {

void LCodeGen::DoCallNew(LCallNew* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->constructor()).is(a1));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->constructor()).is(a1));

+ DCHECK(ToRegister(instr->result()).is(v0));

__ li(a0, Operand(instr->arity()));

// No cell in a2 for construct type feedback in optimized code

@@ -4014,9 +4014,9 @@ void LCodeGen::DoCallNew(LCallNew* instr) {

void LCodeGen::DoCallNewArray(LCallNewArray* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->constructor()).is(a1));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->constructor()).is(a1));

+ DCHECK(ToRegister(instr->result()).is(v0));

__ li(a0, Operand(instr->arity()));

__ LoadRoot(a2, Heap::kUndefinedValueRootIndex);

@@ -4102,13 +4102,13 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {

__ AssertNotSmi(object);

- ASSERT(!representation.IsSmi() ||

+ DCHECK(!representation.IsSmi() ||

!instr->value()->IsConstantOperand() ||

IsSmi(LConstantOperand::cast(instr->value())));

if (representation.IsDouble()) {

- ASSERT(access.IsInobject());

- ASSERT(!instr->hydrogen()->has_transition());

- ASSERT(!instr->hydrogen()->NeedsWriteBarrier());

+ DCHECK(access.IsInobject());

+ DCHECK(!instr->hydrogen()->has_transition());

+ DCHECK(!instr->hydrogen()->NeedsWriteBarrier());

DoubleRegister value = ToDoubleRegister(instr->value());

__ sdc1(value, FieldMemOperand(object, offset));

return;

@@ -4169,9 +4169,9 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {

void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->object()).is(StoreIC::ReceiverRegister()));

- ASSERT(ToRegister(instr->value()).is(StoreIC::ValueRegister()));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->object()).is(StoreIC::ReceiverRegister()));

+ DCHECK(ToRegister(instr->value()).is(StoreIC::ValueRegister()));

__ li(StoreIC::NameRegister(), Operand(instr->name()));

Handle<Code> ic = StoreIC::initialize_stub(isolate(), instr->strict_mode());

@@ -4350,7 +4350,7 @@ void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {

// Do the store.

if (instr->key()->IsConstantOperand()) {

- ASSERT(!instr->hydrogen()->NeedsWriteBarrier());

+ DCHECK(!instr->hydrogen()->NeedsWriteBarrier());

LConstantOperand* const_operand = LConstantOperand::cast(instr->key());

offset += ToInteger32(const_operand) * kPointerSize;

store_base = elements;

@@ -4400,10 +4400,10 @@ void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {

void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->object()).is(KeyedStoreIC::ReceiverRegister()));

- ASSERT(ToRegister(instr->key()).is(KeyedStoreIC::NameRegister()));

- ASSERT(ToRegister(instr->value()).is(KeyedStoreIC::ValueRegister()));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->object()).is(KeyedStoreIC::ReceiverRegister()));

+ DCHECK(ToRegister(instr->key()).is(KeyedStoreIC::NameRegister()));

+ DCHECK(ToRegister(instr->value()).is(KeyedStoreIC::ValueRegister()));

Handle<Code> ic = (instr->strict_mode() == STRICT)

? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()

@@ -4436,8 +4436,8 @@ void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {

GetRAState(),

kDontSaveFPRegs);

} else {

- ASSERT(object_reg.is(a0));

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(object_reg.is(a0));

+ DCHECK(ToRegister(instr->context()).is(cp));

PushSafepointRegistersScope scope(this);

__ li(a1, Operand(to_map));

bool is_js_array = from_map->instance_type() == JS_ARRAY_TYPE;

@@ -4462,9 +4462,9 @@ void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {

void LCodeGen::DoStringAdd(LStringAdd* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

- ASSERT(ToRegister(instr->left()).is(a1));

- ASSERT(ToRegister(instr->right()).is(a0));

+ DCHECK(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->left()).is(a1));

+ DCHECK(ToRegister(instr->right()).is(a0));

StringAddStub stub(isolate(),

instr->hydrogen()->flags(),

instr->hydrogen()->pretenure_flag());

@@ -4543,11 +4543,11 @@ void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {

DeferredStringCharFromCode* deferred =

new(zone()) DeferredStringCharFromCode(this, instr);

- ASSERT(instr->hydrogen()->value()->representation().IsInteger32());

+ DCHECK(instr->hydrogen()->value()->representation().IsInteger32());

- ASSERT(!char_code.is(result));

+ DCHECK(!char_code.is(result));

__ Branch(deferred->entry(), hi,

char_code, Operand(String::kMaxOneByteCharCode));

@@ -4580,9 +4580,9 @@ void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {

void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {

LOperand* input = instr->value();

- ASSERT(input->IsRegister() || input->IsStackSlot());

+ DCHECK(input->IsRegister() || input->IsStackSlot());

LOperand* output = instr->result();

- ASSERT(output->IsDoubleRegister());

+ DCHECK(output->IsDoubleRegister());

FPURegister single_scratch = double_scratch0().low();

if (input->IsStackSlot()) {

@@ -4858,7 +4858,7 @@ void LCodeGen::EmitNumberUntagD(Register input_reg,

}

} else {

__ SmiUntag(scratch, input_reg);

- ASSERT(mode == NUMBER_CANDIDATE_IS_SMI);

+ DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);

}

// Smi to double register conversion

__ bind(&load_smi);

@@ -4876,8 +4876,8 @@ void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {

DoubleRegister double_scratch = double_scratch0();

DoubleRegister double_scratch2 = ToDoubleRegister(instr->temp2());

- ASSERT(!scratch1.is(input_reg) && !scratch1.is(scratch2));

- ASSERT(!scratch2.is(input_reg) && !scratch2.is(scratch1));

+ DCHECK(!scratch1.is(input_reg) && !scratch1.is(scratch2));

+ DCHECK(!scratch2.is(input_reg) && !scratch2.is(scratch1));

Label done;

@@ -4903,7 +4903,7 @@ void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {

__ bind(&no_heap_number);

__ LoadRoot(at, Heap::kUndefinedValueRootIndex);

__ Branch(&check_bools, ne, input_reg, Operand(at));

- ASSERT(ToRegister(instr->result()).is(input_reg));

+ DCHECK(ToRegister(instr->result()).is(input_reg));

__ Branch(USE_DELAY_SLOT, &done);

__ mov(input_reg, zero_reg); // In delay slot.

@@ -4964,8 +4964,8 @@ void LCodeGen::DoTaggedToI(LTaggedToI* instr) {

};

LOperand* input = instr->value();

- ASSERT(input->IsRegister());

- ASSERT(input->Equals(instr->result()));

+ DCHECK(input->IsRegister());

+ DCHECK(input->Equals(instr->result()));

@@ -4986,9 +4986,9 @@ void LCodeGen::DoTaggedToI(LTaggedToI* instr) {

void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {

LOperand* input = instr->value();

- ASSERT(input->IsRegister());

+ DCHECK(input->IsRegister());

LOperand* result = instr->result();

- ASSERT(result->IsDoubleRegister());

+ DCHECK(result->IsDoubleRegister());

DoubleRegister result_reg = ToDoubleRegister(result);

@@ -5116,7 +5116,7 @@ void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {

instr->hydrogen()->GetCheckMaskAndTag(&mask, &tag);

if (IsPowerOf2(mask)) {

- ASSERT(tag == 0 || IsPowerOf2(tag));

+ DCHECK(tag == 0 || IsPowerOf2(tag));

__ And(at, scratch, mask);

DeoptimizeIf(tag == 0 ? ne : eq, instr->environment(),

at, Operand(zero_reg));

@@ -5189,7 +5189,7 @@ void LCodeGen::DoCheckMaps(LCheckMaps* instr) {

LOperand* input = instr->value();

- ASSERT(input->IsRegister());

+ DCHECK(input->IsRegister());

__ lw(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));

@@ -5312,11 +5312,11 @@ void LCodeGen::DoAllocate(LAllocate* instr) {

flags = static_cast<AllocationFlags>(flags | DOUBLE_ALIGNMENT);

}

if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {

- ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());

- ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsOldDataSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());

flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE);

} else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {

- ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());

flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_DATA_SPACE);

}

if (instr->size()->IsConstantOperand()) {

@@ -5363,7 +5363,7 @@ void LCodeGen::DoDeferredAllocate(LAllocate* instr) {

PushSafepointRegistersScope scope(this);

if (instr->size()->IsRegister()) {

- ASSERT(!size.is(result));

+ DCHECK(!size.is(result));

__ SmiTag(size);

__ push(size);

} else {

@@ -5380,11 +5380,11 @@ void LCodeGen::DoDeferredAllocate(LAllocate* instr) {

int flags = AllocateDoubleAlignFlag::encode(

instr->hydrogen()->MustAllocateDoubleAligned());

if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {

- ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());

- ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsOldDataSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());

flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);

} else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {

- ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());

+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());

flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);

} else {

flags = AllocateTargetSpace::update(flags, NEW_SPACE);

@@ -5398,15 +5398,15 @@ void LCodeGen::DoDeferredAllocate(LAllocate* instr) {

void LCodeGen::DoToFastProperties(LToFastProperties* instr) {

- ASSERT(ToRegister(instr->value()).is(a0));

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->value()).is(a0));

+ DCHECK(ToRegister(instr->result()).is(v0));

__ push(a0);

CallRuntime(Runtime::kToFastProperties, 1, instr);

}

void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

Label materialized;

// Registers will be used as follows:

// t3 = literals array.

@@ -5459,7 +5459,7 @@ void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {

void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(ToRegister(instr->context()).is(cp));

// Use the fast case closure allocation code that allocates in new

// space for nested functions that don't need literals cloning.

bool pretenure = instr->hydrogen()->pretenure();

@@ -5480,7 +5480,7 @@ void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {

void LCodeGen::DoTypeof(LTypeof* instr) {

- ASSERT(ToRegister(instr->result()).is(v0));

+ DCHECK(ToRegister(instr->result()).is(v0));

__ push(input);

CallRuntime(Runtime::kTypeof, 1, instr);

@@ -5500,8 +5500,8 @@ void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {

&cmp1,

&cmp2);

- ASSERT(cmp1.is_valid());

- ASSERT(!cmp2.is_reg() || cmp2.rm().is_valid());

+ DCHECK(cmp1.is_valid());

+ DCHECK(!cmp2.is_reg() || cmp2.rm().is_valid());

if (final_branch_condition != kNoCondition) {

EmitBranch(instr, final_branch_condition, cmp1, cmp2);

@@ -5619,7 +5619,7 @@ void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {

void LCodeGen::EmitIsConstructCall(Register temp1, Register temp2) {

- ASSERT(!temp1.is(temp2));

+ DCHECK(!temp1.is(temp2));

// Get the frame pointer for the calling frame.

__ lw(temp1, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));

@@ -5643,7 +5643,7 @@ void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {

int current_pc = masm()->pc_offset();

if (current_pc < last_lazy_deopt_pc_ + space_needed) {

int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;

- ASSERT_EQ(0, padding_size % Assembler::kInstrSize);

+ DCHECK_EQ(0, padding_size % Assembler::kInstrSize);

while (padding_size > 0) {

__ nop();

padding_size -= Assembler::kInstrSize;

@@ -5656,7 +5656,7 @@ void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {

void LCodeGen::DoLazyBailout(LLazyBailout* instr) {

last_lazy_deopt_pc_ = masm()->pc_offset();

- ASSERT(instr->HasEnvironment());

+ DCHECK(instr->HasEnvironment());

LEnvironment* env = instr->environment();

RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);

safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());

@@ -5694,7 +5694,7 @@ void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {

__ CallRuntimeSaveDoubles(Runtime::kStackGuard);

RecordSafepointWithLazyDeopt(

instr, RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);

- ASSERT(instr->HasEnvironment());

+ DCHECK(instr->HasEnvironment());

LEnvironment* env = instr->environment();

safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());

}

@@ -5713,7 +5713,7 @@ void LCodeGen::DoStackCheck(LStackCheck* instr) {

LStackCheck* instr_;

};

- ASSERT(instr->HasEnvironment());

+ DCHECK(instr->HasEnvironment());

LEnvironment* env = instr->environment();

// There is no LLazyBailout instruction for stack-checks. We have to

// prepare for lazy deoptimization explicitly here.

@@ -5722,14 +5722,14 @@ void LCodeGen::DoStackCheck(LStackCheck* instr) {

Label done;

__ LoadRoot(at, Heap::kStackLimitRootIndex);

__ Branch(&done, hs, sp, Operand(at));

- ASSERT(instr->context()->IsRegister());

- ASSERT(ToRegister(instr->context()).is(cp));

+ DCHECK(instr->context()->IsRegister());

+ DCHECK(ToRegister(instr->context()).is(cp));

CallCode(isolate()->builtins()->StackCheck(),

RelocInfo::CODE_TARGET,

instr);

__ bind(&done);

} else {

- ASSERT(instr->hydrogen()->is_backwards_branch());

+ DCHECK(instr->hydrogen()->is_backwards_branch());

// Perform stack overflow check if this goto needs it before jumping.

DeferredStackCheck* deferred_stack_check =

new(zone()) DeferredStackCheck(this, instr);

@@ -5754,7 +5754,7 @@ void LCodeGen::DoOsrEntry(LOsrEntry* instr) {

// If the environment were already registered, we would have no way of

// backpatching it with the spill slot operands.

- ASSERT(!environment->HasBeenRegistered());

+ DCHECK(!environment->HasBeenRegistered());

RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);

GenerateOsrPrologue();

@@ -5779,7 +5779,7 @@ void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {

DeoptimizeIf(le, instr->environment(), a1, Operand(LAST_JS_PROXY_TYPE));

Label use_cache, call_runtime;

- ASSERT(object.is(a0));

+ DCHECK(object.is(a0));

__ CheckEnumCache(null_value, &call_runtime);

__ lw(result, FieldMemOperand(object, HeapObject::kMapOffset));

@@ -5791,7 +5791,7 @@ void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {

CallRuntime(Runtime::kGetPropertyNamesFast, 1, instr);

__ lw(a1, FieldMemOperand(v0, HeapObject::kMapOffset));

- ASSERT(result.is(v0));

+ DCHECK(result.is(v0));

__ LoadRoot(at, Heap::kMetaMapRootIndex);

DeoptimizeIf(ne, instr->environment(), a1, Operand(at));

__ bind(&use_cache);

« no previous file with comments | « src/mips/lithium-codegen-mips.h ('k') | src/mips/lithium-gap-resolver-mips.cc » ('j') | no next file with comments »