[llvm] r289565 - Make a DWARFDIE class that can help avoid using the wrong DWARFUnit when extracting attributes
Greg Clayton via llvm-commits
llvm-commits at lists.llvm.org
Tue Dec 13 10:25:20 PST 2016
Author: gclayton
Date: Tue Dec 13 12:25:19 2016
New Revision: 289565
URL: http://llvm.org/viewvc/llvm-project?rev=289565&view=rev
Log:
Make a DWARFDIE class that can help avoid using the wrong DWARFUnit when extracting attributes
Many places pass around a DWARFDebugInfoEntryMinimal and a DWARFUnit. It is easy to get things wrong by using the wrong DWARFUnit with a DWARFDebugInfoEntryMinimal. This patch creates a DWARFDie class that contains the DWARFUnit and DWARFDebugInfoEntryMinimal objects so that they can't get out of sync. All attribute extraction has been moved out of DWARFDebugInfoEntryMinimal and into DWARFDie. DWARFDebugInfoEntryMinimal was also renamed to DWARFDebugInfoEntry.
DWARFDie objects are temporary objects that are used by clients and contain 2 pointers that you always need to have anyway. Keeping them grouped will avoid errors and simplify many of the attribute extracting APIs by not having to pass in a DWARFUnit.
Differential Revision: https://reviews.llvm.org/D27634
Added:
llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h
llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp
Modified:
llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h
llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h
llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt
llvm/trunk/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp
llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp
llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp
llvm/trunk/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp
llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp
llvm/trunk/tools/dsymutil/DwarfLinker.cpp
llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
llvm/trunk/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
Modified: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h (original)
+++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h Tue Dec 13 12:25:19 2016
@@ -26,8 +26,8 @@ class DWARFContext;
class DWARFFormValue;
struct DWARFDebugInfoEntryInlinedChain;
-/// DWARFDebugInfoEntryMinimal - A DIE with only the minimum required data.
-class DWARFDebugInfoEntryMinimal {
+/// DWARFDebugInfoEntry - A DIE with only the minimum required data.
+class DWARFDebugInfoEntry {
/// Offset within the .debug_info of the start of this entry.
uint32_t Offset;
@@ -36,15 +36,9 @@ class DWARFDebugInfoEntryMinimal {
const DWARFAbbreviationDeclaration *AbbrevDecl;
public:
- DWARFDebugInfoEntryMinimal()
+ DWARFDebugInfoEntry()
: Offset(0), SiblingIdx(0), AbbrevDecl(nullptr) {}
- void dump(raw_ostream &OS, DWARFUnit *u, unsigned recurseDepth,
- unsigned indent = 0) const;
- void dumpAttribute(raw_ostream &OS, DWARFUnit *u, uint32_t *offset_ptr,
- dwarf::Attribute attr, dwarf::Form form,
- unsigned indent = 0) const;
-
/// Extracts a debug info entry, which is a child of a given unit,
/// starting at a given offset. If DIE can't be extracted, returns false and
/// doesn't change OffsetPtr.
@@ -53,35 +47,23 @@ public:
bool extractFast(const DWARFUnit &U, uint32_t *OffsetPtr,
const DataExtractor &DebugInfoData, uint32_t UEndOffset);
- dwarf::Tag getTag() const {
- return AbbrevDecl ? AbbrevDecl->getTag() : dwarf::DW_TAG_null;
- }
-
- bool isNULL() const { return AbbrevDecl == nullptr; }
-
- /// Returns true if DIE represents a subprogram (not inlined).
- bool isSubprogramDIE() const;
- /// Returns true if DIE represents a subprogram or an inlined
- /// subroutine.
- bool isSubroutineDIE() const;
-
uint32_t getOffset() const { return Offset; }
- bool hasChildren() const { return !isNULL() && AbbrevDecl->hasChildren(); }
+ bool hasChildren() const { return AbbrevDecl && AbbrevDecl->hasChildren(); }
// We know we are kept in a vector of contiguous entries, so we know
// our sibling will be some index after "this".
- const DWARFDebugInfoEntryMinimal *getSibling() const {
+ const DWARFDebugInfoEntry *getSibling() const {
return SiblingIdx > 0 ? this + SiblingIdx : nullptr;
}
// We know we are kept in a vector of contiguous entries, so we know
// we don't need to store our child pointer, if we have a child it will
// be the next entry in the list...
- const DWARFDebugInfoEntryMinimal *getFirstChild() const {
+ const DWARFDebugInfoEntry *getFirstChild() const {
return hasChildren() ? this + 1 : nullptr;
}
- void setSibling(const DWARFDebugInfoEntryMinimal *Sibling) {
+ void setSibling(const DWARFDebugInfoEntry *Sibling) {
if (Sibling) {
// We know we are kept in a vector of contiguous entries, so we know
// our sibling will be some index after "this".
@@ -93,81 +75,6 @@ public:
const DWARFAbbreviationDeclaration *getAbbreviationDeclarationPtr() const {
return AbbrevDecl;
}
-
- bool getAttributeValue(const DWARFUnit *U, dwarf::Attribute Attr,
- DWARFFormValue &FormValue) const;
-
- const char *getAttributeValueAsString(const DWARFUnit *U,
- dwarf::Attribute Attr,
- const char *FailValue) const;
-
- uint64_t getAttributeValueAsAddress(const DWARFUnit *U,
- dwarf::Attribute Attr,
- uint64_t FailValue) const;
-
- int64_t getAttributeValueAsSignedConstant(const DWARFUnit *U,
- dwarf::Attribute Attr,
- int64_t FailValue) const;
-
- uint64_t getAttributeValueAsUnsignedConstant(const DWARFUnit *U,
- dwarf::Attribute Attr,
- uint64_t FailValue) const;
-
- uint64_t getAttributeValueAsReference(const DWARFUnit *U,
- dwarf::Attribute Attr,
- uint64_t FailValue) const;
-
- uint64_t getAttributeValueAsSectionOffset(const DWARFUnit *U,
- dwarf::Attribute Attr,
- uint64_t FailValue) const;
-
- uint64_t getRangesBaseAttribute(const DWARFUnit *U, uint64_t FailValue) const;
-
- /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
- /// Returns true if both attributes are present.
- bool getLowAndHighPC(const DWARFUnit *U, uint64_t &LowPC,
- uint64_t &HighPC) const;
-
- DWARFAddressRangesVector getAddressRanges(const DWARFUnit *U) const;
-
- void collectChildrenAddressRanges(const DWARFUnit *U,
- DWARFAddressRangesVector &Ranges) const;
-
- bool addressRangeContainsAddress(const DWARFUnit *U,
- const uint64_t Address) const;
-
- /// If a DIE represents a subprogram (or inlined subroutine),
- /// returns its mangled name (or short name, if mangled is missing).
- /// This name may be fetched from specification or abstract origin
- /// for this subprogram. Returns null if no name is found.
- const char *getSubroutineName(const DWARFUnit *U, DINameKind Kind) const;
-
- /// Return the DIE name resolving DW_AT_sepcification or
- /// DW_AT_abstract_origin references if necessary.
- /// Returns null if no name is found.
- const char *getName(const DWARFUnit *U, DINameKind Kind) const;
-
- /// Retrieves values of DW_AT_call_file, DW_AT_call_line and
- /// DW_AT_call_column from DIE (or zeroes if they are missing).
- void getCallerFrame(const DWARFUnit *U, uint32_t &CallFile,
- uint32_t &CallLine, uint32_t &CallColumn) const;
-
- /// Get inlined chain for a given address, rooted at the current DIE.
- /// Returns empty chain if address is not contained in address range
- /// of current DIE.
- DWARFDebugInfoEntryInlinedChain
- getInlinedChainForAddress(const DWARFUnit *U, const uint64_t Address) const;
-};
-
-/// DWARFDebugInfoEntryInlinedChain - represents a chain of inlined_subroutine
-/// DIEs, (possibly ending with subprogram DIE), all of which are contained
-/// in some concrete inlined instance tree. Address range for each DIE
-/// (except the last DIE) in this chain is contained in address
-/// range for next DIE in the chain.
-struct DWARFDebugInfoEntryInlinedChain {
- DWARFDebugInfoEntryInlinedChain() : U(nullptr) {}
- SmallVector<DWARFDebugInfoEntryMinimal, 4> DIEs;
- const DWARFUnit *U;
};
}
Added: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h?rev=289565&view=auto
==============================================================================
--- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h (added)
+++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h Tue Dec 13 12:25:19 2016
@@ -0,0 +1,300 @@
+//===-- DWARFDie.h --------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_DEBUGINFO_DWARFDIE_H
+#define LLVM_LIB_DEBUGINFO_DWARFDIE_H
+
+#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+
+namespace llvm {
+
+class DWARFUnit;
+class DWARFDebugInfoEntry;
+class raw_ostream;
+
+//===----------------------------------------------------------------------===//
+/// Utility class that carries the DWARF compile/type unit and the debug info
+/// entry in an object.
+///
+/// When accessing information from a debug info entry we always need to DWARF
+/// compile/type unit in order to extract the info correctly as some information
+/// is relative to the compile/type unit. Prior to this class the DWARFUnit and
+/// the DWARFDebugInfoEntry was passed around separately and there was the
+/// possibility for error if the wrong DWARFUnit was used to extract a unit
+/// relative offset. This class helps to ensure that this doesn't happen and
+/// also simplifies the attribute extraction calls by not having to specify the
+/// DWARFUnit for each call.
+class DWARFDie {
+ DWARFUnit *U;
+ const DWARFDebugInfoEntry *Die;
+public:
+ DWARFDie() : U(nullptr), Die(nullptr) {}
+ DWARFDie(DWARFUnit *Unit, const DWARFDebugInfoEntry * D) : U(Unit), Die(D) {}
+
+ bool isValid() const { return U && Die; }
+ explicit operator bool() const { return isValid(); }
+ const DWARFDebugInfoEntry *getDebugInfoEntry() const { return Die; }
+ DWARFUnit *getDwarfUnit() const { return U; }
+
+
+ /// Get the abbreviation declaration for this DIE.
+ ///
+ /// \returns the abbreviation declaration or NULL for null tags.
+ const DWARFAbbreviationDeclaration *getAbbreviationDeclarationPtr() const {
+ assert(isValid() && "must check validity prior to calling");
+ return Die->getAbbreviationDeclarationPtr();
+ }
+
+ /// Get the absolute offset into the debug info or types section.
+ ///
+ /// \returns the DIE offset or -1U if invalid.
+ uint32_t getOffset() const {
+ assert(isValid() && "must check validity prior to calling");
+ return Die->getOffset();
+ }
+
+ dwarf::Tag getTag() const {
+ auto AbbrevDecl = getAbbreviationDeclarationPtr();
+ if (AbbrevDecl)
+ return AbbrevDecl->getTag();
+ return dwarf::DW_TAG_null;
+ }
+
+ bool hasChildren() const {
+ assert(isValid() && "must check validity prior to calling");
+ return Die->hasChildren();
+ }
+
+ /// Returns true for a valid DIE that terminates a sibling chain.
+ bool isNULL() const {
+ return getAbbreviationDeclarationPtr() == nullptr;
+ }
+ /// Returns true if DIE represents a subprogram (not inlined).
+ bool isSubprogramDIE() const;
+
+ /// Returns true if DIE represents a subprogram or an inlined subroutine.
+ bool isSubroutineDIE() const;
+
+
+ /// Get the silbing of this DIE object.
+ ///
+ /// \returns a valid DWARFDie instance if this object has a sibling or an
+ /// invalid DWARFDie instance if it doesn't.
+ DWARFDie getSibling() const {
+ assert(isValid() && "must check validity prior to calling");
+ return DWARFDie(U, Die->getSibling());
+ }
+
+ /// Get the first child of this DIE object.
+ ///
+ /// \returns a valid DWARFDie instance if this object has children or an
+ /// invalid DWARFDie instance if it doesn't.
+ DWARFDie getFirstChild() const {
+ assert(isValid() && "must check validity prior to calling");
+ return DWARFDie(U, Die->getFirstChild());
+ }
+
+ /// Dump the DIE and all of its attributes to the supplied stream.
+ ///
+ /// \param OS the stream to use for output.
+ /// \param recurseDepth the depth to recurse to when dumping this DIE and its
+ /// children.
+ /// \param indent the number of characters to indent each line that is output.
+ void dump(raw_ostream &OS, unsigned recurseDepth, unsigned indent = 0) const;
+
+ /// Extract the specified attribute from this DIE.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FormValue contains the attribute value if true is returned.
+ /// \returns true if the attribute was extracted from this DIE.
+ bool getAttributeValue(dwarf::Attribute Attr,
+ DWARFFormValue &FormValue) const;
+
+ /// Extract the specified attribute from this DIE as a C string.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the NULL terminated C string value owned by the DWARF section
+ /// that contains the string or FailValue if the attribute doesn't exist or
+ /// if the attribute's form isn't a form that describes an string.
+ const char *getAttributeValueAsString(dwarf::Attribute Attr,
+ const char *FailValue) const;
+
+ /// Extract the specified attribute from this DIE as an address.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the address value of the attribute or FailValue if the
+ /// attribute doesn't exist or if the attribute's form isn't a form that
+ /// describes an address.
+ uint64_t getAttributeValueAsAddress(dwarf::Attribute Attr,
+ uint64_t FailValue) const;
+
+ /// Extract the specified attribute from this DIE as a signed integer.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the signed integer constant value of the attribute or FailValue
+ /// if the attribute doesn't exist or if the attribute's form isn't a form
+ /// that describes a signed integer.
+ int64_t getAttributeValueAsSignedConstant(dwarf::Attribute Attr,
+ int64_t FailValue) const;
+
+ /// Extract the specified attribute from this DIE as an unsigned integer.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the unsigned integer constant value of the attribute or FailValue
+ /// if the attribute doesn't exist or if the attribute's form isn't a form
+ /// that describes an unsigned integer.
+ uint64_t getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr,
+ uint64_t FailValue) const;
+
+ /// Extract the specified attribute from this DIE as absolute DIE Offset.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the unsigned integer constant value of the attribute or FailValue
+ /// if the attribute doesn't exist or if the attribute's form isn't a form
+ /// that describes a reference.
+ uint64_t getAttributeValueAsReference(dwarf::Attribute Attr,
+ uint64_t FailValue) const;
+
+ /// Extract the specified attribute from this DIE as absolute section offset.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \param FailValue the value to return if this DIE doesn't have this
+ /// attribute.
+ /// \returns the unsigned integer constant value of the attribute or FailValue
+ /// if the attribute doesn't exist or if the attribute's form isn't a form
+ /// that describes a section offset.
+ uint64_t getAttributeValueAsSectionOffset(dwarf::Attribute Attr,
+ uint64_t FailValue) const;
+
+ /// Extract the specified attribute from this DIE as the referenced DIE.
+ ///
+ /// Regardless of the reference type, return the correct DWARFDie instance if
+ /// the attribute exists. The returned DWARFDie object might be from another
+ /// DWARFUnit, but that is all encapsulated in the new DWARFDie object.
+ ///
+ /// Extract an attribute value from this DIE only. This call doesn't look
+ /// for the attribute value in any DW_AT_specification or
+ /// DW_AT_abstract_origin referenced DIEs.
+ ///
+ /// \param Attr the attribute to extract.
+ /// \returns a valid DWARFDie instance if the attribute exists, or an invalid
+ /// DWARFDie object if it doesn't.
+ DWARFDie getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const;
+
+ /// Extract the range base attribute from this DIE as absolute section offset.
+ ///
+ /// This is a utility function that checks for either the DW_AT_rnglists_base
+ /// or DW_AT_GNU_ranges_base attribute.
+ ///
+ /// \returns the absolute section offset value of the attribute or FailValue
+ /// if the attribute doesn't exist.
+ uint64_t getRangesBaseAttribute(uint64_t FailValue) const;
+
+ /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
+ /// Returns true if both attributes are present.
+ bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const;
+
+ /// Get the address ranges for this DIE.
+ ///
+ /// Get the hi/low PC range if both attributes are available or exrtracts the
+ /// non-contiguous address ranges from the DW_AT_ranges attribute.
+ ///
+ /// Extracts the range information from this DIE only. This call doesn't look
+ /// for the range in any DW_AT_specification or DW_AT_abstract_origin DIEs.
+ ///
+ /// \returns a address range vector that might be empty if no address range
+ /// information is available.
+ DWARFAddressRangesVector getAddressRanges() const;
+
+ /// Get all address ranges for any DW_TAG_subprogram DIEs in this DIE or any
+ /// of its children.
+ ///
+ /// Get the hi/low PC range if both attributes are available or exrtracts the
+ /// non-contiguous address ranges from the DW_AT_ranges attribute for this DIE
+ /// and all children.
+ ///
+ /// \param Ranges the addres range vector to fill in.
+ void collectChildrenAddressRanges(DWARFAddressRangesVector &Ranges) const;
+
+ bool addressRangeContainsAddress(const uint64_t Address) const;
+
+ /// If a DIE represents a subprogram (or inlined subroutine), returns its
+ /// mangled name (or short name, if mangled is missing). This name may be
+ /// fetched from specification or abstract origin for this subprogram.
+ /// Returns null if no name is found.
+ const char *getSubroutineName(DINameKind Kind) const;
+
+ /// Return the DIE name resolving DW_AT_sepcification or DW_AT_abstract_origin
+ /// references if necessary. Returns null if no name is found.
+ const char *getName(DINameKind Kind) const;
+
+ /// Retrieves values of DW_AT_call_file, DW_AT_call_line and DW_AT_call_column
+ /// from DIE (or zeroes if they are missing). This function looks for
+ /// DW_AT_call attributes in this DIE only, it will not resolve the attribute
+ /// values in any DW_AT_specification or DW_AT_abstract_origin DIEs.
+ /// \param CallFile filled in with non-zero if successful, zero if there is no
+ /// DW_AT_call_file attribute in this DIE.
+ /// \param CallLine filled in with non-zero if successful, zero if there is no
+ /// DW_AT_call_line attribute in this DIE.
+ /// \param CallColumn filled in with non-zero if successful, zero if there is
+ /// no DW_AT_call_column attribute in this DIE.
+ void getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
+ uint32_t &CallColumn) const;
+
+ /// Get inlined chain for a given address, rooted at the current DIE.
+ /// Returns empty chain if address is not contained in address range
+ /// of current DIE.
+ void
+ getInlinedChainForAddress(const uint64_t Address,
+ SmallVectorImpl<DWARFDie> &InlinedChain) const;
+
+};
+
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_DEBUGINFO_DWARFDIE_H
Modified: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h (original)
+++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h Tue Dec 13 12:25:19 2016
@@ -14,6 +14,7 @@
#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
#include "llvm/DebugInfo/DWARF/DWARFSection.h"
#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
@@ -124,7 +125,7 @@ class DWARFUnit {
uint8_t AddrSize;
uint64_t BaseAddr;
// The compile unit debug information entry items.
- std::vector<DWARFDebugInfoEntryMinimal> DieArray;
+ std::vector<DWARFDebugInfoEntry> DieArray;
class DWOHolder {
object::OwningBinary<object::ObjectFile> DWOFile;
@@ -214,9 +215,11 @@ public:
BaseAddr = base_addr;
}
- const DWARFDebugInfoEntryMinimal *getUnitDIE(bool ExtractUnitDIEOnly = true) {
+ DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
extractDIEsIfNeeded(ExtractUnitDIEOnly);
- return DieArray.empty() ? nullptr : &DieArray[0];
+ if (DieArray.empty())
+ return DWARFDie();
+ return DWARFDie(this, &DieArray[0]);
}
const char *getCompilationDir();
@@ -227,7 +230,8 @@ public:
/// getInlinedChainForAddress - fetches inlined chain for a given address.
/// Returns empty chain if there is no subprogram containing address. The
/// chain is valid as long as parsed compile unit DIEs are not cleared.
- DWARFDebugInfoEntryInlinedChain getInlinedChainForAddress(uint64_t Address);
+ void getInlinedChainForAddress(uint64_t Address,
+ SmallVectorImpl<DWARFDie> &InlinedChain);
/// getUnitSection - Return the DWARFUnitSection containing this unit.
const DWARFUnitSectionBase &getUnitSection() const { return UnitSection; }
@@ -245,31 +249,35 @@ public:
/// created by this unit. In other word, it's illegal to call this
/// method on a DIE that isn't accessible by following
/// children/sibling links starting from this unit's getUnitDIE().
- uint32_t getDIEIndex(const DWARFDebugInfoEntryMinimal *DIE) {
+ uint32_t getDIEIndex(const DWARFDie &D) {
+ auto DIE = D.getDebugInfoEntry();
assert(!DieArray.empty() && DIE >= &DieArray[0] &&
DIE < &DieArray[0] + DieArray.size());
return DIE - &DieArray[0];
}
/// \brief Return the DIE object at the given index.
- const DWARFDebugInfoEntryMinimal *getDIEAtIndex(unsigned Index) const {
- assert(Index < DieArray.size());
- return &DieArray[Index];
+ DWARFDie getDIEAtIndex(unsigned Index) {
+ if (Index < DieArray.size())
+ return DWARFDie(this, &DieArray[Index]);
+ return DWARFDie();
}
/// \brief Return the DIE object for a given offset inside the
/// unit's DIE vector.
///
/// The unit needs to have its DIEs extracted for this method to work.
- const DWARFDebugInfoEntryMinimal *getDIEForOffset(uint32_t Offset) {
+ DWARFDie getDIEForOffset(uint32_t Offset) {
extractDIEsIfNeeded(false);
assert(!DieArray.empty());
auto it = std::lower_bound(
DieArray.begin(), DieArray.end(), Offset,
- [](const DWARFDebugInfoEntryMinimal &LHS, uint32_t Offset) {
+ [](const DWARFDebugInfoEntry &LHS, uint32_t Offset) {
return LHS.getOffset() < Offset;
});
- return it == DieArray.end() ? nullptr : &*it;
+ if (it == DieArray.end())
+ return DWARFDie();
+ return DWARFDie(this, &*it);
}
uint32_t getLineTableOffset() const {
@@ -288,7 +296,7 @@ private:
size_t extractDIEsIfNeeded(bool CUDieOnly);
/// extractDIEsToVector - Appends all parsed DIEs to a vector.
void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
- std::vector<DWARFDebugInfoEntryMinimal> &DIEs) const;
+ std::vector<DWARFDebugInfoEntry> &DIEs) const;
/// setDIERelations - We read in all of the DIE entries into our flat list
/// of DIE entries and now we need to go back through all of them and set the
/// parent, sibling and child pointers for quick DIE navigation.
@@ -303,7 +311,7 @@ private:
/// getSubprogramForAddress - Returns subprogram DIE with address range
/// encompassing the provided address. The pointer is alive as long as parsed
/// compile unit DIEs are not cleared.
- const DWARFDebugInfoEntryMinimal *getSubprogramForAddress(uint64_t Address);
+ DWARFDie getSubprogramForAddress(uint64_t Address);
};
}
Modified: llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt Tue Dec 13 12:25:19 2016
@@ -12,6 +12,7 @@ add_llvm_library(LLVMDebugInfoDWARF
DWARFDebugLoc.cpp
DWARFDebugMacro.cpp
DWARFDebugRangeList.cpp
+ DWARFDie.cpp
DWARFFormValue.cpp
DWARFGdbIndex.cpp
DWARFTypeUnit.cpp
Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp Tue Dec 13 12:25:19 2016
@@ -9,7 +9,7 @@
#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
@@ -24,8 +24,8 @@ void DWARFCompileUnit::dump(raw_ostream
<< " (next unit at " << format("0x%08x", getNextUnitOffset())
<< ")\n";
- if (const DWARFDebugInfoEntryMinimal *CU = getUnitDIE(false))
- CU->dump(OS, this, -1U);
+ if (DWARFDie CUDie = getUnitDIE(false))
+ CUDie.dump(OS, -1U);
else
OS << "<compile unit can't be parsed!>\n\n";
}
Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp Tue Dec 13 12:25:19 2016
@@ -156,11 +156,11 @@ void DWARFContext::dump(raw_ostream &OS,
OS << "\n.debug_line contents:\n";
for (const auto &CU : compile_units()) {
savedAddressByteSize = CU->getAddressByteSize();
- const auto *CUDIE = CU->getUnitDIE();
- if (CUDIE == nullptr)
+ auto CUDIE = CU->getUnitDIE();
+ if (!CUDIE)
continue;
- unsigned stmtOffset = CUDIE->getAttributeValueAsSectionOffset(
- CU.get(), DW_AT_stmt_list, -1U);
+ unsigned stmtOffset = CUDIE.getAttributeValueAsSectionOffset(
+ DW_AT_stmt_list, -1U);
if (stmtOffset != -1U) {
DataExtractor lineData(getLineSection().Data, isLittleEndian(),
savedAddressByteSize);
@@ -412,12 +412,12 @@ DWARFContext::getLineTableForUnit(DWARFU
if (!Line)
Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
- const auto *UnitDIE = U->getUnitDIE();
- if (UnitDIE == nullptr)
+ auto UnitDIE = U->getUnitDIE();
+ if (!UnitDIE)
return nullptr;
unsigned stmtOffset =
- UnitDIE->getAttributeValueAsSectionOffset(U, DW_AT_stmt_list, -1U);
+ UnitDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list, -1U);
if (stmtOffset == -1U)
return nullptr; // No line table for this compile unit.
@@ -477,14 +477,12 @@ static bool getFunctionNameForAddress(DW
return false;
// The address may correspond to instruction in some inlined function,
// so we have to build the chain of inlined functions and take the
- // name of the topmost function in it.
- const DWARFDebugInfoEntryInlinedChain &InlinedChain =
- CU->getInlinedChainForAddress(Address);
- if (InlinedChain.DIEs.size() == 0)
+ // name of the topmost function in it.SmallVectorImpl<DWARFDie> &InlinedChain
+ SmallVector<DWARFDie, 4> InlinedChain;
+ CU->getInlinedChainForAddress(Address, InlinedChain);
+ if (InlinedChain.size() == 0)
return false;
- const DWARFDebugInfoEntryMinimal &TopFunctionDIE = InlinedChain.DIEs[0];
- if (const char *Name =
- TopFunctionDIE.getSubroutineName(InlinedChain.U, Kind)) {
+ if (const char *Name = InlinedChain[0].getSubroutineName(Kind)) {
FunctionName = Name;
return true;
}
@@ -559,9 +557,9 @@ DWARFContext::getInliningInfoForAddress(
return InliningInfo;
const DWARFLineTable *LineTable = nullptr;
- const DWARFDebugInfoEntryInlinedChain &InlinedChain =
- CU->getInlinedChainForAddress(Address);
- if (InlinedChain.DIEs.size() == 0) {
+ SmallVector<DWARFDie, 4> InlinedChain;
+ CU->getInlinedChainForAddress(Address, InlinedChain);
+ if (InlinedChain.size() == 0) {
// If there is no DIE for address (e.g. it is in unavailable .dwo file),
// try to at least get file/line info from symbol table.
if (Spec.FLIKind != FileLineInfoKind::None) {
@@ -576,12 +574,11 @@ DWARFContext::getInliningInfoForAddress(
}
uint32_t CallFile = 0, CallLine = 0, CallColumn = 0;
- for (uint32_t i = 0, n = InlinedChain.DIEs.size(); i != n; i++) {
- const DWARFDebugInfoEntryMinimal &FunctionDIE = InlinedChain.DIEs[i];
+ for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
+ DWARFDie &FunctionDIE = InlinedChain[i];
DILineInfo Frame;
// Get function name if necessary.
- if (const char *Name =
- FunctionDIE.getSubroutineName(InlinedChain.U, Spec.FNKind))
+ if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind))
Frame.FunctionName = Name;
if (Spec.FLIKind != FileLineInfoKind::None) {
if (i == 0) {
@@ -603,8 +600,7 @@ DWARFContext::getInliningInfoForAddress(
}
// Get call file/line/column of a current DIE.
if (i + 1 < n) {
- FunctionDIE.getCallerFrame(InlinedChain.U, CallFile, CallLine,
- CallColumn);
+ FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn);
}
}
InliningInfo.addFrame(Frame);
Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp Tue Dec 13 12:25:19 2016
@@ -22,174 +22,13 @@ using namespace llvm;
using namespace dwarf;
using namespace syntax;
-// Small helper to extract a DIE pointed by a reference
-// attribute. It looks up the Unit containing the DIE and calls
-// DIE.extractFast with the right unit. Returns new unit on success,
-// nullptr otherwise.
-static const DWARFUnit *findUnitAndExtractFast(DWARFDebugInfoEntryMinimal &DIE,
- const DWARFUnit *Unit,
- uint32_t *Offset) {
- Unit = Unit->getUnitSection().getUnitForOffset(*Offset);
- return (Unit && DIE.extractFast(*Unit, Offset)) ? Unit : nullptr;
-}
-
-void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, DWARFUnit *u,
- unsigned recurseDepth,
- unsigned indent) const {
- DataExtractor debug_info_data = u->getDebugInfoExtractor();
- uint32_t offset = Offset;
-
- if (debug_info_data.isValidOffset(offset)) {
- uint32_t abbrCode = debug_info_data.getULEB128(&offset);
- WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
-
- if (abbrCode) {
- if (AbbrevDecl) {
- auto tagString = TagString(getTag());
- if (!tagString.empty())
- WithColor(OS, syntax::Tag).get().indent(indent) << tagString;
- else
- WithColor(OS, syntax::Tag).get().indent(indent)
- << format("DW_TAG_Unknown_%x", getTag());
-
- OS << format(" [%u] %c\n", abbrCode,
- AbbrevDecl->hasChildren() ? '*' : ' ');
-
- // Dump all data in the DIE for the attributes.
- for (const auto &AttrSpec : AbbrevDecl->attributes()) {
- dumpAttribute(OS, u, &offset, AttrSpec.Attr, AttrSpec.Form, indent);
- }
-
- const DWARFDebugInfoEntryMinimal *child = getFirstChild();
- if (recurseDepth > 0 && child) {
- while (child) {
- child->dump(OS, u, recurseDepth-1, indent+2);
- child = child->getSibling();
- }
- }
- } else {
- OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
- << abbrCode << '\n';
- }
- } else {
- OS.indent(indent) << "NULL\n";
- }
- }
-}
-
-static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
- OS << " (";
- do {
- uint64_t Shift = countTrailingZeros(Val);
- assert(Shift < 64 && "undefined behavior");
- uint64_t Bit = 1ULL << Shift;
- auto PropName = ApplePropertyString(Bit);
- if (!PropName.empty())
- OS << PropName;
- else
- OS << format("DW_APPLE_PROPERTY_0x%" PRIx64, Bit);
- if (!(Val ^= Bit))
- break;
- OS << ", ";
- } while (true);
- OS << ")";
-}
-
-static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
- unsigned AddressSize, unsigned Indent) {
- if (Ranges.empty())
- return;
-
- for (const auto &Range: Ranges) {
- OS << '\n';
- OS.indent(Indent);
- OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
- AddressSize*2, Range.first,
- AddressSize*2, Range.second);
- }
-}
-
-void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
- DWARFUnit *u,
- uint32_t *offset_ptr,
- dwarf::Attribute attr,
- dwarf::Form form,
- unsigned indent) const {
- const char BaseIndent[] = " ";
- OS << BaseIndent;
- OS.indent(indent+2);
- auto attrString = AttributeString(attr);
- if (!attrString.empty())
- WithColor(OS, syntax::Attribute) << attrString;
- else
- WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", attr);
-
- auto formString = FormEncodingString(form);
- if (!formString.empty())
- OS << " [" << formString << ']';
- else
- OS << format(" [DW_FORM_Unknown_%x]", form);
-
- DWARFFormValue formValue(form);
-
- if (!formValue.extractValue(u->getDebugInfoExtractor(), offset_ptr, u))
- return;
-
- OS << "\t(";
-
- StringRef Name;
- std::string File;
- auto Color = syntax::Enumerator;
- if (attr == DW_AT_decl_file || attr == DW_AT_call_file) {
- Color = syntax::String;
- if (const auto *LT = u->getContext().getLineTableForUnit(u))
- if (LT->getFileNameByIndex(
- formValue.getAsUnsignedConstant().getValue(),
- u->getCompilationDir(),
- DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
- File = '"' + File + '"';
- Name = File;
- }
- } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
- Name = AttributeValueString(attr, *Val);
-
- if (!Name.empty())
- WithColor(OS, Color) << Name;
- else if (attr == DW_AT_decl_line || attr == DW_AT_call_line)
- OS << *formValue.getAsUnsignedConstant();
- else
- formValue.dump(OS);
-
- // We have dumped the attribute raw value. For some attributes
- // having both the raw value and the pretty-printed value is
- // interesting. These attributes are handled below.
- if (attr == DW_AT_specification || attr == DW_AT_abstract_origin) {
- Optional<uint64_t> Ref = formValue.getAsReference();
- if (Ref.hasValue()) {
- uint32_t RefOffset = Ref.getValue();
- DWARFDebugInfoEntryMinimal DIE;
- if (const DWARFUnit *RefU = findUnitAndExtractFast(DIE, u, &RefOffset))
- if (const char *Name = DIE.getName(RefU, DINameKind::LinkageName))
- OS << " \"" << Name << '\"';
- }
- } else if (attr == DW_AT_APPLE_property_attribute) {
- if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
- dumpApplePropertyAttribute(OS, *OptVal);
- } else if (attr == DW_AT_ranges) {
- dumpRanges(OS, getAddressRanges(u), u->getAddressByteSize(),
- sizeof(BaseIndent)+indent+4);
- }
-
- OS << ")\n";
-}
-
-bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit &U,
+bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U,
uint32_t *OffsetPtr) {
DataExtractor DebugInfoData = U.getDebugInfoExtractor();
const uint32_t UEndOffset = U.getNextUnitOffset();
return extractFast(U, OffsetPtr, DebugInfoData, UEndOffset);
}
-bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit &U,
+bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U,
uint32_t *OffsetPtr,
const DataExtractor &DebugInfoData,
uint32_t UEndOffset) {
@@ -231,237 +70,3 @@ bool DWARFDebugInfoEntryMinimal::extract
}
return true;
}
-
-bool DWARFDebugInfoEntryMinimal::isSubprogramDIE() const {
- return getTag() == DW_TAG_subprogram;
-}
-
-bool DWARFDebugInfoEntryMinimal::isSubroutineDIE() const {
- uint32_t Tag = getTag();
- return Tag == DW_TAG_subprogram ||
- Tag == DW_TAG_inlined_subroutine;
-}
-
-bool DWARFDebugInfoEntryMinimal::getAttributeValue(const DWARFUnit *U,
- dwarf::Attribute Attr, DWARFFormValue &FormValue) const {
- if (!AbbrevDecl || !U)
- return false;
- return AbbrevDecl->getAttributeValue(Offset, Attr, *U, FormValue);
-}
-
-const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
- const DWARFUnit *U, dwarf::Attribute Attr,
- const char *FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<const char *> Result = FormValue.getAsCString();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
- const DWARFUnit *U, dwarf::Attribute Attr,
- uint64_t FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<uint64_t> Result = FormValue.getAsAddress();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-int64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSignedConstant(
- const DWARFUnit *U, dwarf::Attribute Attr, int64_t FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<int64_t> Result = FormValue.getAsSignedConstant();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
- const DWARFUnit *U, dwarf::Attribute Attr,
- uint64_t FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
- const DWARFUnit *U, dwarf::Attribute Attr,
- uint64_t FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<uint64_t> Result = FormValue.getAsReference();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSectionOffset(
- const DWARFUnit *U, dwarf::Attribute Attr,
- uint64_t FailValue) const {
- DWARFFormValue FormValue;
- if (!getAttributeValue(U, Attr, FormValue))
- return FailValue;
- Optional<uint64_t> Result = FormValue.getAsSectionOffset();
- return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-uint64_t
-DWARFDebugInfoEntryMinimal::getRangesBaseAttribute(const DWARFUnit *U,
- uint64_t FailValue) const {
- uint64_t Result =
- getAttributeValueAsSectionOffset(U, DW_AT_rnglists_base, -1ULL);
- if (Result != -1ULL)
- return Result;
- return getAttributeValueAsSectionOffset(U, DW_AT_GNU_ranges_base, FailValue);
-}
-
-bool DWARFDebugInfoEntryMinimal::getLowAndHighPC(const DWARFUnit *U,
- uint64_t &LowPC,
- uint64_t &HighPC) const {
- LowPC = getAttributeValueAsAddress(U, DW_AT_low_pc, -1ULL);
- if (LowPC == -1ULL)
- return false;
- HighPC = getAttributeValueAsAddress(U, DW_AT_high_pc, -1ULL);
- if (HighPC == -1ULL) {
- // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case
- // it represents function size.
- HighPC = getAttributeValueAsUnsignedConstant(U, DW_AT_high_pc, -1ULL);
- if (HighPC != -1ULL)
- HighPC += LowPC;
- }
- return (HighPC != -1ULL);
-}
-
-DWARFAddressRangesVector
-DWARFDebugInfoEntryMinimal::getAddressRanges(const DWARFUnit *U) const {
- if (isNULL())
- return DWARFAddressRangesVector();
- // Single range specified by low/high PC.
- uint64_t LowPC, HighPC;
- if (getLowAndHighPC(U, LowPC, HighPC)) {
- return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC));
- }
- // Multiple ranges from .debug_ranges section.
- uint32_t RangesOffset =
- getAttributeValueAsSectionOffset(U, DW_AT_ranges, -1U);
- if (RangesOffset != -1U) {
- DWARFDebugRangeList RangeList;
- if (U->extractRangeList(RangesOffset, RangeList))
- return RangeList.getAbsoluteRanges(U->getBaseAddress());
- }
- return DWARFAddressRangesVector();
-}
-
-void DWARFDebugInfoEntryMinimal::collectChildrenAddressRanges(
- const DWARFUnit *U, DWARFAddressRangesVector& Ranges) const {
- if (isNULL())
- return;
- if (isSubprogramDIE()) {
- const auto &DIERanges = getAddressRanges(U);
- Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end());
- }
-
- const DWARFDebugInfoEntryMinimal *Child = getFirstChild();
- while (Child) {
- Child->collectChildrenAddressRanges(U, Ranges);
- Child = Child->getSibling();
- }
-}
-
-bool DWARFDebugInfoEntryMinimal::addressRangeContainsAddress(
- const DWARFUnit *U, const uint64_t Address) const {
- for (const auto& R : getAddressRanges(U)) {
- if (R.first <= Address && Address < R.second)
- return true;
- }
- return false;
-}
-
-const char *
-DWARFDebugInfoEntryMinimal::getSubroutineName(const DWARFUnit *U,
- DINameKind Kind) const {
- if (!isSubroutineDIE())
- return nullptr;
- return getName(U, Kind);
-}
-
-const char *
-DWARFDebugInfoEntryMinimal::getName(const DWARFUnit *U,
- DINameKind Kind) const {
- if (Kind == DINameKind::None)
- return nullptr;
- // Try to get mangled name only if it was asked for.
- if (Kind == DINameKind::LinkageName) {
- if (const char *name =
- getAttributeValueAsString(U, DW_AT_MIPS_linkage_name, nullptr))
- return name;
- if (const char *name =
- getAttributeValueAsString(U, DW_AT_linkage_name, nullptr))
- return name;
- }
- if (const char *name = getAttributeValueAsString(U, DW_AT_name, nullptr))
- return name;
- // Try to get name from specification DIE.
- uint32_t spec_ref =
- getAttributeValueAsReference(U, DW_AT_specification, -1U);
- if (spec_ref != -1U) {
- DWARFDebugInfoEntryMinimal spec_die;
- if (const DWARFUnit *RefU = findUnitAndExtractFast(spec_die, U, &spec_ref)) {
- if (const char *name = spec_die.getName(RefU, Kind))
- return name;
- }
- }
- // Try to get name from abstract origin DIE.
- uint32_t abs_origin_ref =
- getAttributeValueAsReference(U, DW_AT_abstract_origin, -1U);
- if (abs_origin_ref != -1U) {
- DWARFDebugInfoEntryMinimal abs_origin_die;
- if (const DWARFUnit *RefU = findUnitAndExtractFast(abs_origin_die, U,
- &abs_origin_ref)) {
- if (const char *name = abs_origin_die.getName(RefU, Kind))
- return name;
- }
- }
- return nullptr;
-}
-
-void DWARFDebugInfoEntryMinimal::getCallerFrame(const DWARFUnit *U,
- uint32_t &CallFile,
- uint32_t &CallLine,
- uint32_t &CallColumn) const {
- CallFile = getAttributeValueAsUnsignedConstant(U, DW_AT_call_file, 0);
- CallLine = getAttributeValueAsUnsignedConstant(U, DW_AT_call_line, 0);
- CallColumn = getAttributeValueAsUnsignedConstant(U, DW_AT_call_column, 0);
-}
-
-DWARFDebugInfoEntryInlinedChain
-DWARFDebugInfoEntryMinimal::getInlinedChainForAddress(
- const DWARFUnit *U, const uint64_t Address) const {
- DWARFDebugInfoEntryInlinedChain InlinedChain;
- InlinedChain.U = U;
- if (isNULL())
- return InlinedChain;
- for (const DWARFDebugInfoEntryMinimal *DIE = this; DIE; ) {
- // Append current DIE to inlined chain only if it has correct tag
- // (e.g. it is not a lexical block).
- if (DIE->isSubroutineDIE()) {
- InlinedChain.DIEs.push_back(*DIE);
- }
- // Try to get child which also contains provided address.
- const DWARFDebugInfoEntryMinimal *Child = DIE->getFirstChild();
- while (Child) {
- if (Child->addressRangeContainsAddress(U, Address)) {
- // Assume there is only one such child.
- break;
- }
- Child = Child->getSibling();
- }
- DIE = Child;
- }
- // Reverse the obtained chain to make the root of inlined chain last.
- std::reverse(InlinedChain.DIEs.begin(), InlinedChain.DIEs.end());
- return InlinedChain;
-}
Added: llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp?rev=289565&view=auto
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp (added)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp Tue Dec 13 12:25:19 2016
@@ -0,0 +1,391 @@
+//===-- DWARFDie.cpp ------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "SyntaxHighlighting.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace dwarf;
+using namespace syntax;
+
+namespace {
+ static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
+ OS << " (";
+ do {
+ uint64_t Shift = countTrailingZeros(Val);
+ assert(Shift < 64 && "undefined behavior");
+ uint64_t Bit = 1ULL << Shift;
+ auto PropName = ApplePropertyString(Bit);
+ if (!PropName.empty())
+ OS << PropName;
+ else
+ OS << format("DW_APPLE_PROPERTY_0x%" PRIx64, Bit);
+ if (!(Val ^= Bit))
+ break;
+ OS << ", ";
+ } while (true);
+ OS << ")";
+}
+
+static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
+ unsigned AddressSize, unsigned Indent) {
+ if (Ranges.empty())
+ return;
+
+ for (const auto &Range: Ranges) {
+ OS << '\n';
+ OS.indent(Indent);
+ OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
+ AddressSize*2, Range.first,
+ AddressSize*2, Range.second);
+ }
+}
+
+static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
+ uint32_t *OffsetPtr, dwarf::Attribute Attr,
+ dwarf::Form Form, unsigned Indent) {
+ if (!Die.isValid())
+ return;
+ const char BaseIndent[] = " ";
+ OS << BaseIndent;
+ OS.indent(Indent+2);
+ auto attrString = AttributeString(Attr);
+ if (!attrString.empty())
+ WithColor(OS, syntax::Attribute) << attrString;
+ else
+ WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", Attr);
+
+ auto formString = FormEncodingString(Form);
+ if (!formString.empty())
+ OS << " [" << formString << ']';
+ else
+ OS << format(" [DW_FORM_Unknown_%x]", Form);
+
+ DWARFUnit *U = Die.getDwarfUnit();
+ DWARFFormValue formValue(Form);
+
+ if (!formValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr, U))
+ return;
+
+ OS << "\t(";
+
+ StringRef Name;
+ std::string File;
+ auto Color = syntax::Enumerator;
+ if (Attr == DW_AT_decl_file || Attr == DW_AT_call_file) {
+ Color = syntax::String;
+ if (const auto *LT = U->getContext().getLineTableForUnit(U))
+ if (LT->getFileNameByIndex(formValue.getAsUnsignedConstant().getValue(), U->getCompilationDir(), DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
+ File = '"' + File + '"';
+ Name = File;
+ }
+ } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
+ Name = AttributeValueString(Attr, *Val);
+
+ if (!Name.empty())
+ WithColor(OS, Color) << Name;
+ else if (Attr == DW_AT_decl_line || Attr == DW_AT_call_line)
+ OS << *formValue.getAsUnsignedConstant();
+ else
+ formValue.dump(OS);
+
+ // We have dumped the attribute raw value. For some attributes
+ // having both the raw value and the pretty-printed value is
+ // interesting. These attributes are handled below.
+ if (Attr == DW_AT_specification || Attr == DW_AT_abstract_origin) {
+ if (const char *Name = Die.getAttributeValueAsReferencedDie(Attr).getName(DINameKind::LinkageName))
+ OS << " \"" << Name << '\"';
+ } else if (Attr == DW_AT_APPLE_property_attribute) {
+ if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
+ dumpApplePropertyAttribute(OS, *OptVal);
+ } else if (Attr == DW_AT_ranges) {
+ dumpRanges(OS, Die.getAddressRanges(), U->getAddressByteSize(),
+ sizeof(BaseIndent)+Indent+4);
+ }
+
+ OS << ")\n";
+}
+
+} // end anonymous namespace
+
+bool DWARFDie::isSubprogramDIE() const {
+ return getTag() == DW_TAG_subprogram;
+}
+
+bool DWARFDie::isSubroutineDIE() const {
+ auto Tag = getTag();
+ return Tag == DW_TAG_subprogram || Tag == DW_TAG_inlined_subroutine;
+}
+
+bool DWARFDie::getAttributeValue(dwarf::Attribute Attr,
+ DWARFFormValue &FormValue) const {
+ if (!U)
+ return false;
+ auto AbbrevDecl = getAbbreviationDeclarationPtr();
+ if (AbbrevDecl)
+ return AbbrevDecl->getAttributeValue(getOffset(), Attr, *U, FormValue);
+ return false;
+}
+
+const char *DWARFDie::getAttributeValueAsString(dwarf::Attribute Attr,
+ const char *FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<const char *> Result = FormValue.getAsCString();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+uint64_t DWARFDie::getAttributeValueAsAddress(dwarf::Attribute Attr,
+ uint64_t FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<uint64_t> Result = FormValue.getAsAddress();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+int64_t DWARFDie::getAttributeValueAsSignedConstant(dwarf::Attribute Attr,
+ int64_t FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<int64_t> Result = FormValue.getAsSignedConstant();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+uint64_t
+DWARFDie::getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr,
+ uint64_t FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+uint64_t DWARFDie::getAttributeValueAsReference(dwarf::Attribute Attr,
+ uint64_t FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<uint64_t> Result = FormValue.getAsReference();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+uint64_t DWARFDie::getAttributeValueAsSectionOffset(dwarf::Attribute Attr,
+ uint64_t FailValue) const {
+ DWARFFormValue FormValue;
+ if (!getAttributeValue(Attr, FormValue))
+ return FailValue;
+ Optional<uint64_t> Result = FormValue.getAsSectionOffset();
+ return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
+DWARFDie
+DWARFDie::getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const {
+ uint32_t SpecRef = getAttributeValueAsReference(Attr, -1U);
+ if (SpecRef != -1U) {
+ auto SpecUnit = U->getUnitSection().getUnitForOffset(SpecRef);
+ if (SpecUnit)
+ return SpecUnit->getDIEForOffset(SpecRef);
+ }
+ return DWARFDie();
+}
+
+uint64_t
+DWARFDie::getRangesBaseAttribute(uint64_t FailValue) const {
+ auto Result = getAttributeValueAsSectionOffset(DW_AT_rnglists_base, -1ULL);
+ if (Result != -1ULL)
+ return Result;
+ return getAttributeValueAsSectionOffset(DW_AT_GNU_ranges_base, FailValue);
+}
+
+bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const {
+ LowPC = getAttributeValueAsAddress(DW_AT_low_pc, -1ULL);
+ if (LowPC == -1ULL)
+ return false;
+ HighPC = getAttributeValueAsAddress(DW_AT_high_pc, -1ULL);
+ if (HighPC == -1ULL) {
+ // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case
+ // it represents function size.
+ HighPC = getAttributeValueAsUnsignedConstant(DW_AT_high_pc, -1ULL);
+ if (HighPC != -1ULL)
+ HighPC += LowPC;
+ }
+ return (HighPC != -1ULL);
+}
+
+DWARFAddressRangesVector
+DWARFDie::getAddressRanges() const {
+ if (isNULL())
+ return DWARFAddressRangesVector();
+ // Single range specified by low/high PC.
+ uint64_t LowPC, HighPC;
+ if (getLowAndHighPC(LowPC, HighPC)) {
+ return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC));
+ }
+ // Multiple ranges from .debug_ranges section.
+ uint32_t RangesOffset = getAttributeValueAsSectionOffset(DW_AT_ranges, -1U);
+ if (RangesOffset != -1U) {
+ DWARFDebugRangeList RangeList;
+ if (U->extractRangeList(RangesOffset, RangeList))
+ return RangeList.getAbsoluteRanges(U->getBaseAddress());
+ }
+ return DWARFAddressRangesVector();
+}
+
+void
+DWARFDie::collectChildrenAddressRanges(DWARFAddressRangesVector& Ranges) const {
+ if (isNULL())
+ return;
+ if (isSubprogramDIE()) {
+ const auto &DIERanges = getAddressRanges();
+ Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end());
+ }
+
+ DWARFDie Child = getFirstChild();
+ while (Child) {
+ Child.collectChildrenAddressRanges(Ranges);
+ Child = Child.getSibling();
+ }
+}
+
+bool DWARFDie::addressRangeContainsAddress(const uint64_t Address) const {
+ for (const auto& R : getAddressRanges()) {
+ if (R.first <= Address && Address < R.second)
+ return true;
+ }
+ return false;
+}
+
+const char *
+DWARFDie::getSubroutineName(DINameKind Kind) const {
+ if (!isSubroutineDIE())
+ return nullptr;
+ return getName(Kind);
+}
+
+const char *
+DWARFDie::getName(DINameKind Kind) const {
+ if (!isValid() || Kind == DINameKind::None)
+ return nullptr;
+ const char *name = nullptr;
+ // Try to get mangled name only if it was asked for.
+ if (Kind == DINameKind::LinkageName) {
+ if ((name = getAttributeValueAsString(DW_AT_MIPS_linkage_name, nullptr)))
+ return name;
+ if ((name = getAttributeValueAsString(DW_AT_linkage_name, nullptr)))
+ return name;
+ }
+ if ((name = getAttributeValueAsString(DW_AT_name, nullptr)))
+ return name;
+ // Try to get name from specification DIE.
+ DWARFDie SpecDie = getAttributeValueAsReferencedDie(DW_AT_specification);
+ if (SpecDie && (name = SpecDie.getName(Kind)))
+ return name;
+ // Try to get name from abstract origin DIE.
+ DWARFDie AbsDie = getAttributeValueAsReferencedDie(DW_AT_abstract_origin);
+ if (AbsDie && (name = AbsDie.getName(Kind)))
+ return name;
+ return nullptr;
+}
+
+void DWARFDie::getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
+ uint32_t &CallColumn) const {
+ CallFile = getAttributeValueAsUnsignedConstant(DW_AT_call_file, 0);
+ CallLine = getAttributeValueAsUnsignedConstant(DW_AT_call_line, 0);
+ CallColumn = getAttributeValueAsUnsignedConstant(DW_AT_call_column, 0);
+}
+
+void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth,
+ unsigned Indent) const {
+ if (!isValid())
+ return;
+ DataExtractor debug_info_data = U->getDebugInfoExtractor();
+ const uint32_t Offset = getOffset();
+ uint32_t offset = Offset;
+
+ if (debug_info_data.isValidOffset(offset)) {
+ uint32_t abbrCode = debug_info_data.getULEB128(&offset);
+ WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
+
+ if (abbrCode) {
+ auto AbbrevDecl = getAbbreviationDeclarationPtr();
+ if (AbbrevDecl) {
+ auto tagString = TagString(getTag());
+ if (!tagString.empty())
+ WithColor(OS, syntax::Tag).get().indent(Indent) << tagString;
+ else
+ WithColor(OS, syntax::Tag).get().indent(Indent)
+ << format("DW_TAG_Unknown_%x", getTag());
+
+ OS << format(" [%u] %c\n", abbrCode,
+ AbbrevDecl->hasChildren() ? '*' : ' ');
+
+ // Dump all data in the DIE for the attributes.
+ for (const auto &AttrSpec : AbbrevDecl->attributes()) {
+ dumpAttribute(OS, *this, &offset, AttrSpec.Attr, AttrSpec.Form,
+ Indent);
+ }
+
+ DWARFDie child = getFirstChild();
+ if (RecurseDepth > 0 && child) {
+ while (child) {
+ child.dump(OS, RecurseDepth-1, Indent+2);
+ child = child.getSibling();
+ }
+ }
+ } else {
+ OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
+ << abbrCode << '\n';
+ }
+ } else {
+ OS.indent(Indent) << "NULL\n";
+ }
+ }
+}
+
+
+void DWARFDie::getInlinedChainForAddress(
+ const uint64_t Address, SmallVectorImpl<DWARFDie> &InlinedChain) const {
+ if (isNULL())
+ return;
+ DWARFDie DIE(*this);
+ while (DIE) {
+ // Append current DIE to inlined chain only if it has correct tag
+ // (e.g. it is not a lexical block).
+ if (DIE.isSubroutineDIE())
+ InlinedChain.push_back(DIE);
+
+ // Try to get child which also contains provided address.
+ DWARFDie Child = DIE.getFirstChild();
+ while (Child) {
+ if (Child.addressRangeContainsAddress(Address)) {
+ // Assume there is only one such child.
+ break;
+ }
+ Child = Child.getSibling();
+ }
+ DIE = Child;
+ }
+ // Reverse the obtained chain to make the root of inlined chain last.
+ std::reverse(InlinedChain.begin(), InlinedChain.end());
+}
+
Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp Tue Dec 13 12:25:19 2016
@@ -25,11 +25,10 @@ bool DWARFTypeUnit::extractImpl(DataExtr
}
void DWARFTypeUnit::dump(raw_ostream &OS, bool SummarizeTypes) {
- const DWARFDebugInfoEntryMinimal *TD =
- getDIEForOffset(TypeOffset + getOffset());
+ DWARFDie TD = getDIEForOffset(TypeOffset + getOffset());
DWARFFormValue NameVal;
const char *Name = "";
- if (TD->getAttributeValue(this, llvm::dwarf::DW_AT_name, NameVal))
+ if (TD.getAttributeValue(llvm::dwarf::DW_AT_name, NameVal))
if (auto ON = NameVal.getAsCString())
Name = *ON;
@@ -50,8 +49,8 @@ void DWARFTypeUnit::dump(raw_ostream &OS
<< " type_offset = " << format("0x%04x", TypeOffset)
<< " (next unit at " << format("0x%08x", getNextUnitOffset()) << ")\n";
- if (const DWARFDebugInfoEntryMinimal *TU = getUnitDIE(false))
- TU->dump(OS, this, -1U);
+ if (DWARFDie TU = getUnitDIE(false))
+ TU.dump(OS, -1U);
else
OS << "<type unit can't be parsed!>\n\n";
}
Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp (original)
+++ llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp Tue Dec 13 12:25:19 2016
@@ -151,27 +151,20 @@ void DWARFUnit::clear() {
}
const char *DWARFUnit::getCompilationDir() {
- extractDIEsIfNeeded(true);
- if (DieArray.empty())
- return nullptr;
- return DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, nullptr);
+ return getUnitDIE().getAttributeValueAsString(DW_AT_comp_dir, nullptr);
}
uint64_t DWARFUnit::getDWOId() {
- extractDIEsIfNeeded(true);
- const uint64_t FailValue = -1ULL;
- if (DieArray.empty())
- return FailValue;
- return DieArray[0]
- .getAttributeValueAsUnsignedConstant(this, DW_AT_GNU_dwo_id, FailValue);
+ return getUnitDIE().getAttributeValueAsUnsignedConstant(DW_AT_GNU_dwo_id,
+ -1ULL);
}
void DWARFUnit::setDIERelations() {
if (DieArray.size() <= 1)
return;
- std::vector<DWARFDebugInfoEntryMinimal *> ParentChain;
- DWARFDebugInfoEntryMinimal *SiblingChain = nullptr;
+ std::vector<DWARFDebugInfoEntry *> ParentChain;
+ DWARFDebugInfoEntry *SiblingChain = nullptr;
for (auto &DIE : DieArray) {
if (SiblingChain) {
SiblingChain->setSibling(&DIE);
@@ -197,7 +190,7 @@ void DWARFUnit::setDIERelations() {
void DWARFUnit::extractDIEsToVector(
bool AppendCUDie, bool AppendNonCUDies,
- std::vector<DWARFDebugInfoEntryMinimal> &Dies) const {
+ std::vector<DWARFDebugInfoEntry> &Dies) const {
if (!AppendCUDie && !AppendNonCUDies)
return;
@@ -205,7 +198,7 @@ void DWARFUnit::extractDIEsToVector(
// next compilation unit header.
uint32_t DIEOffset = Offset + getHeaderSize();
uint32_t NextCUOffset = getNextUnitOffset();
- DWARFDebugInfoEntryMinimal DIE;
+ DWARFDebugInfoEntry DIE;
DataExtractor DebugInfoData = getDebugInfoExtractor();
uint32_t Depth = 0;
bool IsCUDie = true;
@@ -260,15 +253,15 @@ size_t DWARFUnit::extractDIEsIfNeeded(bo
// If CU DIE was just parsed, copy several attribute values from it.
if (!HasCUDie) {
- uint64_t BaseAddr =
- DieArray[0].getAttributeValueAsAddress(this, DW_AT_low_pc, -1ULL);
+ DWARFDie UnitDie = getUnitDIE();
+ uint64_t BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_low_pc, -1ULL);
if (BaseAddr == -1ULL)
- BaseAddr = DieArray[0].getAttributeValueAsAddress(this, DW_AT_entry_pc, 0);
+ BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_entry_pc, 0);
setBaseAddress(BaseAddr);
- AddrOffsetSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
- this, DW_AT_GNU_addr_base, 0);
- RangeSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
- this, DW_AT_rnglists_base, 0);
+ AddrOffsetSectionBase = UnitDie.getAttributeValueAsSectionOffset(
+ DW_AT_GNU_addr_base, 0);
+ RangeSectionBase = UnitDie.getAttributeValueAsSectionOffset(
+ DW_AT_rnglists_base, 0);
// Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
// skeleton CU DIE, so that DWARF users not aware of it are not broken.
}
@@ -297,15 +290,15 @@ bool DWARFUnit::parseDWO() {
return false;
if (DWO.get())
return false;
- extractDIEsIfNeeded(true);
- if (DieArray.empty())
+ DWARFDie UnitDie = getUnitDIE();
+ if (!UnitDie)
return false;
const char *DWOFileName =
- DieArray[0].getAttributeValueAsString(this, DW_AT_GNU_dwo_name, nullptr);
+ UnitDie.getAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
if (!DWOFileName)
return false;
const char *CompilationDir =
- DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, nullptr);
+ UnitDie.getAttributeValueAsString(DW_AT_comp_dir, nullptr);
SmallString<16> AbsolutePath;
if (sys::path::is_relative(DWOFileName) && CompilationDir != nullptr) {
sys::path::append(AbsolutePath, CompilationDir);
@@ -320,7 +313,7 @@ bool DWARFUnit::parseDWO() {
}
// Share .debug_addr and .debug_ranges section with compile unit in .dwo
DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
- uint32_t DWORangesBase = DieArray[0].getRangesBaseAttribute(this, 0);
+ uint32_t DWORangesBase = UnitDie.getRangesBaseAttribute(0);
DWOCU->setRangesSection(RangeSection, DWORangesBase);
return true;
}
@@ -334,7 +327,7 @@ void DWARFUnit::clearDIEs(bool KeepCUDie
// contents which will cause just the internal pointers to be swapped
// so that when temporary vector goes out of scope, it will destroy the
// contents.
- std::vector<DWARFDebugInfoEntryMinimal> TmpArray;
+ std::vector<DWARFDebugInfoEntry> TmpArray;
DieArray.swap(TmpArray);
// Save at least the compile unit DIE
if (KeepCUDie)
@@ -343,11 +336,11 @@ void DWARFUnit::clearDIEs(bool KeepCUDie
}
void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
- const auto *U = getUnitDIE();
- if (U == nullptr)
+ DWARFDie UnitDie = getUnitDIE();
+ if (!UnitDie)
return;
// First, check if unit DIE describes address ranges for the whole unit.
- const auto &CUDIERanges = U->getAddressRanges(this);
+ const auto &CUDIERanges = UnitDie.getAddressRanges();
if (!CUDIERanges.empty()) {
CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
return;
@@ -360,7 +353,7 @@ void DWARFUnit::collectAddressRanges(DWA
// up parsing the DWARF and then throwing them all away to keep memory usage
// down.
const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
- DieArray[0].collectChildrenAddressRanges(this, CURanges);
+ getUnitDIE().collectChildrenAddressRanges(CURanges);
// Collect address ranges from DIEs in .dwo if necessary.
bool DWOCreated = parseDWO();
@@ -375,36 +368,37 @@ void DWARFUnit::collectAddressRanges(DWA
clearDIEs(true);
}
-const DWARFDebugInfoEntryMinimal *
+DWARFDie
DWARFUnit::getSubprogramForAddress(uint64_t Address) {
extractDIEsIfNeeded(false);
- for (const DWARFDebugInfoEntryMinimal &DIE : DieArray) {
+ for (const DWARFDebugInfoEntry &D : DieArray) {
+ DWARFDie DIE(this, &D);
if (DIE.isSubprogramDIE() &&
- DIE.addressRangeContainsAddress(this, Address)) {
- return &DIE;
+ DIE.addressRangeContainsAddress(Address)) {
+ return DIE;
}
}
- return nullptr;
+ return DWARFDie();
}
-DWARFDebugInfoEntryInlinedChain
-DWARFUnit::getInlinedChainForAddress(uint64_t Address) {
+void
+DWARFUnit::getInlinedChainForAddress(uint64_t Address,
+ SmallVectorImpl<DWARFDie> &InlinedChain) {
// First, find a subprogram that contains the given address (the root
// of inlined chain).
- const DWARFUnit *ChainCU = nullptr;
- const DWARFDebugInfoEntryMinimal *SubprogramDIE;
+ DWARFDie SubprogramDIE;
// Try to look for subprogram DIEs in the DWO file.
parseDWO();
- if (DWO) {
- if ((SubprogramDIE = DWO->getUnit()->getSubprogramForAddress(Address)))
- ChainCU = DWO->getUnit();
- } else if ((SubprogramDIE = getSubprogramForAddress(Address)))
- ChainCU = this;
+ if (DWO)
+ SubprogramDIE = DWO->getUnit()->getSubprogramForAddress(Address);
+ else
+ SubprogramDIE = getSubprogramForAddress(Address);
// Get inlined chain rooted at this subprogram DIE.
- if (!SubprogramDIE)
- return DWARFDebugInfoEntryInlinedChain();
- return SubprogramDIE->getInlinedChainForAddress(ChainCU, Address);
+ if (SubprogramDIE)
+ SubprogramDIE.getInlinedChainForAddress(Address, InlinedChain);
+ else
+ InlinedChain.clear();
}
const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
Modified: llvm/trunk/tools/dsymutil/DwarfLinker.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/dsymutil/DwarfLinker.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/tools/dsymutil/DwarfLinker.cpp (original)
+++ llvm/trunk/tools/dsymutil/DwarfLinker.cpp Tue Dec 13 12:25:19 2016
@@ -102,7 +102,7 @@ class DeclContext {
StringRef Name;
StringRef File;
const DeclContext &Parent;
- const DWARFDebugInfoEntryMinimal *LastSeenDIE;
+ DWARFDie LastSeenDIE;
uint32_t LastSeenCompileUnitID;
uint32_t CanonicalDIEOffset;
@@ -114,19 +114,18 @@ public:
DeclContext()
: QualifiedNameHash(0), Line(0), ByteSize(0),
Tag(dwarf::DW_TAG_compile_unit), Name(), File(), Parent(*this),
- LastSeenDIE(nullptr), LastSeenCompileUnitID(0), CanonicalDIEOffset(0) {}
+ LastSeenDIE(), LastSeenCompileUnitID(0), CanonicalDIEOffset(0) {}
DeclContext(unsigned Hash, uint32_t Line, uint32_t ByteSize, uint16_t Tag,
StringRef Name, StringRef File, const DeclContext &Parent,
- const DWARFDebugInfoEntryMinimal *LastSeenDIE = nullptr,
- unsigned CUId = 0)
+ DWARFDie LastSeenDIE = DWARFDie(), unsigned CUId = 0)
: QualifiedNameHash(Hash), Line(Line), ByteSize(ByteSize), Tag(Tag),
Name(Name), File(File), Parent(Parent), LastSeenDIE(LastSeenDIE),
LastSeenCompileUnitID(CUId), CanonicalDIEOffset(0) {}
uint32_t getQualifiedNameHash() const { return QualifiedNameHash; }
- bool setLastSeenDIE(CompileUnit &U, const DWARFDebugInfoEntryMinimal *Die);
+ bool setLastSeenDIE(CompileUnit &U, const DWARFDie &Die);
uint32_t getCanonicalDIEOffset() const { return CanonicalDIEOffset; }
void setCanonicalDIEOffset(uint32_t Offset) { CanonicalDIEOffset = Offset; }
@@ -174,7 +173,7 @@ public:
/// emulate some dsymutil-classic functionality.
PointerIntPair<DeclContext *, 1>
getChildDeclContext(DeclContext &Context,
- const DWARFDebugInfoEntryMinimal *DIE, CompileUnit &Unit,
+ const DWARFDie &DIE, CompileUnit &Unit,
NonRelocatableStringpool &StringPool, bool InClangModule);
DeclContext &getRoot() { return Root; }
@@ -200,14 +199,13 @@ public:
StringRef ClangModuleName)
: OrigUnit(OrigUnit), ID(ID), NewUnit(OrigUnit.getVersion(),
OrigUnit.getAddressByteSize(),
- OrigUnit.getUnitDIE()->getTag()),
+ OrigUnit.getUnitDIE().getTag()),
LowPc(UINT64_MAX), HighPc(0), RangeAlloc(), Ranges(RangeAlloc),
ClangModuleName(ClangModuleName) {
Info.resize(OrigUnit.getNumDIEs());
- const auto *CUDie = OrigUnit.getUnitDIE(false);
- unsigned Lang = CUDie->getAttributeValueAsUnsignedConstant(
- &OrigUnit, dwarf::DW_AT_language, 0);
+ auto CUDie = OrigUnit.getUnitDIE(false);
+ unsigned Lang = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_language, 0);
HasODR = CanUseODR && (Lang == dwarf::DW_LANG_C_plus_plus ||
Lang == dwarf::DW_LANG_C_plus_plus_03 ||
Lang == dwarf::DW_LANG_C_plus_plus_11 ||
@@ -841,10 +839,10 @@ void DwarfStreamer::emitLocationsForUnit
const DWARFSection &InputSec = Dwarf.getLocSection();
DataExtractor Data(InputSec.Data, Dwarf.isLittleEndian(), AddressSize);
DWARFUnit &OrigUnit = Unit.getOrigUnit();
- const auto *OrigUnitDie = OrigUnit.getUnitDIE(false);
+ auto OrigUnitDie = OrigUnit.getUnitDIE(false);
int64_t UnitPcOffset = 0;
- uint64_t OrigLowPc = OrigUnitDie->getAttributeValueAsAddress(
- &OrigUnit, dwarf::DW_AT_low_pc, -1ULL);
+ uint64_t OrigLowPc = OrigUnitDie.getAttributeValueAsAddress(
+ dwarf::DW_AT_low_pc, -1ULL);
if (OrigLowPc != -1ULL)
UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
@@ -1116,8 +1114,8 @@ public:
/// \brief Link the contents of the DebugMap.
bool link(const DebugMap &);
- void reportWarning(const Twine &Warning, const DWARFUnit *Unit = nullptr,
- const DWARFDebugInfoEntryMinimal *DIE = nullptr) const;
+ void reportWarning(const Twine &Warning,
+ const DWARFDie *DIE = nullptr) const;
private:
/// \brief Called at the start of a debug object link.
@@ -1193,7 +1191,7 @@ private:
/// \brief Recursively walk the \p DIE tree and look for DIEs to
/// keep. Store that information in \p CU's DIEInfo.
void lookForDIEsToKeep(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
const DebugMapObject &DMO, CompileUnit &CU,
unsigned Flags);
@@ -1203,7 +1201,7 @@ private:
/// A skeleton CU is a CU without children, a DW_AT_gnu_dwo_name
/// pointing to the module, and a DW_AT_gnu_dwo_id with the module
/// hash.
- bool registerModuleReference(const DWARFDebugInfoEntryMinimal &CUDie,
+ bool registerModuleReference(const DWARFDie &CUDie,
const DWARFUnit &Unit, DebugMap &ModuleMap,
unsigned Indent = 0);
@@ -1227,23 +1225,23 @@ private:
/// \brief Mark the passed DIE as well as all the ones it depends on
/// as kept.
void keepDIEAndDependencies(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit::DIEInfo &MyInfo,
const DebugMapObject &DMO, CompileUnit &CU,
bool UseODR);
unsigned shouldKeepDIE(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
unsigned Flags);
unsigned shouldKeepVariableDIE(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit &Unit,
CompileUnit::DIEInfo &MyInfo, unsigned Flags);
unsigned shouldKeepSubprogramDIE(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit &Unit,
CompileUnit::DIEInfo &MyInfo,
unsigned Flags);
@@ -1283,7 +1281,7 @@ private:
/// applied to the entry point of the function to get the linked address.
/// \param Die the output DIE to use, pass NULL to create one.
/// \returns the root of the cloned tree or null if nothing was selected.
- DIE *cloneDIE(const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &U,
+ DIE *cloneDIE(const DWARFDie &InputDIE, CompileUnit &U,
int64_t PCOffset, uint32_t OutOffset, unsigned Flags,
DIE *Die = nullptr);
@@ -1316,7 +1314,7 @@ private:
/// Helper for cloneDIE.
unsigned cloneAttribute(DIE &Die,
- const DWARFDebugInfoEntryMinimal &InputDIE,
+ const DWARFDie &InputDIE,
CompileUnit &U, const DWARFFormValue &Val,
const AttributeSpec AttrSpec, unsigned AttrSize,
AttributesInfo &AttrInfo);
@@ -1333,7 +1331,7 @@ private:
/// \returns the size of the new attribute.
unsigned
cloneDieReferenceAttribute(DIE &Die,
- const DWARFDebugInfoEntryMinimal &InputDIE,
+ const DWARFDie &InputDIE,
AttributeSpec AttrSpec, unsigned AttrSize,
const DWARFFormValue &Val, CompileUnit &Unit);
@@ -1354,7 +1352,7 @@ private:
/// Clone a scalar attribute and add it to \p Die.
/// \returns the size of the new attribute.
unsigned cloneScalarAttribute(DIE &Die,
- const DWARFDebugInfoEntryMinimal &InputDIE,
+ const DWARFDie &InputDIE,
CompileUnit &U, AttributeSpec AttrSpec,
const DWARFFormValue &Val, unsigned AttrSize,
AttributesInfo &Info);
@@ -1363,8 +1361,7 @@ private:
/// described by \p Die and store them in \Info if they are not
/// already there.
/// \returns is a name was found.
- bool getDIENames(const DWARFDebugInfoEntryMinimal &Die, DWARFUnit &U,
- AttributesInfo &Info);
+ bool getDIENames(const DWARFDie &Die, AttributesInfo &Info);
/// Create a copy of abbreviation Abbrev.
void copyAbbrev(const DWARFAbbreviationDeclaration &Abbrev, bool hasODR);
@@ -1480,19 +1477,19 @@ static CompileUnit *getUnitForOffset(
/// extracted in \p RefValue. The resulting DIE migh be in another
/// CompileUnit which is stored into \p ReferencedCU.
/// \returns null if resolving fails for any reason.
-static const DWARFDebugInfoEntryMinimal *resolveDIEReference(
+static DWARFDie resolveDIEReference(
const DwarfLinker &Linker, std::vector<std::unique_ptr<CompileUnit>> &Units,
const DWARFFormValue &RefValue, const DWARFUnit &Unit,
- const DWARFDebugInfoEntryMinimal &DIE, CompileUnit *&RefCU) {
+ const DWARFDie &DIE, CompileUnit *&RefCU) {
assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
uint64_t RefOffset = *RefValue.getAsReference();
if ((RefCU = getUnitForOffset(Units, RefOffset)))
- if (const auto *RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset))
+ if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset))
return RefDie;
- Linker.reportWarning("could not find referenced DIE", &Unit, &DIE);
- return nullptr;
+ Linker.reportWarning("could not find referenced DIE", &DIE);
+ return DWARFDie();
}
/// \returns whether the passed \a Attr type might contain a DIE
@@ -1526,7 +1523,7 @@ static bool isODRAttribute(uint16_t Attr
/// If a context that is not a namespace appears twice in the same CU,
/// we know it is ambiguous. Make it invalid.
bool DeclContext::setLastSeenDIE(CompileUnit &U,
- const DWARFDebugInfoEntryMinimal *Die) {
+ const DWARFDie &Die) {
if (LastSeenCompileUnitID == U.getUniqueID()) {
DWARFUnit &OrigUnit = U.getOrigUnit();
uint32_t FirstIdx = OrigUnit.getDIEIndex(LastSeenDIE);
@@ -1540,9 +1537,9 @@ bool DeclContext::setLastSeenDIE(Compile
}
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
- DeclContext &Context, const DWARFDebugInfoEntryMinimal *DIE, CompileUnit &U,
+ DeclContext &Context, const DWARFDie &DIE, CompileUnit &U,
NonRelocatableStringpool &StringPool, bool InClangModule) {
- unsigned Tag = DIE->getTag();
+ unsigned Tag = DIE.getTag();
// FIXME: dsymutil-classic compat: We should bail out here if we
// have a specification or an abstract_origin. We will get the
@@ -1560,8 +1557,7 @@ PointerIntPair<DeclContext *, 1> DeclCon
// Do not unique anything inside CU local functions.
if ((Context.getTag() == dwarf::DW_TAG_namespace ||
Context.getTag() == dwarf::DW_TAG_compile_unit) &&
- !DIE->getAttributeValueAsUnsignedConstant(&U.getOrigUnit(),
- dwarf::DW_AT_external, 0))
+ !DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_external, 0))
return PointerIntPair<DeclContext *, 1>(nullptr);
LLVM_FALLTHROUGH;
case dwarf::DW_TAG_member:
@@ -1575,14 +1571,13 @@ PointerIntPair<DeclContext *, 1> DeclCon
// created on demand. For example implicitely defined constructors
// are ambiguous because of the way we identify contexts, and they
// won't be generated everytime everywhere.
- if (DIE->getAttributeValueAsUnsignedConstant(&U.getOrigUnit(),
- dwarf::DW_AT_artificial, 0))
+ if (DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_artificial, 0))
return PointerIntPair<DeclContext *, 1>(nullptr);
break;
}
- const char *Name = DIE->getName(&U.getOrigUnit(), DINameKind::LinkageName);
- const char *ShortName = DIE->getName(&U.getOrigUnit(), DINameKind::ShortName);
+ const char *Name = DIE.getName(DINameKind::LinkageName);
+ const char *ShortName = DIE.getName(DINameKind::ShortName);
StringRef NameRef;
StringRef ShortNameRef;
StringRef FileRef;
@@ -1616,11 +1611,11 @@ PointerIntPair<DeclContext *, 1> DeclCon
// namespaces, use these additional data points to make the process
// safer. This is disabled for clang modules, because forward
// declarations of module-defined types do not have a file and line.
- ByteSize = DIE->getAttributeValueAsUnsignedConstant(
- &U.getOrigUnit(), dwarf::DW_AT_byte_size, UINT64_MAX);
+ ByteSize = DIE.getAttributeValueAsUnsignedConstant(
+ dwarf::DW_AT_byte_size, UINT64_MAX);
if (Tag != dwarf::DW_TAG_namespace || !Name) {
- if (unsigned FileNum = DIE->getAttributeValueAsUnsignedConstant(
- &U.getOrigUnit(), dwarf::DW_AT_decl_file, 0)) {
+ if (unsigned FileNum = DIE.getAttributeValueAsUnsignedConstant(
+ dwarf::DW_AT_decl_file, 0)) {
if (const auto *LT = U.getOrigUnit().getContext().getLineTableForUnit(
&U.getOrigUnit())) {
// FIXME: dsymutil-classic compatibility. I'd rather not
@@ -1633,8 +1628,8 @@ PointerIntPair<DeclContext *, 1> DeclCon
// instead of "" would allow more uniquing, but for now, do
// it this way to match dsymutil-classic.
if (LT->hasFileAtIndex(FileNum)) {
- Line = DIE->getAttributeValueAsUnsignedConstant(
- &U.getOrigUnit(), dwarf::DW_AT_decl_line, 0);
+ Line = DIE.getAttributeValueAsUnsignedConstant(
+ dwarf::DW_AT_decl_line, 0);
// Cache the resolved paths, because calling realpath is expansive.
StringRef ResolvedPath = U.getResolvedPath(FileNum);
if (!ResolvedPath.empty()) {
@@ -1714,16 +1709,16 @@ PointerIntPair<DeclContext *, 1> DeclCon
return PointerIntPair<DeclContext *, 1>(*ContextIter);
}
-bool DwarfLinker::DIECloner::getDIENames(const DWARFDebugInfoEntryMinimal &Die,
- DWARFUnit &U, AttributesInfo &Info) {
+bool DwarfLinker::DIECloner::getDIENames(const DWARFDie &Die,
+ AttributesInfo &Info) {
// FIXME: a bit wasteful as the first getName might return the
// short name.
if (!Info.MangledName &&
- (Info.MangledName = Die.getName(&U, DINameKind::LinkageName)))
+ (Info.MangledName = Die.getName(DINameKind::LinkageName)))
Info.MangledNameOffset =
Linker.StringPool.getStringOffset(Info.MangledName);
- if (!Info.Name && (Info.Name = Die.getName(&U, DINameKind::ShortName)))
+ if (!Info.Name && (Info.Name = Die.getName(DINameKind::ShortName)))
Info.NameOffset = Linker.StringPool.getStringOffset(Info.Name);
return Info.Name || Info.MangledName;
@@ -1731,8 +1726,8 @@ bool DwarfLinker::DIECloner::getDIENames
/// \brief Report a warning to the user, optionaly including
/// information about a specific \p DIE related to the warning.
-void DwarfLinker::reportWarning(const Twine &Warning, const DWARFUnit *Unit,
- const DWARFDebugInfoEntryMinimal *DIE) const {
+void DwarfLinker::reportWarning(const Twine &Warning,
+ const DWARFDie *DIE) const {
StringRef Context = "<debug map>";
if (CurrentDebugObject)
Context = CurrentDebugObject->getObjectFilename();
@@ -1742,8 +1737,7 @@ void DwarfLinker::reportWarning(const Tw
return;
errs() << " in DIE:\n";
- DIE->dump(errs(), const_cast<DWARFUnit *>(Unit), 0 /* RecurseDepth */,
- 6 /* Indent */);
+ DIE->dump(errs(), 0 /* RecurseDepth */, 6 /* Indent */);
}
bool DwarfLinker::createStreamer(const Triple &TheTriple,
@@ -1761,7 +1755,7 @@ bool DwarfLinker::createStreamer(const T
/// \return true when this DIE and all of its children are only
/// forward declarations to types defined in external clang modules
/// (i.e., forward declarations that are children of a DW_TAG_module).
-static bool analyzeContextInfo(const DWARFDebugInfoEntryMinimal *DIE,
+static bool analyzeContextInfo(const DWARFDie &DIE,
unsigned ParentIdx, CompileUnit &CU,
DeclContext *CurrentDeclContext,
NonRelocatableStringpool &StringPool,
@@ -1782,9 +1776,9 @@ static bool analyzeContextInfo(const DWA
// definitions match)."
//
// We treat non-C++ modules like namespaces for this reason.
- if (DIE->getTag() == dwarf::DW_TAG_module && ParentIdx == 0 &&
- DIE->getAttributeValueAsString(&CU.getOrigUnit(), dwarf::DW_AT_name,
- "") != CU.getClangModuleName()) {
+ if (DIE.getTag() == dwarf::DW_TAG_module && ParentIdx == 0 &&
+ DIE.getAttributeValueAsString(dwarf::DW_AT_name,
+ "") != CU.getClangModuleName()) {
InImportedModule = true;
}
@@ -1802,18 +1796,18 @@ static bool analyzeContextInfo(const DWA
}
Info.Prune = InImportedModule;
- if (DIE->hasChildren())
- for (auto *Child = DIE->getFirstChild(); Child && !Child->isNULL();
- Child = Child->getSibling())
+ if (DIE.hasChildren())
+ for (auto Child = DIE.getFirstChild(); Child && !Child.isNULL();
+ Child = Child.getSibling())
Info.Prune &= analyzeContextInfo(Child, MyIdx, CU, CurrentDeclContext,
StringPool, Contexts, InImportedModule);
// Prune this DIE if it is either a forward declaration inside a
// DW_TAG_module or a DW_TAG_module that contains nothing but
// forward declarations.
- Info.Prune &= (DIE->getTag() == dwarf::DW_TAG_module) ||
- DIE->getAttributeValueAsUnsignedConstant(
- &CU.getOrigUnit(), dwarf::DW_AT_declaration, 0);
+ Info.Prune &= (DIE.getTag() == dwarf::DW_TAG_module) ||
+ DIE.getAttributeValueAsUnsignedConstant(
+ dwarf::DW_AT_declaration, 0);
// Don't prune it if there is no definition for the DIE.
Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
@@ -2071,7 +2065,7 @@ getAttributeOffsets(const DWARFAbbreviat
/// \brief Check if a variable describing DIE should be kept.
/// \returns updated TraversalFlags.
unsigned DwarfLinker::shouldKeepVariableDIE(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit &Unit,
CompileUnit::DIEInfo &MyInfo,
unsigned Flags) {
@@ -2105,7 +2099,7 @@ unsigned DwarfLinker::shouldKeepVariable
return Flags;
if (Options.Verbose)
- DIE.dump(outs(), const_cast<DWARFUnit *>(&OrigUnit), 0, 8 /* Indent */);
+ DIE.dump(outs(), 0, 8 /* Indent */);
return Flags | TF_Keep;
}
@@ -2114,7 +2108,7 @@ unsigned DwarfLinker::shouldKeepVariable
/// \returns updated TraversalFlags.
unsigned DwarfLinker::shouldKeepSubprogramDIE(
RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE, CompileUnit &Unit,
+ const DWARFDie &DIE, CompileUnit &Unit,
CompileUnit::DIEInfo &MyInfo, unsigned Flags) {
const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
@@ -2131,21 +2125,21 @@ unsigned DwarfLinker::shouldKeepSubprogr
getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);
uint64_t LowPc =
- DIE.getAttributeValueAsAddress(&OrigUnit, dwarf::DW_AT_low_pc, -1ULL);
+ DIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc, -1ULL);
assert(LowPc != -1ULL && "low_pc attribute is not an address.");
if (LowPc == -1ULL ||
!RelocMgr.hasValidRelocation(LowPcOffset, LowPcEndOffset, MyInfo))
return Flags;
if (Options.Verbose)
- DIE.dump(outs(), const_cast<DWARFUnit *>(&OrigUnit), 0, 8 /* Indent */);
+ DIE.dump(outs(), 0, 8 /* Indent */);
Flags |= TF_Keep;
DWARFFormValue HighPcValue;
- if (!DIE.getAttributeValue(&OrigUnit, dwarf::DW_AT_high_pc, HighPcValue)) {
+ if (!DIE.getAttributeValue(dwarf::DW_AT_high_pc, HighPcValue)) {
reportWarning("Function without high_pc. Range will be discarded.\n",
- &OrigUnit, &DIE);
+ &DIE);
return Flags;
}
@@ -2166,7 +2160,7 @@ unsigned DwarfLinker::shouldKeepSubprogr
/// \brief Check if a DIE should be kept.
/// \returns updated TraversalFlags.
unsigned DwarfLinker::shouldKeepDIE(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &DIE,
+ const DWARFDie &DIE,
CompileUnit &Unit,
CompileUnit::DIEInfo &MyInfo,
unsigned Flags) {
@@ -2198,18 +2192,18 @@ unsigned DwarfLinker::shouldKeepDIE(Relo
/// TraversalFlags to inform it that it's not doing the primary DIE
/// tree walk.
void DwarfLinker::keepDIEAndDependencies(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &Die,
+ const DWARFDie &Die,
CompileUnit::DIEInfo &MyInfo,
const DebugMapObject &DMO,
CompileUnit &CU, bool UseODR) {
- const DWARFUnit &Unit = CU.getOrigUnit();
+ DWARFUnit &Unit = CU.getOrigUnit();
MyInfo.Keep = true;
// First mark all the parent chain as kept.
unsigned AncestorIdx = MyInfo.ParentIdx;
while (!CU.getInfo(AncestorIdx).Keep) {
unsigned ODRFlag = UseODR ? TF_ODR : 0;
- lookForDIEsToKeep(RelocMgr, *Unit.getDIEAtIndex(AncestorIdx), DMO, CU,
+ lookForDIEsToKeep(RelocMgr, Unit.getDIEAtIndex(AncestorIdx), DMO, CU,
TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag);
AncestorIdx = CU.getInfo(AncestorIdx).ParentIdx;
}
@@ -2231,7 +2225,7 @@ void DwarfLinker::keepDIEAndDependencies
Val.extractValue(Data, &Offset, &Unit);
CompileUnit *ReferencedCU;
- if (const auto *RefDIE =
+ if (auto RefDIE =
resolveDIEReference(*this, Units, Val, Unit, Die, ReferencedCU)) {
uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDIE);
CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
@@ -2254,7 +2248,7 @@ void DwarfLinker::keepDIEAndDependencies
Info.Prune = false;
unsigned ODRFlag = UseODR ? TF_ODR : 0;
- lookForDIEsToKeep(RelocMgr, *RefDIE, DMO, *ReferencedCU,
+ lookForDIEsToKeep(RelocMgr, RefDIE, DMO, *ReferencedCU,
TF_Keep | TF_DependencyWalk | ODRFlag);
}
}
@@ -2273,10 +2267,10 @@ void DwarfLinker::keepDIEAndDependencies
/// not respected. The TF_DependencyWalk flag tells us which kind of
/// traversal we are currently doing.
void DwarfLinker::lookForDIEsToKeep(RelocationManager &RelocMgr,
- const DWARFDebugInfoEntryMinimal &Die,
+ const DWARFDie &Die,
const DebugMapObject &DMO, CompileUnit &CU,
unsigned Flags) {
- unsigned Idx = CU.getOrigUnit().getDIEIndex(&Die);
+ unsigned Idx = CU.getOrigUnit().getDIEIndex(Die);
CompileUnit::DIEInfo &MyInfo = CU.getInfo(Idx);
bool AlreadyKept = MyInfo.Keep;
if (MyInfo.Prune)
@@ -2310,9 +2304,9 @@ void DwarfLinker::lookForDIEsToKeep(Relo
if (!Die.hasChildren() || (Flags & TF_ParentWalk))
return;
- for (auto *Child = Die.getFirstChild(); Child && !Child->isNULL();
- Child = Child->getSibling())
- lookForDIEsToKeep(RelocMgr, *Child, DMO, CU, Flags);
+ for (auto Child = Die.getFirstChild(); Child && !Child.isNULL();
+ Child = Child.getSibling())
+ lookForDIEsToKeep(RelocMgr, Child, DMO, CU, Flags);
}
/// \brief Assign an abbreviation numer to \p Abbrev.
@@ -2358,7 +2352,7 @@ unsigned DwarfLinker::DIECloner::cloneSt
}
unsigned DwarfLinker::DIECloner::cloneDieReferenceAttribute(
- DIE &Die, const DWARFDebugInfoEntryMinimal &InputDIE,
+ DIE &Die, const DWARFDie &InputDIE,
AttributeSpec AttrSpec, unsigned AttrSize, const DWARFFormValue &Val,
CompileUnit &Unit) {
const DWARFUnit &U = Unit.getOrigUnit();
@@ -2367,8 +2361,8 @@ unsigned DwarfLinker::DIECloner::cloneDi
CompileUnit *RefUnit = nullptr;
DeclContext *Ctxt = nullptr;
- const DWARFDebugInfoEntryMinimal *RefDie =
- resolveDIEReference(Linker, CompileUnits, Val, U, InputDIE, RefUnit);
+ DWARFDie RefDie = resolveDIEReference(Linker, CompileUnits, Val, U, InputDIE,
+ RefUnit);
// If the referenced DIE is not found, drop the attribute.
if (!RefDie)
@@ -2393,7 +2387,7 @@ unsigned DwarfLinker::DIECloner::cloneDi
assert(Ref > InputDIE.getOffset());
// We haven't cloned this DIE yet. Just create an empty one and
// store it. It'll get really cloned when we process it.
- RefInfo.Clone = DIE::get(DIEAlloc, dwarf::Tag(RefDie->getTag()));
+ RefInfo.Clone = DIE::get(DIEAlloc, dwarf::Tag(RefDie.getTag()));
}
NewRefDie = RefInfo.Clone;
@@ -2509,7 +2503,7 @@ unsigned DwarfLinker::DIECloner::cloneAd
}
unsigned DwarfLinker::DIECloner::cloneScalarAttribute(
- DIE &Die, const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &Unit,
+ DIE &Die, const DWARFDie &InputDIE, CompileUnit &Unit,
AttributeSpec AttrSpec, const DWARFFormValue &Val, unsigned AttrSize,
AttributesInfo &Info) {
uint64_t Value;
@@ -2528,7 +2522,7 @@ unsigned DwarfLinker::DIECloner::cloneSc
else {
Linker.reportWarning(
"Unsupported scalar attribute form. Dropping attribute.",
- &Unit.getOrigUnit(), &InputDIE);
+ &InputDIE);
return 0;
}
PatchLocation Patch =
@@ -2553,7 +2547,7 @@ unsigned DwarfLinker::DIECloner::cloneSc
/// value \p Val, and add it to \p Die.
/// \returns the size of the cloned attribute.
unsigned DwarfLinker::DIECloner::cloneAttribute(
- DIE &Die, const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &Unit,
+ DIE &Die, const DWARFDie &InputDIE, CompileUnit &Unit,
const DWARFFormValue &Val, const AttributeSpec AttrSpec, unsigned AttrSize,
AttributesInfo &Info) {
const DWARFUnit &U = Unit.getOrigUnit();
@@ -2590,8 +2584,7 @@ unsigned DwarfLinker::DIECloner::cloneAt
Info);
default:
Linker.reportWarning(
- "Unsupported attribute form in cloneAttribute. Dropping.", &U,
- &InputDIE);
+ "Unsupported attribute form in cloneAttribute. Dropping.", &InputDIE);
}
return 0;
@@ -2701,10 +2694,10 @@ shouldSkipAttribute(DWARFAbbreviationDec
}
DIE *DwarfLinker::DIECloner::cloneDIE(
- const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &Unit,
+ const DWARFDie &InputDIE, CompileUnit &Unit,
int64_t PCOffset, uint32_t OutOffset, unsigned Flags, DIE *Die) {
DWARFUnit &U = Unit.getOrigUnit();
- unsigned Idx = U.getDIEIndex(&InputDIE);
+ unsigned Idx = U.getDIEIndex(InputDIE);
CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
// Should the DIE appear in the output?
@@ -2740,7 +2733,7 @@ DIE *DwarfLinker::DIECloner::cloneDIE(
// DW_TAG_compile_unit without any children, point to the next unit.
uint32_t NextOffset =
(Idx + 1 < U.getNumDIEs())
- ? U.getDIEAtIndex(Idx + 1)->getOffset()
+ ? U.getDIEAtIndex(Idx + 1).getOffset()
: U.getNextUnitOffset();
AttributesInfo AttrInfo;
@@ -2759,12 +2752,12 @@ DIE *DwarfLinker::DIECloner::cloneDIE(
// independantly by the linker). The computation of the actual
// high_pc value is done in cloneAddressAttribute().
AttrInfo.OrigHighPc =
- InputDIE.getAttributeValueAsAddress(&U, dwarf::DW_AT_high_pc, 0);
+ InputDIE.getAttributeValueAsAddress(dwarf::DW_AT_high_pc, 0);
// Also store the low_pc. It might get relocated in an
// inline_subprogram that happens at the beginning of its
// inlining function.
AttrInfo.OrigLowPc =
- InputDIE.getAttributeValueAsAddress(&U, dwarf::DW_AT_low_pc, UINT64_MAX);
+ InputDIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc, UINT64_MAX);
}
// Reset the Offset to 0 as we will be working on the local copy of
@@ -2816,7 +2809,7 @@ DIE *DwarfLinker::DIECloner::cloneDIE(
// accelerator tables too. For now stick with dsymutil's behavior.
if ((Info.InDebugMap || AttrInfo.HasLowPc) &&
Tag != dwarf::DW_TAG_compile_unit &&
- getDIENames(InputDIE, Unit.getOrigUnit(), AttrInfo)) {
+ getDIENames(InputDIE, AttrInfo)) {
if (AttrInfo.MangledName && AttrInfo.MangledName != AttrInfo.Name)
Unit.addNameAccelerator(Die, AttrInfo.MangledName,
AttrInfo.MangledNameOffset,
@@ -2825,14 +2818,14 @@ DIE *DwarfLinker::DIECloner::cloneDIE(
Unit.addNameAccelerator(Die, AttrInfo.Name, AttrInfo.NameOffset,
Tag == dwarf::DW_TAG_inlined_subroutine);
} else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration &&
- getDIENames(InputDIE, Unit.getOrigUnit(), AttrInfo)) {
+ getDIENames(InputDIE, AttrInfo)) {
Unit.addTypeAccelerator(Die, AttrInfo.Name, AttrInfo.NameOffset);
}
// Determine whether there are any children that we want to keep.
bool HasChildren = false;
- for (auto *Child = InputDIE.getFirstChild(); Child && !Child->isNULL();
- Child = Child->getSibling()) {
+ for (auto Child = InputDIE.getFirstChild(); Child && !Child.isNULL();
+ Child = Child.getSibling()) {
unsigned Idx = U.getDIEIndex(Child);
if (Unit.getInfo(Idx).Keep) {
HasChildren = true;
@@ -2857,9 +2850,9 @@ DIE *DwarfLinker::DIECloner::cloneDIE(
}
// Recursively clone children.
- for (auto *Child = InputDIE.getFirstChild(); Child && !Child->isNULL();
- Child = Child->getSibling()) {
- if (DIE *Clone = cloneDIE(*Child, Unit, PCOffset, OutOffset, Flags)) {
+ for (auto Child = InputDIE.getFirstChild(); Child && !Child.isNULL();
+ Child = Child.getSibling()) {
+ if (DIE *Clone = cloneDIE(Child, Unit, PCOffset, OutOffset, Flags)) {
Die->addChild(Clone);
OutOffset = Clone->getOffset() + Clone->getSize();
}
@@ -2884,9 +2877,9 @@ void DwarfLinker::patchRangesForUnit(con
OrigDwarf.isLittleEndian(), AddressSize);
auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
DWARFUnit &OrigUnit = Unit.getOrigUnit();
- const auto *OrigUnitDie = OrigUnit.getUnitDIE(false);
- uint64_t OrigLowPc = OrigUnitDie->getAttributeValueAsAddress(
- &OrigUnit, dwarf::DW_AT_low_pc, -1ULL);
+ auto OrigUnitDie = OrigUnit.getUnitDIE(false);
+ uint64_t OrigLowPc = OrigUnitDie.getAttributeValueAsAddress(
+ dwarf::DW_AT_low_pc, -1ULL);
// Ranges addresses are based on the unit's low_pc. Compute the
// offset we need to apply to adapt to the new unit's low_pc.
int64_t UnitPcOffset = 0;
@@ -2980,9 +2973,9 @@ static void patchStmtList(DIE &Die, DIEI
/// are present in the binary.
void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
DWARFContext &OrigDwarf) {
- const DWARFDebugInfoEntryMinimal *CUDie = Unit.getOrigUnit().getUnitDIE();
- uint64_t StmtList = CUDie->getAttributeValueAsSectionOffset(
- &Unit.getOrigUnit(), dwarf::DW_AT_stmt_list, -1ULL);
+ DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
+ uint64_t StmtList = CUDie.getAttributeValueAsSectionOffset(
+ dwarf::DW_AT_stmt_list, -1ULL);
if (StmtList == -1ULL)
return;
@@ -3212,34 +3205,34 @@ void DwarfLinker::DIECloner::copyAbbrev(
Linker.AssignAbbrev(Copy);
}
-static uint64_t getDwoId(const DWARFDebugInfoEntryMinimal &CUDie,
+static uint64_t getDwoId(const DWARFDie &CUDie,
const DWARFUnit &Unit) {
uint64_t DwoId =
- CUDie.getAttributeValueAsUnsignedConstant(&Unit, dwarf::DW_AT_dwo_id, 0);
+ CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_dwo_id, 0);
if (!DwoId)
- DwoId = CUDie.getAttributeValueAsUnsignedConstant(&Unit,
- dwarf::DW_AT_GNU_dwo_id, 0);
+ DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_GNU_dwo_id,
+ 0);
return DwoId;
}
bool DwarfLinker::registerModuleReference(
- const DWARFDebugInfoEntryMinimal &CUDie, const DWARFUnit &Unit,
+ const DWARFDie &CUDie, const DWARFUnit &Unit,
DebugMap &ModuleMap, unsigned Indent) {
std::string PCMfile =
- CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_dwo_name, "");
+ CUDie.getAttributeValueAsString(dwarf::DW_AT_dwo_name, "");
if (PCMfile.empty())
PCMfile =
- CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_GNU_dwo_name, "");
+ CUDie.getAttributeValueAsString(dwarf::DW_AT_GNU_dwo_name, "");
if (PCMfile.empty())
return false;
// Clang module DWARF skeleton CUs abuse this for the path to the module.
std::string PCMpath =
- CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_comp_dir, "");
+ CUDie.getAttributeValueAsString(dwarf::DW_AT_comp_dir, "");
uint64_t DwoId = getDwoId(CUDie, Unit);
std::string Name =
- CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_name, "");
+ CUDie.getAttributeValueAsString(dwarf::DW_AT_name, "");
if (Name.empty()) {
reportWarning("Anonymous module skeleton CU for " + PCMfile);
return true;
@@ -3340,9 +3333,9 @@ void DwarfLinker::loadClangModule(String
DWARFContextInMemory DwarfContext(*ErrOrObj);
RelocationManager RelocMgr(*this);
for (const auto &CU : DwarfContext.compile_units()) {
- auto *CUDie = CU->getUnitDIE(false);
+ auto CUDie = CU->getUnitDIE(false);
// Recursively get all modules imported by this one.
- if (!registerModuleReference(*CUDie, *CU, ModuleMap, Indent)) {
+ if (!registerModuleReference(CUDie, *CU, ModuleMap, Indent)) {
if (Unit) {
errs() << Filename << ": Clang modules are expected to have exactly"
<< " 1 compile unit.\n";
@@ -3351,7 +3344,7 @@ void DwarfLinker::loadClangModule(String
// FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
// fixed in clang, only warn about DWO_id mismatches in verbose mode.
// ASTFileSignatures will change randomly when a module is rebuilt.
- uint64_t PCMDwoId = getDwoId(*CUDie, *CU);
+ uint64_t PCMDwoId = getDwoId(CUDie, *CU);
if (PCMDwoId != DwoId) {
if (Options.Verbose)
reportWarning(
@@ -3388,11 +3381,11 @@ void DwarfLinker::DIECloner::cloneAllCom
return;
for (auto &CurrentUnit : CompileUnits) {
- const auto *InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
+ auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
CurrentUnit->setStartOffset(Linker.OutputDebugInfoSize);
// Clonse the InputDIE into your Unit DIE in our compile unit since it
// already has a DIE inside of it.
- if (!cloneDIE(*InputDIE, *CurrentUnit, 0 /* PC offset */,
+ if (!cloneDIE(InputDIE, *CurrentUnit, 0 /* PC offset */,
11 /* Unit Header size */, 0,
CurrentUnit->getOutputUnitDIE()))
continue;
@@ -3456,13 +3449,13 @@ bool DwarfLinker::link(const DebugMap &M
// In a first phase, just read in the debug info and load all clang modules.
for (const auto &CU : DwarfContext.compile_units()) {
- auto *CUDie = CU->getUnitDIE(false);
+ auto CUDie = CU->getUnitDIE(false);
if (Options.Verbose) {
outs() << "Input compilation unit:";
- CUDie->dump(outs(), CU.get(), 0);
+ CUDie.dump(outs(), 0);
}
- if (!registerModuleReference(*CUDie, *CU, ModuleMap))
+ if (!registerModuleReference(CUDie, *CU, ModuleMap))
Units.push_back(llvm::make_unique<CompileUnit>(*CU, UnitID++,
!Options.NoODR, ""));
}
@@ -3478,7 +3471,7 @@ bool DwarfLinker::link(const DebugMap &M
// references require the ParentIdx to be setup for every CU in
// the object file before calling this.
for (auto &CurrentUnit : Units)
- lookForDIEsToKeep(RelocMgr, *CurrentUnit->getOrigUnit().getUnitDIE(), *Obj,
+ lookForDIEsToKeep(RelocMgr, CurrentUnit->getOrigUnit().getUnitDIE(), *Obj,
*CurrentUnit, 0);
// The calls to applyValidRelocs inside cloneDIE will walk the
Modified: llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp (original)
+++ llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp Tue Dec 13 12:25:19 2016
@@ -10,7 +10,7 @@
#include "DwarfGenerator.h"
#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
#include "llvm/Support/Dwarf.h"
@@ -215,13 +215,13 @@ void TestAllForms() {
uint32_t NumCUs = DwarfContext.getNumCompileUnits();
EXPECT_EQ(NumCUs, 1u);
DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
- auto DiePtr = U->getUnitDIE(false);
- EXPECT_TRUE(DiePtr != nullptr);
+ auto DieDG = U->getUnitDIE(false);
+ EXPECT_TRUE(DieDG.isValid());
//----------------------------------------------------------------------
// Test address forms
//----------------------------------------------------------------------
- EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_DW_FORM_addr, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_DW_FORM_addr, 0),
AddrValue);
//----------------------------------------------------------------------
@@ -231,28 +231,28 @@ void TestAllForms() {
ArrayRef<uint8_t> ExtractedBlockData;
Optional<ArrayRef<uint8_t>> BlockDataOpt;
- EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block, FormValue));
+ EXPECT_TRUE(DieDG.getAttributeValue(Attr_DW_FORM_block, FormValue));
BlockDataOpt = FormValue.getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block1, FormValue));
+ EXPECT_TRUE(DieDG.getAttributeValue(Attr_DW_FORM_block1, FormValue));
BlockDataOpt = FormValue.getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block2, FormValue));
+ EXPECT_TRUE(DieDG.getAttributeValue(Attr_DW_FORM_block2, FormValue));
BlockDataOpt = FormValue.getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
- EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block4, FormValue));
+ EXPECT_TRUE(DieDG.getAttributeValue(Attr_DW_FORM_block4, FormValue));
BlockDataOpt = FormValue.getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
ExtractedBlockData = BlockDataOpt.getValue();
@@ -263,60 +263,60 @@ void TestAllForms() {
// Test data forms
//----------------------------------------------------------------------
EXPECT_EQ(
- DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data1, 0),
+ DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data1, 0),
Data1);
EXPECT_EQ(
- DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data2, 0),
+ DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data2, 0),
Data2);
EXPECT_EQ(
- DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data4, 0),
+ DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data4, 0),
Data4);
EXPECT_EQ(
- DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data8, 0),
+ DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data8, 0),
Data8);
//----------------------------------------------------------------------
// Test string forms
//----------------------------------------------------------------------
const char *ExtractedStringValue =
- DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_string, nullptr);
+ DieDG.getAttributeValueAsString(Attr_DW_FORM_string, nullptr);
EXPECT_TRUE(ExtractedStringValue != nullptr);
EXPECT_TRUE(strcmp(StringValue, ExtractedStringValue) == 0);
const char *ExtractedStrpValue =
- DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_strp, nullptr);
+ DieDG.getAttributeValueAsString(Attr_DW_FORM_strp, nullptr);
EXPECT_TRUE(ExtractedStrpValue != nullptr);
EXPECT_TRUE(strcmp(StrpValue, ExtractedStrpValue) == 0);
//----------------------------------------------------------------------
// Test reference forms
//----------------------------------------------------------------------
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_addr, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_addr, 0),
RefAddr);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref1, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref1, 0),
Data1);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref2, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref2, 0),
Data2);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref4, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref4, 0),
Data4);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref8, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref8, 0),
Data8);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_sig8, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_sig8, 0),
Data8_2);
- EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_udata, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_udata, 0),
UData[0]);
//----------------------------------------------------------------------
// Test flag forms
//----------------------------------------------------------------------
- EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
- U, Attr_DW_FORM_flag_true, 0ULL),
+ EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
+ Attr_DW_FORM_flag_true, 0ULL),
1ULL);
- EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
- U, Attr_DW_FORM_flag_false, 1ULL),
+ EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
+ Attr_DW_FORM_flag_false, 1ULL),
0ULL);
- EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
- U, Attr_DW_FORM_flag_present, 0ULL),
+ EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
+ Attr_DW_FORM_flag_present, 0ULL),
1ULL);
// TODO: test Attr_DW_FORM_implicit_const extraction
@@ -324,30 +324,30 @@ void TestAllForms() {
//----------------------------------------------------------------------
// Test SLEB128 based forms
//----------------------------------------------------------------------
- EXPECT_EQ(DiePtr->getAttributeValueAsSignedConstant(U, Attr_DW_FORM_sdata, 0),
+ EXPECT_EQ(DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_sdata, 0),
SData);
//----------------------------------------------------------------------
// Test ULEB128 based forms
//----------------------------------------------------------------------
EXPECT_EQ(
- DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_udata, 0),
+ DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_udata, 0),
UData[0]);
//----------------------------------------------------------------------
// Test DWARF32/DWARF64 forms
//----------------------------------------------------------------------
EXPECT_EQ(
- DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_GNU_ref_alt, 0),
+ DieDG.getAttributeValueAsReference(Attr_DW_FORM_GNU_ref_alt, 0),
Dwarf32Values[0]);
EXPECT_EQ(
- DiePtr->getAttributeValueAsSectionOffset(U, Attr_DW_FORM_sec_offset, 0),
+ DieDG.getAttributeValueAsSectionOffset(Attr_DW_FORM_sec_offset, 0),
Dwarf32Values[1]);
//----------------------------------------------------------------------
// Add an address at the end to make sure we can decode this value
//----------------------------------------------------------------------
- EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_Last, 0), AddrValue);
+ EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_Last, 0), AddrValue);
}
TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
@@ -449,41 +449,41 @@ template <uint16_t Version, class AddrTy
DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
// Get the compile unit DIE is valid.
- auto DiePtr = U->getUnitDIE(false);
- EXPECT_TRUE(DiePtr != nullptr);
- // DiePtr->dump(llvm::outs(), U, UINT32_MAX);
+ auto DieDG = U->getUnitDIE(false);
+ EXPECT_TRUE(DieDG.isValid());
+ // DieDG.dump(llvm::outs(), U, UINT32_MAX);
// Verify the first child of the compile unit DIE is our subprogram.
- auto SubprogramDiePtr = DiePtr->getFirstChild();
- EXPECT_TRUE(SubprogramDiePtr != nullptr);
- EXPECT_EQ(SubprogramDiePtr->getTag(), DW_TAG_subprogram);
+ auto SubprogramDieDG = DieDG.getFirstChild();
+ EXPECT_TRUE(SubprogramDieDG.isValid());
+ EXPECT_EQ(SubprogramDieDG.getTag(), DW_TAG_subprogram);
// Verify the first child of the subprogram is our formal parameter.
- auto ArgcDiePtr = SubprogramDiePtr->getFirstChild();
- EXPECT_TRUE(ArgcDiePtr != nullptr);
- EXPECT_EQ(ArgcDiePtr->getTag(), DW_TAG_formal_parameter);
+ auto ArgcDieDG = SubprogramDieDG.getFirstChild();
+ EXPECT_TRUE(ArgcDieDG.isValid());
+ EXPECT_EQ(ArgcDieDG.getTag(), DW_TAG_formal_parameter);
// Verify our formal parameter has a NULL tag sibling.
- auto NullDiePtr = ArgcDiePtr->getSibling();
- EXPECT_TRUE(NullDiePtr != nullptr);
- if (NullDiePtr) {
- EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null);
- EXPECT_TRUE(NullDiePtr->getSibling() == nullptr);
- EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr);
+ auto NullDieDG = ArgcDieDG.getSibling();
+ EXPECT_TRUE(NullDieDG.isValid());
+ if (NullDieDG) {
+ EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
+ EXPECT_TRUE(!NullDieDG.getSibling().isValid());
+ EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
}
// Verify the sibling of our subprogram is our integer base type.
- auto IntDiePtr = SubprogramDiePtr->getSibling();
- EXPECT_TRUE(IntDiePtr != nullptr);
- EXPECT_EQ(IntDiePtr->getTag(), DW_TAG_base_type);
+ auto IntDieDG = SubprogramDieDG.getSibling();
+ EXPECT_TRUE(IntDieDG.isValid());
+ EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
// Verify the sibling of our subprogram is our integer base is a NULL tag.
- NullDiePtr = IntDiePtr->getSibling();
- EXPECT_TRUE(NullDiePtr != nullptr);
- if (NullDiePtr) {
- EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null);
- EXPECT_TRUE(NullDiePtr->getSibling() == nullptr);
- EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr);
+ NullDieDG = IntDieDG.getSibling();
+ EXPECT_TRUE(NullDieDG.isValid());
+ if (NullDieDG) {
+ EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
+ EXPECT_TRUE(!NullDieDG.getSibling().isValid());
+ EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
}
}
@@ -623,127 +623,127 @@ template <uint16_t Version, class AddrTy
DWARFCompileUnit *U2 = DwarfContext.getCompileUnitAtIndex(1);
// Get the compile unit DIE is valid.
- auto Unit1DiePtr = U1->getUnitDIE(false);
- EXPECT_TRUE(Unit1DiePtr != nullptr);
- // Unit1DiePtr->dump(llvm::outs(), U1, UINT32_MAX);
-
- auto Unit2DiePtr = U2->getUnitDIE(false);
- EXPECT_TRUE(Unit2DiePtr != nullptr);
- // Unit2DiePtr->dump(llvm::outs(), U2, UINT32_MAX);
+ auto Unit1DieDG = U1->getUnitDIE(false);
+ EXPECT_TRUE(Unit1DieDG.isValid());
+ // Unit1DieDG.dump(llvm::outs(), UINT32_MAX);
+
+ auto Unit2DieDG = U2->getUnitDIE(false);
+ EXPECT_TRUE(Unit2DieDG.isValid());
+ // Unit2DieDG.dump(llvm::outs(), UINT32_MAX);
// Verify the first child of the compile unit 1 DIE is our int base type.
- auto CU1TypeDiePtr = Unit1DiePtr->getFirstChild();
- EXPECT_TRUE(CU1TypeDiePtr != nullptr);
- EXPECT_EQ(CU1TypeDiePtr->getTag(), DW_TAG_base_type);
+ auto CU1TypeDieDG = Unit1DieDG.getFirstChild();
+ EXPECT_TRUE(CU1TypeDieDG.isValid());
+ EXPECT_EQ(CU1TypeDieDG.getTag(), DW_TAG_base_type);
EXPECT_EQ(
- CU1TypeDiePtr->getAttributeValueAsUnsignedConstant(U1, DW_AT_encoding, 0),
+ CU1TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding, 0),
DW_ATE_signed);
// Verify the first child of the compile unit 2 DIE is our float base type.
- auto CU2TypeDiePtr = Unit2DiePtr->getFirstChild();
- EXPECT_TRUE(CU2TypeDiePtr != nullptr);
- EXPECT_EQ(CU2TypeDiePtr->getTag(), DW_TAG_base_type);
+ auto CU2TypeDieDG = Unit2DieDG.getFirstChild();
+ EXPECT_TRUE(CU2TypeDieDG.isValid());
+ EXPECT_EQ(CU2TypeDieDG.getTag(), DW_TAG_base_type);
EXPECT_EQ(
- CU2TypeDiePtr->getAttributeValueAsUnsignedConstant(U2, DW_AT_encoding, 0),
+ CU2TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding, 0),
DW_ATE_float);
// Verify the sibling of the base type DIE is our Ref1 DIE and that its
// DW_AT_type points to our base type DIE.
- auto CU1Ref1DiePtr = CU1TypeDiePtr->getSibling();
- EXPECT_TRUE(CU1Ref1DiePtr != nullptr);
- EXPECT_EQ(CU1Ref1DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1Ref1DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
- CU1TypeDiePtr->getOffset());
+ auto CU1Ref1DieDG = CU1TypeDieDG.getSibling();
+ EXPECT_TRUE(CU1Ref1DieDG.isValid());
+ EXPECT_EQ(CU1Ref1DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU1Ref1DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU1TypeDieDG.getOffset());
// Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
- auto CU1Ref2DiePtr = CU1Ref1DiePtr->getSibling();
- EXPECT_TRUE(CU1Ref2DiePtr != nullptr);
- EXPECT_EQ(CU1Ref2DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1Ref2DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
- CU1TypeDiePtr->getOffset());
+ auto CU1Ref2DieDG = CU1Ref1DieDG.getSibling();
+ EXPECT_TRUE(CU1Ref2DieDG.isValid());
+ EXPECT_EQ(CU1Ref2DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU1Ref2DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU1TypeDieDG.getOffset());
// Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
- auto CU1Ref4DiePtr = CU1Ref2DiePtr->getSibling();
- EXPECT_TRUE(CU1Ref4DiePtr != nullptr);
- EXPECT_EQ(CU1Ref4DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1Ref4DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
- CU1TypeDiePtr->getOffset());
+ auto CU1Ref4DieDG = CU1Ref2DieDG.getSibling();
+ EXPECT_TRUE(CU1Ref4DieDG.isValid());
+ EXPECT_EQ(CU1Ref4DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU1Ref4DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU1TypeDieDG.getOffset());
// Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
// base type DIE in CU1.
- auto CU1Ref8DiePtr = CU1Ref4DiePtr->getSibling();
- EXPECT_TRUE(CU1Ref8DiePtr != nullptr);
- EXPECT_EQ(CU1Ref8DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1Ref8DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
- CU1TypeDiePtr->getOffset());
+ auto CU1Ref8DieDG = CU1Ref4DieDG.getSibling();
+ EXPECT_TRUE(CU1Ref8DieDG.isValid());
+ EXPECT_EQ(CU1Ref8DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU1Ref8DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU1TypeDieDG.getOffset());
// Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
// base type DIE in CU1.
- auto CU1RefAddrDiePtr = CU1Ref8DiePtr->getSibling();
- EXPECT_TRUE(CU1RefAddrDiePtr != nullptr);
- EXPECT_EQ(CU1RefAddrDiePtr->getTag(), DW_TAG_variable);
+ auto CU1RefAddrDieDG = CU1Ref8DieDG.getSibling();
+ EXPECT_TRUE(CU1RefAddrDieDG.isValid());
+ EXPECT_EQ(CU1RefAddrDieDG.getTag(), DW_TAG_variable);
EXPECT_EQ(
- CU1RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
- CU1TypeDiePtr->getOffset());
+ CU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU1TypeDieDG.getOffset());
// Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
// DW_AT_type points to our base type DIE.
- auto CU1ToCU2RefAddrDiePtr = CU1RefAddrDiePtr->getSibling();
- EXPECT_TRUE(CU1ToCU2RefAddrDiePtr != nullptr);
- EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type,
+ auto CU1ToCU2RefAddrDieDG = CU1RefAddrDieDG.getSibling();
+ EXPECT_TRUE(CU1ToCU2RefAddrDieDG.isValid());
+ EXPECT_EQ(CU1ToCU2RefAddrDieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU1ToCU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type,
-1ULL),
- CU2TypeDiePtr->getOffset());
+ CU2TypeDieDG.getOffset());
// Verify the sibling of the base type DIE is our Ref1 DIE and that its
// DW_AT_type points to our base type DIE.
- auto CU2Ref1DiePtr = CU2TypeDiePtr->getSibling();
- EXPECT_TRUE(CU2Ref1DiePtr != nullptr);
- EXPECT_EQ(CU2Ref1DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2Ref1DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
- CU2TypeDiePtr->getOffset());
+ auto CU2Ref1DieDG = CU2TypeDieDG.getSibling();
+ EXPECT_TRUE(CU2Ref1DieDG.isValid());
+ EXPECT_EQ(CU2Ref1DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU2Ref1DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU2TypeDieDG.getOffset());
// Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
- auto CU2Ref2DiePtr = CU2Ref1DiePtr->getSibling();
- EXPECT_TRUE(CU2Ref2DiePtr != nullptr);
- EXPECT_EQ(CU2Ref2DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2Ref2DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
- CU2TypeDiePtr->getOffset());
+ auto CU2Ref2DieDG = CU2Ref1DieDG.getSibling();
+ EXPECT_TRUE(CU2Ref2DieDG.isValid());
+ EXPECT_EQ(CU2Ref2DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU2Ref2DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU2TypeDieDG.getOffset());
// Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
- auto CU2Ref4DiePtr = CU2Ref2DiePtr->getSibling();
- EXPECT_TRUE(CU2Ref4DiePtr != nullptr);
- EXPECT_EQ(CU2Ref4DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2Ref4DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
- CU2TypeDiePtr->getOffset());
+ auto CU2Ref4DieDG = CU2Ref2DieDG.getSibling();
+ EXPECT_TRUE(CU2Ref4DieDG.isValid());
+ EXPECT_EQ(CU2Ref4DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU2Ref4DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU2TypeDieDG.getOffset());
// Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
// base type DIE in CU2.
- auto CU2Ref8DiePtr = CU2Ref4DiePtr->getSibling();
- EXPECT_TRUE(CU2Ref8DiePtr != nullptr);
- EXPECT_EQ(CU2Ref8DiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2Ref8DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
- CU2TypeDiePtr->getOffset());
+ auto CU2Ref8DieDG = CU2Ref4DieDG.getSibling();
+ EXPECT_TRUE(CU2Ref8DieDG.isValid());
+ EXPECT_EQ(CU2Ref8DieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU2Ref8DieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU2TypeDieDG.getOffset());
// Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
// base type DIE in CU2.
- auto CU2RefAddrDiePtr = CU2Ref8DiePtr->getSibling();
- EXPECT_TRUE(CU2RefAddrDiePtr != nullptr);
- EXPECT_EQ(CU2RefAddrDiePtr->getTag(), DW_TAG_variable);
+ auto CU2RefAddrDieDG = CU2Ref8DieDG.getSibling();
+ EXPECT_TRUE(CU2RefAddrDieDG.isValid());
+ EXPECT_EQ(CU2RefAddrDieDG.getTag(), DW_TAG_variable);
EXPECT_EQ(
- CU2RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
- CU2TypeDiePtr->getOffset());
+ CU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type, -1ULL),
+ CU2TypeDieDG.getOffset());
// Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
// DW_AT_type points to our base type DIE.
- auto CU2ToCU1RefAddrDiePtr = CU2RefAddrDiePtr->getSibling();
- EXPECT_TRUE(CU2ToCU1RefAddrDiePtr != nullptr);
- EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getTag(), DW_TAG_variable);
- EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type,
+ auto CU2ToCU1RefAddrDieDG = CU2RefAddrDieDG.getSibling();
+ EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
+ EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
+ EXPECT_EQ(CU2ToCU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type,
-1ULL),
- CU1TypeDiePtr->getOffset());
+ CU1TypeDieDG.getOffset());
}
TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
Modified: llvm/trunk/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/DWARF/DwarfGenerator.cpp?rev=289565&r1=289564&r2=289565&view=diff
==============================================================================
--- llvm/trunk/unittests/DebugInfo/DWARF/DwarfGenerator.cpp (original)
+++ llvm/trunk/unittests/DebugInfo/DWARF/DwarfGenerator.cpp Tue Dec 13 12:25:19 2016
@@ -13,7 +13,6 @@
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/DIE.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "llvm/IR/LegacyPassManagers.h"
More information about the llvm-commits
mailing list