contrib/llvm/tools/lldb/source/Core/ValueObjectConstResult.cpp

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