1//===--- Cuda.cpp - Cuda Tool and ToolChain Implementations -----*- C++ -*-===//
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#include "Cuda.h"
10#include "clang/Basic/Cuda.h"
11#include "clang/Config/config.h"
12#include "clang/Driver/CommonArgs.h"
13#include "clang/Driver/Compilation.h"
14#include "clang/Driver/Distro.h"
15#include "clang/Driver/Driver.h"
16#include "clang/Driver/InputInfo.h"
17#include "clang/Options/Options.h"
18#include "llvm/ADT/SmallSet.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/Config/llvm-config.h" // for LLVM_HOST_TRIPLE
21#include "llvm/Option/ArgList.h"
22#include "llvm/Support/FileSystem.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/Process.h"
25#include "llvm/Support/Program.h"
26#include "llvm/Support/VirtualFileSystem.h"
27#include "llvm/TargetParser/Host.h"
28#include "llvm/TargetParser/TargetParser.h"
29#include <system_error>
30
31using namespace clang::driver;
32using namespace clang::driver::toolchains;
33using namespace clang::driver::tools;
34using namespace clang;
35using namespace llvm::opt;
36
37namespace {
38
39CudaVersion getCudaVersion(uint32_t raw_version) {
40 if (raw_version < 7050)
41 return CudaVersion::CUDA_70;
42 if (raw_version < 8000)
43 return CudaVersion::CUDA_75;
44 if (raw_version < 9000)
45 return CudaVersion::CUDA_80;
46 if (raw_version < 9010)
47 return CudaVersion::CUDA_90;
48 if (raw_version < 9020)
49 return CudaVersion::CUDA_91;
50 if (raw_version < 10000)
51 return CudaVersion::CUDA_92;
52 if (raw_version < 10010)
53 return CudaVersion::CUDA_100;
54 if (raw_version < 10020)
55 return CudaVersion::CUDA_101;
56 if (raw_version < 11000)
57 return CudaVersion::CUDA_102;
58 if (raw_version < 11010)
59 return CudaVersion::CUDA_110;
60 if (raw_version < 11020)
61 return CudaVersion::CUDA_111;
62 if (raw_version < 11030)
63 return CudaVersion::CUDA_112;
64 if (raw_version < 11040)
65 return CudaVersion::CUDA_113;
66 if (raw_version < 11050)
67 return CudaVersion::CUDA_114;
68 if (raw_version < 11060)
69 return CudaVersion::CUDA_115;
70 if (raw_version < 11070)
71 return CudaVersion::CUDA_116;
72 if (raw_version < 11080)
73 return CudaVersion::CUDA_117;
74 if (raw_version < 11090)
75 return CudaVersion::CUDA_118;
76 if (raw_version < 12010)
77 return CudaVersion::CUDA_120;
78 if (raw_version < 12020)
79 return CudaVersion::CUDA_121;
80 if (raw_version < 12030)
81 return CudaVersion::CUDA_122;
82 if (raw_version < 12040)
83 return CudaVersion::CUDA_123;
84 if (raw_version < 12050)
85 return CudaVersion::CUDA_124;
86 if (raw_version < 12060)
87 return CudaVersion::CUDA_125;
88 if (raw_version < 12070)
89 return CudaVersion::CUDA_126;
90 if (raw_version < 12090)
91 return CudaVersion::CUDA_128;
92 if (raw_version < 13000)
93 return CudaVersion::CUDA_129;
94 if (raw_version < 13010)
95 return CudaVersion::CUDA_130;
96 if (raw_version < 13020)
97 return CudaVersion::CUDA_131;
98 if (raw_version < 13030)
99 return CudaVersion::CUDA_132;
100 if (raw_version < 13040)
101 return CudaVersion::CUDA_133;
102 if (raw_version < 13050)
103 return CudaVersion::CUDA_134;
104 return CudaVersion::NEW;
105}
106
107CudaVersion parseCudaHFile(llvm::StringRef Input) {
108 // Helper lambda which skips the words if the line starts with them or returns
109 // std::nullopt otherwise.
110 auto StartsWithWords =
111 [](llvm::StringRef Line,
112 const SmallVector<StringRef, 3> words) -> std::optional<StringRef> {
113 for (StringRef word : words) {
114 if (!Line.consume_front(Prefix: word))
115 return {};
116 Line = Line.ltrim();
117 }
118 return Line;
119 };
120
121 Input = Input.ltrim();
122 while (!Input.empty()) {
123 if (auto Line =
124 StartsWithWords(Input.ltrim(), {"#", "define", "CUDA_VERSION"})) {
125 uint32_t RawVersion;
126 Line->consumeInteger(Radix: 10, Result&: RawVersion);
127 return getCudaVersion(raw_version: RawVersion);
128 }
129 // Find next non-empty line.
130 Input = Input.drop_front(N: Input.find_first_of(Chars: "\n\r")).ltrim();
131 }
132 return CudaVersion::UNKNOWN;
133}
134} // namespace
135
136void CudaInstallationDetector::WarnIfUnsupportedVersion() const {
137 if (Version > CudaVersion::PARTIALLY_SUPPORTED) {
138 std::string VersionString = CudaVersionToString(V: Version);
139 if (!VersionString.empty())
140 VersionString.insert(pos: 0, s: " ");
141 D.Diag(DiagID: diag::warn_drv_new_cuda_version)
142 << VersionString
143 << (CudaVersion::PARTIALLY_SUPPORTED != CudaVersion::FULLY_SUPPORTED)
144 << CudaVersionToString(V: CudaVersion::PARTIALLY_SUPPORTED);
145 } else if (Version > CudaVersion::FULLY_SUPPORTED)
146 D.Diag(DiagID: diag::warn_drv_partially_supported_cuda_version)
147 << CudaVersionToString(V: Version);
148}
149
150CudaInstallationDetector::CudaInstallationDetector(
151 const Driver &D, const llvm::Triple &HostTriple,
152 const llvm::opt::ArgList &Args)
153 : D(D) {
154 struct Candidate {
155 std::string Path;
156 bool StrictChecking;
157
158 Candidate(std::string Path, bool StrictChecking = false)
159 : Path(Path), StrictChecking(StrictChecking) {}
160 };
161 SmallVector<Candidate, 4> Candidates;
162
163 // In decreasing order so we prefer newer versions to older versions.
164 std::initializer_list<const char *> Versions = {"8.0", "7.5", "7.0"};
165 auto &FS = D.getVFS();
166
167 if (Args.hasArg(Ids: options::OPT_cuda_path_EQ)) {
168 Candidates.emplace_back(
169 Args: Args.getLastArgValue(Id: options::OPT_cuda_path_EQ).str());
170 } else if (HostTriple.isOSWindows()) {
171 for (const char *Ver : Versions)
172 Candidates.emplace_back(
173 Args: D.SysRoot + "/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v" +
174 Ver);
175 } else {
176 if (!Args.hasArg(Ids: options::OPT_cuda_path_ignore_env)) {
177 // Try to find ptxas binary. If the executable is located in a directory
178 // called 'bin/', its parent directory might be a good guess for a valid
179 // CUDA installation.
180 // However, some distributions might installs 'ptxas' to /usr/bin. In that
181 // case the candidate would be '/usr' which passes the following checks
182 // because '/usr/include' exists as well. To avoid this case, we always
183 // check for the directory potentially containing files for libdevice,
184 // even if the user passes -nocudalib.
185 if (llvm::ErrorOr<std::string> ptxas =
186 llvm::sys::findProgramByName(Name: "ptxas")) {
187 SmallString<256> ptxasAbsolutePath;
188 llvm::sys::fs::real_path(path: *ptxas, output&: ptxasAbsolutePath);
189
190 StringRef ptxasDir = llvm::sys::path::parent_path(path: ptxasAbsolutePath);
191 if (llvm::sys::path::filename(path: ptxasDir) == "bin")
192 Candidates.emplace_back(
193 Args: std::string(llvm::sys::path::parent_path(path: ptxasDir)),
194 /*StrictChecking=*/Args: true);
195 }
196 }
197
198 Candidates.emplace_back(Args: D.SysRoot + "/usr/local/cuda");
199 for (const char *Ver : Versions)
200 Candidates.emplace_back(Args: D.SysRoot + "/usr/local/cuda-" + Ver);
201
202 Distro Dist(FS, llvm::Triple(llvm::sys::getProcessTriple()));
203 if (Dist.IsDebian() || Dist.IsUbuntu())
204 // Special case for Debian to have nvidia-cuda-toolkit work
205 // out of the box. More info on http://bugs.debian.org/882505
206 Candidates.emplace_back(Args: D.SysRoot + "/usr/lib/cuda");
207 }
208
209 bool NoCudaLib =
210 !Args.hasFlag(Pos: options::OPT_offloadlib, Neg: options::OPT_no_offloadlib, Default: true);
211
212 for (const auto &Candidate : Candidates) {
213 InstallPath = Candidate.Path;
214 if (InstallPath.empty() || !FS.exists(Path: InstallPath))
215 continue;
216
217 BinPath = InstallPath + "/bin";
218 IncludePath = InstallPath + "/include";
219 LibDevicePath = InstallPath + "/nvvm/libdevice";
220
221 if (!(FS.exists(Path: IncludePath) && FS.exists(Path: BinPath)))
222 continue;
223 bool CheckLibDevice = (!NoCudaLib || Candidate.StrictChecking);
224 if (CheckLibDevice && !FS.exists(Path: LibDevicePath))
225 continue;
226
227 Version = CudaVersion::UNKNOWN;
228 if (auto CudaHFile = FS.getBufferForFile(Name: InstallPath + "/include/cuda.h"))
229 Version = parseCudaHFile(Input: (*CudaHFile)->getBuffer());
230 // As the last resort, make an educated guess between CUDA-7.0, which had
231 // old-style libdevice bitcode, and an unknown recent CUDA version.
232 if (Version == CudaVersion::UNKNOWN) {
233 Version = FS.exists(Path: LibDevicePath + "/libdevice.10.bc")
234 ? CudaVersion::NEW
235 : CudaVersion::CUDA_70;
236 }
237
238 if (Version >= CudaVersion::CUDA_90) {
239 // CUDA-9+ uses single libdevice file for all GPU variants.
240 std::string FilePath = LibDevicePath + "/libdevice.10.bc";
241 if (FS.exists(Path: FilePath)) {
242 // CUDA-9+ uses a single libdevice file for every NVIDIA GPU variant
243 // (sm_30 and newer).
244#define NVPTX_GPU(NAME, KIND, VIRTUAL, SM_ID, MIN_VER, MAX_VER, SUFFIX) \
245 if ((SM_ID) >= 300) \
246 LibDeviceMap[NAME] = FilePath;
247#include "llvm/TargetParser/NVPTXTargetParser.def"
248 }
249 } else {
250 std::error_code EC;
251 for (llvm::vfs::directory_iterator LI = FS.dir_begin(Dir: LibDevicePath, EC),
252 LE;
253 !EC && LI != LE; LI = LI.increment(EC)) {
254 StringRef FilePath = LI->path();
255 StringRef FileName = llvm::sys::path::filename(path: FilePath);
256 // Process all bitcode filenames that look like
257 // libdevice.compute_XX.YY.bc
258 const StringRef LibDeviceName = "libdevice.";
259 if (!(FileName.starts_with(Prefix: LibDeviceName) && FileName.ends_with(Suffix: ".bc")))
260 continue;
261 StringRef GpuArch = FileName.slice(
262 Start: LibDeviceName.size(), End: FileName.find(C: '.', From: LibDeviceName.size()));
263 LibDeviceMap[GpuArch] = FilePath.str();
264 // Insert map entries for specific devices with this compute
265 // capability. NVCC's choice of the libdevice library version is
266 // rather peculiar and depends on the CUDA version.
267 if (GpuArch == "compute_20") {
268 LibDeviceMap["sm_20"] = std::string(FilePath);
269 LibDeviceMap["sm_21"] = std::string(FilePath);
270 LibDeviceMap["sm_32"] = std::string(FilePath);
271 } else if (GpuArch == "compute_30") {
272 LibDeviceMap["sm_30"] = std::string(FilePath);
273 if (Version < CudaVersion::CUDA_80) {
274 LibDeviceMap["sm_50"] = std::string(FilePath);
275 LibDeviceMap["sm_52"] = std::string(FilePath);
276 LibDeviceMap["sm_53"] = std::string(FilePath);
277 }
278 LibDeviceMap["sm_60"] = std::string(FilePath);
279 LibDeviceMap["sm_61"] = std::string(FilePath);
280 LibDeviceMap["sm_62"] = std::string(FilePath);
281 } else if (GpuArch == "compute_35") {
282 LibDeviceMap["sm_35"] = std::string(FilePath);
283 LibDeviceMap["sm_37"] = std::string(FilePath);
284 } else if (GpuArch == "compute_50") {
285 if (Version >= CudaVersion::CUDA_80) {
286 LibDeviceMap["sm_50"] = std::string(FilePath);
287 LibDeviceMap["sm_52"] = std::string(FilePath);
288 LibDeviceMap["sm_53"] = std::string(FilePath);
289 }
290 }
291 }
292 }
293
294 // Check that we have found at least one libdevice that we can link in if
295 // -nocudalib hasn't been specified.
296 if (LibDeviceMap.empty() && !NoCudaLib)
297 continue;
298
299 IsValid = true;
300 break;
301 }
302}
303
304void CudaInstallationDetector::AddCudaIncludeArgs(
305 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
306 if (DriverArgs.hasFlag(Pos: options::OPT_foffload_via_llvm,
307 Neg: options::OPT_fno_offload_via_llvm, Default: false))
308 return;
309
310 if (!DriverArgs.hasArg(Ids: options::OPT_nobuiltininc)) {
311 // Add cuda_wrappers/* to our system include path. This lets us wrap
312 // standard library headers.
313 SmallString<128> P(D.ResourceDir);
314 llvm::sys::path::append(path&: P, a: "include");
315 llvm::sys::path::append(path&: P, a: "cuda_wrappers");
316 CC1Args.push_back(Elt: "-internal-isystem");
317 CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: P));
318 }
319
320 if (!DriverArgs.hasFlag(Pos: options::OPT_offload_inc, Neg: options::OPT_no_offload_inc,
321 Default: true))
322 return;
323
324 if (!isValid()) {
325 D.Diag(DiagID: diag::err_drv_no_cuda_installation);
326 return;
327 }
328
329 CC1Args.push_back(Elt: "-include");
330 CC1Args.push_back(Elt: "__clang_cuda_runtime_wrapper.h");
331
332 // From CUDA 13.0 on, libcu++, CUB and Thrust are in include/cccl, and some
333 // of the toolkit's own headers, such as cooperative_groups.h, include them.
334 SmallString<128> CCCLPath(getIncludePath());
335 llvm::sys::path::append(path&: CCCLPath, a: "cccl");
336 if (D.getVFS().exists(Path: CCCLPath)) {
337 CC1Args.push_back(Elt: "-internal-isystem");
338 CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: CCCLPath));
339 }
340}
341
342void CudaInstallationDetector::CheckCudaVersionSupportsArch(
343 OffloadArch Arch) const {
344 // Only NVIDIA architectures depend on the CUDA toolkit version.
345 if (!Arch.isNVPTX() || Version == CudaVersion::UNKNOWN ||
346 ArchsWithBadVersion[Arch.nvptxKind()])
347 return;
348
349 auto MinVersion = MinVersionForOffloadArch(A: Arch);
350 auto MaxVersion = MaxVersionForOffloadArch(A: Arch);
351 if (Version < MinVersion || Version > MaxVersion) {
352 ArchsWithBadVersion[Arch.nvptxKind()] = true;
353 D.Diag(DiagID: diag::err_drv_cuda_version_unsupported)
354 << OffloadArchToString(A: Arch) << CudaVersionToString(V: MinVersion)
355 << CudaVersionToString(V: MaxVersion) << InstallPath
356 << CudaVersionToString(V: Version);
357 }
358}
359
360void CudaInstallationDetector::print(raw_ostream &OS) const {
361 if (isValid())
362 OS << "Found CUDA installation: " << InstallPath << ", version "
363 << CudaVersionToString(V: Version) << "\n";
364}
365
366namespace {
367/// Debug info level for the NVPTX devices. We may need to emit different debug
368/// info level for the host and for the device itselfi. This type controls
369/// emission of the debug info for the devices. It either prohibits disable info
370/// emission completely, or emits debug directives only, or emits same debug
371/// info as for the host.
372enum DeviceDebugInfoLevel {
373 DisableDebugInfo, /// Do not emit debug info for the devices.
374 DebugDirectivesOnly, /// Emit only debug directives.
375 EmitSameDebugInfoAsHost, /// Use the same debug info level just like for the
376 /// host.
377};
378} // anonymous namespace
379
380/// Define debug info level for the NVPTX devices. If the debug info for both
381/// the host and device are disabled (-g0/-ggdb0 or no debug options at all). If
382/// only debug directives are requested for the both host and device
383/// (-gline-directvies-only), or the debug info only for the device is disabled
384/// (optimization is on and --cuda-noopt-device-debug was not specified), the
385/// debug directves only must be emitted for the device. Otherwise, use the same
386/// debug info level just like for the host (with the limitations of only
387/// supported DWARF2 standard).
388static DeviceDebugInfoLevel mustEmitDebugInfo(const ArgList &Args) {
389 const Arg *A = Args.getLastArg(Ids: options::OPT_O_Group);
390 bool IsDebugEnabled = !A || A->getOption().matches(ID: options::OPT_O0) ||
391 Args.hasFlag(Pos: options::OPT_cuda_noopt_device_debug,
392 Neg: options::OPT_no_cuda_noopt_device_debug,
393 /*Default=*/false);
394 if (const Arg *A = Args.getLastArg(Ids: options::OPT_g_Group)) {
395 const Option &Opt = A->getOption();
396 if (Opt.matches(ID: options::OPT_gN_Group)) {
397 if (Opt.matches(ID: options::OPT_g0) || Opt.matches(ID: options::OPT_ggdb0))
398 return DisableDebugInfo;
399 if (Opt.matches(ID: options::OPT_gline_directives_only))
400 return DebugDirectivesOnly;
401 }
402 return IsDebugEnabled ? EmitSameDebugInfoAsHost : DebugDirectivesOnly;
403 }
404 return willEmitRemarks(Args) ? DebugDirectivesOnly : DisableDebugInfo;
405}
406
407void NVPTX::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
408 const InputInfo &Output,
409 const InputInfoList &Inputs,
410 const ArgList &Args,
411 const char *LinkingOutput) const {
412 const auto &TC =
413 static_cast<const toolchains::NVPTXToolChain &>(getToolChain());
414
415 bool UsesLLVMOffloading = Args.hasFlag(
416 Pos: options::OPT_foffload_via_llvm, Neg: options::OPT_fno_offload_via_llvm, Default: false);
417 assert((TC.getTriple().isNVPTX() || UsesLLVMOffloading) && "Wrong platform");
418
419 BoundArch GPUArch;
420 // If this is a CUDA action we need to extract the device architecture
421 // from the Job's associated architecture, otherwise use the -march=arch
422 // option. This option may come from -Xopenmp-target flag or the default
423 // value.
424 if (JA.isDeviceOffloading(OKind: Action::OFK_Cuda)) {
425 GPUArch = JA.getOffloadingArch();
426 } else {
427 GPUArch = BoundArch(Args.getLastArgValue(Id: options::OPT_march_EQ));
428 if (GPUArch.empty()) {
429 C.getDriver().Diag(DiagID: diag::err_drv_offload_missing_gpu_arch)
430 << getToolChain().getArchName() << getShortName();
431 return;
432 }
433 }
434
435 // Obtain architecture from the action.
436 assert(!GPUArch.Arch.isUnknown() &&
437 "Device action expected to have an architecture.");
438
439 // Check that our installation's ptxas supports gpu_arch.
440 if (!UsesLLVMOffloading && !Args.hasArg(Ids: options::OPT_no_cuda_version_check)) {
441 TC.CudaInstallation.CheckCudaVersionSupportsArch(Arch: GPUArch.Arch);
442 }
443
444 ArgStringList CmdArgs;
445 CmdArgs.push_back(Elt: TC.getTriple().isArch64Bit() ? "-m64" : "-m32");
446 DeviceDebugInfoLevel DIKind = mustEmitDebugInfo(Args);
447 if (DIKind == EmitSameDebugInfoAsHost) {
448 // ptxas does not accept -g option if optimization is enabled, so
449 // we ignore the compiler's -O* options if we want debug info.
450 CmdArgs.push_back(Elt: "-g");
451 CmdArgs.push_back(Elt: "--dont-merge-basicblocks");
452 CmdArgs.push_back(Elt: "--return-at-end");
453 } else if (Arg *A = Args.getLastArg(Ids: options::OPT_O_Group)) {
454 // Map the -O we received to -O{0,1,2,3}.
455 //
456 // TODO: Perhaps we should map host -O2 to ptxas -O3. -O3 is ptxas's
457 // default, so it may correspond more closely to the spirit of clang -O2.
458
459 // -O3 seems like the least-bad option when -Osomething is specified to
460 // clang but it isn't handled below.
461 StringRef OOpt = "3";
462 if (A->getOption().matches(ID: options::OPT_O4) ||
463 A->getOption().matches(ID: options::OPT_Ofast))
464 OOpt = "3";
465 else if (A->getOption().matches(ID: options::OPT_O0))
466 OOpt = "0";
467 else if (A->getOption().matches(ID: options::OPT_O)) {
468 // -Os, -Oz, and -O(anything else) map to -O2, for lack of better options.
469 OOpt = llvm::StringSwitch<const char *>(A->getValue())
470 .Case(S: "1", Value: "1")
471 .Case(S: "2", Value: "2")
472 .Case(S: "3", Value: "3")
473 .Case(S: "s", Value: "2")
474 .Case(S: "z", Value: "2")
475 .Default(Value: "2");
476 }
477 CmdArgs.push_back(Elt: Args.MakeArgString(Str: llvm::Twine("-O") + OOpt));
478 } else {
479 // If no -O was passed, pass -O0 to ptxas -- no opt flag should correspond
480 // to no optimizations, but ptxas's default is -O3.
481 CmdArgs.push_back(Elt: "-O0");
482 }
483 if (DIKind == DebugDirectivesOnly)
484 CmdArgs.push_back(Elt: "-lineinfo");
485
486 // Pass -v to ptxas if it was passed to the driver.
487 if (Args.hasArg(Ids: options::OPT_v))
488 CmdArgs.push_back(Elt: "-v");
489
490 CmdArgs.push_back(Elt: "--gpu-name");
491 CmdArgs.push_back(Elt: Args.MakeArgString(Str: GPUArch.ArchName));
492 CmdArgs.push_back(Elt: "--output-file");
493 std::string OutputFileName = TC.getInputFilename(Input: Output);
494
495 if (Output.isFilename() && OutputFileName != Output.getFilename())
496 C.addTempFile(Name: Args.MakeArgString(Str: OutputFileName));
497
498 CmdArgs.push_back(Elt: Args.MakeArgString(Str: OutputFileName));
499 for (const auto &II : Inputs)
500 CmdArgs.push_back(Elt: Args.MakeArgString(Str: II.getFilename()));
501
502 for (const auto &A : Args.getAllArgValues(Id: options::OPT_Xcuda_ptxas))
503 CmdArgs.push_back(Elt: Args.MakeArgString(Str: A));
504
505 bool Relocatable;
506 if (JA.isOffloading(OKind: Action::OFK_OpenMP))
507 // In OpenMP we need to generate relocatable code.
508 Relocatable = Args.hasFlag(Pos: options::OPT_fopenmp_relocatable_target,
509 Neg: options::OPT_fnoopenmp_relocatable_target,
510 /*Default=*/true);
511 else if (JA.isOffloading(OKind: Action::OFK_Cuda))
512 // In CUDA we generate relocatable code by default.
513 Relocatable = UsesLLVMOffloading ||
514 Args.hasFlag(Pos: options::OPT_fgpu_rdc, Neg: options::OPT_fno_gpu_rdc,
515 /*Default=*/false);
516 else
517 // Otherwise, we are compiling directly and should create linkable output.
518 Relocatable = true;
519
520 if (Relocatable)
521 CmdArgs.push_back(Elt: "-c");
522
523 const char *Exec;
524 if (Arg *A = Args.getLastArg(Ids: options::OPT_ptxas_path_EQ))
525 Exec = A->getValue();
526 else
527 Exec = Args.MakeArgString(Str: TC.GetProgramPath(Name: "ptxas"));
528 C.addCommand(Cmd: std::make_unique<Command>(
529 args: JA, args: *this,
530 args: ResponseFileSupport{.ResponseKind: ResponseFileSupport::RF_Full, .ResponseEncoding: llvm::sys::WEM_UTF8,
531 .ResponseFlag: "--options-file="},
532 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
533}
534
535static bool shouldIncludePTX(const ArgList &Args, StringRef InputArch) {
536 bool includePTX = false;
537 for (Arg *A : Args.filtered(Ids: options::OPT_cuda_include_ptx_EQ,
538 Ids: options::OPT_no_cuda_include_ptx_EQ)) {
539 A->claim();
540 const StringRef ArchStr = A->getValue();
541 if (A->getOption().matches(ID: options::OPT_cuda_include_ptx_EQ) &&
542 (ArchStr == "all" || ArchStr == InputArch))
543 includePTX = true;
544 else if (A->getOption().matches(ID: options::OPT_no_cuda_include_ptx_EQ) &&
545 (ArchStr == "all" || ArchStr == InputArch))
546 includePTX = false;
547 }
548 return includePTX;
549}
550
551// All inputs to this linker must be from CudaDeviceActions, as we need to look
552// at the Inputs' Actions in order to figure out which GPU architecture they
553// correspond to.
554void NVPTX::FatBinary::ConstructJob(Compilation &C, const JobAction &JA,
555 const InputInfo &Output,
556 const InputInfoList &Inputs,
557 const ArgList &Args,
558 const char *LinkingOutput) const {
559 const auto &TC =
560 static_cast<const toolchains::CudaToolChain &>(getToolChain());
561 [[maybe_unused]] bool UsesLLVMOffloading = Args.hasFlag(
562 Pos: options::OPT_foffload_via_llvm, Neg: options::OPT_fno_offload_via_llvm, Default: false);
563 assert((UsesLLVMOffloading || TC.getTriple().isNVPTX()) && "Wrong platform");
564
565 ArgStringList CmdArgs;
566 if (TC.CudaInstallation.version() <= CudaVersion::CUDA_100)
567 CmdArgs.push_back(Elt: "--cuda");
568 CmdArgs.push_back(Elt: TC.getTriple().isArch64Bit() ? "-64" : "-32");
569 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--create"));
570 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Output.getFilename()));
571 if (mustEmitDebugInfo(Args) == EmitSameDebugInfoAsHost)
572 CmdArgs.push_back(Elt: "-g");
573
574 for (const auto &II : Inputs) {
575 auto *A = II.getAction();
576 assert(A->getInputs().size() == 1 &&
577 "Device offload action is expected to have a single input");
578 BoundArch GpuArch = A->getOffloadingArch();
579 assert(!GpuArch.empty() &&
580 "Device action expected to have associated a GPU architecture!");
581
582 if (II.getType() == types::TY_PP_Asm &&
583 !shouldIncludePTX(Args, InputArch: GpuArch.ArchName))
584 continue;
585 StringRef Kind = (II.getType() == types::TY_PP_Asm) ? "ptx" : "elf";
586 CmdArgs.push_back(Elt: Args.MakeArgString(
587 Str: "--image3=kind=" + Kind + ",sm=" + GpuArch.ArchName.drop_front(N: 3) +
588 ",file=" + getToolChain().getInputFilename(Input: II)));
589 }
590
591 for (const auto &A : Args.getAllArgValues(Id: options::OPT_Xcuda_fatbinary))
592 CmdArgs.push_back(Elt: Args.MakeArgString(Str: A));
593
594 const char *Exec = Args.MakeArgString(Str: TC.GetProgramPath(Name: "fatbinary"));
595 C.addCommand(Cmd: std::make_unique<Command>(
596 args: JA, args: *this,
597 args: ResponseFileSupport{.ResponseKind: ResponseFileSupport::RF_Full, .ResponseEncoding: llvm::sys::WEM_UTF8,
598 .ResponseFlag: "--options-file="},
599 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
600}
601
602void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
603 const InputInfo &Output,
604 const InputInfoList &Inputs,
605 const ArgList &Args,
606 const char *LinkingOutput) const {
607 const auto &TC =
608 static_cast<const toolchains::NVPTXToolChain &>(getToolChain());
609 ArgStringList CmdArgs;
610
611 [[maybe_unused]] bool UsesLLVMOffloading = Args.hasFlag(
612 Pos: options::OPT_foffload_via_llvm, Neg: options::OPT_fno_offload_via_llvm, Default: false);
613 assert((UsesLLVMOffloading || TC.getTriple().isNVPTX()) && "Wrong platform");
614
615 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
616 if (Output.isFilename()) {
617 CmdArgs.push_back(Elt: "-o");
618 CmdArgs.push_back(Elt: Output.getFilename());
619 }
620
621 if (mustEmitDebugInfo(Args) == EmitSameDebugInfoAsHost)
622 CmdArgs.push_back(Elt: "-g");
623
624 if (Args.hasArg(Ids: options::OPT_v))
625 CmdArgs.push_back(Elt: "-v");
626
627 StringRef GPUArch = Args.getLastArgValue(Id: options::OPT_march_EQ);
628 if (GPUArch.empty() && !getToolChain().isUsingLTO(Args)) {
629 C.getDriver().Diag(DiagID: diag::err_drv_offload_missing_gpu_arch)
630 << getToolChain().getArchName() << getShortName();
631 return;
632 }
633
634 if (!GPUArch.empty()) {
635 CmdArgs.push_back(Elt: "-arch");
636 CmdArgs.push_back(Elt: Args.MakeArgString(Str: GPUArch));
637 }
638
639 if (Args.hasArg(Ids: options::OPT_ptxas_path_EQ))
640 CmdArgs.push_back(Elt: Args.MakeArgString(
641 Str: "--ptxas-path=" + Args.getLastArgValue(Id: options::OPT_ptxas_path_EQ)));
642
643 // The wrapper runs 'ptxas' itself when doing LTO, so it needs these.
644 for (const Arg *A : Args.filtered(Ids: options::OPT_Xcuda_ptxas)) {
645 A->claim();
646 CmdArgs.append(IL: {"-Xptxas", A->getValue()});
647 }
648
649 if (Args.hasArg(Ids: options::OPT_cuda_path_EQ) || TC.CudaInstallation.isValid()) {
650 StringRef CudaPath = Args.getLastArgValue(
651 Id: options::OPT_cuda_path_EQ,
652 Default: llvm::sys::path::parent_path(path: TC.CudaInstallation.getBinPath()));
653 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--cuda-path=" + CudaPath));
654 }
655
656 // Add paths specified in LIBRARY_PATH environment variable as -L options.
657 addDirectoryList(Args, CmdArgs, ArgName: "-L", EnvVar: "LIBRARY_PATH");
658
659 // Add standard library search paths passed on the command line.
660 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_L);
661 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
662 AddLinkerInputs(TC: getToolChain(), Inputs, Args, CmdArgs, JA);
663
664 if (auto LTO = getToolChain().getLTOMode(Args); LTO != LTOK_None)
665 addLTOOptions(ToolChain: getToolChain(), Args, CmdArgs, Output, Inputs,
666 IsThinLTO: LTO == LTOK_Thin);
667
668 // Forward the PTX features if the nvlink-wrapper needs it.
669 std::vector<StringRef> Features;
670 getNVPTXTargetFeatures(D: C.getDriver(), Triple: getToolChain().getTriple(), Args,
671 Features);
672 CmdArgs.push_back(
673 Elt: Args.MakeArgString(Str: "--plugin-opt=-mattr=" + llvm::join(R&: Features, Separator: ",")));
674
675 // Add paths for the default clang library path.
676 SmallString<256> DefaultLibPath =
677 llvm::sys::path::parent_path(path: TC.getDriver().Dir);
678 llvm::sys::path::append(path&: DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
679 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("-L") + DefaultLibPath));
680
681 getToolChain().addProfileRTLibs(Args, CmdArgs);
682 addSanitizerRuntimes(TC: getToolChain(), Args, CmdArgs, C);
683
684 if (Args.hasArg(Ids: options::OPT_stdlib))
685 CmdArgs.append(IL: {"-lc", "-lm"});
686 if (Args.hasArg(Ids: options::OPT_startfiles)) {
687 std::optional<std::string> IncludePath = getToolChain().getStdlibPath();
688 if (!IncludePath)
689 IncludePath = "/lib";
690 SmallString<128> P(*IncludePath);
691 llvm::sys::path::append(path&: P, a: "crt1.o");
692 CmdArgs.push_back(Elt: Args.MakeArgString(Str: P));
693 }
694
695 C.addCommand(Cmd: std::make_unique<Command>(
696 args: JA, args: *this, args: ResponseFileSupport::AtFileUTF8(),
697 args: Args.MakeArgString(Str: getToolChain().GetProgramPath(Name: "clang-nvlink-wrapper")),
698 args&: CmdArgs, args: Inputs, args: Output));
699}
700
701void NVPTX::getNVPTXTargetFeatures(const Driver &D, const llvm::Triple &Triple,
702 const llvm::opt::ArgList &Args,
703 std::vector<StringRef> &Features) {
704 if (Args.hasArg(Ids: options::OPT_cuda_feature_EQ)) {
705 StringRef PtxFeature = Args.getLastArgValue(Id: options::OPT_cuda_feature_EQ);
706 Features.push_back(x: Args.MakeArgString(Str: PtxFeature));
707 return;
708 }
709 CudaInstallationDetector CudaInstallation(D, Triple, Args);
710
711 // New CUDA versions often introduce new instructions that are only supported
712 // by new PTX version, so we need to raise PTX level to enable them in NVPTX
713 // back-end.
714 const char *PtxFeature = nullptr;
715 switch (CudaInstallation.version()) {
716#define CASE_CUDA_VERSION(CUDA_VER, PTX_VER) \
717 case CudaVersion::CUDA_##CUDA_VER: \
718 PtxFeature = "+ptx" #PTX_VER; \
719 break;
720 CASE_CUDA_VERSION(134, 94);
721 CASE_CUDA_VERSION(133, 93);
722 CASE_CUDA_VERSION(132, 92);
723 CASE_CUDA_VERSION(131, 91);
724 CASE_CUDA_VERSION(130, 90);
725 CASE_CUDA_VERSION(129, 88);
726 CASE_CUDA_VERSION(128, 87);
727 CASE_CUDA_VERSION(126, 85);
728 CASE_CUDA_VERSION(125, 85);
729 CASE_CUDA_VERSION(124, 84);
730 CASE_CUDA_VERSION(123, 83);
731 CASE_CUDA_VERSION(122, 82);
732 CASE_CUDA_VERSION(121, 81);
733 CASE_CUDA_VERSION(120, 80);
734 CASE_CUDA_VERSION(118, 78);
735 CASE_CUDA_VERSION(117, 77);
736 CASE_CUDA_VERSION(116, 76);
737 CASE_CUDA_VERSION(115, 75);
738 CASE_CUDA_VERSION(114, 74);
739 CASE_CUDA_VERSION(113, 73);
740 CASE_CUDA_VERSION(112, 72);
741 CASE_CUDA_VERSION(111, 71);
742 CASE_CUDA_VERSION(110, 70);
743 CASE_CUDA_VERSION(102, 65);
744 CASE_CUDA_VERSION(101, 64);
745 CASE_CUDA_VERSION(100, 63);
746 CASE_CUDA_VERSION(92, 61);
747 CASE_CUDA_VERSION(91, 61);
748 CASE_CUDA_VERSION(90, 60);
749 CASE_CUDA_VERSION(80, 50);
750 CASE_CUDA_VERSION(75, 43);
751 CASE_CUDA_VERSION(70, 42);
752#undef CASE_CUDA_VERSION
753 // TODO: Use specific CUDA version once it's public.
754 case clang::CudaVersion::NEW:
755 PtxFeature = "+ptx86";
756 break;
757 default:
758 // No PTX feature specified; let the backend choose based on the target SM.
759 break;
760 }
761 if (PtxFeature)
762 Features.push_back(x: PtxFeature);
763}
764
765/// NVPTX toolchain. Our assembler is ptxas, and our linker is nvlink. This
766/// operates as a stand-alone version of the NVPTX tools without the host
767/// toolchain.
768NVPTXToolChain::NVPTXToolChain(const Driver &D, const llvm::Triple &Triple,
769 const llvm::Triple &HostTriple,
770 const ArgList &Args)
771 : ToolChain(D, Triple, Args), CudaInstallation(D, HostTriple, Args) {
772 if (CudaInstallation.isValid())
773 getProgramPaths().push_back(Elt: std::string(CudaInstallation.getBinPath()));
774 // Lookup binaries into the driver directory, this is used to
775 // discover the 'nvptx-arch' executable.
776 getProgramPaths().push_back(Elt: getDriver().Dir);
777}
778
779/// We only need the host triple to locate the CUDA binary utilities, use the
780/// system's default triple if not provided.
781NVPTXToolChain::NVPTXToolChain(const Driver &D, const llvm::Triple &Triple,
782 const ArgList &Args)
783 : NVPTXToolChain(D, Triple, llvm::Triple(LLVM_HOST_TRIPLE), Args) {
784 loadMultilibsFromYAML(Args, D);
785}
786
787llvm::opt::DerivedArgList *
788NVPTXToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
789 BoundArch BA,
790 Action::OffloadKind OffloadKind) const {
791 DerivedArgList *DAL = ToolChain::TranslateArgs(Args, BA, DeviceOffloadKind: OffloadKind);
792 if (!DAL)
793 DAL = new DerivedArgList(Args.getBaseArgs());
794
795 const OptTable &Opts = getDriver().getOpts();
796
797 for (Arg *A : Args)
798 if (!llvm::is_contained(Range&: *DAL, Element: A))
799 DAL->append(A);
800
801 if (!DAL->hasArg(Ids: options::OPT_march_EQ) && OffloadKind != Action::OFK_None) {
802 DAL->AddJoinedArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_march_EQ),
803 Value: OffloadArchToString(A: OffloadArch::CudaDefault()));
804 } else if (DAL->getLastArgValue(Id: options::OPT_march_EQ) == "generic" &&
805 OffloadKind == Action::OFK_None) {
806 DAL->eraseArg(Id: options::OPT_march_EQ);
807 } else if (DAL->getLastArgValue(Id: options::OPT_march_EQ) == "native") {
808 auto GPUsOrErr = getSystemGPUArchs(Args);
809 if (!GPUsOrErr) {
810 getDriver().Diag(DiagID: diag::err_drv_undetermined_gpu_arch)
811 << getArchName() << llvm::toString(E: GPUsOrErr.takeError()) << "-march";
812 } else {
813 auto &GPUs = *GPUsOrErr;
814 if (llvm::SmallSet<std::string, 1>(GPUs.begin(), GPUs.end()).size() > 1)
815 getDriver().Diag(DiagID: diag::warn_drv_multi_gpu_arch)
816 << getArchName() << llvm::join(R&: GPUs, Separator: ", ") << "-march";
817 DAL->AddJoinedArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_march_EQ),
818 Value: Args.MakeArgString(Str: GPUs.front()));
819 }
820 }
821
822 return DAL;
823}
824
825void NVPTXToolChain::addClangTargetOptions(
826 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
827 BoundArch BA, Action::OffloadKind DeviceOffloadingKind) const {}
828
829void NVPTXToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
830 ArgStringList &CC1Args) const {
831 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc) ||
832 DriverArgs.hasArg(Ids: options::OPT_nostdlibinc))
833 return;
834
835 // Add multilib variant include paths in priority order.
836 for (const Multilib &M : getOrderedMultilibs()) {
837 if (M.isDefault())
838 continue;
839 if (std::optional<std::string> StdlibIncDir = getStdlibIncludePath()) {
840 SmallString<128> Dir(*StdlibIncDir);
841 llvm::sys::path::append(path&: Dir, a: M.includeSuffix());
842 if (getDriver().getVFS().exists(Path: Dir))
843 addSystemInclude(DriverArgs, CC1Args, Path: Dir);
844 }
845 }
846
847 if (std::optional<std::string> Path = getStdlibIncludePath())
848 addSystemInclude(DriverArgs, CC1Args, Path: *Path);
849}
850
851bool NVPTXToolChain::supportsDebugInfoOption(const llvm::opt::Arg *A) const {
852 const Option &O = A->getOption();
853 return (O.matches(ID: options::OPT_gN_Group) &&
854 !O.matches(ID: options::OPT_gmodules)) ||
855 O.matches(ID: options::OPT_g_Flag) ||
856 O.matches(ID: options::OPT_ggdbN_Group) || O.matches(ID: options::OPT_ggdb) ||
857 O.matches(ID: options::OPT_gdwarf) || O.matches(ID: options::OPT_gdwarf_2) ||
858 O.matches(ID: options::OPT_gdwarf_3) || O.matches(ID: options::OPT_gdwarf_4) ||
859 O.matches(ID: options::OPT_gdwarf_5) ||
860 O.matches(ID: options::OPT_gcolumn_info);
861}
862
863void NVPTXToolChain::adjustDebugInfoKind(
864 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
865 const ArgList &Args) const {
866 switch (mustEmitDebugInfo(Args)) {
867 case DisableDebugInfo:
868 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
869 break;
870 case DebugDirectivesOnly:
871 DebugInfoKind = llvm::codegenoptions::DebugDirectivesOnly;
872 break;
873 case EmitSameDebugInfoAsHost:
874 // Use same debug info level as the host.
875 break;
876 }
877}
878
879Expected<SmallVector<std::string>>
880NVPTXToolChain::getSystemGPUArchs(const ArgList &Args) const {
881 // Detect NVIDIA GPUs availible on the system.
882 std::string Program;
883 if (Arg *A = Args.getLastArg(Ids: options::OPT_offload_arch_tool_EQ))
884 Program = A->getValue();
885 else
886 Program = GetProgramPath(Name: "nvptx-arch");
887
888 auto StdoutOrErr = getDriver().executeProgram(Args: {Program});
889 if (!StdoutOrErr)
890 return StdoutOrErr.takeError();
891
892 SmallVector<std::string, 1> GPUArchs;
893 for (StringRef Arch : llvm::split(Str: (*StdoutOrErr)->getBuffer(), Separator: "\n"))
894 if (!Arch.empty())
895 GPUArchs.push_back(Elt: Arch.str());
896
897 if (GPUArchs.empty())
898 return llvm::createStringError(EC: std::error_code(),
899 S: "No NVIDIA GPU detected in the system");
900
901 return std::move(GPUArchs);
902}
903
904/// CUDA toolchain. Our assembler is ptxas, and our "linker" is fatbinary,
905/// which isn't properly a linker but nonetheless performs the step of stitching
906/// together object files from the assembler into a single blob.
907
908CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
909 const ToolChain &HostTC, const ArgList &Args)
910 : NVPTXToolChain(D, Triple, HostTC.getTriple(), Args), HostTC(HostTC) {}
911
912void CudaToolChain::addClangTargetOptions(
913 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
914 BoundArch BA, Action::OffloadKind DeviceOffloadingKind) const {
915 HostTC.addClangTargetOptions(DriverArgs, CC1Args, BA, DeviceOffloadKind: DeviceOffloadingKind);
916
917 bool UsesLLVMOffloading = DriverArgs.hasFlag(
918 Pos: options::OPT_foffload_via_llvm, Neg: options::OPT_fno_offload_via_llvm, Default: false);
919
920 StringRef GpuArch = DriverArgs.getLastArgValue(Id: options::OPT_march_EQ);
921 assert((DeviceOffloadingKind == Action::OFK_OpenMP ||
922 DeviceOffloadingKind == Action::OFK_Cuda || UsesLLVMOffloading) &&
923 "Only OpenMP or CUDA offloading kinds are supported for NVIDIA GPUs.");
924
925 CC1Args.append(IL: {"-fcuda-is-device", "-fno-threadsafe-statics"});
926
927 if (DriverArgs.hasFlag(Pos: options::OPT_fcuda_short_ptr,
928 Neg: options::OPT_fno_cuda_short_ptr, Default: false))
929 CC1Args.append(IL: {"-target-abi", "shortptr"});
930
931 if (!DriverArgs.hasFlag(Pos: options::OPT_offloadlib, Neg: options::OPT_no_offloadlib,
932 Default: true))
933 return;
934
935 if (DeviceOffloadingKind == Action::OFK_OpenMP &&
936 DriverArgs.hasArg(Ids: options::OPT_S))
937 return;
938
939 if (UsesLLVMOffloading)
940 return;
941
942 std::string LibDeviceFile = CudaInstallation.getLibDeviceFile(Gpu: GpuArch);
943 if (LibDeviceFile.empty()) {
944 getDriver().Diag(DiagID: diag::err_drv_no_cuda_libdevice) << GpuArch;
945 return;
946 }
947
948 CC1Args.push_back(Elt: "-mlink-builtin-bitcode");
949 CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: LibDeviceFile));
950
951 clang::CudaVersion CudaInstallationVersion = CudaInstallation.version();
952
953 if (CudaInstallationVersion >= CudaVersion::UNKNOWN)
954 CC1Args.push_back(
955 Elt: DriverArgs.MakeArgString(Str: Twine("-target-sdk-version=") +
956 CudaVersionToString(V: CudaInstallationVersion)));
957
958 if (DeviceOffloadingKind == Action::OFK_OpenMP) {
959 if (CudaInstallationVersion < CudaVersion::CUDA_92) {
960 getDriver().Diag(
961 DiagID: diag::err_drv_omp_offload_target_cuda_version_not_support)
962 << CudaVersionToString(V: CudaInstallationVersion);
963 return;
964 }
965
966 // Link the bitcode library late if we're using device LTO.
967 if (isUsingLTO(Args: DriverArgs, Kind: DeviceOffloadingKind))
968 return;
969
970 addOpenMPDeviceRTL(D: getDriver(), DriverArgs, CC1Args, BitcodeSuffix: GpuArch.str(),
971 Triple: getTriple(), HostTC);
972 }
973}
974
975llvm::DenormalMode CudaToolChain::getDefaultDenormalModeForType(
976 const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
977 const llvm::fltSemantics *FPType) const {
978 if (JA.getOffloadingDeviceKind() == Action::OFK_Cuda) {
979 if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
980 DriverArgs.hasFlag(Pos: options::OPT_fgpu_flush_denormals_to_zero,
981 Neg: options::OPT_fno_gpu_flush_denormals_to_zero, Default: false))
982 return llvm::DenormalMode::getPreserveSign();
983 }
984
985 assert(JA.getOffloadingDeviceKind() != Action::OFK_Host);
986 return llvm::DenormalMode::getIEEE();
987}
988
989void CudaToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
990 ArgStringList &CC1Args) const {
991 if (DriverArgs.hasFlag(Pos: options::OPT_foffload_via_llvm,
992 Neg: options::OPT_fno_offload_via_llvm, Default: false))
993 return;
994
995 // Check our CUDA version if we're going to include the CUDA headers.
996 if (DriverArgs.hasFlag(Pos: options::OPT_offload_inc, Neg: options::OPT_no_offload_inc,
997 Default: true) &&
998 !DriverArgs.hasArg(Ids: options::OPT_no_cuda_version_check)) {
999 StringRef Arch = DriverArgs.getLastArgValue(Id: options::OPT_march_EQ);
1000 assert(!Arch.empty() && "Must have an explicit GPU arch.");
1001 CudaInstallation.CheckCudaVersionSupportsArch(Arch: StringToOffloadArch(S: Arch));
1002 }
1003 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
1004}
1005
1006std::string CudaToolChain::getInputFilename(const InputInfo &Input) const {
1007 // Only object files are changed, for example assembly files keep their .s
1008 // extensions. If the user requested device-only compilation don't change it.
1009 if (Input.getType() != types::TY_Object || getDriver().offloadDeviceOnly())
1010 return ToolChain::getInputFilename(Input);
1011
1012 return ToolChain::getInputFilename(Input);
1013}
1014
1015llvm::opt::DerivedArgList *
1016CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
1017 BoundArch BA,
1018 Action::OffloadKind DeviceOffloadKind) const {
1019 DerivedArgList *DAL = HostTC.TranslateArgs(Args, BA, DeviceOffloadKind);
1020 if (!DAL)
1021 DAL = new DerivedArgList(Args.getBaseArgs());
1022
1023 const OptTable &Opts = getDriver().getOpts();
1024
1025 for (Arg *A : Args) {
1026 // Make sure flags are not duplicated.
1027 if (!llvm::is_contained(Range&: *DAL, Element: A)) {
1028 DAL->append(A);
1029 }
1030 }
1031
1032 if (BA) {
1033 DAL->eraseArg(Id: options::OPT_march_EQ);
1034 DAL->AddJoinedArg(BaseArg: nullptr, Opt: Opts.getOption(Opt: options::OPT_march_EQ),
1035 Value: BA.ArchName);
1036 }
1037 return DAL;
1038}
1039
1040Tool *NVPTXToolChain::buildAssembler() const {
1041 return new tools::NVPTX::Assembler(*this);
1042}
1043
1044Tool *NVPTXToolChain::buildLinker() const {
1045 return new tools::NVPTX::Linker(*this);
1046}
1047
1048Tool *CudaToolChain::buildAssembler() const {
1049 return new tools::NVPTX::Assembler(*this);
1050}
1051
1052Tool *CudaToolChain::buildLinker() const {
1053 return new tools::NVPTX::FatBinary(*this);
1054}
1055
1056void CudaToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {
1057 HostTC.addClangWarningOptions(CC1Args);
1058}
1059
1060ToolChain::CXXStdlibType
1061CudaToolChain::GetCXXStdlibType(const ArgList &Args) const {
1062 return HostTC.GetCXXStdlibType(Args);
1063}
1064
1065void CudaToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1066 ArgStringList &CC1Args) const {
1067 if (DriverArgs.hasFlag(Pos: options::OPT_foffload_via_llvm,
1068 Neg: options::OPT_fno_offload_via_llvm, Default: false))
1069 return;
1070
1071 HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args);
1072
1073 if (DriverArgs.hasFlag(Pos: options::OPT_offload_inc, Neg: options::OPT_no_offload_inc,
1074 Default: true) &&
1075 CudaInstallation.isValid())
1076 CC1Args.append(
1077 IL: {"-internal-isystem",
1078 DriverArgs.MakeArgString(Str: CudaInstallation.getIncludePath())});
1079}
1080
1081void CudaToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args,
1082 ArgStringList &CC1Args) const {
1083 HostTC.AddClangCXXStdlibIncludeArgs(DriverArgs: Args, CC1Args);
1084}
1085
1086void CudaToolChain::AddIAMCUIncludeArgs(const ArgList &Args,
1087 ArgStringList &CC1Args) const {
1088 HostTC.AddIAMCUIncludeArgs(DriverArgs: Args, CC1Args);
1089}
1090
1091SanitizerMask CudaToolChain::getSupportedSanitizers(
1092 BoundArch BA, Action::OffloadKind DeviceOffloadKind) const {
1093 // The CudaToolChain only supports sanitizers in the sense that it allows
1094 // sanitizer arguments on the command line if they are supported by the host
1095 // toolchain. The CudaToolChain will actually ignore any command line
1096 // arguments for any of these "supported" sanitizers. That means that no
1097 // sanitization of device code is actually supported at this time.
1098 //
1099 // This behavior is necessary because the host and device toolchains
1100 // invocations often share the command line, so the device toolchain must
1101 // tolerate flags meant only for the host toolchain.
1102
1103 // FIXME: Be accurate and use DeviceOffloadKind.
1104 return HostTC.getSupportedSanitizers(BA, DeviceOffloadKind);
1105}
1106
1107VersionTuple CudaToolChain::computeMSVCVersion(const Driver *D,
1108 const ArgList &Args) const {
1109 return HostTC.computeMSVCVersion(D, Args);
1110}
1111