1 //===-- StackFrameRecognizer.cpp --------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include <vector>
11 #include "lldb/Core/Module.h"
12 #include "lldb/Interpreter/ScriptInterpreter.h"
13 #include "lldb/Symbol/Symbol.h"
14 #include "lldb/Target/StackFrame.h"
15 #include "lldb/Target/StackFrameRecognizer.h"
16 #include "lldb/Utility/RegularExpression.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 #ifndef LLDB_DISABLE_PYTHON
22 
23 class ScriptedRecognizedStackFrame : public RecognizedStackFrame {
24 public:
25   ScriptedRecognizedStackFrame(ValueObjectListSP args) {
26     m_arguments = args;
27   }
28 };
29 
30 ScriptedStackFrameRecognizer::ScriptedStackFrameRecognizer(
31     ScriptInterpreter *interpreter, const char *pclass)
32     : m_interpreter(interpreter), m_python_class(pclass) {
33   m_python_object_sp =
34       m_interpreter->CreateFrameRecognizer(m_python_class.c_str());
35 }
36 
37 RecognizedStackFrameSP
38 ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
39   if (!m_python_object_sp || !m_interpreter)
40     return RecognizedStackFrameSP();
41 
42   ValueObjectListSP args =
43       m_interpreter->GetRecognizedArguments(m_python_object_sp, frame);
44 
45   return RecognizedStackFrameSP(new ScriptedRecognizedStackFrame(args));
46 }
47 
48 #endif
49 
50 class StackFrameRecognizerManagerImpl {
51 public:
52   void AddRecognizer(StackFrameRecognizerSP recognizer,
53                      const ConstString &module, const ConstString &symbol,
54                      bool first_instruction_only) {
55     m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
56                               symbol, RegularExpressionSP(),
57                               first_instruction_only});
58   }
59 
60   void AddRecognizer(StackFrameRecognizerSP recognizer,
61                      RegularExpressionSP module, RegularExpressionSP symbol,
62                      bool first_instruction_only) {
63     m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, true, ConstString(), module,
64                               ConstString(), symbol, first_instruction_only});
65   }
66 
67   void ForEach(
68       std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
69                          std::string symbol, bool regexp)> const &callback) {
70     for (auto entry : m_recognizers) {
71       if (entry.is_regexp) {
72         callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module_regexp->GetText(),
73                  entry.symbol_regexp->GetText(), true);
74       } else {
75         callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module.GetCString(),
76                  entry.symbol.GetCString(), false);
77       }
78     }
79   }
80 
81   bool RemoveRecognizerWithID(uint32_t recognizer_id) {
82     if (recognizer_id >= m_recognizers.size()) return false;
83     if (m_recognizers[recognizer_id].deleted) return false;
84     m_recognizers[recognizer_id].deleted = true;
85     return true;
86   }
87 
88   void RemoveAllRecognizers() {
89     m_recognizers.clear();
90   }
91 
92   StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
93     const SymbolContext &symctx =
94         frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
95     ConstString function_name = symctx.GetFunctionName();
96     ModuleSP module_sp = symctx.module_sp;
97     if (!module_sp) return StackFrameRecognizerSP();
98     ConstString module_name = module_sp->GetFileSpec().GetFilename();
99     Symbol *symbol = symctx.symbol;
100     if (!symbol) return StackFrameRecognizerSP();
101     Address start_addr = symbol->GetAddress();
102     Address current_addr = frame->GetFrameCodeAddress();
103 
104     for (auto entry : m_recognizers) {
105       if (entry.deleted) continue;
106       if (entry.module)
107         if (entry.module != module_name) continue;
108 
109       if (entry.module_regexp)
110         if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue;
111 
112       if (entry.symbol)
113         if (entry.symbol != function_name) continue;
114 
115       if (entry.symbol_regexp)
116         if (!entry.symbol_regexp->Execute(function_name.GetStringRef()))
117           continue;
118 
119       if (entry.first_instruction_only)
120         if (start_addr != current_addr) continue;
121 
122       return entry.recognizer;
123     }
124     return StackFrameRecognizerSP();
125   }
126 
127   RecognizedStackFrameSP RecognizeFrame(StackFrameSP frame) {
128     auto recognizer = GetRecognizerForFrame(frame);
129     if (!recognizer) return RecognizedStackFrameSP();
130     return recognizer->RecognizeFrame(frame);
131   }
132 
133  private:
134   struct RegisteredEntry {
135     uint32_t recognizer_id;
136     bool deleted;
137     StackFrameRecognizerSP recognizer;
138     bool is_regexp;
139     ConstString module;
140     RegularExpressionSP module_regexp;
141     ConstString symbol;
142     RegularExpressionSP symbol_regexp;
143     bool first_instruction_only;
144   };
145 
146   std::deque<RegisteredEntry> m_recognizers;
147 };
148 
149 StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
150   static StackFrameRecognizerManagerImpl instance =
151       StackFrameRecognizerManagerImpl();
152   return instance;
153 }
154 
155 void StackFrameRecognizerManager::AddRecognizer(
156     StackFrameRecognizerSP recognizer, const ConstString &module,
157     const ConstString &symbol, bool first_instruction_only) {
158   GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
159                                                      first_instruction_only);
160 }
161 
162 void StackFrameRecognizerManager::AddRecognizer(
163     StackFrameRecognizerSP recognizer, RegularExpressionSP module,
164     RegularExpressionSP symbol, bool first_instruction_only) {
165   GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
166                                                      first_instruction_only);
167 }
168 
169 void StackFrameRecognizerManager::ForEach(
170     std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
171                        std::string symbol, bool regexp)> const &callback) {
172   GetStackFrameRecognizerManagerImpl().ForEach(callback);
173 }
174 
175 void StackFrameRecognizerManager::RemoveAllRecognizers() {
176   GetStackFrameRecognizerManagerImpl().RemoveAllRecognizers();
177 }
178 
179 bool StackFrameRecognizerManager::RemoveRecognizerWithID(uint32_t recognizer_id) {
180   return GetStackFrameRecognizerManagerImpl().RemoveRecognizerWithID(recognizer_id);
181 }
182 
183 RecognizedStackFrameSP StackFrameRecognizerManager::RecognizeFrame(
184     StackFrameSP frame) {
185   return GetStackFrameRecognizerManagerImpl().RecognizeFrame(frame);
186 }
187 
188 StackFrameRecognizerSP StackFrameRecognizerManager::GetRecognizerForFrame(
189     lldb::StackFrameSP frame) {
190   return GetStackFrameRecognizerManagerImpl().GetRecognizerForFrame(frame);
191 }
192