LLDB  mainline
StackFrameRecognizer.h
Go to the documentation of this file.
1 //===-- StackFrameRecognizer.h ----------------------------------*- 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 #ifndef liblldb_StackFrameRecognizer_h_
10 #define liblldb_StackFrameRecognizer_h_
11 
12 #include "lldb/Core/ValueObject.h"
17 #include "lldb/lldb-public.h"
18 
19 namespace lldb_private {
20 
21 /// \class RecognizedStackFrame
22 ///
23 /// This class provides extra information about a stack frame that was
24 /// provided by a specific stack frame recognizer. Right now, this class only
25 /// holds recognized arguments (via GetRecognizedArguments).
26 
28  : public std::enable_shared_from_this<RecognizedStackFrame> {
29 public:
30  virtual lldb::ValueObjectListSP GetRecognizedArguments() {
31  return m_arguments;
32  }
33  virtual lldb::ValueObjectSP GetExceptionObject() {
34  return lldb::ValueObjectSP();
35  }
36  virtual ~RecognizedStackFrame(){};
37 
38 protected:
39  lldb::ValueObjectListSP m_arguments;
40 };
41 
42 /// \class StackFrameRecognizer
43 ///
44 /// A base class for frame recognizers. Subclasses (actual frame recognizers)
45 /// should implement RecognizeFrame to provide a RecognizedStackFrame for a
46 /// given stack frame.
47 
49  : public std::enable_shared_from_this<StackFrameRecognizer> {
50 public:
51  virtual lldb::RecognizedStackFrameSP RecognizeFrame(
52  lldb::StackFrameSP frame) {
53  return lldb::RecognizedStackFrameSP();
54  };
55  virtual std::string GetName() {
56  return "";
57  }
58 
59  virtual ~StackFrameRecognizer(){};
60 };
61 
62 /// \class ScriptedStackFrameRecognizer
63 ///
64 /// Python implementation for frame recognizers. An instance of this class
65 /// tracks a particular Python classobject, which will be asked to recognize
66 /// stack frames.
67 
69  lldb_private::ScriptInterpreter *m_interpreter;
70  lldb_private::StructuredData::ObjectSP m_python_object_sp;
71  std::string m_python_class;
72 
73 public:
75  const char *pclass);
77 
78  std::string GetName() override {
79  return GetPythonClassName();
80  }
81 
82  const char *GetPythonClassName() { return m_python_class.c_str(); }
83 
84  lldb::RecognizedStackFrameSP RecognizeFrame(
85  lldb::StackFrameSP frame) override;
86 
87 private:
88  DISALLOW_COPY_AND_ASSIGN(ScriptedStackFrameRecognizer);
89 };
90 
91 /// \class StackFrameRecognizerManager
92 ///
93 /// Static class that provides a registry of known stack frame recognizers.
94 /// Has static methods to add, enumerate, remove, query and invoke recognizers.
95 
97 public:
98  static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
99  ConstString module,
100  ConstString symbol,
101  bool first_instruction_only = true);
102 
103  static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
104  lldb::RegularExpressionSP module,
105  lldb::RegularExpressionSP symbol,
106  bool first_instruction_only = true);
107 
108  static void ForEach(
109  std::function<void(uint32_t recognizer_id, std::string recognizer_name,
110  std::string module, std::string symbol,
111  bool regexp)> const &callback);
112 
113  static bool RemoveRecognizerWithID(uint32_t recognizer_id);
114 
115  static void RemoveAllRecognizers();
116 
117  static lldb::StackFrameRecognizerSP GetRecognizerForFrame(
118  lldb::StackFrameSP frame);
119 
120  static lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame);
121 };
122 
123 /// \class ValueObjectRecognizerSynthesizedValue
124 ///
125 /// ValueObject subclass that presents the passed ValueObject as a recognized
126 /// value with the specified ValueType. Frame recognizers should return
127 /// instances of this class as the returned objects in GetRecognizedArguments().
128 
130  public:
131  static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) {
132  return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP();
133  }
135  lldb::ValueType type)
136  : ValueObject(parent), m_type(type) {
137  SetName(parent.GetName());
138  }
139 
140  uint64_t GetByteSize() override { return m_parent->GetByteSize(); }
141  lldb::ValueType GetValueType() const override { return m_type; }
142  bool UpdateValue() override {
143  if (!m_parent->UpdateValueIfNeeded()) return false;
144  m_value = m_parent->GetValue();
145  return true;
146  }
147  size_t CalculateNumChildren(uint32_t max = UINT32_MAX) override {
148  return m_parent->GetNumChildren(max);
149  }
151  return m_parent->GetCompilerType();
152  }
153  bool IsSynthetic() override { return true; }
154 
155  private:
156  lldb::ValueType m_type;
157 };
158 
159 } // namespace lldb_private
160 
161 #endif // liblldb_StackFrameRecognizer_h_
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
ConstString GetName() const
ValueObject subclass that presents the passed ValueObject as a recognized value with the specified Va...
static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type)
ValueObjectRecognizerSynthesizedValue(ValueObject &parent, lldb::ValueType type)
A base class for frame recognizers.
Static class that provides a registry of known stack frame recognizers.
#define UINT32_MAX
Definition: lldb-defines.h:31
virtual lldb::ValueObjectListSP GetRecognizedArguments()
virtual lldb::ValueObjectSP GetExceptionObject()
size_t CalculateNumChildren(uint32_t max=UINT32_MAX) override
Python implementation for frame recognizers.
A uniqued constant string class.
Definition: ConstString.h:38
std::shared_ptr< Object > ObjectSP
This class provides extra information about a stack frame that was provided by a specific stack frame...
virtual lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame)