mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 08:36:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/lldb/source/Core/Address.cpp
Chandler Carruth 2946cd7010 Update the file headers across all of the LLVM projects in the monorepo 
to reflect the new license.

We understand that people may be surprised that we're moving the header
entirely to discuss the new license. We checked this carefully with the
Foundation's lawyer and we believe this is the correct approach.

Essentially, all code in the project is now made available by the LLVM
project under our new license, so you will see that the license headers
include that license only. Some of our contributors have contributed
code under our old license, and accordingly, we have retained a copy of
our old license notice in the top-level files in each project and
repository.

llvm-svn: 351636
2019-01-19 08:50:56 +00:00

1009 lines
34 KiB
C++
Raw Blame History

//===-- Address.cpp ---------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Address.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/Section.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Declaration.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Symtab.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Support/Compiler.h"
#include <cstdint>
#include <memory>
#include <vector>
#include <assert.h>
#include <inttypes.h>
#include <string.h>
namespace lldb_private {
class CompileUnit;
}
namespace lldb_private {
class Function;
}
using namespace lldb;
using namespace lldb_private;
static size_t ReadBytes(ExecutionContextScope *exe_scope,
const Address &address, void *dst, size_t dst_len) {
if (exe_scope == nullptr)
return 0;
TargetSP target_sp(exe_scope->CalculateTarget());
if (target_sp) {
Status error;
bool prefer_file_cache = false;
return target_sp->ReadMemory(address, prefer_file_cache, dst, dst_len,
error);
}
return 0;
}
static bool GetByteOrderAndAddressSize(ExecutionContextScope *exe_scope,
const Address &address,
ByteOrder &byte_order,
uint32_t &addr_size) {
byte_order = eByteOrderInvalid;
addr_size = 0;
if (exe_scope == nullptr)
return false;
TargetSP target_sp(exe_scope->CalculateTarget());
if (target_sp) {
byte_order = target_sp->GetArchitecture().GetByteOrder();
addr_size = target_sp->GetArchitecture().GetAddressByteSize();
}
if (byte_order == eByteOrderInvalid || addr_size == 0) {
ModuleSP module_sp(address.GetModule());
if (module_sp) {
byte_order = module_sp->GetArchitecture().GetByteOrder();
addr_size = module_sp->GetArchitecture().GetAddressByteSize();
}
}
return byte_order != eByteOrderInvalid && addr_size != 0;
}
static uint64_t ReadUIntMax64(ExecutionContextScope *exe_scope,
const Address &address, uint32_t byte_size,
bool &success) {
uint64_t uval64 = 0;
if (exe_scope == nullptr || byte_size > sizeof(uint64_t)) {
success = false;
return 0;
}
uint64_t buf = 0;
success = ReadBytes(exe_scope, address, &buf, byte_size) == byte_size;
if (success) {
ByteOrder byte_order = eByteOrderInvalid;
uint32_t addr_size = 0;
if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
DataExtractor data(&buf, sizeof(buf), byte_order, addr_size);
lldb::offset_t offset = 0;
uval64 = data.GetU64(&offset);
} else
success = false;
}
return uval64;
}
static bool ReadAddress(ExecutionContextScope *exe_scope,
const Address &address, uint32_t pointer_size,
Address &deref_so_addr) {
if (exe_scope == nullptr)
return false;
bool success = false;
addr_t deref_addr = ReadUIntMax64(exe_scope, address, pointer_size, success);
if (success) {
ExecutionContext exe_ctx;
exe_scope->CalculateExecutionContext(exe_ctx);
// If we have any sections that are loaded, try and resolve using the
// section load list
Target *target = exe_ctx.GetTargetPtr();
if (target && !target->GetSectionLoadList().IsEmpty()) {
if (target->GetSectionLoadList().ResolveLoadAddress(deref_addr,
deref_so_addr))
return true;
} else {
// If we were not running, yet able to read an integer, we must have a
// module
ModuleSP module_sp(address.GetModule());
assert(module_sp);
if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr))
return true;
}
// We couldn't make "deref_addr" into a section offset value, but we were
// able to read the address, so we return a section offset address with no
// section and "deref_addr" as the offset (address).
deref_so_addr.SetRawAddress(deref_addr);
return true;
}
return false;
}
static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
uint32_t byte_size, Stream *strm) {
if (exe_scope == nullptr || byte_size == 0)
return 0;
std::vector<uint8_t> buf(byte_size, 0);
if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) {
ByteOrder byte_order = eByteOrderInvalid;
uint32_t addr_size = 0;
if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
DataExtractor data(&buf.front(), buf.size(), byte_order, addr_size);
DumpDataExtractor(data, strm,
0, // Start offset in "data"
eFormatHex, // Print as characters
buf.size(), // Size of item
1, // Items count
UINT32_MAX, // num per line
LLDB_INVALID_ADDRESS, // base address
0, // bitfield bit size
0); // bitfield bit offset
return true;
}
}
return false;
}
static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
const Address &address, Stream *strm) {
if (exe_scope == nullptr)
return 0;
const size_t k_buf_len = 256;
char buf[k_buf_len + 1];
buf[k_buf_len] = '\0'; // NULL terminate
// Byte order and address size don't matter for C string dumping..
DataExtractor data(buf, sizeof(buf), endian::InlHostByteOrder(), 4);
size_t total_len = 0;
size_t bytes_read;
Address curr_address(address);
strm->PutChar('"');
while ((bytes_read = ReadBytes(exe_scope, curr_address, buf, k_buf_len)) >
0) {
size_t len = strlen(buf);
if (len == 0)
break;
if (len > bytes_read)
len = bytes_read;
DumpDataExtractor(data, strm,
0, // Start offset in "data"
eFormatChar, // Print as characters
1, // Size of item (1 byte for a char!)
len, // How many bytes to print?
UINT32_MAX, // num per line
LLDB_INVALID_ADDRESS, // base address
0, // bitfield bit size
0); // bitfield bit offset
total_len += bytes_read;
if (len < k_buf_len)
break;
curr_address.SetOffset(curr_address.GetOffset() + bytes_read);
}
strm->PutChar('"');
return total_len;
}
Address::Address(lldb::addr_t abs_addr) : m_section_wp(), m_offset(abs_addr) {}
Address::Address(addr_t address, const SectionList *section_list)
: m_section_wp(), m_offset(LLDB_INVALID_ADDRESS) {
ResolveAddressUsingFileSections(address, section_list);
}
const Address &Address::operator=(const Address &rhs) {
if (this != &rhs) {
m_section_wp = rhs.m_section_wp;
m_offset = rhs.m_offset;
}
return *this;
}
bool Address::ResolveAddressUsingFileSections(addr_t file_addr,
const SectionList *section_list) {
if (section_list) {
SectionSP section_sp(
section_list->FindSectionContainingFileAddress(file_addr));
m_section_wp = section_sp;
if (section_sp) {
assert(section_sp->ContainsFileAddress(file_addr));
m_offset = file_addr - section_sp->GetFileAddress();
return true; // Successfully transformed addr into a section offset
// address
}
}
m_offset = file_addr;
return false; // Failed to resolve this address to a section offset value
}
ModuleSP Address::GetModule() const {
lldb::ModuleSP module_sp;
SectionSP section_sp(GetSection());
if (section_sp)
module_sp = section_sp->GetModule();
return module_sp;
}
addr_t Address::GetFileAddress() const {
SectionSP section_sp(GetSection());
if (section_sp) {
addr_t sect_file_addr = section_sp->GetFileAddress();
if (sect_file_addr == LLDB_INVALID_ADDRESS) {
// Section isn't resolved, we can't return a valid file address
return LLDB_INVALID_ADDRESS;
}
// We have a valid file range, so we can return the file based address by
// adding the file base address to our offset
return sect_file_addr + m_offset;
} else if (SectionWasDeletedPrivate()) {
// Used to have a valid section but it got deleted so the offset doesn't
// mean anything without the section
return LLDB_INVALID_ADDRESS;
}
// No section, we just return the offset since it is the value in this case
return m_offset;
}
addr_t Address::GetLoadAddress(Target *target) const {
SectionSP section_sp(GetSection());
if (section_sp) {
if (target) {
addr_t sect_load_addr = section_sp->GetLoadBaseAddress(target);
if (sect_load_addr != LLDB_INVALID_ADDRESS) {
// We have a valid file range, so we can return the file based address
// by adding the file base address to our offset
return sect_load_addr + m_offset;
}
}
} else if (SectionWasDeletedPrivate()) {
// Used to have a valid section but it got deleted so the offset doesn't
// mean anything without the section
return LLDB_INVALID_ADDRESS;
} else {
// We don't have a section so the offset is the load address
return m_offset;
}
// The section isn't resolved or an invalid target was passed in so we can't
// return a valid load address.
return LLDB_INVALID_ADDRESS;
}
addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const {
addr_t code_addr = LLDB_INVALID_ADDRESS;
if (is_indirect && target) {
ProcessSP processSP = target->GetProcessSP();
Status error;
if (processSP) {
code_addr = processSP->ResolveIndirectFunction(this, error);
if (!error.Success())
code_addr = LLDB_INVALID_ADDRESS;
}
} else {
code_addr = GetLoadAddress(target);
}
if (code_addr == LLDB_INVALID_ADDRESS)
return code_addr;
if (target)
return target->GetCallableLoadAddress(code_addr, GetAddressClass());
return code_addr;
}
bool Address::SetCallableLoadAddress(lldb::addr_t load_addr, Target *target) {
if (SetLoadAddress(load_addr, target)) {
if (target)
m_offset = target->GetCallableLoadAddress(m_offset, GetAddressClass());
return true;
}
return false;
}
addr_t Address::GetOpcodeLoadAddress(Target *target,
AddressClass addr_class) const {
addr_t code_addr = GetLoadAddress(target);
if (code_addr != LLDB_INVALID_ADDRESS) {
if (addr_class == AddressClass::eInvalid)
addr_class = GetAddressClass();
code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class);
}
return code_addr;
}
bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target,
AddressClass addr_class,
bool allow_section_end) {
if (SetLoadAddress(load_addr, target, allow_section_end)) {
if (target) {
if (addr_class == AddressClass::eInvalid)
addr_class = GetAddressClass();
m_offset = target->GetOpcodeLoadAddress(m_offset, addr_class);
}
return true;
}
return false;
}
bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
DumpStyle fallback_style, uint32_t addr_size) const {
// If the section was nullptr, only load address is going to work unless we
// are trying to deref a pointer
SectionSP section_sp(GetSection());
if (!section_sp && style != DumpStyleResolvedPointerDescription)
style = DumpStyleLoadAddress;
ExecutionContext exe_ctx(exe_scope);
Target *target = exe_ctx.GetTargetPtr();
// If addr_byte_size is UINT32_MAX, then determine the correct address byte
// size for the process or default to the size of addr_t
if (addr_size == UINT32_MAX) {
if (target)
addr_size = target->GetArchitecture().GetAddressByteSize();
else
addr_size = sizeof(addr_t);
}
Address so_addr;
switch (style) {
case DumpStyleInvalid:
return false;
case DumpStyleSectionNameOffset:
if (section_sp) {
section_sp->DumpName(s);
s->Printf(" + %" PRIu64, m_offset);
} else {
s->Address(m_offset, addr_size);
}
break;
case DumpStyleSectionPointerOffset:
s->Printf("(Section *)%p + ", static_cast<void *>(section_sp.get()));
s->Address(m_offset, addr_size);
break;
case DumpStyleModuleWithFileAddress:
if (section_sp) {
ModuleSP module_sp = section_sp->GetModule();
if (module_sp)
s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString(
"<Unknown>"));
else
s->Printf("%s[", "<Unknown>");
}
LLVM_FALLTHROUGH;
case DumpStyleFileAddress: {
addr_t file_addr = GetFileAddress();
if (file_addr == LLDB_INVALID_ADDRESS) {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
s->Address(file_addr, addr_size);
if (style == DumpStyleModuleWithFileAddress && section_sp)
s->PutChar(']');
} break;
case DumpStyleLoadAddress: {
addr_t load_addr = GetLoadAddress(target);
/*
* MIPS:
* Display address in compressed form for MIPS16 or microMIPS
* if the address belongs to AddressClass::eCodeAlternateISA.
*/
if (target) {
const llvm::Triple::ArchType llvm_arch =
target->GetArchitecture().GetMachine();
if (llvm_arch == llvm::Triple::mips ||
llvm_arch == llvm::Triple::mipsel ||
llvm_arch == llvm::Triple::mips64 ||
llvm_arch == llvm::Triple::mips64el)
load_addr = GetCallableLoadAddress(target);
}
if (load_addr == LLDB_INVALID_ADDRESS) {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
s->Address(load_addr, addr_size);
} break;
case DumpStyleResolvedDescription:
case DumpStyleResolvedDescriptionNoModule:
case DumpStyleResolvedDescriptionNoFunctionArguments:
case DumpStyleNoFunctionName:
if (IsSectionOffset()) {
uint32_t pointer_size = 4;
ModuleSP module_sp(GetModule());
if (target)
pointer_size = target->GetArchitecture().GetAddressByteSize();
else if (module_sp)
pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
bool showed_info = false;
if (section_sp) {
SectionType sect_type = section_sp->GetType();
switch (sect_type) {
case eSectionTypeData:
if (module_sp) {
SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
if (sym_vendor) {
Symtab *symtab = sym_vendor->GetSymtab();
if (symtab) {
const addr_t file_Addr = GetFileAddress();
Symbol *symbol =
symtab->FindSymbolContainingFileAddress(file_Addr);
if (symbol) {
const char *symbol_name = symbol->GetName().AsCString();
if (symbol_name) {
s->PutCString(symbol_name);
addr_t delta =
file_Addr - symbol->GetAddressRef().GetFileAddress();
if (delta)
s->Printf(" + %" PRIu64, delta);
showed_info = true;
}
}
}
}
}
break;
case eSectionTypeDataCString:
// Read the C string from memory and display it
showed_info = true;
ReadCStringFromMemory(exe_scope, *this, s);
break;
case eSectionTypeDataCStringPointers:
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("(char *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(": ");
#endif
showed_info = true;
ReadCStringFromMemory(exe_scope, so_addr, s);
}
break;
case eSectionTypeDataObjCMessageRefs:
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
if (target && so_addr.IsSectionOffset()) {
SymbolContext func_sc;
target->GetImages().ResolveSymbolContextForAddress(
so_addr, eSymbolContextEverything, func_sc);
if (func_sc.function != nullptr || func_sc.symbol != nullptr) {
showed_info = true;
#if VERBOSE_OUTPUT
s->PutCString("(objc_msgref *) -> { (func*)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
#else
s->PutCString("{ ");
#endif
Address cstr_addr(*this);
cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
func_sc.DumpStopContext(s, exe_scope, so_addr, true, true,
false, true, true);
if (ReadAddress(exe_scope, cstr_addr, pointer_size, so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("), (char *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(" (");
#else
s->PutCString(", ");
#endif
ReadCStringFromMemory(exe_scope, so_addr, s);
}
#if VERBOSE_OUTPUT
s->PutCString(") }");
#else
s->PutCString(" }");
#endif
}
}
}
break;
case eSectionTypeDataObjCCFStrings: {
Address cfstring_data_addr(*this);
cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() +
(2 * pointer_size));
if (ReadAddress(exe_scope, cfstring_data_addr, pointer_size,
so_addr)) {
#if VERBOSE_OUTPUT
s->PutCString("(CFString *) ");
cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
s->PutCString(" -> @");
#else
s->PutChar('@');
#endif
if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription))
showed_info = true;
}
} break;
case eSectionTypeData4:
// Read the 4 byte data and display it
showed_info = true;
s->PutCString("(uint32_t) ");
DumpUInt(exe_scope, *this, 4, s);
break;
case eSectionTypeData8:
// Read the 8 byte data and display it
showed_info = true;
s->PutCString("(uint64_t) ");
DumpUInt(exe_scope, *this, 8, s);
break;
case eSectionTypeData16:
// Read the 16 byte data and display it
showed_info = true;
s->PutCString("(uint128_t) ");
DumpUInt(exe_scope, *this, 16, s);
break;
case eSectionTypeDataPointers:
// Read the pointer data and display it
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
s->PutCString("(void *)");
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
DumpStyleFileAddress);
showed_info = true;
if (so_addr.IsSectionOffset()) {
SymbolContext pointer_sc;
if (target) {
target->GetImages().ResolveSymbolContextForAddress(
so_addr, eSymbolContextEverything, pointer_sc);
if (pointer_sc.function != nullptr ||
pointer_sc.symbol != nullptr) {
s->PutCString(": ");
pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false,
false, true, true);
}
}
}
}
break;
default:
break;
}
}
if (!showed_info) {
if (module_sp) {
SymbolContext sc;
module_sp->ResolveSymbolContextForAddress(
*this, eSymbolContextEverything, sc);
if (sc.function || sc.symbol) {
bool show_stop_context = true;
const bool show_module = (style == DumpStyleResolvedDescription);
const bool show_fullpaths = false;
const bool show_inlined_frames = true;
const bool show_function_arguments =
(style != DumpStyleResolvedDescriptionNoFunctionArguments);
const bool show_function_name = (style != DumpStyleNoFunctionName);
if (sc.function == nullptr && sc.symbol != nullptr) {
// If we have just a symbol make sure it is in the right section
if (sc.symbol->ValueIsAddress()) {
if (sc.symbol->GetAddressRef().GetSection() != GetSection()) {
// don't show the module if the symbol is a trampoline symbol
show_stop_context = false;
}
}
}
if (show_stop_context) {
// We have a function or a symbol from the same sections as this
// address.
sc.DumpStopContext(s, exe_scope, *this, show_fullpaths,
show_module, show_inlined_frames,
show_function_arguments, show_function_name);
} else {
// We found a symbol but it was in a different section so it
// isn't the symbol we should be showing, just show the section
// name + offset
Dump(s, exe_scope, DumpStyleSectionNameOffset);
}
}
}
}
} else {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
break;
case DumpStyleDetailedSymbolContext:
if (IsSectionOffset()) {
ModuleSP module_sp(GetModule());
if (module_sp) {
SymbolContext sc;
module_sp->ResolveSymbolContextForAddress(
*this, eSymbolContextEverything | eSymbolContextVariable, sc);
if (sc.symbol) {
// If we have just a symbol make sure it is in the same section as
// our address. If it isn't, then we might have just found the last
// symbol that came before the address that we are looking up that
// has nothing to do with our address lookup.
if (sc.symbol->ValueIsAddress() &&
sc.symbol->GetAddressRef().GetSection() != GetSection())
sc.symbol = nullptr;
}
sc.GetDescription(s, eDescriptionLevelBrief, target);
if (sc.block) {
bool can_create = true;
bool get_parent_variables = true;
bool stop_if_block_is_inlined_function = false;
VariableList variable_list;
sc.block->AppendVariables(can_create, get_parent_variables,
stop_if_block_is_inlined_function,
[](Variable *) { return true; },
&variable_list);
const size_t num_variables = variable_list.GetSize();
for (size_t var_idx = 0; var_idx < num_variables; ++var_idx) {
Variable *var = variable_list.GetVariableAtIndex(var_idx).get();
if (var && var->LocationIsValidForAddress(*this)) {
s->Indent();
s->Printf(" Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
var->GetID(), var->GetName().GetCString());
Type *type = var->GetType();
if (type)
s->Printf(", type = \"%s\"", type->GetName().GetCString());
else
s->PutCString(", type = <unknown>");
s->PutCString(", location = ");
var->DumpLocationForAddress(s, *this);
s->PutCString(", decl = ");
var->GetDeclaration().DumpStopContext(s, false);
s->EOL();
}
}
}
}
} else {
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
}
break;
case DumpStyleResolvedPointerDescription: {
Process *process = exe_ctx.GetProcessPtr();
if (process) {
addr_t load_addr = GetLoadAddress(target);
if (load_addr != LLDB_INVALID_ADDRESS) {
Status memory_error;
addr_t dereferenced_load_addr =
process->ReadPointerFromMemory(load_addr, memory_error);
if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) {
Address dereferenced_addr;
if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
target)) {
StreamString strm;
if (dereferenced_addr.Dump(&strm, exe_scope,
DumpStyleResolvedDescription,
DumpStyleInvalid, addr_size)) {
s->Address(dereferenced_load_addr, addr_size, " -> ", " ");
s->Write(strm.GetString().data(), strm.GetSize());
return true;
}
}
}
}
}
if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
return false;
} break;
}
return true;
}
bool Address::SectionWasDeleted() const {
if (GetSection())
return false;
return SectionWasDeletedPrivate();
}
bool Address::SectionWasDeletedPrivate() const {
lldb::SectionWP empty_section_wp;
// If either call to "std::weak_ptr::owner_before(...) value returns true,
// this indicates that m_section_wp once contained (possibly still does) a
// reference to a valid shared pointer. This helps us know if we had a valid
// reference to a section which is now invalid because the module it was in
// was unloaded/deleted, or if the address doesn't have a valid reference to
// a section.
return empty_section_wp.owner_before(m_section_wp) ||
m_section_wp.owner_before(empty_section_wp);
}
uint32_t
Address::CalculateSymbolContext(SymbolContext *sc,
SymbolContextItem resolve_scope) const {
sc->Clear(false);
// Absolute addresses don't have enough information to reconstruct even their
// target.
SectionSP section_sp(GetSection());
if (section_sp) {
ModuleSP module_sp(section_sp->GetModule());
if (module_sp) {
sc->module_sp = module_sp;
if (sc->module_sp)
return sc->module_sp->ResolveSymbolContextForAddress(
*this, resolve_scope, *sc);
}
}
return 0;
}
ModuleSP Address::CalculateSymbolContextModule() const {
SectionSP section_sp(GetSection());
if (section_sp)
return section_sp->GetModule();
return ModuleSP();
}
CompileUnit *Address::CalculateSymbolContextCompileUnit() const {
SectionSP section_sp(GetSection());
if (section_sp) {
SymbolContext sc;
sc.module_sp = section_sp->GetModule();
if (sc.module_sp) {
sc.module_sp->ResolveSymbolContextForAddress(*this,
eSymbolContextCompUnit, sc);
return sc.comp_unit;
}
}
return nullptr;
}
Function *Address::CalculateSymbolContextFunction() const {
SectionSP section_sp(GetSection());
if (section_sp) {
SymbolContext sc;
sc.module_sp = section_sp->GetModule();
if (sc.module_sp) {
sc.module_sp->ResolveSymbolContextForAddress(*this,
eSymbolContextFunction, sc);
return sc.function;
}
}
return nullptr;
}
Block *Address::CalculateSymbolContextBlock() const {
SectionSP section_sp(GetSection());
if (section_sp) {
SymbolContext sc;
sc.module_sp = section_sp->GetModule();
if (sc.module_sp) {
sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextBlock,
sc);
return sc.block;
}
}
return nullptr;
}
Symbol *Address::CalculateSymbolContextSymbol() const {
SectionSP section_sp(GetSection());
if (section_sp) {
SymbolContext sc;
sc.module_sp = section_sp->GetModule();
if (sc.module_sp) {
sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextSymbol,
sc);
return sc.symbol;
}
}
return nullptr;
}
bool Address::CalculateSymbolContextLineEntry(LineEntry &line_entry) const {
SectionSP section_sp(GetSection());
if (section_sp) {
SymbolContext sc;
sc.module_sp = section_sp->GetModule();
if (sc.module_sp) {
sc.module_sp->ResolveSymbolContextForAddress(*this,
eSymbolContextLineEntry, sc);
if (sc.line_entry.IsValid()) {
line_entry = sc.line_entry;
return true;
}
}
}
line_entry.Clear();
return false;
}
int Address::CompareFileAddress(const Address &a, const Address &b) {
addr_t a_file_addr = a.GetFileAddress();
addr_t b_file_addr = b.GetFileAddress();
if (a_file_addr < b_file_addr)
return -1;
if (a_file_addr > b_file_addr)
return +1;
return 0;
}
int Address::CompareLoadAddress(const Address &a, const Address &b,
Target *target) {
assert(target != nullptr);
addr_t a_load_addr = a.GetLoadAddress(target);
addr_t b_load_addr = b.GetLoadAddress(target);
if (a_load_addr < b_load_addr)
return -1;
if (a_load_addr > b_load_addr)
return +1;
return 0;
}
int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) {
ModuleSP a_module_sp(a.GetModule());
ModuleSP b_module_sp(b.GetModule());
Module *a_module = a_module_sp.get();
Module *b_module = b_module_sp.get();
if (a_module < b_module)
return -1;
if (a_module > b_module)
return +1;
// Modules are the same, just compare the file address since they should be
// unique
addr_t a_file_addr = a.GetFileAddress();
addr_t b_file_addr = b.GetFileAddress();
if (a_file_addr < b_file_addr)
return -1;
if (a_file_addr > b_file_addr)
return +1;
return 0;
}
size_t Address::MemorySize() const {
// Noting special for the memory size of a single Address object, it is just
// the size of itself.
return sizeof(Address);
}
//----------------------------------------------------------------------
// NOTE: Be careful using this operator. It can correctly compare two
// addresses from the same Module correctly. It can't compare two addresses
// from different modules in any meaningful way, but it will compare the module
// pointers.
//
// To sum things up:
// - works great for addresses within the same module - it works for addresses
// across multiple modules, but don't expect the
// address results to make much sense
//
// This basically lets Address objects be used in ordered collection classes.
//----------------------------------------------------------------------
bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
ModuleSP lhs_module_sp(lhs.GetModule());
ModuleSP rhs_module_sp(rhs.GetModule());
Module *lhs_module = lhs_module_sp.get();
Module *rhs_module = rhs_module_sp.get();
if (lhs_module == rhs_module) {
// Addresses are in the same module, just compare the file addresses
return lhs.GetFileAddress() < rhs.GetFileAddress();
} else {
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module < rhs_module;
}
}
bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
ModuleSP lhs_module_sp(lhs.GetModule());
ModuleSP rhs_module_sp(rhs.GetModule());
Module *lhs_module = lhs_module_sp.get();
Module *rhs_module = rhs_module_sp.get();
if (lhs_module == rhs_module) {
// Addresses are in the same module, just compare the file addresses
return lhs.GetFileAddress() > rhs.GetFileAddress();
} else {
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module > rhs_module;
}
}
// The operator == checks for exact equality only (same section, same offset)
bool lldb_private::operator==(const Address &a, const Address &rhs) {
return a.GetOffset() == rhs.GetOffset() && a.GetSection() == rhs.GetSection();
}
// The operator != checks for exact inequality only (differing section, or
// different offset)
bool lldb_private::operator!=(const Address &a, const Address &rhs) {
return a.GetOffset() != rhs.GetOffset() || a.GetSection() != rhs.GetSection();
}
AddressClass Address::GetAddressClass() const {
ModuleSP module_sp(GetModule());
if (module_sp) {
ObjectFile *obj_file = module_sp->GetObjectFile();
if (obj_file) {
// Give the symbol vendor a chance to add to the unified section list
// and to symtab from symbol file
if (SymbolVendor *vendor = module_sp->GetSymbolVendor())
vendor->GetSymtab();
return obj_file->GetAddressClass(GetFileAddress());
}
}
return AddressClass::eUnknown;
}
bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target,
bool allow_section_end) {
if (target && target->GetSectionLoadList().ResolveLoadAddress(
load_addr, *this, allow_section_end))
return true;
m_section_wp.reset();
m_offset = load_addr;
return false;
}
Reference in New Issue View Git Blame Copy Permalink