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