[OpenCL] Change sampler representation

[dmitry]

Summary

Change sampler encoding so that it's now a set of bit-flags and there must be exactly 3 of them set: one for each of parameters required by OpenCL specification (addressing mode, filter and coordinates normalisation). Thus there are no defaults and all modes must be specified explicitly and there isn't a combination of addressing mode flags that could produce another valid addressing mode.

[yaxunl]

What's the benefit of this change? Since this change will require all device libraries implementing __translate_sampler_initializer to change accordingly. We need a compelling reason.

[b-sumner]

In D41699#971106, @yaxunl wrote:

What's the benefit of this change? Since this change will require all device libraries implementing __translate_sampler_initializer to change accordingly. We need a compelling reason.

I agree. The current layout doesn't prevent validation.

[Anastasia]

In D41699#971144, @b-sumner wrote:

In D41699#971106, @yaxunl wrote:

What's the benefit of this change? Since this change will require all device libraries implementing __translate_sampler_initializer to change accordingly. We need a compelling reason.

I agree. The current layout doesn't prevent validation.

I think the main issue is that this patch allows to detect problems when several values of the same type are mistakenly combined. I.e. if you look in test/SemaOpenCL/sampler_t.cl this allows to detect when addressing mode is set twice to different values:

constant sampler_t glb_smp5 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_ADDRESS_CLAMP ...

Even though it seems to be obvious in this example it might not always be the case. The code might be written using macros or even function calls to obtain the sampler mode. By giving each sampler type value a unique bit we are able to detect and diagnose such cases.

[b-sumner]

This will break all existing implementations and is not backwards compatible. Is this extra diagnosis really worthwhile? Are developers complaining?

[Anastasia]

In D41699#971357, @b-sumner wrote:

This will break all existing implementations and is not backwards compatible. Is this extra diagnosis really worthwhile? Are developers complaining?

Ok. Do you envision it would be a big change to update though? It looks like a useful diagnostic improvement and also makes this a bit cleaner. But of course, if it causes large overhead, it would be undesirable.

[dmitry]

@yaxunl there are two benefits of this change.

1. As pointed by Anastasia. Currently, we have values of addressing mode flags so that they produce valid addressing mode if to combine some of them (see Anastasia's example). And the spec (https://www.khronos.org/registry/OpenCL/sdk/1.0/docs/man/xhtml/sampler_t.html) says addressing mode must be one of CLK_ADDRESS_REPEAT, CLK_ADDRESS_CLAMP_TO_EDGE, CLK_ADDRESS_CLAMP, CLK_ADDRESS_NONE. Though the spec doesn't require it, it's still better to diagnose if a developer specified multiple addressing modes.
2. In current implementation filtering modes and normalized coordinates might be omitted when initializing samplers. The spec again says that these fields must be one of the predefined enums. Thus having defaults (i.e. constants of 0 values) allow a developer to omit some of the modes and write less portable code which is harder to debug.

So these 2 points are clearly technical benefits of this patch.

[Anastasia]

In D41699#975584, @dmitry wrote:

@yaxunl there are two benefits of this change.

1. As pointed by Anastasia. Currently, we have values of addressing mode flags so that they produce valid addressing mode if to combine some of them (see Anastasia's example). And the spec (https://www.khronos.org/registry/OpenCL/sdk/1.0/docs/man/xhtml/sampler_t.html) says addressing mode must be one of CLK_ADDRESS_REPEAT, CLK_ADDRESS_CLAMP_TO_EDGE, CLK_ADDRESS_CLAMP, CLK_ADDRESS_NONE. Though the spec doesn't require it, it's still better to diagnose if a developer specified multiple addressing modes.
2. In current implementation filtering modes and normalized coordinates might be omitted when initializing samplers. The spec again says that these fields must be one of the predefined enums. Thus having defaults (i.e. constants of 0 values) allow a developer to omit some of the modes and write less portable code which is harder to debug.

So these 2 points are clearly technical benefits of this patch.

Ping! @yaxunl, it would be nice to conclude how to proceed here. Do you still feel we don't have a convincing argument to go ahead with this change?

[yaxunl]

In D41699#990369, @Anastasia wrote:

In D41699#975584, @dmitry wrote:

@yaxunl there are two benefits of this change.

1. As pointed by Anastasia. Currently, we have values of addressing mode flags so that they produce valid addressing mode if to combine some of them (see Anastasia's example). And the spec (https://www.khronos.org/registry/OpenCL/sdk/1.0/docs/man/xhtml/sampler_t.html) says addressing mode must be one of CLK_ADDRESS_REPEAT, CLK_ADDRESS_CLAMP_TO_EDGE, CLK_ADDRESS_CLAMP, CLK_ADDRESS_NONE. Though the spec doesn't require it, it's still better to diagnose if a developer specified multiple addressing modes.
2. In current implementation filtering modes and normalized coordinates might be omitted when initializing samplers. The spec again says that these fields must be one of the predefined enums. Thus having defaults (i.e. constants of 0 values) allow a developer to omit some of the modes and write less portable code which is harder to debug.

So these 2 points are clearly technical benefits of this patch.

Ping! @yaxunl, it would be nice to conclude how to proceed here. Do you still feel we don't have a convincing argument to go ahead with this change?

Sorry for the delay.

Both the old and new definitions can diagnose invalid sampler values. The advantage of the new definition is that

1. it is able to detect certain invalid mixing of different modes of the same kind, e.g. CLK_ADDRESS_CLAMP_TO_EDGE | CLK_ADDRESS_CLAMP_ , whereas the old definition may fail to detect (not always, only for certain combinations).
2. it forces user not to use 0 as initial value for sampler since 0 is no longer a valid sampler value. (I think this is not a significant advantage since if a user wants to use number instead of macro to initialize the sampler for some reason, they may continue doing that after this change).

The disadvantage is

1. There is binary backward compatibility issue which may break the existing OpenCL applications: The applications may use hard coded sampler values, or store/load them to/from disk, or use LLVM binaries which assume old sampler value definitions. If OpenCL runtime suddenly switches to the new macro definition, these applications will break. To support the old applications, the runtime needs to detect the runtime version these applications compiled with and support the old sample definition, which increases the complexity of the OpenCL runtime.

2. the new definition is less extendable. If new address mode is added, it is easy for the old definition to maintain binary backward compatibility since the old definition has room for new address mode. However for the new definition, it is hard to maintain binary backward compatibility and a clean definition at the same time. If the new bit is added at higher bits they are going to be separated from the other bits for address mode.

Probably we should seek opinions from more OpenCL platform/library developers since this change could be disruptive for them.

[b-sumner]

I believe there are 20 distinct samplers. I'd be more comfortable with this if you could arrange that __translate_sampler_initializer would be called with values in [0, 19] instead of [133, 322].

[b-sumner]

In D41699#990909, @b-sumner wrote:

I believe there are 20 distinct samplers. I'd be more comfortable with this if you could arrange that __translate_sampler_initializer would be called with values in [0, 19] instead of [133, 322].

And, FWIW, after subtracting 16 from the current input to __translate_sampler_initializer, we get a number in the range [0, 25] which is close enough.

[Anastasia]

In D41699#990894, @yaxunl wrote:

whereas the old definition may fail to detect (not always, only for certain combinations).

For this reason I think it would be good to fix this. I don't think it's good to report errors inconsistently

2. the new definition is less extendable. If new address mode is added, it is easy for the old definition to maintain binary backward compatibility since the old definition has room for new address mode. However for the new definition, it is hard to maintain binary backward compatibility and a clean definition at the same time. If the new bit is added at higher bits they are going to be separated from the other bits for address mode.

Probably we should seek opinions from more OpenCL platform/library developers since this change could be disruptive for them.

Sure, let's hope some over developers can jump in. As for sampler modes I am not sure how much it is going to change in the future OpenCL versions. And as for binary compatibility I think this is a valid point, however it is solvable (by maintaining binary versions). I think we won't be able to do many interesting compiler refactoring tasks if we are to keep binary format unchanged.... It would be very pity to restrict us on that. Perhaps we should think of the solution to that overall long term.

lib/Headers/opencl-c.h

 // OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf
 
 int printf(__constant const char* st, ...);
 #endif
 
 // OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions
 
 // These values need to match the runtime equivalent
+// Sampler must specify only one mode from each of the following groups.
+// To validate that requirement a bit is reserved for each distinct value
+// of Addressing Mode, Coordinates and Filtering Mode. Thus there are no default
+// values and all Addressing Mode, Coordinates Normalization, and Filtering
+// Mode have to be specified. Any combination of two or more flags from the same
+// group leads to an incorrect value which can be detected in a trivial way.
 //
 // Addressing Mode.
 //
-#define CLK_ADDRESS_NONE                0
-#define CLK_ADDRESS_CLAMP_TO_EDGE       2
-#define CLK_ADDRESS_CLAMP               4
-#define CLK_ADDRESS_REPEAT              6
-#define CLK_ADDRESS_MIRRORED_REPEAT     8
+#define CLK_ADDRESS_NONE            (1 << 2)
+#define CLK_ADDRESS_CLAMP           (1 << 3)
+#define CLK_ADDRESS_CLAMP_TO_EDGE   (1 << 4)
+#define CLK_ADDRESS_REPEAT          (1 << 5)
+#define CLK_ADDRESS_MIRRORED_REPEAT (1 << 6)
 
 //
 // Coordination Normalization
 //
-#define CLK_NORMALIZED_COORDS_FALSE     0
-#define CLK_NORMALIZED_COORDS_TRUE      1
+#define CLK_NORMALIZED_COORDS_FALSE (1 << 0)
+#define CLK_NORMALIZED_COORDS_TRUE  (1 << 1)
 
 //
 // Filtering Mode.
 //
-#define CLK_FILTER_NEAREST              0x10
-#define CLK_FILTER_LINEAR               0x20
+#define CLK_FILTER_NEAREST          (1 << 7)
+#define CLK_FILTER_LINEAR           (1 << 8)
 
 #ifdef cl_khr_gl_msaa_sharing
 #pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable
 #endif //cl_khr_gl_msaa_sharing
 
 /**
  * Use the coordinate (coord.xy) to do an element lookup in
  * the 2D image object specified by image.

lib/Sema/SemaInit.cpp

case SK_OCLSamplerInit: {
         }
 
         llvm::APSInt Result;
         Init->EvaluateAsInt(Result, S.Context);
         const uint64_t SamplerValue = Result.getLimitedValue();
         // 32-bit value of sampler's initializer is interpreted as
         // bit-field with the following structure:
         // |unspecified|Filter|Addressing Mode| Normalized Coords|
-        // |31        6|5    4|3             1|                 0|
-        // This structure corresponds to enum values of sampler properties
-        // defined in SPIR spec v1.2 and also opencl-c.h
-        unsigned AddressingMode  = (0x0E & SamplerValue) >> 1;
-        unsigned FilterMode      = (0x30 & SamplerValue) >> 4;
+        // |31        9|8    7|6             2| 1               0|
+        unsigned NormalizedCoords  = (0x003 & SamplerValue) >> 0;
+        unsigned AddressingMode    = (0x07F & SamplerValue) >> 2;
+        unsigned FilterMode        = (0x1FF & SamplerValue) >> 7;
+        std::string SamplerWarning {};
+        if (NormalizedCoords != 1 && NormalizedCoords != 2)
+          SamplerWarning += "Normalized Coords";
         if (FilterMode != 1 && FilterMode != 2)
+          SamplerWarning += (SamplerWarning.empty() ? "Filter Mode"
+                                                    : ", Filter Mode");
+        // 0 or more then 1 addressing mode is used
+        if (!AddressingMode || AddressingMode & (AddressingMode - 1))
+          SamplerWarning += (SamplerWarning.empty() ? "Addressing Mode"
+                                                    : ", Addressing Mode");
+        if (!SamplerWarning.empty())
           S.Diag(Kind.getLocation(),
                  diag::warn_sampler_initializer_invalid_bits)
-                 << "Filter Mode";
-        if (AddressingMode > 4)
-          S.Diag(Kind.getLocation(),
-                 diag::warn_sampler_initializer_invalid_bits)
-                 << "Addressing Mode";
+                 << SamplerWarning;
       }
 
       // Cases 1a, 2a and 2b
       // Insert cast from integer to sampler.
       CurInit = S.ImpCastExprToType(Init, S.Context.OCLSamplerTy,
                                       CK_IntToOCLSampler);
       break;
     }

test/CodeGenOpenCL/opencl_types.cl

-// RUN: %clang_cc1 -cl-std=CL2.0 %s -triple "spir-unknown-unknown" -emit-llvm -o - -O0 | FileCheck %s --check-prefixes=CHECK-COM,CHECK-SPIR
-// RUN: %clang_cc1 -cl-std=CL2.0 %s -triple "amdgcn--amdhsa" -emit-llvm -o - -O0 | FileCheck %s --check-prefixes=CHECK-COM,CHECK-AMDGCN
-
-#define CLK_ADDRESS_CLAMP_TO_EDGE       2
-#define CLK_NORMALIZED_COORDS_TRUE      1
-#define CLK_FILTER_NEAREST              0x10
-#define CLK_FILTER_LINEAR               0x20
+// RUN: %clang_cc1 -internal-isystem ../../lib/Headers -include opencl-c.h -cl-std=CL2.0 %s -triple "spir-unknown-unknown" -emit-llvm -o - -O0 | FileCheck %s --check-prefixes=CHECK-COM,CHECK-SPIR
+// RUN: %clang_cc1 -internal-isystem ../../lib/Headers -include opencl-c.h -cl-std=CL2.0 %s -triple "amdgcn--amdhsa" -emit-llvm -o - -O0 | FileCheck %s --check-prefixes=CHECK-COM,CHECK-AMDGCN
 
 constant sampler_t glb_smp = CLK_ADDRESS_CLAMP_TO_EDGE|CLK_NORMALIZED_COORDS_TRUE|CLK_FILTER_NEAREST;
 // CHECK-COM-NOT: constant i32
 
 void fnc1(image1d_t img) {}
 // CHECK-SPIR: @fnc1(%opencl.image1d_ro_t addrspace(1)*
 // CHECK-AMDGCN: @fnc1(%opencl.image1d_ro_t addrspace(2)*
 

test/CodeGenOpenCL/sampler.cl

-// RUN: %clang_cc1 %s -emit-llvm -triple spir-unknown-unknown -o - -O0 | FileCheck %s
+// RUN: %clang_cc1 %s -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -triple spir-unknown-unknown -o - -O0 | FileCheck %s
 //
 // This test covers 5 cases of sampler initialzation:
 //   1. function argument passing
 //      1a. argument is a file-scope variable
 //      1b. argument is a function-scope variable
 //      1c. argument is one of caller function's parameters
 //   2. variable initialization
 //      2a. initializing a file-scope variable
 //      2b. initializing a function-scope variable
 
-#define CLK_ADDRESS_CLAMP_TO_EDGE       2
-#define CLK_NORMALIZED_COORDS_TRUE      1
-#define CLK_FILTER_NEAREST              0x10
-#define CLK_FILTER_LINEAR               0x20
-
 // CHECK: %opencl.sampler_t = type opaque
 
 // Case 2a
 constant sampler_t glb_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
 // CHECK-NOT: glb_smp
 
 int get_sampler_initializer(void);
 
 void fnc4smp(sampler_t s) {}
 // CHECK: define spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* %
 
 kernel void foo(sampler_t smp_par) {
   // CHECK-LABEL: define spir_kernel void @foo(%opencl.sampler_t addrspace(2)* %smp_par)
   // CHECK: [[smp_par_ptr:%[A-Za-z0-9_\.]+]] = alloca %opencl.sampler_t addrspace(2)*
 
   // Case 2b
   sampler_t smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_NEAREST;
   // CHECK: [[smp_ptr:%[A-Za-z0-9_\.]+]] = alloca %opencl.sampler_t addrspace(2)*
-  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 19)
+  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 146)
   // CHECK: store %opencl.sampler_t addrspace(2)* [[SAMP]], %opencl.sampler_t addrspace(2)** [[smp_ptr]]
 
   // Case 1b
   fnc4smp(smp);
-  // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 19)
+  // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 146)
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_ptr]]
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1b
   fnc4smp(smp);
-  // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 19)
+  // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 146)
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_ptr]]
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1a
   fnc4smp(glb_smp);
-  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
+  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 274)
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1c
   fnc4smp(smp_par);
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_par_ptr]]
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
-  fnc4smp(5);
-  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 5)
+  fnc4smp(274);
+  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 274)
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   const sampler_t const_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
   fnc4smp(const_smp);
-   // CHECK: [[CONST_SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
+   // CHECK: [[CONST_SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 274)
   // CHECK: store %opencl.sampler_t addrspace(2)* [[CONST_SAMP]], %opencl.sampler_t addrspace(2)** [[CONST_SMP_PTR:%[a-zA-Z0-9]+]]
   fnc4smp(const_smp);
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[CONST_SMP_PTR]]
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   constant sampler_t constant_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
   fnc4smp(constant_smp);
-  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
+  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 274)
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // TODO: enable sampler initialization with non-constant integer.
   //const sampler_t const_smp_func_init = get_sampler_initializer();
 }

test/SemaOpenCL/sampler_t.cl

-// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
-// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -DCHECK_SAMPLER_VALUE -Wspir-compat -triple amdgcn--amdhsa
-// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -DCHECK_SAMPLER_VALUE -triple spir-unknown-unknown
-
-#define CLK_ADDRESS_CLAMP_TO_EDGE       2
-#define CLK_NORMALIZED_COORDS_TRUE      1
-#define CLK_FILTER_NEAREST              0x10
-#define CLK_FILTER_LINEAR               0x20
+// RUN: %clang_cc1 %s -internal-isystem ../../lib/Headers -include opencl-c.h -verify -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -internal-isystem ../../lib/Headers -include opencl-c.h -verify -pedantic -fsyntax-only -DCHECK_SAMPLER_VALUE -Wspir-compat -triple amdgcn--amdhsa
+// RUN: %clang_cc1 %s -internal-isystem ../../lib/Headers -include opencl-c.h -verify -pedantic -fsyntax-only -DCHECK_SAMPLER_VALUE -triple spir-unknown-unknown
 
 constant sampler_t glb_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
 constant sampler_t glb_smp2; // expected-error{{variable in constant address space must be initialized}}
 global sampler_t glb_smp3 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_NEAREST; // expected-error{{sampler type cannot be used with the __local and __global address space qualifiers}} expected-error {{global sampler requires a const or constant address space qualifier}}
 const global sampler_t glb_smp3_const = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;  // expected-error{{sampler type cannot be used with the __local and __global address space qualifiers}}
 
 constant sampler_t glb_smp4 = 0;
 #ifdef CHECK_SAMPLER_VALUE
-// expected-warning@-2{{sampler initializer has invalid Filter Mode bits}}
+// expected-warning@-2{{sampler initializer has invalid Normalized Coords, Filter Mode, Addressing Mode bits}}
 #endif
 
-constant sampler_t glb_smp5 = 0x1f;
+constant sampler_t glb_smp5 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_ADDRESS_CLAMP | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
 #ifdef CHECK_SAMPLER_VALUE
 // expected-warning@-2{{sampler initializer has invalid Addressing Mode bits}}
 #endif
 
-constant sampler_t glb_smp6 = glb_smp; // expected-error{{initializer element is not a compile-time constant}}
+constant sampler_t glb_smp6 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE;
+#ifdef CHECK_SAMPLER_VALUE
+// expected-warning@-2{{sampler initializer has invalid Filter Mode bits}}
+#endif
+
+constant sampler_t glb_smp7 = glb_smp; // expected-error{{initializer element is not a compile-time constant}}
 
 int f(void);
-constant sampler_t glb_smp7 = f(); // expected-error{{initializer element is not a compile-time constant}}
+constant sampler_t glb_smp8 = f(); // expected-error{{initializer element is not a compile-time constant}}
 
-constant sampler_t glb_smp8 = 1.0f; // expected-error{{initializing '__constant sampler_t' with an expression of incompatible type 'float'}}
+constant sampler_t glb_smp9 = 1.0f; // expected-error{{initializing '__constant sampler_t' with an expression of incompatible type 'float'}}
 
-constant sampler_t glb_smp9 = 0x100000000LL; // expected-error{{sampler_t initialization requires 32-bit integer, not 'long long'}}
+constant sampler_t glb_smp10 = 0x100000000LL; // expected-error{{sampler_t initialization requires 32-bit integer, not 'long long'}}
 
 void foo(sampler_t); // expected-note{{passing argument to parameter here}}
 
 constant struct sampler_s {
   sampler_t smp; // expected-error{{the 'sampler_t' type cannot be used to declare a structure or union field}}
 } sampler_str = {0};
 
 sampler_t bad(void); //expected-error{{declaring function return value of type 'sampler_t' is not allowed}}
 
 sampler_t global_nonconst_smp = 0; // expected-error {{global sampler requires a const or constant address space qualifier}}
 
-const sampler_t glb_smp10 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
-const constant sampler_t glb_smp11 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
+const sampler_t glb_smp11 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
+const constant sampler_t glb_smp12 = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
 
 void kernel ker(sampler_t argsmp) {
   local sampler_t smp; // expected-error{{sampler type cannot be used with the __local and __global address space qualifiers}}
   const sampler_t const_smp5 = 1.0f; // expected-error{{initializing 'const sampler_t' with an expression of incompatible type 'float'}}
   const sampler_t const_smp6 = 0x100000000LL; // expected-error{{sampler_t initialization requires 32-bit integer, not 'long long'}}
 
   foo(5.0f); // expected-error {{passing 'float' to parameter of incompatible type 'sampler_t'}}
   sampler_t sa[] = {argsmp, glb_smp}; // expected-error {{array of 'sampler_t' type is invalid in OpenCL}}