[llvm-nm] Switch command line parsing from llvm::cl to OptTable

[MaskRay]

Summary

Part of https://lists.llvm.org/pipermail/llvm-dev/2021-July/151622.html
"Binary utilities: switch command line parsing from llvm::cl to OptTable"

Users should generally observe no difference as long as they only use intended
option forms. Behavior changes:

• -t=d is removed. Use -t d instead.
• --demangle=0 cannot be used. Omit the option or use --no-demangle instead.
• --help-list is removed. This is a cl:: specific option.

Note:

• -t diagnostic gets improved.
• Avoid cl::opt collision if we decide to support multiplexing for binary utilities
• One-dash long options are still supported.
• The -s collision (-s segment section for Mach-O) is unfortunate. -s means --print-armap in GNU nm.
• This patch removes the last cl::multi_val use case from the llvm/lib/Support/CommandLine.cpp library

-M (--print-armap), -U (--defined-only), and -W (--no-weak)
are now deprecated. They could conflict with future GNU nm options.
(--print-armap has an existing alias -s, so GNU will unlikely add a new one.
--no-weak (not in GNU nm) is rarely used anyway.)

--just-symbol-name is now deprecated in favor of
--format=just-symbols and -j.

[jhenderson]

@gbreynoo, could you do a check to see if any of our internal code bases would be broken by the changes made in this patch?

@MaskRay: not that I mind, but any particular reason single-dash long options are still supported for llvm-nm, but not other tools? That could be explained in the patch description, I think.

The -s collision (-s segment section for Mach-O) is unfortunate. -s means --print-armap in GNU nm.

I wonder if (in a separate patch), we should add a long option and deprecate this short alias? Then, in a future release, we can switch the meaning over, whilst giving people a path forward to migrate any scripts they may have.

llvm/test/tools/llvm-nm/help.test

5

Perhaps worth adding some check showing the Mach-O option grouping?

llvm/tools/llvm-nm/Opts.td

34

This should be above radix for alphabetical ordering.

35–36

Help description of these two options is incorrect.

47

This should be above arch for alphabetical ordering.

62

-h alias for --help?

llvm/tools/llvm-nm/llvm-nm.cpp

109–128

clang-format I think adds this.

2142

Perhaps worth adding a check for this (or more specifically probably just @FILE to help.test?

2219–2229

It's unfortunate that we have to hand-roll this additional logic, rather than relying on the command-line parser code to do it for us...

[xgupta]

Hi @MaskRay! I think you should drop an email on llvm-dev regarding these changes of "Switch command line parsing from llvm::cl to OptTable". Some kind of RFC would be good. (I am not opposing changes btw)

[MaskRay]

In D105330#2854877, @xgupta wrote:

Hi @MaskRay! I think you should drop an email on llvm-dev regarding these changes of "Switch command line parsing from llvm::cl to OptTable". Some kind of RFC would be good. (I am not opposing changes btw)

https://lists.llvm.org/pipermail/llvm-dev/2021-July/151622.html Binary utilities: switch command line parsing from llvm::cl to OptTable (byproduct: drop -long-option?)

[MaskRay]

In D105330#2854841, @jhenderson wrote:

@gbreynoo, could you do a check to see if any of our internal code bases would be broken by the changes made in this patch?

@MaskRay: not that I mind, but any particular reason single-dash long options are still supported for llvm-nm, but not other tools? That could be explained in the patch description, I think.

I am in favor of dropping support for single-dash long options, but just want to do it separately.
With this patch, I expect most users will not observe any difference. -t=d --demangle=0 are rare.
(For llvm-strings, I combined the two steps because I don't think anyone may use the single-dash form for the few long options in llvm-strings.)

nm -arch is a Mach-O specific option which might be controversial: https://lists.llvm.org/pipermail/llvm-dev/2021-July/151622.html

The -s collision (-s segment section for Mach-O) is unfortunate. -s means --print-armap in GNU nm.

I wonder if (in a separate patch), we should add a long option and deprecate this short alias? Then, in a future release, we can switch the meaning over, whilst giving people a path forward to migrate any scripts they may have.

The problem is that Darwin nm uses -s differently from GNU nm.
For -s it is fine for me because nm -s is not used that much and I can remember to use --print-armap.
To my surprise Darwin nm and GNU nm do share many command line options... otherwise I guess we would need something similar to llvm-libtool-darwin.

-s is indeed very unfortunate. In other places the convention is a comma-separated form, e.g. __TEXT,__text

[aganea]

llvm/tools/llvm-nm/llvm-nm.cpp

108

Can you take the opportunity and put all this onto a stack-based state class? So that the tool can be used as-a-lib & be thread-safe? A practical example could be usage of llvm/tools/llvm-shlib/gen-msvc-exports.py, but in-process.

2127–2147

It looks like L2128-L2151 are the same as D104889, llvm/tools/llvm-strings/llvm-strings.cpp, L131-L151. Is it worth putting this boilerplate in a small utility function in llvm/Support/, since we'll probably write the same thing for other bintools?

[MaskRay]

llvm/tools/llvm-nm/llvm-nm.cpp

2127–2147

BumpPtrAllocator and StringSaver are the same.

OPT_help can be different (specially the " [options] <input object files>", "llvm string table dumper" lines).
It is hard for code sharing because OPT_help is not special in OptTable. The user code knows this is an help option but OptTable doesn't.

OPT_version can be different (some utilities need GNU libtool workaround like: outs() << "llvm-nm, compatible with GNU nm" << '\n';).

Overall I think code sharing.is difficult for the boilerplate.

[• post.kadirselcuk]

Hey, everyone, I guess this revision is up to date right now?

[MaskRay]

Hide options that are currently hidden, e.g. -M (--print-armap; GNU doesn't have -M), -W

[MaskRay]

address comments

[jhenderson]

llvm/tools/llvm-nm/Opts.td

39

I don't follow why you've hidden this option?

52

Ditto.

65

FTR: this one I can get behind if GNU doesn't have it, due to the risk of a future name clash. You should remove it from the CommandGuide though. Maybe also add a deprecation note for it to the release notes too.

Same with -W and -U below.

[MaskRay]

Mark -M/-U/-W deprecated

llvm/tools/llvm-nm/Opts.td

39

--without-aliases is currently hidden. It seems to be for debugging.

The name is confusing: it applies to just LLVM bitcode files but the documentation isn't clear about this fact.

52

The canonical forms are --format=just-symbols and -j now. It seems wasteful to have a third form --just-symbol-name.

llvm/tools/llvm-nm/llvm-nm.cpp

108

Answered in D104889. Not sure localization will help for the oneshot utility.

[jhenderson]

llvm/docs/CommandGuide/llvm-nm.rst

135

Up to you, but I personally think it's fine to remove reference to -U (also -W, -M) entirely.

llvm/docs/ReleaseNotes.rst

173

Either "have been deprecated" or "are now deprecated". Perhaps also say "Use the long form versions instead." or some equivalent phrasing.

174

This is the wrong link.

llvm/tools/llvm-nm/Opts.td

39

It's in the command guide text. Either we should remove it from there, or it should be visible in the help text.

52

Fair enough. In that case, can we go through a deprecation process like the short option aliases? (Namely remove it from the command guide and add a release note).

[MaskRay]

address comments

llvm/tools/llvm-nm/Opts.td

39

Removed --without-aliases from llvm/docs/CommandGuide/llvm-nm.rst

[jhenderson]

Okay, LGTM. Please leave it for a bit before committing though, in case @aganea or anybody else has any more comments.

[dyung]

I'm not sure why, but after your change (but strangely not when testing your change) to the test tools/llvm-nm/just-symbols.test, it seems to periodically fail on the PS4 buildbot.

1. https://lab.llvm.org/buildbot/#/builders/139/builds/6756
2. https://lab.llvm.org/buildbot/#/builders/139/builds/6759
3. https://lab.llvm.org/buildbot/#/builders/139/builds/6761
4. https://lab.llvm.org/buildbot/#/builders/139/builds/6762

Can you take a look?

[MaskRay]

In D105330#2863243, @dyung wrote:

I'm not sure why, but after your change (but strangely not when testing your change) to the test tools/llvm-nm/just-symbols.test, it seems to periodically fail on the PS4 buildbot.

1. https://lab.llvm.org/buildbot/#/builders/139/builds/6756
2. https://lab.llvm.org/buildbot/#/builders/139/builds/6759
3. https://lab.llvm.org/buildbot/#/builders/139/builds/6761
4. https://lab.llvm.org/buildbot/#/builders/139/builds/6762

Can you take a look?

Thanks for the report. Fixed by b81aa458afd023323dcd4400164f6a43d981d7de

[hubert.reinterpretcast]

llvm/test/tools/llvm-nm/just-symbols.test

10

This is causing failures on our AIX builds:

diff: illegal option -- q
Usage: diff [-bitw] [[-C Lines|-D String|-e|-f|-n|-U Lines|-c|-u]|[-h]] File1 File2
       diff [-bilrstw] [[-C Lines|-e|-f|-n|-U Lines|-c|-u]|[-h]] [-S File] Directory1 Directory2

[MaskRay]

llvm/test/tools/llvm-nm/just-symbols.test

10

I removed -q.

[DavidSpickett]

@MaskRay You say in the commit msg:

One-dash long options are still supported.

Does that mean that -format=sysv should still be supported? I'm not sure if that's a "long option" or what.

It's used in the llvm-testsuite: https://github.com/llvm/llvm-test-suite/blob/main/litsupport/modules/codesize.py

[DavidSpickett]

Updated the test suite in https://reviews.llvm.org/rTd73ac5f0188c.

[MaskRay]

In D105330#2876946, @DavidSpickett wrote:

@MaskRay You say in the commit msg:

One-dash long options are still supported.

Does that mean that -format=sysv should still be supported? I'm not sure if that's a "long option" or what.

It's used in the llvm-testsuite: https://github.com/llvm/llvm-test-suite/blob/main/litsupport/modules/codesize.py

This is llvm-nm.

The llvm-test-suite you fixed is llvm-size. llvm-size is simple so I just removed one-dash long options.

llvm/docs/CommandGuide/llvm-nm.rst

 .. option:: -B
 
  Use BSD output format. Alias for ``--format=bsd``.
 
 .. option:: --debug-syms, -a
 
  Show all symbols, even those usually suppressed.
 
-.. option:: --defined-only, -U
+.. option:: --defined-only
 
  Print only symbols defined in this file.
 
 .. option:: --demangle, -C
 
  Demangle symbol names.
 
 .. option:: --dynamic, -D
 
  Display dynamic symbols instead of normal symbols.
 
 .. option:: --extern-only, -g
 
  Print only symbols whose definitions are external; that is, accessible from
  other files.
 
 .. option:: --format=<format>, -f
 
  Select an output format; *format* may be *sysv*, *posix*, *darwin*, *bsd* or
  *just-symbols*.
  The default is *bsd*.
 
 .. option:: --help, -h
 
  Print a summary of command-line options and their meanings.
 
-.. option:: --help-list
-
- Print an uncategorized summary of command-line options and their meanings.
-
-.. option:: --just-symbol-name, -j
+.. option:: -j
 
  Print just the symbol names. Alias for `--format=just-symbols``.
 
 .. option:: -m
 
  Use Darwin format. Alias for ``--format=darwin``.
 
 .. option:: --no-demangle
 
  Don't demangle symbol names. This is the default.
 
 .. option:: --no-llvm-bc
 
  Disable the LLVM bitcode reader.
 
 .. option:: --no-sort, -p
 
  Show symbols in the order encountered.
 
-.. option:: --no-weak, -W
+.. option:: --no-weak
 
  Don't print weak symbols.
 
 .. option:: --numeric-sort, -n, -v
 
  Sort symbols by address.
 
 .. option:: --portability, -P
 
  Use POSIX.2 output format.  Alias for ``--format=posix``.
 
-.. option:: --print-armap, -M
+.. option:: --print-armap
 
  Print the archive symbol table, in addition to the symbols.
 
 .. option:: --print-file-name, -A, -o
 
  Precede each symbol with the file it came from.
 
 .. option:: --print-size, -S

 
  Print only undefined symbols.
 
 .. option:: --version, -V
 
  Display the version of the :program:`llvm-nm` executable, then exit. Does not
  stack with other commands.
 
-.. option:: --without-aliases
-
- Exclude aliases from the output.
-
 .. option:: @<FILE>
 
  Read command-line options from response file `<FILE>`.
 
 MACH-O SPECIFIC OPTIONS
 -----------------------
 
 .. option:: --add-dyldinfo

 .. option:: --dyldinfo-only
 
  Dump only symbols from the dyldinfo.
 
 .. option:: --no-dyldinfo
 
  Do not add any symbols from the dyldinfo.
 
-.. option:: -s=<segment section>
+.. option:: -s <segment> <section>
 
  Dump only symbols from this segment and section name.
 
 .. option:: -x
 
  Print symbol entry in hex.
 
 BUGS

llvm/docs/ReleaseNotes.rst

* llvm-objdump supports ``-M {att,intel}`` now.
   ``--x86-asm-syntax`` is a deprecated internal option which will be removed in LLVM 14.0.0.
   (`D101695 <https://reviews.llvm.org/D101695>`_)
 
 * The llvm-readobj short aliases ``-s`` (previously ``--sections``) and ``-t``
   (previously ``--syms``) have been changed to ``--syms`` and
   ``--section-details`` respectively, to match llvm-readelf.
   (`D105055 <https://reviews.llvm.org/D105055>`_)
 
+* The llvm-nm short aliases ``-M`` (``--print-armap``), ``-U``
+  (``--defined-only``), and ``-W`` (``--no-weak``) are now deprecated.
+  Use the long form versions instead.
+  The alias ``--just-symbol-name`` is now deprecated in favor of
+  ``--format=just-symbols`` and ``-j``.
+  (`D105330 <https://reviews.llvm.org/D105330>`_)
+
 Changes to LLDB
 ---------------------------------
 
 Changes to Sanitizers
 ---------------------
 
 External Open Source Projects Using LLVM 13
 ===========================================

llvm/test/Object/nm-universal-binary.test

 RUN: llvm-nm --arch=all %p/Inputs/macho-universal.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-OBJ
 RUN: llvm-nm --arch=all %p/Inputs/macho-universal64.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-64-OBJ
 RUN: llvm-nm --arch=x86_64 %p/Inputs/macho-universal.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-OBJ-x86_64
 RUN: not llvm-nm --arch=armv7m %p/Inputs/macho-universal.x86_64.i386 2>&1 \
-RUN:         | FileCheck %s -check-prefix CHECK-OBJ-armv7m
+RUN:         | FileCheck %s --check-prefix=CHECK-OBJ-armv7m --implicit-check-not=error:
 RUN: not llvm-nm --arch=foobar %p/Inputs/macho-universal.x86_64.i386 2>&1 \
-RUN:         | FileCheck %s -check-prefix CHECK-OBJ-foobar
+RUN:         | FileCheck %s --check-prefix=CHECK-OBJ-foobar --implicit-check-not=error:
 RUN: llvm-nm --arch=all %p/Inputs/macho-universal-archive.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-AR
 RUN: llvm-nm --arch=all %p/Inputs/macho-universal64-archive.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-64-AR
 RUN: llvm-nm --arch=i386 %p/Inputs/macho-universal-archive.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-AR-i386
 RUN: llvm-nm -o --arch=all %p/Inputs/macho-universal-archive.x86_64.i386 \
 RUN:         | FileCheck %s -check-prefix CHECK-AR-o
 
 CHECK-OBJ: macho-universal.x86_64.i386 (for architecture x86_64):
 CHECK-OBJ: 0000000100000f60 T _main
 CHECK-OBJ: macho-universal.x86_64.i386 (for architecture i386):
 CHECK-OBJ: 00001fa0 T _main
 
 CHECK-64-OBJ: macho-universal64.x86_64.i386 (for architecture x86_64):
 CHECK-64-OBJ: 0000000100000f60 T _main
 CHECK-64-OBJ: macho-universal64.x86_64.i386 (for architecture i386):
 CHECK-64-OBJ: 00001fa0 T _main
 
 CHECK-OBJ-x86_64: 0000000100000000 T __mh_execute_header
 CHECK-OBJ-x86_64: 0000000100000f60 T _main
 CHECK-OBJ-x86_64:                  U dyld_stub_binder
 
-CHECK-OBJ-armv7m-NOT: Unknown architecture named
-CHECK-OBJ-armv7m: does not contain architecture
+CHECK-OBJ-armv7m: error: file: {{.*}} does not contain architecture
 
-CHECK-OBJ-foobar: Unknown architecture named
-CHECK-OBJ-foobar: does not contain architecture
+CHECK-OBJ-foobar: error: for the --arch option: Unknown architecture named 'foobar'
 
 CHECK-AR: macho-universal-archive.x86_64.i386(hello.o) (for architecture x86_64):
 CHECK-AR: 0000000000000068 s EH_frame0
 CHECK-AR: 000000000000003b s L_.str
 CHECK-AR: 0000000000000000 T _main
 CHECK-AR: 0000000000000080 S _main.eh
 CHECK-AR:                  U _printf
 CHECK-AR: macho-universal-archive.x86_64.i386(foo.o) (for architecture i386):

llvm/test/tools/llvm-nm/X86/radix.s

 // #check radix formats of llvm-nm
 // RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t.o
 // RUN: llvm-nm --radix=d %t.o | FileCheck %s
 // RUN: llvm-nm --radix=o %t.o | FileCheck --check-prefix=OCTAL %s
-// RUN: llvm-nm -t=x %t.o | FileCheck --check-prefix=HEX %s
+// RUN: llvm-nm -tx %t.o | FileCheck --check-prefix=HEX %s
+// RUN: llvm-nm -t x %t.o | FileCheck --check-prefix=HEX %s
 
   .text
   .file "1.c"
   .type i0,@object              # @i0
   .bss
   .globl  i0
   .align  4
 i0:

llvm/test/tools/llvm-nm/format-bsd.test

 ## --format-bsd is the default output format of llvm-nm. Show that the default
 ## and bsd output (including its aliases) match to confirm this.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-nm %t.o --format=bsd > %t.formatbsd.txt
-# RUN: llvm-nm %t.o -f=bsd > %t.fbsd.txt
+# RUN: llvm-nm %t.o -f bsd > %t.fbsd.txt
 # RUN: llvm-nm %t.o -B > %t.b.txt
 # RUN: llvm-nm %t.o > %t.default.txt
 
 # RUN: cmp %t.formatbsd.txt %t.default.txt
 # RUN: cmp %t.formatbsd.txt %t.fbsd.txt
 # RUN: cmp %t.formatbsd.txt %t.b.txt
 
 ## Sanity check that some output is actually printed.

llvm/test/tools/llvm-nm/format-sysv-layout.test

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-nm %t.o --debug-syms --format=sysv | FileCheck %s -DFILE=%t.o --strict-whitespace
-# RUN: llvm-nm %t.o --debug-syms -f=sysv | FileCheck %s -DFILE=%t.o --strict-whitespace
+# RUN: llvm-nm %t.o --debug-syms -fsysv | FileCheck %s -DFILE=%t.o --strict-whitespace
+# RUN: llvm-nm %t.o --debug-syms -f sysv | FileCheck %s -DFILE=%t.o --strict-whitespace
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-nm/help.test

 RUN: llvm-nm --help 2>&1 | FileCheck --implicit-check-not="General Options:" %s
-CHECK: Generic Options:
-CHECK: llvm-nm Options:
+RUN: llvm-nm -h 2>&1 | FileCheck --implicit-check-not="General Options:" %s
+CHECK: OPTIONS:
+CHECK:   --debug-syms
+CHECK:   --demangle
+CHECK:   --format=<format>
+CHECK: llvm-nm Mach-O Specific Options:
+CHECK:   --arch=<value>
+CHECK:   -s
+CHECK: Pass @FILE {{.*}}

llvm/test/tools/llvm-nm/just-symbols.test

 ## Show that the -j/--just-symbol-name/--format=just-symbols prints only the the
 ## symbol name.
 
 # RUN: yaml2obj %s -o %t.o
 
 # RUN: llvm-nm -j %t.o > %t.txt
 # RUN: llvm-nm --just-symbol-name %t.o | diff %t.txt -
 # RUN: llvm-nm --format=just-symbols %t.o | diff %t.txt -
 # RUN: llvm-nm --format=sysv -j %t.o | diff %t.txt -
-# RUN: llvm-nm -j --format=posix %t.o | diff %t.txt -
+# RUN: llvm-nm -j --format=posix %t.o | not diff -q %t.txt %t1.txt
 
 # RUN: FileCheck %s --input-file=%t.txt --implicit-check-not={{.}} --check-prefix=COMMON
 
 # COMMON:      {{^}}defined{{$}}
 # COMMON-NEXT: {{^}}undefined{{$}}
 
 # RUN: llvm-nm -j %t.o %t.o | FileCheck %s --check-prefix=MULTI1 -DFILE=%t.o
 

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

 # Check that the output of llvm-nm -V (and --version) contains the text
 # "GNU" somewhere, to let libtool know that it is compatible with GNU nm.
 # Also check that it contains the LLVM version.
 
 RUN: llvm-nm -V | FileCheck %s
 RUN: llvm-nm --version | FileCheck %s
-CHECK: LLVM version
 CHECK: GNU
+CHECK: LLVM version

llvm/tools/llvm-nm/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsInfos
   BinaryFormat
   Core
   Demangle
   Object
+  Option
   Support
   TextAPI
   )
 
+set(LLVM_TARGET_DEFINITIONS Opts.td)
+tablegen(LLVM Opts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(NmOptsTableGen)
+
 add_llvm_tool(llvm-nm
   llvm-nm.cpp
 
   DEPENDS
+  NmOptsTableGen
   intrinsics_gen
   )
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(nm llvm-nm)
 endif()

llvm/tools/llvm-nm/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>;
+
+multiclass BB<string name, string help1, string help2> {
+  def NAME: Flag<["--", "-"], name>, HelpText<help1>;
+  def no_ # NAME: Flag<["--", "-"], "no-" # name>, HelpText<help2>;
+}
+
+multiclass Eq<string name, string help> {
+  def NAME #_EQ : Joined<["--", "-"], name #"=">,
+                  HelpText<help>;
+  def : Separate<["--", "-"], name>, Alias<!cast<Joined>(NAME #_EQ)>;
+}
+
+def debug_syms : FF<"debug-syms", "Show all symbols, even debugger only">;
+def defined_only : FF<"defined-only", "Show only defined symbols">;
+defm demangle : BB<"demangle", "Demangle C++ symbol names", "Don't demangle symbol names">;
+def dynamic : FF<"dynamic", "Display dynamic symbols instead of normal symbols">;
+def extern_only : FF<"extern-only", "Show only external symbols">;
+defm format : Eq<"format", "Specify output format: bsd (default), posix, sysv, darwin, just-symbols">, MetaVarName<"<format>">;
+def help : FF<"help", "Display this help">;
+def no_llvm_bc : FF<"no-llvm-bc", "Disable LLVM bitcode reader">;
+def no_sort : FF<"no-sort", "Show symbols in order encountered">;
+def no_weak : FF<"no-weak", "Show only non-weak symbols">;
+def numeric_sort : FF<"numeric-sort", "Sort symbols by address">;
+def print_armap : FF<"print-armap", "Print the archive map">;
+def print_file_name : FF<"print-file-name", "Precede each symbol with the object file it came from">;
+def print_size : FF<"print-size", "Show symbol size as well as address">;
+def quiet : FF<"quiet", "Suppress 'no symbols' diagnostic">;
+defm radix : Eq<"radix", "Radix (o/d/x) for printing symbol Values">, MetaVarName<"<radix>">;
+def reverse_sort : FF<"reverse-sort", "Sort in reverse order">;
+def size_sort : FF<"size-sort", "Sort symbols by size">;
+def special_syms : FF<"special-syms", "Do not filter special symbols from the output">;
+def undefined_only : FF<"undefined-only", "Show only undefined symbols">;
+def version : FF<"version", "Display the version">;
+def without_aliases : FF<"without-aliases", "Exclude aliases from output">, Flags<[HelpHidden]>;
+
+// Mach-O specific options.
+def grp_mach_o : OptionGroup<"kind">, HelpText<"llvm-nm Mach-O Specific Options">;
+
+def add_dyldinfo : FF<"add-dyldinfo", "Add symbols from the dyldinfo not already in the symbol table">, Group<grp_mach_o>;
+def add_inlinedinfo : FF<"add-inlinedinfo", "Add symbols from the inlined libraries, TBD only">, Group<grp_mach_o>;
+defm arch : Eq<"arch", "architecture(s) from a Mach-O file to dump">, Group<grp_mach_o>;
+def dyldinfo_only : FF<"dyldinfo-only", "Show only symbols from the dyldinfo">, Group<grp_mach_o>;
+def no_dyldinfo : FF<"no-dyldinfo", "Don't add any symbols from the dyldinfo">, Group<grp_mach_o>;
+def s : F<"s", "Dump only symbols from this segment and section name">, Group<grp_mach_o>;
+def x : F<"x", "Print symbol entry in hex">, Group<grp_mach_o>;
+
+def : FF<"just-symbol-name", "Alias for --format=just-symbols">, Alias<format_EQ>, AliasArgs<["just-symbols"]>, Flags<[HelpHidden]>;
+def : FF<"portability", "Alias for --format=posix">, Alias<format_EQ>, AliasArgs<["posix"]>;
+
+def : F<"a", "Alias for --debug-syms">, Alias<debug_syms>;
+def : F<"A", "Alias for --print-file-name">, Alias<print_file_name>;
+def : F<"B", "Alias for --format=bsd">, Alias<format_EQ>, AliasArgs<["bsd"]>;
+def : F<"C", "Alias for --demangle">, Alias<demangle>;
+def : F<"D", "Alias for --dynamic">, Alias<dynamic>;
+def : JoinedOrSeparate<["-"], "f">, HelpText<"Alias for --format">, Alias<format_EQ>, MetaVarName<"<format>">;
+def : F<"h", "Alias for --help">, Alias<help>;
+def : F<"g", "Alias for --extern-only">, Alias<extern_only>;
+def : F<"j", "Alias for --format=just-symbols">, Alias<format_EQ>, AliasArgs<["just-symbols"]>;
+def : F<"m", "Alias for --format=darwin">, Alias<format_EQ>, AliasArgs<["darwin"]>;
+def : F<"M", "Deprecated alias for --print-armap">, Alias<print_armap>, Flags<[HelpHidden]>;
+def : F<"n", "Alias for --numeric-sort">, Alias<numeric_sort>;
+def : F<"o", "Alias for --print-file-name">, Alias<print_file_name>;
+def : F<"p", "Alias for --no-sort">, Alias<no_sort>;
+def : F<"P", "Alias for --format=posix">, Alias<format_EQ>, AliasArgs<["posix"]>;
+def : F<"r", "Alias for --reverse-sort">, Alias<reverse_sort>;
+def : F<"S", "Alias for --print-size">, Alias<print_size>;
+def : JoinedOrSeparate<["-"], "t">, HelpText<"Alias for --radix">, Alias<radix_EQ>, MetaVarName<"<radix>">;
+def : F<"u", "Alias for --undefined-only">, Alias<undefined_only>;
+def : F<"U", "Deprecated alias for --defined-only">, Alias<defined_only>, Flags<[HelpHidden]>;
+def : F<"v", "Alias for --numeric-sort">, Alias<numeric_sort>;
+def : F<"V", "Alias for --version">, Alias<version>;
+def : F<"W", "Deprecated alias for --no-weak">, Alias<no_weak>, Flags<[HelpHidden]>;

llvm/tools/llvm-nm/llvm-nm.cpp

 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/TapiFile.h"
 #include "llvm/Object/TapiUniversal.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 using namespace llvm;
 using namespace object;
 
 namespace {
-enum OutputFormatTy { bsd, sysv, posix, darwin, just_symbols };
+using namespace llvm::opt; // for HelpHidden in Opts.inc
+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
+};
 
-cl::OptionCategory NMCat("llvm-nm Options");
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Opts.inc"
+#undef PREFIX
+
+static const 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
+};
 
-cl::opt<OutputFormatTy> OutputFormat(
-    "format", cl::desc("Specify output format"),
-    cl::values(clEnumVal(bsd, "BSD format"), clEnumVal(sysv, "System V format"),
-               clEnumVal(posix, "POSIX.2 format"),
-               clEnumVal(darwin, "Darwin -m format"),
-               cl::OptionEnumValue{"just-symbols", int(just_symbols),
-                                   "just symbol names"}),
-    cl::init(bsd), cl::cat(NMCat));
-cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
-                        cl::aliasopt(OutputFormat), cl::NotHidden);
-
-cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
-                                     cl::ZeroOrMore);
-
-cl::opt<bool> UndefinedOnly("undefined-only",
-                            cl::desc("Show only undefined symbols"),
-                            cl::cat(NMCat));
-cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
-                         cl::aliasopt(UndefinedOnly), cl::Grouping,
-                         cl::NotHidden);
-
-cl::opt<bool> DynamicSyms("dynamic",
-                          cl::desc("Display the dynamic symbols instead "
-                                   "of normal symbols."),
-                          cl::cat(NMCat));
-cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"),
-                       cl::aliasopt(DynamicSyms), cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> DefinedOnly("defined-only", cl::desc("Show only defined symbols"),
-                          cl::cat(NMCat));
-cl::alias DefinedOnly2("U", cl::desc("Alias for --defined-only"),
-                       cl::aliasopt(DefinedOnly), cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> ExternalOnly("extern-only",
-                           cl::desc("Show only external symbols"),
-                           cl::ZeroOrMore, cl::cat(NMCat));
-cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
-                        cl::aliasopt(ExternalOnly), cl::Grouping,
-                        cl::ZeroOrMore, cl::NotHidden);
-
-cl::opt<bool> NoWeakSymbols("no-weak", cl::desc("Show only non-weak symbols"),
-                            cl::cat(NMCat));
-cl::alias NoWeakSymbols2("W", cl::desc("Alias for --no-weak"),
-                         cl::aliasopt(NoWeakSymbols), cl::Grouping,
-                         cl::NotHidden);
-
-cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"), cl::Grouping,
-                        cl::cat(NMCat));
-cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"),
-                          cl::Grouping, cl::cat(NMCat));
-cl::alias Portability("portability", cl::desc("Alias for --format=posix"),
-                      cl::aliasopt(POSIXFormat), cl::NotHidden);
-cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin"),
-                           cl::Grouping, cl::cat(NMCat), cl::NotHidden);
-
-static cl::list<std::string>
-    ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
-              cl::ZeroOrMore, cl::cat(NMCat));
-bool ArchAll = false;
-
-cl::opt<bool> PrintFileName(
-    "print-file-name",
-    cl::desc("Precede each symbol with the object file it came from"),
-    cl::cat(NMCat));
-
-cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"),
-                         cl::aliasopt(PrintFileName), cl::Grouping,
-                         cl::NotHidden);
-cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"),
-                         cl::aliasopt(PrintFileName), cl::Grouping,
-                         cl::NotHidden);
-
-cl::opt<bool> Quiet("quiet", cl::desc("Suppress 'no symbols' diagnostic"),
-                    cl::cat(NMCat));
-
-cl::opt<bool> DebugSyms("debug-syms",
-                        cl::desc("Show all symbols, even debugger only"),
-                        cl::cat(NMCat));
-cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"),
-                     cl::aliasopt(DebugSyms), cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address"),
-                          cl::cat(NMCat));
-cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
-                       cl::aliasopt(NumericSort), cl::Grouping, cl::NotHidden);
-cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
-                       cl::aliasopt(NumericSort), cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"),
-                     cl::cat(NMCat));
-cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort),
-                  cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> Demangle("demangle", cl::ZeroOrMore,
-                       cl::desc("Demangle C++ symbol names"), cl::cat(NMCat));
-cl::alias DemangleC("C", cl::desc("Alias for --demangle"),
-                    cl::aliasopt(Demangle), cl::Grouping, cl::NotHidden);
-cl::opt<bool> NoDemangle("no-demangle", cl::init(false), cl::ZeroOrMore,
-                         cl::desc("Don't demangle symbol names"),
-                         cl::cat(NMCat));
-
-cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"),
-                          cl::cat(NMCat));
-cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
-                       cl::aliasopt(ReverseSort), cl::Grouping, cl::NotHidden);
-
-cl::opt<bool> PrintSize("print-size",
-                        cl::desc("Show symbol size as well as address"),
-                        cl::cat(NMCat));
-cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
-                     cl::aliasopt(PrintSize), cl::Grouping, cl::NotHidden);
-bool MachOPrintSizeWarning = false;
-
-cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size"),
-                       cl::cat(NMCat));
-
-cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
-                             cl::desc("Exclude aliases from output"),
-                             cl::cat(NMCat), cl::NotHidden);
-
-cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"),
-                         cl::cat(NMCat));
-cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
-                      cl::aliasopt(ArchiveMap), cl::Grouping, cl::NotHidden);
+class NmOptTable : public opt::OptTable {
+public:
+  NmOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+};
 
-enum Radix { d, o, x };
-cl::opt<Radix>
-    AddressRadix("radix", cl::desc("Radix (o/d/x) for printing symbol Values"),
-                 cl::values(clEnumVal(d, "decimal"), clEnumVal(o, "octal"),
-                            clEnumVal(x, "hexadecimal")),
-                 cl::init(x), cl::cat(NMCat));
-cl::alias RadixAlias("t", cl::desc("Alias for --radix"),
-                     cl::aliasopt(AddressRadix), cl::NotHidden);
-
-cl::opt<bool> JustSymbolName("just-symbol-name",
-                             cl::desc("Alias for --format=just-symbols"),
-                             cl::cat(NMCat), cl::NotHidden);
-cl::alias JustSymbolNames("j", cl::desc("Alias for --format-just-symbols"),
-                          cl::aliasopt(JustSymbolName), cl::Grouping,
-                          cl::NotHidden);
-
-cl::opt<bool>
-    SpecialSyms("special-syms",
-                cl::desc("Do not filter special symbols from the output"),
-                cl::cat(NMCat));
-
-cl::list<std::string> SegSect("s", cl::multi_val(2), cl::ZeroOrMore,
-                              cl::value_desc("segment section"), cl::Hidden,
-                              cl::desc("Dump only symbols from this segment "
-                                       "and section name, Mach-O only"),
-                              cl::cat(NMCat));
-
-cl::opt<bool> FormatMachOasHex("x",
-                               cl::desc("Print symbol entry in hex, "
-                                        "Mach-O only"),
-                               cl::Grouping, cl::cat(NMCat));
-cl::opt<bool> AddDyldInfo("add-dyldinfo",
-                          cl::desc("Add symbols from the dyldinfo not already "
-                                   "in the symbol table, Mach-O only"),
-                          cl::cat(NMCat));
-cl::opt<bool> NoDyldInfo("no-dyldinfo",
-                         cl::desc("Don't add any symbols from the dyldinfo, "
-                                  "Mach-O only"),
-                         cl::cat(NMCat));
-cl::opt<bool> DyldInfoOnly("dyldinfo-only",
-                           cl::desc("Show only symbols from the dyldinfo, "
-                                    "Mach-O only"),
-                           cl::cat(NMCat));
-
-cl::opt<bool> NoLLVMBitcode("no-llvm-bc",
-                            cl::desc("Disable LLVM bitcode reader"),
-                            cl::cat(NMCat));
-
-cl::opt<bool> AddInlinedInfo("add-inlinedinfo",
-                             cl::desc("Add symbols from the inlined libraries, "
-                                      "TBD(Mach-O) only"),
-                             cl::cat(NMCat));
-
-cl::opt<bool> Version("V", cl::desc("Print version info"), cl::cat(NMCat));
-
-cl::extrahelp HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
+enum OutputFormatTy { bsd, sysv, posix, darwin, just_symbols };
+} // namespace
 
-bool PrintAddress = true;
+static bool ArchiveMap;
+static bool DebugSyms;
+static bool DefinedOnly;
+static bool Demangle;
+static bool DynamicSyms;
+static bool ExternalOnly;
+static OutputFormatTy OutputFormat;
+static bool NoLLVMBitcode;
+static bool NoSort;
+static bool NoWeakSymbols;
+static bool NumericSort;
+static bool PrintFileName;
+static bool PrintSize;
+static bool Quiet;
+static bool ReverseSort;
+static bool SpecialSyms;
+static bool SizeSort;
+static bool UndefinedOnly;
+static bool WithoutAliases;
 
-bool MultipleFiles = false;
+namespace {
+enum Radix { d, o, x };
+} // namespace
+static Radix AddressRadix;
 
-bool HadError = false;
+// Mach-O specific options.
+static bool ArchAll = false;
+static std::vector<StringRef> ArchFlags;
+static bool AddDyldInfo;
+static bool AddInlinedInfo;
+static bool DyldInfoOnly;
+static bool FormatMachOasHex;
+static bool NoDyldInfo;
+static std::vector<StringRef> SegSect;
+static bool MachOPrintSizeWarning = false;
+
+// Miscellaneous states.
+static bool PrintAddress = true;
+static bool MultipleFiles = false;
+static bool HadError = false;
 
-std::string ToolName;
-} // anonymous namespace
+static StringRef ToolName;
 
 static void error(Twine Message, Twine Path = Twine()) {
   HadError = true;
   WithColor::error(errs(), ToolName) << Path << ": " << Message << "\n";
 }
 
 static bool error(std::error_code EC, Twine Path = Twine()) {
   if (EC) {
if (!MachOPrintSizeWarning && PrintSize &&  isa<MachOObjectFile>(O)) {
       MachOPrintSizeWarning = true;
     }
     if (!checkMachOAndArchFlags(O, Filename))
       return;
     dumpSymbolNamesFromObject(*O, true);
   }
 }
 
-static void printExtraVersionInfo(raw_ostream &Outs) {
-  // This needs to contain the word "GNU", libtool looks for that string.
-  Outs << "llvm-nm, compatible with GNU nm\n";
-}
-
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
-  cl::HideUnrelatedOptions(NMCat);
-  cl::AddExtraVersionPrinter(printExtraVersionInfo);
-  cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");
-
-  if (Version) {
+  BumpPtrAllocator A;
+  StringSaver Saver(A);
+  NmOptTable Tbl;
+  ToolName = argv[0];
+  opt::InputArgList Args =
+      Tbl.parseArgs(argc, argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
+        error(Msg);
+        exit(1);
+      });
+  if (Args.hasArg(OPT_help)) {
+    Tbl.printHelp(
+        outs(),
+        (Twine(ToolName) + " [options] <input object files>").str().c_str(),
+        "LLVM symbol table dumper");
+    // TODO Replace this with OptTable API once it adds extrahelp support.
+    outs() << "\nPass @FILE as argument to read options from FILE.\n";
+    return 0;
+  }
+  if (Args.hasArg(OPT_version)) {
+    // This needs to contain the word "GNU", libtool looks for that string.
+    outs() << "llvm-nm, compatible with GNU nm" << '\n';
     cl::PrintVersionMessage();
-    printExtraVersionInfo(outs());
     return 0;
   }
 
+  DebugSyms = Args.hasArg(OPT_debug_syms);
+  DefinedOnly = Args.hasArg(OPT_defined_only);
+  Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, false);
+  DynamicSyms = Args.hasArg(OPT_dynamic);
+  ExternalOnly = Args.hasArg(OPT_extern_only);
+  StringRef V = Args.getLastArgValue(OPT_format_EQ, "bsd");
+  if (V == "bsd")
+    OutputFormat = bsd;
+  else if (V == "posix")
+    OutputFormat = posix;
+  else if (V == "sysv")
+    OutputFormat = sysv;
+  else if (V == "darwin")
+    OutputFormat = darwin;
+  else if (V == "just-symbols")
+    OutputFormat = just_symbols;
+  else
+    error("--format value should be one of: bsd, posix, sysv, darwin, "
+          "just-symbols");
+  NoLLVMBitcode = Args.hasArg(OPT_no_llvm_bc);
+  NoSort = Args.hasArg(OPT_no_sort);
+  NoWeakSymbols = Args.hasArg(OPT_no_weak);
+  NumericSort = Args.hasArg(OPT_numeric_sort);
+  ArchiveMap = Args.hasArg(OPT_print_armap);
+  PrintFileName = Args.hasArg(OPT_print_file_name);
+  PrintSize = Args.hasArg(OPT_print_size);
+  ReverseSort = Args.hasArg(OPT_reverse_sort);
+  Quiet = Args.hasArg(OPT_quiet);
+  V = Args.getLastArgValue(OPT_radix_EQ, "x");
+  if (V == "o")
+    AddressRadix = Radix::o;
+  else if (V == "d")
+    AddressRadix = Radix::d;
+  else if (V == "x")
+    AddressRadix = Radix::x;
+  else
+    error("--radix value should be one of: 'o' (octal), 'd' (decimal), 'x' "
+          "(hexadecimal)");
+  SizeSort = Args.hasArg(OPT_size_sort);
+  SpecialSyms = Args.hasArg(OPT_special_syms);
+  UndefinedOnly = Args.hasArg(OPT_undefined_only);
+  WithoutAliases = Args.hasArg(OPT_without_aliases);
+
+  // Mach-O specific options.
+  FormatMachOasHex = Args.hasArg(OPT_x);
+  AddDyldInfo = Args.hasArg(OPT_add_dyldinfo);
+  AddInlinedInfo = Args.hasArg(OPT_add_inlinedinfo);
+  DyldInfoOnly = Args.hasArg(OPT_dyldinfo_only);
+  NoDyldInfo = Args.hasArg(OPT_no_dyldinfo);
+
   // llvm-nm only reads binary files.
   if (error(sys::ChangeStdinToBinary()))
     return 1;
 
   // These calls are needed so that we can read bitcode correctly.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
-  ToolName = argv[0];
-  if (BSDFormat)
-    OutputFormat = bsd;
-  if (POSIXFormat)
-    OutputFormat = posix;
-  if (DarwinFormat)
-    OutputFormat = darwin;
-  if (JustSymbolName)
-    OutputFormat = just_symbols;
-
   // The relative order of these is important. If you pass --size-sort it should
   // only print out the size. However, if you pass -S --size-sort, it should
   // print out both the size and address.
   if (SizeSort && !PrintSize)
     PrintAddress = false;
   if (OutputFormat == sysv || SizeSort)
     PrintSize = true;
-  if (InputFilenames.empty())
-    InputFilenames.push_back("a.out");
-  if (InputFilenames.size() > 1)
-    MultipleFiles = true;
 
-  // If both --demangle and --no-demangle are specified then pick the last one.
-  if (NoDemangle.getPosition() > Demangle.getPosition())
-    Demangle = !NoDemangle;
-
-  for (unsigned i = 0; i < ArchFlags.size(); ++i) {
-    if (ArchFlags[i] == "all") {
+  for (const auto *A : Args.filtered(OPT_arch_EQ)) {
+    SmallVector<StringRef, 2> Values;
+    llvm::SplitString(A->getValue(), Values, ",");
+    for (StringRef V : Values) {
+      if (V == "all")
         ArchAll = true;
-    } else {
-      if (!MachOObjectFile::isValidArch(ArchFlags[i]))
-        error("Unknown architecture named '" + ArchFlags[i] + "'",
+      else if (MachOObjectFile::isValidArch(V))
+        ArchFlags.push_back(V);
+      else
+        error("Unknown architecture named '" + V + "'",
               "for the --arch option");
     }
   }
 
+  // Mach-O takes -s to accept two arguments. We emulate this by iterating over
+  // both OPT_s and OPT_INPUT.
+  std::vector<std::string> InputFilenames;
+  int SegSectArgs = 0;
+  for (opt::Arg *A : Args.filtered(OPT_s, OPT_INPUT)) {
+    if (SegSectArgs > 0) {
+      --SegSectArgs;
+      SegSect.push_back(A->getValue());
+    } else if (A->getOption().matches(OPT_s)) {
+      SegSectArgs = 2;
+    } else {
+      InputFilenames.push_back(A->getValue());
+    }
+  }
   if (!SegSect.empty() && SegSect.size() != 2)
     error("bad number of arguments (must be two arguments)",
           "for the -s option");
 
+  if (InputFilenames.empty())
+    InputFilenames.push_back("a.out");
+  if (InputFilenames.size() > 1)
+    MultipleFiles = true;
+
   if (NoDyldInfo && (AddDyldInfo || DyldInfoOnly))
     error("--no-dyldinfo can't be used with --add-dyldinfo or --dyldinfo-only");
 
   llvm::for_each(InputFilenames, dumpSymbolNamesFromFile);
 
   if (HadError)
     return 1;
 }

llvm/utils/gn/secondary/llvm/tools/llvm-nm/BUILD.gn

 import("//llvm/tools/binutils_symlinks.gni")
+import("//llvm/utils/TableGen/tablegen.gni")
 import("//llvm/utils/gn/build/symlink_or_copy.gni")
 
+tablegen("Opts") {
+  visibility = [ ":llvm-nm" ]
+  args = [ "-gen-opt-parser-defs" ]
+}
+
 if (llvm_install_binutils_symlinks) {
   symlink_or_copy("nm") {
     deps = [ ":llvm-nm" ]
     source = "llvm-nm"
     output = "$root_out_dir/bin/nm"
   }
 }
 
 # //:llvm-nm depends on this symlink target, see comment in //BUILD.gn.
 group("symlinks") {
   deps = [ ":llvm-nm" ]
   if (llvm_install_binutils_symlinks) {
     deps += [ ":nm" ]
   }
 }
 
 executable("llvm-nm") {
   deps = [
+    ":Opts",
     "//llvm/lib/Bitcode/Reader",
     "//llvm/lib/Demangle",
     "//llvm/lib/IR",
     "//llvm/lib/Object",
+    "//llvm/lib/Option",
     "//llvm/lib/Support",
     "//llvm/lib/Target:AllTargetsAsmParsers",
     "//llvm/lib/Target:AllTargetsDescs",
     "//llvm/lib/Target:AllTargetsInfos",
   ]
   sources = [ "llvm-nm.cpp" ]
 }

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

cc_binary(
     deps = [
         ":MtTableGen",
         ":Option",
         ":Support",
         ":WindowsManifest",
     ],
 )
 
+gentbl(
+    name = "NmOptsTableGen",
+    strip_include_prefix = "tools/llvm-nm",
+    tbl_outs = [(
+        "-gen-opt-parser-defs",
+        "tools/llvm-nm/Opts.inc",
+    )],
+    tblgen = ":llvm-tblgen",
+    td_file = "tools/llvm-nm/Opts.td",
+    td_srcs = ["include/llvm/Option/OptParser.td"],
+)
+
 cc_binary(
     name = "llvm-nm",
     srcs = glob([
         "tools/llvm-nm/*.cpp",
         "tools/llvm-nm/*.h",
     ]),
     copts = llvm_copts,
     stamp = 0,
     deps = [
         ":AllTargetsAsmParsers",
         ":AllTargetsCodeGens",
         ":BinaryFormat",
         ":BitReader",
         ":Core",
         ":Demangle",
+        ":NmOptsTableGen",
         ":Object",
+        ":Option",
         ":Support",
     ],
 )
 
 gentbl(
     name = "llvm-objcopy-opts",
     strip_include_prefix = "tools/llvm-objcopy",
     tbl_outs = [(