1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
//===-- StackFrameRecognizer.h ----------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_TARGET_STACKFRAMERECOGNIZER_H
#define LLDB_TARGET_STACKFRAMERECOGNIZER_H
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-public.h"
namespace lldb_private {
/// \class RecognizedStackFrame
///
/// This class provides extra information about a stack frame that was
/// provided by a specific stack frame recognizer. Right now, this class only
/// holds recognized arguments (via GetRecognizedArguments).
class RecognizedStackFrame
: public std::enable_shared_from_this<RecognizedStackFrame> {
public:
virtual lldb::ValueObjectListSP GetRecognizedArguments() {
return m_arguments;
}
virtual lldb::ValueObjectSP GetExceptionObject() {
return lldb::ValueObjectSP();
}
virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
virtual ~RecognizedStackFrame(){};
std::string GetStopDescription() { return m_stop_desc; }
protected:
lldb::ValueObjectListSP m_arguments;
std::string m_stop_desc;
};
/// \class StackFrameRecognizer
///
/// A base class for frame recognizers. Subclasses (actual frame recognizers)
/// should implement RecognizeFrame to provide a RecognizedStackFrame for a
/// given stack frame.
class StackFrameRecognizer
: public std::enable_shared_from_this<StackFrameRecognizer> {
public:
virtual lldb::RecognizedStackFrameSP RecognizeFrame(
lldb::StackFrameSP frame) {
return lldb::RecognizedStackFrameSP();
};
virtual std::string GetName() {
return "";
}
virtual ~StackFrameRecognizer(){};
};
/// \class ScriptedStackFrameRecognizer
///
/// Python implementation for frame recognizers. An instance of this class
/// tracks a particular Python classobject, which will be asked to recognize
/// stack frames.
class ScriptedStackFrameRecognizer : public StackFrameRecognizer {
lldb_private::ScriptInterpreter *m_interpreter;
lldb_private::StructuredData::ObjectSP m_python_object_sp;
std::string m_python_class;
public:
ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter,
const char *pclass);
~ScriptedStackFrameRecognizer() override {}
std::string GetName() override {
return GetPythonClassName();
}
const char *GetPythonClassName() { return m_python_class.c_str(); }
lldb::RecognizedStackFrameSP RecognizeFrame(
lldb::StackFrameSP frame) override;
private:
ScriptedStackFrameRecognizer(const ScriptedStackFrameRecognizer &) = delete;
const ScriptedStackFrameRecognizer &
operator=(const ScriptedStackFrameRecognizer &) = delete;
};
/// \class StackFrameRecognizerManager
///
/// Static class that provides a registry of known stack frame recognizers.
/// Has static methods to add, enumerate, remove, query and invoke recognizers.
class StackFrameRecognizerManager {
public:
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
ConstString module,
llvm::ArrayRef<ConstString> symbols,
bool first_instruction_only = true);
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
lldb::RegularExpressionSP module,
lldb::RegularExpressionSP symbol,
bool first_instruction_only = true);
static void
ForEach(std::function<void(uint32_t recognizer_id,
std::string recognizer_name, std::string module,
llvm::ArrayRef<ConstString> symbols,
bool regexp)> const &callback);
static bool RemoveRecognizerWithID(uint32_t recognizer_id);
static void RemoveAllRecognizers();
static lldb::StackFrameRecognizerSP GetRecognizerForFrame(
lldb::StackFrameSP frame);
static lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame);
};
/// \class ValueObjectRecognizerSynthesizedValue
///
/// ValueObject subclass that presents the passed ValueObject as a recognized
/// value with the specified ValueType. Frame recognizers should return
/// instances of this class as the returned objects in GetRecognizedArguments().
class ValueObjectRecognizerSynthesizedValue : public ValueObject {
public:
static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) {
return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP();
}
ValueObjectRecognizerSynthesizedValue(ValueObject &parent,
lldb::ValueType type)
: ValueObject(parent), m_type(type) {
SetName(parent.GetName());
}
uint64_t GetByteSize() override { return m_parent->GetByteSize(); }
lldb::ValueType GetValueType() const override { return m_type; }
bool UpdateValue() override {
if (!m_parent->UpdateValueIfNeeded()) return false;
m_value = m_parent->GetValue();
return true;
}
size_t CalculateNumChildren(uint32_t max = UINT32_MAX) override {
return m_parent->GetNumChildren(max);
}
CompilerType GetCompilerTypeImpl() override {
return m_parent->GetCompilerType();
}
bool IsSynthetic() override { return true; }
private:
lldb::ValueType m_type;
};
} // namespace lldb_private
#endif // LLDB_TARGET_STACKFRAMERECOGNIZER_H
|
