[OpenCL] Add string literals to the constant address space.

[joey]

Summary

OpenCL requires string literals to be in the constant address space.

[jordan_rose]

Does LangOpts.OpenCL imply LangOpts.ConstStrings? It probably should, just in case anything else is checking to see if it can rely on all string constants being const. You could even then (in a followup patch) complain if anyone tried to turn this off, e.g. with -fwritable-strings.

(I see that you still have to special case the address space.)

[joey]

I made LangOpts.OpenCL imply LangOpts.ConstStrings, and updated some of the tests I missed the first time round.

[joey]

I forgot to add the CodeGen parts of this patch to the review, here it is.

[joey]

I updated this patch to remove the 'const' part as I now believe it is wrong, and I changed IsModifiable as Tanya suggested.

Ok to commit?

Sorry about the long delay on this.

[pekka.jaaskelainen]

This is supposed to use the string constant sharing mechanism, right? Maybe a test could be added that checks that the constant data is shared for two same string constants? Otherwise, LGTM.

[joey]

I

[joey]

r194717, thanks!

lib/Frontend/CompilerInvocation.cpp

     Opts.LaxVectorConversions = 0;
     Opts.DefaultFPContract = 1;
     Opts.NativeHalfType = 1;
+    Opts.ConstStrings = 1;
   }
 
   if (LangStd == LangStandard::lang_cuda)

lib/Sema/SemaExpr.cpp

   if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
     StrTy.addConst();
 
+  // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
+  if (getLangOpts().OpenCL) {
+    StrTy = Context.getAddrSpaceQualType(StrTy, LangAS::opencl_constant);
+  }
+
   // Get an array type for the string, according to C99 6.4.5.  This includes
   // the nul terminator character as well as the string length for pascal
   // strings.

lib/Sema/SemaType.cpp

 
   unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
   Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
+
+  // Constant address space implies const qualifier
+  if(S.getLangOpts().OpenCL && ASIdx == LangAS::opencl_constant)
+    Type = S.Context.getConstType(Type);
 }
 
 /// Does this type have a "direct" ownership qualifier?  That is,

test/CodeGenOpenCL/opencl_types.cl

 // RUN: %clang_cc1 %s -emit-llvm -o - -O0 | FileCheck %s
 
 constant sampler_t glb_smp = 7;
-// CHECK: global i32 7
+// CHECK: constant i32 7
 
 void fnc1(image1d_t img) {}
 // CHECK: @fnc1(%opencl.image1d_t*

test/SemaOpenCL/address-spaces.cl

   int *ip;
   ip = gip; // expected-error {{assigning '__global int *' to 'int *' changes address space of pointer}}
   ip = &li; // expected-error {{assigning '__local int *' to 'int *' changes address space of pointer}}
-  ip = &ci; // expected-error {{assigning '__constant int *' to 'int *' changes address space of pointer}}
+  ip = &ci; // expected-error {{assigning 'const __constant int *' to 'int *' changes address space of pointer}}
 }

test/SemaOpenCL/str_literals.cl

+// RUN: %clang_cc1 %s -verify
+// expected-no-diagnostics
+
+__constant char * __constant x = "hello world";
+
+void foo(__constant char * a) {
+
+}
+
+void bar() {
+  foo("hello world");
+}