VM: New calling convention for generated code.

runtime/vm/stub_code_mips.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_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 23 matching lines @@
 //   SP : address of last argument in argument array.
 //   SP + 4*S4 - 4 : address of first argument in argument array.
 //   SP + 4*S4 : address of return value.
 //   S5 : address of the runtime function to call.
 //   S4 : number of arguments to the call.
 void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
   const intptr_t thread_offset = NativeArguments::thread_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
-  const intptr_t exitframe_last_param_slot_from_fp = 2;
 
   __ SetPrologueOffset();
   __ Comment("CallToRuntimeStub");
   __ EnterStubFrame();
 
-  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
-  __ LoadIsolate(S6);
+  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S2)) != 0);
+  __ LoadIsolate(S2);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to Dart VM C++ code.
   __ sw(FP, Address(THR, Thread::top_exit_frame_info_offset()));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
-    __ lw(T0, Address(S6, Isolate::vm_tag_offset()));
+    __ lw(T0, Address(S2, Isolate::vm_tag_offset()));
     __ BranchEqual(T0, Immediate(VMTag::kDartTagId), &ok);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing VM code.
-  __ sw(S5, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(S5, Address(S2, Isolate::vm_tag_offset()));
 
   // Reserve space for arguments and align frame before entering C++ world.
   // NativeArguments are passed in registers.
   ASSERT(sizeof(NativeArguments) == 4 * kWordSize);
   __ ReserveAlignedFrameSpace(4 * kWordSize);  // Reserve space for arguments.
 
   // Pass NativeArguments structure by value and call runtime.
   // Registers A0, A1, A2, and A3 are used.
 
   ASSERT(thread_offset == 0 * kWordSize);
   // Set thread in NativeArgs.
   __ mov(A0, THR);
 
   // There are no runtime calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   __ mov(A1, S4);  // Set argc in NativeArguments.
 
   ASSERT(argv_offset == 2 * kWordSize);
   __ sll(A2, S4, 2);
   __ addu(A2, FP, A2);  // Compute argv.
   // Set argv in NativeArguments.
-  __ addiu(A2, A2, Immediate(exitframe_last_param_slot_from_fp * kWordSize));
+  __ addiu(A2, A2, Immediate(kParamEndSlotFromFp * kWordSize));
 
 
   // Call runtime or redirection via simulator.
   // We defensively always jalr through T9 because it is sometimes required by
   // the MIPS ABI.
   __ mov(T9, S5);
   __ jalr(T9);
 
     ASSERT(retval_offset == 3 * kWordSize);
   // Retval is next to 1st argument.
   __ delay_slot()->addiu(A3, A2, Immediate(kWordSize));
   __ Comment("CallToRuntimeStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
-  __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(A2, Address(S2, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(THR, Thread::top_exit_frame_info_offset()));
 
   __ LeaveStubFrameAndReturn();
 }
 
 
 // Print the stop message.
 DEFINE_LEAF_RUNTIME_ENTRY(void, PrintStopMessage, 1, const char* message) {
@@ skipping 23 matching lines @@
 void StubCode::GenerateCallNativeCFunctionStub(Assembler* assembler) {
   const intptr_t thread_offset = NativeArguments::thread_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
   __ Comment("CallNativeCFunctionStub");
   __ EnterStubFrame();
 
-  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
-  __ LoadIsolate(S6);
+  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S2)) != 0);
+  __ LoadIsolate(S2);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ sw(FP, Address(THR, Thread::top_exit_frame_info_offset()));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
-    __ lw(T0, Address(S6, Isolate::vm_tag_offset()));
+    __ lw(T0, Address(S2, Isolate::vm_tag_offset()));
     __ BranchEqual(T0, Immediate(VMTag::kDartTagId), &ok);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing Native code.
-  __ sw(T5, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(T5, Address(S2, Isolate::vm_tag_offset()));
 
   // Initialize NativeArguments structure and call native function.
   // Registers A0, A1, A2, and A3 are used.
 
   ASSERT(thread_offset == 0 * kWordSize);
   // Set thread in NativeArgs.
   __ mov(A0, THR);
 
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: A1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: A2 already contains argv.
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ addiu(A3, FP, Immediate(3 * kWordSize));  // Set retval in NativeArgs.
+  // Set retval in NativeArgs.
+  __ addiu(A3, FP, Immediate(kCallerSpSlotFromFp * kWordSize));
 
   // Passing the structure by value as in runtime calls would require changing
   // Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
   __ sw(A3, Address(SP, 3 * kWordSize));
   __ sw(A2, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ sw(A0, Address(SP, 0 * kWordSize));
   __ mov(A0, SP);  // Pass the pointer to the NativeArguments.
 
 
   __ mov(A1, T5);  // Pass the function entrypoint.
   __ ReserveAlignedFrameSpace(2 * kWordSize);  // Just passing A0, A1.
   // Call native wrapper function or redirection via simulator.
 #if defined(USING_SIMULATOR)
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
   __ LoadImmediate(T9, entry);
   __ jalr(T9);
 #else
   __ BranchLink(&NativeEntry::NativeCallWrapperLabel(), kNotPatchable);
 #endif
   __ Comment("CallNativeCFunctionStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
-  __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(A2, Address(S2, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(THR, Thread::top_exit_frame_info_offset()));
 
   __ LeaveStubFrameAndReturn();
 }
 
 
 // Input parameters:
 //   RA : return address.
 //   SP : address of return value.
 //   T5 : address of the native function to call.
 //   A2 : address of first argument in argument array.
 //   A1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallBootstrapCFunctionStub(Assembler* assembler) {
   const intptr_t thread_offset = NativeArguments::thread_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
   __ Comment("CallNativeCFunctionStub");
   __ EnterStubFrame();
 
-  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
-  __ LoadIsolate(S6);
+  COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S2)) != 0);
+  __ LoadIsolate(S2);
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ sw(FP, Address(THR, Thread::top_exit_frame_info_offset()));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
-    __ lw(T0, Address(S6, Isolate::vm_tag_offset()));
+    __ lw(T0, Address(S2, Isolate::vm_tag_offset()));
     __ BranchEqual(T0, Immediate(VMTag::kDartTagId), &ok);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing Native code.
-  __ sw(T5, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(T5, Address(S2, Isolate::vm_tag_offset()));
 
   // Initialize NativeArguments structure and call native function.
   // Registers A0, A1, A2, and A3 are used.
 
   ASSERT(thread_offset == 0 * kWordSize);
   // Set thread in NativeArgs.
   __ mov(A0, THR);
 
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: A1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: A2 already contains argv.
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ addiu(A3, FP, Immediate(3 * kWordSize));  // Set retval in NativeArgs.
+  // Set retval in NativeArgs.
+  __ addiu(A3, FP, Immediate(kCallerSpSlotFromFp * kWordSize));
 
   // Passing the structure by value as in runtime calls would require changing
   // Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
   __ sw(A3, Address(SP, 3 * kWordSize));
   __ sw(A2, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ sw(A0, Address(SP, 0 * kWordSize));
   __ mov(A0, SP);  // Pass the pointer to the NativeArguments.
 
   __ ReserveAlignedFrameSpace(kWordSize);  // Just passing A0.
 
   // Call native function or redirection via simulator.
 
   // We defensively always jalr through T9 because it is sometimes required by
   // the MIPS ABI.
   __ mov(T9, T5);
   __ jalr(T9);
   __ Comment("CallNativeCFunctionStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
-  __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(A2, Address(S2, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(THR, Thread::top_exit_frame_info_offset()));
 
   __ LeaveStubFrameAndReturn();
 }
 
 
 // Input parameters:
 //   S4: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   __ Comment("CallStaticFunctionStub");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
 
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   __ Comment("CallStaticFunctionStub return");
 
   // Get Code object result and restore arguments descriptor array.
-  __ lw(T0, Address(SP, 0 * kWordSize));
+  __ lw(CODE_REG, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
-  __ lw(T0, FieldAddress(T0, Code::entry_point_offset()));
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
 
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // S4: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
+  // Load code pointer to this stub from the thread:
+  // The one that is passed in, is not correct - it points to the code object
+  // that needs to be replaced.
+  __ lw(CODE_REG, Address(THR, Thread::fix_callers_target_code_offset()));
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  __ Comment("FixCallersTarget");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   // Get Code object result and restore arguments descriptor array.
-  __ lw(T0, Address(SP, 0 * kWordSize));
+  __ lw(CODE_REG, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   // Jump to the dart function.
-  __ lw(T0, FieldAddress(T0, Code::entry_point_offset()));
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from object allocate instruction when the allocation stub has been
 // disabled.
 void StubCode::GenerateFixAllocationStubTargetStub(Assembler* assembler) {
-  __ Comment("FixAllocationStubTarget");
+  // Load code pointer to this stub from the thread:
+  // The one that is passed in, is not correct - it points to the code object
+  // that needs to be replaced.
+  __ lw(CODE_REG, Address(THR, Thread::fix_allocation_stub_code_offset()));
   __ EnterStubFrame();
   // Setup space on stack for return value.
   __ addiu(SP, SP, Immediate(-1 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixAllocationStubTargetRuntimeEntry, 0);
   // Get Code object result.
-  __ lw(T0, Address(SP, 0 * kWordSize));
+  __ lw(CODE_REG, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(1 * kWordSize));
 
   // Jump to the dart function.
-  __ lw(T0, FieldAddress(T0, Code::entry_point_offset()));
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Input parameters:
 //   A1: Smi-tagged argument count, may be zero.
 //   FP[kParamEndSlotFromFp + 1]: Last argument.
 static void PushArgumentsArray(Assembler* assembler) {
@@ skipping 36 matching lines @@
 // - Push all registers that can contain values.
 // - Call C routine to copy the stack and saved registers into temporary buffer.
 // - Adjust caller's frame to correct unoptimized frame size.
 // - Fill the unoptimized frame.
 // - Materialize objects that require allocation (e.g. Double instances).
 // GC can occur only after frame is fully rewritten.
 // Stack after EnterFrame(...) below:
 //   +------------------+
 //   | Saved PP         | <- TOS
 //   +------------------+
+//   | Saved CODE_REG   |
+//   +------------------+
 //   | Saved FP         | <- FP of stub
 //   +------------------+
 //   | Saved LR         |  (deoptimization point)
 //   +------------------+
-//   | PC marker        |
+//   | 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) {
   const intptr_t kPushedRegistersSize =
-      kNumberOfCpuRegisters * kWordSize +
-      4 * kWordSize +  // PP, FP, RA, PC marker.
-      kNumberOfFRegisters * kWordSize;
+      kNumberOfCpuRegisters * kWordSize + kNumberOfFRegisters * kWordSize;
 
   __ SetPrologueOffset();
   __ Comment("GenerateDeoptimizationSequence");
-  // DeoptimizeCopyFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
-  // is no need to set the correct PC marker or load PP, since they get patched.
-  __ addiu(SP, SP, Immediate(-kPushedRegistersSize * kWordSize));
-  __ sw(ZR, Address(SP, kPushedRegistersSize - 1 * kWordSize));
-  __ sw(RA, Address(SP, kPushedRegistersSize - 2 * kWordSize));
-  __ sw(FP, Address(SP, kPushedRegistersSize - 3 * kWordSize));
-  __ sw(PP, Address(SP, kPushedRegistersSize - 4 * kWordSize));
-  __ addiu(FP, SP, Immediate(kPushedRegistersSize - 3 * kWordSize));
-
-  __ LoadPoolPointer();
+  // DeoptimizeCopyFrame expects a Dart frame.
+  __ EnterStubFrame(kPushedRegistersSize);
 
   // 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 - V0);
   // Result in V0 is preserved as part of pushing all registers below.
 
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   for (int i = 0; i < kNumberOfCpuRegisters; i++) {
-    const int slot = 4 + kNumberOfCpuRegisters - i;
+    const int slot = kNumberOfCpuRegisters - i;
     Register reg = static_cast<Register>(i);
-    __ sw(reg, Address(SP, kPushedRegistersSize - slot * kWordSize));
+    if (reg == CODE_REG) {
+      // Save the original value of CODE_REG pushed before invoking this stub
+      // instead of the value used to call this stub.
+      COMPILE_ASSERT(TMP < CODE_REG);  // Assert TMP is pushed first.
+      __ lw(TMP, Address(FP, kCallerSpSlotFromFp * kWordSize));
+      __ sw(TMP, Address(SP, kPushedRegistersSize - slot * kWordSize));
+    } else {
+      __ sw(reg, Address(SP, kPushedRegistersSize - slot * kWordSize));
+    }
   }
   for (int i = 0; i < kNumberOfFRegisters; i++) {
     // These go below the CPU registers.
-    const int slot = 4 + kNumberOfCpuRegisters + kNumberOfFRegisters - i;
+    const int slot = kNumberOfCpuRegisters + kNumberOfFRegisters - i;
     FRegister reg = static_cast<FRegister>(i);
     __ swc1(reg, Address(SP, kPushedRegistersSize - slot * kWordSize));
   }
 
   __ mov(A0, SP);  // Pass address of saved registers block.
+  __ LoadImmediate(A1, (kind == kLazyDeopt) ? 1 : 0);
   __ ReserveAlignedFrameSpace(1 * kWordSize);
-  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
+  __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 2);
   // Result (V0) is stack-size (FP - SP) in bytes, incl. the return address.
 
+  const bool preserve_result = (kind == kLazyDeopt);
   if (preserve_result) {
     // Restore result into T1 temporarily.
     __ lw(T1, Address(FP, saved_result_slot_from_fp * kWordSize));
   }
 
+  __ RestoreCodePointer();
   __ LeaveDartFrame();
   __ subu(SP, FP, V0);
 
   // DeoptimizeFillFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
   __ EnterStubFrame();
 
   __ mov(A0, FP);  // Get last FP address.
   if (preserve_result) {
     __ Push(T1);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(1 * kWordSize);
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);  // Pass last FP in A0.
   if (preserve_result) {
     // Restore result into T1.
     __ lw(T1, Address(FP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
+  __ RestoreCodePointer();
   __ LeaveStubFrame();
 
   // Frame is fully rewritten at this point and it is safe to perform a GC.
   // Materialize any objects that were deferred by FillFrame because they
   // require allocation.
   // Enter stub frame with loading PP. The caller's PP is not materialized yet.
   __ EnterStubFrame();
   if (preserve_result) {
     __ Push(T1);  // Preserve result, it will be GC-d here.
   }
   __ PushObject(Smi::ZoneHandle());  // Space for the result.
   __ CallRuntime(kDeoptimizeMaterializeRuntimeEntry, 0);
   // Result tells stub how many bytes to remove from the expression stack
   // of the bottom-most frame. They were used as materialization arguments.
   __ Pop(T1);
   if (preserve_result) {
     __ Pop(V0);  // Restore result.
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
   __ SmiUntag(T1);
   __ addu(SP, SP, T1);
   __ Ret();
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   // Correct return address to point just after the call that is being
   // deoptimized.
-  __ AddImmediate(RA, -CallPattern::kFixedLengthInBytes);
-  GenerateDeoptimizationSequence(assembler, true);  // Preserve V0.
+  __ AddImmediate(RA, -CallPattern::kDeoptCallLengthInBytes);
+  // Push zap value instead of CODE_REG for lazy deopt.
+  __ LoadImmediate(TMP, 0xf1f1f1f1);
+  __ Push(TMP);
+  GenerateDeoptimizationSequence(assembler, kLazyDeopt);
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
-  GenerateDeoptimizationSequence(assembler, false);  // Don't preserve V0.
+  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.
   __ BranchNotEqual(T0, Object::null_object(), call_target_function);
   __ EnterStubFrame();
@@ skipping 49 matching lines @@
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
 
   __ lw(T0, Address(SP, 3 * kWordSize));  // Get result function.
   __ lw(S4, Address(SP, 4 * kWordSize));  // Restore argument descriptor.
   __ lw(S5, Address(SP, 5 * kWordSize));  // Restore IC data.
   __ addiu(SP, SP, Immediate(6 * kWordSize));
 
+  __ RestoreCodePointer();
   __ LeaveStubFrame();
 
   if (!FLAG_lazy_dispatchers) {
     Label call_target_function;
     GenerateDispatcherCode(assembler, &call_target_function);
     __ Bind(&call_target_function);
   }
 
+  __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
   __ lw(T2, FieldAddress(T0, Function::entry_point_offset()));
   __ jr(T2);
 }
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   RA: return address.
 //   A1: Array length as Smi (must be preserved).
 //   A0: array element type (either NULL or an instantiated type).
@@ skipping 137 matching lines @@
   __ lw(A0, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
 
   __ LeaveStubFrameAndReturn();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
-//   A0 : entrypoint of the Dart function to call.
+//   A0 : code object of the Dart function to call.
 //   A1 : arguments descriptor array.
 //   A2 : arguments array.
 //   A3 : current thread.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
   __ Comment("InvokeDartCodeStub");
   __ EnterFrame();
 
+  // Push code object to PC marker slot.
+  __ lw(TMP, Address(A3, Thread::invoke_dart_code_stub_offset()));
+  __ Push(TMP);
+
   // Save new context and C++ ABI callee-saved registers.
 
   // The saved vm tag, top resource, and top exit frame info.
   const intptr_t kPreservedSlots = 3;
   const intptr_t kPreservedRegSpace =
       kWordSize * (kAbiPreservedCpuRegCount + kAbiPreservedFpuRegCount +
                    kPreservedSlots);
 
   __ addiu(SP, SP, Immediate(-kPreservedRegSpace));
   for (int i = S0; i <= S7; i++) {
     Register r = static_cast<Register>(i);
     const intptr_t slot = i - S0 + kPreservedSlots;
     __ sw(r, Address(SP, slot * kWordSize));
   }
 
   for (intptr_t i = kAbiFirstPreservedFpuReg;
        i <= kAbiLastPreservedFpuReg; i++) {
     FRegister r = static_cast<FRegister>(i);
     const intptr_t slot =
         kAbiPreservedCpuRegCount + kPreservedSlots + i -
         kAbiFirstPreservedFpuReg;
     __ swc1(r, Address(SP, slot * kWordSize));
   }
 
-  // We now load the pool pointer(PP) as we are about to invoke dart code and we
-  // could potentially invoke some intrinsic functions which need the PP to be
-  // set up.
-  __ LoadPoolPointer();
+  // We now load the pool pointer(PP) with a GC safe value as we are about
+  // to invoke dart code.
+  __ LoadImmediate(PP, 0);
 
   // Set up THR, which caches the current thread in Dart code.
   if (THR != A3) {
     __ mov(THR, A3);
   }
   __ LoadIsolate(T2);
 
   // Save the current VMTag on the stack.
   __ lw(T1, Address(T2, Isolate::vm_tag_offset()));
   __ sw(T1, Address(SP, 2 * kWordSize));
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(T0, VMTag::kDartTagId);
   __ sw(T0, Address(T2, Isolate::vm_tag_offset()));
 
   // Save top resource and top exit frame info. Use T0 as a temporary register.
   // StackFrameIterator reads the top exit frame info saved in this frame.
   __ lw(T0, Address(THR, Thread::top_resource_offset()));
   __ sw(ZR, Address(THR, Thread::top_resource_offset()));
   __ sw(T0, Address(SP, 1 * kWordSize));
   __ lw(T0, Address(THR, Thread::top_exit_frame_info_offset()));
   __ sw(ZR, Address(THR, Thread::top_exit_frame_info_offset()));
   // kExitLinkSlotFromEntryFp must be kept in sync with the code below.
-  ASSERT(kExitLinkSlotFromEntryFp == -23);
+  ASSERT(kExitLinkSlotFromEntryFp == -24);
   __ sw(T0, Address(SP, 0 * kWordSize));
 
   // After the call, The stack pointer is restored to this location.
   // Pushed S0-7, F20-31, T0, T0, T1 = 23.
 
   // Load arguments descriptor array into S4, which is passed to Dart code.
   __ lw(S4, Address(A1, VMHandles::kOffsetOfRawPtrInHandle));
 
   // Load number of arguments into S5.
   __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
@@ skipping 14 matching lines @@
   __ Push(A3);
   __ addiu(A1, A1, Immediate(1));
   __ BranchSignedLess(A1, T1, &push_arguments);
   __ delay_slot()->addiu(A2, A2, Immediate(kWordSize));
 
   __ Bind(&done_push_arguments);
 
   // Call the Dart code entrypoint.
   // We are calling into Dart code, here, so there is no need to call through
   // T9 to match the ABI.
+  __ lw(CODE_REG, Address(A0, VMHandles::kOffsetOfRawPtrInHandle));
+  __ lw(A0, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ jalr(A0);  // S4 is the arguments descriptor array.
   __ Comment("InvokeDartCodeStub return");
 
   // Get rid of arguments pushed on the stack.
   __ AddImmediate(SP, FP, kExitLinkSlotFromEntryFp * kWordSize);
 
-  __ LoadIsolate(S6);
+  __ LoadIsolate(S2);
 
   // Restore the current VMTag from the stack.
   __ lw(T1, Address(SP, 2 * kWordSize));
-  __ sw(T1, Address(S6, Isolate::vm_tag_offset()));
+  __ sw(T1, Address(S2, Isolate::vm_tag_offset()));
 
   // Restore the saved top resource and top exit frame info back into the
   // Isolate structure. Uses T0 as a temporary register for this.
   __ lw(T0, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(THR, Thread::top_resource_offset()));
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ sw(T0, Address(THR, Thread::top_exit_frame_info_offset()));
 
   // Restore C++ ABI callee-saved registers.
   for (int i = S0; i <= S7; i++) {
@@ skipping 202 matching lines @@
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RA : return address.
 //   SP + 0 : type arguments object (only if class is parameterized).
-// 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) {
+void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
+                                              const Class& cls) {
   __ Comment("AllocationStubForClass");
-  *entry_patch_offset = assembler->CodeSize();
   // 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.
   const int kInlineInstanceSize = 12;
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
@@ skipping 102 matching lines @@
     __ sw(T7, Address(SP, 0 * kWordSize));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 2);  // Allocate object.
   __ Comment("AllocationStubForClass return");
   // Pop result (newly allocated object).
   __ lw(V0, Address(SP, 2 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer and return.
   __ LeaveStubFrameAndReturn(RA);
-  *patch_code_pc_offset = assembler->CodeSize();
-  __ BranchPatchable(*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:
 //  RA : return address.
 //  SP : address of last argument.
 //  S4: arguments descriptor array.
@@ skipping 299 matching lines @@
   __ CallRuntime(handle_ic_miss, num_args + 1);
   __ Comment("NArgsCheckInlineCacheStub return");
   // Pop returned function object into T3.
   // Restore arguments descriptor array and IC data array.
   __ lw(T3, Address(SP, (num_slots - 3) * kWordSize));
   __ lw(S4, Address(SP, (num_slots - 2) * kWordSize));
   __ lw(S5, Address(SP, (num_slots - 1) * kWordSize));
   // Remove the call arguments pushed earlier, including the IC data object
   // and the arguments descriptor array.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
+  if (range_collection_mode == kCollectRanges) {
+    __ RestoreCodePointer();
+  }
   __ LeaveStubFrame();
 
   Label call_target_function;
   if (!FLAG_lazy_dispatchers) {
     __ mov(T0, T3);
     GenerateDispatcherCode(assembler, &call_target_function);
   } else {
     __ b(&call_target_function);
   }
 
@@ skipping 27 matching lines @@
       __ lw(T1, Address(SP, 1 * kWordSize));
     }
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(- frame_size * kWordSize));
     __ sw(RA, Address(SP, (frame_size - 1) * kWordSize));  // Return address.
     __ sw(S5, Address(SP, (frame_size - 2) * kWordSize));  // Preserve IC data.
     __ sw(T3, Address(SP, 0 * kWordSize));
     if (num_args == 2) {
       __ sw(T1, Address(SP, 1 * kWordSize));
     }
+    __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
     __ jalr(T4);
     __ lw(S5, Address(SP, (frame_size - 2) * kWordSize));
     __ lw(RA, Address(SP, (frame_size - 1) * kWordSize));
     Label done;
     __ UpdateRangeFeedback(V0, 2, S5, T1, &done);
     __ Bind(&done);
     __ addiu(SP, SP, Immediate(frame_size * kWordSize));
+    __ RestoreCodePointer();
     __ LeaveStubFrame();
     __ Ret();
   } else {
+    __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
     __ jr(T4);
   }
 
   // Call single step callback in debugger.
   if (FLAG_support_debugger && !optimized) {
     __ Bind(&stepping);
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(S5, Address(SP, 1 * kWordSize));  // Preserve IC data.
     __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
     __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
     __ lw(RA, Address(SP, 0 * kWordSize));
     __ lw(S5, Address(SP, 1 * kWordSize));
     __ addiu(SP, SP, Immediate(2 * kWordSize));
+    __ RestoreCodePointer();
     __ LeaveStubFrame();
     __ b(&done_stepping);
   }
 }
 
 
 // Use inline cache data array to invoke the target or continue in inline
 // cache miss handler. Stub for 1-argument check (receiver class).
 //  RA: Return address.
 //  S5: Inline cache data object.
@@ skipping 125 matching lines @@
     __ LoadImmediate(T4, Smi::RawValue(Smi::kMaxValue));
     __ movz(T4, T7, CMPRES1);
     __ sw(T4, Address(T0, count_offset));
   }
 
   // Load arguments descriptor into S4.
   __ lw(S4,  FieldAddress(S5, ICData::arguments_descriptor_offset()));
 
   // Get function and call it, if possible.
   __ lw(T0, Address(T0, target_offset));
+  __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
   __ lw(T4, FieldAddress(T0, Function::entry_point_offset()));
   __ jr(T4);
 
   // Call single step callback in debugger.
   if (FLAG_support_debugger) {
     __ Bind(&stepping);
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(S5, Address(SP, 1 * kWordSize));  // Preserve IC data.
     __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
     __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
     __ lw(RA, Address(SP, 0 * kWordSize));
     __ lw(S5, Address(SP, 1 * kWordSize));
     __ addiu(SP, SP, Immediate(2 * kWordSize));
+    __ RestoreCodePointer();
     __ LeaveStubFrame();
     __ b(&done_stepping);
   }
 }
 
 
 void StubCode::GenerateOneArgUnoptimizedStaticCallStub(Assembler* assembler) {
   GenerateUsageCounterIncrement(assembler, T0);
   GenerateNArgsCheckInlineCacheStub(
       assembler, 1, kStaticCallMissHandlerOneArgRuntimeEntry, Token::kILLEGAL,
@@ skipping 19 matching lines @@
   __ sw(S5, Address(SP, 2 * kWordSize));  // Preserve IC data object.
   __ sw(S4, Address(SP, 1 * kWordSize));  // Preserve args descriptor array.
   __ sw(T0, Address(SP, 0 * kWordSize));  // Pass function.
   __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
   __ lw(T0, Address(SP, 0 * kWordSize));  // Restore function.
   __ lw(S4, Address(SP, 1 * kWordSize));  // Restore args descriptor array.
   __ lw(S5, Address(SP, 2 * kWordSize));  // Restore IC data array.
   __ addiu(SP, SP, Immediate(3 * kWordSize));
   __ LeaveStubFrame();
 
+  __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
   __ lw(T2, FieldAddress(T0, Function::entry_point_offset()));
   __ jr(T2);
 }
 
 
 // S5: Contains an ICData.
 void StubCode::GenerateICCallBreakpointStub(Assembler* assembler) {
   __ Comment("ICCallBreakpoint stub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
 
   __ lw(S5, Address(SP, 1 * kWordSize));
-  __ lw(T0, Address(SP, 0 * kWordSize));
+  __ lw(CODE_REG, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ LeaveStubFrame();
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ jr(T0);
 }
 
 
 void StubCode::GenerateRuntimeCallBreakpointStub(Assembler* assembler) {
   __ Comment("RuntimeCallBreakpoint stub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-1 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kBreakpointRuntimeHandlerRuntimeEntry, 0);
 
-  __ lw(T0, Address(SP, 0 * kWordSize));
+  __ lw(CODE_REG, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
   __ LeaveStubFrame();
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ jr(T0);
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // RA: return address.
 void StubCode::GenerateDebugStepCheckStub(Assembler* assembler) {
   // Check single stepping.
   Label stepping, done_stepping;
   __ LoadIsolate(T0);
@@ skipping 170 matching lines @@
   __ Comment("OptimizeFunctionStub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(S4, Address(SP, 2 * kWordSize));
   // Setup space on stack for return value.
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
   __ Comment("OptimizeFunctionStub return");
-  __ lw(T0, Address(SP, 1 * kWordSize));  // Get Code object
+  __ lw(CODE_REG, Address(SP, 1 * kWordSize));  // Get Code object
   __ lw(S4, Address(SP, 2 * kWordSize));  // Restore argument descriptor.
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Discard argument.
 
-  __ lw(T0, FieldAddress(T0, Code::entry_point_offset()));
+  __ lw(T0, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ LeaveStubFrameAndReturn(T0);
   __ break_(0);
 }
 
 
 // Does identical check (object references are equal or not equal) with special
 // checks for boxed numbers.
 // Returns: CMPRES1 is zero if equal, non-zero otherwise.
 // Note: A Mint cannot contain a value that would fit in Smi, a Bigint
 // cannot contain a value that fits in Mint or Smi.
@@ skipping 100 matching lines @@
 
   // Call single step callback in debugger.
   if (FLAG_support_debugger) {
     __ Bind(&stepping);
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-1 * kWordSize));
     __ sw(RA, Address(SP, 0 * kWordSize));  // Return address.
     __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
     __ lw(RA, Address(SP, 0 * kWordSize));
     __ addiu(SP, SP, Immediate(1 * kWordSize));
+    __ RestoreCodePointer();
     __ LeaveStubFrame();
     __ b(&done_stepping);
   }
 }
 
 
 // Called from optimized code only.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Returns: CMPRES1 is zero if equal, non-zero otherwise.
@@ skipping 40 matching lines @@
 
   __ Bind(&call_target_function);
   // 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.
   __ sll(T1, T3, 2);
   __ addu(T1, T2, T1);
   __ lw(T0, FieldAddress(T1, base + kWordSize));
 
+  __ lw(CODE_REG, FieldAddress(T0, Function::code_offset()));
   __ lw(target, FieldAddress(T0, Function::entry_point_offset()));
 }
 
 
 // Called from megamorphic calls.
 //  T0: receiver.
 //  T1: lookup cache.
 // Result:
 //  T1: entry point.
 void StubCode::GenerateMegamorphicLookupStub(Assembler* assembler) {
   EmitMegamorphicLookup(assembler, T0, T1, T1);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS