X64: Call runtime function from JS stack frame.

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 47 matching lines @@
   bind(&L);
 }
 
 
 void MacroAssembler::ConstructAndTestJSFunction() {
   const int initial_buffer_size = 4 * KB;
   char* buffer = new char[initial_buffer_size];
   MacroAssembler masm(buffer, initial_buffer_size);
 
   const uint64_t secret = V8_INT64_C(0xdeadbeefcafebabe);
+  Handle<String> constant =
+      Factory::NewStringFromAscii(Vector<const char>("451", 3), TENURED);
 #define __ ACCESS_MASM((&masm))
   // Construct a simple JSfunction here, using Assembler and MacroAssembler
   // commands.
-  __ movq(rax, secret, RelocInfo::NONE);
+  __ movq(rax, constant, RelocInfo::EMBEDDED_OBJECT);
+  __ push(rax);
+  __ CallRuntime(Runtime::kStringParseFloat, 1);
+  __ movq(kScratchRegister, secret, RelocInfo::NONE);
+  __ addq(rax, kScratchRegister);
   __ ret(0);
 #undef __
   CodeDesc desc;
   masm.GetCode(&desc);
   Code::Flags flags = Code::ComputeFlags(Code::FUNCTION);
   Object* code = Heap::CreateCode(desc, NULL, flags, Handle<Object>::null());
   if (!code->IsFailure()) {
     Handle<Code> code_handle(Code::cast(code));
     Handle<String> name =
         Factory::NewStringFromAscii(Vector<const char>("foo", 3), NOT_TENURED);
     Handle<JSFunction> function =
         Factory::NewFunction(name,
                              JS_FUNCTION_TYPE,
                              JSObject::kHeaderSize,
                              code_handle,
                              true);
     bool pending_exceptions;
     Handle<Object> result =
         Execution::Call(function,
                         Handle<Object>::cast(function),
                         0,
                         NULL,
                         &pending_exceptions);
     CHECK(result->IsSmi());
-    CHECK(secret == reinterpret_cast<uint64_t>(*result));
+    CHECK(secret + (451 << kSmiTagSize) == reinterpret_cast<uint64_t>(*result));
   }
 }
 
 
 void MacroAssembler::Abort(const char* msg) {
   // We want to pass the msg string like a smi to avoid GC
   // problems, however msg is not guaranteed to be aligned
   // properly. Instead, we pass an aligned pointer that is
   // a proper v8 smi, but also pass the alignment difference
   // from the real pointer as a smi.
@@ skipping 467 matching lines @@
   movq(rbp, rsp);
 
   // Reserve room for entry stack pointer and push the debug marker.
   ASSERT(ExitFrameConstants::kSPOffset  == -1 * kPointerSize);
   push(Immediate(0));  // saved entry sp, patched before call
   push(Immediate(type == StackFrame::EXIT_DEBUG ? 1 : 0));
 
   // Save the frame pointer and the context in top.
   ExternalReference c_entry_fp_address(Top::k_c_entry_fp_address);
   ExternalReference context_address(Top::k_context_address);
-  movq(kScratchRegister, rax);
+  movq(rdi, rax);  // Backup rax before we use it.
+
   movq(rax, rbp);
   store_rax(c_entry_fp_address);
   movq(rax, rsi);
   store_rax(context_address);
-  movq(rax, kScratchRegister);
 
-  // Setup argc and argv in callee-saved registers.
+  // Setup argv in callee-saved register r15.
   int offset = StandardFrameConstants::kCallerSPOffset - kPointerSize;
-  movq(rdi, rax);
-  lea(rsi, Operand(rbp, rax, kTimesPointerSize, offset));
+  lea(r15, Operand(rbp, rdi, kTimesPointerSize, offset));
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Save the state of all registers to the stack from the memory
   // location. This is needed to allow nested break points.
   if (type == StackFrame::EXIT_DEBUG) {
     // TODO(1243899): This should be symmetric to
     // CopyRegistersFromStackToMemory() but it isn't! esp is assumed
     // correct here, but computed for the other call. Very error
     // prone! FIX THIS.  Actually there are deeper problems with
     // register saving than this asymmetry (see the bug report
     // associated with this issue).
     PushRegistersFromMemory(kJSCallerSaved);
   }
 #endif
 
-  // Reserve space for two arguments: argc and argv.
+  // Reserve space for two arguments: argc and argv
   subq(rsp, Immediate(2 * kPointerSize));
 
   // Get the required frame alignment for the OS.
   static const int kFrameAlignment = OS::ActivationFrameAlignment();
   if (kFrameAlignment > 0) {
     ASSERT(IsPowerOf2(kFrameAlignment));
-    movq(r10, Immediate(-kFrameAlignment));
-    and_(rsp, r10);
+    movq(kScratchRegister, Immediate(-kFrameAlignment));
+    and_(rsp, kScratchRegister);
   }
 
   // Patch the saved entry sp.
   movq(Operand(rbp, ExitFrameConstants::kSPOffset), rsp);
 }
 
 
 void MacroAssembler::LeaveExitFrame(StackFrame::Type type) {
+  // Registers:
+  // r14 : argc
+  // r15 : argv
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Restore the memory copy of the registers by digging them out from
   // the stack. This is needed to allow nested break points.
   if (type == StackFrame::EXIT_DEBUG) {
     // It's okay to clobber register ebx below because we don't need
     // the function pointer after this.
     const int kCallerSavedSize = kNumJSCallerSaved * kPointerSize;
     int kOffset = ExitFrameConstants::kDebugMarkOffset - kCallerSavedSize;
     lea(rbx, Operand(rbp, kOffset));
     CopyRegistersFromStackToMemory(rbx, rcx, kJSCallerSaved);
   }
 #endif
 
   // Get the return address from the stack and restore the frame pointer.
   movq(rcx, Operand(rbp, 1 * kPointerSize));
   movq(rbp, Operand(rbp, 0 * kPointerSize));
 
   // Pop the arguments and the receiver from the caller stack.
-  lea(rsp, Operand(rsi, 1 * kPointerSize));
+  lea(rsp, Operand(r15, 1 * kPointerSize));
 
   // Restore current context from top and clear it in debug mode.
   ExternalReference context_address(Top::k_context_address);
   movq(kScratchRegister, context_address);
   movq(rsi, Operand(kScratchRegister, 0));
 #ifdef DEBUG
   movq(Operand(kScratchRegister, 0), Immediate(0));
 #endif
 
   // Push the return address to get ready to return.
   push(rcx);
 
   // Clear the top frame.
   ExternalReference c_entry_fp_address(Top::k_c_entry_fp_address);
   movq(kScratchRegister, c_entry_fp_address);
   movq(Operand(kScratchRegister, 0), Immediate(0));
 }
 
 
 } }  // namespace v8::internal