VM: New calling convention for generated code.

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 62 matching lines @@
   __ AddImmediate(ESP, Immediate(-INT32_SIZEOF(NativeArguments)));
   if (OS::ActivationFrameAlignment() > 1) {
     __ andl(ESP, Immediate(~(OS::ActivationFrameAlignment() - 1)));
   }
 
   // Pass NativeArguments structure by value and call runtime.
   __ movl(Address(ESP, thread_offset), THR);  // Set thread in NativeArgs.
   // There are no runtime calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   __ movl(Address(ESP, argc_tag_offset), EDX);  // Set argc in NativeArguments.
-  __ leal(EAX, Address(EBP, EDX, TIMES_4, 1 * kWordSize));  // Compute argv.
+  // Compute argv.
+  __ leal(EAX, Address(EBP, EDX, TIMES_4, kParamEndSlotFromFp * kWordSize));
   __ movl(Address(ESP, argv_offset), EAX);  // Set argv in NativeArguments.
   __ addl(EAX, Immediate(1 * kWordSize));  // Retval is next to 1st argument.
   __ movl(Address(ESP, retval_offset), EAX);  // Set retval in NativeArguments.
   __ call(ECX);
 
   // Mark that the isolate is executing Dart code. EDI is callee saved.
   __ movl(Address(EDI, Isolate::vm_tag_offset()),
           Immediate(VMTag::kDartTagId));
 
   // Reset exit frame information in Isolate structure.
@@ skipping 268 matching lines @@
 // - Materialize objects that require allocation (e.g. Double instances).
 // GC can occur only after frame is fully rewritten.
 // Stack after EnterDartFrame(0) below:
 //   +------------------+
 //   | PC marker        | <- TOS
 //   +------------------+
 //   | Saved FP         | <- FP of stub
 //   +------------------+
 //   | return-address   |  (deoptimization point)
 //   +------------------+
+//   | Saved CODE_REG   |
+//   +------------------+
 //   | ...              | <- SP of optimized frame
 //
 // Parts of the code cannot GC, part of the code can GC.
 static void GenerateDeoptimizationSequence(Assembler* assembler,
-                                           bool preserve_result) {
+                                           DeoptStubKind kind) {
   // Leaf runtime function DeoptimizeCopyFrame expects a Dart frame.
   __ EnterDartFrame(0);
   // The code in this frame may not cause GC. kDeoptimizeCopyFrameRuntimeEntry
   // and kDeoptimizeFillFrameRuntimeEntry are leaf runtime calls.
   const intptr_t saved_result_slot_from_fp =
       kFirstLocalSlotFromFp + 1 - (kNumberOfCpuRegisters - EAX);
   // Result in EAX is preserved as part of pushing all registers below.
 
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   for (intptr_t i = kNumberOfCpuRegisters - 1; i >= 0; i--) {
-    __ pushl(static_cast<Register>(i));
+    if (i == CODE_REG) {
+      // Save the original value of CODE_REG pushed before invoking this stub
+      // instead of the value used to call this stub.
+      __ pushl(Address(EBP, 2 * kWordSize));
+    } else {
+      __ pushl(static_cast<Register>(i));
+    }
   }
   __ subl(ESP, Immediate(kNumberOfXmmRegisters * kFpuRegisterSize));
   intptr_t offset = 0;
   for (intptr_t reg_idx = 0; reg_idx < kNumberOfXmmRegisters; ++reg_idx) {
     XmmRegister xmm_reg = static_cast<XmmRegister>(reg_idx);
     __ movups(Address(ESP, offset), xmm_reg);
     offset += kFpuRegisterSize;
   }
 
   __ movl(ECX, ESP);  // Preserve saved registers block.
-  __ ReserveAlignedFrameSpace(1 * kWordSize);
-  __ movl(Address(ESP, 0), ECX);  // Start of register block.
-  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
+  __ ReserveAlignedFrameSpace(2 * kWordSize);
+  __ movl(Address(ESP, 0 * kWordSize), ECX);  // Start of register block.
+  __ movl(Address(ESP, 1 * kWordSize), Immediate(kind == kLazyDeopt ? 1 : 0));
+  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 2);
   // Result (EAX) is stack-size (FP - SP) in bytes.
 
+  const bool preserve_result = (kind == kLazyDeopt);
   if (preserve_result) {
     // Restore result into EBX temporarily.
     __ movl(EBX, Address(EBP, saved_result_slot_from_fp * kWordSize));
   }
 
   __ LeaveFrame();
   __ popl(EDX);  // Preserve return address.
   __ movl(ESP, EBP);  // Discard optimized frame.
   __ subl(ESP, EAX);  // Reserve space for deoptimized frame.
   __ pushl(EDX);  // Restore return address.
@@ skipping 39 matching lines @@
 
 
 // TOS: return address + call-instruction-size (5 bytes).
 // EAX: result, must be preserved
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   // Correct return address to point just after the call that is being
   // deoptimized.
   __ popl(EBX);
   __ subl(EBX, Immediate(CallPattern::pattern_length_in_bytes()));
   __ pushl(EBX);
-  GenerateDeoptimizationSequence(assembler, true);  // Preserve EAX.
+  GenerateDeoptimizationSequence(assembler, kLazyDeopt);
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
-  GenerateDeoptimizationSequence(assembler, false);  // Don't preserve EAX.
+  GenerateDeoptimizationSequence(assembler, kEagerDeopt);
 }
 
 
 static void GenerateDispatcherCode(Assembler* assembler,
                                    Label* call_target_function) {
   __ Comment("NoSuchMethodDispatch");
   // When lazily generated invocation dispatchers are disabled, the
   // miss-handler may return null.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 198 matching lines @@
   __ popl(EDX);  // Pop array length argument (preserved).
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Called when invoking dart code from C++ (VM code).
 // Input parameters:
 //   ESP : points to return address.
-//   ESP + 4 : entrypoint of the dart function to call.
+//   ESP + 4 : code object of the dart function to call.
 //   ESP + 8 : arguments descriptor array.
 //   ESP + 12 : arguments array.
 //   ESP + 16 : current thread.
 // Uses EAX, EDX, ECX, EDI as temporary registers.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
-  const intptr_t kEntryPointOffset = 2 * kWordSize;
+  const intptr_t kTargetCodeOffset = 2 * kWordSize;
   const intptr_t kArgumentsDescOffset = 3 * kWordSize;
   const intptr_t kArgumentsOffset = 4 * kWordSize;
   const intptr_t kThreadOffset = 5 * kWordSize;
 
   // Save frame pointer coming in.
   __ EnterFrame(0);
 
+  // Push code object to PC marker slot.
+  __ movl(EAX, Address(EBP, kThreadOffset));
+  __ pushl(Address(EAX, Thread::invoke_dart_code_stub_offset()));
+
   // Save C++ ABI callee-saved registers.
   __ pushl(EBX);
   __ pushl(ESI);
   __ pushl(EDI);
 
   // Set up THR, which caches the current thread in Dart code.
-  __ movl(THR, Address(EBP, kThreadOffset));
+  __ movl(THR, EAX);
   __ LoadIsolate(EDI);
 
   // Save the current VMTag on the stack.
   __ movl(ECX, Address(EDI, Isolate::vm_tag_offset()));
   __ pushl(ECX);
 
   // Mark that the isolate is executing Dart code.
   __ movl(Address(EDI, Isolate::vm_tag_offset()),
           Immediate(VMTag::kDartTagId));
 
   // Save top resource and top exit frame info. Use EDX as a temporary register.
   // StackFrameIterator reads the top exit frame info saved in this frame.
   __ movl(EDX, Address(THR, Thread::top_resource_offset()));
   __ pushl(EDX);
   __ movl(Address(THR, Thread::top_resource_offset()), Immediate(0));
   // The constant kExitLinkSlotFromEntryFp must be kept in sync with the
   // code below.
-  ASSERT(kExitLinkSlotFromEntryFp == -6);
+  ASSERT(kExitLinkSlotFromEntryFp == -7);
   __ movl(EDX, Address(THR, Thread::top_exit_frame_info_offset()));
   __ pushl(EDX);
   __ movl(Address(THR, Thread::top_exit_frame_info_offset()), Immediate(0));
 
   // Load arguments descriptor array into EDX.
   __ movl(EDX, Address(EBP, kArgumentsDescOffset));
   __ movl(EDX, Address(EDX, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load number of arguments into EBX.
   __ movl(EBX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
@@ skipping 13 matching lines @@
 
   __ Bind(&push_arguments);
   __ movl(ECX, Address(EDI, EAX, TIMES_4, 0));
   __ pushl(ECX);
   __ incl(EAX);
   __ cmpl(EAX, EBX);
   __ j(LESS, &push_arguments, Assembler::kNearJump);
   __ Bind(&done_push_arguments);
 
   // Call the dart code entrypoint.
-  __ call(Address(EBP, kEntryPointOffset));
+  __ movl(EAX, Address(EBP, kTargetCodeOffset));
+  __ movl(EAX, Address(EAX, VMHandles::kOffsetOfRawPtrInHandle));
+  __ call(FieldAddress(EAX, Code::entry_point_offset()));
 
   // Reread the arguments descriptor array to obtain the number of passed
   // arguments.
   __ movl(EDX, Address(EBP, kArgumentsDescOffset));
   __ movl(EDX, Address(EDX, VMHandles::kOffsetOfRawPtrInHandle));
   __ movl(EDX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // Get rid of arguments pushed on the stack.
   __ leal(ESP, Address(ESP, EDX, TIMES_2, 0));  // EDX is a Smi.
 
   // Restore the saved top exit frame info and top resource back into the
@@ skipping 224 matching lines @@
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   ESP + 4 : type arguments object (only if class is parameterized).
 //   ESP : points to return address.
 // Uses EAX, EBX, ECX, EDX, EDI as temporary registers.
 // Returns patch_code_pc offset where patching code for disabling the stub
 // has been generated (similar to regularly generated Dart code).
 void StubCode::GenerateAllocationStubForClass(
-    Assembler* assembler, const Class& cls,
-    uword* entry_patch_offset, uword* patch_code_pc_offset) {
-  *entry_patch_offset = assembler->CodeSize();
+    Assembler* assembler, const Class& cls) {
   const intptr_t kObjectTypeArgumentsOffset = 1 * kWordSize;
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
   ASSERT(!is_cls_parameterized ||
          (cls.type_arguments_field_offset() != Class::kNoTypeArguments));
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
@@ skipping 101 matching lines @@
     __ pushl(raw_null);  // Push null type arguments.
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 2);  // Allocate object.
   __ popl(EAX);  // Pop argument (type arguments of object).
   __ popl(EAX);  // Pop argument (class of object).
   __ popl(EAX);  // Pop result (newly allocated object).
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
-  // Emit function patching code. This will be swapped with the first 5 bytes
-  // at entry point.
-  *patch_code_pc_offset = assembler->CodeSize();
-  __ Jmp(*StubCode::FixAllocationStubTarget_entry());
 }
 
 
 // Called for invoking "dynamic noSuchMethod(Invocation invocation)" function
 // from the entry code of a dart function after an error in passed argument
 // name or number is detected.
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of last argument.
 //   EDX : arguments descriptor array.
@@ skipping 19 matching lines @@
   __ CallRuntime(kInvokeClosureNoSuchMethodRuntimeEntry, kNumArgs);
   // noSuchMethod on closures always throws an error, so it will never return.
   __ int3();
 }
 
 
 // Cannot use function object from ICData as it may be the inlined
 // function and not the top-scope function.
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
   Register ic_reg = ECX;
-  Register func_reg = EDI;
+  Register func_reg = EBX;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ pushl(func_reg);     // Preserve
     __ pushl(ic_reg);       // Preserve.
     __ pushl(ic_reg);       // Argument.
     __ pushl(func_reg);     // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ popl(EAX);          // Discard argument;
     __ popl(EAX);          // Discard argument;
     __ popl(ic_reg);       // Restore.
@@ skipping 515 matching lines @@
 void StubCode::GenerateICCallBreakpointStub(Assembler* assembler) {
   __ EnterStubFrame();
   // Save IC data.
   __ pushl(ECX);
   // Room for result. Debugger stub returns address of the
   // unpatched runtime stub.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
   __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
-  __ popl(EAX);  // Address of original stub.
+  __ popl(EAX);  // Code of original stub.
   __ popl(ECX);  // Restore IC data.
   __ LeaveFrame();
-  __ jmp(EAX);   // Jump to original stub.
+  // Jump to original stub.
+  __ movl(EAX, FieldAddress(EAX, Code::entry_point_offset()));
+  __ jmp(EAX);
 }
 
 
 void StubCode::GenerateRuntimeCallBreakpointStub(Assembler* assembler) {
   __ EnterStubFrame();
   // Room for result. Debugger stub returns address of the
   // unpatched runtime stub.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
   __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
-  __ popl(EAX);  // Address of original stub.
+  __ popl(EAX);  // Code of the original stub
   __ LeaveFrame();
-  __ jmp(EAX);   // Jump to original stub.
+  // Jump to original stub.
+  __ movl(EAX, FieldAddress(EAX, Code::entry_point_offset()));
+  __ jmp(EAX);
 }
 
 
 // Called only from unoptimized code.
 void StubCode::GenerateDebugStepCheckStub(Assembler* assembler) {
   // Check single stepping.
   Label stepping, done_stepping;
   __ LoadIsolate(EAX);
   __ movzxb(EAX, Address(EAX, Isolate::single_step_offset()));
   __ cmpl(EAX, Immediate(0));
@@ skipping 151 matching lines @@
   // Set tag.
   __ movl(Address(EDI, Isolate::vm_tag_offset()),
           Immediate(VMTag::kDartTagId));
   // Clear top exit frame.
   __ movl(Address(THR, Thread::top_exit_frame_info_offset()), Immediate(0));
   __ jmp(EBX);  // Jump to the exception handler code.
 }
 
 
 // Calls to the runtime to optimize the given function.
-// EDI: function to be reoptimized.
+// EBX: function to be reoptimized.
 // EDX: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
   __ pushl(EDX);
   __ pushl(raw_null);  // Setup space on stack for return value.
-  __ pushl(EDI);
+  __ pushl(EBX);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ popl(EAX);  // Discard argument.
   __ popl(EAX);  // Get Code object
   __ popl(EDX);  // Restore argument descriptor.
   __ movl(EAX, FieldAddress(EAX, Code::entry_point_offset()));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
@@ skipping 146 matching lines @@
   // Call the target found in the cache.  For a class id match, this is a
   // proper target for the given name and arguments descriptor.  If the
   // illegal class id was found, the target is a cache miss handler that can
   // be invoked as a normal Dart function.
   __ movl(EAX, FieldAddress(EDI, ECX, TIMES_4, base + kWordSize));
   __ movl(target, FieldAddress(EAX, Function::entry_point_offset()));
 }
 
 
 // Called from megamorphic calls.
-//  EDI: receiver.
+//  ECX: receiver.
 //  EBX: lookup cache.
 // Result:
 //  EBX: entry point.
 void StubCode::GenerateMegamorphicLookupStub(Assembler* assembler) {
-  EmitMegamorphicLookup(assembler, EDI, EBX, EBX);
+  EmitMegamorphicLookup(assembler, ECX, EBX, EBX);
   __ ret();
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32