Extend llvm-objdump to support clang offload fat bins

  extend option --offloading

Change-Id: Ibc865f80e30aa1a6e5495ecfe617be68a5e15fcf

Author: dsalinas

llvm/docs/CommandGuide/llvm-objdump.rst

@@ -217,7 +217,7 @@ OPTIONS
 
 .. option:: --offloading
 
-  Display the content of the LLVM offloading section.
+  Display the content of the LLVM offloading sections and HIP offload bundles.
 
 .. option:: --prefix=<prefix>
 

llvm/include/llvm/Object/OffloadBundle.h

@@ -1,19 +1,18 @@
-//===--- OffloadBundle.h - Utilities for handling offloading code -*- C++
-//-*-===//
+//===- OffloadBundle.h - Utilities for offload bundles---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-//===------------------------------------------------------------------------===//
+//===-------------------------------------------------------------------------===//
 //
 // This file contains the binary format used for budingling device metadata with
 // an associated device image. The data can then be stored inside a host object
 // file to create a fat binary and read by the linker. This is intended to be a
 // thin wrapper around the image itself. If this format becomes sufficiently
 // complex it should be moved to a standard binary format like msgpack or ELF.
 //
-//===------------------------------------------------------------------------===//
+//===-------------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_OFFLOADBUNDLE_H
 #define LLVM_OBJECT_OFFLOADBUNDLE_H
@@ -109,16 +108,6 @@ class OffloadBundleFatBin {
   OffloadBundleFatBin(MemoryBufferRef Source, StringRef File)
       : FileName(File), NumberOfEntries(0),
         Entries(SmallVector<OffloadBundleEntry>()) {}
-
-  SmallVector<OffloadBundleEntry> entryIDContains(StringRef Str) {
-
-    SmallVector<OffloadBundleEntry> Found = SmallVector<OffloadBundleEntry>();
-    llvm::transform(Entries, std::back_inserter(Found), [Str](auto &X) {
-      if (X.ID.contains(Str))
-        return X;
-    });
-    return Found;
-  }
 };
 
 enum UriTypeT { FILE_URI, MEMORY_URI };
@@ -146,9 +135,6 @@ struct OffloadBundleURI {
     case MEMORY_URI:
       return createMemoryURI(Str);
       break;
-    default:
-      return createStringError(object_error::parse_failed,
-                               "Unrecognized URI type");
     }
   }
 
@@ -180,7 +166,7 @@ struct OffloadBundleURI {
     Str.getAsInteger(10, S);
     std::unique_ptr<OffloadBundleURI> OffloadingURI(
         new OffloadBundleURI(FilePathname, O, S));
-    return OffloadingURI;
+    return std::move(OffloadingURI);
   }
 
   static Expected<std::unique_ptr<OffloadBundleURI>>

llvm/lib/Object/OffloadBundle.cpp

@@ -1,11 +1,10 @@
-//===- OffloadBundle.cpp - Utilities for handling offloading code  -*- C++
-//-*-===//
+//===- OffloadBundle.cpp - Utilities for offload bundles---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------===//
 
 #include "llvm/Object/OffloadBundle.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -79,9 +78,8 @@ Error OffloadBundleFatBin::readEntries(StringRef Buffer,
 
   // Read the Magic String first.
   StringRef Magic;
-  if (auto EC = Reader.readFixedString(Magic, 24)) {
+  if (auto EC = Reader.readFixedString(Magic, 24))
     return errorCodeToError(object_error::parse_failed);
-  }
 
   // Read the number of Code Objects (Entries) in the current Bundle.
   if (auto EC = Reader.readInteger(NumOfEntries))
@@ -108,9 +106,8 @@ Error OffloadBundleFatBin::readEntries(StringRef Buffer,
     if (auto EC = Reader.readFixedString(EntryID, EntryIDSize))
       return errorCodeToError(object_error::parse_failed);
 
-    // create a Bundle Entry object:
-    auto Entry = new OffloadBundleEntry(EntryOffset + SectionOffset, EntrySize,
-                                        EntryIDSize, EntryID);
+    auto Entry = std::make_unique<OffloadBundleEntry>(
+        EntryOffset + SectionOffset, EntrySize, EntryIDSize, EntryID);
 
     Entries.push_back(*Entry);
   }
@@ -142,15 +139,16 @@ Error OffloadBundleFatBin::extractBundle(const ObjectFile &Source) {
   // This will extract all entries in the Bundle
   for (OffloadBundleEntry &Entry : Entries) {
 
-    if (Entry.Size > 0) {
-      // create output file name. Which should be
-      // <fileName>-offset<Offset>-size<Size>.co"
-      std::string Str = getFileName().str() + "-offset" + itostr(Entry.Offset) +
-                        "-size" + itostr(Entry.Size) + ".co";
-      if (Error Err = object::extractCodeObject(Source, Entry.Offset,
-                                                Entry.Size, StringRef(Str)))
-        return Err;
-    }
+    if (Entry.Size == 0)
+      continue;
+
+    // create output file name. Which should be
+    // <fileName>-offset<Offset>-size<Size>.co"
+    std::string Str = getFileName().str() + "-offset" + itostr(Entry.Offset) +
+                      "-size" + itostr(Entry.Size) + ".co";
+    if (Error Err = object::extractCodeObject(Source, Entry.Offset, Entry.Size,
+                                              StringRef(Str)))
+      return Err;
   }
 
   return Error::success();
@@ -160,7 +158,7 @@ Error object::extractOffloadBundleFatBinary(
     const ObjectFile &Obj, SmallVectorImpl<OffloadBundleFatBin> &Bundles) {
   assert((Obj.isELF() || Obj.isCOFF()) && "Invalid file type");
 
-  // iterate through Sections until we find an offload_bundle section.
+  // Iterate through Sections until we find an offload_bundle section.
   for (SectionRef Sec : Obj.sections()) {
     Expected<StringRef> Buffer = Sec.getContents();
     if (!Buffer)
@@ -174,11 +172,9 @@ Error object::extractOffloadBundleFatBinary(
       uint64_t SectionOffset = 0;
       if (Obj.isELF()) {
         SectionOffset = ELFSectionRef(Sec).getOffset();
-      } else if (Obj.isCOFF()) {
-        if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj)) {
-          const coff_section *CoffSection = COFFObj->getCOFFSection(Sec);
-        }
-      }
+      } else if (Obj.isCOFF()) // TODO: add COFF Support
+        return createStringError(object_error::parse_failed,
+                                 "COFF object files not supported.\n");
 
       MemoryBufferRef Contents(*Buffer, Obj.getFileName());
 
@@ -341,7 +337,7 @@ CompressedOffloadBundle::decompress(llvm::MemoryBufferRef &Input,
     double DecompressionTimeSeconds =
         DecompressTimer.getTotalTime().getWallTime();
 
-    // Recalculate MD5 hash for integrity check
+    // Recalculate MD5 hash for integrity check.
     llvm::Timer HashRecalcTimer("Hash Recalculation Timer",
                                 "Hash recalculation time",
                                 OffloadBundlerTimerGroup);

llvm/test/tools/llvm-objdump/Offloading/fatbin.test

@@ -14,12 +14,16 @@
 #include "OffloadDump.h"
 #include "llvm-objdump.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/OffloadBinary.h"
+#include "llvm/Object/OffloadBundle.h"
 #include "llvm/Support/Alignment.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;
 
+void disassembleObject(llvm::object::ObjectFile *, bool InlineRelocs);
+
 /// Get the printable name of the image kind.
 static StringRef getImageName(const OffloadBinary &OB) {
   switch (OB.getImageKind()) {
@@ -48,7 +52,7 @@ static void printBinary(const OffloadBinary &OB, uint64_t Index) {
 }
 
 /// Print the embedded offloading contents of an ObjectFile \p O.
-void llvm::dumpOffloadBinary(const ObjectFile &O) {
+void llvm::dumpOffloadBinary(const ObjectFile &O, StringRef ArchName) {
   if (!O.isELF() && !O.isCOFF()) {
     reportWarning(
         "--offloading is currently only supported for COFF and ELF targets",
@@ -64,6 +68,44 @@ void llvm::dumpOffloadBinary(const ObjectFile &O) {
   // Print out all the binaries that are contained in this buffer.
   for (uint64_t I = 0, E = Binaries.size(); I != E; ++I)
     printBinary(*Binaries[I].getBinary(), I);
+
+  dumpOffloadBundleFatBinary(O, ArchName);
+}
+
+// Given an Object file, collect all Bundles of FatBin Binaries
+// and dump them into Code Object files
+// if -arch=-name is specified, only dump the Entries that match the target arch
+void llvm::dumpOffloadBundleFatBinary(const ObjectFile &O, StringRef ArchName) {
+  if (!O.isELF() && !O.isCOFF()) {
+    reportWarning(
+        "--offloading is currently only supported for COFF and ELF targets",
+        O.getFileName());
+    return;
+  }
+
+  SmallVector<llvm::object::OffloadBundleFatBin> FoundBundles;
+
+  if (Error Err = llvm::object::extractOffloadBundleFatBinary(O, FoundBundles))
+    reportError(O.getFileName(), "while extracting offload FatBin bundles: " +
+                                     toString(std::move(Err)));
+
+  for (const auto &[BundleNum, Bundle] : llvm::enumerate(FoundBundles)) {
+    for (OffloadBundleEntry &Entry : Bundle.getEntries()) {
+      if (!ArchName.empty() && !Entry.ID.contains(ArchName))
+        continue;
+
+      // create file name for this object file:  <source-filename>.<Bundle
+      // Number>.<EntryID>
+      std::string str = Bundle.getFileName().str() + "." + itostr(BundleNum) +
+                        "." + Entry.ID.str();
+      if (Error Err = object::extractCodeObject(O, Entry.Offset, Entry.Size,
+                                                StringRef(str)))
+        reportError(O.getFileName(),
+                    "while extracting offload Bundle Entries: " +
+                        toString(std::move(Err)));
+      outs() << "Extracting offload bundle: " << str << "\n";
+    }
+  }
 }
 
 /// Print the contents of an offload binary file \p OB. This may contain

llvm/tools/llvm-objdump/OffloadDump.cpp

@@ -11,12 +11,16 @@
 
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/OffloadBinary.h"
+#include "llvm/Object/OffloadBundle.h"
 
 namespace llvm {
 
 void dumpOffloadSections(const object::OffloadBinary &OB);
-void dumpOffloadBinary(const object::ObjectFile &O);
+void dumpOffloadBinary(const object::ObjectFile &O, StringRef ArchName);
 
+/// Dump fat binary in binary clang-offload-bundler format
+void dumpOffloadBundleFatBinary(const object::ObjectFile &O,
+                                StringRef ArchName);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objdump/OffloadDump.h

@@ -56,6 +56,7 @@
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/OffloadBinary.h"
+#include "llvm/Object/OffloadBundle.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
@@ -3338,7 +3339,7 @@ static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
   if (FaultMapSection)
     printFaultMaps(O);
   if (Offloading)
-    dumpOffloadBinary(*O);
+    dumpOffloadBinary(*O, StringRef(ArchName));
 }
 
 static void dumpObject(const COFFImportFile *I, const Archive *A,

llvm/tools/llvm-objdump/llvm-objdump.cpp

@@ -1,7 +1,11 @@
+// Skip running on Windows.
+#if !defined(_WIN32)
+
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Object/OffloadBundle.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Testing/Support/Error.h"
@@ -11,27 +15,7 @@
 using namespace llvm;
 using namespace llvm::object;
 
-// ELF Object creation
-static Expected<std::unique_ptr<ObjectFile>>
-toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
-  raw_svector_ostream OS(Storage);
-  yaml::Input YIn(Yaml);
-  if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
-    return createStringError(std::errc::invalid_argument,
-                             "unable to convert YAML");
-  return object::ObjectFile::createELFObjectFile(
-      MemoryBufferRef(OS.str(), "dummyELF"));
-}
-
-TEST(OffloadingBundleTest, checkOffloadingFatBinary) {
-
-  // create a Memory Buffer with a fatbin offloading section
-  MemoryBufferRef mbuf;
-  StringRef FileName;
-  SmallVector<OffloadBundleEntry>();
-  SmallString<0> Storage;
-  // Expected<ELFObjectFile<ELF64LE>> ObjOrErr = toBinary<ELF64LE>(Storage, R"(
-  Expected<std::unique_ptr<ObjectFile>> ObjOrErr = toBinary(Storage, R"(
+StringRef simpleAdd = R"(
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
@@ -52,11 +36,54 @@ TEST(OffloadingBundleTest, checkOffloadingFatBinary) {
     Address:         0x202FD0
     AddressAlign:    0x8
     Content:         '465049480100000000102000000000000000000000000000'
-)");
+)";
+
+// ELF Object creation
+static Expected<std::unique_ptr<ObjectFile>>
+toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
+  raw_svector_ostream OS(Storage);
+  yaml::Input YIn(Yaml);
+  if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
+    return createStringError(std::errc::invalid_argument,
+                             "unable to convert YAML");
+  return object::ObjectFile::createELFObjectFile(
+      MemoryBufferRef(OS.str(), "dummyELF"));
+}
+
+TEST(OffloadingBundleTest, checkExtractOffloadBundleFatBinary) {
+
+  // create a Memory Buffer with a fatbin offloading section
+  MemoryBufferRef mbuf;
+  StringRef FileName;
+  SmallVector<OffloadBundleEntry>();
+  SmallString<0> Storage;
+  // Expected<ELFObjectFile<ELF64LE>> ObjOrErr = toBinary<ELF64LE>(Storage, R"(
+  Expected<std::unique_ptr<ObjectFile>> ObjOrErr = toBinary(Storage, simpleAdd);
 
   ASSERT_THAT_EXPECTED(ObjOrErr, Succeeded());
 
   SmallVector<llvm::object::OffloadBundleFatBin> Bundles;
   Error Err = extractOffloadBundleFatBinary(**ObjOrErr, Bundles);
   EXPECT_FALSE(errorToBool(std::move(Err)));
 }
+
+TEST(OffloadingBundleTest, checkExtractCodeObject) {
+  // create a Memory Buffer with a fatbin offloading section
+  MemoryBufferRef mbuf;
+  StringRef FileName;
+  SmallVector<OffloadBundleEntry>();
+  SmallString<0> Storage;
+  // Expected<ELFObjectFile<ELF64LE>> ObjOrErr = toBinary<ELF64LE>(Storage, R"(
+  Expected<std::unique_ptr<ObjectFile>> ObjOrErr = toBinary(Storage, simpleAdd);
+
+  ASSERT_THAT_EXPECTED(ObjOrErr, Succeeded());
+
+  int64_t Offset = 8192;
+  int64_t Size = 4048;
+
+  Error Err = extractCodeObject(**ObjOrErr, Offset, Size,
+                                StringRef("checkExtractCodeObject.co"));
+  EXPECT_FALSE(errorToBool(std::move(Err)));
+}
+
+#endif