A64: Synchronize with r15545.

src/x64/builtins-x64.cc

 // Copyright 2012 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
-#if defined(V8_TARGET_ARCH_X64)
+#if V8_TARGET_ARCH_X64
 
 #include "codegen.h"
 #include "deoptimizer.h"
 #include "full-codegen.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define __ ACCESS_MASM(masm)
 
 
 void Builtins::Generate_Adaptor(MacroAssembler* masm,
                                 CFunctionId id,
                                 BuiltinExtraArguments extra_args) {
   // ----------- S t a t e -------------
-  //  -- rax                : number of arguments excluding receiver
-  //  -- rdi                : called function (only guaranteed when
-  //                          extra_args requires it)
-  //  -- rsi                : context
-  //  -- rsp[0]             : return address
-  //  -- rsp[8]             : last argument
+  //  -- rax                 : number of arguments excluding receiver
+  //  -- rdi                 : called function (only guaranteed when
+  //                           extra_args requires it)
+  //  -- rsi                 : context
+  //  -- rsp[0]              : return address
+  //  -- rsp[8]              : last argument
   //  -- ...
-  //  -- rsp[8 * argc]      : first argument (argc == rax)
-  //  -- rsp[8 * (argc +1)] : receiver
+  //  -- rsp[8 * argc]       : first argument (argc == rax)
+  //  -- rsp[8 * (argc + 1)] : receiver
   // -----------------------------------
 
   // Insert extra arguments.
   int num_extra_args = 0;
   if (extra_args == NEEDS_CALLED_FUNCTION) {
     num_extra_args = 1;
     __ pop(kScratchRegister);  // Save return address.
     __ push(rdi);
     __ push(kScratchRegister);  // Restore return address.
   } else {
@@ skipping 383 matching lines @@
 }
 
 
 void Builtins::Generate_JSConstructStubApi(MacroAssembler* masm) {
   Generate_JSConstructStubHelper(masm, true, false);
 }
 
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
                                              bool is_construct) {
+  ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
   // Expects five C++ function parameters.
   // - Address entry (ignored)
   // - JSFunction* function (
   // - Object* receiver
   // - int argc
   // - Object*** argv
   // (see Handle::Invoke in execution.cc).
 
   // Open a C++ scope for the FrameScope.
   {
     // Platform specific argument handling. After this, the stack contains
     // an internal frame and the pushed function and receiver, and
     // register rax and rbx holds the argument count and argument array,
     // while rdi holds the function pointer and rsi the context.
 
 #ifdef _WIN64
     // MSVC parameters in:
-    // rcx : entry (ignored)
-    // rdx : function
-    // r8 : receiver
-    // r9 : argc
+    // rcx        : entry (ignored)
+    // rdx        : function
+    // r8         : receiver
+    // r9         : argc
     // [rsp+0x20] : argv
 
     // Clear the context before we push it when entering the internal frame.
     __ Set(rsi, 0);
     // Enter an internal frame.
     FrameScope scope(masm, StackFrame::INTERNAL);
 
     // Load the function context into rsi.
     __ movq(rsi, FieldOperand(rdx, JSFunction::kContextOffset));
 
@@ skipping 28 matching lines @@
     __ push(rdi);
     __ push(rdx);
     __ movq(rsi, FieldOperand(rdi, JSFunction::kContextOffset));
 
     // Load the number of arguments and setup pointer to the arguments.
     __ movq(rax, rcx);
     __ movq(rbx, r8);
 #endif  // _WIN64
 
     // Current stack contents:
-    // [rsp + 2 * kPointerSize ... ]: Internal frame
-    // [rsp + kPointerSize]         : function
-    // [rsp]                        : receiver
+    // [rsp + 2 * kPointerSize ... ] : Internal frame
+    // [rsp + kPointerSize]          : function
+    // [rsp]                         : receiver
     // Current register contents:
     // rax : argc
     // rbx : argv
     // rsi : context
     // rdi : function
 
     // Copy arguments to the stack in a loop.
     // Register rbx points to array of pointers to handle locations.
     // Push the values of these handles.
     Label loop, entry;
@@ skipping 176 matching lines @@
   __ bind(&not_no_registers);
   __ movq(rax, Operand(rsp, 2 * kPointerSize));
   __ cmpq(r10, Immediate(FullCodeGenerator::TOS_REG));
   __ j(not_equal, &not_tos_rax, Label::kNear);
   __ ret(2 * kPointerSize);  // Remove state, rax.
 
   __ bind(&not_tos_rax);
   __ Abort("no cases left");
 }
 
+
 void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) {
   Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::EAGER);
 }
 
 
 void Builtins::Generate_NotifySoftDeoptimized(MacroAssembler* masm) {
   Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::SOFT);
 }
 
 
@@ skipping 12 matching lines @@
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ CallRuntime(Runtime::kNotifyOSR, 0);
   }
   __ Popad();
   __ ret(0);
 }
 
 
 void Builtins::Generate_FunctionCall(MacroAssembler* masm) {
   // Stack Layout:
-  // rsp[0]:   Return address
-  // rsp[1]:   Argument n
-  // rsp[2]:   Argument n-1
+  // rsp[0]           : Return address
+  // rsp[8]           : Argument n
+  // rsp[16]          : Argument n-1
   //  ...
-  // rsp[n]:   Argument 1
-  // rsp[n+1]: Receiver (function to call)
+  // rsp[8 * n]       : Argument 1
+  // rsp[8 * (n + 1)] : Receiver (function to call)
   //
   // rax contains the number of arguments, n, not counting the receiver.
   //
   // 1. Make sure we have at least one argument.
   { Label done;
     __ testq(rax, rax);
     __ j(not_zero, &done);
     __ pop(rbx);
     __ Push(masm->isolate()->factory()->undefined_value());
     __ push(rbx);
@@ skipping 147 matching lines @@
        RelocInfo::CODE_TARGET);
 
   ParameterCount expected(0);
   __ InvokeCode(rdx, expected, expected, JUMP_FUNCTION,
                 NullCallWrapper(), CALL_AS_METHOD);
 }
 
 
 void Builtins::Generate_FunctionApply(MacroAssembler* masm) {
   // Stack at entry:
-  //    rsp: return address
-  //  rsp+8: arguments
-  // rsp+16: receiver ("this")
-  // rsp+24: function
+  // rsp     : return address
+  // rsp[8]  : arguments
+  // rsp[16] : receiver ("this")
+  // rsp[24] : function
   {
     FrameScope frame_scope(masm, StackFrame::INTERNAL);
     // Stack frame:
-    //    rbp: Old base pointer
-    // rbp[1]: return address
-    // rbp[2]: function arguments
-    // rbp[3]: receiver
-    // rbp[4]: function
+    // rbp     : Old base pointer
+    // rbp[8]  : return address
+    // rbp[16] : function arguments
+    // rbp[24] : receiver
+    // rbp[32] : function
     static const int kArgumentsOffset = 2 * kPointerSize;
     static const int kReceiverOffset = 3 * kPointerSize;
     static const int kFunctionOffset = 4 * kPointerSize;
 
     __ push(Operand(rbp, kFunctionOffset));
     __ push(Operand(rbp, kArgumentsOffset));
     __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
 
     // Check the stack for overflow. We are not trying to catch
     // interruptions (e.g. debug break and preemption) here, so the "real stack
@@ skipping 134 matching lines @@
             RelocInfo::CODE_TARGET);
 
     // Leave internal frame.
   }
   __ ret(3 * kPointerSize);  // remove this, receiver, and arguments
 }
 
 
 void Builtins::Generate_InternalArrayCode(MacroAssembler* masm) {
   // ----------- S t a t e -------------
-  //  -- rax : argc
+  //  -- rax    : argc
   //  -- rsp[0] : return address
   //  -- rsp[8] : last argument
   // -----------------------------------
   Label generic_array_code;
 
   // Get the InternalArray function.
   __ LoadGlobalFunction(Context::INTERNAL_ARRAY_FUNCTION_INDEX, rdi);
 
   if (FLAG_debug_code) {
     // Initial map for the builtin InternalArray functions should be maps.
     __ movq(rbx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     STATIC_ASSERT(kSmiTag == 0);
     Condition not_smi = NegateCondition(masm->CheckSmi(rbx));
     __ Check(not_smi, "Unexpected initial map for InternalArray function");
     __ CmpObjectType(rbx, MAP_TYPE, rcx);
     __ Check(equal, "Unexpected initial map for InternalArray function");
   }
 
   // Run the native code for the InternalArray function called as a normal
   // function.
   // tail call a stub
   InternalArrayConstructorStub stub(masm->isolate());
   __ TailCallStub(&stub);
 }
 
 
 void Builtins::Generate_ArrayCode(MacroAssembler* masm) {
   // ----------- S t a t e -------------
-  //  -- rax : argc
+  //  -- rax    : argc
   //  -- rsp[0] : return address
   //  -- rsp[8] : last argument
   // -----------------------------------
   Label generic_array_code;
 
   // Get the Array function.
   __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, rdi);
 
   if (FLAG_debug_code) {
     // Initial map for the builtin Array functions should be maps.
@@ skipping 293 matching lines @@
   Deoptimizer::EntryGenerator generator(masm, Deoptimizer::OSR);
   generator.Generate();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64