LLDB mainline
StackFrameList.h
Go to the documentation of this file.
1//===-- StackFrameList.h ----------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_TARGET_STACKFRAMELIST_H
10#define LLDB_TARGET_STACKFRAMELIST_H
11
12#include <memory>
13#include <mutex>
14#include <vector>
15
17
18namespace lldb_private {
19
20class ScriptedThread;
21
23public:
24 // Constructors and Destructors
25 StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp,
26 bool show_inline_frames);
27
29
30 /// Get the number of visible frames. Frames may be created if \p can_create
31 /// is true. Synthetic (inline) frames expanded from the concrete frame #0
32 /// (aka invisible frames) are not included in this count.
33 uint32_t GetNumFrames(bool can_create = true);
34
35 /// Get the frame at index \p idx. Invisible frames cannot be indexed.
36 lldb::StackFrameSP GetFrameAtIndex(uint32_t idx);
37
38 /// Get the first concrete frame with index greater than or equal to \p idx.
39 /// Unlike \ref GetFrameAtIndex, this cannot return a synthetic frame.
40 lldb::StackFrameSP GetFrameWithConcreteFrameIndex(uint32_t unwind_idx);
41
42 /// Retrieve the stack frame with the given ID \p stack_id.
43 lldb::StackFrameSP GetFrameWithStackID(const StackID &stack_id);
44
45 /// Mark a stack frame as the currently selected frame and return its index.
47
48 /// Get the currently selected frame index.
50
51 /// Mark a stack frame as the currently selected frame using the frame index
52 /// \p idx. Like \ref GetFrameAtIndex, invisible frames cannot be selected.
54
55 /// If the current inline depth (i.e the number of invisible frames) is valid,
56 /// subtract it from \p idx. Otherwise simply return \p idx.
59 return idx - m_current_inlined_depth;
60 else
61 return idx;
62 }
63
64 /// Calculate and set the current inline depth. This may be used to update
65 /// the StackFrameList's set of inline frames when execution stops, e.g when
66 /// a breakpoint is hit.
68
69 /// If the currently selected frame comes from the currently selected thread,
70 /// point the default file and line of the thread's target to the location
71 /// specified by the frame.
73
74 /// Clear the cache of frames.
75 void Clear();
76
77 void Dump(Stream *s);
78
79 /// If \p stack_frame_ptr is contained in this StackFrameList, return its
80 /// wrapping shared pointer.
81 lldb::StackFrameSP
83
84 size_t GetStatus(Stream &strm, uint32_t first_frame, uint32_t num_frames,
85 bool show_frame_info, uint32_t num_frames_with_source,
86 bool show_unique = false,
87 const char *frame_marker = nullptr);
88
89protected:
90 friend class Thread;
91 friend class ScriptedThread;
92
93 bool SetFrameAtIndex(uint32_t idx, lldb::StackFrameSP &frame_sp);
94
95 void GetFramesUpTo(uint32_t end_idx);
96
97 void GetOnlyConcreteFramesUpTo(uint32_t end_idx, Unwind &unwinder);
98
99 void SynthesizeTailCallFrames(StackFrame &next_frame);
100
102
104
106
108
110
111 void SetCurrentInlinedDepth(uint32_t new_depth);
112
113 typedef std::vector<lldb::StackFrameSP> collection;
114 typedef collection::iterator iterator;
115 typedef collection::const_iterator const_iterator;
116
117 /// The thread this frame list describes.
119
120 /// The old stack frame list.
121 // TODO: The old stack frame list is used to fill in missing frame info
122 // heuristically when it's otherwise unavailable (say, because the unwinder
123 // fails). We should have stronger checks to make sure that this is a valid
124 // source of information.
125 lldb::StackFrameListSP m_prev_frames_sp;
126
127 /// A mutex for this frame list.
128 // TODO: This mutex may not always be held when required. In particular, uses
129 // of the StackFrameList APIs in lldb_private::Thread look suspect. Consider
130 // passing around a lock_guard reference to enforce proper locking.
131 mutable std::recursive_mutex m_mutex;
132
133 /// A cache of frames. This may need to be updated when the program counter
134 /// changes.
136
137 /// The currently selected frame.
139
140 /// The number of concrete frames fetched while filling the frame list. This
141 /// is only used when synthetic frames are enabled.
143
144 /// The number of synthetic function activations (invisible frames) expanded
145 /// from the concrete frame #0 activation.
146 // TODO: Use an optional instead of UINT32_MAX to denote invalid values.
148
149 /// The program counter value at the currently selected synthetic activation.
150 /// This is only valid if m_current_inlined_depth is valid.
151 // TODO: Use an optional instead of UINT32_MAX to denote invalid values.
153
154 /// Whether or not to show synthetic (inline) frames. Immutable.
156
157private:
159 const StackFrameList &operator=(const StackFrameList &) = delete;
160};
161
162} // namespace lldb_private
163
164#endif // LLDB_TARGET_STACKFRAMELIST_H
lldb::addr_t m_current_inlined_pc
The program counter value at the currently selected synthetic activation.
collection m_frames
A cache of frames.
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, const char *frame_marker=nullptr)
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.
std::vector< lldb::StackFrameSP > collection
void Clear()
Clear the cache of frames.
lldb::StackFrameSP GetFrameAtIndex(uint32_t idx)
Get the frame at index idx. Invisible frames cannot be indexed.
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.
std::recursive_mutex m_mutex
A mutex for this frame list.
Thread & m_thread
The thread this frame list describes.
const bool m_show_inlined_frames
Whether or not to show synthetic (inline) frames. Immutable.
uint32_t m_selected_frame_idx
The currently selected frame.
bool SetFrameAtIndex(uint32_t idx, lldb::StackFrameSP &frame_sp)
void GetOnlyConcreteFramesUpTo(uint32_t end_idx, Unwind &unwinder)
void GetFramesUpTo(uint32_t end_idx)
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.
uint32_t GetNumFrames(bool can_create=true)
Get the number of visible frames.
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...
StackFrameList(const StackFrameList &)=delete
uint32_t GetSelectedFrameIndex() const
Get the currently selected frame index.
void SetCurrentInlinedDepth(uint32_t new_depth)
collection::iterator iterator
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.
const StackFrameList & operator=(const StackFrameList &)=delete
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.
Definition: StackFrame.h:41
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
uint64_t addr_t
Definition: lldb-types.h:83