[OpenCL] Add predefined macros.

[yaxunl]

Summary

OpenCL spec requires __OPENCL_C_VERSION__ to be defined based on -cl-std option. This patch implements that.

The patch also defines __FAST_RELAXED_MATH__ based on -cl-fast-relaxed-math option.

Also fixed a test using -std=c99 for OpenCL program. Limit allowed language standard of OpenCL to be OpenCL standards.

[bader]

LGTM

[pxli168]

lib/Frontend/InitPreprocessor.cpp

421 ↗

(On Diff #53606)

What is 0 stand for as OpenCLVersion, it seems the default OpenCLVersion if we did not pass any -cl-std=CLXX is 100.
So maybe we did not need this case 0:

439 ↗

(On Diff #53606)

These macros maybe need for all cl version, and in the header we should compare OPENCL_C_VERSION with CL_VERSION_2_0 instead of the integer 200 in the header of http://reviews.llvm.org/D18369?

[yaxunl]

lib/Frontend/InitPreprocessor.cpp

421 ↗

(On Diff #53606)

There is a test test/Frontend/stdlang.c:

// RUN: %clang_cc1 -x cl -std=c99 -DOPENCL %s

With this test, LangOpts.OpenCL is 1 but LangOpts.OpenCLVersion is 0.

If we all agree that this test is invalid and -x cl can only be compiled with OpenCL language standard and the default one is OpenCL 1.0, I can fix that test first and then remove case 0 in this switch.

439 ↗

(On Diff #53606)

Each OpenCL version only defines some of these macros by spec.

In the header file __OPENCL_C_VERSION__ can compare with 200 since the spec defines the integer value for __OPENCL_C_VERSION__. Comparing with CL_VERSION_2_0 requires checking CL_VERSION_2_0 is available first. I think probably I can define a macro

#define _OPENCL20_AND_ABOVE defined(__OPENCL_C_VERSION__) and defined(CL_VERSION_2_0) and __OPENCL_C_VERSION__ >= 200

and then use this macro for conditioning 2.0 specific functions.

[Anastasia]

lib/Frontend/InitPreprocessor.cpp

426 ↗

(On Diff #53606)

So why we can't use unified OPENCL_C_VERSION?

438 ↗

(On Diff #53606)

I am not sure we should add this conditionally though. If you want to compile CL code like this (forcing pointer to point to private AS for all CL versions the code is compiled for):

#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
private void* priv_ptr;
#else
void* priv_ptr;
#endif

This code would fail with -cl-sdt=CL1.1 (because CL_VERSION_2_0 is no longer defined), but the purpose of having version macros is to be able to condition on the passed CL version in the particular compilation run to avoid the compiler failure/miscompilation. This way we provide a way to select the right CL code for all versions the code is being compiled (if such selection is needed) to allow portability of CL code among OpenCL version.

[yaxunl]

lib/Frontend/InitPreprocessor.cpp

426 ↗

(On Diff #53606)

__OPENCL_C_VERSION__ is not defined in OpenCL spec v1.0 and 1.1.

438 ↗

(On Diff #53606)

CL_VERSION_x_y is only defined in OpenCL spec version equal or above x.y.

We can use macros like

#if defined(__OPENCL_C_VERSION__) && defined(CL_VERSION_2_0) && __OPENCL_C_VERSION__ >= CL_VERSION_2_0
#define _CL20_AND_ABOVE 1
#endif

439 ↗

(On Diff #53606)

should be

#if defined(__OPENCL_C_VERSION__) && defined(CL_VERSION_2_0) && __OPENCL_C_VERSION__ >= CL_VERSION_2_0
#define _CL20_AND_ABOVE 1
#endif

[Anastasia]

lib/Frontend/InitPreprocessor.cpp

439 ↗

(On Diff #53606)

Where do you plan to add this code?

My point is that the code is a bit complicated and messy with this checks and on the other hand it's kind of logical that compiler supporting all CL version would also accept all CL_VERSION_X_Y macros irrespectively from the passed -cl-std flag... I don't think spec is being that explicit on how CL2.0 compliant compiler should enable those macros when earlier versions of -cl-std are being passed.

[yaxunl]

lib/Frontend/InitPreprocessor.cpp

421 ↗

(On Diff #53606)

Anastasia,

What's your opinion on this? Should we limit the allowed language standard for cl to OpenCL standard only? Should I diagnose invalid language standard and also add a lit test for that?

Thanks.

439 ↗

(On Diff #53606)

OK I will add these macros.

[yaxunl]

Added OPENCL_C_VERSION and CL_VERSION_X_Y for all OpenCL versions.

Also fixed the test using -std=c99 for OpenCL and limit allowed language standard for OpenCL.

I think an OpenCL program by definition should follow certain OpenCL language standard.

[Anastasia]

lib/Frontend/InitPreprocessor.cpp

421 ↗

(On Diff #54243)

Yes, perfectly makes sense. I don't think passing C std flag should be allowed since OpenCL is based strictly on C99 and use of other versions are not possible anyways.

Nice cleanup!

439 ↗

(On Diff #54243)

Could you update the test please.

test/Frontend/stdlang.c

10 ↗

(On Diff #54243)

I think expected-no-diagnostics is only used if -verify is passed.

[yaxunl]

Fix test/preprocessor/predefined_macros.c.

Merge test/frontend/std.cl into langstd.c since they are similar.

[Anastasia]

lib/Frontend/InitPreprocessor.cpp

418 ↗

(On Diff #54404)

CLANG_OPENCL_C_VERSION -> OPENCL_C_VERSION

test/Frontend/stdlang.c

11 ↗

(On Diff #54404)

I still think that "// expected-no-diagnostics" is not needed here as we don't pass -verify.

[yaxunl]

Revised as Anastasia suggested.

[Anastasia]

test/Preprocessor/predefined-macros.c

180 ↗

(On Diff #54552)

Could we also add CHECK-NOT for all the above cases to make sure FAST_RELAXED_MATH doesn't appear there.

[yaxunl]

Add CHECK-NOT for __FAST_RELAXED_MATH__.

[Anastasia]

LGTM! Thanks!

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

else {
       case IK_ObjCXX:
       case IK_PreprocessedCXX:
       case IK_PreprocessedObjCXX:
         if (!Std.isCPlusPlus())
           Diags.Report(diag::err_drv_argument_not_allowed_with)
             << A->getAsString(Args) << "C++/ObjC++";
         break;
       case IK_OpenCL:
-        if (!Std.isC99())
-          Diags.Report(diag::err_drv_argument_not_allowed_with)
-            << A->getAsString(Args) << "OpenCL";
         break;
       case IK_CUDA:
       case IK_PreprocessedCuda:
         if (!Std.isCPlusPlus())
           Diags.Report(diag::err_drv_argument_not_allowed_with)
             << A->getAsString(Args) << "CUDA";
         break;
       default:

cfe/trunk/lib/Frontend/InitPreprocessor.cpp

static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
   // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
   // and 32-bit character literals.
   Builder.defineMacro("__STDC_UTF_16__", "1");
   Builder.defineMacro("__STDC_UTF_32__", "1");
 
   if (LangOpts.ObjC1)
     Builder.defineMacro("__OBJC__");
 
+  // OpenCL v1.0/1.1 s6.9, v1.2/2.0 s6.10: Preprocessor Directives and Macros.
+  if (LangOpts.OpenCL) {
+    // OpenCL v1.0 and v1.1 do not have a predefined macro to indicate the
+    // language standard with which the program is compiled. __OPENCL_VERSION__
+    // is for the OpenCL version supported by the OpenCL device, which is not
+    // necessarily the language standard with which the program is compiled.
+    // A shared OpenCL header file requires a macro to indicate the language
+    // standard. As a workaround, __OPENCL_C_VERSION__ is defined for
+    // OpenCL v1.0 and v1.1.
+    switch (LangOpts.OpenCLVersion) {
+    case 100:
+      Builder.defineMacro("__OPENCL_C_VERSION__", "100");
+      break;
+    case 110:
+      Builder.defineMacro("__OPENCL_C_VERSION__", "110");
+      break;
+    case 120:
+      Builder.defineMacro("__OPENCL_C_VERSION__", "120");
+      break;
+    case 200:
+      Builder.defineMacro("__OPENCL_C_VERSION__", "200");
+      break;
+    default:
+      llvm_unreachable("Unsupported OpenCL version");
+    }
+    Builder.defineMacro("CL_VERSION_1_0", "100");
+    Builder.defineMacro("CL_VERSION_1_1", "110");
+    Builder.defineMacro("CL_VERSION_1_2", "120");
+    Builder.defineMacro("CL_VERSION_2_0", "200");
+
+    if (LangOpts.FastRelaxedMath)
+      Builder.defineMacro("__FAST_RELAXED_MATH__");
+  }
   // Not "standard" per se, but available even with the -undef flag.
   if (LangOpts.AsmPreprocessor)
     Builder.defineMacro("__ASSEMBLER__");
   if (LangOpts.CUDA)
     Builder.defineMacro("__CUDA__");
 }
 
 /// Initialize the predefined C++ language feature test macros defined in

cfe/trunk/test/Frontend/std.cl

-// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL
-// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL1.1
-// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL1.2
-// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL2.0
-// RUN: not %clang_cc1 %s -fsyntax-only -cl-std=invalid -DINVALID 2>&1 | FileCheck %s
-
-#ifdef INVALID 
-// CHECK: invalid value 'invalid' in '-cl-std=invalid'
-#endif

cfe/trunk/test/Frontend/stdlang.c

 // RUN: %clang_cc1 -x cuda -std=c++11 -DCUDA %s
-// RUN: %clang_cc1 -x cl -std=c99 -DOPENCL %s
-// expected-no-diagnostics
+// 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.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: 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

cfe/trunk/test/Preprocessor/predefined-macros.c

 // RUN: %clang_cc1 %s -E -dM -o - -triple mips64 -target-cpu mips3 \
 // RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-SYNC_CAS_MIPS \
 // RUN:         --check-prefix=CHECK-SYNC_CAS_MIPS64
 // CHECK-SYNC_CAS_MIPS: #define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
 // CHECK-SYNC_CAS_MIPS: #define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
 // CHECK-SYNC_CAS_MIPS: #define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
 // CHECK-SYNC_CAS_MIPS32-NOT: __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
 // CHECK-SYNC_CAS_MIPS64: #define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
+
+// RUN: %clang_cc1 %s -E -dM -o - -x cl \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-CL10
+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL1.1 \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-CL11
+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL1.2 \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-CL12
+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL2.0 \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-CL20
+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-fast-relaxed-math \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-FRM
+// CHECK-CL10: #define CL_VERSION_1_0 100
+// CHECK-CL10: #define CL_VERSION_1_1 110
+// CHECK-CL10: #define CL_VERSION_1_2 120
+// CHECK-CL10: #define CL_VERSION_2_0 200
+// CHECK-CL10: #define __OPENCL_C_VERSION__ 100
+// CHECK-CL10-NOT: #define __FAST_RELAXED_MATH__ 1
+// CHECK-CL11: #define CL_VERSION_1_0 100
+// CHECK-CL11: #define CL_VERSION_1_1 110
+// CHECK-CL11: #define CL_VERSION_1_2 120
+// CHECK-CL11: #define CL_VERSION_2_0 200
+// CHECK-CL11: #define __OPENCL_C_VERSION__ 110
+// CHECK-CL11-NOT: #define __FAST_RELAXED_MATH__ 1
+// CHECK-CL12: #define CL_VERSION_1_0 100
+// CHECK-CL12: #define CL_VERSION_1_1 110
+// CHECK-CL12: #define CL_VERSION_1_2 120
+// CHECK-CL12: #define CL_VERSION_2_0 200
+// CHECK-CL12: #define __OPENCL_C_VERSION__ 120
+// CHECK-CL12-NOT: #define __FAST_RELAXED_MATH__ 1
+// CHECK-CL20: #define CL_VERSION_1_0 100
+// CHECK-CL20: #define CL_VERSION_1_1 110
+// CHECK-CL20: #define CL_VERSION_1_2 120
+// CHECK-CL20: #define CL_VERSION_2_0 200
+// CHECK-CL20: #define __OPENCL_C_VERSION__ 200
+// CHECK-CL20-NOT: #define __FAST_RELAXED_MATH__ 1
+// CHECK-FRM: #define __FAST_RELAXED_MATH__ 1
+