• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- ValueObjectMemory.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/ValueObjectMemory.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/Core/ValueObjectList.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Core/ValueObject.h"
21 
22 #include "lldb/Symbol/ObjectFile.h"
23 #include "lldb/Symbol/SymbolContext.h"
24 #include "lldb/Symbol/Type.h"
25 #include "lldb/Symbol/Variable.h"
26 
27 #include "lldb/Target/ExecutionContext.h"
28 #include "lldb/Target/Process.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Target/Target.h"
31 #include "lldb/Target/Thread.h"
32 
33 using namespace lldb;
34 using namespace lldb_private;
35 
36 ValueObjectSP
Create(ExecutionContextScope * exe_scope,const char * name,const Address & address,lldb::TypeSP & type_sp)37 ValueObjectMemory::Create (ExecutionContextScope *exe_scope,
38                            const char *name,
39                            const Address &address,
40                            lldb::TypeSP &type_sp)
41 {
42     return (new ValueObjectMemory (exe_scope, name, address, type_sp))->GetSP();
43 }
44 
45 ValueObjectSP
Create(ExecutionContextScope * exe_scope,const char * name,const Address & address,const ClangASTType & ast_type)46 ValueObjectMemory::Create (ExecutionContextScope *exe_scope,
47                            const char *name,
48                            const Address &address,
49                            const ClangASTType &ast_type)
50 {
51     return (new ValueObjectMemory (exe_scope, name, address, ast_type))->GetSP();
52 }
53 
ValueObjectMemory(ExecutionContextScope * exe_scope,const char * name,const Address & address,lldb::TypeSP & type_sp)54 ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
55                                       const char *name,
56                                       const Address &address,
57                                       lldb::TypeSP &type_sp) :
58     ValueObject(exe_scope),
59     m_address (address),
60     m_type_sp(type_sp),
61     m_clang_type()
62 {
63     // Do not attempt to construct one of these objects with no variable!
64     assert (m_type_sp.get() != NULL);
65     SetName (ConstString(name));
66     m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
67     TargetSP target_sp (GetTargetSP());
68     lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
69     if (load_address != LLDB_INVALID_ADDRESS)
70     {
71         m_value.SetValueType(Value::eValueTypeLoadAddress);
72         m_value.GetScalar() = load_address;
73     }
74     else
75     {
76         lldb::addr_t file_address = m_address.GetFileAddress();
77         if (file_address != LLDB_INVALID_ADDRESS)
78         {
79             m_value.SetValueType(Value::eValueTypeFileAddress);
80             m_value.GetScalar() = file_address;
81         }
82         else
83         {
84             m_value.GetScalar() = m_address.GetOffset();
85             m_value.SetValueType (Value::eValueTypeScalar);
86         }
87     }
88 }
89 
ValueObjectMemory(ExecutionContextScope * exe_scope,const char * name,const Address & address,const ClangASTType & ast_type)90 ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
91                                       const char *name,
92                                       const Address &address,
93                                       const ClangASTType &ast_type) :
94     ValueObject(exe_scope),
95     m_address (address),
96     m_type_sp(),
97     m_clang_type(ast_type)
98 {
99     // Do not attempt to construct one of these objects with no variable!
100     assert (m_clang_type.GetASTContext());
101     assert (m_clang_type.GetOpaqueQualType());
102 
103     TargetSP target_sp (GetTargetSP());
104 
105     SetName (ConstString(name));
106 //    m_value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType());
107     m_value.SetClangType(m_clang_type);
108     lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get());
109     if (load_address != LLDB_INVALID_ADDRESS)
110     {
111         m_value.SetValueType(Value::eValueTypeLoadAddress);
112         m_value.GetScalar() = load_address;
113     }
114     else
115     {
116         lldb::addr_t file_address = m_address.GetFileAddress();
117         if (file_address != LLDB_INVALID_ADDRESS)
118         {
119             m_value.SetValueType(Value::eValueTypeFileAddress);
120             m_value.GetScalar() = file_address;
121         }
122         else
123         {
124             m_value.GetScalar() = m_address.GetOffset();
125             m_value.SetValueType (Value::eValueTypeScalar);
126         }
127     }
128 }
129 
~ValueObjectMemory()130 ValueObjectMemory::~ValueObjectMemory()
131 {
132 }
133 
134 ClangASTType
GetClangTypeImpl()135 ValueObjectMemory::GetClangTypeImpl ()
136 {
137     if (m_type_sp)
138         return m_type_sp->GetClangForwardType();
139     return m_clang_type;
140 }
141 
142 ConstString
GetTypeName()143 ValueObjectMemory::GetTypeName()
144 {
145     if (m_type_sp)
146         return m_type_sp->GetName();
147     return m_clang_type.GetConstTypeName();
148 }
149 
150 size_t
CalculateNumChildren()151 ValueObjectMemory::CalculateNumChildren()
152 {
153     if (m_type_sp)
154         return m_type_sp->GetNumChildren(true);
155     const bool omit_empty_base_classes = true;
156     return m_clang_type.GetNumChildren (omit_empty_base_classes);
157 }
158 
159 uint64_t
GetByteSize()160 ValueObjectMemory::GetByteSize()
161 {
162     if (m_type_sp)
163         return m_type_sp->GetByteSize();
164     return m_clang_type.GetByteSize ();
165 }
166 
167 lldb::ValueType
GetValueType() const168 ValueObjectMemory::GetValueType() const
169 {
170     // RETHINK: Should this be inherited from somewhere?
171     return lldb::eValueTypeVariableGlobal;
172 }
173 
174 bool
UpdateValue()175 ValueObjectMemory::UpdateValue ()
176 {
177     SetValueIsValid (false);
178     m_error.Clear();
179 
180     ExecutionContext exe_ctx (GetExecutionContextRef());
181 
182     Target *target = exe_ctx.GetTargetPtr();
183     if (target)
184     {
185         m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
186         m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
187     }
188 
189     Value old_value(m_value);
190     if (m_address.IsValid())
191     {
192         Value::ValueType value_type = m_value.GetValueType();
193 
194         switch (value_type)
195         {
196         default:
197             assert(!"Unhandled expression result value kind...");
198             break;
199 
200         case Value::eValueTypeScalar:
201             // The variable value is in the Scalar value inside the m_value.
202             // We can point our m_data right to it.
203             m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
204             break;
205 
206         case Value::eValueTypeFileAddress:
207         case Value::eValueTypeLoadAddress:
208         case Value::eValueTypeHostAddress:
209             // The DWARF expression result was an address in the inferior
210             // process. If this variable is an aggregate type, we just need
211             // the address as the main value as all child variable objects
212             // will rely upon this location and add an offset and then read
213             // their own values as needed. If this variable is a simple
214             // type, we read all data for it into m_data.
215             // Make sure this type has a value before we try and read it
216 
217             // If we have a file address, convert it to a load address if we can.
218             if (value_type == Value::eValueTypeFileAddress && exe_ctx.GetProcessPtr())
219             {
220                 lldb::addr_t load_addr = m_address.GetLoadAddress(target);
221                 if (load_addr != LLDB_INVALID_ADDRESS)
222                 {
223                     m_value.SetValueType(Value::eValueTypeLoadAddress);
224                     m_value.GetScalar() = load_addr;
225                 }
226             }
227 
228             if (GetClangType().IsAggregateType())
229             {
230                 // this value object represents an aggregate type whose
231                 // children have values, but this object does not. So we
232                 // say we are changed if our location has changed.
233                 SetValueDidChange (value_type != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar());
234             }
235             else
236             {
237                 // Copy the Value and set the context to use our Variable
238                 // so it can extract read its value into m_data appropriately
239                 Value value(m_value);
240                 if (m_type_sp)
241                     value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
242                 else
243                 {
244                     //value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType());
245                     value.SetClangType(m_clang_type);
246                 }
247 
248                 m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
249             }
250             break;
251         }
252 
253         SetValueIsValid (m_error.Success());
254     }
255     return m_error.Success();
256 }
257 
258 
259 
260 bool
IsInScope()261 ValueObjectMemory::IsInScope ()
262 {
263     // FIXME: Maybe try to read the memory address, and if that works, then
264     // we are in scope?
265     return true;
266 }
267 
268 
269 lldb::ModuleSP
GetModule()270 ValueObjectMemory::GetModule()
271 {
272     return m_address.GetModule();
273 }
274 
275 
276