LCOV - code coverage report
Current view: top level - include/llvm/DebugInfo/DWARF - DWARFDie.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 39 46 84.8 %
Date: 2018-10-20 13:21:21 Functions: 5 12 41.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- DWARFDie.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_DWARFDIE_H
      11             : #define LLVM_DEBUGINFO_DWARFDIE_H
      12             : 
      13             : #include "llvm/ADT/ArrayRef.h"
      14             : #include "llvm/ADT/Optional.h"
      15             : #include "llvm/ADT/iterator.h"
      16             : #include "llvm/ADT/iterator_range.h"
      17             : #include "llvm/BinaryFormat/Dwarf.h"
      18             : #include "llvm/DebugInfo/DIContext.h"
      19             : #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
      20             : #include "llvm/DebugInfo/DWARF/DWARFAttribute.h"
      21             : #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
      22             : #include <cassert>
      23             : #include <cstdint>
      24             : #include <iterator>
      25             : 
      26             : namespace llvm {
      27             : 
      28             : class DWARFUnit;
      29             : class raw_ostream;
      30             : 
      31             : //===----------------------------------------------------------------------===//
      32             : /// Utility class that carries the DWARF compile/type unit and the debug info
      33             : /// entry in an object.
      34             : ///
      35             : /// When accessing information from a debug info entry we always need to DWARF
      36             : /// compile/type unit in order to extract the info correctly as some information
      37             : /// is relative to the compile/type unit. Prior to this class the DWARFUnit and
      38             : /// the DWARFDebugInfoEntry was passed around separately and there was the
      39             : /// possibility for error if the wrong DWARFUnit was used to extract a unit
      40             : /// relative offset. This class helps to ensure that this doesn't happen and
      41             : /// also simplifies the attribute extraction calls by not having to specify the
      42             : /// DWARFUnit for each call.
      43             : class DWARFDie {
      44             :   DWARFUnit *U = nullptr;
      45             :   const DWARFDebugInfoEntry *Die = nullptr;
      46             : 
      47             : public:
      48         123 :   DWARFDie() = default;
      49        1412 :   DWARFDie(DWARFUnit *Unit, const DWARFDebugInfoEntry *D) : U(Unit), Die(D) {}
      50             : 
      51      271606 :   bool isValid() const { return U && Die; }
      52       82230 :   explicit operator bool() const { return isValid(); }
      53           0 :   const DWARFDebugInfoEntry *getDebugInfoEntry() const { return Die; }
      54           0 :   DWARFUnit *getDwarfUnit() const { return U; }
      55             : 
      56             :   /// Get the abbreviation declaration for this DIE.
      57             :   ///
      58             :   /// \returns the abbreviation declaration or NULL for null tags.
      59           0 :   const DWARFAbbreviationDeclaration *getAbbreviationDeclarationPtr() const {
      60             :     assert(isValid() && "must check validity prior to calling");
      61      103286 :     return Die->getAbbreviationDeclarationPtr();
      62             :   }
      63             : 
      64             :   /// Get the absolute offset into the debug info or types section.
      65             :   ///
      66             :   /// \returns the DIE offset or -1U if invalid.
      67           0 :   uint32_t getOffset() const {
      68             :     assert(isValid() && "must check validity prior to calling");
      69      105875 :     return Die->getOffset();
      70             :   }
      71             : 
      72             :   dwarf::Tag getTag() const {
      73       47873 :     auto AbbrevDecl = getAbbreviationDeclarationPtr();
      74       59431 :     if (AbbrevDecl)
      75       54566 :       return AbbrevDecl->getTag();
      76             :     return dwarf::DW_TAG_null;
      77             :   }
      78             : 
      79           0 :   bool hasChildren() const {
      80             :     assert(isValid() && "must check validity prior to calling");
      81        2012 :     return Die->hasChildren();
      82             :   }
      83             : 
      84             :   /// Returns true for a valid DIE that terminates a sibling chain.
      85        7668 :   bool isNULL() const { return getAbbreviationDeclarationPtr() == nullptr; }
      86             : 
      87             :   /// Returns true if DIE represents a subprogram (not inlined).
      88             :   bool isSubprogramDIE() const;
      89             : 
      90             :   /// Returns true if DIE represents a subprogram or an inlined subroutine.
      91             :   bool isSubroutineDIE() const;
      92             : 
      93             :   /// Get the parent of this DIE object.
      94             :   ///
      95             :   /// \returns a valid DWARFDie instance if this object has a parent or an
      96             :   /// invalid DWARFDie instance if it doesn't.
      97             :   DWARFDie getParent() const;
      98             : 
      99             :   /// Get the sibling of this DIE object.
     100             :   ///
     101             :   /// \returns a valid DWARFDie instance if this object has a sibling or an
     102             :   /// invalid DWARFDie instance if it doesn't.
     103             :   DWARFDie getSibling() const;
     104             : 
     105             :   /// Get the previous sibling of this DIE object.
     106             :   ///
     107             :   /// \returns a valid DWARFDie instance if this object has a sibling or an
     108             :   /// invalid DWARFDie instance if it doesn't.
     109             :   DWARFDie getPreviousSibling() const;
     110             : 
     111             :   /// Get the first child of this DIE object.
     112             :   ///
     113             :   /// \returns a valid DWARFDie instance if this object has children or an
     114             :   /// invalid DWARFDie instance if it doesn't.
     115             :   DWARFDie getFirstChild() const;
     116             : 
     117             :   /// Get the last child of this DIE object.
     118             :   ///
     119             :   /// \returns a valid null DWARFDie instance if this object has children or an
     120             :   /// invalid DWARFDie instance if it doesn't.
     121             :   DWARFDie getLastChild() const;
     122             : 
     123             :   /// Dump the DIE and all of its attributes to the supplied stream.
     124             :   ///
     125             :   /// \param OS the stream to use for output.
     126             :   /// \param indent the number of characters to indent each line that is output.
     127             :   void dump(raw_ostream &OS, unsigned indent = 0,
     128             :             DIDumpOptions DumpOpts = DIDumpOptions()) const;
     129             : 
     130             :   /// Convenience zero-argument overload for debugging.
     131             :   LLVM_DUMP_METHOD void dump() const;
     132             : 
     133             :   /// Extract the specified attribute from this DIE.
     134             :   ///
     135             :   /// Extract an attribute value from this DIE only. This call doesn't look
     136             :   /// for the attribute value in any DW_AT_specification or
     137             :   /// DW_AT_abstract_origin referenced DIEs.
     138             :   ///
     139             :   /// \param Attr the attribute to extract.
     140             :   /// \returns an optional DWARFFormValue that will have the form value if the
     141             :   /// attribute was successfully extracted.
     142             :   Optional<DWARFFormValue> find(dwarf::Attribute Attr) const;
     143             : 
     144             :   /// Extract the first value of any attribute in Attrs from this DIE.
     145             :   ///
     146             :   /// Extract the first attribute that matches from this DIE only. This call
     147             :   /// doesn't look for the attribute value in any DW_AT_specification or
     148             :   /// DW_AT_abstract_origin referenced DIEs. The attributes will be searched
     149             :   /// linearly in the order they are specified within Attrs.
     150             :   ///
     151             :   /// \param Attrs an array of DWARF attribute to look for.
     152             :   /// \returns an optional that has a valid DWARFFormValue for the first
     153             :   /// matching attribute in Attrs, or None if none of the attributes in Attrs
     154             :   /// exist in this DIE.
     155             :   Optional<DWARFFormValue> find(ArrayRef<dwarf::Attribute> Attrs) const;
     156             : 
     157             :   /// Extract the first value of any attribute in Attrs from this DIE and
     158             :   /// recurse into any DW_AT_specification or DW_AT_abstract_origin referenced
     159             :   /// DIEs.
     160             :   ///
     161             :   /// \param Attrs an array of DWARF attribute to look for.
     162             :   /// \returns an optional that has a valid DWARFFormValue for the first
     163             :   /// matching attribute in Attrs, or None if none of the attributes in Attrs
     164             :   /// exist in this DIE or in any DW_AT_specification or DW_AT_abstract_origin
     165             :   /// DIEs.
     166             :   Optional<DWARFFormValue>
     167             :   findRecursively(ArrayRef<dwarf::Attribute> Attrs) const;
     168             : 
     169             :   /// Extract the specified attribute from this DIE as the referenced DIE.
     170             :   ///
     171             :   /// Regardless of the reference type, return the correct DWARFDie instance if
     172             :   /// the attribute exists. The returned DWARFDie object might be from another
     173             :   /// DWARFUnit, but that is all encapsulated in the new DWARFDie object.
     174             :   ///
     175             :   /// Extract an attribute value from this DIE only. This call doesn't look
     176             :   /// for the attribute value in any DW_AT_specification or
     177             :   /// DW_AT_abstract_origin referenced DIEs.
     178             :   ///
     179             :   /// \param Attr the attribute to extract.
     180             :   /// \returns a valid DWARFDie instance if the attribute exists, or an invalid
     181             :   /// DWARFDie object if it doesn't.
     182             :   DWARFDie getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const;
     183             : 
     184             :   /// Extract the range base attribute from this DIE as absolute section offset.
     185             :   ///
     186             :   /// This is a utility function that checks for either the DW_AT_rnglists_base
     187             :   /// or DW_AT_GNU_ranges_base attribute.
     188             :   ///
     189             :   /// \returns anm optional absolute section offset value for the attribute.
     190             :   Optional<uint64_t> getRangesBaseAttribute() const;
     191             : 
     192             :   /// Get the DW_AT_high_pc attribute value as an address.
     193             :   ///
     194             :   /// In DWARF version 4 and later the high PC can be encoded as an offset from
     195             :   /// the DW_AT_low_pc. This function takes care of extracting the value as an
     196             :   /// address or offset and adds it to the low PC if needed and returns the
     197             :   /// value as an optional in case the DIE doesn't have a DW_AT_high_pc
     198             :   /// attribute.
     199             :   ///
     200             :   /// \param LowPC the low PC that might be needed to calculate the high PC.
     201             :   /// \returns an optional address value for the attribute.
     202             :   Optional<uint64_t> getHighPC(uint64_t LowPC) const;
     203             : 
     204             :   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
     205             :   /// Returns true if both attributes are present.
     206             :   bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
     207             :                        uint64_t &SectionIndex) const;
     208             : 
     209             :   /// Get the address ranges for this DIE.
     210             :   ///
     211             :   /// Get the hi/low PC range if both attributes are available or exrtracts the
     212             :   /// non-contiguous address ranges from the DW_AT_ranges attribute.
     213             :   ///
     214             :   /// Extracts the range information from this DIE only. This call doesn't look
     215             :   /// for the range in any DW_AT_specification or DW_AT_abstract_origin DIEs.
     216             :   ///
     217             :   /// \returns a address range vector that might be empty if no address range
     218             :   /// information is available.
     219             :   Expected<DWARFAddressRangesVector> getAddressRanges() const;
     220             : 
     221             :   /// Get all address ranges for any DW_TAG_subprogram DIEs in this DIE or any
     222             :   /// of its children.
     223             :   ///
     224             :   /// Get the hi/low PC range if both attributes are available or exrtracts the
     225             :   /// non-contiguous address ranges from the DW_AT_ranges attribute for this DIE
     226             :   /// and all children.
     227             :   ///
     228             :   /// \param Ranges the addres range vector to fill in.
     229             :   void collectChildrenAddressRanges(DWARFAddressRangesVector &Ranges) const;
     230             : 
     231             :   bool addressRangeContainsAddress(const uint64_t Address) const;
     232             : 
     233             :   /// If a DIE represents a subprogram (or inlined subroutine), returns its
     234             :   /// mangled name (or short name, if mangled is missing). This name may be
     235             :   /// fetched from specification or abstract origin for this subprogram.
     236             :   /// Returns null if no name is found.
     237             :   const char *getSubroutineName(DINameKind Kind) const;
     238             : 
     239             :   /// Return the DIE name resolving DW_AT_sepcification or DW_AT_abstract_origin
     240             :   /// references if necessary. Returns null if no name is found.
     241             :   const char *getName(DINameKind Kind) const;
     242             : 
     243             :   /// Returns the declaration line (start line) for a DIE, assuming it specifies
     244             :   /// a subprogram. This may be fetched from specification or abstract origin
     245             :   /// for this subprogram by resolving DW_AT_sepcification or
     246             :   /// DW_AT_abstract_origin references if necessary.
     247             :   uint64_t getDeclLine() const;
     248             : 
     249             :   /// Retrieves values of DW_AT_call_file, DW_AT_call_line and DW_AT_call_column
     250             :   /// from DIE (or zeroes if they are missing). This function looks for
     251             :   /// DW_AT_call attributes in this DIE only, it will not resolve the attribute
     252             :   /// values in any DW_AT_specification or DW_AT_abstract_origin DIEs.
     253             :   /// \param CallFile filled in with non-zero if successful, zero if there is no
     254             :   /// DW_AT_call_file attribute in this DIE.
     255             :   /// \param CallLine filled in with non-zero if successful, zero if there is no
     256             :   /// DW_AT_call_line attribute in this DIE.
     257             :   /// \param CallColumn filled in with non-zero if successful, zero if there is
     258             :   /// no DW_AT_call_column attribute in this DIE.
     259             :   /// \param CallDiscriminator filled in with non-zero if successful, zero if
     260             :   /// there is no DW_AT_GNU_discriminator attribute in this DIE.
     261             :   void getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
     262             :                       uint32_t &CallColumn, uint32_t &CallDiscriminator) const;
     263             : 
     264             :   class attribute_iterator;
     265             : 
     266             :   /// Get an iterator range to all attributes in the current DIE only.
     267             :   ///
     268             :   /// \returns an iterator range for the attributes of the current DIE.
     269             :   iterator_range<attribute_iterator> attributes() const;
     270             : 
     271             :   class iterator;
     272             : 
     273             :   iterator begin() const;
     274             :   iterator end() const;
     275             : 
     276             :   std::reverse_iterator<iterator> rbegin() const;
     277             :   std::reverse_iterator<iterator> rend() const;
     278             : 
     279             :   iterator_range<iterator> children() const;
     280             : };
     281             : 
     282             : class DWARFDie::attribute_iterator
     283             :     : public iterator_facade_base<attribute_iterator, std::forward_iterator_tag,
     284             :                                   const DWARFAttribute> {
     285             :   /// The DWARF DIE we are extracting attributes from.
     286             :   DWARFDie Die;
     287             :   /// The value vended to clients via the operator*() or operator->().
     288             :   DWARFAttribute AttrValue;
     289             :   /// The attribute index within the abbreviation declaration in Die.
     290             :   uint32_t Index;
     291             : 
     292             :   friend bool operator==(const attribute_iterator &LHS,
     293             :                          const attribute_iterator &RHS);
     294             : 
     295             :   /// Update the attribute index and attempt to read the attribute value. If the
     296             :   /// attribute is able to be read, update AttrValue and the Index member
     297             :   /// variable. If the attribute value is not able to be read, an appropriate
     298             :   /// error will be set if the Err member variable is non-NULL and the iterator
     299             :   /// will be set to the end value so iteration stops.
     300             :   void updateForIndex(const DWARFAbbreviationDeclaration &AbbrDecl, uint32_t I);
     301             : 
     302             : public:
     303             :   attribute_iterator() = delete;
     304             :   explicit attribute_iterator(DWARFDie D, bool End);
     305             : 
     306             :   attribute_iterator &operator++();
     307             :   attribute_iterator &operator--();
     308             :   explicit operator bool() const { return AttrValue.isValid(); }
     309             :   const DWARFAttribute &operator*() const { return AttrValue; }
     310             : };
     311             : 
     312           0 : inline bool operator==(const DWARFDie::attribute_iterator &LHS,
     313             :                        const DWARFDie::attribute_iterator &RHS) {
     314           0 :   return LHS.Index == RHS.Index;
     315             : }
     316             : 
     317             : inline bool operator!=(const DWARFDie::attribute_iterator &LHS,
     318             :                        const DWARFDie::attribute_iterator &RHS) {
     319        2941 :   return !(LHS == RHS);
     320             : }
     321             : 
     322             : inline bool operator==(const DWARFDie &LHS, const DWARFDie &RHS) {
     323       11308 :   return LHS.getDebugInfoEntry() == RHS.getDebugInfoEntry() &&
     324        4714 :          LHS.getDwarfUnit() == RHS.getDwarfUnit();
     325             : }
     326             : 
     327             : inline bool operator!=(const DWARFDie &LHS, const DWARFDie &RHS) {
     328             :   return !(LHS == RHS);
     329             : }
     330             : 
     331             : inline bool operator<(const DWARFDie &LHS, const DWARFDie &RHS) {
     332         740 :   return LHS.getOffset() < RHS.getOffset();
     333             : }
     334             : 
     335             : class DWARFDie::iterator
     336             :     : public iterator_facade_base<iterator, std::bidirectional_iterator_tag,
     337             :                                   const DWARFDie> {
     338             :   DWARFDie Die;
     339             : 
     340             :   friend std::reverse_iterator<llvm::DWARFDie::iterator>;
     341             :   friend bool operator==(const DWARFDie::iterator &LHS,
     342             :                          const DWARFDie::iterator &RHS);
     343             : 
     344             : public:
     345             :   iterator() = default;
     346             : 
     347             :   explicit iterator(DWARFDie D) : Die(D) {}
     348             : 
     349             :   iterator &operator++() {
     350        4320 :     Die = Die.getSibling();
     351             :     return *this;
     352             :   }
     353             : 
     354             :   iterator &operator--() {
     355           3 :     Die = Die.getPreviousSibling();
     356             :     return *this;
     357             :   }
     358             : 
     359             :   const DWARFDie &operator*() const { return Die; }
     360             : };
     361             : 
     362             : inline bool operator==(const DWARFDie::iterator &LHS,
     363             :                        const DWARFDie::iterator &RHS) {
     364             :   return LHS.Die == RHS.Die;
     365             : }
     366             : 
     367             : inline bool operator!=(const DWARFDie::iterator &LHS,
     368             :                        const DWARFDie::iterator &RHS) {
     369             :   return !(LHS == RHS);
     370             : }
     371             : 
     372             : // These inline functions must follow the DWARFDie::iterator definition above
     373             : // as they use functions from that class.
     374             : inline DWARFDie::iterator DWARFDie::begin() const {
     375        4653 :   return iterator(getFirstChild());
     376             : }
     377             : 
     378             : inline DWARFDie::iterator DWARFDie::end() const {
     379        4654 :   return iterator(getLastChild());
     380             : }
     381             : 
     382        4115 : inline iterator_range<DWARFDie::iterator> DWARFDie::children() const {
     383        4115 :   return make_range(begin(), end());
     384             : }
     385             : 
     386             : } // end namespace llvm
     387             : 
     388             : namespace std {
     389             : 
     390             : template <>
     391             : class reverse_iterator<llvm::DWARFDie::iterator>
     392             :     : public llvm::iterator_facade_base<
     393             :           reverse_iterator<llvm::DWARFDie::iterator>,
     394             :           bidirectional_iterator_tag, const llvm::DWARFDie> {
     395             : 
     396             : private:
     397             :   llvm::DWARFDie Die;
     398             :   bool AtEnd;
     399             : 
     400             : public:
     401         987 :   reverse_iterator(llvm::DWARFDie::iterator It)
     402         987 :       : Die(It.Die), AtEnd(!It.Die.getPreviousSibling()) {
     403         987 :     if (!AtEnd)
     404         494 :       Die = Die.getPreviousSibling();
     405         987 :   }
     406             : 
     407        1641 :   reverse_iterator<llvm::DWARFDie::iterator> &operator++() {
     408             :     assert(!AtEnd && "Incrementing rend");
     409        1641 :     llvm::DWARFDie D = Die.getPreviousSibling();
     410             :     if (D)
     411        1147 :       Die = D;
     412             :     else
     413         494 :       AtEnd = true;
     414        1641 :     return *this;
     415             :   }
     416             : 
     417             :   reverse_iterator<llvm::DWARFDie::iterator> &operator--() {
     418           3 :     if (AtEnd) {
     419           1 :       AtEnd = false;
     420             :       return *this;
     421             :     }
     422           2 :     Die = Die.getSibling();
     423             :     assert(!Die.isNULL() && "Decrementing rbegin");
     424             :     return *this;
     425             :   }
     426             : 
     427             :   const llvm::DWARFDie &operator*() const {
     428             :     assert(Die.isValid());
     429             :     return Die;
     430             :   }
     431             : 
     432             :   // FIXME: We should be able to specify the equals operator as a friend, but
     433             :   //        that causes the compiler to think the operator overload is ambiguous
     434             :   //        with the friend declaration and the actual definition as candidates.
     435             :   bool equals(const reverse_iterator<llvm::DWARFDie::iterator> &RHS) const {
     436         985 :     return Die == RHS.Die && AtEnd == RHS.AtEnd;
     437             :   }
     438             : };
     439             : 
     440             : } // namespace std
     441             : 
     442             : namespace llvm {
     443             : 
     444             : inline bool operator==(const std::reverse_iterator<DWARFDie::iterator> &LHS,
     445             :                        const std::reverse_iterator<DWARFDie::iterator> &RHS) {
     446             :   return LHS.equals(RHS);
     447             : }
     448             : 
     449             : inline bool operator!=(const std::reverse_iterator<DWARFDie::iterator> &LHS,
     450             :                        const std::reverse_iterator<DWARFDie::iterator> &RHS) {
     451             :   return !(LHS == RHS);
     452             : }
     453             : 
     454           3 : inline std::reverse_iterator<DWARFDie::iterator> DWARFDie::rbegin() const {
     455           3 :   return llvm::make_reverse_iterator(end());
     456             : }
     457             : 
     458           2 : inline std::reverse_iterator<DWARFDie::iterator> DWARFDie::rend() const {
     459           2 :   return llvm::make_reverse_iterator(begin());
     460             : }
     461             : 
     462             : } // end namespace llvm
     463             : 
     464             : #endif // LLVM_DEBUGINFO_DWARFDIE_H

Generated by: LCOV version 1.13