Simplify representation of stack frames. Remove the special types DartFrame/StubFrame and instead u…

vm/stub_code_ia32.cc

 // Copyright (c) 2011, 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/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
@@ skipping 13 matching lines @@
 DECLARE_FLAG(int, optimization_counter_threshold);
 
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of last argument in argument array.
 //   ESP + 4*EDX : address of first argument in argument array.
 //   ESP + 4*EDX + 4 : address of return value.
 //   ECX : address of the runtime function to call.
 //   EDX : number of arguments to the call.
 // Must preserve callee saved registers EDI and EBX.
-static void GenerateCallRuntimeStub(Assembler* assembler) {
+void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_offset = NativeArguments::argc_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ EnterFrame(0);
 
   // Load current Isolate pointer from Context structure into EAX.
   __ movl(EAX, FieldAddress(CTX, Context::isolate_offset()));
 
@@ skipping 34 matching lines @@
   __ movl(Address(CTX, Isolate::top_context_offset()), raw_null);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movl(CTX, ECX);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
-// Input parameters:
-//   ESP : points to return address.
-//   ESP + 4 : address of last argument in argument array.
-//   ESP + 4*EDX : address of first argument in argument array.
-//   ESP + 4*EDX + 4 : address of return value.
-//   ECX : address of the runtime function to call.
-//   EDX : number of arguments to the call.
-// Must preserve callee saved registers EDI and EBX.
-void StubCode::GenerateDartCallToRuntimeStub(Assembler* assembler) {
-  GenerateCallRuntimeStub(assembler);
-}
-
-
-// Input parameters:
-//   ESP : points to return address.
-//   ESP + 4 : address of last argument in argument array.
-//   ESP + 4*EDX : address of first argument in argument array.
-//   ESP + 4*EDX + 4 : address of return value.
-//   ECX : address of the runtime function to call.
-//   EDX : number of arguments to the call.
-// Must preserve callee saved registers EDI and EBX.
-void StubCode::GenerateStubCallToRuntimeStub(Assembler* assembler) {
-  GenerateCallRuntimeStub(assembler);
-}
-
-
 // Print the stop message.
 static void PrintStopMessage(const char* message) {
   OS::Print("Stop message: %s\n", message);
 }
 
 
 // Input parameters:
 //   ESP : points to return address.
 //   EAX : stop message (const char*).
 // Must preserve all registers, except EAX.
@@ skipping 109 matching lines @@
   __ cmpl(EAX, raw_null);
   Label function_compiled;
   __ j(NOT_EQUAL, &function_compiled, Assembler::kNearJump);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterFrame(0);
 
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);
-  __ CallRuntimeFromStub(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry);
   __ popl(ECX);  // Restore read-only function object argument in ECX.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Restore EAX.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ Bind(&function_compiled);
   // Patch caller.
   __ EnterFrame(0);
 
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve function object.
-  __ CallRuntimeFromStub(kPatchStaticCallRuntimeEntry);
+  __ CallRuntime(kPatchStaticCallRuntimeEntry);
   __ popl(ECX);  // Restore function object argument in ECX.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
 
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // ECX: function object.
 // EDX: arguments descriptor array (num_args is first Smi element).
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   __ EnterFrame(0);
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve target function.
   __ pushl(ECX);  // Target function.
-  __ CallRuntimeFromStub(kFixCallersTargetRuntimeEntry);
+  __ CallRuntime(kFixCallersTargetRuntimeEntry);
   __ popl(EAX);  // discard argument.
   __ popl(EAX);  // Restore function.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ movl(EAX, FieldAddress(EAX, Function::code_offset()));
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
@@ skipping 140 matching lines @@
   // Total number of args is the first Smi in args descriptor array (EDX).
   __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
   __ movl(EAX, Address(ESP, EAX, TIMES_2, kWordSize));  // Get receiver.
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(EAX);  // Preserve receiver.
   __ pushl(ECX);  // Preserve ic-data.
   // First resolve the function to get the function object.
 
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EAX);  // Push receiver.
-  __ CallRuntimeFromStub(kResolveCompileInstanceFunctionRuntimeEntry);
+  __ CallRuntime(kResolveCompileInstanceFunctionRuntimeEntry);
   __ popl(EAX);  // Remove receiver pushed earlier.
   __ popl(ECX);  // Pop returned code object into ECX.
   // Pop preserved values
   __ popl(EDX);  // Restore ic-data.
   __ popl(EAX);  // Restore receiver.
   __ popl(EDI);  // Restore arguments descriptor array.
 
   __ cmpl(ECX, raw_null);
   Label check_implicit_closure;
   __ j(EQUAL, &check_implicit_closure, Assembler::kNearJump);
@@ skipping 15 matching lines @@
   // First check to see if this is a getter function and we are
   // trying to create a closure of an instance function.
   // Push values that need to be preserved across runtime call.
   __ pushl(EAX);  // Preserve receiver.
   __ pushl(EDX);  // Preserve ic-data.
   __ pushl(EDI);  // Preserve arguments descriptor array.
 
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EAX);  // Push receiver.
   __ pushl(EDX);  // Ic-data.
-  __ CallRuntimeFromStub(kResolveImplicitClosureFunctionRuntimeEntry);
+  __ CallRuntime(kResolveImplicitClosureFunctionRuntimeEntry);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(ECX);  // Get return value into ECX, might be Closure object.
 
   // Pop preserved values.
   __ popl(EDI);  // Restore arguments descriptor array.
   __ popl(EDX);  // Restore ic-data.
   __ popl(EAX);  // Restore receiver.
 
   __ cmpl(ECX, raw_null);
@@ skipping 14 matching lines @@
   // same name and see if we get a closure back which we are then
   // supposed to invoke.
   // Push values that need to be preserved across runtime call.
   __ pushl(EAX);  // Preserve receiver.
   __ pushl(EDX);  // Preserve ic-data.
   __ pushl(EDI);  // Preserve arguments descriptor array.
 
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EAX);  // Push receiver.
   __ pushl(EDX);  // Ic-data.
-  __ CallRuntimeFromStub(kResolveImplicitClosureThroughGetterRuntimeEntry);
+  __ CallRuntime(kResolveImplicitClosureThroughGetterRuntimeEntry);
   __ popl(EDX);  // Pop argument.
   __ popl(EAX);  // Pop argument.
   __ popl(ECX);  // get return value into ECX, might be Closure object.
 
   // Pop preserved values.
   __ popl(EDI);  // Restore arguments descriptor array.
   __ popl(EDX);  // Restore ic-data.
   __ popl(EAX);  // Restore receiver.
 
   __ cmpl(ECX, raw_null);
@@ skipping 12 matching lines @@
   // Stack layout explaining "(kWordSize * 5)" offset.
   // TOS + 0: Argument array.
   // TOS + 1: Arguments descriptor array.
   // TOS + 2: Closure object.
   // TOS + 3: Place for result from closure function.
   // TOS + 4: Saved EBP of previous frame. <== EBP
   // TOS + 5: Dart code return address
   // TOS + 6: Last argument of caller.
   // ....
 
-  __ CallRuntimeFromStub(kInvokeImplicitClosureFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeImplicitClosureFunctionRuntimeEntry);
   // Remove arguments.
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 
@@ skipping 19 matching lines @@
   // TOS + 0: Argument array.
   // TOS + 1: Argument descriptor array.
   // TOS + 2: IC-data.
   // TOS + 3: Receiver.
   // TOS + 4: Place for result from noSuchMethod.
   // TOS + 5: Saved EBP of previous frame. <== EBP
   // TOS + 6: Dart code return address
   // TOS + 7: Last argument of caller.
   // ....
 
-  __ CallRuntimeFromStub(kInvokeNoSuchMethodFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry);
   // Remove arguments.
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   __ EnterFrame(0);
   // EAX: deoptimization reason id.
   // Stack at this point:
   // TOS + 0: Saved EBP of function frame that will be deoptimized. <== EBP
   // TOS + 1: Deoptimization point (return address), will be patched.
   // TOS + 2: top-of-stack at deoptimization point (all arguments on stack).
   __ pushl(EAX);
-  __ CallRuntimeFromStub(kDeoptimizeRuntimeEntry);
+  __ CallRuntime(kDeoptimizeRuntimeEntry);
   __ popl(EAX);
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   EDX : Array length as Smi.
 //   ECX : array element type (either NULL or an instantiated type).
@@ skipping 118 matching lines @@
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDX);  // Array length as Smi.
   __ pushl(ECX);  // Element type.
-  __ CallRuntimeFromStub(kAllocateArrayRuntimeEntry);
+  __ CallRuntime(kAllocateArrayRuntimeEntry);
   __ popl(EAX);  // Pop element type argument.
   __ popl(EDX);  // Pop array length argument.
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   EDX: Arguments descriptor array (num_args is first Smi element, closure
@@ skipping 37 matching lines @@
   __ cmpl(EAX, raw_null);
   Label function_compiled;
   __ j(NOT_EQUAL, &function_compiled, Assembler::kNearJump);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterFrame(0);
 
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);
-  __ CallRuntimeFromStub(kCompileFunctionRuntimeEntry);
+  __ CallRuntime(kCompileFunctionRuntimeEntry);
   __ popl(ECX);  // Restore read-only function object argument in ECX.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Restore EAX.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveFrame();
 
   __ Bind(&function_compiled);
   // EAX: Code.
@@ skipping 24 matching lines @@
   PushArgumentsArray(assembler, (kWordSize * 4));
 
   // Stack:
   // TOS + 0: Argument array.
   // TOS + 1: Non-closure object.
   // TOS + 2: Place for result from reporting the error.
   // TOS + 3: Saved EBP of previous frame. <== EBP
   // TOS + 4: Dart code return address
   // TOS + 5: Last argument of caller.
   // ....
-  __ CallRuntimeFromStub(kReportObjectNotClosureRuntimeEntry);
+  __ CallRuntime(kReportObjectNotClosureRuntimeEntry);
   __ Stop("runtime call throws an exception");
 }
 
 
 // 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 + 8 : arguments descriptor array.
 //   ESP + 12 : pointer to the argument array.
@@ skipping 214 matching lines @@
     // EAX: new object.
     __ ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame.
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ SmiTag(EDX);
   __ pushl(EDX);
-  __ CallRuntimeFromStub(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
   __ popl(EAX);  // Pop number of context variables argument.
   __ popl(EAX);  // Pop the new context object.
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of objects.
@@ skipping 170 matching lines @@
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushl(EAX);  // Push type arguments of object to be allocated.
     __ pushl(EDX);  // Push type arguments of instantiator.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
     __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
-  __ CallRuntimeFromStub(kAllocateObjectRuntimeEntry);  // Allocate object.
+  __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
   __ popl(EAX);  // Pop argument (instantiator).
   __ 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();
 }
 
@@ skipping 125 matching lines @@
     __ movl(ECX, Address(ESP, kTypeArgumentsOffset));
   }
   if (is_implicit_instance_closure) {
     __ movl(EAX, Address(ESP, kReceiverOffset));
   }
   // Create a stub frame.
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(func);
   if (is_implicit_static_closure) {
-    __ CallRuntimeFromStub(kAllocateImplicitStaticClosureRuntimeEntry);
+    __ CallRuntime(kAllocateImplicitStaticClosureRuntimeEntry);
   } else {
     if (is_implicit_instance_closure) {
       __ pushl(EAX);  // Receiver.
     }
     if (has_type_arguments) {
       __ pushl(ECX);  // Push type arguments of closure to be allocated.
     } else {
       __ pushl(raw_null);  // Push null type arguments.
     }
     if (is_implicit_instance_closure) {
-      __ CallRuntimeFromStub(kAllocateImplicitInstanceClosureRuntimeEntry);
+      __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
       __ popl(EAX);  // Pop argument (type arguments of object).
       __ popl(EAX);  // Pop receiver.
     } else {
       ASSERT(func.IsNonImplicitClosureFunction());
-      __ CallRuntimeFromStub(kAllocateClosureRuntimeEntry);
+      __ CallRuntime(kAllocateClosureRuntimeEntry);
       __ popl(EAX);  // Pop argument (type arguments of object).
     }
   }
   __ popl(EAX);  // Pop function object.
   __ popl(EAX);
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
@@ skipping 40 matching lines @@
   // TOS + 1: Arguments descriptor array.
   // TOS + 2: Ic-data.
   // TOS + 3: Receiver.
   // TOS + 4: Place for result from noSuchMethod.
   // TOS + 5: Saved EBP of previous frame. <== EBP
   // TOS + 6: Dart callee (or stub) code return address
   // TOS + 7: Saved EBP of dart caller frame.
   // TOS + 8: Dart caller code return address
   // TOS + 9: Last argument of caller.
   // ....
-  __ CallRuntimeFromStub(kInvokeNoSuchMethodFunctionRuntimeEntry);
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry);
   // Remove arguments.
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
@@ skipping 18 matching lines @@
   __ incl(FieldAddress(EBX, Function::usage_counter_offset()));
   if (CodeGenerator::CanOptimize()) {
     __ cmpl(FieldAddress(EBX, Function::usage_counter_offset()),
         Immediate(FLAG_optimization_counter_threshold));
     Label not_yet_hot;
     __ j(LESS_EQUAL, &not_yet_hot);
     __ EnterFrame(0);
     __ pushl(ECX);  // Preserve inline cache data object.
     __ pushl(EDX);  // Preserve arguments array.
     __ pushl(EBX);  // Argument for runtime: function object.
-    __ CallRuntimeFromStub(kOptimizeInvokedFunctionRuntimeEntry);
+    __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
     __ popl(EBX);  // Remove argument.
     __ popl(EDX);  // Restore arguments array.
     __ popl(ECX);  // Restore inline cache data object.
     __ LeaveFrame();
     __ Bind(&not_yet_hot);
   }
 
   ASSERT(num_args > 0);
   // Get receiver (first read number of arguments from argument descriptor array
   // and then access the receiver from the stack).
@@ skipping 72 matching lines @@
   __ EnterFrame(0);
   __ pushl(EDX);  // Preserve arguments array.
   __ pushl(ECX);  // Preserve IC data array
   __ pushl(raw_null);  // Setup space on stack for result (target code object).
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movl(EDX, Address(EAX, -kWordSize * i));
     __ pushl(EDX);
   }
   if (num_args == 1) {
-    __ CallRuntimeFromStub(kInlineCacheMissHandlerOneArgRuntimeEntry);
+    __ CallRuntime(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
-    __ CallRuntimeFromStub(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
+    __ CallRuntime(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
   } else {
     UNIMPLEMENTED();
   }
   // Remove call arguments pushed earlier.
   for (intptr_t i = 0; i < num_args; i++) {
     __ popl(EAX);
   }
   __ popl(EAX);  // Pop returned code object into EAX (null if not found).
   __ popl(ECX);  // Restore IC data array.
   __ popl(EDX);  // Restore arguments array.
@@ skipping 51 matching lines @@
   return GenerateNArgsCheckInlineCacheStub(assembler, 2);
 }
 
 //  ECX: Function object.
 //  EDX: Arguments array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   __ EnterFrame(0);
   __ pushl(EDX);
   __ pushl(ECX);
-  __ CallRuntimeFromStub(kBreakpointStaticHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
   __ popl(ECX);
   __ popl(EDX);
   __ LeaveFrame();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   __ EnterFrame(0);
   __ pushl(EAX);
-  __ CallRuntimeFromStub(kBreakpointReturnHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
   __ popl(EAX);
   __ LeaveFrame();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ popl(ECX);  // Discard return address to patched dart code.
   // Execute function epilog code that was smashed in the Dart code.
   __ LeaveFrame();
   __ ret();
 }
 
 
 //  ECX: Inline cache data array.
 //  EDX: Arguments array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   __ EnterFrame(0);
   __ pushl(ECX);
   __ pushl(EDX);
-  __ CallRuntimeFromStub(kBreakpointDynamicHandlerRuntimeEntry);
+  __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
   __ popl(EDX);
   __ popl(ECX);
   __ LeaveFrame();
 
   // Find out which dispatch stub to call.
   Label ic_cache_one_arg;
   __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
   __ cmpl(EBX, Immediate(1));
   __ j(EQUAL, &ic_cache_one_arg, Assembler::kNearJump);
   __ jmp(&StubCode::TwoArgsCheckInlineCacheLabel());
@@ skipping 76 matching lines @@
   __ j(EQUAL, &not_found, Assembler::kNearJump);
   __ movl(ECX, FieldAddress(ECX, Type::type_class_offset()));
   __ cmpl(EDX, ECX);
   __ j(NOT_EQUAL, &super_loop, Assembler::kNearJump);
   __ jmp(&found, Assembler::kNearJump);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32