Begins removing intptr_t from raw object fields.

runtime/vm/intermediate_language_arm64.cc

Index: runtime/vm/intermediate_language_arm64.cc
===================================================================
--- runtime/vm/intermediate_language_arm64.cc	(revision 37230)
+++ runtime/vm/intermediate_language_arm64.cc	(working copy)
@@ -1416,24 +1416,25 @@
   if (emit_full_guard) {
     __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
 
-    FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());
+    FieldAddress field_cid_operand(
+        field_reg, Field::guarded_cid_offset(), kWord);
     FieldAddress field_nullability_operand(
-        field_reg, Field::is_nullable_offset());
+        field_reg, Field::is_nullable_offset(), kWord);
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
       Label skip_length_check;
-      __ ldr(TMP, field_cid_operand);
+      __ ldr(TMP, field_cid_operand, kWord);
       __ CompareRegisters(value_cid_reg, TMP);
       __ b(&ok, EQ);
-      __ ldr(TMP, field_nullability_operand);
+      __ ldr(TMP, field_nullability_operand, kWord);
       __ CompareRegisters(value_cid_reg, TMP);
     } else if (value_cid == kNullCid) {
-      __ ldr(value_cid_reg, field_nullability_operand);
+      __ ldr(value_cid_reg, field_nullability_operand, kWord);
       __ CompareImmediate(value_cid_reg, value_cid, PP);
     } else {
       Label skip_length_check;
-      __ ldr(value_cid_reg, field_cid_operand);
+      __ ldr(value_cid_reg, field_cid_operand, kWord);
       __ CompareImmediate(value_cid_reg, value_cid, PP);
     }
     __ b(&ok, EQ);
@@ -1447,17 +1448,17 @@
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
-      __ ldr(TMP, field_cid_operand);
+      __ ldr(TMP, field_cid_operand, kWord);
       __ CompareImmediate(TMP, kIllegalCid, PP);
       __ b(fail, NE);
 
       if (value_cid == kDynamicCid) {
-        __ str(value_cid_reg, field_cid_operand);
-        __ str(value_cid_reg, field_nullability_operand);
+        __ str(value_cid_reg, field_cid_operand, kWord);
+        __ str(value_cid_reg, field_nullability_operand, kWord);
       } else {
         __ LoadImmediate(TMP, value_cid, PP);
-        __ str(TMP, field_cid_operand);
-        __ str(TMP, field_nullability_operand);
+        __ str(TMP, field_cid_operand, kWord);
+        __ str(TMP, field_nullability_operand, kWord);
       }
 
       if (deopt == NULL) {
@@ -1470,7 +1471,8 @@
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
-      __ LoadFieldFromOffset(TMP, field_reg, Field::guarded_cid_offset(), PP);
+      __ LoadFieldFromOffset(
+          TMP, field_reg, Field::guarded_cid_offset(), PP, kWord);
       __ CompareImmediate(TMP, kDynamicCid, PP);
       __ b(&ok, EQ);
 
@@ -1737,7 +1739,7 @@
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP);
+    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP, kWord);
     __ CompareImmediate(temp2, kNullCid, PP);
     __ b(&store_pointer, EQ);
 
@@ -1747,15 +1749,15 @@
     __ tsti(temp2, 1 << Field::kUnboxingCandidateBit);
     __ b(&store_pointer, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord);
     __ CompareImmediate(temp2, kDoubleCid, PP);
     __ b(&store_double, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord);
     __ CompareImmediate(temp2, kFloat32x4Cid, PP);
     __ b(&store_float32x4, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord);
     __ CompareImmediate(temp2, kFloat64x2Cid, PP);
     __ b(&store_float64x2, EQ);
 
@@ -2124,23 +2126,24 @@
 
     __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()), PP);
 
-    FieldAddress field_cid_operand(result_reg, Field::guarded_cid_offset());
-    FieldAddress field_nullability_operand(result_reg,
-                                           Field::is_nullable_offset());
+    FieldAddress field_cid_operand(
+        result_reg, Field::guarded_cid_offset(), kWord);
+    FieldAddress field_nullability_operand(
+        result_reg, Field::is_nullable_offset(), kWord);
 
-    __ ldr(temp, field_nullability_operand);
+    __ ldr(temp, field_nullability_operand, kWord);
     __ CompareImmediate(temp, kNullCid, PP);
     __ b(&load_pointer, EQ);
 
-    __ ldr(temp, field_cid_operand);
+    __ ldr(temp, field_cid_operand, kWord);
     __ CompareImmediate(temp, kDoubleCid, PP);
     __ b(&load_double, EQ);
 
-    __ ldr(temp, field_cid_operand);
+    __ ldr(temp, field_cid_operand, kWord);
     __ CompareImmediate(temp, kFloat32x4Cid, PP);
     __ b(&load_float32x4, EQ);
 
-    __ ldr(temp, field_cid_operand);
+    __ ldr(temp, field_cid_operand, kWord);
     __ CompareImmediate(temp, kFloat64x2Cid, PP);
     __ b(&load_float64x2, EQ);
 
@@ -2475,7 +2478,8 @@
     __ LoadObject(temp, compiler->parsed_function().function(), PP);
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
-    __ LoadFieldFromOffset(temp, temp, Function::usage_counter_offset(), PP);
+    __ LoadFieldFromOffset(
+        temp, temp, Function::usage_counter_offset(), PP, kWord);
     __ CompareImmediate(temp, threshold, PP);
     __ b(slow_path->osr_entry_label(), GE);
   }