[DWARFLinkerParallel] Add support of accelerator tables to DWARFLinkerParallel.

This patch is extracted from D96035, it adds support for the accelerator
tables to the DWARFLinkerParallel functionality.

Differential Revision: https://reviews.llvm.org/D154793

Author: avl-llvm

llvm/include/llvm/CodeGen/AccelTable.h

@@ -25,6 +25,7 @@
 #include "llvm/Support/DJB.h"
 #include "llvm/Support/Debug.h"
 #include <cstdint>
+#include <variant>
 #include <vector>
 
 /// \file
@@ -310,9 +311,13 @@ void emitDWARF5AccelTable(AsmPrinter *Asm,
                           const DwarfDebug &DD,
                           ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs);
 
+/// Emit a DWARFv5 Accelerator Table consisting of entries in the specified
+/// AccelTable. The \p CUs contains either symbols keeping offsets to the
+/// start of compilation unit, either offsets to the start of compilation
+/// unit themselves.
 void emitDWARF5AccelTable(
     AsmPrinter *Asm, AccelTable<DWARF5AccelTableStaticData> &Contents,
-    ArrayRef<MCSymbol *> CUs,
+    ArrayRef<std::variant<MCSymbol *, uint64_t>> CUs,
     llvm::function_ref<unsigned(const DWARF5AccelTableStaticData &)>
         getCUIndexForEntry);
 

llvm/include/llvm/DWARFLinkerParallel/DWARFLinker.h

@@ -100,9 +100,6 @@ class ExtraDwarfEmitter {
   /// Emit section named SecName with data SecData.
   virtual void emitSectionContents(StringRef SecData, StringRef SecName) = 0;
 
-  /// Emit temporarily symbol named \p SymName inside section \p SecName.
-  virtual MCSymbol *emitTempSym(StringRef SecName, StringRef SymName) = 0;
-
   /// Emit the swift_ast section stored in \p Buffer.
   virtual void emitSwiftAST(StringRef Buffer) = 0;
 

llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp

@@ -213,7 +213,7 @@ class Dwarf5AccelTableWriter : public AccelTableWriter {
 
   Header Header;
   DenseMap<uint32_t, SmallVector<AttributeEncoding, 2>> Abbreviations;
-  ArrayRef<MCSymbol *> CompUnits;
+  ArrayRef<std::variant<MCSymbol *, uint64_t>> CompUnits;
   llvm::function_ref<unsigned(const DataT &)> getCUIndexForEntry;
   MCSymbol *ContributionEnd = nullptr;
   MCSymbol *AbbrevStart = Asm->createTempSymbol("names_abbrev_start");
@@ -235,7 +235,7 @@ class Dwarf5AccelTableWriter : public AccelTableWriter {
 public:
   Dwarf5AccelTableWriter(
       AsmPrinter *Asm, const AccelTableBase &Contents,
-      ArrayRef<MCSymbol *> CompUnits,
+      ArrayRef<std::variant<MCSymbol *, uint64_t>> CompUnits,
       llvm::function_ref<unsigned(const DataT &)> GetCUIndexForEntry);
 
   void emit();
@@ -419,7 +419,10 @@ template <typename DataT>
 void Dwarf5AccelTableWriter<DataT>::emitCUList() const {
   for (const auto &CU : enumerate(CompUnits)) {
     Asm->OutStreamer->AddComment("Compilation unit " + Twine(CU.index()));
-    Asm->emitDwarfSymbolReference(CU.value());
+    if (std::holds_alternative<MCSymbol *>(CU.value()))
+      Asm->emitDwarfSymbolReference(std::get<MCSymbol *>(CU.value()));
+    else
+      Asm->emitDwarfLengthOrOffset(std::get<uint64_t>(CU.value()));
   }
 }
 
@@ -508,7 +511,7 @@ template <typename DataT> void Dwarf5AccelTableWriter<DataT>::emitData() const {
 template <typename DataT>
 Dwarf5AccelTableWriter<DataT>::Dwarf5AccelTableWriter(
     AsmPrinter *Asm, const AccelTableBase &Contents,
-    ArrayRef<MCSymbol *> CompUnits,
+    ArrayRef<std::variant<MCSymbol *, uint64_t>> CompUnits,
     llvm::function_ref<unsigned(const DataT &)> getCUIndexForEntry)
     : AccelTableWriter(Asm, Contents, false),
       Header(CompUnits.size(), Contents.getBucketCount(),
@@ -545,7 +548,7 @@ void llvm::emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents,
 void llvm::emitDWARF5AccelTable(
     AsmPrinter *Asm, AccelTable<DWARF5AccelTableData> &Contents,
     const DwarfDebug &DD, ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs) {
-  std::vector<MCSymbol *> CompUnits;
+  std::vector<std::variant<MCSymbol *, uint64_t>> CompUnits;
   SmallVector<unsigned, 1> CUIndex(CUs.size());
   int Count = 0;
   for (const auto &CU : enumerate(CUs)) {
@@ -581,7 +584,7 @@ void llvm::emitDWARF5AccelTable(
 
 void llvm::emitDWARF5AccelTable(
     AsmPrinter *Asm, AccelTable<DWARF5AccelTableStaticData> &Contents,
-    ArrayRef<MCSymbol *> CUs,
+    ArrayRef<std::variant<MCSymbol *, uint64_t>> CUs,
     llvm::function_ref<unsigned(const DWARF5AccelTableStaticData &)>
         getCUIndexForEntry) {
   Contents.finalize(Asm, "names");

llvm/lib/DWARFLinker/DWARFStreamer.cpp

@@ -297,7 +297,7 @@ void DwarfStreamer::emitDebugNames(
     return;
 
   // Build up data structures needed to emit this section.
-  std::vector<MCSymbol *> CompUnits;
+  std::vector<std::variant<MCSymbol *, uint64_t>> CompUnits;
   DenseMap<unsigned, size_t> UniqueIdToCuMap;
   unsigned Id = 0;
   for (auto &CU : EmittedUnits) {

llvm/lib/DWARFLinkerParallel/ArrayList.h

@@ -9,60 +9,63 @@
 #ifndef LLVM_LIB_DWARFLINKERPARALLEL_ARRAYLIST_H
 #define LLVM_LIB_DWARFLINKERPARALLEL_ARRAYLIST_H
 
-#include "DWARFLinkerGlobalData.h"
 #include "llvm/Support/PerThreadBumpPtrAllocator.h"
+#include <atomic>
 
 namespace llvm {
 namespace dwarflinker_parallel {
 
 /// This class is a simple list of T structures. It keeps elements as
 /// pre-allocated groups to save memory for each element's next pointer.
 /// It allocates internal data using specified per-thread BumpPtrAllocator.
+/// Method add() can be called asynchronously.
 template <typename T, size_t ItemsGroupSize = 512> class ArrayList {
 public:
-  /// Copy specified \p Item into the list.
-  T &noteItem(const T &Item) {
-    assert(Allocator != nullptr);
-
-    ItemsGroup *CurGroup = LastGroup;
-
-    if (CurGroup == nullptr) {
-      // Allocate first ItemsGroup.
-      LastGroup = Allocator->Allocate<ItemsGroup>();
-      LastGroup->ItemsCount = 0;
-      LastGroup->Next = nullptr;
-      GroupsHead = LastGroup;
-      CurGroup = LastGroup;
+  /// Add specified \p Item to the list.
+  T &add(const T &Item) {
+    assert(Allocator);
+
+    // Allocate head group if it is not allocated yet.
+    while (!LastGroup) {
+      if (allocateNewGroup(GroupsHead))
+        LastGroup = GroupsHead.load();
     }
 
-    if (CurGroup->ItemsCount == ItemsGroupSize) {
-      // Allocate next ItemsGroup if current one is full.
-      LastGroup = Allocator->Allocate<ItemsGroup>();
-      LastGroup->ItemsCount = 0;
-      LastGroup->Next = nullptr;
-      CurGroup->Next = LastGroup;
+    ItemsGroup *CurGroup;
+    size_t CurItemsCount;
+    do {
       CurGroup = LastGroup;
-    }
+      CurItemsCount = CurGroup->ItemsCount.fetch_add(1);
+
+      // Check whether current group is full.
+      if (CurItemsCount < ItemsGroupSize)
+        break;
+
+      // Allocate next group if necessary.
+      if (!CurGroup->Next)
+        allocateNewGroup(CurGroup->Next);
+
+      LastGroup.compare_exchange_weak(CurGroup, CurGroup->Next);
+    } while (true);
 
-    // Copy item into the next position inside current ItemsGroup.
-    CurGroup->Items[CurGroup->ItemsCount] = Item;
-    return CurGroup->Items[CurGroup->ItemsCount++];
+    // Store item into the current group.
+    CurGroup->Items[CurItemsCount] = Item;
+    return CurGroup->Items[CurItemsCount];
   }
 
   using ItemHandlerTy = function_ref<void(T &)>;
 
   /// Enumerate all items and apply specified \p Handler to each.
   void forEach(ItemHandlerTy Handler) {
-    for (ItemsGroup *CurGroup = GroupsHead; CurGroup != nullptr;
+    for (ItemsGroup *CurGroup = GroupsHead; CurGroup;
          CurGroup = CurGroup->Next) {
-      for (size_t Idx = 0; Idx < CurGroup->ItemsCount; Idx++) {
-        Handler(CurGroup->Items[Idx]);
-      }
+      for (T &Item : *CurGroup)
+        Handler(Item);
     }
   }
 
   /// Check whether list is empty.
-  bool empty() { return GroupsHead == nullptr; }
+  bool empty() { return !GroupsHead; }
 
   /// Erase list.
   void erase() {
@@ -76,13 +79,61 @@ template <typename T, size_t ItemsGroupSize = 512> class ArrayList {
 
 protected:
   struct ItemsGroup {
-    std::array<T, ItemsGroupSize> Items;
-    ItemsGroup *Next = nullptr;
-    size_t ItemsCount = 0;
+    using ArrayTy = std::array<T, ItemsGroupSize>;
+
+    // Array of items kept by this group.
+    ArrayTy Items;
+
+    // Pointer to the next items group.
+    std::atomic<ItemsGroup *> Next = nullptr;
+
+    // Number of items in this group.
+    // NOTE: ItemsCount could be inaccurate as it might be incremented by
+    // several threads. Use getItemsCount() method to get real number of items
+    // inside ItemsGroup.
+    std::atomic<size_t> ItemsCount = 0;
+
+    size_t getItemsCount() const {
+      return std::min(ItemsCount.load(), ItemsGroupSize);
+    }
+
+    typename ArrayTy::iterator begin() { return Items.begin(); }
+    typename ArrayTy::iterator end() { return Items.begin() + getItemsCount(); }
   };
 
-  ItemsGroup *GroupsHead = nullptr;
-  ItemsGroup *LastGroup = nullptr;
+  // Allocate new group. Put allocated group into the \p AtomicGroup if
+  // it is empty. If \p AtomicGroup is filled by another thread then
+  // put allocated group into the end of groups list.
+  // \returns true if allocated group is put into the \p AtomicGroup.
+  bool allocateNewGroup(std::atomic<ItemsGroup *> &AtomicGroup) {
+    ItemsGroup *CurGroup = nullptr;
+
+    // Allocate new group.
+    ItemsGroup *NewGroup = Allocator->Allocate<ItemsGroup>();
+    NewGroup->ItemsCount = 0;
+    NewGroup->Next = nullptr;
+
+    // Try to replace current group with allocated one.
+    if (AtomicGroup.compare_exchange_weak(CurGroup, NewGroup))
+      return true;
+
+    // Put allocated group as last group.
+    while (CurGroup) {
+      ItemsGroup *NextGroup = CurGroup->Next;
+
+      if (!NextGroup) {
+        if (CurGroup->Next.compare_exchange_weak(NextGroup, NewGroup))
+          break;
+      }
+
+      CurGroup = NextGroup;
+    }
+
+    return false;
+  }
+
+  std::atomic<ItemsGroup *> GroupsHead = nullptr;
+  std::atomic<ItemsGroup *> LastGroup = nullptr;
   parallel::PerThreadBumpPtrAllocator *Allocator = nullptr;
 };
 

llvm/lib/DWARFLinkerParallel/DIEAttributeCloner.cpp

@@ -226,7 +226,7 @@ size_t DIEAttributeCloner::cloneDieRefAttr(
     return 0;
 
   std::optional<std::pair<CompileUnit *, uint32_t>> RefDiePair =
-      CU.resolveDIEReference(Val);
+      CU.resolveDIEReference(Val, ResolveInterCUReferencesMode::Resolve);
   if (!RefDiePair) {
     // If the referenced DIE is not found,  drop the attribute.
     CU.warn("cann't find referenced DIE.", InputDieEntry);
@@ -314,6 +314,11 @@ size_t DIEAttributeCloner::cloneScalarAttr(
   }
 
   uint64_t Value;
+  if (AttrSpec.Attr == dwarf::DW_AT_const_value &&
+      (InputDieEntry->getTag() == dwarf::DW_TAG_variable ||
+       InputDieEntry->getTag() == dwarf::DW_TAG_constant))
+    AttrInfo.HasLiveAddress = true;
+
   if (CU.getGlobalData().getOptions().UpdateIndexTablesOnly) {
     if (auto OptionalValue = Val.getAsUnsignedConstant())
       Value = *OptionalValue;
@@ -483,14 +488,19 @@ size_t DIEAttributeCloner::cloneBlockAttr(
         (AttrOutOffset + (FinalAttributeSize - Bytes.size()));
   }
 
+  if (HasLocationExpressionAddress)
+    AttrInfo.HasLiveAddress =
+        VarAddressAdjustment.has_value() ||
+        CU.getGlobalData().getOptions().UpdateIndexTablesOnly;
+
   return FinalAttributeSize;
 }
 
 size_t DIEAttributeCloner::cloneAddressAttr(
     const DWARFFormValue &Val,
     const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec) {
   if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
-    AttrInfo.HasLowPc = true;
+    AttrInfo.HasLiveAddress = true;
 
   if (CU.getGlobalData().getOptions().UpdateIndexTablesOnly)
     return Generator

llvm/lib/DWARFLinkerParallel/DIEAttributeCloner.h

@@ -17,6 +17,28 @@
 namespace llvm {
 namespace dwarflinker_parallel {
 
+/// Information gathered and exchanged between the various
+/// clone*Attr helpers about the attributes of a particular DIE.
+struct AttributesInfo {
+  /// Short Name.
+  StringEntry *Name = nullptr;
+
+  /// Mangled Name.
+  StringEntry *MangledName = nullptr;
+
+  /// Does the DIE have an address pointing to live code section?
+  bool HasLiveAddress = false;
+
+  /// Is this DIE only a declaration?
+  bool IsDeclaration = false;
+
+  /// Does the DIE have a ranges attribute?
+  bool HasRanges = false;
+
+  /// Does the DIE have a string offset attribute?
+  bool HasStringOffsetBaseAttr = false;
+};
+
 /// This class creates clones of input DIE attributes.
 /// It enumerates attributes of input DIE, creates clone for each
 /// attribute, adds cloned attribute to the output DIE.
@@ -44,29 +66,7 @@ class DIEAttributeCloner {
   /// Create abbreviations for the output DIE after all attributes are cloned.
   unsigned finalizeAbbreviations(bool HasChildrenToClone);
 
-  /// Information gathered and exchanged between the various
-  /// clone*Attr helpers about the attributes of a particular DIE.
-  ///
   /// Cannot be used concurrently.
-  struct AttributesInfo {
-    /// Names.
-    StringEntry *Name = nullptr;
-    StringEntry *MangledName = nullptr;
-    StringEntry *NameWithoutTemplate = nullptr;
-
-    /// Does the DIE have a low_pc attribute?
-    bool HasLowPc = false;
-
-    /// Is this DIE only a declaration?
-    bool IsDeclaration = false;
-
-    /// Does the DIE have a ranges attribute?
-    bool HasRanges = false;
-
-    /// Does the DIE have a string offset attribute?
-    bool HasStringOffsetBaseAttr = false;
-  };
-
   AttributesInfo AttrInfo;
 
 protected: