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

   1 //===-- clang-offload-bundler/ClangOffloadBundler.cpp ---------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// This file implements a stand-alone clang-offload-bundler tool using the
  11 /// OffloadBundler API.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Basic/Cuda.h"
  16 #include "clang/Basic/TargetID.h"
  17 #include "clang/Basic/Version.h"
  18 #include "clang/Driver/OffloadBundler.h"
  19 #include "llvm/ADT/ArrayRef.h"
  20 #include "llvm/ADT/SmallString.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/Object/Archive.h"
  24 #include "llvm/Object/ArchiveWriter.h"
  25 #include "llvm/Object/Binary.h"
  26 #include "llvm/Object/ObjectFile.h"
  27 #include "llvm/Support/Casting.h"
  28 #include "llvm/Support/CommandLine.h"
  29 #include "llvm/Support/Debug.h"
  30 #include "llvm/Support/Errc.h"
  31 #include "llvm/Support/Error.h"
  32 #include "llvm/Support/ErrorOr.h"
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/MemoryBuffer.h"
  35 #include "llvm/Support/Path.h"
  36 #include "llvm/Support/Program.h"
  37 #include "llvm/Support/Signals.h"
  38 #include "llvm/Support/StringSaver.h"
  39 #include "llvm/Support/WithColor.h"
  40 #include "llvm/Support/raw_ostream.h"
  41 #include "llvm/TargetParser/Host.h"
  42 #include "llvm/TargetParser/Triple.h"
  43 #include <algorithm>
  44 #include <cassert>
  45 #include <cstddef>
  46 #include <cstdint>
  47 #include <forward_list>
  48 #include <map>
  49 #include <memory>
  50 #include <set>
  51 #include <string>
  52 #include <system_error>
  53 #include <utility>
  54
  55 using namespace llvm;
  56 using namespace llvm::object;
  57 using namespace clang;
  58
  59 static void PrintVersion(raw_ostream &OS) {
  60   OS << clang::getClangToolFullVersion("clang-offload-bundler") << '\n';
  61 }
  62
  63 int main(int argc, const char **argv) {
  64
  65   cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
  66
  67   // Mark all our options with this category, everything else (except for
  68   // -version and -help) will be hidden.
  69   cl::OptionCategory
  70     ClangOffloadBundlerCategory("clang-offload-bundler options");
  71   cl::list<std::string>
  72     InputFileNames("input",
  73                    cl::desc("Input file."
  74                             " Can be specified multiple times "
  75                             "for multiple input files."),
  76                    cl::cat(ClangOffloadBundlerCategory));
  77   cl::list<std::string>
  78     InputFileNamesDeprecatedOpt("inputs", cl::CommaSeparated,
  79                                 cl::desc("[<input file>,...] (deprecated)"),
  80                                 cl::cat(ClangOffloadBundlerCategory));
  81   cl::list<std::string>
  82     OutputFileNames("output",
  83                     cl::desc("Output file."
  84                              " Can be specified multiple times "
  85                              "for multiple output files."),
  86                     cl::cat(ClangOffloadBundlerCategory));
  87   cl::list<std::string>
  88     OutputFileNamesDeprecatedOpt("outputs", cl::CommaSeparated,
  89                                  cl::desc("[<output file>,...] (deprecated)"),
  90                                  cl::cat(ClangOffloadBundlerCategory));
  91   cl::list<std::string>
  92     TargetNames("targets", cl::CommaSeparated,
  93                 cl::desc("[<offload kind>-<target triple>,...]"),
  94                 cl::cat(ClangOffloadBundlerCategory));
  95   cl::opt<std::string> FilesType(
  96       "type", cl::Required,
  97       cl::desc("Type of the files to be bundled/unbundled.\n"
  98                "Current supported types are:\n"
  99                "  i    - cpp-output\n"
 100                "  ii   - c++-cpp-output\n"
 101                "  cui  - cuda-cpp-output\n"
 102                "  hipi - hip-cpp-output\n"
 103                "  d    - dependency\n"
 104                "  ll   - llvm\n"
 105                "  bc   - llvm-bc\n"
 106                "  s    - assembler\n"
 107                "  o    - object\n"
 108                "  a    - archive of objects\n"
 109                "  gch  - precompiled-header\n"
 110                "  ast  - clang AST file"),
 111       cl::cat(ClangOffloadBundlerCategory));
 112   cl::opt<bool>
 113     Unbundle("unbundle",
 114              cl::desc("Unbundle bundled file into several output files.\n"),
 115              cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 116   cl::opt<bool>
 117     ListBundleIDs("list", cl::desc("List bundle IDs in the bundled file.\n"),
 118                   cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 119   cl::opt<bool> PrintExternalCommands(
 120     "###",
 121     cl::desc("Print any external commands that are to be executed "
 122              "instead of actually executing them - for testing purposes.\n"),
 123     cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 124   cl::opt<bool>
 125     AllowMissingBundles("allow-missing-bundles",
 126                         cl::desc("Create empty files if bundles are missing "
 127                                  "when unbundling.\n"),
 128                         cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 129   cl::opt<unsigned>
 130     BundleAlignment("bundle-align",
 131                     cl::desc("Alignment of bundle for binary files"),
 132                     cl::init(1), cl::cat(ClangOffloadBundlerCategory));
 133   cl::opt<bool> CheckInputArchive(
 134       "check-input-archive",
 135       cl::desc("Check if input heterogeneous archive is "
 136                "valid in terms of TargetID rules.\n"),
 137       cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 138   cl::opt<bool> HipOpenmpCompatible(
 139     "hip-openmp-compatible",
 140     cl::desc("Treat hip and hipv4 offload kinds as "
 141              "compatible with openmp kind, and vice versa.\n"),
 142     cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 143   cl::opt<bool> Compress("compress",
 144                          cl::desc("Compress output file when bundling.\n"),
 145                          cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 146   cl::opt<bool> Verbose("verbose", cl::desc("Print debug information.\n"),
 147                         cl::init(false), cl::cat(ClangOffloadBundlerCategory));
 148   cl::opt<int> CompressionLevel(
 149       "compression-level", cl::desc("Specify the compression level (integer)"),
 150       cl::value_desc("n"), cl::Optional, cl::cat(ClangOffloadBundlerCategory));
 151
 152   // Process commandline options and report errors
 153   sys::PrintStackTraceOnErrorSignal(argv[0]);
 154
 155   cl::HideUnrelatedOptions(ClangOffloadBundlerCategory);
 156   cl::SetVersionPrinter(PrintVersion);
 157   cl::ParseCommandLineOptions(
 158       argc, argv,
 159       "A tool to bundle several input files of the specified type <type> \n"
 160       "referring to the same source file but different targets into a single \n"
 161       "one. The resulting file can also be unbundled into different files by \n"
 162       "this tool if -unbundle is provided.\n");
 163
 164   if (Help) {
 165     cl::PrintHelpMessage();
 166     return 0;
 167   }
 168
 169   /// Class to store bundler options in standard (non-cl::opt) data structures
 170   // Avoid using cl::opt variables after these assignments when possible
 171   OffloadBundlerConfig BundlerConfig;
 172   BundlerConfig.AllowMissingBundles = AllowMissingBundles;
 173   BundlerConfig.CheckInputArchive = CheckInputArchive;
 174   BundlerConfig.PrintExternalCommands = PrintExternalCommands;
 175   BundlerConfig.HipOpenmpCompatible = HipOpenmpCompatible;
 176   BundlerConfig.BundleAlignment = BundleAlignment;
 177   BundlerConfig.FilesType = FilesType;
 178   BundlerConfig.ObjcopyPath = "";
 179   // Do not override the default value Compress and Verbose in BundlerConfig.
 180   if (Compress.getNumOccurrences() > 0)
 181     BundlerConfig.Compress = Compress;
 182   if (Verbose.getNumOccurrences() > 0)
 183     BundlerConfig.Verbose = Verbose;
 184   if (CompressionLevel.getNumOccurrences() > 0)
 185     BundlerConfig.CompressionLevel = CompressionLevel;
 186
 187   BundlerConfig.TargetNames = TargetNames;
 188   BundlerConfig.InputFileNames = InputFileNames;
 189   BundlerConfig.OutputFileNames = OutputFileNames;
 190
 191   /// The index of the host input in the list of inputs.
 192   BundlerConfig.HostInputIndex = ~0u;
 193
 194   /// Whether not having host target is allowed.
 195   BundlerConfig.AllowNoHost = false;
 196
 197   auto reportError = [argv](Error E) {
 198     logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
 199     exit(1);
 200   };
 201
 202   auto doWork = [&](std::function<llvm::Error()> Work) {
 203     if (llvm::Error Err = Work()) {
 204       reportError(std::move(Err));
 205     }
 206   };
 207
 208   auto warningOS = [argv]() -> raw_ostream & {
 209     return WithColor::warning(errs(), StringRef(argv[0]));
 210   };
 211
 212   /// Path to the current binary.
 213   std::string BundlerExecutable = argv[0];
 214
 215   if (!llvm::sys::fs::exists(BundlerExecutable))
 216     BundlerExecutable =
 217       sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
 218
 219   // Find llvm-objcopy in order to create the bundle binary.
 220   ErrorOr<std::string> Objcopy = sys::findProgramByName(
 221     "llvm-objcopy",
 222     sys::path::parent_path(BundlerExecutable));
 223   if (!Objcopy)
 224     Objcopy = sys::findProgramByName("llvm-objcopy");
 225   if (!Objcopy)
 226     reportError(createStringError(Objcopy.getError(),
 227                              "unable to find 'llvm-objcopy' in path"));
 228   else
 229     BundlerConfig.ObjcopyPath = *Objcopy;
 230
 231   if (InputFileNames.getNumOccurrences() != 0 &&
 232       InputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
 233     reportError(createStringError(
 234         errc::invalid_argument,
 235         "-inputs and -input cannot be used together, use only -input instead"));
 236   }
 237
 238   if (InputFileNamesDeprecatedOpt.size()) {
 239     warningOS() << "-inputs is deprecated, use -input instead\n";
 240     // temporary hack to support -inputs
 241     std::vector<std::string> &s = InputFileNames;
 242     s.insert(s.end(), InputFileNamesDeprecatedOpt.begin(),
 243              InputFileNamesDeprecatedOpt.end());
 244   }
 245   BundlerConfig.InputFileNames = InputFileNames;
 246
 247   if (OutputFileNames.getNumOccurrences() != 0 &&
 248       OutputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
 249     reportError(createStringError(errc::invalid_argument,
 250                                   "-outputs and -output cannot be used "
 251                                   "together, use only -output instead"));
 252   }
 253
 254   if (OutputFileNamesDeprecatedOpt.size()) {
 255     warningOS() << "-outputs is deprecated, use -output instead\n";
 256     // temporary hack to support -outputs
 257     std::vector<std::string> &s = OutputFileNames;
 258     s.insert(s.end(), OutputFileNamesDeprecatedOpt.begin(),
 259              OutputFileNamesDeprecatedOpt.end());
 260   }
 261   BundlerConfig.OutputFileNames = OutputFileNames;
 262
 263   if (ListBundleIDs) {
 264     if (Unbundle) {
 265       reportError(
 266           createStringError(errc::invalid_argument,
 267                             "-unbundle and -list cannot be used together"));
 268     }
 269     if (InputFileNames.size() != 1) {
 270       reportError(createStringError(errc::invalid_argument,
 271                                     "only one input file supported for -list"));
 272     }
 273     if (OutputFileNames.size()) {
 274       reportError(createStringError(errc::invalid_argument,
 275                                     "-outputs option is invalid for -list"));
 276     }
 277     if (TargetNames.size()) {
 278       reportError(createStringError(errc::invalid_argument,
 279                                     "-targets option is invalid for -list"));
 280     }
 281
 282     doWork([&]() { return OffloadBundler::ListBundleIDsInFile(
 283           InputFileNames.front(),
 284           BundlerConfig); });
 285     return 0;
 286   }
 287
 288   if (BundlerConfig.CheckInputArchive) {
 289     if (!Unbundle) {
 290       reportError(createStringError(errc::invalid_argument,
 291                                     "-check-input-archive cannot be used while "
 292                                     "bundling"));
 293     }
 294     if (Unbundle && BundlerConfig.FilesType != "a") {
 295       reportError(createStringError(errc::invalid_argument,
 296                                     "-check-input-archive can only be used for "
 297                                     "unbundling archives (-type=a)"));
 298     }
 299   }
 300
 301   if (OutputFileNames.size() == 0) {
 302     reportError(
 303         createStringError(errc::invalid_argument, "no output file specified!"));
 304   }
 305
 306   if (TargetNames.getNumOccurrences() == 0) {
 307     reportError(createStringError(
 308         errc::invalid_argument,
 309         "for the --targets option: must be specified at least once!"));
 310   }
 311
 312   if (Unbundle) {
 313     if (InputFileNames.size() != 1) {
 314       reportError(createStringError(
 315           errc::invalid_argument,
 316           "only one input file supported in unbundling mode"));
 317     }
 318     if (OutputFileNames.size() != TargetNames.size()) {
 319       reportError(createStringError(errc::invalid_argument,
 320                                     "number of output files and targets should "
 321                                     "match in unbundling mode"));
 322     }
 323   } else {
 324     if (BundlerConfig.FilesType == "a") {
 325       reportError(createStringError(errc::invalid_argument,
 326                                     "Archive files are only supported "
 327                                     "for unbundling"));
 328     }
 329     if (OutputFileNames.size() != 1) {
 330       reportError(createStringError(
 331           errc::invalid_argument,
 332           "only one output file supported in bundling mode"));
 333     }
 334     if (InputFileNames.size() != TargetNames.size()) {
 335       reportError(createStringError(
 336           errc::invalid_argument,
 337           "number of input files and targets should match in bundling mode"));
 338     }
 339   }
 340
 341   // Verify that the offload kinds and triples are known. We also check that we
 342   // have exactly one host target.
 343   unsigned Index = 0u;
 344   unsigned HostTargetNum = 0u;
 345   bool HIPOnly = true;
 346   llvm::DenseSet<StringRef> ParsedTargets;
 347   // Map {offload-kind}-{triple} to target IDs.
 348   std::map<std::string, std::set<StringRef>> TargetIDs;
 349   // Standardize target names to include env field
 350   std::vector<std::string> StandardizedTargetNames;
 351   for (StringRef Target : TargetNames) {
 352     if (!ParsedTargets.insert(Target).second) {
 353       reportError(createStringError(errc::invalid_argument,
 354                                     "Duplicate targets are not allowed"));
 355     }
 356
 357     auto OffloadInfo = OffloadTargetInfo(Target, BundlerConfig);
 358     bool KindIsValid = OffloadInfo.isOffloadKindValid();
 359     bool TripleIsValid = OffloadInfo.isTripleValid();
 360
 361     StandardizedTargetNames.push_back(OffloadInfo.str());
 362
 363     if (!KindIsValid || !TripleIsValid) {
 364       SmallVector<char, 128u> Buf;
 365       raw_svector_ostream Msg(Buf);
 366       Msg << "invalid target '" << Target << "'";
 367       if (!KindIsValid)
 368         Msg << ", unknown offloading kind '" << OffloadInfo.OffloadKind << "'";
 369       if (!TripleIsValid)
 370         Msg << ", unknown target triple '" << OffloadInfo.Triple.str() << "'";
 371       reportError(createStringError(errc::invalid_argument, Msg.str()));
 372     }
 373
 374     TargetIDs[OffloadInfo.OffloadKind.str() + "-" + OffloadInfo.Triple.str()]
 375         .insert(OffloadInfo.TargetID);
 376     if (KindIsValid && OffloadInfo.hasHostKind()) {
 377       ++HostTargetNum;
 378       // Save the index of the input that refers to the host.
 379       BundlerConfig.HostInputIndex = Index;
 380     }
 381
 382     if (OffloadInfo.OffloadKind != "hip" && OffloadInfo.OffloadKind != "hipv4")
 383       HIPOnly = false;
 384
 385     ++Index;
 386   }
 387
 388   BundlerConfig.TargetNames = StandardizedTargetNames;
 389
 390   for (const auto &TargetID : TargetIDs) {
 391     if (auto ConflictingTID =
 392             clang::getConflictTargetIDCombination(TargetID.second)) {
 393       SmallVector<char, 128u> Buf;
 394       raw_svector_ostream Msg(Buf);
 395       Msg << "Cannot bundle inputs with conflicting targets: '"
 396           << TargetID.first + "-" + ConflictingTID->first << "' and '"
 397           << TargetID.first + "-" + ConflictingTID->second << "'";
 398       reportError(createStringError(errc::invalid_argument, Msg.str()));
 399     }
 400   }
 401
 402   // HIP uses clang-offload-bundler to bundle device-only compilation results
 403   // for multiple GPU archs, therefore allow no host target if all entries
 404   // are for HIP.
 405   BundlerConfig.AllowNoHost = HIPOnly;
 406
 407   // Host triple is not really needed for unbundling operation, so do not
 408   // treat missing host triple as error if we do unbundling.
 409   if ((Unbundle && HostTargetNum > 1) ||
 410       (!Unbundle && HostTargetNum != 1 && !BundlerConfig.AllowNoHost)) {
 411     reportError(createStringError(errc::invalid_argument,
 412                                   "expecting exactly one host target but got " +
 413                                       Twine(HostTargetNum)));
 414   }
 415
 416   OffloadBundler Bundler(BundlerConfig);
 417
 418   doWork([&]() {
 419     if (Unbundle) {
 420       if (BundlerConfig.FilesType == "a")
 421         return Bundler.UnbundleArchive();
 422       else
 423         return Bundler.UnbundleFiles();
 424     } else
 425       return Bundler.BundleFiles();
 426   });
 427   return 0;
 428 }