Direct call C++ functions

src/ia32/macro-assembler-ia32.cc

 // Copyright 2006-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 1127 matching lines @@
 
 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);
     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.
-  Set(eax, Immediate(num_arguments));
-  mov(ebx, Immediate(ExternalReference(f)));
-  CEntryStub ces(1);
-  CallStub(&ces);
+  if (Runtime::EXIT_FRAME_CALL == f->calling_convention) {
+    // 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.
+    Set(eax, Immediate(num_arguments));
+    mov(ebx, Immediate(ExternalReference(f)));
+    CEntryStub ces(1);
+    CallStub(&ces);
+  } else {
+    DirectInvokeRuntime(f, CALL_FUNCTION);
+  }
+}
+
+
+void MacroAssembler::DirectInvokeRuntime(Runtime::Function* f,
+                                         InvokeFlag flag) {
+  // Stack:
+  //   arg1
+  //   ...
+  //   argN
+  //   ret addr (if tail call)
+  static const int kFrameAlignment = OS::ActivationFrameAlignment();
+

[Søren Thygesen Gjesse, 2010/02/22 12:38:22]

I still think we should have the handling of calling a C function directly
abstracted into a PrepareCallCFunction function and retire FrameAlign etc. in
regexp-macro-assembler-ia32.cc.

As far as I can see you optimize the removal of the existing arguments into
restoring esp, and use push instead of
  mov(xxx, Operand(eax, Y * kPointerSize);
  mov(Operand(esp, X * kPointerSize), xxx);
I don't know whether it makes a performance difference, but if it does the
PrepareCallCFunction could take parameters to indicate whether the stack should
be prepared for push or storing into and number additional stack slots to get
rid of when restoring after alignment.

+  ASSERT(kFrameAlignment > 0);
+  if (flag == JUMP_FUNCTION) {
+    mov(eax, esp);
+  } else {
+    // This value will be stored on stack and then loaded into esp
+    // to remove arguments.
+    lea(eax, Operand(esp, f->nargs * kPointerSize));
+  }
+
+  ASSERT(IsPowerOf2(kFrameAlignment));
+  and_(esp, -kFrameAlignment);
+
+  // How many bytes need to be reserved to keep stack aligned after
+  // pushing eax and args.
+  const int alignmentPlaceholder = (-(f->nargs + 1) * kPointerSize)
+      & (kFrameAlignment - 1);
+  sub(Operand(esp), Immediate(alignmentPlaceholder));
+  ASSERT((alignmentPlaceholder + kPointerSize * (f->nargs + 1))
+      % kFrameAlignment == 0);
+
+  push(eax);
+  for (int i = 0; i < f->nargs; i++) {
+    if (flag == JUMP_FUNCTION) {
+      push(Operand(eax, (i + 1) * kPointerSize));
+    } else {
+      push(Operand(eax, (i - f->nargs) * kPointerSize));
+    }
+  }
+
+  // Stack:
+  //   ag1
+  //   ...
+  //   argN
+  //   ret addr (if tail call)
+  //   <stack alignment placeholder>
+  //   esp to restore
+  //   argN
+  //   ...
+  //   arg1
+
+  // Performing a semi tail call as we need to copy the arguments for alignment.
+  call(FUNCTION_ADDR(ExternalReference(f).address()), RelocInfo::RUNTIME_ENTRY);
+
+  mov(esp, Operand(esp, f->nargs * kPointerSize));
+  if (flag == JUMP_FUNCTION) {
+    ret(f->nargs);
+  }

[Søren Thygesen Gjesse, 2010/02/22 12:38:22]

Maybe just adjust the stack by f->nargs in an else to keep things simpler.
Otherwise please comment on then mov(esp, ... removes the arguments.

 }
 
 
 void MacroAssembler::CallExternalReference(ExternalReference ref,
                                            int num_arguments) {
   mov(eax, Immediate(num_arguments));
   mov(ebx, Immediate(ref));
 
   CEntryStub stub(1);
   CallStub(&stub);
@@ skipping 13 matching lines @@
   // arguments passed in because it is constant. At some point we
   // should remove this need and make the runtime routine entry code
   // smarter.
   Set(eax, Immediate(num_arguments));
   mov(ebx, Immediate(ExternalReference(f)));
   CEntryStub ces(1);
   return TryCallStub(&ces);
 }
 
 
-void MacroAssembler::TailCallRuntime(const ExternalReference& ext,
+void MacroAssembler::TailCallRuntime(Runtime::FunctionId id,
                                      int num_arguments,
                                      int result_size) {
+  Runtime::Function* f = Runtime::FunctionForId(id);
+  // 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.
+  if (f->calling_convention == Runtime::EXIT_FRAME_CALL) {
+    TailCallExternalReference(ExternalReference(f), num_arguments, result_size);
+  } else {
+    DirectInvokeRuntime(f, JUMP_FUNCTION);
+  }
+}
+
+
+void MacroAssembler::TailCallExternalReference(const ExternalReference& ext,
+                                               int num_arguments,
+                                               int result_size) {
   // 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.
   Set(eax, Immediate(num_arguments));
   JumpToRuntime(ext);
 }
 
 
 void MacroAssembler::PushHandleScope(Register scratch) {
@@ skipping 426 matching lines @@
   // 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