LCOV - code coverage report
Current view: top level - lib/DebugInfo/DWARF - DWARFDebugArangeSet.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 40 40 100.0 %
Date: 2017-09-14 15:23:50 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13