[llvm-readobj/llvm-readelf] - Implement GNU style dumper of the SHT_GNU_verdef section.

[grimar]

Summary

It was not implemented yet, we had only LLVM style dumper implemented.
Section description is here: https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/symversion.html

This patch is rebased on top of D62516 (which implements GNU-style SHT_GNU_verneed dumping).

[MaskRay]

LGTM, but you may want to wait for others to comment.

tools/llvm-readobj/ELFDumper.cpp

3523 ↗

(On Diff #201647)

StringRef a(...) or String a{...} are probably more common.

[Higuoxing]

LGTM, I was coping with my graduation essay these days, so I did not finished my revision in time :) Thank you @rupprecht for informing me.

[MaskRay]

BTW, the latest Linux Stand Base is of version 5.0: https://refspecs.linuxfoundation.org/lsb.shtml You may update the link in the descritpion

[grimar]

• Rebased.
• Addressed review comments.

llvm/trunk/test/tools/llvm-readobj/elf-versioninfo.test

- Name:         .gnu.version_d
     Link:         .dynstr
     AddressAlign: 0x0000000000000004
     Info:         0x0000000000000003
     Entries:
       - Version:    1
         Flags:      0
         VersionNdx: 2
         Hash:       175630257
-        Names:           
+        Names:
           - VERSION1
       - Version:    1
         Flags:      0
         VersionNdx: 3
         Hash:       175630258
         Names:
           - VERSION2
           - VERSION1
Dependencies:
             Other: 5
       - Version: 1
         File:    verneed2.so.0
         Entries:
           - Name:  v3
             Hash:  1937
             Flags: 0
             Other: 6
-DynamicSymbols:  
+DynamicSymbols:
   - Name:            sym1
     Binding:         STB_GLOBAL
   - Name:            sym2
     Binding:         STB_GLOBAL
   - Name:            sym3
     Binding:         STB_GLOBAL
   - Name:            sym4
     Binding:         STB_GLOBAL

 # LLVM-NEXT:   }
 # LLVM-NEXT: }
 
 # GNU:      Version symbols section '.gnu.version' contains 6 entries:
 # GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000280  Link: 7 (.dynsym)
 # GNU-NEXT:   000:   0 (*local*) 2 (VERSION1) 3 (VERSION2) 4 (v1)
 # GNU-NEXT:   004:   5 (v2)      6 (v3)
 # GNU-EMPTY:
-# GNU-NEXT: Dumper for .gnu.version_d is not implemented
+# GNU-NEXT: Version definition section '.gnu.version_d' contains 3 entries:
+# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x00028c  Link: 8 (.dynstr)
+# GNU-NEXT:   0x0000: Rev: 1  Flags: none  Index: 2  Cnt: 1  Name: VERSION1
+# GNU-NEXT:   0x001c: Rev: 1  Flags: none  Index: 3  Cnt: 2  Name: VERSION2
+# GNU-NEXT:   0x0038: Parent 1: VERSION1
+# GNU-NEXT:   0x001c: Rev: 1  Flags: none  Index: 3  Cnt: 2  Name: VERSION2
+# GNU-NEXT:   0x0038: Parent 1: VERSION1
 # GNU-EMPTY:
 # GNU-NEXT: Version needs section '.gnu.version_r' contains 2 entries:
 # GNU-NEXT:  Addr: 0000000000000000  Offset: 0x0002cc  Link: 8 (.dynstr)
 # GNU-NEXT:   0x0000: Version: 1  File: verneed1.so.0  Cnt: 2
 # GNU-NEXT:   0x0010:   Name: v1  Flags: none  Version: 4
 # GNU-NEXT:   0x0020:   Name: v2  Flags: none  Version: 5
 # GNU-NEXT:   0x0030: Version: 1  File: verneed2.so.0  Cnt: 1
 # GNU-NEXT:   0x0040:   Name: v3  Flags: none  Version: 6

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

for (uint64_t VersymIndex = 0;
       }
       VersymBuf += sizeof(Elf_Versym);
     }
     OS << '\n';
   }
   OS << '\n';
 }
 
-template <class ELFT>
-void GNUStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
-                                                   const Elf_Shdr *Sec) {
-  if (!Sec)
-    return;
-
-  StringRef SecName = unwrapOrError(Obj->getSectionName(Sec));
-  OS << "Dumper for " << SecName << " is not implemented\n";
-  OS << '\n';
-}
-
-static std::string verNeedFlagToString(unsigned Flags) {
+static std::string versionFlagToString(unsigned Flags) {
   if (Flags == 0)
     return "none";
 
   std::string Ret;
   auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) {
     if (!(Flags & Flag))
       return;
     if (!Ret.empty())
       Ret += " | ";
     Ret += Name;
     Flags &= ~Flag;
   };
 
   AddFlag(VER_FLG_BASE, "BASE");
   AddFlag(VER_FLG_WEAK, "WEAK");
   AddFlag(VER_FLG_INFO, "INFO");
   AddFlag(~0, "<unknown>");
   return Ret;
 }
 
 template <class ELFT>
+void GNUStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
+                                                   const Elf_Shdr *Sec) {
+  if (!Sec)
+    return;
+
+  unsigned VerDefsNum = Sec->sh_info;
+  printGNUVersionSectionProlog(OS, "Version definition", VerDefsNum, Obj, Sec);
+
+  const Elf_Shdr *StrTabSec = unwrapOrError(Obj->getSection(Sec->sh_link));
+  StringRef StringTable(
+      reinterpret_cast<const char *>(Obj->base() + StrTabSec->sh_offset),
+      StrTabSec->sh_size);
+
+  const uint8_t *VerdefBuf = unwrapOrError(Obj->getSectionContents(Sec)).data();
+  const uint8_t *Begin = VerdefBuf;
+
+  while (VerDefsNum--) {
+    const Elf_Verdef *Verdef = reinterpret_cast<const Elf_Verdef *>(VerdefBuf);
+    OS << format("  0x%04x: Rev: %u  Flags: %s  Index: %u  Cnt: %u",
+                 VerdefBuf - Begin, (unsigned)Verdef->vd_version,
+                 versionFlagToString(Verdef->vd_flags).c_str(),
+                 (unsigned)Verdef->vd_ndx, (unsigned)Verdef->vd_cnt);
+
+    const uint8_t *VerdauxBuf = VerdefBuf + Verdef->vd_aux;
+    const Elf_Verdaux *Verdaux =
+        reinterpret_cast<const Elf_Verdaux *>(VerdauxBuf);
+    OS << format("  Name: %s\n",
+                 StringTable.drop_front(Verdaux->vda_name).data());
+
+    for (unsigned I = 1; I < Verdef->vd_cnt; ++I) {
+      VerdauxBuf += Verdaux->vda_next;
+      Verdaux = reinterpret_cast<const Elf_Verdaux *>(VerdauxBuf);
+      OS << format("  0x%04x: Parent %u: %s\n", VerdauxBuf - Begin, I,
+                   StringTable.drop_front(Verdaux->vda_name).data());
+    }
+
+    VerdefBuf += Verdef->vd_next;
+  }
+  OS << '\n';
+}
+
+template <class ELFT>
 void GNUStyle<ELFT>::printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                                    const Elf_Shdr *Sec) {
   if (!Sec)
     return;
 
   unsigned VerneedNum = Sec->sh_info;
   printGNUVersionSectionProlog(OS, "Version needs", VerneedNum, Obj, Sec);
 
for (unsigned I = 0; I < VerneedNum; ++I) {
     const uint8_t *VernauxBuf = VerneedBuf + Verneed->vn_aux;
     for (unsigned J = 0; J < Verneed->vn_cnt; ++J) {
       const Elf_Vernaux *Vernaux =
           reinterpret_cast<const Elf_Vernaux *>(VernauxBuf);
 
       OS << format("  0x%04x:   Name: %s  Flags: %s  Version: %u\n",
                    reinterpret_cast<const uint8_t *>(Vernaux) - SecData.begin(),
                    StringTable.drop_front(Vernaux->vna_name).data(),
-                   verNeedFlagToString(Vernaux->vna_flags).c_str(),
+                   versionFlagToString(Vernaux->vna_flags).c_str(),
                    (unsigned)Vernaux->vna_other);
       VernauxBuf += Vernaux->vna_next;
     }
     VerneedBuf += Verneed->vn_next;
   }
   OS << '\n';
 }