28#include "llvm/ADT/SmallPtrSet.h"
40 bool show_inline_frames)
41 : m_thread(thread), m_prev_frames_sp(prev_frames_sp), m_frames(),
42 m_selected_frame_idx(), m_concrete_frames_fetched(0),
45 m_show_inlined_frames(show_inline_frames) {
76 "GetCurrentInlinedDepth: invalidating current inlined depth.\n");
93 auto inline_depth = stop_info_sp->GetSuggestedStackFrameIndex(inlined);
103 "ResetCurrentInlinedDepth: setting inlined "
104 "depth: %d 0x%" PRIx64
".\n",
113 "ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
121 if (current_inlined_depth > 0) {
141 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
164 LLDB_LOG(log,
"Finding frames between {0} and {1}, retn-pc={2:x}",
170 LLDB_LOG(log,
"FindInterveningFrames: found call with retn-PC = {0:x}",
171 edge->GetReturnPCAddress(begin, target));
174 LLDB_LOG(log,
"No call edge outgoing from {0} with retn-PC == {1:x}",
182 LLDB_LOG(log,
"Could not resolve callee");
185 if (first_callee == &end) {
186 LLDB_LOG(log,
"Not searching further, first callee is {0} (retn-PC: {1:x})",
197 llvm::SmallPtrSet<Function *, 2> visited_nodes = {};
198 bool ambiguous =
false;
206 : end(end), images(images), target(target), context(context) {}
210 dfs(first_edge, first_callee);
212 path = std::move(solution_path);
217 if (&callee == end) {
218 if (solution_path.empty())
219 solution_path = active_path;
229 if (!visited_nodes.insert(&callee).second) {
237 Function *next_callee = edge->GetCallee(images, context);
241 std::tie(active_path.back().address_type, active_path.back().address) =
242 edge->GetCallerAddress(callee, target);
244 dfs(*edge, *next_callee);
248 active_path.pop_back();
252 DFS(&end, images, target, exe_ctx).search(*first_edge, *first_callee, path);
281 if (!next_reg_ctx_sp)
293 LLDB_LOG(log,
"SynthesizeTailCallFrames: can't find previous function");
299 LLDB_LOG(log,
"SynthesizeTailCallFrames: can't find next function");
306 addr_t return_pc = next_reg_ctx_sp->GetPC();
307 Target &target = *target_sp.get();
315 for (
auto calleeInfo : llvm::reverse(path)) {
317 uint32_t frame_idx =
m_frames.size();
320 bool cfa_is_valid =
false;
324 const bool behaves_like_zeroth_frame =
328 auto synth_frame = std::make_shared<StackFrame>(
329 m_thread.shared_from_this(), frame_idx, concrete_frame_idx, cfa,
331 behaves_like_zeroth_frame, &sc);
345 std::unique_lock<std::shared_mutex> guard(
m_list_mutex);
352 bool was_interrupted =
false;
369#if defined(DEBUG_STACK_FRAMES)
370 s.PutCString(
"\n\nNew frames:\n");
374 return was_interrupted;
379 assert(
m_frames.size() <= end_idx &&
"Expected there to be frames to fill");
387 if (num_frames <= end_idx + 1) {
400 bool was_interrupted =
false;
402#if defined(DEBUG_STACK_FRAMES)
411 uint32_t inlined_depth = 0;
416 end_idx += inlined_depth;
426 bool behaves_like_zeroth_frame = (idx == 0);
435 idx, cfa,
pc, behaves_like_zeroth_frame);
440 cfa = reg_ctx_sp->GetSP();
441 pc = reg_ctx_sp->GetPC();
444 unwind_frame_sp = std::make_shared<StackFrame>(
446 cfa,
pc, behaves_like_zeroth_frame,
nullptr);
447 m_frames.push_back(unwind_frame_sp);
451 cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
456 if (allow_interrupt &&
459 was_interrupted =
true;
470 const bool cfa_is_valid =
true;
471 unwind_frame_sp = std::make_shared<StackFrame>(
480 m_frames.push_back(unwind_frame_sp);
483 assert(unwind_frame_sp);
485 eSymbolContextBlock | eSymbolContextFunction);
490 unwind_frame_sp->GetFrameCodeAddressForSymbolication());
496 curr_frame_address, next_frame_sc, next_frame_address)) {
498 behaves_like_zeroth_frame =
false;
501 unwind_frame_sp->GetRegisterContextSP(), cfa, next_frame_address,
502 behaves_like_zeroth_frame, &next_frame_sc));
505 unwind_sc = next_frame_sc;
506 curr_frame_address = next_frame_address;
509 }
while (
m_frames.size() - 1 < end_idx);
516#if defined(DEBUG_STACK_FRAMES)
518 prev_frames->
Dump(&s);
520 curr_frames->
Dump(&s);
523 size_t curr_frame_num, prev_frame_num;
525 for (curr_frame_num = curr_frames->
m_frames.size(),
526 prev_frame_num = prev_frames->
m_frames.size();
527 curr_frame_num > 0 && prev_frame_num > 0;
528 --curr_frame_num, --prev_frame_num) {
529 const size_t curr_frame_idx = curr_frame_num - 1;
530 const size_t prev_frame_idx = prev_frame_num - 1;
534#if defined(DEBUG_STACK_FRAMES)
535 s.
Printf(
"\n\nCurr frame #%u ", curr_frame_idx);
537 curr_frame_sp->Dump(&s,
true,
false);
540 s.
Printf(
"\nPrev frame #%u ", prev_frame_idx);
542 prev_frame_sp->Dump(&s,
true,
false);
550 if (curr_frame ==
nullptr || prev_frame ==
nullptr)
560 m_frames[curr_frame_idx] = prev_frame_sp;
562#if defined(DEBUG_STACK_FRAMES)
563 s.
Printf(
"\n Copying previous frame to current frame");
571 return was_interrupted;
582 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
592 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
595 for (pos = begin; pos != end; ++pos) {
597 s->
Printf(
"%p: ",
static_cast<void *
>(frame));
602 s->
Printf(
"frame #%u", (uint32_t)std::distance(begin, pos));
610 uint32_t original_idx = idx;
616 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
620 idx += inlined_depth;
634 LLDB_LOG(log,
"GetFrameAtIndex was interrupted");
639 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
642 }
else if (original_idx == 0) {
669 uint32_t frame_idx = unwind_idx;
672 if (frame_sp->GetFrameIndex() == unwind_idx)
681 return stack_sp->GetStackID() < stack_id;
688 uint32_t frame_idx = 0;
692 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
694 collection::const_iterator pos =
696 if (pos !=
m_frames.end() && (*pos)->GetStackID() == stack_id)
702 if (frame_sp && frame_sp->GetStackID() == stack_id)
711 std::unique_lock<std::shared_mutex> guard(
m_list_mutex);
734 LLDB_LOG(log,
"Failed to construct Frame #0");
740 if (recognized_frame_sp) {
742 recognized_frame_sp->GetMostRelevantFrame()) {
743 LLDB_LOG(log,
"Found most relevant frame at index {0}",
744 most_relevant_frame_sp->GetFrameIndex());
749 LLDB_LOG(log,
"Frame #0 not recognized");
754 uint32_t stack_idx = 0;
755 bool found_relevant =
false;
760 bool inlined =
false;
761 std::optional<uint32_t> stack_opt =
762 stop_info_sp->GetSuggestedStackFrameIndex(inlined);
764 stack_idx = *stack_opt;
765 found_relevant =
true;
771 LLDB_LOG(log,
"Stop info suggested relevant frame {0} but it didn't exist",
773 else if (found_relevant)
774 LLDB_LOG(log,
"Setting selected frame from stop info to {0}", stack_idx);
781 LLDB_LOG(log,
"No relevant frame!");
791 if (!select_most_relevant)
800 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
807 for (pos = begin; pos != end; ++pos) {
808 if (pos->get() == frame) {
835 SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
851 std::unique_lock<std::shared_mutex> guard(
m_list_mutex);
859 std::shared_lock<std::shared_mutex> guard(
m_list_mutex);
865 for (pos = begin; pos != end; ++pos) {
866 if (pos->get() == stack_frame_ptr) {
875 uint32_t num_frames,
bool show_frame_info,
876 uint32_t num_frames_with_source,
877 bool show_unique,
bool show_hidden,
878 const char *selected_frame_marker) {
879 size_t num_frames_displayed = 0;
885 uint32_t frame_idx = 0;
892 last_frame = first_frame + num_frames;
896 const char *unselected_marker =
nullptr;
898 if (selected_frame_marker) {
899 size_t len = strlen(selected_frame_marker);
900 buffer.insert(buffer.begin(), len,
' ');
901 unselected_marker = buffer.c_str();
903 const char *marker =
nullptr;
904 for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx) {
909 if (selected_frame_marker !=
nullptr) {
910 if (frame_sp == selected_frame_sp)
911 marker = selected_frame_marker;
913 marker = unselected_marker;
917 if (!show_hidden && frame_sp != selected_frame_sp && frame_sp->IsHidden())
924 dbg,
"Interrupted dumping stack for thread {0:x} with {1} shown.",
929 if (!frame_sp->GetStatus(strm, show_frame_info,
930 num_frames_with_source > (first_frame - frame_idx),
931 show_unique, marker))
933 ++num_frames_displayed;
937 return num_frames_displayed;
#define INTERRUPT_REQUESTED(debugger,...)
This handy define will keep you from having to generate a report for the interruption by hand.
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
static void FindInterveningFrames(Function &begin, Function &end, ExecutionContext &exe_ctx, Target &target, addr_t return_pc, CallSequence &path, ModuleList &images, Log *log)
Find the unique path through the call graph from begin (with return PC return_pc) to end.
static bool CompareStackID(const StackFrameSP &stack_sp, const StackID &stack_id)
std::vector< CallDescriptor > CallSequence
A section + offset based address class.
A class that describes a single lexical block.
Represent a call made within a Function.
virtual Function * GetCallee(ModuleList &images, ExecutionContext &exe_ctx)=0
Get the callee's definition.
A class to manage flag bits.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void SetFramePtr(StackFrame *frame)
Set accessor to set only the frame shared pointer from a frame pointer.
A class that describes a function.
CallEdge * GetCallEdgeForReturnAddress(lldb::addr_t return_pc, Target &target)
Get the outgoing call edge from this function which has the given return address return_pc,...
llvm::ArrayRef< std::unique_ptr< CallEdge > > GetCallEdges()
Get the outgoing call edges from this function, sorted by their return PC addresses (in increasing or...
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
llvm::ArrayRef< std::unique_ptr< CallEdge > > GetTailCallingEdges()
Get the outgoing tail-calling edges from this function.
ConstString GetDisplayName() const
A collection class for Module objects.
lldb::addr_t m_current_inlined_pc
The program counter value at the currently selected synthetic activation.
collection m_frames
A cache of frames.
lldb::StackFrameSP GetFrameWithStackID(const StackID &stack_id)
Retrieve the stack frame with the given ID stack_id.
lldb::StackFrameSP GetFrameWithConcreteFrameIndex(uint32_t unwind_idx)
Get the first concrete frame with index greater than or equal to idx.
bool GetFramesUpTo(uint32_t end_idx, InterruptionControl allow_interrupt)
Ensures that frames up to (and including) end_idx are realized in the StackFrameList.
void ResetCurrentInlinedDepth()
void Clear()
Clear the cache of frames.
lldb::StackFrameSP GetFrameAtIndex(uint32_t idx)
Get the frame at index idx. Invisible frames cannot be indexed.
bool GetAllFramesFetched() const
std::optional< uint32_t > m_selected_frame_idx
The currently selected frame.
lldb::StackFrameListSP m_prev_frames_sp
The old stack frame list.
uint32_t m_concrete_frames_fetched
The number of concrete frames fetched while filling the frame list.
size_t GetStatus(Stream &strm, uint32_t first_frame, uint32_t num_frames, bool show_frame_info, uint32_t num_frames_with_source, bool show_unique=false, bool show_hidden=false, const char *frame_marker=nullptr)
void FetchOnlyConcreteFramesUpTo(uint32_t end_idx)
Not currently interruptible so returns void.
Thread & m_thread
The thread this frame list describes.
void SelectMostRelevantFrame()
Calls into the stack frame recognizers and stop info to set the most relevant frame.
const bool m_show_inlined_frames
Whether or not to show synthetic (inline) frames. Immutable.
std::mutex m_inlined_depth_mutex
bool SetFrameAtIndex(uint32_t idx, lldb::StackFrameSP &frame_sp)
Use this API to build a stack frame list (used for scripted threads, for instance....
uint32_t m_current_inlined_depth
The number of synthetic function activations (invisible frames) expanded from the concrete frame #0 a...
void SetDefaultFileAndLineToSelectedFrame()
If the currently selected frame comes from the currently selected thread, point the default file and ...
uint32_t GetVisibleStackFrameIndex(uint32_t idx)
If the current inline depth (i.e the number of invisible frames) is valid, subtract it from idx.
bool DecrementCurrentInlinedDepth()
uint32_t GetNumFrames(bool can_create=true)
Get the number of visible frames.
bool FetchFramesUpTo(uint32_t end_idx, InterruptionControl allow_interrupt)
These two Fetch frames APIs and SynthesizeTailCallFrames are called in GetFramesUpTo,...
collection::const_iterator const_iterator
void SynthesizeTailCallFrames(StackFrame &next_frame)
Given that next_frame will be appended to the frame list, synthesize tail call frames between the cur...
void SetAllFramesFetched()
StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp, bool show_inline_frames)
void SetCurrentInlinedDepth(uint32_t new_depth)
uint32_t GetSelectedFrameIndex(SelectMostRelevant select_most_relevant_frame)
Get the currently selected frame index.
std::shared_mutex m_list_mutex
A mutex for this frame list.
uint32_t SetSelectedFrame(lldb_private::StackFrame *frame)
Mark a stack frame as the currently selected frame and return its index.
void CalculateCurrentInlinedDepth()
Calculate and set the current inline depth.
lldb::StackFrameSP GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr)
If stack_frame_ptr is contained in this StackFrameList, return its wrapping shared pointer.
bool WereAllFramesFetched() const
Returns whether we have currently fetched all the frames of a stack.
uint32_t GetCurrentInlinedDepth()
bool SetSelectedFrameByIndex(uint32_t idx)
Mark a stack frame as the currently selected frame using the frame index idx.
This base class provides an interface to stack frames.
void UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame)
uint32_t GetConcreteFrameIndex() const
Query this frame to find what frame it is in this Thread's StackFrameList, not counting inlined frame...
void SetFrameIndex(uint32_t index)
Set this frame's synthetic frame index.
void DumpUsingSettingsFormat(Stream *strm, bool show_unique=false, const char *frame_marker=nullptr)
Print a description for this frame using the frame-format formatter settings.
lldb::RegisterContextSP GetRegisterContext()
Get the RegisterContext for this frame, if possible.
@ Artificial
An artificial stack frame (e.g.
@ Regular
A regular stack frame with access to registers and local variables.
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
lldb::TargetSP CalculateTarget() override
A stream class that can stream formatted output to a file.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
size_t EOL()
Output and End of Line character to the stream.
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
bool GetParentOfInlinedScope(const Address &curr_frame_pc, SymbolContext &next_frame_sc, Address &inlined_frame_addr) const
Find the block containing the inlined block that contains this block.
Block * block
The Block for a given query.
LineEntry line_entry
The LineEntry for a given query.
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb::StackFrameSP GetSelectedFrame(SelectMostRelevant select_most_relevant)
virtual Unwind & GetUnwinder()
lldb::TargetSP CalculateTarget() override
lldb::ProcessSP GetProcess() const
lldb::StopInfoSP GetStopInfo()
bool GetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa, lldb::addr_t &pc, bool &behaves_like_zeroth_frame)
uint32_t GetFramesUpTo(uint32_t end_idx)
#define LLDB_INVALID_ADDRESS
@ DoNoSelectMostRelevantFrame
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::RecognizedStackFrame > RecognizedStackFrameSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
std::shared_ptr< lldb_private::StackFrameList > StackFrameListSP
A sequence of calls that comprise some portion of a backtrace.
uint32_t line
The source line number, or LLDB_INVALID_LINE_NUMBER if there is no line number information.
const FileSpec & GetFile() const
Helper to access the file.
lldb::SupportFileSP file_sp
The source file, possibly mapped by the target.source-map setting.
void ApplyFileMappings(lldb::TargetSP target_sp)
Apply file mappings from target.source-map to the LineEntry's file.
lldb::user_id_t GetID() const
Get accessor for the user ID.