Fixes for the profiler on 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/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/isolate.h"
@@ skipping 1950 matching lines @@
     const InterruptedThreadState& state,
     void* data) {
   Isolate* isolate = reinterpret_cast<Isolate*>(data);
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return;
   }
 
   ASSERT(isolate != Dart::vm_isolate());
 
+  uintptr_t sp = 0;
+  if ((isolate->stub_code() != NULL) &&
+      (isolate->top_exit_frame_info() == 0) &&
+      (isolate->vm_tag() == VMTag::kDartTagId)) {
+    // If we're in Dart code, use the Dart stack pointer.
+    sp = state.dsp;
+  } 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 ((state.sp == 0) || (state.fp == 0) || (state.pc == 0)) {
+  if ((sp == 0) || (state.fp == 0) || (state.pc == 0)) {
     // None of these registers should be zero.
     return;
   }
 
-  if (state.sp > state.fp) {
+  if (sp > state.fp) {
     // Assuming the stack grows down, we should never have a stack pointer above
     // the frame pointer.
     return;
   }
 
   if (StubCode::InJumpToExceptionHandlerStub(state.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;
   isolate->GetProfilerStackBounds(&stack_lower, &stack_upper);
   if ((stack_lower == 0) || (stack_upper == 0)) {
     // Could not get stack boundary.
     return;
   }
 
-  if (state.sp > stack_lower) {
+  if (sp > stack_lower) {
     // The stack pointer gives us a tighter lower bound.
-    stack_lower = state.sp;
+    stack_lower = sp;
   }
 
   if (stack_lower >= stack_upper) {
     // Stack boundary is invalid.
     return;
   }
 
-  if ((state.sp < stack_lower) || (state.sp >= stack_upper)) {
+  if ((sp < stack_lower) || (sp >= stack_upper)) {
     // Stack pointer is outside isolate stack boundary.
     return;
   }
 
   if ((state.fp < stack_lower) || (state.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.
 
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(isolate->vm_tag());
 
   // Setup sample.
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate, OS::GetCurrentTimeMicros(), state.tid);
   sample->set_vm_tag(isolate->vm_tag());
   sample->set_user_tag(isolate->user_tag());
-  sample->set_sp(state.sp);
+  sample->set_sp(sp);
   sample->set_fp(state.fp);
 #if !(defined(TARGET_OS_WINDOWS) && defined(TARGET_ARCH_X64))
   // It is never safe to read other thread's stack unless on Win64
   // other thread is inside Dart code.
   SetPCMarkerIfSafe(sample);
 #endif
 
   // Walk the call stack.
   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,
-                                          state.sp);
+                                          sp);
     stackWalker.walk();
   } else {
     // Attempt to walk only the Dart call stack, falling back to walking
     // the native stack.
     if ((isolate->stub_code() != NULL) &&
         (isolate->top_exit_frame_info() != 0) &&
         (isolate->vm_tag() != VMTag::kDartTagId)) {
       // We have a valid exit frame info, use the Dart stack walker.
       ProfilerDartExitStackWalker stackWalker(isolate, sample);
       stackWalker.walk();
     } else if ((isolate->stub_code() != NULL) &&
                (isolate->top_exit_frame_info() == 0) &&
                (isolate->vm_tag() == VMTag::kDartTagId)) {
       // We are executing Dart code. We have frame pointers.
       ProfilerDartStackWalker stackWalker(isolate,
                                           sample,
                                           stack_lower,
                                           stack_upper,
                                           state.pc,
                                           state.fp,
-                                          state.sp);
+                                          sp);
       stackWalker.walk();
     } else {
 #if defined(TARGET_OS_WINDOWS) && defined(TARGET_ARCH_X64)
       // ProfilerNativeStackWalker is known to cause crashes on Win64.
       // BUG=20423.
       sample->set_ignore_sample(true);
 #else
       // Fall back to an extremely conservative stack walker.
       ProfilerNativeStackWalker stackWalker(sample,
                                             stack_lower,
                                             stack_upper,
                                             state.pc,
                                             state.fp,
-                                            state.sp);
+                                            sp);
       stackWalker.walk();
 #endif
     }
   }
 }
 
 }  // namespace dart