bf9a77305f
This moves the following classes from Core -> Utility. ConstString Error RegularExpression Stream StreamString The goal here is to get lldbUtility into a state where it has no dependendencies except on itself and LLVM, so it can be the starting point at which to start untangling LLDB's dependencies. These are all low level and very widely used classes, and previously lldbUtility had dependencies up to lldbCore in order to use these classes. So moving then down to lldbUtility makes sense from both the short term and long term perspective in solving this problem. Differential Revision: https://reviews.llvm.org/D29427 llvm-svn: 293941
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;
|
|
}
|