LCOV - code coverage report
Current view: top level - include/llvm/DebugInfo/DWARF - DWARFDebugRangeList.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 5 6 83.3 %
Date: 2018-09-23 13:06:45 Functions: 0 1 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- DWARFDebugRangeList.h ------------------------------------*- C++ -*-===//
       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             : #ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H
      11             : #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H
      12             : 
      13             : #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
      14             : #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
      15             : #include <cassert>
      16             : #include <cstdint>
      17             : #include <vector>
      18             : 
      19             : namespace llvm {
      20             : 
      21             : struct BaseAddress;
      22             : class raw_ostream;
      23             : 
      24             : class DWARFDebugRangeList {
      25             : public:
      26             :   struct RangeListEntry {
      27             :     /// A beginning address offset. This address offset has the size of an
      28             :     /// address and is relative to the applicable base address of the
      29             :     /// compilation unit referencing this range list. It marks the beginning
      30             :     /// of an address range.
      31             :     uint64_t StartAddress;
      32             :     /// An ending address offset. This address offset again has the size of
      33             :     /// an address and is relative to the applicable base address of the
      34             :     /// compilation unit referencing this range list. It marks the first
      35             :     /// address past the end of the address range. The ending address must
      36             :     /// be greater than or equal to the beginning address.
      37             :     uint64_t EndAddress;
      38             :     /// A section index this range belongs to.
      39             :     uint64_t SectionIndex;
      40             : 
      41             :     /// The end of any given range list is marked by an end of list entry,
      42             :     /// which consists of a 0 for the beginning address offset
      43             :     /// and a 0 for the ending address offset.
      44           0 :     bool isEndOfListEntry() const {
      45        7796 :       return (StartAddress == 0) && (EndAddress == 0);
      46             :     }
      47             : 
      48             :     /// A base address selection entry consists of:
      49             :     /// 1. The value of the largest representable address offset
      50             :     /// (for example, 0xffffffff when the size of an address is 32 bits).
      51             :     /// 2. An address, which defines the appropriate base address for
      52             :     /// use in interpreting the beginning and ending address offsets of
      53             :     /// subsequent entries of the location list.
      54             :     bool isBaseAddressSelectionEntry(uint8_t AddressSize) const {
      55             :       assert(AddressSize == 4 || AddressSize == 8);
      56        6496 :       if (AddressSize == 4)
      57          18 :         return StartAddress == -1U;
      58             :       else
      59        6478 :         return StartAddress == -1ULL;
      60             :     }
      61             :   };
      62             : 
      63             : private:
      64             :   /// Offset in .debug_ranges section.
      65             :   uint32_t Offset;
      66             :   uint8_t AddressSize;
      67             :   std::vector<RangeListEntry> Entries;
      68             : 
      69             : public:
      70        2752 :   DWARFDebugRangeList() { clear(); }
      71             : 
      72             :   void clear();
      73             :   void dump(raw_ostream &OS) const;
      74             :   Error extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
      75             :   const std::vector<RangeListEntry> &getEntries() { return Entries; }
      76             : 
      77             :   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
      78             :   /// list. Has to be passed base address of the compile unit referencing this
      79             :   /// range list.
      80             :   DWARFAddressRangesVector
      81             :   getAbsoluteRanges(llvm::Optional<BaseAddress> BaseAddr) const;
      82             : };
      83             : 
      84             : } // end namespace llvm
      85             : 
      86             : #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H

Generated by: LCOV version 1.13