Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(109)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/ppc/lithium-ppc.cc

Issue 422063005: Contribution of PowerPC port. (Closed) Base URL: http://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Caught up to bleending edge (8/15) 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
Download patch
« src/objects-printer.cc ('K') | « src/ppc/lithium-ppc.h ('k') | src/ppc/macro-assembler-ppc.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/ppc/lithium-ppc.cc
diff --git a/src/arm/lithium-arm.cc b/src/ppc/lithium-ppc.cc
similarity index 95%
copy from src/arm/lithium-arm.cc
copy to src/ppc/lithium-ppc.cc
index 6b86088ee7c9462469abb1a21af4559a0b2a0b8e..0685d3fe27c976e547425387c0d8138f48571e4c 100644
--- a/src/arm/lithium-arm.cc
+++ b/src/ppc/lithium-ppc.cc
@@ -1,12 +1,15 @@
// Copyright 2012 the V8 project authors. All rights reserved.
+//
+// Copyright IBM Corp. 2012, 2013. All rights reserved.
+//
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/v8.h"
-#include "src/arm/lithium-codegen-arm.h"
#include "src/hydrogen-osr.h"
#include "src/lithium-inl.h"
+#include "src/ppc/lithium-codegen-ppc.h"
namespace v8 {
namespace internal {
@@ -725,10 +728,13 @@ LInstruction* LChunkBuilder::DoArithmeticD(Token::Value op,
DCHECK(instr->left()->representation().IsDouble());
DCHECK(instr->right()->representation().IsDouble());
if (op == Token::MOD) {
- LOperand* left = UseFixedDouble(instr->left(), d0);
- LOperand* right = UseFixedDouble(instr->right(), d1);
+ LOperand* left = UseFixedDouble(instr->left(), d1);
+ LOperand* right = UseFixedDouble(instr->right(), d2);
LArithmeticD* result = new(zone()) LArithmeticD(op, left, right);
- return MarkAsCall(DefineFixedDouble(result, d0), instr);
+ // We call a C function for double modulo. It can't trigger a GC. We need
+ // to use fixed result register for the call.
+ // TODO(fschneider): Allow any register as input registers.
+ return MarkAsCall(DefineFixedDouble(result, d1), instr);
} else {
LOperand* left = UseRegisterAtStart(instr->left());
LOperand* right = UseRegisterAtStart(instr->right());
@@ -745,11 +751,11 @@ LInstruction* LChunkBuilder::DoArithmeticT(Token::Value op,
DCHECK(left->representation().IsTagged());
DCHECK(right->representation().IsTagged());
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* left_operand = UseFixed(left, r1);
- LOperand* right_operand = UseFixed(right, r0);
+ LOperand* left_operand = UseFixed(left, r4);
+ LOperand* right_operand = UseFixed(right, r3);
LArithmeticT* result =
new(zone()) LArithmeticT(op, context, left_operand, right_operand);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -981,9 +987,9 @@ LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
LInstruction* LChunkBuilder::DoInstanceOf(HInstanceOf* instr) {
LOperand* context = UseFixed(instr->context(), cp);
LInstanceOf* result =
- new(zone()) LInstanceOf(context, UseFixed(instr->left(), r0),
- UseFixed(instr->right(), r1));
- return MarkAsCall(DefineFixed(result, r0), instr);
+ new(zone()) LInstanceOf(context, UseFixed(instr->left(), r3),
+ UseFixed(instr->right(), r4));
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -992,9 +998,9 @@ LInstruction* LChunkBuilder::DoInstanceOfKnownGlobal(
LInstanceOfKnownGlobal* result =
new(zone()) LInstanceOfKnownGlobal(
UseFixed(instr->context(), cp),
- UseFixed(instr->left(), r0),
- FixedTemp(r4));
- return MarkAsCall(DefineFixed(result, r0), instr);
+ UseFixed(instr->left(), r3),
+ FixedTemp(r7));
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -1007,15 +1013,15 @@ LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
- LOperand* function = UseFixed(instr->function(), r1);
- LOperand* receiver = UseFixed(instr->receiver(), r0);
- LOperand* length = UseFixed(instr->length(), r2);
- LOperand* elements = UseFixed(instr->elements(), r3);
+ LOperand* function = UseFixed(instr->function(), r4);
+ LOperand* receiver = UseFixed(instr->receiver(), r3);
+ LOperand* length = UseFixed(instr->length(), r5);
+ LOperand* elements = UseFixed(instr->elements(), r6);
LApplyArguments* result = new(zone()) LApplyArguments(function,
receiver,
length,
elements);
- return MarkAsCall(DefineFixed(result, r0), instr, CAN_DEOPTIMIZE_EAGERLY);
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
}
@@ -1072,11 +1078,11 @@ LInstruction* LChunkBuilder::DoDeclareGlobals(HDeclareGlobals* instr) {
LInstruction* LChunkBuilder::DoCallJSFunction(
HCallJSFunction* instr) {
- LOperand* function = UseFixed(instr->function(), r1);
+ LOperand* function = UseFixed(instr->function(), r4);
LCallJSFunction* result = new(zone()) LCallJSFunction(function);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -1095,15 +1101,15 @@ LInstruction* LChunkBuilder::DoCallWithDescriptor(
LCallWithDescriptor* result = new(zone()) LCallWithDescriptor(
descriptor, ops, zone());
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* function = UseFixed(instr->function(), r1);
+ LOperand* function = UseFixed(instr->function(), r4);
LInvokeFunction* result = new(zone()) LInvokeFunction(context, function);
- return MarkAsCall(DefineFixed(result, r0), instr, CANNOT_DEOPTIMIZE_EAGERLY);
+ return MarkAsCall(DefineFixed(result, r3), instr, CANNOT_DEOPTIMIZE_EAGERLY);
}
@@ -1173,8 +1179,8 @@ LInstruction* LChunkBuilder::DoMathAbs(HUnaryMathOperation* instr) {
LInstruction* LChunkBuilder::DoMathLog(HUnaryMathOperation* instr) {
DCHECK(instr->representation().IsDouble());
DCHECK(instr->value()->representation().IsDouble());
- LOperand* input = UseFixedDouble(instr->value(), d0);
- return MarkAsCall(DefineFixedDouble(new(zone()) LMathLog(input), d0), instr);
+ LOperand* input = UseFixedDouble(instr->value(), d1);
+ return MarkAsCall(DefineFixedDouble(new(zone()) LMathLog(input), d1), instr);
}
@@ -1213,31 +1219,31 @@ LInstruction* LChunkBuilder::DoMathPowHalf(HUnaryMathOperation* instr) {
LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* constructor = UseFixed(instr->constructor(), r1);
+ LOperand* constructor = UseFixed(instr->constructor(), r4);
LCallNew* result = new(zone()) LCallNew(context, constructor);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
LInstruction* LChunkBuilder::DoCallNewArray(HCallNewArray* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* constructor = UseFixed(instr->constructor(), r1);
+ LOperand* constructor = UseFixed(instr->constructor(), r4);
LCallNewArray* result = new(zone()) LCallNewArray(context, constructor);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
LInstruction* LChunkBuilder::DoCallFunction(HCallFunction* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* function = UseFixed(instr->function(), r1);
+ LOperand* function = UseFixed(instr->function(), r4);
LCallFunction* call = new(zone()) LCallFunction(context, function);
- return MarkAsCall(DefineFixed(call, r0), instr);
+ return MarkAsCall(DefineFixed(call, r3), instr);
}
LInstruction* LChunkBuilder::DoCallRuntime(HCallRuntime* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- return MarkAsCall(DefineFixed(new(zone()) LCallRuntime(context), r0), instr);
+ return MarkAsCall(DefineFixed(new(zone()) LCallRuntime(context), r3), instr);
}
@@ -1317,15 +1323,12 @@ LInstruction* LChunkBuilder::DoDivI(HDiv* instr) {
DCHECK(instr->right()->representation().Equals(instr->representation()));
LOperand* dividend = UseRegister(instr->left());
LOperand* divisor = UseRegister(instr->right());
- LOperand* temp =
- CpuFeatures::IsSupported(SUDIV) ? NULL : TempDoubleRegister();
LInstruction* result =
- DefineAsRegister(new(zone()) LDivI(dividend, divisor, temp));
+ DefineAsRegister(new(zone()) LDivI(dividend, divisor));
if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
instr->CheckFlag(HValue::kBailoutOnMinusZero) ||
(instr->CheckFlag(HValue::kCanOverflow) &&
- (!CpuFeatures::IsSupported(SUDIV) ||
- !instr->CheckFlag(HValue::kAllUsesTruncatingToInt32))) ||
+ !instr->CheckFlag(HValue::kAllUsesTruncatingToInt32)) ||
(!instr->IsMathFloorOfDiv() &&
!instr->CheckFlag(HValue::kAllUsesTruncatingToInt32))) {
result = AssignEnvironment(result);
@@ -1390,9 +1393,7 @@ LInstruction* LChunkBuilder::DoFlooringDivI(HMathFloorOfDiv* instr) {
DCHECK(instr->right()->representation().Equals(instr->representation()));
LOperand* dividend = UseRegister(instr->left());
LOperand* divisor = UseRegister(instr->right());
- LOperand* temp =
- CpuFeatures::IsSupported(SUDIV) ? NULL : TempDoubleRegister();
- LFlooringDivI* div = new(zone()) LFlooringDivI(dividend, divisor, temp);
+ LFlooringDivI* div = new(zone()) LFlooringDivI(dividend, divisor);
return AssignEnvironment(DefineAsRegister(div));
}
@@ -1445,12 +1446,8 @@ LInstruction* LChunkBuilder::DoModI(HMod* instr) {
DCHECK(instr->right()->representation().Equals(instr->representation()));
LOperand* dividend = UseRegister(instr->left());
LOperand* divisor = UseRegister(instr->right());
- LOperand* temp =
- CpuFeatures::IsSupported(SUDIV) ? NULL : TempDoubleRegister();
- LOperand* temp2 =
- CpuFeatures::IsSupported(SUDIV) ? NULL : TempDoubleRegister();
LInstruction* result = DefineAsRegister(new(zone()) LModI(
- dividend, divisor, temp, temp2));
+ dividend, divisor));
if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
result = AssignEnvironment(result);
@@ -1527,13 +1524,14 @@ LInstruction* LChunkBuilder::DoMul(HMul* instr) {
// multiply-add in DoAdd.
return NULL;
}
- if (instr == use->right() && use->IsAdd() && !use->left()->IsMul()) {
+ if (instr == use->right() && use->IsAdd() &&
+ !(use->left()->IsMul() && use->left()->HasOneUse())) {
// This mul is the rhs of an add, where the lhs is not another mul.
// The add and mul will be folded into a multiply-add in DoAdd.
return NULL;
}
- if (instr == use->right() && use->IsSub()) {
- // This mul is the rhs of a sub. The sub and mul will be folded into a
+ if (instr == use->left() && use->IsSub()) {
+ // This mul is the lhs of a sub. The mul and sub will be folded into a
// multiply-sub in DoSub.
return NULL;
}
@@ -1551,7 +1549,8 @@ LInstruction* LChunkBuilder::DoSub(HSub* instr) {
DCHECK(instr->left()->representation().Equals(instr->representation()));
DCHECK(instr->right()->representation().Equals(instr->representation()));
- if (instr->left()->IsConstant()) {
+ if (instr->left()->IsConstant() &&
+ !instr->CheckFlag(HValue::kCanOverflow)) {
// If lhs is constant, do reverse subtraction instead.
return DoRSub(instr);
}
@@ -1565,8 +1564,8 @@ LInstruction* LChunkBuilder::DoSub(HSub* instr) {
}
return result;
} else if (instr->representation().IsDouble()) {
- if (instr->right()->IsMul() && instr->right()->HasOneUse()) {
- return DoMultiplySub(instr->left(), HMul::cast(instr->right()));
+ if (instr->left()->IsMul() && instr->left()->HasOneUse()) {
+ return DoMultiplySub(instr->right(), HMul::cast(instr->left()));
}
return DoArithmeticD(Token::SUB, instr);
@@ -1580,6 +1579,7 @@ LInstruction* LChunkBuilder::DoRSub(HSub* instr) {
DCHECK(instr->representation().IsSmiOrInteger32());
DCHECK(instr->left()->representation().Equals(instr->representation()));
DCHECK(instr->right()->representation().Equals(instr->representation()));
+ DCHECK(!instr->CheckFlag(HValue::kCanOverflow));
// Note: The lhs of the subtraction becomes the rhs of the
// reverse-subtraction.
@@ -1587,9 +1587,6 @@ LInstruction* LChunkBuilder::DoRSub(HSub* instr) {
LOperand* right = UseOrConstantAtStart(instr->left());
LRSubI* rsb = new(zone()) LRSubI(left, right);
LInstruction* result = DefineAsRegister(rsb);
- if (instr->CheckFlag(HValue::kCanOverflow)) {
- result = AssignEnvironment(result);
- }
return result;
}
@@ -1677,12 +1674,12 @@ LInstruction* LChunkBuilder::DoPower(HPower* instr) {
// We need to use fixed result register for the call.
Representation exponent_type = instr->right()->representation();
DCHECK(instr->left()->representation().IsDouble());
- LOperand* left = UseFixedDouble(instr->left(), d0);
+ LOperand* left = UseFixedDouble(instr->left(), d1);
LOperand* right = exponent_type.IsDouble() ?
- UseFixedDouble(instr->right(), d1) :
- UseFixed(instr->right(), r2);
+ UseFixedDouble(instr->right(), d2) :
+ UseFixed(instr->right(), r5);
LPower* result = new(zone()) LPower(left, right);
- return MarkAsCall(DefineFixedDouble(result, d2),
+ return MarkAsCall(DefineFixedDouble(result, d3),
instr,
CAN_DEOPTIMIZE_EAGERLY);
}
@@ -1692,10 +1689,10 @@ LInstruction* LChunkBuilder::DoCompareGeneric(HCompareGeneric* instr) {
DCHECK(instr->left()->representation().IsTagged());
DCHECK(instr->right()->representation().IsTagged());
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* left = UseFixed(instr->left(), r1);
- LOperand* right = UseFixed(instr->right(), r0);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
LCmpT* result = new(zone()) LCmpT(context, left, right);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -1777,8 +1774,8 @@ LInstruction* LChunkBuilder::DoStringCompareAndBranch(
DCHECK(instr->left()->representation().IsTagged());
DCHECK(instr->right()->representation().IsTagged());
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* left = UseFixed(instr->left(), r1);
- LOperand* right = UseFixed(instr->right(), r0);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
LStringCompareAndBranch* result =
new(zone()) LStringCompareAndBranch(context, left, right);
return MarkAsCall(result, instr);
@@ -1825,10 +1822,10 @@ LInstruction* LChunkBuilder::DoMapEnumLength(HMapEnumLength* instr) {
LInstruction* LChunkBuilder::DoDateField(HDateField* instr) {
- LOperand* object = UseFixed(instr->value(), r0);
+ LOperand* object = UseFixed(instr->value(), r3);
LDateField* result =
- new(zone()) LDateField(object, FixedTemp(r1), instr->index());
- return MarkAsCall(DefineFixed(result, r0), instr, CAN_DEOPTIMIZE_EAGERLY);
+ new(zone()) LDateField(object, FixedTemp(r4), instr->index());
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
}
@@ -2040,8 +2037,6 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
return DefineAsRegister(new(zone()) LClampIToUint8(reg));
} else {
DCHECK(input_rep.IsSmiOrTagged());
- // Register allocator doesn't (yet) support allocation of double
- // temps. Reserve d1 explicitly.
LClampTToUint8* result =
new(zone()) LClampTToUint8(reg, TempDoubleRegister());
return AssignEnvironment(DefineAsRegister(result));
@@ -2068,7 +2063,7 @@ LInstruction* LChunkBuilder::DoReturn(HReturn* instr) {
? UseFixed(instr->context(), cp)
: NULL;
LOperand* parameter_count = UseRegisterOrConstant(instr->parameter_count());
- return new(zone()) LReturn(UseFixed(instr->value(), r0), context,
+ return new(zone()) LReturn(UseFixed(instr->value(), r3), context,
parameter_count);
}
@@ -2110,7 +2105,7 @@ LInstruction* LChunkBuilder::DoLoadGlobalGeneric(HLoadGlobalGeneric* instr) {
}
LLoadGlobalGeneric* result =
new(zone()) LLoadGlobalGeneric(context, global_object, vector);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -2168,7 +2163,7 @@ LInstruction* LChunkBuilder::DoLoadNamedGeneric(HLoadNamedGeneric* instr) {
}
LInstruction* result =
- DefineFixed(new(zone()) LLoadNamedGeneric(context, object, vector), r0);
+ DefineFixed(new(zone()) LLoadNamedGeneric(context, object, vector), r3);
return MarkAsCall(result, instr);
}
@@ -2196,7 +2191,6 @@ LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
if (instr->representation().IsDouble()) {
obj = UseRegister(instr->elements());
} else {
- DCHECK(instr->representation().IsSmiOrTagged());
obj = UseRegisterAtStart(instr->elements());
}
result = DefineAsRegister(new(zone()) LLoadKeyed(obj, key));
@@ -2235,7 +2229,7 @@ LInstruction* LChunkBuilder::DoLoadKeyedGeneric(HLoadKeyedGeneric* instr) {
LInstruction* result =
DefineFixed(new(zone()) LLoadKeyedGeneric(context, object, key, vector),
- r0);
+ r3);
return MarkAsCall(result, instr);
}
@@ -2253,7 +2247,6 @@ LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
val = UseRegister(instr->value());
key = UseRegisterOrConstantAtStart(instr->key());
} else {
- DCHECK(instr->value()->representation().IsSmiOrTagged());
if (needs_write_barrier) {
object = UseTempRegister(instr->elements());
val = UseTempRegister(instr->value());
@@ -2308,7 +2301,7 @@ LInstruction* LChunkBuilder::DoTransitionElementsKind(
new(zone()) LTransitionElementsKind(object, NULL, new_map_reg);
return result;
} else {
- LOperand* object = UseFixed(instr->object(), r0);
+ LOperand* object = UseFixed(instr->object(), r3);
LOperand* context = UseFixed(instr->context(), cp);
LTransitionElementsKind* result =
new(zone()) LTransitionElementsKind(object, context, NULL);
@@ -2372,10 +2365,10 @@ LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* left = UseFixed(instr->left(), r1);
- LOperand* right = UseFixed(instr->right(), r0);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
return MarkAsCall(
- DefineFixed(new(zone()) LStringAdd(context, left, right), r0),
+ DefineFixed(new(zone()) LStringAdd(context, left, right), r3),
instr);
}
@@ -2413,14 +2406,14 @@ LInstruction* LChunkBuilder::DoAllocate(HAllocate* instr) {
LInstruction* LChunkBuilder::DoRegExpLiteral(HRegExpLiteral* instr) {
LOperand* context = UseFixed(instr->context(), cp);
return MarkAsCall(
- DefineFixed(new(zone()) LRegExpLiteral(context), r0), instr);
+ DefineFixed(new(zone()) LRegExpLiteral(context), r3), instr);
}
LInstruction* LChunkBuilder::DoFunctionLiteral(HFunctionLiteral* instr) {
LOperand* context = UseFixed(instr->context(), cp);
return MarkAsCall(
- DefineFixed(new(zone()) LFunctionLiteral(context), r0), instr);
+ DefineFixed(new(zone()) LFunctionLiteral(context), r3), instr);
}
@@ -2468,7 +2461,7 @@ LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
LInstruction* LChunkBuilder::DoCallStub(HCallStub* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- return MarkAsCall(DefineFixed(new(zone()) LCallStub(context), r0), instr);
+ return MarkAsCall(DefineFixed(new(zone()) LCallStub(context), r3), instr);
}
@@ -2499,16 +2492,16 @@ LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) {
LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) {
- LOperand* object = UseFixed(instr->value(), r0);
+ LOperand* object = UseFixed(instr->value(), r3);
LToFastProperties* result = new(zone()) LToFastProperties(object);
- return MarkAsCall(DefineFixed(result, r0), instr);
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
LInstruction* LChunkBuilder::DoTypeof(HTypeof* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LTypeof* result = new(zone()) LTypeof(context, UseFixed(instr->value(), r0));
- return MarkAsCall(DefineFixed(result, r0), instr);
+ LTypeof* result = new(zone()) LTypeof(context, UseFixed(instr->value(), r3));
+ return MarkAsCall(DefineFixed(result, r3), instr);
}
@@ -2583,9 +2576,9 @@ LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
LInstruction* LChunkBuilder::DoForInPrepareMap(HForInPrepareMap* instr) {
LOperand* context = UseFixed(instr->context(), cp);
- LOperand* object = UseFixed(instr->enumerable(), r0);
+ LOperand* object = UseFixed(instr->enumerable(), r3);
LForInPrepareMap* result = new(zone()) LForInPrepareMap(context, object);
- return MarkAsCall(DefineFixed(result, r0), instr, CAN_DEOPTIMIZE_EAGERLY);
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
}
« src/objects-printer.cc ('K') | « src/ppc/lithium-ppc.h ('k') | src/ppc/macro-assembler-ppc.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698