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