16 #include "llvm/Option/ArgList.h"
17 #include "llvm/Support/Error.h"
18 #include "llvm/Support/FileUtilities.h"
19 #include "llvm/Support/LineIterator.h"
20 #include "llvm/Support/Path.h"
21 #include "llvm/Support/VirtualFileSystem.h"
22 #include <system_error>
24 #define AMDGPU_ARCH_PROGRAM_NAME "amdgpu-arch"
29 using namespace clang;
39 RocmInstallationDetector::findSPACKPackage(
const Candidate &Cand,
40 StringRef PackageName) {
44 std::string Prefix = Twine(PackageName +
"-" + Cand.SPACKReleaseStr).str();
46 for (llvm::vfs::directory_iterator
File = D.getVFS().dir_begin(Cand.Path, EC),
48 File != FileEnd && !EC;
File.increment(EC)) {
49 llvm::StringRef FileName = llvm::sys::path::filename(
File->path());
50 if (FileName.startswith(Prefix)) {
51 SubDirs.push_back(FileName);
52 if (SubDirs.size() > 1)
56 if (SubDirs.size() == 1) {
57 auto PackagePath = Cand.Path;
58 llvm::sys::path::append(PackagePath, SubDirs[0]);
61 if (SubDirs.size() == 0 && Verbose) {
62 llvm::errs() <<
"SPACK package " << Prefix <<
" not found at " << Cand.Path
67 if (SubDirs.size() > 1 && Verbose) {
68 llvm::errs() <<
"Cannot use SPACK package " << Prefix <<
" at " << Cand.Path
69 <<
" due to multiple installations for the same version\n";
74 void RocmInstallationDetector::scanLibDevicePath(llvm::StringRef Path) {
75 assert(!Path.empty());
77 const StringRef Suffix(
".bc");
78 const StringRef Suffix2(
".amdgcn.bc");
81 for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(Path, EC),
LE;
82 !EC && LI !=
LE; LI = LI.increment(EC)) {
83 StringRef FilePath = LI->path();
84 StringRef FileName = llvm::sys::path::filename(FilePath);
85 if (!FileName.endswith(Suffix))
89 if (FileName.endswith(Suffix2))
90 BaseName = FileName.drop_back(Suffix2.size());
91 else if (FileName.endswith(Suffix))
92 BaseName = FileName.drop_back(Suffix.size());
94 const StringRef ABIVersionPrefix =
"oclc_abi_version_";
95 if (BaseName ==
"ocml") {
97 }
else if (BaseName ==
"ockl") {
99 }
else if (BaseName ==
"opencl") {
101 }
else if (BaseName ==
"hip") {
103 }
else if (BaseName ==
"asanrtl") {
105 }
else if (BaseName ==
"oclc_finite_only_off") {
106 FiniteOnly.Off = FilePath;
107 }
else if (BaseName ==
"oclc_finite_only_on") {
108 FiniteOnly.On = FilePath;
109 }
else if (BaseName ==
"oclc_daz_opt_on") {
110 DenormalsAreZero.On = FilePath;
111 }
else if (BaseName ==
"oclc_daz_opt_off") {
112 DenormalsAreZero.Off = FilePath;
113 }
else if (BaseName ==
"oclc_correctly_rounded_sqrt_on") {
114 CorrectlyRoundedSqrt.On = FilePath;
115 }
else if (BaseName ==
"oclc_correctly_rounded_sqrt_off") {
116 CorrectlyRoundedSqrt.Off = FilePath;
117 }
else if (BaseName ==
"oclc_unsafe_math_on") {
118 UnsafeMath.On = FilePath;
119 }
else if (BaseName ==
"oclc_unsafe_math_off") {
120 UnsafeMath.Off = FilePath;
121 }
else if (BaseName ==
"oclc_wavefrontsize64_on") {
122 WavefrontSize64.On = FilePath;
123 }
else if (BaseName ==
"oclc_wavefrontsize64_off") {
124 WavefrontSize64.Off = FilePath;
125 }
else if (BaseName.startswith(ABIVersionPrefix)) {
126 unsigned ABIVersionNumber;
127 if (BaseName.drop_front(ABIVersionPrefix.size())
128 .getAsInteger(0, ABIVersionNumber))
130 ABIVersionMap[ABIVersionNumber] = FilePath.str();
134 const StringRef DeviceLibPrefix =
"oclc_isa_version_";
135 if (!BaseName.startswith(DeviceLibPrefix))
138 StringRef IsaVersionNumber =
139 BaseName.drop_front(DeviceLibPrefix.size());
141 llvm::Twine GfxName = Twine(
"gfx") + IsaVersionNumber;
144 std::make_pair(GfxName.toStringRef(Tmp), FilePath.str()));
151 bool RocmInstallationDetector::parseHIPVersionFile(llvm::StringRef
V) {
153 V.split(VersionParts,
'\n');
154 unsigned Major = ~0
U;
155 unsigned Minor = ~0
U;
156 for (
auto Part : VersionParts) {
157 auto Splits = Part.rtrim().split(
'=');
158 if (Splits.first ==
"HIP_VERSION_MAJOR") {
159 if (Splits.second.getAsInteger(0, Major))
161 }
else if (Splits.first ==
"HIP_VERSION_MINOR") {
162 if (Splits.second.getAsInteger(0, Minor))
164 }
else if (Splits.first ==
"HIP_VERSION_PATCH")
165 VersionPatch = Splits.second.str();
167 if (Major == ~0
U || Minor == ~0
U)
169 VersionMajorMinor = llvm::VersionTuple(Major, Minor);
171 (Twine(Major) +
"." + Twine(Minor) +
"." + VersionPatch).str();
178 RocmInstallationDetector::getInstallationPathCandidates() {
181 if (!ROCmSearchDirs.empty())
182 return ROCmSearchDirs;
184 auto DoPrintROCmSearchDirs = [&]() {
185 if (PrintROCmSearchDirs)
186 for (
auto Cand : ROCmSearchDirs) {
187 llvm::errs() <<
"ROCm installation search path";
189 llvm::errs() <<
" (Spack " << Cand.SPACKReleaseStr <<
")";
190 llvm::errs() <<
": " << Cand.Path <<
'\n';
196 if (!RocmPathArg.empty()) {
197 ROCmSearchDirs.emplace_back(RocmPathArg.str());
198 DoPrintROCmSearchDirs();
199 return ROCmSearchDirs;
200 }
else if (
const char *RocmPathEnv = ::getenv(
"ROCM_PATH")) {
201 if (!StringRef(RocmPathEnv).empty()) {
202 ROCmSearchDirs.emplace_back(RocmPathEnv);
203 DoPrintROCmSearchDirs();
204 return ROCmSearchDirs;
209 const char *InstallDir = D.getInstalledDir();
214 auto DeduceROCmPath = [](StringRef ClangPath) {
216 StringRef ParentDir = llvm::sys::path::parent_path(ClangPath);
217 StringRef ParentName = llvm::sys::path::filename(ParentDir);
220 if (ParentName ==
"bin") {
221 ParentDir = llvm::sys::path::parent_path(ParentDir);
222 ParentName = llvm::sys::path::filename(ParentDir);
230 if (ParentName.startswith(
"llvm-amdgpu-")) {
232 ParentName.drop_front(strlen(
"llvm-amdgpu-")).split(
'-');
233 auto SPACKReleaseStr = SPACKPostfix.first;
234 if (!SPACKReleaseStr.empty()) {
235 ParentDir = llvm::sys::path::parent_path(ParentDir);
236 return Candidate(ParentDir.str(),
true,
243 if (ParentName ==
"llvm" || ParentName.startswith(
"aomp"))
244 ParentDir = llvm::sys::path::parent_path(ParentDir);
246 return Candidate(ParentDir.str(),
true);
251 ROCmSearchDirs.emplace_back(DeduceROCmPath(InstallDir));
256 llvm::sys::fs::real_path(D.getClangProgramPath(), RealClangPath);
257 auto ParentPath = llvm::sys::path::parent_path(RealClangPath);
258 if (ParentPath != InstallDir)
259 ROCmSearchDirs.emplace_back(DeduceROCmPath(ParentPath));
262 auto ClangRoot = llvm::sys::path::parent_path(InstallDir);
263 auto RealClangRoot = llvm::sys::path::parent_path(ParentPath);
264 ROCmSearchDirs.emplace_back(ClangRoot.str(),
true);
265 if (RealClangRoot != ClangRoot)
266 ROCmSearchDirs.emplace_back(RealClangRoot.str(),
true);
267 ROCmSearchDirs.emplace_back(D.ResourceDir,
270 ROCmSearchDirs.emplace_back(D.SysRoot +
"/opt/rocm",
276 llvm::VersionTuple LatestVer;
278 auto GetROCmVersion = [](StringRef DirName) {
279 llvm::VersionTuple
V;
280 std::string VerStr = DirName.drop_front(strlen(
"rocm-")).str();
283 std::replace(VerStr.begin(), VerStr.end(),
'-',
'.');
287 for (llvm::vfs::directory_iterator
288 File = D.getVFS().dir_begin(D.SysRoot +
"/opt", EC),
290 File != FileEnd && !EC;
File.increment(EC)) {
291 llvm::StringRef FileName = llvm::sys::path::filename(
File->path());
292 if (!FileName.startswith(
"rocm-"))
294 if (LatestROCm.empty()) {
295 LatestROCm = FileName.str();
296 LatestVer = GetROCmVersion(LatestROCm);
299 auto Ver = GetROCmVersion(FileName);
300 if (LatestVer < Ver) {
301 LatestROCm = FileName.str();
305 if (!LatestROCm.empty())
306 ROCmSearchDirs.emplace_back(D.SysRoot +
"/opt/" + LatestROCm,
309 DoPrintROCmSearchDirs();
310 return ROCmSearchDirs;
314 const Driver &D,
const llvm::Triple &HostTriple,
315 const llvm::opt::ArgList &Args,
bool DetectHIPRuntime,
bool DetectDeviceLib)
317 Verbose = Args.hasArg(options::OPT_v);
318 RocmPathArg = Args.getLastArgValue(clang::driver::options::OPT_rocm_path_EQ);
319 PrintROCmSearchDirs =
320 Args.hasArg(clang::driver::options::OPT_print_rocm_search_dirs);
321 RocmDeviceLibPathArg =
322 Args.getAllArgValues(clang::driver::options::OPT_rocm_device_lib_path_EQ);
323 HIPPathArg = Args.getLastArgValue(clang::driver::options::OPT_hip_path_EQ);
324 if (
auto *A = Args.getLastArg(clang::driver::options::OPT_hip_version_EQ)) {
325 HIPVersionArg = A->getValue();
326 unsigned Major = ~0
U;
327 unsigned Minor = ~0
U;
329 HIPVersionArg.split(Parts,
'.');
331 Parts[0].getAsInteger(0, Major);
332 if (Parts.size() > 1)
333 Parts[1].getAsInteger(0, Minor);
334 if (Parts.size() > 2)
335 VersionPatch = Parts[2].str();
336 if (VersionPatch.empty())
338 if (Major != ~0
U && Minor == ~0
U)
340 if (Major == ~0
U || Minor == ~0
U)
341 D.
Diag(diag::err_drv_invalid_value)
342 << A->getAsString(Args) << HIPVersionArg;
344 VersionMajorMinor = llvm::VersionTuple(Major, Minor);
346 (Twine(Major) +
"." + Twine(Minor) +
"." + VersionPatch).str();
348 VersionPatch = DefaultVersionPatch;
350 llvm::VersionTuple(DefaultVersionMajor, DefaultVersionMinor);
351 DetectedVersion = (Twine(DefaultVersionMajor) +
"." +
352 Twine(DefaultVersionMinor) +
"." + VersionPatch)
356 if (DetectHIPRuntime)
363 assert(LibDevicePath.empty());
365 if (!RocmDeviceLibPathArg.empty())
366 LibDevicePath = RocmDeviceLibPathArg[RocmDeviceLibPathArg.size() - 1];
367 else if (
const char *LibPathEnv = ::getenv(
"HIP_DEVICE_LIB_PATH"))
368 LibDevicePath = LibPathEnv;
371 if (!LibDevicePath.empty()) {
375 if (!FS.exists(LibDevicePath))
378 scanLibDevicePath(LibDevicePath);
379 HasDeviceLibrary = allGenericLibsValid() && !LibDeviceMap.empty();
388 auto &ROCmDirs = getInstallationPathCandidates();
389 for (
const auto &Candidate : ROCmDirs) {
390 auto CandidatePath = Candidate.Path;
393 auto CheckDeviceLib = [&](StringRef Path) {
394 bool CheckLibDevice = (!NoBuiltinLibs || Candidate.StrictChecking);
395 if (CheckLibDevice && !FS.exists(Path))
398 scanLibDevicePath(Path);
400 if (!NoBuiltinLibs) {
402 if (!allGenericLibsValid())
407 if (LibDeviceMap.empty())
418 static constexpr std::array<const char *, 2> SubDirsList[] = {
419 {
"amdgcn",
"bitcode"},
426 auto Path = CandidatePath;
427 for (
auto SubDir : SubDirs)
428 llvm::sys::path::append(Path, SubDir);
432 for (
auto SubDirs : SubDirsList) {
433 LibDevicePath = MakePath(SubDirs);
434 HasDeviceLibrary = CheckDeviceLib(LibDevicePath);
435 if (HasDeviceLibrary)
443 if (!HIPPathArg.empty())
444 HIPSearchDirs.emplace_back(HIPPathArg.str(),
true);
446 HIPSearchDirs.append(getInstallationPathCandidates());
449 for (
const auto &Candidate : HIPSearchDirs) {
450 InstallPath = Candidate.Path;
451 if (InstallPath.empty() || !FS.exists(InstallPath))
455 auto SPACKPath = findSPACKPackage(Candidate,
"hip");
456 InstallPath = SPACKPath.empty() ? InstallPath : SPACKPath;
458 BinPath = InstallPath;
459 llvm::sys::path::append(BinPath,
"bin");
460 IncludePath = InstallPath;
461 llvm::sys::path::append(IncludePath,
"include");
462 LibPath = InstallPath;
463 llvm::sys::path::append(LibPath,
"lib");
465 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
466 FS.getBufferForFile(BinPath +
"/.hipVersion");
467 if (!VersionFile && Candidate.StrictChecking)
470 if (HIPVersionArg.empty() && VersionFile)
471 if (parseHIPVersionFile((*VersionFile)->getBuffer()))
474 HasHIPRuntime =
true;
477 HasHIPRuntime =
false;
482 OS <<
"Found HIP installation: " << InstallPath <<
", version "
483 << DetectedVersion <<
'\n';
487 ArgStringList &CC1Args)
const {
488 bool UsesRuntimeWrapper = VersionMajorMinor > llvm::VersionTuple(3, 5) &&
489 !DriverArgs.hasArg(options::OPT_nohipwrapperinc);
491 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
506 if (UsesRuntimeWrapper)
507 llvm::sys::path::append(
P,
"include",
"cuda_wrappers");
508 CC1Args.push_back(
"-internal-isystem");
509 CC1Args.push_back(DriverArgs.MakeArgString(
P));
512 if (DriverArgs.hasArg(options::OPT_nogpuinc))
516 D.
Diag(diag::err_drv_no_hip_runtime);
520 CC1Args.push_back(
"-idirafter");
522 if (UsesRuntimeWrapper)
523 CC1Args.append({
"-include",
"__clang_hip_runtime_wrapper.h"});
530 const char *LinkingOutput)
const {
533 ArgStringList CmdArgs;
536 CmdArgs.push_back(
"-shared");
537 CmdArgs.push_back(
"-o");
539 C.addCommand(std::make_unique<Command>(
541 CmdArgs, Inputs, Output));
545 const llvm::Triple &Triple,
546 const llvm::opt::ArgList &Args,
547 std::vector<StringRef> &Features) {
550 StringRef TargetID = Args.getLastArgValue(options::OPT_mcpu_EQ);
551 if (!TargetID.empty()) {
552 llvm::StringMap<bool> FeatureMap;
553 auto OptionalGpuArch =
parseTargetID(Triple, TargetID, &FeatureMap);
554 if (OptionalGpuArch) {
555 StringRef GpuArch = OptionalGpuArch.getValue();
561 auto Pos = FeatureMap.find(Feature);
562 if (Pos == FeatureMap.end())
564 Features.push_back(Args.MakeArgStringRef(
565 (Twine(Pos->second ?
"+" :
"-") + Feature).str()));
570 if (Args.hasFlag(options::OPT_mwavefrontsize64,
571 options::OPT_mno_wavefrontsize64,
false))
572 Features.push_back(
"+wavefrontsize64");
575 Args, Features, options::OPT_m_amdgpu_Features_Group);
579 AMDGPUToolChain::AMDGPUToolChain(
const Driver &D,
const llvm::Triple &Triple,
583 {{options::OPT_O,
"3"}, {options::OPT_cl_std_EQ,
"CL1.2"}}) {
599 DerivedArgList *DAL =
605 DAL =
new DerivedArgList(Args.getBaseArgs());
607 for (Arg *A : Args) {
614 if (!Args.getLastArgValue(options::OPT_x).equals(
"cl"))
618 if (Args.hasArg(options::OPT_c) && Args.hasArg(options::OPT_emit_llvm)) {
619 DAL->AddFlagArg(
nullptr, Opts.getOption(
getTriple().isArch64Bit()
621 : options::OPT_m32));
625 if (!Args.hasArg(options::OPT_O, options::OPT_O0, options::OPT_O4,
627 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_O),
635 llvm::AMDGPU::GPUKind
Kind) {
638 if (
Kind == llvm::AMDGPU::GK_NONE)
641 const unsigned ArchAttr = llvm::AMDGPU::getArchAttrAMDGCN(
Kind);
645 const bool BothDenormAndFMAFast =
646 (ArchAttr & llvm::AMDGPU::FEATURE_FAST_FMA_F32) &&
647 (ArchAttr & llvm::AMDGPU::FEATURE_FAST_DENORMAL_F32);
648 return !BothDenormAndFMAFast;
652 const llvm::opt::ArgList &DriverArgs,
const JobAction &JA,
653 const llvm::fltSemantics *FPType)
const {
655 if (!FPType || FPType != &llvm::APFloat::IEEEsingle())
656 return llvm::DenormalMode::getIEEE();
661 auto Kind = llvm::AMDGPU::parseArchAMDGCN(Arch);
662 if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
663 DriverArgs.hasFlag(options::OPT_fgpu_flush_denormals_to_zero,
664 options::OPT_fno_gpu_flush_denormals_to_zero,
666 return llvm::DenormalMode::getPreserveSign();
668 return llvm::DenormalMode::getIEEE();
671 const StringRef GpuArch =
getGPUArch(DriverArgs);
672 auto Kind = llvm::AMDGPU::parseArchAMDGCN(GpuArch);
676 bool DAZ = DriverArgs.hasArg(options::OPT_cl_denorms_are_zero) ||
681 return DAZ ? llvm::DenormalMode::getPreserveSign() :
682 llvm::DenormalMode::getIEEE();
686 llvm::AMDGPU::GPUKind
Kind) {
687 const unsigned ArchAttr = llvm::AMDGPU::getArchAttrAMDGCN(
Kind);
688 bool HasWave32 = (ArchAttr & llvm::AMDGPU::FEATURE_WAVE32);
690 return !HasWave32 || DriverArgs.hasFlag(
691 options::OPT_mwavefrontsize64, options::OPT_mno_wavefrontsize64,
false);
703 const llvm::opt::ArgList &DriverArgs,
704 llvm::opt::ArgStringList &CC1Args,
708 if (!DriverArgs.hasArg(options::OPT_fvisibility_EQ,
709 options::OPT_fvisibility_ms_compat)) {
710 CC1Args.push_back(
"-fvisibility");
711 CC1Args.push_back(
"hidden");
712 CC1Args.push_back(
"-fapply-global-visibility-to-externs");
719 getTriple(), DriverArgs.getLastArgValue(options::OPT_mcpu_EQ));
724 StringRef TargetID = DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
725 if (TargetID.empty())
726 return {None, None, None};
728 llvm::StringMap<bool> FeatureMap;
730 if (!OptionalGpuArch)
731 return {TargetID.str(), None, None};
733 return {TargetID.str(), OptionalGpuArch.getValue().str(), FeatureMap};
737 const llvm::opt::ArgList &DriverArgs)
const {
739 if (PTID.OptionalTargetID && !PTID.OptionalGPUArch) {
741 << PTID.OptionalTargetID.getValue();
749 if (Arg *A = Args.getLastArg(options::OPT_amdgpu_arch_tool_EQ))
750 Program = A->getValue();
754 llvm::sys::fs::createTemporaryFile(
"print-system-gpus",
"" ,
756 llvm::FileRemover OutputRemover(OutputFile.c_str());
764 if (
int Result = llvm::sys::ExecuteAndWait(
765 Program, {}, {}, Redirects, 0,
768 ErrorMessage =
"Exited with error code " + std::to_string(Result);
769 }
else if (Result == -1) {
770 ErrorMessage =
"Execute failed: " + ErrorMessage;
772 ErrorMessage =
"Crashed: " + ErrorMessage;
775 return llvm::createStringError(std::error_code(),
776 Program +
": " + ErrorMessage);
779 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
780 llvm::MemoryBuffer::getFile(OutputFile.c_str());
782 return llvm::createStringError(OutputBuf.getError(),
783 "Failed to read stdout of " + Program +
784 ": " + OutputBuf.getError().message());
787 for (llvm::line_iterator LineIt(**OutputBuf); !LineIt.is_at_end(); ++LineIt) {
788 GPUArchs.push_back(LineIt->str());
790 return llvm::Error::success();
801 if (GPUArchs.empty()) {
802 return llvm::createStringError(std::error_code(),
803 "No AMD GPU detected in the system");
805 GPUArch = GPUArchs[0];
806 if (GPUArchs.size() > 1) {
807 bool AllSame = llvm::all_of(GPUArchs, [&](
const StringRef &GPUArch) {
808 return GPUArch == GPUArchs.front();
811 return llvm::createStringError(
812 std::error_code(),
"Multiple AMD GPUs found with different archs");
814 return llvm::Error::success();
818 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
821 DeviceOffloadingKind);
826 DriverArgs.hasArg(options::OPT_nostdlib))
829 if (DriverArgs.hasArg(options::OPT_nogpulib))
833 const StringRef GpuArch =
getGPUArch(DriverArgs);
834 auto Kind = llvm::AMDGPU::parseArchAMDGCN(GpuArch);
835 const StringRef CanonArch = llvm::AMDGPU::getArchNameAMDGCN(
Kind);
847 bool DAZ = DriverArgs.hasArg(options::OPT_cl_denorms_are_zero) ||
849 bool FiniteOnly = DriverArgs.hasArg(options::OPT_cl_finite_math_only);
852 DriverArgs.hasArg(options::OPT_cl_unsafe_math_optimizations);
853 bool FastRelaxedMath = DriverArgs.hasArg(options::OPT_cl_fast_relaxed_math);
855 DriverArgs.hasArg(options::OPT_cl_fp32_correctly_rounded_divide_sqrt);
863 DriverArgs, LibDeviceFile, Wave64, DAZ, FiniteOnly, UnsafeMathOpt,
864 FastRelaxedMath, CorrectSqrt, ABIVer,
false));
866 llvm::for_each(BCLibs, [&](StringRef BCFile) {
867 CC1Args.push_back(
"-mlink-builtin-bitcode");
868 CC1Args.push_back(DriverArgs.MakeArgString(BCFile));
873 StringRef GPUArch, StringRef LibDeviceFile,
875 if (!hasDeviceLibrary()) {
876 D.Diag(diag::err_drv_no_rocm_device_lib) << 0;
879 if (LibDeviceFile.empty()) {
880 D.Diag(diag::err_drv_no_rocm_device_lib) << 1 << GPUArch;
884 D.Diag(diag::err_drv_no_rocm_device_lib) << 2 << ABIVer.
toString();
892 const llvm::opt::ArgList &DriverArgs, StringRef LibDeviceFile,
bool Wave64,
893 bool DAZ,
bool FiniteOnly,
bool UnsafeMathOpt,
bool FastRelaxedMath,
897 auto AddBCLib = [&](StringRef BCFile) { BCLibs.push_back(BCFile.str()); };
899 AddBCLib(getOCMLPath());
900 AddBCLib(getOCKLPath());
901 AddBCLib(getDenormalsAreZeroPath(DAZ));
902 AddBCLib(getUnsafeMathPath(UnsafeMathOpt || FastRelaxedMath));
903 AddBCLib(getFiniteOnlyPath(FiniteOnly || FastRelaxedMath));
904 AddBCLib(getCorrectlyRoundedSqrtPath(CorrectSqrt));
905 AddBCLib(getWavefrontSize64Path(Wave64));
906 AddBCLib(LibDeviceFile);
907 auto ABIVerPath = getABIVersionPath(ABIVer);
908 if (!ABIVerPath.empty())
909 AddBCLib(ABIVerPath);
915 Option O = A->getOption();
916 if (O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie))
924 bool isOpenMP)
const {
925 auto Kind = llvm::AMDGPU::parseArchAMDGCN(GPUArch);
926 const StringRef CanonArch = llvm::AMDGPU::getArchNameAMDGCN(
Kind);
938 bool DAZ = DriverArgs.hasFlag(options::OPT_fgpu_flush_denormals_to_zero,
939 options::OPT_fno_gpu_flush_denormals_to_zero,
941 bool FiniteOnly = DriverArgs.hasFlag(
942 options::OPT_ffinite_math_only, options::OPT_fno_finite_math_only,
false);
944 DriverArgs.hasFlag(options::OPT_funsafe_math_optimizations,
945 options::OPT_fno_unsafe_math_optimizations,
false);
946 bool FastRelaxedMath = DriverArgs.hasFlag(options::OPT_ffast_math,
947 options::OPT_fno_fast_math,
false);
948 bool CorrectSqrt = DriverArgs.hasFlag(
949 options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
950 options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt,
true);
954 DriverArgs, LibDeviceFile, Wave64, DAZ, FiniteOnly, UnsafeMathOpt,
955 FastRelaxedMath, CorrectSqrt, ABIVer, isOpenMP);