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
170
171
172
173
174
175
176
177
178
179
180
181
182
|
//===-- Value.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_CORE_VALUE_H
#define LLDB_CORE_VALUE_H
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-types.h"
#include "llvm/ADT/APInt.h"
#include <vector>
#include <cstdint>
#include <cstring>
namespace lldb_private {
class DataExtractor;
class ExecutionContext;
class Module;
class Stream;
class Type;
class Variable;
}
namespace lldb_private {
class Value {
public:
/// Type that describes Value::m_value.
enum class ValueType {
Invalid = -1,
// m_value contains:
/// A raw scalar value.
Scalar = 0,
/// A file address value.
FileAddress,
/// A load address value.
LoadAddress,
/// A host address value (for memory in the process that < A is
/// using liblldb).
HostAddress
};
/// Type that describes Value::m_context.
enum class ContextType {
// m_context contains:
/// Undefined.
Invalid = -1,
/// RegisterInfo * (can be a scalar or a vector register).
RegisterInfo = 0,
/// lldb_private::Type *.
LLDBType,
/// lldb_private::Variable *.
Variable
};
Value();
Value(const Scalar &scalar);
Value(const void *bytes, int len);
Value(const Value &rhs);
void SetBytes(const void *bytes, int len);
void AppendBytes(const void *bytes, int len);
Value &operator=(const Value &rhs);
const CompilerType &GetCompilerType();
void SetCompilerType(const CompilerType &compiler_type);
ValueType GetValueType() const;
AddressType GetValueAddressType() const;
ContextType GetContextType() const { return m_context_type; }
void SetValueType(ValueType value_type) { m_value_type = value_type; }
void ClearContext() {
m_context = nullptr;
m_context_type = ContextType::Invalid;
}
void SetContext(ContextType context_type, void *p) {
m_context_type = context_type;
m_context = p;
if (m_context_type == ContextType::RegisterInfo) {
RegisterInfo *reg_info = GetRegisterInfo();
if (reg_info->encoding == lldb::eEncodingVector)
SetValueType(ValueType::Scalar);
}
}
RegisterInfo *GetRegisterInfo() const;
Type *GetType();
Scalar &ResolveValue(ExecutionContext *exe_ctx);
const Scalar &GetScalar() const { return m_value; }
Scalar &GetScalar() { return m_value; }
size_t ResizeData(size_t len);
size_t AppendDataToHostBuffer(const Value &rhs);
DataBufferHeap &GetBuffer() { return m_data_buffer; }
const DataBufferHeap &GetBuffer() const { return m_data_buffer; }
bool ValueOf(ExecutionContext *exe_ctx);
Variable *GetVariable();
void Dump(Stream *strm);
lldb::Format GetValueDefaultFormat();
uint64_t GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx);
Status GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
Module *module); // Can be nullptr
static const char *GetValueTypeAsCString(ValueType context_type);
static const char *GetContextTypeAsCString(ContextType context_type);
/// Convert this value's file address to a load address, if possible.
void ConvertToLoadAddress(Module *module, Target *target);
bool GetData(DataExtractor &data);
void Clear();
protected:
Scalar m_value;
CompilerType m_compiler_type;
void *m_context = nullptr;
ValueType m_value_type = ValueType::Scalar;
ContextType m_context_type = ContextType::Invalid;
DataBufferHeap m_data_buffer;
};
class ValueList {
public:
ValueList() : m_values() {}
ValueList(const ValueList &rhs);
~ValueList() = default;
const ValueList &operator=(const ValueList &rhs);
// void InsertValue (Value *value, size_t idx);
void PushValue(const Value &value);
size_t GetSize();
Value *GetValueAtIndex(size_t idx);
void Clear();
private:
typedef std::vector<Value> collection;
collection m_values;
};
} // namespace lldb_private
#endif // LLDB_CORE_VALUE_H
|
