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
55using namespace llvm;
56using namespace llvm::object;
57using namespace clang;
58
59static void PrintVersion(raw_ostream &OS) {
60 OS << clang::getClangToolFullVersion(ToolName: "clang-offload-bundler") << '\n';
61}
62
63int 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(Val: false), cl::cat(ClangOffloadBundlerCategory));
116 cl::opt<bool>
117 ListBundleIDs("list", cl::desc("List bundle IDs in the bundled file.\n"),
118 cl::init(Val: 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(Val: 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(Val: false), cl::cat(ClangOffloadBundlerCategory));
129 cl::opt<unsigned>
130 BundleAlignment("bundle-align",
131 cl::desc("Alignment of bundle for binary files"),
132 cl::init(Val: 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(Val: 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(Val: false), cl::cat(ClangOffloadBundlerCategory));
143 cl::opt<bool> Compress("compress",
144 cl::desc("Compress output file when bundling.\n"),
145 cl::init(Val: false), cl::cat(ClangOffloadBundlerCategory));
146 cl::opt<bool> Verbose("verbose", cl::desc("Print debug information.\n"),
147 cl::init(Val: 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(Argv0: argv[0]);
154
155 cl::HideUnrelatedOptions(Category&: ClangOffloadBundlerCategory);
156 cl::SetVersionPrinter(PrintVersion);
157 cl::ParseCommandLineOptions(
158 argc, argv,
159 Overview: "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.assign(in_start: TargetNames.begin(), in_end: TargetNames.end());
188 BundlerConfig.InputFileNames.assign(in_start: InputFileNames.begin(),
189 in_end: InputFileNames.end());
190 BundlerConfig.OutputFileNames.assign(in_start: OutputFileNames.begin(),
191 in_end: OutputFileNames.end());
192
193 /// The index of the host input in the list of inputs.
194 BundlerConfig.HostInputIndex = ~0u;
195
196 /// Whether not having host target is allowed.
197 BundlerConfig.AllowNoHost = false;
198
199 auto reportError = [argv](Error E) {
200 logAllUnhandledErrors(E: std::move(E), OS&: WithColor::error(OS&: errs(), Prefix: argv[0]));
201 return 1;
202 };
203
204 auto doWork = [&](std::function<llvm::Error()> Work) {
205 if (llvm::Error Err = Work()) {
206 return reportError(std::move(Err));
207 }
208 return 0;
209 };
210
211 auto warningOS = [argv]() -> raw_ostream & {
212 return WithColor::warning(OS&: errs(), Prefix: StringRef(argv[0]));
213 };
214
215 /// Path to the current binary.
216 std::string BundlerExecutable = argv[0];
217
218 if (!llvm::sys::fs::exists(Path: BundlerExecutable))
219 BundlerExecutable =
220 sys::fs::getMainExecutable(argv0: argv[0], MainExecAddr: &BundlerExecutable);
221
222 // Find llvm-objcopy in order to create the bundle binary.
223 ErrorOr<std::string> Objcopy = sys::findProgramByName(
224 Name: "llvm-objcopy",
225 Paths: sys::path::parent_path(path: BundlerExecutable));
226 if (!Objcopy)
227 Objcopy = sys::findProgramByName(Name: "llvm-objcopy");
228 if (!Objcopy)
229 return reportError(createStringError(
230 EC: Objcopy.getError(), S: "unable to find 'llvm-objcopy' in path"));
231 else
232 BundlerConfig.ObjcopyPath = *Objcopy;
233
234 if (InputFileNames.getNumOccurrences() != 0 &&
235 InputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
236 return reportError(createStringError(
237 EC: errc::invalid_argument,
238 S: "-inputs and -input cannot be used together, use only -input instead"));
239 }
240
241 if (InputFileNamesDeprecatedOpt.size()) {
242 warningOS() << "-inputs is deprecated, use -input instead\n";
243 // temporary hack to support -inputs
244 std::vector<std::string> &s = InputFileNames;
245 s.insert(position: s.end(), first: InputFileNamesDeprecatedOpt.begin(),
246 last: InputFileNamesDeprecatedOpt.end());
247 }
248 BundlerConfig.InputFileNames.assign(in_start: InputFileNames.begin(),
249 in_end: InputFileNames.end());
250
251 if (OutputFileNames.getNumOccurrences() != 0 &&
252 OutputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
253 return reportError(createStringError(EC: errc::invalid_argument,
254 S: "-outputs and -output cannot be used "
255 "together, use only -output instead"));
256 }
257
258 if (OutputFileNamesDeprecatedOpt.size()) {
259 warningOS() << "-outputs is deprecated, use -output instead\n";
260 // temporary hack to support -outputs
261 std::vector<std::string> &s = OutputFileNames;
262 s.insert(position: s.end(), first: OutputFileNamesDeprecatedOpt.begin(),
263 last: OutputFileNamesDeprecatedOpt.end());
264 }
265 BundlerConfig.OutputFileNames.assign(in_start: OutputFileNames.begin(),
266 in_end: OutputFileNames.end());
267
268 if (ListBundleIDs) {
269 if (Unbundle) {
270 return reportError(
271 createStringError(EC: errc::invalid_argument,
272 S: "-unbundle and -list cannot be used together"));
273 }
274 if (InputFileNames.size() != 1) {
275 return reportError(createStringError(
276 EC: errc::invalid_argument, S: "only one input file supported for -list"));
277 }
278 if (OutputFileNames.size()) {
279 return reportError(createStringError(
280 EC: errc::invalid_argument, S: "-outputs option is invalid for -list"));
281 }
282 if (TargetNames.size()) {
283 return reportError(createStringError(
284 EC: errc::invalid_argument, S: "-targets option is invalid for -list"));
285 }
286
287 return doWork([&]() {
288 return OffloadBundler::ListBundleIDsInFile(InputFileName: InputFileNames.front(),
289 BundlerConfig);
290 });
291 }
292
293 if (BundlerConfig.CheckInputArchive) {
294 if (!Unbundle) {
295 return reportError(createStringError(
296 EC: errc::invalid_argument, S: "-check-input-archive cannot be used while "
297 "bundling"));
298 }
299 if (Unbundle && BundlerConfig.FilesType != "a") {
300 return reportError(createStringError(
301 EC: errc::invalid_argument, S: "-check-input-archive can only be used for "
302 "unbundling archives (-type=a)"));
303 }
304 }
305
306 if (OutputFileNames.size() == 0) {
307 return reportError(
308 createStringError(EC: errc::invalid_argument, S: "no output file specified!"));
309 }
310
311 if (TargetNames.getNumOccurrences() == 0) {
312 return reportError(createStringError(
313 EC: errc::invalid_argument,
314 S: "for the --targets option: must be specified at least once!"));
315 }
316
317 if (Unbundle) {
318 if (InputFileNames.size() != 1) {
319 return reportError(createStringError(
320 EC: errc::invalid_argument,
321 S: "only one input file supported in unbundling mode"));
322 }
323 if (OutputFileNames.size() != TargetNames.size()) {
324 return reportError(createStringError(
325 EC: errc::invalid_argument, S: "number of output files and targets should "
326 "match in unbundling mode"));
327 }
328 } else {
329 if (BundlerConfig.FilesType == "a") {
330 return reportError(createStringError(EC: errc::invalid_argument,
331 S: "Archive files are only supported "
332 "for unbundling"));
333 }
334 if (OutputFileNames.size() != 1) {
335 return reportError(
336 createStringError(EC: errc::invalid_argument,
337 S: "only one output file supported in bundling mode"));
338 }
339 if (InputFileNames.size() != TargetNames.size()) {
340 return reportError(createStringError(
341 EC: errc::invalid_argument,
342 S: "number of input files and targets should match in bundling mode"));
343 }
344 }
345
346 // Verify that the offload kinds and triples are known. We also check that we
347 // have exactly one host target.
348 unsigned Index = 0u;
349 unsigned HostTargetNum = 0u;
350 bool HIPOnly = true;
351 llvm::DenseSet<StringRef> ParsedTargets;
352 // Map {offload-kind}-{triple} to target IDs.
353 std::map<std::string, std::set<StringRef>> TargetIDs;
354 // Standardize target names to include env field
355 std::vector<std::string> StandardizedTargetNames;
356 for (StringRef Target : TargetNames) {
357 if (!ParsedTargets.insert(V: Target).second) {
358 return reportError(createStringError(
359 EC: errc::invalid_argument, S: "Duplicate targets are not allowed"));
360 }
361
362 if (!checkOffloadBundleID(Str: Target)) {
363 return reportError(createStringError(
364 EC: errc::invalid_argument,
365 S: "Targets need to follow the format '<offload kind>-<target triple>', "
366 "where '<target triple>' follows the format "
367 "'<kind>-<arch>-<vendor>-<os>-<env>[-<target id>[:target "
368 "features]]'."));
369 }
370
371 auto OffloadInfo = OffloadTargetInfo(Target, BundlerConfig);
372 bool KindIsValid = OffloadInfo.isOffloadKindValid();
373 bool TripleIsValid = OffloadInfo.isTripleValid();
374
375 StandardizedTargetNames.push_back(x: OffloadInfo.str());
376
377 if (!KindIsValid || !TripleIsValid) {
378 SmallVector<char, 128u> Buf;
379 raw_svector_ostream Msg(Buf);
380 Msg << "invalid target '" << Target << "'";
381 if (!KindIsValid)
382 Msg << ", unknown offloading kind '" << OffloadInfo.OffloadKind << "'";
383 if (!TripleIsValid)
384 Msg << ", unknown target triple '" << OffloadInfo.Triple.str() << "'";
385 return reportError(createStringError(EC: errc::invalid_argument, S: Msg.str()));
386 }
387
388 TargetIDs[OffloadInfo.OffloadKind.str() + "-" + OffloadInfo.Triple.str()]
389 .insert(x: OffloadInfo.TargetID);
390 if (KindIsValid && OffloadInfo.hasHostKind()) {
391 ++HostTargetNum;
392 // Save the index of the input that refers to the host.
393 BundlerConfig.HostInputIndex = Index;
394 }
395
396 if (OffloadInfo.OffloadKind != "hip" && OffloadInfo.OffloadKind != "hipv4")
397 HIPOnly = false;
398
399 ++Index;
400 }
401
402 BundlerConfig.TargetNames.assign(in_start: StandardizedTargetNames.begin(),
403 in_end: StandardizedTargetNames.end());
404
405 for (const auto &TargetID : TargetIDs) {
406 if (auto ConflictingTID =
407 clang::getConflictTargetIDCombination(TargetIDs: TargetID.second)) {
408 SmallVector<char, 128u> Buf;
409 raw_svector_ostream Msg(Buf);
410 Msg << "Cannot bundle inputs with conflicting targets: '"
411 << TargetID.first + "-" + ConflictingTID->first << "' and '"
412 << TargetID.first + "-" + ConflictingTID->second << "'";
413 return reportError(createStringError(EC: errc::invalid_argument, S: Msg.str()));
414 }
415 }
416
417 // HIP uses clang-offload-bundler to bundle device-only compilation results
418 // for multiple GPU archs, therefore allow no host target if all entries
419 // are for HIP.
420 BundlerConfig.AllowNoHost = HIPOnly;
421
422 // Host triple is not really needed for unbundling operation, so do not
423 // treat missing host triple as error if we do unbundling.
424 if ((Unbundle && HostTargetNum > 1) ||
425 (!Unbundle && HostTargetNum != 1 && !BundlerConfig.AllowNoHost)) {
426 return reportError(createStringError(
427 EC: errc::invalid_argument,
428 S: "expecting exactly one host target but got " + Twine(HostTargetNum)));
429 }
430
431 OffloadBundler Bundler(BundlerConfig);
432
433 return doWork([&]() {
434 if (Unbundle)
435 return (BundlerConfig.FilesType == "a") ? Bundler.UnbundleArchive()
436 : Bundler.UnbundleFiles();
437 return Bundler.BundleFiles();
438 });
439}
440