[clang-offload-bundler] Library-ize ClangOffloadBundler (2/4)

[lamb-j]

Summary

Lifting the core functionalities of the clang-offload-bundler into a
user-facing library/API.

This patch (2/4) introduces a Config class that locally stores the
previously global cl::opt options and arrays. This localization
will allow users to call the APIs in a multi-threaded context. This
patch also introduces an OffloadBundler class to encapsulate the
top-level API functions.

[lamb-j]

Abandoned in favor of combined patch: https://reviews.llvm.org/D129873

clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp

 #include <string>
 #include <system_error>
 #include <utility>
 #include "OffloadBundler.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
+static void PrintVersion(raw_ostream &OS) {
+  OS << clang::getClangToolFullVersion("clang-offload-bundler") << '\n';
+}
+
+int main(int argc, const char **argv) {
   static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
 
-// Mark all our options with this category, everything else (except for -version
-// and -help) will be hidden.
+  // Mark all our options with this category, everything else (except for
+  // -version and -help) will be hidden.
   cl::OptionCategory
     ClangOffloadBundlerCategory("clang-offload-bundler options");
   cl::list<std::string>
     InputFileNames("input", cl::ZeroOrMore,
                    cl::desc("Input file."
                             " Can be specified multiple times "
                             "for multiple input files."),
                    cl::cat(ClangOffloadBundlerCategory));
-static cl::list<std::string>
+  cl::list<std::string>
     InputFileNamesDeprecatedOpt("inputs", cl::CommaSeparated, cl::ZeroOrMore,
                                 cl::desc("[<input file>,...] (deprecated)"),
                                 cl::cat(ClangOffloadBundlerCategory));
   cl::list<std::string>
     OutputFileNames("output", cl::ZeroOrMore,
                     cl::desc("Output file."
                              " Can be specified multiple times "
                              "for multiple output files."),
                     cl::cat(ClangOffloadBundlerCategory));
-static cl::list<std::string>
+  cl::list<std::string>
     OutputFileNamesDeprecatedOpt("outputs", cl::CommaSeparated, cl::ZeroOrMore,
                                  cl::desc("[<output file>,...] (deprecated)"),
                                  cl::cat(ClangOffloadBundlerCategory));
   cl::list<std::string>
     TargetNames("targets", cl::CommaSeparated,
                 cl::desc("[<offload kind>-<target triple>,...]"),
                 cl::cat(ClangOffloadBundlerCategory));
   cl::opt<std::string>
     FilesType("type", cl::Required,
               cl::desc("Type of the files to be bundled/unbundled.\n"
                        "Current supported types are:\n"
                        "  i   - cpp-output\n"
                        "  ii  - c++-cpp-output\n"
                        "  cui - cuda/hip-output\n"
                        "  d   - dependency\n"
                        "  ll  - llvm\n"
                        "  bc  - llvm-bc\n"
                        "  s   - assembler\n"
                        "  o   - object\n"
                        "  a   - archive of objects\n"
                        "  gch - precompiled-header\n"
                        "  ast - clang AST file"),
               cl::cat(ClangOffloadBundlerCategory));
   cl::opt<bool>
     Unbundle("unbundle",
              cl::desc("Unbundle bundled file into several output files.\n"),
              cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 
   cl::opt<bool>
     ListBundleIDs("list", cl::desc("List bundle IDs in the bundled file.\n"),
                   cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 
   cl::opt<bool> PrintExternalCommands(
     "###",
     cl::desc("Print any external commands that are to be executed "
              "instead of actually executing them - for testing purposes.\n"),
     cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 
   cl::opt<bool>
     AllowMissingBundles("allow-missing-bundles",
                         cl::desc("Create empty files if bundles are missing "
                                  "when unbundling.\n"),
                         cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 
   cl::opt<unsigned>
     BundleAlignment("bundle-align",
                     cl::desc("Alignment of bundle for binary files"),
                     cl::init(1), cl::cat(ClangOffloadBundlerCategory));
 
   cl::opt<bool> HipOpenmpCompatible(
     "hip-openmp-compatible",
     cl::desc("Treat hip and hipv4 offload kinds as "
              "compatible with openmp kind, and vice versa.\n"),
     cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 
   /// The index of the host input in the list of inputs.
   unsigned HostInputIndex = ~0u;
 
-/// Whether not having host target is allowed.
-bool AllowNoHost = false;
-
-/// Path to the current binary.
-std::string BundlerExecutable;
-
-static void PrintVersion(raw_ostream &OS) {
-  OS << clang::getClangToolFullVersion("clang-offload-bundler") << '\n';
-}
-
-int main(int argc, const char **argv) {
+  // Process commandline options and report errors
   sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   cl::HideUnrelatedOptions(ClangOffloadBundlerCategory);
   cl::SetVersionPrinter(PrintVersion);
   cl::ParseCommandLineOptions(
       argc, argv,
       "A tool to bundle several input files of the specified type <type> \n"
       "referring to the same source file but different targets into a single \n"
       "one. The resulting file can also be unbundled into different files by \n"
       "this tool if -unbundle is provided.\n");
 
   if (Help) {
     cl::PrintHelpMessage();
     return 0;
   }
 
   auto reportError = [argv](Error E) {
     logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
     exit(1);
   };
 
   auto doWork = [&](std::function<llvm::Error()> Work) {
-    // Save the current executable directory as it will be useful to find other
-    // tools.
-    BundlerExecutable = argv[0];
-    if (!llvm::sys::fs::exists(BundlerExecutable))
-      BundlerExecutable =
-          sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
-
     if (llvm::Error Err = Work()) {
       reportError(std::move(Err));
     }
   };
 
   auto warningOS = [argv]() -> raw_ostream & {
     return WithColor::warning(errs(), StringRef(argv[0]));
   };
 
+  // Save the current executable directory as it will be useful to find other
+  // tools.
+  std::string BundlerExecutable = argv[0];
+  if (!llvm::sys::fs::exists(BundlerExecutable))
+    BundlerExecutable =
+      sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
+
   if (InputFileNames.getNumOccurrences() != 0 &&
       InputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
     reportError(createStringError(
         errc::invalid_argument,
         "-inputs and -input cannot be used together, use only -input instead"));
   }
 
   if (InputFileNamesDeprecatedOpt.size()) {
if (OutputFileNames.size()) {
       reportError(createStringError(errc::invalid_argument,
                                     "-outputs option is invalid for -list"));
     }
     if (TargetNames.size()) {
       reportError(createStringError(errc::invalid_argument,
                                     "-targets option is invalid for -list"));
     }
 
-    doWork([]() { return ListBundleIDsInFile(InputFileNames.front()); });
+    Config BundlerPrint;
+    BundlerPrint.PrintExternalCommands = PrintExternalCommands;
+    BundlerPrint.BundlerExecutable = BundlerExecutable;
+    doWork([&]() { return ListBundleIDsInFile(InputFileNames.front(),
+                                             &BundlerPrint); });
     return 0;
   }
 
   if (OutputFileNames.size() == 0) {
     reportError(
         createStringError(errc::invalid_argument, "no output file specified!"));
   }
 
int main(int argc, const char **argv) {
   llvm::DenseSet<StringRef> ParsedTargets;
   for (StringRef Target : TargetNames) {
     if (ParsedTargets.contains(Target)) {
       reportError(createStringError(errc::invalid_argument,
                                     "Duplicate targets are not allowed"));
     }
     ParsedTargets.insert(Target);
 
-    auto OffloadInfo = OffloadTargetInfo(Target);
+    Config BundlerOpenmp;
+    BundlerOpenmp.HipOpenmpCompatible = HipOpenmpCompatible;
+    BundlerOpenmp.BundlerExecutable = BundlerExecutable;
+    auto OffloadInfo = OffloadTargetInfo(Target, &BundlerOpenmp);
     bool KindIsValid = OffloadInfo.isOffloadKindValid();
     bool TripleIsValid = OffloadInfo.isTripleValid();
 
     if (!KindIsValid || !TripleIsValid) {
       SmallVector<char, 128u> Buf;
       raw_svector_ostream Msg(Buf);
       Msg << "invalid target '" << Target << "'";
       if (!KindIsValid)
if (OffloadInfo.OffloadKind != "hip" && OffloadInfo.OffloadKind != "hipv4")
       HIPOnly = false;
 
     ++Index;
   }
 
   // HIP uses clang-offload-bundler to bundle device-only compilation results
   // for multiple GPU archs, therefore allow no host target if all entries
   // are for HIP.
-  AllowNoHost = HIPOnly;
+  bool AllowNoHost = HIPOnly;
 
   // Host triple is not really needed for unbundling operation, so do not
   // treat missing host triple as error if we do unbundling.
   if ((Unbundle && HostTargetNum > 1) ||
       (!Unbundle && HostTargetNum != 1 && !AllowNoHost)) {
     reportError(createStringError(errc::invalid_argument,
                                   "expecting exactly one host target but got " +
                                       Twine(HostTargetNum)));
   }
 
-  doWork([]() {
+  Config BundlerConfig;
+  BundlerConfig.AllowNoHost = AllowNoHost;
+  BundlerConfig.AllowMissingBundles = AllowMissingBundles;
+  BundlerConfig.PrintExternalCommands = PrintExternalCommands;
+  BundlerConfig.HipOpenmpCompatible = HipOpenmpCompatible;
+  BundlerConfig.BundleAlignment = BundleAlignment;
+  BundlerConfig.HostInputIndex = HostInputIndex;
+  BundlerConfig.FilesType = FilesType;
+  BundlerConfig.BundlerExecutable = BundlerExecutable;
+
+  BundlerConfig.TargetNames = TargetNames;
+  BundlerConfig.InputFileNames = InputFileNames;
+  BundlerConfig.OutputFileNames = OutputFileNames;
+
+  OffloadBundler Bundler(&BundlerConfig);
+
+  doWork([&]() {
     if (Unbundle) {
       if (FilesType == "a")
-        return UnbundleArchive();
+        return Bundler.UnbundleArchive();
       else
-        return UnbundleFiles();
+        return Bundler.UnbundleFiles();
     } else
-      return BundleFiles();
+      return Bundler.BundleFiles();
   });
   return 0;
 }

clang/tools/clang-offload-bundler/OffloadBundler.h

 /// single one. Also the implements the opposite functionality, i.e. unbundle
 /// files previous created by this tool.
 ///
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 using namespace llvm::object;
 
+class Config {
+public:
+  bool AllowNoHost = false;
+  bool AllowMissingBundles = false;
+  bool CheckInputArchive = false;
+  bool PrintExternalCommands = false;
+  bool HipOpenmpCompatible = false;
+
+  unsigned BundleAlignment = 1;
+  unsigned HostInputIndex = ~0u;
+
+  std::string FilesType;
+  std::string BundlerExecutable;
+
+  // TODO: Convert these to llvm::SmallVector
+  std::vector<std::string> TargetNames;
+  std::vector<std::string> InputFileNames;
+  std::vector<std::string> OutputFileNames;
+};
+
+class OffloadBundler {
+public:
+  Config *BundlerConfig;
+
+  // TODO: Add error checking from ClangOffloadBundler.cpp
+  OffloadBundler(Config *BC) : BundlerConfig(BC) {}
+
   Error BundleFiles();
   Error UnbundleFiles();
   Error UnbundleArchive();
+};
 
 /// Obtain the offload kind, real machine triple, and an optional GPUArch
 /// out of the target information specified by the user.
 /// Bundle Entry ID (or, Offload Target String) has following components:
 ///  * Offload Kind - Host, OpenMP, or HIP
 ///  * Triple - Standard LLVM Triple
 ///  * GPUArch (Optional) - Processor name, followed by set of ON/OFF features
 struct OffloadTargetInfo {
   StringRef OffloadKind;
   llvm::Triple Triple;
   StringRef GPUArch;
+  Config *BundlerConfig;
 
-  OffloadTargetInfo(const StringRef Target);
+  OffloadTargetInfo(const StringRef Target, Config *BC);
   bool hasHostKind() const;
   bool isOffloadKindValid() const;
   bool isOffloadKindCompatible(const StringRef TargetOffloadKind) const;
   bool isTripleValid() const;
   bool operator==(const OffloadTargetInfo &Target) const;
   std::string str();
 };
 
 // List bundle IDs. Return true if an error was found.
-Error ListBundleIDsInFile(StringRef InputFileName);
+Error ListBundleIDsInFile(StringRef InputFileName, Config *BundlerConfig);

clang/tools/clang-offload-bundler/OffloadBundler.cpp

 #include <system_error>
 #include <utility>
 
 #include "OffloadBundler.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
-extern cl::list<std::string> InputFileNames;
-extern cl::list<std::string> OutputFileNames;
-extern cl::list<std::string> TargetNames;
-extern cl::opt<std::string> FilesType;
-extern cl::opt<bool> PrintExternalCommands;
-extern cl::opt<bool> AllowMissingBundles;
-extern cl::opt<unsigned> BundleAlignment;
-extern cl::opt<bool> HipOpenmpCompatible;
-
 /// Magic string that marks the existence of offloading data.
 #define OFFLOAD_BUNDLER_MAGIC_STR "__CLANG_OFFLOAD_BUNDLE__"
 
-/// The index of the host input in the list of inputs.
-extern unsigned HostInputIndex;
-
-/// Whether not having host target is allowed.
-extern bool AllowNoHost;
-
-/// Path to the current binary.
-extern std::string BundlerExecutable;
-
-OffloadTargetInfo::OffloadTargetInfo(const StringRef Target) {
+OffloadTargetInfo::OffloadTargetInfo(const StringRef Target, Config *BC) {
+  // TODO: Add error checking from ClangOffloadBundler.cpp
+  BundlerConfig = BC;
   auto TargetFeatures = Target.split(':');
   auto TripleOrGPU = TargetFeatures.first.rsplit('-');
 
   if (clang::StringToCudaArch(TripleOrGPU.second) !=
       clang::CudaArch::UNKNOWN) {
     auto KindTriple = TripleOrGPU.first.split('-');
     this->OffloadKind = KindTriple.first;
     this->Triple = llvm::Triple(KindTriple.second);

 bool OffloadTargetInfo::isOffloadKindValid() const {
   return OffloadKind == "host" || OffloadKind == "openmp" ||
     OffloadKind == "hip" || OffloadKind == "hipv4";
 }
 
 bool OffloadTargetInfo::isOffloadKindCompatible(const StringRef TargetOffloadKind) const {
   if (OffloadKind == TargetOffloadKind)
     return true;
-  if (HipOpenmpCompatible) {
+  if (BundlerConfig->HipOpenmpCompatible) {
     bool HIPCompatibleWithOpenMP =
       OffloadKind.startswith_insensitive("hip") &&
       TargetOffloadKind == "openmp";
     bool OpenMPCompatibleWithHIP =
       OffloadKind == "openmp" &&
       TargetOffloadKind.startswith_insensitive("hip");
     return HIPCompatibleWithOpenMP || OpenMPCompatibleWithHIP;
   }
class BinaryFileHandler final : public FileHandler {
 
   /// Iterator for the bundle information that is being read.
   StringMap<BinaryBundleInfo>::iterator CurBundleInfo;
   StringMap<BinaryBundleInfo>::iterator NextBundleInfo;
 
   /// Current bundle target to be written.
   std::string CurWriteBundleTarget;
 
+  /// Configuration options and arrays for this bundler job
+  Config *BundlerConfig;
+
 public:
-  BinaryFileHandler() {}
+  // TODO: Add error checking from ClangOffloadBundler.cpp
+  BinaryFileHandler(Config *BC) : BundlerConfig(BC) {}
 
   ~BinaryFileHandler() final {}
 
   Error ReadHeader(MemoryBuffer &Input) final {
     StringRef FC = Input.getBuffer();
 
     // Initialize the current bundle with the end of the container.
     CurBundleInfo = BundlesInfo.end();
public:
   Error WriteHeader(raw_fd_ostream &OS,
                     ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
     // Compute size of the header.
     uint64_t HeaderSize = 0;
 
     HeaderSize += sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1;
     HeaderSize += 8; // Number of Bundles
 
-    for (auto &T : TargetNames) {
+    for (auto &T : BundlerConfig->TargetNames) {
       HeaderSize += 3 * 8; // Bundle offset, Size of bundle and size of triple.
       HeaderSize += T.size(); // The triple.
     }
 
     // Write to the buffer the header.
     OS << OFFLOAD_BUNDLER_MAGIC_STR;
 
-    Write8byteIntegerToBuffer(OS, TargetNames.size());
+    Write8byteIntegerToBuffer(OS, BundlerConfig->TargetNames.size());
 
     unsigned Idx = 0;
-    for (auto &T : TargetNames) {
+    for (auto &T : BundlerConfig->TargetNames) {
       MemoryBuffer &MB = *Inputs[Idx++];
-      HeaderSize = alignTo(HeaderSize, BundleAlignment);
+      HeaderSize = alignTo(HeaderSize, BundlerConfig->BundleAlignment);
       // Bundle offset.
       Write8byteIntegerToBuffer(OS, HeaderSize);
       // Size of the bundle (adds to the next bundle's offset)
       Write8byteIntegerToBuffer(OS, MB.getBufferSize());
       BundlesInfo[T] = BinaryBundleInfo(MB.getBufferSize(), HeaderSize);
       HeaderSize += MB.getBufferSize();
       // Size of the triple
       Write8byteIntegerToBuffer(OS, T.size());
class ObjectFileHandler final : public FileHandler {
   /// Total number of processed inputs, i.e, inputs that were already
   /// read from the buffers.
   unsigned NumberOfProcessedInputs = 0;
 
   /// Iterator of the current and next section.
   section_iterator CurrentSection;
   section_iterator NextSection;
 
+  /// Configuration options and arrays for this bundler job
+  Config *BundlerConfig;
+
 public:
-  ObjectFileHandler(std::unique_ptr<ObjectFile> ObjIn)
+  // TODO: Add error checking from ClangOffloadBundler.cpp
+  ObjectFileHandler(std::unique_ptr<ObjectFile> ObjIn, Config *BC)
       : Obj(std::move(ObjIn)), CurrentSection(Obj->section_begin()),
-        NextSection(Obj->section_begin()) {}
+        NextSection(Obj->section_begin()), BundlerConfig(BC) {}
 
   ~ObjectFileHandler() final {}
 
   Error ReadHeader(MemoryBuffer &Input) final { return Error::success(); }
 
   Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
     while (NextSection != Obj->section_end()) {
       CurrentSection = NextSection;
if (Content.size() == 1u && Content.front() == 0)
       Content = StringRef(Input.getBufferStart(), Input.getBufferSize());
 
     OS.write(Content.data(), Content.size());
     return Error::success();
   }
 
   Error WriteHeader(raw_fd_ostream &OS,
                     ArrayRef<std::unique_ptr<MemoryBuffer>> Inputs) final {
-    assert(HostInputIndex != ~0u && "Host input index not defined.");
+    assert(BundlerConfig->HostInputIndex != ~0u && "Host input index not defined.");
 
     // Record number of inputs.
     NumberOfInputs = Inputs.size();
     return Error::success();
   }
 
   Error WriteBundleStart(raw_fd_ostream &OS, StringRef TargetTriple) final {
     ++NumberOfProcessedInputs;
     return Error::success();
   }
 
   Error WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     assert(NumberOfProcessedInputs <= NumberOfInputs &&
            "Processing more inputs that actually exist!");
-    assert(HostInputIndex != ~0u && "Host input index not defined.");
+    assert(BundlerConfig->HostInputIndex != ~0u && "Host input index not defined.");
 
     // If this is not the last output, we don't have to do anything.
     if (NumberOfProcessedInputs != NumberOfInputs)
       return Error::success();
 
     // We will use llvm-objcopy to add target objects sections to the output
     // fat object. These sections should have 'exclude' flag set which tells
     // link editor to remove them from linker inputs when linking executable or
     // shared library.
 
     // Find llvm-objcopy in order to create the bundle binary.
     ErrorOr<std::string> Objcopy = sys::findProgramByName(
-        "llvm-objcopy", sys::path::parent_path(BundlerExecutable));
+        "llvm-objcopy",
+  sys::path::parent_path(BundlerConfig->BundlerExecutable));
     if (!Objcopy)
       Objcopy = sys::findProgramByName("llvm-objcopy");
     if (!Objcopy)
       return createStringError(Objcopy.getError(),
                                "unable to find 'llvm-objcopy' in path");
 
     // We write to the output file directly. So, we close it and use the name
     // to pass down to llvm-objcopy.
     OS.close();
 
     // Temporary files that need to be removed.
     TempFileHandlerRAII TempFiles;
 
     // Compose llvm-objcopy command line for add target objects' sections with
     // appropriate flags.
     BumpPtrAllocator Alloc;
     StringSaver SS{Alloc};
     SmallVector<StringRef, 8u> ObjcopyArgs{"llvm-objcopy"};
     for (unsigned I = 0; I < NumberOfInputs; ++I) {
-      StringRef InputFile = InputFileNames[I];
-      if (I == HostInputIndex) {
+      StringRef InputFile = BundlerConfig->InputFileNames[I];
+      if (I == BundlerConfig->HostInputIndex) {
         // Special handling for the host bundle. We do not need to add a
         // standard bundle for the host object since we are going to use fat
         // object as a host object. Therefore use dummy contents (one zero byte)
         // when creating section for the host bundle.
         Expected<StringRef> TempFileOrErr = TempFiles.Create(ArrayRef<char>(0));
         if (!TempFileOrErr)
           return TempFileOrErr.takeError();
         InputFile = *TempFileOrErr;
       }
 
       ObjcopyArgs.push_back(SS.save(Twine("--add-section=") +
-                                    OFFLOAD_BUNDLER_MAGIC_STR + TargetNames[I] +
+                                    OFFLOAD_BUNDLER_MAGIC_STR +
+            BundlerConfig->TargetNames[I] +
                                     "=" + InputFile));
       ObjcopyArgs.push_back(SS.save(Twine("--set-section-flags=") +
-                                    OFFLOAD_BUNDLER_MAGIC_STR + TargetNames[I] +
+                                    OFFLOAD_BUNDLER_MAGIC_STR +
+            BundlerConfig->TargetNames[I] +
                                     "=readonly,exclude"));
     }
     ObjcopyArgs.push_back("--");
-    ObjcopyArgs.push_back(InputFileNames[HostInputIndex]);
-    ObjcopyArgs.push_back(OutputFileNames.front());
+    ObjcopyArgs.push_back(
+      BundlerConfig->InputFileNames[BundlerConfig->HostInputIndex]);
+    ObjcopyArgs.push_back(BundlerConfig->OutputFileNames.front());
 
     if (Error Err = executeObjcopy(*Objcopy, ObjcopyArgs))
       return Err;
 
     return Error::success();
   }
 
   Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     return Error::success();
   }
 
 private:
-  static Error executeObjcopy(StringRef Objcopy, ArrayRef<StringRef> Args) {
+  Error executeObjcopy(StringRef Objcopy, ArrayRef<StringRef> Args) {
     // If the user asked for the commands to be printed out, we do that
     // instead of executing it.
-    if (PrintExternalCommands) {
+    if (BundlerConfig->PrintExternalCommands) {
       errs() << "\"" << Objcopy << "\"";
       for (StringRef Arg : drop_begin(Args, 1))
         errs() << " \"" << Arg << "\"";
       errs() << "\n";
     } else {
       if (sys::ExecuteAndWait(Objcopy, Args))
         return createStringError(inconvertibleErrorCode(),
                                  "'llvm-objcopy' tool failed");
Error listBundleIDsCallback(MemoryBuffer &Input,
     return Error::success();
   }
 };
 
 /// Return an appropriate object file handler. We use the specific object
 /// handler if we know how to deal with that format, otherwise we use a default
 /// binary file handler.
 static std::unique_ptr<FileHandler>
-CreateObjectFileHandler(MemoryBuffer &FirstInput) {
+CreateObjectFileHandler(MemoryBuffer &FirstInput, Config *BundlerConfig) {
   // Check if the input file format is one that we know how to deal with.
   Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(FirstInput);
 
   // We only support regular object files. If failed to open the input as a
   // known binary or this is not an object file use the default binary handler.
   if (errorToBool(BinaryOrErr.takeError()) || !isa<ObjectFile>(*BinaryOrErr))
-    return std::make_unique<BinaryFileHandler>();
+    return std::make_unique<BinaryFileHandler>(BundlerConfig);
 
   // Otherwise create an object file handler. The handler will be owned by the
   // client of this function.
   return std::make_unique<ObjectFileHandler>(
-      std::unique_ptr<ObjectFile>(cast<ObjectFile>(BinaryOrErr->release())));
+      std::unique_ptr<ObjectFile>(cast<ObjectFile>(BinaryOrErr->release())),
+      BundlerConfig);
 }
 
 /// Return an appropriate handler given the input files and options.
 static Expected<std::unique_ptr<FileHandler>>
-CreateFileHandler(MemoryBuffer &FirstInput) {
+CreateFileHandler(MemoryBuffer &FirstInput, Config *BundlerConfig) {
+  std::string FilesType = BundlerConfig->FilesType;
+
   if (FilesType == "i")
     return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   if (FilesType == "ii")
     return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   if (FilesType == "cui")
     return std::make_unique<TextFileHandler>(/*Comment=*/"//");
   // TODO: `.d` should be eventually removed once `-M` and its variants are
   // handled properly in offload compilation.
   if (FilesType == "d")
     return std::make_unique<TextFileHandler>(/*Comment=*/"#");
   if (FilesType == "ll")
     return std::make_unique<TextFileHandler>(/*Comment=*/";");
   if (FilesType == "bc")
-    return std::make_unique<BinaryFileHandler>();
+    return std::make_unique<BinaryFileHandler>(BundlerConfig);
   if (FilesType == "s")
     return std::make_unique<TextFileHandler>(/*Comment=*/"#");
   if (FilesType == "o")
-    return CreateObjectFileHandler(FirstInput);
+    return CreateObjectFileHandler(FirstInput, BundlerConfig);
   if (FilesType == "a")
-    return CreateObjectFileHandler(FirstInput);
+    return CreateObjectFileHandler(FirstInput, BundlerConfig);
   if (FilesType == "gch")
-    return std::make_unique<BinaryFileHandler>();
+    return std::make_unique<BinaryFileHandler>(BundlerConfig);
   if (FilesType == "ast")
-    return std::make_unique<BinaryFileHandler>();
+    return std::make_unique<BinaryFileHandler>(BundlerConfig);
 
   return createStringError(errc::invalid_argument,
                            "'" + FilesType + "': invalid file type specified");
 }
 
 // List bundle IDs. Return true if an error was found.
-Error ListBundleIDsInFile(StringRef InputFileName) {
+Error ListBundleIDsInFile(StringRef InputFileName, Config *BundlerConfig) {
   // Open Input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFileName);
   if (std::error_code EC = CodeOrErr.getError())
     return createFileError(InputFileName, EC);
 
   MemoryBuffer &Input = **CodeOrErr;
 
   // Select the right files handler.
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
-      CreateFileHandler(Input);
+      CreateFileHandler(Input, BundlerConfig);
   if (!FileHandlerOrErr)
     return FileHandlerOrErr.takeError();
 
   std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
   assert(FH);
   return FH->listBundleIDs(Input);
 }
 
 /// Bundle the files. Return true if an error was found.
-Error BundleFiles() {
+Error OffloadBundler::BundleFiles() {
   std::error_code EC;
 
   // Create output file.
-  raw_fd_ostream OutputFile(OutputFileNames.front(), EC, sys::fs::OF_None);
+  raw_fd_ostream OutputFile(BundlerConfig->OutputFileNames.front(),
+                            EC, sys::fs::OF_None);
   if (EC)
-    return createFileError(OutputFileNames.front(), EC);
+    return createFileError(BundlerConfig->OutputFileNames.front(), EC);
 
   // Open input files.
   SmallVector<std::unique_ptr<MemoryBuffer>, 8u> InputBuffers;
-  InputBuffers.reserve(InputFileNames.size());
-  for (auto &I : InputFileNames) {
+  InputBuffers.reserve(BundlerConfig->InputFileNames.size());
+  for (auto &I : BundlerConfig->InputFileNames) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getFileOrSTDIN(I);
     if (std::error_code EC = CodeOrErr.getError())
       return createFileError(I, EC);
     InputBuffers.emplace_back(std::move(*CodeOrErr));
   }
 
   // Get the file handler. We use the host buffer as reference.
-  assert((HostInputIndex != ~0u || AllowNoHost) &&
+  assert((BundlerConfig->HostInputIndex != ~0u || BundlerConfig->AllowNoHost) &&
          "Host input index undefined??");
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
-      CreateFileHandler(*InputBuffers[AllowNoHost ? 0 : HostInputIndex]);
+      CreateFileHandler(*InputBuffers[BundlerConfig->AllowNoHost ? 0
+                        : BundlerConfig->HostInputIndex],
+                        BundlerConfig);
   if (!FileHandlerOrErr)
     return FileHandlerOrErr.takeError();
 
   std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
   assert(FH);
 
   // Write header.
   if (Error Err = FH->WriteHeader(OutputFile, InputBuffers))
     return Err;
 
   // Write all bundles along with the start/end markers. If an error was found
   // writing the end of the bundle component, abort the bundle writing.
   auto Input = InputBuffers.begin();
-  for (auto &Triple : TargetNames) {
+  for (auto &Triple : BundlerConfig->TargetNames) {
     if (Error Err = FH->WriteBundleStart(OutputFile, Triple))
       return Err;
     if (Error Err = FH->WriteBundle(OutputFile, **Input))
       return Err;
     if (Error Err = FH->WriteBundleEnd(OutputFile, Triple))
       return Err;
     ++Input;
   }
   return Error::success();
 }
 
 // Unbundle the files. Return true if an error was found.
-Error UnbundleFiles() {
+Error OffloadBundler::UnbundleFiles() {
   // Open Input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFileNames.front());
+      MemoryBuffer::getFileOrSTDIN(BundlerConfig->InputFileNames.front());
   if (std::error_code EC = CodeOrErr.getError())
-    return createFileError(InputFileNames.front(), EC);
+    return createFileError(BundlerConfig->InputFileNames.front(), EC);
 
   MemoryBuffer &Input = **CodeOrErr;
 
   // Select the right files handler.
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
-      CreateFileHandler(Input);
+      CreateFileHandler(Input, BundlerConfig);
   if (!FileHandlerOrErr)
     return FileHandlerOrErr.takeError();
 
   std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
   assert(FH);
 
   // Read the header of the bundled file.
   if (Error Err = FH->ReadHeader(Input))
     return Err;
 
   // Create a work list that consist of the map triple/output file.
   StringMap<StringRef> Worklist;
-  auto Output = OutputFileNames.begin();
-  for (auto &Triple : TargetNames) {
+  auto Output = BundlerConfig->OutputFileNames.begin();
+  for (auto &Triple : BundlerConfig->TargetNames) {
     Worklist[Triple] = *Output;
     ++Output;
   }
 
   // Read all the bundles that are in the work list. If we find no bundles we
   // assume the file is meant for the host target.
   bool FoundHostBundle = false;
   while (!Worklist.empty()) {
if (EC)
       return createFileError(Output->second, EC);
     if (Error Err = FH->ReadBundle(OutputFile, Input))
       return Err;
     if (Error Err = FH->ReadBundleEnd(Input))
       return Err;
     Worklist.erase(Output);
 
     // Record if we found the host bundle.
-    auto OffloadInfo = OffloadTargetInfo(CurTriple);
+    auto OffloadInfo = OffloadTargetInfo(CurTriple, BundlerConfig);
     if (OffloadInfo.hasHostKind())
       FoundHostBundle = true;
   }
 
-  if (!AllowMissingBundles && !Worklist.empty()) {
+  if (!BundlerConfig->AllowMissingBundles && !Worklist.empty()) {
     std::string ErrMsg = "Can't find bundles for";
     std::set<StringRef> Sorted;
     for (auto &E : Worklist)
       Sorted.insert(E.first());
     unsigned I = 0;
     unsigned Last = Sorted.size() - 1;
     for (auto &E : Sorted) {
       if (I != 0 && Last > 1)
         ErrMsg += ",";
       ErrMsg += " ";
       if (I == Last && I != 0)
         ErrMsg += "and ";
       ErrMsg += E.str();
       ++I;
     }
     return createStringError(inconvertibleErrorCode(), ErrMsg);
   }
 
   // If no bundles were found, assume the input file is the host bundle and
   // create empty files for the remaining targets.
-  if (Worklist.size() == TargetNames.size()) {
+  if (Worklist.size() == BundlerConfig->TargetNames.size()) {
     for (auto &E : Worklist) {
       std::error_code EC;
       raw_fd_ostream OutputFile(E.second, EC, sys::fs::OF_None);
       if (EC)
         return createFileError(E.second, EC);
 
       // If this entry has a host kind, copy the input file to the output file.
-      auto OffloadInfo = OffloadTargetInfo(E.getKey());
+      auto OffloadInfo = OffloadTargetInfo(E.getKey(), BundlerConfig);
       if (OffloadInfo.hasHostKind())
         OutputFile.write(Input.getBufferStart(), Input.getBufferSize());
     }
     return Error::success();
   }
 
   // If we found elements, we emit an error if none of those were for the host
   // in case host bundle name was provided in command line.
-  if (!FoundHostBundle && HostInputIndex != ~0u)
+  if (!FoundHostBundle && BundlerConfig->HostInputIndex != ~0u)
     return createStringError(inconvertibleErrorCode(),
                              "Can't find bundle for the host target");
 
   // If we still have any elements in the worklist, create empty files for them.
   for (auto &E : Worklist) {
     std::error_code EC;
     raw_fd_ostream OutputFile(E.second, EC, sys::fs::OF_None);
     if (EC)

 /// @brief Computes a list of targets among all given targets which are
 /// compatible with this code object
 /// @param [in] CodeObjectInfo Code Object
 /// @param [out] CompatibleTargets List of all compatible targets among all
 /// given targets
 /// @return false, if no compatible target is found.
 static bool
 getCompatibleOffloadTargets(OffloadTargetInfo &CodeObjectInfo,
-                            SmallVectorImpl<StringRef> &CompatibleTargets) {
+                            SmallVectorImpl<StringRef> &CompatibleTargets,
+                            Config *BundlerConfig) {
   if (!CompatibleTargets.empty()) {
     DEBUG_WITH_TYPE("CodeObjectCompatibility",
                     dbgs() << "CompatibleTargets list should be empty\n");
     return false;
   }
-  for (auto &Target : TargetNames) {
-    auto TargetInfo = OffloadTargetInfo(Target);
+  for (auto &Target : BundlerConfig->TargetNames) {
+    auto TargetInfo = OffloadTargetInfo(Target, BundlerConfig);
     if (isCodeObjectCompatible(CodeObjectInfo, TargetInfo))
       CompatibleTargets.push_back(Target);
   }
   return !CompatibleTargets.empty();
 }
 
 /// UnbundleArchive takes an archive file (".a") as input containing bundled
 /// code object files, and a list of offload targets (not host), and extracts
 /// the code objects into a new archive file for each offload target. Each
 /// resulting archive file contains all code object files corresponding to that
 /// particular offload target. The created archive file does not
 /// contain an index of the symbols and code object files are named as
 /// <<Parent Bundle Name>-<CodeObject's GPUArch>>, with ':' replaced with '_'.
-Error UnbundleArchive() {
+Error OffloadBundler::UnbundleArchive() {
   std::vector<std::unique_ptr<MemoryBuffer>> ArchiveBuffers;
 
   /// Map of target names with list of object files that will form the device
   /// specific archive for that target
   StringMap<std::vector<NewArchiveMember>> OutputArchivesMap;
 
   // Map of target names and output archive filenames
   StringMap<StringRef> TargetOutputFileNameMap;
 
-  auto Output = OutputFileNames.begin();
-  for (auto &Target : TargetNames) {
+  auto Output = BundlerConfig->OutputFileNames.begin();
+  for (auto &Target : BundlerConfig->TargetNames) {
     TargetOutputFileNameMap[Target] = *Output;
     ++Output;
   }
 
-  StringRef IFName = InputFileNames.front();
+  StringRef IFName = BundlerConfig->InputFileNames.front();
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFileOrSTDIN(IFName, true, false);
   if (std::error_code EC = BufOrErr.getError())
-    return createFileError(InputFileNames.front(), EC);
+    return createFileError(BundlerConfig->InputFileNames.front(), EC);
 
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   Expected<std::unique_ptr<llvm::object::Archive>> LibOrErr =
       Archive::create(ArchiveBuffers.back()->getMemBufferRef());
   if (!LibOrErr)
     return LibOrErr.takeError();
 
   auto Archive = std::move(*LibOrErr);
for (auto ArchiveIter = Archive->child_begin(ArchiveErr);
     auto CodeObjectBufferRefOrErr = (*ArchiveIter).getMemoryBufferRef();
     if (!CodeObjectBufferRefOrErr)
       return CodeObjectBufferRefOrErr.takeError();
 
     auto CodeObjectBuffer =
         MemoryBuffer::getMemBuffer(*CodeObjectBufferRefOrErr, false);
 
     Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
-        CreateFileHandler(*CodeObjectBuffer);
+        CreateFileHandler(*CodeObjectBuffer, BundlerConfig);
     if (!FileHandlerOrErr)
       return FileHandlerOrErr.takeError();
 
     std::unique_ptr<FileHandler> &FileHandler = *FileHandlerOrErr;
     assert(FileHandler &&
      "FileHandle creation failed for file in the archive!");
 
     if (Error ReadErr = FileHandler.get()->ReadHeader(*CodeObjectBuffer))
for (auto ArchiveIter = Archive->child_begin(ArchiveErr);
     if (!OptionalCurBundleID.hasValue())
       continue;
     StringRef CodeObject = *OptionalCurBundleID;
 
     // Process all bundle entries (CodeObjects) found in this child of input
     // archive.
     while (!CodeObject.empty()) {
       SmallVector<StringRef> CompatibleTargets;
-      auto CodeObjectInfo = OffloadTargetInfo(CodeObject);
+      auto CodeObjectInfo = OffloadTargetInfo(CodeObject, BundlerConfig);
       if (CodeObjectInfo.hasHostKind()) {
         // Do nothing, we don't extract host code yet.
       } else if (getCompatibleOffloadTargets(CodeObjectInfo,
-                                             CompatibleTargets)) {
+                                             CompatibleTargets,
+                                             BundlerConfig)) {
         std::string BundleData;
         raw_string_ostream DataStream(BundleData);
         if (Error Err =
                 FileHandler.get()->ReadBundle(DataStream, *CodeObjectBuffer))
           return Err;
 
         for (auto &CompatibleTarget : CompatibleTargets) {
           SmallString<128> BundledObjectFileName;
while (!CodeObject.empty()) {
 
       CodeObject = ((*NextTripleOrErr).hasValue()) ? **NextTripleOrErr : "";
     } // End of processing of all bundle entries of this child of input archive.
   }   // End of while over children of input archive.
 
   assert(!ArchiveErr && "Error occurred while reading archive!");
 
   /// Write out an archive for each target
-  for (auto &Target : TargetNames) {
+  for (auto &Target : BundlerConfig->TargetNames) {
     StringRef FileName = TargetOutputFileNameMap[Target];
     StringMapIterator<std::vector<llvm::NewArchiveMember>> CurArchiveMembers =
         OutputArchivesMap.find(Target);
     if (CurArchiveMembers != OutputArchivesMap.end()) {
       if (Error WriteErr = writeArchive(FileName, CurArchiveMembers->getValue(),
                                         true, getDefaultArchiveKindForHost(),
                                         true, false, nullptr))
         return WriteErr;
-    } else if (!AllowMissingBundles) {
+    } else if (!BundlerConfig->AllowMissingBundles) {
       std::string ErrMsg =
           Twine("no compatible code object found for the target '" + Target +
                 "' in heterogeneous archive library: " + IFName)
               .str();
       return createStringError(inconvertibleErrorCode(), ErrMsg);
     } else { // Create an empty archive file if no compatible code object is
              // found and "allow-missing-bundles" is enabled. It ensures that
              // the linker using output of this step doesn't complain about