DBC: CheckClassInstr

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 1960 matching lines @@
     const RawSmi* actual_cid =
         SimulatorHelpers::GetClassIdAsSmi(static_cast<RawObject*>(FP[rA]));
     const RawSmi* desired_cid = RAW_CAST(Smi, LOAD_CONSTANT(rD));
     if (actual_cid == desired_cid) {
       pc++;
     }
     DISPATCH();
   }
 
   {
+    BYTECODE(CheckDenseSwitch, A_D);
+    const intptr_t raw_value = reinterpret_cast<intptr_t>(FP[rA]);
+    const bool is_smi = ((raw_value & kSmiTagMask) == kSmiTag);
+    const intptr_t cid_min =
+        Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(Bytecode::DecodeD(*pc))));
+    const intptr_t cid_mask =
+        Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(Bytecode::DecodeD(*(pc + 1)))));
+    if (LIKELY(!is_smi)) {
+      const intptr_t cid_max = Utils::HighestBit(cid_mask) + cid_min;
+      const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
+      // The cid is in-bounds, and the bit is set in the mask.
+      if ((cid >= cid_min) && (cid <= cid_max) &&
+          ((cid_mask & (1 << (cid - cid_min))) != 0)) {
+        pc += 3;
+      } else {
+        pc += 2;
+      }
+    } else {
+      const bool may_be_smi = (rD == 1);
+      pc += (may_be_smi ? 3 : 2);
+    }
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(CheckCid, A_D);
+    const intptr_t raw_value = reinterpret_cast<intptr_t>(FP[rA]);
+    const bool is_smi = ((raw_value & kSmiTagMask) == kSmiTag);
+    const bool may_be_smi = (rD == 1);
+    if (is_smi) {
+      pc += (may_be_smi ? 2 : 1);
+    } else {
+      const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
+      const intptr_t desired_cid =
+          Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(Bytecode::DecodeD(*pc))));
+      pc += ((cid == desired_cid) ? 2 : 1);
+    }
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(CheckCids, A_D);
+    const intptr_t raw_value = reinterpret_cast<intptr_t>(FP[rA]);
+    const bool is_smi = ((raw_value & kSmiTagMask) == kSmiTag);
+    const bool may_be_smi = (rD == 1);
+    if (is_smi) {

[Vyacheslav Egorov (Google), 2016/06/29 17:11:06]

Flip this conditions to match CheckDenseSwitch

if (!LIKELY(is_smi)) {
  // ...
} else {
  // ...
}

[zra, 2016/06/29 22:19:19]

Done.

+      pc += (may_be_smi ? 2 : 1);
+    } else {
+      const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
+      const RawArray* cid_array =
+          RAW_CAST(Array, LOAD_CONSTANT(Bytecode::DecodeD(*pc)));
+      RawObject** cids = cid_array->ptr()->data();
+      const intptr_t cids_length = Smi::Value(cid_array->ptr()->length_);
+      for (intptr_t i = 0; i < cids_length; i++) {
+        const intptr_t desired_cid = Smi::Value(RAW_CAST(Smi, cids[i]));

[Vyacheslav Egorov (Google), 2016/06/29 18:33:10]

the array of cids is sorted so you can exit the loop early but maybe it does not
matter for small amount of cids.

[zra, 2016/06/29 22:19:19]

Done.

+        if (cid == desired_cid) {
+          pc++;
+          break;
+        }
+      }
+      pc++;
+    }
+    DISPATCH();
+  }
+
+  {
     BYTECODE(IfEqStrictTOS, 0);
     SP -= 2;
     if (SP[1] != SP[2]) {
       pc++;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(IfNeStrictTOS, 0);
@@ skipping 68 matching lines @@
     BYTECODE(IfNeStrictNum, A_D);
     RawObject* lhs = FP[rA];
     RawObject* rhs = FP[rD];
     if (SimulatorHelpers::IsStrictEqualWithNumberCheck(lhs, rhs)) {
       pc++;
     }
     DISPATCH();
   }
 
   {
+    BYTECODE(IfEqNull, A);
+    if (FP[rA] != null_value) {
+      pc++;
+    }
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(IfNeNull, A_D);
+    if (FP[rA] == null_value) {
+      pc++;
+    }
+    DISPATCH();
+  }
+
+  {
     BYTECODE(Jump, 0);
     const int32_t target = static_cast<int32_t>(op) >> 8;
     pc += (target - 1);
     DISPATCH();
   }
 
   {
     BYTECODE(LoadClassId, A_D);
     const uint16_t object_reg = rD;
     RawObject* obj = static_cast<RawObject*>(FP[object_reg]);
@@ skipping 65 matching lines @@
     {
       if (is_lazy) {
         *++SP = result;  // Preserve result (call below can cause GC).
       }
       *++SP = 0;  // Space for the result: number of materialization args.
       Exit(thread, FP, SP + 1, /*pc=*/0);
       NativeArguments native_args(thread, 0, SP, SP);
       INVOKE_RUNTIME(DRT_DeoptimizeMaterialize, native_args);
     }
     const intptr_t materialization_arg_count =
-        Smi::Value(RAW_CAST(Smi, *SP--));
+        Smi::Value(RAW_CAST(Smi, *SP--)) / kWordSize;
     if (is_lazy) {
       // Reload the result. It might have been relocated by GC.
       result = *SP--;
     }
 
     // Restore caller PC.
     pc = SavedCallerPC(FP);
 
     // Check if it is a fake PC marking the entry frame.
     ASSERT((reinterpret_cast<uword>(pc) & 2) == 0);
@@ skipping 125 matching lines @@
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 
 #endif  // defined TARGET_ARCH_DBC