llvm-readobj: print COFF import table

[ruiu]

Summary

This patch adds a new flag "-coff-imports" to llvm-readobj. When the flag
is given, the command prints out the COFF import table.

Currently only the import table directory will be printed. I'm going to make
another patch to print out the imported symbols.

The implementation of import directory entry iterator in COFFObjectFile.cpp
was buggy. This patch fixes that too.

[majnemer]

You don't check to see if the import table is RVA based.

tools/llvm-readobj/COFFDumper.cpp

887–888

We should probably add an iterator_range for this, then you can use a range-based for loop.

890

Name

893

Addr1 and Addr2

Alternatively, you could do:

if (error(I->getImportLookupTableRVA(Addr))) return;
W.printHex("ImportLookupTableRVA", Addr);
if (error(I->getImportAddressTableRVA(Addr))) return;
W.printHex("ImportAddressTableRVA", Addr);

[ruiu]

There's no notion of VA/RVA flag in the import table.
Maybe you are talking about the delay-load import table?
That's different from the (regular) import table.

tools/llvm-readobj/COFFDumper.cpp

887–888

Yeah, maybe we should, but not in this patch. All the other iterators in COFFObjects.cpp are written this way, so they should be updated all at once.

890

Done

893

Done

[majnemer]

LGTM

[Eugene.Zelenko]

Committed in r218891.

include/llvm/Object/COFF.h

public:
   ImportDirectoryEntryRef() : OwningObject(nullptr) {}
   ImportDirectoryEntryRef(const import_directory_table_entry *Table, uint32_t I,
                           const COFFObjectFile *Owner)
       : ImportTable(Table), Index(I), OwningObject(Owner) {}
 
   bool operator==(const ImportDirectoryEntryRef &Other) const;
   void moveNext();
   std::error_code getName(StringRef &Result) const;
+  std::error_code getImportLookupTableRVA(uint32_t &Result) const;
+  std::error_code getImportAddressTableRVA(uint32_t &Result) const;
 
   std::error_code
   getImportTableEntry(const import_directory_table_entry *&Result) const;
 
   std::error_code
   getImportLookupEntry(const import_lookup_table_entry32 *&Result) const;
 
 private:

lib/Object/COFFObjectFile.cpp

std::error_code COFFObjectFile::initImportTablePtr() {
   if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry))
     return object_error::success;
 
   // Do nothing if the pointer to import table is NULL.
   if (DataEntry->RelativeVirtualAddress == 0)
     return object_error::success;
 
   uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress;
+  // -1 because the last entry is the null entry.
   NumberOfImportDirectory = DataEntry->Size /
-      sizeof(import_directory_table_entry);
+      sizeof(import_directory_table_entry) - 1;
 
   // Find the section that contains the RVA. This is needed because the RVA is
   // the import table's memory address which is different from its file offset.
   uintptr_t IntPtr = 0;
   if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr))
     return EC;
   ImportDirectory = reinterpret_cast<
       const import_directory_table_entry *>(IntPtr);

 }
 
 void ImportDirectoryEntryRef::moveNext() {
   ++Index;
 }
 
 std::error_code ImportDirectoryEntryRef::getImportTableEntry(
     const import_directory_table_entry *&Result) const {
-  Result = ImportTable;
+  Result = ImportTable + Index;
   return object_error::success;
 }
 
 std::error_code ImportDirectoryEntryRef::getName(StringRef &Result) const {
   uintptr_t IntPtr = 0;
   if (std::error_code EC =
-          OwningObject->getRvaPtr(ImportTable->NameRVA, IntPtr))
+          OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr))
     return EC;
   Result = StringRef(reinterpret_cast<const char *>(IntPtr));
   return object_error::success;
 }
 
+std::error_code ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t  &Result) const {
+  Result = ImportTable[Index].ImportLookupTableRVA;
+  return object_error::success;
+}
+
+std::error_code ImportDirectoryEntryRef::getImportAddressTableRVA(uint32_t &Result) const {
+  Result = ImportTable[Index].ImportAddressTableRVA;
+  return object_error::success;
+}
+
 std::error_code ImportDirectoryEntryRef::getImportLookupEntry(
     const import_lookup_table_entry32 *&Result) const {
   uintptr_t IntPtr = 0;
   if (std::error_code EC =
-          OwningObject->getRvaPtr(ImportTable->ImportLookupTableRVA, IntPtr))
+          OwningObject->getRvaPtr(ImportTable[Index].ImportLookupTableRVA, IntPtr))
     return EC;
   Result = reinterpret_cast<const import_lookup_table_entry32 *>(IntPtr);
   return object_error::success;
 }
 
 bool ExportDirectoryEntryRef::
 operator==(const ExportDirectoryEntryRef &Other) const {
   return ExportTable == Other.ExportTable && Index == Other.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: 0x204C
+X86-NEXT:   ImportAddressTableRVA: 0x2000
+X86-NEXT: }
+X86-NEXT: Import {
+X86-NEXT:   Name: USER32.dll
+X86-NEXT:   ImportLookupTableRVA: 0x2054
+X86-NEXT:   ImportAddressTableRVA: 0x2008
+X86-NEXT: }
+
+X64:      Import {
+X64-NEXT:   Name: KERNEL32.dll
+X64-NEXT:   ImportLookupTableRVA: 0x2060
+X64-NEXT:   ImportAddressTableRVA: 0x2000
+X64-NEXT: }
+X64-NEXT: Import {
+X64-NEXT:   Name: USER32.dll
+X64-NEXT:   ImportLookupTableRVA: 0x2070
+X64-NEXT:   ImportAddressTableRVA: 0x2010
+X64-NEXT: }

tools/llvm-readobj/COFFDumper.cpp

public:
   }
 
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
+  void printCOFFImports() override;
 
 private:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc);
   void printDataDirectory(uint32_t Index, const std::string &FieldName);
 
   template <class PEHeader> void printPEHeader(const PEHeader *Hdr);
   void printBaseOfDataField(const pe32_header *Hdr);
void COFFDumper::printUnwindInfo() {
   }
   default:
     W.printEnum("unsupported Image Machine", Obj->getMachine(),
                 makeArrayRef(ImageFileMachineType));
     break;
   }
 }
 
+void COFFDumper::printCOFFImports() {
+  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 addr1, addr2;
+    if (error(I->getImportLookupTableRVA(addr1))) return;
+    if (error(I->getImportAddressTableRVA(addr2))) return;
+    W.printHex("ImportLookupTableRVA", addr1);
+    W.printHex("ImportAddressTableRVA", addr2);
+  }
+}

tools/llvm-readobj/ObjDumper.h

public:
   virtual void printProgramHeaders() { }
 
   // Only implemented for ARM ELF at this time.
   virtual void printAttributes() { }
 
   // Only implemented for MIPS ELF at this time.
   virtual void printMipsPLTGOT() { }
 
+  // Only implemented for PE/COFF.
+  virtual void printCOFFImports() { }
+
 protected:
   StreamWriter& W;
 };
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  StreamWriter &Writer,
                                  std::unique_ptr<ObjDumper> &Result);
 

tools/llvm-readobj/llvm-readobj.cpp

cl::opt<bool> ARMAttributes("arm-attributes",
                               cl::desc("Display the ARM attributes section"));
   cl::alias ARMAttributesShort("-a", cl::desc("Alias for --arm-attributes"),
                                cl::aliasopt(ARMAttributes));
 
   // -mips-plt-got
   cl::opt<bool>
   MipsPLTGOT("mips-plt-got",
              cl::desc("Display the MIPS GOT and PLT GOT sections"));
+
+  // -coff-imports
+  cl::opt<bool>
+  COFFImports("coff-imports", cl::desc("Display the PE/COFF import table"));
 } // namespace opts
 
 static int ReturnValue = EXIT_SUCCESS;
 
 namespace llvm {
 
 bool error(std::error_code EC) {
   if (!EC)
static void dumpObject(const ObjectFile *Obj) {
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();
   if (Obj->getArch() == llvm::Triple::arm && Obj->isELF())
     if (opts::ARMAttributes)
       Dumper->printAttributes();
   if (isMipsArch(Obj->getArch()) && Obj->isELF())
     if (opts::MipsPLTGOT)
       Dumper->printMipsPLTGOT();
+  if (opts::COFFImports)
+    Dumper->printCOFFImports();
 }
 
 
 /// @brief Dumps each object file in \a Arc;
 static void dumpArchive(const Archive *Arc) {
   for (Archive::child_iterator ArcI = Arc->child_begin(),
                                ArcE = Arc->child_end();
                                ArcI != ArcE; ++ArcI) {