Enable the profiler on the simulator

runtime/vm/isolate.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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 631 matching lines @@
 // TODO(5411455): Use flag to override default value and Validate the
 // stack size by querying OS.
 uword Isolate::GetSpecifiedStackSize() {
   ASSERT(Isolate::kStackSizeBuffer < Thread::GetMaxStackSize());
   uword stack_size = Thread::GetMaxStackSize() - Isolate::kStackSizeBuffer;
   return stack_size;
 }
 
 
 void Isolate::SetStackLimitFromStackBase(uword stack_base) {
+  // Set stack base.
+  stack_base_ = stack_base;
+
+  // Set stack limit.
 #if defined(USING_SIMULATOR)
   // Ignore passed-in native stack top and use Simulator stack top.
   Simulator* sim = Simulator::Current();  // May allocate a simulator.
   ASSERT(simulator() == sim);  // This isolate's simulator is the current one.
   stack_base = sim->StackTop();
   // The overflow area is accounted for by the simulator.
 #endif
-  // Set stack base.
-  stack_base_ = stack_base;
-  // Set stack limit.
-  SetStackLimit(stack_base_ - GetSpecifiedStackSize());
+  SetStackLimit(stack_base - GetSpecifiedStackSize());
 }
 
 
 void Isolate::SetStackLimit(uword limit) {
   // The isolate setting the stack limit is not necessarily the isolate which
   // the stack limit is being set on.
   MutexLocker ml(mutex_);
   if (stack_limit_ == saved_stack_limit_) {
     // No interrupt pending, set stack_limit_ too.
     stack_limit_ = limit;
   }
   saved_stack_limit_ = limit;
 }
 
 
 void Isolate::ClearStackLimit() {
   SetStackLimit(~static_cast<uword>(0));
   stack_base_ = 0;
 }
 
 
 bool Isolate::GetProfilerStackBounds(uword* lower, uword* upper) const {
-  uword stack_lower = stack_limit();
-  if (stack_lower == kUwordMax) {
-    stack_lower = saved_stack_limit();
-  }
-  if (stack_lower == kUwordMax) {
+  uword stack_upper = stack_base_;
+  if (stack_upper == 0) {
     return false;
   }
-  uword stack_upper = stack_lower + GetSpecifiedStackSize();
+  uword stack_lower = stack_upper - GetSpecifiedStackSize();
   *lower = stack_lower;
   *upper = stack_upper;
   return true;
 }

[siva, 2014/11/14 18:02:51]

When this function is called by Profiler::RecordSampleInterruptCallback for a
sample in dart code the dart stack pointer is going to be
compared against the native stack pointer limits and it might end up skipping
that sample as the stack boundary could potentially be invalid.

 
 
 void Isolate::ScheduleInterrupts(uword interrupt_bits) {
   MutexLocker ml(mutex_);
   ASSERT((interrupt_bits & ~kInterruptsMask) == 0);  // Must fit in mask.
   if (stack_limit_ == saved_stack_limit_) {
     stack_limit_ = (~static_cast<uword>(0)) & ~kInterruptsMask;
   }
   stack_limit_ |= interrupt_bits;
 }
@@ skipping 874 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart