v8::internal::SafeStackFrameIterator Class Reference

#include <frames.h>

Inheritance diagram for v8::internal::SafeStackFrameIterator:

Collaboration diagram for v8::internal::SafeStackFrameIterator:

Public Member Functions
	SafeStackFrameIterator (Isolate *isolate, Address fp, Address sp, Address js_entry_sp)
StackFrame *	frame () const
void	Advance ()
StackFrame::Type	top_frame_type () const

Private Member Functions
void	AdvanceOneFrame ()
bool	IsValidStackAddress (Address addr) const
bool	IsValidFrame (StackFrame *frame) const
bool	IsValidCaller (StackFrame *frame)
bool	IsValidExitFrame (Address fp) const
bool	IsValidTop (ThreadLocalTop *top) const

Private Attributes
const Address	low_bound_
const Address	high_bound_
StackFrame::Type	top_frame_type_
ExternalCallbackScope *	external_callback_scope_

Detailed Description

Definition at line 893 of file frames.h.

Constructor & Destructor Documentation

SafeStackFrameIterator()

v8::internal::SafeStackFrameIterator::SafeStackFrameIterator	(	Isolate *	isolate,
		Address	fp,
		Address	sp,
		Address	js_entry_sp
	)

Definition at line 194 of file frames.cc.

    : StackFrameIteratorBase(isolate, false),
      low_bound_(sp),
      high_bound_(js_entry_sp),
      top_frame_type_(StackFrame::NONE),
      external_callback_scope_(isolate->external_callback_scope()) {
  StackFrame::State state;
  StackFrame::Type type;
  ThreadLocalTop* top = isolate->thread_local_top();
  if (IsValidTop(top)) {
    type = ExitFrame::GetStateForFramePointer(Isolate::c_entry_fp(top), &state);
    top_frame_type_ = type;
  } else if (IsValidStackAddress(fp)) {
    DCHECK(fp != NULL);
    state.fp = fp;
    state.sp = sp;
    state.pc_address = StackFrame::ResolveReturnAddressLocation(
        reinterpret_cast<Address*>(StandardFrame::ComputePCAddress(fp)));
    // StackFrame::ComputeType will read both kContextOffset and kMarkerOffset,
    // we check only that kMarkerOffset is within the stack bounds and do
    // compile time check that kContextOffset slot is pushed on the stack before
    // kMarkerOffset.
    STATIC_ASSERT(StandardFrameConstants::kMarkerOffset <
                  StandardFrameConstants::kContextOffset);
    Address frame_marker = fp + StandardFrameConstants::kMarkerOffset;
    if (IsValidStackAddress(frame_marker)) {
      type = StackFrame::ComputeType(this, &state);
      top_frame_type_ = type;
    } else {
      // Mark the frame as JAVA_SCRIPT if we cannot determine its type.
      // The frame anyways will be skipped.
      type = StackFrame::JAVA_SCRIPT;
      // Top frame is incomplete so we cannot reliably determine its type.
      top_frame_type_ = StackFrame::NONE;
    }
  } else {
    return;
  }
  if (SingletonFor(type) == NULL) return;
  frame_ = SingletonFor(type, &state);
  if (frame_ == NULL) return;
 
  Advance();
 
  if (frame_ != NULL && !frame_->is_exit() &&
      external_callback_scope_ != NULL &&
      external_callback_scope_->scope_address() < frame_->fp()) {
    // Skip top ExternalCallbackScope if we already advanced to a JS frame
    // under it. Sampler will anyways take this top external callback.
    external_callback_scope_ = external_callback_scope_->previous();
  }
}

References Advance(), v8::internal::Isolate::c_entry_fp(), v8::internal::StandardFrame::ComputePCAddress(), DCHECK, external_callback_scope_, v8::internal::fp, v8::internal::ExitFrame::GetStateForFramePointer(), IsValidStackAddress(), IsValidTop(), v8::internal::StandardFrameConstants::kContextOffset, v8::internal::StandardFrameConstants::kMarkerOffset, NONE, NULL, v8::internal::sp, v8::internal::STATIC_ASSERT(), v8::internal::Isolate::thread_local_top(), and top_frame_type_.

Here is the call graph for this function:

Member Function Documentation

Advance()

void v8::internal::SafeStackFrameIterator::Advance

(

)

Definition at line 327 of file frames.cc.

                                     {
  while (true) {
    AdvanceOneFrame();
    if (done()) return;
    if (frame_->is_java_script()) return;
    if (frame_->is_exit() && external_callback_scope_) {
      // Some of the EXIT frames may have ExternalCallbackScope allocated on
      // top of them. In that case the scope corresponds to the first EXIT
      // frame beneath it. There may be other EXIT frames on top of the
      // ExternalCallbackScope, just skip them as we cannot collect any useful
      // information about them.
      if (external_callback_scope_->scope_address() < frame_->fp()) {
        Address* callback_address =
            external_callback_scope_->callback_address();
        if (*callback_address != NULL) {
          frame_->state_.pc_address = callback_address;
        }
        external_callback_scope_ = external_callback_scope_->previous();
        DCHECK(external_callback_scope_ == NULL ||
               external_callback_scope_->scope_address() > frame_->fp());
        return;
      }
    }
  }
}

References AdvanceOneFrame(), DCHECK, external_callback_scope_, and NULL.

Referenced by v8::internal::TickSample::Init(), and SafeStackFrameIterator().

Here is the call graph for this function:

Here is the caller graph for this function:

AdvanceOneFrame()

void v8::internal::SafeStackFrameIterator::AdvanceOneFrame ( )

private

Definition at line 261 of file frames.cc.

                                             {
  DCHECK(!done());
  StackFrame* last_frame = frame_;
  Address last_sp = last_frame->sp(), last_fp = last_frame->fp();
  // Before advancing to the next stack frame, perform pointer validity tests.
  if (!IsValidFrame(last_frame) || !IsValidCaller(last_frame)) {
    frame_ = NULL;
    return;
  }
 
  // Advance to the previous frame.
  StackFrame::State state;
  StackFrame::Type type = frame_->GetCallerState(&state);
  frame_ = SingletonFor(type, &state);
  if (frame_ == NULL) return;
 
  // Check that we have actually moved to the previous frame in the stack.
  if (frame_->sp() < last_sp || frame_->fp() < last_fp) {
    frame_ = NULL;
  }
}

References DCHECK, IsValidCaller(), IsValidFrame(), and NULL.

Referenced by Advance().

Here is the call graph for this function:

Here is the caller graph for this function:

frame()

StackFrame * v8::internal::SafeStackFrameIterator::frame ( ) const

inline

Definition at line 325 of file frames-inl.h.

                                                       {
  DCHECK(!done());
  DCHECK(frame_->is_java_script() || frame_->is_exit());
  return frame_;
}

References DCHECK.

Referenced by v8::internal::TickSample::Init(), IsValidCaller(), and IsValidFrame().

Here is the caller graph for this function:

IsValidCaller()

bool v8::internal::SafeStackFrameIterator::IsValidCaller ( StackFrame *  frame )

private

Definition at line 289 of file frames.cc.

                                                            {
  StackFrame::State state;
  if (frame->is_entry() || frame->is_entry_construct()) {
    // See EntryFrame::GetCallerState. It computes the caller FP address
    // and calls ExitFrame::GetStateForFramePointer on it. We need to be
    // sure that caller FP address is valid.
    Address caller_fp = Memory::Address_at(
        frame->fp() + EntryFrameConstants::kCallerFPOffset);
    if (!IsValidExitFrame(caller_fp)) return false;
  } else if (frame->is_arguments_adaptor()) {
    // See ArgumentsAdaptorFrame::GetCallerStackPointer. It assumes that
    // the number of arguments is stored on stack as Smi. We need to check
    // that it really an Smi.
    Object* number_of_args = reinterpret_cast<ArgumentsAdaptorFrame*>(frame)->
        GetExpression(0);
    if (!number_of_args->IsSmi()) {
      return false;
    }
  }
  frame->ComputeCallerState(&state);
  return IsValidStackAddress(state.sp) && IsValidStackAddress(state.fp) &&
      SingletonFor(frame->GetCallerState(&state)) != NULL;
}

References v8::internal::Memory::Address_at(), frame(), IsValidExitFrame(), IsValidStackAddress(), v8::internal::EntryFrameConstants::kCallerFPOffset, and NULL.

Referenced by AdvanceOneFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidExitFrame()

bool v8::internal::SafeStackFrameIterator::IsValidExitFrame ( Address  fp ) const

private

Definition at line 314 of file frames.cc.

                                                              {
  if (!IsValidStackAddress(fp)) return false;
  Address sp = ExitFrame::ComputeStackPointer(fp);
  if (!IsValidStackAddress(sp)) return false;
  StackFrame::State state;
  ExitFrame::FillState(fp, sp, &state);
  if (!IsValidStackAddress(reinterpret_cast<Address>(state.pc_address))) {
    return false;
  }
  return *state.pc_address != NULL;
}

References v8::internal::ExitFrame::ComputeStackPointer(), v8::internal::ExitFrame::FillState(), v8::internal::fp, IsValidStackAddress(), NULL, and v8::internal::sp.

Referenced by IsValidCaller(), and IsValidTop().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidFrame()

bool v8::internal::SafeStackFrameIterator::IsValidFrame ( StackFrame *  frame ) const

private

Definition at line 284 of file frames.cc.

                                                                 {
  return IsValidStackAddress(frame->sp()) && IsValidStackAddress(frame->fp());
}

References frame(), and IsValidStackAddress().

Referenced by AdvanceOneFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidStackAddress()

bool v8::internal::SafeStackFrameIterator::IsValidStackAddress ( Address  addr ) const

inlineprivate

Definition at line 907 of file frames.h.

                                               {
    return low_bound_ <= addr && addr <= high_bound_;
  }

Referenced by IsValidCaller(), IsValidExitFrame(), IsValidFrame(), and SafeStackFrameIterator().

Here is the caller graph for this function:

IsValidTop()

bool v8::internal::SafeStackFrameIterator::IsValidTop ( ThreadLocalTop *  top ) const

private

Definition at line 250 of file frames.cc.

                                                                 {
  Address c_entry_fp = Isolate::c_entry_fp(top);
  if (!IsValidExitFrame(c_entry_fp)) return false;
  // There should be at least one JS_ENTRY stack handler.
  Address handler = Isolate::handler(top);
  if (handler == NULL) return false;
  // Check that there are no js frames on top of the native frames.
  return c_entry_fp < handler;
}

References v8::internal::Isolate::c_entry_fp(), v8::internal::Isolate::handler(), IsValidExitFrame(), and NULL.

Referenced by SafeStackFrameIterator().

Here is the call graph for this function:

Here is the caller graph for this function:

top_frame_type()

StackFrame::Type v8::internal::SafeStackFrameIterator::top_frame_type ( ) const

inline

Definition at line 902 of file frames.h.

{ return top_frame_type_; }

Referenced by v8::internal::TickSample::Init().

Here is the caller graph for this function:

Member Data Documentation

external_callback_scope_

ExternalCallbackScope* v8::internal::SafeStackFrameIterator::external_callback_scope_

private

Definition at line 918 of file frames.h.

Referenced by Advance(), and SafeStackFrameIterator().

high_bound_

const Address v8::internal::SafeStackFrameIterator::high_bound_

private

Definition at line 916 of file frames.h.

low_bound_

const Address v8::internal::SafeStackFrameIterator::low_bound_

private

Definition at line 915 of file frames.h.

top_frame_type_

StackFrame::Type v8::internal::SafeStackFrameIterator::top_frame_type_

private

Definition at line 917 of file frames.h.

Referenced by SafeStackFrameIterator().

---

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

• /mnt/V8SourceCode/src/frames.h
• /mnt/V8SourceCode/src/frames-inl.h
• /mnt/V8SourceCode/src/frames.cc