dart::StackFrame Class Reference

#include <stack_frame.h>

Inheritance diagram for dart::StackFrame:

Public Member Functions
virtual	~StackFrame ()
uword	sp () const
uword	fp () const
uword	pc () const
bool	IsMarkedForLazyDeopt () const
void	MarkForLazyDeopt ()
void	UnmarkForLazyDeopt ()
void	set_pc (uword value)
void	set_pc_marker (CodePtr code)
virtual void	VisitObjectPointers (ObjectPointerVisitor *visitor)
const char *	ToCString () const
virtual bool	IsValid () const
bool	IsBareInstructionsDartFrame () const
bool	IsBareInstructionsStubFrame () const
virtual bool	IsDartFrame (bool validate=true) const
virtual bool	IsStubFrame () const
virtual bool	IsEntryFrame () const
virtual bool	IsExitFrame () const
FunctionPtr	LookupDartFunction () const
CodePtr	LookupDartCode () const
bool	FindExceptionHandler (Thread *thread, uword *handler_pc, bool *needs_stacktrace, bool *is_catch_all, bool *is_optimized) const
TokenPosition	GetTokenPos () const
uword	GetCallerSp () const
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Static Public Member Functions
static int	SavedCallerPpSlotFromFp ()
static void	DumpCurrentTrace ()

Protected Member Functions
	StackFrame (Thread *thread)
virtual const char *	GetName () const
Isolate *	isolate () const
IsolateGroup *	isolate_group () const
Thread *	thread () const

Friends
class	FrameSetIterator
class	StackFrameIterator
class	UntaggedSuspendState
class	ProfilerDartStackWalker

Detailed Description

Definition at line 36 of file stack_frame.h.

Constructor & Destructor Documentation

~StackFrame()

virtual dart::StackFrame::~StackFrame ( )

inlinevirtual

Definition at line 38 of file stack_frame.h.

{}

StackFrame()

dart::StackFrame::StackFrame ( Thread *  thread )

inlineexplicitprotected

Definition at line 120 of file stack_frame.h.

      : fp_(0), sp_(0), pc_(0), thread_(thread) {}

Member Function Documentation

DumpCurrentTrace()

void dart::StackFrame::DumpCurrentTrace ( )

static

Definition at line 454 of file stack_frame.cc.

                                  {
  StackFrameIterator frames(ValidationPolicy::kDontValidateFrames,
                            Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
  StackFrame* frame = frames.NextFrame();
  while (frame != nullptr) {
    OS::PrintErr("%s\n", frame->ToCString());
    frame = frames.NextFrame();
  }
}

FindExceptionHandler()

bool dart::StackFrame::FindExceptionHandler	(	Thread *	thread,
		uword *	handler_pc,
		bool *	needs_stacktrace,
		bool *	is_catch_all,
		bool *	is_optimized
	)		const

Definition at line 370 of file stack_frame.cc.

                                                                {
  REUSABLE_CODE_HANDLESCOPE(thread);
  Code& code = reused_code_handle.Handle();
  REUSABLE_EXCEPTION_HANDLERS_HANDLESCOPE(thread);
  ExceptionHandlers& handlers = reused_exception_handlers_handle.Handle();
  REUSABLE_PC_DESCRIPTORS_HANDLESCOPE(thread);
  PcDescriptors& descriptors = reused_pc_descriptors_handle.Handle();
  uword start;
  code = LookupDartCode();
  if (code.IsNull()) {
    return false;  // Stub frames do not have exception handlers.
  }
  start = code.PayloadStart();
  handlers = code.exception_handlers();
  descriptors = code.pc_descriptors();
  *is_optimized = code.is_optimized();
  HandlerInfoCache* cache = thread->isolate()->handler_info_cache();
  ExceptionHandlerInfo* info = cache->Lookup(pc());
  if (info != nullptr) {
    *handler_pc = start + info->handler_pc_offset;
    *needs_stacktrace = (info->needs_stacktrace != 0);
    *has_catch_all = (info->has_catch_all != 0);
    return true;
  }
 
  intptr_t try_index = -1;
  if (handlers.num_entries() != 0) {
    uword pc_offset = pc() - code.PayloadStart();
    PcDescriptors::Iterator iter(descriptors, UntaggedPcDescriptors::kAnyKind);
    while (iter.MoveNext()) {
      const intptr_t current_try_index = iter.TryIndex();
      if ((iter.PcOffset() == pc_offset) && (current_try_index != -1)) {
        try_index = current_try_index;
        break;
      }
    }
  }
  if (try_index == -1) {
    if (handlers.has_async_handler()) {
      *handler_pc = StubCode::AsyncExceptionHandler().EntryPoint();
      *needs_stacktrace = true;
      *has_catch_all = true;
      return true;
    }
    return false;
  }
  ExceptionHandlerInfo handler_info;
  handlers.GetHandlerInfo(try_index, &handler_info);
  *handler_pc = start + handler_info.handler_pc_offset;
  *needs_stacktrace = (handler_info.needs_stacktrace != 0);
  *has_catch_all = (handler_info.has_catch_all != 0);
  cache->Insert(pc(), handler_info);
  return true;
}

fp()

uword dart::StackFrame::fp ( ) const

inline

Definition at line 42 of file stack_frame.h.

{ return fp_; }

GetCallerSp()

uword dart::StackFrame::GetCallerSp ( ) const

inline

Definition at line 117 of file stack_frame.h.

{ return fp() + (kCallerSpSlotFromFp * kWordSize); }

GetName()

virtual const char * dart::StackFrame::GetName ( ) const

inlineprotectedvirtual

Reimplemented in dart::ExitFrame, and dart::EntryFrame.

Definition at line 124 of file stack_frame.h.

                                      {
    if (IsBareInstructionsStubFrame()) return "bare-stub";
    if (IsStubFrame()) return "stub";
    return IsBareInstructionsDartFrame() ? "bare-dart" : "dart";
  }

GetTokenPos()

TokenPosition dart::StackFrame::GetTokenPos

(

)

const

Definition at line 429 of file stack_frame.cc.

                                            {
  const Code& code = Code::Handle(LookupDartCode());
  if (code.IsNull()) {
    return TokenPosition::kNoSource;  // Stub frames do not have token_pos.
  }
  uword pc_offset = pc() - code.PayloadStart();
  const PcDescriptors& descriptors =
      PcDescriptors::Handle(code.pc_descriptors());
  ASSERT(!descriptors.IsNull());
  PcDescriptors::Iterator iter(descriptors, UntaggedPcDescriptors::kAnyKind);
  while (iter.MoveNext()) {
    if (iter.PcOffset() == pc_offset) {
      return TokenPosition(iter.TokenPos());
    }
  }
  return TokenPosition::kNoSource;
}

IsBareInstructionsDartFrame()

bool dart::StackFrame::IsBareInstructionsDartFrame

(

)

const

Definition at line 114 of file stack_frame.cc.

                                                   {
  if (!FLAG_precompiled_mode) {
    return false;
  }
  NoSafepointScope no_safepoint;
 
  Code code;
  code = ReversePc::Lookup(this->isolate_group(), pc(),
                           /*is_return_address=*/true);
  if (!code.IsNull()) {
    auto const cid = code.OwnerClassId();
    ASSERT(cid == kNullCid || cid == kClassCid || cid == kFunctionCid);
    return cid == kFunctionCid;
  }
 
  return false;
}

IsBareInstructionsStubFrame()

bool dart::StackFrame::IsBareInstructionsStubFrame

(

)

const

Definition at line 132 of file stack_frame.cc.

                                                   {
  if (!FLAG_precompiled_mode) {
    return false;
  }
  NoSafepointScope no_safepoint;
 
  Code code;
  code = ReversePc::Lookup(this->isolate_group(), pc(),
                           /*is_return_address=*/true);
  if (!code.IsNull()) {
    auto const cid = code.OwnerClassId();
    ASSERT(cid == kNullCid || cid == kClassCid || cid == kFunctionCid);
    return cid == kNullCid || cid == kClassCid;
  }
 
  return false;
}

IsDartFrame()

virtual bool dart::StackFrame::IsDartFrame ( bool  validate = true ) const

inlinevirtual

Reimplemented in dart::ExitFrame, and dart::EntryFrame.

Definition at line 97 of file stack_frame.h.

                                                       {
    ASSERT(!validate || IsValid());
    return !(IsEntryFrame() || IsExitFrame() || IsStubFrame());
  }

IsEntryFrame()

virtual bool dart::StackFrame::IsEntryFrame ( ) const

inlinevirtual

Reimplemented in dart::EntryFrame.

Definition at line 102 of file stack_frame.h.

{ return false; }

IsExitFrame()

virtual bool dart::StackFrame::IsExitFrame ( ) const

inlinevirtual

Reimplemented in dart::ExitFrame.

Definition at line 103 of file stack_frame.h.

{ return false; }

IsMarkedForLazyDeopt()

bool dart::StackFrame::IsMarkedForLazyDeopt ( ) const

inline

Definition at line 55 of file stack_frame.h.

                                    {
    uword raw_pc =
        *reinterpret_cast<uword*>(sp() + (kSavedPcSlotFromSp * kWordSize));
    return raw_pc == StubCode::DeoptimizeLazyFromReturn().EntryPoint();
  }

isolate()

Isolate * dart::StackFrame::isolate ( ) const

inlineprotected

Definition at line 130 of file stack_frame.h.

{ return thread_->isolate(); }

isolate_group()

IsolateGroup * dart::StackFrame::isolate_group ( ) const

inlineprotected

Definition at line 131 of file stack_frame.h.

{ return thread_->isolate_group(); }

IsStubFrame()

bool dart::StackFrame::IsStubFrame ( ) const

virtual

Reimplemented in dart::ExitFrame, and dart::EntryFrame.

Definition at line 150 of file stack_frame.cc.

                                   {
  if (FLAG_precompiled_mode) {
    return IsBareInstructionsStubFrame();
  }
 
  ASSERT(!(IsEntryFrame() || IsExitFrame()));
#if !defined(DART_HOST_OS_WINDOWS) && !defined(DART_HOST_OS_FUCHSIA)
  // On Windows and Fuchsia, the profiler calls this from a separate thread
  // where Thread::Current() is nullptr, so we cannot create a NoSafepointScope.
  NoSafepointScope no_safepoint;
#endif
 
  CodePtr code = GetCodeObject();
  ASSERT(code != Object::null());
  auto const cid = Code::OwnerClassIdOf(code);
  ASSERT(cid == kNullCid || cid == kClassCid || cid == kFunctionCid);
  return cid == kNullCid || cid == kClassCid;
}

IsValid()

bool dart::StackFrame::IsValid ( ) const

virtual

Reimplemented in dart::ExitFrame, and dart::EntryFrame.

Definition at line 447 of file stack_frame.cc.

                               {
  if (IsEntryFrame() || IsExitFrame() || IsStubFrame()) {
    return true;
  }
  return (LookupDartCode() != Code::null());
}

LookupDartCode()

CodePtr dart::StackFrame::LookupDartCode

(

)

const

Definition at line 336 of file stack_frame.cc.

                                         {
// We add a no gc scope to ensure that the code below does not trigger
// a GC as we are handling raw object references here. It is possible
// that the code is called while a GC is in progress, that is ok.
#if !defined(DART_HOST_OS_WINDOWS) && !defined(DART_HOST_OS_FUCHSIA)
  // On Windows and Fuchsia, the profiler calls this from a separate thread
  // where Thread::Current() is nullptr, so we cannot create a NoSafepointScope.
  NoSafepointScope no_safepoint;
#endif
  CodePtr code = GetCodeObject();
  if ((code != Code::null()) && Code::OwnerClassIdOf(code) == kFunctionCid) {
    return code;
  }
  return Code::null();
}

LookupDartFunction()

FunctionPtr dart::StackFrame::LookupDartFunction

(

)

const

Definition at line 325 of file stack_frame.cc.

                                                 {
  const Code& code = Code::Handle(LookupDartCode());
  if (!code.IsNull()) {
    const Object& owner = Object::Handle(code.owner());
    if (owner.IsFunction()) {
      return Function::Cast(owner).ptr();
    }
  }
  return Function::null();
}

MarkForLazyDeopt()

void dart::StackFrame::MarkForLazyDeopt ( )

inline

Definition at line 60 of file stack_frame.h.

                          {
    set_pc(StubCode::DeoptimizeLazyFromReturn().EntryPoint());
  }

pc()

uword dart::StackFrame::pc ( ) const

inline

Definition at line 43 of file stack_frame.h.

{ return pc_; }

SavedCallerPpSlotFromFp()

static int dart::StackFrame::SavedCallerPpSlotFromFp ( )

inlinestatic

Definition at line 46 of file stack_frame.h.

                                       {
    if (runtime_frame_layout.saved_caller_pp_from_fp !=
        kSavedCallerFpSlotFromFp) {
      return runtime_frame_layout.saved_caller_pp_from_fp;
    }
    UNREACHABLE();
    return 0;
  }

set_pc()

void dart::StackFrame::set_pc ( uword  value )

inline

Definition at line 72 of file stack_frame.h.

                           {
    *reinterpret_cast<uword*>(sp() + (kSavedPcSlotFromSp * kWordSize)) = value;
    pc_ = value;
  }

set_pc_marker()

void dart::StackFrame::set_pc_marker ( CodePtr  code )

inline

Definition at line 77 of file stack_frame.h.

                                   {
    *reinterpret_cast<CodePtr*>(
        fp() + (runtime_frame_layout.code_from_fp * kWordSize)) = code;
  }

sp()

uword dart::StackFrame::sp ( ) const

inline

Definition at line 41 of file stack_frame.h.

{ return sp_; }

thread()

Thread * dart::StackFrame::thread ( ) const

inlineprotected

Definition at line 133 of file stack_frame.h.

{ return thread_; }

ToCString()

const char * dart::StackFrame::ToCString

(

)

const

Definition at line 169 of file stack_frame.cc.

                                        {
  ASSERT(thread_ == Thread::Current());
  Zone* zone = Thread::Current()->zone();
  const Code& code = Code::Handle(zone, GetCodeObject());
  const char* name =
      code.IsNull()
          ? "Cannot find code object"
          : code.QualifiedName(NameFormattingParams(Object::kInternalName));
  return zone->PrintToString("  pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp " %s",
                             pc(), fp(), sp(), name);
}

UnmarkForLazyDeopt()

void dart::StackFrame::UnmarkForLazyDeopt ( )

inline

Definition at line 63 of file stack_frame.h.

                            {
    // If this frame was marked for lazy deopt, pc_ was computed to be the
    // original return address using the pending deopts table in GetCallerPc.
    // Write this value back into the frame.
    uword original_pc = pc();
    ASSERT(original_pc != StubCode::DeoptimizeLazyFromReturn().EntryPoint());
    set_pc(original_pc);
  }

VisitObjectPointers()

void dart::StackFrame::VisitObjectPointers ( ObjectPointerVisitor *  visitor )

virtual

Reimplemented in dart::ExitFrame, and dart::EntryFrame.

Definition at line 206 of file stack_frame.cc.

                                                                  {
  ASSERT(visitor != nullptr);
  // NOTE: This code runs while GC is in progress and runs within
  // a NoHandleScope block. Hence it is not ok to use regular Zone or
  // Scope handles. We use direct stack handles, the raw pointers in
  // these handles are not traversed. The use of handles is mainly to
  // be able to reuse the handle based code and avoid having to add
  // helper functions to the raw object interface.
  NoSafepointScope no_safepoint;
  Code code;
 
  CompressedStackMaps::RawPayloadHandle maps;
  CompressedStackMaps::RawPayloadHandle global_table;
 
  uword code_start;
 
  if (FLAG_precompiled_mode) {
    const UntaggedCompressedStackMaps::Payload* global_table_payload;
    maps = ReversePc::FindStackMap(isolate_group(), pc(),
                                   /*is_return_address=*/true, &code_start,
                                   &global_table_payload);
    global_table = global_table_payload;
  } else {
    ObjectPtr pc_marker = *(reinterpret_cast<ObjectPtr*>(
        fp() + (runtime_frame_layout.code_from_fp * kWordSize)));
    // May forward raw code. Note we don't just visit the pc marker slot first
    // because the visitor's forwarding might not be idempotent.
    visitor->VisitPointer(&pc_marker);
    if (pc_marker->IsHeapObject() && (pc_marker->GetClassId() == kCodeCid)) {
      code ^= pc_marker;
      code_start = code.PayloadStart();
      ASSERT(code.compressed_stackmaps() != CompressedStackMaps::null());
      maps = code.compressed_stackmaps();
      if (maps.UsesGlobalTable()) {
        global_table =
            isolate_group()->object_store()->canonicalized_stack_map_entries();
      }
    } else {
      ASSERT(pc_marker == Object::null());
    }
  }
 
  if (!maps.IsNull()) {
    // Optimized frames have a stack map. We need to visit the frame based
    // on the stack map.
    CompressedStackMaps::Iterator<CompressedStackMaps::RawPayloadHandle> it(
        maps, global_table);
    const uint32_t pc_offset = pc() - code_start;
    if (it.Find(pc_offset)) {
      ObjectPtr* first = reinterpret_cast<ObjectPtr*>(sp());
      ObjectPtr* last = reinterpret_cast<ObjectPtr*>(
          fp() + (runtime_frame_layout.first_local_from_fp * kWordSize));
 
      // A stack map is present in the code object, use the stack map to
      // visit frame slots which are marked as having objects.
      //
      // The layout of the frame is (lower addresses to the right):
      // | spill slots | outgoing arguments | saved registers | slow-path args |
      // |XXXXXXXXXXXXX|--------------------|XXXXXXXXXXXXXXXXX|XXXXXXXXXXXXXXXX|
      //
      // The spill slots and any saved registers are described in the stack
      // map.  The outgoing arguments are assumed to be tagged; the number
      // of outgoing arguments is not explicitly tracked.
 
      // Spill slots are at the 'bottom' of the frame.
      intptr_t spill_slot_count = it.SpillSlotBitCount();
      for (intptr_t bit = 0; bit < spill_slot_count; ++bit) {
        if (it.IsObject(bit)) {
          visitor->VisitPointer(last);
        }
        --last;
      }
 
      // The live registers at the 'top' of the frame comprise the rest of the
      // stack map.
      for (intptr_t bit = it.Length() - 1; bit >= spill_slot_count; --bit) {
        if (it.IsObject(bit)) {
          visitor->VisitPointer(first);
        }
        ++first;
      }
 
      // The last slot can be one slot (but not more) past the last slot
      // in the case that all slots were covered by the stack map.
      ASSERT((last + 1) >= first);
      visitor->VisitPointers(first, last);
 
      // Now visit other slots which might be part of the calling convention.
      first = reinterpret_cast<ObjectPtr*>(
          fp() + ((runtime_frame_layout.first_local_from_fp + 1) * kWordSize));
      last = reinterpret_cast<ObjectPtr*>(
          fp() + (runtime_frame_layout.first_object_from_fp * kWordSize));
      visitor->VisitPointers(first, last);
      return;
    }
 
    // If we are missing a stack map for a given PC offset, this must either be
    // unoptimized code, code with no stack map information at all, or the entry
    // to an osr function. In each of these cases, all stack slots contain
    // tagged pointers, so fall through.
#if defined(DEBUG)
    if (FLAG_precompiled_mode) {
      ASSERT(IsStubFrame());
    } else {
      ASSERT(!code.is_optimized() ||
             (pc_offset == code.EntryPoint() - code.PayloadStart()));
    }
#endif  // defined(DEBUG)
  }
 
  // For normal unoptimized Dart frames and Stub frames each slot
  // between the first and last included are tagged objects.
  ObjectPtr* first = reinterpret_cast<ObjectPtr*>(sp());
  ObjectPtr* last = reinterpret_cast<ObjectPtr*>(
      fp() + (runtime_frame_layout.first_object_from_fp * kWordSize));
 
  visitor->VisitPointers(first, last);
}

Friends And Related Function Documentation

FrameSetIterator

friend class FrameSetIterator

friend

Definition at line 160 of file stack_frame.h.

ProfilerDartStackWalker

friend class ProfilerDartStackWalker

friend

Definition at line 165 of file stack_frame.h.

StackFrameIterator

friend class StackFrameIterator

friend

Definition at line 161 of file stack_frame.h.

UntaggedSuspendState

friend class UntaggedSuspendState

friend

Definition at line 164 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