Contribution of PowerPC port.

src/ppc/lithium-ppc.cc

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 6ed8add0b0cc2a373b579418b29586e34ccd73f9..1186deb262e5d39cf67dfafb12c6d0040a8a9e96 100644
--- a/src/arm/lithium-arm.cc
+++ b/src/ppc/lithium-ppc.cc
@@ -1,13 +1,16 @@
 // 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-arm.h"
-#include "src/arm/lithium-codegen-arm.h"
 #include "src/hydrogen-osr.h"
 #include "src/lithium-allocator-inl.h"
+#include "src/ppc/lithium-codegen-ppc.h"
+#include "src/ppc/lithium-ppc.h"
 
 namespace v8 {
 namespace internal {
@@ -726,10 +729,13 @@ LInstruction* LChunkBuilder::DoArithmeticD(Token::Value op,
   ASSERT(instr->left()->representation().IsDouble());
   ASSERT(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());
@@ -746,11 +752,11 @@ LInstruction* LChunkBuilder::DoArithmeticT(Token::Value op,
   ASSERT(left->representation().IsTagged());
   ASSERT(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);
 }
 
 
@@ -982,9 +988,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);
 }
 
 
@@ -993,9 +999,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);
 }
 
 
@@ -1008,15 +1014,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);
 }
 
 
@@ -1073,11 +1079,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);
 }
 
 
@@ -1096,15 +1102,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);
 }
 
 
@@ -1157,8 +1163,8 @@ LInstruction* LChunkBuilder::DoMathAbs(HUnaryMathOperation* instr) {
 LInstruction* LChunkBuilder::DoMathLog(HUnaryMathOperation* instr) {
   ASSERT(instr->representation().IsDouble());
   ASSERT(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);
 }
 
 
@@ -1197,31 +1203,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);
 }
 
 
@@ -1301,15 +1307,12 @@ LInstruction* LChunkBuilder::DoDivI(HDiv* instr) {
   ASSERT(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);
@@ -1374,9 +1377,7 @@ LInstruction* LChunkBuilder::DoFlooringDivI(HMathFloorOfDiv* instr) {
   ASSERT(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));
 }
 
@@ -1428,12 +1429,8 @@ LInstruction* LChunkBuilder::DoModI(HMod* instr) {
   ASSERT(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);
@@ -1510,13 +1507,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;
       }
@@ -1534,7 +1532,8 @@ LInstruction* LChunkBuilder::DoSub(HSub* instr) {
     ASSERT(instr->left()->representation().Equals(instr->representation()));
     ASSERT(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);
     }
@@ -1548,8 +1547,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);
@@ -1563,6 +1562,7 @@ LInstruction* LChunkBuilder::DoRSub(HSub* instr) {
   ASSERT(instr->representation().IsSmiOrInteger32());
   ASSERT(instr->left()->representation().Equals(instr->representation()));
   ASSERT(instr->right()->representation().Equals(instr->representation()));
+  ASSERT(!instr->CheckFlag(HValue::kCanOverflow));
 
   // Note: The lhs of the subtraction becomes the rhs of the
   // reverse-subtraction.
@@ -1570,9 +1570,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;
 }
 
@@ -1660,12 +1657,12 @@ LInstruction* LChunkBuilder::DoPower(HPower* instr) {
   // We need to use fixed result register for the call.
   Representation exponent_type = instr->right()->representation();
   ASSERT(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);
 }
@@ -1675,10 +1672,10 @@ LInstruction* LChunkBuilder::DoCompareGeneric(HCompareGeneric* instr) {
   ASSERT(instr->left()->representation().IsTagged());
   ASSERT(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);
 }
 
 
@@ -1760,8 +1757,8 @@ LInstruction* LChunkBuilder::DoStringCompareAndBranch(
   ASSERT(instr->left()->representation().IsTagged());
   ASSERT(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);
@@ -1808,10 +1805,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);
 }
 
 
@@ -2023,8 +2020,6 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
     return DefineAsRegister(new(zone()) LClampIToUint8(reg));
   } else {
     ASSERT(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));
@@ -2051,7 +2046,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);
 }
 
@@ -2093,7 +2088,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);
 }
 
 
@@ -2151,7 +2146,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);
 }
 
@@ -2179,7 +2174,6 @@ LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
     if (instr->representation().IsDouble()) {
       obj = UseRegister(instr->elements());
     } else {
-      ASSERT(instr->representation().IsSmiOrTagged());
       obj = UseRegisterAtStart(instr->elements());
     }
     result = DefineAsRegister(new(zone()) LLoadKeyed(obj, key));
@@ -2218,7 +2212,7 @@ LInstruction* LChunkBuilder::DoLoadKeyedGeneric(HLoadKeyedGeneric* instr) {
 
   LInstruction* result =
       DefineFixed(new(zone()) LLoadKeyedGeneric(context, object, key, vector),
-                  r0);
+                  r3);
   return MarkAsCall(result, instr);
 }
 
@@ -2236,7 +2230,6 @@ LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
       val = UseRegister(instr->value());
       key = UseRegisterOrConstantAtStart(instr->key());
     } else {
-      ASSERT(instr->value()->representation().IsSmiOrTagged());
       if (needs_write_barrier) {
         object = UseTempRegister(instr->elements());
         val = UseTempRegister(instr->value());
@@ -2291,7 +2284,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);
@@ -2355,10 +2348,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);
 }
 
@@ -2396,14 +2389,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);
 }
 
 
@@ -2451,7 +2444,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);
 }
 
 
@@ -2482,16 +2475,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);
 }
 
 
@@ -2566,9 +2559,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);
 }