Object: Add range iterators for COFF import/export table

[ruiu]

Summary

Object: Add range iterators for COFF import/export table

[majnemer]

LGTM

tools/llvm-readobj/COFFDumper.cpp

78

Please capitalize range to Range.

888

Likewise.

[Eugene.Zelenko]

Committed in r219383.

include/llvm/Object/COFF.h

public:
 
   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;
 
+  iterator_range<import_directory_iterator> import_directories() const;
+  iterator_range<delay_import_directory_iterator>
+      delay_import_directories() const;
+  iterator_range<export_directory_iterator> export_directories() 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;
   template <typename coff_symbol_type>
   std::error_code getSymbol(uint32_t Index,
                             const coff_symbol_type *&Res) const {
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();
 
   imported_symbol_iterator imported_symbol_begin() const;
   imported_symbol_iterator imported_symbol_end() const;
+  iterator_range<imported_symbol_iterator> imported_symbols() const;
 
   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;
 
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;
+  iterator_range<imported_symbol_iterator> imported_symbols() const;
 
   std::error_code getName(StringRef &Result) const;
   std::error_code getDelayImportTable(
       const delay_import_directory_table_entry *&Result) const;
 
 private:
   const delay_import_directory_table_entry *Table;
   uint32_t Index;

lib/Object/COFFObjectFile.cpp

case COFF::IMAGE_FILE_MACHINE_AMD64:
     return Triple::x86_64;
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return Triple::thumb;
   default:
     return Triple::UnknownArch;
   }
 }
 
+iterator_range<import_directory_iterator>
+COFFObjectFile::import_directories() const {
+  return make_range(import_directory_begin(), import_directory_end());
+}
+
+iterator_range<delay_import_directory_iterator>
+COFFObjectFile::delay_import_directories() const {
+  return make_range(delay_import_directory_begin(),
+                    delay_import_directory_end());
+}
+
+iterator_range<export_directory_iterator>
+COFFObjectFile::export_directories() const {
+  return make_range(export_directory_begin(), export_directory_end());
+}
+
 std::error_code COFFObjectFile::getPE32Header(const pe32_header *&Res) const {
   Res = PE32Header;
   return object_error::success;
 }
 
 std::error_code
 COFFObjectFile::getPE32PlusHeader(const pe32plus_header *&Res) const {
   Res = PE32PlusHeader;

 }
 
 imported_symbol_iterator
 ImportDirectoryEntryRef::imported_symbol_end() const {
   return importedSymbolEnd(ImportTable[Index].ImportLookupTableRVA,
                            OwningObject);
 }
 
+iterator_range<imported_symbol_iterator>
+ImportDirectoryEntryRef::imported_symbols() const {
+  return make_range(imported_symbol_begin(), imported_symbol_end());
+}
+
 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));
   return object_error::success;
 }

 }
 
 imported_symbol_iterator
 DelayImportDirectoryEntryRef::imported_symbol_end() const {
   return importedSymbolEnd(Table[Index].DelayImportNameTable,
                            OwningObject);
 }
 
+iterator_range<imported_symbol_iterator>
+DelayImportDirectoryEntryRef::imported_symbols() const {
+  return make_range(imported_symbol_begin(), imported_symbol_end());
+}
+
 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;
 }
 

tools/llvm-readobj/COFFDumper.cpp

private:
   void printCodeViewLineTables(const SectionRef &Section);
 
   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);
+  void printImportedSymbols(iterator_range<imported_symbol_iterator> range);
 
   typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;
 
   const llvm::object::COFFObjectFile *Obj;
   RelocMapTy RelocMap;
   StringRef CVFileIndexToStringOffsetTable;
   StringRef CVStringTable;
 };
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) {
+void COFFDumper::printImportedSymbols(
+    iterator_range<imported_symbol_iterator> range) {
+  for (const ImportedSymbolRef &I : range) {
     StringRef Sym;
-    if (error(I->getSymbolName(Sym))) return;
+    if (error(I.getSymbolName(Sym))) return;
     uint16_t Ordinal;
-    if (error(I->getOrdinal(Ordinal))) return;
+    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) {
+  for (const ImportDirectoryEntryRef &I : Obj->import_directories()) {
     DictScope Import(W, "Import");
     StringRef Name;
-    if (error(I->getName(Name))) return;
+    if (error(I.getName(Name))) return;
     W.printString("Name", Name);
     uint32_t Addr;
-    if (error(I->getImportLookupTableRVA(Addr))) return;
+    if (error(I.getImportLookupTableRVA(Addr))) return;
     W.printHex("ImportLookupTableRVA", Addr);
-    if (error(I->getImportAddressTableRVA(Addr))) return;
+    if (error(I.getImportAddressTableRVA(Addr))) return;
     W.printHex("ImportAddressTableRVA", Addr);
-    printImportedSymbols(I->imported_symbol_begin(), I->imported_symbol_end());
+    printImportedSymbols(I.imported_symbols());
   }
 
   // Delay imports
-  for (auto I = Obj->delay_import_directory_begin(),
-            E = Obj->delay_import_directory_end();
-       I != E; ++I) {
+  for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) {
     DictScope Import(W, "DelayImport");
     StringRef Name;
-    if (error(I->getName(Name))) return;
+    if (error(I.getName(Name))) return;
     W.printString("Name", Name);
     const delay_import_directory_table_entry *Table;
-    if (error(I->getDelayImportTable(Table))) return;
+    if (error(I.getDelayImportTable(Table))) return;
     W.printHex("Attributes", Table->Attributes);
     W.printHex("ModuleHandle", Table->ModuleHandle);
     W.printHex("ImportAddressTable", Table->DelayImportAddressTable);
     W.printHex("ImportNameTable", Table->DelayImportNameTable);
     W.printHex("BoundDelayImportTable", Table->BoundDelayImportTable);
     W.printHex("UnloadDelayImportTable", Table->UnloadDelayImportTable);
-    printImportedSymbols(I->imported_symbol_begin(), I->imported_symbol_end());
+    printImportedSymbols(I.imported_symbols());
   }
 }
 
 void COFFDumper::printCOFFDirectives() {
   for (const SectionRef &Section : Obj->sections()) {
     StringRef Contents;
     StringRef Name;
 
     if (error(Section.getName(Name)))
       continue;
     if (Name != ".drectve")
       continue;
 
     if (error(Section.getContents(Contents)))
       return;
 
     W.printString("Directive(s)", Contents);
   }
 }
-