[CIR] Fix Global Ctor/Dtor priority attributes (#1743)

- This fixes default value to be expected 65535
- Introduces DefaultGlobalCtorDtorPriority constant
- Makes function to use I32Attr for priority instead of unnecessary attribute with reference to function

Author: xlauko

clang/include/clang/CIR/Dialect/IR/CIRAttrs.h

@@ -21,6 +21,10 @@
 #include "clang/CIR/Interfaces/ASTAttrInterfaces.h"
 #include "clang/CIR/Interfaces/CIRTypeInterfaces.h"
 
+namespace cir {
+inline constexpr uint32_t DefaultGlobalCtorDtorPriority = 65535;
+} // namespace cir
+
 //===----------------------------------------------------------------------===//
 // CIR Dialect Attrs
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -1207,42 +1207,50 @@ def CIR_UWTableAttr : CIR_EnumAttr<CIR_UWTableKind, "uwtable"> {
   let cppClassName = "UWTableAttr";
 }
 
-class CIR_GlobalCtorDtor<string name, string attrMnemonic,
-                         string sum, string desc>
+class CIR_GlobalCtorDtor<string name, string attrMnemonic>
     : CIR_Attr<"Global" # name, "global_" # attrMnemonic> {
-  let summary = sum;
-  let description = desc;
-
   let parameters = (ins "mlir::StringAttr":$name, "int":$priority);
-  let assemblyFormat = [{
-    `<`
-      $name `,` $priority
-    `>`
-  }];
+
+  let skipDefaultBuilders = 1;
   let builders = [
-    AttrBuilder<(ins "llvm::StringRef":$name,
-                      CArg<"int", "65536">:$priority), [{
+    AttrBuilder<(ins
+        "llvm::StringRef":$name,
+        CArg<"int", "cir::DefaultGlobalCtorDtorPriority">:$priority), [{
       return $_get($_ctxt, mlir::StringAttr::get($_ctxt, name), priority);
     }]>,
-    AttrBuilderWithInferredContext<(ins "mlir::StringAttr":$name,
-                                        CArg<"int", "65536">:$priority), [{
+    AttrBuilderWithInferredContext<(ins
+        "mlir::StringAttr":$name,
+        CArg<"int", "cir::DefaultGlobalCtorDtorPriority">:$priority), [{
       return $_get(name.getContext(), name, priority);
     }]>
   ];
+
+  let assemblyFormat = [{
+    `<` $name `,` $priority `>`
+  }];
+
   let extraClassDeclaration = [{
-    bool isDefaultPriority() const { return getPriority() == 65536; };
+    bool isDefaultPriority() const {
+      return getPriority() == cir::DefaultGlobalCtorDtorPriority;
+    };
   }];
-  let skipDefaultBuilders = 1;
 }
 
-def GlobalCtorAttr : CIR_GlobalCtorDtor<"Ctor", "ctor",
-  "Marks a function as a global constructor",
-  "A function with this attribute executes before main()"
->;
-def GlobalDtorAttr : CIR_GlobalCtorDtor<"Dtor", "dtor",
-  "Marks a function as a global destructor",
-  "A function with this attribute excutes before module unloading"
->;
+def GlobalCtorAttr : CIR_GlobalCtorDtor<"Ctor", "ctor"> {
+  let summary = "Marks a function as a global constructor";
+  let description = [{
+    Marks the function as a global constructor in the module's constructor list.
+    It will be executed before main() is called.
+  }];
+}
+
+def GlobalDtorAttr : CIR_GlobalCtorDtor<"Dtor", "dtor"> {
+  let summary = "Marks a function as a global destructor";
+  let description = [{
+      Marks a function as a global destructor in the module dtors list.
+      The function will be executed before the module unloading.
+  }];
+}
 
 def BitfieldInfoAttr : CIR_Attr<"BitfieldInfo", "bitfield_info"> {
   let summary = "Represents a bit field info";

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -84,6 +84,20 @@ class LLVMLoweringInfo {
 class CIR_Op<string mnemonic, list<Trait> traits = []> :
     Op<CIR_Dialect, mnemonic, traits>, LLVMLoweringInfo;
 
+//===----------------------------------------------------------------------===//
+// CIR Operation Traits
+//===----------------------------------------------------------------------===//
+
+class HasAtMostOneOfAttrsPred<list<string> names> :
+  CPred<!foldl("0", names, acc, name,  acc # " + (" # name # " ? 1 : 0)")
+        # " <= 1">;
+
+class HasAtMostOneOfAttrs<list<string> names> : PredOpTrait<
+  "has only one of the optional attributes: " # !interleave(names, ", "),
+  HasAtMostOneOfAttrsPred<!foreach(name, names, "$" # name)>
+>;
+
+
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
@@ -3597,9 +3611,17 @@ def CIR_CallingConv : CIR_I32EnumAttr<"CallingConv", "calling convention", [
   I32EnumAttrCase<"PTXKernel", 5, "ptx_kernel">
 ]>;
 
-def CIR_FuncOp : CIR_Op<"func", [
+def CIR_OptionalPriorityAttr : OptionalAttr<
+  DefaultValuedAttr<
+    ConfinedAttr<I32Attr, [IntMinValue<101>, IntMaxValue<65535>]>,
+    "cir::DefaultGlobalCtorDtorPriority"
+  >
+>;
+
+def FuncOp : CIR_Op<"func", [
   AutomaticAllocationScope, CallableOpInterface, FunctionOpInterface,
   DeclareOpInterfaceMethods<CIRGlobalValueInterface>,
+  HasAtMostOneOfAttrs<["global_ctor_priority", "global_dtor_priority"]>,
   IsolatedFromAbove
 ]> {
   let summary = "Declare or define a function";
@@ -3699,8 +3721,8 @@ def CIR_FuncOp : CIR_Op<"func", [
     OptionalAttr<DictArrayAttr>:$arg_attrs,
     OptionalAttr<DictArrayAttr>:$res_attrs,
     OptionalAttr<FlatSymbolRefAttr>:$aliasee,
-    OptionalAttr<GlobalCtorAttr>:$global_ctor,
-    OptionalAttr<GlobalDtorAttr>:$global_dtor,
+    CIR_OptionalPriorityAttr:$global_ctor_priority,
+    CIR_OptionalPriorityAttr:$global_dtor_priority,
     OptionalAttr<ArrayAttr>:$annotations,
     OptionalAttr<AnyASTFunctionDeclAttr>:$ast
   );

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -781,21 +781,20 @@ void CIRGenModule::emitGlobalFunctionDefinition(GlobalDecl gd,
 }
 
 /// Track functions to be called before main() runs.
-void CIRGenModule::AddGlobalCtor(cir::FuncOp ctor, int priority) {
+void CIRGenModule::AddGlobalCtor(cir::FuncOp ctor,
+                                 std::optional<int> priority) {
   // FIXME(cir): handle LexOrder and Associated data upon testcases.
   //
   // Traditional LLVM codegen directly adds the function to the list of global
   // ctors. In CIR we just add a global_ctor attribute to the function. The
   // global list is created in LoweringPrepare.
   //
   // FIXME(from traditional LLVM): Type coercion of void()* types.
-  ctor->setAttr(
-      ctor.getGlobalCtorAttrName(),
-      cir::GlobalCtorAttr::get(&getMLIRContext(), ctor.getName(), priority));
+  ctor.setGlobalCtorPriority(priority);
 }
 
 /// Add a function to the list that will be called when the module is unloaded.
-void CIRGenModule::AddGlobalDtor(cir::FuncOp dtor, int priority,
+void CIRGenModule::AddGlobalDtor(cir::FuncOp dtor, std::optional<int> priority,
                                  bool isDtorAttrFunc) {
   assert(isDtorAttrFunc && "NYI");
   if (codeGenOpts.RegisterGlobalDtorsWithAtExit &&
@@ -805,9 +804,7 @@ void CIRGenModule::AddGlobalDtor(cir::FuncOp dtor, int priority,
   }
 
   // FIXME(from traditional LLVM): Type coercion of void()* types.
-  dtor->setAttr(
-      dtor.getGlobalDtorAttrName(),
-      cir::GlobalDtorAttr::get(&getMLIRContext(), dtor.getName(), priority));
+  dtor.setGlobalDtorPriority(priority);
 }
 
 mlir::Operation *CIRGenModule::getGlobalValue(StringRef name) {

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -265,10 +265,13 @@ class CIRGenModule : public CIRGenTypeCache {
       mlir::Operation *insertPoint = nullptr,
       cir::GlobalLinkageKind linkage = cir::GlobalLinkageKind::ExternalLinkage);
 
-  // FIXME: Hardcoding priority here is gross.
-  void AddGlobalCtor(cir::FuncOp Ctor, int Priority = 65535);
-  void AddGlobalDtor(cir::FuncOp Dtor, int Priority = 65535,
-                     bool IsDtorAttrFunc = false);
+  /// Add a global constructor or destructor to the module.
+  /// The priority is optional, if not specified, the default priority is used.
+  void AddGlobalCtor(cir::FuncOp ctor,
+                     std::optional<int> priority = std::nullopt);
+  void AddGlobalDtor(cir::FuncOp dtor,
+                     std::optional<int> priority = std::nullopt,
+                     bool isDtorAttrFunc = false);
 
   // Return whether structured convergence intrinsics should be generated for
   // this target.

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

@@ -2652,35 +2652,35 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
           llvm::function_ref<void(std::optional<int> prio)> createAttr)
       -> mlir::LogicalResult {
     if (::mlir::succeeded(parser.parseOptionalKeyword(keyword))) {
-      std::optional<int> prio;
+      std::optional<int> priority;
       if (mlir::succeeded(parser.parseOptionalLParen())) {
         auto parsedPrio = mlir::FieldParser<int>::parse(parser);
         if (mlir::failed(parsedPrio))
           return parser.emitError(parser.getCurrentLocation(),
                                   "failed to parse 'priority', of type 'int'");
-        prio = parsedPrio.value_or(int());
+        priority = parsedPrio.value_or(int());
         // Parse literal ')'
         if (parser.parseRParen())
           return failure();
       }
-      createAttr(prio);
+      createAttr(priority);
     }
     return success();
   };
 
-  if (parseGlobalDtorCtor("global_ctor", [&](std::optional<int> prio) {
-        cir::GlobalCtorAttr globalCtorAttr =
-            prio ? cir::GlobalCtorAttr::get(nameAttr, *prio)
-                 : cir::GlobalCtorAttr::get(nameAttr);
-        state.addAttribute(getGlobalCtorAttrName(state.name), globalCtorAttr);
+  if (parseGlobalDtorCtor("global_ctor", [&](std::optional<int> priority) {
+        auto globalCtorPriorityAttr = builder.getI32IntegerAttr(
+            priority ? *priority : DefaultGlobalCtorDtorPriority);
+        state.addAttribute(getGlobalCtorPriorityAttrName(state.name),
+                           globalCtorPriorityAttr);
       }).failed())
     return failure();
 
-  if (parseGlobalDtorCtor("global_dtor", [&](std::optional<int> prio) {
-        cir::GlobalDtorAttr globalDtorAttr =
-            prio ? cir::GlobalDtorAttr::get(nameAttr, *prio)
-                 : cir::GlobalDtorAttr::get(nameAttr);
-        state.addAttribute(getGlobalDtorAttrName(state.name), globalDtorAttr);
+  if (parseGlobalDtorCtor("global_dtor", [&](std::optional<int> priority) {
+        auto globalDtorPriorityAttr = builder.getI32IntegerAttr(
+            priority ? *priority : DefaultGlobalCtorDtorPriority);
+        state.addAttribute(getGlobalDtorPriorityAttrName(state.name),
+                           globalDtorPriorityAttr);
       }).failed())
     return failure();
 
@@ -2794,9 +2794,9 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
       // These are all omitted since they are custom printed already.
       {getAliaseeAttrName(), getBuiltinAttrName(), getCoroutineAttrName(),
        getDsoLocalAttrName(), getExtraAttrsAttrName(),
-       getFunctionTypeAttrName(), getGlobalCtorAttrName(),
-       getGlobalDtorAttrName(), getLambdaAttrName(), getLinkageAttrName(),
-       getCallingConvAttrName(), getNoProtoAttrName(),
+       getFunctionTypeAttrName(), getGlobalCtorPriorityAttrName(),
+       getGlobalDtorPriorityAttrName(), getLambdaAttrName(),
+       getLinkageAttrName(), getCallingConvAttrName(), getNoProtoAttrName(),
        getSymVisibilityAttrName(), getArgAttrsAttrName(), getResAttrsAttrName(),
        getComdatAttrName(), getGlobalVisibilityAttrName(),
        getAnnotationsAttrName()});
@@ -2813,16 +2813,16 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
     p << ")";
   }
 
-  if (auto globalCtor = getGlobalCtorAttr()) {
+  if (auto globalCtorPriority = getGlobalCtorPriority()) {
     p << " global_ctor";
-    if (!globalCtor.isDefaultPriority())
-      p << "(" << globalCtor.getPriority() << ")";
+    if (globalCtorPriority.value() != DefaultGlobalCtorDtorPriority)
+      p << "(" << globalCtorPriority.value() << ")";
   }
 
-  if (auto globalDtor = getGlobalDtorAttr()) {
+  if (auto globalDtorPriority = getGlobalDtorPriority()) {
     p << " global_dtor";
-    if (!globalDtor.isDefaultPriority())
-      p << "(" << globalDtor.getPriority() << ")";
+    if (globalDtorPriority.value() != DefaultGlobalCtorDtorPriority)
+      p << "(" << globalDtorPriority.value() << ")";
   }
 
   if (!getExtraAttrs().getElements().empty()) {

clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp

@@ -183,10 +183,10 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
   llvm::StringMap<uint32_t> dynamicInitializerNames;
   llvm::SmallVector<FuncOp, 4> dynamicInitializers;
 
-  /// List of ctors to be called before main()
-  llvm::SmallVector<mlir::Attribute, 4> globalCtorList;
-  /// List of dtors to be called when unloading module.
-  llvm::SmallVector<mlir::Attribute, 4> globalDtorList;
+  /// List of ctors and their priorities to be called before main()
+  llvm::SmallVector<std::pair<std::string, uint32_t>, 4> globalCtorList;
+  /// List of dtors and their priorities to be called when unloading module.
+  llvm::SmallVector<std::pair<std::string, uint32_t>, 4> globalDtorList;
   /// List of annotations in the module
   llvm::SmallVector<mlir::Attribute, 4> globalAnnotations;
 };
@@ -939,14 +939,33 @@ void LoweringPreparePass::lowerGlobalOp(GlobalOp op) {
   }
 }
 
+template <typename AttributeTy>
+static llvm::SmallVector<mlir::Attribute>
+prepareCtorDtorAttrList(mlir::MLIRContext *context,
+                        llvm::ArrayRef<std::pair<std::string, uint32_t>> list) {
+  llvm::SmallVector<mlir::Attribute> attrs;
+  for (const auto &[name, priority] : list)
+    attrs.push_back(AttributeTy::get(context, name, priority));
+  return attrs;
+}
+
 void LoweringPreparePass::buildGlobalCtorDtorList() {
+
   if (!globalCtorList.empty()) {
+    llvm::SmallVector<mlir::Attribute> globalCtors =
+        prepareCtorDtorAttrList<cir::GlobalCtorAttr>(&getContext(),
+                                                     globalCtorList);
+
     theModule->setAttr(cir::CIRDialect::getGlobalCtorsAttrName(),
-                       mlir::ArrayAttr::get(&getContext(), globalCtorList));
+                       mlir::ArrayAttr::get(&getContext(), globalCtors));
   }
+
   if (!globalDtorList.empty()) {
+    llvm::SmallVector<mlir::Attribute> globalDtors =
+        prepareCtorDtorAttrList<cir::GlobalDtorAttr>(&getContext(),
+                                                     globalDtorList);
     theModule->setAttr(cir::CIRDialect::getGlobalDtorsAttrName(),
-                       mlir::ArrayAttr::get(&getContext(), globalDtorList));
+                       mlir::ArrayAttr::get(&getContext(), globalDtors));
   }
 }
 
@@ -956,8 +975,9 @@ void LoweringPreparePass::buildCXXGlobalInitFunc() {
 
   for (auto &f : dynamicInitializers) {
     // TODO: handle globals with a user-specified initialzation priority.
-    auto ctorAttr = cir::GlobalCtorAttr::get(&getContext(), f.getName());
-    globalCtorList.push_back(ctorAttr);
+    // TODO: handle defaule priority more nicely.
+    globalCtorList.emplace_back(f.getName(),
+                                cir::DefaultGlobalCtorDtorPriority);
   }
 
   SmallString<256> fnName;
@@ -1118,7 +1138,9 @@ void LoweringPreparePass::buildCUDAModuleCtor() {
   auto moduleCtor = buildRuntimeFunction(builder, moduleCtorName, loc,
                                          FuncType::get({}, voidTy),
                                          GlobalLinkageKind::InternalLinkage);
-  globalCtorList.push_back(GlobalCtorAttr::get(&getContext(), moduleCtorName));
+  // TODO figure out default mode priority
+  globalCtorList.emplace_back(moduleCtorName,
+                              cir::DefaultGlobalCtorDtorPriority);
   builder.setInsertionPointToStart(moduleCtor.addEntryBlock());
 
   // Register binary with CUDA runtime. This is substantially different in
@@ -1598,10 +1620,10 @@ void LoweringPreparePass::runOnOp(Operation *op) {
     if (isa<cir::ArrayType>(valTy) || isa<cir::RecordType>(valTy))
       lowerToMemCpy(storeOp);
   } else if (auto fnOp = dyn_cast<cir::FuncOp>(op)) {
-    if (auto globalCtor = fnOp.getGlobalCtorAttr()) {
-      globalCtorList.push_back(globalCtor);
-    } else if (auto globalDtor = fnOp.getGlobalDtorAttr()) {
-      globalDtorList.push_back(globalDtor);
+    if (auto globalCtor = fnOp.getGlobalCtorPriority()) {
+      globalCtorList.emplace_back(fnOp.getName(), globalCtor.value());
+    } else if (auto globalDtor = fnOp.getGlobalDtorPriority()) {
+      globalDtorList.emplace_back(fnOp.getName(), globalDtor.value());
     }
     if (auto attr = fnOp.getExtraAttrs().getElements().get(
             CUDAKernelNameAttr::getMnemonic())) {

clang/test/CIR/CodeGen/global-ctor-dtor.cpp

@@ -11,7 +11,7 @@ void foo(void) {
   bar();
 }
 
-// BEFORE: cir.func dso_local @_Z3foov() global_ctor(65535)
+// BEFORE: cir.func dso_local @_Z3foov() global_ctor
 
 void foo2(void) __attribute__((constructor(777)));
 void foo2(void) {
@@ -25,7 +25,7 @@ void foo3(void) {
   bar();
 }
 
-// BEFORE: cir.func dso_local @_Z4foo3v() global_dtor(65535)
+// BEFORE: cir.func dso_local @_Z4foo3v() global_dtor
 
 void foo4(void) __attribute__((destructor(789)));
 void foo4(void) {

clang/test/CIR/CodeGen/global-new.cpp

@@ -68,7 +68,7 @@ e *g = new e(0);
 // LLVM_EH:   ret void
 // LLVM_EH: }
 
-// LLVM-DAG: @llvm.global_ctors = appending constant [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65536, ptr @__cxx_global_var_init, ptr null }, { i32, ptr, ptr } { i32 65536, ptr @__cxx_global_var_init.1, ptr null }]
+// LLVM-DAG: @llvm.global_ctors = appending constant [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @__cxx_global_var_init, ptr null }, { i32, ptr, ptr } { i32 65535, ptr @__cxx_global_var_init.1, ptr null }]
 // LLVM: define internal void @__cxx_global_var_init()
 // LLVM: call ptr @_Znwm(i64 1)