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 16 using namespace lldb; 17 using namespace lldb_private; 18 19 class ScriptedRecognizedStackFrame : public RecognizedStackFrame { 20 public: 21 ScriptedRecognizedStackFrame(ValueObjectListSP args) { 22 m_arguments = args; 23 } 24 }; 25 26 ScriptedStackFrameRecognizer::ScriptedStackFrameRecognizer( 27 ScriptInterpreter *interpreter, const char *pclass) 28 : m_interpreter(interpreter), m_python_class(pclass) { 29 m_python_object_sp = 30 m_interpreter->CreateFrameRecognizer(m_python_class.c_str()); 31 } 32 33 RecognizedStackFrameSP 34 ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) { 35 if (!m_python_object_sp || !m_interpreter) 36 return RecognizedStackFrameSP(); 37 38 ValueObjectListSP args = 39 m_interpreter->GetRecognizedArguments(m_python_object_sp, frame); 40 auto args_synthesized = ValueObjectListSP(new ValueObjectList()); 41 for (const auto &o : args->GetObjects()) { 42 args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create( 43 *o, eValueTypeVariableArgument)); 44 } 45 46 return RecognizedStackFrameSP( 47 new ScriptedRecognizedStackFrame(args_synthesized)); 48 } 49 50 void StackFrameRecognizerManager::AddRecognizer( 51 StackFrameRecognizerSP recognizer, ConstString module, 52 llvm::ArrayRef<ConstString> symbols, bool first_instruction_only) { 53 m_recognizers.push_front({(uint32_t)m_recognizers.size(), recognizer, false, 54 module, RegularExpressionSP(), symbols, 55 RegularExpressionSP(), first_instruction_only}); 56 } 57 58 void StackFrameRecognizerManager::AddRecognizer( 59 StackFrameRecognizerSP recognizer, RegularExpressionSP module, 60 RegularExpressionSP symbol, bool first_instruction_only) { 61 m_recognizers.push_front({(uint32_t)m_recognizers.size(), recognizer, true, 62 ConstString(), module, std::vector<ConstString>(), 63 symbol, first_instruction_only}); 64 } 65 66 void 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 89 bool StackFrameRecognizerManager::RemoveRecognizerWithID( 90 uint32_t recognizer_id) { 91 if (recognizer_id >= m_recognizers.size()) 92 return false; 93 auto found = 94 llvm::find_if(m_recognizers, [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(found); 100 return true; 101 } 102 103 void StackFrameRecognizerManager::RemoveAllRecognizers() { 104 m_recognizers.clear(); 105 } 106 107 StackFrameRecognizerSP 108 StackFrameRecognizerManager::GetRecognizerForFrame(StackFrameSP frame) { 109 const SymbolContext &symctx = frame->GetSymbolContext( 110 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(module_name.GetStringRef())) 129 continue; 130 131 if (!entry.symbols.empty()) 132 if (!llvm::is_contained(entry.symbols, function_name)) 133 continue; 134 135 if (entry.symbol_regexp) 136 if (!entry.symbol_regexp->Execute(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 148 RecognizedStackFrameSP 149 StackFrameRecognizerManager::RecognizeFrame(StackFrameSP frame) { 150 auto recognizer = GetRecognizerForFrame(frame); 151 if (!recognizer) 152 return RecognizedStackFrameSP(); 153 return recognizer->RecognizeFrame(frame); 154 } 155