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