[clang] 62c3c1c - Revert "[Driver][SYCL] Add initial SYCL offload compilation support" (#116381)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Nov 15 05:05:03 PST 2024
Author: Aaron Ballman
Date: 2024-11-15T08:04:59-05:00
New Revision: 62c3c1cad78b3354432fe44285f3472d9c93a45a
URL: https://github.com/llvm/llvm-project/commit/62c3c1cad78b3354432fe44285f3472d9c93a45a
DIFF: https://github.com/llvm/llvm-project/commit/62c3c1cad78b3354432fe44285f3472d9c93a45a.diff
LOG: Revert "[Driver][SYCL] Add initial SYCL offload compilation support" (#116381)
Reverts llvm/llvm-project#107493
Failing bots include:
https://lab.llvm.org/buildbot/#/builders/190/builds/9546
https://lab.llvm.org/buildbot/#/builders/46/builds/7938
Added:
Modified:
clang/include/clang/Driver/Action.h
clang/include/clang/Driver/Driver.h
clang/include/clang/Driver/Options.td
clang/include/clang/Driver/ToolChain.h
clang/lib/Driver/Action.cpp
clang/lib/Driver/CMakeLists.txt
clang/lib/Driver/Compilation.cpp
clang/lib/Driver/Driver.cpp
clang/lib/Driver/ToolChain.cpp
clang/lib/Driver/ToolChains/Clang.cpp
clang/lib/Driver/ToolChains/Gnu.cpp
clang/lib/Driver/ToolChains/Gnu.h
clang/lib/Driver/ToolChains/Linux.cpp
clang/lib/Driver/ToolChains/Linux.h
clang/lib/Driver/ToolChains/MSVC.cpp
clang/lib/Driver/ToolChains/MSVC.h
llvm/include/llvm/TargetParser/Triple.h
Removed:
clang/lib/Driver/ToolChains/SYCL.cpp
clang/lib/Driver/ToolChains/SYCL.h
clang/test/Driver/sycl-offload-jit.cpp
################################################################################
diff --git a/clang/include/clang/Driver/Action.h b/clang/include/clang/Driver/Action.h
index feeabae89d6b1c..04fa8b01b418f8 100644
--- a/clang/include/clang/Driver/Action.h
+++ b/clang/include/clang/Driver/Action.h
@@ -94,7 +94,6 @@ class Action {
OFK_Cuda = 0x02,
OFK_OpenMP = 0x04,
OFK_HIP = 0x08,
- OFK_SYCL = 0x10,
};
static const char *getClassName(ActionClass AC);
diff --git a/clang/include/clang/Driver/Driver.h b/clang/include/clang/Driver/Driver.h
index 3fee9dd4318a92..9177d56718ee77 100644
--- a/clang/include/clang/Driver/Driver.h
+++ b/clang/include/clang/Driver/Driver.h
@@ -582,10 +582,6 @@ class Driver {
/// @name Helper Methods
/// @{
- /// getSYCLDeviceTriple - Returns the SYCL device triple for the
- /// specified ArchType.
- llvm::Triple getSYCLDeviceTriple(StringRef TargetArch = "spir64") const;
-
/// PrintActions - Print the list of actions.
void PrintActions(const Compilation &C) const;
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index ad14fa88ea6ffb..0a94a7185df8c7 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -182,8 +182,7 @@ def opencl_Group : OptionGroup<"<opencl group>">, Group<f_Group>,
DocName<"OpenCL options">;
def sycl_Group : OptionGroup<"<SYCL group>">, Group<f_Group>,
- DocName<"SYCL options">,
- Visibility<[ClangOption, CLOption]>;
+ DocName<"SYCL options">;
def cuda_Group : OptionGroup<"<CUDA group>">, Group<f_Group>,
DocName<"CUDA options">,
@@ -6781,20 +6780,16 @@ defm : FlangIgnoredDiagOpt<"frontend-loop-interchange">;
defm : FlangIgnoredDiagOpt<"target-lifetime">;
// C++ SYCL options
-let Group = sycl_Group in {
def fsycl : Flag<["-"], "fsycl">,
- HelpText<"Enables SYCL kernels compilation for device">;
+ Visibility<[ClangOption, CLOption]>,
+ Group<sycl_Group>, HelpText<"Enables SYCL kernels compilation for device">;
def fno_sycl : Flag<["-"], "fno-sycl">,
- HelpText<"Disables SYCL kernels compilation for device">;
-def fsycl_device_only : Flag<["-"], "fsycl-device-only">,
- Alias<offload_device_only>, HelpText<"Compile SYCL kernels for device only">;
-def fsycl_host_only : Flag<["-"], "fsycl-host-only">,
- Alias<offload_host_only>, HelpText<"Compile SYCL kernels for host only">;
+ Visibility<[ClangOption, CLOption]>,
+ Group<sycl_Group>, HelpText<"Disables SYCL kernels compilation for device">;
def sycl_link : Flag<["--"], "sycl-link">, Flags<[HelpHidden]>,
- HelpText<"Perform link through clang-sycl-linker via the target "
+ Visibility<[ClangOption, CLOption]>,
+ Group<sycl_Group>, HelpText<"Perform link through clang-sycl-linker via the target "
"offloading toolchain.">;
-} // let Group = sycl_Group
-
// OS-specific options
let Flags = [TargetSpecific] in {
defm android_pad_segment : BooleanFFlag<"android-pad-segment">, Group<f_Group>;
diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h
index 4efef49346fa4d..5347e29be91439 100644
--- a/clang/include/clang/Driver/ToolChain.h
+++ b/clang/include/clang/Driver/ToolChain.h
@@ -762,10 +762,6 @@ class ToolChain {
virtual void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const;
- /// Add arguments to use system-specific SYCL includes.
- virtual void AddSYCLIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const;
-
/// Add arguments to use MCU GCC toolchain includes.
virtual void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const;
diff --git a/clang/lib/Driver/Action.cpp b/clang/lib/Driver/Action.cpp
index 23dbcebc9a1ca1..849bf6035ebd2e 100644
--- a/clang/lib/Driver/Action.cpp
+++ b/clang/lib/Driver/Action.cpp
@@ -111,8 +111,6 @@ std::string Action::getOffloadingKindPrefix() const {
return "device-openmp";
case OFK_HIP:
return "device-hip";
- case OFK_SYCL:
- return "device-sycl";
// TODO: Add other programming models here.
}
@@ -130,8 +128,6 @@ std::string Action::getOffloadingKindPrefix() const {
Res += "-hip";
if (ActiveOffloadKindMask & OFK_OpenMP)
Res += "-openmp";
- if (ActiveOffloadKindMask & OFK_SYCL)
- Res += "-sycl";
// TODO: Add other programming models here.
@@ -168,8 +164,6 @@ StringRef Action::GetOffloadKindName(OffloadKind Kind) {
return "openmp";
case OFK_HIP:
return "hip";
- case OFK_SYCL:
- return "sycl";
// TODO: Add other programming models here.
}
@@ -326,7 +320,7 @@ void OffloadAction::DeviceDependences::add(Action &A, const ToolChain &TC,
DeviceBoundArchs.push_back(BoundArch);
// Add each active offloading kind from a mask.
- for (OffloadKind OKind : {OFK_OpenMP, OFK_Cuda, OFK_HIP, OFK_SYCL})
+ for (OffloadKind OKind : {OFK_OpenMP, OFK_Cuda, OFK_HIP})
if (OKind & OffloadKindMask)
DeviceOffloadKinds.push_back(OKind);
}
diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt
index ea2fc967cad476..4fd10bf671512f 100644
--- a/clang/lib/Driver/CMakeLists.txt
+++ b/clang/lib/Driver/CMakeLists.txt
@@ -77,7 +77,6 @@ add_clang_library(clangDriver
ToolChains/RISCVToolchain.cpp
ToolChains/Solaris.cpp
ToolChains/SPIRV.cpp
- ToolChains/SYCL.cpp
ToolChains/TCE.cpp
ToolChains/UEFI.cpp
ToolChains/VEToolchain.cpp
diff --git a/clang/lib/Driver/Compilation.cpp b/clang/lib/Driver/Compilation.cpp
index 57315493f16e13..ad077d5bbfa69a 100644
--- a/clang/lib/Driver/Compilation.cpp
+++ b/clang/lib/Driver/Compilation.cpp
@@ -217,11 +217,10 @@ static bool ActionFailed(const Action *A,
if (FailingCommands.empty())
return false;
- // CUDA/HIP/SYCL can have the same input source code compiled multiple times
- // so do not compile again if there are already failures. It is OK to abort
- // the CUDA/HIP/SYCL pipeline on errors.
- if (A->isOffloading(Action::OFK_Cuda) || A->isOffloading(Action::OFK_HIP) ||
- A->isOffloading(Action::OFK_SYCL))
+ // CUDA/HIP can have the same input source code compiled multiple times so do
+ // not compiled again if there are already failures. It is OK to abort the
+ // CUDA pipeline on errors.
+ if (A->isOffloading(Action::OFK_Cuda) || A->isOffloading(Action::OFK_HIP))
return true;
for (const auto &CI : FailingCommands)
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index accbb8635331ca..93e85f7dffe35a 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -43,7 +43,6 @@
#include "ToolChains/PS4CPU.h"
#include "ToolChains/RISCVToolchain.h"
#include "ToolChains/SPIRV.h"
-#include "ToolChains/SYCL.h"
#include "ToolChains/Solaris.h"
#include "ToolChains/TCE.h"
#include "ToolChains/UEFI.h"
@@ -782,27 +781,6 @@ Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const {
return RT;
}
-static const char *getDefaultSYCLArch(Compilation &C) {
- // If -fsycl is supplied we will assume SPIR-V
- if (C.getDefaultToolChain().getTriple().isArch32Bit())
- return "spirv32";
- return "spirv64";
-}
-
-static bool addSYCLDefaultTriple(Compilation &C,
- SmallVectorImpl<llvm::Triple> &SYCLTriples) {
- for (const auto &SYCLTriple : SYCLTriples) {
- if (SYCLTriple.getSubArch() == llvm::Triple::NoSubArch &&
- SYCLTriple.isSPIROrSPIRV())
- return false;
- }
- // Add the default triple as it was not found.
- llvm::Triple DefaultTriple =
- C.getDriver().getSYCLDeviceTriple(getDefaultSYCLArch(C));
- SYCLTriples.insert(SYCLTriples.begin(), DefaultTriple);
- return true;
-}
-
void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
InputList &Inputs) {
@@ -1016,41 +994,6 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
return;
}
- //
- // SYCL
- //
- // We need to generate a SYCL toolchain if the user specified -fsycl.
- bool IsSYCL = C.getInputArgs().hasFlag(options::OPT_fsycl,
- options::OPT_fno_sycl, false);
-
- auto argSYCLIncompatible = [&](OptSpecifier OptId) {
- if (!IsSYCL)
- return;
- if (Arg *IncompatArg = C.getInputArgs().getLastArg(OptId))
- Diag(clang::diag::err_drv_argument_not_allowed_with)
- << IncompatArg->getSpelling() << "-fsycl";
- };
- // -static-libstdc++ is not compatible with -fsycl.
- argSYCLIncompatible(options::OPT_static_libstdcxx);
- // -ffreestanding cannot be used with -fsycl
- argSYCLIncompatible(options::OPT_ffreestanding);
-
- llvm::SmallVector<llvm::Triple, 4> UniqueSYCLTriplesVec;
-
- if (IsSYCL) {
- addSYCLDefaultTriple(C, UniqueSYCLTriplesVec);
-
- // We'll need to use the SYCL and host triples as the key into
- // getOffloadingDeviceToolChain, because the device toolchains we're
- // going to create will depend on both.
- const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
- for (const auto &TT : UniqueSYCLTriplesVec) {
- auto SYCLTC = &getOffloadingDeviceToolChain(C.getInputArgs(), TT, *HostTC,
- Action::OFK_SYCL);
- C.addOffloadDeviceToolChain(SYCLTC, Action::OFK_SYCL);
- }
- }
-
//
// TODO: Add support for other offloading programming models here.
//
@@ -2084,20 +2027,6 @@ void Driver::PrintHelp(bool ShowHidden) const {
VisibilityMask);
}
-llvm::Triple Driver::getSYCLDeviceTriple(StringRef TargetArch) const {
- SmallVector<StringRef, 5> SYCLAlias = {"spir", "spir64", "spirv32",
- "spirv64"};
- if (std::find(SYCLAlias.begin(), SYCLAlias.end(), TargetArch) !=
- SYCLAlias.end()) {
- llvm::Triple TT;
- TT.setArchName(TargetArch);
- TT.setVendor(llvm::Triple::UnknownVendor);
- TT.setOS(llvm::Triple::UnknownOS);
- return TT;
- }
- return llvm::Triple(TargetArch);
-}
-
void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
if (IsFlangMode()) {
OS << getClangToolFullVersion("flang") << '\n';
@@ -4255,7 +4184,6 @@ void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
bool UseNewOffloadingDriver =
C.isOffloadingHostKind(Action::OFK_OpenMP) ||
- C.isOffloadingHostKind(Action::OFK_SYCL) ||
Args.hasFlag(options::OPT_foffload_via_llvm,
options::OPT_fno_offload_via_llvm, false) ||
Args.hasFlag(options::OPT_offload_new_driver,
@@ -4666,8 +4594,6 @@ Driver::getOffloadArchs(Compilation &C, const llvm::opt::DerivedArgList &Args,
Archs.insert(OffloadArchToString(OffloadArch::HIPDefault));
else if (Kind == Action::OFK_OpenMP)
Archs.insert(StringRef());
- else if (Kind == Action::OFK_SYCL)
- Archs.insert(StringRef());
} else {
Args.ClaimAllArgs(options::OPT_offload_arch_EQ);
Args.ClaimAllArgs(options::OPT_no_offload_arch_EQ);
@@ -4692,7 +4618,7 @@ Action *Driver::BuildOffloadingActions(Compilation &C,
OffloadAction::DeviceDependences DDeps;
const Action::OffloadKind OffloadKinds[] = {
- Action::OFK_OpenMP, Action::OFK_Cuda, Action::OFK_HIP, Action::OFK_SYCL};
+ Action::OFK_OpenMP, Action::OFK_Cuda, Action::OFK_HIP};
for (Action::OffloadKind Kind : OffloadKinds) {
SmallVector<const ToolChain *, 2> ToolChains;
@@ -4737,11 +4663,6 @@ Action *Driver::BuildOffloadingActions(Compilation &C,
break;
}
- // Assemble actions are not used for the SYCL device side. Both compile
- // and backend actions are used to generate IR and textual IR if needed.
- if (Kind == Action::OFK_SYCL && Phase == phases::Assemble)
- continue;
-
auto TCAndArch = TCAndArchs.begin();
for (Action *&A : DeviceActions) {
if (A->getType() == types::TY_Nothing)
@@ -4980,7 +4901,6 @@ Action *Driver::ConstructPhaseAction(
return C.MakeAction<BackendJobAction>(Input, Output);
}
if (Args.hasArg(options::OPT_emit_llvm) ||
- TargetDeviceOffloadKind == Action::OFK_SYCL ||
(((Input->getOffloadingToolChain() &&
Input->getOffloadingToolChain()->getTriple().isAMDGPU()) ||
TargetDeviceOffloadKind == Action::OFK_HIP) &&
@@ -6672,19 +6592,6 @@ const ToolChain &Driver::getOffloadingDeviceToolChain(
HostTC, Args);
break;
}
- case Action::OFK_SYCL:
- switch (Target.getArch()) {
- case llvm::Triple::spir:
- case llvm::Triple::spir64:
- case llvm::Triple::spirv32:
- case llvm::Triple::spirv64:
- TC = std::make_unique<toolchains::SYCLToolChain>(*this, Target, HostTC,
- Args);
- break;
- default:
- break;
- }
- break;
default:
break;
}
diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp
index 69ca739e03996d..646dbc0faf5a9f 100644
--- a/clang/lib/Driver/ToolChain.cpp
+++ b/clang/lib/Driver/ToolChain.cpp
@@ -1487,9 +1487,6 @@ void ToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
void ToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {}
-void ToolChain::AddSYCLIncludeArgs(const ArgList &DriverArgs,
- ArgStringList &CC1Args) const {}
-
llvm::SmallVector<ToolChain::BitCodeLibraryInfo, 12>
ToolChain::getDeviceLibs(const ArgList &DriverArgs) const {
return {};
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index adcdf8552c62eb..3133b8f5762389 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -24,7 +24,6 @@
#include "Hexagon.h"
#include "MSP430.h"
#include "PS4CPU.h"
-#include "SYCL.h"
#include "clang/Basic/CLWarnings.h"
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/CodeGenOptions.h"
@@ -1071,16 +1070,14 @@ void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
Args.AddLastArg(CmdArgs, options::OPT_MP);
Args.AddLastArg(CmdArgs, options::OPT_MV);
- // Add offload include arguments specific for CUDA/HIP/SYCL. This must happen
+ // Add offload include arguments specific for CUDA/HIP. This must happen
// before we -I or -include anything else, because we must pick up the
- // CUDA/HIP/SYCL headers from the particular CUDA/ROCm/SYCL installation,
- // rather than from e.g. /usr/local/include.
+ // CUDA/HIP headers from the particular CUDA/ROCm installation, rather than
+ // from e.g. /usr/local/include.
if (JA.isOffloading(Action::OFK_Cuda))
getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
if (JA.isOffloading(Action::OFK_HIP))
getToolChain().AddHIPIncludeArgs(Args, CmdArgs);
- if (JA.isOffloading(Action::OFK_SYCL))
- getToolChain().AddSYCLIncludeArgs(Args, CmdArgs);
// If we are offloading to a target via OpenMP we need to include the
// openmp_wrappers folder which contains alternative system headers.
@@ -5035,21 +5032,17 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
// second input. Module precompilation accepts a list of header files to
// include as part of the module. API extraction accepts a list of header
// files whose API information is emitted in the output. All other jobs are
- // expected to have exactly one input. SYCL compilation only expects a
- // single input.
+ // expected to have exactly one input.
bool IsCuda = JA.isOffloading(Action::OFK_Cuda);
bool IsCudaDevice = JA.isDeviceOffloading(Action::OFK_Cuda);
bool IsHIP = JA.isOffloading(Action::OFK_HIP);
bool IsHIPDevice = JA.isDeviceOffloading(Action::OFK_HIP);
- bool IsSYCL = JA.isOffloading(Action::OFK_SYCL);
- bool IsSYCLDevice = JA.isDeviceOffloading(Action::OFK_SYCL);
bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP);
bool IsExtractAPI = isa<ExtractAPIJobAction>(JA);
bool IsDeviceOffloadAction = !(JA.isDeviceOffloading(Action::OFK_None) ||
JA.isDeviceOffloading(Action::OFK_Host));
bool IsHostOffloadingAction =
JA.isHostOffloading(Action::OFK_OpenMP) ||
- JA.isHostOffloading(Action::OFK_SYCL) ||
(JA.isHostOffloading(C.getActiveOffloadKinds()) &&
Args.hasFlag(options::OPT_offload_new_driver,
options::OPT_no_offload_new_driver, false));
@@ -5099,10 +5092,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
bool IsIAMCU = RawTriple.isOSIAMCU();
- // Adjust IsWindowsXYZ for CUDA/HIP/SYCL compilations. Even when compiling in
+ // Adjust IsWindowsXYZ for CUDA/HIP compilations. Even when compiling in
// device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not
// Windows), we need to pass Windows-specific flags to cc1.
- if (IsCuda || IsHIP || IsSYCL)
+ if (IsCuda || IsHIP)
IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
// C++ is not supported for IAMCU.
@@ -5186,34 +5179,11 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
if (const Arg *PF = Args.getLastArg(options::OPT_mprintf_kind_EQ))
PF->claim();
- Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
+ if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl, false)) {
+ CmdArgs.push_back("-fsycl-is-device");
- if (IsSYCL) {
- if (IsSYCLDevice) {
- // Host triple is needed when doing SYCL device compilations.
- llvm::Triple AuxT = C.getDefaultToolChain().getTriple();
- std::string NormalizedTriple = AuxT.normalize();
- CmdArgs.push_back("-aux-triple");
- CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
-
- // We want to compile sycl kernels.
- CmdArgs.push_back("-fsycl-is-device");
-
- // Set O2 optimization level by default
- if (!Args.getLastArg(options::OPT_O_Group))
- CmdArgs.push_back("-O2");
- } else {
- // Add any options that are needed specific to SYCL offload while
- // performing the host side compilation.
-
- // Let the front-end host compilation flow know about SYCL offload
- // compilation.
- CmdArgs.push_back("-fsycl-is-host");
- }
-
- // Set options for both host and device.
- if (SYCLStdArg) {
- SYCLStdArg->render(Args, CmdArgs);
+ if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
+ A->render(Args, CmdArgs);
} else {
// Ensure the default version in SYCL mode is 2020.
CmdArgs.push_back("-sycl-std=2020");
@@ -6159,7 +6129,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
// Prepare `-aux-target-cpu` and `-aux-target-feature` unless
// `--gpu-use-aux-triple-only` is specified.
if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) &&
- (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) {
+ (IsCudaDevice || IsHIPDevice)) {
const ArgList &HostArgs =
C.getArgsForToolChain(nullptr, StringRef(), Action::OFK_None);
std::string HostCPU =
diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp
index 35f69a3bc8d18f..8397f1121ec2ce 100644
--- a/clang/lib/Driver/ToolChains/Gnu.cpp
+++ b/clang/lib/Driver/ToolChains/Gnu.cpp
@@ -3058,8 +3058,7 @@ bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
const ArgList &Args)
: ToolChain(D, Triple, Args), GCCInstallation(D),
- CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args),
- SYCLInstallation(D) {
+ CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
getProgramPaths().push_back(getDriver().Dir);
}
diff --git a/clang/lib/Driver/ToolChains/Gnu.h b/clang/lib/Driver/ToolChains/Gnu.h
index 4c5ecf5401746a..0b664a182d75e1 100644
--- a/clang/lib/Driver/ToolChains/Gnu.h
+++ b/clang/lib/Driver/ToolChains/Gnu.h
@@ -12,7 +12,6 @@
#include "Cuda.h"
#include "LazyDetector.h"
#include "ROCm.h"
-#include "SYCL.h"
#include "clang/Driver/Tool.h"
#include "clang/Driver/ToolChain.h"
#include <set>
@@ -289,7 +288,6 @@ class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
GCCInstallationDetector GCCInstallation;
LazyDetector<CudaInstallationDetector> CudaInstallation;
LazyDetector<RocmInstallationDetector> RocmInstallation;
- SYCLInstallationDetector SYCLInstallation;
public:
Generic_GCC(const Driver &D, const llvm::Triple &Triple,
diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp
index 731159ee2d78ef..d1cb625613415b 100644
--- a/clang/lib/Driver/ToolChains/Linux.cpp
+++ b/clang/lib/Driver/ToolChains/Linux.cpp
@@ -759,11 +759,6 @@ void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
}
}
-void Linux::AddSYCLIncludeArgs(const ArgList &DriverArgs,
- ArgStringList &CC1Args) const {
- SYCLInstallation.AddSYCLIncludeArgs(DriverArgs, CC1Args);
-}
-
bool Linux::isPIEDefault(const llvm::opt::ArgList &Args) const {
return CLANG_DEFAULT_PIE_ON_LINUX || getTriple().isAndroid() ||
getTriple().isMusl() || getSanitizerArgs(Args).requiresPIE();
diff --git a/clang/lib/Driver/ToolChains/Linux.h b/clang/lib/Driver/ToolChains/Linux.h
index cdec2fd39bbfa0..2d9e674e50a630 100644
--- a/clang/lib/Driver/ToolChains/Linux.h
+++ b/clang/lib/Driver/ToolChains/Linux.h
@@ -41,8 +41,6 @@ class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
llvm::opt::ArgStringList &CmdArgs) const override;
void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override;
- void AddSYCLIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const override;
RuntimeLibType GetDefaultRuntimeLibType() const override;
unsigned GetDefaultDwarfVersion() const override;
CXXStdlibType GetDefaultCXXStdlibType() const override;
diff --git a/clang/lib/Driver/ToolChains/MSVC.cpp b/clang/lib/Driver/ToolChains/MSVC.cpp
index 513b4ccc1ad48f..80799d1e715f07 100644
--- a/clang/lib/Driver/ToolChains/MSVC.cpp
+++ b/clang/lib/Driver/ToolChains/MSVC.cpp
@@ -424,7 +424,7 @@ void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
const ArgList &Args)
: ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
- RocmInstallation(D, Triple, Args), SYCLInstallation(D) {
+ RocmInstallation(D, Triple, Args) {
getProgramPaths().push_back(getDriver().Dir);
std::optional<llvm::StringRef> VCToolsDir, VCToolsVersion;
@@ -503,11 +503,6 @@ void MSVCToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,
RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
}
-void MSVCToolChain::AddSYCLIncludeArgs(const ArgList &DriverArgs,
- ArgStringList &CC1Args) const {
- SYCLInstallation.AddSYCLIncludeArgs(DriverArgs, CC1Args);
-}
-
void MSVCToolChain::AddHIPRuntimeLibArgs(const ArgList &Args,
ArgStringList &CmdArgs) const {
CmdArgs.append({Args.MakeArgString(StringRef("-libpath:") +
diff --git a/clang/lib/Driver/ToolChains/MSVC.h b/clang/lib/Driver/ToolChains/MSVC.h
index 6485fe6ba63a1e..3950a8ed38e8b4 100644
--- a/clang/lib/Driver/ToolChains/MSVC.h
+++ b/clang/lib/Driver/ToolChains/MSVC.h
@@ -12,7 +12,6 @@
#include "AMDGPU.h"
#include "Cuda.h"
#include "LazyDetector.h"
-#include "SYCL.h"
#include "clang/Driver/Compilation.h"
#include "clang/Driver/Tool.h"
#include "clang/Driver/ToolChain.h"
@@ -101,9 +100,6 @@ class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
void AddHIPRuntimeLibArgs(const llvm::opt::ArgList &Args,
llvm::opt::ArgStringList &CmdArgs) const override;
- void AddSYCLIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const override;
-
bool getWindowsSDKLibraryPath(
const llvm::opt::ArgList &Args, std::string &path) const;
bool getUniversalCRTLibraryPath(const llvm::opt::ArgList &Args,
@@ -142,7 +138,6 @@ class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
llvm::ToolsetLayout VSLayout = llvm::ToolsetLayout::OlderVS;
LazyDetector<CudaInstallationDetector> CudaInstallation;
LazyDetector<RocmInstallationDetector> RocmInstallation;
- SYCLInstallationDetector SYCLInstallation;
};
} // end namespace toolchains
diff --git a/clang/lib/Driver/ToolChains/SYCL.cpp b/clang/lib/Driver/ToolChains/SYCL.cpp
deleted file mode 100644
index 241444b71384b5..00000000000000
--- a/clang/lib/Driver/ToolChains/SYCL.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-//===--- SYCL.cpp - SYCL Tool and ToolChain Implementations -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-#include "SYCL.h"
-#include "CommonArgs.h"
-#include "llvm/Support/Path.h"
-
-using namespace clang::driver;
-using namespace clang::driver::toolchains;
-using namespace clang::driver::tools;
-using namespace clang;
-using namespace llvm::opt;
-
-SYCLInstallationDetector::SYCLInstallationDetector(const Driver &D) : D(D) {
- InstallationCandidates.emplace_back(D.Dir + "/..");
-}
-
-void SYCLInstallationDetector::AddSYCLIncludeArgs(
- const ArgList &DriverArgs, ArgStringList &CC1Args) const {
- // Add the SYCL header search locations in the specified order.
- // ../include/sycl/stl_wrappers
- // ../include
- SmallString<128> IncludePath(D.Dir);
- llvm::sys::path::append(IncludePath, "..");
- llvm::sys::path::append(IncludePath, "include");
- // This is used to provide our wrappers around STL headers that provide
- // additional functions/template specializations when the user includes those
- // STL headers in their programs (e.g., <complex>).
- SmallString<128> STLWrappersPath(IncludePath);
- llvm::sys::path::append(STLWrappersPath, "sycl");
- llvm::sys::path::append(STLWrappersPath, "stl_wrappers");
- CC1Args.push_back("-internal-isystem");
- CC1Args.push_back(DriverArgs.MakeArgString(STLWrappersPath));
- CC1Args.push_back("-internal-isystem");
- CC1Args.push_back(DriverArgs.MakeArgString(IncludePath));
-}
-
-void SYCLInstallationDetector::print(llvm::raw_ostream &OS) const {
- if (!InstallationCandidates.size())
- return;
- OS << "SYCL Installation Candidates: \n";
- for (const auto &IC : InstallationCandidates) {
- OS << IC << "\n";
- }
-}
-
-// Unsupported options for SYCL device compilation.
-static std::vector<OptSpecifier> getUnsupportedOpts() {
- std::vector<OptSpecifier> UnsupportedOpts = {
- options::OPT_fsanitize_EQ, // -fsanitize
- options::OPT_fcf_protection_EQ, // -fcf-protection
- options::OPT_fprofile_generate,
- options::OPT_fprofile_generate_EQ,
- options::OPT_fno_profile_generate, // -f[no-]profile-generate
- options::OPT_ftest_coverage,
- options::OPT_fno_test_coverage, // -f[no-]test-coverage
- options::OPT_fcoverage_mapping,
- options::OPT_fno_coverage_mapping, // -f[no-]coverage-mapping
- options::OPT_coverage, // --coverage
- options::OPT_fprofile_instr_generate,
- options::OPT_fprofile_instr_generate_EQ,
- options::OPT_fno_profile_instr_generate, // -f[no-]profile-instr-generate
- options::OPT_fprofile_arcs,
- options::OPT_fno_profile_arcs, // -f[no-]profile-arcs
- options::OPT_fcreate_profile, // -fcreate-profile
- options::OPT_fprofile_instr_use,
- options::OPT_fprofile_instr_use_EQ, // -fprofile-instr-use
- options::OPT_forder_file_instrumentation, // -forder-file-instrumentation
- options::OPT_fcs_profile_generate, // -fcs-profile-generate
- options::OPT_fcs_profile_generate_EQ};
- return UnsupportedOpts;
-}
-
-SYCLToolChain::SYCLToolChain(const Driver &D, const llvm::Triple &Triple,
- const ToolChain &HostTC, const ArgList &Args)
- : ToolChain(D, Triple, Args), HostTC(HostTC), SYCLInstallation(D) {
- // Lookup binaries into the driver directory, this is used to discover any
- // dependent SYCL offload compilation tools.
- getProgramPaths().push_back(getDriver().Dir);
-
- // Diagnose unsupported options only once.
- for (OptSpecifier Opt : getUnsupportedOpts()) {
- if (const Arg *A = Args.getLastArg(Opt)) {
- // All sanitizer options are not currently supported, except
- // AddressSanitizer.
- if (A->getOption().getID() == options::OPT_fsanitize_EQ &&
- A->getValues().size() == 1) {
- std::string SanitizeVal = A->getValue();
- if (SanitizeVal == "address")
- continue;
- }
- D.Diag(clang::diag::warn_drv_unsupported_option_for_target)
- << A->getAsString(Args) << getTriple().str();
- }
- }
-}
-
-void SYCLToolChain::addClangTargetOptions(
- const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
- Action::OffloadKind DeviceOffloadingKind) const {
- HostTC.addClangTargetOptions(DriverArgs, CC1Args, DeviceOffloadingKind);
-}
-
-llvm::opt::DerivedArgList *
-SYCLToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
- StringRef BoundArch,
- Action::OffloadKind DeviceOffloadKind) const {
- DerivedArgList *DAL =
- HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind);
-
- bool IsNewDAL = false;
- if (!DAL) {
- DAL = new DerivedArgList(Args.getBaseArgs());
- IsNewDAL = true;
- }
-
- for (Arg *A : Args) {
- // Filter out any options we do not want to pass along to the device
- // compilation.
- auto Opt(A->getOption());
- bool Unsupported = false;
- for (OptSpecifier UnsupportedOpt : getUnsupportedOpts()) {
- if (Opt.matches(UnsupportedOpt)) {
- if (Opt.getID() == options::OPT_fsanitize_EQ &&
- A->getValues().size() == 1) {
- std::string SanitizeVal = A->getValue();
- if (SanitizeVal == "address") {
- if (IsNewDAL)
- DAL->append(A);
- continue;
- }
- }
- if (!IsNewDAL)
- DAL->eraseArg(Opt.getID());
- Unsupported = true;
- }
- }
- if (Unsupported)
- continue;
- if (IsNewDAL)
- DAL->append(A);
- }
-
- const OptTable &Opts = getDriver().getOpts();
- if (!BoundArch.empty()) {
- DAL->eraseArg(options::OPT_march_EQ);
- DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ),
- BoundArch);
- }
- return DAL;
-}
-
-void SYCLToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {
- HostTC.addClangWarningOptions(CC1Args);
-}
-
-ToolChain::CXXStdlibType
-SYCLToolChain::GetCXXStdlibType(const ArgList &Args) const {
- return HostTC.GetCXXStdlibType(Args);
-}
-
-void SYCLToolChain::AddSYCLIncludeArgs(const ArgList &DriverArgs,
- ArgStringList &CC1Args) const {
- SYCLInstallation.AddSYCLIncludeArgs(DriverArgs, CC1Args);
-}
-
-void SYCLToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
- ArgStringList &CC1Args) const {
- HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args);
-}
-
-void SYCLToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args,
- ArgStringList &CC1Args) const {
- HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args);
-}
-
-SanitizerMask SYCLToolChain::getSupportedSanitizers() const {
- return SanitizerKind::Address;
-}
diff --git a/clang/lib/Driver/ToolChains/SYCL.h b/clang/lib/Driver/ToolChains/SYCL.h
deleted file mode 100644
index 9395478cb044d2..00000000000000
--- a/clang/lib/Driver/ToolChains/SYCL.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//===--- SYCL.h - SYCL ToolChain Implementations ----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SYCL_H
-#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SYCL_H
-
-#include "clang/Driver/Tool.h"
-#include "clang/Driver/ToolChain.h"
-
-namespace clang {
-namespace driver {
-
-class SYCLInstallationDetector {
-public:
- SYCLInstallationDetector(const Driver &D);
- void AddSYCLIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const;
- void print(llvm::raw_ostream &OS) const;
-
-private:
- const Driver &D;
- llvm::SmallVector<llvm::SmallString<128>, 4> InstallationCandidates;
-};
-
-namespace toolchains {
-
-class LLVM_LIBRARY_VISIBILITY SYCLToolChain : public ToolChain {
-public:
- SYCLToolChain(const Driver &D, const llvm::Triple &Triple,
- const ToolChain &HostTC, const llvm::opt::ArgList &Args);
-
- const llvm::Triple *getAuxTriple() const override {
- return &HostTC.getTriple();
- }
-
- llvm::opt::DerivedArgList *
- TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
- Action::OffloadKind DeviceOffloadKind) const override;
- void
- addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args,
- Action::OffloadKind DeviceOffloadKind) const override;
-
- bool useIntegratedAs() const override { return true; }
- bool isPICDefault() const override { return false; }
- llvm::codegenoptions::DebugInfoFormat getDefaultDebugFormat() const override {
- return this->HostTC.getDefaultDebugFormat();
- }
- bool isPIEDefault(const llvm::opt::ArgList &Args) const override {
- return false;
- }
- bool isPICDefaultForced() const override { return false; }
-
- void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
- CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
- void AddSYCLIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const override;
- void
- AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
- llvm::opt::ArgStringList &CC1Args) const override;
- void AddClangCXXStdlibIncludeArgs(
- const llvm::opt::ArgList &Args,
- llvm::opt::ArgStringList &CC1Args) const override;
-
- SanitizerMask getSupportedSanitizers() const override;
-
-private:
- const ToolChain &HostTC;
- SYCLInstallationDetector SYCLInstallation;
-};
-
-} // end namespace toolchains
-
-} // end namespace driver
-} // end namespace clang
-
-#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SYCL_H
diff --git a/clang/test/Driver/sycl-offload-jit.cpp b/clang/test/Driver/sycl-offload-jit.cpp
deleted file mode 100644
index 08cac727d8a197..00000000000000
--- a/clang/test/Driver/sycl-offload-jit.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-///
-/// Perform several driver tests for SYCL offloading for JIT
-///
-
-/// Check the phases graph with -fsycl. Use of -fsycl enables offload
-// RUN: %clang -ccc-print-phases --target=x86_64-unknown-linux-gnu \
-// RUN: -fsycl %s 2>&1 \
-// RUN: | FileCheck -check-prefixes=CHK-PHASES %s
-// RUN: %clang_cl -ccc-print-phases --target=x86_64-pc-windows-msvc -fsycl \
-// RUN: %s 2>&1 \
-// RUN: | FileCheck -check-prefixes=CHK-PHASES %s
-// CHK-PHASES: 0: input, "[[INPUT:.+\.cpp]]", c++, (host-sycl)
-// CHK-PHASES: 1: preprocessor, {0}, c++-cpp-output, (host-sycl)
-// CHK-PHASES: 2: compiler, {1}, ir, (host-sycl)
-// CHK-PHASES: 3: input, "[[INPUT]]", c++, (device-sycl)
-// CHK-PHASES: 4: preprocessor, {3}, c++-cpp-output, (device-sycl)
-// CHK-PHASES: 5: compiler, {4}, ir, (device-sycl)
-// CHK-PHASES: 6: backend, {5}, ir, (device-sycl)
-// CHK-PHASES: 7: offload, "device-sycl (spirv64-unknown-unknown)" {6}, ir
-// CHK-PHASES: 8: clang-offload-packager, {7}, image, (device-sycl)
-// CHK-PHASES: 9: offload, "host-sycl (x86_64{{.*}})" {2}, "device-sycl (x86_64{{.*}})" {8}, ir
-// CHK-PHASES: 10: backend, {9}, assembler, (host-sycl)
-// CHK-PHASES: 11: assembler, {10}, object, (host-sycl)
-// CHK-PHASES: 12: clang-linker-wrapper, {11}, image, (host-sycl)
-
-/// Check expected default values for device compilation when using -fsycl as
-/// well as clang-offload-packager inputs.
-// RUN: %clang -### -fsycl -c --target=x86_64-unknown-linux-gnu %s 2>&1 \
-// RUN: | FileCheck -check-prefix=CHK-DEVICE-TRIPLE %s
-// CHK-DEVICE-TRIPLE: clang{{.*}} "-triple" "spirv64-unknown-unknown"
-// CHK-DEVICE-TRIPLE-SAME: "-aux-triple" "x86_64-unknown-linux-gnu"
-// CHK-DEVICE-TRIPLE-SAME: "-fsycl-is-device"
-// CHK-DEVICE-TRIPLE-SAME: "-O2"
-// CHK-DEVICE-TRIPLE: clang-offload-packager{{.*}} "--image=file={{.*}}.bc,triple=spirv64-unknown-unknown,arch=,kind=sycl"
-
-/// Check -fsycl-is-device is passed when compiling for the device.
-/// Check -fsycl-is-host is passed when compiling for host.
-// RUN: %clang -### -fsycl -c %s 2>&1 \
-// RUN: | FileCheck -check-prefixes=CHK-FSYCL-IS-DEVICE,CHK-FSYCL-IS-HOST %s
-// RUN: %clang -### -fsycl -fsycl-device-only %s 2>&1 \
-// RUN: | FileCheck -check-prefix=CHK-FSYCL-IS-DEVICE %s
-// RUN: %clang_cl -### -fsycl -c %s 2>&1 \
-// RUN: | FileCheck -check-prefixes=CHK-FSYCL-IS-DEVICE,CHK-FSYCL-IS-HOST %s
-// RUN: %clang -### -fsycl -fsycl-host-only %s 2>&1 \
-// RUN: | FileCheck -check-prefix=CHK-FSYCL-IS-HOST %s
-// CHK-FSYCL-IS-DEVICE: clang{{.*}} "-fsycl-is-device" {{.*}} "-emit-llvm-bc"
-// CHK-FSYCL-IS-HOST: clang{{.*}} "-fsycl-is-host"
-
-// Verify header search dirs are added with -fsycl
-// RUN: %clang -### -fsycl %s 2>&1 \
-// RUN: | FileCheck %s -check-prefixes=CHECK-HEADER-DIR
-// RUN: %clang_cl -### -fsycl %s 2>&1 \
-// RUN: | FileCheck %s -check-prefixes=CHECK-HEADER-DIR
-// CHECK-HEADER-DIR: clang{{.*}} "-fsycl-is-device"
-// CHECK-HEADER-DIR-SAME: "-internal-isystem" "[[ROOT:[^"]*]]bin{{[/\\]+}}..{{[/\\]+}}include{{[/\\]+}}sycl{{[/\\]+}}stl_wrappers"
-// CHECK-HEADER-DIR-NOT: -internal-isystem
-// CHECK-HEADER-DIR-SAME: "-internal-isystem" "[[ROOT]]bin{{[/\\]+}}..{{[/\\]+}}include"
-// CHECK-HEADER-DIR: clang{{.*}} "-fsycl-is-host"
-// CHECK-HEADER-DIR-SAME: "-internal-isystem" "[[ROOT]]bin{{[/\\]+}}..{{[/\\]+}}include{{[/\\]+}}sycl{{[/\\]+}}stl_wrappers"
-// CHECK-HEADER-DIR-NOT: -internal-isystem
-// CHECK-HEADER-DIR-SAME: "-internal-isystem" "[[ROOT]]bin{{[/\\]+}}..{{[/\\]+}}include"
-
-/// Check for option incompatibility with -fsycl
-// RUN: not %clang -### -fsycl -ffreestanding %s 2>&1 \
-// RUN: | FileCheck -check-prefix=CHK-INCOMPATIBILITY %s \
-// RUN: -DINCOMPATOPT=-ffreestanding
-// RUN: not %clang -### -fsycl --offload-new-driver -static-libstdc++ %s 2>&1 \
-// RUN: | FileCheck -check-prefix=CHK-INCOMPATIBILITY %s \
-// RUN: -DINCOMPATOPT=-static-libstdc++
-// CHK-INCOMPATIBILITY: error: invalid argument '[[INCOMPATOPT]]' not allowed with '-fsycl'
diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h
index ecbf2914495085..779bd9017d7f12 100644
--- a/llvm/include/llvm/TargetParser/Triple.h
+++ b/llvm/include/llvm/TargetParser/Triple.h
@@ -844,9 +844,6 @@ class Triple {
getArch() == Triple::spirv;
}
- // Tests whether the target is SPIR-V or SPIR.
- bool isSPIROrSPIRV() const { return isSPIR() || isSPIRV(); }
-
/// Tests whether the target is SPIR-V Logical
bool isSPIRVLogical() const {
return getArch() == Triple::spirv;
More information about the cfe-commits
mailing list