Allow StackFrameIterator to be used on a different thread than the isolate whose stack frames are b…

runtime/vm/stack_frame.h

 // 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.
 
 #ifndef VM_STACK_FRAME_H_
 #define VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
@@ skipping 62 matching lines @@
   RawFunction* LookupDartFunction() const;
   RawCode* LookupDartCode() const;
   bool FindExceptionHandler(Isolate* isolate,
                             uword* handler_pc,
                             bool* needs_stacktrace,
                             bool* is_catch_all) const;
   // Returns token_pos of the pc(), or -1 if none exists.
   intptr_t GetTokenPos() const;
 
  protected:
-  StackFrame() : fp_(0), sp_(0), pc_(0) { }
+  explicit StackFrame(Isolate* isolate)
+      : fp_(0), sp_(0), pc_(0), isolate_(isolate) { }
 
   // Name of the frame, used for generic frame printing functionality.
   virtual const char* GetName() const { return IsStubFrame()? "stub" : "dart"; }
 
+  Isolate* isolate() const { return isolate_; }
+
  private:
   RawCode* GetCodeObject() const;
 
   uword GetCallerSp() const {
     return fp() + (kCallerSpSlotFromFp * kWordSize);
   }
   uword GetCallerFp() const {
     return *(reinterpret_cast<uword*>(
         fp() + (kSavedCallerFpSlotFromFp * kWordSize)));
   }
   uword GetCallerPc() const {
     return *(reinterpret_cast<uword*>(
         fp() + (kSavedCallerPcSlotFromFp * kWordSize)));
   }
 
   uword fp_;
   uword sp_;
   uword pc_;
+  Isolate* isolate_;
 
   // The iterators FrameSetIterator and StackFrameIterator set the private
   // fields fp_ and sp_ when they return the respective frame objects.
   friend class FrameSetIterator;
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(StackFrame);
 };
 
 
 // Exit frame is used to mark the transition from dart code into dart VM
 // runtime code.
 class ExitFrame : public StackFrame {
  public:
   bool IsValid() const { return sp() == 0; }
   bool IsDartFrame() const { return false; }
   bool IsStubFrame() const { return false; }
   bool IsExitFrame() const { return true; }
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "exit"; }
 
  private:
-  ExitFrame() { }
+  explicit ExitFrame(Isolate* isolate) : StackFrame(isolate) { }
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(ExitFrame);
 };
 
 
 // Entry Frame is used to mark the transition from dart VM runtime code into
 // dart code.
 class EntryFrame : public StackFrame {
  public:
-  bool IsValid() const { return StubCode::InInvocationStub(pc()); }
+  bool IsValid() const {
+    return StubCode::InInvocationStubForIsolate(isolate(), pc());
+  }
   bool IsDartFrame() const { return false; }
   bool IsStubFrame() const { return false; }
   bool IsEntryFrame() const { return true; }
 
   RawContext* SavedContext() const;
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "entry"; }
 
  private:
-  EntryFrame() { }
+  explicit EntryFrame(Isolate* isolate) : StackFrame(isolate) { }
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(EntryFrame);
 };
 
 
 class StackFrameIterator : public ValueObject {
  public:
   static const bool kValidateFrames = true;
   static const bool kDontValidateFrames = false;
 
   // Iterators for iterating over all frames from the last ExitFrame to the
   // first EntryFrame.

[siva, 2014/06/30 23:26:44]

We should document in this comment here and in DartFrameIterator clearly that if
an isolate other than the current isolate is used it is the responsibility of
the caller to ensure that the isolate is not running concurrently while this
thread is iterating over the stack frames.

[Cutch, 2014/07/01 14:26:09]

Done.

-  explicit StackFrameIterator(bool validate);
-  StackFrameIterator(uword last_fp, bool validate);
+  explicit StackFrameIterator(bool validate,
+                              Isolate* isolate = Isolate::Current());

[siva, 2014/06/30 23:26:44]

Not explicit anymore? one more param has been added.

[Cutch, 2014/07/01 14:26:09]

Done.

+  StackFrameIterator(uword last_fp, bool validate,
+                     Isolate* isolate = Isolate::Current());
 
   // Iterator for iterating over all frames from the current frame (given by its
   // fp, sp, and pc) to the first EntryFrame.
-  StackFrameIterator(uword fp, uword sp, uword pc, bool validate);
+  StackFrameIterator(uword fp, uword sp, uword pc, bool validate,
+                     Isolate* isolate = Isolate::Current());
 
   // Checks if a next frame exists.
   bool HasNextFrame() const { return frames_.fp_ != 0; }
 
   // Get next frame.
   StackFrame* NextFrame();
 
  private:
   // Iterator for iterating over the set of frames (dart or stub) which exist
   // in one EntryFrame and ExitFrame block.
   class FrameSetIterator : public ValueObject {
    public:
+    explicit FrameSetIterator(Isolate* isolate)
+        : fp_(0), sp_(0), pc_(0), stack_frame_(isolate), isolate_(isolate) { }

[siva, 2014/06/30 23:26:44]

why is this constructor public now?

[Cutch, 2014/07/01 14:26:09]

Done.

+
     // Checks if a next non entry/exit frame exists in the set.
     bool HasNext() const {
       if (fp_ == 0) {
         return false;
       }
       const uword pc = *(reinterpret_cast<uword*>(
           sp_ + (kSavedPcSlotFromSp * kWordSize)));
-      return !StubCode::InInvocationStub(pc);
+      return !StubCode::InInvocationStubForIsolate(isolate_, pc);
     }
 
     // Get next non entry/exit frame in the set (assumes a next frame exists).
     StackFrame* NextFrame(bool validate);
 
    private:
-    FrameSetIterator() : fp_(0), sp_(0), pc_(0), stack_frame_() { }
-
     uword fp_;
     uword sp_;
     uword pc_;
     StackFrame stack_frame_;  // Singleton frame returned by NextFrame().
+    Isolate* isolate_;
 
     friend class StackFrameIterator;
     DISALLOW_COPY_AND_ASSIGN(FrameSetIterator);
   };
 
   // Get next exit frame.
   ExitFrame* NextExitFrame();
 
   // Get next entry frame.
   EntryFrame* NextEntryFrame();
 
   // Get an iterator to the next set of frames between an entry and exit
   // frame.
   FrameSetIterator* NextFrameSet() { return &frames_; }
 
   // Setup last or next exit frames so that we are ready to iterate over
   // stack frames.
   void SetupLastExitFrameData();
   void SetupNextExitFrameData();
 
   bool validate_;  // Validate each frame as we traverse the frames.
   EntryFrame entry_;  // Singleton entry frame returned by NextEntryFrame().
   ExitFrame exit_;  // Singleton exit frame returned by NextExitFrame().
   FrameSetIterator frames_;
   StackFrame* current_frame_;  // Points to the current frame in the iterator.
+  Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
 
 // Iterator for iterating over all dart frames (skips over exit frames,
 // entry frames and stub frames).
 class DartFrameIterator : public ValueObject {
  public:
-  DartFrameIterator() : frames_(StackFrameIterator::kDontValidateFrames) { }
-  explicit DartFrameIterator(uword last_fp)
-      : frames_(last_fp, StackFrameIterator::kDontValidateFrames) { }
-  DartFrameIterator(uword fp, uword sp, uword pc)
-      : frames_(fp, sp, pc, StackFrameIterator::kDontValidateFrames) { }
+  DartFrameIterator(Isolate* isolate = Isolate::Current())
+      : frames_(StackFrameIterator::kDontValidateFrames, isolate) { }
+  explicit DartFrameIterator(uword last_fp,
+                             Isolate* isolate = Isolate::Current())
+      : frames_(last_fp, StackFrameIterator::kDontValidateFrames, isolate) { }

[siva, 2014/06/30 23:26:44]

explicit on the other constructor?

[Cutch, 2014/07/01 14:26:09]

Done.

+  DartFrameIterator(uword fp,
+                    uword sp,
+                    uword pc,
+                    Isolate* isolate = Isolate::Current())
+      : frames_(fp, sp, pc, StackFrameIterator::kDontValidateFrames, isolate) {
+  }
   // Get next dart frame.
   StackFrame* NextFrame() {
     StackFrame* frame = frames_.NextFrame();
     while (frame != NULL && !frame->IsDartFrame()) {
       frame = frames_.NextFrame();
     }
     return frame;
   }
 
  private:
@@ skipping 40 matching lines @@
   uword pc_;
   GrowableArray<DeoptInstr*> deopt_instructions_;
   Array& object_table_;
 
   DISALLOW_COPY_AND_ASSIGN(InlinedFunctionsIterator);
 };
 
 }  // namespace dart
 
 #endif  // VM_STACK_FRAME_H_