[WIP] Initial CallFunctionCallback builtin.

src/builtins/arm/builtins-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_ARM
 
+#include "src/api-arguments.h"
 #include "src/assembler-inl.h"
 #include "src/codegen.h"
 #include "src/counters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/objects-inl.h"
 #include "src/runtime/runtime.h"
 
 namespace v8 {
@@ skipping 2686 matching lines @@
 
   // CheckSpreadAndPushToStack will push r3 to save it.
   __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
   CheckSpreadAndPushToStack(masm);
   __ Jump(masm->isolate()->builtins()->Call(ConvertReceiverMode::kAny,
                                             TailCallMode::kDisallow),
           RelocInfo::CODE_TARGET);
 }
 
 // static
+void Builtins::Generate_CallFunctionCallback(MacroAssembler* masm) {
+  // ----------- S t a t e -------------
+  //  -- r0                : the number of arguments (not incl. the receiver)
+  //  -- r1                : api function address
+  //  -- sp[0]             : holder
+  //  -- sp[4]             : isolate
+  //  -- sp[8]             : return value default
+  //  -- sp[12]            : return value
+  //  -- sp[16]            : call data
+  //  -- sp[20]            : target
+  //  -- sp[24]            : context save
+  //  -- sp[28]            : new.target
+  //  -- sp[32]            : last argument
+  //  -- sp[28 + argc * 4] : first argument
+  //  -- sp[32 + argc * 4] : receiver
+  // -----------------------------------
+  typedef FunctionCallbackArguments FCA;
+
+  STATIC_ASSERT(FCA::kNewTargetIndex == 7);
+  STATIC_ASSERT(FCA::kContextSaveIndex == 6);
+  STATIC_ASSERT(FCA::kCalleeIndex == 5);
+  STATIC_ASSERT(FCA::kDataIndex == 4);
+  STATIC_ASSERT(FCA::kReturnValueOffset == 3);
+  STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2);
+  STATIC_ASSERT(FCA::kIsolateIndex == 1);
+  STATIC_ASSERT(FCA::kHolderIndex == 0);
+  STATIC_ASSERT(FCA::kArgsLength == 8);
+
+  // Compute the pointer to the implicit args on the stack.
+  __ mov(r2, sp);
+
+  // Allocate the v8::FunctionCallbackInfo structure in the arguments' space
+  // since it's not controlled by the GC.
+  const int kApiStackSpace = 3;
+  FrameScope frame_scope(masm, StackFrame::MANUAL);
+  __ EnterExitFrame(false, kApiStackSpace);
+  // r3 = FunctionCallbackInfo&
+  // Arguments is after the return address.
+  __ add(r3, sp, Operand(1 * kPointerSize));
+  // Initialize FunctionCallbackInfo::implicit_args_.
+  __ str(r2, MemOperand(r3, 0 * kPointerSize));
+  // Initialize FunctionCallbackInfo::values_.
+  __ add(r2, r2, Operand(r0, LSL, kPointerSizeLog2));
+  __ add(r2, r2, Operand((FCA::kArgsLength - 1) * kPointerSize));
+  __ str(r2, MemOperand(r3, 1 * kPointerSize));
+  // Initialize FunctionCallbackInfo::length_.
+  __ str(r0, MemOperand(r3, 2 * kPointerSize));
+
+  // Load first argument with pointer to FunctionCallbackInfo.
+  __ mov(r0, r3);
+
+  // TODO(bmeurer): Do we need this?
+  AllowExternalCallThatCantCauseGC scope(masm);
+
+  const int kNextOffset = 0;
+  const int kLimitOffset = AddressOffset(
+      ExternalReference::handle_scope_limit_address(masm->isolate()),
+      ExternalReference::handle_scope_next_address(masm->isolate()));
+  const int kLevelOffset = AddressOffset(
+      ExternalReference::handle_scope_level_address(masm->isolate()),
+      ExternalReference::handle_scope_next_address(masm->isolate()));
+
+  // Allocate HandleScope in callee-save registers.
+  __ mov(
+      r9,
+      Operand(ExternalReference::handle_scope_next_address(masm->isolate())));
+  __ ldr(r4, MemOperand(r9, kNextOffset));
+  __ ldr(r5, MemOperand(r9, kLimitOffset));
+  __ ldr(r6, MemOperand(r9, kLevelOffset));
+  __ add(r6, r6, Operand(1));
+  __ str(r6, MemOperand(r9, kLevelOffset));
+
+  // Check if profiling is active, and if so call the function indirectly
+  // via the invoke_function_callback helper.
+  Label call_indirect, done_call;
+  __ mov(ip, Operand(ExternalReference::is_profiling_address(masm->isolate())));
+  __ ldrb(ip, MemOperand(ip, 0));
+  __ cmp(ip, Operand(0));
+  __ b(ne, &call_indirect);
+  {
+    // Call the API function directly.
+    // TODO(all): Deprecate DirectCEntryStub usage here, since this builtin
+    // is part of the snapshot and thus isn't relocated by the GC ever.
+    DirectCEntryStub stub(masm->isolate());
+    stub.GenerateCall(masm, r1);
+  }
+  __ b(&done_call);
+  __ bind(&call_indirect);
+  {
+    // Call the API function indirectly when profiling is on.
+    // TODO(all): Deprecate DirectCEntryStub usage here, since this builtin
+    // is part of the snapshot and thus isn't relocated by the GC ever.
+    DirectCEntryStub stub(masm->isolate());
+    __ mov(
+        r3,
+        Operand(ExternalReference::invoke_function_callback(masm->isolate())));
+    stub.GenerateCall(masm, r3);
+  }
+  __ bind(&done_call);
+
+  // No more valid handles (the result handle was the last one). Restore
+  // previous handle scope.
+  Label delete_allocated_handles;
+  __ str(r4, MemOperand(r9, kNextOffset));
+  __ sub(r6, r6, Operand(1));
+  __ str(r6, MemOperand(r9, kLevelOffset));
+  __ ldr(ip, MemOperand(r9, kLimitOffset));
+  __ cmp(r5, ip);
+  __ b(ne, &delete_allocated_handles);
+
+  // Leave the API exit frame.
+  Label leave_exit_frame;
+  __ bind(&leave_exit_frame);
+  __ ldr(r0, MemOperand(fp, (2 + FCA::kReturnValueOffset) * kPointerSize));
+  __ ldr(cp, MemOperand(fp, (2 + FCA::kContextSaveIndex) * kPointerSize));
+  __ ldr(r4, MemOperand(sp, 3 * kPointerSize));
+  __ LeaveExitFrame(false, no_reg, false);
+
+  // Check if the function scheduled an exception.
+  Label promote_scheduled_exception;
+  __ mov(
+      ip,
+      Operand(ExternalReference::scheduled_exception_address(masm->isolate())));
+  __ ldr(r5, MemOperand(ip));
+  __ JumpIfNotRoot(r5, Heap::kTheHoleValueRootIndex,
+                   &promote_scheduled_exception);
+
+  // Check if the function returned a valid JavaScript value.
+  __ AssertApiCallResult(r0);
+
+  // Drop the arguments and return.
+  __ add(sp, sp, Operand((FCA::kArgsLength + 1) * kPointerSize));
+  __ add(sp, sp, Operand(r4, LSL, kPointerSizeLog2));
+  __ Ret();
+
+  // Re-throw by promoting a scheduled exception.
+  __ bind(&promote_scheduled_exception);
+  __ TailCallRuntime(Runtime::kPromoteScheduledException);
+
+  // HandleScope limit has changed. Delete allocated extensions.
+  __ bind(&delete_allocated_handles);
+  {
+    __ str(r5, MemOperand(r9, kLimitOffset));
+    __ PrepareCallCFunction(1, r5);
+    __ mov(r0, Operand(ExternalReference::isolate_address(masm->isolate())));
+    __ CallCFunction(
+        ExternalReference::delete_handle_scope_extensions(masm->isolate()), 1);
+  }
+  __ b(&leave_exit_frame);
+}
+
+// static
 void Builtins::Generate_ConstructFunction(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r0 : the number of arguments (not including the receiver)
   //  -- r1 : the constructor to call (checked to be a JSFunction)
   //  -- r3 : the new target (checked to be a constructor)
   // -----------------------------------
   __ AssertFunction(r1);
 
   // Calling convention for function specific ConstructStubs require
   // r2 to contain either an AllocationSite or undefined.
@@ skipping 299 matching lines @@
   }
   // Now jump to the instructions of the returned code object.
   __ Jump(r8);
 }
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM