| //===-- 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; |
| } |
