[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

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

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

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

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

So why we can't use unified OPENCL_C_VERSION?

438

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

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

438

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

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

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

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

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

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

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

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

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!

lib/Frontend/InitPreprocessor.cpp

   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, __CLANG_OPENCL_C_VERSION__ is defined for
+    // OpenCL v1.0 and v1.1.
+    switch (LangOpts.OpenCLVersion) {
+    case 0:
+    case 100:
+      Builder.defineMacro("__CLANG_OPENCL_C_VERSION__", "100");
+      break;
+    case 110:
+      Builder.defineMacro("__CLANG_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");
+    if (LangOpts.OpenCLVersion >= 110)
+      Builder.defineMacro("CL_VERSION_1_1", "110");
+    if (LangOpts.OpenCLVersion >= 120)
+      Builder.defineMacro("CL_VERSION_1_2", "120");
+    if (LangOpts.OpenCLVersion >= 200)
+      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__");

test/Preprocessor/predefined-macros.c

 // 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 __CLANG_OPENCL_C_VERSION__ 100
+// CHECK-CL11: #define CL_VERSION_1_0 100
+// CHECK-CL11: #define CL_VERSION_1_1 110
+// CHECK-CL11: #define __CLANG_OPENCL_C_VERSION__ 110
+// 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 __OPENCL_C_VERSION__ 120
+// 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-FRM: #define __FAST_RELAXED_MATH__ 1
+