2010-06-09 00:52:24 +08:00
|
|
|
//===-- Address.cpp ---------------------------------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "lldb/Core/Address.h"
|
2016-03-02 09:09:03 +08:00
|
|
|
|
|
|
|
// C Includes
|
|
|
|
// C++ Includes
|
|
|
|
#include "llvm/ADT/Triple.h"
|
|
|
|
|
|
|
|
// Other libraries and framework includes
|
|
|
|
// Project includes
|
2017-03-04 04:57:05 +08:00
|
|
|
#include "lldb/Core/DumpDataExtractor.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Core/Module.h"
|
|
|
|
#include "lldb/Core/Section.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Symbol/Block.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/ObjectFile.h"
|
2016-09-07 04:57:50 +08:00
|
|
|
#include "lldb/Symbol/SymbolVendor.h"
|
2011-07-11 13:12:02 +08:00
|
|
|
#include "lldb/Symbol/Variable.h"
|
|
|
|
#include "lldb/Symbol/VariableList.h"
|
2010-09-15 07:36:40 +08:00
|
|
|
#include "lldb/Target/ExecutionContext.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
2013-12-06 09:12:00 +08:00
|
|
|
#include "lldb/Target/SectionLoadList.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Target/Target.h"
|
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
static size_t ReadBytes(ExecutionContextScope *exe_scope,
|
|
|
|
const Address &address, void *dst, size_t dst_len) {
|
|
|
|
if (exe_scope == nullptr)
|
2010-06-09 00:52:24 +08:00
|
|
|
return 0;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
TargetSP target_sp(exe_scope->CalculateTarget());
|
|
|
|
if (target_sp) {
|
|
|
|
Error 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;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
TargetSP target_sp(exe_scope->CalculateTarget());
|
|
|
|
if (target_sp) {
|
|
|
|
byte_order = target_sp->GetArchitecture().GetByteOrder();
|
|
|
|
addr_size = target_sp->GetArchitecture().GetAddressByteSize();
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return byte_order != eByteOrderInvalid && addr_size != 0;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
2010-09-15 07:36:40 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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))
|
2010-06-09 00:52:24 +08:00
|
|
|
return true;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
|
|
|
// If we were not running, yet able to read an integer, we must
|
|
|
|
// have a module
|
|
|
|
ModuleSP module_sp(address.GetModule());
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
assert(module_sp);
|
|
|
|
if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr))
|
|
|
|
return true;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
// 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;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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);
|
2012-02-24 09:59:29 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2017-03-04 04:57:05 +08:00
|
|
|
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
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return true;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return false;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
|
|
|
|
2017-03-04 04:57:05 +08:00
|
|
|
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
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-03-04 04:57:05 +08:00
|
|
|
0); // bitfield bit offset
|
2016-09-07 04:57:50 +08:00
|
|
|
|
|
|
|
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;
|
2012-01-30 04:56:30 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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) {
|
2010-06-09 00:52:24 +08:00
|
|
|
// We have a valid file range, so we can return the file based
|
|
|
|
// address by adding the file base address to our offset
|
2016-09-07 04:57:50 +08:00
|
|
|
return sect_load_addr + m_offset;
|
|
|
|
}
|
2013-11-06 10:29:13 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} 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
|
2010-06-09 00:52:24 +08:00
|
|
|
return m_offset;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
// 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;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const {
|
|
|
|
addr_t code_addr = LLDB_INVALID_ADDRESS;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (is_indirect && target) {
|
|
|
|
ProcessSP processSP = target->GetProcessSP();
|
|
|
|
Error error;
|
|
|
|
if (processSP) {
|
|
|
|
code_addr = processSP->ResolveIndirectFunction(this, error);
|
|
|
|
if (!error.Success())
|
|
|
|
code_addr = LLDB_INVALID_ADDRESS;
|
2014-01-11 07:46:59 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
|
|
|
code_addr = GetLoadAddress(target);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (code_addr == LLDB_INVALID_ADDRESS)
|
2011-05-19 06:01:49 +08:00
|
|
|
return code_addr;
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
if (target)
|
|
|
|
return target->GetCallableLoadAddress(code_addr, GetAddressClass());
|
|
|
|
return code_addr;
|
2011-05-22 12:32:55 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
2011-05-20 02:17:41 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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 == eAddressClassInvalid)
|
|
|
|
addr_class = GetAddressClass();
|
|
|
|
code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class);
|
|
|
|
}
|
|
|
|
return code_addr;
|
2011-05-22 12:32:55 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target,
|
|
|
|
AddressClass addr_class) {
|
|
|
|
if (SetLoadAddress(load_addr, target)) {
|
|
|
|
if (target) {
|
|
|
|
if (addr_class == eAddressClassInvalid)
|
|
|
|
addr_class = GetAddressClass();
|
|
|
|
m_offset = target->GetOpcodeLoadAddress(m_offset, addr_class);
|
2010-07-01 07:03:03 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
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);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
Address so_addr;
|
|
|
|
switch (style) {
|
|
|
|
case DumpStyleInvalid:
|
|
|
|
return false;
|
2015-09-22 14:36:56 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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 eAddressClassCodeAlternateISA.
|
|
|
|
*/
|
|
|
|
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);
|
2010-06-09 00:52:24 +08:00
|
|
|
showed_info = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case eSectionTypeDataCString:
|
|
|
|
// Read the C string from memory and display it
|
|
|
|
showed_info = true;
|
|
|
|
ReadCStringFromMemory(exe_scope, *this, s);
|
|
|
|
break;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
case eSectionTypeDataCStringPointers:
|
|
|
|
if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
|
2010-06-09 00:52:24 +08:00
|
|
|
#if VERBOSE_OUTPUT
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString("(char *)");
|
|
|
|
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
|
|
|
|
DumpStyleFileAddress);
|
|
|
|
s->PutCString(": ");
|
2010-06-09 00:52:24 +08:00
|
|
|
#endif
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
2010-06-09 00:52:24 +08:00
|
|
|
#if VERBOSE_OUTPUT
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString("(objc_msgref *) -> { (func*)");
|
|
|
|
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
|
|
|
|
DumpStyleFileAddress);
|
2010-06-09 00:52:24 +08:00
|
|
|
#else
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString("{ ");
|
2010-06-09 00:52:24 +08:00
|
|
|
#endif
|
2016-09-07 04:57:50 +08:00
|
|
|
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)) {
|
2010-06-09 00:52:24 +08:00
|
|
|
#if VERBOSE_OUTPUT
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString("), (char *)");
|
|
|
|
so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
|
|
|
|
DumpStyleFileAddress);
|
|
|
|
s->PutCString(" (");
|
2010-06-09 00:52:24 +08:00
|
|
|
#else
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString(", ");
|
2010-06-09 00:52:24 +08:00
|
|
|
#endif
|
2016-09-07 04:57:50 +08:00
|
|
|
ReadCStringFromMemory(exe_scope, so_addr, s);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
#if VERBOSE_OUTPUT
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString(") }");
|
2010-06-09 00:52:24 +08:00
|
|
|
#else
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString(" }");
|
2010-06-09 00:52:24 +08:00
|
|
|
#endif
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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)) {
|
2010-06-09 00:52:24 +08:00
|
|
|
#if VERBOSE_OUTPUT
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutCString("(CFString *) ");
|
|
|
|
cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
|
|
|
|
DumpStyleFileAddress);
|
|
|
|
s->PutCString(" -> @");
|
2010-06-09 00:52:24 +08:00
|
|
|
#else
|
2016-09-07 04:57:50 +08:00
|
|
|
s->PutChar('@');
|
2010-06-09 00:52:24 +08:00
|
|
|
#endif
|
2016-09-07 04:57:50 +08:00
|
|
|
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);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
break;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
default:
|
|
|
|
break;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2011-07-11 13:12:02 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-07-01 07:03:03 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
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);
|
2012-07-12 06:18:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-08-13 05:40:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
} 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) {
|
2011-08-13 05:40:01 +08:00
|
|
|
SymbolContext sc;
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
2011-08-13 05:40:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
2011-08-13 05:40:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
} 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) {
|
|
|
|
Error 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, " -> ", " ");
|
2016-11-17 05:15:24 +08:00
|
|
|
s->Write(strm.GetString().data(), strm.GetSize());
|
2016-09-07 04:57:50 +08:00
|
|
|
return true;
|
2011-08-13 05:40:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-08-13 05:40:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
if (fallback_style != DumpStyleInvalid)
|
|
|
|
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
|
2011-08-13 05:40:01 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
} break;
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
return true;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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,
|
|
|
|
uint32_t 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);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2011-01-08 08:05:12 +08:00
|
|
|
//----------------------------------------------------------------------
|
2016-09-07 04:57:50 +08:00
|
|
|
// NOTE: Be careful using this operator. It can correctly compare two
|
|
|
|
// addresses from the same Module correctly. It can't compare two
|
2011-01-08 08:05:12 +08:00
|
|
|
// addresses from different modules in any meaningful way, but it will
|
|
|
|
// compare the module pointers.
|
2016-09-07 04:57:50 +08:00
|
|
|
//
|
2011-01-08 08:05:12 +08:00
|
|
|
// 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
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
2016-09-07 04:57:50 +08:00
|
|
|
// This basically lets Address objects be used in ordered collection
|
2011-01-08 08:05:12 +08:00
|
|
|
// classes.
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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;
|
|
|
|
}
|
2011-01-08 08:05:12 +08:00
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// The operator == checks for exact equality only (same section, same offset)
|
2016-09-07 04:57:50 +08:00
|
|
|
bool lldb_private::operator==(const Address &a, const Address &rhs) {
|
|
|
|
return a.GetOffset() == rhs.GetOffset() && a.GetSection() == rhs.GetSection();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-03-02 09:09:03 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// The operator != checks for exact inequality only (differing section, or
|
|
|
|
// different offset)
|
2016-09-07 04:57:50 +08:00
|
|
|
bool lldb_private::operator!=(const Address &a, const Address &rhs) {
|
|
|
|
return a.GetOffset() != rhs.GetOffset() || a.GetSection() != rhs.GetSection();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
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.
|
|
|
|
module_sp->GetSymbolVendor();
|
|
|
|
return obj_file->GetAddressClass(GetFileAddress());
|
2011-03-19 09:12:21 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
return eAddressClassUnknown;
|
2011-03-19 09:12:21 +08:00
|
|
|
}
|
2011-05-18 09:58:14 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target) {
|
|
|
|
if (target &&
|
|
|
|
target->GetSectionLoadList().ResolveLoadAddress(load_addr, *this))
|
|
|
|
return true;
|
|
|
|
m_section_wp.reset();
|
|
|
|
m_offset = load_addr;
|
|
|
|
return false;
|
2011-05-18 09:58:14 +08:00
|
|
|
}
|