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)
 
 #if !defined(USING_SIMULATOR)
 #error "DBC is a simulated architecture"
 #endif
 
 #include "vm/simulator.h"
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/constants_dbc.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/disassembler.h"
+#include "vm/flow_graph_compiler.h"
 #include "vm/lockers.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os_thread.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
@@ skipping 1937 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(CheckNull, A_D);
+    RawObject* obj = FP[rA];
+    if (((rD == 1) && (obj != null_value)) ||
+        ((rD == 0) && (obj == null_value))) {
+      pc++;
+    }
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(CheckDenseSwitchTOS, A_D);
+    const intptr_t cid_mask = Smi::Value(RAW_CAST(Smi, *SP--));
+    const intptr_t cid_min = Smi::Value(RAW_CAST(Smi, *SP--));
+    const ICData& ic_data =
+        ICData::Handle(RAW_CAST(ICData, LOAD_CONSTANT(rD)));
+    const intptr_t value = reinterpret_cast<intptr_t>(FP[rA]);
+    const bool is_smi = ((value & kSmiTagMask) == kSmiTag);
+    if (is_smi) {
+      //OS::PrintErr("CheckDenseSwitchTOS: Smi\n");
+      if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
+        //OS::PrintErr("\tCheckDenseSwitchTOS: receiver is smi\n");
+        pc++;
+      } else {
+        //OS::PrintErr("\tCheckDenseSwitchTOS: receiver is NOT smi\n");
+      }
+    } else {
+      const intptr_t cid_max = Utils::HighestBit(cid_mask) + cid_min;
+      const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
+      //OS::PrintErr("\tCheckDenseSwitchTOS: cid_min = %ld, cid_max = %ld, cid = %ld\n",
+          //cid_min, cid_max, cid);
+      // 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)) {
+        //OS::PrintErr("\tCheckDenseSwitchTOS: Good\n");
+        pc++;
+      } else {
+        //OS::PrintErr("\tCheckDenseSwitchTOS: Not Good\n");
+      }
+    }
+    DISPATCH();
+  }
+
+  {
+    BYTECODE(CheckForCid, A_D);
+    const ICData& ic_data =
+        ICData::Handle(RAW_CAST(ICData, LOAD_CONSTANT(rD)));
+    const intptr_t value = reinterpret_cast<intptr_t>(FP[rA]);
+    const bool is_smi = ((value & kSmiTagMask) == kSmiTag);
+    if (is_smi) {
+      //OS::PrintErr("CheckForCid: Smi\n");
+      if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
+        //OS::PrintErr("\tCheckForCid: receiver is smi\n");
+        pc++;
+      } else {
+        //OS::PrintErr("\tCheckForCid: receiver is not smi\n");
+      }
+    } else {
+      const intptr_t cid = SimulatorHelpers::GetClassId(FP[rA]);
+      GrowableArray<CidTarget> sorted_ic_data;
+      FlowGraphCompiler::SortICDataByCount(ic_data,
+                                           &sorted_ic_data,
+                                           /* drop_smi = */ true);
+      const intptr_t num_checks = sorted_ic_data.length();
+      //OS::PrintErr("CheckForCid: cid = %ld, num_checks = %ld\n",
+          //cid, num_checks);
+      for (intptr_t i = 0; i < num_checks; i++) {
+        const intptr_t data_cid = sorted_ic_data[i].cid;
+        //OS::PrintErr("\tCheckForCid: looking at %ld\n", data_cid);
+        ASSERT(cid != kSmiCid);
+        if (cid == data_cid) {
+          //OS::PrintErr("\tCheckForCid: Found\n");
+          pc++;
+          break;
+        }
+      }
+    }
+    DISPATCH();
+  }
+
+  {
     BYTECODE(IfEqStrictTOS, 0);
     SP -= 2;
     if (SP[1] != SP[2]) {
       pc++;
     }
     DISPATCH();
   }
 
   {
     BYTECODE(IfNeStrictTOS, 0);
@@ skipping 118 matching lines @@
     ASSERT(!index->IsHeapObject());
     ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
     array->StorePointer(array->ptr()->data() + Smi::Value(index), value);
     DISPATCH();
   }
 
   {
     BYTECODE(Deopt, A_D);
     const bool is_lazy = rD == 0;
 
+    OS::PrintErr("Deopt instr pc = %p\n", pc - 1);
+    {
+      const Function& f = Function::Handle(FrameFunction(FP));
+      Disassembler::DisassembleCode(f, true);
+    }
+
     // Preserve result of the previous call.
     // TODO(vegorov) we could have actually included result into the
     // deoptimization environment because it is passed through the stack.
     // If we do then we could remove special result handling from this code.
     RawObject* result = SP[0];
 
     // When not preserving the result, we still need to preserve SP[0] as it
     // contains some temporary expression.
     if (!is_lazy) {
       SP++;
@@ skipping 15 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