1 //===-- ValueObjectConstResult.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/ValueObjectConstResult.h"
11 
12 #include "lldb/Core/Scalar.h" // for Scalar
13 #include "lldb/Core/ValueObjectDynamicValue.h"
14 #include "lldb/Symbol/CompilerType.h"
15 #include "lldb/Target/ExecutionContext.h"
16 #include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope
17 #include "lldb/Target/Process.h"
18 #include "lldb/Utility/DataBuffer.h"     // for DataBuffer
19 #include "lldb/Utility/DataBufferHeap.h" // for DataBufferHeap
20 #include "lldb/Utility/DataExtractor.h"
21 
22 namespace lldb_private {
23 class Module;
24 }
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
30                                              ByteOrder byte_order,
31                                              uint32_t addr_byte_size,
32                                              lldb::addr_t address) {
33   return (new ValueObjectConstResult(exe_scope, byte_order, addr_byte_size,
34                                      address))
35       ->GetSP();
36 }
37 
38 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
39                                                ByteOrder byte_order,
40                                                uint32_t addr_byte_size,
41                                                lldb::addr_t address)
42     : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
43       m_impl(this, address) {
44   SetIsConstant();
45   SetValueIsValid(true);
46   m_data.SetByteOrder(byte_order);
47   m_data.SetAddressByteSize(addr_byte_size);
48   SetAddressTypeOfChildren(eAddressTypeLoad);
49 }
50 
51 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
52                                              const CompilerType &compiler_type,
53                                              const ConstString &name,
54                                              const DataExtractor &data,
55                                              lldb::addr_t address) {
56   return (new ValueObjectConstResult(exe_scope, compiler_type, name, data,
57                                      address))
58       ->GetSP();
59 }
60 
61 ValueObjectConstResult::ValueObjectConstResult(
62     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
63     const ConstString &name, const DataExtractor &data, lldb::addr_t address)
64     : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
65       m_impl(this, address) {
66   m_data = data;
67 
68   if (!m_data.GetSharedDataBuffer()) {
69     DataBufferSP shared_data_buffer(
70         new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
71     m_data.SetData(shared_data_buffer);
72   }
73 
74   m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
75   m_value.SetValueType(Value::eValueTypeHostAddress);
76   m_value.SetCompilerType(compiler_type);
77   m_name = name;
78   SetIsConstant();
79   SetValueIsValid(true);
80   SetAddressTypeOfChildren(eAddressTypeLoad);
81 }
82 
83 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
84                                              const CompilerType &compiler_type,
85                                              const ConstString &name,
86                                              const lldb::DataBufferSP &data_sp,
87                                              lldb::ByteOrder data_byte_order,
88                                              uint32_t data_addr_size,
89                                              lldb::addr_t address) {
90   return (new ValueObjectConstResult(exe_scope, compiler_type, name, data_sp,
91                                      data_byte_order, data_addr_size, address))
92       ->GetSP();
93 }
94 
95 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
96                                              Value &value,
97                                              const ConstString &name,
98                                              Module *module) {
99   return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP();
100 }
101 
102 ValueObjectConstResult::ValueObjectConstResult(
103     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
104     const ConstString &name, const lldb::DataBufferSP &data_sp,
105     lldb::ByteOrder data_byte_order, uint32_t data_addr_size,
106     lldb::addr_t address)
107     : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
108       m_impl(this, address) {
109   m_data.SetByteOrder(data_byte_order);
110   m_data.SetAddressByteSize(data_addr_size);
111   m_data.SetData(data_sp);
112   m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
113   m_value.SetValueType(Value::eValueTypeHostAddress);
114   // m_value.SetContext(Value::eContextTypeClangType, compiler_type);
115   m_value.SetCompilerType(compiler_type);
116   m_name = name;
117   SetIsConstant();
118   SetValueIsValid(true);
119   SetAddressTypeOfChildren(eAddressTypeLoad);
120 }
121 
122 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
123                                              const CompilerType &compiler_type,
124                                              const ConstString &name,
125                                              lldb::addr_t address,
126                                              AddressType address_type,
127                                              uint32_t addr_byte_size) {
128   return (new ValueObjectConstResult(exe_scope, compiler_type, name, address,
129                                      address_type, addr_byte_size))
130       ->GetSP();
131 }
132 
133 ValueObjectConstResult::ValueObjectConstResult(
134     ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
135     const ConstString &name, lldb::addr_t address, AddressType address_type,
136     uint32_t addr_byte_size)
137     : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
138       m_impl(this, address) {
139   m_value.GetScalar() = address;
140   m_data.SetAddressByteSize(addr_byte_size);
141   m_value.GetScalar().GetData(m_data, addr_byte_size);
142   // m_value.SetValueType(Value::eValueTypeHostAddress);
143   switch (address_type) {
144   case eAddressTypeInvalid:
145     m_value.SetValueType(Value::eValueTypeScalar);
146     break;
147   case eAddressTypeFile:
148     m_value.SetValueType(Value::eValueTypeFileAddress);
149     break;
150   case eAddressTypeLoad:
151     m_value.SetValueType(Value::eValueTypeLoadAddress);
152     break;
153   case eAddressTypeHost:
154     m_value.SetValueType(Value::eValueTypeHostAddress);
155     break;
156   }
157   //    m_value.SetContext(Value::eContextTypeClangType, compiler_type);
158   m_value.SetCompilerType(compiler_type);
159   m_name = name;
160   SetIsConstant();
161   SetValueIsValid(true);
162   SetAddressTypeOfChildren(eAddressTypeLoad);
163 }
164 
165 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
166                                              const Error &error) {
167   return (new ValueObjectConstResult(exe_scope, error))->GetSP();
168 }
169 
170 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
171                                                const Error &error)
172     : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
173   m_error = error;
174   SetIsConstant();
175 }
176 
177 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
178                                                const Value &value,
179                                                const ConstString &name,
180                                                Module *module)
181     : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
182   m_value = value;
183   m_name = name;
184   ExecutionContext exe_ctx;
185   exe_scope->CalculateExecutionContext(exe_ctx);
186   m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module);
187 }
188 
189 ValueObjectConstResult::~ValueObjectConstResult() {}
190 
191 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
192   return m_value.GetCompilerType();
193 }
194 
195 lldb::ValueType ValueObjectConstResult::GetValueType() const {
196   return eValueTypeConstResult;
197 }
198 
199 uint64_t ValueObjectConstResult::GetByteSize() {
200   ExecutionContext exe_ctx(GetExecutionContextRef());
201 
202   if (m_byte_size == 0)
203     SetByteSize(
204         GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
205   return m_byte_size;
206 }
207 
208 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
209 
210 size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
211   auto children_count = GetCompilerType().GetNumChildren(true);
212   return children_count <= max ? children_count : max;
213 }
214 
215 ConstString ValueObjectConstResult::GetTypeName() {
216   if (m_type_name.IsEmpty())
217     m_type_name = GetCompilerType().GetConstTypeName();
218   return m_type_name;
219 }
220 
221 ConstString ValueObjectConstResult::GetDisplayTypeName() {
222   return GetCompilerType().GetDisplayTypeName();
223 }
224 
225 bool ValueObjectConstResult::UpdateValue() {
226   // Const value is always valid
227   SetValueIsValid(true);
228   return true;
229 }
230 
231 bool ValueObjectConstResult::IsInScope() {
232   // A const result value is always in scope since it serializes all
233   // information needed to contain the constant value.
234   return true;
235 }
236 
237 lldb::ValueObjectSP ValueObjectConstResult::Dereference(Error &error) {
238   return m_impl.Dereference(error);
239 }
240 
241 lldb::ValueObjectSP ValueObjectConstResult::GetSyntheticChildAtOffset(
242     uint32_t offset, const CompilerType &type, bool can_create,
243     ConstString name_const_str) {
244   return m_impl.GetSyntheticChildAtOffset(offset, type, can_create,
245                                           name_const_str);
246 }
247 
248 lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Error &error) {
249   return m_impl.AddressOf(error);
250 }
251 
252 lldb::addr_t ValueObjectConstResult::GetAddressOf(bool scalar_is_load_address,
253                                                   AddressType *address_type) {
254   return m_impl.GetAddressOf(scalar_is_load_address, address_type);
255 }
256 
257 ValueObject *ValueObjectConstResult::CreateChildAtIndex(
258     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
259   return m_impl.CreateChildAtIndex(idx, synthetic_array_member,
260                                    synthetic_index);
261 }
262 
263 size_t ValueObjectConstResult::GetPointeeData(DataExtractor &data,
264                                               uint32_t item_idx,
265                                               uint32_t item_count) {
266   return m_impl.GetPointeeData(data, item_idx, item_count);
267 }
268 
269 lldb::ValueObjectSP
270 ValueObjectConstResult::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
271   // Always recalculate dynamic values for const results as the memory that
272   // they might point to might have changed at any time.
273   if (use_dynamic != eNoDynamicValues) {
274     if (!IsDynamic()) {
275       ExecutionContext exe_ctx(GetExecutionContextRef());
276       Process *process = exe_ctx.GetProcessPtr();
277       if (process && process->IsPossibleDynamicValue(*this))
278         m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
279     }
280     if (m_dynamic_value)
281       return m_dynamic_value->GetSP();
282   }
283   return ValueObjectSP();
284 }
285 
286 lldb::ValueObjectSP
287 ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
288   return m_impl.Cast(compiler_type);
289 }
290 
291 lldb::LanguageType ValueObjectConstResult::GetPreferredDisplayLanguage() {
292   if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
293     return m_preferred_display_language;
294   return GetCompilerTypeImpl().GetMinimumLanguage();
295 }
296