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