llvm-nm: Implement --special-syms.

[MaskRay]

LGTM, with a nit about tests. Please give some time for other reviewers to respond.

llvm/test/tools/llvm-nm/AArch64/special-syms.test

2

Consider using ## for comments and moving to the top.

(Most newer binary utility tests use ## and some reviewers find the marker makes comments stand out.)

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

745

In BFD the logic is more complex:

• bfd/cpu-arm.c:bfd_is_arm_special_symbol_name
• bfd/cpu-aarch64.c:bfd_is_aarch64_special_symbol_name

I think the simplified rule should be fine.

[jhenderson]

Seems reasonable, but the llvm-nm documentation needs updating (see llvm/docs/CommandGuide/llvm-nm.rst).

It may also be worth release-noting the change in behaviour too, since it will mean current ARM users who use llvm-nm will see their mapping symbols disappear from the output, if they aren't already using --special-syms.

[pcc]

In D82251#2106010, @jhenderson wrote:

Seems reasonable, but the llvm-nm documentation needs updating (see llvm/docs/CommandGuide/llvm-nm.rst).

It may also be worth release-noting the change in behaviour too, since it will mean current ARM users who use llvm-nm will see their mapping symbols disappear from the output, if they aren't already using --special-syms.

Done.

lld/test/ELF/aarch64-thunk-script.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
 // RUN: echo "SECTIONS { \
 // RUN:       .text_low 0x2000: { *(.text_low) } \
 // RUN:       .text_high 0x8002000 : { *(.text_high) } \
 // RUN:       } " > %t.script
 // RUN: ld.lld --script %t.script %t.o -o %t
 // RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex %t | FileCheck %s
-// RUN: llvm-nm --no-sort %t | FileCheck --check-prefix=NM %s
+// RUN: llvm-nm --no-sort --special-syms %t | FileCheck --check-prefix=NM %s
 
 // Check that we have the out of branch range calculation right. The immediate
 // field is signed so we have a slightly higher negative displacement.
  .section .text_low, "ax", %progbits
  .globl _start
  .type _start, %function
 _start:
  // Need thunk to high_target@plt

llvm/test/MC/AArch64/mapping-within-section.s

-// RUN: llvm-mc -triple=aarch64-none-linux-gnu -filetype=obj %s | llvm-nm - | FileCheck %s
+// RUN: llvm-mc -triple=aarch64-none-linux-gnu -filetype=obj %s | llvm-nm --special-syms - | FileCheck %s
 
     .text
 // $x at 0x0000
     add w0, w0, w0
 // $d at 0x0004
     .ascii "012"
     .byte 1
     .hword 2

llvm/test/tools/llvm-nm/AArch64/special-syms.test

 # RUN: yaml2obj %s -o %t
-# Test --special-syms flag. Currently this flag is a no-op, so outputs with and without
-# this flag should be identical. GNU nm doesn't show ARM and AArch64 special symbols
-# without --special-syms, so this test is to be changed when/if we decide to implement
-# GNU nm-like behavior in llvm-nm
+# Test --special-syms flag.
 
-# RUN: llvm-nm %t | FileCheck %s
+# RUN: llvm-nm %t | count 0
 # RUN: llvm-nm %t --special-syms | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_AARCH64

llvm/test/tools/llvm-nm/debug-syms.test

 # RUN: yaml2obj %s -o %t.o
-# RUN: llvm-nm --debug-syms %t.o | FileCheck %s --implicit-check-not {{.}} --check-prefix SYMBOL
-# RUN: llvm-nm -a %t.o | FileCheck %s --implicit-check-not {{.}} --check-prefix SYMBOL
+# RUN: llvm-nm --special-syms --debug-syms %t.o | FileCheck %s --implicit-check-not {{.}} --check-prefix SYMBOL
+# RUN: llvm-nm --special-syms -a %t.o | FileCheck %s --implicit-check-not {{.}} --check-prefix SYMBOL
 
 # SYMBOL:      0000000000000000 n $a
 # SYMBOL-NEXT: 0000000000000000 n $d
 # SYMBOL-NEXT: 0000000000000000 n $t
 # SYMBOL-NEXT: 0000000000000000 a file_sym
 # SYMBOL-NEXT: 0000000000000000 n section
 
 # RUN: llvm-nm --debug-syms --dynamic %t.o | FileCheck %s --implicit-check-not {{.}} --check-prefix DYNSYM

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

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::cat(NMCat));
 cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
                           cl::aliasopt(JustSymbolName), cl::Grouping);
 
-cl::opt<bool> SpecialSyms("special-syms",
-                          cl::desc("No-op. Used for GNU compatibility only"));
+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",
if (OutputFormat == posix && !ArchiveName.empty())
     S << ArchiveName << "[" << CurrentFilename << "]: ";
   else {
     if (!ArchiveName.empty())
       S << ArchiveName << ":";
     S << CurrentFilename << ": ";
   }
 }
 
+static bool isSpecialSym(SymbolicFile &Obj, StringRef Name) {
+  auto *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj);
+  if (!ELFObj)
+    return false;
+  uint16_t EMachine = ELFObj->getEMachine();
+  if (EMachine != ELF::EM_ARM && EMachine != ELF::EM_AARCH64)
+    return false;
+  return Name[0] == '$';
+}
+
 static void sortAndPrintSymbolList(SymbolicFile &Obj, bool printName,
                                    StringRef ArchiveName,
                                    StringRef ArchitectureName) {
   if (!NoSort) {
     using Comparator = bool (*)(const NMSymbol &, const NMSymbol &);
     Comparator Cmp;
     if (NumericSort)
       Cmp = &compareSymbolAddress;
if (S.Sym.getRawDataRefImpl().p) {
       SymFlags = *SymFlagsOrErr;
     } else
       SymFlags = S.SymFlags;
 
     bool Undefined = SymFlags & SymbolRef::SF_Undefined;
     bool Global = SymFlags & SymbolRef::SF_Global;
     bool Weak = SymFlags & SymbolRef::SF_Weak;
     if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
-        (!Global && ExternalOnly) || (Weak && NoWeakSymbols))
+        (!Global && ExternalOnly) || (Weak && NoWeakSymbols) ||
+        (!SpecialSyms && isSpecialSym(Obj, Name)))
       continue;
     if (PrintFileName)
       writeFileName(outs(), ArchiveName, ArchitectureName);
     if ((JustSymbolName ||
          (UndefinedOnly && MachO && OutputFormat != darwin)) &&
         OutputFormat != posix) {
       outs() << Name << "\n";
       continue;