[WIP] Initial CallFunctionCallback builtin.

src/arm64/code-stubs-arm64.cc

 // Copyright 2013 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_ARM64
 
 #include "src/api-arguments.h"
 #include "src/arm64/assembler-arm64-inl.h"
 #include "src/arm64/frames-arm64.h"
 #include "src/arm64/macro-assembler-arm64-inl.h"
@@ skipping 2810 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 // The number of register that CallApiFunctionAndReturn will need to save on
 // the stack. The space for these registers need to be allocated in the
 // ExitFrame before calling CallApiFunctionAndReturn.
 static const int kCallApiFunctionSpillSpace = 4;
 
 
-static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
-  return static_cast<int>(ref0.address() - ref1.address());
-}
-
-
 // Calls an API function. Allocates HandleScope, extracts returned value
 // from handle and propagates exceptions.
 // 'stack_space' is the space to be unwound on exit (includes the call JS
 // arguments space and the additional space allocated for the fast call).
 // 'spill_offset' is the offset from the stack pointer where
 // CallApiFunctionAndReturn can spill registers.
 static void CallApiFunctionAndReturn(
     MacroAssembler* masm, Register function_address,
     ExternalReference thunk_ref, int stack_space,
     MemOperand* stack_space_operand, int spill_offset,
@@ skipping 109 matching lines @@
   }
 
   __ LeaveExitFrame(false, x1, !restore_context);
 
   // Check if the function scheduled an exception.
   __ Mov(x5, ExternalReference::scheduled_exception_address(isolate));
   __ Ldr(x5, MemOperand(x5));
   __ JumpIfNotRoot(x5, Heap::kTheHoleValueRootIndex,
                    &promote_scheduled_exception);
 
+  // Check if the function returned a valid JavaScript value.
+  __ AssertApiCallResult(x0);
+
   if (stack_space_operand != NULL) {
     __ Drop(x2, 1);
   } else {
     __ Drop(stack_space);
   }
   __ Ret();
 
   // Re-throw by promoting a scheduled exception.
   __ Bind(&promote_scheduled_exception);
   __ TailCallRuntime(Runtime::kPromoteScheduledException);
@@ skipping 57 matching lines @@
   }
 
   __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex);
   Register isolate_reg = x5;
   __ Mov(isolate_reg, ExternalReference::isolate_address(masm->isolate()));
 
   // FunctionCallbackArguments:
   //    return value, return value default, isolate, holder.
   __ Push(call_data, call_data, isolate_reg, holder);
 
+  if (!is_store()) {
+    __ Mov(x0, argc());
+    __ Jump(masm->isolate()->builtins()->CallFunctionCallback(),
+            RelocInfo::CODE_TARGET);
+  }
+
   // Prepare arguments.
   Register args = x6;
   __ Mov(args, masm->StackPointer());
 
   // Allocate the v8::Arguments structure in the arguments' space, since it's
   // not controlled by GC.
   const int kApiStackSpace = 3;
 
   // Allocate space for CallApiFunctionAndReturn can store some scratch
   // registeres on the stack.
@@ skipping 109 matching lines @@
                            kStackUnwindSpace, NULL, spill_offset,
                            return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64