[llvm-libtool-darwin] Switch to OptTableSummary

[avillega]

Summary

Switch the parse of command line options fromllvm::cl to OptTable.

The motivation for this change is to continue adding llvm based tools
to the llvm driver multicall. For more information about the proposal
and motivation, please see https://discourse.llvm.org/t/rfc-llvm-busybox-proposal/58494

[avillega]

Add end of line char

[smeenai]

This looks good, but could you add the motivation for the change to the commit description as well?

llvm/tools/llvm-libtool-darwin/Opts.td

24

Apple's libtool accepts this option with or without a space, so this should be SeparateOrJoined (and the help should be updated accordingly).

[smeenai]

Okay, this looks good after you address the -L comment. It'd be great if you could add a test for both the separate and joined forms of the argument as part of that too.

[avillega]

Fix review comments and type in bazel build file

[avillega]

Add tests for passing the -L and -l option arguments separated from the
option name

[smeenai]

Thank you!

llvm/docs/CommandGuide/llvm-libtool-darwin.rst

 --------
 :program:`llvm-libtool-darwin` supports the following options:
 
 .. option:: -arch_only <architecture>
 
   Build a static library only for the specified `<architecture>` and ignore all
   other architectures in the files.
 
-.. option:: -color
-
-  Use colors in output.
-
 .. option:: -D
 
   Use zero for timestamps and UIDs/GIDs. This is set by default.
 
 .. option:: -filelist <listfile[,dirname]>
 
   Read input file names from `<listfile>`. File names are specified in `<listfile>`
   one per line, separated only by newlines. Whitespace on a line is assumed
   to be part of the filename. If the directory name, `dirname`, is also
   specified then it is prepended to each file name in the `<listfile>`.
 
 .. option:: -h, -help
 
   Show help and usage for this command.
 
-.. option:: -help-list
-
-  Show help and usage for this command without grouping the options
-  into categories.
-
 .. option:: -l <x>
 
   Searches for the library libx.a in the library search path. If the string `<x>`
   ends with '.o', then the library 'x' is searched for without prepending 'lib'
   or appending '.a'. If the library is found, it is added to the list of input
   files. Otherwise, an error is raised.
 
 .. option:: -L <dir>

llvm/test/tools/llvm-libtool-darwin/L-and-l.test

 # RUN: llvm-ar cr %t/otherDirname/libinput1.a %t-input1.o
 
 # RUN: llvm-libtool-darwin -static -o %t.lib -linput2 -linput1 -L%t/dirname -L%t/otherDirname
 # RUN: llvm-ar t %t.lib | \
 # RUN:   FileCheck %s --check-prefix=OTHER-NAMES --implicit-check-not={{.}} -DPREFIX=%basename_t.tmp
 # RUN: llvm-nm --print-armap %t.lib | \
 # RUN:   FileCheck %s --check-prefix=OTHER-SYMBOLS -DPREFIX=%basename_t.tmp --match-full-lines
 
+## Check it is possible to pass arguments to -l and -L separated from the option
+## and the options specified multiple times:
+# RUN: rm -rf %t/otherDirname && mkdir -p %t/otherDirname
+# RUN: llvm-ar cr %t/otherDirname/libinput1.a %t-input1.o
+
+# RUN: llvm-libtool-darwin -static -o %t.lib -l input2 -l input1 -L %t/dirname -L %t/otherDirname
+# RUN: llvm-ar t %t.lib | \
+# RUN:   FileCheck %s --check-prefix=OTHER-NAMES --implicit-check-not={{.}} -DPREFIX=%basename_t.tmp
+# RUN: llvm-nm --print-armap %t.lib | \
+# RUN:   FileCheck %s --check-prefix=OTHER-SYMBOLS -DPREFIX=%basename_t.tmp --match-full-lines
+
 # OTHER-NAMES:      [[PREFIX]]-input2.o
 # OTHER-NAMES-NEXT: [[PREFIX]]-input1.o
 
 # OTHER-SYMBOLS:      Archive map
 # OTHER-SYMBOLS-NEXT: _symbol2 in [[PREFIX]]-input2.o
 # OTHER-SYMBOLS-NEXT: _symbol1 in [[PREFIX]]-input1.o
 # OTHER-SYMBOLS-EMPTY:
 

llvm/test/tools/llvm-libtool-darwin/help-message.test

 ## This test checks that the help message is displayed correctly.
 
 # RUN: llvm-libtool-darwin -h | \
-# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE,CATEG %s --match-full-lines --implicit-check-not="General options:"
+# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE %s --match-full-lines --implicit-check-not="General options:"
 # RUN: llvm-libtool-darwin -help | \
-# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE,CATEG %s --match-full-lines --implicit-check-not="General options:"
+# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE %s --match-full-lines --implicit-check-not="General options:"
 # RUN: llvm-libtool-darwin --help | \
-# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE,CATEG %s --match-full-lines --implicit-check-not="General options:"
-# RUN: llvm-libtool-darwin --help-list | \
-# RUN:   FileCheck -check-prefixes=LIBTOOL-USAGE,LIST %s --match-full-lines --implicit-check-not="safepoint-ir-verifier-print-only"
+# RUN:   FileCheck --check-prefixes=LIBTOOL-USAGE %s --match-full-lines --implicit-check-not="General options:"
 
 # RUN: not llvm-libtool-darwin -abcabc 2>&1 | FileCheck --check-prefix=UNKNOWN-ARG %s
 # RUN: not llvm-libtool-darwin --abcabc 2>&1 | FileCheck --check-prefix=UNKNOWN-ARG %s
 
 # LIBTOOL-USAGE: OVERVIEW: llvm-libtool-darwin
 # LIBTOOL-USAGE: USAGE: llvm-libtool-darwin{{(\.exe)?}} [options] <input files>
 # LIBTOOL-USAGE: OPTIONS:
 
-# CATEG:    Color Options:
-# LIST-NOT: Color Options:
-# CATEG:    Generic Options:
-# LIST-NOT: Generic Options:
-# CATEG:    llvm-libtool-darwin Options:
-# LIST-NOT: llvm-libtool-darwin Options:
-# LIST-NOT: General options:
-
-# UNKNOWN-ARG: Unknown command line argument '{{-+}}abcabc'
+# UNKNOWN-ARG: unknown argument '{{-+}}abcabc'

llvm/test/tools/llvm-libtool-darwin/invalid-input-output-args.test

 ## This test checks that an error is thrown in case of invalid input/output args.
 
 ## Missing input file:
 # RUN: not llvm-libtool-darwin -static -o %t.lib 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-INPUT
 
 # NO-INPUT: error: no input files specified
 
 ## Missing output file:
 # RUN: not llvm-libtool-darwin -static %t.input 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-OUTPUT
 
-# NO-OUTPUT: for the -o option: must be specified
+# NO-OUTPUT: -o option: must be specified
 
 ## Missing argument to -o:
 # RUN: not llvm-libtool-darwin -static %t.input -o 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=MISSING
 
-# MISSING: for the -o option: requires a value!
+# MISSING: -o: missing argument
 
 ## Input file not found:
 # RUN: not llvm-libtool-darwin -static -o %t.lib %t.missing 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-FILE -DFILE=%t.missing -DMSG=%errc_ENOENT
 
 # NO-FILE: error: '[[FILE]]': [[MSG]]
 
 ## Input file is not an object file:

llvm/test/tools/llvm-libtool-darwin/missing-library-type.test

 ## Missing library type option:
 # RUN: not llvm-libtool-darwin -o %t.lib %t.input 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=MISSING-OPERATION
 
-# MISSING-OPERATION: Library Type: option: must be specified
+# MISSING-OPERATION: -static option: must be specified

llvm/test/tools/llvm-libtool-darwin/universal-object-flattening.test

 # RUN:   FileCheck %s --check-prefix=MISSING-ARCH
 
 # MISSING-ARCH: error: no library created (no object files in input files matching -arch_only ppc)
 
 ## arch_only missing argument:
 # RUN: not llvm-libtool-darwin -static -o %t.lib %t-universal.o -arch_only 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=REQUIRE-ARCH
 
-# REQUIRE-ARCH: for the --arch_only option: requires a value!
+# REQUIRE-ARCH: -arch_only: missing argument
 
 ## x86_64-arm64-universal.yaml
 --- !fat-mach-o
 FatHeader:
   magic:           0xCAFEBABE
   nfat_arch:       2
 FatArchs:
   - cputype:         0x01000007

llvm/test/tools/llvm-libtool-darwin/version.test

 ## environments, so this is the most specific we can get.
 # CHECK: LLVM version
 
 ## Parsing errors should not be surfaced when no operation is specified.
 # RUN: llvm-libtool-darwin -V -D -U | FileCheck %s
 
 ## Regular errors should occur when an operation is specified.
 # RUN: not llvm-libtool-darwin -V -static 2>&1 | FileCheck --check-prefix=ERROR %s
-# ERROR: for the -o option: must be specified
+# ERROR: -o option: must be specified
 
 ## A valid command line should print the version and perform the operation.
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-libtool-darwin -static -o %t.lib %t-input1.o %t-input2.o -V | FileCheck %s
 # RUN: llvm-libtool-darwin -static -o %t2.lib %t-input1.o %t-input2.o
 # RUN: cmp %t.lib %t2.lib

llvm/tools/llvm-libtool-darwin/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   Core
   Object
+  Option
   Support
   TargetParser
   TextAPI
   ${LLVM_TARGETS_TO_BUILD}
   )
 
+set(LLVM_TARGET_DEFINITIONS Opts.td)
+tablegen(LLVM Opts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(LibtoolDarwinOptsTableGen)
+
 add_llvm_tool(llvm-libtool-darwin
   llvm-libtool-darwin.cpp
+
+  DEPENDS
+  LibtoolDarwinOptsTableGen
 )
 
 if(LLVM_INSTALL_CCTOOLS_SYMLINKS)
   add_llvm_tool_symlink(libtool llvm-libtool-darwin)
 endif()

llvm/tools/llvm-libtool-darwin/Opts.td

+include "llvm/Option/OptParser.td"
+
+class F<string letter, string help> : Flag<["-", "--"], letter>, HelpText<help>;
+class FF<string name, string help> : Flag<["-", "--"], name>, HelpText<help>;
+class S<string letter, string help> : Separate<["-", "--"], letter>, HelpText<help>;
+class SS<string name, string help> : Separate<["-", "--"], name>, HelpText<help>;
+class JS<string letter, string help> : JoinedOrSeparate<["-", "--"], letter>, HelpText<help>;
+
+def help : FF<"help", "Display this help">;
+def : F<"h", "">, Alias<help>;
+def deterministicOption : F<"D","Use zero for timestamps and UIDs/GIDs (Default)">;
+def nonDeterministicOption : F<"U", "Use actual timestamps and UIDs/GIDs">;
+def version : FF<"version", "Display the version of this program">;
+def : F<"V", "Print the version number and exit">, Alias<version>;
+def noWarningForNoSymbols : FF<"no_warning_for_no_symbols", "Do not warn about files that have no symbols">;
+def warningsAsErrors : FF<"warnings_as_errors", "Treat warnings as errors">;
+def static : Flag<["-", "--"], "static">, HelpText<"Produce a statically linked library from the input files">;
+def outputFile : S<"o", "Specify output filename">, MetaVarName<"<filename>">;
+def fileList : SS<"filelist", "Pass in file containing a list of filenames">, MetaVarName<"<listfile[,dirname]>">;
+def archType : SS<"arch_only", "Specify architecture type for output library">, MetaVarName<"<arch_type>">;
+def libraries : JS<"l", "l<x> searches for the library libx.a in the library search path. If the string 'x'"#
+                       " ends with '.o', then the library 'x' is searched for without prepending 'lib' or appending '.a'">, MetaVarName<"<x>">;
+def librarySearchDirs : JS<"L", "L<dir> adds <dir> to the list of directories in which to search for libraries">, MetaVarName<"<dir>">;
+def ignoredSyslibRoot : SS<"syslibroot", "">, Flags<[HelpHidden]>;
+def dependencyInfoPath : SS<"dependency_info", "Write an Xcode dependency info file describing the dependencies of the created library">, MetaVarName<"<string>">;

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/MachOUniversalWriter.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/WithColor.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TextAPI/Architecture.h"
 #include <map>
 #include <type_traits>
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::opt;
+
+// Command-line option boilerplate.
+namespace {
+enum ID {
+  OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  OPT_##ID,
+#include "Opts.inc"
+#undef OPTION
+};
+
+#define PREFIX(NAME, VALUE)                                                    \
+  static constexpr StringLiteral NAME##_init[] = VALUE;                        \
+  static constexpr ArrayRef<StringLiteral> NAME(NAME##_init,                   \
+                                                std::size(NAME##_init) - 1);
+#include "Opts.inc"
+#undef PREFIX
+
+static constexpr opt::OptTable::Info InfoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  {                                                                            \
+      PREFIX,      NAME,      HELPTEXT,                                        \
+      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
+      PARAM,       FLAGS,     OPT_##GROUP,                                     \
+      OPT_##ALIAS, ALIASARGS, VALUES},
+#include "Opts.inc"
+#undef OPTION
+};
+
+class LibtoolDarwinOptTable : public opt::GenericOptTable {
+public:
+  LibtoolDarwinOptTable() : GenericOptTable(InfoTable) {}
+};
+} // end anonymous namespace
 
 class NewArchiveMemberList;
 typedef std::map<uint64_t, NewArchiveMemberList> MembersPerArchitectureMap;
 
-cl::OptionCategory LibtoolCategory("llvm-libtool-darwin Options");
-
-static cl::opt<std::string> OutputFile("o", cl::desc("Specify output filename"),
-                                       cl::value_desc("filename"),
-                                       cl::cat(LibtoolCategory));
-
-static cl::list<std::string> InputFiles(cl::Positional,
-                                        cl::desc("<input files>"),
-                                        cl::cat(LibtoolCategory));
-
-static cl::opt<std::string>
-    ArchType("arch_only",
-             cl::desc("Specify architecture type for output library"),
-             cl::value_desc("arch_type"), cl::cat(LibtoolCategory));
+static std::string OutputFile;
+static std::vector<std::string> InputFiles;
+static std::optional<std::string> ArchType;
 
 enum class Operation { None, Static };
+static Operation LibraryOperation = Operation::None;
 
-static cl::opt<Operation> LibraryOperation(
-    cl::desc("Library Type: "),
-    cl::values(
-        clEnumValN(Operation::Static, "static",
-                   "Produce a statically linked library from the input files")),
-    cl::init(Operation::None), cl::cat(LibtoolCategory));
-
-static cl::opt<bool> DeterministicOption(
-    "D", cl::desc("Use zero for timestamps and UIDs/GIDs (Default)"),
-    cl::init(false), cl::cat(LibtoolCategory));
-
-static cl::opt<bool>
-    NonDeterministicOption("U", cl::desc("Use actual timestamps and UIDs/GIDs"),
-                           cl::init(false), cl::cat(LibtoolCategory));
-
-static cl::opt<std::string>
-    FileList("filelist",
-             cl::desc("Pass in file containing a list of filenames"),
-             cl::value_desc("listfile[,dirname]"), cl::cat(LibtoolCategory));
-
-static cl::list<std::string> Libraries(
-    "l",
-    cl::desc(
-        "l<x> searches for the library libx.a in the library search path. If"
-        " the string 'x' ends with '.o', then the library 'x' is searched for"
-        " without prepending 'lib' or appending '.a'"),
-    cl::Prefix, cl::cat(LibtoolCategory));
-
-static cl::list<std::string> LibrarySearchDirs(
-    "L",
-    cl::desc(
-        "L<dir> adds <dir> to the list of directories in which to search for"
-        " libraries"),
-    cl::Prefix, cl::cat(LibtoolCategory));
-
-static cl::opt<std::string> DependencyInfoPath(
-    "dependency_info",
-    cl::desc("Write an Xcode dependency info file describing the dependencies "
-             "of the created library"),
-    cl::cat(LibtoolCategory));
-
-static cl::opt<bool>
-    VersionOption("V", cl::desc("Print the version number and exit"),
-                  cl::cat(LibtoolCategory));
-
-static cl::opt<bool> NoWarningForNoSymbols(
-    "no_warning_for_no_symbols",
-    cl::desc("Do not warn about files that have no symbols"),
-    cl::cat(LibtoolCategory), cl::init(false));
-
-static cl::opt<bool> WarningsAsErrors("warnings_as_errors",
-                                      cl::desc("Treat warnings as errors"),
-                                      cl::cat(LibtoolCategory),
-                                      cl::init(false));
-
-static cl::opt<std::string> IgnoredSyslibRoot("syslibroot", cl::Hidden);
+static bool DeterministicOption;
+static bool NonDeterministicOption;
+static std::string FileList;
+static std::vector<std::string> Libraries;
+static std::vector<std::string> LibrarySearchDirs;
+static std::string DependencyInfoPath;
+static bool VersionOption;
+static bool NoWarningForNoSymbols;
+static bool WarningsAsErrors;
+static std::string IgnoredSyslibRoot;
 
 static const std::array<std::string, 3> StandardSearchDirs{
     "/lib",
     "/usr/lib",
     "/usr/local/lib",
 };
 
 std::unique_ptr<DependencyInfo> GlobalDependencyInfo;
public:
   MembersBuilder(LLVMContext &LLVMCtx, const Config &C)
       : LLVMCtx(LLVMCtx), C(C) {}
 
   Expected<MembersData> build() {
     for (StringRef FileName : InputFiles)
       if (Error E = AddMember(*this, FileName)())
         return std::move(E);
 
-    if (!ArchType.empty()) {
+    std::string Arch = ArchType.value_or("");
+    if (!Arch.empty()) {
       uint64_t ArchCPUID = getCPUID(C.ArchCPUType, C.ArchCPUSubtype);
       if (Data.MembersPerArchitecture.find(ArchCPUID) ==
           Data.MembersPerArchitecture.end())
         return createStringError(std::errc::invalid_argument,
                                  "no library created (no object files in input "
                                  "files matching -arch_only %s)",
-                                 ArchType.c_str());
+                                 Arch.c_str());
     }
     return std::move(Data);
   }
 
 private:
   class AddMember {
     MembersBuilder &Builder;
     StringRef FileName;
Error verifyAndAddMachOObject(NewArchiveMember Member) {
 
       auto *O = cast<MachOObjectFile>(ObjOrErr->get());
       uint32_t FileCPUType, FileCPUSubtype;
       std::tie(FileCPUType, FileCPUSubtype) = MachO::getCPUTypeFromArchitecture(
           MachO::getArchitectureFromName(O->getArchTriple().getArchName()));
 
       // If -arch_only is specified then skip this file if it doesn't match
       // the architecture specified.
-      if (!ArchType.empty() && !acceptFileArch(FileCPUType, FileCPUSubtype)) {
+      if (ArchType && !acceptFileArch(FileCPUType, FileCPUSubtype)) {
         return Error::success();
       }
 
       if (!NoWarningForNoSymbols && O->symbols().empty()) {
         Error E = createFileError(
             Member.MemberName,
             createStringError(std::errc::invalid_argument,
                               "has no symbols for architecture %s",
Error verifyAndAddIRObject(NewArchiveMember Member) {
         return FileCPUTypeOrErr.takeError();
 
       Expected<uint32_t> FileCPUSubTypeOrErr = MachO::getCPUSubType(TT);
       if (!FileCPUSubTypeOrErr)
         return FileCPUSubTypeOrErr.takeError();
 
       // If -arch_only is specified then skip this file if it doesn't match
       // the architecture specified.
-      if (!ArchType.empty() &&
+      if (ArchType &&
           !acceptFileArch(*FileCPUTypeOrErr, *FileCPUSubTypeOrErr)) {
         return Error::success();
       }
 
       uint64_t FileCPUID = getCPUID(*FileCPUTypeOrErr, *FileCPUSubTypeOrErr);
       Builder.Data.MembersPerArchitecture[FileCPUID].push_back(
           std::move(Member), FileName);
       return Error::success();
static Error createStaticLibrary(LLVMContext &LLVMCtx, const Config &C) {
   Expected<SmallVector<Slice, 2>> Slices = buildSlices(LLVMCtx, OutputBinaries);
   if (!Slices)
     return Slices.takeError();
 
   llvm::stable_sort(*Slices);
   return writeUniversalBinary(*Slices, OutputFile);
 }
 
+static void parseRawArgs(int Argc, char **Argv) {
+  LibtoolDarwinOptTable Tbl;
+  llvm::BumpPtrAllocator A;
+  llvm::StringSaver Saver{A};
+  opt::InputArgList Args =
+      Tbl.parseArgs(Argc, Argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
+        llvm::errs() << Msg << '\n';
+        std::exit(1);
+      });
+
+  if (Args.hasArg(OPT_help)) {
+    Tbl.printHelp(llvm::outs(), "llvm-libtool-darwin [options] <input files>",
+                  "llvm-libtool-darwin");
+    std::exit(0);
+  }
+
+  InputFiles = Args.getAllArgValues(OPT_INPUT);
+  Libraries = Args.getAllArgValues(OPT_libraries);
+  LibrarySearchDirs = Args.getAllArgValues(OPT_librarySearchDirs);
+
+  if (const opt::Arg *A = Args.getLastArg(OPT_outputFile))
+    OutputFile = A->getValue();
+
+  if (const opt::Arg *A = Args.getLastArg(OPT_archType))
+    ArchType = std::make_optional(A->getValue());
+
+  if (const opt::Arg *A = Args.getLastArg(OPT_fileList))
+    FileList = A->getValue();
+
+  if (const opt::Arg *A = Args.getLastArg(OPT_dependencyInfoPath))
+    DependencyInfoPath = A->getValue();
+
+  if (const opt::Arg *A = Args.getLastArg(OPT_ignoredSyslibRoot))
+    IgnoredSyslibRoot = A->getValue();
+
+  LibraryOperation =
+      Args.hasArg(OPT_static) ? Operation::Static : Operation::None;
+  DeterministicOption = Args.hasArg(OPT_deterministicOption);
+  NonDeterministicOption = Args.hasArg(OPT_nonDeterministicOption);
+  VersionOption = Args.hasArg(OPT_version);
+  NoWarningForNoSymbols = Args.hasArg(OPT_noWarningForNoSymbols);
+  WarningsAsErrors = Args.hasArg(OPT_warningsAsErrors);
+}
+
 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
   Config C;
-  cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
+  parseRawArgs(Argc, Argv);
 
   if (LibraryOperation == Operation::None) {
     if (!VersionOption) {
-      std::string Error;
-      raw_string_ostream Stream(Error);
-      LibraryOperation.error("must be specified", "", Stream);
-      return createStringError(std::errc::invalid_argument, Error.c_str());
+      return createStringError(std::errc::invalid_argument,
+                               "-static option: must be specified");
     }
     return C;
   }
 
   GlobalDependencyInfo =
       DependencyInfoPath.empty()
           ? std::make_unique<DummyDependencyInfo>()
           : std::make_unique<DependencyInfo>(DependencyInfoPath);
 
   if (OutputFile.empty()) {
-    std::string Error;
-    raw_string_ostream Stream(Error);
-    OutputFile.error("must be specified", "o", Stream);
-    return createStringError(std::errc::invalid_argument, Error.c_str());
+    return createStringError(std::errc::invalid_argument,
+                             "-o option: must be specified");
   }
 
   if (DeterministicOption && NonDeterministicOption)
     return createStringError(std::errc::invalid_argument,
                              "cannot specify both -D and -U flags");
   else if (NonDeterministicOption)
     C.Deterministic = false;
 
   if (!Libraries.empty())
     if (Error E = processCommandLineLibraries())
       return std::move(E);
 
   if (!FileList.empty())
     if (Error E = processFileList())
       return std::move(E);
 
   if (InputFiles.empty())
     return createStringError(std::errc::invalid_argument,
                              "no input files specified");
 
-  if (ArchType.getNumOccurrences()) {
-    if (Error E = validateArchitectureName(ArchType))
+  if (ArchType) {
+    if (Error E = validateArchitectureName(ArchType.value()))
       return std::move(E);
 
     std::tie(C.ArchCPUType, C.ArchCPUSubtype) =
         MachO::getCPUTypeFromArchitecture(
-            MachO::getArchitectureFromName(ArchType));
+            MachO::getArchitectureFromName(ArchType.value()));
   }
 
   GlobalDependencyInfo->write("llvm-libtool-darwin " LLVM_VERSION_STRING,
                               InputFiles, OutputFile);
 
   return C;
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
-  cl::HideUnrelatedOptions({&LibtoolCategory, &getColorCategory()});
   Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
   if (!ConfigOrErr) {
     WithColor::defaultErrorHandler(ConfigOrErr.takeError());
     return EXIT_FAILURE;
   }
 
   if (VersionOption)
     cl::PrintVersionMessage();

llvm/utils/gn/secondary/llvm/tools/llvm-libtool-darwin/BUILD.gn

 import("//llvm/tools/cctools_symlinks.gni")
 import("//llvm/utils/gn/build/symlink_or_copy.gni")
+import("//llvm/utils/TableGen/tablegen.gni")
+
+tablegen("Opts") {
+  visibility = [ ":llvm-libtool-darwin" ]
+  args = [ "-gen-opt-parser-defs" ]
+}
 
 if (llvm_install_cctools_symlinks) {
   symlink_or_copy("libtool") {
     deps = [ ":llvm-libtool-darwin" ]
     source = "llvm-libtool-darwin"
     output = "$root_out_dir/bin/libtool"
   }
 }
 
 # //:llvm-libtool-darwin depends on this symlink target, see comment in
 # //BUILD.gn.
 group("symlinks") {
   deps = [ ":llvm-libtool-darwin" ]
   if (llvm_install_cctools_symlinks) {
     deps += [ ":libtool" ]
   }
 }
 
 executable("llvm-libtool-darwin") {
   deps = [
+    ":Opts",
     "//llvm/lib/Object",
+    "//llvm/lib/Option",
     "//llvm/lib/Support",
     "//llvm/lib/Target:TargetsToBuild",
     "//llvm/lib/TargetParser",
   ]
   sources = [ "llvm-libtool-darwin.cpp" ]
 }

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

deps = [
         ":OrcShared",
         ":OrcTargetProcess",
         ":Support",
         ":TargetParser",
         ":config",
     ],
 )
 
+gentbl(
+    name = "LibtoolDarwinOptionsTableGen",
+    strip_include_prefix = "tools/llvm-libtool-darwin",
+    tbl_outs = [(
+        "-gen-opt-parser-defs",
+        "tools/llvm-libtool-darwin/Opts.inc",
+    )],
+    tblgen = ":llvm-tblgen",
+    td_file = "tools/llvm-libtool-darwin/Opts.td",
+    td_srcs = ["include/llvm/Option/OptParser.td"],
+)
+
 cc_binary(
     name = "llvm-libtool-darwin",
     srcs = glob([
         "tools/llvm-libtool-darwin/*.cpp",
         "tools/llvm-libtool-darwin/*.h",
     ]),
     copts = llvm_copts,
     stamp = 0,
     deps = [
         ":AllTargetsAsmParsers",
         ":AllTargetsCodeGens",
         ":BinaryFormat",
+        ":LibtoolDarwinOptionsTableGen",
         ":Core",
         ":Object",
+        ":Option",
         ":Support",
         ":TextAPI",
     ],
 )
 
 cc_binary(
     name = "llvm-link",
     srcs = glob([