12#include "clang/Config/config.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/Option/ArgList.h"
21#include "llvm/Support/FileSystem.h"
22#include "llvm/Support/FormatAdapters.h"
23#include "llvm/Support/FormatVariadic.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/Process.h"
26#include "llvm/Support/Program.h"
27#include "llvm/Support/VirtualFileSystem.h"
28#include "llvm/TargetParser/Host.h"
29#include "llvm/TargetParser/TargetParser.h"
30#include <system_error>
41 if (raw_version < 7050)
42 return CudaVersion::CUDA_70;
43 if (raw_version < 8000)
44 return CudaVersion::CUDA_75;
45 if (raw_version < 9000)
46 return CudaVersion::CUDA_80;
47 if (raw_version < 9010)
48 return CudaVersion::CUDA_90;
49 if (raw_version < 9020)
50 return CudaVersion::CUDA_91;
51 if (raw_version < 10000)
52 return CudaVersion::CUDA_92;
53 if (raw_version < 10010)
54 return CudaVersion::CUDA_100;
55 if (raw_version < 10020)
56 return CudaVersion::CUDA_101;
57 if (raw_version < 11000)
58 return CudaVersion::CUDA_102;
59 if (raw_version < 11010)
60 return CudaVersion::CUDA_110;
61 if (raw_version < 11020)
62 return CudaVersion::CUDA_111;
63 if (raw_version < 11030)
64 return CudaVersion::CUDA_112;
65 if (raw_version < 11040)
66 return CudaVersion::CUDA_113;
67 if (raw_version < 11050)
68 return CudaVersion::CUDA_114;
69 if (raw_version < 11060)
70 return CudaVersion::CUDA_115;
71 if (raw_version < 11070)
72 return CudaVersion::CUDA_116;
73 if (raw_version < 11080)
74 return CudaVersion::CUDA_117;
75 if (raw_version < 11090)
76 return CudaVersion::CUDA_118;
77 if (raw_version < 12010)
78 return CudaVersion::CUDA_120;
79 if (raw_version < 12020)
80 return CudaVersion::CUDA_121;
81 if (raw_version < 12030)
82 return CudaVersion::CUDA_122;
83 if (raw_version < 12040)
84 return CudaVersion::CUDA_123;
85 return CudaVersion::NEW;
91 auto StartsWithWords =
92 [](llvm::StringRef Line,
94 for (StringRef word : words) {
95 if (!Line.consume_front(word))
102 Input = Input.ltrim();
103 while (!Input.empty()) {
105 StartsWithWords(Input.ltrim(), {
"#",
"define",
"CUDA_VERSION"})) {
107 Line->consumeInteger(10, RawVersion);
108 return getCudaVersion(RawVersion);
111 Input = Input.drop_front(Input.find_first_of(
"\n\r")).ltrim();
113 return CudaVersion::UNKNOWN;
120 if (!VersionString.empty())
121 VersionString.insert(0,
" ");
122 D.
Diag(diag::warn_drv_new_cuda_version)
127 D.
Diag(diag::warn_drv_partially_supported_cuda_version)
132 const Driver &D,
const llvm::Triple &HostTriple,
133 const llvm::opt::ArgList &Args)
139 Candidate(std::string Path,
bool StrictChecking =
false)
140 : Path(Path), StrictChecking(StrictChecking) {}
145 std::initializer_list<const char *> Versions = {
"8.0",
"7.5",
"7.0"};
148 if (Args.hasArg(clang::driver::options::OPT_cuda_path_EQ)) {
149 Candidates.emplace_back(
150 Args.getLastArgValue(clang::driver::options::OPT_cuda_path_EQ).str());
151 }
else if (HostTriple.isOSWindows()) {
152 for (
const char *Ver : Versions)
153 Candidates.emplace_back(
154 D.
SysRoot +
"/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v" +
157 if (!Args.hasArg(clang::driver::options::OPT_cuda_path_ignore_env)) {
166 if (llvm::ErrorOr<std::string> ptxas =
167 llvm::sys::findProgramByName(
"ptxas")) {
169 llvm::sys::fs::real_path(*ptxas, ptxasAbsolutePath);
171 StringRef ptxasDir = llvm::sys::path::parent_path(ptxasAbsolutePath);
172 if (llvm::sys::path::filename(ptxasDir) ==
"bin")
173 Candidates.emplace_back(
174 std::string(llvm::sys::path::parent_path(ptxasDir)),
179 Candidates.emplace_back(D.
SysRoot +
"/usr/local/cuda");
180 for (
const char *Ver : Versions)
181 Candidates.emplace_back(D.
SysRoot +
"/usr/local/cuda-" + Ver);
183 Distro Dist(FS, llvm::Triple(llvm::sys::getProcessTriple()));
187 Candidates.emplace_back(D.
SysRoot +
"/usr/lib/cuda");
190 bool NoCudaLib = Args.hasArg(options::OPT_nogpulib);
192 for (
const auto &Candidate : Candidates) {
193 InstallPath = Candidate.Path;
194 if (InstallPath.empty() || !FS.exists(InstallPath))
197 BinPath = InstallPath +
"/bin";
198 IncludePath = InstallPath +
"/include";
199 LibDevicePath = InstallPath +
"/nvvm/libdevice";
201 if (!(FS.exists(IncludePath) && FS.exists(BinPath)))
203 bool CheckLibDevice = (!NoCudaLib || Candidate.StrictChecking);
204 if (CheckLibDevice && !FS.exists(LibDevicePath))
208 if (
auto CudaHFile = FS.getBufferForFile(InstallPath +
"/include/cuda.h"))
209 Version = parseCudaHFile((*CudaHFile)->getBuffer());
213 Version = FS.exists(LibDevicePath +
"/libdevice.10.bc")
220 std::string FilePath = LibDevicePath +
"/libdevice.10.bc";
221 if (FS.exists(FilePath)) {
228 LibDeviceMap[GpuArchName] = FilePath;
233 for (llvm::vfs::directory_iterator LI = FS.dir_begin(LibDevicePath, EC),
235 !EC && LI != LE; LI = LI.increment(EC)) {
236 StringRef FilePath = LI->path();
237 StringRef
FileName = llvm::sys::path::filename(FilePath);
240 const StringRef LibDeviceName =
"libdevice.";
244 LibDeviceName.size(),
FileName.find(
'.', LibDeviceName.size()));
245 LibDeviceMap[GpuArch] = FilePath.str();
249 if (GpuArch ==
"compute_20") {
250 LibDeviceMap[
"sm_20"] = std::string(FilePath);
251 LibDeviceMap[
"sm_21"] = std::string(FilePath);
252 LibDeviceMap[
"sm_32"] = std::string(FilePath);
253 }
else if (GpuArch ==
"compute_30") {
254 LibDeviceMap[
"sm_30"] = std::string(FilePath);
256 LibDeviceMap[
"sm_50"] = std::string(FilePath);
257 LibDeviceMap[
"sm_52"] = std::string(FilePath);
258 LibDeviceMap[
"sm_53"] = std::string(FilePath);
260 LibDeviceMap[
"sm_60"] = std::string(FilePath);
261 LibDeviceMap[
"sm_61"] = std::string(FilePath);
262 LibDeviceMap[
"sm_62"] = std::string(FilePath);
263 }
else if (GpuArch ==
"compute_35") {
264 LibDeviceMap[
"sm_35"] = std::string(FilePath);
265 LibDeviceMap[
"sm_37"] = std::string(FilePath);
266 }
else if (GpuArch ==
"compute_50") {
268 LibDeviceMap[
"sm_50"] = std::string(FilePath);
269 LibDeviceMap[
"sm_52"] = std::string(FilePath);
270 LibDeviceMap[
"sm_53"] = std::string(FilePath);
278 if (LibDeviceMap.empty() && !NoCudaLib)
287 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
288 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
292 llvm::sys::path::append(
P,
"include");
293 llvm::sys::path::append(
P,
"cuda_wrappers");
294 CC1Args.push_back(
"-internal-isystem");
295 CC1Args.push_back(DriverArgs.MakeArgString(
P));
298 if (DriverArgs.hasArg(options::OPT_nogpuinc))
302 D.
Diag(diag::err_drv_no_cuda_installation);
306 CC1Args.push_back(
"-include");
307 CC1Args.push_back(
"__clang_cuda_runtime_wrapper.h");
313 ArchsWithBadVersion[(
int)Arch])
318 if (Version < MinVersion || Version > MaxVersion) {
319 ArchsWithBadVersion[(
int)Arch] =
true;
320 D.
Diag(diag::err_drv_cuda_version_unsupported)
329 OS <<
"Found CUDA installation: " << InstallPath <<
", version "
339enum DeviceDebugInfoLevel {
342 EmitSameDebugInfoAsHost,
356 const Arg *A = Args.getLastArg(options::OPT_O_Group);
357 bool IsDebugEnabled = !A || A->getOption().matches(options::OPT_O0) ||
358 Args.hasFlag(options::OPT_cuda_noopt_device_debug,
359 options::OPT_no_cuda_noopt_device_debug,
361 if (
const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
362 const Option &Opt = A->getOption();
363 if (Opt.matches(options::OPT_gN_Group)) {
364 if (Opt.matches(options::OPT_g0) || Opt.matches(options::OPT_ggdb0))
365 return DisableDebugInfo;
366 if (Opt.matches(options::OPT_gline_directives_only))
367 return DebugDirectivesOnly;
369 return IsDebugEnabled ? EmitSameDebugInfoAsHost : DebugDirectivesOnly;
378 const char *LinkingOutput)
const {
381 assert(TC.getTriple().isNVPTX() &&
"Wrong platform");
383 StringRef GPUArchName;
391 GPUArchName = Args.getLastArgValue(options::OPT_march_EQ);
392 if (GPUArchName.empty()) {
393 C.getDriver().Diag(diag::err_drv_offload_missing_gpu_arch)
394 << getToolChain().getArchName() << getShortName();
402 "Device action expected to have an architecture.");
405 if (!Args.hasArg(options::OPT_no_cuda_version_check)) {
406 TC.CudaInstallation.CheckCudaVersionSupportsArch(gpu_arch);
409 ArgStringList CmdArgs;
410 CmdArgs.push_back(TC.getTriple().isArch64Bit() ?
"-m64" :
"-m32");
412 if (DIKind == EmitSameDebugInfoAsHost) {
415 CmdArgs.push_back(
"-g");
416 CmdArgs.push_back(
"--dont-merge-basicblocks");
417 CmdArgs.push_back(
"--return-at-end");
418 }
else if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
426 StringRef OOpt =
"3";
427 if (A->getOption().matches(options::OPT_O4) ||
428 A->getOption().matches(options::OPT_Ofast))
430 else if (A->getOption().matches(options::OPT_O0))
432 else if (A->getOption().matches(options::OPT_O)) {
434 OOpt = llvm::StringSwitch<const char *>(A->getValue())
442 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(
"-O") + OOpt));
446 CmdArgs.push_back(
"-O0");
448 if (DIKind == DebugDirectivesOnly)
449 CmdArgs.push_back(
"-lineinfo");
452 if (Args.hasArg(options::OPT_v))
453 CmdArgs.push_back(
"-v");
455 CmdArgs.push_back(
"--gpu-name");
457 CmdArgs.push_back(
"--output-file");
458 std::string OutputFileName = TC.getInputFilename(Output);
462 if (!
C.getInputArgs().getLastArg(options::OPT_c)) {
464 llvm::sys::path::replace_extension(
Filename,
"cubin");
468 C.addTempFile(Args.MakeArgString(OutputFileName));
470 CmdArgs.push_back(Args.MakeArgString(OutputFileName));
471 for (
const auto &II : Inputs)
472 CmdArgs.push_back(Args.MakeArgString(II.getFilename()));
474 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
475 CmdArgs.push_back(Args.MakeArgString(A));
480 Relocatable = Args.hasFlag(options::OPT_fopenmp_relocatable_target,
481 options::OPT_fnoopenmp_relocatable_target,
485 Relocatable = Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
492 CmdArgs.push_back(
"-c");
495 if (Arg *A = Args.getLastArg(options::OPT_ptxas_path_EQ))
496 Exec = A->getValue();
498 Exec = Args.MakeArgString(TC.GetProgramPath(
"ptxas"));
499 C.addCommand(std::make_unique<Command>(
503 Exec, CmdArgs, Inputs, Output));
508 bool includePTX = !Args.hasFlag(options::OPT_offload_new_driver,
509 options::OPT_no_offload_new_driver,
false);
510 for (Arg *A : Args.filtered(options::OPT_cuda_include_ptx_EQ,
511 options::OPT_no_cuda_include_ptx_EQ)) {
513 const StringRef ArchStr = A->getValue();
514 if (A->getOption().matches(options::OPT_cuda_include_ptx_EQ) &&
515 (ArchStr ==
"all" || ArchStr == InputArch))
517 else if (A->getOption().matches(options::OPT_no_cuda_include_ptx_EQ) &&
518 (ArchStr ==
"all" || ArchStr == InputArch))
531 const char *LinkingOutput)
const {
534 assert(TC.getTriple().isNVPTX() &&
"Wrong platform");
536 ArgStringList CmdArgs;
538 CmdArgs.push_back(
"--cuda");
539 CmdArgs.push_back(TC.getTriple().isArch64Bit() ?
"-64" :
"-32");
540 CmdArgs.push_back(Args.MakeArgString(
"--create"));
541 CmdArgs.push_back(Args.MakeArgString(Output.
getFilename()));
543 CmdArgs.push_back(
"-g");
545 for (
const auto &II : Inputs) {
546 auto *A = II.getAction();
547 assert(A->getInputs().size() == 1 &&
548 "Device offload action is expected to have a single input");
549 const char *gpu_arch_str = A->getOffloadingArch();
550 assert(gpu_arch_str &&
551 "Device action expected to have associated a GPU architecture!");
554 if (II.getType() == types::TY_PP_Asm &&
559 const char *Arch = (II.getType() == types::TY_PP_Asm)
563 Args.MakeArgString(llvm::Twine(
"--image=profile=") + Arch +
564 ",file=" + getToolChain().getInputFilename(II)));
567 for (
const auto &A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
568 CmdArgs.push_back(Args.MakeArgString(A));
570 const char *Exec = Args.MakeArgString(TC.GetProgramPath(
"fatbinary"));
571 C.addCommand(std::make_unique<Command>(
575 Exec, CmdArgs, Inputs, Output));
582 const char *LinkingOutput)
const {
585 ArgStringList CmdArgs;
587 assert(TC.getTriple().isNVPTX() &&
"Wrong platform");
591 CmdArgs.push_back(
"-o");
596 CmdArgs.push_back(
"-g");
598 if (Args.hasArg(options::OPT_v))
599 CmdArgs.push_back(
"-v");
601 StringRef GPUArch = Args.getLastArgValue(options::OPT_march_EQ);
602 if (GPUArch.empty()) {
603 C.getDriver().Diag(diag::err_drv_offload_missing_gpu_arch)
604 << getToolChain().getArchName() << getShortName();
608 CmdArgs.push_back(
"-arch");
609 CmdArgs.push_back(Args.MakeArgString(GPUArch));
615 Args.AddAllArgs(CmdArgs, options::OPT_L);
616 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
620 llvm::sys::path::parent_path(TC.getDriver().Dir);
621 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
622 CmdArgs.push_back(Args.MakeArgString(Twine(
"-L") + DefaultLibPath));
624 for (
const auto &II : Inputs) {
625 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
626 II.getType() == types::TY_LTO_BC || II.getType() == types::TY_LLVM_BC) {
627 C.getDriver().Diag(diag::err_drv_no_linker_llvm_support)
628 << getToolChain().getTripleString();
636 if (II.isFilename()) {
637 auto InputFile = getToolChain().getInputFilename(II);
638 if (llvm::sys::path::extension(InputFile) !=
".cubin") {
642 if (II.getAction() && II.getAction()->getInputs().size() == 0) {
644 Args.MakeArgString(getToolChain().getDriver().GetTemporaryPath(
645 llvm::sys::path::stem(InputFile),
"cubin"));
646 if (llvm::sys::fs::copy_file(InputFile,
C.addTempFile(CubinF)))
649 CmdArgs.push_back(CubinF);
652 llvm::sys::path::replace_extension(
Filename,
"cubin");
653 CmdArgs.push_back(Args.MakeArgString(
Filename));
656 CmdArgs.push_back(Args.MakeArgString(InputFile));
658 }
else if (!II.isNothing()) {
659 II.getInputArg().renderAsInput(Args, CmdArgs);
663 C.addCommand(std::make_unique<Command>(
667 Args.MakeArgString(getToolChain().GetProgramPath(
"nvlink")), CmdArgs,
672 const llvm::opt::ArgList &Args,
673 std::vector<StringRef> &Features) {
674 if (Args.hasArg(options::OPT_cuda_feature_EQ)) {
675 StringRef PtxFeature =
676 Args.getLastArgValue(options::OPT_cuda_feature_EQ,
"+ptx42");
677 Features.push_back(Args.MakeArgString(PtxFeature));
685 const char *PtxFeature =
nullptr;
686 switch (CudaInstallation.
version()) {
687#define CASE_CUDA_VERSION(CUDA_VER, PTX_VER) \
688 case CudaVersion::CUDA_##CUDA_VER: \
689 PtxFeature = "+ptx" #PTX_VER; \
710#undef CASE_CUDA_VERSION
712 PtxFeature =
"+ptx42";
714 Features.push_back(PtxFeature);
721 const llvm::Triple &HostTriple,
722 const ArgList &Args,
bool Freestanding =
false)
723 :
ToolChain(D, Triple, Args), CudaInstallation(D, HostTriple, Args),
724 Freestanding(Freestanding) {
725 if (CudaInstallation.isValid())
726 getProgramPaths().push_back(std::string(CudaInstallation.getBinPath()));
729 getProgramPaths().push_back(getDriver().Dir);
739llvm::opt::DerivedArgList *
745 DAL =
new DerivedArgList(Args.getBaseArgs());
747 const OptTable &Opts = getDriver().getOpts();
750 if (!llvm::is_contained(*DAL, A))
753 if (!DAL->hasArg(options::OPT_march_EQ) && OffloadKind !=
Action::OFK_None) {
754 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ),
756 }
else if (DAL->getLastArgValue(options::OPT_march_EQ) ==
"generic" &&
758 DAL->eraseArg(options::OPT_march_EQ);
759 }
else if (DAL->getLastArgValue(options::OPT_march_EQ) ==
"native") {
760 auto GPUsOrErr = getSystemGPUArchs(Args);
762 getDriver().Diag(diag::err_drv_undetermined_gpu_arch)
763 << getArchName() << llvm::toString(GPUsOrErr.takeError()) <<
"-march";
765 if (GPUsOrErr->size() > 1)
766 getDriver().Diag(diag::warn_drv_multi_gpu_arch)
767 << getArchName() << llvm::join(*GPUsOrErr,
", ") <<
"-march";
768 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ),
769 Args.MakeArgString(GPUsOrErr->front()));
777 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
783 CC1Args.append({
"-mllvm",
"--nvptx-lower-global-ctor-dtor"});
787 const Option &O = A->getOption();
788 return (O.matches(options::OPT_gN_Group) &&
789 !O.matches(options::OPT_gmodules)) ||
790 O.matches(options::OPT_g_Flag) ||
791 O.matches(options::OPT_ggdbN_Group) || O.matches(options::OPT_ggdb) ||
792 O.matches(options::OPT_gdwarf) || O.matches(options::OPT_gdwarf_2) ||
793 O.matches(options::OPT_gdwarf_3) || O.matches(options::OPT_gdwarf_4) ||
794 O.matches(options::OPT_gdwarf_5) ||
795 O.matches(options::OPT_gcolumn_info);
799 llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
800 const ArgList &Args)
const {
802 case DisableDebugInfo:
803 DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
805 case DebugDirectivesOnly:
806 DebugInfoKind = llvm::codegenoptions::DebugDirectivesOnly;
808 case EmitSameDebugInfoAsHost:
818 if (Arg *A = Args.getLastArg(options::OPT_nvptx_arch_tool_EQ))
819 Program = A->getValue();
821 Program = GetProgramPath(
"nvptx-arch");
823 auto StdoutOrErr = executeToolChainProgram(Program);
825 return StdoutOrErr.takeError();
828 for (StringRef Arch : llvm::split((*StdoutOrErr)->getBuffer(),
"\n"))
830 GPUArchs.push_back(Arch.str());
832 if (GPUArchs.empty())
833 return llvm::createStringError(std::error_code(),
834 "No NVIDIA GPU detected in the system");
836 return std::move(GPUArchs);
844 const ToolChain &HostTC,
const ArgList &Args)
845 :
NVPTXToolChain(D, Triple, HostTC.getTriple(), Args), HostTC(HostTC) {}
848 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
852 StringRef GpuArch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
853 assert(!GpuArch.empty() &&
"Must have an explicit GPU arch.");
856 "Only OpenMP or CUDA offloading kinds are supported for NVIDIA GPUs.");
860 {
"-fcuda-is-device",
"-mllvm",
"-enable-memcpyopt-without-libcalls"});
867 CC1Args.push_back(
"-fcuda-allow-variadic-functions");
870 if (DriverArgs.hasArg(options::OPT_nogpulib))
874 DriverArgs.hasArg(options::OPT_S))
878 if (LibDeviceFile.empty()) {
879 getDriver().
Diag(diag::err_drv_no_cuda_libdevice) << GpuArch;
883 CC1Args.push_back(
"-mlink-builtin-bitcode");
884 CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
888 if (DriverArgs.hasFlag(options::OPT_fcuda_short_ptr,
889 options::OPT_fno_cuda_short_ptr,
false))
890 CC1Args.append({
"-mllvm",
"--nvptx-short-ptr"});
894 DriverArgs.MakeArgString(Twine(
"-target-sdk-version=") +
900 diag::err_drv_omp_offload_target_cuda_version_not_support)
915 const llvm::opt::ArgList &DriverArgs,
const JobAction &JA,
916 const llvm::fltSemantics *FPType)
const {
918 if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
919 DriverArgs.hasFlag(options::OPT_fgpu_flush_denormals_to_zero,
920 options::OPT_fno_gpu_flush_denormals_to_zero,
false))
921 return llvm::DenormalMode::getPreserveSign();
925 return llvm::DenormalMode::getIEEE();
929 ArgStringList &CC1Args)
const {
931 if (!DriverArgs.hasArg(options::OPT_nogpuinc) &&
932 !DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {
933 StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
934 assert(!Arch.empty() &&
"Must have an explicit GPU arch.");
949 llvm::sys::path::replace_extension(
Filename,
"cubin");
953llvm::opt::DerivedArgList *
957 DerivedArgList *DAL =
960 DAL =
new DerivedArgList(Args.getBaseArgs());
969 if (!llvm::is_contained(*DAL, A))
972 if (!DAL->hasArg(options::OPT_march_EQ)) {
973 StringRef Arch = BoundArch;
978 llvm::formatv(
"{0}", llvm::fmt_consume(ArchsOrErr.takeError()));
980 << llvm::Triple::getArchTypeName(
getArch()) << ErrMsg <<
"-march";
983 Arch = Args.MakeArgString(ArchsOrErr->front());
986 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ), Arch);
992 for (Arg *A : Args) {
994 if (!llvm::is_contained(*DAL, A)) {
999 if (!BoundArch.empty()) {
1000 DAL->eraseArg(options::OPT_march_EQ);
1001 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ),
1033 ArgStringList &CC1Args)
const {
1038 {
"-internal-isystem",
1043 ArgStringList &CC1Args)
const {
1048 ArgStringList &CC1Args)
const {
1066 const ArgList &Args)
const {
const char * getOffloadingArch() const
OffloadKind getOffloadingDeviceKind() const
bool isDeviceOffloading(OffloadKind OKind) const
bool isOffloading(OffloadKind OKind) const
Compilation - A set of tasks to perform for a single driver invocation.
A class to find a viable CUDA installation.
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
CudaInstallationDetector(const Driver &D, const llvm::Triple &HostTriple, const llvm::opt::ArgList &Args)
void WarnIfUnsupportedVersion()
CudaVersion version() const
Get the detected Cuda install's version.
std::string getLibDeviceFile(StringRef Gpu) const
Get libdevice file for given architecture.
void CheckCudaVersionSupportsArch(CudaArch Arch) const
Emit an error if Version does not support the given Arch.
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
StringRef getIncludePath() const
Get the detected Cuda Include path.
bool isValid() const
Check whether we detected a valid Cuda install.
Distro - Helper class for detecting and classifying Linux distributions.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
DiagnosticBuilder Diag(unsigned DiagID) const
const llvm::opt::OptTable & getOpts() const
std::string ResourceDir
The path to the compiler resource directory.
llvm::vfs::FileSystem & getVFS() const
bool willEmitRemarks(const llvm::opt::ArgList &Args)
The JSON file list parser is used to communicate input to InstallAPI.
const char * CudaArchToVirtualArchString(CudaArch A)
CudaVersion MaxVersionForCudaArch(CudaArch A)
Get the latest CudaVersion that supports the given CudaArch.
CudaArch StringToCudaArch(llvm::StringRef S)
CudaVersion MinVersionForCudaArch(CudaArch A)
Get the earliest CudaVersion that supports the given CudaArch.
static bool IsNVIDIAGpuArch(CudaArch A)
const char * CudaVersionToString(CudaVersion V)
const char * CudaArchToString(CudaArch A)
Diagnostic wrappers for TextAPI types for error reporting.