Partially implement DBC profiler.

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 535 matching lines @@
                                          RawObject*** SP) {
   RawObject** callee_fp = call_top + kDartFrameFixedSize;
 
   RawFunction* function = FrameFunction(callee_fp);
   RawCode* code = function->ptr()->code_;
   callee_fp[kPcMarkerSlotFromFp] = code;
   callee_fp[kSavedCallerPcSlotFromFp] = reinterpret_cast<RawObject*>(*pc);
   callee_fp[kSavedCallerFpSlotFromFp] = reinterpret_cast<RawObject*>(*FP);
   *pp = code->ptr()->object_pool_->ptr();
   *pc = reinterpret_cast<uint32_t*>(code->ptr()->entry_point_);
+  pc_ = reinterpret_cast<uword>(*pc);  // For the profiler.
   *FP = callee_fp;
   *SP = *FP - 1;
 }
 
 
 void Simulator::InlineCacheMiss(int checked_args,
                                 Thread* thread,
                                 RawICData* icdata,
                                 RawObject** args,
                                 RawObject** top,
@@ skipping 132 matching lines @@
 static DART_NOINLINE bool InvokeRuntime(
     Thread* thread,
     Simulator* sim,
     RuntimeFunction drt,
     const NativeArguments& args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(drt));
     drt(args);
     thread->set_vm_tag(VMTag::kDartTagId);
+    thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 
 static DART_NOINLINE bool InvokeNative(
     Thread* thread,
     Simulator* sim,
     SimulatorBootstrapNativeCall f,
     NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     f(args);
     thread->set_vm_tag(VMTag::kDartTagId);
+    thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
 
 static DART_NOINLINE bool InvokeNativeWrapper(
     Thread* thread,
     Simulator* sim,
     Dart_NativeFunction f,
     NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     NativeEntry::NativeCallWrapper(reinterpret_cast<Dart_NativeArguments>(args),
                                    f);
     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.
 
 // Decode opcode and A part of the given value and dispatch to the
 // corresponding bytecode handler.
@@ skipping 181 matching lines @@
   //  SP > | fp_         |  |
   //  FP > | ........... |   > normal Dart frame (see stack_frame_dbc.h)
   //                        |
   //                        v
   //
   FP = fp_ + 1 + arguments.Length() + kDartFrameFixedSize;
   SP = FP - 1;
 
   // Save outer top_exit_frame_info.
   fp_[0] = reinterpret_cast<RawObject*>(thread->top_exit_frame_info());
+  thread->set_top_exit_frame_info(0);
 
   // Copy arguments and setup the Dart frame.
   const intptr_t argc = arguments.Length();
   for (intptr_t i = 0; i < argc; i++) {
     fp_[1 + i] = arguments.At(i);
   }
 
   FP[kFunctionSlotFromFp] = code.function();
   FP[kPcMarkerSlotFromFp] = code.raw();
   FP[kSavedCallerPcSlotFromFp] = reinterpret_cast<RawObject*>((argc << 2) | 2);
   FP[kSavedCallerFpSlotFromFp] = reinterpret_cast<RawObject*>(fp_);
 
   // Load argument descriptor.
   argdesc = arguments_descriptor.raw();
 
   // Ready to start executing bytecode. Load entry point and corresponding
   // object pool.
   pc = reinterpret_cast<uint32_t*>(code.raw()->ptr()->entry_point_);
+  pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
   pp = code.object_pool()->ptr();
 
   // Cache some frequently used values in the frame.
   RawBool* true_value = Bool::True().raw();
   RawBool* false_value = Bool::False().raw();
   RawObject* null_value = Object::null();
   RawObject* empty_context = thread->isolate()->object_store()->empty_context();
 
 #if defined(DEBUG)
   Function& function_h = Function::Handle();
@@ skipping 201 matching lines @@
     FP[1] = 0;
     Exit(thread, FP, FP + 2, pc);
     NativeArguments args(thread, 1, FP, FP + 1);
     INVOKE_RUNTIME(DRT_CompileFunction, args);
     {
       // Function should be compiled now, dispatch to its entry point.
       RawCode* code = FrameFunction(FP)->ptr()->code_;
       SimulatorHelpers::SetFrameCode(FP, code);
       pp = code->ptr()->object_pool_->ptr();
       pc = reinterpret_cast<uint32_t*>(code->ptr()->entry_point_);
+      pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
     }
     DISPATCH();
   }
 
   {
     BYTECODE(HotCheck, A_D);
     const uint8_t increment = rA;
     const uint16_t threshold = rD;
     RawFunction* f =  FrameFunction(FP);
     int32_t counter = f->ptr()->usage_counter_;
     // Note: we don't increment usage counter in the prologue of optimized
     // functions.
     if (increment) {
       counter += increment;
       f->ptr()->usage_counter_ = counter;
     }
     if (counter >= threshold) {
       FP[0] = f;
       FP[1] = 0;
       Exit(thread, FP, FP + 2, pc);
       NativeArguments args(thread, 1, FP, FP + 1);
       INVOKE_RUNTIME(DRT_OptimizeInvokedFunction, args);
       {
         // DRT_OptimizeInvokedFunction returns the code object to execute.
         ASSERT(FP[1]->GetClassId() == kCodeCid);
         RawCode* code = static_cast<RawCode*>(FP[1]);
         SimulatorHelpers::SetFrameCode(FP, code);
         pp = code->ptr()->object_pool_->ptr();
         pc = reinterpret_cast<uint32_t*>(code->ptr()->entry_point_);
+        pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
       }
     }
     DISPATCH();
   }
 
   {
     BYTECODE(CheckStack, A);
     {
       if (reinterpret_cast<uword>(SP) >= thread->stack_limit()) {
         Exit(thread, FP, SP + 1, pc);
@@ skipping 917 matching lines @@
     result = FP[rA];
     goto ReturnImpl;
 
     BYTECODE(ReturnTOS, 0);
     result = *SP;
     // Fall through to the ReturnImpl.
 
   ReturnImpl:
     // Restore caller PC.
     pc = SavedCallerPC(FP);
+    pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
 
     // Check if it is a fake PC marking the entry frame.
     if ((reinterpret_cast<uword>(pc) & 2) != 0) {
       const intptr_t argc = reinterpret_cast<uword>(pc) >> 2;
       fp_ = sp_ =
           reinterpret_cast<RawObject**>(FrameArguments(FP, argc + 1)[0]);
       thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));
       thread->set_top_resource(top_resource);
       thread->set_vm_tag(vm_tag);
       return result;
@@ skipping 884 matching lines @@
     }
     const intptr_t materialization_arg_count =
         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);
+    pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
 
     // Check if it is a fake PC marking the entry frame.
     ASSERT((reinterpret_cast<uword>(pc) & 2) == 0);
 
     // Restore SP, FP and PP. Push result and dispatch.
     // Note: unlike in a normal return sequence we don't need to drop
     // arguments - those are not part of the innermost deoptimization
     // environment they were dropped by FlowGraphCompiler::RecordAfterCall.
 
     // If the result is not preserved, the unoptimized frame ends at the
@@ skipping 118 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC