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/Scalar.h" // for Scalar
14 #include "lldb/Core/Value.h"  // for Value, Value::ContextType:...
15 #include "lldb/Symbol/CompilerType.h"
16 #include "lldb/Symbol/TypeSystem.h" // for TypeSystem
17 #include "lldb/Target/ExecutionContext.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Target/RegisterContext.h"
20 #include "lldb/Target/StackFrame.h" // for StackFrame
21 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/DataExtractor.h" // for DataExtractor
23 #include "lldb/Utility/Status.h"        // for Status
24 #include "lldb/Utility/Stream.h"        // for Stream
25 
26 #include "llvm/ADT/StringRef.h" // for StringRef
27 
28 #include <assert.h> // for assert
29 #include <memory>   // for shared_ptr
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 
40 ValueObjectRegisterContext::ValueObjectRegisterContext(
41     ValueObject &parent, RegisterContextSP &reg_ctx)
42     : ValueObject(parent), m_reg_ctx_sp(reg_ctx) {
43   assert(reg_ctx);
44   m_name.SetCString("Registers");
45   SetValueIsValid(true);
46 }
47 
48 ValueObjectRegisterContext::~ValueObjectRegisterContext() {}
49 
50 CompilerType ValueObjectRegisterContext::GetCompilerTypeImpl() {
51   return CompilerType();
52 }
53 
54 ConstString ValueObjectRegisterContext::GetTypeName() { return ConstString(); }
55 
56 ConstString ValueObjectRegisterContext::GetDisplayTypeName() {
57   return ConstString();
58 }
59 
60 ConstString ValueObjectRegisterContext::GetQualifiedTypeName() {
61   return ConstString();
62 }
63 
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 
69 uint64_t ValueObjectRegisterContext::GetByteSize() { return 0; }
70 
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 
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
107 ValueObjectRegisterSet::Create(ExecutionContextScope *exe_scope,
108                                lldb::RegisterContextSP &reg_ctx_sp,
109                                uint32_t set_idx) {
110   return (new ValueObjectRegisterSet(exe_scope, reg_ctx_sp, set_idx))->GetSP();
111 }
112 
113 ValueObjectRegisterSet::ValueObjectRegisterSet(ExecutionContextScope *exe_scope,
114                                                lldb::RegisterContextSP &reg_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 
125 ValueObjectRegisterSet::~ValueObjectRegisterSet() {}
126 
127 CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
128   return CompilerType();
129 }
130 
131 ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); }
132 
133 ConstString ValueObjectRegisterSet::GetQualifiedTypeName() {
134   return ConstString();
135 }
136 
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 
146 uint64_t ValueObjectRegisterSet::GetByteSize() { return 0; }
147 
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 
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
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
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 
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 
231 ValueObjectRegister::ValueObjectRegister(ValueObject &parent,
232                                          lldb::RegisterContextSP &reg_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 
240 ValueObjectSP ValueObjectRegister::Create(ExecutionContextScope *exe_scope,
241                                           lldb::RegisterContextSP &reg_ctx_sp,
242                                           uint32_t reg_num) {
243   return (new ValueObjectRegister(exe_scope, reg_ctx_sp, reg_num))->GetSP();
244 }
245 
246 ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
247                                          lldb::RegisterContextSP &reg_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 
255 ValueObjectRegister::~ValueObjectRegister() {}
256 
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 
275 ConstString ValueObjectRegister::GetTypeName() {
276   if (m_type_name.IsEmpty())
277     m_type_name = GetCompilerType().GetConstTypeName();
278   return m_type_name;
279 }
280 
281 size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
282   auto children_count = GetCompilerType().GetNumChildren(true);
283   return children_count <= max ? children_count : max;
284 }
285 
286 uint64_t ValueObjectRegister::GetByteSize() { return m_reg_info.byte_size; }
287 
288 bool ValueObjectRegister::UpdateValue() {
289   m_error.Clear();
290   ExecutionContext exe_ctx(GetExecutionContextRef());
291   StackFrame *frame = exe_ctx.GetFramePtr();
292   if (frame == NULL) {
293     m_reg_ctx_sp.reset();
294     m_reg_value.Clear();
295   }
296 
297   if (m_reg_ctx_sp) {
298     RegisterValue m_old_reg_value(m_reg_value);
299     if (m_reg_ctx_sp->ReadRegister(&m_reg_info, m_reg_value)) {
300       if (m_reg_value.GetData(m_data)) {
301         Process *process = exe_ctx.GetProcessPtr();
302         if (process)
303           m_data.SetAddressByteSize(process->GetAddressByteSize());
304         m_value.SetContext(Value::eContextTypeRegisterInfo,
305                            (void *)&m_reg_info);
306         m_value.SetValueType(Value::eValueTypeHostAddress);
307         m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
308         SetValueIsValid(true);
309         SetValueDidChange(!(m_old_reg_value == m_reg_value));
310         return true;
311       }
312     }
313   }
314 
315   SetValueIsValid(false);
316   m_error.SetErrorToGenericError();
317   return false;
318 }
319 
320 bool ValueObjectRegister::SetValueFromCString(const char *value_str,
321                                               Status &error) {
322   // The new value will be in the m_data.  Copy that into our register value.
323   error =
324       m_reg_value.SetValueFromString(&m_reg_info, llvm::StringRef(value_str));
325   if (error.Success()) {
326     if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
327       SetNeedsUpdate();
328       return true;
329     } else
330       return false;
331   } else
332     return false;
333 }
334 
335 bool ValueObjectRegister::SetData(DataExtractor &data, Status &error) {
336   error = m_reg_value.SetValueFromData(&m_reg_info, data, 0, false);
337   if (error.Success()) {
338     if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
339       SetNeedsUpdate();
340       return true;
341     } else
342       return false;
343   } else
344     return false;
345 }
346 
347 bool ValueObjectRegister::ResolveValue(Scalar &scalar) {
348   if (UpdateValueIfNeeded(
349           false)) // make sure that you are up to date before returning anything
350     return m_reg_value.GetScalarValue(scalar);
351   return false;
352 }
353 
354 void ValueObjectRegister::GetExpressionPath(Stream &s,
355                                             bool qualify_cxx_base_classes,
356                                             GetExpressionPathFormat epformat) {
357   s.Printf("$%s", m_reg_info.name);
358 }
359