Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Target/StackFrameList.h
Line
Count
Source
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
16
#include "lldb/Target/StackFrame.h"
17
18
namespace lldb_private {
19
20
class ScriptedThread;
21
22
class StackFrameList {
23
public:
24
  // Constructors and Destructors
25
  StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp,
26
                 bool show_inline_frames);
27
28
  ~StackFrameList();
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.
46
  uint32_t SetSelectedFrame(lldb_private::StackFrame *frame);
47
48
  /// Get the currently selected frame index.
49
  uint32_t GetSelectedFrameIndex() const;
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.
53
  bool SetSelectedFrameByIndex(uint32_t idx);
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.
57
7.06k
  uint32_t GetVisibleStackFrameIndex(uint32_t idx) {
58
7.06k
    if (m_current_inlined_depth < UINT32_MAX)
59
110
      return idx - m_current_inlined_depth;
60
6.95k
    else
61
6.95k
      return idx;
62
7.06k
  }
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.
67
  void CalculateCurrentInlinedDepth();
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.
72
  void SetDefaultFileAndLineToSelectedFrame();
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
82
  GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr);
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
89
protected:
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
101
85.4k
  bool GetAllFramesFetched() { return m_concrete_frames_fetched == UINT32_MAX; }
102
103
1.38k
  void SetAllFramesFetched() { m_concrete_frames_fetched = UINT32_MAX; }
104
105
  bool DecrementCurrentInlinedDepth();
106
107
  void ResetCurrentInlinedDepth();
108
109
  uint32_t GetCurrentInlinedDepth();
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.
118
  Thread &m_thread;
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.
135
  collection m_frames;
136
137
  /// The currently selected frame.
138
  uint32_t m_selected_frame_idx;
139
140
  /// The number of concrete frames fetched while filling the frame list. This
141
  /// is only used when synthetic frames are enabled.
142
  uint32_t m_concrete_frames_fetched;
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.
147
  uint32_t m_current_inlined_depth;
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.
152
  lldb::addr_t m_current_inlined_pc;
153
154
  /// Whether or not to show synthetic (inline) frames. Immutable.
155
  const bool m_show_inlined_frames;
156
157
private:
158
  StackFrameList(const StackFrameList &) = delete;
159
  const StackFrameList &operator=(const StackFrameList &) = delete;
160
};
161
162
} // namespace lldb_private
163
164
#endif // LLDB_TARGET_STACKFRAMELIST_H