Line data    Source code

       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 "llvm/DebugInfo/DWARFDebugArangeSet.h"
      11             : #include "llvm/Support/Format.h"
      12             : #include "llvm/Support/raw_ostream.h"
      13             : #include <algorithm>
      14             : #include <cassert>
      15             : using namespace llvm;
      16             : 
      17         159 : void DWARFDebugArangeSet::clear() {
      18         159 :   Offset = -1U;
      19         159 :   std::memset(&HeaderData, 0, sizeof(Header));
      20         159 :   ArangeDescriptors.clear();
      21         159 : }
      22             : 
      23             : bool
      24        2774 : DWARFDebugArangeSet::extract(DataExtractor data, uint32_t *offset_ptr) {
      25        5548 :   if (data.isValidOffset(*offset_ptr)) {
      26        2632 :     ArangeDescriptors.clear();
      27        2632 :     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        2632 :     HeaderData.Length = data.getU32(offset_ptr);
      44        2632 :     HeaderData.Version = data.getU16(offset_ptr);
      45        2632 :     HeaderData.CuOffset = data.getU32(offset_ptr);
      46        2632 :     HeaderData.AddrSize = data.getU8(offset_ptr);
      47        2632 :     HeaderData.SegSize = data.getU8(offset_ptr);
      48             : 
      49             :     // Perform basic validation of the header fields.
      50        7896 :     if (!data.isValidOffsetForDataOfSize(Offset, HeaderData.Length) ||
      51        2632 :         (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)) {
      52           0 :       clear();
      53           0 :       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        2632 :     const uint32_t header_size = *offset_ptr - Offset;
      61        2632 :     const uint32_t tuple_size = HeaderData.AddrSize * 2;
      62        2632 :     uint32_t first_tuple_offset = 0;
      63        7901 :     while (first_tuple_offset < header_size)
      64        2637 :       first_tuple_offset += tuple_size;
      65             : 
      66        2632 :     *offset_ptr = Offset + first_tuple_offset;
      67             : 
      68             :     Descriptor arangeDescriptor;
      69             : 
      70             :     static_assert(sizeof(arangeDescriptor.Address) ==
      71             :                       sizeof(arangeDescriptor.Length),
      72             :                   "Different datatypes for addresses and sizes!");
      73             :     assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);
      74             : 
      75      413298 :     while (data.isValidOffset(*offset_ptr)) {
      76      205333 :       arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
      77      205333 :       arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
      78             : 
      79             :       // Each set of tuples is terminated by a 0 for the address and 0
      80             :       // for the length.
      81      205333 :       if (arangeDescriptor.Address || arangeDescriptor.Length)
      82      202701 :         ArangeDescriptors.push_back(arangeDescriptor);
      83             :       else
      84             :         break; // We are done if we get a zero address and length
      85             :     }
      86             : 
      87        5264 :     return !ArangeDescriptors.empty();
      88             :   }
      89             :   return false;
      90             : }
      91             : 
      92           9 : void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
      93             :   OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
      94          27 :                HeaderData.Length, HeaderData.Version)
      95             :      << format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
      96          27 :                HeaderData.CuOffset, HeaderData.AddrSize, HeaderData.SegSize);
      97             : 
      98           9 :   const uint32_t hex_width = HeaderData.AddrSize * 2;
      99          49 :   for (const auto &Desc : ArangeDescriptors) {
     100          39 :     OS << format("[0x%*.*" PRIx64 " -", hex_width, hex_width, Desc.Address)
     101             :        << format(" 0x%*.*" PRIx64 ")\n",
     102          39 :                  hex_width, hex_width, Desc.getEndAddress());
     103             :   }
     104           9 : }