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

[lamb-j]

Summary

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

This patch (3/4) lifts the BundlerExecutable variable, which is
specific to the clang-offload-bundler tool, from the API, and
replaces its use with an ObjcopyPath variable. This variable
must be set in order to internally call llvm-objcopy.

[lamb-j]

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

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

int main(int argc, const char **argv) {
 
   // 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);
 
+  // Find llvm-objcopy in order to create the bundle binary.
+  ErrorOr<std::string> Objcopy = sys::findProgramByName(
+    "llvm-objcopy",
+    sys::path::parent_path(BundlerExecutable));
+  if (!Objcopy)
+    Objcopy = sys::findProgramByName("llvm-objcopy");
+  if (!Objcopy)
+    reportError(createStringError(Objcopy.getError(),
+                             "unable to find 'llvm-objcopy' in path"));
+
   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 (ListBundleIDs) {
     }
     if (TargetNames.size()) {
       reportError(createStringError(errc::invalid_argument,
                                     "-targets option is invalid for -list"));
     }
 
     Config BundlerPrint;
     BundlerPrint.PrintExternalCommands = PrintExternalCommands;
-    BundlerPrint.BundlerExecutable = BundlerExecutable;
+    BundlerPrint.ObjcopyPath = *Objcopy;
     doWork([&]() { return ListBundleIDsInFile(InputFileNames.front(),
                                              &BundlerPrint); });
     return 0;
   }
 
   if (OutputFileNames.size() == 0) {
     reportError(
         createStringError(errc::invalid_argument, "no output file specified!"));
for (StringRef Target : TargetNames) {
     if (ParsedTargets.contains(Target)) {
       reportError(createStringError(errc::invalid_argument,
                                     "Duplicate targets are not allowed"));
     }
     ParsedTargets.insert(Target);
 
     Config BundlerOpenmp;
     BundlerOpenmp.HipOpenmpCompatible = HipOpenmpCompatible;
-    BundlerOpenmp.BundlerExecutable = BundlerExecutable;
+    BundlerOpenmp.ObjcopyPath = *Objcopy;
     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 << "'";
int main(int argc, const char **argv) {
   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.ObjcopyPath = *Objcopy;
 
   BundlerConfig.TargetNames = TargetNames;
   BundlerConfig.InputFileNames = InputFileNames;
   BundlerConfig.OutputFileNames = OutputFileNames;
 
   OffloadBundler Bundler(&BundlerConfig);
 
   doWork([&]() {

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

public:
   bool CheckInputArchive = false;
   bool PrintExternalCommands = false;
   bool HipOpenmpCompatible = false;
 
   unsigned BundleAlignment = 1;
   unsigned HostInputIndex = ~0u;
 
   std::string FilesType;
-  std::string BundlerExecutable;
+  std::string ObjcopyPath;
 
   // TODO: Convert these to llvm::SmallVector
   std::vector<std::string> TargetNames;
   std::vector<std::string> InputFileNames;
   std::vector<std::string> OutputFileNames;
 };
 
 class OffloadBundler {

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

Error WriteBundleEnd(raw_fd_ostream &OS, StringRef TargetTriple) final {
     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(BundlerConfig->BundlerExecutable));
-    if (!Objcopy)
-      Objcopy = sys::findProgramByName("llvm-objcopy");
-    if (!Objcopy)
-      return createStringError(Objcopy.getError(),
-                               "unable to find 'llvm-objcopy' in path");
+    assert(BundlerConfig->ObjcopyPath != "" &&
+           "llvm-objcopy path not specified");
 
     // 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;
 
for (unsigned I = 0; I < NumberOfInputs; ++I) {
             BundlerConfig->TargetNames[I] +
                                     "=readonly,exclude"));
     }
     ObjcopyArgs.push_back("--");
     ObjcopyArgs.push_back(
       BundlerConfig->InputFileNames[BundlerConfig->HostInputIndex]);
     ObjcopyArgs.push_back(BundlerConfig->OutputFileNames.front());
 
-    if (Error Err = executeObjcopy(*Objcopy, ObjcopyArgs))
+    if (Error Err = executeObjcopy(BundlerConfig->ObjcopyPath, ObjcopyArgs))
       return Err;
 
     return Error::success();
   }
 
   Error WriteBundle(raw_fd_ostream &OS, MemoryBuffer &Input) final {
     return Error::success();
   }