Begins removing intptr_t from raw object fields.

runtime/vm/intermediate_language_x64.cc

Index: runtime/vm/intermediate_language_x64.cc
===================================================================
--- runtime/vm/intermediate_language_x64.cc	(revision 37281)
+++ runtime/vm/intermediate_language_x64.cc	(working copy)
@@ -1376,13 +1376,13 @@
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
 
-      __ cmpq(value_cid_reg, field_cid_operand);
+      __ cmpl(value_cid_reg, field_cid_operand);
       __ j(EQUAL, &ok);
-      __ cmpq(value_cid_reg, field_nullability_operand);
+      __ cmpl(value_cid_reg, field_nullability_operand);
     } else if (value_cid == kNullCid) {
-      __ CompareImmediate(field_nullability_operand, Immediate(value_cid), PP);
+      __ cmpl(field_nullability_operand, Immediate(value_cid));
     } else {
-      __ CompareImmediate(field_cid_operand, Immediate(value_cid), PP);
+      __ cmpl(field_cid_operand, Immediate(value_cid));
     }
     __ j(EQUAL, &ok);
 
@@ -1393,16 +1393,16 @@
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
-      __ CompareImmediate(field_cid_operand, Immediate(kIllegalCid), PP);
+      __ cmpl(field_cid_operand, Immediate(kIllegalCid));
       __ j(NOT_EQUAL, fail);
 
       if (value_cid == kDynamicCid) {
-        __ movq(field_cid_operand, value_cid_reg);
-        __ movq(field_nullability_operand, value_cid_reg);
+        __ movl(field_cid_operand, value_cid_reg);
+        __ movl(field_nullability_operand, value_cid_reg);
       } else {
         ASSERT(field_reg != kNoRegister);
-        __ LoadImmediate(field_cid_operand, Immediate(value_cid), PP);
-        __ LoadImmediate(field_nullability_operand, Immediate(value_cid), PP);
+        __ movl(field_cid_operand, Immediate(value_cid));
+        __ movl(field_nullability_operand, Immediate(value_cid));
       }
 
       if (deopt == NULL) {
@@ -1415,8 +1415,8 @@
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
-      __ CompareImmediate(FieldAddress(field_reg, Field::guarded_cid_offset()),
-                          Immediate(kDynamicCid), PP);
+      __ cmpl(FieldAddress(field_reg, Field::guarded_cid_offset()),
+              Immediate(kDynamicCid));
       __ j(EQUAL, &ok);
 
       __ pushq(field_reg);
@@ -1685,7 +1685,7 @@
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
 
-    __ cmpq(FieldAddress(temp, Field::is_nullable_offset()),
+    __ cmpl(FieldAddress(temp, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &store_pointer);
 
@@ -1693,11 +1693,11 @@
     __ testq(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ j(ZERO, &store_pointer);
 
-    __ cmpq(FieldAddress(temp, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
             Immediate(kDoubleCid));
     __ j(EQUAL, &store_double);
 
-    __ cmpq(FieldAddress(temp, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
             Immediate(kFloat32x4Cid));
     __ j(EQUAL, &store_float32x4);
 
@@ -2187,19 +2187,19 @@
 
     __ LoadObject(result, Field::ZoneHandle(field()->raw()), PP);
 
-    __ cmpq(FieldAddress(result, Field::is_nullable_offset()),
+    __ cmpl(FieldAddress(result, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &load_pointer);
 
-    __ cmpq(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kDoubleCid));
     __ j(EQUAL, &load_double);
 
-    __ cmpq(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kFloat32x4Cid));
     __ j(EQUAL, &load_float32x4);
 
-    __ cmpq(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kFloat64x2Cid));
     __ j(EQUAL, &load_float64x2);
 
@@ -2542,10 +2542,10 @@
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function(), PP);
-    intptr_t threshold =
+    int32_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
-    __ CompareImmediate(FieldAddress(temp, Function::usage_counter_offset()),
-                        Immediate(threshold), PP);
+    __ cmpl(FieldAddress(temp, Function::usage_counter_offset()),
+            Immediate(threshold));
     __ j(GREATER_EQUAL, slow_path->osr_entry_label());
   }
   if (compiler->ForceSlowPathForStackOverflow()) {