Do not directly load smi constants larger than a 16 bit payload on ia32.

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 132 matching lines @@
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out().IsInvalid()) {
     Register result = locs()->out().reg();
-    __ LoadObject(result, value());
+    __ LoadObjectSafely(result, value());
   }
 }
 
 
 LocationSummary* AssertAssignableInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(EAX));  // Value.
@@ skipping 770 matching lines @@
       (is_bootstrap_native()) ? &StubCode::CallBootstrapCFunctionLabel() :
                                 &StubCode::CallNativeCFunctionLabel();
   compiler->GenerateCall(token_pos(),
                          stub_entry,
                          PcDescriptors::kOther,
                          locs());
   __ popl(result);
 }
 
 
-static bool CanBeImmediateIndex(Value* index, intptr_t cid) {
-  if (!index->definition()->IsConstant()) return false;
-  const Object& constant = index->definition()->AsConstant()->value();
-  if (!constant.IsSmi()) return false;
-  const Smi& smi_const = Smi::Cast(constant);
+static bool CanBeImmediateIndex(Value* value, intptr_t cid) {
+  ConstantInstr* constant = value->definition()->AsConstant();
+  if ((constant == NULL) || !Assembler::IsSafeSmi(constant->value())) {
+    return false;
+  }
+  const int64_t index = Smi::Cast(constant->value()).AsInt64Value();
   const intptr_t scale = FlowGraphCompiler::ElementSizeFor(cid);
-  const intptr_t data_offset = FlowGraphCompiler::DataOffsetFor(cid);
-  const int64_t disp = smi_const.AsInt64Value() * scale + data_offset;
-  return Utils::IsInt(32, disp);
+  const intptr_t offset = FlowGraphCompiler::DataOffsetFor(cid);
+  const int64_t displacement = index * scale + offset;
+  return Utils::IsInt(32, displacement);
 }
 
 
 LocationSummary* StringFromCharCodeInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   // TODO(fschneider): Allow immediate operands for the char code.
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
@@ skipping 143 matching lines @@
   }
 }
 
 
 LocationSummary* LoadIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
-  // The smi index is either untagged (element size == 1), or it is left smi
-  // tagged (for all element sizes > 1).
-  if (index_scale() == 1) {
-    locs->set_in(1, CanBeImmediateIndex(index(), class_id())
-                      ? Location::Constant(
-                          index()->definition()->AsConstant()->value())
-                      : Location::WritableRegister());
+  if (CanBeImmediateIndex(index(), class_id())) {
+    // CanBeImmediateIndex must return false for unsafe smis.
+    locs->set_in(1, Location::Constant(index()->BoundConstant()));
   } else {
-    locs->set_in(1, CanBeImmediateIndex(index(), class_id())
-                      ? Location::Constant(
-                          index()->definition()->AsConstant()->value())
-                      : Location::RequiresRegister());
+    // The index is either untagged (element size == 1) or a smi (for all
+    // element sizes > 1).
+    locs->set_in(1, (index_scale() == 1)
+                        ? Location::WritableRegister()
+                        : Location::RequiresRegister());
   }
   if (representation() == kUnboxedDouble) {
     locs->set_out(Location::RequiresFpuRegister());
   } else {
     locs->set_out(Location::RequiresRegister());
   }
   return locs;
 }
 
 
@@ skipping 134 matching lines @@
   }
 }
 
 
 LocationSummary* StoreIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
-  // The smi index is either untagged (element size == 1), or it is left smi
-  // tagged (for all element sizes > 1).
-  if (index_scale() == 1) {
-    locs->set_in(1, CanBeImmediateIndex(index(), class_id())
-                      ? Location::Constant(
-                          index()->definition()->AsConstant()->value())
-                      : Location::WritableRegister());
+  if (CanBeImmediateIndex(index(), class_id())) {
+    // CanBeImmediateIndex must return false for unsafe smis.
+    locs->set_in(1, Location::Constant(index()->BoundConstant()));
   } else {
-    locs->set_in(1, CanBeImmediateIndex(index(), class_id())
-                      ? Location::Constant(
-                          index()->definition()->AsConstant()->value())
-                      : Location::RequiresRegister());
+    // The index is either untagged (element size == 1) or a smi (for all
+    // element sizes > 1).
+    locs->set_in(1, (index_scale() == 1)
+                        ? Location::WritableRegister()
+                        : Location::RequiresRegister());
   }
   switch (class_id()) {
     case kArrayCid:
       locs->set_in(2, ShouldEmitStoreBarrier()
                         ? Location::WritableRegister()
                         : Location::RegisterOrConstant(value()));
       break;
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt8ArrayCid:
@@ skipping 1123 matching lines @@
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     if (RightIsPowerOfTwoConstant()) {
       summary->set_in(0, Location::RequiresRegister());
       ConstantInstr* right_constant = right()->definition()->AsConstant();
+      // The programmer only controls one bit, so the constant is safe.
       summary->set_in(1, Location::Constant(right_constant->value()));
       summary->set_temp(0, Location::RequiresRegister());
       summary->set_out(Location::SameAsFirstInput());
     } else {
       // Both inputs must be writable because they will be untagged.
       summary->set_in(0, Location::RegisterLocation(EAX));
       summary->set_in(1, Location::WritableRegister());
       summary->set_out(Location::SameAsFirstInput());
       // Will be used for sign extension and division.
       summary->set_temp(0, Location::RegisterLocation(EDX));
@@ skipping 2730 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32