contrib/llvm-project/lldb/source/Target/StackFrameRecognizer.cpp

   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 }