Extend llvm-objdump to support FatBins

  add option --offload-fatbin

SWDEV-333176 - Shift functionality of 'roc-obj-*' perl scripts into
llvm-objdump

Change-Id: Ibc865f80e30aa1a6e5495ecfe617be68a5e15fcf

Author: dsalinas

llvm/include/llvm/Object/OffloadBinary.h

@@ -210,60 +210,76 @@ class OffloadFile : public OwningBinary<OffloadBinary> {
   }
 };
 
+struct BundleEntry {
+  uint64_t Offset = 0u;
+  uint64_t Size = 0u;
+  uint64_t IDLength = 0u;
+  StringRef ID;
+  BundleEntry(uint64_t O, uint64_t S, uint64_t I, StringRef T)
+      : Offset(O), Size(S), IDLength(I), ID(T) {}
+  void dumpInfo(raw_ostream &OS) {
+    OS << "Offset = " << Offset << ", Size = " << Size
+       << ", ID Length = " << IDLength << ", ID = " << ID;
+  }
+  void dumpURI(raw_ostream &OS, StringRef filePath) {
+    OS << ID.data() << "\tfile:\/\/" << filePath << "#offset=" << Offset
+       << "&size=" << Size << "\n";
+  }
+};
+
 class OffloadFatBinBundle {
 
 private:
   uint64_t Size = 0u;
   StringRef FileName;
-  int64_t NumberOfEntries;
+  uint64_t NumberOfEntries;
+  SmallVector<BundleEntry> Entries;
 
 public:
-  struct BundleEntry {
-    uint64_t Offset = 0u;
-    uint64_t Size = 0u;
-    uint64_t IDLength = 0u;
-    StringRef ID;
-    BundleEntry(uint64_t O, uint64_t S, uint64_t I, StringRef T)
-        : Offset(O), Size(S), IDLength(I), ID(T) {}
-    void dump(raw_ostream &OS) {
-      OS << "Offset = " << Offset << ", Size = " << Size
-         << ", ID Length = " << IDLength << ", ID = " << ID;
-    }
-    void dumpURI(raw_ostream &OS, StringRef filePath) {
-      OS << ID.data() << "\tfile:\/\/" << filePath << "#offset=" << Offset
-         << "&size=" << Size << "\n";
-    }
-  };
-
+  SmallVector<BundleEntry> getEntries() { return Entries; }
   uint64_t getSize() const { return Size; }
   StringRef getFileName() const { return FileName; }
-  int64_t getNumEntries() const { return NumberOfEntries; }
+  uint64_t getNumEntries() const { return NumberOfEntries; }
 
-  std::unique_ptr<SmallVector<BundleEntry>> Entries;
   static Expected<std::unique_ptr<OffloadFatBinBundle>>
   create(MemoryBufferRef, uint64_t SectionOffset, StringRef fileName);
   Error extractBundle(const ObjectFile &Source);
 
+  Error DumpEntryToCodeObject();
+
   Error ReadEntries(StringRef Section, uint64_t SectionOffset);
   void DumpEntries() {
-    SmallVectorImpl<BundleEntry>::iterator it = Entries->begin();
-    for (int64_t I = 0; I < Entries->size(); I++) {
-      it->dump(outs());
+    SmallVectorImpl<BundleEntry>::iterator it = Entries.begin();
+    for (uint64_t I = 0; I < Entries.size(); I++) {
+      it->dumpInfo(outs());
       ++it;
     }
   }
 
   void PrintEntriesAsURI() {
-    SmallVectorImpl<BundleEntry>::iterator it = Entries->begin();
-    for (int64_t I = 0; I < NumberOfEntries; I++) {
+    SmallVectorImpl<BundleEntry>::iterator it = Entries.begin();
+    for (uint64_t I = 0; I < NumberOfEntries; I++) {
       it->dumpURI(outs(), FileName);
       ++it;
     }
   }
 
   OffloadFatBinBundle(MemoryBufferRef Source, StringRef file) : FileName(file) {
     NumberOfEntries = 0;
-    Entries = std::make_unique<SmallVector<BundleEntry>>();
+    Entries = SmallVector<BundleEntry>();
+  }
+
+  SmallVector<BundleEntry> EntryIDContains(StringRef str) {
+    SmallVector<BundleEntry> found = SmallVector<BundleEntry>();
+    SmallVectorImpl<BundleEntry>::iterator it = Entries.begin();
+    for (uint64_t I = 0; I < NumberOfEntries; I++) {
+      if (it->ID.contains(str)) {
+        found.push_back(*it);
+      }
+
+      ++it;
+    }
+    return found;
   }
 };
 

llvm/lib/Object/ObjectFile.cpp

@@ -212,7 +212,6 @@ ObjectFile::createObjectFile(StringRef ObjectPath) {
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> Buffer = std::move(FileOrErr.get());
-
   Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
       createObjectFile(Buffer->getMemBufferRef());
   if (Error Err = ObjOrErr.takeError())

llvm/lib/Object/OffloadBinary.cpp

@@ -18,7 +18,6 @@
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/Binary.h"
-#include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/Error.h"
@@ -36,8 +35,8 @@ using namespace llvm::object;
 namespace {
 
 static llvm::TimerGroup
-    ClangOffloadBundlerTimerGroup("Clang Offload Bundler Timer Group",
-                                  "Timer group for clang offload bundler");
+    OffloadBundlerTimerGroup("Offload Bundler Timer Group",
+                             "Timer group for offload bundler");
 
 /// Attempts to extract all the embedded device images contained inside the
 /// buffer \p Contents. The buffer is expected to contain a valid offloading
@@ -107,7 +106,7 @@ Error extractFromObject(const ObjectFile &Obj,
   return Error::success();
 }
 
-// Extract an Offload bundle (usually a Clang Offload Bundle) from a fat_bin
+// Extract an Offload bundle (usually a Offload Bundle) from a fat_bin
 // section
 Error extractOffloadBundle(MemoryBufferRef Contents, uint64_t SectionOffset,
                            StringRef fileName,
@@ -267,10 +266,10 @@ Error OffloadFatBinBundle::ReadEntries(StringRef Buffer,
     }
 
     // create a Bundle Entry object:
-    auto entry = new OffloadFatBinBundle::BundleEntry(
-        EntryOffset + SectionOffset, EntrySize, EntryIDSize, EntryID);
+    auto entry = new BundleEntry(EntryOffset + SectionOffset, EntrySize,
+                                 EntryIDSize, EntryID);
 
-    Entries->push_back(*entry);
+    Entries.push_back(*entry);
   } // end of for loop
 
   return Error::success();
@@ -298,8 +297,7 @@ OffloadFatBinBundle::create(MemoryBufferRef Buf, uint64_t SectionOffset,
 
 Error OffloadFatBinBundle::extractBundle(const ObjectFile &Source) {
   // This will extract all entries in the Bundle
-  SmallVectorImpl<OffloadFatBinBundle::BundleEntry>::iterator it =
-      Entries->begin();
+  SmallVectorImpl<BundleEntry>::iterator it = Entries.begin();
   for (int64_t I = 0; I < getNumEntries(); I++) {
 
     if (it->Size > 0) {
@@ -467,10 +465,6 @@ Error object::extractFatBinaryFromObject(
       } else if (Obj.isCOFF()) {
         if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj)) {
           const coff_section *CoffSection = COFFObj->getCOFFSection(Sec);
-          fprintf(
-              stderr, "DAVE: COFF viritual address =0x%llX\n",
-              CoffSection
-                  ->VirtualAddress); // COFFObj->getCOFFSection(Sec)->VirtualAddress);
         }
       }
 
@@ -698,7 +692,7 @@ CompressedOffloadBundle::decompress(llvm::MemoryBufferRef &Input,
                              "Unknown compressing method");
 
   llvm::Timer DecompressTimer("Decompression Timer", "Decompression time",
-                              ClangOffloadBundlerTimerGroup);
+                              OffloadBundlerTimerGroup);
   if (Verbose)
     DecompressTimer.startTimer();
 
@@ -720,7 +714,7 @@ CompressedOffloadBundle::decompress(llvm::MemoryBufferRef &Input,
     // Recalculate MD5 hash for integrity check
     llvm::Timer HashRecalcTimer("Hash Recalculation Timer",
                                 "Hash recalculation time",
-                                ClangOffloadBundlerTimerGroup);
+                                OffloadBundlerTimerGroup);
     HashRecalcTimer.startTimer();
     llvm::MD5 Hash;
     llvm::MD5::MD5Result Result;
@@ -775,7 +769,7 @@ CompressedOffloadBundle::compress(llvm::compression::Params P,
                              "Compression not supported");
 
   llvm::Timer HashTimer("Hash Calculation Timer", "Hash calculation time",
-                        ClangOffloadBundlerTimerGroup);
+                        OffloadBundlerTimerGroup);
   if (Verbose)
     HashTimer.startTimer();
   llvm::MD5 Hash;
@@ -792,7 +786,7 @@ CompressedOffloadBundle::compress(llvm::compression::Params P,
       Input.getBuffer().size());
 
   llvm::Timer CompressTimer("Compression Timer", "Compression time",
-                            ClangOffloadBundlerTimerGroup);
+                            OffloadBundlerTimerGroup);
   if (Verbose)
     CompressTimer.startTimer();
   llvm::compression::compress(P, BufferUint8, CompressedBuffer);