More compact string representation on 64 bit.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 1530 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) == kInt32Size);
+  ASSERT(sizeof(classid_t) == kInt16Size);
   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) {
     if (Compiler::IsBackgroundCompilation()) {
       // Field state changed while compiling.
       Compiler::AbortBackgroundCompilation(
           deopt_id(),
           "GuardFieldClassInstr: field state changed while compiling");
@@ skipping 25 matching lines @@
       compiler->is_optimizing()
           ? compiler->AddDeoptStub(deopt_id(), ICData::kDeoptGuardField)
           : NULL;
 
   Label* fail = (deopt != NULL) ? deopt : &fail_label;
 
   if (emit_full_guard) {
     __ LoadObject(field_reg, Field::ZoneHandle(field().Original()));
 
     FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset(),
-                                   kUnsignedWord);
+                                   kUnsignedHalfword);
     FieldAddress field_nullability_operand(
-        field_reg, Field::is_nullable_offset(), kUnsignedWord);
+        field_reg, Field::is_nullable_offset(), kUnsignedHalfword);
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
       Label skip_length_check;
-      __ ldr(TMP, field_cid_operand, kUnsignedWord);
+      __ ldr(TMP, field_cid_operand, kUnsignedHalfword);
       __ CompareRegisters(value_cid_reg, TMP);
       __ b(&ok, EQ);
-      __ ldr(TMP, field_nullability_operand, kUnsignedWord);
+      __ ldr(TMP, field_nullability_operand, kUnsignedHalfword);
       __ CompareRegisters(value_cid_reg, TMP);
     } else if (value_cid == kNullCid) {
-      __ ldr(value_cid_reg, field_nullability_operand, kUnsignedWord);
+      __ ldr(value_cid_reg, field_nullability_operand, kUnsignedHalfword);
       __ CompareImmediate(value_cid_reg, value_cid);
     } else {
       Label skip_length_check;
-      __ ldr(value_cid_reg, field_cid_operand, kUnsignedWord);
+      __ ldr(value_cid_reg, field_cid_operand, kUnsignedHalfword);
       __ CompareImmediate(value_cid_reg, value_cid);
     }
     __ b(&ok, EQ);
 
     // 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.
     // Length guard will be emitted separately when needed via GuardFieldLength
     // instruction after GuardFieldClass.
     if (!field().needs_length_check()) {
       // Uninitialized field can be handled inline. Check if the
       // field is still unitialized.
-      __ ldr(TMP, field_cid_operand, kUnsignedWord);
+      __ ldr(TMP, field_cid_operand, kUnsignedHalfword);
       __ CompareImmediate(TMP, kIllegalCid);
       __ b(fail, NE);
 
       if (value_cid == kDynamicCid) {
-        __ str(value_cid_reg, field_cid_operand, kUnsignedWord);
-        __ str(value_cid_reg, field_nullability_operand, kUnsignedWord);
+        __ str(value_cid_reg, field_cid_operand, kUnsignedHalfword);
+        __ str(value_cid_reg, field_nullability_operand, kUnsignedHalfword);
       } else {
         __ LoadImmediate(TMP, value_cid);
-        __ str(TMP, field_cid_operand, kUnsignedWord);
-        __ str(TMP, field_nullability_operand, kUnsignedWord);
+        __ str(TMP, field_cid_operand, kUnsignedHalfword);
+        __ str(TMP, field_nullability_operand, kUnsignedHalfword);
       }
 
       if (deopt == NULL) {
         ASSERT(!compiler->is_optimizing());
         __ b(&ok);
       }
     }
 
     if (deopt == NULL) {
       ASSERT(!compiler->is_optimizing());
       __ Bind(fail);
 
       __ LoadFieldFromOffset(TMP, field_reg, Field::guarded_cid_offset(),
-                             kUnsignedWord);
+                             kUnsignedHalfword);
       __ CompareImmediate(TMP, kDynamicCid);
       __ b(&ok, EQ);
 
       __ Push(field_reg);
       __ Push(value_reg);
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
@@ skipping 218 matching lines @@
   } else {
     summary->set_in(1, ShouldEmitStoreBarrier()
                            ? Location::WritableRegister()
                            : Location::RegisterOrConstant(value()));
   }
   return summary;
 }
 
 
 void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ASSERT(sizeof(classid_t) == kInt32Size);
+  ASSERT(sizeof(classid_t) == kInt16Size);
   Label skip_store;
 
   const Register instance_reg = locs()->in(0).reg();
 
   if (IsUnboxedStore() && compiler->is_optimizing()) {
     const VRegister value = locs()->in(1).fpu_reg();
     const Register temp = locs()->temp(0).reg();
     const Register temp2 = locs()->temp(1).reg();
     const intptr_t cid = field().UnboxedFieldCid();
 
@@ skipping 51 matching lines @@
     }
 
     Label store_pointer;
     Label store_double;
     Label store_float32x4;
     Label store_float64x2;
 
     __ LoadObject(temp, Field::ZoneHandle(Z, field().Original()));
 
     __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(),
-                           kUnsignedWord);
+                           kUnsignedHalfword);
     __ CompareImmediate(temp2, kNullCid);
     __ b(&store_pointer, EQ);
 
     __ LoadFromOffset(temp2, temp, Field::kind_bits_offset() - kHeapObjectTag,
                       kUnsignedByte);
     __ tsti(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ b(&store_pointer, EQ);
 
     __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
-                           kUnsignedWord);
+                           kUnsignedHalfword);
     __ CompareImmediate(temp2, kDoubleCid);
     __ b(&store_double, EQ);
 
     __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
-                           kUnsignedWord);
+                           kUnsignedHalfword);
     __ CompareImmediate(temp2, kFloat32x4Cid);
     __ b(&store_float32x4, EQ);
 
     __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(),
-                           kUnsignedWord);
+                           kUnsignedHalfword);
     __ CompareImmediate(temp2, kFloat64x2Cid);
     __ b(&store_float64x2, EQ);
 
     // Fall through.
     __ b(&store_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
       locs()->live_registers()->Add(locs()->in(1));
     }
@@ skipping 243 matching lines @@
     locs->set_temp(0, Location::RequiresRegister());
   } else if (IsPotentialUnboxedLoad()) {
     locs->set_temp(0, Location::RequiresRegister());
   }
   locs->set_out(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ASSERT(sizeof(classid_t) == kInt32Size);
+  ASSERT(sizeof(classid_t) == kInt16Size);
   const Register instance_reg = locs()->in(0).reg();
   if (IsUnboxedLoad() && compiler->is_optimizing()) {
     const VRegister result = locs()->out(0).fpu_reg();
     const Register temp = locs()->temp(0).reg();
     __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
     const intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleLoadFieldInstr");
         __ LoadDFieldFromOffset(result, temp, Double::value_offset());
@@ skipping 16 matching lines @@
     const Register temp = locs()->temp(0).reg();
 
     Label load_pointer;
     Label load_double;
     Label load_float32x4;
     Label load_float64x2;
 
     __ LoadObject(result_reg, Field::ZoneHandle(field()->Original()));
 
     FieldAddress field_cid_operand(result_reg, Field::guarded_cid_offset(),
-                                   kUnsignedWord);
+                                   kUnsignedHalfword);
     FieldAddress field_nullability_operand(
-        result_reg, Field::is_nullable_offset(), kUnsignedWord);
+        result_reg, Field::is_nullable_offset(), kUnsignedHalfword);
 
-    __ ldr(temp, field_nullability_operand, kUnsignedWord);
+    __ ldr(temp, field_nullability_operand, kUnsignedHalfword);
     __ CompareImmediate(temp, kNullCid);
     __ b(&load_pointer, EQ);
 
-    __ ldr(temp, field_cid_operand, kUnsignedWord);
+    __ ldr(temp, field_cid_operand, kUnsignedHalfword);
     __ CompareImmediate(temp, kDoubleCid);
     __ b(&load_double, EQ);
 
-    __ ldr(temp, field_cid_operand, kUnsignedWord);
+    __ ldr(temp, field_cid_operand, kUnsignedHalfword);
     __ CompareImmediate(temp, kFloat32x4Cid);
     __ b(&load_float32x4, EQ);
 
-    __ ldr(temp, field_cid_operand, kUnsignedWord);
+    __ ldr(temp, field_cid_operand, kUnsignedHalfword);
     __ CompareImmediate(temp, kFloat64x2Cid);
     __ b(&load_float64x2, EQ);
 
     // Fall through.
     __ b(&load_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
     }
 
@@ skipping 3766 matching lines @@
   compiler->GenerateRuntimeCall(TokenPosition::kNoSource, deopt_id(),
                                 kGrowRegExpStackRuntimeEntry, 1, locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64