Remove remaining uses of null's absolute address from non-IA32.

runtime/vm/flow_graph_compiler_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"  // Needed here to get TARGET_ARCH_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 209 matching lines @@
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("CallSubtypeTestStub");
   ASSERT(instance_reg == A0);
   ASSERT(temp_reg == kNoRegister);  // Unused on MIPS.
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(zone(), SubtypeTestCache::New());
   __ LoadUniqueObject(A2, type_test_cache);
   if (test_kind == kTestTypeOneArg) {
     ASSERT(type_arguments_reg == kNoRegister);
-    __ LoadImmediate(A1, reinterpret_cast<int32_t>(Object::null()));
+    __ LoadObject(A1, Object::null_object());
     __ BranchLink(*StubCode::Subtype1TestCache_entry());
   } else if (test_kind == kTestTypeTwoArgs) {
     ASSERT(type_arguments_reg == kNoRegister);
-    __ LoadImmediate(A1, reinterpret_cast<int32_t>(Object::null()));
+    __ LoadObject(A1, Object::null_object());
     __ BranchLink(*StubCode::Subtype2TestCache_entry());
   } else if (test_kind == kTestTypeThreeArgs) {
     ASSERT(type_arguments_reg == A1);
     __ BranchLink(*StubCode::Subtype3TestCache_entry());
   } else {
     UNREACHABLE();
   }
   // Result is in V0: null -> not found, otherwise Bool::True or Bool::False.
   GenerateBoolToJump(V0, is_instance_lbl, is_not_instance_lbl);
   return type_test_cache.raw();
@@ skipping 193 matching lines @@
     Label* is_not_instance_lbl) {
   __ Comment("UninstantiatedTypeTest");
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
   if (type.IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(type);
     // Load instantiator (or null) and instantiator type arguments on stack.
     __ lw(A1, Address(SP, 0));  // Get instantiator type arguments.
     // A1: instantiator type arguments.
     // Check if type arguments are null, i.e. equivalent to vector of dynamic.
-    __ LoadImmediate(T7, reinterpret_cast<int32_t>(Object::null()));
+    __ LoadObject(T7, Object::null_object());
     __ beq(A1, T7, is_instance_lbl);
     __ lw(T2,
         FieldAddress(A1, TypeArguments::type_at_offset(type_param.index())));
     // R2: concrete type of type.
     // Check if type argument is dynamic.
     __ BranchEqual(T2,
         Type::ZoneHandle(zone(), Type::DynamicType()), is_instance_lbl);
     __ BranchEqual(T2,
         Type::ZoneHandle(zone(), Type::ObjectType()), is_instance_lbl);
 
@@ skipping 488 matching lines @@
   __ sll(T2, T2, 1);  // T2 is a Smi.
 
   __ Comment("Null arguments loop");
   Label null_args_loop, null_args_loop_exit;
   __ blez(T2, &null_args_loop_exit);
   __ delay_slot()->addiu(T1, FP,
                          Immediate((kParamEndSlotFromFp + 1) * kWordSize));
   __ Bind(&null_args_loop);
   __ addiu(T2, T2, Immediate(-kWordSize));
   __ addu(T3, T1, T2);
-  __ LoadImmediate(T5, reinterpret_cast<int32_t>(Object::null()));
+  __ LoadObject(T5, Object::null_object());
   __ bgtz(T2, &null_args_loop);
   __ delay_slot()->sw(T5, Address(T3));
   __ Bind(&null_args_loop_exit);
 }
 
 
 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   // RA: return address.
   // SP: receiver.
   // Sequence node has one return node, its input is load field node.
   __ Comment("Inlined Getter");
   __ lw(V0, Address(SP, 0 * kWordSize));
   __ lw(V0, Address(V0, offset - kHeapObjectTag));
   __ Ret();
 }
 
 
 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   // RA: return address.
   // SP+1: receiver.
   // SP+0: value.
   // Sequence node has one store node and one return NULL node.
   __ Comment("Inlined Setter");
   __ lw(T0, Address(SP, 1 * kWordSize));  // Receiver.
   __ lw(T1, Address(SP, 0 * kWordSize));  // Value.
   __ StoreIntoObjectOffset(T0, offset, T1);
-  __ LoadImmediate(V0, reinterpret_cast<int32_t>(Object::null()));
+  __ LoadObject(V0, Object::null_object());
   __ Ret();
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   if (CanOptimizeFunction() &&
       function.IsOptimizable() &&
       (!is_optimizing() || may_reoptimize())) {
     const Register function_reg = T0;
@@ skipping 119 matching lines @@
 
   // In unoptimized code, initialize (non-argument) stack allocated slots to
   // null.
   if (!is_optimizing()) {
     ASSERT(num_locals > 0);  // There is always at least context_var.
     __ Comment("Initialize spill slots");
     const intptr_t slot_base = parsed_function().first_stack_local_index();
     const intptr_t context_index =
         parsed_function().current_context_var()->index();
     if (num_locals > 1) {
-      __ LoadImmediate(V0, reinterpret_cast<int32_t>(Object::null()));
+      __ LoadObject(V0, Object::null_object());
     }
     for (intptr_t i = 0; i < num_locals; ++i) {
       // Subtract index i (locals lie at lower addresses than FP).
       if (((slot_base - i) == context_index)) {
         if (function.IsClosureFunction()) {
           __ sw(CTX, Address(FP, (slot_base - i) * kWordSize));
         } else {
           const Context& empty_context = Context::ZoneHandle(
               zone(), isolate()->object_store()->empty_context());
           __ LoadObject(V1, empty_context);
@@ skipping 724 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS