Support profiling of simulated Dart code on mips, arm, and arm64.

runtime/vm/profiler.cc

 // Copyright (c) 2013, 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 "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 936 matching lines @@
   ASSERT(isolate != Dart::vm_isolate());
 
   const bool exited_dart_code = (isolate->stub_code() != NULL) &&
                                 (isolate->top_exit_frame_info() != 0) &&
                                 (isolate->vm_tag() != VMTag::kDartTagId);
   const bool in_dart_code = (isolate->stub_code() != NULL) &&
                             (isolate->top_exit_frame_info() == 0) &&
                             (isolate->vm_tag() == VMTag::kDartTagId);
 
   uintptr_t sp = 0;
+  uintptr_t fp = state.fp;
+  uintptr_t pc = state.pc;
+  uintptr_t lr = state.lr;
+#if defined(USING_SIMULATOR)
+  Simulator* simulator = NULL;
+#endif
 
   if (in_dart_code) {
     // If we're in Dart code, use the Dart stack pointer.
+#if defined(USING_SIMULATOR)
+    simulator = isolate->simulator();
+    sp = simulator->get_register(SPREG);
+    fp = simulator->get_register(FPREG);
+    pc = simulator->get_pc();
+    lr = simulator->get_register(LRREG);
+#else
     sp = state.dsp;
+#endif
   } else {
     // If we're in runtime code, use the C stack pointer.
     sp = state.csp;
   }
 
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     // Profiler not initialized.
     return;
   }
 
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
-  if ((sp == 0) || (state.fp == 0) || (state.pc == 0)) {
+  if ((sp == 0) || (fp == 0) || (pc == 0)) {
     // None of these registers should be zero.
     return;
   }
 
-  if (sp > state.fp) {
+  if (sp > fp) {
     // Assuming the stack grows down, we should never have a stack pointer above
     // the frame pointer.
     return;
   }
 
-  if (StubCode::InJumpToExceptionHandlerStub(state.pc)) {
+  if (StubCode::InJumpToExceptionHandlerStub(pc)) {
     // The JumpToExceptionHandler stub manually adjusts the stack pointer,
     // frame pointer, and some isolate state before jumping to a catch entry.
     // It is not safe to walk the stack when executing this stub.
     return;
   }
 
   uword stack_lower = 0;
   uword stack_upper = 0;
+#if defined(USING_SIMULATOR)
+  if (in_dart_code) {
+    stack_lower = simulator->StackBase();
+    stack_upper = simulator->StackTop();
+  } else if (!isolate->GetProfilerStackBounds(&stack_lower, &stack_upper)) {
+    // Could not get stack boundary.
+    return;
+  }
+  if ((stack_lower == 0) || (stack_upper == 0)) {
+    return;
+  }
+#else
   if (!isolate->GetProfilerStackBounds(&stack_lower, &stack_upper) ||
       (stack_lower == 0) || (stack_upper == 0)) {
     // Could not get stack boundary.
     return;
   }
+#endif
 
   if (sp > stack_lower) {
     // The stack pointer gives us a tighter lower bound.
     stack_lower = sp;
   }
 
   if (stack_lower >= stack_upper) {
     // Stack boundary is invalid.
     return;
   }
 
   if ((sp < stack_lower) || (sp >= stack_upper)) {
     // Stack pointer is outside isolate stack boundary.
     return;
   }
 
-  if ((state.fp < stack_lower) || (state.fp >= stack_upper)) {
+  if ((fp < stack_lower) || (fp >= stack_upper)) {
     // Frame pointer is outside isolate stack boundary.
     return;
   }
 
   // At this point we have a valid stack boundary for this isolate and
   // know that our initial stack and frame pointers are within the boundary.
 
   // Setup sample.
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate, OS::GetCurrentTimeMicros(), state.tid);
   uword vm_tag = isolate->vm_tag();
 #if defined(USING_SIMULATOR)
   // When running in the simulator, the runtime entry function address
   // (stored as the vm tag) is the address of a redirect function.
   // Attempt to find the real runtime entry function address and use that.
   uword redirect_vm_tag = Simulator::FunctionForRedirect(vm_tag);
   if (redirect_vm_tag != 0) {
     vm_tag = redirect_vm_tag;
   }
 #endif
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(vm_tag);
   sample->set_vm_tag(vm_tag);
   sample->set_user_tag(isolate->user_tag());
   sample->set_sp(sp);
-  sample->set_fp(state.fp);
-  sample->set_lr(state.lr);
+  sample->set_fp(fp);
+  sample->set_lr(lr);
   CopyStackBuffer(sample);
   CopyPCMarkerIfSafe(sample);
 
   if (FLAG_profile_vm) {
     // Always walk the native stack collecting both native and Dart frames.
     ProfilerNativeStackWalker stackWalker(sample,
                                           stack_lower,
                                           stack_upper,
-                                          state.pc,
-                                          state.fp,
+                                          pc,
+                                          fp,
                                           sp);
     stackWalker.walk();
   } else if (exited_dart_code) {
     // We have a valid exit frame info, use the Dart stack walker.
     ProfilerDartExitStackWalker stackWalker(isolate, sample);
     stackWalker.walk();
   } else if (in_dart_code) {
     // We are executing Dart code. We have frame pointers.
     ProfilerDartStackWalker stackWalker(isolate,
                                         sample,
                                         stack_lower,
                                         stack_upper,
-                                        state.pc,
-                                        state.fp,
+                                        pc,
+                                        fp,
                                         sp);
     stackWalker.walk();
   } else {
     sample->set_vm_tag(VMTag::kEmbedderTagId);
-    sample->SetAt(0, state.pc);
+    sample->SetAt(0, pc);
   }
 }
 
 }  // namespace dart