On MIPS, uses more branch delay slots.

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 63 matching lines @@
   // 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.
   __ addiu(A2, A2, Immediate(kWordSize));  // Set argv in NativeArguments.
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ addiu(A3, A2, Immediate(kWordSize));  // Retval is next to 1st argument.
 
   // Call runtime or redirection via simulator.
   __ jalr(S5);
+  // Retval is next to 1st argument.
+  __ delay_slot()->addiu(A3, A2, Immediate(kWordSize));
   __ TraceSimMsg("CallToRuntimeStub return");
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(CTX, Isolate::top_exit_frame_info_offset()));
 
   // Load Context pointer from Isolate structure into A2.
   __ lw(A2, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(A3, reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 70 matching lines @@
 
   // TODO(regis): Should we pass the structure by value as in runtime calls?
   // It 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.
-
   // Call native function or redirection via simulator.
   __ jalr(T5);
+  __ delay_slot()->mov(A0, SP);  // Pass the pointer to the NativeArguments.
   __ TraceSimMsg("CallNativeCFunctionStub return");
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(CTX, Isolate::top_exit_frame_info_offset()));
 
   // Load Context pointer from Isolate structure into A2.
   __ lw(A2, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(A3, reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 29 matching lines @@
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveStubFrame();
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ jr(T0);
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 // 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) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
   __ LoadImmediate(T0, reinterpret_cast<intptr_t>(Object::null()));
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixCallersTargetRuntimeEntry);
   // Get Code object result and restore arguments descriptor array.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   // Remove the stub frame.
   __ LeaveStubFrame();
+
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ jr(T0);
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 // Input parameters:
 //   A1: Smi-tagged argument count, may be zero.
 //   FP[kLastParamSlotIndex]: Last argument.
 static void PushArgumentsArray(Assembler* assembler) {
   __ TraceSimMsg("PushArgumentsArray");
   // Allocate array to store arguments of caller.
   __ LoadImmediate(A0, reinterpret_cast<intptr_t>(Object::null()));
   // A0: Null element type for raw Array.
   // A1: Smi-tagged argument count, may be zero.
   __ BranchLink(&StubCode::AllocateArrayLabel());
   __ TraceSimMsg("PushArgumentsArray return");
   // V0: newly allocated array.
   // A1: Smi-tagged argument count, may be zero (was preserved by the stub).
   __ Push(V0);  // Array is in V0 and on top of stack.
   __ sll(T1, A1, 1);
   __ addu(T1, FP, T1);
   __ AddImmediate(T1, (kLastParamSlotIndex - 1) * kWordSize);
-  __ AddImmediate(T2, V0, Array::data_offset() - kHeapObjectTag);
   // T1: address of first argument on stack.
   // T2: address of first argument in array.
-  Label loop, loop_condition;
-  __ b(&loop_condition);
+
+  Label loop, loop_exit;
+  __ blez(A1, &loop_exit);
+  __ delay_slot()->addiu(T2, V0,
+                         Immediate(Array::data_offset() - kHeapObjectTag));
   __ Bind(&loop);
   __ lw(TMP, Address(T1));
-  __ sw(TMP, Address(T2));
-  __ AddImmediate(T1, -kWordSize);
-  __ AddImmediate(T2, kWordSize);
-  __ Bind(&loop_condition);
-  __ AddImmediate(A1, -Smi::RawValue(1));  // A1 is Smi.
-  __ BranchSignedGreaterEqual(A1, ZR, &loop);
+  __ addiu(A1, A1, Immediate(-Smi::RawValue(1)));
+  __ addiu(T1, T1, Immediate(-kWordSize));
+  __ addiu(T2, T2, Immediate(kWordSize));
+  __ bgez(A1, &loop);
+  __ delay_slot()->sw(TMP, Address(T2, -kWordSize));
+  __ Bind(&loop_exit);
 }
 
 
 // Input parameters:
 //   S5: ic-data.
 //   S4: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
@@ skipping 31 matching lines @@
   // TOS + 6: dart code return address
   // TOS + 7: pc marker (0 for stub).
   // TOS + 8: last argument of caller.
   // ....
   __ CallRuntime(kInstanceFunctionLookupRuntimeEntry);
   // Remove arguments.
   __ lw(V0, Address(SP, 4 * kWordSize));
   __ addiu(SP, SP, Immediate(5 * kWordSize));  // Get result into V0.
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
                            uword saved_registers_address);
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, uword last_fp);
 
 
@@ skipping 96 matching lines @@
   __ EnterStubFrame();
   if (preserve_result) {
     __ Push(T1);  // Preserve result, it will be GC-d here.
   }
   __ CallRuntime(kDeoptimizeMaterializeDoublesRuntimeEntry);
   if (preserve_result) {
     __ Pop(V0);  // Restore result.
   }
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   __ Unimplemented("DeoptimizeLazy stub");
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   GenerateDeoptimizationSequence(assembler, false);  // Don't preserve V0.
@@ skipping 96 matching lines @@
     // Get the class index and insert it into the tags.
     __ LoadImmediate(TMP1, RawObject::ClassIdTag::encode(kArrayCid));
     __ or_(T3, T3, TMP1);
     __ sw(T3, FieldAddress(V0, Array::tags_offset()));
 
     // Initialize all array elements to raw_null.
     // V0: new object start as a tagged pointer.
     // T2: new object end address.
     // A1: Array length as Smi.
     __ AddImmediate(T3, V0, Array::data_offset() - kHeapObjectTag);
-    // R1: iterator which initially points to the start of the variable
+    // T3: iterator which initially points to the start of the variable
     // data area to be initialized.
-    __ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
-    Label loop, test;
-    __ b(&test);
+
+    Label loop, loop_exit;
+    intptr_t null = reinterpret_cast<intptr_t>(Object::null());
+    uint16_t null_lo = Utils::Low16Bits(null);
+    uint16_t null_hi = Utils::High16Bits(null);
+    __ lui(TMP1, Immediate(null_hi));
+    __ BranchUnsignedGreaterEqual(T3, T2, &loop_exit);
+    __ delay_slot()->ori(TMP1, TMP1, Immediate(null_lo));
     __ Bind(&loop);
-    // TODO(cshapiro): StoreIntoObjectNoBarrier
-    __ sw(TMP1, Address(T3, 0));
-    __ AddImmediate(T3, kWordSize);
-    __ Bind(&test);
+    __ addiu(T3, T3, Immediate(kWordSize));
     __ bne(T3, T2, &loop);
+    __ delay_slot()->sw(TMP1, Address(T3, -kWordSize));
+    __ Bind(&loop_exit);
 
     // Done allocating and initializing the array.
     // V0: new object.
     // A1: Array length as Smi (preserved for the caller.)
     __ Ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
@@ skipping 10 matching lines @@
   __ CallRuntime(kAllocateArrayRuntimeEntry);
   __ TraceSimMsg("AllocateArrayStub return");
   // Pop arguments; result is popped in IP.
   __ lw(TMP1, Address(SP, 2 * kWordSize));
   __ lw(A1, Address(SP, 1 * kWordSize));
   __ lw(T3, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
   __ mov(V0, TMP1);
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 // Input parameters:
 //   RA: return address.
 //   SP: address of last argument.
 //   S4: Arguments descriptor array.
 // Return: V0.
 // Note: The closure object is the first argument to the function being
 //       called, the stub accesses the closure from this location directly
@@ skipping 51 matching lines @@
   __ TraceSimMsg("GenerateCallClosureFunctionStub return");
   // Restore arguments descriptor array and read-only function object argument.
   __ lw(T2, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   // Restore T0.
   __ lw(T0, FieldAddress(T2, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();
 
   __ Bind(&function_compiled);
   // T0: Code.
   // S4: Arguments descriptor array.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ jr(T0);
 
   __ Bind(&not_closure);
   // Call runtime to attempt to resolve and invoke a call method on a
@@ skipping 25 matching lines @@
   // TOS + 5: PC marker (0 for stub).
   // TOS + 6: Last argument of caller.
   // ....
   __ CallRuntime(kInvokeNonClosureRuntimeEntry);
   __ lw(V0, Address(SP, 2 * kWordSize));  // Get result into V0.
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Remove arguments.
 
   // Remove the stub frame as we are about to return.
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
 //   A0 : entrypoint of the Dart function to call.
 //   A1 : arguments descriptor array.
 //   A2 : arguments array.
 //   A3 : new context containing the current isolate pointer.
@@ skipping 48 matching lines @@
 
   // 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()));
   __ SmiUntag(T1);
 
   // Compute address of 'arguments array' data area into A2.
   __ lw(A2, Address(A2, VMHandles::kOffsetOfRawPtrInHandle));
-  __ AddImmediate(A2, Array::data_offset() - kHeapObjectTag);
 
   // Set up arguments for the Dart call.
   Label push_arguments;
   Label done_push_arguments;
   __ beq(T1, ZR, &done_push_arguments);  // check if there are arguments.
+  __ delay_slot()->addiu(A2, A2,
+                         Immediate(Array::data_offset() - kHeapObjectTag));
   __ mov(A1, ZR);
   __ Bind(&push_arguments);
   __ lw(A3, Address(A2));
   __ Push(A3);
   __ addiu(A1, A1, Immediate(1));
   __ BranchSignedLess(A1, T1, &push_arguments);
   __ delay_slot()->addiu(A2, A2, Immediate(kWordSize));
 
   __ Bind(&done_push_arguments);
 
@@ skipping 24 matching lines @@
   for (int i = S0; i <= S7; i++) {
     Register r = static_cast<Register>(i);
     __ lw(r, Address(SP, (i - S0 + 3) * kWordSize));
   }
   __ lw(A3, Address(SP, 2 * kWordSize));
   __ addiu(SP, SP, Immediate((3 + kAbiPreservedCpuRegCount) * kWordSize));
 
   // Restore the frame pointer and return.
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 //   T1: number of context variables.
 // Output:
 //   V0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   if (FLAG_inline_alloc) {
@@ skipping 62 matching lines @@
     __ sw(T1, FieldAddress(V0, Context::num_variables_offset()));
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into R2.
     // V0: new object.
     // T1: number of context variables.
     __ lw(T2, FieldAddress(CTX, Context::isolate_offset()));
     // T2: isolate, not an object.
     __ sw(T2, FieldAddress(V0, Context::isolate_offset()));
 
-    // Setup the parent field.
-    // V0: new object.
-    // T1: number of context variables.
     __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
-    __ sw(T2, FieldAddress(V0, Context::parent_offset()));
 
     // Initialize the context variables.
     // V0: new object.
     // T1: number of context variables.
     // T2: raw null.
-    Label loop, loop_test;
+    Label loop, loop_exit;
+    __ blez(T1, &loop_exit);
+    // Setup the parent field.
+    __ delay_slot()->sw(T2, FieldAddress(V0, Context::parent_offset()));
     __ AddImmediate(T3, V0, Context::variable_offset(0) - kHeapObjectTag);
-    __ b(&loop_test);
-    __ delay_slot()->sll(T1, T1, 2);
+    __ sll(T1, T1, 2);
     __ Bind(&loop);
+    __ addiu(T1, T1, Immediate(-kWordSize));
     __ addu(TMP1, T3, T1);
-    __ sw(T2, Address(TMP1));
-    __ Bind(&loop_test);
-    __ addiu(T1, T1, Immediate(-kWordSize));
-    __ bne(T1, ZR, &loop);  // Loop if R1 not zero.
+    __ bgtz(T1, &loop);
+    __ delay_slot()->sw(T2, Address(TMP1));
+    __ Bind(&loop_exit);
 
     // Done allocating and initializing the context.
     // V0: new object.
     __ Ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value.
   __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
   __ SmiTag(T1);
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(T2, Address(SP, 1 * kWordSize));
   __ sw(T1, Address(SP, 0 * kWordSize));
   __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
   __ lw(V0, Address(SP, 1 * kWordSize));  // Get the new context.
   __ addiu(SP, SP, Immediate(2 * kWordSize));  // Pop argument and return.
 
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();

[regis, 2013/05/01 01:21:46]

Why didn't you use the delay slot here?

[zra, 2013/05/01 16:53:17]

Missed it. Thanks!

   __ Ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
 
 // Helper stub to implement Assembler::StoreIntoObject.
 // Input parameters:
 //   T0: Address (i.e. object) being stored into.
@@ skipping 162 matching lines @@
         __ sw(T0, Address(T2, current_offset));
       }
     } else {
       __ addiu(T4, T2, Immediate(sizeof(RawObject)));
       // Loop until the whole object is initialized.
       // T0: raw null.
       // T2: new object.
       // T3: next object start.
       // T4: next word to be initialized.
       // T1: new object type arguments (if is_cls_parameterized).
-      Label init_loop;
-      Label done;
-      __ Bind(&init_loop);
-      __ BranchUnsignedGreaterEqual(T4, T3, &done);  // Done if T4 >= T3.
-      __ sw(T0, Address(T4));
-      __ AddImmediate(T4, kWordSize);
-      __ b(&init_loop);
-      __ Bind(&done);
+      Label loop, loop_exit;
+      __ BranchUnsignedGreaterEqual(T4, T3, &loop_exit);
+      __ Bind(&loop);
+      __ addiu(T4, T4, Immediate(kWordSize));
+      __ bne(T4, T3, &loop);
+      __ delay_slot()->sw(T0, Address(T4, -kWordSize));
+      __ Bind(&loop_exit);
     }
     if (is_cls_parameterized) {
       // R1: new object type arguments.
       // Set the type arguments in the new object.
       __ sw(T1, Address(T2, cls.type_arguments_field_offset()));
     }
     // Done allocating and initializing the instance.
     // T2: new object still missing its heap tag.
     __ Ret();
     __ delay_slot()->addiu(V0, T2, Immediate(kHeapObjectTag));
@@ skipping 26 matching lines @@
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
   __ TraceSimMsg("AllocationStubForClass return");
   // Pop result (newly allocated object).
   __ lw(V0, Address(SP, 3 * kWordSize));
   __ addiu(SP, SP, Immediate(4 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore(true);
 }
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   RA: return address.
 //   SP + 4 : receiver (null if not an implicit instance closure).
 //   SP + 0 : type arguments object (null if class is no parameterized).
 void StubCode::GenerateAllocationStubForClosure(Assembler* assembler,
                                                 const Function& func) {
@@ skipping 96 matching lines @@
 
     // Set the type arguments field in the newly allocated closure.
     __ lw(T0, Address(FP, kTypeArgumentsFPOffset));
     __ sw(T0, Address(T2, Closure::type_arguments_offset()));
 
     // Done allocating and initializing the instance.
     // V0: new object.
     __ addiu(V0, T2, Immediate(kHeapObjectTag));
     __ LeaveStubFrame(true);
     __ Ret();
+    __ delay_slot()->LeaveStubFrameSPRestore(true);
 
     __ Bind(&slow_case);
   }
 
   // If it's an implicit static closure we need 2 stack slots. Otherwise,
   // If it's an implicit instance closure we need 4 stack slots, o/w only 3.
   int num_slots = 2;
   if (!is_implicit_static_closure) {
     num_slots = is_implicit_instance_closure ? 4 : 3;
   }
@@ skipping 27 matching lines @@
       __ TraceSimMsg("AllocationStubForClosure return");
     }
   }
   __ lw(V0, Address(SP, (num_slots - 1) * kWordSize));  // Pop function object.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
 
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore(true);
 }
 
 
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   __ Unimplemented("CallNoSuchMethodFunction stub");
 }
 
 
 //  T0: function object.
 //  S5: inline cache data object.
 //  S4: arguments descriptor array.
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
   __ TraceSimMsg("OptimizedUsageCounterIncrement");
   Register ic_reg = S5;
   Register func_reg = T0;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-5 * kWordSize));
     __ sw(T0, Address(SP, 4 * kWordSize));
     __ sw(S5, Address(SP, 3 * kWordSize));
     __ sw(S4, Address(SP, 2 * kWordSize));  // Preserve.
     __ sw(ic_reg, Address(SP, 1 * kWordSize));  // Argument.
     __ sw(func_reg, Address(SP, 0 * kWordSize));  // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry);
     __ lw(S4, Address(SP, 2 * kWordSize));  // Restore.
     __ lw(S5, Address(SP, 3 * kWordSize));
     __ lw(T0, Address(SP, 4 * kWordSize));
     __ addiu(SP, SP, Immediate(5 * kWordSize));  // Discard argument;
     __ LeaveStubFrame();
+    __ LeaveStubFrameSPRestore();
   }
   __ lw(T7, FieldAddress(func_reg, Function::usage_counter_offset()));
   Label is_hot;
   if (FlowGraphCompiler::CanOptimize()) {
     ASSERT(FLAG_optimization_counter_threshold > 1);
     __ BranchSignedGreaterEqual(T7, FLAG_optimization_counter_threshold,
                                 &is_hot);
     // As long as VM has no OSR do not optimize in the middle of the function
     // but only at exit so that we have collected all type feedback before
     // optimizing.
@@ skipping 165 matching lines @@
   __ 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));
   __ LeaveStubFrame();
   Label call_target_function;
   __ BranchNotEqual(T3, reinterpret_cast<intptr_t>(Object::null()),
                     &call_target_function);
+  __ delay_slot()->LeaveStubFrameSPRestore();
   // NoSuchMethod or closure.
   // Mark IC call that it may be a closure call that does not collect
   // type feedback.
   __ LoadImmediate(TMP2, 1);
   __ Branch(&StubCode::InstanceFunctionLookupLabel());
   __ delay_slot()->sb(TMP2, FieldAddress(S5, ICData::is_closure_call_offset()));
 
   __ Bind(&found);
   // T0: Pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ lw(T3, Address(T0, target_offset));
   __ lw(T4, Address(T0, count_offset));
 
   __ AddImmediateDetectOverflow(T4, T4, Smi::RawValue(1), T5);
 
   __ bgez(T5, &call_target_function);  // No overflow.
   __ delay_slot()->sw(T4, Address(T0, count_offset));
 
   __ LoadImmediate(T1, Smi::RawValue(Smi::kMaxValue));
   __ sw(T1, Address(T0, count_offset));
 
   __ Bind(&call_target_function);
   // T3: Target function.
   __ lw(T3, FieldAddress(T3, Function::code_offset()));
   __ lw(T3, FieldAddress(T3, Code::instructions_offset()));
   __ AddImmediate(T3, Instructions::HeaderSize() - kHeapObjectTag);
   __ jr(T3);
+  __ delay_slot()->addiu(T3, T3,
+      Immediate(Instructions::HeaderSize() - kHeapObjectTag));
 
   // Instance in T3, return its class-id in T3 as Smi.
   __ Bind(&get_class_id_as_smi);
   Label not_smi;
   // Test if Smi -> load Smi class for comparison.
   __ andi(TMP1, T3, Immediate(kSmiTagMask));
   __ bne(TMP1, ZR, &not_smi);
-  __ LoadImmediate(T3, Smi::RawValue(kSmiCid));
   __ jr(RA);
+  __ delay_slot()->addiu(T3, ZR, Immediate(Smi::RawValue(kSmiCid)));
 
   __ Bind(&not_smi);
   __ LoadClassId(T3, T3);
-  __ SmiTag(T3);
   __ jr(RA);
+  __ delay_slot()->SmiTag(T3);
 }
 
 
 // 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.
 //  S4: Arguments descriptor array.
 // Inline cache data object structure:
 // 0: function-name
@@ skipping 61 matching lines @@
   // Preserve arguments descriptor and make room for result.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
   // Pop code object result and restore arguments descriptor.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ jr(T0);
 }
 
 
 //  V0: return value.
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   __ TraceSimMsg("BreakpoingReturnStub");
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ Push(V0);
   __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
   __ Pop(V0);
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ LeaveDartFrame();
   __ Ret();
 }
 
 
 //  RA: return address (Dart code).
 //  S5: Inline cache data array.
 //  S4: Arguments descriptor array.
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
   __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
   __ lw(S4, Address(SP, 0 * kWordSize));
   __ lw(S5, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();
 
   // Find out which dispatch stub to call.
   __ lw(TMP1, FieldAddress(S5, ICData::num_args_tested_offset()));
 
   Label one_arg, two_args, three_args;
   __ BranchEqual(TMP1, 1, &one_arg);
   __ BranchEqual(TMP1, 2, &two_args);
   __ BranchEqual(TMP1, 3, &three_args);
   __ Stop("Unsupported number of arguments tested.");
 
@@ skipping 57 matching lines @@
     if (n == 2) {
       __ beq(T3, T1, &found);
     } else {
       __ bne(T3, T1, &next_iteration);
       __ lw(T3, Address(T2, kWordSize *
                         SubtypeTestCache::kInstantiatorTypeArguments));
       __ beq(T3, A1, &found);
     }
   }
   __ Bind(&next_iteration);
-  __ AddImmediate(T2, kWordSize * SubtypeTestCache::kTestEntryLength);
   __ b(&loop);
+  __ delay_slot()->addiu(T2, T2,
+      Immediate(kWordSize * SubtypeTestCache::kTestEntryLength));
   // Fall through to not found.
   __ Bind(&not_found);
-  __ LoadImmediate(V0, reinterpret_cast<intptr_t>(Object::null()));
+  intptr_t null = reinterpret_cast<intptr_t>(Object::null());
+  uint16_t null_lo = Utils::Low16Bits(null);
+  uint16_t null_hi = Utils::High16Bits(null);
+  __ lui(V0, Immediate(null_hi));
   __ Ret();
+  __ delay_slot()->ori(V0, V0, Immediate(null_lo));
 
   __ Bind(&found);
   __ Ret();
   __ delay_slot()->lw(V0,
                       Address(T2, kWordSize * SubtypeTestCache::kTestResult));
 }
 
 
 // Used to check class and type arguments. Arguments passed in registers:
 // RA: return address.
@@ skipping 42 matching lines @@
 // A2: frame_pointer.
 // A3: error object.
 // SP: address of stacktrace object.
 // Does not return.
 void StubCode::GenerateJumpToExceptionHandlerStub(Assembler* assembler) {
   ASSERT(kExceptionObjectReg == V0);
   ASSERT(kStackTraceObjectReg == V1);
   __ mov(V0, A3);  // Exception object.
   __ lw(V1, Address(SP, 0));  // StackTrace object.
   __ mov(FP, A2);  // Frame_pointer.
-  __ mov(SP, A1);  // Stack pointer.
   __ jr(A0);  // Jump to the exception handler code.
+  __ delay_slot()->mov(SP, A1);  // Stack pointer.
 }
 
 
 // Implements equality operator when one of the arguments is null
 // (identity check) and updates ICData if necessary.
 // RA: return address.
 // A1: left argument.
 // A0: right argument.
 // T0: ICData.
 // V0: result.
@@ skipping 24 matching lines @@
   __ lw(T3, Address(T6, 0 * kWordSize));
   __ bne(T2, T3, &no_match);  // Class id match?
 
   // Check right.
   __ bal(&get_class_id_as_smi);
   __ delay_slot()->mov(T2, A0);
   __ lw(T3, Address(T6, 1 * kWordSize));
   __ beq(T2, T3, &found);  // Class id match?
   __ Bind(&no_match);
   // Next check group.
-  __ AddImmediate(T6, kWordSize * ICData::TestEntryLengthFor(kNumArgsTested));
-  __ BranchNotEqual(T3, Smi::RawValue(kIllegalCid), &loop);  // Done?
+  intptr_t entry_bytes = kWordSize * ICData::TestEntryLengthFor(kNumArgsTested);
+  if (Utils::IsInt(kImmBits, entry_bytes)) {
+    __ BranchNotEqual(T3, Smi::RawValue(kIllegalCid), &loop);  // Done?
+    __ delay_slot()->addiu(T6, T6, Immediate(entry_bytes));
+  } else {
+    __ AddImmediate(T6, entry_bytes);
+    __ BranchNotEqual(T3, Smi::RawValue(kIllegalCid), &loop);  // Done?
+  }
 
   Label update_ic_data;
   __ b(&update_ic_data);
 
   __ Bind(&found);
   const intptr_t count_offset =
       ICData::CountIndexFor(kNumArgsTested) * kWordSize;
   Label no_overflow;
   __ lw(T1, Address(T6, count_offset));
   __ AddImmediateDetectOverflow(T1, T1, Smi::RawValue(1), CMPRES);
   __ bgez(CMPRES, &no_overflow);
   __ LoadImmediate(TMP1, Smi::RawValue(Smi::kMaxValue));
   __ sw(TMP1, Address(T6, count_offset));  // If overflow.
   __ Bind(&no_overflow);
 
   Label compute_result;
   __ Bind(&compute_result);
   __ LoadObject(TMP1, Bool::True());
   __ LoadObject(TMP2, Bool::False());
   __ subu(CMPRES, A0, A1);
   __ movz(V0, TMP1, CMPRES);
   __ movn(V0, TMP2, CMPRES);
   __ LeaveStubFrame();
   __ Ret();
+  __ delay_slot()->LeaveStubFrameSPRestore();
 
   __ Bind(&get_class_id_as_smi);
   // Test if Smi -> load Smi class for comparison.
   Label not_smi;
   __ andi(CMPRES, T2, Immediate(kSmiTagMask));
   __ bne(CMPRES, ZR, &not_smi);
   __ jr(RA);
   __ delay_slot()->addiu(T2, ZR, Immediate(Smi::RawValue(kSmiCid)));
   __ Bind(&not_smi);
   __ LoadClassId(T2, T2);
@@ skipping 31 matching lines @@
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
   __ TraceSimMsg("OptimizeFunctionStub return");
   __ lw(T0, 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::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ LeaveStubFrame();
   __ jr(T0);
+  __ delay_slot()->LeaveStubFrameSPRestore();
   __ break_(0);
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t,
                            BigintCompare,
                            RawBigint* left,
                            RawBigint* right);
 
 
@@ skipping 73 matching lines @@
   __ bne(ret, ZR, &done);
 
   __ EnterStubFrame(0);
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ sw(T1, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kBigintCompareRuntimeEntry);
   __ TraceSimMsg("IdenticalWithNumberCheckStub return");
   // Result in V0, 0 means equal.
   __ LeaveStubFrame();
+  __ LeaveStubFrameSPRestore();
   __ b(&done);
   __ delay_slot()->mov(CMPRES, V0);
 
   __ Bind(&reference_compare);
   __ subu(ret, left, right);
   __ Bind(&done);
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(T1, Address(SP, 1 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS