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 = 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(E: std::move(E), OS&: WithColor::error(OS&: errs(), Prefix: argv[0]));
199 exit(status: 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(OS&: errs(), Prefix: StringRef(argv[0]));
210 };
211
212 /// Path to the current binary.
213 std::string BundlerExecutable = argv[0];
214
215 if (!llvm::sys::fs::exists(Path: BundlerExecutable))
216 BundlerExecutable =
217 sys::fs::getMainExecutable(argv0: argv[0], MainExecAddr: &BundlerExecutable);
218
219 // Find llvm-objcopy in order to create the bundle binary.
220 ErrorOr<std::string> Objcopy = sys::findProgramByName(
221 Name: "llvm-objcopy",
222 Paths: sys::path::parent_path(path: BundlerExecutable));
223 if (!Objcopy)
224 Objcopy = sys::findProgramByName(Name: "llvm-objcopy");
225 if (!Objcopy)
226 reportError(createStringError(EC: Objcopy.getError(),
227 Msg: "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 EC: errc::invalid_argument,
235 Msg: "-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(position: s.end(), first: InputFileNamesDeprecatedOpt.begin(),
243 last: InputFileNamesDeprecatedOpt.end());
244 }
245 BundlerConfig.InputFileNames = InputFileNames;
246
247 if (OutputFileNames.getNumOccurrences() != 0 &&
248 OutputFileNamesDeprecatedOpt.getNumOccurrences() != 0) {
249 reportError(createStringError(EC: errc::invalid_argument,
250 Msg: "-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(position: s.end(), first: OutputFileNamesDeprecatedOpt.begin(),
259 last: OutputFileNamesDeprecatedOpt.end());
260 }
261 BundlerConfig.OutputFileNames = OutputFileNames;
262
263 if (ListBundleIDs) {
264 if (Unbundle) {
265 reportError(
266 createStringError(EC: errc::invalid_argument,
267 Msg: "-unbundle and -list cannot be used together"));
268 }
269 if (InputFileNames.size() != 1) {
270 reportError(createStringError(EC: errc::invalid_argument,
271 Msg: "only one input file supported for -list"));
272 }
273 if (OutputFileNames.size()) {
274 reportError(createStringError(EC: errc::invalid_argument,
275 Msg: "-outputs option is invalid for -list"));
276 }
277 if (TargetNames.size()) {
278 reportError(createStringError(EC: errc::invalid_argument,
279 Msg: "-targets option is invalid for -list"));
280 }
281
282 doWork([&]() { return OffloadBundler::ListBundleIDsInFile(
283 InputFileName: InputFileNames.front(),
284 BundlerConfig); });
285 return 0;
286 }
287
288 if (BundlerConfig.CheckInputArchive) {
289 if (!Unbundle) {
290 reportError(createStringError(EC: errc::invalid_argument,
291 Msg: "-check-input-archive cannot be used while "
292 "bundling"));
293 }
294 if (Unbundle && BundlerConfig.FilesType != "a") {
295 reportError(createStringError(EC: errc::invalid_argument,
296 Msg: "-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(EC: errc::invalid_argument, Msg: "no output file specified!"));
304 }
305
306 if (TargetNames.getNumOccurrences() == 0) {
307 reportError(createStringError(
308 EC: errc::invalid_argument,
309 Msg: "for the --targets option: must be specified at least once!"));
310 }
311
312 if (Unbundle) {
313 if (InputFileNames.size() != 1) {
314 reportError(createStringError(
315 EC: errc::invalid_argument,
316 Msg: "only one input file supported in unbundling mode"));
317 }
318 if (OutputFileNames.size() != TargetNames.size()) {
319 reportError(createStringError(EC: errc::invalid_argument,
320 Msg: "number of output files and targets should "
321 "match in unbundling mode"));
322 }
323 } else {
324 if (BundlerConfig.FilesType == "a") {
325 reportError(createStringError(EC: errc::invalid_argument,
326 Msg: "Archive files are only supported "
327 "for unbundling"));
328 }
329 if (OutputFileNames.size() != 1) {
330 reportError(createStringError(
331 EC: errc::invalid_argument,
332 Msg: "only one output file supported in bundling mode"));
333 }
334 if (InputFileNames.size() != TargetNames.size()) {
335 reportError(createStringError(
336 EC: errc::invalid_argument,
337 Msg: "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.contains(V: Target)) {
353 reportError(createStringError(EC: errc::invalid_argument,
354 Msg: "Duplicate targets are not allowed"));
355 }
356 ParsedTargets.insert(V: Target);
357
358 auto OffloadInfo = OffloadTargetInfo(Target, BundlerConfig);
359 bool KindIsValid = OffloadInfo.isOffloadKindValid();
360 bool TripleIsValid = OffloadInfo.isTripleValid();
361
362 StandardizedTargetNames.push_back(x: OffloadInfo.str());
363
364 if (!KindIsValid || !TripleIsValid) {
365 SmallVector<char, 128u> Buf;
366 raw_svector_ostream Msg(Buf);
367 Msg << "invalid target '" << Target << "'";
368 if (!KindIsValid)
369 Msg << ", unknown offloading kind '" << OffloadInfo.OffloadKind << "'";
370 if (!TripleIsValid)
371 Msg << ", unknown target triple '" << OffloadInfo.Triple.str() << "'";
372 reportError(createStringError(EC: errc::invalid_argument, S: Msg.str()));
373 }
374
375 TargetIDs[OffloadInfo.OffloadKind.str() + "-" + OffloadInfo.Triple.str()]
376 .insert(x: OffloadInfo.TargetID);
377 if (KindIsValid && OffloadInfo.hasHostKind()) {
378 ++HostTargetNum;
379 // Save the index of the input that refers to the host.
380 BundlerConfig.HostInputIndex = Index;
381 }
382
383 if (OffloadInfo.OffloadKind != "hip" && OffloadInfo.OffloadKind != "hipv4")
384 HIPOnly = false;
385
386 ++Index;
387 }
388
389 BundlerConfig.TargetNames = StandardizedTargetNames;
390
391 for (const auto &TargetID : TargetIDs) {
392 if (auto ConflictingTID =
393 clang::getConflictTargetIDCombination(TargetIDs: TargetID.second)) {
394 SmallVector<char, 128u> Buf;
395 raw_svector_ostream Msg(Buf);
396 Msg << "Cannot bundle inputs with conflicting targets: '"
397 << TargetID.first + "-" + ConflictingTID->first << "' and '"
398 << TargetID.first + "-" + ConflictingTID->second << "'";
399 reportError(createStringError(EC: errc::invalid_argument, S: Msg.str()));
400 }
401 }
402
403 // HIP uses clang-offload-bundler to bundle device-only compilation results
404 // for multiple GPU archs, therefore allow no host target if all entries
405 // are for HIP.
406 BundlerConfig.AllowNoHost = HIPOnly;
407
408 // Host triple is not really needed for unbundling operation, so do not
409 // treat missing host triple as error if we do unbundling.
410 if ((Unbundle && HostTargetNum > 1) ||
411 (!Unbundle && HostTargetNum != 1 && !BundlerConfig.AllowNoHost)) {
412 reportError(createStringError(EC: errc::invalid_argument,
413 S: "expecting exactly one host target but got " +
414 Twine(HostTargetNum)));
415 }
416
417 OffloadBundler Bundler(BundlerConfig);
418
419 doWork([&]() {
420 if (Unbundle) {
421 if (BundlerConfig.FilesType == "a")
422 return Bundler.UnbundleArchive();
423 else
424 return Bundler.UnbundleFiles();
425 } else
426 return Bundler.BundleFiles();
427 });
428 return 0;
429}
430

source code of clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp