[llvm-nm] Add --format=just-symbols and make --just-symbol-name its alias

[MaskRay]

Summary

https://sourceware.org/bugzilla/show_bug.cgi?id=27487 binutils will have
--format=just-symbols/-j as well.

Arbitrarily prefer -j to --format=sysv. Previously --format=sysv -j prints
in the sysv format while -j takes precedence over other formats.

[jhenderson]

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

777–781

By making -j an output format, the code here could change in behaviour, if I understand it correctly, so the --print-file-name option will not be respected anymore. It probably doesn't matter too much, but perhaps we should treat -j as the same output format as bsd/posix here (speaking of which, feel free to fold the two semantically identical cases together here whilst you're at it).

[MaskRay]

Test
llvm-nm -j %t.o %t.o
and
llvm-nm -j -A %t.o %t.o
do not change behavior (untested previously).

[jhenderson]

LGTM, with one nit.

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

32

Should we have a MULTI2-NOT: {{.}} here too?

[MaskRay]

Add a -NOT: {{.}}

llvm/docs/CommandGuide/llvm-nm.rst

 
 .. 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*, or *bsd*.
+ 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
 
- Print just the symbol names.
+ 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.

llvm/test/tools/llvm-nm/just-symbol-name.test

-## Show that the -j/--just-symbol-name prints only the the symbol name (except
-## in posix output).
-
-# RUN: yaml2obj %s -o %t.o
-
-# RUN: llvm-nm --just-symbol-name %t.o > %t.bsd.txt
-# RUN: llvm-nm -j %t.o > %t.j.txt
-# RUN: cmp %t.bsd.txt %t.j.txt
-
-# RUN: FileCheck %s --input-file=%t.bsd.txt --implicit-check-not={{.}} --check-prefix=COMMON
-# RUN: llvm-nm -j %t.o --format=sysv | \
-# RUN:   FileCheck %s --implicit-check-not={{.}} --check-prefixes=COMMON,SYSV -DFILE=%t.o
-# RUN: llvm-nm -j %t.o --format=posix | FileCheck %s --implicit-check-not={{.}} --check-prefix=POSIX
-
-# SYSV:        Symbols from [[FILE]]:
-# SYSV-EMPTY:
-# SYSV-NEXT:   Name Value Class Type Size Line Section
-# COMMON:      {{^}}defined{{$}}
-# COMMON-NEXT: {{^}}undefined{{$}}
-
-# POSIX:      defined T 0 0
-# POSIX-NEXT: undefined U 0 0
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-Sections:
-  - Name:  .text
-    Type:  SHT_PROGBITS
-    Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
-Symbols:
-  - Name:    defined
-    Section: .text
-    Binding: STB_GLOBAL
-  - Name:    undefined
-    Binding: STB_GLOBAL

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: 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
+
+# MULTI1-NOT:   {{.}}
+# MULTI1:       {{^$}}
+# MULTI1-NEXT:  [[FILE]]:
+# MULTI1-NEXT:  defined
+# MULTI1-NEXT:  undefined
+# MULTI1-EMPTY:
+# MULTI1-NEXT:  [[FILE]]:
+# MULTI1-NEXT:  defined
+# MULTI1-NEXT:  undefined
+# MULTI1-NOT:   {{.}}
+
+# RUN: llvm-nm -j --print-file-name %t.o %t.o | FileCheck %s --check-prefix=MULTI2 -DFILE=%t.o
+
+# MULTI2-NOT:   {{.}}
+# MULTI2:       [[FILE]]: defined
+# MULTI2-NEXT:  [[FILE]]: undefined
+# MULTI2-NEXT:  [[FILE]]: defined
+# MULTI2-NEXT:  [[FILE]]: undefined
+# MULTI2-NOT:   {{.}}
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+Sections:
+  - Name:  .text
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
+Symbols:
+  - Name:    defined
+    Section: .text
+    Binding: STB_GLOBAL
+  - Name:    undefined
+    Binding: STB_GLOBAL

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

 #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 };
+enum OutputFormatTy { bsd, sysv, posix, darwin, just_symbols };
 
 cl::OptionCategory NMCat("llvm-nm Options");
 
 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")),
+               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::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
                                      cl::ZeroOrMore);
 
 cl::opt<bool> UndefinedOnly("undefined-only",
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::opt<bool> JustSymbolName("just-symbol-name",
-                             cl::desc("Print just the symbol's name"),
+                             cl::desc("Alias for --format=just-symbols"),
                              cl::cat(NMCat));
-cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
+cl::alias JustSymbolNames("j", cl::desc("Alias for --format-just-symbols"),
                           cl::aliasopt(JustSymbolName), cl::Grouping);
 
 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,
if (ReverseSort)
       llvm::sort(SymbolList, [=](const NMSymbol &A, const NMSymbol &B) -> bool {
         return Cmp(B, A);
       });
     else
       llvm::sort(SymbolList, Cmp);
   }
 
   if (!PrintFileName) {
-    if (OutputFormat == posix && MultipleFiles && printName) {
+    if ((OutputFormat == bsd || OutputFormat == posix ||
+         OutputFormat == just_symbols) &&
+        MultipleFiles && printName) {
       outs() << '\n' << CurrentFilename << ":\n";
-    } else if (OutputFormat == bsd && MultipleFiles && printName) {
-      outs() << "\n" << CurrentFilename << ":\n";
     } else if (OutputFormat == sysv) {
       outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n";
       if (isSymbolList64Bit(Obj))
         outs() << "Name                  Value           Class        Type"
                << "         Size             Line  Section\n";
       else
         outs() << "Name                  Value   Class        Type"
                << "         Size     Line  Section\n";
     }
for (const NMSymbol &S : SymbolList) {
     bool Global = SymFlags & SymbolRef::SF_Global;
     bool Weak = SymFlags & SymbolRef::SF_Weak;
     if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
         (!Global && ExternalOnly) || (Weak && NoWeakSymbols) ||
         (!SpecialSyms && isSpecialSym(Obj, Name)))
       continue;
     if (PrintFileName)
       writeFileName(outs(), ArchiveName, ArchitectureName);
-    if ((JustSymbolName ||
+    if ((OutputFormat == just_symbols ||
          (UndefinedOnly && MachO && OutputFormat != darwin)) &&
         OutputFormat != posix) {
       outs() << Name << "\n";
       continue;
     }
 
     char SymbolAddrStr[23], SymbolSizeStr[23];
 
int main(int argc, char **argv) {
 
   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;