DBC: Fix CheckClass bug. Add some intrinsics

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 221 matching lines @@
     RawSmi* index = static_cast<RawSmi*>(args[1]);
     RawGrowableObjectArray* array =
         static_cast<RawGrowableObjectArray*>(args[0]);
     if (CheckIndex(index, array->ptr()->length_)) {
       *result = array->ptr()->data_->ptr()->data()[Smi::Value(index)];
       return true;
     }
     return false;
   }
 
+  static bool Double_getIsNan(Thread* thread,
+                              RawObject** FP,
+                              RawObject** result) {
+    RawObject** args = FrameArguments(FP, 1);
+    RawDouble* d = static_cast<RawDouble*>(args[0]);
+    *result = isnan(d->ptr()->value_)
+            ? Bool::True().raw()
+            : Bool::False().raw();
+    return true;
+  }
+
+  static bool ObjectEquals(Thread* thread,
+                           RawObject** FP,
+                           RawObject** result) {
+    RawObject** args = FrameArguments(FP, 2);
+    *result = args[0] == args[1] ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
+  static bool ObjectRuntimeType(Thread* thread,
+                                RawObject** FP,
+                                RawObject** result) {
+    RawObject** args = FrameArguments(FP, 1);
+    const intptr_t cid = GetClassId(args[0]);
+    if (cid == kClosureCid) {
+      return false;
+    }
+    RawClass* cls = thread->isolate()->class_table()->At(cid);
+    if (cls->ptr()->num_type_arguments_ != 0) {
+      return false;
+    }
+    RawType* typ = cls->ptr()->canonical_type_;
+    if (typ == Object::null()) {
+      return false;
+    }
+    *result = static_cast<RawObject*>(typ);
+    return true;
+  }
+
+  static bool GetDoubleOperands(RawObject** args, double* d1, double* d2) {
+    RawObject* obj2 = args[1];
+    if (!obj2->IsHeapObject()) {

[Florian Schneider, 2016/10/17 16:58:54]

I'd rather use obj2->IsSmi() for readability avoiding the negation.

[zra, 2016/10/17 17:22:51]

IsSmi() calls GetClassId() which calls ptr() which only makes sense on a heap
object =(

+      *d2 = static_cast<double>(
+          reinterpret_cast<intptr_t>(obj2) >> kSmiTagSize);
+    } else if (obj2->GetClassId() == kDoubleCid) {
+      RawDouble* obj2d = static_cast<RawDouble*>(obj2);
+      *d2 = obj2d->ptr()->value_;
+    } else {
+      return false;
+    }
+    RawDouble* obj1 = static_cast<RawDouble*>(args[0]);
+    *d1 = obj1->ptr()->value_;
+    return true;
+  }
+
+  static bool Double_add(Thread* thread,
+                         RawObject** FP,
+                         RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = static_cast<RawObject*>(Double::New(d1 + d2));
+    return true;
+  }
+
+  static bool Double_mul(Thread* thread,
+                         RawObject** FP,
+                         RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = static_cast<RawObject*>(Double::New(d1 * d2));
+    return true;
+  }
+
+  static bool Double_sub(Thread* thread,
+                         RawObject** FP,
+                         RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = static_cast<RawObject*>(Double::New(d1 - d2));
+    return true;
+  }
+
+  static bool Double_div(Thread* thread,
+                         RawObject** FP,
+                         RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = static_cast<RawObject*>(Double::New(d1 / d2));
+    return true;
+  }
+
+  static bool Double_greaterThan(Thread* thread,
+                                 RawObject** FP,
+                                 RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = d1 > d2 ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
+  static bool Double_greaterEqualThan(Thread* thread,
+                                 RawObject** FP,
+                                 RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = d1 >= d2 ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
+  static bool Double_lessThan(Thread* thread,
+                                 RawObject** FP,
+                                 RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = d1 < d2 ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
+  static bool Double_equal(Thread* thread,
+                                 RawObject** FP,
+                                 RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = d1 == d2 ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
+  static bool Double_lessEqualThan(Thread* thread,
+                                 RawObject** FP,
+                                 RawObject** result) {
+    double d1, d2;
+    if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
+      return false;
+    }
+    *result = d1 <= d2 ? Bool::True().raw() : Bool::False().raw();
+    return true;
+  }
+
   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;
   }
@@ skipping 31 matching lines @@
   }
 
   intrinsics_[kObjectArraySetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArraySetIndexed;
   intrinsics_[kObjectArrayGetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArrayGetIndexed;
   intrinsics_[kGrowableArraySetIndexedIntrinsic] =
       SimulatorHelpers::GrowableArraySetIndexed;
   intrinsics_[kGrowableArrayGetIndexedIntrinsic] =
       SimulatorHelpers::GrowableArrayGetIndexed;
+  intrinsics_[kObjectEqualsIntrinsic] =
+      SimulatorHelpers::ObjectEquals;
+  intrinsics_[kObjectRuntimeTypeIntrinsic] =
+      SimulatorHelpers::ObjectRuntimeType;
+
+  intrinsics_[kDouble_getIsNaNIntrinsic] =
+      SimulatorHelpers::Double_getIsNan;
+  intrinsics_[kDouble_addIntrinsic] =
+      SimulatorHelpers::Double_add;
+  intrinsics_[kDouble_mulIntrinsic] =
+      SimulatorHelpers::Double_mul;
+  intrinsics_[kDouble_subIntrinsic] =
+      SimulatorHelpers::Double_sub;
+  intrinsics_[kDouble_divIntrinsic] =
+      SimulatorHelpers::Double_div;
+  intrinsics_[kDouble_greaterThanIntrinsic] =
+      SimulatorHelpers::Double_greaterThan;
+  intrinsics_[kDouble_greaterEqualThanIntrinsic] =
+      SimulatorHelpers::Double_greaterEqualThan;
+  intrinsics_[kDouble_lessThanIntrinsic] =
+      SimulatorHelpers::Double_lessThan;
+  intrinsics_[kDouble_equalIntrinsic] =
+      SimulatorHelpers::Double_equal;
+  intrinsics_[kDouble_lessEqualThanIntrinsic] =
+      SimulatorHelpers::Double_lessEqualThan;
 }
 
 
 Simulator::Simulator()
     : stack_(NULL),
       fp_(NULL),
       sp_(NULL) {
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   // We allocate the stack here, the size is computed as the sum of
@@ skipping 2572 matching lines @@
     const bool may_be_smi = (rB == 1);
     const intptr_t cids_length = rC;
     if (LIKELY(!is_smi)) {
       const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
       for (intptr_t i = 0; i < cids_length; i++) {
         const intptr_t desired_cid = Bytecode::DecodeD(*(pc + i));
         if (cid == desired_cid) {
           pc++;
           break;
         }
-        // The cids are sorted in descending order.
-        if (cid > desired_cid) {
-          break;
-        }
       }
       pc += cids_length;
     } else {
       pc += cids_length;
       pc += (may_be_smi ? 1 : 0);
     }
     DISPATCH();
   }
 
   {
@@ skipping 595 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC