Update on "[CIR][Lowering] Lower globals with global_view initializer"

Adds lowering logic for CIR's global_view attributes with no indexes.
This is done by converting the global to a region-initialized LLVM
global operation, where the region returns the address of the global
used in the gloval_view initializer attribute.

[ghstack-poisoned]

Author: sitio-couto

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -104,10 +104,19 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
   //
 
   /// Get constant address of a global variable as an MLIR attribute.
-  mlir::Attribute getGlobalViewAttr(mlir::cir::GlobalOp globalOp) {
+  /// This wrapper infers the attribute type through the global op.
+  mlir::cir::GlobalViewAttr getGlobalViewAttr(mlir::cir::GlobalOp globalOp,
+                                              mlir::ArrayAttr indices = {}) {
     auto type = getPointerTo(globalOp.getSymType());
-    auto symRef = mlir::FlatSymbolRefAttr::get(globalOp.getSymNameAttr());
-    return mlir::cir::GlobalViewAttr::get(type, symRef);
+    return getGlobalViewAttr(type, globalOp, indices);
+  }
+
+  /// Get constant address of a global variable as an MLIR attribute.
+  mlir::cir::GlobalViewAttr getGlobalViewAttr(mlir::cir::PointerType type,
+                                              mlir::cir::GlobalOp globalOp,
+                                              mlir::ArrayAttr indices = {}) {
+    auto symbol = mlir::FlatSymbolRefAttr::get(globalOp.getSymNameAttr());
+    return mlir::cir::GlobalViewAttr::get(type, symbol, indices);
   }
 
   mlir::TypedAttr getZeroAttr(mlir::Type t) {

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -997,15 +997,13 @@ namespace {
 /// A struct which can be used to peephole certain kinds of finalization
 /// that normally happen during l-value emission.
 struct ConstantLValue {
-  // FIXME(cir): does it make sense to have both parent and child type here?
-  using SymbolTy = mlir::SymbolRefAttr;
-  llvm::PointerUnion<mlir::Value, SymbolTy, mlir::Attribute> Value;
+  llvm::PointerUnion<mlir::Value, mlir::Attribute> Value;
   bool HasOffsetApplied;
 
   /*implicit*/ ConstantLValue(mlir::Value value, bool hasOffsetApplied = false)
       : Value(value), HasOffsetApplied(hasOffsetApplied) {}
 
-  /*implicit*/ ConstantLValue(SymbolTy address) : Value(address) {}
+  /*implicit*/ ConstantLValue(mlir::SymbolRefAttr address) : Value(address) {}
 
   ConstantLValue(std::nullptr_t) : ConstantLValue({}, false) {}
   ConstantLValue(mlir::Attribute value) : Value(value) {}
@@ -1095,15 +1093,13 @@ mlir::Attribute ConstantLValueEmitter::tryEmit() {
     return {};
 
   // Apply the offset if necessary and not already done.
-  if (!result.HasOffsetApplied && !value.is<mlir::SymbolRefAttr>()) {
+  if (!result.HasOffsetApplied && !value.is<mlir::Attribute>()) {
     value = applyOffset(result).Value;
   }
 
   // Convert to the appropriate type; this could be an lvalue for
   // an integer. FIXME: performAddrSpaceCast
   if (destTy.isa<mlir::cir::PointerType>()) {
-    if (value.is<mlir::SymbolRefAttr>())
-      return value.get<mlir::SymbolRefAttr>();
     if (value.is<mlir::Attribute>())
       return value.get<mlir::Attribute>();
     llvm_unreachable("NYI");

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -1107,9 +1107,8 @@ mlir::Attribute CIRGenItaniumRTTIBuilder::BuildTypeInfo(mlir::Location loc,
   if (OldGV && !OldGV.isDeclaration()) {
     assert(!OldGV.hasAvailableExternallyLinkage() &&
            "available_externally typeinfos not yet implemented");
-    return mlir::cir::GlobalViewAttr::get(
-        CGM.getBuilder().getUInt8PtrTy(),
-        mlir::FlatSymbolRefAttr::get(OldGV.getSymNameAttr()));
+    return CGM.getBuilder().getGlobalViewAttr(CGM.getBuilder().getUInt8PtrTy(),
+                                              OldGV);
   }
 
   // Check if there is already an external RTTI descriptor for this type.
@@ -1275,10 +1274,9 @@ void CIRGenItaniumRTTIBuilder::BuildVTablePointer(mlir::Location loc,
   } else {
     SmallVector<mlir::Attribute, 4> offsets{
         mlir::cir::IntAttr::get(PtrDiffTy, 2)};
-    field = mlir::cir::GlobalViewAttr::get(
-        builder.getUInt8PtrTy(),
-        mlir::FlatSymbolRefAttr::get(VTable.getSymNameAttr()),
-        mlir::ArrayAttr::get(builder.getContext(), offsets));
+    auto indices = mlir::ArrayAttr::get(builder.getContext(), offsets);
+    field = CGM.getBuilder().getGlobalViewAttr(CGM.getBuilder().getUInt8PtrTy(),
+                                               VTable, indices);
   }
 
   assert(field && "expected attribute");
@@ -1347,9 +1345,7 @@ CIRGenItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(mlir::Location loc,
       llvm_unreachable("NYI");
   }
 
-  return mlir::cir::GlobalViewAttr::get(
-      builder.getUInt8PtrTy(),
-      mlir::FlatSymbolRefAttr::get(GV.getSymNameAttr()));
+  return builder.getGlobalViewAttr(builder.getUInt8PtrTy(), GV);
 }
 
 mlir::Attribute CIRGenItaniumRTTIBuilder::BuildTypeInfo(
@@ -1374,9 +1370,8 @@ mlir::Attribute CIRGenItaniumRTTIBuilder::BuildTypeInfo(
     // for global pointers.  This is very ARM64-specific.
     llvm_unreachable("NYI");
   } else {
-    TypeNameField = mlir::cir::GlobalViewAttr::get(
-        builder.getUInt8PtrTy(),
-        mlir::FlatSymbolRefAttr::get(TypeName.getSymNameAttr()));
+    TypeNameField =
+        builder.getGlobalViewAttr(builder.getUInt8PtrTy(), TypeName);
   }
   Fields.push_back(TypeNameField);
 
@@ -1539,9 +1534,7 @@ mlir::Attribute CIRGenItaniumRTTIBuilder::BuildTypeInfo(
   assert(!UnimplementedFeature::setDSOLocal());
   CIRGenModule::setInitializer(GV, init);
 
-  return mlir::cir::GlobalViewAttr::get(
-      builder.getUInt8PtrTy(),
-      mlir::FlatSymbolRefAttr::get(GV.getSymNameAttr()));
+  return builder.getGlobalViewAttr(builder.getUInt8PtrTy(), GV);;
 }
 
 mlir::Attribute CIRGenItaniumCXXABI::getAddrOfRTTIDescriptor(mlir::Location loc,

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -708,8 +708,7 @@ CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *D, mlir::Type Ty,
     Ty = getTypes().convertTypeForMem(ASTTy);
 
   auto globalOp = buildGlobal(D, Ty, IsForDefinition);
-  auto symRef = mlir::FlatSymbolRefAttr::get(globalOp.getSymNameAttr());
-  return mlir::cir::GlobalViewAttr::get(builder.getPointerTo(Ty), symRef);
+  return builder.getGlobalViewAttr(builder.getPointerTo(Ty), globalOp);
 }
 
 mlir::Operation* CIRGenModule::getWeakRefReference(const ValueDecl *VD) {