Implement Dart VM option '--trace_sim_after' in DBC simulator

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 511 matching lines @@
   intrinsics_[kDouble_equalIntrinsic] = SimulatorHelpers::Double_equal;
   intrinsics_[kDouble_lessEqualThanIntrinsic] =
       SimulatorHelpers::Double_lessEqualThan;
   intrinsics_[kClearAsyncThreadStackTraceIntrinsic] =
       SimulatorHelpers::ClearAsyncThreadStack;
   intrinsics_[kSetAsyncThreadStackTraceIntrinsic] =
       SimulatorHelpers::SetAsyncThreadStackTrace;
 }
 
 
-Simulator::Simulator() : stack_(NULL), fp_(NULL) {
+Simulator::Simulator() : stack_(NULL), fp_(NULL), icount_(0) {
   // 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
   // the size specified by the user and the buffer space needed for
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ = new uintptr_t[(OSThread::GetSpecifiedStackSize() +
                           OSThread::kStackSizeBuffer +
                           kSimulatorStackUnderflowSize) /
                          sizeof(uintptr_t)];
@@ skipping 25 matching lines @@
 // Returns the top of the stack area to enable checking for stack pointer
 // validity.
 uword Simulator::StackTop() const {
   // To be safe in potential stack underflows we leave some buffer above and
   // set the stack top.
   return StackBase() +
          (OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer);
 }
 
 
+// Returns true if tracing of executed instructions is enabled.
+DART_FORCE_INLINE bool Simulator::IsTracingExecution() const {
+  return icount_ > FLAG_trace_sim_after;
+}
+
+
+// Prints bytecode instruction at given pc for instruction tracing.
+DART_NOINLINE void Simulator::TraceInstruction(uint32_t* pc) const {
+  THR_Print("%" Pu64 " ", icount_);
+  if (FLAG_support_disassembler) {
+    Disassembler::Disassemble(reinterpret_cast<uword>(pc),
+                              reinterpret_cast<uword>(pc + 1));
+  } else {
+    THR_Print("Disassembler not supported in this mode.\n");
+  }
+}
+
+
 // Calls into the Dart runtime are based on this interface.
 typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
 
 // Calls to leaf Dart runtime functions are based on this interface.
 typedef intptr_t (*SimulatorLeafRuntimeCall)(intptr_t r0,
                                              intptr_t r1,
                                              intptr_t r2,
                                              intptr_t r3);
 
 // Calls to leaf float Dart runtime functions are based on this interface.
@@ skipping 389 matching lines @@
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 // Note: all macro helpers are intended to be used only inside Simulator::Call.
 
+// Counts and prints executed bytecode instructions (in a non-PRODUCT mode).
+#if !defined(PRODUCT)
+#define TRACE_INSTRUCTION                                                      \
+  icount_++;                                                                   \
+  if (IsTracingExecution()) {                                                  \
+    TraceInstruction(pc - 1);                                                  \
+  }
+#else
+#define TRACE_INSTRUCTION
+#endif
+
 // Decode opcode and A part of the given value and dispatch to the
 // corresponding bytecode handler.
 #define DISPATCH_OP(val)                                                       \
   do {                                                                         \
     op = (val);                                                                \
     rA = ((op >> 8) & 0xFF);                                                   \
+    TRACE_INSTRUCTION                                                          \
     goto* dispatch[op & 0xFF];                                                 \
   } while (0)
 
 // Fetch next operation from PC, increment program counter and dispatch.
 #define DISPATCH() DISPATCH_OP(*pc++)
 
 // Define entry point that handles bytecode Name with the given operand format.
 #define BYTECODE(Name, Operands)                                               \
   BYTECODE_HEADER(Name, DECLARE_##Operands, DECODE_##Operands)
 
@@ skipping 2897 matching lines @@
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC