clang  13.0.0git
AMDGPU.cpp
Go to the documentation of this file.
1 //===--- AMDGPU.cpp - AMDGPU 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 "AMDGPU.h"
10 #include "CommonArgs.h"
11 #include "InputInfo.h"
12 #include "clang/Basic/TargetID.h"
15 #include "llvm/Option/ArgList.h"
16 #include "llvm/Support/Path.h"
17 #include "llvm/Support/VirtualFileSystem.h"
18 
19 using namespace clang::driver;
20 using namespace clang::driver::tools;
21 using namespace clang::driver::toolchains;
22 using namespace clang;
23 using namespace llvm::opt;
24 
25 // Look for sub-directory starts with PackageName under ROCm candidate path.
26 // If there is one and only one matching sub-directory found, append the
27 // sub-directory to Path. If there is no matching sub-directory or there are
28 // more than one matching sub-directories, diagnose them. Returns the full
29 // path of the package if there is only one matching sub-directory, otherwise
30 // returns an empty string.
32 RocmInstallationDetector::findSPACKPackage(const Candidate &Cand,
33  StringRef PackageName) {
34  if (!Cand.isSPACK())
35  return {};
36  std::error_code EC;
37  std::string Prefix = Twine(PackageName + "-" + Cand.SPACKReleaseStr).str();
39  for (llvm::vfs::directory_iterator File = D.getVFS().dir_begin(Cand.Path, EC),
40  FileEnd;
41  File != FileEnd && !EC; File.increment(EC)) {
42  llvm::StringRef FileName = llvm::sys::path::filename(File->path());
43  if (FileName.startswith(Prefix)) {
44  SubDirs.push_back(FileName);
45  if (SubDirs.size() > 1)
46  break;
47  }
48  }
49  if (SubDirs.size() == 1) {
50  auto PackagePath = Cand.Path;
51  llvm::sys::path::append(PackagePath, SubDirs[0]);
52  return PackagePath;
53  }
54  if (SubDirs.size() == 0) {
55  unsigned DiagID = D.getDiags().getCustomDiagID(
57  "Expecting SPACK package %0 at %1 but not found");
58  D.Diag(DiagID) << Prefix << Cand.Path;
59  return {};
60  }
61 
62  assert(SubDirs.size() > 1);
63  unsigned DiagID = D.getDiags().getCustomDiagID(
65  "Expecting one SPACK package %0 at %1 but found more");
66  D.Diag(DiagID) << Prefix << Cand.Path;
67  return {};
68 }
69 
70 void RocmInstallationDetector::scanLibDevicePath(llvm::StringRef Path) {
71  assert(!Path.empty());
72 
73  const StringRef Suffix(".bc");
74  const StringRef Suffix2(".amdgcn.bc");
75 
76  std::error_code EC;
77  for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(Path, EC), LE;
78  !EC && LI != LE; LI = LI.increment(EC)) {
79  StringRef FilePath = LI->path();
80  StringRef FileName = llvm::sys::path::filename(FilePath);
81  if (!FileName.endswith(Suffix))
82  continue;
83 
84  StringRef BaseName;
85  if (FileName.endswith(Suffix2))
86  BaseName = FileName.drop_back(Suffix2.size());
87  else if (FileName.endswith(Suffix))
88  BaseName = FileName.drop_back(Suffix.size());
89 
90  if (BaseName == "ocml") {
91  OCML = FilePath;
92  } else if (BaseName == "ockl") {
93  OCKL = FilePath;
94  } else if (BaseName == "opencl") {
95  OpenCL = FilePath;
96  } else if (BaseName == "hip") {
97  HIP = FilePath;
98  } else if (BaseName == "asanrtl") {
99  AsanRTL = FilePath;
100  } else if (BaseName == "oclc_finite_only_off") {
101  FiniteOnly.Off = FilePath;
102  } else if (BaseName == "oclc_finite_only_on") {
103  FiniteOnly.On = FilePath;
104  } else if (BaseName == "oclc_daz_opt_on") {
105  DenormalsAreZero.On = FilePath;
106  } else if (BaseName == "oclc_daz_opt_off") {
107  DenormalsAreZero.Off = FilePath;
108  } else if (BaseName == "oclc_correctly_rounded_sqrt_on") {
109  CorrectlyRoundedSqrt.On = FilePath;
110  } else if (BaseName == "oclc_correctly_rounded_sqrt_off") {
111  CorrectlyRoundedSqrt.Off = FilePath;
112  } else if (BaseName == "oclc_unsafe_math_on") {
113  UnsafeMath.On = FilePath;
114  } else if (BaseName == "oclc_unsafe_math_off") {
115  UnsafeMath.Off = FilePath;
116  } else if (BaseName == "oclc_wavefrontsize64_on") {
117  WavefrontSize64.On = FilePath;
118  } else if (BaseName == "oclc_wavefrontsize64_off") {
119  WavefrontSize64.Off = FilePath;
120  } else {
121  // Process all bitcode filenames that look like
122  // ocl_isa_version_XXX.amdgcn.bc
123  const StringRef DeviceLibPrefix = "oclc_isa_version_";
124  if (!BaseName.startswith(DeviceLibPrefix))
125  continue;
126 
127  StringRef IsaVersionNumber =
128  BaseName.drop_front(DeviceLibPrefix.size());
129 
130  llvm::Twine GfxName = Twine("gfx") + IsaVersionNumber;
131  SmallString<8> Tmp;
132  LibDeviceMap.insert(
133  std::make_pair(GfxName.toStringRef(Tmp), FilePath.str()));
134  }
135  }
136 }
137 
138 // Parse and extract version numbers from `.hipVersion`. Return `true` if
139 // the parsing fails.
140 bool RocmInstallationDetector::parseHIPVersionFile(llvm::StringRef V) {
141  SmallVector<StringRef, 4> VersionParts;
142  V.split(VersionParts, '\n');
143  unsigned Major = ~0U;
144  unsigned Minor = ~0U;
145  for (auto Part : VersionParts) {
146  auto Splits = Part.rtrim().split('=');
147  if (Splits.first == "HIP_VERSION_MAJOR") {
148  if (Splits.second.getAsInteger(0, Major))
149  return true;
150  } else if (Splits.first == "HIP_VERSION_MINOR") {
151  if (Splits.second.getAsInteger(0, Minor))
152  return true;
153  } else if (Splits.first == "HIP_VERSION_PATCH")
154  VersionPatch = Splits.second.str();
155  }
156  if (Major == ~0U || Minor == ~0U)
157  return true;
158  VersionMajorMinor = llvm::VersionTuple(Major, Minor);
159  DetectedVersion =
160  (Twine(Major) + "." + Twine(Minor) + "." + VersionPatch).str();
161  return false;
162 }
163 
164 /// \returns a list of candidate directories for ROCm installation, which is
165 /// cached and populated only once.
167 RocmInstallationDetector::getInstallationPathCandidates() {
168 
169  // Return the cached candidate list if it has already been populated.
170  if (!ROCmSearchDirs.empty())
171  return ROCmSearchDirs;
172 
173  auto DoPrintROCmSearchDirs = [&]() {
174  if (PrintROCmSearchDirs)
175  for (auto Cand : ROCmSearchDirs) {
176  llvm::errs() << "ROCm installation search path";
177  if (Cand.isSPACK())
178  llvm::errs() << " (Spack " << Cand.SPACKReleaseStr << ")";
179  llvm::errs() << ": " << Cand.Path << '\n';
180  }
181  };
182 
183  // For candidate specified by --rocm-path we do not do strict check, i.e.,
184  // checking existence of HIP version file and device library files.
185  if (!RocmPathArg.empty()) {
186  ROCmSearchDirs.emplace_back(RocmPathArg.str());
187  DoPrintROCmSearchDirs();
188  return ROCmSearchDirs;
189  } else if (const char *RocmPathEnv = ::getenv("ROCM_PATH")) {
190  if (!StringRef(RocmPathEnv).empty()) {
191  ROCmSearchDirs.emplace_back(RocmPathEnv);
192  DoPrintROCmSearchDirs();
193  return ROCmSearchDirs;
194  }
195  }
196 
197  // Try to find relative to the compiler binary.
198  const char *InstallDir = D.getInstalledDir();
199 
200  // Check both a normal Unix prefix position of the clang binary, as well as
201  // the Windows-esque layout the ROCm packages use with the host architecture
202  // subdirectory of bin.
203  auto DeduceROCmPath = [](StringRef ClangPath) {
204  // Strip off directory (usually bin)
205  StringRef ParentDir = llvm::sys::path::parent_path(ClangPath);
206  StringRef ParentName = llvm::sys::path::filename(ParentDir);
207 
208  // Some builds use bin/{host arch}, so go up again.
209  if (ParentName == "bin") {
210  ParentDir = llvm::sys::path::parent_path(ParentDir);
211  ParentName = llvm::sys::path::filename(ParentDir);
212  }
213 
214  // Detect ROCm packages built with SPACK.
215  // clang is installed at
216  // <rocm_root>/llvm-amdgpu-<rocm_release_string>-<hash>/bin directory.
217  // We only consider the parent directory of llvm-amdgpu package as ROCm
218  // installation candidate for SPACK.
219  if (ParentName.startswith("llvm-amdgpu-")) {
220  auto SPACKPostfix =
221  ParentName.drop_front(strlen("llvm-amdgpu-")).split('-');
222  auto SPACKReleaseStr = SPACKPostfix.first;
223  if (!SPACKReleaseStr.empty()) {
224  ParentDir = llvm::sys::path::parent_path(ParentDir);
225  return Candidate(ParentDir.str(), /*StrictChecking=*/true,
226  SPACKReleaseStr);
227  }
228  }
229 
230  // Some versions of the rocm llvm package install to /opt/rocm/llvm/bin
231  // Some versions of the aomp package install to /opt/rocm/aomp/bin
232  if (ParentName == "llvm" || ParentName.startswith("aomp"))
233  ParentDir = llvm::sys::path::parent_path(ParentDir);
234 
235  return Candidate(ParentDir.str(), /*StrictChecking=*/true);
236  };
237 
238  // Deduce ROCm path by the path used to invoke clang. Do not resolve symbolic
239  // link of clang itself.
240  ROCmSearchDirs.emplace_back(DeduceROCmPath(InstallDir));
241 
242  // Deduce ROCm path by the real path of the invoked clang, resolving symbolic
243  // link of clang itself.
244  llvm::SmallString<256> RealClangPath;
245  llvm::sys::fs::real_path(D.getClangProgramPath(), RealClangPath);
246  auto ParentPath = llvm::sys::path::parent_path(RealClangPath);
247  if (ParentPath != InstallDir)
248  ROCmSearchDirs.emplace_back(DeduceROCmPath(ParentPath));
249 
250  // Device library may be installed in clang resource directory.
251  ROCmSearchDirs.emplace_back(D.ResourceDir,
252  /*StrictChecking=*/true);
253 
254  ROCmSearchDirs.emplace_back(D.SysRoot + "/opt/rocm",
255  /*StrictChecking=*/true);
256 
257  // Find the latest /opt/rocm-{release} directory.
258  std::error_code EC;
259  std::string LatestROCm;
260  llvm::VersionTuple LatestVer;
261  // Get ROCm version from ROCm directory name.
262  auto GetROCmVersion = [](StringRef DirName) {
263  llvm::VersionTuple V;
264  std::string VerStr = DirName.drop_front(strlen("rocm-")).str();
265  // The ROCm directory name follows the format of
266  // rocm-{major}.{minor}.{subMinor}[-{build}]
267  std::replace(VerStr.begin(), VerStr.end(), '-', '.');
268  V.tryParse(VerStr);
269  return V;
270  };
271  for (llvm::vfs::directory_iterator
272  File = D.getVFS().dir_begin(D.SysRoot + "/opt", EC),
273  FileEnd;
274  File != FileEnd && !EC; File.increment(EC)) {
275  llvm::StringRef FileName = llvm::sys::path::filename(File->path());
276  if (!FileName.startswith("rocm-"))
277  continue;
278  if (LatestROCm.empty()) {
279  LatestROCm = FileName.str();
280  LatestVer = GetROCmVersion(LatestROCm);
281  continue;
282  }
283  auto Ver = GetROCmVersion(FileName);
284  if (LatestVer < Ver) {
285  LatestROCm = FileName.str();
286  LatestVer = Ver;
287  }
288  }
289  if (!LatestROCm.empty())
290  ROCmSearchDirs.emplace_back(D.SysRoot + "/opt/" + LatestROCm,
291  /*StrictChecking=*/true);
292 
293  DoPrintROCmSearchDirs();
294  return ROCmSearchDirs;
295 }
296 
298  const Driver &D, const llvm::Triple &HostTriple,
299  const llvm::opt::ArgList &Args, bool DetectHIPRuntime, bool DetectDeviceLib)
300  : D(D) {
301  RocmPathArg = Args.getLastArgValue(clang::driver::options::OPT_rocm_path_EQ);
302  PrintROCmSearchDirs =
303  Args.hasArg(clang::driver::options::OPT_print_rocm_search_dirs);
304  RocmDeviceLibPathArg =
305  Args.getAllArgValues(clang::driver::options::OPT_rocm_device_lib_path_EQ);
306  HIPPathArg = Args.getLastArgValue(clang::driver::options::OPT_hip_path_EQ);
307  if (auto *A = Args.getLastArg(clang::driver::options::OPT_hip_version_EQ)) {
308  HIPVersionArg = A->getValue();
309  unsigned Major = 0;
310  unsigned Minor = 0;
312  HIPVersionArg.split(Parts, '.');
313  if (Parts.size())
314  Parts[0].getAsInteger(0, Major);
315  if (Parts.size() > 1)
316  Parts[1].getAsInteger(0, Minor);
317  if (Parts.size() > 2)
318  VersionPatch = Parts[2].str();
319  if (VersionPatch.empty())
320  VersionPatch = "0";
321  if (Major == 0 || Minor == 0)
322  D.Diag(diag::err_drv_invalid_value)
323  << A->getAsString(Args) << HIPVersionArg;
324 
325  VersionMajorMinor = llvm::VersionTuple(Major, Minor);
326  DetectedVersion =
327  (Twine(Major) + "." + Twine(Minor) + "." + VersionPatch).str();
328  } else {
329  VersionPatch = DefaultVersionPatch;
330  VersionMajorMinor =
331  llvm::VersionTuple(DefaultVersionMajor, DefaultVersionMinor);
332  DetectedVersion = (Twine(DefaultVersionMajor) + "." +
333  Twine(DefaultVersionMinor) + "." + VersionPatch)
334  .str();
335  }
336 
337  if (DetectHIPRuntime)
339  if (DetectDeviceLib)
341 }
342 
344  assert(LibDevicePath.empty());
345 
346  if (!RocmDeviceLibPathArg.empty())
347  LibDevicePath = RocmDeviceLibPathArg[RocmDeviceLibPathArg.size() - 1];
348  else if (const char *LibPathEnv = ::getenv("HIP_DEVICE_LIB_PATH"))
349  LibDevicePath = LibPathEnv;
350 
351  auto &FS = D.getVFS();
352  if (!LibDevicePath.empty()) {
353  // Maintain compatability with HIP flag/envvar pointing directly at the
354  // bitcode library directory. This points directly at the library path instead
355  // of the rocm root installation.
356  if (!FS.exists(LibDevicePath))
357  return;
358 
359  scanLibDevicePath(LibDevicePath);
360  HasDeviceLibrary = allGenericLibsValid() && !LibDeviceMap.empty();
361  return;
362  }
363 
364  // The install path situation in old versions of ROCm is a real mess, and
365  // use a different install layout. Multiple copies of the device libraries
366  // exist for each frontend project, and differ depending on which build
367  // system produced the packages. Standalone OpenCL builds also have a
368  // different directory structure from the ROCm OpenCL package.
369  auto &ROCmDirs = getInstallationPathCandidates();
370  for (const auto &Candidate : ROCmDirs) {
371  auto CandidatePath = Candidate.Path;
372 
373  // Check device library exists at the given path.
374  auto CheckDeviceLib = [&](StringRef Path) {
375  bool CheckLibDevice = (!NoBuiltinLibs || Candidate.StrictChecking);
376  if (CheckLibDevice && !FS.exists(Path))
377  return false;
378 
379  scanLibDevicePath(Path);
380 
381  if (!NoBuiltinLibs) {
382  // Check that the required non-target libraries are all available.
383  if (!allGenericLibsValid())
384  return false;
385 
386  // Check that we have found at least one libdevice that we can link in
387  // if -nobuiltinlib hasn't been specified.
388  if (LibDeviceMap.empty())
389  return false;
390  }
391  return true;
392  };
393 
394  // The possible structures are:
395  // - ${ROCM_ROOT}/amdgcn/bitcode/*
396  // - ${ROCM_ROOT}/lib/*
397  // - ${ROCM_ROOT}/lib/bitcode/*
398  // so try to detect these layouts.
399  static constexpr std::array<const char *, 2> SubDirsList[] = {
400  {"amdgcn", "bitcode"},
401  {"lib", ""},
402  {"lib", "bitcode"},
403  };
404 
405  // Make a path by appending sub-directories to InstallPath.
406  auto MakePath = [&](const llvm::ArrayRef<const char *> &SubDirs) {
407  // Device library built by SPACK is installed to
408  // <rocm_root>/rocm-device-libs-<rocm_release_string>-<hash> directory.
409  auto SPACKPath = findSPACKPackage(Candidate, "rocm-device-libs");
410  auto Path = SPACKPath.empty() ? CandidatePath : SPACKPath;
411  for (auto SubDir : SubDirs)
412  llvm::sys::path::append(Path, SubDir);
413  return Path;
414  };
415 
416  for (auto SubDirs : SubDirsList) {
417  LibDevicePath = MakePath(SubDirs);
418  HasDeviceLibrary = CheckDeviceLib(LibDevicePath);
419  if (HasDeviceLibrary)
420  return;
421  }
422  }
423 }
424 
426  SmallVector<Candidate, 4> HIPSearchDirs;
427  if (!HIPPathArg.empty())
428  HIPSearchDirs.emplace_back(HIPPathArg.str(), /*StrictChecking=*/true);
429  else
430  HIPSearchDirs.append(getInstallationPathCandidates());
431  auto &FS = D.getVFS();
432 
433  for (const auto &Candidate : HIPSearchDirs) {
434  InstallPath = Candidate.Path;
435  if (InstallPath.empty() || !FS.exists(InstallPath))
436  continue;
437  // HIP runtime built by SPACK is installed to
438  // <rocm_root>/hip-<rocm_release_string>-<hash> directory.
439  auto SPACKPath = findSPACKPackage(Candidate, "hip");
440  InstallPath = SPACKPath.empty() ? InstallPath : SPACKPath;
441 
442  BinPath = InstallPath;
443  llvm::sys::path::append(BinPath, "bin");
444  IncludePath = InstallPath;
445  llvm::sys::path::append(IncludePath, "include");
446  LibPath = InstallPath;
447  llvm::sys::path::append(LibPath, "lib");
448 
449  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
450  FS.getBufferForFile(BinPath + "/.hipVersion");
451  if (!VersionFile && Candidate.StrictChecking)
452  continue;
453 
454  if (HIPVersionArg.empty() && VersionFile)
455  if (parseHIPVersionFile((*VersionFile)->getBuffer()))
456  continue;
457 
458  HasHIPRuntime = true;
459  return;
460  }
461  HasHIPRuntime = false;
462 }
463 
464 void RocmInstallationDetector::print(raw_ostream &OS) const {
465  if (hasHIPRuntime())
466  OS << "Found HIP installation: " << InstallPath << ", version "
467  << DetectedVersion << '\n';
468 }
469 
470 void RocmInstallationDetector::AddHIPIncludeArgs(const ArgList &DriverArgs,
471  ArgStringList &CC1Args) const {
472  bool UsesRuntimeWrapper = VersionMajorMinor > llvm::VersionTuple(3, 5);
473 
474  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
475  // HIP header includes standard library wrapper headers under clang
476  // cuda_wrappers directory. Since these wrapper headers include_next
477  // standard C++ headers, whereas libc++ headers include_next other clang
478  // headers. The include paths have to follow this order:
479  // - wrapper include path
480  // - standard C++ include path
481  // - other clang include path
482  // Since standard C++ and other clang include paths are added in other
483  // places after this function, here we only need to make sure wrapper
484  // include path is added.
485  //
486  // ROCm 3.5 does not fully support the wrapper headers. Therefore it needs
487  // a workaround.
489  if (UsesRuntimeWrapper)
490  llvm::sys::path::append(P, "include", "cuda_wrappers");
491  CC1Args.push_back("-internal-isystem");
492  CC1Args.push_back(DriverArgs.MakeArgString(P));
493  }
494 
495  if (DriverArgs.hasArg(options::OPT_nogpuinc))
496  return;
497 
498  if (!hasHIPRuntime()) {
499  D.Diag(diag::err_drv_no_hip_runtime);
500  return;
501  }
502 
503  CC1Args.push_back("-internal-isystem");
504  CC1Args.push_back(DriverArgs.MakeArgString(getIncludePath()));
505  if (UsesRuntimeWrapper)
506  CC1Args.append({"-include", "__clang_hip_runtime_wrapper.h"});
507 }
508 
509 void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
510  const InputInfo &Output,
511  const InputInfoList &Inputs,
512  const ArgList &Args,
513  const char *LinkingOutput) const {
514 
515  std::string Linker = getToolChain().GetProgramPath(getShortName());
516  ArgStringList CmdArgs;
517  addLinkerCompressDebugSectionsOption(getToolChain(), Args, CmdArgs);
518  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
519  CmdArgs.push_back("-shared");
520  CmdArgs.push_back("-o");
521  CmdArgs.push_back(Output.getFilename());
522  C.addCommand(std::make_unique<Command>(
523  JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker),
524  CmdArgs, Inputs, Output));
525 }
526 
528  const llvm::Triple &Triple,
529  const llvm::opt::ArgList &Args,
530  std::vector<StringRef> &Features) {
531  // Add target ID features to -target-feature options. No diagnostics should
532  // be emitted here since invalid target ID is diagnosed at other places.
533  StringRef TargetID = Args.getLastArgValue(options::OPT_mcpu_EQ);
534  if (!TargetID.empty()) {
535  llvm::StringMap<bool> FeatureMap;
536  auto OptionalGpuArch = parseTargetID(Triple, TargetID, &FeatureMap);
537  if (OptionalGpuArch) {
538  StringRef GpuArch = OptionalGpuArch.getValue();
539  // Iterate through all possible target ID features for the given GPU.
540  // If it is mapped to true, add +feature.
541  // If it is mapped to false, add -feature.
542  // If it is not in the map (default), do not add it
543  for (auto &&Feature : getAllPossibleTargetIDFeatures(Triple, GpuArch)) {
544  auto Pos = FeatureMap.find(Feature);
545  if (Pos == FeatureMap.end())
546  continue;
547  Features.push_back(Args.MakeArgStringRef(
548  (Twine(Pos->second ? "+" : "-") + Feature).str()));
549  }
550  }
551  }
552 
553  if (Args.hasFlag(options::OPT_mwavefrontsize64,
554  options::OPT_mno_wavefrontsize64, false))
555  Features.push_back("+wavefrontsize64");
556 
558  Args, Features, options::OPT_m_amdgpu_Features_Group);
559 }
560 
561 /// AMDGPU Toolchain
562 AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
563  const ArgList &Args)
564  : Generic_ELF(D, Triple, Args),
565  OptionsDefault(
566  {{options::OPT_O, "3"}, {options::OPT_cl_std_EQ, "CL1.2"}}) {
567  // Check code object version options. Emit warnings for legacy options
568  // and errors for the last invalid code object version options.
569  // It is done here to avoid repeated warning or error messages for
570  // each tool invocation.
571  (void)getOrCheckAMDGPUCodeObjectVersion(D, Args, /*Diagnose=*/true);
572 }
573 
575  return new tools::amdgpu::Linker(*this);
576 }
577 
578 DerivedArgList *
579 AMDGPUToolChain::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
580  Action::OffloadKind DeviceOffloadKind) const {
581 
582  DerivedArgList *DAL =
583  Generic_ELF::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
584 
585  const OptTable &Opts = getDriver().getOpts();
586 
587  if (!DAL)
588  DAL = new DerivedArgList(Args.getBaseArgs());
589 
590  for (Arg *A : Args) {
591  if (!shouldSkipArgument(A))
592  DAL->append(A);
593  }
594 
595  checkTargetID(*DAL);
596 
597  if (!Args.getLastArgValue(options::OPT_x).equals("cl"))
598  return DAL;
599 
600  // Phase 1 (.cl -> .bc)
601  if (Args.hasArg(options::OPT_c) && Args.hasArg(options::OPT_emit_llvm)) {
602  DAL->AddFlagArg(nullptr, Opts.getOption(getTriple().isArch64Bit()
603  ? options::OPT_m64
604  : options::OPT_m32));
605 
606  // Have to check OPT_O4, OPT_O0 & OPT_Ofast separately
607  // as they defined that way in Options.td
608  if (!Args.hasArg(options::OPT_O, options::OPT_O0, options::OPT_O4,
609  options::OPT_Ofast))
610  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_O),
611  getOptionDefault(options::OPT_O));
612  }
613 
614  return DAL;
615 }
616 
618  llvm::AMDGPU::GPUKind Kind) {
619 
620  // Assume nothing without a specific target.
621  if (Kind == llvm::AMDGPU::GK_NONE)
622  return false;
623 
624  const unsigned ArchAttr = llvm::AMDGPU::getArchAttrAMDGCN(Kind);
625 
626  // Default to enabling f32 denormals by default on subtargets where fma is
627  // fast with denormals
628  const bool BothDenormAndFMAFast =
629  (ArchAttr & llvm::AMDGPU::FEATURE_FAST_FMA_F32) &&
630  (ArchAttr & llvm::AMDGPU::FEATURE_FAST_DENORMAL_F32);
631  return !BothDenormAndFMAFast;
632 }
633 
635  const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
636  const llvm::fltSemantics *FPType) const {
637  // Denormals should always be enabled for f16 and f64.
638  if (!FPType || FPType != &llvm::APFloat::IEEEsingle())
639  return llvm::DenormalMode::getIEEE();
640 
644  auto Kind = llvm::AMDGPU::parseArchAMDGCN(Arch);
645  if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
646  DriverArgs.hasFlag(options::OPT_fgpu_flush_denormals_to_zero,
647  options::OPT_fno_gpu_flush_denormals_to_zero,
649  return llvm::DenormalMode::getPreserveSign();
650 
651  return llvm::DenormalMode::getIEEE();
652  }
653 
654  const StringRef GpuArch = getGPUArch(DriverArgs);
655  auto Kind = llvm::AMDGPU::parseArchAMDGCN(GpuArch);
656 
657  // TODO: There are way too many flags that change this. Do we need to check
658  // them all?
659  bool DAZ = DriverArgs.hasArg(options::OPT_cl_denorms_are_zero) ||
661 
662  // Outputs are flushed to zero (FTZ), preserving sign. Denormal inputs are
663  // also implicit treated as zero (DAZ).
664  return DAZ ? llvm::DenormalMode::getPreserveSign() :
665  llvm::DenormalMode::getIEEE();
666 }
667 
668 bool AMDGPUToolChain::isWave64(const llvm::opt::ArgList &DriverArgs,
669  llvm::AMDGPU::GPUKind Kind) {
670  const unsigned ArchAttr = llvm::AMDGPU::getArchAttrAMDGCN(Kind);
671  bool HasWave32 = (ArchAttr & llvm::AMDGPU::FEATURE_WAVE32);
672 
673  return !HasWave32 || DriverArgs.hasFlag(
674  options::OPT_mwavefrontsize64, options::OPT_mno_wavefrontsize64, false);
675 }
676 
677 
678 /// ROCM Toolchain
679 ROCMToolChain::ROCMToolChain(const Driver &D, const llvm::Triple &Triple,
680  const ArgList &Args)
681  : AMDGPUToolChain(D, Triple, Args) {
683 }
684 
686  const llvm::opt::ArgList &DriverArgs,
687  llvm::opt::ArgStringList &CC1Args,
688  Action::OffloadKind DeviceOffloadingKind) const {
689  // Default to "hidden" visibility, as object level linking will not be
690  // supported for the foreseeable future.
691  if (!DriverArgs.hasArg(options::OPT_fvisibility_EQ,
692  options::OPT_fvisibility_ms_compat)) {
693  CC1Args.push_back("-fvisibility");
694  CC1Args.push_back("hidden");
695  CC1Args.push_back("-fapply-global-visibility-to-externs");
696  }
697 }
698 
699 StringRef
700 AMDGPUToolChain::getGPUArch(const llvm::opt::ArgList &DriverArgs) const {
702  getTriple(), DriverArgs.getLastArgValue(options::OPT_mcpu_EQ));
703 }
704 
706  const llvm::opt::ArgList &DriverArgs) const {
707  StringRef TargetID = DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
708  if (TargetID.empty())
709  return;
710 
711  llvm::StringMap<bool> FeatureMap;
712  auto OptionalGpuArch = parseTargetID(getTriple(), TargetID, &FeatureMap);
713  if (!OptionalGpuArch) {
714  getDriver().Diag(clang::diag::err_drv_bad_target_id) << TargetID;
715  }
716 }
717 
719  const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
720  Action::OffloadKind DeviceOffloadingKind) const {
721  AMDGPUToolChain::addClangTargetOptions(DriverArgs, CC1Args,
722  DeviceOffloadingKind);
723 
724  // For the OpenCL case where there is no offload target, accept -nostdlib to
725  // disable bitcode linking.
726  if (DeviceOffloadingKind == Action::OFK_None &&
727  DriverArgs.hasArg(options::OPT_nostdlib))
728  return;
729 
730  if (DriverArgs.hasArg(options::OPT_nogpulib))
731  return;
732 
734  getDriver().Diag(diag::err_drv_no_rocm_device_lib) << 0;
735  return;
736  }
737 
738  // Get the device name and canonicalize it
739  const StringRef GpuArch = getGPUArch(DriverArgs);
740  auto Kind = llvm::AMDGPU::parseArchAMDGCN(GpuArch);
741  const StringRef CanonArch = llvm::AMDGPU::getArchNameAMDGCN(Kind);
742  std::string LibDeviceFile = RocmInstallation.getLibDeviceFile(CanonArch);
743  if (LibDeviceFile.empty()) {
744  getDriver().Diag(diag::err_drv_no_rocm_device_lib) << 1 << GpuArch;
745  return;
746  }
747 
748  bool Wave64 = isWave64(DriverArgs, Kind);
749 
750  // TODO: There are way too many flags that change this. Do we need to check
751  // them all?
752  bool DAZ = DriverArgs.hasArg(options::OPT_cl_denorms_are_zero) ||
754  bool FiniteOnly = DriverArgs.hasArg(options::OPT_cl_finite_math_only);
755 
756  bool UnsafeMathOpt =
757  DriverArgs.hasArg(options::OPT_cl_unsafe_math_optimizations);
758  bool FastRelaxedMath = DriverArgs.hasArg(options::OPT_cl_fast_relaxed_math);
759  bool CorrectSqrt =
760  DriverArgs.hasArg(options::OPT_cl_fp32_correctly_rounded_divide_sqrt);
761 
762  // Add the OpenCL specific bitcode library.
764  BCLibs.push_back(RocmInstallation.getOpenCLPath().str());
765 
766  // Add the generic set of libraries.
768  DriverArgs, LibDeviceFile, Wave64, DAZ, FiniteOnly, UnsafeMathOpt,
769  FastRelaxedMath, CorrectSqrt));
770 
771  llvm::for_each(BCLibs, [&](StringRef BCFile) {
772  CC1Args.push_back("-mlink-builtin-bitcode");
773  CC1Args.push_back(DriverArgs.MakeArgString(BCFile));
774  });
775 }
776 
779  const llvm::opt::ArgList &DriverArgs, StringRef LibDeviceFile, bool Wave64,
780  bool DAZ, bool FiniteOnly, bool UnsafeMathOpt, bool FastRelaxedMath,
781  bool CorrectSqrt) const {
782 
784 
785  auto AddBCLib = [&](StringRef BCFile) { BCLibs.push_back(BCFile.str()); };
786 
787  AddBCLib(getOCMLPath());
788  AddBCLib(getOCKLPath());
789  AddBCLib(getDenormalsAreZeroPath(DAZ));
790  AddBCLib(getUnsafeMathPath(UnsafeMathOpt || FastRelaxedMath));
791  AddBCLib(getFiniteOnlyPath(FiniteOnly || FastRelaxedMath));
792  AddBCLib(getCorrectlyRoundedSqrtPath(CorrectSqrt));
793  AddBCLib(getWavefrontSize64Path(Wave64));
794  AddBCLib(LibDeviceFile);
795 
796  return BCLibs;
797 }
798 
799 bool AMDGPUToolChain::shouldSkipArgument(const llvm::opt::Arg *A) const {
800  Option O = A->getOption();
801  if (O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie))
802  return true;
803  return false;
804 }
clang::OpenCL
@ OpenCL
Definition: LangStandard.h:58
clang::driver::RocmInstallationDetector::detectHIPRuntime
void detectHIPRuntime()
Definition: AMDGPU.cpp:425
clang::driver::toolchains
Definition: AIX.h:55
clang::driver::toolchains::AMDGPUToolChain::getGPUArch
StringRef getGPUArch(const llvm::opt::ArgList &DriverArgs) const
Get GPU arch from -mcpu without checking.
Definition: AMDGPU.cpp:700
clang::driver::Action::getOffloadingArch
const char * getOffloadingArch() const
Definition: Action.h:200
clang::driver::toolchains::AMDGPUToolChain::shouldSkipArgument
bool shouldSkipArgument(const llvm::opt::Arg *Arg) const
Should skip argument.
Definition: AMDGPU.cpp:799
clang::driver::RocmInstallationDetector::hasHIPRuntime
bool hasHIPRuntime() const
Check whether we detected a valid HIP runtime.
Definition: ROCm.h:147
clang::driver::RocmInstallationDetector::AddHIPIncludeArgs
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: AMDGPU.cpp:470
clang::DeclaratorContext::File
@ File
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::Action::OFK_Cuda
@ OFK_Cuda
Definition: Action.h:92
clang::driver::toolchains::Generic_GCC::TranslateArgs
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: Gnu.cpp:3021
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::tools::getOrCheckAMDGPUCodeObjectVersion
unsigned getOrCheckAMDGPUCodeObjectVersion(const Driver &D, const llvm::opt::ArgList &Args, bool Diagnose=false)
Definition: CommonArgs.cpp:1576
clang::driver::RocmInstallationDetector::detectDeviceLibrary
void detectDeviceLibrary()
Definition: AMDGPU.cpp:343
clang::driver::tools
Definition: AIX.h:17
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:214
clang::driver::Action::OFK_HIP
@ OFK_HIP
Definition: Action.h:94
clang::driver::RocmInstallationDetector::RocmInstallationDetector
RocmInstallationDetector(const Driver &D, const llvm::Triple &HostTriple, const llvm::opt::ArgList &Args, bool DetectHIPRuntime=true, bool DetectDeviceLib=false)
Definition: AMDGPU.cpp:297
clang::driver::Driver::getOpts
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:322
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::toolchains::ROCMToolChain::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: AMDGPU.cpp:718
InputInfo.h
clang::driver::RocmInstallationDetector::getIncludePath
StringRef getIncludePath() const
Get the detected path to Rocm's bin directory.
Definition: ROCm.h:165
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
U
V
#define V(N, I)
Definition: ASTContext.h:3018
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
clang::driver::toolchains::Generic_ELF
Definition: Gnu.h:367
clang::interp::LE
bool LE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:237
clang::driver::RocmInstallationDetector::getOpenCLPath
StringRef getOpenCLPath() const
Definition: ROCm.h:183
llvm::opt
Definition: DiagnosticOptions.h:19
DriverDiagnostic.h
clang::driver::ResponseFileSupport::AtFileCurCP
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:91
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
clang::getProcessorFromTargetID
llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch)
Get processor name from target ID.
Definition: TargetID.cpp:53
clang::driver::toolchains::AMDGPUToolChain::isWave64
static bool isWave64(const llvm::opt::ArgList &DriverArgs, llvm::AMDGPU::GPUKind Kind)
Definition: AMDGPU.cpp:668
llvm::SmallString< 0 >
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition: ToolChain.h:216
TargetID.h
clang::driver::toolchains::AMDGPUToolChain::buildLinker
Tool * buildLinker() const override
Definition: AMDGPU.cpp:574
clang::driver::tools::handleTargetFeaturesGroup
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
Iterate Args and convert -mxxx to +xxx and -mno-xxx to -xxx and append it to Features.
clang::driver::Action::OFK_None
@ OFK_None
Definition: Action.h:86
AMDGPU.h
clang::driver::toolchains::ROCMToolChain::ROCMToolChain
ROCMToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
ROCM Toolchain.
Definition: AMDGPU.cpp:679
clang::driver::RocmInstallationDetector::hasDeviceLibrary
bool hasDeviceLibrary() const
Check whether we detected a valid ROCm device library.
Definition: ROCm.h:150
clang::driver::Driver::ResourceDir
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:132
clang::parseTargetID
llvm::Optional< llvm::StringRef > parseTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch, llvm::StringMap< bool > *FeatureMap)
Parse a target ID to get processor and feature map.
Definition: TargetID.cpp:104
clang::driver::RocmInstallationDetector::print
void print(raw_ostream &OS) const
Print information about the detected ROCm installation.
Definition: AMDGPU.cpp:464
clang::driver::toolchains::Generic_GCC::RocmInstallation
RocmInstallationDetector RocmInstallation
Definition: Gnu.h:290
clang::getAllPossibleTargetIDFeatures
const llvm::SmallVector< llvm::StringRef, 4 > getAllPossibleTargetIDFeatures(const llvm::Triple &T, llvm::StringRef Processor)
Get all feature strings that can be used in target ID for Processor.
Definition: TargetID.cpp:37
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
Compilation.h
llvm::ArrayRef< const char * >
clang::driver::RocmInstallationDetector::getCommonBitcodeLibs
llvm::SmallVector< std::string, 12 > getCommonBitcodeLibs(const llvm::opt::ArgList &DriverArgs, StringRef LibDeviceFile, bool Wave64, bool DAZ, bool FiniteOnly, bool UnsafeMathOpt, bool FastRelaxedMath, bool CorrectSqrt) const
Get file paths of default bitcode libraries common to AMDGPU based toolchains.
Definition: AMDGPU.cpp:778
clang::driver::Action::getOffloadingDeviceKind
OffloadKind getOffloadingDeviceKind() const
Definition: Action.h:199
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::driver::toolchains::AMDGPUToolChain::TranslateArgs
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: AMDGPU.cpp:579
clang::driver::tools::amdgpu::getAMDGPUTargetFeatures
void getAMDGPUTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
Definition: AMDGPU.cpp:527
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
clang::driver::toolchains::AMDGPUToolChain::getOptionDefault
const StringRef getOptionDefault(options::ID OptID) const
Definition: AMDGPU.h:54
clang::driver::RocmInstallationDetector::getLibDeviceFile
std::string getLibDeviceFile(StringRef Gpu) const
Get libdevice file for given architecture.
Definition: ROCm.h:217
CommonArgs.h
clang
Dataflow Directional Tag Classes.
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
clang::driver::toolchains::AMDGPUToolChain::checkTargetID
void checkTargetID(const llvm::opt::ArgList &DriverArgs) const
Check and diagnose invalid target ID specified by -mcpu.
Definition: AMDGPU.cpp:705
clang::driver::tools::amdgpu::Linker
Definition: AMDGPU.h:29
clang::driver::toolchains::AMDGPUToolChain::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: AMDGPU.cpp:685
clang::driver::Driver::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:326
clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormalModeForType
llvm::DenormalMode getDefaultDenormalModeForType(const llvm::opt::ArgList &DriverArgs, const JobAction &JA, const llvm::fltSemantics *FPType=nullptr) const override
Returns the output denormal handling type in the default floating point environment for the given FPT...
Definition: AMDGPU.cpp:634
clang::driver::tools::addLinkerCompressDebugSectionsOption
void addLinkerCompressDebugSectionsOption(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Definition: CommonArgs.cpp:275
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:85
clang::Language::HIP
@ HIP
clang::driver
Definition: Action.h:31
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::driver::JobAction
Definition: Action.h:380
clang::driver::toolchains::AMDGPUToolChain
Definition: AMDGPU.h:49
clang::driver::toolchains::AMDGPUToolChain::getDefaultDenormsAreZeroForTarget
static bool getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind GPUKind)
Return whether denormals should be flushed, and treated as 0 by default for the subtarget.
Definition: AMDGPU.cpp:617