1//===-- StackFrameRecognizer.cpp ------------------------------------------===//
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#include "lldb/Target/StackFrameRecognizer.h"
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/Utility/RegularExpression.h"
15
16using namespace lldb;
17using namespace lldb_private;
18
19class ScriptedRecognizedStackFrame : public RecognizedStackFrame {
20public:
21 ScriptedRecognizedStackFrame(ValueObjectListSP args) {
22 m_arguments = args;
23 }
24};
25
26ScriptedStackFrameRecognizer::ScriptedStackFrameRecognizer(
27 ScriptInterpreter *interpreter, const char *pclass)
28 : m_interpreter(interpreter), m_python_class(pclass) {
29 m_python_object_sp =
30 m_interpreter->CreateFrameRecognizer(class_name: m_python_class.c_str());
31}
32
33RecognizedStackFrameSP
34ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
35 if (!m_python_object_sp || !m_interpreter)
36 return RecognizedStackFrameSP();
37
38 ValueObjectListSP args =
39 m_interpreter->GetRecognizedArguments(implementor: m_python_object_sp, frame_sp: frame);
40 auto args_synthesized = ValueObjectListSP(new ValueObjectList());
41 for (const auto &o : args->GetObjects()) {
42 args_synthesized->Append(val_obj_sp: ValueObjectRecognizerSynthesizedValue::Create(
43 parent&: *o, type: eValueTypeVariableArgument));
44 }
45
46 return RecognizedStackFrameSP(
47 new ScriptedRecognizedStackFrame(args_synthesized));
48}
49
50void StackFrameRecognizerManager::AddRecognizer(
51 StackFrameRecognizerSP recognizer, ConstString module,
52 llvm::ArrayRef<ConstString> symbols, bool first_instruction_only) {
53 m_recognizers.push_front(x: {.recognizer_id: (uint32_t)m_recognizers.size(), .recognizer: recognizer, .is_regexp: false,
54 .module: module, .module_regexp: RegularExpressionSP(), .symbols: symbols,
55 .symbol_regexp: RegularExpressionSP(), .first_instruction_only: first_instruction_only});
56}
57
58void StackFrameRecognizerManager::AddRecognizer(
59 StackFrameRecognizerSP recognizer, RegularExpressionSP module,
60 RegularExpressionSP symbol, bool first_instruction_only) {
61 m_recognizers.push_front(x: {.recognizer_id: (uint32_t)m_recognizers.size(), .recognizer: recognizer, .is_regexp: true,
62 .module: ConstString(), .module_regexp: module, .symbols: std::vector<ConstString>(),
63 .symbol_regexp: symbol, .first_instruction_only: first_instruction_only});
64}
65
66void StackFrameRecognizerManager::ForEach(
67 const std::function<void(uint32_t, std::string, std::string,
68 llvm::ArrayRef<ConstString>, bool)> &callback) {
69 for (auto entry : m_recognizers) {
70 if (entry.is_regexp) {
71 std::string module_name;
72 std::string symbol_name;
73
74 if (entry.module_regexp)
75 module_name = entry.module_regexp->GetText().str();
76 if (entry.symbol_regexp)
77 symbol_name = entry.symbol_regexp->GetText().str();
78
79 callback(entry.recognizer_id, entry.recognizer->GetName(), module_name,
80 llvm::ArrayRef(ConstString(symbol_name)), true);
81
82 } else {
83 callback(entry.recognizer_id, entry.recognizer->GetName(),
84 entry.module.GetCString(), entry.symbols, false);
85 }
86 }
87}
88
89bool StackFrameRecognizerManager::RemoveRecognizerWithID(
90 uint32_t recognizer_id) {
91 if (recognizer_id >= m_recognizers.size())
92 return false;
93 auto found =
94 llvm::find_if(Range&: m_recognizers, P: [recognizer_id](const RegisteredEntry &e) {
95 return e.recognizer_id == recognizer_id;
96 });
97 if (found == m_recognizers.end())
98 return false;
99 m_recognizers.erase(position: found);
100 return true;
101}
102
103void StackFrameRecognizerManager::RemoveAllRecognizers() {
104 m_recognizers.clear();
105}
106
107StackFrameRecognizerSP
108StackFrameRecognizerManager::GetRecognizerForFrame(StackFrameSP frame) {
109 const SymbolContext &symctx = frame->GetSymbolContext(
110 resolve_scope: eSymbolContextModule | eSymbolContextFunction | eSymbolContextSymbol);
111 ConstString function_name = symctx.GetFunctionName();
112 ModuleSP module_sp = symctx.module_sp;
113 if (!module_sp)
114 return StackFrameRecognizerSP();
115 ConstString module_name = module_sp->GetFileSpec().GetFilename();
116 Symbol *symbol = symctx.symbol;
117 if (!symbol)
118 return StackFrameRecognizerSP();
119 Address start_addr = symbol->GetAddress();
120 Address current_addr = frame->GetFrameCodeAddress();
121
122 for (auto entry : m_recognizers) {
123 if (entry.module)
124 if (entry.module != module_name)
125 continue;
126
127 if (entry.module_regexp)
128 if (!entry.module_regexp->Execute(string: module_name.GetStringRef()))
129 continue;
130
131 if (!entry.symbols.empty())
132 if (!llvm::is_contained(Range&: entry.symbols, Element: function_name))
133 continue;
134
135 if (entry.symbol_regexp)
136 if (!entry.symbol_regexp->Execute(string: function_name.GetStringRef()))
137 continue;
138
139 if (entry.first_instruction_only)
140 if (start_addr != current_addr)
141 continue;
142
143 return entry.recognizer;
144 }
145 return StackFrameRecognizerSP();
146}
147
148RecognizedStackFrameSP
149StackFrameRecognizerManager::RecognizeFrame(StackFrameSP frame) {
150 auto recognizer = GetRecognizerForFrame(frame);
151 if (!recognizer)
152 return RecognizedStackFrameSP();
153 return recognizer->RecognizeFrame(frame);
154}
155

source code of lldb/source/Target/StackFrameRecognizer.cpp