[SYCL] Driver option to enable SYCL mode and select SYCL version

[bader]

Summary

User can select the version of SYCL the compiler will
use via the flag -sycl-std, similar to -cl-std.

The flag defines the LangOpts.SYCLVersion option to the
version of SYCL. The default value is undefined.
If driver is building SYCL code, flag is set to the default SYCL
version (1.2.1)

The preprocessor uses this variable to define CL_SYCL_LANGUAGE_VERSION macro,
which should be defined according to SYCL 1.2.1 standard.

Only valid value at this point for the flag is 1.2.1.

Co-Authored-By: David Wood <[e-mail]>
Signed-off-by: Ruyman Reyes <[e-mail]>
Signed-off-by: Alexey Bader <[e-mail]>

[Ruyk]

Maybe we should use the year of issue (2015 instead of 1.2.1) for the -sycl-std version? That would be more stable for the upcoming SYCL versions, and match somehow the C++ versioning.

[bader]

Maybe we should use the year of issue (2015 instead of 1.2.1) for the -sycl-std version? That would be more stable for the upcoming SYCL versions, and match somehow the C++ versioning.

Sounds good to me. I'll update the patch. I also have a couple of design related questions below.

clang/include/clang/Basic/LangOptions.def

207

All other language options controlling standard versions are added as "LANGOPT" i.e. int. Why SYCLVersion is different?
@Ruyk, do you think we should convert other options (e.g. OpenCL) to enums as well?

clang/include/clang/Driver/Options.td

3426

What do you think we integrate sycl versions to existing clang options controlling language version: -std.
As far as I can see it's used for all the C/C+ extensions like OpenMP/OpenCL/CUDA/HIP/ObjC.

If I understand correctly clang supports -cl-std only because it's required by OpenCL standard. Similar option (i.e. -sycl-std) is not required by the SYCL specification, so using -std is more aligned with existing clang design.

See clang/include/clang/Basic/LangStandard.h and clang/include/clang/Basic/LangStandards.def.

[bader]

Applied suggestion from Ruyman.

[merge_guards_bot]

Unit tests: pass. 62372 tests passed, 0 failed and 839 were skipped.

clang-tidy: fail. clang-tidy found 0 errors and 1 warnings. 0 of them are added as review comments below (why?).

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[bader]

Fix clang-format and clang-tidy issues reported by merge_guards_bot

[merge_guards_bot]

Unit tests: pass. 62372 tests passed, 0 failed and 839 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[ABataev]

clang/include/clang/Driver/Options.td

3423–3425

Better to split this into 2 parts: the first for -fsycl and the second for -sycl-std=.

[bader]

clang/include/clang/Driver/Options.td

3423–3425

Okay. Just one question:

Do you know if it's okay to have two commits per review request (like the first version of the "patch" in this review - it was split as you suggest)? Or I should create two separate review requests?

[ABataev]

clang/include/clang/Driver/Options.td

3423–3425

Separate patches must have separate review requests

[Ruyk]

clang/include/clang/Basic/LangOptions.def

207

Thats a good point. I don't see strong reasons for the enum, basically I read the comment in https://code.woboq.org/llvm/clang/include/clang/Basic/LangOptions.def.html#22

// ENUM_LANGOPT: for options that have enumeration, rather than unsigned, type.

And since there is a known set of SYCL specifications, made more sense to enumerate it.
It also simplifies writing variants to 1.2.1 (e.g. 1.2.1-oneapi) in the code since then you can add another entry to the enum.

But no strong feelings, so feel free to change it.

clang/include/clang/Driver/Options.td

3426

In the case of SYCL, you may want to compile your code with C++17 and SYCL 2015, in which case you need both -std=c++17 and -sycl=sycl-2015 .
SYCL specification mandates a minimum C++ version but users can write code on newer versions as long as the code in the kernel scope is still valid.

clang/lib/Driver/ToolChains/Clang.cpp

4052

This should probably change to 2015 if we are allowing that, just for consistency

[bader]

Applied suggestions from Alexey and Ruyman and rebased on ToT.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[ABataev]

clang/include/clang/Basic/LangOptions.h

122 ↗

(On Diff #242845)

s/undefined/Undefined/g

122 ↗

(On Diff #242845)

Do you use SYCL_1_2_1 anywhere in the code? I don't see it is used and you can drop this enum.

clang/lib/Frontend/CompilerInvocation.cpp

2543–2544

It does not match the list of values in Options.td file

2553

Can OPT_fsycl flag be ever passed to the frontend? Also, seems to me the driver has a special case already for device mode, so this code must be the dead code, actually.

[bader]

Applied Alexey's comments.

[ABataev]

clang/lib/Driver/ToolChains/Clang.cpp

4047–4048

Should this option also be controlled by -fsycl?

[bader]

clang/lib/Driver/ToolChains/Clang.cpp

4047–4048

Make sense to me.
@Ruyk, are you okay with that?

@ABataev, do you have any suggestion on what we should we do if -sycl-std option is used w/o -fsycl? Ignore or report warning/error?

[ABataev]

clang/lib/Driver/ToolChains/Clang.cpp

4047–4048

Mark this option as NoArgumentUnused (so the compiler does not report unused option) and ignore it.

[bader]

clang/lib/Driver/ToolChains/Clang.cpp

4047–4048

Ok. Is it okay if we add one more flag - CoreOption? We'd like enable these options fir clang-cl as well.

[ABataev]

clang/lib/Driver/ToolChains/Clang.cpp

4047–4048

Hard to say, need to look at the patch.

[bader]

Ignore -sycl-std if it used in non-SYCL mode.

[ABataev]

clang/include/clang/Driver/Options.td

3423–3425

These flags should not be ignored, NoArgumentUnused should be applied to this flags.

clang/lib/Driver/ToolChains/Clang.cpp

5347–5349

This code is not required, you already forwarded sycl-std to the frontend earlier

clang/lib/Frontend/CompilerInvocation.cpp

2540

I think processing of sycl-std in the frontend also must be controlled by some high-level option, like -fsycl or something like this. Without this -fsycl-like option this std option also must be ignored.

[bader]

Applied code review comments.

[bader]

clang/include/clang/Driver/Options.td

3423–3425

Do you mean "NoArgumentUnused should not be applied"?

[ABataev]

clang/include/clang/Driver/Options.td

3423–3425

Yes, missed not

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2538

-fno-sycl should not be passed to frontend. Just use hasFlag(OPT_fsycl).

2539

This option also must be controlled by -fsycl:

Opts.SYCLIsDevice =  Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device);

[bader]

clang/lib/Frontend/CompilerInvocation.cpp

2539

Does it really has to? This logic is already present in the driver and it makes front-end tests verbose %clang_cc1 -fsycl -fsycl-is-device.
Can -fsycl-is-device imply -fsycl?
Looking how CUDA/OpenMP options are handled, not all of them are processed using this pattern.

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2539

In general, this is how we handle it in OpenMP. Cuda works differently, because it has its own kind of files (.cu) and Cuda is triggered by the language switch (-x cu). Seems to me, you're using something close to OpenMP model, no? Or do you want to define your own language kind just like Cuda?

[bader]

Applied review commits from Alexey.

[bader]

clang/lib/Frontend/CompilerInvocation.cpp

2539

I applied you suggest, although I don't fully understand the need of using two options instead of two. I would prefer having following code:

Opts.SYCLIsDevice = Args.hasArg(options::OPT_fsycl_is_device);
Opts.SYCL = Args.hasArg(options::OPT_fsycl) || Opts.SYCLIsDevice; // -fsycl-is-device enable SYCL mode as well

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2539

I'm not quite familiar with SYCL model, maybe this the right approach. You'd better try to provide more details. Are there any differences between just SYCL and SYCL-device compilation modes? How do you see the compilation sequence in general? At first you're going to compile the host version of the code, then the device? OR something different?

[bader]

clang/lib/Frontend/CompilerInvocation.cpp

2539

I think SYCL model is quite similar to OpenMP model. One significant difference might be that to implement standard SYCL functionality we don't need any modifications for the host compiler. AFAIK, OpenMP compiler has to support OpenMP pragmas.
We have a few attributes for Intel FPGA devices, which we can't pre-process with __SYCL_DEVICE_ONLY__ macro and we have added "SYCL-host" mode to suppress compiler warnings about attributes ignored on the host. I think there might be other options how this can be achieved w/o adding new compilation mode and use regular C++ front-end as SYCL host compiler.
I think there is a difference between SYCL and SYCL-device modes, but it's mostly changes the compilation workflow in the driver, but not in the front-end. In SYCL-device mode, driver invokes only one front-end instance to generate offload code. In SYCL mode, driver invokes multiple front-end instances: one in SYCL-device mode and one in regular C++ mode (to be accurate we use SYCL-host mode, but as I mentioned above I don't think it really needed).
I hope it makes it clear now. Let me know if you have any other questions.

Do I understand it correctly that OpenMP option enables OpenMP mode, which is equivalent of "SYCL-host" mode and enabling both OpenMP and OpenMPIsDevice is required for enabling OpenMP mode, which is similar to SYCL-device mode?
If so, can we assume that OpenMPIsDevice implies that OpenMP option is also set (implicitly)?

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2539

Do I understand it correctly that OpenMP option enables OpenMP mode, which is equivalent of "SYCL-host" mode and enabling both OpenMP and OpenMPIsDevice is required for enabling OpenMP mode, which is similar to SYCL-device mode?

Well, for driver you need to pass -fopenmp -fopenmp-target=<list_of_targets> to enable the compilation with offloading support. In the frontend the host part is compiled with -fopenmp only (+ aux-triple, probably), for devices - -fopenmp -fopenmp-is-device. Without -fopenmp -fopenmp-is-device is just ignored.

[bader]

clang/lib/Frontend/CompilerInvocation.cpp

2539

What is the reason to require the driver to pass both options for the devices? It sounds like -fopenmp-is-device should be enough to differentiate from the host part (-fopenmp only). Right?

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2539

We treat a little bit differently. -fopenmp turns support for OpenMP, while -fopenmp-is-device turns processing for device compilation.

[bader]

clang/lib/Frontend/CompilerInvocation.cpp

2539

I'm okay to use OpenMP way to treat front-end options as they impact only clang developers (more verbose LIT test + a little bit more logic in the code), but I'd like to keep driver options handling simpler for clang users.
We can discuss this later, when -fsycl-device-only driver option is added.

Do you have any other comments to this change?

BTW, thanks a lot for take your time to review SYCL patches - it's highly appreciated!

[bader]

Ping.

[Ruyk]

@Naghasan please take a look

[Naghasan]

clang/include/clang/Basic/LangOptions.def

207

int allows the use of relational operators which should ease version managements.

As SYCLVersionList is a strongly typed enum so this may not be the best, and as the SYCL version are now meant to be a year int should do just fine.

clang/include/clang/Driver/Options.td

3426

+1 on this, ComputeCpp used to mix-up both and this proved to be complex to manage. It also integrates better with build systems.

clang/lib/Frontend/CompilerInvocation.cpp

2539

We treat a little bit differently. -fopenmp turns support for OpenMP, while -fopenmp-is-device turns processing for device compilation.

Seems to me that SYCL is kind of an hybrid here.

@bader do you plan on raising kernel specific diagnostics even on the host side ? In this case reusing this model will fully make sense.

[bader]

clang/include/clang/Basic/LangOptions.def

207

Okay. I'll change the type from enum to int.

clang/include/clang/Driver/Options.td

3426

Okay. I'll leave it as a separate option.

clang/lib/Frontend/CompilerInvocation.cpp

2539

do you plan on raising kernel specific diagnostics even on the host side ? In this case reusing this model will fully make sense.

Not sure I understand the question. Why would we need raising kernel specific diagnostics on the host side? Is it against the SYCL design principal?

[ABataev]

clang/lib/Frontend/CompilerInvocation.cpp

2540

Just Opt.SYCL should be enough

clang/lib/Frontend/InitPreprocessor.cpp

465

Must be guarded with LangOpts.SYCL:

if (LangOpts.SYCL) ...

[bader]

Address comments from Victor and Alexey.

[keryell]

clang/include/clang/Driver/Options.td

3428

I suggest replacing all the 2015 by 2017.
While this is true SYCL 1.2 was published in 2015, SYCL 1.2.1 was published in 2017. Only 1.2.1 matters here since 1.2 was never fully implemented by any conformant implementation. https://en.wikipedia.org/wiki/SYCL

clang/lib/Driver/ToolChains/Clang.cpp

4051

Replace 2015 by 2017 in both lines above.

clang/lib/Frontend/CompilerInvocation.cpp

2545

Replace 2015 by 2017.

clang/lib/Frontend/InitPreprocessor.cpp

466

Replace 2015 by 2017.

clang/test/Driver/sycl.c

5

Replace all the 2015 by 2017 here and below.

[bader]

Rebase to ToT and address comments from Ronan.

[bader]

clang/include/clang/Driver/Options.td

3428

Done.

[bader]

Rebase.

Any other comments?

[ABataev]

If no other comments, LGTM

[thakis]

This landed here: https://github.com/llvm/llvm-project/commit/bd97704eaaaab5a95ecb048ce343c1a4be5d94e5

It broke tests on mac: http://45.33.8.238/mac/9011/step_7.txt

Please take a look, and if it takes a while please revert while you investigate.

[bader]

In D72857#1895625, @thakis wrote:

This landed here: https://github.com/llvm/llvm-project/commit/bd97704eaaaab5a95ecb048ce343c1a4be5d94e5

It broke tests on mac: http://45.33.8.238/mac/9011/step_7.txt

Please take a look, and if it takes a while please revert while you investigate.

@thakis, thank for letting me know. I've reverted it at 740ed617f7d4d16e7883636c5eff994f8be7eba4. Sorry for inconvenience.

[bader]

In D72857#1895649, @bader wrote:

In D72857#1895625, @thakis wrote:

This landed here: https://github.com/llvm/llvm-project/commit/bd97704eaaaab5a95ecb048ce343c1a4be5d94e5

It broke tests on mac: http://45.33.8.238/mac/9011/step_7.txt

Please take a look, and if it takes a while please revert while you investigate.

@thakis, thank for letting me know. I've reverted it at 740ed617f7d4d16e7883636c5eff994f8be7eba4. Sorry for inconvenience.

@thakis, could you help to find the logs for the "build" step?
I don't have access to a Mac system and I can't reproduce the problem on my Linux system, but just looking at the log it looks like that changes to clang/include/clang/Driver/Options.td were not applied.

<stdin>:7:42: note: possible intended match here
clang: warning: argument unused during compilation: '-fsycl' [-Wunused-command-line-argument]

I'd like to make sure that clang is built with the patch applied.

I also noticed that on your system uses gn instead of cmake. Can it be that there is a missing dependency in GN files, which lead to skipping clang re-build?

clang/include/clang/Basic/LangOptions.def

 ENUM_LANGOPT(DefaultCallingConv, DefaultCallingConvention, 3, DCC_None, "default calling convention")
 
 LANGOPT(ShortEnums        , 1, 0, "short enum types")
 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL C version")
 LANGOPT(OpenCLCPlusPlus   , 1, 0, "C++ for OpenCL")
 LANGOPT(OpenCLCPlusPlusVersion     , 32, 0, "C++ for OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(HIP               , 1, 0, "HIP")
 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
 LANGOPT(OpenMPSimd        , 1, 0, "Use SIMD only OpenMP support.")
 LANGOPT(OpenMPUseTLS      , 1, 0, "Use TLS for threadprivates or runtime calls")
 LANGOPT(OpenMPIsDevice    , 1, 0, "Generate code only for OpenMP target device")

 LANGOPT(CUDAIsDevice      , 1, 0, "compiling for CUDA device")
 LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code")
 LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__")
 LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions")
 LANGOPT(GPURelocatableDeviceCode, 1, 0, "generate relocatable device code")
 LANGOPT(GPUAllowDeviceInit, 1, 0, "allowing device side global init functions for HIP")
 LANGOPT(GPUMaxThreadsPerBlock, 32, 256, "default max threads per block for kernel launch bounds for HIP")
 
+LANGOPT(SYCL              , 1, 0, "SYCL")
 LANGOPT(SYCLIsDevice      , 1, 0, "Generate code for SYCL device")
+LANGOPT(SYCLVersion       , 32, 0, "Version of the SYCL standard used")
 
 LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
 
 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
 LANGOPT(ConceptSatisfactionCaching , 1, 1, "enable satisfaction caching for C++2a Concepts")

clang/include/clang/Driver/Options.td

 defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>;
 defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>;
 defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>;
 defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>;
 defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>;
 defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>;
 
 // C++ SYCL options
-def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>,
+def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>, Flags<[CC1Option, CoreOption]>,
   HelpText<"Enable SYCL kernels compilation for device">;
-def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>,
+def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>, Flags<[CoreOption]>,
   HelpText<"Disable SYCL kernels compilation for device">;
+def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
+  HelpText<"SYCL language standard to compile for.">, Values<"2017, 121, 1.2.1, sycl-1.2.1">;
 
 include "CC1Options.td"
 
 include "CLCompatOptions.td"

clang/lib/Driver/ToolChains/Clang.cpp

else {
               Twine("-target-sdk-version=") +
               CudaVersionToString(CTC->CudaInstallation.version())));
       }
     }
     CmdArgs.push_back("-aux-triple");
     CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
   }
 
-  if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl, false))
+  if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl, false)) {
+    CmdArgs.push_back("-fsycl");
     CmdArgs.push_back("-fsycl-is-device");
 
+    if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
+      A->render(Args, CmdArgs);
+    } else {
+      // Ensure the default version in SYCL mode is 1.2.1 (aka 2017)
+      CmdArgs.push_back("-sycl-std=2017");
+    }
+  }
+
   if (IsOpenMPDevice) {
     // We have to pass the triple of the host if compiling for an OpenMP device.
     std::string NormalizedTriple =
         C.getSingleOffloadToolChain<Action::OFK_Host>()
             ->getTriple()
             .normalize();
     CmdArgs.push_back("-aux-triple");
     CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));

 
   // Forward -cl options to -cc1
   RenderOpenCLOptions(Args, CmdArgs);
 
   if (Args.hasFlag(options::OPT_fhip_new_launch_api,
                    options::OPT_fno_hip_new_launch_api, false))
     CmdArgs.push_back("-fhip-new-launch-api");
 
   if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
     CmdArgs.push_back(
         Args.MakeArgString(Twine("-fcf-protection=") + A->getValue()));
   }
 
   // Forward -f options with positive and negative forms; we translate
   // these by hand.
   if (Arg *A = getLastProfileSampleUseArg(Args)) {
     auto *PGOArg = Args.getLastArg(
         options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
         options::OPT_fcs_profile_generate, options::OPT_fcs_profile_generate_EQ,

clang/lib/Frontend/CompilerInvocation.cpp

if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
     if (OpenCLLangStd == LangStandard::lang_unspecified) {
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << A->getValue();
     }
     else
       LangStd = OpenCLLangStd;
   }
 
+  Opts.SYCL = Args.hasArg(options::OPT_fsycl);
+  Opts.SYCLIsDevice = Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device);
+  if (Opts.SYCL) {
+    // -sycl-std applies to any SYCL source, not only those containing kernels,
+    // but also those using the SYCL API
+    if (const Arg *A = Args.getLastArg(OPT_sycl_std_EQ)) {
+      Opts.SYCLVersion = llvm::StringSwitch<unsigned>(A->getValue())
+                             .Cases("2017", "1.2.1", "121", "sycl-1.2.1", 2017)
+                             .Default(0U);
+
+      if (Opts.SYCLVersion == 0U) {
+        // User has passed an invalid value to the flag, this is an error
+        Diags.Report(diag::err_drv_invalid_value)
+            << A->getAsString(Args) << A->getValue();
+      }
+    }
+  }
+
   Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
   Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
 
   llvm::Triple T(TargetOpts.Triple);
   CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
 
   // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
   // This option should be deprecated for CL > 1.0 because
#include "clang/Basic/LangStandards.def"
   // found
   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
     Opts.OMPHostIRFile = A->getValue();
     if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
       Diags.Report(diag::err_drv_omp_host_ir_file_not_found)
           << Opts.OMPHostIRFile;
   }
 
-  Opts.SYCLIsDevice = Args.hasArg(options::OPT_fsycl_is_device);
-
   // Set CUDA mode for OpenMP target NVPTX if specified in options
   Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && T.isNVPTX() &&
                         Args.hasArg(options::OPT_fopenmp_cuda_mode);
 
   // Set CUDA mode for OpenMP target NVPTX if specified in options
   Opts.OpenMPCUDAForceFullRuntime =
       Opts.OpenMPIsDevice && T.isNVPTX() &&
       Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime);

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.OpenCL) {
     Builder.defineMacro("CL_VERSION_2_0", "200");
 
     if (TI.isLittleEndian())
       Builder.defineMacro("__ENDIAN_LITTLE__");
 
     if (LangOpts.FastRelaxedMath)
       Builder.defineMacro("__FAST_RELAXED_MATH__");
   }
+
+  if (LangOpts.SYCL) {
+    // SYCL Version is set to a value when building SYCL applications
+    if (LangOpts.SYCLVersion == 2017)
+      Builder.defineMacro("CL_SYCL_LANGUAGE_VERSION", "121");
+  }
+
   // Not "standard" per se, but available even with the -undef flag.
   if (LangOpts.AsmPreprocessor)
     Builder.defineMacro("__ASSEMBLER__");
   if (LangOpts.CUDA && !LangOpts.HIP)
     Builder.defineMacro("__CUDA__");
   if (LangOpts.HIP) {
     Builder.defineMacro("__HIP__");
     Builder.defineMacro("__HIPCC__");

clang/test/Driver/sycl.c

 // RUN: %clang -### -fsycl -c %s 2>&1 | FileCheck %s --check-prefix=ENABLED
 // RUN: %clang -### -fsycl %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang -### -fsycl -sycl-std=1.2.1 %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang -### -fsycl -sycl-std=121 %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang -### -fsycl -sycl-std=2017 %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang -### -fsycl -sycl-std=sycl-1.2.1 %s 2>&1 | FileCheck %s --check-prefix=ENABLED
 // RUN: %clang -### -fno-sycl -fsycl %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang -### -sycl-std=2017 %s 2>&1 | FileCheck %s --check-prefix=DISABLED
 // RUN: %clangxx -### -fsycl %s 2>&1 | FileCheck %s --check-prefix=ENABLED
 // RUN: %clangxx -### -fno-sycl %s 2>&1 | FileCheck %s --check-prefix=DISABLED
 // RUN: %clangxx -### -fsycl -fno-sycl %s 2>&1 | FileCheck %s --check-prefix=DISABLED
 // RUN: %clangxx -### %s 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: %clang_cl -### -fsycl -sycl-std=2017 %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang_cl -### -fsycl %s 2>&1 | FileCheck %s --check-prefix=ENABLED
+// RUN: %clang_cl -### %s 2>&1 | FileCheck %s --check-prefix=DISABLED
 
 // ENABLED: "-cc1"{{.*}} "-fsycl-is-device"
+// ENABLED-SAME: "-sycl-std={{[-.sycl0-9]+}}"
 // DISABLED-NOT: "-fsycl-is-device"
+// DISABLED-NOT: "-sycl-std="

clang/test/Frontend/sycl-aux-triple.cpp

 // RUN: %clang_cc1 %s -triple spir -aux-triple x86_64-unknown-linux-gnu -E -dM | FileCheck %s
-// RUN: %clang_cc1 %s -fsycl-is-device -triple spir -aux-triple x86_64-unknown-linux-gnu -E -dM | FileCheck --check-prefix=CHECK-SYCL %s
+// RUN: %clang_cc1 %s -fsycl -fsycl-is-device -triple spir -aux-triple x86_64-unknown-linux-gnu -E -dM | FileCheck --check-prefix=CHECK-SYCL %s
 
 // CHECK-NOT:#define __x86_64__ 1
 // CHECK-SYCL:#define __x86_64__ 1

clang/test/Preprocessor/sycl-macro.cpp

 // RUN: %clang_cc1 %s -E -dM | FileCheck %s
-// RUN: %clang_cc1 %s -fsycl-is-device -E -dM | FileCheck --check-prefix=CHECK-SYCL %s
+// RUN: %clang_cc1 %s -fsycl -sycl-std=2017 -E -dM | FileCheck --check-prefix=CHECK-SYCL-STD %s
+// RUN: %clang_cc1 %s -fsycl -fsycl-is-device -sycl-std=1.2.1 -E -dM | FileCheck --check-prefix=CHECK-SYCL-STD %s
+// RUN: %clang_cc1 %s -fsycl -fsycl-is-device -E -dM | FileCheck --check-prefixes=CHECK-SYCL %s
 
 // CHECK-NOT:#define __SYCL_DEVICE_ONLY__ 1
+// CHECK-NOT:#define CL_SYCL_LANGUAGE_VERSION 121
+// CHECK-SYCL-STD:#define CL_SYCL_LANGUAGE_VERSION 121
 // CHECK-SYCL:#define __SYCL_DEVICE_ONLY__ 1

clang/test/SemaSYCL/kernel-attribute.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fsycl-is-device -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fsycl -fsycl-is-device -verify %s
 
 // Only function templates
 [[clang::sycl_kernel]] int gv2 = 0; // expected-warning {{'sycl_kernel' attribute only applies to function templates}}
 __attribute__((sycl_kernel)) int gv3 = 0; // expected-warning {{'sycl_kernel' attribute only applies to function templates}}
 
 __attribute__((sycl_kernel)) void foo(); // expected-warning {{'sycl_kernel' attribute only applies to function templates}}
 [[clang::sycl_kernel]] void foo1(); // expected-warning {{'sycl_kernel' attribute only applies to function templates}}