DBC: Fixes typed data bugs. Adds unboxed int32 instructions

runtime/vm/intermediate_language_dbc.cc

 // Copyright (c) 2016, 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_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 29 matching lines @@
   M(BoxInt64)                                                                  \
   M(MergedMath)                                                                \
   M(GuardFieldClass)                                                           \
   M(GuardFieldLength)                                                          \
   M(IfThenElse)                                                                \
   M(ExtractNthOutput)                                                          \
   M(BinaryUint32Op)                                                            \
   M(ShiftUint32Op)                                                             \
   M(UnaryUint32Op)                                                             \
   M(UnboxedIntConverter)                                                       \
-  M(BoxInteger32)                                                              \
-  M(UnboxInteger32)                                                            \
 
 // List of instructions that are not used by DBC.
 // Things we aren't planning to implement for DBC:
 // - Unboxed SIMD,
 // - Unboxed Mint,
 // - Optimized RegExps,
 // - Precompilation.
 #define FOR_EACH_UNREACHABLE_INSTRUCTION(M)                                    \
   M(CaseInsensitiveCompareUC16)                                                \
   M(GenericCheckBound)                                                         \
@@ skipping 634 matching lines @@
 }
 
 
 EMIT_NATIVE_CODE(StoreIndexed, 3, Location::NoLocation(),
                  LocationSummary::kNoCall, 1) {
   if (!compiler->is_optimizing()) {
     ASSERT(class_id() == kArrayCid);
     __ StoreIndexedTOS();
     return;
   }
-
   const Register array = locs()->in(kArrayPos).reg();
   const Register index = locs()->in(kIndexPos).reg();
   const Register value = locs()->in(kValuePos).reg();
   const Register temp = locs()->temp(0).reg();
   switch (class_id()) {
     case kArrayCid:
       __ StoreIndexed(array, index, value);
       break;
     case kTypedDataUint8ArrayCid:
     case kTypedDataInt8ArrayCid:
     case kExternalOneByteStringCid:
     case kExternalTypedDataUint8ArrayCid:
       ASSERT(index_scale() == 1);
       if (IsExternal()) {
         __ StoreIndexedExternalUint8(array, index, value);
       } else {
         __ StoreIndexedUint8(array, index, value);
       }
       break;
-    case kTypedDataFloat64ArrayCid:
-      if (IsExternal() || ((index_scale() != 8) && (index_scale() != 1))) {
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid: {
+      if (IsExternal()) {
         Unsupported(compiler);
         UNREACHABLE();
       }
-      if (index_scale() == 1) {
-        __ ShrImm(temp, index, 3);
+      if (index_scale() != 1) {
+        __ ShlImm(temp, index, Utils::ShiftForPowerOfTwo(index_scale()));
       } else {
         __ Move(temp, index);
       }
+      __ StoreIndexedUint32(array, temp, value);
+      break;
+    }
+    case kTypedDataFloat64ArrayCid:
+      if (IsExternal()) {
+        Unsupported(compiler);
+        UNREACHABLE();
+      }
+      if (index_scale() != 1) {
+        __ ShlImm(temp, index, Utils::ShiftForPowerOfTwo(index_scale()));
+      } else {
+        __ Move(temp, index);
+      }
       __ StoreIndexedFloat64(array, temp, value);
       break;
     default:
       Unsupported(compiler);
       UNREACHABLE();
       break;
   }
 }
 
 
-EMIT_NATIVE_CODE(LoadIndexed, 2, Location::RequiresRegister()) {
+EMIT_NATIVE_CODE(LoadIndexed, 2, Location::RequiresRegister(),
+                 LocationSummary::kNoCall, 1) {
   ASSERT(compiler->is_optimizing());
   const Register array = locs()->in(0).reg();
   const Register index = locs()->in(1).reg();
+  const Register temp = locs()->temp(0).reg();
   const Register result = locs()->out(0).reg();
   switch (class_id()) {
     case kArrayCid:
       __ LoadIndexed(result, array, index);
       break;
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalOneByteStringCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
@@ skipping 17 matching lines @@
       __ LoadIndexedOneByteString(result, array, index);
       break;
     case kTwoByteStringCid:
       if (index_scale() != 2) {
         // TODO(zra): Fix-up index.
         Unsupported(compiler);
         UNREACHABLE();
       }
       __ LoadIndexedTwoByteString(result, array, index);
       break;
+    case kTypedDataInt32ArrayCid:
+      ASSERT(representation() == kUnboxedInt32);
+      if (index_scale() != 1) {
+        __ ShlImm(temp, index, Utils::ShiftForPowerOfTwo(index_scale()));
+      } else {
+        __ Move(temp, index);
+      }
+      __ LoadIndexedInt32(result, array, temp);
+      break;
+    case kTypedDataUint32ArrayCid:
+      ASSERT(representation() == kUnboxedUint32);
+      if (index_scale() != 1) {
+        __ ShlImm(temp, index, Utils::ShiftForPowerOfTwo(index_scale()));
+      } else {
+        __ Move(temp, index);
+      }
+      __ LoadIndexedUint32(result, array, temp);
+      break;
     case kTypedDataFloat64ArrayCid:
-      if ((index_scale() != 8) && (index_scale() != 1)) {
-        Unsupported(compiler);
-        UNREACHABLE();
+      if (index_scale() != 1) {
+        __ ShlImm(temp, index, Utils::ShiftForPowerOfTwo(index_scale()));
+      } else {
+        __ Move(temp, index);
       }
-      if (index_scale() == 1) {
-        __ ShrImm(index, index, 3);
-      }
-      __ LoadIndexedFloat64(result, array, index);
+      __ LoadIndexedFloat64(result, array, temp);
       break;
     default:
       Unsupported(compiler);
       UNREACHABLE();
       break;
   }
 }
 
 
 EMIT_NATIVE_CODE(StringInterpolate,
@@ skipping 595 matching lines @@
     __ IfEqNull(box);
     compiler->EmitDeopt(GetDeoptId(), ICData::kDeoptCheckClass);
     __ UnboxDouble(result, box);
   } else {
     __ CheckedUnboxDouble(result, box);
     compiler->EmitDeopt(GetDeoptId(), ICData::kDeoptCheckClass);
   }
 }
 
 
+EMIT_NATIVE_CODE(UnboxInteger32, 1, Location::RequiresRegister()) {
+#if defined(ARCH_IS_64_BIT)
+  const Register out = locs()->out(0).reg();
+  const Register value = locs()->in(0).reg();
+  const bool may_truncate = is_truncating() || !CanDeoptimize();
+  __ UnboxInt32(out, value, may_truncate);
+  if (CanDeoptimize()) {
+    compiler->EmitDeopt(GetDeoptId(), ICData::kDeoptUnboxInteger);
+  } else {
+    __ Nop(0);
+  }
+#else
+  Unsupported(compiler);
+  UNREACHABLE();
+#endif  // defined(ARCH_IS_64_BIT)
+}
+
+
+EMIT_NATIVE_CODE(BoxInteger32, 1, Location::RequiresRegister()) {
+#if defined(ARCH_IS_64_BIT)
+  const Register out = locs()->out(0).reg();
+  const Register value = locs()->in(0).reg();
+  if (from_representation() == kUnboxedInt32) {
+    __ BoxInt32(out, value);
+  } else {
+    ASSERT(from_representation() == kUnboxedUint32);
+    __ BoxUint32(out, value);
+  }
+#else
+  Unsupported(compiler);
+  UNREACHABLE();
+#endif  // defined(ARCH_IS_64_BIT)
+}
+
+
 EMIT_NATIVE_CODE(DoubleToSmi, 1, Location::RequiresRegister()) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ DoubleToSmi(result, value);
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptDoubleToSmi);
 }
 
 
 EMIT_NATIVE_CODE(SmiToDouble, 1, Location::RequiresRegister()) {
   const Register value = locs()->in(0).reg();
@@ skipping 249 matching lines @@
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(),
                       ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                       (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC