[elfabi] Add support for reading DT_NEEDED from binaries

[amontanez]

Summary

This patch gives elfabi the ability to read DT_NEEDED entries from ELF binaries to populate NeededLibs in TextAPI's ELFStub.

[jakehehrlich]

Other than me realizing I made a mistake in previous reviews and a minor little issue (NeededLibCount), this LGTM.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

122

You never use the NeededLibCount. Why do you have it?

llvm/tools/llvm-elfabi/ELFObjHandler.h

31

ditto (below)

37

ditto (below)

45

ditto (below)

56

Just realized something I should have caught in previous reviews. You don't need these in the headers. You can make them static template functions in just the file they're used in. That reduces .o size and improves the compilers ability to perform optimizations.

69

Ditto here.

[ruiu]

llvm/test/tools/llvm-elfabi/binary-read-neededlibs.test

35

nit: remove extraneous space characters?

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

130

Is NeededLibs empty on function entry? If so, you can return TargetStub.NeededLibs.count() and remove NeededLibCount variable.

[amontanez]

Rebase onto previous patch resolves most of the comments for this patch.

[ruiu]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

118

nit: I believe you don't need std::string as std::string has an implicit constructor from const char *.

[amontanez]

Rebase and use terminatedSubstr() to fetch DT_NEEDED strings from .dynstr string table.

[ruiu]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

26–27

Indentation should be 2 spaces.

118

I think all strings in a string table should be terminated with '\0' in any ELF file. If the last string "overruns" the string table, it is an error, and the last string should not automatically be terminated at the end of the string table.

[amontanez]

Rebase on D55629 change that addresses strings that overrun string table bounds.

[amontanez]

Rebase again.

[amontanez]

Rebase, update error message for DT_NEEDED entries that are outside the string table, and add another test.

[jakehehrlich]

LGTM

llvm/test/tools/llvm-elfabi/binary-read-neededlibs.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-elfabi %t -emit-tbe=%t2
+# RUN: cat %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    Content:         "010000000000000001000000000000000e00000000000000150000000000000001000000000000000b000000000000000a000000000000001c000000000000000500000000000000d00200000000000000000000000000000000000000000000"
+      # DT_NEEDED     1 (0x01)
+      # DT_SONAME     21 (0x15)
+      # DT_NEEDED     11 (0x0b)
+      # DT_STRSZ      36 (0x24)
+      # DT_STRTAB     0x2b0
+      # DT_NULL       0x0
+    Size:            96
+  - Name:            .dynsym
+    Type:            SHT_DYNSYM
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    EntSize:         24
+    Size:            0
+    Link:            .dynstr
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x3000
+#                     \0 l i b f o o . s o\0 l i b b a r . s o\0 s o m e l i b . s o\0 f o o\0
+    Content:         "006c6962666f6f2e736f006c69626261722e736f00736f6d656c69622e736f00666f6f00"
+ProgramHeaders:
+  - Type: PT_LOAD
+    VAddr: 0x0000
+    PAddr: 0x0000
+  - Type: PT_DYNAMIC
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Sections:
+      - Section: .dynamic
+
+#CHECK:         --- !tapi-tbe
+#CHECK-NEXT:    TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+#CHECK-NEXT:    SoName: somelib.so
+#CHECK-NEXT:    Arch: x86_64
+#CHECK-NEXT:    NeededLibs:
+#CHECK-NEXT:      - libfoo.so
+#CHECK-NEXT:      - libbar.so
+#CHECK-NEXT:    Symbols: {}
+#CHECK-NEXT:    ...

llvm/tools/llvm-elfabi/ELFObjHandler.h

 class MemoryBuffer;
 
 namespace elfabi {
 
 /// Returns a new ELFStub with all members populated from an ELFObjectFile.
 /// @param ElfObj Pointer to an ELFObjectFile as a source.
 template <class ELFT>
 Expected<std::unique_ptr<ELFStub>>
 buildStub(const object::ELFObjectFile<ELFT> &ElfObj);
 
 /// Populate the `Arch` member of an ELFStub.
 /// @param TargetStub Reference to an ELFStub who's member will be populated.
 /// @param Header Reference to an ELF file header.
 template <class ELFT>
 Error populateArch(ELFStub &TargetStub, const typename ELFT::Ehdr &Header);
 
 /// Attempt to fetch a reference to the dynamic string table of an ELF binary.
 /// @param DynamicEntries Reference to an ArrayRef containing dynamic entries.
 /// @param ObjBuffer Pointer to the start of the buffer containing the binary.
 ///
 /// @return A llvm::Error or a StringRef to the dynamic string table.
 template <class ELFT>
 Expected<StringRef> getDynStr(const typename ELFT::DynRange &DynamicEntries,
                               const uint8_t *ObjBuffer);
 
 /// Populate the `SoName` member of an ELFStub.
 /// Since SoName is optional, this doesn't return any errors and will simply
 /// return true if SoName is successfully populated.
 /// @param TargetStub Reference to an ELFStub who's member will be populated.
 /// @param DynamicEntries Reference to an ArrayRef containing dynamic entries.
 ///
 /// @return true if TargetStub.SoName is successfully populated.
 template <class ELFT>
 bool populateSoName(ELFStub &TargetStub,
                     const typename ELFT::DynRange &DynamicEntries,
                     StringRef DynStr);
 
+/// Populate the `NeededLibs` member of an ELFStub.
+/// Since NeededLibs is optional, this doesn't return any errors and will simply
+/// return the number of located occurrences of DT_NEEDED entries.
+/// @param TargetStub An ELFStub whose NeededLibs member will be populated.
+/// @param DynamicEntries Dynamic entries to pull DT_NEEDED entries from.
+/// @param DynStr String table containing library names.
+///
+/// @return Number of DT_NEEDED entries read and added to NeededLibs.
+template <class ELFT>
+int populateNeededLibs(ELFStub &TargetStub,
+                       const typename ELFT::DynRange &DynamicEntries,
+                       StringRef DynStr);
+
 /// Attempt to read a binary ELF file from a MemoryBuffer reference.
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf);
 
 } // end namespace elfabi
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_ELFABI_ELFOBJHANDLER_H

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

 
 using llvm::MemoryBufferRef;
 using llvm::object::ELFObjectFile;
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::elfabi;
 using namespace llvm::ELF;
 
 namespace llvm {
 namespace elfabi {
 
 template <class ELFT>
 Expected<std::unique_ptr<ELFStub>>
 buildStub(const object::ELFObjectFile<ELFT> &ElfObj) {
   std::unique_ptr<ELFStub> DestStub = make_unique<ELFStub>();
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Dyn_Range = typename ELFT::DynRange;
buildStub(const object::ELFObjectFile<ELFT> &ElfObj) {
   // Populate architecture.
   Error ReadArchError = populateArch<ELFT>(*DestStub, *ElfHeader);
   if (ReadArchError)
     return std::move(ReadArchError);
 
   // Populate SoName from .dynamic entries and dynamic string table.
   populateSoName<ELFT>(*DestStub, DynamicEntries, DynStr);
 
-  // TODO: Populate NeededLibs from .dynamic entries and linked string table.
+  // Populate NeededLibs from .dynamic entries and dynamic string table.
+  populateNeededLibs<ELFT>(*DestStub, DynamicEntries, DynStr);
+
   // TODO: Populate Symbols from .dynsym table and linked string table.
 
   return std::move(DestStub);
 }
 
 template <class ELFT>
 Expected<StringRef> getDynStr(const typename ELFT::DynRange &DynamicEntries,
                               const uint8_t *ObjBuffer) {
if (Entry.d_tag == DT_SONAME) {
       TargetStub.SoName = std::string(SoNamePtr);
 
       // SoName has been successfully populated.
       return true;
     }
   }
 
   // Unable to populate SoName.
   return false;
 }
 
 template <class ELFT>
+int populateNeededLibs(ELFStub &TargetStub,
+                       const typename ELFT::DynRange &DynamicEntries,
+                       StringRef DynStr) {
+  uint64_t NeededLibCount = 0;
+  for (auto &Entry : DynamicEntries) {
+    if (Entry.d_tag == DT_NEEDED) {
+      uint64_t LibNameOffset = Entry.d_un.d_val;
+      const char *SoNamePtr = DynStr.data() + LibNameOffset;
+      TargetStub.NeededLibs.push_back(SoNamePtr);
+      NeededLibCount++;
+    }
+  }
+
+  return NeededLibCount;
+}
+
+template <class ELFT>
 Error populateArch(ELFStub &TargetStub, const typename ELFT::Ehdr &Header) {
   TargetStub.Arch = Header.e_machine;
   return Error::success();
 }
 
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
   if (!BinOrErr) {