Compute and Print Type and Section columns in "llvm-nm -f sysv" output.

[Sunil_Srivastava]

Summary

Fixes PR39998 and PR39999.

[Sunil_Srivastava]

To clarify, this patch is only attempting to fix ELF files.

[mtrent]

Built it locally, stepped through the nm code for Mach-O files, didn't see any unintended problems. Elf changes reviewed visually only, they look mechanical. The name for "getNMSectionTagAndName" seems imperfect to me, as the Mach-O symbol type code isn't strictly about the section (A, I, -); that said, sysv is not a common format for viewing Mach-O, so I just offer it as a minor point to consider.

tools/llvm-nm/llvm-nm.cpp

1100 ↗

(On Diff #186946)

Nit: Should this be getNMClassTagAndSectionName?

1243 ↗

(On Diff #186946)

Nit: See above

[Sunil_Srivastava]

Thx mtrent.

[Sunil_Srivastava]

This checkin has been reverted due to an ASAN buildbot failure.

I will be looking at that and updating this page after the fix.

[Sunil_Srivastava]

Replaced by https://reviews.llvm.org/D59060

llvm/trunk/include/llvm/Object/ELFObjectFile.h

 #include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
 #include <cstdint>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
+extern const llvm::EnumEntry<unsigned> ElfSymbolTypes[8];
+
 class elf_symbol_iterator;
 
 class ELFObjectFileBase : public ObjectFile {
   friend class ELFRelocationRef;
   friend class ELFSectionRef;
   friend class ELFSymbolRef;
 
 protected:
public:
 
   uint8_t getOther() const {
     return getObject()->getSymbolOther(getRawDataRefImpl());
   }
 
   uint8_t getELFType() const {
     return getObject()->getSymbolELFType(getRawDataRefImpl());
   }
+
+  void getELFTypeName(StringRef &TN) const {
+    uint8_t et = getELFType();
+    TN = "";
+    for (auto &ee : ElfSymbolTypes) {
+      if (ee.Value == et) {
+        TN = ee.AltName;
+        break;
+      }
+    }
+  }
 };
 
 class elf_symbol_iterator : public symbol_iterator {
 public:
   elf_symbol_iterator(const basic_symbol_iterator &B)
       : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
                                   cast<ELFObjectFileBase>(B->getObject()))) {}
 
protected:
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
   uint8_t getSymbolOther(DataRefImpl Symb) const override;
   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb,
                                               const Elf_Shdr *SymTab) const;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
+  int getSymbolSectionIndex(DataRefImpl Symb) const override;
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   std::error_code getSectionName(DataRefImpl Sec,
                                  StringRef &Res) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   std::error_code getSectionContents(DataRefImpl Sec,
ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
   auto SymTabOrErr = EF.getSection(Symb.d.a);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
   const Elf_Shdr *SymTab = *SymTabOrErr;
   return getSymbolSection(Sym, SymTab);
 }
 
 template <class ELFT>
+int
+ELFObjectFile<ELFT>::getSymbolSectionIndex(DataRefImpl Symb) const {
+  const Elf_Sym *Sym = getSymbol(Symb);
+  return Sym->st_shndx;
+}
+
+template <class ELFT>
 void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
   const Elf_Shdr *ESec = getSection(Sec);
   Sec = toDRI(++ESec);
 }
 
 template <class ELFT>
 std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
                                                     StringRef &Result) const {

llvm/trunk/include/llvm/Object/ObjectFile.h

public:
   uint32_t getAlignment() const;
   uint64_t getCommonSize() const;
   Expected<SymbolRef::Type> getType() const;
 
   /// Get section this symbol is defined in reference to. Result is
   /// end_sections() if it is undefined or is an absolute symbol.
   Expected<section_iterator> getSection() const;
 
+  // Get the section index of the section of this symbol
+  int getSectionIndex() const;
+
   const ObjectFile *getObject() const;
 };
 
 class symbol_iterator : public basic_symbol_iterator {
 public:
   symbol_iterator(SymbolRef Sym) : basic_symbol_iterator(Sym) {}
   symbol_iterator(const basic_symbol_iterator &B)
       : basic_symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
std::error_code printSymbolName(raw_ostream &OS,
                                   DataRefImpl Symb) const override;
   virtual Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const = 0;
   virtual uint64_t getSymbolValueImpl(DataRefImpl Symb) const = 0;
   virtual uint32_t getSymbolAlignment(DataRefImpl Symb) const;
   virtual uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const = 0;
   virtual Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const = 0;
   virtual Expected<section_iterator>
   getSymbolSection(DataRefImpl Symb) const = 0;
+  virtual int getSymbolSectionIndex(DataRefImpl Symb) const { return -1; }
 
   // Same as above for SectionRef.
   friend class SectionRef;
 
   virtual void moveSectionNext(DataRefImpl &Sec) const = 0;
   virtual std::error_code getSectionName(DataRefImpl Sec,
                                          StringRef &Res) const = 0;
   virtual uint64_t getSectionAddress(DataRefImpl Sec) const = 0;

 inline uint32_t SymbolRef::getAlignment() const {
   return getObject()->getSymbolAlignment(getRawDataRefImpl());
 }
 
 inline uint64_t SymbolRef::getCommonSize() const {
   return getObject()->getCommonSymbolSize(getRawDataRefImpl());
 }
 
+inline int SymbolRef::getSectionIndex() const {
+  return getObject()->getSymbolSectionIndex(getRawDataRefImpl());
+}
+
 inline Expected<section_iterator> SymbolRef::getSection() const {
   return getObject()->getSymbolSection(getRawDataRefImpl());
 }
 
 inline Expected<SymbolRef::Type> SymbolRef::getType() const {
   return getObject()->getSymbolType(getRawDataRefImpl());
 }
 

llvm/trunk/lib/Object/ELFObjectFile.cpp

 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>
 
 using namespace llvm;
 using namespace object;
 
+const EnumEntry<unsigned> llvm::object::ElfSymbolTypes[8] = {
+    {"None", "NOTYPE", ELF::STT_NOTYPE},
+    {"Object", "OBJECT", ELF::STT_OBJECT},
+    {"Function", "FUNC", ELF::STT_FUNC},
+    {"Section", "SECTION", ELF::STT_SECTION},
+    {"File", "FILE", ELF::STT_FILE},
+    {"Common", "COMMON", ELF::STT_COMMON},
+    {"TLS", "TLS", ELF::STT_TLS},
+    {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC}};
+
 ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
     : ObjectFile(Type, Source) {}
 
 template <class ELFT>
 static Expected<std::unique_ptr<ELFObjectFile<ELFT>>>
 createPtr(MemoryBufferRef Object) {
   auto Ret = ELFObjectFile<ELFT>::create(Object);
   if (Error E = Ret.takeError())

llvm/trunk/test/tools/llvm-nm/X86/sysv-i386.test

 RUN: llvm-nm -f sysv %p/Inputs/hello.obj.elf-i386 | FileCheck %s --strict-whitespace
 
 CHECK: Name                  Value   Class        Type         Size     Line  Section
-CHECK: .L.str              |00000000|   r  |                  |0000000f|     |
-CHECK: main                |00000000|   T  |                  |00000015|     |
-CHECK: puts                |        |   U  |                  |        |     |
+CHECK: .L.str              |00000000|   r  |            OBJECT|0000000f|     |.rodata.str1.1
+CHECK: main                |00000000|   T  |              FUNC|00000015|     |.text
+CHECK: puts                |        |   U  |            NOTYPE|        |     |*UND*

llvm/trunk/test/tools/llvm-nm/X86/sysv-x86_64.test

 RUN: llvm-nm -f sysv %p/Inputs/hello.obj.elf-x86_64 | FileCheck %s --check-prefix=ELF --strict-whitespace
 RUN: llvm-nm -f sysv %p/Inputs/hello.obj.macho-x86_64 2>&1 | FileCheck %s --check-prefix=MACHO --strict-whitespace
 
 ELF: Name                  Value           Class        Type         Size             Line  Section
-ELF: main                |0000000000000000|   T  |                  |0000000000000015|     |
-ELF: puts                |                |   U  |                  |                |     |
+ELF: main                |0000000000000000|   T  |              FUNC|0000000000000015|     |.text
+ELF: puts                |                |   U  |            NOTYPE|                |     |*UND*
 
 MACHO: Name                  Value           Class        Type         Size             Line  Section
 MACHO: EH_frame0           |0000000000000068|   s  |                  |0000000000000000|     |
 MACHO: L_.str              |000000000000003b|   s  |                  |0000000000000000|     |
 MACHO: _main               |0000000000000000|   T  |                  |0000000000000000|     |
 MACHO: _main.eh            |0000000000000080|   S  |                  |0000000000000000|     |
 MACHO: _printf             |                |   U  |                  |                |     |

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

 }
 
 namespace {
 struct NMSymbol {
   uint64_t Address;
   uint64_t Size;
   char TypeChar;
   StringRef Name;
+  StringRef SectionName;
+  StringRef TypeName;
   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() << I->IndirectName << ")";
       }
       outs() << "\n";
     } else if (OutputFormat == sysv) {
       std::string PaddedName(Name);
       while (PaddedName.length() < 20)
         PaddedName += " ";
+      std::string TNPad = "";
+      int TNL = I->TypeName.size();
+      while ((TNPad.length() + TNL) < 18)
+        TNPad += " ";
       outs() << PaddedName << "|" << SymbolAddrStr << "|   " << I->TypeChar
-             << "  |                  |" << SymbolSizeStr << "|     |\n";
+             << "  |" << TNPad << I->TypeName << "|" << SymbolSizeStr
+             << "|     |" << I->SectionName << "\n";
     }
   }
 
   SymbolList.clear();
 }
 
 static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,
                                 basic_symbol_iterator I) {

 }
 
 static bool isObject(SymbolicFile &Obj, basic_symbol_iterator I) {
   return !dyn_cast<ELFObjectFileBase>(&Obj)
              ? false
              : elf_symbol_iterator(I)->getELFType() == ELF::STT_OBJECT;
 }
 
-static char getNMTypeChar(SymbolicFile &Obj, basic_symbol_iterator I) {
+// For ELF object files, Set TypeName to the symbol typename, to be printed
+// in the 'Type' column of the SYSV format output.
+static void getNMTypeName(SymbolicFile &Obj, basic_symbol_iterator I,
+                          StringRef &TypeName) {
+  if (isa<ELFObjectFileBase>(&Obj)) {
+    elf_symbol_iterator SymI(I);
+    SymI->getELFTypeName(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 getNMClassTagAndSectionName(SymbolicFile &Obj,
+                                        basic_symbol_iterator I,
+                                        StringRef &SecName) {
+  if (isa<ELFObjectFileBase>(&Obj)) {
+    elf_symbol_iterator SymI(I);
+
+    Expected<elf_section_iterator> SecIOrErr = SymI->getSection();
+    if (!SecIOrErr) {
+      consumeError(SecIOrErr.takeError());
+      return '?';
+    }
+    int SI = SymI->getSectionIndex();
+    if (SI == 0) {
+      SecName = "*UND*";
+    } else {
+      elf_section_iterator secT = *SecIOrErr;
+      secT->getName(SecName);
+    }
+  }
   uint32_t Symflags = I->getFlags();
   if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) {
     char Ret = isObject(Obj, I) ? 'v' : 'w';
     return (!(Symflags & object::SymbolRef::SF_Undefined)) ? toupper(Ret) : Ret;
   }
 
   if (Symflags & object::SymbolRef::SF_Undefined)
     return 'U';
 
-  if (Symflags & object::SymbolRef::SF_Common)
+  if (Symflags & object::SymbolRef::SF_Common) {
+    SecName = "*COM*";
     return 'C';
+  }
 
   char Ret = '?';
   if (Symflags & object::SymbolRef::SF_Absolute)
     Ret = 'a';
   else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*IR, I);
   else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*COFF, I);
for (BasicSymbolRef Sym : Symbols) {
         SymbolRef SymRef(Sym);
         Expected<uint64_t> AddressOrErr = SymRef.getAddress();
         if (!AddressOrErr) {
           consumeError(AddressOrErr.takeError());
           break;
         }
         S.Address = *AddressOrErr;
       }
-      S.TypeChar = getNMTypeChar(Obj, Sym);
+      getNMTypeName(Obj, Sym, S.TypeName);
+      S.TypeChar = getNMClassTagAndSectionName(Obj, Sym, S.SectionName);
       std::error_code EC = Sym.printName(OS);
       if (EC && MachO)
         OS << "bad string index";
       else
         error(EC);
       OS << '\0';
       S.Sym = Sym;
       SymbolList.push_back(S);

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfSymbolBindings[] = {
     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
 
 static const EnumEntry<unsigned> ElfSymbolVisibilities[] = {
     {"DEFAULT",   "DEFAULT",   ELF::STV_DEFAULT},
     {"INTERNAL",  "INTERNAL",  ELF::STV_INTERNAL},
     {"HIDDEN",    "HIDDEN",    ELF::STV_HIDDEN},
     {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}};
 
-static const EnumEntry<unsigned> ElfSymbolTypes[] = {
-    {"None",      "NOTYPE",  ELF::STT_NOTYPE},
-    {"Object",    "OBJECT",  ELF::STT_OBJECT},
-    {"Function",  "FUNC",    ELF::STT_FUNC},
-    {"Section",   "SECTION", ELF::STT_SECTION},
-    {"File",      "FILE",    ELF::STT_FILE},
-    {"Common",    "COMMON",  ELF::STT_COMMON},
-    {"TLS",       "TLS",     ELF::STT_TLS},
-    {"GNU_IFunc", "IFUNC",   ELF::STT_GNU_IFUNC}};
-
 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
   { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL }
 };
 
 static const char *getGroupType(uint32_t Flag) {
   if (Flag & ELF::GRP_COMDAT)
     return "COMDAT";
   else