Box values of LoadCodeUnits that fall outside of smi range on 32bit platforms.

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"
@@ skipping 1310 matching lines @@
       __ SmiTag(result);
       break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ ldr(result, element_address);
       break;
   }
 }
 
 
-Representation LoadCodeUnitsInstr::representation() const {
-  switch (class_id()) {
-    case kOneByteStringCid:
-    case kExternalOneByteStringCid:
-    case kTwoByteStringCid:
-    case kExternalTwoByteStringCid:
-      // TODO(zerny): kUnboxedUint32 could be a better choice.
-      return can_pack_into_smi() ? kTagged : kUnboxedMint;
-    default:
-      UNIMPLEMENTED();
-      return kTagged;
-  }
-}
-
-
-LocationSummary* LoadCodeUnitsInstr::MakeLocationSummary(Isolate* isolate,
-                                                         bool opt) const {
-  const intptr_t kNumInputs = 2;
-  const intptr_t kNumTemps = 0;
-  LocationSummary* summary = new(isolate) LocationSummary(
-      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, Location::RequiresRegister());
-  summary->set_in(1, Location::RequiresRegister());
-
-  if (representation() == kUnboxedMint) {
-    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
-                                    Location::RequiresRegister()));
-  } else {
-    ASSERT(representation() == kTagged);
-    summary->set_out(0, Location::RequiresRegister());
-  }
-
-  return summary;
-}
-
-
-void LoadCodeUnitsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const Register array = locs()->in(0).reg();
-  const Location index = locs()->in(1);
-
-  Address element_address = __ ElementAddressForRegIndex(
-        true,  IsExternal(), class_id(), index_scale(), array, index.reg());
-  // Warning: element_address may use register IP as base.
-
-  if (representation() == kUnboxedMint) {
-    ASSERT(locs()->out(0).IsPairLocation());
-    PairLocation* result_pair = locs()->out(0).AsPairLocation();
-    Register result1 = result_pair->At(0).reg();
-    Register result2 = result_pair->At(1).reg();
-    switch (class_id()) {
-      case kOneByteStringCid:
-      case kExternalOneByteStringCid:
-        ASSERT(element_count() == 4);
-        __ ldr(result1, element_address);
-        __ eor(result2, result2, Operand(result2));
-        break;
-      case kTwoByteStringCid:
-      case kExternalTwoByteStringCid:
-        ASSERT(element_count() == 2);
-        __ ldr(result1, element_address);
-        __ eor(result2, result2, Operand(result2));
-        break;
-      default:
-        UNREACHABLE();
-    }
-  } else {
-    ASSERT(representation() == kTagged);
-    Register result = locs()->out(0).reg();
-    switch (class_id()) {
-      case kOneByteStringCid:
-      case kExternalOneByteStringCid:
-        switch (element_count()) {
-          case 1: __ ldrb(result, element_address); break;
-          case 2: __ ldrh(result, element_address); break;
-          default: UNREACHABLE();
-        }
-        __ SmiTag(result);
-        break;
-      case kTwoByteStringCid:
-      case kExternalTwoByteStringCid:
-        ASSERT(element_count() == 1);
-        __ ldrh(result, element_address);
-        __ SmiTag(result);
-        break;
-      default:
-        UNREACHABLE();
-        break;
-    }
-  }
-}
-
-
 Representation StoreIndexedInstr::RequiredInputRepresentation(
     intptr_t idx) const {
   // Array can be a Dart object or a pointer to external data.
   if (idx == 0)  return kNoRepresentation;  // Flexible input representation.
   if (idx == 1) return kTagged;  // Index is a smi.
   ASSERT(idx == 2);
   switch (class_id_) {
     case kArrayCid:
     case kOneByteStringCid:
     case kTypedDataInt8ArrayCid:
@@ skipping 515 matching lines @@
     }
   }
 
  private:
   Instruction* instruction_;
   const Class& cls_;
   const Register result_;
 };
 
 
+
+
+LocationSummary* LoadCodeUnitsInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const bool kMightBox = (representation() == kTagged) && !can_pack_into_smi();

[Florian Schneider, 2014/11/18 12:20:24]

Since this is not a compile-time constant, I'd rename it:

s/kMightBox/might_box/

[zerny-google, 2014/11/18 12:34:04]

Yes. Done here and in _ia32.cc

+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = kMightBox ? 1 : 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps,
+      kMightBox ? LocationSummary::kCallOnSlowPath : LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+
+  if (kMightBox) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
+
+  if (representation() == kUnboxedMint) {
+    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                       Location::RequiresRegister()));
+  } else {
+    ASSERT(representation() == kTagged);
+    summary->set_out(0, Location::RequiresRegister());
+  }
+
+  return summary;
+}
+
+
+void LoadCodeUnitsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const Register array = locs()->in(0).reg();
+  const Location index = locs()->in(1);
+
+  Address element_address = __ ElementAddressForRegIndex(
+        true,  IsExternal(), class_id(), index_scale(), array, index.reg());
+  // Warning: element_address may use register IP as base.
+
+  if (representation() == kUnboxedMint) {
+    ASSERT(compiler->is_optimizing());
+    ASSERT(locs()->out(0).IsPairLocation());
+    PairLocation* result_pair = locs()->out(0).AsPairLocation();
+    Register result1 = result_pair->At(0).reg();
+    Register result2 = result_pair->At(1).reg();
+    switch (class_id()) {
+      case kOneByteStringCid:
+      case kExternalOneByteStringCid:
+        ASSERT(element_count() == 4);
+        __ ldr(result1, element_address);
+        __ eor(result2, result2, Operand(result2));
+        break;
+      case kTwoByteStringCid:
+      case kExternalTwoByteStringCid:
+        ASSERT(element_count() == 2);
+        __ ldr(result1, element_address);
+        __ eor(result2, result2, Operand(result2));
+        break;
+      default:
+        UNREACHABLE();
+    }
+  } else {
+    ASSERT(representation() == kTagged);
+    Register result = locs()->out(0).reg();
+    switch (class_id()) {
+      case kOneByteStringCid:
+      case kExternalOneByteStringCid:
+        switch (element_count()) {
+          case 1: __ ldrb(result, element_address); break;
+          case 2: __ ldrh(result, element_address); break;
+          case 4: __ ldr(result, element_address); break;
+          default: UNREACHABLE();
+        }
+        break;
+      case kTwoByteStringCid:
+      case kExternalTwoByteStringCid:
+        switch (element_count()) {
+          case 1: __ ldrh(result, element_address); break;
+          case 2: __ ldr(result, element_address); break;
+          default: UNREACHABLE();
+        }
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
+    if (can_pack_into_smi()) {
+      __ SmiTag(result);
+    } else {
+      // If the value cannot fit in a smi then allocate a mint box for it.
+      Register value = locs()->temp(0).reg();
+      Register temp = locs()->temp(1).reg();
+      ASSERT(result != value);
+      __ MoveRegister(value, result);
+      __ SmiTag(result);
+
+      Label done;
+      __ TestImmediate(value, 0xC0000000);
+      __ b(&done, EQ);
+      BoxAllocationSlowPath::Allocate(
+          compiler, this, compiler->mint_class(), result, temp);
+      __ eor(temp, temp, Operand(temp));
+      __ StoreToOffset(kWord, value, result,
+                       Mint::value_offset() - kHeapObjectTag);
+      __ StoreToOffset(kWord, temp, result,
+                       Mint::value_offset() - kHeapObjectTag + kWordSize);
+      __ Bind(&done);
+    }
+  }
+}
+
+
 LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary(Isolate* isolate,
                                                               bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps =
       (IsUnboxedStore() && opt) ? 2 :
           ((IsPotentialUnboxedStore()) ? 3 : 0);
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps,
           ((IsUnboxedStore() && opt && is_initialization_) ||
            IsPotentialUnboxedStore())
@@ skipping 4928 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer);
   __ LoadImmediate(R5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM