dart::StackFrameIterator Class Reference

#include <stack_frame.h>

Public Types
enum	CrossThreadPolicy { kNoCrossThreadIteration = 0 , kAllowCrossThreadIteration = 1 }

Public Member Functions
	StackFrameIterator (ValidationPolicy validation_policy, Thread *thread, CrossThreadPolicy cross_thread_policy)
	StackFrameIterator (uword last_fp, ValidationPolicy validation_policy, Thread *thread, CrossThreadPolicy cross_thread_policy)
	StackFrameIterator (uword fp, uword sp, uword pc, ValidationPolicy validation_policy, Thread *thread, CrossThreadPolicy cross_thread_policy)
	StackFrameIterator (const StackFrameIterator &orig)
bool	HasNextFrame () const
StackFrame *	NextFrame ()
bool	validate () const

Friends
class	ProfilerDartStackWalker

Detailed Description

Definition at line 218 of file stack_frame.h.

Member Enumeration Documentation

CrossThreadPolicy

enum dart::StackFrameIterator::CrossThreadPolicy

Enumerator
kNoCrossThreadIteration
kAllowCrossThreadIteration

Definition at line 220 of file stack_frame.h.

                         {
    kNoCrossThreadIteration = 0,
    kAllowCrossThreadIteration = 1,
  };

Constructor & Destructor Documentation

StackFrameIterator() [1/4]

dart::StackFrameIterator::StackFrameIterator	(	ValidationPolicy	validation_policy,
		Thread *	thread,
		CrossThreadPolicy	cross_thread_policy
	)

Definition at line 484 of file stack_frame.cc.

    : validate_(validation_policy == ValidationPolicy::kValidateFrames),
      entry_(thread),
      exit_(thread),
      frames_(thread),
      current_frame_(nullptr),
      thread_(thread) {
  ASSERT(cross_thread_policy == kAllowCrossThreadIteration ||
         thread_ == Thread::Current());
  SetupLastExitFrameData();  // Setup data for last exit frame.
}

StackFrameIterator() [2/4]

dart::StackFrameIterator::StackFrameIterator	(	uword	last_fp,
		ValidationPolicy	validation_policy,
		Thread *	thread,
		CrossThreadPolicy	cross_thread_policy
	)

Definition at line 498 of file stack_frame.cc.

    : validate_(validation_policy == ValidationPolicy::kValidateFrames),
      entry_(thread),
      exit_(thread),
      frames_(thread),
      current_frame_(nullptr),
      thread_(thread) {
  ASSERT(cross_thread_policy == kAllowCrossThreadIteration ||
         thread_ == Thread::Current());
  frames_.fp_ = last_fp;
  frames_.sp_ = 0;
  frames_.pc_ = 0;
  frames_.Unpoison();
}

StackFrameIterator() [3/4]

dart::StackFrameIterator::StackFrameIterator	(	uword	fp,
		uword	sp,
		uword	pc,
		ValidationPolicy	validation_policy,
		Thread *	thread,
		CrossThreadPolicy	cross_thread_policy
	)

Definition at line 516 of file stack_frame.cc.

    : validate_(validation_policy == ValidationPolicy::kValidateFrames),
      entry_(thread),
      exit_(thread),
      frames_(thread),
      current_frame_(nullptr),
      thread_(thread) {
  ASSERT(cross_thread_policy == kAllowCrossThreadIteration ||
         thread_ == Thread::Current());
  frames_.fp_ = fp;
  frames_.sp_ = sp;
  frames_.pc_ = pc;
  frames_.Unpoison();
}

StackFrameIterator() [4/4]

dart::StackFrameIterator::StackFrameIterator ( const StackFrameIterator &  orig )

explicit

Definition at line 536 of file stack_frame.cc.

    : validate_(orig.validate_),
      entry_(orig.thread_),
      exit_(orig.thread_),
      frames_(orig.thread_),
      current_frame_(nullptr),
      thread_(orig.thread_) {
  frames_.fp_ = orig.frames_.fp_;
  frames_.sp_ = orig.frames_.sp_;
  frames_.pc_ = orig.frames_.pc_;
  frames_.Unpoison();
}

Member Function Documentation

HasNextFrame()

bool dart::StackFrameIterator::HasNextFrame ( ) const

inline

Definition at line 247 of file stack_frame.h.

{ return frames_.fp_ != 0; }

NextFrame()

StackFrame * dart::StackFrameIterator::NextFrame

(

)

Definition at line 549 of file stack_frame.cc.

                                          {
  // When we are at the start of iteration after having created an
  // iterator object, current_frame_ will be nullptr as we haven't seen
  // any frames yet (unless we start iterating in the simulator from a given
  // triplet of fp, sp, and pc). At this point, if NextFrame is called, it tries
  // to set up the next exit frame by reading the top_exit_frame_info
  // from the isolate. If we do not have any dart invocations yet,
  // top_exit_frame_info will be 0 and so we would return nullptr.
 
  // current_frame_ will also be nullptr, when we are at the end of having
  // iterated through all the frames. If NextFrame is called at this
  // point, we will try and set up the next exit frame, but since we are
  // at the end of the iteration, fp_ will be 0 and we would return nullptr.
  if (current_frame_ == nullptr) {
    if (!HasNextFrame()) {
      return nullptr;
    }
    if (frames_.pc_ == 0) {
      // Iteration starts from an exit frame given by its fp.
      current_frame_ = NextExitFrame();
    } else if (*(reinterpret_cast<uword*>(
                   frames_.fp_ + (kSavedCallerFpSlotFromFp * kWordSize))) ==
               0) {
      // Iteration starts from an entry frame given by its fp, sp, and pc.
      current_frame_ = NextEntryFrame();
    } else {
      // Iteration starts from a Dart or stub frame given by its fp, sp, and pc.
      current_frame_ = frames_.NextFrame(validate_);
    }
    return current_frame_;
  }
  ASSERT(!validate_ || current_frame_->IsValid());
  if (current_frame_->IsEntryFrame()) {
    if (HasNextFrame()) {  // We have another chained block.
      current_frame_ = NextExitFrame();
      return current_frame_;
    }
    current_frame_ = nullptr;  // No more frames.
    return current_frame_;
  }
  ASSERT(!validate_ || current_frame_->IsExitFrame() ||
         current_frame_->IsDartFrame(validate_) ||
         current_frame_->IsStubFrame());
 
  // Consume dart/stub frames using StackFrameIterator::FrameSetIterator
  // until we are out of dart/stub frames at which point we return the
  // corresponding entry frame for that set of dart/stub frames.
  current_frame_ =
      (frames_.HasNext()) ? frames_.NextFrame(validate_) : NextEntryFrame();
  return current_frame_;
}

validate()

bool dart::StackFrameIterator::validate ( ) const

inline

Definition at line 252 of file stack_frame.h.

{ return validate_; }

Friends And Related Symbol Documentation

ProfilerDartStackWalker

friend class ProfilerDartStackWalker

friend

Definition at line 309 of file stack_frame.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/stack_frame.h
• third_party/dart-lang/sdk/runtime/vm/stack_frame.cc