1 //===-- ValueObjectRegister.cpp ---------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Core/ValueObjectRegister.h"
11
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/Value.h"
14 #include "lldb/Symbol/CompilerType.h"
15 #include "lldb/Symbol/TypeSystem.h"
16 #include "lldb/Target/ExecutionContext.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/RegisterContext.h"
19 #include "lldb/Target/StackFrame.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/DataExtractor.h"
22 #include "lldb/Utility/Scalar.h"
23 #include "lldb/Utility/Status.h"
24 #include "lldb/Utility/Stream.h"
25
26 #include "llvm/ADT/StringRef.h"
27
28 #include <assert.h>
29 #include <memory>
30
31 namespace lldb_private {
32 class ExecutionContextScope;
33 }
34
35 using namespace lldb;
36 using namespace lldb_private;
37
38 #pragma mark ValueObjectRegisterContext
39
ValueObjectRegisterContext(ValueObject & parent,RegisterContextSP & reg_ctx)40 ValueObjectRegisterContext::ValueObjectRegisterContext(
41 ValueObject &parent, RegisterContextSP ®_ctx)
42 : ValueObject(parent), m_reg_ctx_sp(reg_ctx) {
43 assert(reg_ctx);
44 m_name.SetCString("Registers");
45 SetValueIsValid(true);
46 }
47
~ValueObjectRegisterContext()48 ValueObjectRegisterContext::~ValueObjectRegisterContext() {}
49
GetCompilerTypeImpl()50 CompilerType ValueObjectRegisterContext::GetCompilerTypeImpl() {
51 return CompilerType();
52 }
53
GetTypeName()54 ConstString ValueObjectRegisterContext::GetTypeName() { return ConstString(); }
55
GetDisplayTypeName()56 ConstString ValueObjectRegisterContext::GetDisplayTypeName() {
57 return ConstString();
58 }
59
GetQualifiedTypeName()60 ConstString ValueObjectRegisterContext::GetQualifiedTypeName() {
61 return ConstString();
62 }
63
CalculateNumChildren(uint32_t max)64 size_t ValueObjectRegisterContext::CalculateNumChildren(uint32_t max) {
65 auto reg_set_count = m_reg_ctx_sp->GetRegisterSetCount();
66 return reg_set_count <= max ? reg_set_count : max;
67 }
68
GetByteSize()69 uint64_t ValueObjectRegisterContext::GetByteSize() { return 0; }
70
UpdateValue()71 bool ValueObjectRegisterContext::UpdateValue() {
72 m_error.Clear();
73 ExecutionContext exe_ctx(GetExecutionContextRef());
74 StackFrame *frame = exe_ctx.GetFramePtr();
75 if (frame)
76 m_reg_ctx_sp = frame->GetRegisterContext();
77 else
78 m_reg_ctx_sp.reset();
79
80 if (m_reg_ctx_sp.get() == NULL) {
81 SetValueIsValid(false);
82 m_error.SetErrorToGenericError();
83 } else
84 SetValueIsValid(true);
85
86 return m_error.Success();
87 }
88
CreateChildAtIndex(size_t idx,bool synthetic_array_member,int32_t synthetic_index)89 ValueObject *ValueObjectRegisterContext::CreateChildAtIndex(
90 size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
91 ValueObject *new_valobj = NULL;
92
93 const size_t num_children = GetNumChildren();
94 if (idx < num_children) {
95 ExecutionContext exe_ctx(GetExecutionContextRef());
96 new_valobj = new ValueObjectRegisterSet(
97 exe_ctx.GetBestExecutionContextScope(), m_reg_ctx_sp, idx);
98 }
99
100 return new_valobj;
101 }
102
103 #pragma mark -
104 #pragma mark ValueObjectRegisterSet
105
106 ValueObjectSP
Create(ExecutionContextScope * exe_scope,lldb::RegisterContextSP & reg_ctx_sp,uint32_t set_idx)107 ValueObjectRegisterSet::Create(ExecutionContextScope *exe_scope,
108 lldb::RegisterContextSP ®_ctx_sp,
109 uint32_t set_idx) {
110 return (new ValueObjectRegisterSet(exe_scope, reg_ctx_sp, set_idx))->GetSP();
111 }
112
ValueObjectRegisterSet(ExecutionContextScope * exe_scope,lldb::RegisterContextSP & reg_ctx,uint32_t reg_set_idx)113 ValueObjectRegisterSet::ValueObjectRegisterSet(ExecutionContextScope *exe_scope,
114 lldb::RegisterContextSP ®_ctx,
115 uint32_t reg_set_idx)
116 : ValueObject(exe_scope), m_reg_ctx_sp(reg_ctx), m_reg_set(NULL),
117 m_reg_set_idx(reg_set_idx) {
118 assert(reg_ctx);
119 m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
120 if (m_reg_set) {
121 m_name.SetCString(m_reg_set->name);
122 }
123 }
124
~ValueObjectRegisterSet()125 ValueObjectRegisterSet::~ValueObjectRegisterSet() {}
126
GetCompilerTypeImpl()127 CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
128 return CompilerType();
129 }
130
GetTypeName()131 ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); }
132
GetQualifiedTypeName()133 ConstString ValueObjectRegisterSet::GetQualifiedTypeName() {
134 return ConstString();
135 }
136
CalculateNumChildren(uint32_t max)137 size_t ValueObjectRegisterSet::CalculateNumChildren(uint32_t max) {
138 const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
139 if (reg_set) {
140 auto reg_count = reg_set->num_registers;
141 return reg_count <= max ? reg_count : max;
142 }
143 return 0;
144 }
145
GetByteSize()146 uint64_t ValueObjectRegisterSet::GetByteSize() { return 0; }
147
UpdateValue()148 bool ValueObjectRegisterSet::UpdateValue() {
149 m_error.Clear();
150 SetValueDidChange(false);
151 ExecutionContext exe_ctx(GetExecutionContextRef());
152 StackFrame *frame = exe_ctx.GetFramePtr();
153 if (frame == NULL)
154 m_reg_ctx_sp.reset();
155 else {
156 m_reg_ctx_sp = frame->GetRegisterContext();
157 if (m_reg_ctx_sp) {
158 const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
159 if (reg_set == NULL)
160 m_reg_ctx_sp.reset();
161 else if (m_reg_set != reg_set) {
162 SetValueDidChange(true);
163 m_name.SetCString(reg_set->name);
164 }
165 }
166 }
167 if (m_reg_ctx_sp) {
168 SetValueIsValid(true);
169 } else {
170 SetValueIsValid(false);
171 m_error.SetErrorToGenericError();
172 m_children.Clear();
173 }
174 return m_error.Success();
175 }
176
CreateChildAtIndex(size_t idx,bool synthetic_array_member,int32_t synthetic_index)177 ValueObject *ValueObjectRegisterSet::CreateChildAtIndex(
178 size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
179 ValueObject *valobj = NULL;
180 if (m_reg_ctx_sp && m_reg_set) {
181 const size_t num_children = GetNumChildren();
182 if (idx < num_children)
183 valobj = new ValueObjectRegister(*this, m_reg_ctx_sp,
184 m_reg_set->registers[idx]);
185 }
186 return valobj;
187 }
188
189 lldb::ValueObjectSP
GetChildMemberWithName(const ConstString & name,bool can_create)190 ValueObjectRegisterSet::GetChildMemberWithName(const ConstString &name,
191 bool can_create) {
192 ValueObject *valobj = NULL;
193 if (m_reg_ctx_sp && m_reg_set) {
194 const RegisterInfo *reg_info =
195 m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
196 if (reg_info != NULL)
197 valobj = new ValueObjectRegister(*this, m_reg_ctx_sp,
198 reg_info->kinds[eRegisterKindLLDB]);
199 }
200 if (valobj)
201 return valobj->GetSP();
202 else
203 return ValueObjectSP();
204 }
205
206 size_t
GetIndexOfChildWithName(const ConstString & name)207 ValueObjectRegisterSet::GetIndexOfChildWithName(const ConstString &name) {
208 if (m_reg_ctx_sp && m_reg_set) {
209 const RegisterInfo *reg_info =
210 m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
211 if (reg_info != NULL)
212 return reg_info->kinds[eRegisterKindLLDB];
213 }
214 return UINT32_MAX;
215 }
216
217 #pragma mark -
218 #pragma mark ValueObjectRegister
219
ConstructObject(uint32_t reg_num)220 void ValueObjectRegister::ConstructObject(uint32_t reg_num) {
221 const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex(reg_num);
222 if (reg_info) {
223 m_reg_info = *reg_info;
224 if (reg_info->name)
225 m_name.SetCString(reg_info->name);
226 else if (reg_info->alt_name)
227 m_name.SetCString(reg_info->alt_name);
228 }
229 }
230
ValueObjectRegister(ValueObject & parent,lldb::RegisterContextSP & reg_ctx_sp,uint32_t reg_num)231 ValueObjectRegister::ValueObjectRegister(ValueObject &parent,
232 lldb::RegisterContextSP ®_ctx_sp,
233 uint32_t reg_num)
234 : ValueObject(parent), m_reg_ctx_sp(reg_ctx_sp), m_reg_info(),
235 m_reg_value(), m_type_name(), m_compiler_type() {
236 assert(reg_ctx_sp.get());
237 ConstructObject(reg_num);
238 }
239
Create(ExecutionContextScope * exe_scope,lldb::RegisterContextSP & reg_ctx_sp,uint32_t reg_num)240 ValueObjectSP ValueObjectRegister::Create(ExecutionContextScope *exe_scope,
241 lldb::RegisterContextSP ®_ctx_sp,
242 uint32_t reg_num) {
243 return (new ValueObjectRegister(exe_scope, reg_ctx_sp, reg_num))->GetSP();
244 }
245
ValueObjectRegister(ExecutionContextScope * exe_scope,lldb::RegisterContextSP & reg_ctx,uint32_t reg_num)246 ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
247 lldb::RegisterContextSP ®_ctx,
248 uint32_t reg_num)
249 : ValueObject(exe_scope), m_reg_ctx_sp(reg_ctx), m_reg_info(),
250 m_reg_value(), m_type_name(), m_compiler_type() {
251 assert(reg_ctx);
252 ConstructObject(reg_num);
253 }
254
~ValueObjectRegister()255 ValueObjectRegister::~ValueObjectRegister() {}
256
GetCompilerTypeImpl()257 CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
258 if (!m_compiler_type.IsValid()) {
259 ExecutionContext exe_ctx(GetExecutionContextRef());
260 Target *target = exe_ctx.GetTargetPtr();
261 if (target) {
262 Module *exe_module = target->GetExecutableModulePointer();
263 if (exe_module) {
264 TypeSystem *type_system =
265 exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
266 if (type_system)
267 m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize(
268 m_reg_info.encoding, m_reg_info.byte_size * 8);
269 }
270 }
271 }
272 return m_compiler_type;
273 }
274
GetTypeName()275 ConstString ValueObjectRegister::GetTypeName() {
276 if (m_type_name.IsEmpty())
277 m_type_name = GetCompilerType().GetConstTypeName();
278 return m_type_name;
279 }
280
CalculateNumChildren(uint32_t max)281 size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
282 ExecutionContext exe_ctx(GetExecutionContextRef());
283 auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
284 return children_count <= max ? children_count : max;
285 }
286
GetByteSize()287 uint64_t ValueObjectRegister::GetByteSize() { return m_reg_info.byte_size; }
288
UpdateValue()289 bool ValueObjectRegister::UpdateValue() {
290 m_error.Clear();
291 ExecutionContext exe_ctx(GetExecutionContextRef());
292 StackFrame *frame = exe_ctx.GetFramePtr();
293 if (frame == NULL) {
294 m_reg_ctx_sp.reset();
295 m_reg_value.Clear();
296 }
297
298 if (m_reg_ctx_sp) {
299 RegisterValue m_old_reg_value(m_reg_value);
300 if (m_reg_ctx_sp->ReadRegister(&m_reg_info, m_reg_value)) {
301 if (m_reg_value.GetData(m_data)) {
302 Process *process = exe_ctx.GetProcessPtr();
303 if (process)
304 m_data.SetAddressByteSize(process->GetAddressByteSize());
305 m_value.SetContext(Value::eContextTypeRegisterInfo,
306 (void *)&m_reg_info);
307 m_value.SetValueType(Value::eValueTypeHostAddress);
308 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
309 SetValueIsValid(true);
310 SetValueDidChange(!(m_old_reg_value == m_reg_value));
311 return true;
312 }
313 }
314 }
315
316 SetValueIsValid(false);
317 m_error.SetErrorToGenericError();
318 return false;
319 }
320
SetValueFromCString(const char * value_str,Status & error)321 bool ValueObjectRegister::SetValueFromCString(const char *value_str,
322 Status &error) {
323 // The new value will be in the m_data. Copy that into our register value.
324 error =
325 m_reg_value.SetValueFromString(&m_reg_info, llvm::StringRef(value_str));
326 if (error.Success()) {
327 if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
328 SetNeedsUpdate();
329 return true;
330 } else
331 return false;
332 } else
333 return false;
334 }
335
SetData(DataExtractor & data,Status & error)336 bool ValueObjectRegister::SetData(DataExtractor &data, Status &error) {
337 error = m_reg_value.SetValueFromData(&m_reg_info, data, 0, false);
338 if (error.Success()) {
339 if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
340 SetNeedsUpdate();
341 return true;
342 } else
343 return false;
344 } else
345 return false;
346 }
347
ResolveValue(Scalar & scalar)348 bool ValueObjectRegister::ResolveValue(Scalar &scalar) {
349 if (UpdateValueIfNeeded(
350 false)) // make sure that you are up to date before returning anything
351 return m_reg_value.GetScalarValue(scalar);
352 return false;
353 }
354
GetExpressionPath(Stream & s,bool qualify_cxx_base_classes,GetExpressionPathFormat epformat)355 void ValueObjectRegister::GetExpressionPath(Stream &s,
356 bool qualify_cxx_base_classes,
357 GetExpressionPathFormat epformat) {
358 s.Printf("$%s", m_reg_info.name);
359 }
360