contrib/llvm-project/clang/lib/Driver/ToolChains/Cuda.cpp

   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 "CommonArgs.h"
  11 #include "InputInfo.h"
  12 #include "clang/Basic/Cuda.h"
  13 #include "clang/Config/config.h"
  14 #include "clang/Driver/Compilation.h"
  15 #include "clang/Driver/Distro.h"
  16 #include "clang/Driver/Driver.h"
  17 #include "clang/Driver/DriverDiagnostic.h"
  18 #include "clang/Driver/Options.h"
  19 #include "llvm/ADT/Optional.h"
  20 #include "llvm/Option/ArgList.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Host.h"
  23 #include "llvm/Support/Path.h"
  24 #include "llvm/Support/Process.h"
  25 #include "llvm/Support/Program.h"
  26 #include "llvm/Support/TargetParser.h"
  27 #include "llvm/Support/VirtualFileSystem.h"
  28 #include <system_error>
  29
  30 using namespace clang::driver;
  31 using namespace clang::driver::toolchains;
  32 using namespace clang::driver::tools;
  33 using namespace clang;
  34 using namespace llvm::opt;
  35
  36 namespace {
  37 struct CudaVersionInfo {
  38   std::string DetectedVersion;
  39   CudaVersion Version;
  40 };
  41 // Parses the contents of version.txt in an CUDA installation.  It should
  42 // contain one line of the from e.g. "CUDA Version 7.5.2".
  43 CudaVersionInfo parseCudaVersionFile(llvm::StringRef V) {
  44   V = V.trim();
  45   if (!V.startswith("CUDA Version "))
  46     return {V.str(), CudaVersion::UNKNOWN};
  47   V = V.substr(strlen("CUDA Version "));
  48   SmallVector<StringRef,4> VersionParts;
  49   V.split(VersionParts, '.');
  50   return {"version.txt: " + V.str() + ".",
  51           VersionParts.size() < 2
  52               ? CudaVersion::UNKNOWN
  53               : CudaStringToVersion(
  54                     join_items(".", VersionParts[0], VersionParts[1]))};
  55 }
  56
  57 CudaVersion getCudaVersion(uint32_t raw_version) {
  58   if (raw_version < 7050)
  59     return CudaVersion::CUDA_70;
  60   if (raw_version < 8000)
  61     return CudaVersion::CUDA_75;
  62   if (raw_version < 9000)
  63     return CudaVersion::CUDA_80;
  64   if (raw_version < 9010)
  65     return CudaVersion::CUDA_90;
  66   if (raw_version < 9020)
  67     return CudaVersion::CUDA_91;
  68   if (raw_version < 10000)
  69     return CudaVersion::CUDA_92;
  70   if (raw_version < 10010)
  71     return CudaVersion::CUDA_100;
  72   if (raw_version < 10020)
  73     return CudaVersion::CUDA_101;
  74   if (raw_version < 11000)
  75     return CudaVersion::CUDA_102;
  76   if (raw_version < 11010)
  77     return CudaVersion::CUDA_110;
  78   return CudaVersion::LATEST;
  79 }
  80
  81 CudaVersionInfo parseCudaHFile(llvm::StringRef Input) {
  82   // Helper lambda which skips the words if the line starts with them or returns
  83   // None otherwise.
  84   auto StartsWithWords =
  85       [](llvm::StringRef Line,
  86          const SmallVector<StringRef, 3> words) -> llvm::Optional<StringRef> {
  87     for (StringRef word : words) {
  88       if (!Line.consume_front(word))
  89         return {};
  90       Line = Line.ltrim();
  91     }
  92     return Line;
  93   };
  94
  95   Input = Input.ltrim();
  96   while (!Input.empty()) {
  97     if (auto Line =
  98             StartsWithWords(Input.ltrim(), {"#", "define", "CUDA_VERSION"})) {
  99       uint32_t RawVersion;
 100       Line->consumeInteger(10, RawVersion);
 101       return {"cuda.h: CUDA_VERSION=" + Twine(RawVersion).str() + ".",
 102               getCudaVersion(RawVersion)};
 103     }
 104     // Find next non-empty line.
 105     Input = Input.drop_front(Input.find_first_of("\n\r")).ltrim();
 106   }
 107   return {"cuda.h: CUDA_VERSION not found.", CudaVersion::UNKNOWN};
 108 }
 109 } // namespace
 110
 111 void CudaInstallationDetector::WarnIfUnsupportedVersion() {
 112   if (DetectedVersionIsNotSupported)
 113     D.Diag(diag::warn_drv_unknown_cuda_version)
 114         << DetectedVersion
 115         << CudaVersionToString(CudaVersion::LATEST_SUPPORTED);
 116 }
 117
 118 CudaInstallationDetector::CudaInstallationDetector(
 119     const Driver &D, const llvm::Triple &HostTriple,
 120     const llvm::opt::ArgList &Args)
 121     : D(D) {
 122   struct Candidate {
 123     std::string Path;
 124     bool StrictChecking;
 125
 126     Candidate(std::string Path, bool StrictChecking = false)
 127         : Path(Path), StrictChecking(StrictChecking) {}
 128   };
 129   SmallVector<Candidate, 4> Candidates;
 130
 131   // In decreasing order so we prefer newer versions to older versions.
 132   std::initializer_list<const char *> Versions = {"8.0", "7.5", "7.0"};
 133   auto &FS = D.getVFS();
 134
 135   if (Args.hasArg(clang::driver::options::OPT_cuda_path_EQ)) {
 136     Candidates.emplace_back(
 137         Args.getLastArgValue(clang::driver::options::OPT_cuda_path_EQ).str());
 138   } else if (HostTriple.isOSWindows()) {
 139     for (const char *Ver : Versions)
 140       Candidates.emplace_back(
 141           D.SysRoot + "/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v" +
 142           Ver);
 143   } else {
 144     if (!Args.hasArg(clang::driver::options::OPT_cuda_path_ignore_env)) {
 145       // Try to find ptxas binary. If the executable is located in a directory
 146       // called 'bin/', its parent directory might be a good guess for a valid
 147       // CUDA installation.
 148       // However, some distributions might installs 'ptxas' to /usr/bin. In that
 149       // case the candidate would be '/usr' which passes the following checks
 150       // because '/usr/include' exists as well. To avoid this case, we always
 151       // check for the directory potentially containing files for libdevice,
 152       // even if the user passes -nocudalib.
 153       if (llvm::ErrorOr<std::string> ptxas =
 154               llvm::sys::findProgramByName("ptxas")) {
 155         SmallString<256> ptxasAbsolutePath;
 156         llvm::sys::fs::real_path(*ptxas, ptxasAbsolutePath);
 157
 158         StringRef ptxasDir = llvm::sys::path::parent_path(ptxasAbsolutePath);
 159         if (llvm::sys::path::filename(ptxasDir) == "bin")
 160           Candidates.emplace_back(
 161               std::string(llvm::sys::path::parent_path(ptxasDir)),
 162               /*StrictChecking=*/true);
 163       }
 164     }
 165
 166     Candidates.emplace_back(D.SysRoot + "/usr/local/cuda");
 167     for (const char *Ver : Versions)
 168       Candidates.emplace_back(D.SysRoot + "/usr/local/cuda-" + Ver);
 169
 170     Distro Dist(FS, llvm::Triple(llvm::sys::getProcessTriple()));
 171     if (Dist.IsDebian() || Dist.IsUbuntu())
 172       // Special case for Debian to have nvidia-cuda-toolkit work
 173       // out of the box. More info on http://bugs.debian.org/882505
 174       Candidates.emplace_back(D.SysRoot + "/usr/lib/cuda");
 175   }
 176
 177   bool NoCudaLib = Args.hasArg(options::OPT_nogpulib);
 178
 179   for (const auto &Candidate : Candidates) {
 180     InstallPath = Candidate.Path;
 181     if (InstallPath.empty() || !FS.exists(InstallPath))
 182       continue;
 183
 184     BinPath = InstallPath + "/bin";
 185     IncludePath = InstallPath + "/include";
 186     LibDevicePath = InstallPath + "/nvvm/libdevice";
 187
 188     if (!(FS.exists(IncludePath) && FS.exists(BinPath)))
 189       continue;
 190     bool CheckLibDevice = (!NoCudaLib || Candidate.StrictChecking);
 191     if (CheckLibDevice && !FS.exists(LibDevicePath))
 192       continue;
 193
 194     // On Linux, we have both lib and lib64 directories, and we need to choose
 195     // based on our triple.  On MacOS, we have only a lib directory.
 196     //
 197     // It's sufficient for our purposes to be flexible: If both lib and lib64
 198     // exist, we choose whichever one matches our triple.  Otherwise, if only
 199     // lib exists, we use it.
 200     if (HostTriple.isArch64Bit() && FS.exists(InstallPath + "/lib64"))
 201       LibPath = InstallPath + "/lib64";
 202     else if (FS.exists(InstallPath + "/lib"))
 203       LibPath = InstallPath + "/lib";
 204     else
 205       continue;
 206
 207     CudaVersionInfo VersionInfo = {"", CudaVersion::UNKNOWN};
 208     if (auto VersionFile = FS.getBufferForFile(InstallPath + "/version.txt"))
 209       VersionInfo = parseCudaVersionFile((*VersionFile)->getBuffer());
 210     // If version file didn't give us the version, try to find it in cuda.h
 211     if (VersionInfo.Version == CudaVersion::UNKNOWN)
 212       if (auto CudaHFile = FS.getBufferForFile(InstallPath + "/include/cuda.h"))
 213         VersionInfo = parseCudaHFile((*CudaHFile)->getBuffer());
 214     // As the last resort, make an educated guess between CUDA-7.0, (which had
 215     // no version.txt file and had old-style libdevice bitcode ) and an unknown
 216     // recent CUDA version (no version.txt, new style bitcode).
 217     if (VersionInfo.Version == CudaVersion::UNKNOWN) {
 218       VersionInfo.Version = (FS.exists(LibDevicePath + "/libdevice.10.bc"))
 219                                 ? Version = CudaVersion::LATEST
 220                                 : Version = CudaVersion::CUDA_70;
 221       VersionInfo.DetectedVersion =
 222           "No version found in version.txt or cuda.h.";
 223     }
 224
 225     Version = VersionInfo.Version;
 226     DetectedVersion = VersionInfo.DetectedVersion;
 227
 228     // TODO(tra): remove the warning once we have all features of 10.2
 229     // and 11.0 implemented.
 230     DetectedVersionIsNotSupported = Version > CudaVersion::LATEST_SUPPORTED;
 231
 232     if (Version >= CudaVersion::CUDA_90) {
 233       // CUDA-9+ uses single libdevice file for all GPU variants.
 234       std::string FilePath = LibDevicePath + "/libdevice.10.bc";
 235       if (FS.exists(FilePath)) {
 236         for (int Arch = (int)CudaArch::SM_30, E = (int)CudaArch::LAST; Arch < E;
 237              ++Arch) {
 238           CudaArch GpuArch = static_cast<CudaArch>(Arch);
 239           if (!IsNVIDIAGpuArch(GpuArch))
 240             continue;
 241           std::string GpuArchName(CudaArchToString(GpuArch));
 242           LibDeviceMap[GpuArchName] = FilePath;
 243         }
 244       }
 245     } else {
 246       std::error_code EC;
 247       for (llvm::vfs::directory_iterator LI = FS.dir_begin(LibDevicePath, EC),
 248                                          LE;
 249            !EC && LI != LE; LI = LI.increment(EC)) {
 250         StringRef FilePath = LI->path();
 251         StringRef FileName = llvm::sys::path::filename(FilePath);
 252         // Process all bitcode filenames that look like
 253         // libdevice.compute_XX.YY.bc
 254         const StringRef LibDeviceName = "libdevice.";
 255         if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
 256           continue;
 257         StringRef GpuArch = FileName.slice(
 258             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
 259         LibDeviceMap[GpuArch] = FilePath.str();
 260         // Insert map entries for specific devices with this compute
 261         // capability. NVCC's choice of the libdevice library version is
 262         // rather peculiar and depends on the CUDA version.
 263         if (GpuArch == "compute_20") {
 264           LibDeviceMap["sm_20"] = std::string(FilePath);
 265           LibDeviceMap["sm_21"] = std::string(FilePath);
 266           LibDeviceMap["sm_32"] = std::string(FilePath);
 267         } else if (GpuArch == "compute_30") {
 268           LibDeviceMap["sm_30"] = std::string(FilePath);
 269           if (Version < CudaVersion::CUDA_80) {
 270             LibDeviceMap["sm_50"] = std::string(FilePath);
 271             LibDeviceMap["sm_52"] = std::string(FilePath);
 272             LibDeviceMap["sm_53"] = std::string(FilePath);
 273           }
 274           LibDeviceMap["sm_60"] = std::string(FilePath);
 275           LibDeviceMap["sm_61"] = std::string(FilePath);
 276           LibDeviceMap["sm_62"] = std::string(FilePath);
 277         } else if (GpuArch == "compute_35") {
 278           LibDeviceMap["sm_35"] = std::string(FilePath);
 279           LibDeviceMap["sm_37"] = std::string(FilePath);
 280         } else if (GpuArch == "compute_50") {
 281           if (Version >= CudaVersion::CUDA_80) {
 282             LibDeviceMap["sm_50"] = std::string(FilePath);
 283             LibDeviceMap["sm_52"] = std::string(FilePath);
 284             LibDeviceMap["sm_53"] = std::string(FilePath);
 285           }
 286         }
 287       }
 288     }
 289
 290     // Check that we have found at least one libdevice that we can link in if
 291     // -nocudalib hasn't been specified.
 292     if (LibDeviceMap.empty() && !NoCudaLib)
 293       continue;
 294
 295     IsValid = true;
 296     break;
 297   }
 298 }
 299
 300 void CudaInstallationDetector::AddCudaIncludeArgs(
 301     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
 302   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
 303     // Add cuda_wrappers/* to our system include path.  This lets us wrap
 304     // standard library headers.
 305     SmallString<128> P(D.ResourceDir);
 306     llvm::sys::path::append(P, "include");
 307     llvm::sys::path::append(P, "cuda_wrappers");
 308     CC1Args.push_back("-internal-isystem");
 309     CC1Args.push_back(DriverArgs.MakeArgString(P));
 310   }
 311
 312   if (DriverArgs.hasArg(options::OPT_nogpuinc))
 313     return;
 314
 315   if (!isValid()) {
 316     D.Diag(diag::err_drv_no_cuda_installation);
 317     return;
 318   }
 319
 320   CC1Args.push_back("-internal-isystem");
 321   CC1Args.push_back(DriverArgs.MakeArgString(getIncludePath()));
 322   CC1Args.push_back("-include");
 323   CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
 324 }
 325
 326 void CudaInstallationDetector::CheckCudaVersionSupportsArch(
 327     CudaArch Arch) const {
 328   if (Arch == CudaArch::UNKNOWN || Version == CudaVersion::UNKNOWN ||
 329       ArchsWithBadVersion.count(Arch) > 0)
 330     return;
 331
 332   auto MinVersion = MinVersionForCudaArch(Arch);
 333   auto MaxVersion = MaxVersionForCudaArch(Arch);
 334   if (Version < MinVersion || Version > MaxVersion) {
 335     ArchsWithBadVersion.insert(Arch);
 336     D.Diag(diag::err_drv_cuda_version_unsupported)
 337         << CudaArchToString(Arch) << CudaVersionToString(MinVersion)
 338         << CudaVersionToString(MaxVersion) << InstallPath
 339         << CudaVersionToString(Version);
 340   }
 341 }
 342
 343 void CudaInstallationDetector::print(raw_ostream &OS) const {
 344   if (isValid())
 345     OS << "Found CUDA installation: " << InstallPath << ", version "
 346        << CudaVersionToString(Version) << "\n";
 347 }
 348
 349 namespace {
 350 /// Debug info level for the NVPTX devices. We may need to emit different debug
 351 /// info level for the host and for the device itselfi. This type controls
 352 /// emission of the debug info for the devices. It either prohibits disable info
 353 /// emission completely, or emits debug directives only, or emits same debug
 354 /// info as for the host.
 355 enum DeviceDebugInfoLevel {
 356   DisableDebugInfo,        /// Do not emit debug info for the devices.
 357   DebugDirectivesOnly,     /// Emit only debug directives.
 358   EmitSameDebugInfoAsHost, /// Use the same debug info level just like for the
 359                            /// host.
 360 };
 361 } // anonymous namespace
 362
 363 /// Define debug info level for the NVPTX devices. If the debug info for both
 364 /// the host and device are disabled (-g0/-ggdb0 or no debug options at all). If
 365 /// only debug directives are requested for the both host and device
 366 /// (-gline-directvies-only), or the debug info only for the device is disabled
 367 /// (optimization is on and --cuda-noopt-device-debug was not specified), the
 368 /// debug directves only must be emitted for the device. Otherwise, use the same
 369 /// debug info level just like for the host (with the limitations of only
 370 /// supported DWARF2 standard).
 371 static DeviceDebugInfoLevel mustEmitDebugInfo(const ArgList &Args) {
 372   const Arg *A = Args.getLastArg(options::OPT_O_Group);
 373   bool IsDebugEnabled = !A || A->getOption().matches(options::OPT_O0) ||
 374                         Args.hasFlag(options::OPT_cuda_noopt_device_debug,
 375                                      options::OPT_no_cuda_noopt_device_debug,
 376                                      /*Default=*/false);
 377   if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
 378     const Option &Opt = A->getOption();
 379     if (Opt.matches(options::OPT_gN_Group)) {
 380       if (Opt.matches(options::OPT_g0) || Opt.matches(options::OPT_ggdb0))
 381         return DisableDebugInfo;
 382       if (Opt.matches(options::OPT_gline_directives_only))
 383         return DebugDirectivesOnly;
 384     }
 385     return IsDebugEnabled ? EmitSameDebugInfoAsHost : DebugDirectivesOnly;
 386   }
 387   return DisableDebugInfo;
 388 }
 389
 390 void NVPTX::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
 391                                     const InputInfo &Output,
 392                                     const InputInfoList &Inputs,
 393                                     const ArgList &Args,
 394                                     const char *LinkingOutput) const {
 395   const auto &TC =
 396       static_cast<const toolchains::CudaToolChain &>(getToolChain());
 397   assert(TC.getTriple().isNVPTX() && "Wrong platform");
 398
 399   StringRef GPUArchName;
 400   // If this is an OpenMP action we need to extract the device architecture
 401   // from the -march=arch option. This option may come from -Xopenmp-target
 402   // flag or the default value.
 403   if (JA.isDeviceOffloading(Action::OFK_OpenMP)) {
 404     GPUArchName = Args.getLastArgValue(options::OPT_march_EQ);
 405     assert(!GPUArchName.empty() && "Must have an architecture passed in.");
 406   } else
 407     GPUArchName = JA.getOffloadingArch();
 408
 409   // Obtain architecture from the action.
 410   CudaArch gpu_arch = StringToCudaArch(GPUArchName);
 411   assert(gpu_arch != CudaArch::UNKNOWN &&
 412          "Device action expected to have an architecture.");
 413
 414   // Check that our installation's ptxas supports gpu_arch.
 415   if (!Args.hasArg(options::OPT_no_cuda_version_check)) {
 416     TC.CudaInstallation.CheckCudaVersionSupportsArch(gpu_arch);
 417   }
 418
 419   ArgStringList CmdArgs;
 420   CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-m64" : "-m32");
 421   DeviceDebugInfoLevel DIKind = mustEmitDebugInfo(Args);
 422   if (DIKind == EmitSameDebugInfoAsHost) {
 423     // ptxas does not accept -g option if optimization is enabled, so
 424     // we ignore the compiler's -O* options if we want debug info.
 425     CmdArgs.push_back("-g");
 426     CmdArgs.push_back("--dont-merge-basicblocks");
 427     CmdArgs.push_back("--return-at-end");
 428   } else if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
 429     // Map the -O we received to -O{0,1,2,3}.
 430     //
 431     // TODO: Perhaps we should map host -O2 to ptxas -O3. -O3 is ptxas's
 432     // default, so it may correspond more closely to the spirit of clang -O2.
 433
 434     // -O3 seems like the least-bad option when -Osomething is specified to
 435     // clang but it isn't handled below.
 436     StringRef OOpt = "3";
 437     if (A->getOption().matches(options::OPT_O4) ||
 438         A->getOption().matches(options::OPT_Ofast))
 439       OOpt = "3";
 440     else if (A->getOption().matches(options::OPT_O0))
 441       OOpt = "0";
 442     else if (A->getOption().matches(options::OPT_O)) {
 443       // -Os, -Oz, and -O(anything else) map to -O2, for lack of better options.
 444       OOpt = llvm::StringSwitch<const char *>(A->getValue())
 445                  .Case("1", "1")
 446                  .Case("2", "2")
 447                  .Case("3", "3")
 448                  .Case("s", "2")
 449                  .Case("z", "2")
 450                  .Default("2");
 451     }
 452     CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-O") + OOpt));
 453   } else {
 454     // If no -O was passed, pass -O0 to ptxas -- no opt flag should correspond
 455     // to no optimizations, but ptxas's default is -O3.
 456     CmdArgs.push_back("-O0");
 457   }
 458   if (DIKind == DebugDirectivesOnly)
 459     CmdArgs.push_back("-lineinfo");
 460
 461   // Pass -v to ptxas if it was passed to the driver.
 462   if (Args.hasArg(options::OPT_v))
 463     CmdArgs.push_back("-v");
 464
 465   CmdArgs.push_back("--gpu-name");
 466   CmdArgs.push_back(Args.MakeArgString(CudaArchToString(gpu_arch)));
 467   CmdArgs.push_back("--output-file");
 468   CmdArgs.push_back(Args.MakeArgString(TC.getInputFilename(Output)));
 469   for (const auto& II : Inputs)
 470     CmdArgs.push_back(Args.MakeArgString(II.getFilename()));
 471
 472   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
 473     CmdArgs.push_back(Args.MakeArgString(A));
 474
 475   bool Relocatable = false;
 476   if (JA.isOffloading(Action::OFK_OpenMP))
 477     // In OpenMP we need to generate relocatable code.
 478     Relocatable = Args.hasFlag(options::OPT_fopenmp_relocatable_target,
 479                                options::OPT_fnoopenmp_relocatable_target,
 480                                /*Default=*/true);
 481   else if (JA.isOffloading(Action::OFK_Cuda))
 482     Relocatable = Args.hasFlag(options::OPT_fgpu_rdc,
 483                                options::OPT_fno_gpu_rdc, /*Default=*/false);
 484
 485   if (Relocatable)
 486     CmdArgs.push_back("-c");
 487
 488   const char *Exec;
 489   if (Arg *A = Args.getLastArg(options::OPT_ptxas_path_EQ))
 490     Exec = A->getValue();
 491   else
 492     Exec = Args.MakeArgString(TC.GetProgramPath("ptxas"));
 493   C.addCommand(std::make_unique<Command>(
 494       JA, *this,
 495       ResponseFileSupport{ResponseFileSupport::RF_Full, llvm::sys::WEM_UTF8,
 496                           "--options-file"},
 497       Exec, CmdArgs, Inputs));
 498 }
 499
 500 static bool shouldIncludePTX(const ArgList &Args, const char *gpu_arch) {
 501   bool includePTX = true;
 502   for (Arg *A : Args) {
 503     if (!(A->getOption().matches(options::OPT_cuda_include_ptx_EQ) ||
 504           A->getOption().matches(options::OPT_no_cuda_include_ptx_EQ)))
 505       continue;
 506     A->claim();
 507     const StringRef ArchStr = A->getValue();
 508     if (ArchStr == "all" || ArchStr == gpu_arch) {
 509       includePTX = A->getOption().matches(options::OPT_cuda_include_ptx_EQ);
 510       continue;
 511     }
 512   }
 513   return includePTX;
 514 }
 515
 516 // All inputs to this linker must be from CudaDeviceActions, as we need to look
 517 // at the Inputs' Actions in order to figure out which GPU architecture they
 518 // correspond to.
 519 void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 520                                  const InputInfo &Output,
 521                                  const InputInfoList &Inputs,
 522                                  const ArgList &Args,
 523                                  const char *LinkingOutput) const {
 524   const auto &TC =
 525       static_cast<const toolchains::CudaToolChain &>(getToolChain());
 526   assert(TC.getTriple().isNVPTX() && "Wrong platform");
 527
 528   ArgStringList CmdArgs;
 529   if (TC.CudaInstallation.version() <= CudaVersion::CUDA_100)
 530     CmdArgs.push_back("--cuda");
 531   CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-64" : "-32");
 532   CmdArgs.push_back(Args.MakeArgString("--create"));
 533   CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
 534   if (mustEmitDebugInfo(Args) == EmitSameDebugInfoAsHost)
 535     CmdArgs.push_back("-g");
 536
 537   for (const auto& II : Inputs) {
 538     auto *A = II.getAction();
 539     assert(A->getInputs().size() == 1 &&
 540            "Device offload action is expected to have a single input");
 541     const char *gpu_arch_str = A->getOffloadingArch();
 542     assert(gpu_arch_str &&
 543            "Device action expected to have associated a GPU architecture!");
 544     CudaArch gpu_arch = StringToCudaArch(gpu_arch_str);
 545
 546     if (II.getType() == types::TY_PP_Asm &&
 547         !shouldIncludePTX(Args, gpu_arch_str))
 548       continue;
 549     // We need to pass an Arch of the form "sm_XX" for cubin files and
 550     // "compute_XX" for ptx.
 551     const char *Arch = (II.getType() == types::TY_PP_Asm)
 552                            ? CudaArchToVirtualArchString(gpu_arch)
 553                            : gpu_arch_str;
 554     CmdArgs.push_back(Args.MakeArgString(llvm::Twine("--image=profile=") +
 555                                          Arch + ",file=" + II.getFilename()));
 556   }
 557
 558   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
 559     CmdArgs.push_back(Args.MakeArgString(A));
 560
 561   const char *Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
 562   C.addCommand(std::make_unique<Command>(
 563       JA, *this,
 564       ResponseFileSupport{ResponseFileSupport::RF_Full, llvm::sys::WEM_UTF8,
 565                           "--options-file"},
 566       Exec, CmdArgs, Inputs));
 567 }
 568
 569 void NVPTX::OpenMPLinker::ConstructJob(Compilation &C, const JobAction &JA,
 570                                        const InputInfo &Output,
 571                                        const InputInfoList &Inputs,
 572                                        const ArgList &Args,
 573                                        const char *LinkingOutput) const {
 574   const auto &TC =
 575       static_cast<const toolchains::CudaToolChain &>(getToolChain());
 576   assert(TC.getTriple().isNVPTX() && "Wrong platform");
 577
 578   ArgStringList CmdArgs;
 579
 580   // OpenMP uses nvlink to link cubin files. The result will be embedded in the
 581   // host binary by the host linker.
 582   assert(!JA.isHostOffloading(Action::OFK_OpenMP) &&
 583          "CUDA toolchain not expected for an OpenMP host device.");
 584
 585   if (Output.isFilename()) {
 586     CmdArgs.push_back("-o");
 587     CmdArgs.push_back(Output.getFilename());
 588   } else
 589     assert(Output.isNothing() && "Invalid output.");
 590   if (mustEmitDebugInfo(Args) == EmitSameDebugInfoAsHost)
 591     CmdArgs.push_back("-g");
 592
 593   if (Args.hasArg(options::OPT_v))
 594     CmdArgs.push_back("-v");
 595
 596   StringRef GPUArch =
 597       Args.getLastArgValue(options::OPT_march_EQ);
 598   assert(!GPUArch.empty() && "At least one GPU Arch required for ptxas.");
 599
 600   CmdArgs.push_back("-arch");
 601   CmdArgs.push_back(Args.MakeArgString(GPUArch));
 602
 603   // Assume that the directory specified with --libomptarget_nvptx_path
 604   // contains the static library libomptarget-nvptx.a.
 605   if (const Arg *A = Args.getLastArg(options::OPT_libomptarget_nvptx_path_EQ))
 606     CmdArgs.push_back(Args.MakeArgString(Twine("-L") + A->getValue()));
 607
 608   // Add paths specified in LIBRARY_PATH environment variable as -L options.
 609   addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
 610
 611   // Add paths for the default clang library path.
 612   SmallString<256> DefaultLibPath =
 613       llvm::sys::path::parent_path(TC.getDriver().Dir);
 614   llvm::sys::path::append(DefaultLibPath, "lib" CLANG_LIBDIR_SUFFIX);
 615   CmdArgs.push_back(Args.MakeArgString(Twine("-L") + DefaultLibPath));
 616
 617   // Add linking against library implementing OpenMP calls on NVPTX target.
 618   CmdArgs.push_back("-lomptarget-nvptx");
 619
 620   for (const auto &II : Inputs) {
 621     if (II.getType() == types::TY_LLVM_IR ||
 622         II.getType() == types::TY_LTO_IR ||
 623         II.getType() == types::TY_LTO_BC ||
 624         II.getType() == types::TY_LLVM_BC) {
 625       C.getDriver().Diag(diag::err_drv_no_linker_llvm_support)
 626           << getToolChain().getTripleString();
 627       continue;
 628     }
 629
 630     // Currently, we only pass the input files to the linker, we do not pass
 631     // any libraries that may be valid only for the host.
 632     if (!II.isFilename())
 633       continue;
 634
 635     const char *CubinF = C.addTempFile(
 636         C.getArgs().MakeArgString(getToolChain().getInputFilename(II)));
 637
 638     CmdArgs.push_back(CubinF);
 639   }
 640
 641   const char *Exec =
 642       Args.MakeArgString(getToolChain().GetProgramPath("nvlink"));
 643   C.addCommand(std::make_unique<Command>(
 644       JA, *this,
 645       ResponseFileSupport{ResponseFileSupport::RF_Full, llvm::sys::WEM_UTF8,
 646                           "--options-file"},
 647       Exec, CmdArgs, Inputs));
 648 }
 649
 650 /// CUDA toolchain.  Our assembler is ptxas, and our "linker" is fatbinary,
 651 /// which isn't properly a linker but nonetheless performs the step of stitching
 652 /// together object files from the assembler into a single blob.
 653
 654 CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
 655                              const ToolChain &HostTC, const ArgList &Args,
 656                              const Action::OffloadKind OK)
 657     : ToolChain(D, Triple, Args), HostTC(HostTC),
 658       CudaInstallation(D, HostTC.getTriple(), Args), OK(OK) {
 659   if (CudaInstallation.isValid()) {
 660     CudaInstallation.WarnIfUnsupportedVersion();
 661     getProgramPaths().push_back(std::string(CudaInstallation.getBinPath()));
 662   }
 663   // Lookup binaries into the driver directory, this is used to
 664   // discover the clang-offload-bundler executable.
 665   getProgramPaths().push_back(getDriver().Dir);
 666 }
 667
 668 std::string CudaToolChain::getInputFilename(const InputInfo &Input) const {
 669   // Only object files are changed, for example assembly files keep their .s
 670   // extensions. CUDA also continues to use .o as they don't use nvlink but
 671   // fatbinary.
 672   if (!(OK == Action::OFK_OpenMP && Input.getType() == types::TY_Object))
 673     return ToolChain::getInputFilename(Input);
 674
 675   // Replace extension for object files with cubin because nvlink relies on
 676   // these particular file names.
 677   SmallString<256> Filename(ToolChain::getInputFilename(Input));
 678   llvm::sys::path::replace_extension(Filename, "cubin");
 679   return std::string(Filename.str());
 680 }
 681
 682 void CudaToolChain::addClangTargetOptions(
 683     const llvm::opt::ArgList &DriverArgs,
 684     llvm::opt::ArgStringList &CC1Args,
 685     Action::OffloadKind DeviceOffloadingKind) const {
 686   HostTC.addClangTargetOptions(DriverArgs, CC1Args, DeviceOffloadingKind);
 687
 688   StringRef GpuArch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
 689   assert(!GpuArch.empty() && "Must have an explicit GPU arch.");
 690   assert((DeviceOffloadingKind == Action::OFK_OpenMP ||
 691           DeviceOffloadingKind == Action::OFK_Cuda) &&
 692          "Only OpenMP or CUDA offloading kinds are supported for NVIDIA GPUs.");
 693
 694   if (DeviceOffloadingKind == Action::OFK_Cuda) {
 695     CC1Args.push_back("-fcuda-is-device");
 696
 697     if (DriverArgs.hasFlag(options::OPT_fcuda_approx_transcendentals,
 698                            options::OPT_fno_cuda_approx_transcendentals, false))
 699       CC1Args.push_back("-fcuda-approx-transcendentals");
 700
 701     if (DriverArgs.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
 702                            false))
 703       CC1Args.push_back("-fgpu-rdc");
 704   }
 705
 706   if (DriverArgs.hasArg(options::OPT_nogpulib))
 707     return;
 708
 709   std::string LibDeviceFile = CudaInstallation.getLibDeviceFile(GpuArch);
 710
 711   if (LibDeviceFile.empty()) {
 712     if (DeviceOffloadingKind == Action::OFK_OpenMP &&
 713         DriverArgs.hasArg(options::OPT_S))
 714       return;
 715
 716     getDriver().Diag(diag::err_drv_no_cuda_libdevice) << GpuArch;
 717     return;
 718   }
 719
 720   CC1Args.push_back("-mlink-builtin-bitcode");
 721   CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
 722
 723   // New CUDA versions often introduce new instructions that are only supported
 724   // by new PTX version, so we need to raise PTX level to enable them in NVPTX
 725   // back-end.
 726   const char *PtxFeature = nullptr;
 727   switch (CudaInstallation.version()) {
 728   case CudaVersion::CUDA_110:
 729     PtxFeature = "+ptx70";
 730     break;
 731   case CudaVersion::CUDA_102:
 732     PtxFeature = "+ptx65";
 733     break;
 734   case CudaVersion::CUDA_101:
 735     PtxFeature = "+ptx64";
 736     break;
 737   case CudaVersion::CUDA_100:
 738     PtxFeature = "+ptx63";
 739     break;
 740   case CudaVersion::CUDA_92:
 741     PtxFeature = "+ptx61";
 742     break;
 743   case CudaVersion::CUDA_91:
 744     PtxFeature = "+ptx61";
 745     break;
 746   case CudaVersion::CUDA_90:
 747     PtxFeature = "+ptx60";
 748     break;
 749   default:
 750     PtxFeature = "+ptx42";
 751   }
 752   CC1Args.append({"-target-feature", PtxFeature});
 753   if (DriverArgs.hasFlag(options::OPT_fcuda_short_ptr,
 754                          options::OPT_fno_cuda_short_ptr, false))
 755     CC1Args.append({"-mllvm", "--nvptx-short-ptr"});
 756
 757   if (CudaInstallation.version() >= CudaVersion::UNKNOWN)
 758     CC1Args.push_back(DriverArgs.MakeArgString(
 759         Twine("-target-sdk-version=") +
 760         CudaVersionToString(CudaInstallation.version())));
 761
 762   if (DeviceOffloadingKind == Action::OFK_OpenMP) {
 763     SmallVector<StringRef, 8> LibraryPaths;
 764     if (const Arg *A = DriverArgs.getLastArg(options::OPT_libomptarget_nvptx_path_EQ))
 765       LibraryPaths.push_back(A->getValue());
 766
 767     // Add user defined library paths from LIBRARY_PATH.
 768     llvm::Optional<std::string> LibPath =
 769         llvm::sys::Process::GetEnv("LIBRARY_PATH");
 770     if (LibPath) {
 771       SmallVector<StringRef, 8> Frags;
 772       const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
 773       llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
 774       for (StringRef Path : Frags)
 775         LibraryPaths.emplace_back(Path.trim());
 776     }
 777
 778     // Add path to lib / lib64 folder.
 779     SmallString<256> DefaultLibPath =
 780         llvm::sys::path::parent_path(getDriver().Dir);
 781     llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX);
 782     LibraryPaths.emplace_back(DefaultLibPath.c_str());
 783
 784     std::string LibOmpTargetName =
 785       "libomptarget-nvptx-" + GpuArch.str() + ".bc";
 786     bool FoundBCLibrary = false;
 787     for (StringRef LibraryPath : LibraryPaths) {
 788       SmallString<128> LibOmpTargetFile(LibraryPath);
 789       llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);
 790       if (llvm::sys::fs::exists(LibOmpTargetFile)) {
 791         CC1Args.push_back("-mlink-builtin-bitcode");
 792         CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));
 793         FoundBCLibrary = true;
 794         break;
 795       }
 796     }
 797     if (!FoundBCLibrary)
 798       getDriver().Diag(diag::warn_drv_omp_offload_target_missingbcruntime)
 799           << LibOmpTargetName;
 800   }
 801 }
 802
 803 llvm::DenormalMode CudaToolChain::getDefaultDenormalModeForType(
 804     const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
 805     const llvm::fltSemantics *FPType) const {
 806   if (JA.getOffloadingDeviceKind() == Action::OFK_Cuda) {
 807     if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
 808         DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
 809                            options::OPT_fno_cuda_flush_denormals_to_zero,
 810                            false))
 811       return llvm::DenormalMode::getPreserveSign();
 812   }
 813
 814   assert(JA.getOffloadingDeviceKind() != Action::OFK_Host);
 815   return llvm::DenormalMode::getIEEE();
 816 }
 817
 818 bool CudaToolChain::supportsDebugInfoOption(const llvm::opt::Arg *A) const {
 819   const Option &O = A->getOption();
 820   return (O.matches(options::OPT_gN_Group) &&
 821           !O.matches(options::OPT_gmodules)) ||
 822          O.matches(options::OPT_g_Flag) ||
 823          O.matches(options::OPT_ggdbN_Group) || O.matches(options::OPT_ggdb) ||
 824          O.matches(options::OPT_gdwarf) || O.matches(options::OPT_gdwarf_2) ||
 825          O.matches(options::OPT_gdwarf_3) || O.matches(options::OPT_gdwarf_4) ||
 826          O.matches(options::OPT_gdwarf_5) ||
 827          O.matches(options::OPT_gcolumn_info);
 828 }
 829
 830 void CudaToolChain::adjustDebugInfoKind(
 831     codegenoptions::DebugInfoKind &DebugInfoKind, const ArgList &Args) const {
 832   switch (mustEmitDebugInfo(Args)) {
 833   case DisableDebugInfo:
 834     DebugInfoKind = codegenoptions::NoDebugInfo;
 835     break;
 836   case DebugDirectivesOnly:
 837     DebugInfoKind = codegenoptions::DebugDirectivesOnly;
 838     break;
 839   case EmitSameDebugInfoAsHost:
 840     // Use same debug info level as the host.
 841     break;
 842   }
 843 }
 844
 845 void CudaToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
 846                                        ArgStringList &CC1Args) const {
 847   // Check our CUDA version if we're going to include the CUDA headers.
 848   if (!DriverArgs.hasArg(options::OPT_nogpuinc) &&
 849       !DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {
 850     StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
 851     assert(!Arch.empty() && "Must have an explicit GPU arch.");
 852     CudaInstallation.CheckCudaVersionSupportsArch(StringToCudaArch(Arch));
 853   }
 854   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 855 }
 856
 857 llvm::opt::DerivedArgList *
 858 CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
 859                              StringRef BoundArch,
 860                              Action::OffloadKind DeviceOffloadKind) const {
 861   DerivedArgList *DAL =
 862       HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind);
 863   if (!DAL)
 864     DAL = new DerivedArgList(Args.getBaseArgs());
 865
 866   const OptTable &Opts = getDriver().getOpts();
 867
 868   // For OpenMP device offloading, append derived arguments. Make sure
 869   // flags are not duplicated.
 870   // Also append the compute capability.
 871   if (DeviceOffloadKind == Action::OFK_OpenMP) {
 872     for (Arg *A : Args) {
 873       bool IsDuplicate = false;
 874       for (Arg *DALArg : *DAL) {
 875         if (A == DALArg) {
 876           IsDuplicate = true;
 877           break;
 878         }
 879       }
 880       if (!IsDuplicate)
 881         DAL->append(A);
 882     }
 883
 884     StringRef Arch = DAL->getLastArgValue(options::OPT_march_EQ);
 885     if (Arch.empty())
 886       DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ),
 887                         CLANG_OPENMP_NVPTX_DEFAULT_ARCH);
 888
 889     return DAL;
 890   }
 891
 892   for (Arg *A : Args) {
 893     DAL->append(A);
 894   }
 895
 896   if (!BoundArch.empty()) {
 897     DAL->eraseArg(options::OPT_march_EQ);
 898     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
 899   }
 900   return DAL;
 901 }
 902
 903 Tool *CudaToolChain::buildAssembler() const {
 904   return new tools::NVPTX::Assembler(*this);
 905 }
 906
 907 Tool *CudaToolChain::buildLinker() const {
 908   if (OK == Action::OFK_OpenMP)
 909     return new tools::NVPTX::OpenMPLinker(*this);
 910   return new tools::NVPTX::Linker(*this);
 911 }
 912
 913 void CudaToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {
 914   HostTC.addClangWarningOptions(CC1Args);
 915 }
 916
 917 ToolChain::CXXStdlibType
 918 CudaToolChain::GetCXXStdlibType(const ArgList &Args) const {
 919   return HostTC.GetCXXStdlibType(Args);
 920 }
 921
 922 void CudaToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 923                                               ArgStringList &CC1Args) const {
 924   HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args);
 925 }
 926
 927 void CudaToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args,
 928                                                  ArgStringList &CC1Args) const {
 929   HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args);
 930 }
 931
 932 void CudaToolChain::AddIAMCUIncludeArgs(const ArgList &Args,
 933                                         ArgStringList &CC1Args) const {
 934   HostTC.AddIAMCUIncludeArgs(Args, CC1Args);
 935 }
 936
 937 SanitizerMask CudaToolChain::getSupportedSanitizers() const {
 938   // The CudaToolChain only supports sanitizers in the sense that it allows
 939   // sanitizer arguments on the command line if they are supported by the host
 940   // toolchain. The CudaToolChain will actually ignore any command line
 941   // arguments for any of these "supported" sanitizers. That means that no
 942   // sanitization of device code is actually supported at this time.
 943   //
 944   // This behavior is necessary because the host and device toolchains
 945   // invocations often share the command line, so the device toolchain must
 946   // tolerate flags meant only for the host toolchain.
 947   return HostTC.getSupportedSanitizers();
 948 }
 949
 950 VersionTuple CudaToolChain::computeMSVCVersion(const Driver *D,
 951                                                const ArgList &Args) const {
 952   return HostTC.computeMSVCVersion(D, Args);
 953 }