[CIR][CIRGen] Static initialize global addresses

Global addresses are constant, so we can initialize them at compile time
using CIR's global_view attribute. This patch adds codegen support for
the initialization of variables with constant global addresses.

Since a builder method was added for global_view, the patch also updates
the codegen of global variables to use it wherever possible.

ghstack-source-id: 513365c
Pull Request resolved: #204

Author: sitio-couto

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -102,6 +102,23 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
   // Attribute helpers
   // -----------------
   //
+
+  /// Get constant address of a global variable as an MLIR attribute.
+  /// 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());
+    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) {
     return mlir::cir::ZeroAttr::get(getContext(), t);
   }

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -17,6 +17,7 @@
 #include "CIRGenModule.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinAttributeInterfaces.h"
+#include "mlir/IR/BuiltinAttributes.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
@@ -999,16 +1000,16 @@ namespace {
 /// A struct which can be used to peephole certain kinds of finalization
 /// that normally happen during l-value emission.
 struct ConstantLValue {
-  using SymbolTy = mlir::SymbolRefAttr;
-  llvm::PointerUnion<mlir::Value, SymbolTy> 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) {}
 };
 
 /// A helper class for emitting constant l-values.
@@ -1053,10 +1054,13 @@ class ConstantLValueEmitter
   /// Return the value offset.
   mlir::Attribute getOffset() { llvm_unreachable("NYI"); }
 
+  // TODO(cir): create a proper interface to absctract CIR constant values.
+
   /// Apply the value offset to the given constant.
-  mlir::Attribute applyOffset(mlir::Attribute C) {
+  ConstantLValue applyOffset(ConstantLValue &C) {
     if (!hasNonZeroOffset())
       return C;
+
     // TODO(cir): use ptr_stride, or something...
     llvm_unreachable("NYI");
   }
@@ -1092,15 +1096,15 @@ mlir::Attribute ConstantLValueEmitter::tryEmit() {
     return {};
 
   // Apply the offset if necessary and not already done.
-  if (!result.HasOffsetApplied && !value.is<ConstantLValue::SymbolTy>()) {
-    assert(0 && "NYI");
+  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<ConstantLValue::SymbolTy>())
-      return value.get<ConstantLValue::SymbolTy>();
+    if (value.is<mlir::Attribute>())
+      return value.get<mlir::Attribute>();
     llvm_unreachable("NYI");
   }
 
@@ -1124,7 +1128,30 @@ ConstantLValue
 ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
   // Handle values.
   if (const ValueDecl *D = base.dyn_cast<const ValueDecl *>()) {
-    assert(0 && "NYI");
+    // The constant always points to the canonical declaration. We want to look
+    // at properties of the most recent declaration at the point of emission.
+    D = cast<ValueDecl>(D->getMostRecentDecl());
+
+    if (D->hasAttr<WeakRefAttr>())
+      llvm_unreachable("emit pointer base for weakref is NYI");
+
+    if (auto *FD = dyn_cast<FunctionDecl>(D))
+      llvm_unreachable("emit pointer base for fun decl is NYI");
+
+    if (auto *VD = dyn_cast<VarDecl>(D)) {
+      // We can never refer to a variable with local storage.
+      if (!VD->hasLocalStorage()) {
+        if (VD->isFileVarDecl() || VD->hasExternalStorage())
+          return CGM.getAddrOfGlobalVarAttr(VD);
+
+        if (VD->isLocalVarDecl()) {
+          auto linkage =
+              CGM.getCIRLinkageVarDefinition(VD, /*IsConstant=*/false);
+          return CGM.getBuilder().getGlobalViewAttr(
+              CGM.getOrCreateStaticVarDecl(*VD, linkage));
+        }
+      }
+    }
   }
 
   // Handle typeid(T).

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -1109,9 +1109,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.
@@ -1279,10 +1278,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");
@@ -1351,9 +1349,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(
@@ -1378,9 +1374,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);
 
@@ -1545,9 +1540,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

@@ -700,6 +700,18 @@ mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *D, mlir::Type Ty,
                                                 ptrTy, g.getSymName());
 }
 
+mlir::cir::GlobalViewAttr
+CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *D, mlir::Type Ty,
+                                     ForDefinition_t IsForDefinition) {
+  assert(D->hasGlobalStorage() && "Not a global variable");
+  QualType ASTTy = D->getType();
+  if (!Ty)
+    Ty = getTypes().convertTypeForMem(ASTTy);
+
+  auto globalOp = buildGlobal(D, Ty, IsForDefinition);
+  return builder.getGlobalViewAttr(builder.getPointerTo(Ty), globalOp);
+}
+
 mlir::Operation* CIRGenModule::getWeakRefReference(const ValueDecl *VD) {
   const AliasAttr *AA = VD->getAttr<AliasAttr>();
   assert(AA && "No alias?");

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -231,6 +231,11 @@ class CIRGenModule : public CIRGenTypeCache {
   getAddrOfGlobalVar(const VarDecl *D, mlir::Type Ty = {},
                      ForDefinition_t IsForDefinition = NotForDefinition);
 
+  /// Return the mlir::GlobalViewAttr for the address of the given global.
+  mlir::cir::GlobalViewAttr
+  getAddrOfGlobalVarAttr(const VarDecl *D, mlir::Type Ty = {},
+                         ForDefinition_t IsForDefinition = NotForDefinition);
+
   /// Get a reference to the target of VD.
   mlir::Operation* getWeakRefReference(const ValueDecl *VD);
 

clang/test/CIR/CodeGen/globals.cpp

@@ -115,3 +115,8 @@ int testExternVar(void) { return externVar; }
 // CHECK: cir.global "private" external @externVar : !s32i
 // CHECK: cir.func @{{.+}}testExternVar
 // CHECK:   cir.get_global @externVar : cir.ptr <!s32i>
+
+// Should constant initialize global with constant address.
+int var = 1;
+int *constAddr = &var;
+// CHECK-DAG: cir.global external @constAddr = #cir.global_view<@var> : !cir.ptr<!s32i>

clang/test/CIR/CodeGen/static-vars.c

@@ -35,3 +35,10 @@ void func2(void) {
   static float j;
   // CHECK-DAG: cir.global "private" internal @func2.j = 0.000000e+00 : f32
 }
+
+// Should const initialize static vars with constant addresses.
+void func3(void) {
+  static int var;
+  static int *constAddr = &var;
+  // CHECK-DAG: cir.global "private" internal @func3.constAddr = #cir.global_view<@func3.var> : !cir.ptr<!s32i>
+}