A64: Synchronize with r18256.

src/a64/lithium-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 153 matching lines @@
 
 
 void LGoto::PrintDataTo(StringStream* stream) {
   stream->Add("B%d", block_id());
 }
 
 
 void LInnerAllocatedObject::PrintDataTo(StringStream* stream) {
   stream->Add(" = ");
   base_object()->PrintTo(stream);
-  stream->Add(" + %d", offset());
+  stream->Add(" + ");
+  offset()->PrintTo(stream);
 }
 
 
 void LInvokeFunction::PrintDataTo(StringStream* stream) {
   stream->Add("= ");
   function()->PrintTo(stream);
   stream->Add(" #%d / ", arity());
 }
 
 
@@ skipping 1391 matching lines @@
 
 LInstruction* LChunkBuilder::DoHasInstanceTypeAndBranch(
     HHasInstanceTypeAndBranch* instr) {
   ASSERT(instr->value()->representation().IsTagged());
   LOperand* value = UseRegisterAtStart(instr->value());
   return new(zone()) LHasInstanceTypeAndBranch(value, TempRegister());
 }
 
 
 LInstruction* LChunkBuilder::DoInnerAllocatedObject(
-    HInnerAllocatedObject* inner_object) {
-  LOperand* base_object = UseRegisterAtStart(inner_object->base_object());
-  return DefineAsRegister(new(zone()) LInnerAllocatedObject(base_object));
+    HInnerAllocatedObject* instr) {
+  LOperand* base_object = UseRegisterAtStart(instr->base_object());
+  LOperand* offset = UseRegisterOrConstantAtStart(instr->offset());
+  return DefineAsRegister(
+      new(zone()) LInnerAllocatedObject(base_object, offset));
 }
 
 
 LInstruction* LChunkBuilder::DoInstanceOf(HInstanceOf* instr) {
   LInstanceOf* result = new(zone()) LInstanceOf(
       UseFixed(instr->left(), InstanceofStub::left()),
       UseFixed(instr->right(), InstanceofStub::right()));
   return MarkAsCall(DefineFixed(result, x0), instr);
 }
 
@@ skipping 836 matching lines @@
           // The Double case can never fail so it doesn't need an environment.
           return DefineAsRegister(result);
         } else {
           ASSERT(r.IsInteger32() || r.IsSmi());
           // The Integer32 and Smi cases need an environment because they can
           // deoptimize on minimum representable number.
           return AssignEnvironment(DefineAsRegister(result));
         }
       }
     }
-    case kMathCos: {
-      ASSERT(instr->representation().IsDouble());
-      ASSERT(instr->value()->representation().IsDouble());
-      LOperand* input = UseFixedDouble(instr->value(), d0);
-      LMathCos* result = new(zone()) LMathCos(input);
-      return MarkAsCall(DefineFixedDouble(result, d0), instr);
-    }
     case kMathExp: {
       ASSERT(instr->representation().IsDouble());
       ASSERT(instr->value()->representation().IsDouble());
       LOperand* input = UseRegister(instr->value());
       // TODO(all): Implement TempFPRegister.
       LOperand* double_temp1 = FixedTemp(d24);   // This was chosen arbitrarily.
       LOperand* temp1 = TempRegister();
       LOperand* temp2 = TempRegister();
       LOperand* temp3 = TempRegister();
       LMathExp* result = new(zone()) LMathExp(input, double_temp1,
@@ skipping 26 matching lines @@
     case kMathRound: {
       ASSERT(instr->representation().IsInteger32());
       ASSERT(instr->value()->representation().IsDouble());
       // TODO(jbramley): As with kMathFloor, we can probably handle double
       // results fairly easily, but we are never asked for them.
       LOperand* input = UseRegister(instr->value());
       LOperand* temp = FixedTemp(d24);  // Choosen arbitrarily.
       LMathRound* result = new(zone()) LMathRound(input, temp);
       return AssignEnvironment(DefineAsRegister(result));
     }
-    case kMathSin: {
-      ASSERT(instr->representation().IsDouble());
-      ASSERT(instr->value()->representation().IsDouble());
-      LOperand* input = UseFixedDouble(instr->value(), d0);
-      LMathSin* result = new(zone()) LMathSin(input);
-      return MarkAsCall(DefineFixedDouble(result, d0), instr);
-    }
     case kMathSqrt: {
       ASSERT(instr->representation().IsDouble());
       ASSERT(instr->value()->representation().IsDouble());
       LOperand* input = UseRegisterAtStart(instr->value());
       return DefineAsRegister(new(zone()) LMathSqrt(input));
     }
-    case kMathTan: {
-      ASSERT(instr->representation().IsDouble());
-      ASSERT(instr->value()->representation().IsDouble());
-      LOperand* input = UseFixedDouble(instr->value(), d0);
-      LMathTan* result = new(zone()) LMathTan(input);
-      return MarkAsCall(DefineFixedDouble(result, d0), instr);
-    }
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
   // Use an index that corresponds to the location in the unoptimized frame,
   // which the optimized frame will subsume.
@@ skipping 57 matching lines @@
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegisterAtStart(instr->function());
   LOperand* temp = TempRegister();
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function, temp);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal