[BOLT][DWARF] Numerous fixes for a new DWARFRewriter

Summary:

* Some cleanup and minor fixes for the new debug information re-writer before moving on
to productatization.

* The new rewriter wasn't handling binary with DWARF5 and DWARF4 with
-fdebug-types-sections.

* Removed dead cross cu reference code.

* Added support for DW_AT_sibling.

* With the new re-writer abbrev number can change which can lead to offset of Type
Units changing. Before we would just copy raw data. Changed to write out Type
Unit List. This is generated by gdb-add-index.

* Fixed how bolt handles gdb-index generated by gdb-11 with types sections.
Simplified logic that handles variations of gdb-index.

* Clang can generate two type units with the same hash, but different content. LLD
does not de-duplicate when ThinLTO is involved. Changed so that TU hash and
offset are used to make TU's unique.

* It is possible to have references within location expression to another DIE.
Fixed it so that relative offset is updated correctly.

* Removed all the code related to patching.

* Removed dead code. Changed how we handling writting out TUs and TU Index. It now
  should fully work for DWARF4 and DWARF5.

* Removed unused arguments from some APIs, changed return type to void, and other
small cleanups.

Test Plan:

Reviewers:

Subscribers:

Tasks:

Tags:

Differential Revision: https://phabricator.intern.facebook.com/D46168257

Author: ayermolo

bolt/include/bolt/Core/DIEBuilder.h

@@ -16,223 +16,233 @@
 #define BOLT_CORE_DIE_BUILDER_H
 
 #include "llvm/CodeGen/DIE.h"
-#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
-#include "llvm/IR/Type.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 
-#include <cstdint>
-#include <forward_list>
 #include <list>
 #include <memory>
-#include <mutex>
 #include <optional>
-#include <set>
-#include <shared_mutex>
-#include <sys/types.h>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 namespace llvm {
 
 namespace bolt {
+class DIEStreamer;
 
 class DIEBuilder {
+  friend DIEStreamer;
+
+public:
+  /// Wrapper around DIE so we can access DIEs easily.
   struct DIEInfo {
     DIE *Die;
     uint32_t DieId;
     uint32_t UnitId;
-    uint32_t CanonicalDIEOffset;
   };
 
-  struct UnitInfo {
-    std::list<DIEInfo> DieInfoList;
-    uint32_t UnitId;
-    uint32_t UnitOffset;
-    bool Isconstructed = false;
-    uint32_t NewDieId = 0;
+  /// Contains information for the CU level of DWARF.
+  struct DWARFUnitInfo {
+    // Contains all the DIEs for the current unit.
+    // Accessed by DIE ID.
+    std::vector<std::unique_ptr<DIEInfo>> DieInfoVector;
+    DIE *UnitDie = nullptr;
+    uint32_t UnitId = 0;
+    uint32_t UnitOffset = 0;
+    uint32_t UnitLength = 0;
+    bool IsConstructed = false;
+    // A map of DIE offsets in original DWARF section to DIE ID.
+    // Whih is used to access DieInfoVector.
     std::unordered_map<uint64_t, uint32_t> DIEIDMap;
-    std::unordered_map<uint32_t, DIEInfo *> DIEId2InfoMap;
   };
 
-  struct ForwardReferenceInfo {
-    ForwardReferenceInfo(DIEInfo *Die,
-                         DWARFAbbreviationDeclaration::AttributeSpec spec)
-        : Dst(Die), AttrSpec(spec) {}
+private:
+  /// Contains information so that we we can update references in locexpr after
+  /// we calculated all the final DIE offsets.
+  struct LocWithReference {
+    LocWithReference(std::vector<uint8_t> &&BlockData, DWARFUnit &U, DIE &Die,
+                     dwarf::Form Form, dwarf::Attribute Attr)
+        : BlockData(BlockData), U(U), Die(Die), Form(Form), Attr(Attr) {}
+    std::vector<uint8_t> BlockData;
+    DWARFUnit &U;
+    DIE &Die;
+    dwarf::Form Form;
+    dwarf::Attribute Attr;
+  };
+  /// Contains information so that we can update cross CU references, after we
+  /// calculated all the final DIE offsets.
+  struct AddrReferenceInfo {
+    AddrReferenceInfo(DIEInfo *Die,
+                      DWARFAbbreviationDeclaration::AttributeSpec Spec)
+        : Dst(Die), AttrSpec(Spec) {}
     DIEInfo *Dst;
     DWARFAbbreviationDeclaration::AttributeSpec AttrSpec;
   };
 
-  bool IsBuilt = false;
-  std::unordered_map<DWARFUnit *, std::vector<DIE *>> UnitDIEs;
-  std::unordered_map<DWARFUnit *, uint32_t> UnitIDMap;
+  /// A map of Units to Unit Index.
+  std::unordered_map<uint64_t, uint32_t> UnitIDMap;
+  /// A map of Type Units to Type DIEs.
   std::unordered_map<DWARFUnit *, DIE *> TypeDIEMap;
   std::vector<DWARFUnit *> DUList;
-  std::vector<UnitInfo> CloneUnitCtxMap;
-  std::vector<std::pair<DIEInfo *, ForwardReferenceInfo>> ForwardReferences;
+  std::vector<DWARFUnitInfo> CloneUnitCtxMap;
+  std::vector<std::pair<DIEInfo *, AddrReferenceInfo>> AddrReferences;
   FoldingSet<DIEAbbrev> AbbreviationsSet;
   std::vector<std::unique_ptr<DIEAbbrev>> Abbreviations;
   std::vector<DWARFUnit *> DWARF4TUVector;
-  std::vector<DWARFUnit *> DWARF4CUVector;
+  std::vector<LocWithReference> LocWithReferencesToProcess;
   BumpPtrAllocator DIEAlloc;
 
   /// Resolve the reference in DIE, if target is not loaded into IR,
   /// pre-allocate it. \p RefCU will be updated to the Unit specific by \p
   /// RefValue.
-  DWARFDie
-  resolveDIEReference(const DWARFFormValue &RefValue,
-                      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                      DWARFUnit *&RefCU,
-                      DWARFDebugInfoEntry &DwarfDebugInfoEntry,
-                      const std::vector<DWARFUnit *> &DUOffsetList);
-
-  /// Clone one attribute according the format. \return the size of this
+  DWARFDie resolveDIEReference(const DWARFFormValue &RefValue,
+                               DWARFUnit *&RefCU,
+                               DWARFDebugInfoEntry &DwarfDebugInfoEntry,
+                               const std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Resolve the reference in DIE, if target is not loaded into IR,
+  /// pre-allocate it. \p RefCU will be updated to the Unit specific by \p
+  /// RefValue.
+  DWARFDie resolveDIEReference(const uint64_t ReffOffset, DWARFUnit *&RefCU,
+                               DWARFDebugInfoEntry &DwarfDebugInfoEntry,
+                               const std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Clone one attribute according to the format. \return the size of this
   /// attribute.
-  uint32_t
+  void
   cloneAttribute(DIE &Die, const DWARFDie &InputDIE, DWARFUnit &U,
                  const DWARFFormValue &Val,
                  const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                 unsigned AttrSize, bool IsLittleEndian,
-                 std::vector<DWARFUnit *> &DUOffsetList);
+                 const std::vector<DWARFUnit *> &DUOffsetList);
 
   /// Clone an attribute in string format.
-  uint32_t cloneStringAttribute(
-      DIE &Die, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-      unsigned AttrSize, const DWARFFormValue &Val, const DWARFUnit &U);
+  void cloneStringAttribute(
+      DIE &Die, const DWARFUnit &U,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
   /// Clone an attribute in reference format.
-  uint32_t cloneDieReferenceAttribute(
-      DIE &Die, const DWARFDie &InputDIE,
-      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, unsigned AttrSize,
-      const DWARFFormValue &Val, DWARFUnit &U,
-      std::vector<DWARFUnit *> &DUOffsetList);
+  void cloneDieReferenceAttribute(
+      DIE &Die, const DWARFUnit &U, const DWARFDie &InputDIE,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val, const std::vector<DWARFUnit *> &DUOffsetList);
 
   /// Clone an attribute in block format.
-  uint32_t
-  cloneBlockAttribute(DIE &Die, DWARFUnit &U,
-                      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                      const DWARFFormValue &Val, unsigned AttrSize,
-                      bool IsLittleEndian);
+  void cloneBlockAttribute(
+      DIE &Die, DWARFUnit &U,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
+  enum class CloneExpressionStage { INIT, PATCH };
   /// Clone an attribute in expression format. \p OutputBuffer will hold the
   /// output content.
-  void cloneExpression(DataExtractor &Data, DWARFExpression &Expression,
-                       DWARFUnit &U, SmallVectorImpl<uint8_t> &OutputBuffer);
+  /// Returns true if Expression contains a reference.
+  bool cloneExpression(const DataExtractor &Data,
+                       const DWARFExpression &Expression, DWARFUnit &U,
+                       SmallVectorImpl<uint8_t> &OutputBuffer,
+                       const CloneExpressionStage &Stage);
 
   /// Clone an attribute in address format.
-  uint32_t
-  cloneAddressAttribute(DIE &Die,
-                        DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                        const DWARFFormValue &Val, const DWARFUnit &U);
+  void cloneAddressAttribute(
+      DIE &Die, const DWARFUnit &U,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
-  /// Clone an attribute in Refsig format.
-  uint32_t
-  cloneRefsigAttribute(DIE &Die,
-                       DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                       unsigned AttrSize, const DWARFFormValue &Val);
+  /// Clone an attribute in refsig format.
+  void cloneRefsigAttribute(
+      DIE &Die, const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
   /// Clone an attribute in scalar format.
-  uint32_t
-  cloneScalarAttribute(DIE &Die, const DWARFDie &InputDIE,
-                       DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                       const DWARFFormValue &Val, unsigned AttrSize);
+  void cloneScalarAttribute(
+      DIE &Die, const DWARFDie &InputDIE,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
   /// Clone an attribute in loclist format.
-  uint32_t
-  cloneLoclistAttrubute(DIE &Die, const DWARFDie &InputDIE,
-                        DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                        const DWARFFormValue &Val, unsigned AttrSize);
+  void cloneLoclistAttrubute(
+      DIE &Die, const DWARFDie &InputDIE,
+      const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      const DWARFFormValue &Val);
 
-  /// Update the Cross-CU reference offset.
-  void computeReference();
+  /// Update references once the layout is finalized.
+  void updateReferences();
 
   /// Update the Offset and Size of DIE.
-  uint32_t computeDIEOffset(DWARFUnit &CU, DIE &Die, uint32_t &CurOffset);
+  uint32_t computeDIEOffset(const DWARFUnit &CU, DIE &Die, uint32_t &CurOffset);
 
-  void registerUnit(DWARFUnit &Unit) {
-    UnitIDMap[&Unit] = DUList.size();
-    DUList.push_back(&Unit);
-  }
+  void registerUnit(DWARFUnit &DU);
 
   /// \return the unique ID of \p U if it exists.
-  std::optional<uint32_t> getUnitId(DWARFUnit &DU) {
-    if (UnitIDMap.count(&DU))
-      return UnitIDMap[&DU];
-    return std::nullopt;
-  }
+  std::optional<uint32_t> getUnitId(const DWARFUnit &DU);
 
-  UnitInfo &getUnitInfo(uint32_t UnitId) { return CloneUnitCtxMap[UnitId]; }
+  DWARFUnitInfo &getUnitInfo(uint32_t UnitId) {
+    return CloneUnitCtxMap[UnitId];
+  }
 
   DIEInfo &getDIEInfo(uint32_t UnitId, uint32_t DIEId) {
-    if (CloneUnitCtxMap[UnitId].DIEId2InfoMap.count(DIEId))
-      return *CloneUnitCtxMap[UnitId].DIEId2InfoMap[DIEId];
+    if (CloneUnitCtxMap[UnitId].DieInfoVector.size() > DIEId)
+      return *CloneUnitCtxMap[UnitId].DieInfoVector[DIEId].get();
 
-    errs() << "BOLT-ERROR: The DIE is not allocated before looking up, some"
+    errs() << "BOLT-WARNING: [internal-dwarf-error]: The DIE is not allocated "
+              "before looking up, some"
            << "unexpected corner cases happened.\n";
-    return CloneUnitCtxMap[UnitId].DieInfoList.front();
+    return *CloneUnitCtxMap[UnitId].DieInfoVector.front().get();
   }
 
-  UnitInfo &getUnitInfoByDwarfUnit(DWARFUnit &DwarfUnit) {
-    std::optional<uint32_t> UnitId = getUnitId(DwarfUnit);
-    return getUnitInfo(*UnitId);
-  }
-
-  std::optional<uint32_t> getAllocDIEId(DWARFUnit &DU, DWARFDie &DDie) {
-    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(DU);
-    uint64_t Offset = DDie.getOffset();
-
-    if (!UnitInfo.DIEIDMap.count(Offset))
-      return std::nullopt;
-    return UnitInfo.DIEIDMap[Offset];
+  std::optional<uint32_t> getAllocDIEId(const DWARFUnit &DU,
+                                        const uint64_t Offset) {
+    const DWARFUnitInfo &DWARFUnitInfo = getUnitInfoByDwarfUnit(DU);
+    auto Iter = DWARFUnitInfo.DIEIDMap.find(Offset);
+    return (Iter == DWARFUnitInfo.DIEIDMap.end())
+               ? std::nullopt
+               : std::optional<uint32_t>(Iter->second);
   }
-
-  std::optional<uint32_t> getAllocDIEId(DWARFUnit &DU, uint64_t Offset) {
-    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(DU);
-
-    if (!UnitInfo.DIEIDMap.count(Offset))
-      return std::nullopt;
-    return UnitInfo.DIEIDMap[Offset];
+  std::optional<uint32_t> getAllocDIEId(const DWARFUnit &DU,
+                                        const DWARFDie &DDie) {
+    return getAllocDIEId(DU, DDie.getOffset());
   }
 
-  // To avoid overhead, do not use this unless we do get the UnitInfo first.
-  // We can use getDIEInfo with UnitId and DieId
-  DIEInfo &getDIEInfoByDwarfDie(DWARFDie *DwarfDie) {
-    DWARFUnit *DwarfUnit = DwarfDie->getDwarfUnit();
-    std::optional<uint32_t> UnitId = getUnitId(*DwarfUnit);
-    std::optional<uint32_t> hasDIEId = getAllocDIEId(*DwarfUnit, *DwarfDie);
-    assert(hasDIEId.has_value());
+  // To avoid overhead, do not use this unless we do get the DWARFUnitInfo
+  // first. We can use getDIEInfo with UnitId and DieId
+  DIEInfo &getDIEInfoByDwarfDie(DWARFDie &DwarfDie) {
+    DWARFUnit &DwarfUnit = *DwarfDie.getDwarfUnit();
+    std::optional<uint32_t> UnitId = getUnitId(DwarfUnit);
+    std::optional<uint32_t> HasDieId = getAllocDIEId(DwarfUnit, DwarfDie);
+    assert(HasDieId);
 
-    return getDIEInfo(*UnitId, *hasDIEId);
+    return getDIEInfo(*UnitId, *HasDieId);
   }
 
-  std::optional<uint32_t> allocDIE(DWARFUnit &DU, DWARFDie &DDie,
-                                   BumpPtrAllocator &Alloc, uint32_t UId,
-                                   uint32_t offset = 0);
-
-  uint32_t AllocDIEId(DWARFUnit &DU) {
-    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(DU);
-    return UnitInfo.NewDieId++;
-  }
+  uint32_t allocDIE(const DWARFUnit &DU, const DWARFDie &DDie,
+                    BumpPtrAllocator &Alloc, const uint32_t UId);
 
   /// Construct IR for \p DU. \p DUOffsetList specific the Unit in current
   /// Section.
   void constructFromUnit(DWARFUnit &DU, std::vector<DWARFUnit *> &DUOffsetList);
 
   /// Construct a DIE for \p DDie in \p U. \p DUOffsetList specific the Unit in
   /// current Section.
-  DIE *constructDIEFast(DWARFDie &DDie, DWARFUnit &U, bool IsLittleEndian,
-                        uint32_t UnitId,
+  DIE *constructDIEFast(DWARFDie &DDie, DWARFUnit &U, uint32_t UnitId,
                         std::vector<DWARFUnit *> &DUOffsetList);
 
 public:
   DIEBuilder(DWARFContext *DwarfContext, bool IsDWO = false);
 
-  std::vector<DIE *> getDIEsByUnit(DWARFUnit &DU) { return UnitDIEs[&DU]; }
+  /// Returns DWARFUnitInfo for DWARFUnit
+  DWARFUnitInfo &getUnitInfoByDwarfUnit(const DWARFUnit &DwarfUnit) {
+    std::optional<uint32_t> UnitId = getUnitId(DwarfUnit);
+    return getUnitInfo(*UnitId);
+  }
+
+  const std::vector<std::unique_ptr<DIEInfo>> &getDIEsByUnit(DWARFUnit &DU) {
+    DWARFUnitInfo &U = getUnitInfoByDwarfUnit(DU);
+    return U.DieInfoVector;
+  }
   std::vector<std::unique_ptr<DIEAbbrev>> &getAbbrevs() {
     return Abbreviations;
   }
@@ -246,17 +256,16 @@ class DIEBuilder {
   }
 
   std::vector<DWARFUnit *> getDWARF4TUVector() { return DWARF4TUVector; }
-  bool isEmpty() { return !IsBuilt; }
+  bool isEmpty() { return CloneUnitCtxMap.empty(); }
 
-  DIE *getUnitDIEbyUnit(DWARFUnit &DU) {
-    assert(UnitDIEs.count(&DU) && UnitDIEs[&DU].size() &&
-           "DU is not constructed in IR");
-    return UnitDIEs[&DU].front();
+  DIE *getUnitDIEbyUnit(const DWARFUnit &DU) {
+    const DWARFUnitInfo &U = getUnitInfoByDwarfUnit(DU);
+    return U.UnitDie;
   }
 
   /// Generate and populate all Abbrevs.
   void generateAbbrevs();
-  void generateUnitAbbrevs(DIE *die);
+  void generateUnitAbbrevs(DIE *Die);
   void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Finish current DIE construction.