src/x64/lithium-codegen-x64.cc - Issue 11028027: Revert trunk to bleeding_edge at r12484

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

Issue 11028027: Revert trunk to bleeding_edge at r12484 (Closed) Base URL: https://v8.googlecode.com/svn/trunk

Patch Set: Created 8 years, 2 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/x64/lithium-codegen-x64.cc

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

index 8547b09be29686c301e6ad10f4d38b6c75175de8..89e311e4614b10cfe000b417a61c3bf7515b9c85 100644

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

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

@@ -351,9 +351,7 @@ Operand LCodeGen::ToOperand(LOperand* op) const {

void LCodeGen::WriteTranslation(LEnvironment* environment,

- Translation* translation,

- int* arguments_index,

- int* arguments_count) {

+ Translation* translation) {

if (environment == NULL) return;

// The translation includes one command per value in the environment.

@@ -361,17 +359,7 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

// The output frame height does not include the parameters.

int height = translation_size - environment->parameter_count();

- // Function parameters are arguments to the outermost environment. The

- // arguments index points to the first element of a sequence of tagged

- // values on the stack that represent the arguments. This needs to be

- // kept in sync with the LArgumentsElements implementation.

- *arguments_index = -environment->parameter_count();

- *arguments_count = environment->parameter_count();

- WriteTranslation(environment->outer(),

- translation,

- arguments_index,

- arguments_count);

+ WriteTranslation(environment->outer(), translation);

int closure_id = *info()->closure() != *environment->closure()

? DefineDeoptimizationLiteral(environment->closure())

: Translation::kSelfLiteralId;

@@ -397,17 +385,6 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);

break;

}

- // Inlined frames which push their arguments cause the index to be

- // bumped and a new stack area to be used for materialization.

- if (environment->entry() != NULL &&

- environment->entry()->arguments_pushed()) {

- *arguments_index = *arguments_index < 0

- ? GetStackSlotCount()

- : *arguments_index + *arguments_count;

- *arguments_count = environment->entry()->arguments_count() + 1;

- }

for (int i = 0; i < translation_size; ++i) {

LOperand* value = environment->values()->at(i);

// spilled_registers_ and spilled_double_registers_ are either

@@ -419,9 +396,7 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

AddToTranslation(translation,

environment->spilled_registers()[value->index()],

environment->HasTaggedValueAt(i),

- environment->HasUint32ValueAt(i),

- *arguments_index,

- *arguments_count);

+ environment->HasUint32ValueAt(i));

} else if (

value->IsDoubleRegister() &&

environment->spilled_double_registers()[value->index()] != NULL) {

@@ -430,18 +405,14 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

translation,

environment->spilled_double_registers()[value->index()],

false,

- false,

- *arguments_index,

- *arguments_count);

+ false);

}

AddToTranslation(translation,

value,

environment->HasTaggedValueAt(i),

- environment->HasUint32ValueAt(i),

- *arguments_index,

- *arguments_count);

+ environment->HasUint32ValueAt(i));

}

@@ -449,14 +420,12 @@ void LCodeGen::WriteTranslation(LEnvironment* environment,

void LCodeGen::AddToTranslation(Translation* translation,

LOperand* op,

bool is_tagged,

- bool is_uint32,

- int arguments_index,

- int arguments_count) {

+ bool is_uint32) {

if (op == NULL) {

// TODO(twuerthinger): Introduce marker operands to indicate that this value

// is not present and must be reconstructed from the deoptimizer. Currently

// this is only used for the arguments object.

- translation->StoreArgumentsObject(arguments_index, arguments_count);

+ translation->StoreArgumentsObject();

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

if (is_tagged) {

translation->StoreStackSlot(op->index());

@@ -562,16 +531,15 @@ void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,

int frame_count = 0;

int jsframe_count = 0;

- int args_index = 0;

- int args_count = 0;

for (LEnvironment* e = environment; e != NULL; e = e->outer()) {

++frame_count;

if (e->frame_type() == JS_FUNCTION) {

++jsframe_count;

}

- Translation translation(&translations_, frame_count, jsframe_count, zone());

- WriteTranslation(environment, &translation, &args_index, &args_count);

+ Translation translation(&translations_, frame_count, jsframe_count,

+ environment->zone());

+ WriteTranslation(environment, &translation);

int deoptimization_index = deoptimizations_.length();

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

environment->Register(deoptimization_index,

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

void LCodeGen::DoModI(LModI* instr) {

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

- Register dividend = ToRegister(instr->left());

+ Register dividend = ToRegister(instr->InputAt(0));

int32_t divisor =

HConstant::cast(instr->hydrogen()->right())->Integer32Value();

@@ -842,8 +810,8 @@ void LCodeGen::DoModI(LModI* instr) {

__ bind(&done);

} else {

Label done, remainder_eq_dividend, slow, do_subtraction, both_positive;

- Register left_reg = ToRegister(instr->left());

- Register right_reg = ToRegister(instr->right());

+ Register left_reg = ToRegister(instr->InputAt(0));

+ Register right_reg = ToRegister(instr->InputAt(1));

ASSERT(left_reg.is(rax));

@@ -873,7 +841,7 @@ void LCodeGen::DoModI(LModI* instr) {

__ j(less, &remainder_eq_dividend, Label::kNear);

// Check if the divisor is a PowerOfTwo integer.

- Register scratch = ToRegister(instr->temp());

+ Register scratch = ToRegister(instr->TempAt(0));

__ movl(scratch, right_reg);

__ subl(scratch, Immediate(1));

__ testl(scratch, right_reg);

@@ -930,10 +898,10 @@ void LCodeGen::DoModI(LModI* instr) {

void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {

- ASSERT(instr->right()->IsConstantOperand());

+ ASSERT(instr->InputAt(1)->IsConstantOperand());

- const Register dividend = ToRegister(instr->left());

- int32_t divisor = ToInteger32(LConstantOperand::cast(instr->right()));

+ const Register dividend = ToRegister(instr->InputAt(0));

+ int32_t divisor = ToInteger32(LConstantOperand::cast(instr->InputAt(1)));

const Register result = ToRegister(instr->result());

switch (divisor) {

@@ -978,7 +946,7 @@ void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {

__ sarl(result, Immediate(power));

}

} else {

- Register reg1 = ToRegister(instr->temp());

+ Register reg1 = ToRegister(instr->TempAt(0));

// Find b which: 2^b < divisor_abs < 2^(b+1).

@@ -1013,11 +981,11 @@ void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {

void LCodeGen::DoDivI(LDivI* instr) {

- LOperand* right = instr->right();

+ LOperand* right = instr->InputAt(1);

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

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

- ASSERT(!ToRegister(instr->right()).is(rax));

- ASSERT(!ToRegister(instr->right()).is(rdx));

+ ASSERT(ToRegister(instr->InputAt(0)).is(rax));

+ ASSERT(!ToRegister(instr->InputAt(1)).is(rax));

+ ASSERT(!ToRegister(instr->InputAt(1)).is(rdx));

@@ -1059,8 +1027,8 @@ void LCodeGen::DoDivI(LDivI* instr) {

void LCodeGen::DoMulI(LMulI* instr) {

- Register left = ToRegister(instr->left());

- LOperand* right = instr->right();

+ Register left = ToRegister(instr->InputAt(0));

+ LOperand* right = instr->InputAt(1);

if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {

__ movl(kScratchRegister, left);

@@ -1125,11 +1093,8 @@ void LCodeGen::DoMulI(LMulI* instr) {

__ testl(left, left);

__ j(not_zero, &done, Label::kNear);

if (right->IsConstantOperand()) {

- if (ToInteger32(LConstantOperand::cast(right)) < 0) {

+ if (ToInteger32(LConstantOperand::cast(right)) <= 0) {

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

- } else if (ToInteger32(LConstantOperand::cast(right)) == 0) {

- __ cmpl(kScratchRegister, Immediate(0));

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

}

} else if (right->IsStackSlot()) {

__ orl(kScratchRegister, ToOperand(right));

@@ -1145,8 +1110,8 @@ void LCodeGen::DoMulI(LMulI* instr) {

void LCodeGen::DoBitI(LBitI* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

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

ASSERT(left->IsRegister());

@@ -1202,8 +1167,8 @@ void LCodeGen::DoBitI(LBitI* instr) {

void LCodeGen::DoShiftI(LShiftI* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

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

ASSERT(left->IsRegister());

if (right->IsRegister()) {

@@ -1258,8 +1223,8 @@ void LCodeGen::DoShiftI(LShiftI* instr) {

void LCodeGen::DoSubI(LSubI* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

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

if (right->IsConstantOperand()) {

@@ -1293,7 +1258,7 @@ void LCodeGen::DoConstantD(LConstantD* instr) {

if (int_val == 0) {

__ xorps(res, res);

} else {

- Register tmp = ToRegister(instr->temp());

+ Register tmp = ToRegister(instr->TempAt(0));

__ Set(tmp, int_val);

__ movq(res, tmp);

}

@@ -1313,28 +1278,28 @@ void LCodeGen::DoConstantT(LConstantT* instr) {

void LCodeGen::DoJSArrayLength(LJSArrayLength* instr) {

- Register array = ToRegister(instr->value());

+ Register array = ToRegister(instr->InputAt(0));

__ movq(result, FieldOperand(array, JSArray::kLengthOffset));

}

void LCodeGen::DoFixedArrayBaseLength(LFixedArrayBaseLength* instr) {

- Register array = ToRegister(instr->value());

+ Register array = ToRegister(instr->InputAt(0));

__ movq(result, FieldOperand(array, FixedArrayBase::kLengthOffset));

}

void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {

- Register map = ToRegister(instr->value());

+ Register map = ToRegister(instr->InputAt(0));

__ EnumLength(result, map);

}

void LCodeGen::DoElementsKind(LElementsKind* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

// Load map into |result|.

__ movq(result, FieldOperand(input, HeapObject::kMapOffset));

@@ -1347,7 +1312,7 @@ void LCodeGen::DoElementsKind(LElementsKind* instr) {

void LCodeGen::DoValueOf(LValueOf* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

ASSERT(input.is(result));

Label done;

@@ -1364,7 +1329,7 @@ void LCodeGen::DoValueOf(LValueOf* instr) {

void LCodeGen::DoDateField(LDateField* instr) {

- Register object = ToRegister(instr->date());

+ Register object = ToRegister(instr->InputAt(0));

Smi* index = instr->index();

Label runtime, done, not_date_object;

@@ -1406,14 +1371,14 @@ void LCodeGen::DoDateField(LDateField* instr) {

void LCodeGen::DoBitNotI(LBitNotI* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

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

__ not_(ToRegister(input));

}

void LCodeGen::DoThrow(LThrow* instr) {

- __ push(ToRegister(instr->value()));

+ __ push(ToRegister(instr->InputAt(0)));

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

if (FLAG_debug_code) {

@@ -1424,8 +1389,8 @@ void LCodeGen::DoThrow(LThrow* instr) {

void LCodeGen::DoAddI(LAddI* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

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

if (right->IsConstantOperand()) {

@@ -1444,8 +1409,8 @@ void LCodeGen::DoAddI(LAddI* instr) {

void LCodeGen::DoMathMinMax(LMathMinMax* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

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

HMathMinMax::Operation operation = instr->hydrogen()->operation();

if (instr->hydrogen()->representation().IsInteger32()) {

@@ -1510,8 +1475,8 @@ void LCodeGen::DoMathMinMax(LMathMinMax* instr) {

void LCodeGen::DoArithmeticD(LArithmeticD* instr) {

- XMMRegister left = ToDoubleRegister(instr->left());

- XMMRegister right = ToDoubleRegister(instr->right());

+ XMMRegister left = ToDoubleRegister(instr->InputAt(0));

+ XMMRegister right = ToDoubleRegister(instr->InputAt(1));

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

// All operations except MOD are computed in-place.

ASSERT(instr->op() == Token::MOD || left.is(result));

@@ -1545,8 +1510,8 @@ void LCodeGen::DoArithmeticD(LArithmeticD* instr) {

void LCodeGen::DoArithmeticT(LArithmeticT* instr) {

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

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

+ ASSERT(ToRegister(instr->InputAt(0)).is(rdx));

+ ASSERT(ToRegister(instr->InputAt(1)).is(rax));

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

BinaryOpStub stub(instr->op(), NO_OVERWRITE);

@@ -1590,17 +1555,17 @@ void LCodeGen::DoBranch(LBranch* instr) {

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

if (r.IsInteger32()) {

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

__ testl(reg, reg);

EmitBranch(true_block, false_block, not_zero);

} else if (r.IsDouble()) {

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

+ XMMRegister reg = ToDoubleRegister(instr->InputAt(0));

__ xorps(xmm0, xmm0);

__ ucomisd(reg, xmm0);

EmitBranch(true_block, false_block, not_equal);

} else {

ASSERT(r.IsTagged());

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

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

if (type.IsBoolean()) {

__ CompareRoot(reg, Heap::kTrueValueRootIndex);

@@ -1737,8 +1702,8 @@ inline Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {

void LCodeGen::DoCmpIDAndBranch(LCmpIDAndBranch* instr) {

- LOperand* left = instr->left();

- LOperand* right = instr->right();

+ LOperand* left = instr->InputAt(0);

+ LOperand* right = instr->InputAt(1);

int false_block = chunk_->LookupDestination(instr->false_block_id());

int true_block = chunk_->LookupDestination(instr->true_block_id());

Condition cc = TokenToCondition(instr->op(), instr->is_double());

@@ -1785,8 +1750,8 @@ void LCodeGen::DoCmpIDAndBranch(LCmpIDAndBranch* instr) {

void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {

- Register left = ToRegister(instr->left());

- Register right = ToRegister(instr->right());

+ Register left = ToRegister(instr->InputAt(0));

+ Register right = ToRegister(instr->InputAt(1));

int false_block = chunk_->LookupDestination(instr->false_block_id());

int true_block = chunk_->LookupDestination(instr->true_block_id());

@@ -1796,7 +1761,7 @@ void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {

void LCodeGen::DoCmpConstantEqAndBranch(LCmpConstantEqAndBranch* instr) {

- Register left = ToRegister(instr->left());

+ Register left = ToRegister(instr->InputAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

@@ -1806,7 +1771,7 @@ void LCodeGen::DoCmpConstantEqAndBranch(LCmpConstantEqAndBranch* instr) {

void LCodeGen::DoIsNilAndBranch(LIsNilAndBranch* instr) {

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

int false_block = chunk_->LookupDestination(instr->false_block_id());

// If the expression is known to be untagged or a smi, then it's definitely

@@ -1836,7 +1801,7 @@ void LCodeGen::DoIsNilAndBranch(LIsNilAndBranch* instr) {

__ JumpIfSmi(reg, false_label);

// Check for undetectable objects by looking in the bit field in

// the map. The object has already been smi checked.

- Register scratch = ToRegister(instr->temp());

+ Register scratch = ToRegister(instr->TempAt(0));

__ movq(scratch, FieldOperand(reg, HeapObject::kMapOffset));

__ testb(FieldOperand(scratch, Map::kBitFieldOffset),

Immediate(1 << Map::kIsUndetectable));

@@ -1871,7 +1836,7 @@ Condition LCodeGen::EmitIsObject(Register input,

void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

@@ -1895,8 +1860,8 @@ Condition LCodeGen::EmitIsString(Register input,

void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {

- Register reg = ToRegister(instr->value());

- Register temp = ToRegister(instr->temp());

+ Register reg = ToRegister(instr->InputAt(0));

+ Register temp = ToRegister(instr->TempAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

@@ -1913,11 +1878,11 @@ void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {

int false_block = chunk_->LookupDestination(instr->false_block_id());

Condition is_smi;

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

- Register input = ToRegister(instr->value());

+ if (instr->InputAt(0)->IsRegister()) {

+ Register input = ToRegister(instr->InputAt(0));

is_smi = masm()->CheckSmi(input);

} else {

- Operand input = ToOperand(instr->value());

+ Operand input = ToOperand(instr->InputAt(0));

is_smi = masm()->CheckSmi(input);

}

EmitBranch(true_block, false_block, is_smi);

@@ -1925,8 +1890,8 @@ void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {

void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {

- Register input = ToRegister(instr->value());

- Register temp = ToRegister(instr->temp());

+ Register input = ToRegister(instr->InputAt(0));

+ Register temp = ToRegister(instr->TempAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

@@ -1975,7 +1940,7 @@ static Condition BranchCondition(HHasInstanceTypeAndBranch* instr) {

void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

@@ -1990,7 +1955,7 @@ void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {

void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

__ AbortIfNotString(input);

@@ -2003,7 +1968,7 @@ void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {

void LCodeGen::DoHasCachedArrayIndexAndBranch(

LHasCachedArrayIndexAndBranch* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

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

void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {

- Register input = ToRegister(instr->value());

- Register temp = ToRegister(instr->temp());

- Register temp2 = ToRegister(instr->temp2());

+ Register input = ToRegister(instr->InputAt(0));

+ Register temp = ToRegister(instr->TempAt(0));

+ Register temp2 = ToRegister(instr->TempAt(1));

Handle<String> class_name = instr->hydrogen()->class_name();

int true_block = chunk_->LookupDestination(instr->true_block_id());

@@ -2101,7 +2066,7 @@ void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {

void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

int true_block = instr->true_block_id();

int false_block = instr->false_block_id();

@@ -2112,8 +2077,8 @@ void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {

void LCodeGen::DoInstanceOf(LInstanceOf* instr) {

InstanceofStub stub(InstanceofStub::kNoFlags);

- __ push(ToRegister(instr->left()));

- __ push(ToRegister(instr->right()));

+ __ push(ToRegister(instr->InputAt(0)));

+ __ push(ToRegister(instr->InputAt(1)));

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

Label true_value, done;

__ testq(rax, rax);

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

deferred = new(zone()) DeferredInstanceOfKnownGlobal(this, instr);

Label done, false_result;

- Register object = ToRegister(instr->value());

+ Register object = ToRegister(instr->InputAt(0));

// A Smi is not an instance of anything.

__ JumpIfSmi(object, &false_result);

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

// instanceof stub.

Label cache_miss;

// Use a temp register to avoid memory operands with variable lengths.

- Register map = ToRegister(instr->temp());

+ Register map = ToRegister(instr->TempAt(0));

__ movq(map, FieldOperand(object, HeapObject::kMapOffset));

__ bind(deferred->map_check()); // Label for calculating code patching.

Handle<JSGlobalPropertyCell> cache_cell =

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

InstanceofStub::kNoFlags | InstanceofStub::kCallSiteInlineCheck);

InstanceofStub stub(flags);

- __ push(ToRegister(instr->value()));

+ __ push(ToRegister(instr->InputAt(0)));

__ PushHeapObject(instr->function());

static const int kAdditionalDelta = 10;

@@ -2300,7 +2265,7 @@ void LCodeGen::DoStoreGlobalCell(LStoreGlobalCell* instr) {

// it as no longer deleted. We deoptimize in that case.

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

// We have a temp because CompareRoot might clobber kScratchRegister.

- Register cell = ToRegister(instr->temp());

+ Register cell = ToRegister(instr->TempAt(0));

ASSERT(!value.is(cell));

__ movq(cell, cell_handle, RelocInfo::GLOBAL_PROPERTY_CELL);

__ CompareRoot(Operand(cell, 0), Heap::kTheHoleValueRootIndex);

@@ -2368,7 +2333,7 @@ void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {

SmiCheck check_needed =

type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;

int offset = Context::SlotOffset(instr->slot_index());

- Register scratch = ToRegister(instr->temp());

+ Register scratch = ToRegister(instr->TempAt(0));

__ RecordWriteContextSlot(context,

offset,

value,

@@ -2383,7 +2348,7 @@ void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {

void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {

- Register object = ToRegister(instr->object());

+ Register object = ToRegister(instr->InputAt(0));

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

__ movq(result, FieldOperand(object, instr->hydrogen()->offset()));

@@ -2555,7 +2520,7 @@ void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {

void LCodeGen::DoLoadElements(LLoadElements* instr) {

- Register input = ToRegister(instr->object());

+ Register input = ToRegister(instr->InputAt(0));

__ movq(result, FieldOperand(input, JSObject::kElementsOffset));

if (FLAG_debug_code) {

Label done, ok, fail;

@@ -2591,7 +2556,7 @@ void LCodeGen::DoLoadElements(LLoadElements* instr) {

void LCodeGen::DoLoadExternalArrayPointer(

LLoadExternalArrayPointer* instr) {

- Register input = ToRegister(instr->object());

+ Register input = ToRegister(instr->InputAt(0));

__ movq(result, FieldOperand(input,

ExternalPixelArray::kExternalPointerOffset));

}

@@ -2839,10 +2804,10 @@ void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {

Label done;

// If no arguments adaptor frame the number of arguments is fixed.

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

- __ cmpq(rbp, ToRegister(instr->elements()));

+ if (instr->InputAt(0)->IsRegister()) {

+ __ cmpq(rbp, ToRegister(instr->InputAt(0)));

} else {

- __ cmpq(rbp, ToOperand(instr->elements()));

+ __ cmpq(rbp, ToOperand(instr->InputAt(0)));

}

__ movl(result, Immediate(scope()->num_parameters()));

__ j(equal, &done, Label::kNear);

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

void LCodeGen::DoPushArgument(LPushArgument* instr) {

- LOperand* argument = instr->value();

+ LOperand* argument = instr->InputAt(0);

EmitPushTaggedOperand(argument);

}

@@ -3060,7 +3025,7 @@ void LCodeGen::DoCallConstantFunction(LCallConstantFunction* instr) {

void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LUnaryMathOperation* instr) {

- Register input_reg = ToRegister(instr->value());

+ Register input_reg = ToRegister(instr->InputAt(0));

__ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),

Heap::kHeapNumberMapRootIndex);

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

@@ -3112,7 +3077,7 @@ void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LUnaryMathOperation* instr) {

void LCodeGen::EmitIntegerMathAbs(LUnaryMathOperation* instr) {

- Register input_reg = ToRegister(instr->value());

+ Register input_reg = ToRegister(instr->InputAt(0));

__ testl(input_reg, input_reg);

Label is_positive;

__ j(not_sign, &is_positive);

@@ -3137,12 +3102,12 @@ void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {

LUnaryMathOperation* instr_;

};

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

+ ASSERT(instr->InputAt(0)->Equals(instr->result()));

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

if (r.IsDouble()) {

XMMRegister scratch = xmm0;

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

__ xorps(scratch, scratch);

__ subsd(scratch, input_reg);

__ andpd(input_reg, scratch);

@@ -3151,7 +3116,7 @@ void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {

} else { // Tagged case.

DeferredMathAbsTaggedHeapNumber* deferred =

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

- Register input_reg = ToRegister(instr->value());

+ Register input_reg = ToRegister(instr->InputAt(0));

// Smi check.

__ JumpIfNotSmi(input_reg, deferred->entry());

__ SmiToInteger32(input_reg, input_reg);

@@ -3165,7 +3130,7 @@ void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {

void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) {

XMMRegister xmm_scratch = xmm0;

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

if (CpuFeatures::IsSupported(SSE4_1)) {

CpuFeatures::Scope scope(SSE4_1);

@@ -3224,7 +3189,7 @@ void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) {

void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {

const XMMRegister xmm_scratch = xmm0;

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

Label done;

// xmm_scratch = 0.5

@@ -3269,7 +3234,7 @@ void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {

void LCodeGen::DoMathSqrt(LUnaryMathOperation* instr) {

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

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

__ sqrtsd(input_reg, input_reg);

}

@@ -3277,7 +3242,7 @@ void LCodeGen::DoMathSqrt(LUnaryMathOperation* instr) {

void LCodeGen::DoMathPowHalf(LUnaryMathOperation* instr) {

XMMRegister xmm_scratch = xmm0;

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

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

// Note that according to ECMA-262 15.8.2.13:

@@ -3318,11 +3283,11 @@ void LCodeGen::DoPower(LPower* instr) {

#else

#endif

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

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

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

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

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

+ ASSERT(!instr->InputAt(1)->IsRegister() ||

+ ToRegister(instr->InputAt(1)).is(exponent));

+ ASSERT(!instr->InputAt(1)->IsDoubleRegister() ||

+ ToDoubleRegister(instr->InputAt(1)).is(xmm1));

+ ASSERT(ToDoubleRegister(instr->InputAt(0)).is(xmm2));

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

if (exponent_type.IsTagged()) {

@@ -3364,10 +3329,10 @@ void LCodeGen::DoRandom(LRandom* instr) {

// Choose the right register for the first argument depending on

// calling convention.

#ifdef _WIN64

- ASSERT(ToRegister(instr->global_object()).is(rcx));

+ ASSERT(ToRegister(instr->InputAt(0)).is(rcx));

#else

- ASSERT(ToRegister(instr->global_object()).is(rdi));

+ ASSERT(ToRegister(instr->InputAt(0)).is(rdi));

#endif

@@ -3582,7 +3547,7 @@ void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) {

void LCodeGen::DoCallNew(LCallNew* instr) {

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

+ ASSERT(ToRegister(instr->InputAt(0)).is(rdi));

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

CallConstructStub stub(NO_CALL_FUNCTION_FLAGS);

@@ -3606,7 +3571,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {

__ Move(FieldOperand(object, HeapObject::kMapOffset),

instr->transition());

} else {

- Register temp = ToRegister(instr->temp());

+ Register temp = ToRegister(instr->TempAt(0));

__ Move(kScratchRegister, instr->transition());

__ movq(FieldOperand(object, HeapObject::kMapOffset), kScratchRegister);

// Update the write barrier for the map field.

@@ -3627,7 +3592,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {

if (instr->is_in_object()) {

__ movq(FieldOperand(object, offset), value);

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

- Register temp = ToRegister(instr->temp());

+ Register temp = ToRegister(instr->TempAt(0));

// Update the write barrier for the object for in-object properties.

__ RecordWriteField(object,

offset,

@@ -3638,7 +3603,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {

check_needed);

}

} else {

- Register temp = ToRegister(instr->temp());

+ Register temp = ToRegister(instr->TempAt(0));

__ movq(temp, FieldOperand(object, JSObject::kPropertiesOffset));

__ movq(FieldOperand(temp, offset), value);

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

@@ -3777,17 +3742,11 @@ void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {

__ cmpq(reg, reg2);

}

} else {

- Operand length = ToOperand(instr->length());

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

- int constant_index =

- ToInteger32(LConstantOperand::cast(instr->index()));

- if (instr->hydrogen()->length()->representation().IsTagged()) {

- __ Cmp(length, Smi::FromInt(constant_index));

- } else {

- __ cmpq(length, Immediate(constant_index));

- }

+ __ cmpq(ToOperand(instr->length()),

+ Immediate(ToInteger32(LConstantOperand::cast(instr->index()))));

} else {

- __ cmpq(length, ToRegister(instr->index()));

+ __ cmpq(ToOperand(instr->length()), ToRegister(instr->index()));

}

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

@@ -3897,7 +3856,7 @@ void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {

void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {

- Register new_map_reg = ToRegister(instr->new_map_temp());

+ Register new_map_reg = ToRegister(instr->new_map_reg());

Handle<Map> from_map = instr->original_map();

Handle<Map> to_map = instr->transitioned_map();

@@ -3911,12 +3870,12 @@ void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {

if (IsSimpleMapChangeTransition(from_kind, to_kind)) {

__ movq(FieldOperand(object_reg, HeapObject::kMapOffset), new_map_reg);

// Write barrier.

- ASSERT_NE(instr->temp(), NULL);

+ ASSERT_NE(instr->temp_reg(), NULL);

__ RecordWriteField(object_reg, HeapObject::kMapOffset, new_map_reg,

- ToRegister(instr->temp()), kDontSaveFPRegs);

+ ToRegister(instr->temp_reg()), kDontSaveFPRegs);

} else if (IsFastSmiElementsKind(from_kind) &&

IsFastDoubleElementsKind(to_kind)) {

- Register fixed_object_reg = ToRegister(instr->temp());

+ Register fixed_object_reg = ToRegister(instr->temp_reg());

ASSERT(fixed_object_reg.is(rdx));

ASSERT(new_map_reg.is(rbx));

__ movq(fixed_object_reg, object_reg);

@@ -3924,7 +3883,7 @@ void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {

RelocInfo::CODE_TARGET, instr);

} else if (IsFastDoubleElementsKind(from_kind) &&

IsFastObjectElementsKind(to_kind)) {

- Register fixed_object_reg = ToRegister(instr->temp());

+ Register fixed_object_reg = ToRegister(instr->temp_reg());

ASSERT(fixed_object_reg.is(rdx));

ASSERT(new_map_reg.is(rbx));

__ movq(fixed_object_reg, object_reg);

@@ -4055,7 +4014,7 @@ void LCodeGen::DoStringLength(LStringLength* instr) {

void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

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

LOperand* output = instr->result();

ASSERT(output->IsDoubleRegister());

@@ -4068,9 +4027,9 @@ void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {

void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

LOperand* output = instr->result();

- LOperand* temp = instr->temp();

+ LOperand* temp = instr->TempAt(0);

__ LoadUint32(ToDoubleRegister(output),

ToRegister(input),

@@ -4079,7 +4038,7 @@ void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {

void LCodeGen::DoNumberTagI(LNumberTagI* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

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

@@ -4100,7 +4059,7 @@ void LCodeGen::DoNumberTagU(LNumberTagU* instr) {

LNumberTagU* instr_;

};

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

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

@@ -4114,7 +4073,7 @@ void LCodeGen::DoNumberTagU(LNumberTagU* instr) {

void LCodeGen::DoDeferredNumberTagU(LNumberTagU* instr) {

Label slow;

- Register reg = ToRegister(instr->value());

+ Register reg = ToRegister(instr->InputAt(0));

// Preserve the value of all registers.

@@ -4161,9 +4120,9 @@ void LCodeGen::DoNumberTagD(LNumberTagD* instr) {

LNumberTagD* instr_;

};

- XMMRegister input_reg = ToDoubleRegister(instr->value());

+ XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));

- Register tmp = ToRegister(instr->temp());

+ Register tmp = ToRegister(instr->TempAt(0));

DeferredNumberTagD* deferred = new(zone()) DeferredNumberTagD(this, instr);

if (FLAG_inline_new) {

@@ -4194,16 +4153,16 @@ void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {

void LCodeGen::DoSmiTag(LSmiTag* instr) {

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

- Register input = ToRegister(instr->value());

+ ASSERT(instr->InputAt(0)->Equals(instr->result()));

+ Register input = ToRegister(instr->InputAt(0));

ASSERT(!instr->hydrogen_value()->CheckFlag(HValue::kCanOverflow));

__ Integer32ToSmi(input, input);

}

void LCodeGen::DoSmiUntag(LSmiUntag* instr) {

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

- Register input = ToRegister(instr->value());

+ ASSERT(instr->InputAt(0)->Equals(instr->result()));

+ Register input = ToRegister(instr->InputAt(0));

if (instr->needs_check()) {

Condition is_smi = __ CheckSmi(input);

DeoptimizeIf(NegateCondition(is_smi), instr->environment());

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

void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {

Label done, heap_number;

- Register input_reg = ToRegister(instr->value());

+ Register input_reg = ToRegister(instr->InputAt(0));

// Heap number map check.

__ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),

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

// Deoptimize if we don't have a heap number.

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

- XMMRegister xmm_temp = ToDoubleRegister(instr->temp());

+ XMMRegister xmm_temp = ToDoubleRegister(instr->TempAt(0));

__ movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));

__ cvttsd2si(input_reg, xmm0);

__ cvtlsi2sd(xmm_temp, input_reg);

@@ -4324,7 +4283,7 @@ void LCodeGen::DoTaggedToI(LTaggedToI* instr) {

LTaggedToI* instr_;

};

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

ASSERT(input->IsRegister());

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

@@ -4337,7 +4296,7 @@ void LCodeGen::DoTaggedToI(LTaggedToI* instr) {

void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

ASSERT(input->IsRegister());

LOperand* result = instr->result();

ASSERT(result->IsDoubleRegister());

@@ -4353,7 +4312,7 @@ void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {

void LCodeGen::DoDoubleToI(LDoubleToI* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

ASSERT(input->IsDoubleRegister());

LOperand* result = instr->result();

ASSERT(result->IsRegister());

@@ -4393,21 +4352,21 @@ void LCodeGen::DoDoubleToI(LDoubleToI* instr) {

void LCodeGen::DoCheckSmi(LCheckSmi* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

Condition cc = masm()->CheckSmi(ToRegister(input));

DeoptimizeIf(NegateCondition(cc), instr->environment());

}

void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

Condition cc = masm()->CheckSmi(ToRegister(input));

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

}

void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

__ movq(kScratchRegister, FieldOperand(input, HeapObject::kMapOffset));

@@ -4479,7 +4438,7 @@ void LCodeGen::DoCheckMapCommon(Register reg,

void LCodeGen::DoCheckMaps(LCheckMaps* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

ASSERT(input->IsRegister());

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

void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {

XMMRegister value_reg = ToDoubleRegister(instr->unclamped());

- Register temp_reg = ToRegister(instr->temp());

+ Register temp_reg = ToRegister(instr->TempAt(0));

__ ClampDoubleToUint8(value_reg, xmm0, result_reg, temp_reg);

}

@@ -4514,8 +4473,8 @@ void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {

void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {

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

- Register temp_reg = ToRegister(instr->temp());

- XMMRegister temp_xmm_reg = ToDoubleRegister(instr->temp2());

+ Register temp_reg = ToRegister(instr->TempAt(0));

+ XMMRegister temp_xmm_reg = ToDoubleRegister(instr->TempAt(1));

Label is_smi, done, heap_number;

__ JumpIfSmi(input_reg, &is_smi);

@@ -4548,7 +4507,7 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {

void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) {

- Register reg = ToRegister(instr->temp());

+ Register reg = ToRegister(instr->TempAt(0));

Handle<JSObject> holder = instr->holder();

Handle<JSObject> current_prototype = instr->prototype();

@@ -4587,7 +4546,7 @@ void LCodeGen::DoAllocateObject(LAllocateObject* instr) {

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

- Register scratch = ToRegister(instr->temp());

+ Register scratch = ToRegister(instr->TempAt(0));

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

Handle<Map> initial_map(constructor->initial_map());

int instance_size = initial_map->instance_size();

@@ -4889,7 +4848,7 @@ void LCodeGen::DoObjectLiteral(LObjectLiteral* instr) {

void LCodeGen::DoToFastProperties(LToFastProperties* instr) {

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

+ ASSERT(ToRegister(instr->InputAt(0)).is(rax));

__ push(rax);

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

}

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

void LCodeGen::DoTypeof(LTypeof* instr) {

- LOperand* input = instr->value();

+ LOperand* input = instr->InputAt(0);

EmitPushTaggedOperand(input);

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

}

@@ -4990,7 +4949,7 @@ void LCodeGen::EmitPushTaggedOperand(LOperand* operand) {

void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {

- Register input = ToRegister(instr->value());

+ Register input = ToRegister(instr->InputAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

Label* true_label = chunk_->GetAssemblyLabel(true_block);

@@ -5076,7 +5035,7 @@ Condition LCodeGen::EmitTypeofIs(Label* true_label,

void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {

- Register temp = ToRegister(instr->temp());

+ Register temp = ToRegister(instr->TempAt(0));

int true_block = chunk_->LookupDestination(instr->true_block_id());

int false_block = chunk_->LookupDestination(instr->false_block_id());

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