X64: Call runtime function from JS stack frame.

src/x64/codegen-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 411 matching lines @@
 }
 
 
 
 void CEntryStub::GenerateCore(MacroAssembler* masm,
                               Label* throw_normal_exception,
                               Label* throw_out_of_memory_exception,
                               StackFrame::Type frame_type,
                               bool do_gc,
                               bool always_allocate_scope) {
-  // rax: result parameter for PerformGC, if any
-  // rbx: pointer to C function  (C callee-saved)
-  // rbp: frame pointer  (restored after C call)
-  // rsp: stack pointer  (restored after C call)
-  // rdi: number of arguments including receiver  (C callee-saved)
-  // rsi: pointer to the first argument (C callee-saved)
+  // rax: result parameter for PerformGC, if any.

[William Hesse, 2009/06/12 12:45:04]

What does "result parameter" mean?  This is really just the first (only)
parameter that PerformGC takes?  But why is it on the stack?  Or is it the
return address that a GC call should return to?

[Lasse Reichstein, 2009/06/12 13:09:13]

After the code of GenerateCore, the following code is run only if a failure
happened. In that case, rax holds the resulting failure value. If GenerateCore
is given a true value as do_gc argument, it is used as the parameter to
Runtime::PerformGC.
It is unset until after the first GenerateCore (unless GLAG_gc_greedy is set).
So it's both a result of the C-call and parameter to PerformGC.

[William Hesse, 2009/06/12 14:56:51]

I would comment it as:
// rax: result of the previous call to the function.  Pass it to PerformGC if a
GC is needed.

+  // rbx: pointer to C function  (C callee-saved).
+  // rbp: frame pointer  (restored after C call).
+  // rsp: stack pointer  (restored after C call).
+  // rdi: number of arguments including receiver.

[William Hesse, 2009/06/12 12:45:04]

rdi is also callee-saved.  Maybe specify the Unix/Windows X64 ABI in a comment
above // rax.

[Lasse Reichstein, 2009/06/12 13:09:13]

The rdi register is only callee-save in the Windows X64 ABI, not the Unix X64
ABI (it's a parameter register). We should treat it as volatile except in
MSVC-specific code.
Added comment to that point.

+  // r15: pointer to the first argument (C callee-saved)
 
   if (do_gc) {
     __ movq(Operand(rsp, 0), rax);  // Result.
     __ movq(kScratchRegister,
             FUNCTION_ADDR(Runtime::PerformGC),
             RelocInfo::RUNTIME_ENTRY);
     __ call(kScratchRegister);
   }
 
   ExternalReference scope_depth =
       ExternalReference::heap_always_allocate_scope_depth();
   if (always_allocate_scope) {
     __ movq(kScratchRegister, scope_depth);

[William Hesse, 2009/06/12 12:45:04]

I have also used this code sequence for Statistics counters.  Should we have a
MacroAssembler::Incl(ExternalReference) and
Decl(ExternalReference)?

[Lasse Reichstein, 2009/06/12 13:09:13]

If that's the only two places, I'm not too keen on doing extra functions for it.
But it is an idea.

[William Hesse, 2009/06/12 14:56:51]

Well, they are also the only places incl and decl are used.

     __ incl(Operand(kScratchRegister, 0));
   }
 
   // Call C function.
 #ifdef __MSVC__
   // MSVC passes arguments in rcx, rdx, r8, r9
   __ movq(rcx, rdi);  // argc.
-  __ movq(rdx, rsi);  // argv.
+  __ movq(rdx, r15);  // argv.
 #else  // ! defined(__MSVC__)
+  __ movq(rsi, r15);  // argv.
   // GCC passes arguments in rdi, rsi, rdx, rcx, r8, r9.
-  // First two arguments are already in rdi, rsi.
+  // First arguments is already in rdi.

[William Hesse, 2009/06/12 12:45:04]

argument

[Lasse Reichstein, 2009/06/12 13:09:13]

fixed.

 #endif
   __ call(rbx);
   // Result is in rax - do not destroy this register!
 
   if (always_allocate_scope) {
     __ movq(kScratchRegister, scope_depth);
     __ decl(Operand(kScratchRegister, 0));
   }
 
   // Check for failure result.
@@ skipping 109 matching lines @@
   // this by performing a garbage collection and retrying the
   // builtin once.
 
   StackFrame::Type frame_type = is_debug_break ?
       StackFrame::EXIT_DEBUG :
       StackFrame::EXIT;
 
   // Enter the exit frame that transitions from JavaScript to C++.
   __ EnterExitFrame(frame_type);
 
-  // rax: result parameter for PerformGC, if any (setup below)
-  // rbx: pointer to builtin function  (C callee-saved)
-  // rbp: frame pointer  (restored after C call)
-  // rsp: stack pointer  (restored after C call)
-  // rdi: number of arguments including receiver (C callee-saved)
-  // rsi: argv pointer (C callee-saved)
+  // rax: result parameter for PerformGC, if any (setup below).
+  // rbx: pointer to builtin function  (C callee-saved).
+  // rbp: frame pointer  (restored after C call).
+  // rsp: stack pointer  (restored after C call).
+  // rdi: number of arguments including receiver.

[William Hesse, 2009/06/12 12:45:04]

Why isn't this marked as C callee-saved?  Or if it isn't anymore (because it is
now an argument register), then shouldn't it be put in a callee-saved one?

[Lasse Reichstein, 2009/06/12 13:09:13]

It's not callee-saved in the Unix 64-bit ABI, but the values doesn't need to be
saved across the C call anyway, so I kept the value in the parameter register
and removed the "callee-saved" comment.

+  // r15: argv pointer (C callee-saved).
 
   Label throw_out_of_memory_exception;
   Label throw_normal_exception;
 
   // Call into the runtime system. Collect garbage before the call if
   // running with --gc-greedy set.
   if (FLAG_gc_greedy) {
     Failure* failure = Failure::RetryAfterGC(0);
     __ movq(rax, failure, RelocInfo::NONE);
   }
@@ skipping 116 matching lines @@
 
   // Restore frame pointer and return.
   __ pop(rbp);
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal