contrib/llvm-project/lldb/source/Core/ValueObjectConstResult.cpp

   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
  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
  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
  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
  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
  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
  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
 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
 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
 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
 164 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
 165                                              const Status &error) {
 166   return (new ValueObjectConstResult(exe_scope, error))->GetSP();
 167 }
 168
 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
 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, 0, module);
 186 }
 187
 188 ValueObjectConstResult::~ValueObjectConstResult() {}
 189
 190 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
 191   return m_value.GetCompilerType();
 192 }
 193
 194 lldb::ValueType ValueObjectConstResult::GetValueType() const {
 195   return eValueTypeConstResult;
 196 }
 197
 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
 208 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
 209
 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
 216 ConstString ValueObjectConstResult::GetTypeName() {
 217   if (m_type_name.IsEmpty())
 218     m_type_name = GetCompilerType().GetConstTypeName();
 219   return m_type_name;
 220 }
 221
 222 ConstString ValueObjectConstResult::GetDisplayTypeName() {
 223   return GetCompilerType().GetDisplayTypeName();
 224 }
 225
 226 bool ValueObjectConstResult::UpdateValue() {
 227   // Const value is always valid
 228   SetValueIsValid(true);
 229   return true;
 230 }
 231
 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
 238 lldb::ValueObjectSP ValueObjectConstResult::Dereference(Status &error) {
 239   return m_impl.Dereference(error);
 240 }
 241
 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
 249 lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Status &error) {
 250   return m_impl.AddressOf(error);
 251 }
 252
 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
 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
 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
 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
 288 ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
 289   return m_impl.Cast(compiler_type);
 290 }
 291
 292 lldb::LanguageType ValueObjectConstResult::GetPreferredDisplayLanguage() {
 293   if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
 294     return m_preferred_display_language;
 295   return GetCompilerTypeImpl().GetMinimumLanguage();
 296 }