llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang @llvm/pr-subscribers-clang-driver Author: Aaron Ballman (AaronBallman) <details> <summary>Changes</summary> 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 --- Patch is 39.30 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/116381.diff 20 Files Affected: - (modified) clang/include/clang/Driver/Action.h (-1) - (modified) clang/include/clang/Driver/Driver.h (-4) - (modified) clang/include/clang/Driver/Options.td (+7-12) - (modified) clang/include/clang/Driver/ToolChain.h (-4) - (modified) clang/lib/Driver/Action.cpp (+1-7) - (modified) clang/lib/Driver/CMakeLists.txt (-1) - (modified) clang/lib/Driver/Compilation.cpp (+4-5) - (modified) clang/lib/Driver/Driver.cpp (+1-94) - (modified) clang/lib/Driver/ToolChain.cpp (-3) - (modified) clang/lib/Driver/ToolChains/Clang.cpp (+11-41) - (modified) clang/lib/Driver/ToolChains/Gnu.cpp (+1-2) - (modified) clang/lib/Driver/ToolChains/Gnu.h (-2) - (modified) clang/lib/Driver/ToolChains/Linux.cpp (-5) - (modified) clang/lib/Driver/ToolChains/Linux.h (-2) - (modified) clang/lib/Driver/ToolChains/MSVC.cpp (+1-6) - (modified) clang/lib/Driver/ToolChains/MSVC.h (-5) - (removed) clang/lib/Driver/ToolChains/SYCL.cpp (-183) - (removed) clang/lib/Driver/ToolChains/SYCL.h (-82) - (removed) clang/test/Driver/sycl-offload-jit.cpp (-70) - (modified) llvm/include/llvm/TargetParser/Triple.h (-3) ``````````diff 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> @@ ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/116381 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
