[CIR] Implement non-ODR-use constant expression handling

This patch implements support for non-ODR-use constant expressions
(NOUR_Constant) in ClangIR, which allows variables to be referenced
without constituting an odr-use when used in constant contexts.

Author: bcardosolopes

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -552,6 +552,69 @@ CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &D,
   return GV;
 }
 
+Address CIRGenModule::createUnnamedGlobalFrom(const VarDecl &D,
+                                              mlir::Attribute Constant,
+                                              CharUnits Align) {
+  auto functionName = [&](const DeclContext *DC) -> std::string {
+    if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
+      if (const auto *CC = dyn_cast<CXXConstructorDecl>(FD))
+        return CC->getNameAsString();
+      if (const auto *CD = dyn_cast<CXXDestructorDecl>(FD))
+        return CD->getNameAsString();
+      return std::string(getMangledName(FD));
+    } else if (const auto *OM = dyn_cast<ObjCMethodDecl>(DC)) {
+      return OM->getNameAsString();
+    } else if (isa<BlockDecl>(DC)) {
+      return "<block>";
+    } else if (isa<CapturedDecl>(DC)) {
+      return "<captured>";
+    } else {
+      llvm_unreachable("expected a function or method");
+    }
+  };
+
+  // Form a simple per-variable cache of these values in case we find we
+  // want to reuse them.
+  cir::GlobalOp &cacheEntry = initializerConstants[&D];
+  if (!cacheEntry || cacheEntry.getInitialValue() != Constant) {
+    auto ty = mlir::cast<mlir::TypedAttr>(Constant).getType();
+    bool isConstant = true;
+    mlir::ptr::MemorySpaceAttrInterface addrSpace =
+        cir::toCIRLangAddressSpaceAttr(&getMLIRContext(),
+                                       getGlobalVarAddressSpace(&D));
+
+    std::string name;
+    if (D.hasGlobalStorage())
+      name = getMangledName(&D).str() + ".const";
+    else if (const DeclContext *DC = D.getParentFunctionOrMethod())
+      name = ("__const." + functionName(DC) + "." + D.getName()).str();
+    else
+      llvm_unreachable("local variable has no parent function or method");
+
+    cir::GlobalOp gv = builder.createVersionedGlobal(
+        getModule(), getLoc(D.getLocation()), name, ty, isConstant,
+        cir::GlobalLinkageKind::PrivateLinkage, addrSpace);
+    // TODO(cir): infer visibility from linkage in global op builder.
+    gv.setVisibility(getMLIRVisibilityFromCIRLinkage(
+        cir::GlobalLinkageKind::PrivateLinkage));
+    gv.setInitialValueAttr(Constant);
+    gv.setAlignment(Align.getAsAlign().value());
+    // TODO(cir): Set unnamed address attribute when available in CIR
+
+    cacheEntry = gv;
+  } else if (cacheEntry.getAlignment() < Align.getQuantity()) {
+    cacheEntry.setAlignment(Align.getAsAlign().value());
+  }
+
+  // Create a GetGlobalOp to get a pointer to the global
+  mlir::Type eltTy = mlir::cast<mlir::TypedAttr>(Constant).getType();
+  auto ptrTy = builder.getPointerTo(cacheEntry.getSymType(),
+                                    cacheEntry.getAddrSpaceAttr());
+  mlir::Value globalPtr = cir::GetGlobalOp::create(
+      builder, getLoc(D.getLocation()), ptrTy, cacheEntry.getSymName());
+  return Address(globalPtr, eltTy, Align);
+}
+
 /// Add the initializer for 'D' to the global variable that has already been
 /// created for it. If the initializer has a different type than GV does, this
 /// may free GV and return a different one. Otherwise it just returns GV.

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1028,6 +1028,56 @@ static LValue emitFunctionDeclLValue(CIRGenFunction &CGF, const Expr *E,
                             AlignmentSource::Decl);
 }
 
+// TODO: can be a shared AST helper with traditional codegen
+static bool canEmitSpuriousReferenceToVariable(CIRGenFunction &CGF,
+                                               const DeclRefExpr *E,
+                                               const VarDecl *VD) {
+  // For a variable declared in an enclosing scope, do not emit a spurious
+  // reference even if we have a capture, as that will emit an unwarranted
+  // reference to our capture state, and will likely generate worse code than
+  // emitting a local copy.
+  if (E->refersToEnclosingVariableOrCapture())
+    return false;
+
+  // For a local declaration declared in this function, we can always reference
+  // it even if we don't have an odr-use.
+  if (VD->hasLocalStorage()) {
+    return VD->getDeclContext() ==
+           dyn_cast_or_null<DeclContext>(CGF.CurCodeDecl);
+  }
+
+  // For a global declaration, we can emit a reference to it if we know
+  // for sure that we are able to emit a definition of it.
+  VD = VD->getDefinition(CGF.getContext());
+  if (!VD)
+    return false;
+
+  // Don't emit a spurious reference if it might be to a variable that only
+  // exists on a different device / target.
+  // FIXME: This is unnecessarily broad. Check whether this would actually be a
+  // cross-target reference.
+  if (CGF.getLangOpts().OpenMP || CGF.getLangOpts().CUDA ||
+      CGF.getLangOpts().OpenCL) {
+    return false;
+  }
+
+  // We can emit a spurious reference only if the linkage implies that we'll
+  // be emitting a non-interposable symbol that will be retained until link
+  // time.
+  switch (CGF.CGM.getCIRLinkageVarDefinition(
+      VD, /*IsConstant=*/VD->getType().isConstantStorage(
+          CGF.getContext(), /*ExcludeCtor=*/false, /*ExcludeDtor=*/false))) {
+  case cir::GlobalLinkageKind::ExternalLinkage:
+  case cir::GlobalLinkageKind::LinkOnceODRLinkage:
+  case cir::GlobalLinkageKind::WeakODRLinkage:
+  case cir::GlobalLinkageKind::InternalLinkage:
+  case cir::GlobalLinkageKind::PrivateLinkage:
+    return true;
+  default:
+    return false;
+  }
+}
+
 LValue CIRGenFunction::emitDeclRefLValue(const DeclRefExpr *E) {
   const NamedDecl *ND = E->getDecl();
   QualType T = E->getType();
@@ -1041,7 +1091,43 @@ LValue CIRGenFunction::emitDeclRefLValue(const DeclRefExpr *E) {
         !VD->isLocalVarDecl())
       llvm_unreachable("NYI");
 
-    assert(E->isNonOdrUse() != NOUR_Constant && "not implemented");
+    // If this DeclRefExpr does not constitute an odr-use of the variable,
+    // we're not permitted to emit a reference to it in general, and it might
+    // not be captured if capture would be necessary for a use. Emit the
+    // constant value directly instead.
+    if (E->isNonOdrUse() == NOUR_Constant &&
+        (VD->getType()->isReferenceType() ||
+         !canEmitSpuriousReferenceToVariable(*this, E, VD))) {
+      VD->getAnyInitializer(VD);
+      mlir::Attribute val = ConstantEmitter(*this).emitAbstract(
+          E->getLocation(), *VD->evaluateValue(), VD->getType());
+      assert(val && "failed to emit constant expression");
+
+      Address addr = Address::invalid();
+      if (!VD->getType()->isReferenceType()) {
+        // Spill the constant value to a global.
+        addr = CGM.createUnnamedGlobalFrom(*VD, val,
+                                           getContext().getDeclAlign(VD));
+        mlir::Type varTy = getTypes().convertTypeForMem(VD->getType());
+        auto ptrTy = mlir::cast<cir::PointerType>(addr.getPointer().getType());
+        if (ptrTy.getPointee() != varTy) {
+          addr = addr.withElementType(getBuilder(), varTy);
+        }
+      } else {
+        // Should we be using the alignment of the constant pointer we emitted?
+        CharUnits alignment =
+            CGM.getNaturalTypeAlignment(E->getType(),
+                                        /* BaseInfo= */ nullptr,
+                                        /* TBAAInfo= */ nullptr,
+                                        /* forPointeeType= */ true);
+        mlir::Value ptrVal = getBuilder().getConstant(
+            getLoc(E->getExprLoc()), mlir::cast<mlir::TypedAttr>(val));
+        addr = makeNaturalAddressForPointer(ptrVal, T, alignment);
+      }
+      return makeAddrLValue(addr, T, AlignmentSource::Decl);
+    }
+
+    // FIXME(ogcg): Handle other kinds of non-odr-use DeclRefExprs.
 
     // Check for captured variables.
     if (E->refersToEnclosingVariableOrCapture()) {

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -237,6 +237,8 @@ class CIRGenModule : public CIRGenTypeCache {
   void HandleCXXStaticMemberVarInstantiation(VarDecl *VD);
 
   llvm::DenseMap<const Decl *, cir::GlobalOp> StaticLocalDeclMap;
+  llvm::DenseMap<const Decl *, cir::GlobalOp> staticLocalDeclGuardMap;
+  llvm::DenseMap<const VarDecl *, cir::GlobalOp> initializerConstants;
   llvm::DenseMap<llvm::StringRef, mlir::Value> Globals;
   mlir::Operation *getGlobalValue(llvm::StringRef Ref);
   mlir::Value getGlobalValue(const clang::Decl *D);
@@ -259,6 +261,9 @@ class CIRGenModule : public CIRGenTypeCache {
   cir::GlobalOp getOrCreateStaticVarDecl(const VarDecl &D,
                                          cir::GlobalLinkageKind Linkage);
 
+  Address createUnnamedGlobalFrom(const VarDecl &D, mlir::Attribute Constant,
+                                  CharUnits Align);
+
   cir::GlobalOp getOrCreateCIRGlobal(const VarDecl *D, mlir::Type Ty,
                                      ForDefinition_t IsForDefinition);
 

clang/test/CIR/CodeGen/non-odr-use-constant.cpp

@@ -0,0 +1,66 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck %s --input-file=%t.cir --check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll --check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ogcg.ll
+// RUN: FileCheck %s --input-file=%t.ogcg.ll --check-prefix=OGCG
+//
+// Test non-ODR-use constant expressions
+
+namespace llvm {
+  template<typename ValueTy> class StringMapEntry {};
+  template<typename ValueTy> class StringMapIterBase {
+  public:
+    StringMapEntry<ValueTy>& operator*() const;
+    StringMapIterBase& operator++();
+    friend bool operator!=(const StringMapIterBase& LHS, const StringMapIterBase& RHS);
+  };
+  template<typename ValueTy> class StringMap {
+  public:
+    StringMapIterBase<ValueTy> begin();
+    StringMapIterBase<ValueTy> end();
+  };
+  struct EmptyStringSetTag {};
+  template<class AllocatorTy = int> class StringSet : public StringMap<EmptyStringSetTag> {};
+}
+
+namespace clang {
+  // Static variable that will be referenced without ODR-use in range-for
+  static llvm::StringSet<> BuiltinClasses;
+
+  void EmitBuiltins() {
+    // This range-for iterates over BuiltinClasses without constituting an ODR-use
+    // because it's used in an unevaluated context for the range-for desugaring
+    for (const auto &Entry : BuiltinClasses) {
+    }
+  }
+}
+
+// CIR: cir.global "private" internal dso_local @_ZN5clangL14BuiltinClassesE
+// CIR: cir.func {{.*}}@_ZN5clang12EmitBuiltinsEv()
+// CIR:   %{{.*}} = cir.const #cir.global_view<@_ZN5clangL14BuiltinClassesE>
+
+// LLVM: @_ZN5clangL14BuiltinClassesE = internal global
+// LLVM: define {{.*}}@_ZN5clang12EmitBuiltinsEv()
+// LLVM:   %{{.*}} = alloca ptr
+// LLVM:   store ptr @_ZN5clangL14BuiltinClassesE
+
+// OGCG: @_ZN5clangL14BuiltinClassesE = internal global
+// OGCG: define {{.*}}@_ZN5clang12EmitBuiltinsEv()
+// OGCG:   %{{.*}} = alloca ptr
+// OGCG:   store ptr @_ZN5clangL14BuiltinClassesE
+
+// Test non-reference type NOUR_Constant (local constexpr in lambda)
+struct A { int x, y[2]; int arr[3]; };
+// CIR-DAG: @__const._Z1fi.a
+// LLVM-DAG: @__const._Z1fi.a
+// OGCG-DAG: @__const._Z1fi.a
+int f(int i) {
+  constexpr A a = {1, 2, 3, 4, 5, 6};
+  return [] (int n, int A::*p) {
+    return (n >= 0 ? a.arr[n] : (n == -1 ? a.*p : a.y[2 - n]));
+  }(i, &A::x);
+}
+// CIR: cir.get_global @__const._Z1fi.a
+// LLVM: getelementptr {{.*}} @__const._Z1fi.a
+// OGCG: getelementptr inbounds {{.*}} @__const._Z1fi.a