Keep track of stack base whenever Dart code is invoked.

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 398 matching lines @@
       single_step_(false),
       resume_request_(false),
       random_(),
       simulator_(NULL),
       long_jump_base_(NULL),
       timer_list_(),
       deopt_id_(0),
       mutex_(new Mutex()),
       stack_limit_(0),
       saved_stack_limit_(0),
+      stack_base_(0),
       stack_overflow_flags_(0),
       stack_overflow_count_(0),
       message_handler_(NULL),
       spawn_state_(NULL),
       is_runnable_(false),
       gc_prologue_callback_(NULL),
       gc_epilogue_callback_(NULL),
       defer_finalization_count_(0),
       deopt_context_(NULL),
       stacktrace_(NULL),
@@ skipping 165 matching lines @@
 
   // Setup the Dart API state.
   ApiState* state = new ApiState();
   ASSERT(state != NULL);
   result->set_api_state(state);
 
   // Initialize stack top and limit in case we are running the isolate in the
   // main thread.
   // TODO(5411455): Need to figure out how to set the stack limit for the
   // main thread.
-  result->SetStackLimitFromCurrentTOS(reinterpret_cast<uword>(&result));
+  result->SetStackLimitFromStackBase(reinterpret_cast<uword>(&result));
   result->set_main_port(PortMap::CreatePort(result->message_handler()));
   result->set_pause_capability(result->random()->NextUInt64());
   result->set_terminate_capability(result->random()->NextUInt64());
 
   result->BuildName(name_prefix);
 
   result->debugger_ = new Debugger();
   result->debugger_->Initialize(result);
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
@@ skipping 20 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::SetStackLimitFromCurrentTOS(uword stack_top_value) {
+void Isolate::SetStackLimitFromStackBase(uword stack_base) {
 #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_top_value = sim->StackTop();
+  stack_base = sim->StackTop();
   // The overflow area is accounted for by the simulator.
 #endif
-  SetStackLimit(stack_top_value - GetSpecifiedStackSize());
+  // Set stack base.
+  stack_base_ = stack_base;
+  // Set stack limit.
+  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;
 }
 
 
-bool Isolate::GetStackBounds(uword* lower, uword* upper) {
+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) {
     return false;
   }
   uword stack_upper = stack_lower + GetSpecifiedStackSize();
   *lower = stack_lower;
   *upper = stack_upper;
@@ skipping 852 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart