A64: Synchronize with r18642.

src/a64/builtins-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 267 matching lines @@
     __ CallRuntime(Runtime::kNewStringWrapper, 1);
   }
   __ Ret();
 }
 
 
 static void CallRuntimePassFunction(MacroAssembler* masm,
                                     Runtime::FunctionId function_id) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   //   - Push a copy of the function onto the stack.
-  //   - Push call kind information.
-  //   - Function is also the parameter to the runtime call.
-  __ Push(x1, x5, x1);
+  //   - Push another copy as a parameter to the runtime call.
+  __ Push(x1, x1);
 
   __ CallRuntime(function_id, 1);
 
-  //   - Restore call kind information.
   //   - Restore receiver.
-  __ Pop(x5, x1);
+  __ Pop(x1);
 }
 
 
 static void GenerateTailCallToSharedCode(MacroAssembler* masm) {
   __ Ldr(x2, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
   __ Ldr(x2, FieldMemOperand(x2, SharedFunctionInfo::kCodeOffset));
   __ Add(x2, x2, Code::kHeaderSize - kHeapObjectTag);
   __ Br(x2);
 }
 
@@ skipping 259 matching lines @@
     __ Drop(1);
     __ Bind(&done_copying_arguments);
 
     // Call the function.
     // x0: number of arguments
     // x1: constructor function
     if (is_api_function) {
       __ Ldr(cp, FieldMemOperand(constructor, JSFunction::kContextOffset));
       Handle<Code> code =
           masm->isolate()->builtins()->HandleApiCallConstruct();
-      ParameterCount expected(0);
-      __ InvokeCode(code, expected, expected,
-                    RelocInfo::CODE_TARGET, CALL_FUNCTION, CALL_AS_METHOD);
+      __ Call(code, RelocInfo::CODE_TARGET);
     } else {
       ParameterCount actual(argc);
-      __ InvokeFunction(constructor, actual, CALL_FUNCTION,
-                        NullCallWrapper(), CALL_AS_METHOD);
+      __ InvokeFunction(constructor, actual, CALL_FUNCTION, NullCallWrapper());
     }
 
     // Store offset of return address for deoptimizer.
     if (!is_api_function && !count_constructions) {
       masm->isolate()->heap()->SetConstructStubDeoptPCOffset(masm->pc_offset());
     }
 
     // Restore the context from the frame.
     // x0: result
     // jssp[0]: receiver
@@ skipping 130 matching lines @@
     if (is_construct) {
       // No type feedback cell is available.
       Handle<Object> undefined_sentinel(
           masm->isolate()->heap()->undefined_value(), masm->isolate());
       __ Mov(x2, Operand(undefined_sentinel));
 
       CallConstructStub stub(NO_CALL_FUNCTION_FLAGS);
       __ CallStub(&stub);
     } else {
       ParameterCount actual(x0);
-      __ InvokeFunction(function, actual, CALL_FUNCTION,
-                        NullCallWrapper(), CALL_AS_METHOD);
+      __ InvokeFunction(function, actual, CALL_FUNCTION, NullCallWrapper());
     }
     // Exit the JS internal frame and remove the parameters (except function),
     // and return.
   }
 
   // Result is in x0. Return.
   __ Ret();
 }
 
 
 void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, false);
 }
 
 
 void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
   Generate_JSEntryTrampolineHelper(masm, true);
 }
 
 
 void Builtins::Generate_CompileUnoptimized(MacroAssembler* masm) {
   CallRuntimePassFunction(masm, Runtime::kCompileUnoptimized);
   GenerateTailCallToReturnedCode(masm);
 }
 
 
 static void CallCompileOptimized(MacroAssembler* masm, bool concurrent) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   Register function = x1;
-  Register call_kind = x5;
 
-  // Preserve function and call kind. At the same time, push arguments for
+  // Preserve function. At the same time, push arguments for
   // kCompileOptimized.
   __ LoadObject(x10, masm->isolate()->factory()->ToBoolean(concurrent));
-  __ Push(function, call_kind, function, x10);
+  __ Push(function, function, x10);
 
   __ CallRuntime(Runtime::kCompileOptimized, 2);
 
-  // Restore preserved call kind and function.
-  __ Pop(call_kind, function);
+  // Restore receiver.
+  __ Pop(function);
 }
 
 
 void Builtins::Generate_CompileOptimized(MacroAssembler* masm) {
   CallCompileOptimized(masm, false);
   GenerateTailCallToReturnedCode(masm);
 }
 
 
 void Builtins::Generate_CompileOptimizedConcurrent(MacroAssembler* masm) {
@@ skipping 353 matching lines @@
 
   // 5a. Call non-function via tail call to CALL_NON_FUNCTION builtin,
   //     or a function proxy via CALL_FUNCTION_PROXY.
   // x0: actual number of arguments
   // x1: function
   // x4: call type (0: JS function, 1: function proxy, 2: non-function)
   { Label function, non_proxy;
     __ Cbz(x4, &function);
     // Expected number of arguments is 0 for CALL_NON_FUNCTION.
     __ Mov(x2, 0);
-    __ SetCallKind(x5, CALL_AS_METHOD);
     __ Cmp(x4, 1);
     __ B(ne, &non_proxy);
 
     __ Push(x1);  // Re-add proxy object as additional argument.
     __ Add(x0, x0, 1);
-    __ GetBuiltinEntry(x3, Builtins::CALL_FUNCTION_PROXY);
+    __ GetBuiltinFunction(x1, Builtins::CALL_FUNCTION_PROXY);
     __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
             RelocInfo::CODE_TARGET);
 
     __ Bind(&non_proxy);
-    __ GetBuiltinEntry(x3, Builtins::CALL_NON_FUNCTION);
+    __ GetBuiltinFunction(x1, Builtins::CALL_NON_FUNCTION);
     __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
             RelocInfo::CODE_TARGET);
     __ Bind(&function);
   }
 
   // 5b. Get the code to call from the function and check that the number of
   //     expected arguments matches what we're providing.  If so, jump
   //     (tail-call) to the code in register edx without checking arguments.
   // x0: actual number of arguments
   // x1: function
   __ Ldr(x3, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
   __ Ldrsw(x2,
            FieldMemOperand(x3,
              SharedFunctionInfo::kFormalParameterCountOffset));
-  __ Ldr(x3, FieldMemOperand(x1, JSFunction::kCodeEntryOffset));
-  __ SetCallKind(x5, CALL_AS_FUNCTION);
   Label dont_adapt_args;
   __ Cmp(x2, x0);  // Check formal and actual parameter counts.
   __ B(eq, &dont_adapt_args);
   __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
           RelocInfo::CODE_TARGET);
+  __ Bind(&dont_adapt_args);
 
-  __ Bind(&dont_adapt_args);
+  __ Ldr(x3, FieldMemOperand(x1, JSFunction::kCodeEntryOffset));
   ParameterCount expected(0);
-  __ InvokeCode(x3, expected, expected, JUMP_FUNCTION,
-                NullCallWrapper(), CALL_AS_FUNCTION);
+  __ InvokeCode(x3, expected, expected, JUMP_FUNCTION, NullCallWrapper());
 }
 
 
 void Builtins::Generate_FunctionApply(MacroAssembler* masm) {
   ASM_LOCATION("Builtins::Generate_FunctionApply");
   const int kIndexOffset    =
       StandardFrameConstants::kExpressionsOffset - (2 * kPointerSize);
   const int kLimitOffset    =
       StandardFrameConstants::kExpressionsOffset - (1 * kPointerSize);
   const int kArgsOffset     =  2 * kPointerSize;
@@ skipping 122 matching lines @@
     // represented as a smi.
 
     function = x1;  // From now on we want the function to be kept in x1;
     __ Ldr(function, MemOperand(fp, kFunctionOffset));
 
     // Call the function.
     Label call_proxy;
     ParameterCount actual(current);
     __ SmiUntag(current);
     __ JumpIfNotObjectType(function, x10, x11, JS_FUNCTION_TYPE, &call_proxy);
-    __ InvokeFunction(function, actual, CALL_FUNCTION,
-                      NullCallWrapper(), CALL_AS_FUNCTION);
+    __ InvokeFunction(function, actual, CALL_FUNCTION, NullCallWrapper());
     frame_scope.GenerateLeaveFrame();
     __ Drop(3);
     __ Ret();
 
     // Call the function proxy.
     __ Bind(&call_proxy);
     // x0 : argc
     // x1 : function
     __ Push(function);  // Add function proxy as last argument.
     __ Add(x0, x0, 1);
     __ Mov(x2, 0);
-    __ SetCallKind(x5, CALL_AS_FUNCTION);
-    __ GetBuiltinEntry(x3, Builtins::CALL_FUNCTION_PROXY);
+    __ GetBuiltinFunction(x1, Builtins::CALL_FUNCTION_PROXY);
     __ Call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
             RelocInfo::CODE_TARGET);
   }
   __ Drop(3);
   __ Ret();
 }
 
 
 static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) {
   __ SmiTag(x10, x0);
@@ skipping 19 matching lines @@
   __ Drop(1);
 }
 
 
 void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
   ASM_LOCATION("Builtins::Generate_ArgumentsAdaptorTrampoline");
   // ----------- S t a t e -------------
   //  -- x0 : actual number of arguments
   //  -- x1 : function (passed through to callee)
   //  -- x2 : expected number of arguments
-  //  -- x3 : code entry to call
-  //  -- x5 : call kind information
   // -----------------------------------
 
   Label invoke, dont_adapt_arguments;
 
   Label enough, too_few;
+  __ Ldr(x3, FieldMemOperand(x1, JSFunction::kCodeEntryOffset));
   __ Cmp(x0, x2);
   __ B(lt, &too_few);
   __ Cmp(x2, SharedFunctionInfo::kDontAdaptArgumentsSentinel);
   __ B(eq, &dont_adapt_arguments);
 
   {  // Enough parameters: actual >= expected
     EnterArgumentsAdaptorFrame(masm);
 
     // Calculate copy start address into x10 and end address into x11.
     // x0: actual number of arguments
@@ skipping 86 matching lines @@
   __ Bind(&dont_adapt_arguments);
   __ Jump(x3);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM