XXX

Author: xlauko

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

@@ -1192,10 +1192,6 @@ def CIR_OptNoneAttr : CIR_UnitAttr<"OptNone", "optnone"> {
   let storageType = [{ OptNoneAttr }];
 }
 
-def CIR_NoThrowAttr : CIR_UnitAttr<"NoThrow", "nothrow"> {
-  let storageType = [{ NoThrowAttr }];
-}
-
 def CIR_ConvergentAttr : CIR_UnitAttr<"Convergent", "convergent"> {
   let storageType = [{ ConvergentAttr }];
 }

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

@@ -4105,6 +4105,7 @@ def FuncOp : CIR_Op<"func", [
     UnitAttr:$lambda,
     UnitAttr:$no_proto,
     UnitAttr:$dso_local,
+    UnitAttr:$nothrow,
     DefaultValuedAttr<
       CIR_GlobalLinkageKind, "GlobalLinkageKind::ExternalLinkage"
     >:$linkage,

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -162,8 +162,7 @@ static void AddAttributesFromFunctionProtoType(CIRGenBuilderTy &builder,
 
   if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
       FPT->isNothrow()) {
-    auto nu = cir::NoThrowAttr::get(builder.getContext());
-    FuncAttrs.set(nu.getMnemonic(), nu);
+    FuncAttrs.set("nothrow", builder.getUnitAttr());
   }
 }
 
@@ -221,8 +220,8 @@ void CIRGenModule::constructAttributeList(
   if (TargetDecl) {
 
     if (TargetDecl->hasAttr<NoThrowAttr>()) {
-      auto nu = cir::NoThrowAttr::get(&getMLIRContext());
-      funcAttrs.set(nu.getMnemonic(), nu);
+      auto nu = mlir::UnitAttr::get(&getMLIRContext());
+      funcAttrs.set("nothrow", nu);
     }
 
     if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
@@ -324,7 +323,7 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc,
                cir::FuncOp directFuncOp,
                SmallVectorImpl<mlir::Value> &CIRCallArgs, bool isInvoke,
                cir::CallingConv callingConv, cir::SideEffect sideEffect,
-               cir::ExtraFuncAttributesAttr extraFnAttrs) {
+               cir::ExtraFuncAttributesAttr extraFnAttrs, bool cannotThrow) {
   auto &builder = CGF.getBuilder();
   auto getOrCreateSurroundingTryOp = [&]() {
     // In OG, we build the landing pad for this scope. In CIR, we emit a
@@ -383,6 +382,8 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc,
           callLoc, directFuncOp, CIRCallArgs, callingConv, sideEffect);
     }
     callOpWithExceptions->setAttr("extra_attrs", extraFnAttrs);
+    if (cannotThrow)
+      callOpWithExceptions->setAttr("nothrow", builder.getUnitAttr());
     CGF.mayThrow = true;
 
     CGF.callWithExceptionCtx = callOpWithExceptions;
@@ -398,15 +399,20 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc,
   }
 
   assert(builder.getInsertionBlock() && "expected valid basic block");
+  cir::CIRCallOpInterface callOp;
   if (indirectFuncTy) {
     // TODO(cir): Set calling convention for indirect calls.
     assert(callingConv == cir::CallingConv::C && "NYI");
-    return builder.createIndirectCallOp(
+    callOp = builder.createIndirectCallOp(
         callLoc, indirectFuncVal, indirectFuncTy, CIRCallArgs,
         cir::CallingConv::C, sideEffect, extraFnAttrs);
+  } else {
+    callOp = builder.createCallOp(callLoc, directFuncOp, CIRCallArgs, callingConv,
+                                   sideEffect, extraFnAttrs);
   }
-  return builder.createCallOp(callLoc, directFuncOp, CIRCallArgs, callingConv,
-                              sideEffect, extraFnAttrs);
+  if (cannotThrow)
+    callOp->setAttr("nothrow", builder.getUnitAttr());
+  return callOp;
 }
 
 static RValue getRValueThroughMemory(mlir::Location loc,
@@ -601,12 +607,10 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
     CannotThrow = true;
   } else {
     // Otherwise, nounwind call sites will never throw.
-    auto noThrowAttr = cir::NoThrowAttr::get(&getMLIRContext());
-    CannotThrow = Attrs.getNamed(noThrowAttr.getMnemonic()).has_value();
+    CannotThrow = Attrs.getNamed("nothrow").has_value();
 
     if (auto fptr = dyn_cast<cir::FuncOp>(CalleePtr))
-      if (fptr.getExtraAttrs().getElements().contains(
-              noThrowAttr.getMnemonic()))
+      if (fptr.getNothrow())
         CannotThrow = true;
   }
   bool isInvoke = CannotThrow ? false : isInvokeDest();
@@ -650,7 +654,7 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
 
     cir::CIRCallOpInterface callLikeOp = emitCallLikeOp(
         *this, callLoc, indirectFuncTy, indirectFuncVal, directFuncOp,
-        CIRCallArgs, isInvoke, callingConv, sideEffect, extraFnAttrs);
+        CIRCallArgs, isInvoke, callingConv, sideEffect, extraFnAttrs, CannotThrow);
 
     if (E)
       callLikeOp->setAttr("ast",
@@ -1462,8 +1466,8 @@ static void getTrivialDefaultFunctionAttributes(
     llvm_unreachable("NYI");
   if (langOpts.OpenCL ||
       ((langOpts.CUDA || langOpts.HIP) && langOpts.CUDAIsDevice)) {
-    auto noThrow = cir::NoThrowAttr::get(CGM.getBuilder().getContext());
-    funcAttrs.set(noThrow.getMnemonic(), noThrow);
+    auto noThrow = mlir::UnitAttr::get(CGM.getBuilder().getContext());
+    funcAttrs.set("nothrow", noThrow);
   }
 }
 

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -683,11 +683,7 @@ static void tryMarkNoThrow(CIRGenFunction &cgf, cir::FuncOp fn) {
   if (isInterposable(fn) || cgf.mayThrow)
     return;
 
-  mlir::NamedAttrList extraAttrs{fn.getExtraAttrs().getElements().getValue()};
-  auto noThrowAttr = cir::NoThrowAttr::get(&cgf.getMLIRContext());
-  extraAttrs.set(noThrowAttr.getMnemonic(), noThrowAttr);
-  fn.setExtraAttrsAttr(cir::ExtraFuncAttributesAttr::get(
-      extraAttrs.getDictionary(&cgf.getMLIRContext())));
+  fn.setNothrow(true);
 }
 
 cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn,

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -2873,8 +2873,7 @@ void CIRGenModule::setCIRFunctionAttributesForDefinition(const Decl *decl,
     llvm_unreachable("NYI");
 
   if (!hasUnwindExceptions(getLangOpts())) {
-    auto attr = cir::NoThrowAttr::get(&getMLIRContext());
-    attrs.set(attr.getMnemonic(), attr);
+    f.setNothrow(true);
   }
 
   assert(!MissingFeatures::stackProtector());
@@ -3052,6 +3051,21 @@ void CIRGenModule::setCIRFunctionAttributes(GlobalDecl gd,
   func.setExtraAttrsAttr(
       cir::ExtraFuncAttributesAttr::get(pal.getDictionary(&getMLIRContext())));
 
+  // Set nothrow as a direct attribute if the function declaration has it or
+  // if the function type is nothrow.
+  const Decl *TargetDecl = gd.getDecl();
+  if (TargetDecl && TargetDecl->hasAttr<NoThrowAttr>()) {
+    func.setNothrow(true);
+  } else if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
+    if (const FunctionProtoType *FPT =
+            Fn->getType()->getAs<FunctionProtoType>()) {
+      if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
+          FPT->isNothrow()) {
+        func.setNothrow(true);
+      }
+    }
+  }
+
   // TODO(cir): Check X86_VectorCall incompatibility with WinARM64EC
 
   func.setCallingConv(callingConv);

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

@@ -2641,6 +2641,7 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
   auto noProtoNameAttr = getNoProtoAttrName(state.name);
   auto visibilityNameAttr = getGlobalVisibilityAttrName(state.name);
   auto dsoLocalNameAttr = getDsoLocalAttrName(state.name);
+  auto nothrowNameAttr = getNothrowAttrName(state.name);
   auto annotationsNameAttr = getAnnotationsAttrName(state.name);
   auto cxxSpecialMemberAttr = getCxxSpecialMemberAttrName(state.name);
   if (::mlir::succeeded(parser.parseOptionalKeyword(builtinNameAttr.strref())))
@@ -2676,6 +2677,8 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
 
   if (parser.parseOptionalKeyword(dsoLocalNameAttr).succeeded())
     state.addAttribute(dsoLocalNameAttr, parser.getBuilder().getUnitAttr());
+  if (parser.parseOptionalKeyword(nothrowNameAttr).succeeded())
+    state.addAttribute(nothrowNameAttr, parser.getBuilder().getUnitAttr());
 
   StringAttr nameAttr;
   llvm::SmallVector<OpAsmParser::Argument, 8> arguments;
@@ -2907,6 +2910,9 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
   if (getDsoLocal())
     p << " dso_local";
 
+  if (getNothrow())
+    p << " nothrow";
+
   // Print function name, signature, and control.
   p << ' ';
   p.printSymbolName(getSymName());
@@ -2932,7 +2938,7 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
       p, *this,
       // These are all omitted since they are custom printed already.
       {getAliaseeAttrName(), getBuiltinAttrName(), getCoroutineAttrName(),
-       getDsoLocalAttrName(), getExtraAttrsAttrName(),
+       getDsoLocalAttrName(), getNothrowAttrName(), getExtraAttrsAttrName(),
        getFunctionTypeAttrName(), getGlobalCtorPriorityAttrName(),
        getGlobalDtorPriorityAttrName(), getLambdaAttrName(),
        getLinkageAttrName(), getCallingConvAttrName(), getNoProtoAttrName(),

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -2493,6 +2493,10 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewrite(
                                            llvmFnTy, linkage, isDsoLocal, cconv,
                                            mlir::SymbolRefAttr(), attributes);
 
+  if (op.getNothrow()) {
+    fn.setNoUnwind(true);
+  }
+
   // Lower CIR attributes for arguments.
   for (unsigned index = 0; index < fnType.getNumInputs(); index++) {
     mlir::DictionaryAttr cirAttrs = op.getArgAttrDict(index);

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMIR.cpp

@@ -112,8 +112,6 @@ class CIRDialectLLVMIRTranslationInterface
             llvm_unreachable("Unknown inline kind");
         } else if (mlir::dyn_cast<cir::OptNoneAttr>(attr.getValue())) {
           llvmFunc->addFnAttr(llvm::Attribute::OptimizeNone);
-        } else if (mlir::dyn_cast<cir::NoThrowAttr>(attr.getValue())) {
-          llvmFunc->addFnAttr(llvm::Attribute::NoUnwind);
         } else if (mlir::dyn_cast<cir::ConvergentAttr>(attr.getValue())) {
           llvmFunc->addFnAttr(llvm::Attribute::Convergent);
         } else if (mlir::isa<cir::HotAttr>(attr.getValue())) {

clang/test/CIR/CodeGen/OpenCL/nothrow.cl

@@ -5,18 +5,16 @@
 
 // CIR-LABEL: #fn_attr =
 // CIR: cl.kernel = #cir.cl.kernel
-// CIR: nothrow = #cir.nothrow
 
 // CIR-LABEL: #fn_attr1 =
 // CIR-NOT: cl.kernel = #cir.cl.kernel
-// CIR: nothrow = #cir.nothrow
 
 kernel void ker() {};
-// CIR: cir.func @ker{{.*}} extra(#fn_attr) {
+// CIR: cir.func nothrow @ker{{.*}} extra(#fn_attr) {
 // LLVM: define{{.*}}@ker(){{.*}} #0
 
 void foo() {};
-// CIR: cir.func @foo{{.*}} extra(#fn_attr1) {
+// CIR: cir.func nothrow @foo{{.*}} extra(#fn_attr1) {
 // LLVM: define{{.*}}@foo(){{.*}} #1
 
 // LLVM-LABEL: attributes #0

clang/test/CIR/CodeGen/call-extra-attrs.cpp

@@ -18,12 +18,10 @@ int s2(int a, int b) {
   return s1(a, b);
 }
 
-// CIR: #fn_attr = #cir<extra({inline = #cir.inline<no>, nothrow = #cir.nothrow, optnone = #cir.optnone})>
-// CIR: #fn_attr1 = #cir<extra({nothrow = #cir.nothrow})>
+// CIR: #fn_attr = #cir<extra({inline = #cir.inline<no>, optnone = #cir.optnone})>
 
 // CIR: cir.func {{.*}} @_Z2s0ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
 // CIR: cir.func {{.*}} @_Z2s1ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
-// CIR: cir.call @_Z2s0ii(%{{.*}}, %{{.*}}) : ({{.*}}, {{.*}}) -> {{.*}} extra(#fn_attr1)
 // CIR: cir.func {{.*}} @_Z2s2ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
 // CHECK-NOT: cir.call @_Z2s1ii(%{{.*}}, %{{.*}}) : ({{.*}}, {{.*}}) -> {{.*}} extra(#fn_attr{{.*}})