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(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(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 50void 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 58void 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 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(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 103void StackFrameRecognizerManager::RemoveAllRecognizers() { 104 m_recognizers.clear(); 105} 106 107StackFrameRecognizerSP 108StackFrameRecognizerManager::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 148RecognizedStackFrameSP 149StackFrameRecognizerManager::RecognizeFrame(StackFrameSP frame) { 150 auto recognizer = GetRecognizerForFrame(frame); 151 if (!recognizer) 152 return RecognizedStackFrameSP(); 153 return recognizer->RecognizeFrame(frame); 154} 155