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