1 | //===-- StackFrameRecognizer.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_STACKFRAMERECOGNIZER_H |
10 | #define LLDB_TARGET_STACKFRAMERECOGNIZER_H |
11 | |
12 | #include "lldb/Core/ValueObject.h" |
13 | #include "lldb/Core/ValueObjectList.h" |
14 | #include "lldb/Symbol/VariableList.h" |
15 | #include "lldb/Target/StopInfo.h" |
16 | #include "lldb/Utility/StructuredData.h" |
17 | #include "lldb/lldb-private-forward.h" |
18 | #include "lldb/lldb-public.h" |
19 | |
20 | #include <optional> |
21 | #include <vector> |
22 | |
23 | namespace lldb_private { |
24 | |
25 | /// \class RecognizedStackFrame |
26 | /// |
27 | /// This class provides extra information about a stack frame that was |
28 | /// provided by a specific stack frame recognizer. Right now, this class only |
29 | /// holds recognized arguments (via GetRecognizedArguments). |
30 | |
31 | class RecognizedStackFrame |
32 | : public std::enable_shared_from_this<RecognizedStackFrame> { |
33 | public: |
34 | virtual lldb::ValueObjectListSP GetRecognizedArguments() { |
35 | return m_arguments; |
36 | } |
37 | virtual lldb::ValueObjectSP GetExceptionObject() { |
38 | return lldb::ValueObjectSP(); |
39 | } |
40 | virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; }; |
41 | virtual ~RecognizedStackFrame() = default; |
42 | |
43 | std::string GetStopDescription() { return m_stop_desc; } |
44 | |
45 | protected: |
46 | lldb::ValueObjectListSP m_arguments; |
47 | std::string m_stop_desc; |
48 | }; |
49 | |
50 | /// \class StackFrameRecognizer |
51 | /// |
52 | /// A base class for frame recognizers. Subclasses (actual frame recognizers) |
53 | /// should implement RecognizeFrame to provide a RecognizedStackFrame for a |
54 | /// given stack frame. |
55 | |
56 | class StackFrameRecognizer |
57 | : public std::enable_shared_from_this<StackFrameRecognizer> { |
58 | public: |
59 | virtual lldb::RecognizedStackFrameSP RecognizeFrame( |
60 | lldb::StackFrameSP frame) { |
61 | return lldb::RecognizedStackFrameSP(); |
62 | }; |
63 | virtual std::string GetName() { |
64 | return "" ; |
65 | } |
66 | |
67 | virtual ~StackFrameRecognizer() = default; |
68 | }; |
69 | |
70 | /// \class ScriptedStackFrameRecognizer |
71 | /// |
72 | /// Python implementation for frame recognizers. An instance of this class |
73 | /// tracks a particular Python classobject, which will be asked to recognize |
74 | /// stack frames. |
75 | |
76 | class ScriptedStackFrameRecognizer : public StackFrameRecognizer { |
77 | lldb_private::ScriptInterpreter *m_interpreter; |
78 | lldb_private::StructuredData::ObjectSP m_python_object_sp; |
79 | std::string m_python_class; |
80 | |
81 | public: |
82 | ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter, |
83 | const char *pclass); |
84 | ~ScriptedStackFrameRecognizer() override = default; |
85 | |
86 | std::string GetName() override { |
87 | return GetPythonClassName(); |
88 | } |
89 | |
90 | const char *GetPythonClassName() { return m_python_class.c_str(); } |
91 | |
92 | lldb::RecognizedStackFrameSP RecognizeFrame( |
93 | lldb::StackFrameSP frame) override; |
94 | |
95 | private: |
96 | ScriptedStackFrameRecognizer(const ScriptedStackFrameRecognizer &) = delete; |
97 | const ScriptedStackFrameRecognizer & |
98 | operator=(const ScriptedStackFrameRecognizer &) = delete; |
99 | }; |
100 | |
101 | /// Class that provides a registry of known stack frame recognizers. |
102 | class StackFrameRecognizerManager { |
103 | public: |
104 | void AddRecognizer(lldb::StackFrameRecognizerSP recognizer, |
105 | ConstString module, llvm::ArrayRef<ConstString> symbols, |
106 | bool first_instruction_only = true); |
107 | |
108 | void AddRecognizer(lldb::StackFrameRecognizerSP recognizer, |
109 | lldb::RegularExpressionSP module, |
110 | lldb::RegularExpressionSP symbol, |
111 | bool first_instruction_only = true); |
112 | |
113 | void ForEach(std::function< |
114 | void(uint32_t recognizer_id, std::string recognizer_name, |
115 | std::string module, llvm::ArrayRef<ConstString> symbols, |
116 | bool regexp)> const &callback); |
117 | |
118 | bool RemoveRecognizerWithID(uint32_t recognizer_id); |
119 | |
120 | void RemoveAllRecognizers(); |
121 | |
122 | lldb::StackFrameRecognizerSP GetRecognizerForFrame(lldb::StackFrameSP frame); |
123 | |
124 | lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame); |
125 | |
126 | private: |
127 | struct RegisteredEntry { |
128 | uint32_t recognizer_id; |
129 | lldb::StackFrameRecognizerSP recognizer; |
130 | bool is_regexp; |
131 | ConstString module; |
132 | lldb::RegularExpressionSP module_regexp; |
133 | std::vector<ConstString> symbols; |
134 | lldb::RegularExpressionSP symbol_regexp; |
135 | bool first_instruction_only; |
136 | }; |
137 | |
138 | std::deque<RegisteredEntry> m_recognizers; |
139 | }; |
140 | |
141 | /// \class ValueObjectRecognizerSynthesizedValue |
142 | /// |
143 | /// ValueObject subclass that presents the passed ValueObject as a recognized |
144 | /// value with the specified ValueType. Frame recognizers should return |
145 | /// instances of this class as the returned objects in GetRecognizedArguments(). |
146 | |
147 | class ValueObjectRecognizerSynthesizedValue : public ValueObject { |
148 | public: |
149 | static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) { |
150 | return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP(); |
151 | } |
152 | ValueObjectRecognizerSynthesizedValue(ValueObject &parent, |
153 | lldb::ValueType type) |
154 | : ValueObject(parent), m_type(type) { |
155 | SetName(parent.GetName()); |
156 | } |
157 | |
158 | std::optional<uint64_t> GetByteSize() override { |
159 | return m_parent->GetByteSize(); |
160 | } |
161 | lldb::ValueType GetValueType() const override { return m_type; } |
162 | bool UpdateValue() override { |
163 | if (!m_parent->UpdateValueIfNeeded()) return false; |
164 | m_value = m_parent->GetValue(); |
165 | return true; |
166 | } |
167 | size_t CalculateNumChildren(uint32_t max = UINT32_MAX) override { |
168 | return m_parent->GetNumChildren(max); |
169 | } |
170 | CompilerType GetCompilerTypeImpl() override { |
171 | return m_parent->GetCompilerType(); |
172 | } |
173 | bool IsSynthetic() override { return true; } |
174 | |
175 | private: |
176 | lldb::ValueType m_type; |
177 | }; |
178 | |
179 | } // namespace lldb_private |
180 | |
181 | #endif // LLDB_TARGET_STACKFRAMERECOGNIZER_H |
182 | |