1 //===-- StackFrameRecognizer.cpp --------------------------------*- 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 #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(), entry.module_regexp->GetText(), 74 entry.symbol_regexp->GetText(), true); 75 } else { 76 callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module.GetCString(), 77 entry.symbol.GetCString(), false); 78 } 79 } 80 } 81 82 bool RemoveRecognizerWithID(uint32_t recognizer_id) { 83 if (recognizer_id >= m_recognizers.size()) return false; 84 if (m_recognizers[recognizer_id].deleted) return false; 85 m_recognizers[recognizer_id].deleted = true; 86 return true; 87 } 88 89 void RemoveAllRecognizers() { 90 m_recognizers.clear(); 91 } 92 93 StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) { 94 const SymbolContext &symctx = 95 frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction); 96 ConstString function_name = symctx.GetFunctionName(); 97 ModuleSP module_sp = symctx.module_sp; 98 if (!module_sp) return StackFrameRecognizerSP(); 99 ConstString module_name = module_sp->GetFileSpec().GetFilename(); 100 Symbol *symbol = symctx.symbol; 101 if (!symbol) return StackFrameRecognizerSP(); 102 Address start_addr = symbol->GetAddress(); 103 Address current_addr = frame->GetFrameCodeAddress(); 104 105 for (auto entry : m_recognizers) { 106 if (entry.deleted) continue; 107 if (entry.module) 108 if (entry.module != module_name) continue; 109 110 if (entry.module_regexp) 111 if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue; 112 113 if (entry.symbol) 114 if (entry.symbol != function_name) continue; 115 116 if (entry.symbol_regexp) 117 if (!entry.symbol_regexp->Execute(function_name.GetStringRef())) 118 continue; 119 120 if (entry.first_instruction_only) 121 if (start_addr != current_addr) continue; 122 123 return entry.recognizer; 124 } 125 return StackFrameRecognizerSP(); 126 } 127 128 RecognizedStackFrameSP RecognizeFrame(StackFrameSP frame) { 129 auto recognizer = GetRecognizerForFrame(frame); 130 if (!recognizer) return RecognizedStackFrameSP(); 131 return recognizer->RecognizeFrame(frame); 132 } 133 134 private: 135 struct RegisteredEntry { 136 uint32_t recognizer_id; 137 bool deleted; 138 StackFrameRecognizerSP recognizer; 139 bool is_regexp; 140 ConstString module; 141 RegularExpressionSP module_regexp; 142 ConstString symbol; 143 RegularExpressionSP symbol_regexp; 144 bool first_instruction_only; 145 }; 146 147 std::deque<RegisteredEntry> m_recognizers; 148 }; 149 150 StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() { 151 static StackFrameRecognizerManagerImpl instance = 152 StackFrameRecognizerManagerImpl(); 153 return instance; 154 } 155 156 void StackFrameRecognizerManager::AddRecognizer( 157 StackFrameRecognizerSP recognizer, ConstString module, 158 ConstString symbol, bool first_instruction_only) { 159 GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol, 160 first_instruction_only); 161 } 162 163 void StackFrameRecognizerManager::AddRecognizer( 164 StackFrameRecognizerSP recognizer, RegularExpressionSP module, 165 RegularExpressionSP symbol, bool first_instruction_only) { 166 GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol, 167 first_instruction_only); 168 } 169 170 void StackFrameRecognizerManager::ForEach( 171 std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module, 172 std::string symbol, bool regexp)> const &callback) { 173 GetStackFrameRecognizerManagerImpl().ForEach(callback); 174 } 175 176 void StackFrameRecognizerManager::RemoveAllRecognizers() { 177 GetStackFrameRecognizerManagerImpl().RemoveAllRecognizers(); 178 } 179 180 bool StackFrameRecognizerManager::RemoveRecognizerWithID(uint32_t recognizer_id) { 181 return GetStackFrameRecognizerManagerImpl().RemoveRecognizerWithID(recognizer_id); 182 } 183 184 RecognizedStackFrameSP StackFrameRecognizerManager::RecognizeFrame( 185 StackFrameSP frame) { 186 return GetStackFrameRecognizerManagerImpl().RecognizeFrame(frame); 187 } 188 189 StackFrameRecognizerSP StackFrameRecognizerManager::GetRecognizerForFrame( 190 lldb::StackFrameSP frame) { 191 return GetStackFrameRecognizerManagerImpl().GetRecognizerForFrame(frame); 192 } 193