[DWARFLinker][NFC] Change interface of DWARFLinker to specify accel table kinds explicitly.

[avl]

Summary

Currently, DWARFLinker receives kind of accel tables as predefined sets:

Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
Dwarf,   ///< DWARF v5 .debug_names.
Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
Pub,     ///< .debug_pubnames, .debug_pubtypes

This patch removes implicit sets of tables(Default, Dwarf) and allows to ask for several sets:

Apple,     ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
Pub,       ///< .debug_pubnames, .debug_pubtypes
DebugNames ///< .debug_names.

It allows seamlessness adding more accel tables in the future: .gdb_index, .debug_cu_index...
Doing things that way, DWARFLinker will be independent of consumers' requirements.
f.e. dsymutil and llvm-dwarfutil may have different variants for Default set
(so, instead of implementing these differencies inside DWARFLinker it could be
implemented in the corresponding module).

[clayborg]

I am not sure this change makes sense as all of the Apple tables should be included if you have any, and likewise for .debug_pubnames and .debug_pubtypes: you want both or none.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

34–37

All of these go together and you never want any of them unless you have all of them. I would keep these as "Apple" as a single entry.

38–39

I would keep these as "Pub", again, you never want just one of them, you either want both or none.

[avl]

I am not sure this change makes sense as all of the Apple tables should be included if you have any, and likewise for .debug_pubnames and .debug_pubtypes: you want both or none.

My intention is to allow generation other index tables. f.e. we might want to generate .gdb_index and/or .debug_cu_index. In that case we need to have a way to specify not only "Apple" or "Debug" but additional tables.

Another thing is that "Default" can be defined differently for different tools. Thus it would be good if DWARFLinker would not have knowledge about dsymutil or llvm-dwarfutil specifics.

What about following classification:

enum class DwarfLinkerAccelTableKind : uint8_t {
  Apple,            ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
  DWARFv4,   ///< .debug_pubnames, .debug_pubtypes
  DWARFv5    ///< DWARF v5 .debug_names.
};

or even:

enum class DwarfLinkerAccelTableKind : uint8_t {
  Apple,            ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
  DWARF,       ///< .debug_pubnames, .debug_pubtypes for DWARFv4 or  .debug_names for DWARFv5
};

We will be able to extend it for other tables later:

enum class DwarfLinkerAccelTableKind : uint8_t {
  Apple,            ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
  DWARF,       ///< .debug_pubnames, .debug_pubtypes for DWARFv4 or  .debug_names for DWARFv5
  GDB_index
};

?

[clayborg]

In D132371#3741832, @avl wrote:

I am not sure this change makes sense as all of the Apple tables should be included if you have any, and likewise for .debug_pubnames and .debug_pubtypes: you want both or none.

My intention is to allow generation other index tables. f.e. we might want to generate .gdb_index and/or .debug_cu_index. In that case we need to have a way to specify not only "Apple" or "Debug" but additional tables.

Another thing is that "Default" can be defined differently for different tools. Thus it would be good if DWARFLinker would not have knowledge about dsymutil or llvm-dwarfutil specifics.

What about following classification:

enum class DwarfLinkerAccelTableKind : uint8_t {
  Apple,            ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
  DWARFv4,   ///< .debug_pubnames, .debug_pubtypes
  DWARFv5    ///< DWARF v5 .debug_names.
};

Anything like this is fine with me as long as the buckets enable all of the needed sections to be emitted. I like the DWARFv4 and DWARFv5 separation you did above best out of all of our different DwarfLinkerAccelTableKind definitions that you proposed.

[avl]

addressed comments.

[JDevlieghere]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

33–37

So now this removes "None" and "Default" and renames "Pub" to "DWARFv4"? I think this is more confusing than it was.

If it were me I'd say:

enum class DwarfLinkerAccelTableKind : uint8_t {
  Apple,
  DebugNames,  // or DWARFv5 or DWARF5
  Pub,

On Apple platforms we want to use Apple for DWARF <=4 and debug names for >= 5.

818

I would expect a value of 1 here.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1821–1823

Unrelated formatting changes?

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

33–37

ok.

818

ok.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1821–1823

It is related. The new formatting happened because nesting level was changed.

[avl]

addressed comments.

[avl]

rebased.

[avl]

Note: I kept current behavior in this patch(i.e. for the case DsymutilAccelTableKind::Default the type of accelerator table is auto-detected: use DebugNames for (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable) case, use Apple otherwise). If we want this - https://reviews.llvm.org/D132371#inline-1276384 - "On Apple platforms we want to use Apple for DWARF <=4 and debug names for >= 5" - then I would update the patch accordingly.

[avl]

ping.

My understanding is that concerns raised by @clayborg and @JDevlieghere are already addressed.

[clayborg]

Sorry for the delay! Looks good to me. I think someone from Apple/dsymutil should do the final acceptance though to ensure it is ok for them.

[avl]

ping

[JDevlieghere]

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

740–745

The original logic I tried to implement was to prefer the Dwarf debug names for Dwarf 5 and alter, and the Apple variant for anything before that. Can we retain that logic?

[avl]

Excuse me for the delay. Addressed comment: select accelerator table for the "Default" case based on the dwarf version.

[JDevlieghere]

LGTM

llvm/include/llvm/DWARFLinker/DWARFLinker.h

 class DataExtractor;
 class DeclContextTree;
 struct MCDwarfLineTableParams;
 template <typename T> class SmallVectorImpl;
 
 enum class DwarfLinkerClient { Dsymutil, LLD, General };
 
 /// The kind of accelerator tables we should emit.
 enum class DwarfLinkerAccelTableKind : uint8_t {
-  None,
-  Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
-  Dwarf,   ///< DWARF v5 .debug_names.
-  Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
-  Pub,     ///< .debug_pubnames, .debug_pubtypes
+  Apple,     ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
+  Pub,       ///< .debug_pubnames, .debug_pubtypes
+  DebugNames ///< .debug_names.
 };
 
 /// AddressesMap represents information about valid addresses used
 /// by debug information. Valid addresses are those which points to
 /// live code sections. i.e. relocations for these addresses point
 /// into sections which would be/are placed into resulting binary.
 class AddressesMap {
 public:
   virtual ~AddressesMap();
 
   /// Checks that there are valid relocations against a .debug_info
public:
   /// Set whether to keep the enclosing function for a static variable.
   void setKeepFunctionForStatic(bool KeepFunctionForStatic) {
     Options.KeepFunctionForStatic = KeepFunctionForStatic;
   }
 
   /// Use specified number of threads for parallel files linking.
   void setNumThreads(unsigned NumThreads) { Options.Threads = NumThreads; }
 
-  /// Set kind of accelerator tables to be generated.
-  void setAccelTableKind(DwarfLinkerAccelTableKind Kind) {
-    Options.TheAccelTableKind = Kind;
+  /// Add kind of accelerator tables to be generated.
+  void addAccelTableKind(DwarfLinkerAccelTableKind Kind) {
+    assert(std::find(Options.AccelTables.begin(), Options.AccelTables.end(),
+                     Kind) == Options.AccelTables.end());
+    Options.AccelTables.emplace_back(Kind);
   }
 
   /// Set prepend path for clang modules.
   void setPrependPath(const std::string &Ppath) { Options.PrependPath = Ppath; }
 
   /// Set translator which would be used for strings.
   void
   setStringsTranslator(std::function<StringRef(StringRef)> StringsTranslator) {
private:
   }
 
   void reportError(const Twine &Warning, const DWARFFile &File,
                    const DWARFDie *DIE = nullptr) const {
     if (Options.ErrorHandler != nullptr)
       Options.ErrorHandler(Warning, File.FileName, DIE);
   }
 
-  /// Remembers the kinds of accelerator tables we've seen in a unit.
-  void updateAccelKind(DWARFContext &Dwarf);
-
   /// Emit warnings as Dwarf compile units to leave a trail after linking.
   bool emitPaperTrailWarnings(const DWARFFile &File,
                               OffsetsStringPool &StringPool);
 
   void copyInvariantDebugSection(DWARFContext &Dwarf);
 
   /// Keep information for referenced clang module: already loaded DWARF info
   /// of the clang module and a CompileUnit of the module.
private:
   /// Extract the line tables from the original dwarf, extract the relevant
   /// parts according to the linked function ranges and emit the result in the
   /// .debug_line section.
   void patchLineTableForUnit(CompileUnit &Unit, DWARFContext &OrigDwarf,
                              const DWARFFile &File);
 
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
-  void emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit);
-  void emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit);
-  void emitPubAcceleratorEntriesForUnit(CompileUnit &Unit);
 
   /// Patch the frame info for an object file and emit it.
   void patchFrameInfoForObject(const DWARFFile &, RangesTy &Ranges,
                                DWARFContext &, unsigned AddressSize);
 
   /// FoldingSet that uniques the abbreviations.
   FoldingSet<DIEAbbrev> AbbreviationsSet;
 
private:
 
   /// Allocator used for all the DIEValue objects.
   BumpPtrAllocator DIEAlloc;
   /// @}
 
   DwarfEmitter *TheDwarfEmitter;
   std::vector<LinkContext> ObjectContexts;
 
-  bool AtLeastOneAppleAccelTable = false;
-  bool AtLeastOneDwarfAccelTable = false;
-
   /// The CIEs that have been emitted in the output section. The actual CIE
   /// data serves a the key to this StringMap, this takes care of comparing the
   /// semantics of CIEs defined in different object files.
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
   /// .debug_frame section.
   uint32_t LastCIEOffset = 0;
struct DWARFLinkerOptions {
 
     /// Whether we want a static variable to force us to keep its enclosing
     /// function.
     bool KeepFunctionForStatic = false;
 
     /// Number of threads.
     unsigned Threads = 1;
 
-    /// The accelerator table kind
-    DwarfLinkerAccelTableKind TheAccelTableKind =
-        DwarfLinkerAccelTableKind::Default;
+    /// The accelerator table kinds
+    SmallVector<DwarfLinkerAccelTableKind, 1> AccelTables;
 
     /// Prepend path for the clang modules.
     std::string PrependPath;
 
     // warning handler
     messageHandler WarningHandler = nullptr;
 
     // error handler

llvm/lib/DWARFLinker/DWARFLinker.cpp

else {
     TheDwarfEmitter->emitLineTableForUnit(
         Params, LineData.slice(*StmtList + 4, PrologueEnd),
         LineTable.Prologue.MinInstLength, NewRows,
         Unit.getOrigUnit().getAddressByteSize());
   }
 }
 
 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
-  switch (Options.TheAccelTableKind) {
-  case DwarfLinkerAccelTableKind::None:
-    // Nothing to do.
-    break;
-  case DwarfLinkerAccelTableKind::Apple:
-    emitAppleAcceleratorEntriesForUnit(Unit);
-    break;
-  case DwarfLinkerAccelTableKind::Dwarf:
-    emitDwarfAcceleratorEntriesForUnit(Unit);
-    break;
-  case DwarfLinkerAccelTableKind::Pub:
-    emitPubAcceleratorEntriesForUnit(Unit);
-    break;
-  case DwarfLinkerAccelTableKind::Default:
-    llvm_unreachable("The default must be updated to a concrete value.");
-    break;
-  }
-}
-
-void DWARFLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
+  for (DwarfLinkerAccelTableKind AccelTableKind : Options.AccelTables) {
+    switch (AccelTableKind) {
+    case DwarfLinkerAccelTableKind::Apple: {
       // Add namespaces.
       for (const auto &Namespace : Unit.getNamespaces())
-    AppleNamespaces.addName(Namespace.Name,
-                            Namespace.Die->getOffset() + Unit.getStartOffset());
-
-  /// Add names.
+        AppleNamespaces.addName(Namespace.Name, Namespace.Die->getOffset() +
+                                                    Unit.getStartOffset());
+      // Add names.
       for (const auto &Pubname : Unit.getPubnames())
         AppleNames.addName(Pubname.Name,
                            Pubname.Die->getOffset() + Unit.getStartOffset());
-
-  /// Add types.
+      // Add types.
       for (const auto &Pubtype : Unit.getPubtypes())
         AppleTypes.addName(
             Pubtype.Name, Pubtype.Die->getOffset() + Unit.getStartOffset(),
             Pubtype.Die->getTag(),
             Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
                                             : 0,
             Pubtype.QualifiedNameHash);
-
-  /// Add ObjC names.
+      // Add ObjC names.
       for (const auto &ObjC : Unit.getObjC())
-    AppleObjc.addName(ObjC.Name, ObjC.Die->getOffset() + Unit.getStartOffset());
-}
-
-void DWARFLinker::emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit) {
+        AppleObjc.addName(ObjC.Name,
+                          ObjC.Die->getOffset() + Unit.getStartOffset());
+    } break;
+    case DwarfLinkerAccelTableKind::Pub: {
+      TheDwarfEmitter->emitPubNamesForUnit(Unit);
+      TheDwarfEmitter->emitPubTypesForUnit(Unit);
+    } break;
+    case DwarfLinkerAccelTableKind::DebugNames: {
       for (const auto &Namespace : Unit.getNamespaces())
         DebugNames.addName(Namespace.Name, Namespace.Die->getOffset(),
                            Namespace.Die->getTag(), Unit.getUniqueID());
       for (const auto &Pubname : Unit.getPubnames())
         DebugNames.addName(Pubname.Name, Pubname.Die->getOffset(),
                            Pubname.Die->getTag(), Unit.getUniqueID());
       for (const auto &Pubtype : Unit.getPubtypes())
         DebugNames.addName(Pubtype.Name, Pubtype.Die->getOffset(),
                            Pubtype.Die->getTag(), Unit.getUniqueID());
+    } break;
+    }
   }
-
-void DWARFLinker::emitPubAcceleratorEntriesForUnit(CompileUnit &Unit) {
-  TheDwarfEmitter->emitPubNamesForUnit(Unit);
-  TheDwarfEmitter->emitPubTypesForUnit(Unit);
 }
 
 /// Read the frame info stored in the object, and emit the
 /// patched frame descriptions for the resulting file.
 ///
 /// This is actually pretty easy as the data of the CIEs and FDEs can
 /// be considered as black boxes and moved as is. The only thing to do
 /// is to patch the addresses in the headers.
for (auto &CurrentUnit : CompileUnits) {
       assert(Emitter->getDebugInfoSectionSize() ==
              CurrentUnit->computeNextUnitOffset(DwarfVersion));
     }
   }
 
   return OutputDebugInfoSize - StartOutputDebugInfoSize;
 }
 
-void DWARFLinker::updateAccelKind(DWARFContext &Dwarf) {
-  if (Options.TheAccelTableKind != DwarfLinkerAccelTableKind::Default)
-    return;
-
-  auto &DwarfObj = Dwarf.getDWARFObj();
-
-  if (!AtLeastOneDwarfAccelTable &&
-      (!DwarfObj.getAppleNamesSection().Data.empty() ||
-       !DwarfObj.getAppleTypesSection().Data.empty() ||
-       !DwarfObj.getAppleNamespacesSection().Data.empty() ||
-       !DwarfObj.getAppleObjCSection().Data.empty())) {
-    AtLeastOneAppleAccelTable = true;
-  }
-
-  if (!AtLeastOneDwarfAccelTable && !DwarfObj.getNamesSection().Data.empty()) {
-    AtLeastOneDwarfAccelTable = true;
-  }
-}
-
 bool DWARFLinker::emitPaperTrailWarnings(const DWARFFile &File,
                                          OffsetsStringPool &StringPool) {
 
   if (File.Warnings.empty())
     return false;
 
   DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
   CUDie->setOffset(11);
TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getArangesSection(),
                                        "debug_aranges");
 }
 
 void DWARFLinker::addObjectFile(DWARFFile &File, objFileLoader Loader,
                                 CompileUnitHandler OnCUDieLoaded) {
   ObjectContexts.emplace_back(LinkContext(File));
 
   if (ObjectContexts.back().File.Dwarf) {
-    updateAccelKind(*ObjectContexts.back().File.Dwarf);
-
     for (const std::unique_ptr<DWARFUnit> &CU :
          ObjectContexts.back().File.Dwarf->compile_units()) {
       DWARFDie CUDie = CU->getUnitDIE();
 
       if (!CUDie)
         continue;
 
       OnCUDieLoaded(*CU);
Error DWARFLinker::link() {
   // This Dwarf string pool which is used for emission. It must be used
   // serially as the order of calling getStringOffset matters for
   // reproducibility.
   OffsetsStringPool OffsetsStringPool(StringsTranslator, true);
 
   // ODR Contexts for the optimize.
   DeclContextTree ODRContexts;
 
-  // If we haven't decided on an accelerator table kind yet, we base ourselves
-  // on the DWARF we have seen so far. At this point we haven't pulled in debug
-  // information from modules yet, so it is technically possible that they
-  // would affect the decision. However, as they're built with the same
-  // compiler and flags, it is safe to assume that they will follow the
-  // decision made here.
-  if (Options.TheAccelTableKind == DwarfLinkerAccelTableKind::Default) {
-    if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
-      Options.TheAccelTableKind = DwarfLinkerAccelTableKind::Dwarf;
-    else
-      Options.TheAccelTableKind = DwarfLinkerAccelTableKind::Apple;
-  }
-
   for (LinkContext &OptContext : ObjectContexts) {
     if (Options.Verbose) {
       if (DwarfLinkerClientID == DwarfLinkerClient::Dsymutil)
         outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
       else
         outs() << "OBJECT FILE: " << OptContext.File.FileName << "\n";
     }
 
auto CloneLambda = [&](size_t I) {
     cleanupAuxiliarryData(OptContext);
   };
 
   auto EmitLambda = [&]() {
     // Emit everything that's global.
     if (!Options.NoOutput) {
       TheDwarfEmitter->emitAbbrevs(Abbreviations, Options.TargetDWARFVersion);
       TheDwarfEmitter->emitStrings(OffsetsStringPool);
-      switch (Options.TheAccelTableKind) {
-      case DwarfLinkerAccelTableKind::None:
-        // Nothing to do.
-        break;
+      for (DwarfLinkerAccelTableKind TableKind : Options.AccelTables) {
+        switch (TableKind) {
         case DwarfLinkerAccelTableKind::Apple:
-        TheDwarfEmitter->emitAppleNames(AppleNames);
           TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
+          TheDwarfEmitter->emitAppleNames(AppleNames);
           TheDwarfEmitter->emitAppleTypes(AppleTypes);
           TheDwarfEmitter->emitAppleObjc(AppleObjc);
           break;
-      case DwarfLinkerAccelTableKind::Dwarf:
-        TheDwarfEmitter->emitDebugNames(DebugNames);
-        break;
         case DwarfLinkerAccelTableKind::Pub:
-        // Already emitted by emitPubAcceleratorEntriesForUnit.
+          // Already emitted by emitAcceleratorEntriesForUnit.
+          // Already emitted by emitAcceleratorEntriesForUnit.
           break;
-      case DwarfLinkerAccelTableKind::Default:
-        llvm_unreachable("Default should have already been resolved.");
+        case DwarfLinkerAccelTableKind::DebugNames:
+          TheDwarfEmitter->emitDebugNames(DebugNames);
           break;
         }
       }
+    }
   };
 
   auto AnalyzeAll = [&]() {
     for (unsigned I = 0, E = NumObjects; I != E; ++I) {
       AnalyzeLambda(I);
 
       std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
       ProcessedFiles.set(I);

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

bool DwarfLinkerForBinary::link(const DebugMap &Map) {
 
   GeneralLinker.setVerbosity(Options.Verbose);
   GeneralLinker.setStatistics(Options.Statistics);
   GeneralLinker.setVerifyInputDWARF(Options.VerifyInputDWARF);
   GeneralLinker.setNoOutput(Options.NoOutput);
   GeneralLinker.setNoODR(Options.NoODR);
   GeneralLinker.setUpdate(Options.Update);
   GeneralLinker.setNumThreads(Options.Threads);
-  GeneralLinker.setAccelTableKind(Options.TheAccelTableKind);
   GeneralLinker.setPrependPath(Options.PrependPath);
   GeneralLinker.setKeepFunctionForStatic(Options.KeepFunctionForStatic);
   if (Options.Translator)
     GeneralLinker.setStringsTranslator(TranslationLambda);
   GeneralLinker.setWarningHandler(
       [&](const Twine &Warning, StringRef Context, const DWARFDie *DIE) {
         reportWarning(Warning, Context, DIE);
       });
bool DwarfLinkerForBinary::link(const DebugMap &Map) {
 
   // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
   if (MaxDWARFVersion == 0)
     MaxDWARFVersion = 3;
 
   if (Error E = GeneralLinker.setTargetDWARFVersion(MaxDWARFVersion))
     return error(toString(std::move(E)));
 
+  switch (Options.TheAccelTableKind) {
+  case DsymutilAccelTableKind::Apple:
+    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Apple);
+    break;
+  case DsymutilAccelTableKind::Dwarf:
+    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::DebugNames);
+    break;
+  case DsymutilAccelTableKind::Pub:
+    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Pub);
+    break;
+  case DsymutilAccelTableKind::Default:
+    if (MaxDWARFVersion >= 5)
+      GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::DebugNames);
+    else
+      GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Apple);
+    break;
+  case DsymutilAccelTableKind::None:
+    // Nothing to do.
+    break;
+  }
+
   // link debug info for loaded object files.
   if (Error E = GeneralLinker.link())
     return error(toString(std::move(E)));
 
   StringRef ArchName = Map.getTriple().getArchName();
   if (Error E = emitRemarks(Options, Map.getBinaryPath(), ArchName, RL))
     return error(toString(std::move(E)));
 

llvm/tools/dsymutil/LinkUtils.h

 
 #include "llvm/DWARFLinker/DWARFLinker.h"
 #include "llvm/DWARFLinker/DWARFStreamer.h"
 #include <string>
 
 namespace llvm {
 namespace dsymutil {
 
+enum class DsymutilAccelTableKind : uint8_t {
+  None,
+  Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
+  Dwarf,   ///< DWARF v5 .debug_names.
+  Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
+  Pub,     ///< .debug_pubnames, .debug_pubtypes
+};
+
 struct LinkOptions {
   /// Verbosity
   bool Verbose = false;
 
   /// Statistics
   bool Statistics = false;
 
   /// Verify the input DWARF.
struct LinkOptions {
 
   /// Number of threads.
   unsigned Threads = 1;
 
   // Output file type.
   OutputFileType FileType = OutputFileType::Object;
 
   /// The accelerator table kind
-  DwarfLinkerAccelTableKind TheAccelTableKind;
+  DsymutilAccelTableKind TheAccelTableKind;
 
   /// -oso-prepend-path
   std::string PrependPath;
 
   /// The -object-prefix-map.
   std::map<std::string, std::string> ObjectPrefixMap;
 
   /// The Resources directory in the .dSYM bundle.

llvm/tools/dsymutil/dsymutil.cpp

if (!Options.ReproducerPath.empty() &&
       Options.ReproMode != ReproducerMode::Use)
     return make_error<StringError>(
         "cannot combine --gen-reproducer and --use-reproducer.",
         errc::invalid_argument);
 
   return Error::success();
 }
 
-static Expected<DwarfLinkerAccelTableKind>
+static Expected<DsymutilAccelTableKind>
 getAccelTableKind(opt::InputArgList &Args) {
   if (opt::Arg *Accelerator = Args.getLastArg(OPT_accelerator)) {
     StringRef S = Accelerator->getValue();
     if (S == "Apple")
-      return DwarfLinkerAccelTableKind::Apple;
+      return DsymutilAccelTableKind::Apple;
     if (S == "Dwarf")
-      return DwarfLinkerAccelTableKind::Dwarf;
+      return DsymutilAccelTableKind::Dwarf;
     if (S == "Pub")
-      return DwarfLinkerAccelTableKind::Pub;
+      return DsymutilAccelTableKind::Pub;
     if (S == "Default")
-      return DwarfLinkerAccelTableKind::Default;
+      return DsymutilAccelTableKind::Default;
     if (S == "None")
-      return DwarfLinkerAccelTableKind::None;
+      return DsymutilAccelTableKind::None;
     return make_error<StringError>("invalid accelerator type specified: '" + S +
                                        "'. Supported values are 'Apple', "
                                        "'Dwarf', 'Pub', 'Default' and 'None'.",
                                    inconvertibleErrorCode());
   }
-  return DwarfLinkerAccelTableKind::Default;
+  return DsymutilAccelTableKind::Default;
 }
 
 static Expected<ReproducerMode> getReproducerMode(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_gen_reproducer))
     return ReproducerMode::GenerateOnExit;
   if (opt::Arg *Reproducer = Args.getLastArg(OPT_reproducer)) {
     StringRef S = Reproducer->getValue();
     if (S == "GenerateOnExit")
static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
   } else {
     if (Expected<ReproducerMode> ReproMode = getReproducerMode(Args)) {
       Options.ReproMode = *ReproMode;
     } else {
       return ReproMode.takeError();
     }
   }
 
-  if (Expected<DwarfLinkerAccelTableKind> AccelKind = getAccelTableKind(Args)) {
+  if (Expected<DsymutilAccelTableKind> AccelKind = getAccelTableKind(Args)) {
     Options.LinkOpts.TheAccelTableKind = *AccelKind;
   } else {
     return AccelKind.takeError();
   }
 
   if (opt::Arg *SymbolMap = Args.getLastArg(OPT_symbolmap))
     Options.SymbolMap = SymbolMap->getValue();
 

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

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.setAccelTableKind(DwarfLinkerAccelTableKind::None);
   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);