[llvm-branch-commits] [clang] clang/AMDGPU: Merge toolchain subclasses (PR #204863)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Jun 19 09:50:28 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-hexagon
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Simplify the toolchain implementations by collapsing
them into one. Previously we had a confusing split. The
AMDGPUToolChain base class implemented much of the base
support. It was subclassed by ROCMToolChain, which would
have been more accurately described as the offloading subclass.
That was further subclassed into HIP and OpenMP specific subclasses.
Deleting those two is the important part of this change. There was
code duplication, and features arbitrarily handled in one but not
the other. The offload kind is passed in almost everywhere if you
really need to know the original language. However, I consider
this an antifeature, and it is really poor QoI to have the HIP
and OpenMP toolchains behave differently in any way. The platform
should be consistent and the driver behaviors should not depend
on the language.
There is additional mess in the handling of spirv, which this
only partially addresses. There are two different spirv toolchain
paths, which for some reason is keyed off of the amdhsa OS, which
is not the property that should change this. I think it will
ultimately be simplier to just merge all spirv handling into HIPSPV.
The copy-paste machine did most of the work here, and I manually
applied some logical fixups that became apparent after the merge.
Co-Authored-By: Claude <noreply@<!-- -->anthropic.com>
---
Patch is 45.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/204863.diff
10 Files Affected:
- (modified) clang/lib/Driver/CMakeLists.txt (-1)
- (modified) clang/lib/Driver/Driver.cpp (+17-13)
- (modified) clang/lib/Driver/ToolChains/AMDGPU.cpp (+264-123)
- (modified) clang/lib/Driver/ToolChains/AMDGPU.h (+48-23)
- (removed) clang/lib/Driver/ToolChains/AMDGPUOpenMP.cpp (-94)
- (removed) clang/lib/Driver/ToolChains/AMDGPUOpenMP.h (-68)
- (modified) clang/lib/Driver/ToolChains/HIPAMD.cpp (+2-193)
- (modified) clang/lib/Driver/ToolChains/HIPAMD.h (+1-50)
- (modified) clang/test/Driver/hip-device-libs-llvm-env.hip (+7)
- (modified) clang/test/Driver/hip-toolchain-no-rdc.hip (+1-1)
``````````diff
diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt
index cd410899c450f..81ccb31f499c5 100644
--- a/clang/lib/Driver/CMakeLists.txt
+++ b/clang/lib/Driver/CMakeLists.txt
@@ -53,7 +53,6 @@ add_clang_library(clangDriver
ToolChains/Arch/X86.cpp
ToolChains/AIX.cpp
ToolChains/AMDGPU.cpp
- ToolChains/AMDGPUOpenMP.cpp
ToolChains/AVR.cpp
ToolChains/BareMetal.cpp
ToolChains/Clang.cpp
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index a37909694bb90..e97b7356de61a 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -9,7 +9,6 @@
#include "clang/Driver/Driver.h"
#include "ToolChains/AIX.h"
#include "ToolChains/AMDGPU.h"
-#include "ToolChains/AMDGPUOpenMP.h"
#include "ToolChains/AVR.h"
#include "ToolChains/Arch/RISCV.h"
#include "ToolChains/BareMetal.h"
@@ -6974,12 +6973,12 @@ const ToolChain &Driver::getOffloadToolChain(
Args);
break;
case llvm::Triple::AMDHSA:
- if (Kind == Action::OFK_HIP)
- TC = std::make_unique<toolchains::HIPAMDToolChain>(*this, Target,
- *HostTC, Args);
- else if (Kind == Action::OFK_OpenMP)
- TC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(*this, Target,
- *HostTC, Args);
+ // For AMDHSA offloading (HIP, OpenMP), use the unified AMDGPUToolChain
+ // This handles both amdgcn-amd-amdhsa and spirv64-amd-amdhsa
+ // FIXME: This should not key off language or OS.
+ if (Kind == Action::OFK_HIP || Kind == Action::OFK_OpenMP)
+ TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args,
+ HostTC.get(), Kind);
break;
default:
break;
@@ -6988,6 +6987,11 @@ const ToolChain &Driver::getOffloadToolChain(
if (!TC) {
// Detect the toolchain based off of the target architecture if that failed.
switch (Target.getArch()) {
+ case llvm::Triple::amdgcn:
+ case llvm::Triple::r600:
+ TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args,
+ HostTC.get(), Kind);
+ break;
case llvm::Triple::spir:
case llvm::Triple::spir64:
case llvm::Triple::spirv:
@@ -7105,12 +7109,12 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
TC = std::make_unique<toolchains::SPIRVAMDToolChain>(*this, Target,
Args);
} else {
- bool DL = usesInput(Args, types::isOpenCL) ||
- usesInput(Args, types::isLLVMIR);
- TC = DL ? std::make_unique<toolchains::ROCMToolChain>(*this, Target,
- Args)
- : std::make_unique<toolchains::AMDGPUToolChain>(*this, Target,
- Args);
+ // Only link device libraries for OpenCL and LLVM IR inputs
+ bool ShouldLinkDeviceLibs = usesInput(Args, types::isOpenCL) ||
+ usesInput(Args, types::isLLVMIR);
+ TC = std::make_unique<toolchains::AMDGPUToolChain>(
+ *this, Target, Args, nullptr, Action::OFK_None,
+ ShouldLinkDeviceLibs);
}
break;
}
diff --git a/clang/lib/Driver/ToolChains/AMDGPU.cpp b/clang/lib/Driver/ToolChains/AMDGPU.cpp
index 419926cb42aa0..6611b133057f5 100644
--- a/clang/lib/Driver/ToolChains/AMDGPU.cpp
+++ b/clang/lib/Driver/ToolChains/AMDGPU.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "AMDGPU.h"
+#include "HIPAMD.h"
#include "clang/Basic/TargetID.h"
#include "clang/Config/config.h"
#include "clang/Driver/CommonArgs.h"
@@ -672,10 +673,14 @@ void amdgpu::getAMDGPUTargetFeatures(const Driver &D,
/// AMDGPU Toolchain
AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
- const ArgList &Args)
+ const ArgList &Args, const ToolChain *HostTC_,
+ Action::OffloadKind Kind,
+ bool ShouldLinkDeviceLibs_)
: Generic_ELF(D, Triple, Args),
OptionsDefault(
- {{options::OPT_O, "3"}, {options::OPT_cl_std_EQ, "CL1.2"}}) {
+ {{options::OPT_O, "3"}, {options::OPT_cl_std_EQ, "CL1.2"}}),
+ HostTC(HostTC_), UseHIPLinker(Kind == Action::OFK_HIP),
+ ShouldLinkDeviceLibs(ShouldLinkDeviceLibs_) {
loadMultilibsFromYAML(Args, D);
// Check code object version options. Emit warnings for legacy options
@@ -683,9 +688,19 @@ AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
// It is done here to avoid repeated warning or error messages for
// each tool invocation.
checkAMDGPUCodeObjectVersion(D, Args);
+
+ if (Triple.getOS() == llvm::Triple::AMDHSA &&
+ Triple.getEnvironment() != llvm::Triple::LLVM)
+ RocmInstallation->detectDeviceLibrary();
+
+ if (HostTC)
+ getProgramPaths().push_back(getDriver().Dir);
}
Tool *AMDGPUToolChain::buildLinker() const {
+ // FIXME: Should not have 2 linker paths.
+ if (UseHIPLinker)
+ return new tools::AMDGCN::Linker(*this);
return new tools::amdgpu::Linker(*this);
}
@@ -735,24 +750,41 @@ AMDGPUToolChain::TranslateArgs(const DerivedArgList &Args, BoundArch BA,
BA.ArchName);
}
- AMDGPUToolChain::ParsedTargetIDType PTID = checkTargetID(*DAL);
+ if (!getTriple().isSPIRV()) {
+ AMDGPUToolChain::ParsedTargetIDType PTID = checkTargetID(*DAL);
- // Synthesize feature flags for target ID modifiers (xnack, sramecc).
- if (PTID.OptionalFeatureMap) {
- const llvm::StringMap<bool> &FeatureMap = *PTID.OptionalFeatureMap;
+ // Synthesize feature flags for target ID modifiers (xnack, sramecc).
+ if (PTID.OptionalFeatureMap) {
+ const llvm::StringMap<bool> &FeatureMap = *PTID.OptionalFeatureMap;
+
+ auto XnackIt = FeatureMap.find("xnack");
+ if (XnackIt != FeatureMap.end()) {
+ DAL->AddFlagArg(nullptr, Opts.getOption(XnackIt->second
+ ? options::OPT_mxnack
+ : options::OPT_mno_xnack));
+ }
- auto XnackIt = FeatureMap.find("xnack");
- if (XnackIt != FeatureMap.end()) {
- DAL->AddFlagArg(nullptr,
- Opts.getOption(XnackIt->second ? options::OPT_mxnack
- : options::OPT_mno_xnack));
+ auto SrameccIt = FeatureMap.find("sramecc");
+ if (SrameccIt != FeatureMap.end()) {
+ DAL->AddFlagArg(nullptr,
+ Opts.getOption(SrameccIt->second
+ ? options::OPT_msramecc
+ : options::OPT_mno_sramecc));
+ }
}
+ }
- auto SrameccIt = FeatureMap.find("sramecc");
- if (SrameccIt != FeatureMap.end()) {
- DAL->AddFlagArg(nullptr, Opts.getOption(SrameccIt->second
- ? options::OPT_msramecc
- : options::OPT_mno_sramecc));
+ // Filter out sanitizer coverage options that are not supported for AMDGPU.
+ for (Arg *A : Args) {
+ // Sanitizer coverage is currently not supported for AMDGPU.
+ if (A->getOption().matches(options::OPT_fsan_cov_Group)) {
+ // Upgrade to error if the option was explicitly specified for device
+ bool IsExplicitDevice =
+ A->getBaseArg().getOption().matches(options::OPT_Xarch_device);
+ getDriver().Diag(IsExplicitDevice
+ ? diag::err_drv_unsupported_option_for_target
+ : diag::warn_drv_unsupported_option_for_target)
+ << A->getAsString(Args) << getTriple().str();
}
}
@@ -834,41 +866,28 @@ bool AMDGPUToolChain::isWave64(const llvm::opt::ArgList &DriverArgs,
options::OPT_mwavefrontsize64, options::OPT_mno_wavefrontsize64, false);
}
+void AMDGPUToolChain::addClangTargetOptions(
+ const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
+ BoundArch BA, Action::OffloadKind DeviceOffloadingKind) const {
+ if (DeviceOffloadingKind == Action::OFK_HIP) {
+ CC1Args.append({"-fcuda-is-device", "-fno-threadsafe-statics"});
+
+ if (!DriverArgs.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
+ false)) {
+ CC1Args.append({"-mllvm", "-amdgpu-internalize-symbols"});
+ if (DriverArgs.hasArgNoClaim(options::OPT_hipstdpar))
+ CC1Args.append({"-mllvm", "-amdgpu-enable-hipstdpar"});
+ }
-/// ROCM Toolchain
-ROCMToolChain::ROCMToolChain(const Driver &D, const llvm::Triple &Triple,
- const ArgList &Args)
- : AMDGPUToolChain(D, Triple, Args) {
- if (Triple.getEnvironment() != llvm::Triple::LLVM)
- RocmInstallation->detectDeviceLibrary();
-}
-
-DerivedArgList *
-ROCMToolChain::TranslateArgs(const DerivedArgList &Args, BoundArch BA,
- Action::OffloadKind DeviceOffloadKind) const {
- DerivedArgList *DAL =
- AMDGPUToolChain::TranslateArgs(Args, BA, DeviceOffloadKind);
-
- // Filter out sanitizer coverage options that are not supported for AMDGPU.
- for (Arg *A : Args) {
- // Sanitizer coverage is currently not supported for AMDGPU.
- if (A->getOption().matches(options::OPT_fsan_cov_Group)) {
- // Upgrade to error if the option was explicitly specified for device
- bool IsExplicitDevice =
- A->getBaseArg().getOption().matches(options::OPT_Xarch_device);
- getDriver().Diag(IsExplicitDevice
- ? diag::err_drv_unsupported_option_for_target
- : diag::warn_drv_unsupported_option_for_target)
- << A->getAsString(Args) << getTriple().str();
+ // FIXME: This should not depend on HIP
+ StringRef MaxThreadsPerBlock =
+ DriverArgs.getLastArgValue(options::OPT_gpu_max_threads_per_block_EQ);
+ if (!MaxThreadsPerBlock.empty()) {
+ CC1Args.push_back(DriverArgs.MakeArgString(
+ Twine("--gpu-max-threads-per-block=") + MaxThreadsPerBlock));
}
}
- return DAL;
-}
-
-void AMDGPUToolChain::addClangTargetOptions(
- const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
- BoundArch BA, Action::OffloadKind DeviceOffloadingKind) const {
// Default to "hidden" visibility, as object level linking will not be
// supported for the foreseeable future.
// TODO: remove the SPIR-V bypass once it can encode (hidden) visibility.
@@ -879,22 +898,54 @@ void AMDGPUToolChain::addClangTargetOptions(
CC1Args.push_back("-fapply-global-visibility-to-externs");
}
- // For SPIR-V we want to retain the pristine output of Clang CodeGen, since
- // optimizations might lose structure / information that is necessary for
- // generating optimal concrete AMDGPU code.
- // TODO: using the below option is a temporary placeholder until Clang
- // provides the required functionality, which essentially boils down to
- // -O0 being refactored / reworked to not imply optnone / remove TBAA.
- // Once that is added, we should pivot to that functionality, being
- // mindful to not corrupt the user provided and subsequently embedded
- // command-line (i.e. if the user asks for -O3 this is what the
- // finalisation should use).
- if (getTriple().isSPIRV() &&
- !DriverArgs.hasArg(options::OPT_disable_llvm_optzns))
- CC1Args.push_back("-disable-llvm-optzns");
-
- if (DeviceOffloadingKind == Action::OFK_None)
+ if (getEffectiveTriple().isSPIRV()) {
+ // For HIP + SPIRV, embed the command-line into the generated binary
+ if (DeviceOffloadingKind == Action::OFK_HIP &&
+ !DriverArgs.hasArg(options::OPT_fembed_bitcode_marker))
+ CC1Args.push_back("-fembed-bitcode=marker");
+
+ // For SPIR-V we want to retain the pristine output of Clang CodeGen, since
+ // optimizations might lose structure / information that is necessary for
+ // generating optimal concrete AMDGPU code.
+ //
+ // For standalone SPIR-V, use -disable-llvm-optzns
+ // TODO: using the below option is a temporary placeholder until Clang
+ // provides the required functionality, which essentially boils down
+ // to -O0 being refactored / reworked to not imply optnone / remove
+ // TBAA. Once that is added, we should pivot to that functionality,
+ // being mindful to not corrupt the user provided and subsequently
+ // embedded command-line (i.e. if the user asks for -O3 this is what
+ // the finalisation should use).
+ if (!DriverArgs.hasArg(options::OPT_disable_llvm_optzns))
+ CC1Args.push_back("-disable-llvm-optzns");
+
+ return; // No DeviceLibs for SPIR-V.
+ }
+
+ if (DeviceOffloadingKind == Action::OFK_None) {
+ // For the OpenCL case where there is no offload target, accept -nostdlib to
+ // disable bitcode linking.
+ if (DriverArgs.hasArg(options::OPT_nostdlib))
+ return;
+
addOpenCLBuiltinsLib(getDriver(), getTriple(), DriverArgs, CC1Args);
+ }
+
+ if (!DriverArgs.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
+ true))
+ return;
+
+ // With an LLVM environment, only use libraries provided by the resource
+ // directory.
+ if (getEffectiveTriple().getEnvironment() == llvm::Triple::LLVM)
+ return;
+
+ // Link device libraries for OpenCL, HIP, and OpenMP
+ for (auto BCFile : getDeviceLibs(DriverArgs, BA, DeviceOffloadingKind)) {
+ CC1Args.push_back(BCFile.ShouldInternalize ? "-mlink-builtin-bitcode"
+ : "-mlink-bitcode-file");
+ CC1Args.push_back(DriverArgs.MakeArgStringRef(BCFile.Path));
+ }
}
void AMDGPUToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {
@@ -980,66 +1031,6 @@ AMDGPUToolChain::getSystemGPUArchs(const ArgList &Args) const {
return std::move(GPUArchs);
}
-void ROCMToolChain::addClangTargetOptions(
- const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
- BoundArch BA, Action::OffloadKind DeviceOffloadingKind) const {
- AMDGPUToolChain::addClangTargetOptions(DriverArgs, CC1Args, BA,
- DeviceOffloadingKind);
-
- // For the OpenCL case where there is no offload target, accept -nostdlib to
- // disable bitcode linking.
- if (DeviceOffloadingKind == Action::OFK_None &&
- DriverArgs.hasArg(options::OPT_nostdlib))
- return;
-
- if (!DriverArgs.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
- true))
- return;
-
- // For SPIR-V (SPIRVAMDToolChain) we must not link any device libraries so we
- // skip it.
- const llvm::Triple &TT = this->getEffectiveTriple();
- if (TT.isSPIRV())
- return;
-
- // With an LLVM environment, only use libraries provided by the resource
- // directory.
- if (TT.getEnvironment() == llvm::Triple::LLVM)
- return;
-
- // Get the device name and canonicalize it. For offload compilation,
- // BoundArch contains the full target ID. For non-offload (OpenCL),
- // fall back to -mcpu.
- StringRef TargetID =
- BA ? BA.ArchName : DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
- StringRef GpuArch = getProcessorFromTargetID(getTriple(), TargetID);
-
- StringRef LibDeviceFile = RocmInstallation->getLibDeviceFile(GpuArch);
-
- auto ABIVer = DeviceLibABIVersion::fromCodeObjectVersion(
- getAMDGPUCodeObjectVersion(getDriver(), DriverArgs));
- if (!RocmInstallation->checkCommonBitcodeLibs(GpuArch, LibDeviceFile, ABIVer))
- return;
-
- // Add the OpenCL specific bitcode library.
- llvm::SmallVector<BitCodeLibraryInfo, 12> BCLibs;
- BCLibs.emplace_back(RocmInstallation->getOpenCLPath().str());
-
- // Add the generic set of libraries.
- BCLibs.append(RocmInstallation->getCommonBitcodeLibs(
- DriverArgs, LibDeviceFile, GpuArch, DeviceOffloadingKind,
- getSanitizerArgs(DriverArgs, BoundArch{TargetID}, DeviceOffloadingKind)
- .needsAsanRt()));
-
- for (auto [BCFile, Internalize] : BCLibs) {
- if (Internalize)
- CC1Args.push_back("-mlink-builtin-bitcode");
- else
- CC1Args.push_back("-mlink-bitcode-file");
- CC1Args.push_back(DriverArgs.MakeArgString(BCFile));
- }
-}
-
bool RocmInstallationDetector::checkCommonBitcodeLibs(
StringRef GPUArch, StringRef LibDeviceFile,
DeviceLibABIVersion ABIVer) const {
@@ -1104,7 +1095,7 @@ RocmInstallationDetector::getCommonBitcodeLibs(
}
llvm::SmallVector<ToolChain::BitCodeLibraryInfo, 12>
-ROCMToolChain::getCommonDeviceLibNames(
+AMDGPUToolChain::getCommonDeviceLibNames(
const llvm::opt::ArgList &DriverArgs, llvm::StringRef TargetID,
llvm::StringRef GPUArch, Action::OffloadKind DeviceOffloadingKind) const {
auto Kind = llvm::AMDGPU::parseArchAMDGCN(GPUArch);
@@ -1123,6 +1114,156 @@ ROCMToolChain::getCommonDeviceLibNames(
.needsAsanRt());
}
+llvm::SmallVector<ToolChain::BitCodeLibraryInfo, 12>
+AMDGPUToolChain::getDeviceLibs(const llvm::opt::ArgList &DriverArgs,
+ BoundArch BA,
+ Action::OffloadKind DeviceOffloadKind) const {
+ assert(getEffectiveTriple().isAMDGPU() &&
+ "spirv should not try to link device libs");
+
+ if (!DriverArgs.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib,
+ true) ||
+ getEffectiveTriple().getEnvironment() == llvm::Triple::LLVM)
+ return {};
+
+ if (getTriple().getOS() != llvm::Triple::AMDHSA)
+ return {};
+
+ StringRef GpuArch;
+ StringRef TargetID;
+ if (DeviceOffloadKind == Action::OFK_None) {
+ TargetID = DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
+ GpuArch = getProcessorFromTargetID(getTriple(), TargetID);
+ } else {
+ TargetID = BA.ArchName;
+ GpuArch = getProcessorFromTargetID(getTriple(), BA.ArchName);
+ }
+
+ llvm::SmallVector<BitCodeLibraryInfo, 12> BCLibs;
+
+ // HIP-specific handling
+ if (DeviceOffloadKind == Action::OFK_HIP) {
+ // Handle --hip-device-lib manual override
+ auto BCLibArgs = DriverArgs.getAllArgValues(options::OPT_hip_device_lib_EQ);
+ if (!BCLibArgs.empty()) {
+ ArgStringList LibraryPaths;
+ for (StringRef Path : RocmInstallation->getRocmDeviceLibPathArg())
+ LibraryPaths.push_back(DriverArgs.MakeArgStringRef(Path));
+ addDirectoryList(DriverArgs, LibraryPaths, "", "HIP_DEVICE_LIB_PATH");
+
+ for (StringRef BCName : BCLibArgs) {
+ bool Found = false;
+ for (StringRef LibraryPath : LibraryPaths) {
+ SmallString<128> Path(LibraryPath);
+ llvm::sys::path::append(Path, BCName);
+ if (llvm::sys::fs::exists(Path)) {
+ BCLibs.emplace_back(Path);
+ Found = true;
+ break;
+ }
+ }
+ if (!Found)
+ getDriver().Diag(diag::err_drv_no_such_file) << BCName;
+ }
+ return BCLibs;
+ }
+
+ if (!RocmInstallation->hasDeviceLibrary()) {
+ getDriver().Diag(diag::err_drv_no_rocm_device_lib) << 0;
+ return {};
+ }
+
+ // Add common device libraries
+ for (auto N : getCommonDeviceLibNames(DriverArgs, TargetID, GpuArch,
+ DeviceOffloadKind))
+ BCLibs.emplace_back(N);
+
+ // Add instrument lib for HIP
+ auto InstLib =
+ DriverArgs.getLastArgValue(options::OPT_gpu_instrument_lib_EQ);
+ if (!InstLib.empty()) {
+ if (llvm::sys::fs::exists(InstLib))
+ BCLibs.emplace_back(InstLib);
+ else
+ getDriver().Diag(diag::err_drv_no_such_file) << InstLib;
+ }
+
+ return BCLibs;
+ }
+
+ // OpenMP handling
+ if (DeviceOffloadKind == Action::OFK_OpenMP) {
+ for (auto BCLib : getCommonDeviceLibNames(DriverArgs, TargetID, GpuArch,
+ DeviceOffloadKind))
+ BCLibs.emplace_back(BCLib);
+ return BCLibs;
+ }
+
+ // The libraries are currently only built for amdhsa.
+ if (getTriple().getOS() != llvm::Triple::AMDHSA)
+ return {};
+
+ //...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/204863
More information about the llvm-branch-commits
mailing list