1 | //===-- ValueObjectRegister.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 "lldb/Core/ValueObjectRegister.h" |
10 | |
11 | #include "lldb/Core/Module.h" |
12 | #include "lldb/Core/Value.h" |
13 | #include "lldb/Symbol/CompilerType.h" |
14 | #include "lldb/Symbol/TypeSystem.h" |
15 | #include "lldb/Target/ExecutionContext.h" |
16 | #include "lldb/Target/Process.h" |
17 | #include "lldb/Target/RegisterContext.h" |
18 | #include "lldb/Target/StackFrame.h" |
19 | #include "lldb/Target/Target.h" |
20 | #include "lldb/Utility/DataExtractor.h" |
21 | #include "lldb/Utility/LLDBLog.h" |
22 | #include "lldb/Utility/Log.h" |
23 | #include "lldb/Utility/Scalar.h" |
24 | #include "lldb/Utility/Status.h" |
25 | #include "lldb/Utility/Stream.h" |
26 | |
27 | #include "llvm/ADT/StringRef.h" |
28 | |
29 | #include <cassert> |
30 | #include <memory> |
31 | #include <optional> |
32 | |
33 | namespace lldb_private { |
34 | class ExecutionContextScope; |
35 | } |
36 | |
37 | using namespace lldb; |
38 | using namespace lldb_private; |
39 | |
40 | #pragma mark ValueObjectRegisterSet |
41 | |
42 | ValueObjectSP |
43 | ValueObjectRegisterSet::Create(ExecutionContextScope *exe_scope, |
44 | lldb::RegisterContextSP ®_ctx_sp, |
45 | uint32_t set_idx) { |
46 | auto manager_sp = ValueObjectManager::Create(); |
47 | return (new ValueObjectRegisterSet(exe_scope, *manager_sp, reg_ctx_sp, |
48 | set_idx)) |
49 | ->GetSP(); |
50 | } |
51 | |
52 | ValueObjectRegisterSet::ValueObjectRegisterSet(ExecutionContextScope *exe_scope, |
53 | ValueObjectManager &manager, |
54 | lldb::RegisterContextSP ®_ctx, |
55 | uint32_t reg_set_idx) |
56 | : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), |
57 | m_reg_set(nullptr), m_reg_set_idx(reg_set_idx) { |
58 | assert(reg_ctx); |
59 | m_reg_set = reg_ctx->GetRegisterSet(reg_set: m_reg_set_idx); |
60 | if (m_reg_set) { |
61 | m_name.SetCString(m_reg_set->name); |
62 | } |
63 | } |
64 | |
65 | ValueObjectRegisterSet::~ValueObjectRegisterSet() = default; |
66 | |
67 | CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() { |
68 | return CompilerType(); |
69 | } |
70 | |
71 | ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); } |
72 | |
73 | ConstString ValueObjectRegisterSet::GetQualifiedTypeName() { |
74 | return ConstString(); |
75 | } |
76 | |
77 | size_t ValueObjectRegisterSet::CalculateNumChildren(uint32_t max) { |
78 | const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(reg_set: m_reg_set_idx); |
79 | if (reg_set) { |
80 | auto reg_count = reg_set->num_registers; |
81 | return reg_count <= max ? reg_count : max; |
82 | } |
83 | return 0; |
84 | } |
85 | |
86 | std::optional<uint64_t> ValueObjectRegisterSet::GetByteSize() { return 0; } |
87 | |
88 | bool ValueObjectRegisterSet::UpdateValue() { |
89 | m_error.Clear(); |
90 | SetValueDidChange(false); |
91 | ExecutionContext exe_ctx(GetExecutionContextRef()); |
92 | StackFrame *frame = exe_ctx.GetFramePtr(); |
93 | if (frame == nullptr) |
94 | m_reg_ctx_sp.reset(); |
95 | else { |
96 | m_reg_ctx_sp = frame->GetRegisterContext(); |
97 | if (m_reg_ctx_sp) { |
98 | const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(reg_set: m_reg_set_idx); |
99 | if (reg_set == nullptr) |
100 | m_reg_ctx_sp.reset(); |
101 | else if (m_reg_set != reg_set) { |
102 | SetValueDidChange(true); |
103 | m_name.SetCString(reg_set->name); |
104 | } |
105 | } |
106 | } |
107 | if (m_reg_ctx_sp) { |
108 | SetValueIsValid(true); |
109 | } else { |
110 | SetValueIsValid(false); |
111 | m_error.SetErrorToGenericError(); |
112 | m_children.Clear(); |
113 | } |
114 | return m_error.Success(); |
115 | } |
116 | |
117 | ValueObject *ValueObjectRegisterSet::CreateChildAtIndex( |
118 | size_t idx, bool synthetic_array_member, int32_t synthetic_index) { |
119 | ValueObject *valobj = nullptr; |
120 | if (m_reg_ctx_sp && m_reg_set) { |
121 | const size_t num_children = GetNumChildren(); |
122 | if (idx < num_children) |
123 | valobj = new ValueObjectRegister( |
124 | *this, m_reg_ctx_sp, |
125 | m_reg_ctx_sp->GetRegisterInfoAtIndex(reg: m_reg_set->registers[idx])); |
126 | } |
127 | return valobj; |
128 | } |
129 | |
130 | lldb::ValueObjectSP |
131 | ValueObjectRegisterSet::GetChildMemberWithName(llvm::StringRef name, |
132 | bool can_create) { |
133 | ValueObject *valobj = nullptr; |
134 | if (m_reg_ctx_sp && m_reg_set) { |
135 | const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(reg_name: name); |
136 | if (reg_info != nullptr) |
137 | valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, reg_info); |
138 | } |
139 | if (valobj) |
140 | return valobj->GetSP(); |
141 | else |
142 | return ValueObjectSP(); |
143 | } |
144 | |
145 | size_t ValueObjectRegisterSet::GetIndexOfChildWithName(llvm::StringRef name) { |
146 | if (m_reg_ctx_sp && m_reg_set) { |
147 | const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(reg_name: name); |
148 | if (reg_info != nullptr) |
149 | return reg_info->kinds[eRegisterKindLLDB]; |
150 | } |
151 | return UINT32_MAX; |
152 | } |
153 | |
154 | #pragma mark - |
155 | #pragma mark ValueObjectRegister |
156 | |
157 | void ValueObjectRegister::ConstructObject(const RegisterInfo *reg_info) { |
158 | if (reg_info) { |
159 | m_reg_info = *reg_info; |
160 | if (reg_info->name) |
161 | m_name.SetCString(reg_info->name); |
162 | else if (reg_info->alt_name) |
163 | m_name.SetCString(reg_info->alt_name); |
164 | } |
165 | } |
166 | |
167 | ValueObjectRegister::ValueObjectRegister(ValueObject &parent, |
168 | lldb::RegisterContextSP ®_ctx_sp, |
169 | const RegisterInfo *reg_info) |
170 | : ValueObject(parent), m_reg_ctx_sp(reg_ctx_sp), m_reg_info(), |
171 | m_reg_value(), m_type_name(), m_compiler_type() { |
172 | assert(reg_ctx_sp.get()); |
173 | ConstructObject(reg_info); |
174 | } |
175 | |
176 | ValueObjectSP ValueObjectRegister::Create(ExecutionContextScope *exe_scope, |
177 | lldb::RegisterContextSP ®_ctx_sp, |
178 | const RegisterInfo *reg_info) { |
179 | auto manager_sp = ValueObjectManager::Create(); |
180 | return (new ValueObjectRegister(exe_scope, *manager_sp, reg_ctx_sp, reg_info)) |
181 | ->GetSP(); |
182 | } |
183 | |
184 | ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope, |
185 | ValueObjectManager &manager, |
186 | lldb::RegisterContextSP ®_ctx, |
187 | const RegisterInfo *reg_info) |
188 | : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), m_reg_info(), |
189 | m_reg_value(), m_type_name(), m_compiler_type() { |
190 | assert(reg_ctx); |
191 | ConstructObject(reg_info); |
192 | } |
193 | |
194 | ValueObjectRegister::~ValueObjectRegister() = default; |
195 | |
196 | CompilerType ValueObjectRegister::GetCompilerTypeImpl() { |
197 | if (!m_compiler_type.IsValid()) { |
198 | ExecutionContext exe_ctx(GetExecutionContextRef()); |
199 | if (auto *target = exe_ctx.GetTargetPtr()) { |
200 | if (auto *exe_module = target->GetExecutableModulePointer()) { |
201 | auto type_system_or_err = |
202 | exe_module->GetTypeSystemForLanguage(language: eLanguageTypeC); |
203 | if (auto err = type_system_or_err.takeError()) { |
204 | LLDB_LOG_ERROR(GetLog(LLDBLog::Types), std::move(err), |
205 | "Unable to get CompilerType from TypeSystem: {0}" ); |
206 | } else { |
207 | if (auto ts = *type_system_or_err) |
208 | m_compiler_type = ts->GetBuiltinTypeForEncodingAndBitSize( |
209 | encoding: m_reg_info.encoding, bit_size: m_reg_info.byte_size * 8); |
210 | } |
211 | } |
212 | } |
213 | } |
214 | return m_compiler_type; |
215 | } |
216 | |
217 | ConstString ValueObjectRegister::GetTypeName() { |
218 | if (m_type_name.IsEmpty()) |
219 | m_type_name = GetCompilerType().GetTypeName(); |
220 | return m_type_name; |
221 | } |
222 | |
223 | size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) { |
224 | ExecutionContext exe_ctx(GetExecutionContextRef()); |
225 | auto children_count = GetCompilerType().GetNumChildren(omit_empty_base_classes: true, exe_ctx: &exe_ctx); |
226 | return children_count <= max ? children_count : max; |
227 | } |
228 | |
229 | std::optional<uint64_t> ValueObjectRegister::GetByteSize() { |
230 | return m_reg_info.byte_size; |
231 | } |
232 | |
233 | bool ValueObjectRegister::UpdateValue() { |
234 | m_error.Clear(); |
235 | ExecutionContext exe_ctx(GetExecutionContextRef()); |
236 | StackFrame *frame = exe_ctx.GetFramePtr(); |
237 | if (frame == nullptr) { |
238 | m_reg_ctx_sp.reset(); |
239 | m_reg_value.Clear(); |
240 | } |
241 | |
242 | if (m_reg_ctx_sp) { |
243 | RegisterValue m_old_reg_value(m_reg_value); |
244 | if (m_reg_ctx_sp->ReadRegister(reg_info: &m_reg_info, reg_value&: m_reg_value)) { |
245 | if (m_reg_value.GetData(data&: m_data)) { |
246 | Process *process = exe_ctx.GetProcessPtr(); |
247 | if (process) |
248 | m_data.SetAddressByteSize(process->GetAddressByteSize()); |
249 | m_value.SetContext(context_type: Value::ContextType::RegisterInfo, |
250 | p: (void *)&m_reg_info); |
251 | m_value.SetValueType(Value::ValueType::HostAddress); |
252 | m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); |
253 | SetValueIsValid(true); |
254 | SetValueDidChange(!(m_old_reg_value == m_reg_value)); |
255 | return true; |
256 | } |
257 | } |
258 | } |
259 | |
260 | SetValueIsValid(false); |
261 | m_error.SetErrorToGenericError(); |
262 | return false; |
263 | } |
264 | |
265 | bool ValueObjectRegister::SetValueFromCString(const char *value_str, |
266 | Status &error) { |
267 | // The new value will be in the m_data. Copy that into our register value. |
268 | error = |
269 | m_reg_value.SetValueFromString(reg_info: &m_reg_info, value_str: llvm::StringRef(value_str)); |
270 | if (!error.Success()) |
271 | return false; |
272 | |
273 | if (!m_reg_ctx_sp->WriteRegister(reg_info: &m_reg_info, reg_value: m_reg_value)) { |
274 | error.SetErrorString("unable to write back to register" ); |
275 | return false; |
276 | } |
277 | |
278 | SetNeedsUpdate(); |
279 | return true; |
280 | } |
281 | |
282 | bool ValueObjectRegister::(DataExtractor &data, Status &error) { |
283 | error = m_reg_value.SetValueFromData(reg_info: m_reg_info, data, offset: 0, partial_data_ok: false); |
284 | if (!error.Success()) |
285 | return false; |
286 | |
287 | if (!m_reg_ctx_sp->WriteRegister(reg_info: &m_reg_info, reg_value: m_reg_value)) { |
288 | error.SetErrorString("unable to write back to register" ); |
289 | return false; |
290 | } |
291 | |
292 | SetNeedsUpdate(); |
293 | return true; |
294 | } |
295 | |
296 | bool ValueObjectRegister::ResolveValue(Scalar &scalar) { |
297 | if (UpdateValueIfNeeded( |
298 | update_format: false)) // make sure that you are up to date before returning anything |
299 | return m_reg_value.GetScalarValue(scalar); |
300 | return false; |
301 | } |
302 | |
303 | void ValueObjectRegister::GetExpressionPath(Stream &s, |
304 | GetExpressionPathFormat epformat) { |
305 | s.Printf(format: "$%s" , m_reg_info.name); |
306 | } |
307 | |