[OpenCL] Diagnose some reserved types

[svenvh]

Summary

Catch uses of the 'long long', 'unsigned long long', and 'long double'
reserved types.

Remove use of 'long long' in test/Misc/languageOptsOpenCL.cl; it
shouldn't have been added there in the first place as the OpenCL
specification explicitly forbids it in s6.1.4.

Initial patch by Simon Perretta.

[yaxunl]

Sorry for the delay.

The spec says:

The data type names described in the table below are reserved and cannot be used by applications as user-defined type names.

However, it does not forbid using the reserved types as builtin types if the compiler supports it.

I would suggest to emit warning instead of error.

lib/Sema/SemaType.cpp

1366

Please put else on the same line as } to be consistent with the rest of the code. same as below.

include/clang/Basic/DiagnosticSemaKinds.td

 def ext_c99_array_usage : Extension<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature">, InGroup<C99>;
 def err_c99_array_usage_cxx : Error<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature, not permitted in C++">;
 def err_type_unsupported : Error<
   "%0 is not supported on this target">;
+def err_ocl_type_reserved : Error<
+  "'%0' is a reserved type in OpenCL">;
 def err_nsconsumed_attribute_mismatch : Error<
   "overriding method has mismatched ns_consumed attribute on its"
   " parameter">;
 def err_nsreturns_retained_attribute_mismatch : Error<
   "overriding method has mismatched ns_returns_%select{not_retained|retained}0"
   " attributes">;
   
 def note_getter_unavailable : Note<

lib/Sema/SemaType.cpp

if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
         if (!S.getLangOpts().C99) {
           if (S.getLangOpts().CPlusPlus)
             S.Diag(DS.getTypeSpecWidthLoc(),
                    S.getLangOpts().CPlusPlus11 ?
                    diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
           else
             S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
         }
+        else if (S.getLangOpts().OpenCL) {
+          // OpenCL v2.0 s6.1.4: 'long long' is a reserved data type.
+          S.Diag(DS.getTypeSpecWidthLoc(), diag::err_ocl_type_reserved)
+            << "long long";
+        }
         break;
       }
     } else {
       switch (DS.getTypeSpecWidth()) {
       case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
       case DeclSpec::TSW_short:       Result = Context.UnsignedShortTy; break;
       case DeclSpec::TSW_long:        Result = Context.UnsignedLongTy; break;
       case DeclSpec::TSW_longlong:
         Result = Context.UnsignedLongLongTy;
 
         // 'long long' is a C99 or C++11 feature.
         if (!S.getLangOpts().C99) {
           if (S.getLangOpts().CPlusPlus)
             S.Diag(DS.getTypeSpecWidthLoc(),
                    S.getLangOpts().CPlusPlus11 ?
                    diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
           else
             S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
         }
+        else if (S.getLangOpts().OpenCL) {
+          // OpenCL v2.0 s6.1.4: 'unsigned long long' is a reserved data type.
+          S.Diag(DS.getTypeSpecWidthLoc(), diag::err_ocl_type_reserved)
+            << "unsigned long long";
+        }
         break;
       }
     }
     break;
   }
   case DeclSpec::TST_int128:
     if (!S.Context.getTargetInfo().hasInt128Type())
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "__int128";
     if (DS.getTypeSpecSign() == DeclSpec::TSS_unsigned)
       Result = Context.UnsignedInt128Ty;
     else
       Result = Context.Int128Ty;
     break;
   case DeclSpec::TST_half: Result = Context.HalfTy; break;
   case DeclSpec::TST_float: Result = Context.FloatTy; break;
   case DeclSpec::TST_double:
-    if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
+    if (DS.getTypeSpecWidth() == DeclSpec::TSW_long) {
       Result = Context.LongDoubleTy;
-    else
+      if (S.getLangOpts().OpenCL) {
+        // OpenCL v2.0 s6.1.4: 'long double' is a reserved data type.
+        S.Diag(DS.getTypeSpecWidthLoc(), diag::err_ocl_type_reserved)
+          << "long double";
+      }
+    } else
       Result = Context.DoubleTy;
     break;
   case DeclSpec::TST_float128:
     if (!S.Context.getTargetInfo().hasFloat128Type())
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "__float128";
     Result = Context.Float128Ty;
     break;

test/Misc/languageOptsOpenCL.cl

 // RUN: %clang_cc1 -x cl %s -verify -triple spir-unknown-unknown
 // expected-no-diagnostics
 
 // Test the forced language options for OpenCL are set correctly.
 
 kernel void test() {
   int v0[(sizeof(int) == 4) - 1];
   int v1[(__alignof(int)== 4) - 1];
   int v2[(sizeof(long) == 8) - 1];
   int v3[(__alignof(long)== 8) - 1];
-  int v4[(sizeof(long long) == 16) - 1];
-  int v5[(__alignof(long long)== 16) - 1];
-  int v6[(sizeof(float) == 4) - 1];
-  int v7[(__alignof(float)== 4) - 1];
+  int v4[(sizeof(float) == 4) - 1];
+  int v5[(__alignof(float)== 4) - 1];
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
-  int v8[(sizeof(double) == 8) - 1];
-  int v9[(__alignof(double)== 8) - 1];
+  int v6[(sizeof(double) == 8) - 1];
+  int v7[(__alignof(double)== 8) - 1];
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
-  int v10[(sizeof(half) == 2) - 1];
-  int v11[(__alignof(half) == 2) - 1];
+  int v8[(sizeof(half) == 2) - 1];
+  int v9[(__alignof(half) == 2) - 1];
 }

test/SemaOpenCL/unsupported.cl

 // RUN: %clang_cc1 -verify %s
 
 struct {
   int a : 1; // expected-error {{bit-fields are not supported in OpenCL}}
 };
 
 void no_vla(int n) {
   int a[n]; // expected-error {{variable length arrays are not supported in OpenCL}}
 }
 
 void no_logxor(int n) {
   int logxor = n ^^ n; // expected-error {{^^ is a reserved operator in OpenCL}}
 }
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+kernel void no_long_double(global long double *n) {} // expected-error {{'long double' is a reserved type in OpenCL}}
+
+kernel void no_long_long(global long long *n) {} // expected-error {{'long long' is a reserved type in OpenCL}}
+kernel void no_unsigned_long_long(global unsigned long long *n) {} // expected-error {{'unsigned long long' is a reserved type in OpenCL}}