diff options
Diffstat (limited to 'lldb/source/Core/Address.cpp')
| -rw-r--r-- | lldb/source/Core/Address.cpp | 1843 |
1 files changed, 849 insertions, 994 deletions
diff --git a/lldb/source/Core/Address.cpp b/lldb/source/Core/Address.cpp index 2ef5bbee836..6933aba2d07 100644 --- a/lldb/source/Core/Address.cpp +++ b/lldb/source/Core/Address.cpp @@ -19,1108 +19,963 @@ #include "lldb/Core/Section.h" #include "lldb/Symbol/Block.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/Variable.h" #include "lldb/Symbol/VariableList.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/Process.h" #include "lldb/Target/SectionLoadList.h" #include "lldb/Target/Target.h" -#include "lldb/Symbol/SymbolVendor.h" 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) - { - Error error; - bool prefer_file_cache = false; - return target_sp->ReadMemory (address, prefer_file_cache, dst, dst_len, error); - } +static size_t ReadBytes(ExecutionContextScope *exe_scope, + const Address &address, void *dst, size_t dst_len) { + if (exe_scope == nullptr) 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(); - } + 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; - 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; -} + TargetSP target_sp(exe_scope->CalculateTarget()); + if (target_sp) { + byte_order = target_sp->GetArchitecture().GetByteOrder(); + addr_size = target_sp->GetArchitecture().GetAddressByteSize(); + } -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; + 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(); } - 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; + } + return byte_order != eByteOrderInvalid && addr_size != 0; } -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; - } +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; - // 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); + 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; - } - return false; -} + } else { + // If we were not running, yet able to read an integer, we must + // have a module + ModuleSP module_sp(address.GetModule()); -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); - - data.Dump (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; - } + assert(module_sp); + if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr)) + 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; - - data.Dump (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; + // 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; } -Address::Address (lldb::addr_t abs_addr) : - m_section_wp (), - m_offset (abs_addr) -{ -} +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); -Address::Address (addr_t address, const SectionList *section_list) : - m_section_wp (), - m_offset (LLDB_INVALID_ADDRESS) -{ - ResolveAddressUsingFileSections(address, section_list); -} + 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); -const Address& -Address::operator= (const Address& rhs) -{ - if (this != &rhs) - { - m_section_wp = rhs.m_section_wp; - m_offset = rhs.m_offset; - } - return *this; -} + data.Dump(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 -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 - } + return true; } - m_offset = file_addr; - return false; // Failed to resolve this address to a section offset value + } + return false; } -ModuleSP -Address::GetModule () const -{ - lldb::ModuleSP module_sp; - SectionSP section_sp (GetSection()); - if (section_sp) - module_sp = section_sp->GetModule(); - return module_sp; +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; + + data.Dump(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::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; - } +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_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; + return sect_load_addr + m_offset; + } } - // No section, we just return the offset since it is the value in this case + } 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::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; -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(); - Error error; - if (processSP) - { - code_addr = processSP->ResolveIndirectFunction(this, error); - if (!error.Success()) - code_addr = LLDB_INVALID_ADDRESS; - } - } - else - { - code_addr = GetLoadAddress (target); + 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; } - - if (code_addr == LLDB_INVALID_ADDRESS) - return code_addr; - - if (target) - return target->GetCallableLoadAddress (code_addr, GetAddressClass()); + } else { + code_addr = GetLoadAddress(target); + } + + if (code_addr == LLDB_INVALID_ADDRESS) 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; + if (target) + return target->GetCallableLoadAddress(code_addr, GetAddressClass()); + return code_addr; } -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; +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; } -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); - } - 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 == eAddressClassInvalid) + addr_class = GetAddressClass(); + code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class); + } + return code_addr; } -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); +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); } + 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 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); - } + Address so_addr; + switch (style) { + case DumpStyleInvalid: + return false; - 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 + 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); showed_info = true; - ReadCStringFromMemory (exe_scope, *this, s); - break; + } + } + } + } + } + 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)) - { + 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(": "); + 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; + 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); + s->PutCString("(objc_msgref *) -> { (func*)"); + so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, + DumpStyleFileAddress); #else - s->PutCString ("{ "); + 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)) - { + 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(" ("); + s->PutCString("), (char *)"); + so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, + DumpStyleFileAddress); + s->PutCString(" ("); #else - s->PutCString(", "); + s->PutCString(", "); #endif - ReadCStringFromMemory (exe_scope, so_addr, s); - } + ReadCStringFromMemory(exe_scope, so_addr, s); + } #if VERBOSE_OUTPUT - s->PutCString(") }"); + s->PutCString(") }"); #else - s->PutCString(" }"); + 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)) - { + } + } + } + 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(" -> @"); + s->PutCString("(CFString *) "); + cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress, + DumpStyleFileAddress); + s->PutCString(" -> @"); #else - s->PutChar('@'); + 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 (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; - 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; + default: + break; } - 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(); - } - } + } + + 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; } + } } - } - 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, " -> ", " "); - s->Write(strm.GetData(), strm.GetSize()); - return true; - } - } - } - } + 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); } - 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, 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) - { + } + } 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; - sc.module_sp = section_sp->GetModule(); - if (sc.module_sp) - { - sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextFunction, sc); - return sc.function; + 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; } - } - 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; + 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(); + } + } } - } - 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; + } + } 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, " -> ", " "); + s->Write(strm.GetData(), strm.GetSize()); + return true; } + } } + } } - line_entry.Clear(); + if (fallback_style != DumpStyleInvalid) + return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); return false; -} + } break; + } -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; + return true; } -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); +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); } //---------------------------------------------------------------------- -// NOTE: Be careful using this operator. It can correctly compare two -// addresses from the same Module correctly. It can't compare two +// 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 +// 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; - } +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(); +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(); +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. - module_sp->GetSymbolVendor(); - return obj_file->GetAddressClass (GetFileAddress()); - } +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()); } - return eAddressClassUnknown; + } + return eAddressClassUnknown; } -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; +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; } |
