DBC: Collect type feedback for fastpath smi ops

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 736 matching lines @@
 
 #define DECLARE___D uint32_t rD; USE(rD)
 #define DECODE___D rD = (op >> Bytecode::kDShift);
 
 #define DECLARE_A_D DECLARE___D
 #define DECODE_A_D DECODE___D
 
 #define DECLARE_A_X int32_t rD; USE(rD)
 #define DECODE_A_X rD = (static_cast<int32_t>(op) >> Bytecode::kDShift);
 
+// If the following instruction is a call, extract the icdata from the
+// instruction and increment.
+#define SMI_FASTPATH_ICDATA_INC                                                \
+  if ((FLAG_optimization_counter_threshold >= 0) &&                            \
+       Bytecode::IsCallOpcode(*pc)) {                                          \

[Vyacheslav Egorov (Google), 2016/05/31 14:55:44]

I think we should mandate that the next bytecode must be a call. 

Checking that next bytecode is call is too much branches (our fast pathes
already grow to big and convoluted).

[zra, 2016/05/31 16:33:12]

I'll make it mandatory in release builds, but optional in debug builds so that I
can retain the unit tests of the OpTOS instructions.

[Vyacheslav Egorov (Google), 2016/05/31 16:53:07]

I am concerned that we will be unit testing the implementation that is not used.

I think we should be unit testing combination of XyzTOS + InstanceCall.

+    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;           \
+  }                                                                            \
+
 // 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]);                   \
     ResultT* slot = reinterpret_cast<ResultT*>(SP - 1);                        \
     if (LIKELY(AreBothSmis(lhs, rhs) && !Func(lhs, rhs, slot))) {              \
+      SMI_FASTPATH_ICDATA_INC;                                                 \
       /* Fast path succeeded. Skip the generic call that follows. */           \
       pc++;                                                                    \
       /* We dropped 2 arguments and push result                   */           \
       SP--;                                                                    \
     }                                                                          \
   }
 
 // Exception handling helper. Gets handler FP and PC from the Simulator where
 // they were stored by Simulator::Longjmp and proceeds to execute the handler.
 // Corner case: handler PC can be a fake marker that marks entry frame, which
@@ skipping 1330 matching lines @@
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 
 #endif  // defined TARGET_ARCH_DBC