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

runtime/vm/assembler_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/runtime_entry.h"
 #include "vm/simulator.h"
@@ skipping 63 matching lines @@
       addu(rd, rd, PP);
       lw(rd, Address(rd, offset_low));
     } else {
       lw(rd, Address(PP, offset_low));
     }
   }
 }
 
 
 void Assembler::AdduDetectOverflow(Register rd, Register rs, Register rt,
-                                   Register ro) {
+                                   Register ro, Register scratch) {
   ASSERT(rd != ro);
   ASSERT(rd != TMP1);
   ASSERT(ro != TMP1);
   ASSERT(ro != rs);
   ASSERT(ro != rt);
 
   if ((rs == rt) && (rd == rs)) {
-    ASSERT(rd != TMP2);
-    ASSERT(ro != TMP2);
-    ASSERT(rs != TMP2);
-    ASSERT(rt != TMP2);
-    mov(TMP2, rt);
-    rt = TMP2;
+    ASSERT(scratch != kNoRegister);
+    ASSERT(scratch != TMP1);
+    ASSERT(rd != scratch);
+    ASSERT(ro != scratch);
+    ASSERT(rs != scratch);
+    ASSERT(rt != scratch);
+    mov(scratch, rt);
+    rt = scratch;
   }
 
   if (rd == rs) {
     mov(TMP1, rs);  // Preserve rs.
     addu(rd, rs, rt);  // rs is overwritten.
     xor_(TMP1, rd, TMP1);  // Original rs.
     xor_(ro, rd, rt);
     and_(ro, ro, TMP1);
   } else if (rd == rt) {
     mov(TMP1, rt);  // Preserve rt.
@@ skipping 121 matching lines @@
 
 // Preserves object and value registers.
 void Assembler::StoreIntoObjectFilter(Register object,
                                       Register value,
                                       Label* no_update) {
   // For the value we are only interested in the new/old bit and the tag bit.
   // And the new bit with the tag bit. The resulting bit will be 0 for a Smi.
   sll(TMP1, value, kObjectAlignmentLog2 - 1);
   and_(TMP1, value, TMP1);
   // And the result with the negated space bit of the object.
-  nor(TMP2, ZR, object);
-  and_(TMP1, TMP1, TMP2);
+  nor(CMPRES, ZR, object);
+  and_(TMP1, TMP1, CMPRES);
   andi(TMP1, TMP1, Immediate(kNewObjectAlignmentOffset));
   beq(TMP1, ZR, no_update);
 }
 
 
 void Assembler::StoreIntoObject(Register object,
                                 const Address& dest,
                                 Register value,
                                 bool can_value_be_smi) {
   ASSERT(object != value);
@@ skipping 180 matching lines @@
   addiu(FP, SP, Immediate(kWordSize));
 
   // Load the pool pointer.
   lw(PP, Address(T0, -object_pool_pc_dist));
 
   // Reserve space for locals.
   AddImmediate(SP, -frame_size);
 }
 
 
-void Assembler::LeaveDartFrame() {
+void Assembler::LeaveDartFrameAndReturn() {
   addiu(SP, FP, Immediate(-kWordSize));
 
   lw(RA, Address(SP, 2 * kWordSize));
   lw(FP, Address(SP, 1 * kWordSize));
   lw(PP, Address(SP, 0 * kWordSize));
 
-  // Adjust SP for PC pushed in EnterDartFrame.
-  addiu(SP, SP, Immediate(4 * kWordSize));
+  // Adjust SP for PC pushed in EnterDartFrame, and return.
+  Ret();
+  delay_slot()->addiu(SP, SP, Immediate(4 * kWordSize));
 }
 
 
 void Assembler::ReserveAlignedFrameSpace(intptr_t frame_space) {
   // Reserve space for arguments and align frame before entering
   // the C++ world.
   AddImmediate(SP, -frame_space);
   if (OS::ActivationFrameAlignment() > 0) {
     LoadImmediate(TMP1, ~(OS::ActivationFrameAlignment() - 1));
     and_(SP, SP, TMP1);
@@ skipping 115 matching lines @@
     Emit(reinterpret_cast<int32_t>(message));
     Bind(&msg);
     break_(Instr::kMsgMessageCode);
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS