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 
11 #include "lldb/Core/ValueObjectRegister.h"
12 
13 // C Includes
14 // C++ Includes
15 // Other libraries and framework includes
16 // Project includes
17 #include "lldb/Core/Module.h"
18 #include "lldb/Symbol/ClangASTType.h"
19 #include "lldb/Symbol/ClangASTContext.h"
20 #include "lldb/Symbol/TypeList.h"
21 #include "lldb/Target/ExecutionContext.h"
22 #include "lldb/Target/Process.h"
23 #include "lldb/Target/RegisterContext.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Target/Thread.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 #pragma mark ValueObjectRegisterContext
31 
32 ValueObjectRegisterContext::ValueObjectRegisterContext (ValueObject &parent, RegisterContextSP &reg_ctx) :
33     ValueObject (parent),
34     m_reg_ctx_sp (reg_ctx)
35 {
36     assert (reg_ctx);
37     m_name.SetCString("Registers");
38     SetValueIsValid (true);
39 }
40 
41 ValueObjectRegisterContext::~ValueObjectRegisterContext()
42 {
43 }
44 
45 ClangASTType
46 ValueObjectRegisterContext::GetClangTypeImpl ()
47 {
48     return ClangASTType();
49 }
50 
51 ConstString
52 ValueObjectRegisterContext::GetTypeName()
53 {
54     return ConstString();
55 }
56 
57 ConstString
58 ValueObjectRegisterContext::GetDisplayTypeName()
59 {
60     return ConstString();
61 }
62 
63 ConstString
64 ValueObjectRegisterContext::GetQualifiedTypeName()
65 {
66     return ConstString();
67 }
68 
69 size_t
70 ValueObjectRegisterContext::CalculateNumChildren()
71 {
72     return m_reg_ctx_sp->GetRegisterSetCount();
73 }
74 
75 uint64_t
76 ValueObjectRegisterContext::GetByteSize()
77 {
78     return 0;
79 }
80 
81 bool
82 ValueObjectRegisterContext::UpdateValue ()
83 {
84     m_error.Clear();
85     ExecutionContext exe_ctx(GetExecutionContextRef());
86     StackFrame *frame = exe_ctx.GetFramePtr();
87     if (frame)
88         m_reg_ctx_sp = frame->GetRegisterContext();
89     else
90         m_reg_ctx_sp.reset();
91 
92     if (m_reg_ctx_sp.get() == NULL)
93     {
94         SetValueIsValid (false);
95         m_error.SetErrorToGenericError();
96     }
97     else
98         SetValueIsValid (true);
99 
100     return m_error.Success();
101 }
102 
103 ValueObject *
104 ValueObjectRegisterContext::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
105 {
106     ValueObject *new_valobj = NULL;
107 
108     const size_t num_children = GetNumChildren();
109     if (idx < num_children)
110     {
111         ExecutionContext exe_ctx(GetExecutionContextRef());
112         new_valobj = new ValueObjectRegisterSet(exe_ctx.GetBestExecutionContextScope(), m_reg_ctx_sp, idx);
113     }
114 
115     return new_valobj;
116 }
117 
118 
119 #pragma mark -
120 #pragma mark ValueObjectRegisterSet
121 
122 ValueObjectSP
123 ValueObjectRegisterSet::Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t set_idx)
124 {
125     return (new ValueObjectRegisterSet (exe_scope, reg_ctx_sp, set_idx))->GetSP();
126 }
127 
128 
129 ValueObjectRegisterSet::ValueObjectRegisterSet (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx, uint32_t reg_set_idx) :
130     ValueObject (exe_scope),
131     m_reg_ctx_sp (reg_ctx),
132     m_reg_set (NULL),
133     m_reg_set_idx (reg_set_idx)
134 {
135     assert (reg_ctx);
136     m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
137     if (m_reg_set)
138     {
139         m_name.SetCString (m_reg_set->name);
140     }
141 }
142 
143 ValueObjectRegisterSet::~ValueObjectRegisterSet()
144 {
145 }
146 
147 ClangASTType
148 ValueObjectRegisterSet::GetClangTypeImpl ()
149 {
150     return ClangASTType();
151 }
152 
153 ConstString
154 ValueObjectRegisterSet::GetTypeName()
155 {
156     return ConstString();
157 }
158 
159 ConstString
160 ValueObjectRegisterSet::GetQualifiedTypeName()
161 {
162     return ConstString();
163 }
164 
165 size_t
166 ValueObjectRegisterSet::CalculateNumChildren()
167 {
168     const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
169     if (reg_set)
170         return reg_set->num_registers;
171     return 0;
172 }
173 
174 uint64_t
175 ValueObjectRegisterSet::GetByteSize()
176 {
177     return 0;
178 }
179 
180 bool
181 ValueObjectRegisterSet::UpdateValue ()
182 {
183     m_error.Clear();
184     SetValueDidChange (false);
185     ExecutionContext exe_ctx(GetExecutionContextRef());
186     StackFrame *frame = exe_ctx.GetFramePtr();
187     if (frame == NULL)
188         m_reg_ctx_sp.reset();
189     else
190     {
191         m_reg_ctx_sp = frame->GetRegisterContext ();
192         if (m_reg_ctx_sp)
193         {
194             const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet (m_reg_set_idx);
195             if (reg_set == NULL)
196                 m_reg_ctx_sp.reset();
197             else if (m_reg_set != reg_set)
198             {
199                 SetValueDidChange (true);
200                 m_name.SetCString(reg_set->name);
201             }
202         }
203     }
204     if (m_reg_ctx_sp)
205     {
206         SetValueIsValid (true);
207     }
208     else
209     {
210         SetValueIsValid (false);
211         m_error.SetErrorToGenericError ();
212         m_children.Clear();
213     }
214     return m_error.Success();
215 }
216 
217 
218 ValueObject *
219 ValueObjectRegisterSet::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
220 {
221     ValueObject *valobj = NULL;
222     if (m_reg_ctx_sp && m_reg_set)
223     {
224         const size_t num_children = GetNumChildren();
225         if (idx < num_children)
226             valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, m_reg_set->registers[idx]);
227     }
228     return valobj;
229 }
230 
231 lldb::ValueObjectSP
232 ValueObjectRegisterSet::GetChildMemberWithName (const ConstString &name, bool can_create)
233 {
234     ValueObject *valobj = NULL;
235     if (m_reg_ctx_sp && m_reg_set)
236     {
237         const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName (name.AsCString());
238         if (reg_info != NULL)
239             valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, reg_info->kinds[eRegisterKindLLDB]);
240     }
241     if (valobj)
242         return valobj->GetSP();
243     else
244         return ValueObjectSP();
245 }
246 
247 size_t
248 ValueObjectRegisterSet::GetIndexOfChildWithName (const ConstString &name)
249 {
250     if (m_reg_ctx_sp && m_reg_set)
251     {
252         const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName (name.AsCString());
253         if (reg_info != NULL)
254             return reg_info->kinds[eRegisterKindLLDB];
255     }
256     return UINT32_MAX;
257 }
258 
259 #pragma mark -
260 #pragma mark ValueObjectRegister
261 
262 void
263 ValueObjectRegister::ConstructObject (uint32_t reg_num)
264 {
265     const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex (reg_num);
266     if (reg_info)
267     {
268         m_reg_info = *reg_info;
269         if (reg_info->name)
270             m_name.SetCString(reg_info->name);
271         else if (reg_info->alt_name)
272             m_name.SetCString(reg_info->alt_name);
273     }
274 }
275 
276 ValueObjectRegister::ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num) :
277     ValueObject (parent),
278     m_reg_ctx_sp (reg_ctx_sp),
279     m_reg_info (),
280     m_reg_value (),
281     m_type_name (),
282     m_clang_type ()
283 {
284     assert (reg_ctx_sp.get());
285     ConstructObject(reg_num);
286 }
287 
288 ValueObjectSP
289 ValueObjectRegister::Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num)
290 {
291     return (new ValueObjectRegister (exe_scope, reg_ctx_sp, reg_num))->GetSP();
292 }
293 
294 ValueObjectRegister::ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx, uint32_t reg_num) :
295     ValueObject (exe_scope),
296     m_reg_ctx_sp (reg_ctx),
297     m_reg_info (),
298     m_reg_value (),
299     m_type_name (),
300     m_clang_type ()
301 {
302     assert (reg_ctx);
303     ConstructObject(reg_num);
304 }
305 
306 ValueObjectRegister::~ValueObjectRegister()
307 {
308 }
309 
310 ClangASTType
311 ValueObjectRegister::GetClangTypeImpl ()
312 {
313     if (!m_clang_type.IsValid())
314     {
315         ExecutionContext exe_ctx (GetExecutionContextRef());
316         Target *target = exe_ctx.GetTargetPtr();
317         if (target)
318         {
319             Module *exe_module = target->GetExecutableModulePointer();
320             if (exe_module)
321             {
322                 m_clang_type = exe_module->GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize (m_reg_info.encoding,
323                                                                                                      m_reg_info.byte_size * 8);
324             }
325         }
326     }
327     return m_clang_type;
328 }
329 
330 ConstString
331 ValueObjectRegister::GetTypeName()
332 {
333     if (m_type_name.IsEmpty())
334         m_type_name = GetClangType().GetConstTypeName ();
335     return m_type_name;
336 }
337 
338 size_t
339 ValueObjectRegister::CalculateNumChildren()
340 {
341     return GetClangType().GetNumChildren(true);
342 }
343 
344 uint64_t
345 ValueObjectRegister::GetByteSize()
346 {
347     return m_reg_info.byte_size;
348 }
349 
350 bool
351 ValueObjectRegister::UpdateValue ()
352 {
353     m_error.Clear();
354     ExecutionContext exe_ctx(GetExecutionContextRef());
355     StackFrame *frame = exe_ctx.GetFramePtr();
356     if (frame == NULL)
357     {
358         m_reg_ctx_sp.reset();
359         m_reg_value.Clear();
360     }
361 
362 
363     if (m_reg_ctx_sp)
364     {
365         if (m_reg_ctx_sp->ReadRegister (&m_reg_info, m_reg_value))
366         {
367             if (m_reg_value.GetData (m_data))
368             {
369                 Process *process = exe_ctx.GetProcessPtr();
370                 if (process)
371                     m_data.SetAddressByteSize(process->GetAddressByteSize());
372                 m_value.SetContext(Value::eContextTypeRegisterInfo, (void *)&m_reg_info);
373                 m_value.SetValueType(Value::eValueTypeHostAddress);
374                 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
375                 SetValueIsValid (true);
376                 return true;
377             }
378         }
379     }
380 
381     SetValueIsValid (false);
382     m_error.SetErrorToGenericError ();
383     return false;
384 }
385 
386 bool
387 ValueObjectRegister::SetValueFromCString (const char *value_str, Error& error)
388 {
389     // The new value will be in the m_data.  Copy that into our register value.
390     error = m_reg_value.SetValueFromCString (&m_reg_info, value_str);
391     if (error.Success())
392     {
393         if (m_reg_ctx_sp->WriteRegister (&m_reg_info, m_reg_value))
394         {
395             SetNeedsUpdate();
396             return true;
397         }
398         else
399             return false;
400     }
401     else
402         return false;
403 }
404 
405 bool
406 ValueObjectRegister::SetData (DataExtractor &data, Error &error)
407 {
408     error = m_reg_value.SetValueFromData(&m_reg_info, data, 0, false);
409     if (error.Success())
410     {
411         if (m_reg_ctx_sp->WriteRegister (&m_reg_info, m_reg_value))
412         {
413             SetNeedsUpdate();
414             return true;
415         }
416         else
417             return false;
418     }
419     else
420         return false;
421 }
422 
423 bool
424 ValueObjectRegister::ResolveValue (Scalar &scalar)
425 {
426     if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything
427         return m_reg_value.GetScalarValue(scalar);
428     return false;
429 }
430 
431 void
432 ValueObjectRegister::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat)
433 {
434     s.Printf("$%s", m_reg_info.name);
435 }
436 
437 
438