On MIPS, keeps Object::null() in a register.

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 76 matching lines @@
   // 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()));
 
+  // Reload NULLREG.
+  __ LoadImmediate(NULLREG, reinterpret_cast<intptr_t>(Object::null()));
+
   // Reset Context pointer in Isolate structure.
-  __ LoadImmediate(A3, reinterpret_cast<intptr_t>(Object::null()));
-  __ sw(A3, Address(CTX, Isolate::top_context_offset()));
+  __ sw(NULLREG, Address(CTX, Isolate::top_context_offset()));
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, A2);
 
   __ mov(SP, FP);
   __ lw(RA, Address(SP, 1 * kWordSize));
   __ lw(FP, Address(SP, 0 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
 }
@@ skipping 70 matching lines @@
   __ 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()));
 
+  // Reload NULLREG.
+  __ LoadImmediate(NULLREG, reinterpret_cast<intptr_t>(Object::null()));
+
   // Reset Context pointer in Isolate structure.
-  __ LoadImmediate(A3, reinterpret_cast<intptr_t>(Object::null()));
-  __ sw(A3, Address(CTX, Isolate::top_context_offset()));
+  __ sw(NULLREG, Address(CTX, Isolate::top_context_offset()));
 
   // Cache Context pointer into CTX while executing Dart code.
   __ mov(CTX, A2);
 
   __ mov(SP, FP);
   __ lw(RA, Address(SP, 1 * kWordSize));
   __ lw(FP, Address(SP, 0 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 // Input parameters:
 //   S4: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("CallStaticFunctionStub");
   __ 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));
+  __ sw(NULLREG, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kPatchStaticCallRuntimeEntry);
   __ TraceSimMsg("CallStaticFunctionStub return");
 
   // 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));
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // 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) {
   // 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));
+  __ sw(NULLREG, 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));
 
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // 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()));
+  __ mov(A0, NULLREG);
   // 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);
@@ skipping 28 matching lines @@
   // Load the receiver.
   __ lw(A1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   __ sll(TMP1, A1, 1);  // A1 is Smi.
   __ addu(TMP1, FP, TMP1);
   __ lw(T1, Address(TMP1, (kLastParamSlotIndex - 1) * kWordSize));
 
   // Push space for the return value.
   // Push the receiver.
   // Push TMP1 data object.
   // Push arguments descriptor array.
-  __ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
-  __ sw(TMP1, Address(SP, 3 * kWordSize));
+  __ sw(NULLREG, Address(SP, 3 * kWordSize));
   __ sw(T1, Address(SP, 2 * kWordSize));
   __ sw(S5, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
   // A1: Smi-tagged arguments array length.
   PushArgumentsArray(assembler);
   __ TraceSimMsg("InstanceFunctionLookupStub return");
 
   // Stack:
   // TOS + 0: argument array.
@@ skipping 221 matching lines @@
         FieldAddress(V0, Array::length_offset()),
         A1);
 
     // Calculate the size tag.
     // V0: new object start as a tagged pointer.
     // A1: Array length as Smi.
     // T2: new object end address.
     // T3: array size.
     const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
     // If no size tag overflow, shift T3 left, else set T3 to zero.
-    __ LoadImmediate(TMP2, RawObject::SizeTag::kMaxSizeTag);
-    __ sltu(CMPRES, TMP2, T3);  // CMPRES = TMP2 < T3 ? 1 : 0
+    __ LoadImmediate(T4, RawObject::SizeTag::kMaxSizeTag);
+    __ sltu(CMPRES, T4, T3);  // CMPRES = T4 < T3 ? 1 : 0
     __ sll(TMP1, T3, shift);  // TMP1 = T3 << shift;
-    __ movz(T3, TMP1, CMPRES);  // T3 = TMP2 >= T3 ? 0 : T3
-    __ movn(T3, ZR, CMPRES);  // T3 = TMP2 < T3 ? TMP1 : T3
+    __ movz(T3, TMP1, CMPRES);  // T3 = T4 >= T3 ? 0 : T3
+    __ movn(T3, ZR, CMPRES);  // T3 = T4 < T3 ? TMP1 : T3
 
     // 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);
     // T3: iterator which initially points to the start of the variable
     // data area to be initialized.
 
     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);
     __ addiu(T3, T3, Immediate(kWordSize));
     __ bne(T3, T2, &loop);
-    __ delay_slot()->sw(TMP1, Address(T3, -kWordSize));
+    __ delay_slot()->sw(NULLREG, 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);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
-  __ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
-  __ sw(TMP1, Address(SP, 2 * kWordSize));
+  __ sw(NULLREG, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ sw(T3, Address(SP, 0 * kWordSize));
   __ 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);
@@ skipping 18 matching lines @@
   __ subu(T0, T0, TMP1);
 
   // Load closure object in T1.
   __ sll(T1, T0, 1);  // T0 (num_args - 1) is a Smi.
   __ addu(T1, SP, T1);
   __ lw(T1, Address(T1));
 
   // Verify that T1 is a closure by checking its class.
   Label not_closure;
 
-  __ LoadImmediate(T7, reinterpret_cast<intptr_t>(Object::null()));
   // See if it is not a closure, but null object.
-  __ beq(T1, T7, &not_closure);
+  __ beq(T1, NULLREG, &not_closure);
 
   __ andi(CMPRES, T1, Immediate(kSmiTagMask));
   __ beq(CMPRES, ZR, &not_closure);  // Not a closure, but a smi.
 
   // Verify that the class of the object is a closure class by checking that
   // class.signature_function() is not null.
   __ LoadClass(T0, T1);
   __ lw(T0, FieldAddress(T0, Class::signature_function_offset()));
 
   // See if actual class is not a closure class.
-  __ beq(T0, T7, &not_closure);
+  __ beq(T0, NULLREG, &not_closure);
 
   // T0 is just the signature function. Load the actual closure function.
   __ lw(T2, FieldAddress(T1, Closure::function_offset()));
 
   // Load closure context in CTX; note that CTX has already been preserved.
   __ lw(CTX, FieldAddress(T1, Closure::context_offset()));
 
   Label function_compiled;
   // Load closure function code in T0.
   __ lw(T0, FieldAddress(T2, Function::code_offset()));
-  __ bne(T0, T7, &function_compiled);
+  __ bne(T0, NULLREG, &function_compiled);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   // Preserve arguments descriptor array and read-only function object argument.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ sw(T2, Address(SP, 0 * kWordSize));
   __ CallRuntime(kCompileFunctionRuntimeEntry);
@@ skipping 22 matching lines @@
   // If no call method exists, throw a NoSuchMethodError.
   // T1: non-closure object.
   // S4: arguments descriptor array.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
 
   // Setup space on stack for result from error reporting.
   __ addiu(SP, SP, Immediate(2 * kWordSize));
-  __ sw(T7, Address(SP, 1 * kWordSize));  // Arguments descriptor and raw null.
+  // Arguments descriptor and raw null.
+  __ sw(NULLREG, Address(SP, 1 * kWordSize));
   __ sw(S4, Address(SP, 0 * kWordSize));
 
   // Load smi-tagged arguments array length, including the non-closure.
   __ lw(A1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   PushArgumentsArray(assembler);
 
   // Stack:
   // TOS + 0: Argument array.
   // TOS + 1: Arguments descriptor array.
   // TOS + 2: Place for result from the call.
@@ skipping 70 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));
 
+  // Load the null Object into NULLREG for easy comparisons.
+  __ LoadImmediate(NULLREG, reinterpret_cast<intptr_t>(Object::null()));
+
   // 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);
@@ skipping 89 matching lines @@
     __ addiu(V0, V0, Immediate(kHeapObjectTag));
 
     // Calculate the size tag.
     // V0: new object.
     // T1: number of context variables.
     // T2: object size.
     const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
     __ LoadImmediate(TMP1, RawObject::SizeTag::kMaxSizeTag);
     __ sltu(CMPRES, TMP1, T2);  // CMPRES = T2 > TMP1 ? 1 : 0.
     __ movn(T2, ZR, CMPRES);  // T2 = CMPRES != 0 ? 0 : T2.
-    __ sll(TMP1, T2, shift);  // TMP2 = T2 << shift.
+    __ sll(TMP1, T2, shift);  // TMP1 = T2 << shift.
     __ movz(T2, TMP1, CMPRES);  // T2 = CMPRES == 0 ? TMP1 : T2.
 
     // Get the class index and insert it into the tags.
     // T2: size and bit tags.
     __ LoadImmediate(TMP1, RawObject::ClassIdTag::encode(context_class.id()));
     __ or_(T2, T2, TMP1);
     __ sw(T2, FieldAddress(V0, Context::tags_offset()));
 
     // Setup up number of context variables field.
     // V0: new object.
     // T1: number of context variables as integer value (not object).
     __ 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()));
 
-    __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
-
     // Initialize the context variables.
     // V0: new object.
     // T1: number of context variables.
-    // T2: raw null.
     Label loop, loop_exit;
     __ blez(T1, &loop_exit);
     // Setup the parent field.
-    __ delay_slot()->sw(T2, FieldAddress(V0, Context::parent_offset()));
+    __ delay_slot()->sw(NULLREG, FieldAddress(V0, Context::parent_offset()));
     __ AddImmediate(T3, V0, Context::variable_offset(0) - kHeapObjectTag);
     __ sll(T1, T1, 2);
     __ Bind(&loop);
     __ addiu(T1, T1, Immediate(-kWordSize));
     __ addu(TMP1, T3, T1);
     __ bgtz(T1, &loop);
-    __ delay_slot()->sw(T2, Address(TMP1));
+    __ delay_slot()->sw(NULLREG, 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(NULLREG, 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.
   __ LeaveStubFrameAndReturn();
 }
 
@@ skipping 146 matching lines @@
     // T1: new object type arguments (if is_cls_parameterized).
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ LoadImmediate(T0, tags);
     __ sw(T0, Address(T2, Instance::tags_offset()));
 
     // Initialize the remaining words of the object.
-    __ LoadImmediate(T0, reinterpret_cast<intptr_t>(Object::null()));
-
-    // T0: raw null.
     // T2: new object start.
     // T3: next object start.
     // T1: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = sizeof(RawObject);
            current_offset < instance_size;
            current_offset += kWordSize) {
-        __ sw(T0, Address(T2, current_offset));
+        __ sw(NULLREG, 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 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));
+      __ delay_slot()->sw(NULLREG, 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));
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ lw(T1, Address(SP, 1 * kWordSize));
     __ lw(T0, Address(SP, 0 * kWordSize));
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame(true);  // Uses pool pointer to pass cls to runtime.
-  __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
   __ LoadObject(TMP1, cls);
 
   __ addiu(SP, SP, Immediate(-4 * kWordSize));
-  __ sw(T2, Address(SP, 3 * kWordSize));  // Space on stack for return value.
+  // Space on stack for return value.
+  __ sw(NULLREG, Address(SP, 3 * kWordSize));
   __ sw(TMP1, Address(SP, 2 * kWordSize));  // Class of object to be allocated.
 
   if (is_cls_parameterized) {
     // Push type arguments of object to be allocated and of instantiator.
     __ sw(T1, Address(SP, 1 * kWordSize));
     __ sw(T0, Address(SP, 0 * kWordSize));
   } else {
     // Push null type arguments and kNoInstantiator.
     __ LoadImmediate(T1, Smi::RawValue(StubCode::kNoInstantiator));
-    __ sw(T2, Address(SP, 1 * kWordSize));
+    __ sw(NULLREG, Address(SP, 1 * kWordSize));
     __ sw(T1, Address(SP, 0 * kWordSize));
   }
   __ 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 and return.
   __ LeaveStubFrameAndReturn(RA, true);
@@ skipping 83 matching lines @@
 
       // Set number of variables field to 1 (for captured receiver).
       __ LoadImmediate(T0, 1);
       __ sw(T0, Address(T4, Context::num_variables_offset()));
 
       // Set isolate field to isolate of current context.
       __ lw(T0, FieldAddress(CTX, Context::isolate_offset()));
       __ sw(T0, Address(T4, Context::isolate_offset()));
 
       // Set the parent to null.
-      __ LoadImmediate(T0, reinterpret_cast<intptr_t>(Object::null()));
-      __ sw(T0, Address(T4, Context::parent_offset()));
+      __ sw(NULLREG, Address(T4, Context::parent_offset()));
 
       // Initialize the context variable to the receiver.
       __ lw(T0, Address(FP, kReceiverFPOffset));
       __ sw(T0, Address(T4, Context::variable_offset(0)));
 
       // Set the newly allocated context in the newly allocated closure.
       __ AddImmediate(T1, T4, kHeapObjectTag);
       __ sw(T1, Address(T2, Closure::context_offset()));
     } else {
       __ sw(CTX, Address(T2, Closure::context_offset()));
@@ skipping 12 matching lines @@
     __ 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;
   }
   __ addiu(SP, SP, Immediate(-num_slots * kWordSize));
-  __ LoadImmediate(V0, reinterpret_cast<intptr_t>(Object::null()));
   __ LoadObject(TMP1, func);
   // Setup space on stack for return value.
-  __ sw(V0, Address(SP, (num_slots - 1) * kWordSize));
+  __ sw(NULLREG, Address(SP, (num_slots - 1) * kWordSize));
   __ sw(TMP1, Address(SP, (num_slots - 2) * kWordSize));
   if (is_implicit_static_closure) {
     __ CallRuntime(kAllocateImplicitStaticClosureRuntimeEntry);
     __ TraceSimMsg("AllocationStubForClosure return");
   } else {
     if (is_implicit_instance_closure) {
       __ lw(T1, Address(FP, kReceiverFPOffset));
       __ sw(T1, Address(SP, (num_slots - 3) * kWordSize));  // Receiver.
-      __ sw(V0, Address(SP, (num_slots - 4) * kWordSize));  // Push null.
+      __ sw(NULLREG, Address(SP, (num_slots - 4) * kWordSize));  // Push null.
     }
     if (has_type_arguments) {
       __ lw(V0, Address(FP, kTypeArgumentsFPOffset));
       // Push type arguments of closure.
       __ sw(V0, Address(SP, (num_slots - 3) * kWordSize));
     }
 
     if (is_implicit_instance_closure) {
       __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
       __ TraceSimMsg("AllocationStubForClosure return");
@@ skipping 177 matching lines @@
 
   // Compute address of arguments (first read number of arguments from
   // arguments descriptor array and then compute address on the stack).
   // T1: argument_count - 1 (smi).
   __ sll(T1, T1, 1);  // T1 is Smi.
   __ addu(T1, SP, T1);
   // T1: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
-  __ LoadImmediate(T3, reinterpret_cast<intptr_t>(Object::null()));
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
   int num_slots = num_args + 5;
   __ addiu(SP, SP, Immediate(-num_slots * kWordSize));
   __ sw(S5, Address(SP, (num_slots - 1) * kWordSize));
   __ sw(S4, Address(SP, (num_slots - 2) * kWordSize));
-  __ sw(T3, Address(SP, (num_slots - 3) * kWordSize));
+  __ sw(NULLREG, Address(SP, (num_slots - 3) * kWordSize));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ lw(TMP1, Address(T1, -i * kWordSize));
     __ sw(TMP1, Address(SP, (num_slots - i - 4) * kWordSize));
   }
   // Pass IC data object and arguments descriptor array.
   __ sw(S5, Address(SP, (num_slots - num_args - 4) * kWordSize));
   __ sw(S4, Address(SP, (num_slots - num_args - 5) * kWordSize));
 
   if (num_args == 1) {
     __ CallRuntime(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
     __ CallRuntime(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
   } else if (num_args == 3) {
     __ CallRuntime(kInlineCacheMissHandlerThreeArgsRuntimeEntry);
   } else {
     UNIMPLEMENTED();
   }
   __ TraceSimMsg("NArgsCheckInlineCacheStub return");
   // Pop returned code object into T3 (null if not found).
   // 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));
   __ LeaveStubFrame();
   Label call_target_function;
-  __ BranchNotEqual(T3, reinterpret_cast<intptr_t>(Object::null()),
-                    &call_target_function);
+  __ bne(T3, NULLREG, &call_target_function);
+
   // NoSuchMethod or closure.
   // Mark IC call that it may be a closure call that does not collect
   // type feedback.
-  __ LoadImmediate(TMP2, 1);
+  __ LoadImmediate(TMP1, 1);
   __ Branch(&StubCode::InstanceFunctionLookupLabel());
-  __ delay_slot()->sb(TMP2, FieldAddress(S5, ICData::is_closure_call_offset()));
+  __ delay_slot()->sb(TMP1, 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);
+  __ AddImmediateDetectOverflow(T4, T4, Smi::RawValue(1), T5, T6);
 
   __ 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()));
@@ skipping 79 matching lines @@
 }
 
 
 //  RA: return address (Dart code).
 //  S4: Arguments descriptor array.
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   __ TraceSimMsg("BreakpointStaticStub");
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
-  __ LoadImmediate(T0, reinterpret_cast<intptr_t>(Object::null()));
   // 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));
+  __ sw(NULLREG, 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();
 
   // 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();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
-  __ LeaveDartFrame();
-  __ Ret();
+  __ LeaveDartFrameAndReturn();
 }
 
 
 //  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();
@@ skipping 32 matching lines @@
 // A2: cache array.
 // Result in V0: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
   __ TraceSimMsg("SubtypeNTestCacheStub");
   ASSERT((1 <= n) && (n <= 3));
   if (n > 1) {
     // Get instance type arguments.
     __ LoadClass(T0, A0);
     // Compute instance type arguments into R4.
     Label has_no_type_arguments;
-    __ LoadImmediate(T1, reinterpret_cast<intptr_t>(Object::null()));
     __ lw(T2, FieldAddress(T0,
         Class::type_arguments_field_offset_in_words_offset()));
     __ BranchEqual(T2, Class::kNoTypeArguments, &has_no_type_arguments);
     __ sll(T2, T2, 2);
     __ addu(T2, A0, T2);  // T2 <- A0 + T2 * 4
     __ lw(T1, FieldAddress(T2, 0));
     __ Bind(&has_no_type_arguments);
   }
   __ LoadClassId(T0, A0);
   // A0: instance.
   // A1: instantiator type arguments or NULL.
   // A2: SubtypeTestCache.
   // T0: instance class id.
   // T1: instance type arguments (null if none), used only if n > 1.
   __ lw(T2, FieldAddress(A2, SubtypeTestCache::cache_offset()));
   __ AddImmediate(T2, Array::data_offset() - kHeapObjectTag);
 
   Label loop, found, not_found, next_iteration;
   // T0: instance class id.
   // T1: instance type arguments.
   // T2: Entry start.
   __ SmiTag(T0);
   __ Bind(&loop);
   __ lw(T3, Address(T2, kWordSize * SubtypeTestCache::kInstanceClassId));
-  __ BranchEqual(T3, reinterpret_cast<intptr_t>(Object::null()), &not_found);
+  __ beq(T3, NULLREG, &not_found);
 
   if (n == 1) {
     __ beq(T3, T0, &found);
   } else {
     __ bne(T3, T0, &next_iteration);
     __ lw(T3,
           Address(T2, kWordSize * SubtypeTestCache::kInstanceTypeArguments));
     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);
   __ b(&loop);
   __ delay_slot()->addiu(T2, T2,
       Immediate(kWordSize * SubtypeTestCache::kTestEntryLength));
   // Fall through to not found.
   __ Bind(&not_found);
-  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));
+  __ delay_slot()->mov(V0, NULLREG);
 
   __ 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 105 matching lines @@
   }
 
   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);
+  __ AddImmediateDetectOverflow(T1, T1, Smi::RawValue(1), CMPRES, T6);
   __ 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());
+  __ LoadObject(T4, Bool::True());
+  __ LoadObject(T5, Bool::False());
   __ subu(CMPRES, A0, A1);
-  __ movz(V0, TMP1, CMPRES);
-  __ movn(V0, TMP2, CMPRES);
+  __ movz(V0, T4, CMPRES);
+  __ movn(V0, T5, CMPRES);
   __ LeaveStubFrameAndReturn();
 
   __ 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);
@@ skipping 19 matching lines @@
 
 // Calls to the runtime to optimize the given function.
 // T0: function to be reoptimized.
 // S4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("OptimizeFunctionStub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(S4, Address(SP, 2 * kWordSize));
   // Setup space on stack for return value.
-  __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
-  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ sw(NULLREG, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ 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);
   __ LeaveStubFrameAndReturn(T0);
@@ skipping 11 matching lines @@
 // checks for boxed numbers.
 // RA: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Return: CMPRES 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.
 void StubCode::GenerateIdenticalWithNumberCheckStub(Assembler* assembler) {
   __ TraceSimMsg("IdenticalWithNumberCheckStub");
   const Register ret = CMPRES;
-  const Register temp1 = TMP1;
-  const Register temp2 = TMP2;
+  const Register temp1 = T2;
+  const Register temp2 = T3;
   const Register left = T1;
   const Register right = T0;
   // Preserve left, right.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(T1, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   // TOS + 3: left argument.
   // TOS + 2: right argument.
   // TOS + 1: saved left
   // TOS + 0: saved right
@@ skipping 65 matching lines @@
   __ 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