271 lines
11 KiB
C++
271 lines
11 KiB
C++
//===-- DWARFDebugArangeSet.cpp ---------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DWARFDebugArangeSet.h"
|
|
|
|
#include "SymbolFileDWARF.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include <assert.h>
|
|
|
|
using namespace lldb_private;
|
|
|
|
DWARFDebugArangeSet::DWARFDebugArangeSet()
|
|
: m_offset(DW_INVALID_OFFSET), m_header(), m_arange_descriptors() {
|
|
m_header.length = 0;
|
|
m_header.version = 0;
|
|
m_header.cu_offset = 0;
|
|
m_header.addr_size = 0;
|
|
m_header.seg_size = 0;
|
|
}
|
|
|
|
void DWARFDebugArangeSet::Clear() {
|
|
m_offset = DW_INVALID_OFFSET;
|
|
m_header.length = 0;
|
|
m_header.version = 0;
|
|
m_header.cu_offset = 0;
|
|
m_header.addr_size = 0;
|
|
m_header.seg_size = 0;
|
|
m_arange_descriptors.clear();
|
|
}
|
|
|
|
void DWARFDebugArangeSet::SetHeader(uint16_t version, uint32_t cu_offset,
|
|
uint8_t addr_size, uint8_t seg_size) {
|
|
m_header.version = version;
|
|
m_header.cu_offset = cu_offset;
|
|
m_header.addr_size = addr_size;
|
|
m_header.seg_size = seg_size;
|
|
}
|
|
|
|
void DWARFDebugArangeSet::Compact() {
|
|
if (m_arange_descriptors.empty())
|
|
return;
|
|
|
|
// Iterate through all arange descriptors and combine any ranges that
|
|
// overlap or have matching boundaries. The m_arange_descriptors are assumed
|
|
// to be in ascending order after being built by adding descriptors
|
|
// using the AddDescriptor method.
|
|
uint32_t i = 0;
|
|
while (i + 1 < m_arange_descriptors.size()) {
|
|
if (m_arange_descriptors[i].end_address() >=
|
|
m_arange_descriptors[i + 1].address) {
|
|
// The current range ends at or exceeds the start of the next address
|
|
// range.
|
|
// Compute the max end address between the two and use that to make the
|
|
// new
|
|
// length.
|
|
const dw_addr_t max_end_addr =
|
|
std::max(m_arange_descriptors[i].end_address(),
|
|
m_arange_descriptors[i + 1].end_address());
|
|
m_arange_descriptors[i].length =
|
|
max_end_addr - m_arange_descriptors[i].address;
|
|
// Now remove the next entry as it was just combined with the previous
|
|
// one.
|
|
m_arange_descriptors.erase(m_arange_descriptors.begin() + i + 1);
|
|
} else {
|
|
// Discontiguous address range, just proceed to the next one.
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Compare function DWARFDebugArangeSet::Descriptor structures
|
|
//----------------------------------------------------------------------
|
|
static bool DescriptorLessThan(const DWARFDebugArangeSet::Descriptor &range1,
|
|
const DWARFDebugArangeSet::Descriptor &range2) {
|
|
return range1.address < range2.address;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Add a range descriptor and keep things sorted so we can easily
|
|
// compact the ranges before being saved or used.
|
|
//----------------------------------------------------------------------
|
|
void DWARFDebugArangeSet::AddDescriptor(
|
|
const DWARFDebugArangeSet::Descriptor &range) {
|
|
if (m_arange_descriptors.empty()) {
|
|
m_arange_descriptors.push_back(range);
|
|
return;
|
|
}
|
|
|
|
DescriptorIter end = m_arange_descriptors.end();
|
|
DescriptorIter pos =
|
|
lower_bound(m_arange_descriptors.begin(), end, range, DescriptorLessThan);
|
|
const dw_addr_t range_end_addr = range.end_address();
|
|
if (pos != end) {
|
|
const dw_addr_t found_end_addr = pos->end_address();
|
|
if (range.address < pos->address) {
|
|
if (range_end_addr < pos->address) {
|
|
// Non-contiguous entries, add this one before the found entry
|
|
m_arange_descriptors.insert(pos, range);
|
|
} else if (range_end_addr == pos->address) {
|
|
// The top end of 'range' is the lower end of the entry
|
|
// pointed to by 'pos'. We can combine range with the
|
|
// entry we found by setting the starting address and
|
|
// increasing the length since they don't overlap.
|
|
pos->address = range.address;
|
|
pos->length += range.length;
|
|
} else {
|
|
// We can combine these two and make sure the largest end
|
|
// address is used to make end address.
|
|
pos->address = range.address;
|
|
pos->length = std::max(found_end_addr, range_end_addr) - pos->address;
|
|
}
|
|
} else if (range.address == pos->address) {
|
|
pos->length = std::max(pos->length, range.length);
|
|
}
|
|
} else {
|
|
// NOTE: 'pos' points to entry past the end which is ok for insert,
|
|
// don't use otherwise!!!
|
|
const dw_addr_t max_addr = m_arange_descriptors.back().end_address();
|
|
if (max_addr < range.address) {
|
|
// Non-contiguous entries, add this one before the found entry
|
|
m_arange_descriptors.insert(pos, range);
|
|
} else if (max_addr == range.address) {
|
|
m_arange_descriptors.back().length += range.length;
|
|
} else {
|
|
m_arange_descriptors.back().length = std::max(max_addr, range_end_addr) -
|
|
m_arange_descriptors.back().address;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DWARFDebugArangeSet::Extract(const DWARFDataExtractor &data,
|
|
lldb::offset_t *offset_ptr) {
|
|
if (data.ValidOffset(*offset_ptr)) {
|
|
m_arange_descriptors.clear();
|
|
m_offset = *offset_ptr;
|
|
|
|
// 7.20 Address Range Table
|
|
//
|
|
// Each set of entries in the table of address ranges contained in
|
|
// the .debug_aranges section begins with a header consisting of: a
|
|
// 4-byte length containing the length of the set of entries for this
|
|
// compilation unit, not including the length field itself; a 2-byte
|
|
// version identifier containing the value 2 for DWARF Version 2; a
|
|
// 4-byte offset into the.debug_infosection; a 1-byte unsigned integer
|
|
// containing the size in bytes of an address (or the offset portion of
|
|
// an address for segmented addressing) on the target system; and a
|
|
// 1-byte unsigned integer containing the size in bytes of a segment
|
|
// descriptor on the target system. This header is followed by a series
|
|
// of tuples. Each tuple consists of an address and a length, each in
|
|
// the size appropriate for an address on the target architecture.
|
|
m_header.length = data.GetDWARFInitialLength(offset_ptr);
|
|
m_header.version = data.GetU16(offset_ptr);
|
|
m_header.cu_offset = data.GetDWARFOffset(offset_ptr);
|
|
m_header.addr_size = data.GetU8(offset_ptr);
|
|
m_header.seg_size = data.GetU8(offset_ptr);
|
|
|
|
// Try to avoid reading invalid arange sets by making sure:
|
|
// 1 - the version looks good
|
|
// 2 - the address byte size looks plausible
|
|
// 3 - the length seems to make sense
|
|
// size looks plausible
|
|
if ((m_header.version >= 2 && m_header.version <= 5) &&
|
|
(m_header.addr_size == 4 || m_header.addr_size == 8) &&
|
|
(m_header.length > 0)) {
|
|
if (data.ValidOffset(m_offset + sizeof(m_header.length) +
|
|
m_header.length - 1)) {
|
|
// The first tuple following the header in each set begins at an offset
|
|
// that is a multiple of the size of a single tuple (that is, twice the
|
|
// size of an address). The header is padded, if necessary, to the
|
|
// appropriate boundary.
|
|
const uint32_t header_size = *offset_ptr - m_offset;
|
|
const uint32_t tuple_size = m_header.addr_size << 1;
|
|
uint32_t first_tuple_offset = 0;
|
|
while (first_tuple_offset < header_size)
|
|
first_tuple_offset += tuple_size;
|
|
|
|
*offset_ptr = m_offset + first_tuple_offset;
|
|
|
|
Descriptor arangeDescriptor;
|
|
|
|
static_assert(
|
|
sizeof(arangeDescriptor.address) == sizeof(arangeDescriptor.length),
|
|
"DWARFDebugArangeSet::Descriptor.address and "
|
|
"DWARFDebugArangeSet::Descriptor.length must have same size");
|
|
|
|
while (data.ValidOffset(*offset_ptr)) {
|
|
arangeDescriptor.address =
|
|
data.GetMaxU64(offset_ptr, m_header.addr_size);
|
|
arangeDescriptor.length =
|
|
data.GetMaxU64(offset_ptr, m_header.addr_size);
|
|
|
|
// Each set of tuples is terminated by a 0 for the address and 0
|
|
// for the length.
|
|
if (arangeDescriptor.address || arangeDescriptor.length)
|
|
m_arange_descriptors.push_back(arangeDescriptor);
|
|
else
|
|
break; // We are done if we get a zero address and length
|
|
}
|
|
}
|
|
#if defined(LLDB_CONFIGURATION_DEBUG)
|
|
else {
|
|
printf("warning: .debug_arange set length is too large arange data at "
|
|
"0x%8.8x: length=0x%8.8x, version=0x%4.4x, cu_offset=0x%8.8x, "
|
|
"addr_size=%u, seg_size=%u\n",
|
|
m_offset, m_header.length, m_header.version, m_header.cu_offset,
|
|
m_header.addr_size, m_header.seg_size);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(LLDB_CONFIGURATION_DEBUG)
|
|
else {
|
|
printf("warning: .debug_arange set has bad header at 0x%8.8x: "
|
|
"length=0x%8.8x, version=0x%4.4x, cu_offset=0x%8.8x, "
|
|
"addr_size=%u, seg_size=%u\n",
|
|
m_offset, m_header.length, m_header.version, m_header.cu_offset,
|
|
m_header.addr_size, m_header.seg_size);
|
|
}
|
|
#endif
|
|
|
|
return !m_arange_descriptors.empty();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
dw_offset_t DWARFDebugArangeSet::GetOffsetOfNextEntry() const {
|
|
return m_offset + m_header.length + 4;
|
|
}
|
|
|
|
void DWARFDebugArangeSet::Dump(Stream *s) const {
|
|
s->Printf("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, "
|
|
"cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
|
|
m_header.length, m_header.version, m_header.cu_offset,
|
|
m_header.addr_size, m_header.seg_size);
|
|
|
|
const uint32_t hex_width = m_header.addr_size * 2;
|
|
DescriptorConstIter pos;
|
|
DescriptorConstIter end = m_arange_descriptors.end();
|
|
for (pos = m_arange_descriptors.begin(); pos != end; ++pos)
|
|
s->Printf("[0x%*.*" PRIx64 " - 0x%*.*" PRIx64 ")\n", hex_width, hex_width,
|
|
pos->address, hex_width, hex_width, pos->end_address());
|
|
}
|
|
|
|
class DescriptorContainsAddress {
|
|
public:
|
|
DescriptorContainsAddress(dw_addr_t address) : m_address(address) {}
|
|
bool operator()(const DWARFDebugArangeSet::Descriptor &desc) const {
|
|
return (m_address >= desc.address) &&
|
|
(m_address < (desc.address + desc.length));
|
|
}
|
|
|
|
private:
|
|
const dw_addr_t m_address;
|
|
};
|
|
|
|
dw_offset_t DWARFDebugArangeSet::FindAddress(dw_addr_t address) const {
|
|
DescriptorConstIter end = m_arange_descriptors.end();
|
|
DescriptorConstIter pos =
|
|
std::find_if(m_arange_descriptors.begin(), end, // Range
|
|
DescriptorContainsAddress(address)); // Predicate
|
|
if (pos != end)
|
|
return m_header.cu_offset;
|
|
|
|
return DW_INVALID_OFFSET;
|
|
}
|