[llvm-dwarfutil] Add accelerator tables to dwarfutil

[avl]

Summary

This patch allows llvm-dwarfutil to utilize accelerator tables
generation code from DWARFLinker. It adds command line option:

--build-accelerator [none,DWARF]
                        Build accelerator tables(default: none)
  =none - Do not build accelerators
  =DWARF - Build accelerator tables according to the resulting DWARF version
       DWARFv4: .debug_pubnames and .debug_pubtypes
       DWARFv5: .debug_names

[clayborg]

So all debuggers ignore .debug_pubnames and .debug_pubtypes so I don't see any reasons to add them to any binaries. Even if llvm-dwarfutil creates full versions of these accelerator tables, no debuggers will use them. So I am wondering if we should just not emit them. That being said, LLDB _will_ use the Apple accelerator tables (.apple_XXX) if we can generate them. I created the Apple accelerator tables many years ago and the .debug_names were influenced by the Apple tables when they were added to the DWARF specification. So at least LLDB knows it can trust the Apple accelerator tables if they are there. And everyone can trust the .debug_names section. So I would suggest we emit either .debug_names all the time, even for DWARF4 and earlier or emit apple accelerator tables instead of the older .debug_pubXXX sections.

[avl]

yes, we can use .debug_names always(and add using pubnames or apple_XXX when it becomes necessary). will update the patch accordingly.

[avl]

addressed comment: use .debug_names for all DWARF versions.

[avl]

ping.

[JDevlieghere]

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

385–395

Do we still need a list here? I presume this is a remnant of having the debug_pub{names,types} which could co-exist. It seems unlikely that without those we'll ever need more than one concurrent accelerator table type.

This would also make it easier to improve the warning below (line 377) and specify what type of accelerator table the input will be replaced by.

[avl]

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

385–395

Usage of list of accelerator tables was introduced not only for debug_pub{names,type} tables. It would be useful if/when additional tables like .gdb_index and/or .debug_cu_index would be implemented. So it looks it would be good to preserve this interface.

if the warning on 377 line looks unclear, how about replacing it with something like this :

Accelerator tables Table1, Table2 will be replaced with Table3, Table 4?

[JDevlieghere]

LGTM

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

385–395

Ok. I don't feel strongly about the warning, but I think if it's easy to be explicit about the tables that we're generating, that'd be nice.

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
 
   MCSymbol *getSymbol(const GlobalValue *GV) const;
 
   /// Similar to getSymbol() but preferred for references. On ELF, this uses a
   /// local symbol if a reference to GV is guaranteed to be resolved to the
   /// definition in the same module.
   MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const;
 
+  bool doesDwarfUseRelocationsAcrossSections() const {
+    return DwarfUsesRelocationsAcrossSections;
+  }
+
+  void setDwarfUsesRelocationsAcrossSections(bool Enable) {
+    DwarfUsesRelocationsAcrossSections = Enable;
+  }
+
   //===------------------------------------------------------------------===//
   // XRay instrumentation implementation.
   //===------------------------------------------------------------------===//
 public:
   // This describes the kind of sled we're storing in the XRay table.
   enum class SledKind : uint8_t {
     FUNCTION_ENTER = 0,
     FUNCTION_EXIT = 1,

 
 private:
   /// Private state for PrintSpecial()
   // Assign a unique ID to this machine instruction.
   mutable const MachineInstr *LastMI = nullptr;
   mutable unsigned LastFn = 0;
   mutable unsigned Counter = ~0U;
 
+  bool DwarfUsesRelocationsAcrossSections = false;
+
   /// This method emits the header for the current function.
   virtual void emitFunctionHeader();
 
   /// This method emits a comment next to header for the current function.
   virtual void emitFunctionHeaderComment();
 
   /// Emit a blob of inline asm to the output streamer.
   void

llvm/include/llvm/DWARFLinker/DWARFLinker.h

unsigned cloneBlockAttribute(DIE &Die, const DWARFFile &File,
                                  CompileUnit &Unit, AttributeSpec AttrSpec,
                                  const DWARFFormValue &Val, unsigned AttrSize,
                                  bool IsLittleEndian);
 
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec,
-                                   const DWARFFormValue &Val,
+                                   unsigned AttrSize, const DWARFFormValue &Val,
                                    const CompileUnit &Unit,
                                    AttributesInfo &Info);
 
     /// Clone a scalar attribute  and add it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneScalarAttribute(DIE &Die, const DWARFDie &InputDIE,
                                   const DWARFFile &File, CompileUnit &U,
                                   AttributeSpec AttrSpec,

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Align AsmPrinter::getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
   return Alignment;
 }
 
 AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer)
     : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()),
       OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)),
       SM(*this) {
   VerboseAsm = OutStreamer->isVerboseAsm();
+  DwarfUsesRelocationsAcrossSections =
+      MAI->doesDwarfUseRelocationsAcrossSections();
 }
 
 AsmPrinter::~AsmPrinter() {
   assert(!DD && Handlers.size() == NumUserHandlers &&
          "Debug/EH info didn't get finalized");
 }
 
 bool AsmPrinter::isPositionIndependent() const {

 unsigned int AsmPrinter::getDwarfOffsetByteSize() const {
   return dwarf::getDwarfOffsetByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }
 
 dwarf::FormParams AsmPrinter::getDwarfFormParams() const {
   return {getDwarfVersion(), uint8_t(getPointerSize()),
           OutStreamer->getContext().getDwarfFormat(),
-          MAI->doesDwarfUseRelocationsAcrossSections()};
+          doesDwarfUseRelocationsAcrossSections()};
 }
 
 unsigned int AsmPrinter::getUnitLengthFieldByteSize() const {
   return dwarf::getUnitLengthFieldByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

if (!ForceOffset) {
     if (MAI->needsDwarfSectionOffsetDirective()) {
       assert(!isDwarf64() &&
              "emitting DWARF64 is not implemented for COFF targets");
       OutStreamer->emitCOFFSecRel32(Label, /*Offset=*/0);
       return;
     }
 
     // If the format uses relocations with dwarf, refer to the symbol directly.
-    if (MAI->doesDwarfUseRelocationsAcrossSections()) {
+    if (doesDwarfUseRelocationsAcrossSections()) {
       OutStreamer->emitSymbolValue(Label, getDwarfOffsetByteSize());
       return;
     }
   }
 
   // Otherwise, emit it as a label difference from the start of the section.
   emitLabelDifference(Label, Label->getSection().getBeginSymbol(),
                       getDwarfOffsetByteSize());
 }
 
 void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
-  if (MAI->doesDwarfUseRelocationsAcrossSections()) {
+  if (doesDwarfUseRelocationsAcrossSections()) {
     assert(S.Symbol && "No symbol available");
     emitDwarfSymbolReference(S.Symbol);
     return;
   }
 
   // Just emit the offset directly; no need for symbol math.
   OutStreamer->emitIntValue(S.Offset, getDwarfOffsetByteSize());
 }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

void DIEString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_strx1:
   case dwarf::DW_FORM_strx2:
   case dwarf::DW_FORM_strx3:
   case dwarf::DW_FORM_strx4:
     DIEInteger(S.getIndex()).emitValue(AP, Form);
     return;
   case dwarf::DW_FORM_strp:
-    if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
+    if (AP->doesDwarfUseRelocationsAcrossSections())
       DIELabel(S.getSymbol()).emitValue(AP, Form);
     else
       DIEInteger(S.getOffset()).emitValue(AP, Form);
     return;
   default:
     llvm_unreachable("Expected valid string form");
   }
 }

llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

 #include <cassert>
 #include <utility>
 
 using namespace llvm;
 
 DwarfStringPool::DwarfStringPool(BumpPtrAllocator &A, AsmPrinter &Asm,
                                  StringRef Prefix)
     : Pool(A), Prefix(Prefix),
-      ShouldCreateSymbols(Asm.MAI->doesDwarfUseRelocationsAcrossSections()) {}
+      ShouldCreateSymbols(Asm.doesDwarfUseRelocationsAcrossSections()) {}
 
 StringMapEntry<DwarfStringPool::EntryTy> &
 DwarfStringPool::getEntryImpl(AsmPrinter &Asm, StringRef Str) {
   auto I = Pool.insert(std::make_pair(Str, EntryTy()));
   auto &Entry = I.first->second;
   if (I.second) {
     Entry.Index = EntryTy::NotIndexed;
     Entry.Offset = NumBytes;

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                 const MCSymbol *Hi, const MCSymbol *Lo) {
   addAttribute(Die, Attribute, DD->getDwarfSectionOffsetForm(),
                new (DIEValueAllocator) DIEDelta(Hi, Lo));
 }
 
 void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
                                 const MCSymbol *Label, const MCSymbol *Sec) {
-  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
+  if (Asm->doesDwarfUseRelocationsAcrossSections())
     addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label);
   else
     addSectionDelta(Die, Attribute, Label, Sec);
 }
 
 bool DwarfTypeUnit::isDwoUnit() const {
   // Since there are no skeleton type units, all type units are dwo type units
   // when split DWARF is being used.
   return DD->useSplitDwarf();
 }
 
 void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
                                   const DIScope *Context) {
   getCU().addGlobalNameForTypeUnit(Name, Context);
 }
 
 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
                                   const DIScope *Context) {
   getCU().addGlobalTypeUnitType(Ty, Context);
 }
 
 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
-  if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
+  if (!Asm->doesDwarfUseRelocationsAcrossSections())
     return nullptr;
   if (isDwoUnit())
     return nullptr;
   return getSection()->getBeginSymbol();
 }
 
 void DwarfUnit::addStringOffsetsStart() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();

llvm/lib/DWARFLinker/DWARFLinker.cpp

unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
   else
     Block->setSize(Bytes.size());
 
   Die.addValue(DIEAlloc, Value);
   return AttrSize;
 }
 
 unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
-    DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
-    const CompileUnit &Unit, AttributesInfo &Info) {
+    DIE &Die, AttributeSpec AttrSpec, unsigned AttrSize,
+    const DWARFFormValue &Val, const CompileUnit &Unit, AttributesInfo &Info) {
   if (LLVM_UNLIKELY(Linker.Options.Update)) {
     if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
       Info.HasLowPc = true;
     Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                  dwarf::Form(AttrSpec.Form), DIEInteger(Val.getRawUValue()));
-    return Unit.getOrigUnit().getAddressByteSize();
+    return AttrSize;
   }
 
   dwarf::Form Form = AttrSpec.Form;
   uint64_t Addr = 0;
   if (Form == dwarf::DW_FORM_addrx) {
     if (std::optional<uint64_t> AddrOffsetSectionBase =
             Unit.getOrigUnit().getAddrOffsetSectionBase()) {
       uint64_t StartOffset =
unsigned DWARFLinker::DIECloner::cloneAttribute(
   case dwarf::DW_FORM_block1:
   case dwarf::DW_FORM_block2:
   case dwarf::DW_FORM_block4:
   case dwarf::DW_FORM_exprloc:
     return cloneBlockAttribute(Die, File, Unit, AttrSpec, Val, AttrSize,
                                IsLittleEndian);
   case dwarf::DW_FORM_addr:
   case dwarf::DW_FORM_addrx:
-    return cloneAddressAttribute(Die, AttrSpec, Val, Unit, Info);
+    return cloneAddressAttribute(Die, AttrSpec, AttrSize, Val, Unit, Info);
   case dwarf::DW_FORM_data1:
   case dwarf::DW_FORM_data2:
   case dwarf::DW_FORM_data4:
   case dwarf::DW_FORM_data8:
   case dwarf::DW_FORM_udata:
   case dwarf::DW_FORM_sdata:
   case dwarf::DW_FORM_sec_offset:
   case dwarf::DW_FORM_flag:
if (OpenParens != StringRef::npos) {
       //        dsymutil-classic also does it this way.
       MethodNameNoCategory.append(std::string(SelectorStart));
       Unit.addNameAccelerator(Die, StringPool.getEntry(MethodNameNoCategory),
                               SkipPubSection);
     }
   }
 }
 
-static bool
-shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
-                    uint16_t Tag, bool InDebugMap, bool SkipPC,
-                    bool InFunctionScope) {
+static bool shouldSkipAttribute(
+    bool Update, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    uint16_t Tag, bool InDebugMap, bool SkipPC, bool InFunctionScope) {
   switch (AttrSpec.Attr) {
   default:
     return false;
   case dwarf::DW_AT_low_pc:
   case dwarf::DW_AT_high_pc:
   case dwarf::DW_AT_ranges:
-    return SkipPC;
+    return !Update && SkipPC;
   case dwarf::DW_AT_str_offsets_base:
     // FIXME: Use the string offset table with Dwarf 5.
     return true;
   case dwarf::DW_AT_location:
   case dwarf::DW_AT_frame_base:
     // FIXME: for some reason dsymutil-classic keeps the location attributes
     // when they are of block type (i.e. not location lists). This is totally
     // wrong for globals where we will keep a wrong address. It is mostly
     // harmless for locals, but there is no point in keeping these anyway when
     // the function wasn't linked.
-    return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
+    return !Update &&
+           (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
                        !InDebugMap)) &&
            !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
   }
 }
 
 DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
                                       const DWARFFile &File, CompileUnit &Unit,
                                       OffsetsStringPool &StringPool,
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
   } else if (Abbrev->getTag() == dwarf::DW_TAG_variable) {
     // Function-local globals could be in the debug map even when the function
     // is not, e.g., inlined functions.
     if ((Flags & TF_InFunctionScope) && Info.InDebugMap)
       Flags &= ~TF_SkipPC;
   }
 
   for (const auto &AttrSpec : Abbrev->attributes()) {
-    if (LLVM_LIKELY(!Update) &&
-        shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
+    if (shouldSkipAttribute(Update, AttrSpec, Die->getTag(), Info.InDebugMap,
                             Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
       DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
                                 U.getFormParams());
       continue;
     }
 
     DWARFFormValue Val(AttrSpec.Form);
     uint64_t AttrSize = Offset;

llvm/lib/DWARFLinker/DWARFStreamer.cpp

bool DwarfStreamer::init(Triple TheTriple,
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           std::nullopt));
   if (!TM)
     return error("no target machine for target " + TripleName, Context), false;
 
   Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
   if (!Asm)
     return error("no asm printer for target " + TripleName, Context), false;
+  Asm->setDwarfUsesRelocationsAcrossSections(false);
 
   RangesSectionSize = 0;
   LocSectionSize = 0;
   LineSectionSize = 0;
   FrameSectionSize = 0;
   DebugInfoSectionSize = 0;
   MacInfoSectionSize = 0;
   MacroSectionSize = 0;

llvm/test/tools/llvm-dwarfutil/ELF/X86/accelerator-dwarf4.test

+## This test checks that .debug_names accelerator tables are
+## generated if --build-accelerator=DWARF option is specified
+## and source file has DWARFv4 debug info.
+
+# RUN: yaml2obj %p/Inputs/common.yaml -o %t.o
+
+# RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %t.o %t1
+# RUN: llvm-dwarfdump --verify %t1 | FileCheck %s --check-prefix=VERIFY
+# RUN: llvm-dwarfdump -a %t1 | FileCheck %s
+
+# RUN: llvm-dwarfutil --garbage-collection --build-accelerator=DWARF %t.o %t1
+# RUN: llvm-dwarfdump --verify %t1 | FileCheck %s --check-prefix=VERIFY
+# RUN: llvm-dwarfdump -a %t1 | FileCheck %s
+
+# VERIFY: No errors
+
+# CHECK: .debug_names contents:
+# CHECK:  Compilation Unit offsets [
+# CHECK:    CU[0]: 0x00000000
+# CHECK:  ]
+# CHECK: Abbreviations
+# CHECK: String: {{.*}} "foo1"
+# CHECK: Tag: DW_TAG_subprogram
+# CHECK: String: {{.*}} "class1"
+# CHECK: Tag: DW_TAG_class_type
+# CHECK: String: {{.*}} "float"
+# CHECK: Tag: DW_TAG_base_type
+# CHECK: String: {{.*}} "int"
+# CHECK: Tag: DW_TAG_base_type
+# CHECK: String: {{.*}} "var1"
+# CHECK: Tag: DW_TAG_variable
+# CHECK: String: {{.*}} "char"
+# CHECK: Tag: DW_TAG_base_type

llvm/test/tools/llvm-dwarfutil/ELF/X86/accelerator-dwarf5.test

+## This test checks that .debug_names accelerator table
+## is generated if --build-accelerator=DWARF option is
+## specified and source file has DWARFv5 debug info.
+
+# RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %p/Inputs/dwarf5.out %t1
+# RUN: llvm-dwarfdump --verify %t1 | FileCheck %s --check-prefix=VERIFY
+# RUN: llvm-dwarfdump -a %t1 | FileCheck %s
+
+# RUN: llvm-dwarfutil --garbage-collection --build-accelerator=DWARF %p/Inputs/dwarf5.out %t1
+# RUN: llvm-dwarfdump --verify %t1 | FileCheck %s --check-prefix=VERIFY
+# RUN: llvm-dwarfdump -a %t1 | FileCheck %s
+
+# VERIFY: No errors
+
+# CHECK: .debug_names contents:
+# CHECK:  Compilation Unit offsets [
+# CHECK:    CU[0]: 0x00000000
+# CHECK:  ]
+# CHECK: Abbreviations
+# CHECK: String: {{.*}} "_Z3foov"
+# CHECK: Tag: DW_TAG_subprogram
+# CHECK: String: {{.*}} "int"
+# CHECK: Tag: DW_TAG_base_type
+# CHECK: String: {{.*}} "foo"
+# CHECK: Tag: DW_TAG_subprogram
+# CHECK: String: {{.*}} "A"
+# CHECK: Tag: DW_TAG_structure_type
+# CHECK: String: {{.*}} "main"
+# CHECK: Tag: DW_TAG_subprogram
+# CHECK: String: {{.*}} "char"
+# CHECK: Tag: DW_TAG_base_type

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf4-macro.test

 #RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefix=MACINFO
 
 ## Check that macro table preserved during simple copying.
 #
 #RUN: llvm-dwarfutil --no-garbage-collection %p/Inputs/dwarf4-macro.out %t1
 #RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 #RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefix=MACINFO
 
+## Check that macro table preserved during updating accelerator tables.
+#RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %p/Inputs/dwarf4-macro.out %t1
+#RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
+#RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefixes=MACINFO,NAMES
+
 #CHECK: No errors.
 
 #MACINFO: .debug_info contents
 #MACINFO: DW_TAG_compile_unit
 #MACINFO: DW_AT_name        ("main.cpp")
 #MACINFO: DW_AT_macro_info (0x[[MAIN_MACRO_OFFSET:[0-9a-f]*]]
 #MACINFO: DW_TAG_compile_unit
 #MACINFO: DW_AT_name        ("foo.cpp")

 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDC__ 1
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDC_HOSTED__ 1
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __cplusplus 201402L
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDCPP_THREADS__ 1
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDC_UTF_16__ 1
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __STDC_UTF_32__ 1
 #MACINFO-NEXT: DW_MACINFO_define - lineno: 0 macro: __GCC_HAVE_DWARF2_CFI_ASM 1
+
+
+#NAMES: .debug_names contents
+#NAMES: Name Index

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-macro.test

 #RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefix=MACRO
 
 ## Check that macro table preserved during simple copying.
 #
 #RUN: llvm-dwarfutil --no-garbage-collection %p/Inputs/dwarf5-macro.out %t1
 #RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 #RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefix=MACRO
 
+## Check that macro table preserved during updating accelerator tables.
+#RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %p/Inputs/dwarf5-macro.out %t1
+#RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
+#RUN: llvm-dwarfdump -a  %t1 | FileCheck %s --check-prefixes=MACRO,NAMES
+
 #CHECK: No errors.
 
 #MACRO: .debug_info contents
 #MACRO: DW_TAG_compile_unit
 #MACRO: DW_AT_name        ("main.cpp")
 #MACRO: DW_AT_stmt_list   (0x[[LINE_TABLE_MAIN:[0-9a-f]*]])
 #MACRO: DW_AT_macros (0x[[MAIN_MACRO_OFFSET:[0-9a-f]*]]
 #MACRO: DW_TAG_compile_unit

 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDC__ 1
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDC_HOSTED__ 1
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __cplusplus 201402L
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDCPP_THREADS__ 1
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDC_UTF_16__ 1
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __STDC_UTF_32__ 1
 #MACRO-NEXT: DW_MACRO_define_str{{[px]}} - lineno: 0 macro: __GCC_HAVE_DWARF2_CFI_ASM 1
+
+#NAMES: .debug_names contents
+#NAMES: Name Index

llvm/test/tools/llvm-dwarfutil/ELF/X86/verbose.test

 
 ## Check -j alias.
 # RUN: llvm-dwarfutil %t.o %t1 --verbose -j 10 2>&1 | FileCheck %s --check-prefix=CHECK-THREAD-WARNING
 
 ## Check verbose output for --verify.
 # RUN: llvm-dwarfutil %t.o %t1 -j 1 --verbose --verify 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-VERIFY
 
 # CHECK-NOT: warning: --num-threads set to 1 because verbose mode is specified
-# CHECK: Do garbage collection for debug info ...
+# CHECK: Do debug info linking...
 # CHECK: Input compilation unit:
 # CHECK: DW_TAG_compile_unit
 # CHECK: Keeping subprogram DIE
 # CHECK: DW_TAG_subprogram
 # CHECK-THREAD-WARNING: warning: --num-threads set to 1 because verbose mode is specified
 # CHECK-VERIFY: Verifying DWARF...

llvm/test/tools/llvm-dwarfutil/ELF/X86/warning-pubnames.test

 ## This test checks the warning message displayed if input file
-## contains .debug_pubnames section.
+## contains .debug_pubnames section which is incompatible with
+## requested accelerator table.
 
 # RUN: yaml2obj %s -o %t.o
 
-# RUN: llvm-dwarfutil --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o
+# RUN: llvm-dwarfutil --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN1
 
-# CHECK: [[FILE]]: warning: '.debug_pubnames' is not currently supported: section will be skipped
+# RUN: llvm-dwarfutil --build-accelerator=DWARF --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN2
+
+# RUN: llvm-dwarfutil --build-accelerator=DWARF --no-garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN2
+
+# WARN1: [[FILE]]: warning: '.debug_pubnames' will be deleted as no accelerator tables are requested
+
+# WARN2: [[FILE]]: warning: '.debug_pubnames' will be replaced with requested .debug_names table
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
 Sections:
- Table:
             Form:      DW_FORM_data2
           - Attribute: DW_AT_name
             Form:      DW_FORM_string
           - Attribute: DW_AT_low_pc
             Form:      DW_FORM_addr
           - Attribute: DW_AT_high_pc
             Form:      DW_FORM_data8
   debug_info:
-    - Version: 4
+    - Version: 5
+      UnitType:   DW_UT_compile
       Entries:
         - AbbrCode: 1
           Values:
             - CStr: by_hand
             - Value:  0x04
             - CStr: CU1
             - Value:  0x1000
             - Value:  0x4
         - AbbrCode: 0
 ...

llvm/test/tools/llvm-dwarfutil/ELF/X86/warning-pubtypes.test

 ## This test checks the warning message displayed if input file
-## contains .debug_pubtypes section.
+## contains .debug_pubtypes section which is incompatible with
+## requested accelerator table.
 
 # RUN: yaml2obj %s -o %t.o
  
-# RUN: llvm-dwarfutil --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o
+# RUN: llvm-dwarfutil --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN1
 
-# CHECK: [[FILE]]: warning: '.debug_pubtypes' is not currently supported: section will be skipped
+# RUN: llvm-dwarfutil --build-accelerator=DWARF --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN2
+
+# RUN: llvm-dwarfutil --build-accelerator=DWARF --no-garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o --check-prefix=WARN2
+
+# WARN1: [[FILE]]: warning: '.debug_pubtypes' will be deleted as no accelerator tables are requested
+
+# WARN2: [[FILE]]: warning: '.debug_pubtypes' will be replaced with requested .debug_names table
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
 Sections:
- Table:
             Form:      DW_FORM_data2
           - Attribute: DW_AT_name
             Form:      DW_FORM_string
           - Attribute: DW_AT_low_pc
             Form:      DW_FORM_addr
           - Attribute: DW_AT_high_pc
             Form:      DW_FORM_data8
   debug_info:
-    - Version: 4
+    - Version: 5
+      UnitType:   DW_UT_compile
       Entries:
         - AbbrCode: 1
           Values:
             - CStr: by_hand
             - Value:  0x04
             - CStr: CU1
             - Value:  0x1000
             - Value:  0x4
         - AbbrCode: 0
 ...

llvm/test/tools/llvm-dwarfutil/ELF/X86/warning-skipped-names.test

-## This test checks the warning message displayed if input file
-## contains .debug_names section.
-
-# RUN: yaml2obj %s -o %t.o
-
-# RUN: llvm-dwarfutil --garbage-collection %t.o %t1 2>&1 | FileCheck %s -DFILE=%t.o
-
-# CHECK: [[FILE]]: warning: '.debug_names' is not currently supported: section will be skipped
-
---- !ELF
-FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
-Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000000010
-    Content:         "FFFFFFFF"
-  - Name:            .debug_names
-    Type:            SHT_PROGBITS
-    Flags:           [  ]
-    Content:         "0000"
-DWARF:
-  debug_abbrev:
-    - Table:
-      - Tag:      DW_TAG_compile_unit
-        Children: DW_CHILDREN_yes
-        Attributes:
-          - Attribute: DW_AT_producer
-            Form:      DW_FORM_string
-          - Attribute: DW_AT_language
-            Form:      DW_FORM_data2
-          - Attribute: DW_AT_name
-            Form:      DW_FORM_string
-          - Attribute: DW_AT_low_pc
-            Form:      DW_FORM_addr
-          - Attribute: DW_AT_high_pc
-            Form:      DW_FORM_data8
-  debug_info:
-    - Version: 4
-      Entries:
-        - AbbrCode: 1
-          Values:
-            - CStr: by_hand
-            - Value:  0x04
-            - CStr: CU1
-            - Value:  0x1000
-            - Value:  0x4
-        - AbbrCode: 0
-...

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

return llvm::StringSwitch<bool>(SecName)
       .Case(".debug_rnglists", true)
       .Case(".debug_line", true)
       .Case(".debug_line_str", true)
       .Case(".debug_addr", true)
       .Case(".debug_macro", true)
       .Case(".debug_macinfo", true)
       .Case(".debug_str", true)
       .Case(".debug_str_offsets", true)
+      .Case(".debug_pubnames", true)
+      .Case(".debug_pubtypes", true)
+      .Case(".debug_names", true)
       .Default(false);
 }
 
+static std::optional<DwarfLinkerAccelTableKind>
+getAcceleratorTableKind(StringRef SecName) {
+  return llvm::StringSwitch<std::optional<DwarfLinkerAccelTableKind>>(SecName)
+      .Case(".debug_pubnames", DwarfLinkerAccelTableKind::Pub)
+      .Case(".debug_pubtypes", DwarfLinkerAccelTableKind::Pub)
+      .Case(".debug_names", DwarfLinkerAccelTableKind::DebugNames)
+      .Default(std::nullopt);
+}
+
+static std::string getMessageForReplacedAcceleratorTables(
+    SmallVector<StringRef> &AccelTableNamesToReplace,
+    DwarfUtilAccelKind TargetTable) {
+  std::string Message;
+
+  Message += "'";
+  for (StringRef Name : AccelTableNamesToReplace) {
+    if (Message.size() > 1)
+      Message += ", ";
+    Message += Name;
+  }
+
+  Message += "' will be replaced with requested ";
+
+  switch (TargetTable) {
+  case DwarfUtilAccelKind::DWARF:
+    Message += ".debug_names table";
+    break;
+
+  default:
+    assert(false);
+  }
+
+  return Message;
+}
+
+static std::string getMessageForDeletedAcceleratorTables(
+    SmallVector<StringRef> &AccelTableNamesToReplace) {
+  std::string Message;
+
+  Message += "'";
+  for (StringRef Name : AccelTableNamesToReplace) {
+    if (Message.size() > 1)
+      Message += ", ";
+    Message += Name;
+  }
+
+  Message += "' will be deleted as no accelerator tables are requested";
+
+  return Message;
+}
+
 Error linkDebugInfo(object::ObjectFile &File, const Options &Options,
                     raw_pwrite_stream &OutStream) {
 
   auto ReportWarn = [&](const Twine &Message, StringRef Context,
                         const DWARFDie *Die) {
     warning(Message, Context);
 
     if (!Options.Verbose || !Die)
Error linkDebugInfo(object::ObjectFile &File, const Options &Options,
   Triple TargetTriple = File.makeTriple();
   if (!OutStreamer.init(TargetTriple, formatv("cannot create a stream for {0}",
                                               TargetTriple.getTriple())
                                           .str()))
     return createStringError(std::errc::invalid_argument, "");
 
   std::unique_ptr<DWARFContext> Context = DWARFContext::create(File);
 
-  uint16_t MaxDWARFVersion = 0;
-  std::function<void(const DWARFUnit &Unit)> OnCUDieLoaded =
-      [&MaxDWARFVersion](const DWARFUnit &Unit) {
-        MaxDWARFVersion = std::max(Unit.getVersion(), MaxDWARFVersion);
-      };
-
   // Create DWARF linker.
   DWARFLinker DebugInfoLinker(&OutStreamer, DwarfLinkerClient::LLD);
 
   DebugInfoLinker.setEstimatedObjfilesAmount(1);
   DebugInfoLinker.setErrorHandler(ReportErr);
   DebugInfoLinker.setWarningHandler(ReportWarn);
   DebugInfoLinker.setNumThreads(Options.NumThreads);
   DebugInfoLinker.setNoODR(!Options.DoODRDeduplication);
   DebugInfoLinker.setVerbosity(Options.Verbose);
   DebugInfoLinker.setUpdate(!Options.DoGarbageCollection);
 
   std::vector<std::unique_ptr<DWARFFile>> ObjectsForLinking(1);
   std::vector<std::unique_ptr<AddressesMap>> AddresssMapForLinking(1);
   std::vector<std::string> EmptyWarnings;
 
-  // Unknown debug sections would be removed. Display warning
-  // for such sections.
-  for (SectionName Sec : Context->getDWARFObj().getSectionNames()) {
-    if (isDebugSection(Sec.Name) && !knownByDWARFUtil(Sec.Name))
-      warning(
-          formatv("'{0}' is not currently supported: section will be skipped",
-                  Sec.Name),
-          Options.InputFileName);
-  }
-
   // Add object files to the DWARFLinker.
   AddresssMapForLinking[0] =
       std::make_unique<ObjFileAddressMap>(*Context, Options, File);
 
   ObjectsForLinking[0] = std::make_unique<DWARFFile>(
       File.getFileName(), &*Context, AddresssMapForLinking[0].get(),
       EmptyWarnings);
 
+  uint16_t MaxDWARFVersion = 0;
+  std::function<void(const DWARFUnit &Unit)> OnCUDieLoaded =
+      [&MaxDWARFVersion](const DWARFUnit &Unit) {
+        MaxDWARFVersion = std::max(Unit.getVersion(), MaxDWARFVersion);
+      };
+
   for (size_t I = 0; I < ObjectsForLinking.size(); I++)
     DebugInfoLinker.addObjectFile(*ObjectsForLinking[I], nullptr,
                                   OnCUDieLoaded);
 
   // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
   if (MaxDWARFVersion == 0)
     MaxDWARFVersion = 3;
 
   if (Error Err = DebugInfoLinker.setTargetDWARFVersion(MaxDWARFVersion))
     return Err;
 
+  SmallVector<DwarfLinkerAccelTableKind> AccelTables;
+
+  switch (Options.AccelTableKind) {
+  case DwarfUtilAccelKind::None:
+    // Nothing to do.
+    break;
+  case DwarfUtilAccelKind::DWARF:
+    // use .debug_names for all DWARF versions.
+    AccelTables.push_back(DwarfLinkerAccelTableKind::DebugNames);
+    break;
+  }
+
+  // Add accelerator tables to DWARFLinker.
+  for (DwarfLinkerAccelTableKind Table : AccelTables)
+    DebugInfoLinker.addAccelTableKind(Table);
+
+  SmallVector<StringRef> AccelTableNamesToReplace;
+  SmallVector<StringRef> AccelTableNamesToDelete;
+
+  // Unknown debug sections or non-requested accelerator sections would be
+  // removed. Display warning for such sections.
+  for (SectionName Sec : Context->getDWARFObj().getSectionNames()) {
+    if (isDebugSection(Sec.Name)) {
+      std::optional<DwarfLinkerAccelTableKind> SrcAccelTableKind =
+          getAcceleratorTableKind(Sec.Name);
+
+      if (SrcAccelTableKind) {
+        assert(knownByDWARFUtil(Sec.Name));
+
+        if (Options.AccelTableKind == DwarfUtilAccelKind::None)
+          AccelTableNamesToDelete.push_back(Sec.Name);
+        else if (std::find(AccelTables.begin(), AccelTables.end(),
+                           *SrcAccelTableKind) == AccelTables.end())
+          AccelTableNamesToReplace.push_back(Sec.Name);
+      } else if (!knownByDWARFUtil(Sec.Name)) {
+        assert(!SrcAccelTableKind);
+        warning(
+            formatv("'{0}' is not currently supported: section will be skipped",
+                    Sec.Name),
+            Options.InputFileName);
+      }
+    }
+  }
+
+  // Display message for the replaced accelerator tables.
+  if (!AccelTableNamesToReplace.empty())
+    warning(getMessageForReplacedAcceleratorTables(AccelTableNamesToReplace,
+                                                   Options.AccelTableKind),
+            Options.InputFileName);
+
+  // Display message for the removed accelerator tables.
+  if (!AccelTableNamesToDelete.empty())
+    warning(getMessageForDeletedAcceleratorTables(AccelTableNamesToDelete),
+            Options.InputFileName);
+
   // Link debug info.
   if (Error Err = DebugInfoLinker.link())
     return Err;
 
   OutStreamer.finish();
   return Error::success();
 }
 
 } // end of namespace dwarfutil
 } // end of namespace llvm

llvm/tools/llvm-dwarfutil/Options.h

 enum class TombstoneKind {
   BFD,       /// 0/[1:1]. Bfd default.
   MaxPC,     /// -1/-2. Assumed to match with
              /// http://www.dwarfstd.org/ShowIssue.php?issue=200609.1.
   Universal, /// both: BFD + MaxPC
   Exec,      /// match with address range of executable sections.
 };
 
+/// The kind of accelerator table.
+enum class DwarfUtilAccelKind : uint8_t {
+  None,
+  DWARF // DWARFv5: .debug_names
+};
+
 struct Options {
   std::string InputFileName;
   std::string OutputFileName;
   bool DoGarbageCollection = false;
   bool DoODRDeduplication = false;
   bool BuildSeparateDebugFile = false;
   TombstoneKind Tombstone = TombstoneKind::Universal;
   bool Verbose = false;
   int NumThreads = 0;
   bool Verify = false;
+  DwarfUtilAccelKind AccelTableKind = DwarfUtilAccelKind::None;
 
   std::string getSeparateDebugFileName() const {
     return OutputFileName + ".debug";
   }
 };
 
 } // namespace dwarfutil
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_DWARFUTIL_OPTIONS_H

llvm/tools/llvm-dwarfutil/Options.td

 include "llvm/Option/OptParser.td"
 
 multiclass BB<string name, string help1, string help2> {
   def NAME: Flag<["--"], name>, HelpText<help1>;
   def no_ # NAME: Flag<["--"], "no-" # name>, HelpText<help2>;
 }
 
+def build_accelerator: Separate<["--", "-"], "build-accelerator">,
+  MetaVarName<"[none,DWARF]">,
+  HelpText<"Build accelerator tables(default: none)\n"
+  "    =none - Do not build accelerators\n"
+  "    =DWARF - .debug_names are generated for all DWARF versions\n"
+  >;
+def: Joined<["--", "-"], "build-accelerator=">, Alias<build_accelerator>;
+
 def help : Flag<["--"], "help">,
   HelpText<"Prints this help output">;
 
 def h : Flag<["-"], "h">,
   Alias<help>,
   HelpText<"Alias for --help">;
 
 defm odr_deduplication : BB<"odr-deduplication",

llvm/tools/llvm-dwarfutil/llvm-dwarfutil.cpp

if (opt::Arg *Tombstone = Args.getLastArg(OPT_tombstone)) {
     else if (S == "exec")
       Options.Tombstone = TombstoneKind::Exec;
     else
       return createStringError(
           std::errc::invalid_argument,
           formatv("unknown tombstone value: '{0}'", S).str().c_str());
   }
 
+  if (opt::Arg *BuildAccelerator = Args.getLastArg(OPT_build_accelerator)) {
+    StringRef S = BuildAccelerator->getValue();
+
+    if (S == "none")
+      Options.AccelTableKind = DwarfUtilAccelKind::None;
+    else if (S == "DWARF")
+      Options.AccelTableKind = DwarfUtilAccelKind::DWARF;
+    else
+      return createStringError(
+          std::errc::invalid_argument,
+          formatv("unknown build-accelerator value: '{0}'", S).str().c_str());
+  }
+
   if (Options.Verbose) {
     if (Options.NumThreads != 1 && Args.hasArg(OPT_threads))
       warning("--num-threads set to 1 because verbose mode is specified");
 
     Options.NumThreads = 1;
   }
 
   if (Options.DoODRDeduplication && Args.hasArg(OPT_odr_deduplication) &&
if (Error Err = writeToOutput(
             return objcopy::executeObjcopyOnBinary(Config, InputFile, OutFile);
           }))
     return Err;
 
   return Error::success();
 }
 
 static Error applyCLOptions(const struct Options &Opts, ObjectFile &InputFile) {
-  if (Opts.DoGarbageCollection) {
-    verbose("Do garbage collection for debug info ...", Opts.Verbose);
+  if (Opts.DoGarbageCollection ||
+      Opts.AccelTableKind != DwarfUtilAccelKind::None) {
+    verbose("Do debug info linking...", Opts.Verbose);
 
     DebugInfoBits LinkedDebugInfo;
     raw_svector_ostream OutStream(LinkedDebugInfo);
 
     if (Error Err = linkDebugInfo(InputFile, Opts, OutStream))
       return Err;
 
     if (Error Err =

llvm/unittests/CodeGen/TestAsmPrinter.cpp

llvm::Error TestAsmPrinter::init(const Target *TheTarget, StringRef TripleName,
 
   // Set the DWARF format.
   MC->setDwarfFormat(DwarfFormat);
 
   return Error::success();
 }
 
 void TestAsmPrinter::setDwarfUsesRelocationsAcrossSections(bool Enable) {
-  struct HackMCAsmInfo : MCAsmInfo {
-    void setDwarfUsesRelocationsAcrossSections(bool Enable) {
-      DwarfUsesRelocationsAcrossSections = Enable;
-    }
-  };
-  static_cast<HackMCAsmInfo *>(const_cast<MCAsmInfo *>(TM->getMCAsmInfo()))
-      ->setDwarfUsesRelocationsAcrossSections(Enable);
+  Asm->setDwarfUsesRelocationsAcrossSections(Enable);
 }