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

runtime/vm/intermediate_language_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
+DECLARE_FLAG(bool, allow_absolute_addresses);
 DECLARE_FLAG(bool, emit_edge_counters);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, use_osr);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register R0.
 LocationSummary* Instruction::MakeCallSummary(Zone* zone) {
   LocationSummary* result = new(zone) LocationSummary(
       zone, 0, 0, LocationSummary::kCall);
   result->set_out(0, Location::RegisterLocation(R0));
@@ skipping 1659 matching lines @@
         __ b(fail, EQ);
         __ LoadClassId(value_cid_reg, value_reg);
         __ CompareImmediate(value_cid_reg, field_cid);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ b(&ok, EQ);
         if (field_cid != kSmiCid) {
           __ CompareImmediate(value_cid_reg, kNullCid);
         } else {
-          __ CompareImmediate(value_reg,
-                              reinterpret_cast<intptr_t>(Object::null()));
+          __ CompareObject(value_reg, Object::null_object());
         }
       }
       __ b(fail, NE);
     } else {
       // Both value's and field's class id is known.
       ASSERT((value_cid != field_cid) && (value_cid != nullability));
       __ b(fail);
     }
   }
   __ Bind(&ok);
@@ skipping 309 matching lines @@
 
 static void EnsureMutableBox(FlowGraphCompiler* compiler,
                              StoreInstanceFieldInstr* instruction,
                              Register box_reg,
                              const Class& cls,
                              Register instance_reg,
                              intptr_t offset,
                              Register temp) {
   Label done;
   __ ldr(box_reg, FieldAddress(instance_reg, offset));
-  __ CompareImmediate(box_reg,
-                      reinterpret_cast<intptr_t>(Object::null()));
+  __ CompareObject(box_reg, Object::null_object());
   __ b(&done, NE);
 
   BoxAllocationSlowPath::Allocate(
       compiler, instruction, cls, box_reg, temp);
 
   __ MoveRegister(temp, box_reg);
   __ StoreIntoObjectOffset(instance_reg, offset, temp);
   __ Bind(&done);
 }
 
@@ skipping 296 matching lines @@
                               kLengthReg);
 
   // Initialize all array elements to raw_null.
   // R0: new object start as a tagged pointer.
   // R3: new object end address.
   // R9: iterator which initially points to the start of the variable
   // data area to be initialized.
   // R6: null
   if (num_elements > 0) {
     const intptr_t array_size = instance_size - sizeof(RawArray);
-    __ LoadImmediate(R6, reinterpret_cast<intptr_t>(Object::null()));
+    __ LoadObject(R6, Object::null_object());
     if (num_elements >= 2) {
       __ mov(R7, Operand(R6));
     } else {
 #if defined(DEBUG)
       // Clobber R7 with an invalid pointer.
       __ LoadImmediate(R7, 0x1);
 #endif  // DEBUG
     }
     __ AddImmediate(R9, R0, sizeof(RawArray) - kHeapObjectTag);
     if (array_size < (kInlineArraySize * kWordSize)) {
@@ skipping 248 matching lines @@
   // 'instantiator_reg' is the instantiator TypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
+    __ LoadObject(IP, Object::null_object());
     __ cmp(instantiator_reg, Operand(IP));
     __ b(&type_arguments_instantiated, EQ);
   }
 
   __ LoadObject(R2, type_arguments());
   __ ldr(R2, FieldAddress(R2, TypeArguments::instantiations_offset()));
   __ AddImmediate(R2, Array::data_offset() - kHeapObjectTag);
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, found, slow_case;
@@ skipping 244 matching lines @@
  public:
   explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
       uword flags_address = Isolate::Current()->stack_overflow_flags_address();
       const Register value = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
+      ASSERT(FLAG_allow_absolute_addresses);
       __ LoadImmediate(IP, flags_address);
       __ LoadImmediate(value, Isolate::kOsrRequest);
       __ str(value, Address(IP));
     }
     __ Comment("CheckStackOverflowSlowPath");
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(instruction_->locs());
     // pending_deoptimization_env_ is needed to generate a runtime call that
     // may throw an exception.
     ASSERT(compiler->pending_deoptimization_env_ == NULL);
@@ skipping 24 matching lines @@
  private:
   CheckStackOverflowInstr* instruction_;
   Label osr_entry_label_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
-  if (compiler->is_optimizing()) {
+  if (compiler->is_optimizing() && FLAG_allow_absolute_addresses) {
     __ LoadImmediate(IP, Isolate::Current()->stack_limit_address());
     __ ldr(IP, Address(IP));
   } else {
     __ LoadIsolate(IP);
     __ ldr(IP, Address(IP, Isolate::stack_limit_offset()));
   }
   __ cmp(SP, Operand(IP));
   __ b(slow_path->entry_label(), LS);
   if (compiler->CanOSRFunction() && in_loop()) {
     const Register temp = locs()->temp(0).reg();
@@ skipping 806 matching lines @@
     EmitSmiConversion(compiler);
   } else {
     const Register box = locs()->in(0).reg();
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(GetDeoptId(),
                                           ICData::kDeoptCheckClass);
     Label is_smi;
 
     if ((value()->Type()->ToNullableCid() == box_cid) &&
         value()->Type()->is_nullable()) {
-      __ CompareImmediate(box, reinterpret_cast<intptr_t>(Object::null()));
+      __ CompareObject(box, Object::null_object());
       __ b(deopt, EQ);
     } else {
       __ tst(box, Operand(kSmiTagMask));
       __ b(CanConvertSmi() ? &is_smi : deopt, EQ);
       __ CompareClassId(box, box_cid, temp);
       __ b(deopt, NE);
     }
 
     EmitLoadFromBox(compiler);
 
@@ skipping 2138 matching lines @@
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         ICData::kDeoptCheckClass,
                                         licm_hoisted_ ? ICData::kHoisted : 0);
   if (IsNullCheck()) {
-    __ CompareImmediate(locs()->in(0).reg(),
-                        reinterpret_cast<intptr_t>(Object::null()));
+    __ CompareObject(locs()->in(0).reg(), Object::null_object());
     ASSERT(DeoptIfNull() || DeoptIfNotNull());
     Condition cond = DeoptIfNull() ? EQ : NE;
     __ b(deopt, cond);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   const Register value = locs()->in(0).reg();
   const Register temp = locs()->temp(0).reg();
@@ skipping 932 matching lines @@
                                 1,
                                 locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM