llvm-readobj: print COFF delay-load import table

[ruiu]

Summary

llvm-readobj: print COFF delay-load import table

This patch adds another iterator to access the delay-load import table
and use it from llvm-readobj.

[majnemer]

LGTM

[Eugene.Zelenko]

Committed in r218933.

include/llvm/Object/COFF.h

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorOr.h"
 
 namespace llvm {
 template <typename T> class ArrayRef;
 
 namespace object {
 class ImportDirectoryEntryRef;
+class DelayImportDirectoryEntryRef;
 class ExportDirectoryEntryRef;
 class ImportedSymbolRef;
 typedef content_iterator<ImportDirectoryEntryRef> import_directory_iterator;
+typedef content_iterator<DelayImportDirectoryEntryRef>
+    delay_import_directory_iterator;
 typedef content_iterator<ExportDirectoryEntryRef> export_directory_iterator;
 typedef content_iterator<ImportedSymbolRef> imported_symbol_iterator;
 
 /// The DOS compatible header at the front of all PE/COFF executables.
 struct dos_header {
   support::ulittle16_t Magic;
   support::ulittle16_t UsedBytesInTheLastPage;
   support::ulittle16_t FileSizeInPages;
struct import_lookup_table_entry {
   }
 };
 
 typedef import_lookup_table_entry<support::little32_t>
     import_lookup_table_entry32;
 typedef import_lookup_table_entry<support::little64_t>
     import_lookup_table_entry64;
 
+struct delay_import_directory_table_entry {
+  // dumpbin reports this field as "Characteristics" instead of "Attributes".
+  support::ulittle32_t Attributes;
+  support::ulittle32_t Name;
+  support::ulittle32_t ModuleHandle;
+  support::ulittle32_t DelayImportAddressTable;
+  support::ulittle32_t DelayImportNameTable;
+  support::ulittle32_t BoundDelayImportTable;
+  support::ulittle32_t UnloadDelayImportTable;
+  support::ulittle32_t TimeStamp;
+};
+
 struct export_directory_table_entry {
   support::ulittle32_t ExportFlags;
   support::ulittle32_t TimeDateStamp;
   support::ulittle16_t MajorVersion;
   support::ulittle16_t MinorVersion;
   support::ulittle32_t NameRVA;
   support::ulittle32_t OrdinalBase;
   support::ulittle32_t AddressTableEntries;
private:
   const data_directory *DataDirectory;
   const coff_section *SectionTable;
   const coff_symbol16 *SymbolTable16;
   const coff_symbol32 *SymbolTable32;
   const char *StringTable;
   uint32_t StringTableSize;
   const import_directory_table_entry *ImportDirectory;
   uint32_t NumberOfImportDirectory;
+  const delay_import_directory_table_entry *DelayImportDirectory;
+  uint32_t NumberOfDelayImportDirectory;
   const export_directory_table_entry *ExportDirectory;
 
   std::error_code getString(uint32_t offset, StringRef &Res) const;
 
   template <typename coff_symbol_type>
   const coff_symbol_type *toSymb(DataRefImpl Symb) const;
   const coff_section *toSec(DataRefImpl Sec) const;
   const coff_relocation *toRel(DataRefImpl Rel) const;
 
   std::error_code initSymbolTablePtr();
   std::error_code initImportTablePtr();
+  std::error_code initDelayImportTablePtr();
   std::error_code initExportTablePtr();
 
 public:
   uintptr_t getSymbolTable() const {
     if (SymbolTable16)
       return reinterpret_cast<uintptr_t>(SymbolTable16);
     if (SymbolTable32)
       return reinterpret_cast<uintptr_t>(SymbolTable32);
public:
   const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
 
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   unsigned getArch() const override;
 
   import_directory_iterator import_directory_begin() const;
   import_directory_iterator import_directory_end() const;
+  delay_import_directory_iterator delay_import_directory_begin() const;
+  delay_import_directory_iterator delay_import_directory_end() const;
   export_directory_iterator export_directory_begin() const;
   export_directory_iterator export_directory_end() const;
 
   std::error_code getPE32Header(const pe32_header *&Res) const;
   std::error_code getPE32PlusHeader(const pe32plus_header *&Res) const;
   std::error_code getDataDirectory(uint32_t index,
                                    const data_directory *&Res) const;
   std::error_code getSection(int32_t index, const coff_section *&Res) const;
public:
   getImportLookupEntry(const import_lookup_table_entry32 *&Result) const;
 
 private:
   const import_directory_table_entry *ImportTable;
   uint32_t Index;
   const COFFObjectFile *OwningObject;
 };
 
+class DelayImportDirectoryEntryRef {
+public:
+  DelayImportDirectoryEntryRef() : OwningObject(nullptr) {}
+  DelayImportDirectoryEntryRef(const delay_import_directory_table_entry *T,
+                               uint32_t I, const COFFObjectFile *Owner)
+      : Table(T), Index(I), OwningObject(Owner) {}
+
+  bool operator==(const DelayImportDirectoryEntryRef &Other) const;
+  void moveNext();
+
+  imported_symbol_iterator imported_symbol_begin() const;
+  imported_symbol_iterator imported_symbol_end() const;
+
+  std::error_code getName(StringRef &Result) const;
+
+private:
+  const delay_import_directory_table_entry *Table;
+  uint32_t Index;
+  const COFFObjectFile *OwningObject;
+};
+
 // The iterator for the export directory table entry.
 class ExportDirectoryEntryRef {
 public:
   ExportDirectoryEntryRef() : OwningObject(nullptr) {}
   ExportDirectoryEntryRef(const export_directory_table_entry *Table, uint32_t I,
                           const COFFObjectFile *Owner)
       : ExportTable(Table), Index(I), OwningObject(Owner) {}
 

lib/Object/COFFObjectFile.cpp

std::error_code COFFObjectFile::initImportTablePtr() {
   uintptr_t IntPtr = 0;
   if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr))
     return EC;
   ImportDirectory = reinterpret_cast<
       const import_directory_table_entry *>(IntPtr);
   return object_error::success;
 }
 
+// Initializes DelayImportDirectory and NumberOfDelayImportDirectory.
+std::error_code COFFObjectFile::initDelayImportTablePtr() {
+  const data_directory *DataEntry;
+  if (getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR, DataEntry))
+    return object_error::success;
+  if (DataEntry->RelativeVirtualAddress == 0)
+    return object_error::success;
+
+  uint32_t RVA = DataEntry->RelativeVirtualAddress;
+  NumberOfDelayImportDirectory = DataEntry->Size /
+      sizeof(delay_import_directory_table_entry) - 1;
+
+  uintptr_t IntPtr = 0;
+  if (std::error_code EC = getRvaPtr(RVA, IntPtr))
+    return EC;
+  DelayImportDirectory = reinterpret_cast<
+      const delay_import_directory_table_entry *>(IntPtr);
+  return object_error::success;
+}
+
 // Find the export table.
 std::error_code COFFObjectFile::initExportTablePtr() {
   // First, we get the RVA of the export table. If the file lacks a pointer to
   // the export table, do nothing.
   const data_directory *DataEntry;
   if (getDataDirectory(COFF::EXPORT_TABLE, DataEntry))
     return object_error::success;
 

 }
 
 COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
     : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr),
       COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr),
       DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr),
       SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0),
       ImportDirectory(nullptr), NumberOfImportDirectory(0),
+      DelayImportDirectory(nullptr), NumberOfDelayImportDirectory(0),
       ExportDirectory(nullptr) {
   // Check that we at least have enough room for a header.
   if (!checkSize(Data, EC, sizeof(coff_file_header)))
     return;
 
   // The current location in the file where we are looking at.
   uint64_t CurPtr = 0;
 
COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
   // Initialize the pointer to the symbol table.
   if (getPointerToSymbolTable() != 0)
     if ((EC = initSymbolTablePtr()))
       return;
 
   // Initialize the pointer to the beginning of the import table.
   if ((EC = initImportTablePtr()))
     return;
+  if ((EC = initDelayImportTablePtr()))
+    return;
 
   // Initialize the pointer to the export table.
   if ((EC = initExportTablePtr()))
     return;
 
   EC = object_error::success;
 }
 
return import_directory_iterator(
       ImportDirectoryEntryRef(ImportDirectory, 0, this));
 }
 
 import_directory_iterator COFFObjectFile::import_directory_end() const {
   return import_directory_iterator(
       ImportDirectoryEntryRef(ImportDirectory, NumberOfImportDirectory, this));
 }
 
+delay_import_directory_iterator
+COFFObjectFile::delay_import_directory_begin() const {
+  return delay_import_directory_iterator(
+      DelayImportDirectoryEntryRef(DelayImportDirectory, 0, this));
+}
+
+delay_import_directory_iterator
+COFFObjectFile::delay_import_directory_end() const {
+  return delay_import_directory_iterator(
+      DelayImportDirectoryEntryRef(
+          DelayImportDirectory, NumberOfDelayImportDirectory, this));
+}
+
 export_directory_iterator COFFObjectFile::export_directory_begin() const {
   return export_directory_iterator(
       ExportDirectoryEntryRef(ExportDirectory, 0, this));
 }
 
 export_directory_iterator COFFObjectFile::export_directory_end() const {
   if (!ExportDirectory)
     return export_directory_iterator(ExportDirectoryEntryRef(nullptr, 0, this));

 
 std::error_code ImportDirectoryEntryRef::getImportTableEntry(
     const import_directory_table_entry *&Result) const {
   Result = ImportTable + Index;
   return object_error::success;
 }
 
 static imported_symbol_iterator
-makeImportedSymbolIterator(const COFFObjectFile *OwningObject,
+makeImportedSymbolIterator(const COFFObjectFile *Object,
                            uintptr_t Ptr, int Index) {
-  if (OwningObject->getBytesInAddress() == 4) {
+  if (Object->getBytesInAddress() == 4) {
     auto *P = reinterpret_cast<const import_lookup_table_entry32 *>(Ptr);
-    return imported_symbol_iterator(ImportedSymbolRef(P, Index, OwningObject));
+    return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object));
   }
   auto *P = reinterpret_cast<const import_lookup_table_entry64 *>(Ptr);
-  return imported_symbol_iterator(ImportedSymbolRef(P, Index, OwningObject));
+  return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object));
 }
 
-imported_symbol_iterator
-ImportDirectoryEntryRef::imported_symbol_begin() const {
+static imported_symbol_iterator
+importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object) {
   uintptr_t IntPtr = 0;
-  OwningObject->getRvaPtr(ImportTable[Index].ImportLookupTableRVA, IntPtr);
-  return makeImportedSymbolIterator(OwningObject, IntPtr, 0);
+  Object->getRvaPtr(RVA, IntPtr);
+  return makeImportedSymbolIterator(Object, IntPtr, 0);
 }
 
-imported_symbol_iterator
-ImportDirectoryEntryRef::imported_symbol_end() const {
+static imported_symbol_iterator
+importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object) {
   uintptr_t IntPtr = 0;
-  OwningObject->getRvaPtr(ImportTable[Index].ImportLookupTableRVA, IntPtr);
+  Object->getRvaPtr(RVA, IntPtr);
   // Forward the pointer to the last entry which is null.
   int Index = 0;
-  if (OwningObject->getBytesInAddress() == 4) {
+  if (Object->getBytesInAddress() == 4) {
     auto *Entry = reinterpret_cast<ulittle32_t *>(IntPtr);
     while (*Entry++)
       ++Index;
   } else {
     auto *Entry = reinterpret_cast<ulittle64_t *>(IntPtr);
     while (*Entry++)
       ++Index;
   }
-  return makeImportedSymbolIterator(OwningObject, IntPtr, Index);
+  return makeImportedSymbolIterator(Object, IntPtr, Index);
+}
+
+imported_symbol_iterator
+ImportDirectoryEntryRef::imported_symbol_begin() const {
+  return importedSymbolBegin(ImportTable[Index].ImportLookupTableRVA,
+                             OwningObject);
+}
+
+imported_symbol_iterator
+ImportDirectoryEntryRef::imported_symbol_end() const {
+  return importedSymbolEnd(ImportTable[Index].ImportLookupTableRVA,
+                           OwningObject);
 }
 
 std::error_code ImportDirectoryEntryRef::getName(StringRef &Result) const {
   uintptr_t IntPtr = 0;
   if (std::error_code EC =
           OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr))
     return EC;
   Result = StringRef(reinterpret_cast<const char *>(IntPtr));
std::error_code ImportDirectoryEntryRef::getImportLookupEntry(
   uintptr_t IntPtr = 0;
   uint32_t RVA = ImportTable[Index].ImportLookupTableRVA;
   if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
     return EC;
   Result = reinterpret_cast<const import_lookup_table_entry32 *>(IntPtr);
   return object_error::success;
 }
 
+bool DelayImportDirectoryEntryRef::
+operator==(const DelayImportDirectoryEntryRef &Other) const {
+  return Table == Other.Table && Index == Other.Index;
+}
+
+void DelayImportDirectoryEntryRef::moveNext() {
+  ++Index;
+}
+
+imported_symbol_iterator
+DelayImportDirectoryEntryRef::imported_symbol_begin() const {
+  return importedSymbolBegin(Table[Index].DelayImportNameTable,
+                             OwningObject);
+}
+
+imported_symbol_iterator
+DelayImportDirectoryEntryRef::imported_symbol_end() const {
+  return importedSymbolEnd(Table[Index].DelayImportNameTable,
+                           OwningObject);
+}
+
+std::error_code DelayImportDirectoryEntryRef::getName(StringRef &Result) const {
+  uintptr_t IntPtr = 0;
+  if (std::error_code EC = OwningObject->getRvaPtr(Table[Index].Name, IntPtr))
+    return EC;
+  Result = StringRef(reinterpret_cast<const char *>(IntPtr));
+  return object_error::success;
+}
+
 bool ExportDirectoryEntryRef::
 operator==(const ExportDirectoryEntryRef &Other) const {
   return ExportTable == Other.ExportTable && Index == Other.Index;
 }
 
 void ExportDirectoryEntryRef::moveNext() {
   ++Index;
 }

test/tools/llvm-readobj/imports.test

 RUN: llvm-readobj --coff-imports %p/Inputs/imports.exe.coff-i386 | FileCheck -check-prefix=X86 %s
 RUN: llvm-readobj --coff-imports %p/Inputs/imports.exe.coff-x86-64 | FileCheck -check-prefix=X64  %s
 
 X86:      Import {
 X86-NEXT:   Name: KERNEL32.dll
-X86-NEXT:   ImportLookupTableRVA: 0x2070
+X86-NEXT:   ImportLookupTableRVA: 0x2108
 X86-NEXT:   ImportAddressTableRVA: 0x2000
 X86-NEXT:   Symbol: ExitProcess (337)
+X86-NEXT:   Symbol: GetProcAddress (669)
+X86-NEXT:   Symbol: FreeLibrary (414)
+X86-NEXT:   Symbol: GetLastError (592)
+X86-NEXT:   Symbol: RaiseException (1087)
+X86-NEXT:   Symbol: LoadLibraryExA (934)
 X86-NEXT: }
 X86-NEXT: Import {
 X86-NEXT:   Name: USER32.dll
-X86-NEXT:   ImportLookupTableRVA: 0x2078
-X86-NEXT:   ImportAddressTableRVA: 0x2008
+X86-NEXT:   ImportLookupTableRVA: 0x2124
+X86-NEXT:   ImportAddressTableRVA: 0x201C
 X86-NEXT:   Symbol: MessageBoxA (582)
 X86-NEXT: }
 X86-NEXT: Import {
 X86-NEXT:   Name: mydll.dll
-X86-NEXT:   ImportLookupTableRVA: 0x2080
-X86-NEXT:   ImportAddressTableRVA: 0x2010
+X86-NEXT:   ImportLookupTableRVA: 0x212C
+X86-NEXT:   ImportAddressTableRVA: 0x2024
+X86-NEXT:   Symbol: Func1 (0)
 X86-NEXT:   Symbol: Func2 (1)
 X86-NEXT:   Symbol:  (3)
-X86-NEXT:   Symbol: Func1 (0)
+X86-NEXT: }
+X86-NEXT: DelayImport {
+X86-NEXT:   Name: lazyload.dll
+X86-NEXT:   Symbol: Func5 (0)
+X86-NEXT:   Symbol: Func4 (0)
 X86-NEXT: }
 
 X64:      Import {
 X64-NEXT:   Name: KERNEL32.dll
-X64-NEXT:   ImportLookupTableRVA: 0x2090
+X64-NEXT:   ImportLookupTableRVA: 0x2170
 X64-NEXT:   ImportAddressTableRVA: 0x2000
 X64-NEXT:   Symbol: ExitProcess (343)
+X64-NEXT:   Symbol: GetProcAddress (676)
+X64-NEXT:   Symbol: FreeLibrary (420)
+X64-NEXT:   Symbol: GetLastError (598)
+X64-NEXT:   Symbol: RaiseException (1091)
+X64-NEXT:   Symbol: LoadLibraryExA (937)
 X64-NEXT: }
 X64-NEXT: Import {
 X64-NEXT:   Name: USER32.dll
-X64-NEXT:   ImportLookupTableRVA: 0x20A0
-X64-NEXT:   ImportAddressTableRVA: 0x2010
+X64-NEXT:   ImportLookupTableRVA: 0x21A8
+X64-NEXT:   ImportAddressTableRVA: 0x2038
 X64-NEXT:   Symbol: MessageBoxA (586)
 X64-NEXT: }
 X64-NEXT: Import {
 X64-NEXT:   Name: mydll.dll
-X64-NEXT:   ImportLookupTableRVA: 0x20B0
-X64-NEXT:   ImportAddressTableRVA: 0x2020
+X64-NEXT:   ImportLookupTableRVA: 0x21B8
+X64-NEXT:   ImportAddressTableRVA: 0x2048
+X64-NEXT:   Symbol: Func1 (0)
 X64-NEXT:   Symbol: Func2 (1)
 X64-NEXT:   Symbol:  (3)
-X64-NEXT:   Symbol: Func1 (0)
+X64-NEXT: }
+X64-NEXT: DelayImport {
+X64-NEXT:   Name: lazyload.dll
+X64-NEXT:   Symbol: Func5 (0)
+X64-NEXT:   Symbol: Func4 (0)
 X64-NEXT: }

tools/llvm-readobj/COFFDumper.cpp

private:
 
   void cacheRelocations();
 
   std::error_code resolveSymbol(const coff_section *Section, uint64_t Offset,
                                 SymbolRef &Sym);
   std::error_code resolveSymbolName(const coff_section *Section,
                                     uint64_t Offset, StringRef &Name);
 
+  void printImportedSymbols(imported_symbol_iterator I,
+                            imported_symbol_iterator E);
+
   typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;
 
   const llvm::object::COFFObjectFile *Obj;
   RelocMapTy RelocMap;
 };
 
 } // namespace
 
void COFFDumper::printUnwindInfo() {
   }
   default:
     W.printEnum("unsupported Image Machine", Obj->getMachine(),
                 makeArrayRef(ImageFileMachineType));
     break;
   }
 }
 
+void COFFDumper::printImportedSymbols(imported_symbol_iterator I,
+                                      imported_symbol_iterator E) {
+  for (; I != E; ++I) {
+    StringRef Sym;
+    if (error(I->getSymbolName(Sym))) return;
+    uint16_t Ordinal;
+    if (error(I->getOrdinal(Ordinal))) return;
+    W.printNumber("Symbol", Sym, Ordinal);
+  }
+}
+
 void COFFDumper::printCOFFImports() {
+  // Regular imports
   for (auto I = Obj->import_directory_begin(), E = Obj->import_directory_end();
        I != E; ++I) {
     DictScope Import(W, "Import");
     StringRef Name;
     if (error(I->getName(Name))) return;
     W.printString("Name", Name);
     uint32_t Addr;
     if (error(I->getImportLookupTableRVA(Addr))) return;
     W.printHex("ImportLookupTableRVA", Addr);
     if (error(I->getImportAddressTableRVA(Addr))) return;
     W.printHex("ImportAddressTableRVA", Addr);
-    for (auto J = I->imported_symbol_begin(), F = I->imported_symbol_end();
-         J != F; ++J) {
-      StringRef Sym;
-      if (error(J->getSymbolName(Sym))) return;
-      uint16_t Ordinal;
-      if (error(J->getOrdinal(Ordinal))) return;
-      W.printNumber("Symbol", Sym, Ordinal);
-    }
+    printImportedSymbols(I->imported_symbol_begin(), I->imported_symbol_end());
+
+  // Delay imports
+  for (auto I = Obj->delay_import_directory_begin(),
+            E = Obj->delay_import_directory_end();
+       I != E; ++I) {
+    DictScope Import(W, "DelayImport");
+    StringRef Name;
+    if (error(I->getName(Name))) return;
+    W.printString("Name", Name);
+    printImportedSymbols(I->imported_symbol_begin(), I->imported_symbol_end());
   }
 }