Expand the class id to 32 bits and size field to 16 bits on 64-bit platforms.

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 1420 matching lines @@
   for (intptr_t i = 0; i < num_temps; i++) {
     summary->set_temp(i, Location::RequiresRegister());
   }
 
 
   return summary;
 }
 
 
 void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(sizeof(classid_t) == 4);

[siva, 2015/06/12 22:08:11]

Ditto here.

   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t field_cid = field().guarded_cid();
   const intptr_t nullability = field().is_nullable() ? kNullCid : kIllegalCid;
 
   if (field_cid == kDynamicCid) {
     ASSERT(!compiler->is_optimizing());
     return;  // Nothing to emit.
   }
 
   const bool emit_full_guard =
@@ skipping 22 matching lines @@
   if (emit_full_guard) {
     __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
 
     FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());
     FieldAddress field_nullability_operand(
         field_reg, Field::is_nullable_offset());
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
 
-      __ cmpw(value_cid_reg, field_cid_operand);
+      __ cmpl(value_cid_reg, field_cid_operand);
       __ j(EQUAL, &ok);
-      __ cmpw(value_cid_reg, field_nullability_operand);
+      __ cmpl(value_cid_reg, field_nullability_operand);
     } else if (value_cid == kNullCid) {
-      __ cmpw(field_nullability_operand, Immediate(value_cid));
+      __ cmpl(field_nullability_operand, Immediate(value_cid));
     } else {
-      __ cmpw(field_cid_operand, Immediate(value_cid));
+      __ cmpl(field_cid_operand, Immediate(value_cid));
     }
     __ j(EQUAL, &ok);
 
     // Check if the tracked state of the guarded field can be initialized
     // inline. If the field needs length check we fall through to runtime
     // which is responsible for computing offset of the length field
     // based on the class id.
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
-      __ cmpw(field_cid_operand, Immediate(kIllegalCid));
+      __ cmpl(field_cid_operand, Immediate(kIllegalCid));
       __ j(NOT_EQUAL, fail);
 
       if (value_cid == kDynamicCid) {
-        __ movw(field_cid_operand, value_cid_reg);
-        __ movw(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);
-        __ movw(field_cid_operand, Immediate(value_cid));
-        __ movw(field_nullability_operand, Immediate(value_cid));
+        __ movl(field_cid_operand, Immediate(value_cid));
+        __ movl(field_nullability_operand, Immediate(value_cid));
       }
 
       if (deopt == NULL) {
         ASSERT(!compiler->is_optimizing());
         __ jmp(&ok);
       }
     }
 
     if (deopt == NULL) {
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
-      __ cmpw(FieldAddress(field_reg, Field::guarded_cid_offset()),
+      __ cmpl(FieldAddress(field_reg, Field::guarded_cid_offset()),
               Immediate(kDynamicCid));
       __ j(EQUAL, &ok);
 
       __ pushq(field_reg);
       __ pushq(value_reg);
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
@@ skipping 230 matching lines @@
   __ movq(temp, box_reg);
   __ StoreIntoObject(instance_reg,
                      FieldAddress(instance_reg, offset),
                      temp);
 
   __ Bind(&done);
 }
 
 
 void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(sizeof(classid_t) == 4);
   Label skip_store;
 
   Register instance_reg = locs()->in(0).reg();
 
   if (IsUnboxedStore() && compiler->is_optimizing()) {
     XmmRegister value = locs()->in(1).fpu_reg();
     Register temp = locs()->temp(0).reg();
     Register temp2 = locs()->temp(1).reg();
     const intptr_t cid = field().UnboxedFieldCid();
 
@@ skipping 52 matching lines @@
       locs()->live_registers()->Add(locs()->in(1), kTagged);
     }
 
     Label store_pointer;
     Label store_double;
     Label store_float32x4;
     Label store_float64x2;
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
 
-    __ cmpw(FieldAddress(temp, Field::is_nullable_offset()),
+    __ cmpl(FieldAddress(temp, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &store_pointer);
 
     __ movzxb(temp2, FieldAddress(temp, Field::kind_bits_offset()));
     __ testq(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ j(ZERO, &store_pointer);
 
-    __ cmpw(FieldAddress(temp, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
             Immediate(kDoubleCid));
     __ j(EQUAL, &store_double);
 
-    __ cmpw(FieldAddress(temp, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
             Immediate(kFloat32x4Cid));
     __ j(EQUAL, &store_float32x4);
 
-    __ cmpw(FieldAddress(temp, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()),
             Immediate(kFloat64x2Cid));
     __ j(EQUAL, &store_float64x2);
 
     // Fall through.
     __ jmp(&store_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
       locs()->live_registers()->Add(locs()->in(1));
     }
@@ skipping 285 matching lines @@
     locs->set_temp(0, opt ? Location::RequiresFpuRegister()
                           : Location::FpuRegisterLocation(XMM1));
     locs->set_temp(1, Location::RequiresRegister());
   }
   locs->set_out(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(sizeof(classid_t) == 4);
   Register instance_reg = locs()->in(0).reg();
   if (IsUnboxedLoad() && compiler->is_optimizing()) {
     XmmRegister result = locs()->out(0).fpu_reg();
     Register temp = locs()->temp(0).reg();
     __ movq(temp, FieldAddress(instance_reg, offset_in_bytes()));
     intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleLoadFieldInstr");
         __ movsd(result, FieldAddress(temp, Double::value_offset()));
@@ skipping 18 matching lines @@
     Register temp = locs()->temp(1).reg();
     XmmRegister value = locs()->temp(0).fpu_reg();
 
     Label load_pointer;
     Label load_double;
     Label load_float32x4;
     Label load_float64x2;
 
     __ LoadObject(result, Field::ZoneHandle(field()->raw()), PP);
 
-    __ cmpw(FieldAddress(result, Field::is_nullable_offset()),
+    __ cmpl(FieldAddress(result, Field::is_nullable_offset()),
             Immediate(kNullCid));
     __ j(EQUAL, &load_pointer);
 
-    __ cmpw(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kDoubleCid));
     __ j(EQUAL, &load_double);
 
-    __ cmpw(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kFloat32x4Cid));
     __ j(EQUAL, &load_float32x4);
 
-    __ cmpw(FieldAddress(result, Field::guarded_cid_offset()),
+    __ cmpl(FieldAddress(result, Field::guarded_cid_offset()),
             Immediate(kFloat64x2Cid));
     __ j(EQUAL, &load_float64x2);
 
     // Fall through.
     __ jmp(&load_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
     }
 
@@ skipping 4230 matching lines @@
   __ Drop(1);
   __ popq(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64