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
Create(ExecutionContextScope * exe_scope,ByteOrder byte_order,uint32_t addr_byte_size,lldb::addr_t address)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
ValueObjectConstResult(ExecutionContextScope * exe_scope,ByteOrder byte_order,uint32_t addr_byte_size,lldb::addr_t address)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
Create(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,const DataExtractor & data,lldb::addr_t address)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
ValueObjectConstResult(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,const DataExtractor & data,lldb::addr_t address)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
Create(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,const lldb::DataBufferSP & data_sp,lldb::ByteOrder data_byte_order,uint32_t data_addr_size,lldb::addr_t address)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
Create(ExecutionContextScope * exe_scope,Value & value,const ConstString & name,Module * module)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
ValueObjectConstResult(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,const lldb::DataBufferSP & data_sp,lldb::ByteOrder data_byte_order,uint32_t data_addr_size,lldb::addr_t address)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
Create(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,lldb::addr_t address,AddressType address_type,uint32_t addr_byte_size)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
ValueObjectConstResult(ExecutionContextScope * exe_scope,const CompilerType & compiler_type,const ConstString & name,lldb::addr_t address,AddressType address_type,uint32_t addr_byte_size)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
Create(ExecutionContextScope * exe_scope,const Status & error)165 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
166 const Status &error) {
167 return (new ValueObjectConstResult(exe_scope, error))->GetSP();
168 }
169
ValueObjectConstResult(ExecutionContextScope * exe_scope,const Status & error)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
ValueObjectConstResult(ExecutionContextScope * exe_scope,const Value & value,const ConstString & name,Module * module)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
~ValueObjectConstResult()189 ValueObjectConstResult::~ValueObjectConstResult() {}
190
GetCompilerTypeImpl()191 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
192 return m_value.GetCompilerType();
193 }
194
GetValueType() const195 lldb::ValueType ValueObjectConstResult::GetValueType() const {
196 return eValueTypeConstResult;
197 }
198
GetByteSize()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
SetByteSize(size_t size)209 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
210
CalculateNumChildren(uint32_t max)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
GetTypeName()217 ConstString ValueObjectConstResult::GetTypeName() {
218 if (m_type_name.IsEmpty())
219 m_type_name = GetCompilerType().GetConstTypeName();
220 return m_type_name;
221 }
222
GetDisplayTypeName()223 ConstString ValueObjectConstResult::GetDisplayTypeName() {
224 return GetCompilerType().GetDisplayTypeName();
225 }
226
UpdateValue()227 bool ValueObjectConstResult::UpdateValue() {
228 // Const value is always valid
229 SetValueIsValid(true);
230 return true;
231 }
232
IsInScope()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
Dereference(Status & error)239 lldb::ValueObjectSP ValueObjectConstResult::Dereference(Status &error) {
240 return m_impl.Dereference(error);
241 }
242
GetSyntheticChildAtOffset(uint32_t offset,const CompilerType & type,bool can_create,ConstString name_const_str)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
AddressOf(Status & error)250 lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Status &error) {
251 return m_impl.AddressOf(error);
252 }
253
GetAddressOf(bool scalar_is_load_address,AddressType * address_type)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
CreateChildAtIndex(size_t idx,bool synthetic_array_member,int32_t synthetic_index)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
GetPointeeData(DataExtractor & data,uint32_t item_idx,uint32_t item_count)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
GetDynamicValue(lldb::DynamicValueType use_dynamic)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
Cast(const CompilerType & compiler_type)289 ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
290 return m_impl.Cast(compiler_type);
291 }
292
GetPreferredDisplayLanguage()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