[C++4OpenCL] Enable -cl-std flag clc++21 as a shorthand for clc++2021

[Topotuna]

Summary

Allows clc++21 and CLC++21 to be used as possible options for
-cl-std in command line to represent C++ for OpenCL version 2021.

[Anastasia]

@svenvh I would like to discuss it further with Sven whether it is a good direction or not?

[svenvh]

In D108113#2949141, @Anastasia wrote:

@svenvh I would like to discuss it further with Sven whether it is a good direction or not?

The underlying motivation for adding those aliases seems to be missing from the description.

Personally, I do not see the point of adding aliases to save two characters (you only save the "20" part of "clc++2021"), while adding potential confusion ("is the language called C++ for OpenCL 2021 or C++ for OpenCL 21, or maybe it has something to do with OpenCL 2.1?"). Also they are being added as deprecated aliases, suggesting they might be removed at some point in the future again?

I'd much rather see one canonical way of specifying the language version, instead of adding multiple aliases to do the same thing. But perhaps there is a good reason that I am not aware of?

[Anastasia]

In D108113#2949173, @svenvh wrote:

In D108113#2949141, @Anastasia wrote:

@svenvh I would like to discuss it further with Sven whether it is a good direction or not?

The underlying motivation for adding those aliases seems to be missing from the description.

Personally, I do not see the point of adding aliases to save two characters (you only save the "20" part of "clc++2021"), while adding potential confusion ("is the language called C++ for OpenCL 2021 or C++ for OpenCL 21, or maybe it has something to do with OpenCL 2.1?"). Also they are being added as deprecated aliases, suggesting they might be removed at some point in the future again?

I'd much rather see one canonical way of specifying the language version, instead of adding multiple aliases to do the same thing. But perhaps there is a good reason that I am not aware of?

The main motivation for this was just a shorter spelling. Ok, it seems like there is some trade off... so let's hold off this change for now until we either get more input that shows some clear benefit or shows that there is none and then we can abandon the change.

clang/include/clang/Basic/LangStandards.def

 LANGSTANDARD_ALIAS_DEPR(opencl10, "CL")
 LANGSTANDARD_ALIAS_DEPR(opencl11, "CL1.1")
 LANGSTANDARD_ALIAS_DEPR(opencl12, "CL1.2")
 LANGSTANDARD_ALIAS_DEPR(opencl20, "CL2.0")
 LANGSTANDARD_ALIAS_DEPR(opencl30, "CL3.0")
 LANGSTANDARD_ALIAS_DEPR(openclcpp10, "CLC++")
 LANGSTANDARD_ALIAS_DEPR(openclcpp10, "CLC++1.0")
 LANGSTANDARD_ALIAS_DEPR(openclcpp2021, "CLC++2021")
+LANGSTANDARD_ALIAS_DEPR(openclcpp2021, "clc++21")
+LANGSTANDARD_ALIAS_DEPR(openclcpp2021, "CLC++21")
 
 // CUDA
 LANGSTANDARD(cuda, "cuda", CUDA, "NVIDIA CUDA(tm)",
              LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | Digraphs)
 
 // HIP
 LANGSTANDARD(hip, "hip", HIP, "HIP",
              LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | Digraphs)
 
 #undef LANGSTANDARD
 #undef LANGSTANDARD_ALIAS
 #undef LANGSTANDARD_ALIAS_DEPR

clang/include/clang/Driver/Options.td

def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>,
   HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">,
   MarshallingInfoFlag<CodeGenOpts<"LessPreciseFPMAD">>,
   ImpliedByAnyOf<[cl_unsafe_math_optimizations.KeyPath, cl_fast_relaxed_math.KeyPath]>;
 def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
   HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">,
   MarshallingInfoFlag<LangOpts<"CLNoSignedZero">>;
 def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
   HelpText<"OpenCL language standard to compile for.">,
-  Values<"cl,CL,cl1.0,CL1.0,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++,clc++1.0,CLC++1.0,clc++2021,CLC++2021">;
+  Values<"cl,CL,cl1.0,CL1.0,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++,clc++1.0,CLC++1.0,clc++2021,CLC++2021,clc++21,CLC++21">;
 def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>,
   HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
 def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
   HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">,
   MarshallingInfoFlag<CodeGenOpts<"OpenCLCorrectlyRoundedDivSqrt">>;
 def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group<opencl_Group>, Flags<[CC1Option]>,
   HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">,
   MarshallingInfoFlag<CodeGenOpts<"UniformWGSize">>;

clang/lib/Frontend/CompilerInvocation.cpp

LangStandard::Kind OpenCLLangStd
         .Cases("cl1.0", "CL1.0", LangStandard::lang_opencl10)
         .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
         .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
         .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
         .Cases("cl3.0", "CL3.0", LangStandard::lang_opencl30)
         .Cases("clc++", "CLC++", LangStandard::lang_openclcpp10)
         .Cases("clc++1.0", "CLC++1.0", LangStandard::lang_openclcpp10)
         .Cases("clc++2021", "CLC++2021", LangStandard::lang_openclcpp2021)
+        .Cases("clc++21", "CLC++21", LangStandard::lang_openclcpp2021)
         .Default(LangStandard::lang_unspecified);
 
     if (OpenCLLangStd == LangStandard::lang_unspecified) {
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << A->getValue();
     }
     else
       LangStd = OpenCLLangStd;

clang/test/Driver/autocomplete.c

 // CLSTDALL-NEXT: cl3.0
 // CLSTDALL-NEXT: CL3.0
 // CLSTDALL-NEXT: clc++
 // CLSTDALL-NEXT: CLC++
 // CLSTDALL-NEXT: clc++1.0
 // CLSTDALL-NEXT: CLC++1.0
 // CLSTDALL-NEXT: clc++2021
 // CLSTDALL-NEXT: CLC++2021
+// CLSTDALL-NEXT: clc++21
+// CLSTDALL-NEXT: CLC++21
 // RUN: %clang --autocomplete=-fno-sanitize-coverage=,f | FileCheck %s -check-prefix=FNOSANICOVER
 // FNOSANICOVER: func
 // RUN: %clang --autocomplete=-fno-sanitize-coverage= | FileCheck %s -check-prefix=FNOSANICOVERALL
 // FNOSANICOVERALL: 8bit-counters
 // FNOSANICOVERALL-NEXT: bb
 // FNOSANICOVERALL-NEXT: edge
 // FNOSANICOVERALL-NEXT: func
 // FNOSANICOVERALL-NEXT: indirect-calls

clang/test/Frontend/stdlang.c

 // RUN: %clang_cc1 -x cuda -std=c++11 -DCUDA %s
 // RUN: %clang_cc1 -x cl -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl1.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl1.1 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl1.2 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl2.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=cl3.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=clc++ -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=clc++1.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=clc++2021 -DOPENCL %s
+// RUN: %clang_cc1 -x cl -cl-std=clc++21 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CL -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CL2.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CL3.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CLC++ -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CLC++1.0 -DOPENCL %s
 // RUN: %clang_cc1 -x cl -cl-std=CLC++2021 -DOPENCL %s
+// RUN: %clang_cc1 -x cl -cl-std=CLC++21 -DOPENCL %s
 // RUN: not %clang_cc1 -x cl -std=c99 -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-C99 %s
 // RUN: not %clang_cc1 -x cl -cl-std=invalid -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-INVALID %s
 // CHECK-C99: error: invalid argument '-std=c99' not allowed with 'OpenCL'
 // CHECK-INVALID: error: invalid value 'invalid' in '-cl-std=invalid'
 
 #if defined(CUDA)
   __attribute__((device)) void f_device();
 #elif defined(OPENCL)
   kernel void func(void);
 #endif