DBC: Fixes typed data bugs. Adds unboxed int32 instructions

runtime/vm/simulator_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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 231 matching lines @@
   DART_FORCE_INLINE static RawCode* FrameCode(RawObject** FP) {
     ASSERT(GetClassId(FP[kPcMarkerSlotFromFp]) == kCodeCid);
     return static_cast<RawCode*>(FP[kPcMarkerSlotFromFp]);
   }
 
 
   DART_FORCE_INLINE static void SetFrameCode(RawObject** FP, RawCode* code) {
     ASSERT(GetClassId(code) == kCodeCid);
     FP[kPcMarkerSlotFromFp] = code;
   }
+
+  DART_FORCE_INLINE static uint8_t* GetTypedData(
+      RawObject* obj, RawObject* index, intptr_t scale) {
+    ASSERT(RawObject::IsTypedDataClassId(obj->GetClassId()));
+    RawTypedData* array = reinterpret_cast<RawTypedData*>(obj);
+    const intptr_t byte_offset = Smi::Value(RAW_CAST(Smi, index));
+    ASSERT(byte_offset >= 0);
+    ASSERT(((byte_offset + (1 << scale)) >> scale) <=
+               Smi::Value(array->ptr()->length_));
+    return array->ptr()->data() + byte_offset;
+  }
 };
 
 
 DART_FORCE_INLINE static uint32_t* SavedCallerPC(RawObject** FP) {
   return reinterpret_cast<uint32_t*>(FP[kSavedCallerPcSlotFromFp]);
 }
 
 
 DART_FORCE_INLINE static RawFunction* FrameFunction(RawObject** FP) {
   RawFunction* function = static_cast<RawFunction*>(FP[kFunctionSlotFromFp]);
@@ skipping 1488 matching lines @@
           (rhs >= kBitsPerWord) ? (kBitsPerWord - 1) : rhs;
       const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]) >> kSmiTagSize;
       *reinterpret_cast<intptr_t*>(&FP[rA]) =
           (lhs >> shift_amount) << kSmiTagSize;
       pc++;
     }
     DISPATCH();
   }
 
   {
-    BYTECODE(ShrImm, A_B_C);
+    BYTECODE(ShlImm, A_B_C);
     const uint8_t shift = rC;
-    const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]) >> kSmiTagSize;
-    *reinterpret_cast<intptr_t*>(&FP[rA]) = (lhs >> shift) << kSmiTagSize;
+    const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
+    FP[rA] = reinterpret_cast<RawObject*>(lhs << shift);
     DISPATCH();
   }
 
   {
     BYTECODE(Min, A_B_C);
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);
     FP[rA] = reinterpret_cast<RawObject*>((lhs < rhs) ? lhs : rhs);
     DISPATCH();
   }
 
   {
     BYTECODE(Max, A_B_C);
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);
     FP[rA] = reinterpret_cast<RawObject*>((lhs > rhs) ? lhs : rhs);
     DISPATCH();
   }
 
+  {
+    BYTECODE(UnboxInt32, A_B_C);
+    const intptr_t box_cid = SimulatorHelpers::GetClassId(FP[rB]);
+    const bool may_truncate = rC == 1;
+    if (box_cid == kSmiCid) {
+      const intptr_t value = reinterpret_cast<intptr_t>(FP[rB]) >> kSmiTagSize;
+      const int32_t value32 = static_cast<int32_t>(value);
+      if (may_truncate || (value == static_cast<intptr_t>(value32))) {
+        FP[rA] = reinterpret_cast<RawObject*>(value);
+        pc++;
+      }
+    } else if (box_cid == kMintCid) {
+      RawMint* mint = RAW_CAST(Mint, FP[rB]);
+      const int64_t value = mint->ptr()->value_;
+      const int32_t value32 = static_cast<int32_t>(value);
+      if (may_truncate || (value == static_cast<int64_t>(value32))) {
+        FP[rA] = reinterpret_cast<RawObject*>(value);
+        pc++;
+      }
+    }
+    DISPATCH();
+  }
+
 #if defined(ARCH_IS_64_BIT)
   {
     BYTECODE(WriteIntoDouble, A_D);
     const double value = bit_cast<double, RawObject*>(FP[rD]);
     RawDouble* box = RAW_CAST(Double, *SP--);
     box->ptr()->value_ = value;
     FP[rA] = box;
     DISPATCH();
   }
 
@@ skipping 131 matching lines @@
   {
     BYTECODE(DMax, A_B_C);
     const double lhs = bit_cast<double, RawObject*>(FP[rB]);
     const double rhs = bit_cast<double, RawObject*>(FP[rC]);
     FP[rA] = bit_cast<RawObject*, double>(fmax(lhs, rhs));
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexedFloat64, A_B_C);
-    ASSERT(RawObject::IsTypedDataClassId(FP[rB]->GetClassId()));
-    RawTypedData* array = reinterpret_cast<RawTypedData*>(FP[rB]);
-    RawSmi* index = RAW_CAST(Smi, FP[rC]);
-    ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
-    double* data = reinterpret_cast<double*>(array->ptr()->data());
-    FP[rA] = bit_cast<RawObject*, double>(data[Smi::Value(index)]);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 3);
+    *reinterpret_cast<uint64_t*>(&FP[rA]) = *reinterpret_cast<uint64_t*>(data);
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedFloat64, A_B_C);
-    ASSERT(RawObject::IsTypedDataClassId(FP[rA]->GetClassId()));
-    RawTypedData* array = reinterpret_cast<RawTypedData*>(FP[rA]);
-    RawSmi* index = RAW_CAST(Smi, FP[rB]);
-    ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
-    double* data = reinterpret_cast<double*>(array->ptr()->data());
-    data[Smi::Value(index)] = bit_cast<double, RawObject*>(FP[rC]);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 3);
+    *reinterpret_cast<uint64_t*>(data) = reinterpret_cast<uint64_t>(FP[rC]);
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(BoxInt32, A_D);
+    const intptr_t value = reinterpret_cast<intptr_t>(FP[rD]);
+    FP[rA] = reinterpret_cast<RawObject*>((value << 32) >> (32 - kSmiTagSize));

[Florian Schneider, 2016/08/19 21:39:06]

Why is shifting left by 32 and right by 31 necessary? Is the upper half not
always zeroed?

[zra, 2016/08/19 22:16:04]

Both the x64 and arm64 implementations zero or sign-extend the upper bits as
appropriate. It looks like on x64, arithmetic could result in non-zero bits in
the upper half, though here and on arm64 the needed IL instructions aren't
implemented. I'll leave this as-is in case me or someone else implements those
IL instructions.

+    DISPATCH();
+  }
+
+  {
+    BYTECODE(BoxUint32, A_D);
+    const uintptr_t value = reinterpret_cast<uintptr_t>(FP[rD]);
+    FP[rA] = reinterpret_cast<RawObject*>((value << 32) >> (32 - kSmiTagSize));

[Florian Schneider, 2016/08/19 21:39:05]

Maybe add a local helper SmiTagInt32(intptr_t value)?

[zra, 2016/08/19 22:16:04]

Decided to do casting instead of shifting.

     DISPATCH();
   }
 #else  // defined(ARCH_IS_64_BIT)
   {
     BYTECODE(WriteIntoDouble, A_D);
     UNIMPLEMENTED();
     DISPATCH();
   }
 
   {
@@ skipping 96 matching lines @@
     BYTECODE(LoadIndexedFloat64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedFloat64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
+
+  {
+    BYTECODE(BoxInt32, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(BoxUint32, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
 #endif  // defined(ARCH_IS_64_BIT)
 
   // Return and return like instructions (Instrinsic).
   {
     RawObject* result;  // result to return to the caller.
 
     BYTECODE(Intrinsic, A);
     // Try invoking intrinsic handler. If it succeeds (returns true)
     // then just return the value it returned to the caller.
     result = null_value;
@@ skipping 770 matching lines @@
     RawArray* array = RAW_CAST(Array, FP[rA]);
     RawSmi* index = RAW_CAST(Smi, FP[rB]);
     RawObject* value = FP[rC];
     ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
     array->StorePointer(array->ptr()->data() + Smi::Value(index), value);
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedUint8, A_B_C);
-    ASSERT(RawObject::IsTypedDataClassId(FP[rA]->GetClassId()));
-    RawTypedData* array = reinterpret_cast<RawTypedData*>(FP[rA]);
-    RawSmi* index = RAW_CAST(Smi, FP[rB]);
-    RawSmi* value = RAW_CAST(Smi, FP[rC]);
-    ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
-    uint8_t* data = reinterpret_cast<uint8_t*>(array->ptr()->data());
-    data[Smi::Value(index)] = static_cast<uint8_t>(Smi::Value(value));
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 0);
+    *data = static_cast<uint8_t>(Smi::Value(RAW_CAST(Smi, FP[rC])));
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedExternalUint8, A_B_C);
     uint8_t* array = reinterpret_cast<uint8_t*>(FP[rA]);
     RawSmi* index = RAW_CAST(Smi, FP[rB]);
     RawSmi* value = RAW_CAST(Smi, FP[rC]);
     array[Smi::Value(index)] = static_cast<uint8_t>(Smi::Value(value));
     DISPATCH();
   }
 
   {
+    BYTECODE(StoreIndexedUint32, A_B_C);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 2);
+    const uintptr_t value = reinterpret_cast<uintptr_t>(FP[rC]);
+    *reinterpret_cast<uint32_t*>(data) = static_cast<uint32_t>(value);
+    DISPATCH();
+  }
+
+  {
     BYTECODE(LoadIndexed, A_B_C);
     RawArray* array = RAW_CAST(Array, FP[rB]);
     RawSmi* index = RAW_CAST(Smi, FP[rC]);
     ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
     FP[rA] = array->ptr()->data()[Smi::Value(index)];
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexedUint8, A_B_C);
-    ASSERT(RawObject::IsTypedDataClassId(FP[rB]->GetClassId()));
-    RawTypedData* array = reinterpret_cast<RawTypedData*>(FP[rB]);
-    RawSmi* index = RAW_CAST(Smi, FP[rC]);
-    ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
-    uint8_t* data = reinterpret_cast<uint8_t*>(array->ptr()->data());
-    FP[rA] = Smi::New(data[Smi::Value(index)]);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 0);
+    FP[rA] = Smi::New(*data);
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexedInt8, A_B_C);
-    ASSERT(RawObject::IsTypedDataClassId(FP[rB]->GetClassId()));
-    RawTypedData* array = reinterpret_cast<RawTypedData*>(FP[rB]);
-    RawSmi* index = RAW_CAST(Smi, FP[rC]);
-    ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
-    int8_t* data = reinterpret_cast<int8_t*>(array->ptr()->data());
-    FP[rA] = Smi::New(data[Smi::Value(index)]);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 0);
+    FP[rA] = Smi::New(*reinterpret_cast<int8_t*>(data));
     DISPATCH();
   }
 
+  {
+    BYTECODE(LoadIndexedUint32, A_B_C);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 2);
+    FP[rA] = reinterpret_cast<RawObject*>(*reinterpret_cast<uintptr_t*>(data));
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(LoadIndexedInt32, A_B_C);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 2);
+    FP[rA] = reinterpret_cast<RawObject*>(*reinterpret_cast<intptr_t*>(data));
+    DISPATCH();
+  }
+
   {
     BYTECODE(LoadIndexedExternalUint8, A_B_C);
     uint8_t* data = reinterpret_cast<uint8_t*>(FP[rB]);
     RawSmi* index = RAW_CAST(Smi, FP[rC]);
     FP[rA] = Smi::New(data[Smi::Value(index)]);
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexedExternalInt8, A_B_C);
@@ skipping 199 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC