1//===-- DWARFDebugArangeSet.cpp -------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "DWARFDebugArangeSet.h"
11#include "llvm/Support/Format.h"
12#include "llvm/Support/raw_ostream.h"
13#include <algorithm>
14#include <cassert>
15using namespace llvm;
16
17void DWARFDebugArangeSet::clear() {
18  Offset = -1U;
19  std::memset(&HeaderData, 0, sizeof(Header));
20  ArangeDescriptors.clear();
21}
22
23bool
24DWARFDebugArangeSet::extract(DataExtractor data, uint32_t *offset_ptr) {
25  if (data.isValidOffset(*offset_ptr)) {
26    ArangeDescriptors.clear();
27    Offset = *offset_ptr;
28
29    // 7.20 Address Range Table
30    //
31    // Each set of entries in the table of address ranges contained in
32    // the .debug_aranges section begins with a header consisting of: a
33    // 4-byte length containing the length of the set of entries for this
34    // compilation unit, not including the length field itself; a 2-byte
35    // version identifier containing the value 2 for DWARF Version 2; a
36    // 4-byte offset into the.debug_infosection; a 1-byte unsigned integer
37    // containing the size in bytes of an address (or the offset portion of
38    // an address for segmented addressing) on the target system; and a
39    // 1-byte unsigned integer containing the size in bytes of a segment
40    // descriptor on the target system. This header is followed by a series
41    // of tuples. Each tuple consists of an address and a length, each in
42    // the size appropriate for an address on the target architecture.
43    HeaderData.Length = data.getU32(offset_ptr);
44    HeaderData.Version = data.getU16(offset_ptr);
45    HeaderData.CuOffset = data.getU32(offset_ptr);
46    HeaderData.AddrSize = data.getU8(offset_ptr);
47    HeaderData.SegSize = data.getU8(offset_ptr);
48
49    // Perform basic validation of the header fields.
50    if (!data.isValidOffsetForDataOfSize(Offset, HeaderData.Length) ||
51        (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)) {
52      clear();
53      return false;
54    }
55
56    // The first tuple following the header in each set begins at an offset
57    // that is a multiple of the size of a single tuple (that is, twice the
58    // size of an address). The header is padded, if necessary, to the
59    // appropriate boundary.
60    const uint32_t header_size = *offset_ptr - Offset;
61    const uint32_t tuple_size = HeaderData.AddrSize * 2;
62    uint32_t first_tuple_offset = 0;
63    while (first_tuple_offset < header_size)
64      first_tuple_offset += tuple_size;
65
66    *offset_ptr = Offset + first_tuple_offset;
67
68    Descriptor arangeDescriptor;
69
70    assert(sizeof(arangeDescriptor.Address) == sizeof(arangeDescriptor.Length));
71    assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);
72
73    while (data.isValidOffset(*offset_ptr)) {
74      arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
75      arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
76
77      // Each set of tuples is terminated by a 0 for the address and 0
78      // for the length.
79      if (arangeDescriptor.Address || arangeDescriptor.Length)
80        ArangeDescriptors.push_back(arangeDescriptor);
81      else
82        break; // We are done if we get a zero address and length
83    }
84
85    return !ArangeDescriptors.empty();
86  }
87  return false;
88}
89
90void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
91  OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
92               HeaderData.Length, HeaderData.Version)
93     << format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
94               HeaderData.CuOffset, HeaderData.AddrSize, HeaderData.SegSize);
95
96  const uint32_t hex_width = HeaderData.AddrSize * 2;
97  for (DescriptorConstIter pos = ArangeDescriptors.begin(),
98       end = ArangeDescriptors.end(); pos != end; ++pos)
99    OS << format("[0x%*.*" PRIx64 " -", hex_width, hex_width, pos->Address)
100       << format(" 0x%*.*" PRIx64 ")\n",
101                 hex_width, hex_width, pos->getEndAddress());
102}
103