[Interpreter] Add CallRuntime support to the interpreter.

src/x64/builtins-x64.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_X64
 
 #include "src/code-factory.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 753 matching lines @@
   // Drop receiver + arguments and return.
   __ movl(rbx, FieldOperand(kInterpreterBytecodeArrayRegister,
                             BytecodeArray::kParameterSizeOffset));
   __ PopReturnAddressTo(rcx);
   __ addp(rsp, rbx);
   __ PushReturnAddressFrom(rcx);
   __ ret(0);
 }
 
 
+// static
+void Builtins::Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
+  // ----------- S t a t e -------------
+  //  -- rax : the number of arguments (not including the receiver)
+  //  -- rbx : the address of the first argument to be pushed. Subsequent
+  //           arguments should be consecutive above this, in the same order as
+  //           they are to be pushed onto the stack.
+  //  -- rdi : the target to call (can be any Object).
+
+  // Pop return address to allow tail-call after pushing arguments.
+  __ Pop(rdx);
+
+  // Find the address of the last argument.
+  __ movp(rcx, rax);
+  __ addp(rcx, Immediate(1));  // Add one for receiver.
+  __ shlp(rcx, Immediate(kPointerSizeLog2));
+  __ negp(rcx);
+  __ addp(rcx, rbx);
+
+  // Push the arguments.
+  Label loop_header, loop_check;
+  __ j(always, &loop_check);
+  __ bind(&loop_header);
+  __ Push(Operand(rbx, 0));
+  __ subp(rbx, Immediate(kPointerSize));
+  __ bind(&loop_check);
+  __ cmpp(rbx, rcx);
+  __ j(greater, &loop_header, Label::kNear);
+
+  // Call the target.
+  __ Push(rdx);  // Re-push return address.
+  __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
+}
+
+
+void Builtins::Generate_InterpreterCEntry(MacroAssembler* masm) {
+  // ----------- S t a t e -------------
+  //  -- r14 : the number of arguments (argc).
+  //  -- r15 : the address of the first argument (argv).
+  //  -- rbx : the FunctionId of the runtime function to call.
+  //  -- rsi : current context.
+
+  // TODO(rmcilroy): Things that still need to be done:
+  //  - Call ProfileEntryHookStub when isolate has a function_entry_hook.
+  //  - Deal with more than one return value.
+  //  - Deal with saving fpregs if necessary.
+  //  - Handle pending exceptions.
+
+  // Get the function entry address for the FunctionID.
+  const int kFunctionSizeLog2 = 2 + kPointerSizeLog2;

[Michael Starzinger, 2015/09/25 11:23:26]

Hmm, I am not all too excited to have lookup in the kIntrinsicFunctions table in
generated code now. But I cannot think of another efficient way to pull this
off, so I am inclined to go with it.

[rmcilroy, 2015/09/28 16:20:47]

Acknowledged. I can't think of a better way either.

+  STATIC_ASSERT(sizeof(Runtime::Function) == 1 << kFunctionSizeLog2);
+  __ shlp(rbx, Immediate(kFunctionSizeLog2));
+  __ LoadAddress(rax, ExternalReference::runtime_function_table_address());
+  __ addp(rbx, rax);
+  __ movp(rbx, Operand(rbx, offsetof(Runtime::Function, entry)));
+
+  // Enter the exit frame that transitions from JavaScript to C++.
+#ifdef _WIN64
+  int arg_stack_space = 2;
+#else   // _WIN64
+  int arg_stack_space = 0;
+#endif  // _WIN64
+  // TODO(rmcilroy): save fpregs if required.
+  __ EnterApiExitFrame(arg_stack_space);
+
+  // Check stack alignment.
+  if (FLAG_debug_code) {
+    __ CheckStackAlignment();
+  }
+
+  // Call C function.
+  //
+  // Pass argv and argc as two parameters. The arguments object will
+  // be created by stubs declared by DECLARE_RUNTIME_FUNCTION().
+#ifdef _WIN64
+  // Windows 64-bit ABI passes arguments in rcx, rdx, r8, r9.
+  __ movp(rcx, r14);  // argc.
+  __ movp(rdx, r15);  // argv.
+  __ Move(r8, ExternalReference::isolate_address(masm->isolate()));
+#else   // _WIN64
+  // GCC passes arguments in rdi, rsi, rdx, rcx, r8, r9.
+  __ movp(rdi, r14);  // argc.
+  __ movp(rsi, r15);  // argv.
+  __ Move(rdx, ExternalReference::isolate_address(masm->isolate()));
+#endif  // _WIN64
+  __ call(rbx);
+  // Result is in rax - do not destroy this register!
+
+  // Check result for exception sentinel.
+  Label exception_returned;
+  __ CompareRoot(rax, Heap::kExceptionRootIndex);
+  __ j(equal, &exception_returned);
+
+  // Check that there is no pending exception, otherwise we
+  // should have returned the exception sentinel.
+  if (FLAG_debug_code) {
+    Label okay;
+    __ LoadRoot(r14, Heap::kTheHoleValueRootIndex);
+    ExternalReference pending_exception_address(
+        Isolate::kPendingExceptionAddress, masm->isolate());
+    Operand pending_exception_operand =
+        masm->ExternalOperand(pending_exception_address);
+    __ cmpp(r14, pending_exception_operand);
+    __ j(equal, &okay, Label::kNear);
+    __ int3();
+    __ bind(&okay);
+  }
+
+  // Exit the JavaScript to C++ exit frame.
+  // TODO(rmcilroy): restore fpregs if required.
+  __ LeaveExitFrame(false);
+  __ ret(0);
+
+  // TODO(rmcilroy): Handle exceptions.
+  __ bind(&exception_returned);

[Michael Starzinger, 2015/09/25 11:23:26]

I am not too happy about duplicating the CEntryStub.

Is there a fundamental reason we need a separate CEntryStub outside the dynamic
calculation of the C-Function entry address? Would it be possible to use the
normal CEntryStub and just do the entry-address calculation before somehow? Or
am I missing something?

[rmcilroy, 2015/09/28 16:20:47]

Very good point. The missing thing in CEntryStub was to have the argv already in
a register (rather than trying to calculate it's location on the stack). I've
added an option for this to CEntryStub now and moved the entry-address
calculation into interpreter-assembler, so there is now no need for a new
builtin (the only remaining builtin changes are the renaming of the already
existing PushArgsAndCall builtin. WDYT?

+  __ int3();
+}
+
+
 void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
   CallRuntimePassFunction(masm, Runtime::kCompileLazy);
   GenerateTailCallToReturnedCode(masm);
 }
 
 
 static void CallCompileOptimized(MacroAssembler* masm,
                                             bool concurrent) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   // Push a copy of the function onto the stack.
@@ skipping 1041 matching lines @@
   // method.
   __ bind(&non_constructor);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     __ Push(rdi);
     __ CallRuntime(Runtime::kThrowCalledNonCallable, 1);
   }
 }
 
 
-// static
-void Builtins::Generate_PushArgsAndCall(MacroAssembler* masm) {
-  // ----------- S t a t e -------------
-  //  -- rax : the number of arguments (not including the receiver)
-  //  -- rbx : the address of the first argument to be pushed. Subsequent
-  //           arguments should be consecutive above this, in the same order as
-  //           they are to be pushed onto the stack.
-  //  -- rdi : the target to call (can be any Object).
-
-  // Pop return address to allow tail-call after pushing arguments.
-  __ Pop(rdx);
-
-  // Find the address of the last argument.
-  __ movp(rcx, rax);
-  __ addp(rcx, Immediate(1));  // Add one for receiver.
-  __ shlp(rcx, Immediate(kPointerSizeLog2));
-  __ negp(rcx);
-  __ addp(rcx, rbx);
-
-  // Push the arguments.
-  Label loop_header, loop_check;
-  __ j(always, &loop_check);
-  __ bind(&loop_header);
-  __ Push(Operand(rbx, 0));
-  __ subp(rbx, Immediate(kPointerSize));
-  __ bind(&loop_check);
-  __ cmpp(rbx, rcx);
-  __ j(greater, &loop_header, Label::kNear);
-
-  // Call the target.
-  __ Push(rdx);  // Re-push return address.
-  __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
-}
-
-
 void Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
   // Lookup the function in the JavaScript frame.
   __ movp(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     // Pass function as argument.
     __ Push(rax);
     __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
   }
 
@@ skipping 39 matching lines @@
   __ ret(0);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64