Direct call C++ functions

src/x64/macro-assembler-x64.cc

 // Copyright 2009 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 19 matching lines @@
 #include "bootstrapper.h"
 #include "codegen-inl.h"
 #include "assembler-x64.h"
 #include "macro-assembler-x64.h"
 #include "serialize.h"
 #include "debug.h"
 
 namespace v8 {
 namespace internal {
 
+const Register kCArgRegs[kCArgRegsCount] = {
+#ifdef _WIN64
+  rcx, rdx, r8, r9
+#else
+  rdi, rsi, rdx, rcx, r8, r9
+#endif
+};
+
+
 MacroAssembler::MacroAssembler(void* buffer, int size)
     : Assembler(buffer, size),
       generating_stub_(false),
       allow_stub_calls_(true),
       code_object_(Heap::undefined_value()) {
 }
 
 
 void MacroAssembler::LoadRoot(Register destination, Heap::RootListIndex index) {
   movq(destination, Operand(r13, index << kPointerSizeLog2));
@@ skipping 314 matching lines @@
 void MacroAssembler::CallRuntime(Runtime::FunctionId id, int num_arguments) {
   CallRuntime(Runtime::FunctionForId(id), num_arguments);
 }
 
 
 void MacroAssembler::CallRuntime(Runtime::Function* f, int num_arguments) {
   // If the expected number of arguments of the runtime function is
   // constant, we check that the actual number of arguments match the
   // expectation.
   if (f->nargs >= 0 && f->nargs != num_arguments) {
-    IllegalOperation(num_arguments);
+    int num_args_on_stack =
+        (Runtime::EXIT_FRAME_CALL == f->calling_convention) ? 0 : num_arguments;
+    IllegalOperation(num_args_on_stack);
     return;
   }
 
-  // TODO(1236192): Most runtime routines don't need the number of
-  // arguments passed in because it is constant. At some point we
-  // should remove this need and make the runtime routine entry code
-  // smarter.
-  movq(rax, Immediate(num_arguments));
-  movq(rbx, ExternalReference(f));
-  CEntryStub ces(f->result_size);
-  CallStub(&ces);
+  switch (f->calling_convention) {
+    case Runtime::EXIT_FRAME_CALL: {
+        // Arguments are expected to be pushed on stack in left-to-right order.
+        // The stub will pass reference to them as Arguments into the function.
+
+        // TODO(1236192): Most runtime routines don't need the number of
+        // arguments passed in because it is constant. At some point we
+        // should remove this need and make the runtime routine entry code
+        // smarter.
+        movq(rax, Immediate(num_arguments));
+        movq(rbx, ExternalReference(f));
+        CEntryStub ces(f->result_size);
+        CallStub(&ces);
+        break;
+      }
+    case Runtime::DIRECT_CALL_NOT_FAILS:
+      // Arguments are expected to be put into the registers in order of
+      // kCArgRegs.
+      ASSERT(num_arguments <= kCArgRegsCount);
+      PrepareCallCFunction(num_arguments);
+      CallCFunction(ExternalReference(f), num_arguments);
+      break;
+  }
 }
 
 
 void MacroAssembler::CallExternalReference(const ExternalReference& ext,
                                            int num_arguments) {
   movq(rax, Immediate(num_arguments));
   movq(rbx, ext);
 
   CEntryStub stub(1);
   CallStub(&stub);
 }
 
+void MacroAssembler::TailCallRuntime(Runtime::FunctionId id,
+                                     int num_arguments,
+                                     int result_size) {
+  Runtime::Function* f = Runtime::FunctionForId(id);
 
-void MacroAssembler::TailCallRuntime(ExternalReference const& ext,
+  ASSERT(f->nargs == -1 || f->nargs == num_arguments);
+  if (f->calling_convention == Runtime::EXIT_FRAME_CALL) {
+    TailCallExternalReference(ExternalReference(f), num_arguments, result_size);
+  } else if (f->calling_convention == Runtime::DIRECT_CALL_NOT_FAILS) {
+    // Move arguments to registers
+    ASSERT(kCArgRegsCount >= num_arguments);
+    pop(rax);  // get return address
+    for (int i = 0; i < num_arguments; i++) {
+      pop(kCArgRegs[num_arguments - 1 - i]);
+    }
+    PrepareCallCFunction(num_arguments);  // align stack
+    movq(kScratchRegister, ExternalReference(f));
+    push(rax);  // return
+    jmp(kScratchRegister);
+  }
+}
+
+
+void MacroAssembler::TailCallExternalReference(ExternalReference const& ext,
                                      int num_arguments,
                                      int result_size) {
   // ----------- S t a t e -------------
   //  -- rsp[0] : return address
   //  -- rsp[8] : argument num_arguments - 1
   //  ...
   //  -- rsp[8 * num_arguments] : argument 0 (receiver)
   // -----------------------------------
 
   // TODO(1236192): Most runtime routines don't need the number of
@@ skipping 2167 matching lines @@
 CodePatcher::~CodePatcher() {
   // Indicate that code has changed.
   CPU::FlushICache(address_, size_);
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 } }  // namespace v8::internal