DBC: Implement coverage by adding missing count increments to unoptimized static and instance calls.

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 104 matching lines @@
 
   DART_FORCE_INLINE static intptr_t GetClassId(RawObject* obj) {
     return obj->IsHeapObject() ? obj->GetClassId()
                                : static_cast<intptr_t>(kSmiCid);
   }
 
   DART_FORCE_INLINE static void IncrementUsageCounter(RawFunction* f) {
     f->ptr()->usage_counter_++;
   }
 
+  DART_FORCE_INLINE static void IncrementICUsageCount(RawObject** entries,
+                                                      intptr_t offset,
+                                                      intptr_t args_tested) {
+    const intptr_t count_offset = ICData::CountIndexFor(args_tested);
+    const intptr_t raw_smi_old =
+        reinterpret_cast<intptr_t>(entries[offset + count_offset]);
+    const intptr_t raw_smi_new = raw_smi_old + Smi::RawValue(1);
+    *reinterpret_cast<intptr_t*>(&entries[offset + count_offset]) =
+        raw_smi_new;
+  }
+
   DART_FORCE_INLINE static bool IsStrictEqualWithNumberCheck(RawObject* lhs,
                                                              RawObject* rhs) {
     if (lhs == rhs) {
       return true;
     }
 
     if (lhs->IsHeapObject() && rhs->IsHeapObject()) {
       const intptr_t lhs_cid = lhs->GetClassId();
       const intptr_t rhs_cid = rhs->GetClassId();
       if (lhs_cid == rhs_cid) {
@@ skipping 446 matching lines @@
 
 
 DART_FORCE_INLINE void Simulator::InstanceCall1(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
-                                                RawObject*** SP) {
+                                                RawObject*** SP,
+                                                bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 1;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
   RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   for (intptr_t i = 0;
        i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if (cache->data()[i + 0] == receiver_cid) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
+      if (!optimized) {
+        SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);

[zra, 2016/07/28 22:03:53]

Should this be incremented after handling an inline cache miss? Either way,
maybe just remember 'i' here, and do this in an else-if after the if (!found)
below, just to pull this out of the loop.

[rmacnak, 2016/07/28 22:22:04]

No, the runtime call that adds the new entry gives it an initial count of 1.

Either way,
Done

+      }
       break;
     }
   }
 
   if (!found) {
     InlineCacheMiss(
         kCheckedArgs, thread, icdata, call_base, top, *pc, *FP, *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
 
 DART_FORCE_INLINE void Simulator::InstanceCall2(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
-                                                RawObject*** SP) {
+                                                RawObject*** SP,
+                                                bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 2;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
   RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
   RawSmi* arg0_cid = SimulatorHelpers::GetClassIdAsSmi(args[1]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   for (intptr_t i = 0;
        i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if ((cache->data()[i + 0] == receiver_cid) &&
         (cache->data()[i + 1] == arg0_cid)) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
+      if (!optimized) {

[zra, 2016/07/28 22:03:53]

ditto.

+        SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);
+      }
       break;
     }
   }
 
   if (!found) {
     InlineCacheMiss(
         kCheckedArgs, thread, icdata, call_base, top, *pc, *FP, *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
@@ skipping 98 matching lines @@
 
 #define DECLARE_A_X int32_t rD; USE(rD)
 #define DECODE_A_X rD = (static_cast<int32_t>(op) >> Bytecode::kDShift);
 
 
 #define SMI_FASTPATH_ICDATA_INC                                                \
   do {                                                                         \
     ASSERT(Bytecode::IsCallOpcode(*pc));                                       \
     const uint16_t kidx = Bytecode::DecodeD(*pc);                              \
     const RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));           \
-    RawObject** data = icdata->ptr()->ic_data_->ptr()->data();                 \
-    const intptr_t count_offset = ICData::CountIndexFor(2);                    \
-    const intptr_t raw_smi_old =                                               \
-        reinterpret_cast<intptr_t>(data[count_offset]);                        \
-    const intptr_t raw_smi_new = raw_smi_old + Smi::RawValue(1);               \
-    *reinterpret_cast<intptr_t*>(&data[count_offset]) = raw_smi_new;           \
+    RawObject** entries = icdata->ptr()->ic_data_->ptr()->data();              \
+    SimulatorHelpers::IncrementICUsageCount(entries, 0, 2);                    \
   } while (0);                                                                 \
 
 // Declare bytecode handler for a smi operation (e.g. AddTOS) with the
 // given result type and the given behavior specified as a function
 // that takes left and right operands and result slot and returns
 // true if fast-path succeeds.
 #define SMI_FASTPATH_TOS(ResultT, Func)                                        \
   {                                                                            \
     const intptr_t lhs = reinterpret_cast<intptr_t>(SP[-1]);                   \
     const intptr_t rhs = reinterpret_cast<intptr_t>(SP[-0]);                   \
@@ skipping 601 matching lines @@
       NativeArguments args(thread, 0, NULL, NULL);
       INVOKE_RUNTIME(DRT_SingleStepHandler, args);
     }
 
     // Invoke target function.
     {
       const uint16_t argc = rA;
       // Lookup the funciton in the ICData.
       RawObject* ic_data_obj = SP[0];
       RawICData* ic_data = RAW_CAST(ICData, ic_data_obj);
-      RawArray* cache = ic_data->ptr()->ic_data_->ptr();
-      SP[0] = cache->data()[ICData::TargetIndexFor(
+      RawObject** data = ic_data->ptr()->ic_data_->ptr()->data();
+      SimulatorHelpers::IncrementICUsageCount(data, 0, 0);
+      SP[0] = data[ICData::TargetIndexFor(
           ic_data->ptr()->state_bits_ & 0x3)];
       RawObject** call_base = SP - argc;
       RawObject** call_top = SP;  // *SP contains function
       argdesc = static_cast<RawArray*>(LOAD_CONSTANT(rD));
       Invoke(thread, call_base, call_top, &pp, &pc, &FP, &SP);
     }
 
     DISPATCH();
   }
 
@@ skipping 20 matching lines @@
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(
           RAW_CAST(Function, icdata->ptr()->owner_));
-      InstanceCall1(
-          thread, icdata, call_base, call_top, &argdesc, &pp, &pc, &FP, &SP);
+      InstanceCall1(thread, icdata, call_base, call_top,
+                    &argdesc, &pp, &pc, &FP, &SP,
+                    false /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall2, A_D);
     if (thread->isolate()->single_step()) {
       Exit(thread, FP, SP + 1, pc);
       NativeArguments args(thread, 0, NULL, NULL);
       INVOKE_RUNTIME(DRT_SingleStepHandler, args);
     }
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(
           RAW_CAST(Function, icdata->ptr()->owner_));
-      InstanceCall2(
-          thread, icdata, call_base, call_top, &argdesc, &pp, &pc, &FP, &SP);
+      InstanceCall2(thread, icdata, call_base, call_top,
+                    &argdesc, &pp, &pc, &FP, &SP,
+                    false /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall1Opt, A_D);
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(FrameFunction(FP));
-      InstanceCall1(
-          thread, icdata, call_base, call_top, &argdesc, &pp, &pc, &FP, &SP);
+      InstanceCall1(thread, icdata, call_base, call_top,
+                    &argdesc, &pp, &pc, &FP, &SP,
+                    true /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(InstanceCall2Opt, A_D);
 
     {
       const uint16_t argc = rA;
       const uint16_t kidx = rD;
 
       RawObject** call_base = SP - argc + 1;
       RawObject** call_top = SP + 1;
 
       RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));
       SimulatorHelpers::IncrementUsageCounter(FrameFunction(FP));
-      InstanceCall2(
-          thread, icdata, call_base, call_top, &argdesc, &pp, &pc, &FP, &SP);
+      InstanceCall2(thread, icdata, call_base, call_top,
+                    &argdesc, &pp, &pc, &FP, &SP,
+                    true /* optimized */);
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(NativeBootstrapCall, 0);
     RawFunction* function = FrameFunction(FP);
     RawObject** incoming_args =
         (function->ptr()->num_optional_parameters_ == 0)
@@ skipping 1493 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC