1 //===-- Value.cpp -----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Value.h"
12 #include "lldb/Core/Address.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Symbol/CompilerType.h"
15 #include "lldb/Symbol/ObjectFile.h"
16 #include "lldb/Symbol/SymbolContext.h"
17 #include "lldb/Symbol/Type.h"
18 #include "lldb/Symbol/Variable.h"
19 #include "lldb/Target/ExecutionContext.h"
20 #include "lldb/Target/Process.h"
21 #include "lldb/Target/SectionLoadList.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Utility/ConstString.h"
24 #include "lldb/Utility/DataBufferHeap.h"
25 #include "lldb/Utility/DataExtractor.h"
26 #include "lldb/Utility/Endian.h"
27 #include "lldb/Utility/FileSpec.h"
28 #include "lldb/Utility/State.h"
29 #include "lldb/Utility/Stream.h"
30 #include "lldb/lldb-defines.h"
31 #include "lldb/lldb-forward.h"
32 #include "lldb/lldb-types.h"
40 using namespace lldb_private;
43 : m_value(), m_vector(), m_compiler_type(), m_context(NULL),
44 m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
47 Value::Value(const Scalar &scalar)
48 : m_value(scalar), m_vector(), m_compiler_type(), m_context(NULL),
49 m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
52 Value::Value(const void *bytes, int len)
53 : m_value(), m_vector(), m_compiler_type(), m_context(NULL),
54 m_value_type(eValueTypeHostAddress), m_context_type(eContextTypeInvalid),
59 Value::Value(const Value &v)
60 : m_value(v.m_value), m_vector(v.m_vector),
61 m_compiler_type(v.m_compiler_type), m_context(v.m_context),
62 m_value_type(v.m_value_type), m_context_type(v.m_context_type),
64 const uintptr_t rhs_value =
65 (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS);
66 if ((rhs_value != 0) &&
67 (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes())) {
68 m_data_buffer.CopyData(v.m_data_buffer.GetBytes(),
69 v.m_data_buffer.GetByteSize());
71 m_value = (uintptr_t)m_data_buffer.GetBytes();
75 Value &Value::operator=(const Value &rhs) {
77 m_value = rhs.m_value;
78 m_vector = rhs.m_vector;
79 m_compiler_type = rhs.m_compiler_type;
80 m_context = rhs.m_context;
81 m_value_type = rhs.m_value_type;
82 m_context_type = rhs.m_context_type;
83 const uintptr_t rhs_value =
84 (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS);
85 if ((rhs_value != 0) &&
86 (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes())) {
87 m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(),
88 rhs.m_data_buffer.GetByteSize());
90 m_value = (uintptr_t)m_data_buffer.GetBytes();
96 void Value::SetBytes(const void *bytes, int len) {
97 m_value_type = eValueTypeHostAddress;
98 m_data_buffer.CopyData(bytes, len);
99 m_value = (uintptr_t)m_data_buffer.GetBytes();
102 void Value::AppendBytes(const void *bytes, int len) {
103 m_value_type = eValueTypeHostAddress;
104 m_data_buffer.AppendData(bytes, len);
105 m_value = (uintptr_t)m_data_buffer.GetBytes();
108 void Value::Dump(Stream *strm) {
109 m_value.GetValue(strm, true);
110 strm->Printf(", value_type = %s, context = %p, context_type = %s",
111 Value::GetValueTypeAsCString(m_value_type), m_context,
112 Value::GetContextTypeAsCString(m_context_type));
115 Value::ValueType Value::GetValueType() const { return m_value_type; }
117 AddressType Value::GetValueAddressType() const {
118 switch (m_value_type) {
120 case eValueTypeScalar:
122 case eValueTypeLoadAddress:
123 return eAddressTypeLoad;
124 case eValueTypeFileAddress:
125 return eAddressTypeFile;
126 case eValueTypeHostAddress:
127 return eAddressTypeHost;
129 return eAddressTypeInvalid;
132 RegisterInfo *Value::GetRegisterInfo() const {
133 if (m_context_type == eContextTypeRegisterInfo)
134 return static_cast<RegisterInfo *>(m_context);
138 Type *Value::GetType() {
139 if (m_context_type == eContextTypeLLDBType)
140 return static_cast<Type *>(m_context);
144 size_t Value::AppendDataToHostBuffer(const Value &rhs) {
148 size_t curr_size = m_data_buffer.GetByteSize();
150 switch (rhs.GetValueType()) {
151 case eValueTypeScalar: {
152 const size_t scalar_size = rhs.m_value.GetByteSize();
153 if (scalar_size > 0) {
154 const size_t new_size = curr_size + scalar_size;
155 if (ResizeData(new_size) == new_size) {
156 rhs.m_value.GetAsMemoryData(m_data_buffer.GetBytes() + curr_size,
157 scalar_size, endian::InlHostByteOrder(),
163 case eValueTypeVector: {
164 const size_t vector_size = rhs.m_vector.length;
165 if (vector_size > 0) {
166 const size_t new_size = curr_size + vector_size;
167 if (ResizeData(new_size) == new_size) {
168 ::memcpy(m_data_buffer.GetBytes() + curr_size, rhs.m_vector.bytes,
174 case eValueTypeFileAddress:
175 case eValueTypeLoadAddress:
176 case eValueTypeHostAddress: {
177 const uint8_t *src = rhs.GetBuffer().GetBytes();
178 const size_t src_len = rhs.GetBuffer().GetByteSize();
179 if (src && src_len > 0) {
180 const size_t new_size = curr_size + src_len;
181 if (ResizeData(new_size) == new_size) {
182 ::memcpy(m_data_buffer.GetBytes() + curr_size, src, src_len);
191 size_t Value::ResizeData(size_t len) {
192 m_value_type = eValueTypeHostAddress;
193 m_data_buffer.SetByteSize(len);
194 m_value = (uintptr_t)m_data_buffer.GetBytes();
195 return m_data_buffer.GetByteSize();
198 bool Value::ValueOf(ExecutionContext *exe_ctx) {
199 switch (m_context_type) {
200 case eContextTypeInvalid:
201 case eContextTypeRegisterInfo: // RegisterInfo *
202 case eContextTypeLLDBType: // Type *
205 case eContextTypeVariable: // Variable *
206 ResolveValue(exe_ctx);
212 uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
213 uint64_t byte_size = 0;
215 switch (m_context_type) {
216 case eContextTypeRegisterInfo: // RegisterInfo *
217 if (GetRegisterInfo())
218 byte_size = GetRegisterInfo()->byte_size;
221 case eContextTypeInvalid:
222 case eContextTypeLLDBType: // Type *
223 case eContextTypeVariable: // Variable *
225 const CompilerType &ast_type = GetCompilerType();
226 if (ast_type.IsValid())
227 if (llvm::Optional<uint64_t> size = ast_type.GetByteSize(
228 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
234 if (byte_size == 0) {
235 if (error_ptr->Success())
236 error_ptr->SetErrorString("Unable to determine byte size.");
244 const CompilerType &Value::GetCompilerType() {
245 if (!m_compiler_type.IsValid()) {
246 switch (m_context_type) {
247 case eContextTypeInvalid:
250 case eContextTypeRegisterInfo:
251 break; // TODO: Eventually convert into a compiler type?
253 case eContextTypeLLDBType: {
254 Type *lldb_type = GetType();
256 m_compiler_type = lldb_type->GetForwardCompilerType();
259 case eContextTypeVariable: {
260 Variable *variable = GetVariable();
262 Type *variable_type = variable->GetType();
264 m_compiler_type = variable_type->GetForwardCompilerType();
270 return m_compiler_type;
273 void Value::SetCompilerType(const CompilerType &compiler_type) {
274 m_compiler_type = compiler_type;
277 lldb::Format Value::GetValueDefaultFormat() {
278 switch (m_context_type) {
279 case eContextTypeRegisterInfo:
280 if (GetRegisterInfo())
281 return GetRegisterInfo()->format;
284 case eContextTypeInvalid:
285 case eContextTypeLLDBType:
286 case eContextTypeVariable: {
287 const CompilerType &ast_type = GetCompilerType();
288 if (ast_type.IsValid())
289 return ast_type.GetFormat();
293 // Return a good default in case we can't figure anything out
297 bool Value::GetData(DataExtractor &data) {
298 switch (m_value_type) {
302 case eValueTypeScalar:
303 if (m_value.GetData(data))
307 case eValueTypeLoadAddress:
308 case eValueTypeFileAddress:
309 case eValueTypeHostAddress:
310 if (m_data_buffer.GetByteSize()) {
311 data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(),
312 data.GetByteOrder());
321 Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
322 uint32_t data_offset, Module *module) {
326 lldb::addr_t address = LLDB_INVALID_ADDRESS;
327 AddressType address_type = eAddressTypeFile;
328 Address file_so_addr;
329 const CompilerType &ast_type = GetCompilerType();
330 switch (m_value_type) {
331 case eValueTypeVector:
332 if (ast_type.IsValid())
333 data.SetAddressByteSize(ast_type.GetPointerByteSize());
335 data.SetAddressByteSize(sizeof(void *));
336 data.SetData(m_vector.bytes, m_vector.length, m_vector.byte_order);
339 case eValueTypeScalar: {
340 data.SetByteOrder(endian::InlHostByteOrder());
341 if (ast_type.IsValid())
342 data.SetAddressByteSize(ast_type.GetPointerByteSize());
344 data.SetAddressByteSize(sizeof(void *));
346 uint32_t limit_byte_size = UINT32_MAX;
348 if (llvm::Optional<uint64_t> size = ast_type.GetByteSize(
349 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
350 limit_byte_size = *size;
352 if (limit_byte_size <= m_value.GetByteSize()) {
353 if (m_value.GetData(data, limit_byte_size))
354 return error; // Success;
357 error.SetErrorStringWithFormat("extracting data from value failed");
360 case eValueTypeLoadAddress:
361 if (exe_ctx == NULL) {
362 error.SetErrorString("can't read load address (no execution context)");
364 Process *process = exe_ctx->GetProcessPtr();
365 if (process == NULL || !process->IsAlive()) {
366 Target *target = exe_ctx->GetTargetPtr();
368 // Allow expressions to run and evaluate things when the target has
369 // memory sections loaded. This allows you to use "target modules
370 // load" to load your executable and any shared libraries, then
371 // execute commands where you can look at types in data sections.
372 const SectionLoadList &target_sections = target->GetSectionLoadList();
373 if (!target_sections.IsEmpty()) {
374 address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
375 if (target_sections.ResolveLoadAddress(address, file_so_addr)) {
376 address_type = eAddressTypeLoad;
377 data.SetByteOrder(target->GetArchitecture().GetByteOrder());
378 data.SetAddressByteSize(
379 target->GetArchitecture().GetAddressByteSize());
381 address = LLDB_INVALID_ADDRESS;
384 error.SetErrorString("can't read load address (invalid process)");
387 address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
388 address_type = eAddressTypeLoad;
390 process->GetTarget().GetArchitecture().GetByteOrder());
391 data.SetAddressByteSize(
392 process->GetTarget().GetArchitecture().GetAddressByteSize());
397 case eValueTypeFileAddress:
398 if (exe_ctx == NULL) {
399 error.SetErrorString("can't read file address (no execution context)");
400 } else if (exe_ctx->GetTargetPtr() == NULL) {
401 error.SetErrorString("can't read file address (invalid target)");
403 address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
404 if (address == LLDB_INVALID_ADDRESS) {
405 error.SetErrorString("invalid file address");
407 if (module == NULL) {
408 // The only thing we can currently lock down to a module so that we
409 // can resolve a file address, is a variable.
410 Variable *variable = GetVariable();
412 SymbolContext var_sc;
413 variable->CalculateSymbolContext(&var_sc);
414 module = var_sc.module_sp.get();
419 bool resolved = false;
420 ObjectFile *objfile = module->GetObjectFile();
422 Address so_addr(address, objfile->GetSectionList());
423 addr_t load_address =
424 so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
425 bool process_launched_and_stopped =
426 exe_ctx->GetProcessPtr()
427 ? StateIsStoppedState(exe_ctx->GetProcessPtr()->GetState(),
428 true /* must_exist */)
430 // Don't use the load address if the process has exited.
431 if (load_address != LLDB_INVALID_ADDRESS &&
432 process_launched_and_stopped) {
434 address = load_address;
435 address_type = eAddressTypeLoad;
437 exe_ctx->GetTargetRef().GetArchitecture().GetByteOrder());
438 data.SetAddressByteSize(exe_ctx->GetTargetRef()
440 .GetAddressByteSize());
442 if (so_addr.IsSectionOffset()) {
444 file_so_addr = so_addr;
445 data.SetByteOrder(objfile->GetByteOrder());
446 data.SetAddressByteSize(objfile->GetAddressByteSize());
451 Variable *variable = GetVariable();
455 error.SetErrorStringWithFormat(
456 "unable to resolve the module for file address 0x%" PRIx64
457 " for variable '%s' in %s",
458 address, variable->GetName().AsCString(""),
459 module->GetFileSpec().GetPath().c_str());
461 error.SetErrorStringWithFormat(
462 "unable to resolve the module for file address 0x%" PRIx64
464 address, module->GetFileSpec().GetPath().c_str());
467 error.SetErrorStringWithFormat(
468 "unable to resolve the module for file address 0x%" PRIx64
469 " for variable '%s'",
470 address, variable->GetName().AsCString(""));
472 error.SetErrorStringWithFormat(
473 "unable to resolve the module for file address 0x%" PRIx64,
478 // Can't convert a file address to anything valid without more
479 // context (which Module it came from)
480 error.SetErrorString(
481 "can't read memory from file address without more context");
487 case eValueTypeHostAddress:
488 address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
489 address_type = eAddressTypeHost;
491 Target *target = exe_ctx->GetTargetPtr();
493 data.SetByteOrder(target->GetArchitecture().GetByteOrder());
494 data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
498 // fallback to host settings
499 data.SetByteOrder(endian::InlHostByteOrder());
500 data.SetAddressByteSize(sizeof(void *));
504 // Bail if we encountered any errors
508 if (address == LLDB_INVALID_ADDRESS) {
509 error.SetErrorStringWithFormat("invalid %s address",
510 address_type == eAddressTypeHost ? "host"
515 // If we got here, we need to read the value from memory
516 size_t byte_size = GetValueByteSize(&error, exe_ctx);
518 // Bail if we encountered any errors getting the byte size
522 // Make sure we have enough room within "data", and if we don't make
523 // something large enough that does
524 if (!data.ValidOffsetForDataOfSize(data_offset, byte_size)) {
526 std::make_shared<DataBufferHeap>(data_offset + byte_size, '\0');
527 data.SetData(data_sp);
530 uint8_t *dst = const_cast<uint8_t *>(data.PeekData(data_offset, byte_size));
532 if (address_type == eAddressTypeHost) {
533 // The address is an address in this process, so just copy it.
535 error.SetErrorStringWithFormat(
536 "trying to read from host address of 0.");
539 memcpy(dst, reinterpret_cast<uint8_t *>(address), byte_size);
540 } else if ((address_type == eAddressTypeLoad) ||
541 (address_type == eAddressTypeFile)) {
542 if (file_so_addr.IsValid()) {
543 // We have a file address that we were able to translate into a section
544 // offset address so we might be able to read this from the object
545 // files if we don't have a live process. Lets always try and read from
546 // the process if we have one though since we want to read the actual
547 // value by setting "prefer_file_cache" to false.
548 const bool prefer_file_cache = false;
549 if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, prefer_file_cache,
551 error) != byte_size) {
552 error.SetErrorStringWithFormat(
553 "read memory from 0x%" PRIx64 " failed", (uint64_t)address);
556 // The execution context might have a NULL process, but it might have a
557 // valid process in the exe_ctx->target, so use the
558 // ExecutionContext::GetProcess accessor to ensure we get the process
560 Process *process = exe_ctx->GetProcessPtr();
563 const size_t bytes_read =
564 process->ReadMemory(address, dst, byte_size, error);
565 if (bytes_read != byte_size)
566 error.SetErrorStringWithFormat(
567 "read memory from 0x%" PRIx64 " failed (%u of %u bytes read)",
568 (uint64_t)address, (uint32_t)bytes_read, (uint32_t)byte_size);
570 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64
571 " failed (invalid process)",
576 error.SetErrorStringWithFormat("unsupported AddressType value (%i)",
580 error.SetErrorStringWithFormat("out of memory");
586 Scalar &Value::ResolveValue(ExecutionContext *exe_ctx) {
587 const CompilerType &compiler_type = GetCompilerType();
588 if (compiler_type.IsValid()) {
589 switch (m_value_type) {
590 case eValueTypeScalar: // raw scalar value
594 case eValueTypeFileAddress:
595 case eValueTypeLoadAddress: // load address value
596 case eValueTypeHostAddress: // host address value (for memory in the process
597 // that is using liblldb)
600 lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
601 Status error(GetValueAsData(exe_ctx, data, 0, NULL));
602 if (error.Success()) {
604 if (compiler_type.GetValueAsScalar(data, 0, data.GetByteSize(),
607 m_value_type = eValueTypeScalar;
609 if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
611 m_value_type = eValueTypeScalar;
615 if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
617 m_value_type = eValueTypeScalar;
626 Variable *Value::GetVariable() {
627 if (m_context_type == eContextTypeVariable)
628 return static_cast<Variable *>(m_context);
632 void Value::Clear() {
635 m_compiler_type.Clear();
636 m_value_type = eValueTypeScalar;
638 m_context_type = eContextTypeInvalid;
639 m_data_buffer.Clear();
642 const char *Value::GetValueTypeAsCString(ValueType value_type) {
643 switch (value_type) {
644 case eValueTypeScalar:
646 case eValueTypeVector:
648 case eValueTypeFileAddress:
649 return "file address";
650 case eValueTypeLoadAddress:
651 return "load address";
652 case eValueTypeHostAddress:
653 return "host address";
658 const char *Value::GetContextTypeAsCString(ContextType context_type) {
659 switch (context_type) {
660 case eContextTypeInvalid:
662 case eContextTypeRegisterInfo:
663 return "RegisterInfo *";
664 case eContextTypeLLDBType:
666 case eContextTypeVariable:
672 void Value::ConvertToLoadAddress(Module *module, Target *target) {
673 if (!module || !target || (GetValueType() != eValueTypeFileAddress))
676 lldb::addr_t file_addr = GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
677 if (file_addr == LLDB_INVALID_ADDRESS)
681 if (!module->ResolveFileAddress(file_addr, so_addr))
683 lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
684 if (load_addr == LLDB_INVALID_ADDRESS)
687 SetValueType(Value::eValueTypeLoadAddress);
688 GetScalar() = load_addr;
691 ValueList::ValueList(const ValueList &rhs) { m_values = rhs.m_values; }
693 const ValueList &ValueList::operator=(const ValueList &rhs) {
694 m_values = rhs.m_values;
698 void ValueList::PushValue(const Value &value) { m_values.push_back(value); }
700 size_t ValueList::GetSize() { return m_values.size(); }
702 Value *ValueList::GetValueAtIndex(size_t idx) {
703 if (idx < GetSize()) {
704 return &(m_values[idx]);
709 void ValueList::Clear() { m_values.clear(); }