[llvm-readobj] - Implement --dependent-libraries flag.

[grimar]

Summary

There is no way to dump SHT_LLVM_DEPENDENT_LIBRARIES sections
currently. This patch implements this.

The section is described here:
https://llvm.org/docs/Extensions.html#sht-llvm-dependent-libraries-section-dependent-libraries

[grimar]

• Include a few forgotten comments.

[jhenderson]

The llvm-readobj doc needs updating.

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

12

I don't see the need for the Entries: list. Can't you just print them as:

DependentLibs [
  foo,
  bar,
  foo
]

46

when have not null-terminated -> for a non-null-terminated

58

aall -> all

62

when unable to get the content -> when the section offset is invalid

llvm/tools/llvm-readobj/ELFDumper.cpp

6169

reportUniqueWarning?

[grimar]

• Addressed review comments.

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

12

Done.
(Without a comma. It seems to be excessive to have it here + scoped printer's printString() does not print, I think we should not add it manually).

[jhenderson]

I've been thinking about this, and I'm not convinced that the switch name should have "elf" in it. I'd prefer simply "--dependent-libraries". Although the option is currently only implemented for ELF, I don't know of any inherent reason it couldn't apply to COFF for example at a future point, and we'd then just need to add an alias to the switch. See also other switches such as --stack-sizes and --addrsig. I'd keep "elf" prefixes to switches that are inherently tied to the ELF file format, such as --elf-section-groups, or maybe where the same term means completely different things for different formats (I'm not sure about this one).

I've subscribed @bd1976llvm who was heavily involved in getting the dependent libraries stuff implemented. He might have some thoughts too.

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

37

Is there a clean way of not having this empty line? I'm not sure there's any benefit to it. It's not a big deal though if it makes the code significantly more complex.

[MaskRay]

In D70665#1759883, @jhenderson wrote:

I've been thinking about this, and I'm not convinced that the switch name should have "elf" in it. I'd prefer simply "--dependent-libraries". Although the option is currently only implemented for ELF, I don't know of any inherent reason it couldn't apply to COFF for example at a future point, and we'd then just need to add an alias to the switch. See also other switches such as --stack-sizes and --addrsig. I'd keep "elf" prefixes to switches that are inherently tied to the ELF file format, such as --elf-section-groups, or maybe where the same term means completely different things for different formats (I'm not sure about this one).

I've subscribed @bd1976llvm who was heavily involved in getting the dependent libraries stuff implemented. He might have some thoughts too.

This llvm ELF feature had a discussion here http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html . The feature originated from COFF https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2019 So I think this option can apply to COFF as well, though I know too little about COFF to say how that will going to work. @bd1976llvm is the expert.

[bd1976llvm]

The feature certainly could be implemented for COFF, so I think changing the name of the command line option is reasonable. The strings in the .deplibs sections map to libraries in an implementation defined manner, so I refer to them as "specifiers". In COFF dependent libraries are specified via "directives" in the object files. It might be worth naming the option something like: --dependent-lib-directives (as directives works for the entries in an ELF .deplibs sections equally as well as specifiers) ?

[grimar]

• Renamed the option to --dependent-lib-directives

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

37

So, the reason is more global and described here:
https://reviews.llvm.org/D70826#inline-639055

I am going to investigate how can we fix this soon.

[jhenderson]

llvm/docs/CommandGuide/llvm-readobj.rst

157

section -> directives (in case it starts getting used by COFF)

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

74

This test will fail right?

[MaskRay]

The code change looks good.

llvm/docs/CommandGuide/llvm-readobj.rst

157

@bd1976llvm @jhenderson Do we have to call it -directives? A #pragma is referred to as a directive, but the section is not.

We support other options that dump extension sections (e.g. --stack-sizes). None has the suffix -directives. I think --dependent-libs (I presume you will prefer the plural form) should be fine.

[grimar]

llvm/docs/CommandGuide/llvm-readobj.rst

157

section -> directives (in case it starts getting used by COFF)

The section type is called "SHT_LLVM_DEPENDENT_LIBRARIES". That is why I haven't changed the description.
Given this the description seems to be fine?

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

74

Oops. I guess this my last minute change wasn't included into the diff. I definitely fixed this.

[grimar]

llvm/docs/CommandGuide/llvm-readobj.rst

157

Or.. Does "SHT_LLVM_DEPENDENT_LIBRARIES" used by COFF somehow or this section type is needed only for ELF?
(I know nothing about COFF. I've supposed it still creates a section of this type under hood, but may be I getting it wrong?).

[jhenderson]

llvm/docs/CommandGuide/llvm-readobj.rst

157

Do we have to call it -directives? A #pragma is referred to as a directive, but the section is not.

Or.. Does "SHT_LLVM_DEPENDENT_LIBRARIES" used by COFF somehow or this section type is needed only for ELF?

I actually prefer it without, but I chatted offline with @bd1976llvm who explained that for the equivalent feature in COFF, they are not listed as libraries, but rather command-line like directives e.g. /DEFAULTLIB:library.lib. Microsoft's dumpbin uses /directives as the option to dump them, for the record, but that dumps more than just library directives.

Happy to hear what other people think though. --dependent-libs is fine for me (or perhaps we should use --dependent-libraries) and I think would be sufficient for COFF too.

[MaskRay]

llvm/docs/CommandGuide/llvm-readobj.rst

157

--dependent-libraries is fine for me (the section type is called SHT_LLVM_DEPENDENT_LIBRARIES).

llvm/tools/llvm-readobj/ELFDumper.cpp

224

Unintended change?

[grimar]

• Renamed the option to --dependent-libraries.

[jhenderson]

LGTM.

llvm/docs/CommandGuide/llvm-readobj.rst

 .. option:: --arch-specific, -A
 
  Display architecture-specific information, e.g. the ARM attributes section on ARM.
 
 .. option:: --demangle, -C
 
  Display demangled symbol names in the output.
 
+.. option:: --dependent-lib-directives
+
+ Display the dependent libraries section.
+
 .. option:: --dyn-relocations
 
  Display the dynamic relocation entries.
 
 .. option:: --dyn-symbols, --dyn-syms, --dt
 
  Display the dynamic symbol table.
 

llvm/test/tools/llvm-readobj/elf-dependent-libraries.test

+## Check that we can use the --dependent-lib-directives option
+## to dump SHT_LLVM_DEPENDENT_LIBRARIES sections.
+
+## Check how we dump a file that has a single valid SHT_LLVM_DEPENDENT_LIBRARIES
+## section with multiple entries.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --dependent-lib-directives %t1 2>&1 | FileCheck %s -DFILE=%t
+
+# CHECK:      DependentLibs [
+# CHECK-NEXT:   foo
+# CHECK-NEXT:   bar
+# CHECK-NEXT:   foo
+# CHECK-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:      .deplibs
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ foo, bar, foo ]
+
+## Now, check how we dump a mix of valid, empty and invalid SHT_LLVM_DEPENDENT_LIBRARIES sections.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readobj --dependent-lib-directives %t2 2>&1 | FileCheck %s --check-prefix=MIX -DFILE=%t2
+
+# MIX:       DependentLibs [
+# MIX-EMPTY:
+# MIX-NEXT:   warning: '[[FILE]]': SHT_LLVM_DEPENDENT_LIBRARIES section at index 1 is broken: the content is not null-terminated
+# MIX-NEXT:   abc
+# MIX-EMPTY:
+# MIX-NEXT:   warning: '[[FILE]]': SHT_LLVM_DEPENDENT_LIBRARIES section at index 4 is broken: section [index 4] has a sh_offset (0xffff0000) + sh_size (0x4) that cannot be represented
+# MIX-NEXT:   bar
+# MIX-NEXT:   xxx
+# MIX-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+## Case 1: test we report a warning for a non-null-terminated section.
+  - Name:      .deplibs.nonul
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Content:   "666f6f" ## 'f', 'o', 'o'
+## Case 2: test we can dump an entry from a valid section that has a single entry.
+  - Name:      .deplibs.single
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ abc ]
+## Case 3: test we do not display warnings for an empty section.
+  - Name:      .deplibs.empty
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Content:   ""
+## Case 4: test we report a warning when the section offset is invalid.
+  - Name:      .deplibs.broken.shoffset
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ yyy ]
+    ShOffset:  0xffff0000
+## Case 5: test we can dump all entries from a valid section that has more than one entry.
+  - Name:      .deplibs.multiple
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ bar, xxx ]
+
+## llvm-readelf doesn't support --dependent-lib-directives yet.
+# RUN: llvm-readelf --dependent-lib-directives %t1 2>&1 | FileCheck %s --check-prefix=READELF
+
+# READELF: printELFDependentLibs not implemented!

llvm/tools/llvm-readobj/ELFDumper.cpp

 
 template <typename ELFT> class ELFDumper : public ObjDumper {
 public:
   ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, ScopedPrinter &Writer);
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
+  void printDependentLibs() override;
   void printDynamicRelocations() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printHashSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders(bool PrintProgramHeaders,
public:
   void printHashHistogram() override;
 
   void printCGProfile() override;
   void printAddrsig() override;
 
   void printNotes() override;
 
   void printELFLinkerOptions() override;
+
   void printStackSizes() override;
 
   const object::ELFObjectFile<ELFT> *getElfObject() const { return ObjF; };
 
 private:
   std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
 
   TYPEDEF_ELF_TYPES(ELFT)
public:
 
   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymbols(const ELFFile<ELFT> *Obj, bool PrintSymbols,
                             bool PrintDynamicSymbols) = 0;
   virtual void printHashSymbols(const ELFFile<ELFT> *Obj) {}
+  virtual void printDependentLibs(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamic(const ELFFile<ELFT> *Obj) {}
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *Obj, StringRef Name,
                                   size_t Offset, bool NonVisibilityBitsUsed) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
                            bool IsDynamic, bool NonVisibilityBitsUsed) = 0;
   virtual void printProgramHeaders(const ELFFile<ELFT> *Obj,
public:
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj, bool PrintSymbols,
                     bool PrintDynamicSymbols) override;
   void printHashSymbols(const ELFO *Obj) override;
+  void printDependentLibs(const ELFFile<ELFT> *Obj) override;
   void printDynamic(const ELFFile<ELFT> *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printSymtabMessage(const ELFO *Obj, StringRef Name, size_t Offset,
                           bool NonVisibilityBitsUsed) override;
   void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                  const Elf_Shdr *Sec) override;
public:
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
   void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj, bool PrintSymbols,
                     bool PrintDynamicSymbols) override;
+  void printDependentLibs(const ELFFile<ELFT> *Obj) override;
   void printDynamic(const ELFFile<ELFT> *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                  const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
   ELFDumperStyle->printVersionDefinitionSection(ObjF->getELFFile(),
                                                 SymbolVersionDefSection);
 
   // Dump version dependency section.
   ELFDumperStyle->printVersionDependencySection(ObjF->getELFFile(),
                                                 SymbolVersionNeedSection);
 }
 
+template <class ELFT> void ELFDumper<ELFT>::printDependentLibs() {
+  ELFDumperStyle->printDependentLibs(ObjF->getELFFile());
+}
+
 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
   ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile());
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printSymbols(bool PrintSymbols,
                                    bool PrintDynamicSymbols) {
   ELFDumperStyle->printSymbols(ObjF->getELFFile(), PrintSymbols,
void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
+template <class ELFT>
+void GNUStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) {
+  OS << "printDependentLibs not implemented!\n";
+}
+
 // Used for printing section names in places where possible errors can be
 // ignored.
 static StringRef getSectionName(const SectionRef &Sec) {
   Expected<StringRef> NameOrErr = Sec.getName();
   if (NameOrErr)
     return *NameOrErr;
   consumeError(NameOrErr.takeError());
   return "<?>";
for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) {
     }
 
     for (size_t I = 0; I < Strings.size(); I += 2)
       W.printString(Strings[I], Strings[I + 1]);
   }
 }
 
 template <class ELFT>
+void LLVMStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) {
+  ListScope L(W, "DependentLibs");
+
+  auto Warn = [this](unsigned SecNdx, StringRef Msg) {
+    this->reportUniqueWarning(
+        createError("SHT_LLVM_DEPENDENT_LIBRARIES section at index " +
+                    Twine(SecNdx) + " is broken: " + Msg));
+  };
+
+  unsigned I = -1;
+  for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) {
+    ++I;
+    if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES)
+      continue;
+
+    Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(&Shdr);
+    if (!ContentsOrErr) {
+      Warn(I, toString(ContentsOrErr.takeError()));
+      continue;
+    }
+
+    ArrayRef<uint8_t> Contents = *ContentsOrErr;
+    if (!Contents.empty() && Contents.back() != 0) {
+      Warn(I, "the content is not null-terminated");
+      continue;
+    }
+
+    for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) {
+      StringRef Lib((const char *)I);
+      W.printString(Lib);
+      I += Lib.size() + 1;
+    }
+  }
+}
+
+template <class ELFT>
 void LLVMStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) {
   ListScope L(W, "StackSizes");
   if (Obj->isRelocatableObject())
     this->printRelocatableStackSizes(Obj, []() {});
   else
     this->printNonRelocatableStackSizes(Obj, []() {});
 }
 

llvm/tools/llvm-readobj/ObjDumper.h

if (PrintProgramHeaders)
       printProgramHeaders();
     if (PrintSectionMapping == cl::BOU_TRUE)
       printSectionMapping();
   }
 
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
+  virtual void printDependentLibs() {}
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
   virtual void printSectionAsHex(StringRef SectionName) {}
   virtual void printHashTable() { }
   virtual void printGnuHashTable() { }
   virtual void printHashSymbols() {}
   virtual void printLoadName() {}

llvm/tools/llvm-readobj/llvm-readobj.cpp

namespace opts {
   cl::opt<bool>
       All("all",
           cl::desc("Equivalent to setting: --file-headers, --program-headers, "
                    "--section-headers, --symbols, --relocations, "
                    "--dynamic-table, --notes, --version-info, --unwind, "
                    "--section-groups and --elf-hash-histogram."));
   cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All));
 
+  // --dependent-lib-directives
+  cl::opt<bool>
+      DependentLibs("dependent-lib-directives",
+                    cl::desc("Display the dependent libraries section"));
+
   // --headers -e
   cl::opt<bool>
       Headers("headers",
           cl::desc("Equivalent to setting: --file-headers, --program-headers, "
                    "--section-headers"));
   cl::alias HeadersShort("e", cl::desc("Alias for --headers"),
      cl::aliasopt(Headers));
 
if (!opts::HexDump.empty())
     Dumper->printSectionsAsHex(Obj, opts::HexDump);
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)
     Dumper->printGnuHashTable();
   if (opts::VersionInfo)
     Dumper->printVersionInfo();
   if (Obj->isELF()) {
+    if (opts::DependentLibs)
+      Dumper->printDependentLibs();
     if (opts::ELFLinkerOptions)
       Dumper->printELFLinkerOptions();
     if (opts::ArchSpecificInfo)
       Dumper->printArchSpecificInfo();
     if (opts::SectionGroups)
       Dumper->printGroupSections();
     if (opts::HashHistogram)
       Dumper->printHashHistogram();