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/ValueObjectDynamicValue.h"
13 #include "lldb/Symbol/CompilerType.h"
14 #include "lldb/Target/ExecutionContext.h"
15 #include "lldb/Target/ExecutionContextScope.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Utility/DataBuffer.h"
18 #include "lldb/Utility/DataBufferHeap.h"
19 #include "lldb/Utility/DataExtractor.h"
20 #include "lldb/Utility/Scalar.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 Status &error) {
167   return (new ValueObjectConstResult(exe_scope, error))->GetSP();
168 }
169 
170 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
171                                                const Status &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   if (m_byte_size == 0) {
202     if (auto size =
203         GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()))
204       SetByteSize(*size);
205   }
206   return m_byte_size;
207 }
208 
209 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
210 
211 size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
212   ExecutionContext exe_ctx(GetExecutionContextRef());
213   auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
214   return children_count <= max ? children_count : max;
215 }
216 
217 ConstString ValueObjectConstResult::GetTypeName() {
218   if (m_type_name.IsEmpty())
219     m_type_name = GetCompilerType().GetConstTypeName();
220   return m_type_name;
221 }
222 
223 ConstString ValueObjectConstResult::GetDisplayTypeName() {
224   return GetCompilerType().GetDisplayTypeName();
225 }
226 
227 bool ValueObjectConstResult::UpdateValue() {
228   // Const value is always valid
229   SetValueIsValid(true);
230   return true;
231 }
232 
233 bool ValueObjectConstResult::IsInScope() {
234   // A const result value is always in scope since it serializes all
235   // information needed to contain the constant value.
236   return true;
237 }
238 
239 lldb::ValueObjectSP ValueObjectConstResult::Dereference(Status &error) {
240   return m_impl.Dereference(error);
241 }
242 
243 lldb::ValueObjectSP ValueObjectConstResult::GetSyntheticChildAtOffset(
244     uint32_t offset, const CompilerType &type, bool can_create,
245     ConstString name_const_str) {
246   return m_impl.GetSyntheticChildAtOffset(offset, type, can_create,
247                                           name_const_str);
248 }
249 
250 lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Status &error) {
251   return m_impl.AddressOf(error);
252 }
253 
254 lldb::addr_t ValueObjectConstResult::GetAddressOf(bool scalar_is_load_address,
255                                                   AddressType *address_type) {
256   return m_impl.GetAddressOf(scalar_is_load_address, address_type);
257 }
258 
259 ValueObject *ValueObjectConstResult::CreateChildAtIndex(
260     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
261   return m_impl.CreateChildAtIndex(idx, synthetic_array_member,
262                                    synthetic_index);
263 }
264 
265 size_t ValueObjectConstResult::GetPointeeData(DataExtractor &data,
266                                               uint32_t item_idx,
267                                               uint32_t item_count) {
268   return m_impl.GetPointeeData(data, item_idx, item_count);
269 }
270 
271 lldb::ValueObjectSP
272 ValueObjectConstResult::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
273   // Always recalculate dynamic values for const results as the memory that
274   // they might point to might have changed at any time.
275   if (use_dynamic != eNoDynamicValues) {
276     if (!IsDynamic()) {
277       ExecutionContext exe_ctx(GetExecutionContextRef());
278       Process *process = exe_ctx.GetProcessPtr();
279       if (process && process->IsPossibleDynamicValue(*this))
280         m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
281     }
282     if (m_dynamic_value)
283       return m_dynamic_value->GetSP();
284   }
285   return ValueObjectSP();
286 }
287 
288 lldb::ValueObjectSP
289 ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
290   return m_impl.Cast(compiler_type);
291 }
292 
293 lldb::LanguageType ValueObjectConstResult::GetPreferredDisplayLanguage() {
294   if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
295     return m_preferred_display_language;
296   return GetCompilerTypeImpl().GetMinimumLanguage();
297 }
298