CodeGen: Emit string literal in constant address space

[yaxunl]

Summary

Some targets have constant address space (e.g. amdgcn). For them string literal should be
emitted in constant address space then casted to default address space.

[rjmccall]

The part about string literals looks fine, but:

lib/CodeGen/CGDecl.cpp

1375

I don't understand why a patch about string literals is changing auto variable emission.

[yaxunl]

lib/CodeGen/CGDecl.cpp

1375

It is a bug about alloca revealed by the lit test

char l_array[] = "l_array";

Loc contains the alloca casted to default address space, therefore it needs to be casted back to alloca address space here, otherwise CreateBitCast returns invalid bitcast. Unlike lifetime.start, memcpy does not require alloca address space, so an alternative fix is to let BP take address space of Loc.

[rjmccall]

lib/CodeGen/CGDecl.cpp

1375

Yeah, I think using the address space of Loc is more appropriate.

[yaxunl]

Revised by John's comments. Also refactored to extract common code.

[rjmccall]

lib/CodeGen/CGDecl.cpp

1373

CGM.Int8Ty exists.

lib/CodeGen/CodeGenModule.cpp

3077

This should really just be a static function in this file.

[yaxunl]

Revised by John's comments.

[rjmccall]

Thanks, LGTM.

lib/CodeGen/CGDecl.cpp

   // in various ways.
   bool isVolatile = type.isVolatileQualified();
 
   llvm::Value *SizeVal =
     llvm::ConstantInt::get(IntPtrTy,
                            getContext().getTypeSizeInChars(type).getQuantity());
 
   llvm::Type *BP = AllocaInt8PtrTy;
   if (Loc.getType() != BP)
-    Loc = Builder.CreateBitCast(Loc, BP);
+    Loc = Address(EmitCastToVoidPtrInAllocaAddrSpace(Loc.getPointer()),
+                  Loc.getAlignment());
 
   // If the initializer is all or mostly zeros, codegen with memset then do
   // a few stores afterward.
   if (shouldUseMemSetPlusStoresToInitialize(constant,
                 CGM.getDataLayout().getTypeAllocSize(constant->getType()))) {
     Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
                          isVolatile);
     // Zero and undef don't require a stores.
     if (!constant->isNullValue() && !isa<llvm::UndefValue>(constant)) {
       Loc = Builder.CreateBitCast(Loc,
         constant->getType()->getPointerTo(Loc.getAddressSpace()));
       emitStoresForInitAfterMemset(constant, Loc.getPointer(),
                                    isVolatile, Builder);
     }
   } else {
     // Otherwise, create a temporary global with the initializer then
     // memcpy from the global to the alloca.
     std::string Name = getStaticDeclName(CGM, D);
     unsigned AS = 0;
     if (getLangOpts().OpenCL) {
       AS = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
       BP = llvm::PointerType::getInt8PtrTy(getLLVMContext(), AS);
+    } else if (auto OptionalAS = CGM.getTarget().getConstantAddressSpace()) {
+      AS = CGM.getContext().getTargetAddressSpace(OptionalAS.getValue());
+      BP = llvm::PointerType::getInt8PtrTy(getLLVMContext(), AS);
     }
+
     llvm::GlobalVariable *GV =
       new llvm::GlobalVariable(CGM.getModule(), constant->getType(), true,
                                llvm::GlobalValue::PrivateLinkage,
                                constant, Name, nullptr,
                                llvm::GlobalValue::NotThreadLocal, AS);
     GV->setAlignment(Loc.getAlignment().getQuantity());
     GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 

lib/CodeGen/CodeGenModule.cpp

 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
   if (!CGM.supportsCOMDAT())
     return false;
 
   if (D.hasAttr<SelectAnyAttr>())
     return true;
 
   GVALinkage Linkage;
   if (auto *VD = dyn_cast<VarDecl>(&D))
     Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
   else
     Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
 
   switch (Linkage) {
   case GVA_Internal:
   case GVA_AvailableExternally:
   case GVA_StrongExternal:

 static llvm::GlobalVariable *
 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
                       CodeGenModule &CGM, StringRef GlobalName,
                       CharUnits Alignment) {
   // OpenCL v1.2 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);
+  else if (auto AS = CGM.getTarget().getConstantAddressSpace()) {
+    AddrSpace = CGM.getContext().getTargetAddressSpace(AS.getValue());
+  }
 
   llvm::Module &M = CGM.getModule();
   // Create a global variable for this string
   auto *GV = new llvm::GlobalVariable(
       M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
       nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
   GV->setAlignment(Alignment.getQuantity());
   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

   }
 
   auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
   if (Entry)
     *Entry = GV;
 
   SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
                                   QualType());
-  return ConstantAddress(GV, Alignment);
+
+  llvm::Constant *Cast = GV;
+  if (!getLangOpts().OpenCL) {
+    if (auto AS = getTarget().getConstantAddressSpace()) {
+      if (AS != LangAS::Default)
+        Cast = getTargetCodeGenInfo().performAddrSpaceCast(
+            *this, GV, AS.getValue(), LangAS::Default,
+            GV->getValueType()->getPointerTo(
+                getContext().getTargetAddressSpace(LangAS::Default)));
+    }
+  }
+
+  return ConstantAddress(Cast, Alignment);
 }
 
 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
 /// array for the given ObjCEncodeExpr node.
 ConstantAddress
 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
   std::string Str;
   getContext().getObjCEncodingForType(E->getEncodedType(), Str);

   // Get the default prefix if a name wasn't specified.
   if (!GlobalName)
     GlobalName = ".str";
   // Create a global variable for this.
   auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
                                   GlobalName, Alignment);
   if (Entry)
     *Entry = GV;
-  return ConstantAddress(GV, Alignment);
+  llvm::Constant *Cast = GV;
+  if (!getLangOpts().OpenCL) {
+    if (auto AS = getTarget().getConstantAddressSpace()) {
+      if (AS != LangAS::Default)
+        Cast = getTargetCodeGenInfo().performAddrSpaceCast(
+            *this, GV, AS.getValue(), LangAS::Default,
+            GV->getValueType()->getPointerTo(
+                getContext().getTargetAddressSpace(LangAS::Default)));
+    }
+  }
+  return ConstantAddress(Cast, Alignment);
 }
 
 ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
     const MaterializeTemporaryExpr *E, const Expr *Init) {
   assert((E->getStorageDuration() == SD_Static ||
           E->getStorageDuration() == SD_Thread) && "not a global temporary");
   const auto *VD = cast<VarDecl>(E->getExtendingDecl());
 

test/CodeGenCXX/amdgcn-string-literal.cpp

+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm %s -o - | FileCheck %s
+
+// CHECK: @.str = private unnamed_addr addrspace(4) constant [6 x i8] c"g_str\00", align 1
+// CHECK: @g_str = addrspace(1) global i8* addrspacecast (i8 addrspace(4)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(4)* @.str, i32 0, i32 0) to i8*), align 8
+// CHECK: @g_array = addrspace(1) global [8 x i8] c"g_array\00", align 1
+// CHECK: @.str.1 = private unnamed_addr addrspace(4) constant [6 x i8] c"l_str\00", align 1
+// CHECK: @_ZZ1fvE7l_array = private unnamed_addr addrspace(4) constant [8 x i8] c"l_array\00", align 1
+
+const char* g_str = "g_str";
+char g_array[] = "g_array";
+
+void g(const char* p);
+
+// CHECK-LABEL: define void @_Z1fv()
+void f() {
+  const char* l_str = "l_str";
+  
+  // CHECK: call void @llvm.memcpy.p5i8.p4i8.i64
+  char l_array[] = "l_array";
+
+  g(g_str);
+  g(g_array);
+  g(l_str);
+  g(l_array);
+
+  const char* p = g_str;
+  g(p);
+}
 No newline at end of file