[DWARFLinker][NFC] Add None value to the DwarfLinkerAccelTableKind enum.

[avl]

Summary

this review is extracted from D86539.

1. Rename AccelTableKind to DwarfLinkerAccelTableKind (to differentiate from AccelTableKind from CodeGen/AsmPrinter/DwarfDebug.h)

2. Add None value to the DwarfLinkerAccelTableKind.

[JDevlieghere]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1791

Nit: llvm style guide says comments need to be sentences starting with an uppercase letter.

llvm/tools/dsymutil/dsymutil.cpp

209–229

Should we update this and allow None as a valid input for dsymutil?

[avl]

llvm/tools/dsymutil/dsymutil.cpp

209–229

we can, if we want None for dsymutil. Will update this patch accordingly.

[JDevlieghere]

llvm/tools/dsymutil/dsymutil.cpp

209–229

It seems straightforward enough that we might as well support it.

[avl]

added 'None' value for 'accelerator' option of dsymutil.

[aprantl]

llvm/tools/dsymutil/dsymutil.cpp

224

Typo (also in the original): Supported

[avl]

Thank you for the review!

llvm/docs/CommandGuide/dsymutil.rst

 its symbol table. By default, the linked debug information is placed in a
 ``.dSYM`` bundle with the same name as the executable.
 
 OPTIONS
 -------
 .. option:: --accelerator=<accelerator type>
 
  Specify the desired type of accelerator table. Valid options are 'Apple',
- 'Dwarf' and 'Default'.
+ 'Dwarf', 'Default' and 'None'.
 
 .. option:: --arch <arch>
 
  Link DWARF debug information only for specified CPU architecture types.
  Architectures may be specified by name. When using this option, an error will
  be returned if any architectures can not be properly linked.  This option can
  be specified multiple times, once for each desired architecture. All CPU
  architectures will be linked by default and any architectures that can't be

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 AccelTableKind {
+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
 };
 
 /// Partial address range. Besides an offset, only the
 /// HighPC is stored. The structure is stored in a map where the LowPC is the
public:
   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(AccelTableKind Kind) {
+  void setAccelTableKind(DwarfLinkerAccelTableKind Kind) {
     Options.TheAccelTableKind = 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
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
-    AccelTableKind TheAccelTableKind = AccelTableKind::Default;
+    DwarfLinkerAccelTableKind TheAccelTableKind =
+        DwarfLinkerAccelTableKind::Default;
 
     /// Prepend path for the clang modules.
     std::string PrependPath;
 
     // warning handler
     messageHandler WarningHandler = nullptr;
 
     // error handler

llvm/lib/DWARFLinker/DWARFLinker.cpp

TheDwarfEmitter->emitLineTableForUnit(
         Params, LineData.slice(*StmtList + 4, PrologueEnd),
         LineTable.Prologue.MinInstLength, NewRows,
         Unit.getOrigUnit().getAddressByteSize());
   }
 }
 
 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
   switch (Options.TheAccelTableKind) {
-  case AccelTableKind::Apple:
+  case DwarfLinkerAccelTableKind::None:
+    // Nothing to do.
+    break;
+  case DwarfLinkerAccelTableKind::Apple:
     emitAppleAcceleratorEntriesForUnit(Unit);
     break;
-  case AccelTableKind::Dwarf:
+  case DwarfLinkerAccelTableKind::Dwarf:
     emitDwarfAcceleratorEntriesForUnit(Unit);
     break;
-  case AccelTableKind::Pub:
+  case DwarfLinkerAccelTableKind::Pub:
     emitPubAcceleratorEntriesForUnit(Unit);
     break;
-  case AccelTableKind::Default:
+  case DwarfLinkerAccelTableKind::Default:
     llvm_unreachable("The default must be updated to a concrete value.");
     break;
   }
 }
 
 void DWARFLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
   // Add namespaces.
   for (const auto &Namespace : Unit.getNamespaces())
for (auto &CurrentUnit : CompileUnits) {
              CurrentUnit->computeNextUnitOffset(DwarfVersion));
     }
   }
 
   return OutputDebugInfoSize - StartOutputDebugInfoSize;
 }
 
 void DWARFLinker::updateAccelKind(DWARFContext &Dwarf) {
-  if (Options.TheAccelTableKind != AccelTableKind::Default)
+  if (Options.TheAccelTableKind != DwarfLinkerAccelTableKind::Default)
     return;
 
   auto &DwarfObj = Dwarf.getDWARFObj();
 
   if (!AtLeastOneDwarfAccelTable &&
       (!DwarfObj.getAppleNamesSection().Data.empty() ||
        !DwarfObj.getAppleTypesSection().Data.empty() ||
        !DwarfObj.getAppleNamespacesSection().Data.empty() ||
bool DWARFLinker::link() {
   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 == AccelTableKind::Default) {
+  if (Options.TheAccelTableKind == DwarfLinkerAccelTableKind::Default) {
     if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
-      Options.TheAccelTableKind = AccelTableKind::Dwarf;
+      Options.TheAccelTableKind = DwarfLinkerAccelTableKind::Dwarf;
     else
-      Options.TheAccelTableKind = AccelTableKind::Apple;
+      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";
bool DWARFLinker::link() {
   };
 
   auto EmitLambda = [&]() {
     // Emit everything that's global.
     if (!Options.NoOutput) {
       TheDwarfEmitter->emitAbbrevs(Abbreviations, MaxDwarfVersion);
       TheDwarfEmitter->emitStrings(OffsetsStringPool);
       switch (Options.TheAccelTableKind) {
-      case AccelTableKind::Apple:
+      case DwarfLinkerAccelTableKind::None:
+        // Nothing to do.
+        break;
+      case DwarfLinkerAccelTableKind::Apple:
         TheDwarfEmitter->emitAppleNames(AppleNames);
         TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
         TheDwarfEmitter->emitAppleTypes(AppleTypes);
         TheDwarfEmitter->emitAppleObjc(AppleObjc);
         break;
-      case AccelTableKind::Dwarf:
+      case DwarfLinkerAccelTableKind::Dwarf:
         TheDwarfEmitter->emitDebugNames(DebugNames);
         break;
-      case AccelTableKind::Pub:
+      case DwarfLinkerAccelTableKind::Pub:
         // Already emitted by emitPubAcceleratorEntriesForUnit.
         break;
-      case AccelTableKind::Default:
+      case DwarfLinkerAccelTableKind::Default:
         llvm_unreachable("Default should have already been resolved.");
         break;
       }
     }
   };
 
   auto AnalyzeAll = [&]() {
     for (unsigned I = 0, E = NumObjects; I != E; ++I) {

llvm/test/tools/dsymutil/X86/accelerator.test

 RUN: dsymutil -accelerator=Dwarf -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 -o %t.dwarf.dSYM
 RUN: dsymutil -accelerator=Apple -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 -o %t.apple.dSYM
+RUN: dsymutil -accelerator=None -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 -o %t.none.dSYM
 
 RUN: llvm-dwarfdump -verify %t.dwarf.dSYM
 RUN: llvm-dwarfdump -verify %t.apple.dSYM
+RUN: llvm-dwarfdump -verify %t.none.dSYM
 
 RUN: llvm-dwarfdump -debug-names %t.dwarf.dSYM | FileCheck %s -check-prefixes=NAMES,DWARF
 RUN: llvm-dwarfdump -apple-names -apple-namespaces -apple-types %t.apple.dSYM | FileCheck %s -check-prefixes=NAMES,APPLE
+RUN: llvm-dwarfdump -a %t.none.dSYM | FileCheck %s -check-prefixes=NONE
 
 RUN: dsymutil -update -accelerator=Dwarf %t.apple.dSYM
 RUN: dsymutil -update -accelerator=Apple %t.dwarf.dSYM
+RUN: dsymutil -update -accelerator=None %t.none.dSYM
 
 RUN: llvm-dwarfdump -verify %t.dwarf.dSYM
 RUN: llvm-dwarfdump -verify %t.apple.dSYM
+RUN: llvm-dwarfdump -verify %t.none.dSYM
 
 RUN: llvm-dwarfdump -debug-names %t.apple.dSYM | FileCheck %s -check-prefixes=NAMES,DWARF
 RUN: llvm-dwarfdump -apple-names -apple-namespaces -apple-types %t.dwarf.dSYM | FileCheck %s -check-prefixes=NAMES,APPLE
+RUN: llvm-dwarfdump -a %t.none.dSYM | FileCheck %s -check-prefixes=NONE
 
 DWARF: .debug_names contents:
 DWARF: Compilation Unit offsets [
 DWARF:   CU[0]
 DWARF:   CU[1]
 DWARF:   CU[2]
 DWARF: ]
 
 APPLE-DAG: .apple_names contents:
 APPLE-DAG: .apple_types contents:
 APPLE-DAG: .apple_namespaces contents:
 
 NAMES-DAG: "private_int"
 NAMES-DAG: "baz"
 NAMES-DAG: "int"
 NAMES-DAG: "bar"
 NAMES-DAG: "foo"
 NAMES-DAG: "inc"
 NAMES-DAG: "val"
 NAMES-DAG: "main"
 NAMES-DAG: "char"
+
+NONE-NOT: .debug_names
+NONE-NOT: .apple_names
+NONE-NOT: .apple_types
+NONE-NOT: .apple_namespaces
+NONE-NOT: .apple_objc
+NONE-NOT: .debug_pubnames
+NONE-NOT: .debug_types
+NONE-NOT: .debug_gnu_pubnames
+NONE-NOT: .debug_gnu_types

llvm/tools/dsymutil/LinkUtils.h

struct LinkOptions {
 
   /// Number of threads.
   unsigned Threads = 1;
 
   // Output file type.
   OutputFileType FileType = OutputFileType::Object;
 
   /// The accelerator table kind
-  AccelTableKind TheAccelTableKind;
+  DwarfLinkerAccelTableKind 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/Options.td

HelpText<"Link DWARF debug information only for specified CPU architecture"
            "types. This option can be specified multiple times, once for each"
            "desired architecture. All CPU architectures will be linked by"
            "default.">,
   Group<grp_general>;
 def: Joined<["--", "-"], "arch=">, Alias<arch>;
 
 def accelerator: Separate<["--", "-"], "accelerator">,
   MetaVarName<"<accelerator type>">,
-  HelpText<"Specify the desired type of accelerator table. Valid options are 'Apple' (.apple_names, .apple_namespaces, .apple_types, .apple_objc), 'Dwarf' (.debug_names), 'Pub' (.debug_pubnames, .debug_pubtypes) and 'Default'">,
+  HelpText<"Specify the desired type of accelerator table. Valid options are 'Apple' (.apple_names, .apple_namespaces, .apple_types, .apple_objc), 'Dwarf' (.debug_names), 'Pub' (.debug_pubnames, .debug_pubtypes), 'Default' and 'None'">,
   Group<grp_general>;
 def: Joined<["--", "-"], "accelerator=">, Alias<accelerator>;
 
 def toolchain: Separate<["--", "-"], "toolchain">,
   MetaVarName<"<toolchain>">,
   HelpText<"Embed toolchain information in dSYM bundle.">,
   Group<grp_general>;
 

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<AccelTableKind> getAccelTableKind(opt::InputArgList &Args) {
+static Expected<DwarfLinkerAccelTableKind>
+getAccelTableKind(opt::InputArgList &Args) {
   if (opt::Arg *Accelerator = Args.getLastArg(OPT_accelerator)) {
     StringRef S = Accelerator->getValue();
     if (S == "Apple")
-      return AccelTableKind::Apple;
+      return DwarfLinkerAccelTableKind::Apple;
     if (S == "Dwarf")
-      return AccelTableKind::Dwarf;
+      return DwarfLinkerAccelTableKind::Dwarf;
     if (S == "Pub")
-      return AccelTableKind::Pub;
+      return DwarfLinkerAccelTableKind::Pub;
     if (S == "Default")
-      return AccelTableKind::Default;
-    return make_error<StringError>(
-        "invalid accelerator type specified: '" + S +
-            "'. Support values are 'Apple', 'Dwarf', 'Pub' and 'Default'.",
+      return DwarfLinkerAccelTableKind::Default;
+    if (S == "None")
+      return DwarfLinkerAccelTableKind::None;
+    return make_error<StringError>("invalid accelerator type specified: '" + S +
+                                       "'. Supported values are 'Apple', "
+                                       "'Dwarf', 'Pub', 'Default' and 'None'.",
                                    inconvertibleErrorCode());
   }
-  return AccelTableKind::Default;
+  return DwarfLinkerAccelTableKind::Default;
 }
 
 static Expected<DWARFVerify> getVerifyKind(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_verify))
     return DWARFVerify::Output;
   if (opt::Arg *Verify = Args.getLastArg(OPT_verify_dwarf)) {
     StringRef S = Verify->getValue();
     if (S == "input")
       return DWARFVerify::Input;
     if (S == "output")
       return DWARFVerify::Output;
     if (S == "all")
       return DWARFVerify::All;
     if (S == "none")
       return DWARFVerify::None;
     return make_error<StringError>(
         "invalid verify type specified: '" + S +
-            "'. Support values are 'input', 'output', 'all' and 'none'.",
+            "'. Supported values are 'input', 'output', 'all' and 'none'.",
         inconvertibleErrorCode());
   }
   return DWARFVerify::None;
 }
 
 /// Parses the command line options into the LinkOptions struct and performs
 /// some sanity checking. Returns an error in case the latter fails.
 static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
   if (opt::Arg *ReproducerPath = Args.getLastArg(OPT_use_reproducer)) {
     Options.ReproMode = ReproducerMode::Use;
     Options.ReproducerPath = ReproducerPath->getValue();
   }
 
   if (Args.hasArg(OPT_gen_reproducer))
     Options.ReproMode = ReproducerMode::Generate;
 
-  if (Expected<AccelTableKind> AccelKind = getAccelTableKind(Args)) {
+  if (Expected<DwarfLinkerAccelTableKind> AccelKind = getAccelTableKind(Args)) {
     Options.LinkOpts.TheAccelTableKind = *AccelKind;
   } else {
     return AccelKind.takeError();
   }
 
   if (opt::Arg *SymbolMap = Args.getLastArg(OPT_symbolmap))
     Options.SymbolMap = SymbolMap->getValue();