[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/AST/ExprClassification.cpp

if (const ObjCPropertyRefExpr *Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
     if (Expr->isImplicitProperty() && Expr->getImplicitPropertySetter() == 0)
       return Cl::CM_NoSetterProperty;
   }
 
   CanQualType CT = Ctx.getCanonicalType(E->getType());
   // Const stuff is obviously not modifiable.
   if (CT.isConstQualified())
     return Cl::CM_ConstQualified;
+  if (CT.getQualifiers().getAddressSpace() == LangAS::opencl_constant)
+    return Cl::CM_ConstQualified;
 
   // Arrays are not modifiable, only their elements are.
   if (CT->isArrayType())
     return Cl::CM_ArrayType;
   // Incomplete types are not modifiable.
   if (CT->isIncompleteType())
     return Cl::CM_IncompleteType;
 

lib/CodeGen/CodeGenModule.cpp

static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
                                              bool constant,
                                              CodeGenModule &CGM,
                                              const char *GlobalName,
                                              unsigned Alignment) {
   // Create Constant for this string literal. Don't add a '\0'.
   llvm::Constant *C =
       llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
 
+  // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
+  unsigned AddrSpace = 0;
+  if (CGM.getLangOpts().OpenCL)
+    AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
+
   // Create a global variable for this string
-  llvm::GlobalVariable *GV =
-    new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
-                             llvm::GlobalValue::PrivateLinkage,
-                             C, GlobalName);
+  llvm::GlobalVariable *GV = new llvm::GlobalVariable(
+      CGM.getModule(), C->getType(), constant,
+      llvm::GlobalValue::PrivateLinkage, C, GlobalName, 0,
+      llvm::GlobalVariable::NotThreadLocal, AddrSpace);
   GV->setAlignment(Alignment);
   GV->setUnnamedAddr(true);
   return GV;
 }
 
 /// GetAddrOfConstantString - Returns a pointer to a character array
 /// containing the literal. This contents are exactly that of the
 /// given string, i.e. it will not be null terminated automatically;

lib/Sema/SemaExpr.cpp

Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks,
 
   // 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.
   QualType StrTy = Context.getConstantArrayType(CharTyConst,
                                  llvm::APInt(32, Literal.GetNumStringChars()+1),
                                  ArrayType::Normal, 0);
 
+  // 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);
+  }
+
   // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
   StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(),
                                              Kind, Literal.Pascal, StrTy,
                                              &StringTokLocs[0],
                                              StringTokLocs.size());
   if (Literal.getUDSuffix().empty())
     return Owned(Lit);
 

test/CodeGenOpenCL/str_literals.cl

+// RUN: %clang_cc1 %s -emit-llvm -o - -ffake-address-space-map | FileCheck %s
+
+__constant char * __constant x = "hello world";
+
+// CHECK: addrspace(3) unnamed_addr constant
+// CHECK: @x = addrspace(3) global i8 addrspace(3)*

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("heallo world");
+  foo(x);
+}