[CIR][CIRGen][Lowering] Generate GlobalViewAttr for string literals (#242).

Author: yugr

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -223,6 +223,9 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
     if (attr.isa<mlir::cir::ZeroAttr, mlir::cir::NullAttr>())
       return true;
 
+    if (attr.isa<mlir::cir::GlobalViewAttr>())
+      return false;
+
     // TODO(cir): introduce char type in CIR and check for that instead.
     if (const auto intVal = attr.dyn_cast<mlir::cir::IntAttr>())
       return intVal.isNullValue();

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1326,7 +1326,7 @@ LValue CIRGenFunction::buildArraySubscriptExpr(const ArraySubscriptExpr *E,
 }
 
 LValue CIRGenFunction::buildStringLiteralLValue(const StringLiteral *E) {
-  auto sym = CGM.getAddrOfConstantStringFromLiteral(E);
+  auto sym = CGM.getAddrOfConstantStringFromLiteral(E).getSymbol();
 
   auto cstGlobal = mlir::SymbolTable::lookupSymbolIn(CGM.getModule(), sym);
   assert(cstGlobal && "Expected global");

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -1008,7 +1008,7 @@ struct ConstantLValue {
   /*implicit*/ ConstantLValue(mlir::Value value, bool hasOffsetApplied = false)
       : Value(value), HasOffsetApplied(hasOffsetApplied) {}
 
-  /*implicit*/ ConstantLValue(mlir::SymbolRefAttr address) : Value(address) {}
+  /*implicit*/ ConstantLValue(mlir::cir::GlobalViewAttr address) : Value(address) {}
 
   ConstantLValue(std::nullptr_t) : ConstantLValue({}, false) {}
   ConstantLValue(mlir::Attribute value) : Value(value) {}

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -1097,78 +1097,62 @@ generateStringLiteral(mlir::Location loc, mlir::TypedAttr C,
   return GV;
 }
 
-// In address space agnostic languages, string literals are in default address
-// space in AST. However, certain targets (e.g. amdgcn) request them to be
-// emitted in constant address space in LLVM IR. To be consistent with other
-// parts of AST, string literal global variables in constant address space
-// need to be casted to default address space before being put into address
-// map and referenced by other part of CodeGen.
-// In OpenCL, string literals are in constant address space in AST, therefore
-// they should not be casted to default address space.
-static mlir::StringAttr
-castStringLiteralToDefaultAddressSpace(CIRGenModule &CGM, mlir::StringAttr GV) {
-  if (!CGM.getLangOpts().OpenCL) {
-    auto AS = CGM.getGlobalConstantAddressSpace();
-    if (AS != LangAS::Default)
-      assert(0 && "not implemented");
-  }
-  return GV;
-}
-
 /// Return a pointer to a constant array for the given string literal.
-mlir::SymbolRefAttr
+mlir::cir::GlobalViewAttr
 CIRGenModule::getAddrOfConstantStringFromLiteral(const StringLiteral *S,
                                                  StringRef Name) {
   CharUnits Alignment =
       astCtx.getAlignOfGlobalVarInChars(S->getType(), /*VD=*/nullptr);
 
   mlir::Attribute C = getConstantArrayFromStringLiteral(S);
-  mlir::cir::GlobalOp Entry;
-  if (!getLangOpts().WritableStrings) {
-    if (ConstantStringMap.count(C)) {
-      auto g = ConstantStringMap[C];
-      // The bigger alignment always wins.
-      if (!g.getAlignment() ||
-          uint64_t(Alignment.getQuantity()) > *g.getAlignment())
-        g.setAlignmentAttr(getSize(Alignment));
-      return mlir::SymbolRefAttr::get(
-          castStringLiteralToDefaultAddressSpace(*this, g.getSymNameAttr()));
-    }
-  }
 
-  SmallString<256> StringNameBuffer = Name;
-  llvm::raw_svector_ostream Out(StringNameBuffer);
-  if (StringLiteralCnt)
-    Out << StringLiteralCnt;
-  Name = Out.str();
-  StringLiteralCnt++;
+  mlir::cir::GlobalOp GV;
+  if (!getLangOpts().WritableStrings && ConstantStringMap.count(C)) {
+    GV = ConstantStringMap[C];
+    // The bigger alignment always wins.
+    if (!GV.getAlignment() ||
+        uint64_t(Alignment.getQuantity()) > *GV.getAlignment())
+      GV.setAlignmentAttr(getSize(Alignment));
+  } else {
+    SmallString<256> StringNameBuffer = Name;
+    llvm::raw_svector_ostream Out(StringNameBuffer);
+    if (StringLiteralCnt)
+      Out << StringLiteralCnt;
+    Name = Out.str();
+    StringLiteralCnt++;
+
+    SmallString<256> MangledNameBuffer;
+    StringRef GlobalVariableName;
+    auto LT = mlir::cir::GlobalLinkageKind::ExternalLinkage;
+
+    // Mangle the string literal if that's how the ABI merges duplicate strings.
+    // Don't do it if they are writable, since we don't want writes in one TU to
+    // affect strings in another.
+    if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
+        !getLangOpts().WritableStrings) {
+      assert(0 && "not implemented");
+    } else {
+      LT = mlir::cir::GlobalLinkageKind::InternalLinkage;
+      GlobalVariableName = Name;
+    }
 
-  SmallString<256> MangledNameBuffer;
-  StringRef GlobalVariableName;
-  auto LT = mlir::cir::GlobalLinkageKind::ExternalLinkage;
+    auto loc = getLoc(S->getSourceRange());
+    auto typedC = llvm::dyn_cast<mlir::TypedAttr>(C);
+    if (!typedC)
+      llvm_unreachable("this should never be untyped at this point");
+    GV = generateStringLiteral(loc, typedC, LT, *this, GlobalVariableName,
+                               Alignment);
+    ConstantStringMap[C] = GV;
 
-  // Mangle the string literal if that's how the ABI merges duplicate strings.
-  // Don't do it if they are writable, since we don't want writes in one TU to
-  // affect strings in another.
-  if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
-      !getLangOpts().WritableStrings) {
-    assert(0 && "not implemented");
-  } else {
-    LT = mlir::cir::GlobalLinkageKind::InternalLinkage;
-    GlobalVariableName = Name;
+    assert(!cir::UnimplementedFeature::reportGlobalToASan() && "NYI");
   }
 
-  auto loc = getLoc(S->getSourceRange());
-  auto typedC = llvm::dyn_cast<mlir::TypedAttr>(C);
-  if (!typedC)
-    llvm_unreachable("this should never be untyped at this point");
-  auto GV = generateStringLiteral(loc, typedC, LT, *this, GlobalVariableName,
-                                  Alignment);
-  ConstantStringMap[C] = GV;
+  auto ArrayTy = GV.getSymType().dyn_cast<mlir::cir::ArrayType>();
+  assert(ArrayTy && "String literal must be array");
+  auto PtrTy =
+      mlir::cir::PointerType::get(builder.getContext(), ArrayTy.getEltType());
 
-  assert(!cir::UnimplementedFeature::reportGlobalToASan() && "NYI");
-  return mlir::SymbolRefAttr::get(
-      castStringLiteralToDefaultAddressSpace(*this, GV.getSymNameAttr()));
+  return builder.getGlobalViewAttr(PtrTy, GV);
 }
 
 void CIRGenModule::buildDeclContext(const DeclContext *DC) {

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -304,7 +304,7 @@ class CIRGenModule : public CIRGenTypeCache {
 
   /// Return a global symbol reference to a constant array for the given string
   /// literal.
-  mlir::SymbolRefAttr
+  mlir::cir::GlobalViewAttr
   getAddrOfConstantStringFromLiteral(const StringLiteral *S,
                                      StringRef Name = ".str");
   unsigned StringLiteralCnt = 0;

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -1343,8 +1343,6 @@ static void printGlobalOpTypeAndInitialValue(OpAsmPrinter &p, GlobalOp op,
       // This also prints the type...
       if (initAttr)
         printConstant(p, initAttr);
-      if (initAttr.isa<SymbolRefAttr>())
-        printType();
     }
 
     if (!dtorRegion.empty()) {
@@ -1395,16 +1393,10 @@ static ParseResult parseGlobalOpTypeAndInitialValue(OpAsmParser &parser,
       if (parseConstantValue(parser, initialValueAttr).failed())
         return failure();
 
-      if (auto sra = initialValueAttr.dyn_cast<SymbolRefAttr>()) {
-        if (parser.parseColonType(opTy))
-          return failure();
-      } else {
-        // Handle StringAttrs
-        assert(initialValueAttr.isa<mlir::TypedAttr>() &&
-               "Non-typed attrs shouldn't appear here.");
-        auto typedAttr = initialValueAttr.cast<mlir::TypedAttr>();
-        opTy = typedAttr.getType();
-      }
+      assert(initialValueAttr.isa<mlir::TypedAttr>() &&
+             "Non-typed attrs shouldn't appear here.");
+      auto typedAttr = initialValueAttr.cast<mlir::TypedAttr>();
+      opTy = typedAttr.getType();
     }
 
     // Parse destructor, example: