A64: Synchronize with r17807.

src/a64/lithium-codegen-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 416 matching lines @@
   }
 }
 
 
 void LCodeGen::DoCallFunction(LCallFunction* instr) {
   ASSERT(ToRegister(instr->function()).Is(x1));
   ASSERT(ToRegister(instr->result()).Is(x0));
 
   int arity = instr->arity();
   CallFunctionStub stub(arity, NO_CALL_FUNCTION_FLAGS);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
-  __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  if (instr->hydrogen()->IsTailCall()) {
+    if (NeedsEagerFrame()) {
+      __ Mov(masm()->StackPointer(), fp);
+    }
+    __ Jump(stub.GetCode(isolate()), RelocInfo::CODE_TARGET);
+  } else {
+    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+    __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  }
 }
 
 
 void LCodeGen::DoCallNew(LCallNew* instr) {
   ASSERT(instr->IsMarkedAsCall());
   ASSERT(ToRegister(instr->constructor()).is(x1));
 
   __ Mov(x0, instr->arity());
   // No cell in x2 for construct type feedback in optimized code.
   Handle<Object> undefined_value(isolate()->factory()->undefined_value());
@@ skipping 674 matching lines @@
       // Other constants not implemented.
       Abort(kToOperand32UnsupportedImmediate);
     }
   }
   // Other cases are not implemented.
   UNREACHABLE();
   return Operand(0);
 }
 
 
+static ptrdiff_t ArgumentsOffsetWithoutFrame(ptrdiff_t index) {
+  ASSERT(index < 0);
+  return -(index + 1) * kPointerSize;
+}
+
+
 MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
   ASSERT(op != NULL);
   ASSERT(!op->IsRegister());
   ASSERT(!op->IsDoubleRegister());
   ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());
-  return MemOperand(fp, StackSlotOffset(op->index()));
+  if (NeedsEagerFrame()) {
+    return MemOperand(fp, StackSlotOffset(op->index()));
+  } else {
+    // Retrieve parameter without eager stack-frame relative to the
+    // stack-pointer.
+    return MemOperand(masm()->StackPointer(),
+                      ArgumentsOffsetWithoutFrame(op->index()));
+  }
 }
 
 
 Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   ASSERT(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
   return constant->handle(isolate());
 }
 
 
@@ skipping 254 matching lines @@
     __ Str(temp2, MemOperand(result, temp1));
     __ Subs(temp1, temp1, kPointerSize);
     __ B(ge, &loop);
 
     __ Add(result, result, kHeapObjectTag);
   }
 }
 
 
 void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
-  Register result = ToRegister(instr->result());
-
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
-  __ Mov(result, Operand(Smi::FromInt(0)));
+  __ Mov(ToRegister(instr->result()), Operand(Smi::FromInt(0)));
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
+  // We're in a SafepointRegistersScope so we can use any scratch registers.
+  Register size = x0;
   if (instr->size()->IsConstantOperand()) {
-    int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
-    // Use result as a scratch register.
-    __ Mov(result, Operand(Smi::FromInt(size)));
-    __ Push(result);
+    __ Mov(size, Operand(ToSmi(LConstantOperand::cast(instr->size()))));
   } else {
-    Register size = ToRegister(instr->size());
-    __ SmiTag(size);
-    __ Push(size);
+    __ SmiTag(size, ToRegister(instr->size()));
   }
+  int flags = AllocateDoubleAlignFlag::encode(
+      instr->hydrogen()->MustAllocateDoubleAligned());
   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
-    CallRuntimeFromDeferred(Runtime::kAllocateInOldPointerSpace, 1, instr);
+    flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);
   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
-    CallRuntimeFromDeferred(Runtime::kAllocateInOldDataSpace, 1, instr);
+    flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);
   } else {
-    CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
+    flags = AllocateTargetSpace::update(flags, NEW_SPACE);
   }
-  __ StoreToSafepointRegisterSlot(x0, result);
+  __ Mov(x10, Operand(Smi::FromInt(flags)));
+  __ Push(size, x10);
+
+  CallRuntimeFromDeferred(Runtime::kAllocateInTargetSpace, 2, instr);
+  __ StoreToSafepointRegisterSlot(x0, ToRegister(instr->result()));
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Register receiver = ToRegister(instr->receiver());
   Register function = ToRegister(instr->function());
   Register length = ToRegister(instr->length());
   Register elements = ToRegister(instr->elements());
   Register scratch = x5;
   ASSERT(receiver.Is(x0));  // Used for parameter count.
@@ skipping 4163 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal