[llvm-nm] Use same symbol types as gnu nm when --format=sysv

[mmpozulp]

Summary

Addresses https://bugs.llvm.org/show_bug.cgi?id=42686 and https://bugs.llvm.org/show_bug.cgi?id=41713

[mmpozulp]

Should we match gnu nm exactly or is this enough?
If we check all 16 possible bit-patterns of the 4-bit-wide symbol type (as in format-sysv-type.test) we can see that gnu nm prints the symbol_section and symbol_common symbols differently than we do. See (4) below for the differences.

(1) llvm-nm output before applying this patch

Name                  Value           Class        Type         Size             Line  Section
symbol_notype       |                |   U  |            NOTYPE|                |     |*UND*
symbol_obj          |                |   U  |            OBJECT|                |     |*UND*
symbol_function     |                |   U  |              FUNC|                |     |*UND*
symbol_section      |                |   U  |           SECTION|                |     |*UND*
symbol_file         |                |   U  |              FILE|                |     |*UND*
symbol_common       |                |   U  |            COMMON|                |     |*COM*
symbol_tls          |                |   U  |               TLS|                |     |*UND*
symbol_unknown7     |                |   U  |                  |                |     |*UND*
symbol_unknown8     |                |   U  |                  |                |     |*UND*
symbol_unknown9     |                |   U  |                  |                |     |*UND*
symbol_ifunc        |                |   U  |             IFUNC|                |     |*UND*
os_specific10       |                |   U  |             IFUNC|                |     |*UND*
os_specific11       |                |   U  |                  |                |     |*UND*
os_specific12       |                |   U  |                  |                |     |*UND*
proc_specific13     |                |   U  |                  |                |     |*UND*
proc_specific14     |                |   U  |                  |                |     |*UND*
proc_specific15     |                |   U  |                  |                |     |*UND*

(2) llvm-nm output after applying this patch

Name                  Value           Class        Type         Size             Line  Section
symbol_notype       |                |   U  |            NOTYPE|                |     |*UND*
symbol_obj          |                |   U  |            OBJECT|                |     |*UND*
symbol_function     |                |   U  |              FUNC|                |     |*UND*
symbol_section      |                |   U  |           SECTION|                |     |*UND*
symbol_file         |                |   U  |              FILE|                |     |*UND*
symbol_common       |                |   U  |            COMMON|                |     |*COM*
symbol_tls          |                |   U  |               TLS|                |     |*UND*
symbol_unknown7     |                |   U  |      <unknown>: 7|                |     |*UND*
symbol_unknown8     |                |   U  |      <unknown>: 8|                |     |*UND*
symbol_unknown9     |                |   U  |      <unknown>: 9|                |     |*UND*
symbol_ifunc        |                |   U  | <OS specific>: 10|                |     |*UND*
os_specific10       |                |   U  | <OS specific>: 10|                |     |*UND*
os_specific11       |                |   U  | <OS specific>: 11|                |     |*UND*
os_specific12       |                |   U  | <OS specific>: 12|                |     |*UND*
proc_specific13     |                |   U  |<processor specific>: 13|                |     |*UND*
proc_specific14     |                |   U  |<processor specific>: 14|                |     |*UND*
proc_specific15     |                |   U  |<processor specific>: 15|                |     |*UND*

(3) gnu nm (version 2.32) output

Name                  Value           Class        Type         Size             Line  Section

symbol_notype       |                |   U  |            NOTYPE|                |     |*UND*
symbol_obj          |                |   U  |            OBJECT|                |     |*UND*
symbol_function     |                |   U  |              FUNC|                |     |*UND*
symbol_section      |                |   U  |                  |                |     |
symbol_file         |                |   U  |              FILE|                |     |*UND*
symbol_common       |                |   U  |            COMMON|                |     |*UND*
symbol_tls          |                |   U  |               TLS|                |     |*UND*
symbol_unknown7     |                |   U  |      <unknown>: 7|                |     |*UND*
symbol_unknown8     |                |   U  |      <unknown>: 8|                |     |*UND*
symbol_unknown9     |                |   U  |      <unknown>: 9|                |     |*UND*
symbol_ifunc        |                |   U  | <OS specific>: 10|                |     |*UND*
os_specific10       |                |   U  | <OS specific>: 10|                |     |*UND*
os_specific11       |                |   U  | <OS specific>: 11|                |     |*UND*
os_specific12       |                |   U  | <OS specific>: 12|                |     |*UND*
proc_specific13     |                |   U  |<processor specific>: 13|                |     |*UND*
proc_specific14     |                |   U  |<processor specific>: 14|                |     |*UND*
proc_specific15     |                |   U  |<processor specific>: 15|                |     |*UND*

(4) diff llvm-nm gnu-nm

$ diff llvmnm.out gnunm.out 
5a6
> 
9c10
< symbol_section      |                |   U  |           SECTION|                |     |*UND*
---
> symbol_section      |                |   U  |                  |                |     |
11c12
< symbol_common       |                |   U  |            COMMON|                |     |*COM*
---
> symbol_common       |                |   U  |            COMMON|                |     |*UND*

[jhenderson]

Hi @mmpozulp. Thanks for looking at this. One of my colleagues (@Sunil_Srivastava) has been working on the same fix, but we forgot to update the LLVM bug. His approach also solves a bug in llvm-readelf, so would you mind holding off on this patch until he's got a chance to finish off his version ready for review?

[mmpozulp]

In D65374#1604381, @jhenderson wrote:

Hi @mmpozulp. Thanks for looking at this. One of my colleagues (@Sunil_Srivastava) has been working on the same fix, but we forgot to update the LLVM bug. His approach also solves a bug in llvm-readelf, so would you mind holding off on this patch until he's got a chance to finish off his version ready for review?

Sure, no problem. I'll leave this revision open but stop working on it, and when @Sunil_Srivastava commits his patch I'll "abandon and close" this revision. Feel free to add me as a reviewer on Sunil's patch.

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

 # RUN: yaml2obj %s > %t.o
-# RUN: llvm-nm %t.o --debug-syms --format=sysv | FileCheck %s
+# RUN: llvm-nm %t.o --debug-syms --format=sysv --no-sort | FileCheck %s
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name: symbol_notype
     Type: STT_NOTYPE
+  - Name: symbol_obj
+    Type: STT_OBJECT
+  - Name: symbol_function
+    Type: STT_FUNC
+  - Name: symbol_section
+    Type: STT_SECTION
+  - Name: symbol_file
+    Type: STT_FILE
   - Name: symbol_common
     Type: STT_COMMON
   - Name: symbol_tls
     Type: STT_TLS
-  - Name: symbol_file
-    Type: STT_FILE
-  - Name: symbol_obj
-    Type: STT_OBJECT
-  - Name: symbol_func
-    Type: STT_FUNC
+  - Name: symbol_unknown7
+    Type: 7
+  - Name: symbol_unknown8
+    Type: 8
+  - Name: symbol_unknown9
+    Type: 9
   - Name: symbol_ifunc
     Type: STT_GNU_IFUNC
-  - Name: os_specific
+  - Name: os_specific10
+    Type: 10
+  - Name: os_specific11
     Type: 11
-  - Name: proc_specific
+  - Name: os_specific12
+    Type: 12
+  - Name: proc_specific13
     Type: 13
-  - Name: unknown
-    Type: 7
-
-## FIXME: Should not print blank types for unknown, OS-specific and processor-
-##        specific types. See https://bugs.llvm.org/show_bug.cgi?id=41713.
+  - Name: proc_specific14
+    Type: 14
+  - Name: proc_specific15
+    Type: 15
 
-# CHECK:      os_specific   {{.*}}|                  |                |     |*UND*
-# CHECK-NEXT: proc_specific {{.*}}|                  |                |     |*UND*
-# CHECK-NEXT: symbol_common {{.*}}|            COMMON|                |     |*COM*
-# CHECK-NEXT: symbol_file   {{.*}}|              FILE|                |     |*UND*
-# CHECK-NEXT: symbol_func   {{.*}}|              FUNC|                |     |*UND*
-# CHECK-NEXT: symbol_ifunc  {{.*}}|             IFUNC|                |     |*UND*
-# CHECK-NEXT: symbol_notype {{.*}}|            NOTYPE|                |     |*UND*
-# CHECK-NEXT: symbol_obj    {{.*}}|            OBJECT|                |     |*UND*
-# CHECK-NEXT: symbol_tls    {{.*}}|               TLS|                |     |*UND*
-# CHECK-NEXT: unknown       {{.*}}|                  |                |     |*UND*
+# CHECK:      symbol_notype   {{.*}}|            NOTYPE|                |     |*UND*
+# CHECK-NEXT: symbol_obj      {{.*}}|            OBJECT|                |     |*UND*
+# CHECK-NEXT: symbol_function {{.*}}|              FUNC|                |     |*UND*
+# CHECK-NEXT: symbol_section  {{.*}}|           SECTION|                |     |*UND*
+# CHECK-NEXT: symbol_file     {{.*}}|              FILE|                |     |*UND*
+# CHECK-NEXT: symbol_common   {{.*}}|            COMMON|                |     |*COM*
+# CHECK-NEXT: symbol_tls      {{.*}}|               TLS|                |     |*UND*
+# CHECK-NEXT: symbol_unknown7 {{.*}}|      <unknown>: 7|                |     |*UND*
+# CHECK-NEXT: symbol_unknown8 {{.*}}|      <unknown>: 8|                |     |*UND*
+# CHECK-NEXT: symbol_unknown9 {{.*}}|      <unknown>: 9|                |     |*UND*
+# CHECK-NEXT: symbol_ifunc    {{.*}}| <OS specific>: 10|                |     |*UND*
+# CHECK-NEXT: os_specific10   {{.*}}| <OS specific>: 10|                |     |*UND*
+# CHECK-NEXT: os_specific11   {{.*}}| <OS specific>: 11|                |     |*UND*
+# CHECK-NEXT: os_specific12   {{.*}}| <OS specific>: 12|                |     |*UND*
+# CHECK-NEXT: proc_specific13 {{.*}}|<processor specific>: 13|                |     |*UND*
+# CHECK-NEXT: proc_specific14 {{.*}}|<processor specific>: 14|                |     |*UND*
+# CHECK-NEXT: proc_specific15 {{.*}}|<processor specific>: 15|                |     |*UND*

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

 namespace {
 struct NMSymbol {
   uint64_t Address;
   uint64_t Size;
   char TypeChar;
   StringRef Name;
   StringRef SectionName;
   StringRef TypeName;
+  std::string GnuTypeName;
   BasicSymbolRef Sym;
   // The Sym field above points to the native symbol in the object file,
   // for Mach-O when we are creating symbols from the dyld info the above
   // pointer is null as there is no native symbol.  In these cases the fields
   // below are filled in to represent what would have been a Mach-O nlist
   // native symbol.
   uint32_t SymFlags;
   SectionRef Section;
if ((OutputFormat == darwin || FormatMachOasHex) && (MachO || Obj.isIR())) {
           else
             outs() << IndirectName << ")";
         } else
           outs() << S.IndirectName << ")";
       }
       outs() << "\n";
     } else if (OutputFormat == sysv) {
       outs() << left_justify(Name, 20) << "|" << SymbolAddrStr << "|   "
-             << S.TypeChar << "  |" << right_justify(S.TypeName, 18) << "|"
+             << S.TypeChar << "  |" << right_justify(S.GnuTypeName, 18) << "|"
              << SymbolSizeStr << "|     |" << S.SectionName << "\n";
     }
   }
 
   SymbolList.clear();
 }
 
 static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,

 static bool isObject(SymbolicFile &Obj, basic_symbol_iterator I) {
   return !dyn_cast<ELFObjectFileBase>(&Obj)
              ? false
              : elf_symbol_iterator(I)->getELFType() == ELF::STT_OBJECT;
 }
 
 // For ELF object files, Set TypeName to the symbol typename, to be printed
 // in the 'Type' column of the SYSV format output.
-static StringRef getNMTypeName(SymbolicFile &Obj, basic_symbol_iterator I) {
+static StringRef getNMTypeName(SymbolicFile &Obj, basic_symbol_iterator I,
+                               std::string &GnuTypeName) {
+  StringRef TypeName;
   if (isa<ELFObjectFileBase>(&Obj)) {
     elf_symbol_iterator SymI(I);
-    return SymI->getELFTypeName();
+    TypeName = SymI->getELFTypeName();
+    if (TypeName.empty() || TypeName.equals("IFUNC")) {
+      uint8_t Type = SymI->getELFType();
+      if (Type > ELF::STT_TLS && Type < ELF::STT_GNU_IFUNC)
+        GnuTypeName = "<unknown>: " + std::to_string(Type);
+      else if (Type >= ELF::STT_LOOS && Type <= ELF::STT_HIOS)
+        GnuTypeName = "<OS specific>: " + std::to_string(Type);
+      else if (Type >= ELF::STT_LOPROC && Type <= ELF::STT_HIPROC)
+        GnuTypeName = "<processor specific>: " + std::to_string(Type);
+    } else
+      GnuTypeName = TypeName;
   }
-  return "";
+  return TypeName;
 }
 
 // Return Posix nm class type tag (single letter), but also set SecName and
 // section and name, to be used in format=sysv output.
 static char getNMSectionTagAndName(SymbolicFile &Obj, basic_symbol_iterator I,
                                    StringRef &SecName) {
   uint32_t Symflags = I->getFlags();
   if (isa<ELFObjectFileBase>(&Obj)) {
for (BasicSymbolRef Sym : Symbols) {
         SymbolRef SymRef(Sym);
         Expected<uint64_t> AddressOrErr = SymRef.getAddress();
         if (!AddressOrErr) {
           consumeError(AddressOrErr.takeError());
           break;
         }
         S.Address = *AddressOrErr;
       }
-      S.TypeName = getNMTypeName(Obj, Sym);
+      S.TypeName = getNMTypeName(Obj, Sym, S.GnuTypeName);
       S.TypeChar = getNMSectionTagAndName(Obj, Sym, S.SectionName);
       if (Error E = Sym.printName(OS)) {
         if (MachO) {
           OS << "bad string index";
           consumeError(std::move(E));
         } else
           error(std::move(E), Obj.getFileName());
       }