lldb/source/Core/Value.cpp

   1 //===-- Value.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/Value.h"
  10
  11 #include "lldb/Core/Address.h"
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Symbol/CompilerType.h"
  14 #include "lldb/Symbol/ObjectFile.h"
  15 #include "lldb/Symbol/SymbolContext.h"
  16 #include "lldb/Symbol/Type.h"
  17 #include "lldb/Symbol/Variable.h"
  18 #include "lldb/Target/ExecutionContext.h"
  19 #include "lldb/Target/Process.h"
  20 #include "lldb/Target/SectionLoadList.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Utility/ConstString.h"
  23 #include "lldb/Utility/DataBufferHeap.h"
  24 #include "lldb/Utility/DataExtractor.h"
  25 #include "lldb/Utility/Endian.h"
  26 #include "lldb/Utility/FileSpec.h"
  27 #include "lldb/Utility/State.h"
  28 #include "lldb/Utility/Stream.h"
  29 #include "lldb/lldb-defines.h"
  30 #include "lldb/lldb-forward.h"
  31 #include "lldb/lldb-types.h"
  32
  33 #include <memory>
  34 #include <optional>
  35 #include <string>
  36
  37 #include <cinttypes>
  38
  39 using namespace lldb;
  40 using namespace lldb_private;
  41
  42 Value::Value() : m_value(), m_compiler_type(), m_data_buffer() {}
  43
  44 Value::Value(const Scalar &scalar)
  45     : m_value(scalar), m_compiler_type(), m_data_buffer() {}
  46
  47 Value::Value(const void *bytes, int len)
  48     : m_value(), m_compiler_type(), m_value_type(ValueType::HostAddress),
  49       m_data_buffer() {
  50   SetBytes(bytes, len);
  51 }
  52
  53 Value::Value(const Value &v)
  54     : m_value(v.m_value), m_compiler_type(v.m_compiler_type),
  55       m_context(v.m_context), m_value_type(v.m_value_type),
  56       m_context_type(v.m_context_type), m_data_buffer() {
  57   const uintptr_t rhs_value =
  58       (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS);
  59   if ((rhs_value != 0) &&
  60       (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes())) {
  61     m_data_buffer.CopyData(v.m_data_buffer.GetBytes(),
  62                            v.m_data_buffer.GetByteSize());
  63
  64     m_value = (uintptr_t)m_data_buffer.GetBytes();
  65   }
  66 }
  67
  68 Value &Value::operator=(const Value &rhs) {
  69   if (this != &rhs) {
  70     m_value = rhs.m_value;
  71     m_compiler_type = rhs.m_compiler_type;
  72     m_context = rhs.m_context;
  73     m_value_type = rhs.m_value_type;
  74     m_context_type = rhs.m_context_type;
  75     const uintptr_t rhs_value =
  76         (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS);
  77     if ((rhs_value != 0) &&
  78         (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes())) {
  79       m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(),
  80                              rhs.m_data_buffer.GetByteSize());
  81
  82       m_value = (uintptr_t)m_data_buffer.GetBytes();
  83     }
  84   }
  85   return *this;
  86 }
  87
  88 void Value::SetBytes(const void *bytes, int len) {
  89   m_value_type = ValueType::HostAddress;
  90   m_data_buffer.CopyData(bytes, len);
  91   m_value = (uintptr_t)m_data_buffer.GetBytes();
  92 }
  93
  94 void Value::AppendBytes(const void *bytes, int len) {
  95   m_value_type = ValueType::HostAddress;
  96   m_data_buffer.AppendData(bytes, len);
  97   m_value = (uintptr_t)m_data_buffer.GetBytes();
  98 }
  99
 100 void Value::Dump(Stream *strm) {
 101   if (!strm)
 102     return;
 103   m_value.GetValue(*strm, true);
 104   strm->Printf(", value_type = %s, context = %p, context_type = %s",
 105                Value::GetValueTypeAsCString(m_value_type), m_context,
 106                Value::GetContextTypeAsCString(m_context_type));
 107 }
 108
 109 Value::ValueType Value::GetValueType() const { return m_value_type; }
 110
 111 AddressType Value::GetValueAddressType() const {
 112   switch (m_value_type) {
 113   case ValueType::Invalid:
 114   case ValueType::Scalar:
 115     break;
 116   case ValueType::LoadAddress:
 117     return eAddressTypeLoad;
 118   case ValueType::FileAddress:
 119     return eAddressTypeFile;
 120   case ValueType::HostAddress:
 121     return eAddressTypeHost;
 122   }
 123   return eAddressTypeInvalid;
 124 }
 125
 126 Value::ValueType Value::GetValueTypeFromAddressType(AddressType address_type) {
 127   switch (address_type) {
 128     case eAddressTypeFile:
 129       return Value::ValueType::FileAddress;
 130     case eAddressTypeLoad:
 131       return Value::ValueType::LoadAddress;
 132     case eAddressTypeHost:
 133       return Value::ValueType::HostAddress;
 134     case eAddressTypeInvalid:
 135       return Value::ValueType::Invalid;
 136   }
 137   llvm_unreachable("Unexpected address type!");
 138 }
 139
 140 RegisterInfo *Value::GetRegisterInfo() const {
 141   if (m_context_type == ContextType::RegisterInfo)
 142     return static_cast<RegisterInfo *>(m_context);
 143   return nullptr;
 144 }
 145
 146 Type *Value::GetType() {
 147   if (m_context_type == ContextType::LLDBType)
 148     return static_cast<Type *>(m_context);
 149   return nullptr;
 150 }
 151
 152 size_t Value::AppendDataToHostBuffer(const Value &rhs) {
 153   if (this == &rhs)
 154     return 0;
 155
 156   size_t curr_size = m_data_buffer.GetByteSize();
 157   Status error;
 158   switch (rhs.GetValueType()) {
 159   case ValueType::Invalid:
 160     return 0;
 161   case ValueType::Scalar: {
 162     const size_t scalar_size = rhs.m_value.GetByteSize();
 163     if (scalar_size > 0) {
 164       const size_t new_size = curr_size + scalar_size;
 165       if (ResizeData(new_size) == new_size) {
 166         rhs.m_value.GetAsMemoryData(m_data_buffer.GetBytes() + curr_size,
 167                                     scalar_size, endian::InlHostByteOrder(),
 168                                     error);
 169         return scalar_size;
 170       }
 171     }
 172   } break;
 173   case ValueType::FileAddress:
 174   case ValueType::LoadAddress:
 175   case ValueType::HostAddress: {
 176     const uint8_t *src = rhs.GetBuffer().GetBytes();
 177     const size_t src_len = rhs.GetBuffer().GetByteSize();
 178     if (src && src_len > 0) {
 179       const size_t new_size = curr_size + src_len;
 180       if (ResizeData(new_size) == new_size) {
 181         ::memcpy(m_data_buffer.GetBytes() + curr_size, src, src_len);
 182         return src_len;
 183       }
 184     }
 185   } break;
 186   }
 187   return 0;
 188 }
 189
 190 size_t Value::ResizeData(size_t len) {
 191   m_value_type = ValueType::HostAddress;
 192   m_data_buffer.SetByteSize(len);
 193   m_value = (uintptr_t)m_data_buffer.GetBytes();
 194   return m_data_buffer.GetByteSize();
 195 }
 196
 197 bool Value::ValueOf(ExecutionContext *exe_ctx) {
 198   switch (m_context_type) {
 199   case ContextType::Invalid:
 200   case ContextType::RegisterInfo: // RegisterInfo *
 201   case ContextType::LLDBType:     // Type *
 202     break;
 203
 204   case ContextType::Variable: // Variable *
 205     ResolveValue(exe_ctx);
 206     return true;
 207   }
 208   return false;
 209 }
 210
 211 uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
 212   switch (m_context_type) {
 213   case ContextType::RegisterInfo: // RegisterInfo *
 214     if (GetRegisterInfo()) {
 215       if (error_ptr)
 216         error_ptr->Clear();
 217       return GetRegisterInfo()->byte_size;
 218     }
 219     break;
 220
 221   case ContextType::Invalid:
 222   case ContextType::LLDBType: // Type *
 223   case ContextType::Variable: // Variable *
 224   {
 225     auto *scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
 226     if (std::optional<uint64_t> size = GetCompilerType().GetByteSize(scope)) {
 227       if (error_ptr)
 228         error_ptr->Clear();
 229       return *size;
 230     }
 231     break;
 232   }
 233   }
 234   if (error_ptr && error_ptr->Success())
 235     *error_ptr = Status::FromErrorString("Unable to determine byte size.");
 236   return 0;
 237 }
 238
 239 const CompilerType &Value::GetCompilerType() {
 240   if (!m_compiler_type.IsValid()) {
 241     switch (m_context_type) {
 242     case ContextType::Invalid:
 243       break;
 244
 245     case ContextType::RegisterInfo:
 246       break; // TODO: Eventually convert into a compiler type?
 247
 248     case ContextType::LLDBType: {
 249       Type *lldb_type = GetType();
 250       if (lldb_type)
 251         m_compiler_type = lldb_type->GetForwardCompilerType();
 252     } break;
 253
 254     case ContextType::Variable: {
 255       Variable *variable = GetVariable();
 256       if (variable) {
 257         Type *variable_type = variable->GetType();
 258         if (variable_type)
 259           m_compiler_type = variable_type->GetForwardCompilerType();
 260       }
 261     } break;
 262     }
 263   }
 264
 265   return m_compiler_type;
 266 }
 267
 268 void Value::SetCompilerType(const CompilerType &compiler_type) {
 269   m_compiler_type = compiler_type;
 270 }
 271
 272 lldb::Format Value::GetValueDefaultFormat() {
 273   switch (m_context_type) {
 274   case ContextType::RegisterInfo:
 275     if (GetRegisterInfo())
 276       return GetRegisterInfo()->format;
 277     break;
 278
 279   case ContextType::Invalid:
 280   case ContextType::LLDBType:
 281   case ContextType::Variable: {
 282     const CompilerType &ast_type = GetCompilerType();
 283     if (ast_type.IsValid())
 284       return ast_type.GetFormat();
 285   } break;
 286   }
 287
 288   // Return a good default in case we can't figure anything out
 289   return eFormatHex;
 290 }
 291
 292 bool Value::GetData(DataExtractor &data) {
 293   switch (m_value_type) {
 294   case ValueType::Invalid:
 295     return false;
 296   case ValueType::Scalar:
 297     if (m_value.GetData(data))
 298       return true;
 299     break;
 300
 301   case ValueType::LoadAddress:
 302   case ValueType::FileAddress:
 303   case ValueType::HostAddress:
 304     if (m_data_buffer.GetByteSize()) {
 305       data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(),
 306                    data.GetByteOrder());
 307       return true;
 308     }
 309     break;
 310   }
 311
 312   return false;
 313 }
 314
 315 Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
 316                              Module *module) {
 317   data.Clear();
 318
 319   Status error;
 320   lldb::addr_t address = LLDB_INVALID_ADDRESS;
 321   AddressType address_type = eAddressTypeFile;
 322   Address file_so_addr;
 323   const CompilerType &ast_type = GetCompilerType();
 324   std::optional<uint64_t> type_size = ast_type.GetByteSize(
 325       exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
 326   // Nothing to be done for a zero-sized type.
 327   if (type_size && *type_size == 0)
 328     return error;
 329
 330   switch (m_value_type) {
 331   case ValueType::Invalid:
 332     error = Status::FromErrorString("invalid value");
 333     break;
 334   case ValueType::Scalar: {
 335     data.SetByteOrder(endian::InlHostByteOrder());
 336     if (ast_type.IsValid())
 337       data.SetAddressByteSize(ast_type.GetPointerByteSize());
 338     else
 339       data.SetAddressByteSize(sizeof(void *));
 340
 341     uint32_t limit_byte_size = UINT32_MAX;
 342
 343     if (type_size)
 344       limit_byte_size = *type_size;
 345
 346     if (limit_byte_size <= m_value.GetByteSize()) {
 347       if (m_value.GetData(data, limit_byte_size))
 348         return error; // Success;
 349     }
 350
 351     error = Status::FromErrorString("extracting data from value failed");
 352     break;
 353   }
 354   case ValueType::LoadAddress:
 355     if (exe_ctx == nullptr) {
 356       error = Status::FromErrorString(
 357           "can't read load address (no execution context)");
 358     } else {
 359       Process *process = exe_ctx->GetProcessPtr();
 360       if (process == nullptr || !process->IsAlive()) {
 361         Target *target = exe_ctx->GetTargetPtr();
 362         if (target) {
 363           // Allow expressions to run and evaluate things when the target has
 364           // memory sections loaded. This allows you to use "target modules
 365           // load" to load your executable and any shared libraries, then
 366           // execute commands where you can look at types in data sections.
 367           const SectionLoadList &target_sections = target->GetSectionLoadList();
 368           if (!target_sections.IsEmpty()) {
 369             address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
 370             if (target_sections.ResolveLoadAddress(address, file_so_addr)) {
 371               address_type = eAddressTypeLoad;
 372               data.SetByteOrder(target->GetArchitecture().GetByteOrder());
 373               data.SetAddressByteSize(
 374                   target->GetArchitecture().GetAddressByteSize());
 375             } else
 376               address = LLDB_INVALID_ADDRESS;
 377           }
 378         } else {
 379           error = Status::FromErrorString(
 380               "can't read load address (invalid process)");
 381         }
 382       } else {
 383         address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
 384         address_type = eAddressTypeLoad;
 385         data.SetByteOrder(
 386             process->GetTarget().GetArchitecture().GetByteOrder());
 387         data.SetAddressByteSize(
 388             process->GetTarget().GetArchitecture().GetAddressByteSize());
 389       }
 390     }
 391     break;
 392
 393   case ValueType::FileAddress:
 394     if (exe_ctx == nullptr) {
 395       error = Status::FromErrorString(
 396           "can't read file address (no execution context)");
 397     } else if (exe_ctx->GetTargetPtr() == nullptr) {
 398       error =
 399           Status::FromErrorString("can't read file address (invalid target)");
 400     } else {
 401       address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
 402       if (address == LLDB_INVALID_ADDRESS) {
 403         error = Status::FromErrorString("invalid file address");
 404       } else {
 405         if (module == nullptr) {
 406           // The only thing we can currently lock down to a module so that we
 407           // can resolve a file address, is a variable.
 408           Variable *variable = GetVariable();
 409           if (variable) {
 410             SymbolContext var_sc;
 411             variable->CalculateSymbolContext(&var_sc);
 412             module = var_sc.module_sp.get();
 413           }
 414         }
 415
 416         if (module) {
 417           bool resolved = false;
 418           ObjectFile *objfile = module->GetObjectFile();
 419           if (objfile) {
 420             Address so_addr(address, objfile->GetSectionList());
 421             addr_t load_address =
 422                 so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
 423             bool process_launched_and_stopped =
 424                 exe_ctx->GetProcessPtr()
 425                     ? StateIsStoppedState(exe_ctx->GetProcessPtr()->GetState(),
 426                                           true /* must_exist */)
 427                     : false;
 428             // Don't use the load address if the process has exited.
 429             if (load_address != LLDB_INVALID_ADDRESS &&
 430                 process_launched_and_stopped) {
 431               resolved = true;
 432               address = load_address;
 433               address_type = eAddressTypeLoad;
 434               data.SetByteOrder(
 435                   exe_ctx->GetTargetRef().GetArchitecture().GetByteOrder());
 436               data.SetAddressByteSize(exe_ctx->GetTargetRef()
 437                                           .GetArchitecture()
 438                                           .GetAddressByteSize());
 439             } else {
 440               if (so_addr.IsSectionOffset()) {
 441                 resolved = true;
 442                 file_so_addr = so_addr;
 443                 data.SetByteOrder(objfile->GetByteOrder());
 444                 data.SetAddressByteSize(objfile->GetAddressByteSize());
 445               }
 446             }
 447           }
 448           if (!resolved) {
 449             Variable *variable = GetVariable();
 450
 451             if (module) {
 452               if (variable)
 453                 error = Status::FromErrorStringWithFormat(
 454                     "unable to resolve the module for file address 0x%" PRIx64
 455                     " for variable '%s' in %s",
 456                     address, variable->GetName().AsCString(""),
 457                     module->GetFileSpec().GetPath().c_str());
 458               else
 459                 error = Status::FromErrorStringWithFormat(
 460                     "unable to resolve the module for file address 0x%" PRIx64
 461                     " in %s",
 462                     address, module->GetFileSpec().GetPath().c_str());
 463             } else {
 464               if (variable)
 465                 error = Status::FromErrorStringWithFormat(
 466                     "unable to resolve the module for file address 0x%" PRIx64
 467                     " for variable '%s'",
 468                     address, variable->GetName().AsCString(""));
 469               else
 470                 error = Status::FromErrorStringWithFormat(
 471                     "unable to resolve the module for file address 0x%" PRIx64,
 472                     address);
 473             }
 474           }
 475         } else {
 476           // Can't convert a file address to anything valid without more
 477           // context (which Module it came from)
 478           error = Status::FromErrorString(
 479               "can't read memory from file address without more context");
 480         }
 481       }
 482     }
 483     break;
 484
 485   case ValueType::HostAddress:
 486     address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
 487     address_type = eAddressTypeHost;
 488     if (exe_ctx) {
 489       Target *target = exe_ctx->GetTargetPtr();
 490       if (target) {
 491         data.SetByteOrder(target->GetArchitecture().GetByteOrder());
 492         data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
 493         break;
 494       }
 495     }
 496     // fallback to host settings
 497     data.SetByteOrder(endian::InlHostByteOrder());
 498     data.SetAddressByteSize(sizeof(void *));
 499     break;
 500   }
 501
 502   // Bail if we encountered any errors
 503   if (error.Fail())
 504     return error;
 505
 506   if (address == LLDB_INVALID_ADDRESS) {
 507     error = Status::FromErrorStringWithFormat(
 508         "invalid %s address",
 509         address_type == eAddressTypeHost ? "host" : "load");
 510     return error;
 511   }
 512
 513   // If we got here, we need to read the value from memory.
 514   size_t byte_size = GetValueByteSize(&error, exe_ctx);
 515
 516   // Bail if we encountered any errors getting the byte size.
 517   if (error.Fail())
 518     return error;
 519
 520   // No memory to read for zero-sized types.
 521   if (byte_size == 0)
 522     return error;
 523
 524   // Make sure we have enough room within "data", and if we don't make
 525   // something large enough that does
 526   if (!data.ValidOffsetForDataOfSize(0, byte_size)) {
 527     auto data_sp = std::make_shared<DataBufferHeap>(byte_size, '\0');
 528     data.SetData(data_sp);
 529   }
 530
 531   uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, byte_size));
 532   if (dst != nullptr) {
 533     if (address_type == eAddressTypeHost) {
 534       // The address is an address in this process, so just copy it.
 535       if (address == 0) {
 536         error =
 537             Status::FromErrorString("trying to read from host address of 0.");
 538         return error;
 539       }
 540       memcpy(dst, reinterpret_cast<uint8_t *>(address), byte_size);
 541     } else if ((address_type == eAddressTypeLoad) ||
 542                (address_type == eAddressTypeFile)) {
 543       if (file_so_addr.IsValid()) {
 544         const bool force_live_memory = true;
 545         if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, dst, byte_size,
 546                                                error, force_live_memory) !=
 547             byte_size) {
 548           error = Status::FromErrorStringWithFormat(
 549               "read memory from 0x%" PRIx64 " failed", (uint64_t)address);
 550         }
 551       } else {
 552         // The execution context might have a NULL process, but it might have a
 553         // valid process in the exe_ctx->target, so use the
 554         // ExecutionContext::GetProcess accessor to ensure we get the process
 555         // if there is one.
 556         Process *process = exe_ctx->GetProcessPtr();
 557
 558         if (process) {
 559           const size_t bytes_read =
 560               process->ReadMemory(address, dst, byte_size, error);
 561           if (bytes_read != byte_size)
 562             error = Status::FromErrorStringWithFormat(
 563                 "read memory from 0x%" PRIx64 " failed (%u of %u bytes read)",
 564                 (uint64_t)address, (uint32_t)bytes_read, (uint32_t)byte_size);
 565         } else {
 566           error = Status::FromErrorStringWithFormat(
 567               "read memory from 0x%" PRIx64 " failed (invalid process)",
 568               (uint64_t)address);
 569         }
 570       }
 571     } else {
 572       error = Status::FromErrorStringWithFormat(
 573           "unsupported AddressType value (%i)", address_type);
 574     }
 575   } else {
 576     error = Status::FromErrorString("out of memory");
 577   }
 578
 579   return error;
 580 }
 581
 582 Scalar &Value::ResolveValue(ExecutionContext *exe_ctx, Module *module) {
 583   const CompilerType &compiler_type = GetCompilerType();
 584   if (compiler_type.IsValid()) {
 585     switch (m_value_type) {
 586     case ValueType::Invalid:
 587     case ValueType::Scalar: // raw scalar value
 588       break;
 589
 590     case ValueType::FileAddress:
 591     case ValueType::LoadAddress: // load address value
 592     case ValueType::HostAddress: // host address value (for memory in the process
 593                                 // that is using liblldb)
 594     {
 595       DataExtractor data;
 596       lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
 597       Status error(GetValueAsData(exe_ctx, data, module));
 598       if (error.Success()) {
 599         Scalar scalar;
 600         if (compiler_type.GetValueAsScalar(
 601                 data, 0, data.GetByteSize(), scalar,
 602                 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr)) {
 603           m_value = scalar;
 604           m_value_type = ValueType::Scalar;
 605         } else {
 606           if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
 607             m_value.Clear();
 608             m_value_type = ValueType::Scalar;
 609           }
 610         }
 611       } else {
 612         if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
 613           m_value.Clear();
 614           m_value_type = ValueType::Scalar;
 615         }
 616       }
 617     } break;
 618     }
 619   }
 620   return m_value;
 621 }
 622
 623 Variable *Value::GetVariable() {
 624   if (m_context_type == ContextType::Variable)
 625     return static_cast<Variable *>(m_context);
 626   return nullptr;
 627 }
 628
 629 void Value::Clear() {
 630   m_value.Clear();
 631   m_compiler_type.Clear();
 632   m_value_type = ValueType::Scalar;
 633   m_context = nullptr;
 634   m_context_type = ContextType::Invalid;
 635   m_data_buffer.Clear();
 636 }
 637
 638 const char *Value::GetValueTypeAsCString(ValueType value_type) {
 639   switch (value_type) {
 640   case ValueType::Invalid:
 641     return "invalid";
 642   case ValueType::Scalar:
 643     return "scalar";
 644   case ValueType::FileAddress:
 645     return "file address";
 646   case ValueType::LoadAddress:
 647     return "load address";
 648   case ValueType::HostAddress:
 649     return "host address";
 650   };
 651   llvm_unreachable("enum cases exhausted.");
 652 }
 653
 654 const char *Value::GetContextTypeAsCString(ContextType context_type) {
 655   switch (context_type) {
 656   case ContextType::Invalid:
 657     return "invalid";
 658   case ContextType::RegisterInfo:
 659     return "RegisterInfo *";
 660   case ContextType::LLDBType:
 661     return "Type *";
 662   case ContextType::Variable:
 663     return "Variable *";
 664   };
 665   llvm_unreachable("enum cases exhausted.");
 666 }
 667
 668 void Value::ConvertToLoadAddress(Module *module, Target *target) {
 669   if (!module || !target || (GetValueType() != ValueType::FileAddress))
 670     return;
 671
 672   lldb::addr_t file_addr = GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
 673   if (file_addr == LLDB_INVALID_ADDRESS)
 674     return;
 675
 676   Address so_addr;
 677   if (!module->ResolveFileAddress(file_addr, so_addr))
 678     return;
 679   lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
 680   if (load_addr == LLDB_INVALID_ADDRESS)
 681     return;
 682
 683   SetValueType(Value::ValueType::LoadAddress);
 684   GetScalar() = load_addr;
 685 }
 686
 687 void ValueList::PushValue(const Value &value) { m_values.push_back(value); }
 688
 689 size_t ValueList::GetSize() { return m_values.size(); }
 690
 691 Value *ValueList::GetValueAtIndex(size_t idx) {
 692   if (idx < GetSize()) {
 693     return &(m_values[idx]);
 694   } else
 695     return nullptr;
 696 }
 697
 698 void ValueList::Clear() { m_values.clear(); }