DBC: Double converstion 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 233 matching lines @@
     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) {
+      RawObject* obj, RawObject* index) {
     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);
     return array->ptr()->data() + byte_offset;
   }
 };
 
 
 DART_FORCE_INLINE static uint32_t* SavedCallerPC(RawObject** FP) {
@@ skipping 1697 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(DTruncate, A_D);
+    const double value = bit_cast<double, RawObject*>(FP[rD]);
+    FP[rA] = bit_cast<RawObject*, double>(trunc(value));
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DFloor, A_D);
+    const double value = bit_cast<double, RawObject*>(FP[rD]);
+    FP[rA] = bit_cast<RawObject*, double>(floor(value));
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DCeil, A_D);
+    const double value = bit_cast<double, RawObject*>(FP[rD]);
+    FP[rA] = bit_cast<RawObject*, double>(ceil(value));
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DoubleToFloat, A_D);
+    const double value = bit_cast<double, RawObject*>(FP[rD]);
+    const float valuef = static_cast<float>(value);
+    *reinterpret_cast<float*>(&FP[rA]) = valuef;
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(FloatToDouble, A_D);
+    const float valuef = *reinterpret_cast<float*>(&FP[rD]);
+    const double value = static_cast<double>(valuef);
+    FP[rA] = bit_cast<RawObject*, double>(value);
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(LoadIndexedFloat32, A_B_C);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
+    const uint32_t value = *reinterpret_cast<uint32_t*>(data);
+    const uint64_t value64 = value;
+    FP[rA] = reinterpret_cast<RawObject*>(value64);
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(LoadIndexed4Float32, 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_));
+    const uint32_t value =
+        reinterpret_cast<uint32_t*>(array->ptr()->data())[Smi::Value(index)];
+    const uint64_t value64 = value;  // sign extend to clear high bits.
+    FP[rA] = reinterpret_cast<RawObject*>(value64);
+    DISPATCH();
+  }
+
+  {
     BYTECODE(LoadIndexedFloat64, A_B_C);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 3);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
     *reinterpret_cast<uint64_t*>(&FP[rA]) = *reinterpret_cast<uint64_t*>(data);
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexed8Float64, 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_));
     const int64_t value =
         reinterpret_cast<int64_t*>(array->ptr()->data())[Smi::Value(index)];
     FP[rA] = reinterpret_cast<RawObject*>(value);
     DISPATCH();
   }
 
   {
+    BYTECODE(StoreIndexedFloat32, A_B_C);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB]);
+    const uint64_t value = reinterpret_cast<uint64_t>(FP[rC]);
+    const uint32_t value32 = value;
+    *reinterpret_cast<uint32_t*>(data) = value32;
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(StoreIndexed4Float32, 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_));
+    const uint64_t value = reinterpret_cast<uint64_t>(FP[rC]);
+    const uint32_t value32 = value;
+    reinterpret_cast<uint32_t*>(array->ptr()->data())[Smi::Value(index)] =
+        value32;
+    DISPATCH();
+  }
+
+  {
     BYTECODE(StoreIndexedFloat64, A_B_C);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 3);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB]);
     *reinterpret_cast<uint64_t*>(data) = reinterpret_cast<uint64_t>(FP[rC]);
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexed8Float64, 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_));
@@ skipping 116 matching lines @@
     DISPATCH();
   }
 
   {
     BYTECODE(DMax, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
+    BYTECODE(DTruncate, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DFloor, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DCeil, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(DoubleToFloat, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(FloatToDouble, A_D);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(LoadIndexedFloat32, A_B_C);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(LoadIndexed4Float32, A_B_C);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
     BYTECODE(LoadIndexedFloat64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexed8Float64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
+    BYTECODE(StoreIndexedFloat32, A_B_C);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(StoreIndexed4Float32, A_B_C);
+    UNREACHABLE();
+    DISPATCH();
+  }
+
+  {
     BYTECODE(StoreIndexedFloat64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexed8Float64, A_B_C);
     UNREACHABLE();
     DISPATCH();
   }
@@ skipping 885 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);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 0);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB]);
     *data = 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)] = Smi::Value(value);
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedOneByteString, A_B_C);
     RawOneByteString* array = RAW_CAST(OneByteString, FP[rA]);
     RawSmi* index = RAW_CAST(Smi, FP[rB]);
     RawSmi* value = RAW_CAST(Smi, FP[rC]);
     ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
     array->ptr()->data()[Smi::Value(index)] = Smi::Value(value);
     DISPATCH();
   }
 
   {
     BYTECODE(StoreIndexedUint32, A_B_C);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB], 2);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rA], FP[rB]);
     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);
     RawObject* obj = FP[rB];
     ASSERT(obj->IsArray() || obj->IsImmutableArray());
     RawArray* array = reinterpret_cast<RawArray*>(obj);
     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);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 0);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
     FP[rA] = Smi::New(*data);
     DISPATCH();
   }
 
   {
     BYTECODE(LoadIndexedInt8, A_B_C);
-    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC], 0);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
     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);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
     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);
+    uint8_t* data = SimulatorHelpers::GetTypedData(FP[rB], FP[rC]);
     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();
@@ skipping 204 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC