- Add an OSThread structure which is the generic TLS structure for all C++

runtime/vm/dart_entry.cc

 // Copyright (c) 2011, 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/dart_entry.h"
 
 #include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
@@ skipping 15 matching lines @@
                                      const Array& arguments) {
   ASSERT(Thread::Current()->IsMutatorThread());
   const Array& arguments_descriptor =
       Array::Handle(ArgumentsDescriptor::New(arguments.Length()));
   return InvokeFunction(function, arguments, arguments_descriptor);
 }
 
 
 class ScopedIsolateStackLimits : public ValueObject {
  public:
-  explicit ScopedIsolateStackLimits(Isolate* isolate)
-      : isolate_(isolate), stack_base_(Isolate::GetCurrentStackPointer()) {
-    ASSERT(isolate_ != NULL);
-    ASSERT(isolate_ == Isolate::Current());
-    if (stack_base_ >= isolate_->stack_base()) {
-      isolate_->SetStackLimitFromStackBase(stack_base_);
+  explicit ScopedIsolateStackLimits(Thread* thread)
+      : thread_(thread), saved_stack_limit_(0) {
+    ASSERT(thread != NULL);
+    // Set the thread's stack_base based on the current
+    // stack pointer, we keep refining this value as we
+    // see higher stack pointers (Note: we assume the stack
+    // grows from high to low addresses).
+    OSThread* os_thread = thread->os_thread();
+    ASSERT(os_thread != NULL);
+    uword current_sp = Isolate::GetCurrentStackPointer();
+    if (current_sp > os_thread->stack_base()) {
+      os_thread->set_stack_base(current_sp);
     }
+    // Save the Isolate's current stack limit and adjust the stack
+    // limit based on the thread's stack_base.
+    Isolate* isolate = thread->isolate();
+    ASSERT(isolate == Isolate::Current());
+    saved_stack_limit_ = isolate->saved_stack_limit();
+    isolate->SetStackLimitFromStackBase(os_thread->stack_base());
   }
 
   ~ScopedIsolateStackLimits() {
-    ASSERT(isolate_ == Isolate::Current());
-    if (isolate_->stack_base() == stack_base_) {
-      // Bottomed out.
-      isolate_->ClearStackLimit();
-    }
+    Isolate* isolate = thread_->isolate();
+    ASSERT(isolate == Isolate::Current());
+    // Since we started with a stack limit of 0 we should be getting back
+    // to a stack limit of 0 when all nested invocations are done and
+    // we have bottomed out.
+    isolate->SetStackLimit(saved_stack_limit_);
   }
 
  private:
-  Isolate* isolate_;
-  uword stack_base_;
+  Thread* thread_;
+  uword saved_stack_limit_;
 };
 
 
 // Clears/restores Thread::long_jump_base on construction/destruction.
 // Ensures that we do not attempt to long jump across Dart frames.
 class SuspendLongJumpScope : public StackResource {
  public:
   explicit SuspendLongJumpScope(Thread* thread)
       : StackResource(thread),
         saved_long_jump_base_(thread->long_jump_base()) {
@@ skipping 11 matching lines @@
 
 
 RawObject* DartEntry::InvokeFunction(const Function& function,
                                      const Array& arguments,
                                      const Array& arguments_descriptor) {
   // Get the entrypoint corresponding to the function specified, this
   // will result in a compilation of the function if it is not already
   // compiled.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  Isolate* isolate = thread->isolate();
   ASSERT(thread->IsMutatorThread());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(
         zone, Compiler::CompileFunction(thread, function));
     if (!error.IsNull()) {
       return error.raw();
     }
   }
   // Now Call the invoke stub which will invoke the dart function.
   invokestub entrypoint = reinterpret_cast<invokestub>(
       StubCode::InvokeDartCode_entry()->EntryPoint());
   const Code& code = Code::Handle(zone, function.CurrentCode());
   ASSERT(!code.IsNull());
   ASSERT(thread->no_callback_scope_depth() == 0);
-  ScopedIsolateStackLimits stack_limit(isolate);
+  ScopedIsolateStackLimits stack_limit(thread);
   SuspendLongJumpScope suspend_long_jump_scope(thread);
 #if defined(USING_SIMULATOR)
   return bit_copy<RawObject*, int64_t>(Simulator::Current()->Call(
       reinterpret_cast<intptr_t>(entrypoint),
       reinterpret_cast<intptr_t>(&code),
       reinterpret_cast<intptr_t>(&arguments_descriptor),
       reinterpret_cast<intptr_t>(&arguments),
       reinterpret_cast<intptr_t>(thread)));
 #else
   return entrypoint(code,
@@ skipping 467 matching lines @@
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, map);
   args.SetAt(1, key);
   args.SetAt(2, value);
   const Object& result = Object::Handle(DartEntry::InvokeFunction(function,
                                                                   args));
   return result.raw();
 }
 
 }  // namespace dart