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