[DWARF parser] Compress DIEMinimal even further, simplify building DIE tree.

DIE doesn't need to store a pointer to its parent: we can traverse the DIE tree
only with functions getFirstChild() and getSibling(). Parents must be known
only when we construct the tree. Rewrite setDIERelations() procedure in a more
straightforward way, and get rid of lots of now unused DIEMinimal methods.

No functionality change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207563 91177308-0d34-0410-b5e6-96231b3b80d8

lib/DebugInfo/DWARFDebugInfoEntry.h

@@ -29,17 +29,13 @@ class DWARFDebugInfoEntryMinimal {
   /// Offset within the .debug_info of the start of this entry.
   uint32_t Offset;
 
-  /// How many to subtract from "this" to get the parent.
-  /// If zero this die has no parent.
-  uint32_t ParentIdx;
-
   /// How many to add to "this" to get the sibling.
   uint32_t SiblingIdx;
 
   const DWARFAbbreviationDeclaration *AbbrevDecl;
 public:
   DWARFDebugInfoEntryMinimal()
-    : Offset(0), ParentIdx(0), SiblingIdx(0), AbbrevDecl(nullptr) {}
+    : Offset(0), SiblingIdx(0), AbbrevDecl(nullptr) {}
 
   void dump(raw_ostream &OS, const DWARFUnit *u, unsigned recurseDepth,
             unsigned indent = 0) const;
@@ -63,46 +59,24 @@ public:
   uint32_t getOffset() const { return Offset; }
   bool hasChildren() const { return !isNULL() && AbbrevDecl->hasChildren(); }
 
-  // We know we are kept in a vector of contiguous entries, so we know
-  // our parent will be some index behind "this".
-  DWARFDebugInfoEntryMinimal *getParent() {
-    return ParentIdx > 0 ? this - ParentIdx : nullptr;
-  }
-  const DWARFDebugInfoEntryMinimal *getParent() const {
-    return ParentIdx > 0 ? this - ParentIdx : nullptr;
-  }
   // We know we are kept in a vector of contiguous entries, so we know
   // our sibling will be some index after "this".
-  DWARFDebugInfoEntryMinimal *getSibling() {
-    return SiblingIdx > 0 ? this + SiblingIdx : nullptr;
-  }
   const DWARFDebugInfoEntryMinimal *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...
-  DWARFDebugInfoEntryMinimal *getFirstChild() {
-    return hasChildren() ? this + 1 : nullptr;
-  }
   const DWARFDebugInfoEntryMinimal *getFirstChild() const {
     return hasChildren() ? this + 1 : nullptr;
   }
 
-  void setParent(DWARFDebugInfoEntryMinimal *parent) {
+  void setSibling(const DWARFDebugInfoEntryMinimal *Sibling) {
-    if (parent) {
+    if (Sibling) {
-      // We know we are kept in a vector of contiguous entries, so we know
-      // our parent will be some index behind "this".
-      ParentIdx = this - parent;
-    } else
-      ParentIdx = 0;
-  }
-  void setSibling(DWARFDebugInfoEntryMinimal *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".
-      SiblingIdx = sibling - this;
+      SiblingIdx = Sibling - this;
-      sibling->setParent(getParent());
     } else
       SiblingIdx = 0;
   }

lib/DebugInfo/DWARFUnit.cpp

@@ -126,38 +126,32 @@ uint64_t DWARFUnit::getDWOId() {
 }
 
 void DWARFUnit::setDIERelations() {
-  if (DieArray.empty())
+  if (DieArray.size() <= 1)
     return;
-  DWARFDebugInfoEntryMinimal *die_array_begin = &DieArray.front();
-  DWARFDebugInfoEntryMinimal *die_array_end = &DieArray.back();
-  DWARFDebugInfoEntryMinimal *curr_die;
-  // We purposely are skipping the last element in the array in the loop below
-  // so that we can always have a valid next item
-  for (curr_die = die_array_begin; curr_die < die_array_end; ++curr_die) {
-    // Since our loop doesn't include the last element, we can always
-    // safely access the next die in the array.
-    DWARFDebugInfoEntryMinimal *next_die = curr_die + 1;
 
-    const DWARFAbbreviationDeclaration *curr_die_abbrev =
+  std::vector<DWARFDebugInfoEntryMinimal *> ParentChain;
-      curr_die->getAbbreviationDeclarationPtr();
+  DWARFDebugInfoEntryMinimal *SiblingChain = nullptr;
-
+  for (auto &DIE : DieArray) {
-    if (curr_die_abbrev) {
+    if (SiblingChain) {
-      // Normal DIE
+      SiblingChain->setSibling(&DIE);
-      if (curr_die_abbrev->hasChildren())
+    }
-        next_die->setParent(curr_die);
+    if (const DWARFAbbreviationDeclaration *AbbrDecl =
-      else
+            DIE.getAbbreviationDeclarationPtr()) {
-        curr_die->setSibling(next_die);
+      // Normal DIE.
+      if (AbbrDecl->hasChildren()) {
+        ParentChain.push_back(&DIE);
+        SiblingChain = nullptr;
+      } else {
+        SiblingChain = &DIE;
+      }
     } else {
-      // NULL DIE that terminates a sibling chain
+      // NULL entry terminates the sibling chain.
-      DWARFDebugInfoEntryMinimal *parent = curr_die->getParent();
+      SiblingChain = ParentChain.back();
-      if (parent)
+      ParentChain.pop_back();
-        parent->setSibling(next_die);
     }
   }
-
+  assert(SiblingChain == nullptr || SiblingChain == &DieArray[0]);
-  // Since we skipped the last element, we need to fix it up!
+  assert(ParentChain.empty());
-  if (die_array_begin < die_array_end)
-    curr_die->setParent(die_array_begin);
 }
 
 void DWARFUnit::extractDIEsToVector(
@@ -189,9 +183,8 @@ void DWARFUnit::extractDIEsToVector(
       Dies.push_back(DIE);
     }
 
-    const DWARFAbbreviationDeclaration *AbbrDecl =
+    if (const DWARFAbbreviationDeclaration *AbbrDecl =
-      DIE.getAbbreviationDeclarationPtr();
+            DIE.getAbbreviationDeclarationPtr()) {
-    if (AbbrDecl) {
       // Normal DIE
       if (AbbrDecl->hasChildren())
         ++Depth;