1 //===-- StackFrameRecognizer.cpp ------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Module.h"
11 #include "lldb/Interpreter/ScriptInterpreter.h"
12 #include "lldb/Symbol/Symbol.h"
13 #include "lldb/Target/StackFrame.h"
14 #include "lldb/Target/StackFrameRecognizer.h"
15 #include "lldb/Utility/RegularExpression.h"
18 using namespace lldb_private;
20 class ScriptedRecognizedStackFrame : public RecognizedStackFrame {
22 ScriptedRecognizedStackFrame(ValueObjectListSP args) {
27 ScriptedStackFrameRecognizer::ScriptedStackFrameRecognizer(
28 ScriptInterpreter *interpreter, const char *pclass)
29 : m_interpreter(interpreter), m_python_class(pclass) {
31 m_interpreter->CreateFrameRecognizer(m_python_class.c_str());
34 RecognizedStackFrameSP
35 ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
36 if (!m_python_object_sp || !m_interpreter)
37 return RecognizedStackFrameSP();
39 ValueObjectListSP args =
40 m_interpreter->GetRecognizedArguments(m_python_object_sp, frame);
41 auto args_synthesized = ValueObjectListSP(new ValueObjectList());
42 for (const auto &o : args->GetObjects()) {
43 args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create(
44 *o, eValueTypeVariableArgument));
47 return RecognizedStackFrameSP(
48 new ScriptedRecognizedStackFrame(args_synthesized));
51 class StackFrameRecognizerManagerImpl {
53 void AddRecognizer(StackFrameRecognizerSP recognizer, ConstString module,
54 llvm::ArrayRef<ConstString> symbols,
55 bool first_instruction_only) {
56 m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer,
57 false, module, RegularExpressionSP(), symbols,
58 RegularExpressionSP(), first_instruction_only});
61 void AddRecognizer(StackFrameRecognizerSP recognizer,
62 RegularExpressionSP module, RegularExpressionSP symbol,
63 bool first_instruction_only) {
64 m_recognizers.push_front(
65 {(uint32_t)m_recognizers.size(), false, recognizer, true, ConstString(),
66 module, std::vector<ConstString>(), symbol, first_instruction_only});
69 void ForEach(std::function<
70 void(uint32_t recognized_id, std::string recognizer_name,
71 std::string module, llvm::ArrayRef<ConstString> symbols,
72 bool regexp)> const &callback) {
73 for (auto entry : m_recognizers) {
74 if (entry.is_regexp) {
75 std::string module_name;
76 std::string symbol_name;
78 if (entry.module_regexp)
79 module_name = entry.module_regexp->GetText().str();
80 if (entry.symbol_regexp)
81 symbol_name = entry.symbol_regexp->GetText().str();
83 callback(entry.recognizer_id, entry.recognizer->GetName(), module_name,
84 llvm::makeArrayRef(ConstString(symbol_name)), true);
87 callback(entry.recognizer_id, entry.recognizer->GetName(),
88 entry.module.GetCString(), entry.symbols, false);
93 bool RemoveRecognizerWithID(uint32_t recognizer_id) {
94 if (recognizer_id >= m_recognizers.size()) return false;
95 if (m_recognizers[recognizer_id].deleted) return false;
96 m_recognizers[recognizer_id].deleted = true;
100 void RemoveAllRecognizers() {
101 m_recognizers.clear();
104 StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
105 const SymbolContext &symctx = frame->GetSymbolContext(
106 eSymbolContextModule | eSymbolContextFunction | eSymbolContextSymbol);
107 ConstString function_name = symctx.GetFunctionName();
108 ModuleSP module_sp = symctx.module_sp;
109 if (!module_sp) return StackFrameRecognizerSP();
110 ConstString module_name = module_sp->GetFileSpec().GetFilename();
111 Symbol *symbol = symctx.symbol;
112 if (!symbol) return StackFrameRecognizerSP();
113 Address start_addr = symbol->GetAddress();
114 Address current_addr = frame->GetFrameCodeAddress();
116 for (auto entry : m_recognizers) {
117 if (entry.deleted) continue;
119 if (entry.module != module_name) continue;
121 if (entry.module_regexp)
122 if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue;
124 if (!entry.symbols.empty())
125 if (!llvm::is_contained(entry.symbols, function_name))
128 if (entry.symbol_regexp)
129 if (!entry.symbol_regexp->Execute(function_name.GetStringRef()))
132 if (entry.first_instruction_only)
133 if (start_addr != current_addr) continue;
135 return entry.recognizer;
137 return StackFrameRecognizerSP();
140 RecognizedStackFrameSP RecognizeFrame(StackFrameSP frame) {
141 auto recognizer = GetRecognizerForFrame(frame);
142 if (!recognizer) return RecognizedStackFrameSP();
143 return recognizer->RecognizeFrame(frame);
147 struct RegisteredEntry {
148 uint32_t recognizer_id;
150 StackFrameRecognizerSP recognizer;
153 RegularExpressionSP module_regexp;
154 std::vector<ConstString> symbols;
155 RegularExpressionSP symbol_regexp;
156 bool first_instruction_only;
159 std::deque<RegisteredEntry> m_recognizers;
162 StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
163 static StackFrameRecognizerManagerImpl instance =
164 StackFrameRecognizerManagerImpl();
168 void StackFrameRecognizerManager::AddRecognizer(
169 StackFrameRecognizerSP recognizer, ConstString module,
170 llvm::ArrayRef<ConstString> symbols, bool first_instruction_only) {
171 GetStackFrameRecognizerManagerImpl().AddRecognizer(
172 recognizer, module, symbols, first_instruction_only);
175 void StackFrameRecognizerManager::AddRecognizer(
176 StackFrameRecognizerSP recognizer, RegularExpressionSP module,
177 RegularExpressionSP symbol, bool first_instruction_only) {
178 GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
179 first_instruction_only);
182 void StackFrameRecognizerManager::ForEach(
183 std::function<void(uint32_t recognized_id, std::string recognizer_name,
184 std::string module, llvm::ArrayRef<ConstString> symbols,
185 bool regexp)> const &callback) {
186 GetStackFrameRecognizerManagerImpl().ForEach(callback);
189 void StackFrameRecognizerManager::RemoveAllRecognizers() {
190 GetStackFrameRecognizerManagerImpl().RemoveAllRecognizers();
193 bool StackFrameRecognizerManager::RemoveRecognizerWithID(uint32_t recognizer_id) {
194 return GetStackFrameRecognizerManagerImpl().RemoveRecognizerWithID(recognizer_id);
197 RecognizedStackFrameSP StackFrameRecognizerManager::RecognizeFrame(
198 StackFrameSP frame) {
199 return GetStackFrameRecognizerManagerImpl().RecognizeFrame(frame);
202 StackFrameRecognizerSP StackFrameRecognizerManager::GetRecognizerForFrame(
203 lldb::StackFrameSP frame) {
204 return GetStackFrameRecognizerManagerImpl().GetRecognizerForFrame(frame);