181 lines · cpp
1//===- DWARFDebugArangeSet.cpp --------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"10#include "llvm/BinaryFormat/Dwarf.h"11#include "llvm/DebugInfo/DWARF/DWARFContext.h"12#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"13#include "llvm/Support/Errc.h"14#include "llvm/Support/Format.h"15#include "llvm/Support/raw_ostream.h"16#include <cassert>17#include <cinttypes>18#include <cstdint>19#include <cstring>20 21using namespace llvm;22 23void DWARFDebugArangeSet::Descriptor::dump(raw_ostream &OS,24 uint32_t AddressSize) const {25 OS << '[';26 DWARFFormValue::dumpAddress(OS, AddressSize, Address);27 OS << ", ";28 DWARFFormValue::dumpAddress(OS, AddressSize, getEndAddress());29 OS << ')';30}31 32void DWARFDebugArangeSet::clear() {33 Offset = -1ULL;34 std::memset(&HeaderData, 0, sizeof(Header));35 ArangeDescriptors.clear();36}37 38Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,39 uint64_t *offset_ptr,40 function_ref<void(Error)> WarningHandler) {41 assert(data.isValidOffset(*offset_ptr));42 ArangeDescriptors.clear();43 Offset = *offset_ptr;44 45 // 7.21 Address Range Table (extract)46 // Each set of entries in the table of address ranges contained in47 // the .debug_aranges section begins with a header containing:48 // 1. unit_length (initial length)49 // A 4-byte (32-bit DWARF) or 12-byte (64-bit DWARF) length containing50 // the length of the set of entries for this compilation unit,51 // not including the length field itself.52 // 2. version (uhalf)53 // The value in this field is 2.54 // 3. debug_info_offset (section offset)55 // A 4-byte (32-bit DWARF) or 8-byte (64-bit DWARF) offset into the56 // .debug_info section of the compilation unit header.57 // 4. address_size (ubyte)58 // 5. segment_selector_size (ubyte)59 // This header is followed by a series of tuples. Each tuple consists of60 // a segment, an address and a length. The segment selector size is given by61 // the segment_selector_size field of the header; the address and length62 // size are each given by the address_size field of the header. Each set of63 // tuples is terminated by a 0 for the segment, a 0 for the address and 064 // for the length. If the segment_selector_size field in the header is zero,65 // the segment selectors are omitted from all tuples, including66 // the terminating tuple.67 68 Error Err = Error::success();69 std::tie(HeaderData.Length, HeaderData.Format) =70 data.getInitialLength(offset_ptr, &Err);71 HeaderData.Version = data.getU16(offset_ptr, &Err);72 HeaderData.CuOffset = data.getUnsigned(73 offset_ptr, dwarf::getDwarfOffsetByteSize(HeaderData.Format), &Err);74 HeaderData.AddrSize = data.getU8(offset_ptr, &Err);75 HeaderData.SegSize = data.getU8(offset_ptr, &Err);76 if (Err) {77 return createStringError(errc::invalid_argument,78 "parsing address ranges table at offset 0x%" PRIx6479 ": %s",80 Offset, toString(std::move(Err)).c_str());81 }82 83 // Perform basic validation of the header fields.84 uint64_t full_length =85 dwarf::getUnitLengthFieldByteSize(HeaderData.Format) + HeaderData.Length;86 if (!data.isValidOffsetForDataOfSize(Offset, full_length))87 return createStringError(errc::invalid_argument,88 "the length of address range table at offset "89 "0x%" PRIx64 " exceeds section size",90 Offset);91 if (Error SizeErr = DWARFContext::checkAddressSizeSupported(92 HeaderData.AddrSize, errc::invalid_argument,93 "address range table at offset 0x%" PRIx64, Offset))94 return SizeErr;95 if (HeaderData.SegSize != 0)96 return createStringError(errc::not_supported,97 "non-zero segment selector size in address range "98 "table at offset 0x%" PRIx64 " is not supported",99 Offset);100 101 // The first tuple following the header in each set begins at an offset that102 // is a multiple of the size of a single tuple (that is, twice the size of103 // an address because we do not support non-zero segment selector sizes).104 // Therefore, the full length should also be a multiple of the tuple size.105 const uint32_t tuple_size = HeaderData.AddrSize * 2;106 if (full_length % tuple_size != 0)107 return createStringError(108 errc::invalid_argument,109 "address range table at offset 0x%" PRIx64110 " has length that is not a multiple of the tuple size",111 Offset);112 113 // The header is padded, if necessary, to the appropriate boundary.114 const uint32_t header_size = *offset_ptr - Offset;115 uint32_t first_tuple_offset = 0;116 while (first_tuple_offset < header_size)117 first_tuple_offset += tuple_size;118 119 // There should be space for at least one tuple.120 if (full_length <= first_tuple_offset)121 return createStringError(122 errc::invalid_argument,123 "address range table at offset 0x%" PRIx64124 " has an insufficient length to contain any entries",125 Offset);126 127 *offset_ptr = Offset + first_tuple_offset;128 129 Descriptor arangeDescriptor;130 131 static_assert(sizeof(arangeDescriptor.Address) ==132 sizeof(arangeDescriptor.Length),133 "Different datatypes for addresses and sizes!");134 assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);135 136 uint64_t end_offset = Offset + full_length;137 while (*offset_ptr < end_offset) {138 uint64_t EntryOffset = *offset_ptr;139 arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);140 arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);141 142 // Each set of tuples is terminated by a 0 for the address and 0143 // for the length.144 if (arangeDescriptor.Length == 0 && arangeDescriptor.Address == 0) {145 if (*offset_ptr == end_offset)146 return ErrorSuccess();147 if (WarningHandler) {148 WarningHandler(createStringError(149 errc::invalid_argument,150 "address range table at offset 0x%" PRIx64151 " has a premature terminator entry at offset 0x%" PRIx64,152 Offset, EntryOffset));153 }154 }155 156 ArangeDescriptors.push_back(arangeDescriptor);157 }158 159 return createStringError(errc::invalid_argument,160 "address range table at offset 0x%" PRIx64161 " is not terminated by null entry",162 Offset);163}164 165void DWARFDebugArangeSet::dump(raw_ostream &OS) const {166 int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(HeaderData.Format);167 OS << "Address Range Header: "168 << format("length = 0x%0*" PRIx64 ", ", OffsetDumpWidth, HeaderData.Length)169 << "format = " << dwarf::FormatString(HeaderData.Format) << ", "170 << format("version = 0x%4.4x, ", HeaderData.Version)171 << format("cu_offset = 0x%0*" PRIx64 ", ", OffsetDumpWidth,172 HeaderData.CuOffset)173 << format("addr_size = 0x%2.2x, ", HeaderData.AddrSize)174 << format("seg_size = 0x%2.2x\n", HeaderData.SegSize);175 176 for (const auto &Desc : ArangeDescriptors) {177 Desc.dump(OS, HeaderData.AddrSize);178 OS << '\n';179 }180}181