A64: Synchronize with r19234.

src/a64/code-stubs-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 3244 matching lines @@
 
   __ Bind(&done);
 }
 
 
 void CallFunctionStub::Generate(MacroAssembler* masm) {
   ASM_LOCATION("CallFunctionStub::Generate");
   // x1  function    the function to call
   // x2  cache_cell  cache cell for call target
   Register function = x1;
+  Register cache_cell = x2;
   Register type = x4;
   Label slow, non_function, wrap, cont;
 
-  // TODO(jbramley): x2 is clobbered in a number of cases. Is it ever used?
-
   // TODO(jbramley): This function has a lot of unnamed registers. Name them,
   // and tidy things up a bit.
 
   if (NeedsChecks()) {
     // Check that the function is really a JavaScript function.
     __ JumpIfSmi(function, &non_function);
 
     // Goto slow case if we do not have a function.
     __ JumpIfNotObjectType(function, x10, x10, JS_FUNCTION_TYPE, &slow);
 
     if (RecordCallTarget()) {
       GenerateRecordCallTarget(masm);
     }
   }
 
   // Fast-case: Invoke the function now.
   // x1  function  pushed function
   ParameterCount actual(argc_);
 
   if (CallAsMethod()) {
     if (NeedsChecks()) {
       // Do not transform the receiver for strict mode functions.
-      __ Ldr(x2, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
-      __ Ldr(w3, FieldMemOperand(x2, SharedFunctionInfo::kCompilerHintsOffset));
-      __ Tbnz(w3, SharedFunctionInfo::kStrictModeFunction, &cont);
+      __ Ldr(x3, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
+      __ Ldr(w4, FieldMemOperand(x3, SharedFunctionInfo::kCompilerHintsOffset));
+      __ Tbnz(w4, SharedFunctionInfo::kStrictModeFunction, &cont);
 
       // Do not transform the receiver for native (Compilerhints already in x3).
-      __ Tbnz(w3, SharedFunctionInfo::kNative, &cont);
+      __ Tbnz(w4, SharedFunctionInfo::kNative, &cont);
     }
 
     // Compute the receiver in non-strict mode.
-    __ Peek(x2, argc_ * kPointerSize);
+    __ Peek(x3, argc_ * kPointerSize);
 
     if (NeedsChecks()) {
-      // x0: actual number of arguments
-      // x1: function
-      // x2: first argument
-      __ JumpIfSmi(x2, &wrap);
-      __ JumpIfObjectType(x2, x10, type, FIRST_SPEC_OBJECT_TYPE, &wrap, lt);
+      __ JumpIfSmi(x3, &wrap);
+      __ JumpIfObjectType(x3, x10, type, FIRST_SPEC_OBJECT_TYPE, &wrap, lt);
     } else {
       __ B(&wrap);
     }
 
     __ Bind(&cont);
   }
   __ InvokeFunction(function,
                     actual,
                     JUMP_FUNCTION,
                     NullCallWrapper());
 
   if (NeedsChecks()) {
     // Slow-case: Non-function called.
     __ Bind(&slow);
     if (RecordCallTarget()) {
       // If there is a call target cache, mark it megamorphic in the
       // non-function case. MegamorphicSentinel is an immortal immovable object
       // (undefined) so no write barrier is needed.
       ASSERT_EQ(*TypeFeedbackCells::MegamorphicSentinel(masm->isolate()),
                 masm->isolate()->heap()->undefined_value());
       __ LoadRoot(x11, Heap::kUndefinedValueRootIndex);
-      __ Str(x11, FieldMemOperand(x2, Cell::kValueOffset));
+      __ Str(x11, FieldMemOperand(cache_cell, Cell::kValueOffset));
     }
     // Check for function proxy.
     // x10 : function type.
     __ CompareAndBranch(type, JS_FUNCTION_PROXY_TYPE, ne, &non_function);
     __ Push(function);  // put proxy as additional argument
     __ Mov(x0, argc_ + 1);
     __ Mov(x2, 0);
     __ GetBuiltinFunction(x1, Builtins::CALL_FUNCTION_PROXY);
     {
       Handle<Code> adaptor =
           masm->isolate()->builtins()->ArgumentsAdaptorTrampoline();
       __ Jump(adaptor, RelocInfo::CODE_TARGET);
     }
 
     // CALL_NON_FUNCTION expects the non-function callee as receiver (instead
     // of the original receiver from the call site).
     __ Bind(&non_function);
     __ Poke(function, argc_ * kXRegSizeInBytes);
     __ Mov(x0, argc_);  // Set up the number of arguments.
     __ Mov(x2, 0);
     __ GetBuiltinFunction(function, Builtins::CALL_NON_FUNCTION);
     __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
             RelocInfo::CODE_TARGET);
   }
 
   if (CallAsMethod()) {
     __ Bind(&wrap);
     // Wrap the receiver and patch it back onto the stack.
     { FrameScope frame_scope(masm, StackFrame::INTERNAL);
-      __ Push(x1, x2);
+      __ Push(x1, x3);
       __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
       __ Pop(x1);
     }
     __ Poke(x0, argc_ * kPointerSize);
     __ B(&cont);
   }
 }
 
 
 void CallConstructStub::Generate(MacroAssembler* masm) {
@@ skipping 2313 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64