[CIR] Make optnone explicit function attribute (#2036)

xlauko · web-flow · commit 4088ded2e870 · 2025-12-02T14:55:39.000-08:00
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -1205,10 +1205,6 @@ def CIR_InlineKind : CIR_I32EnumAttr<"InlineKind", "inlineKind", [
 // Unit Function Attributes
 //===----------------------------------------------------------------------===//
 
-def CIR_OptNoneAttr : CIR_UnitAttr<"OptNone", "optnone"> {
-  let storageType = [{ OptNoneAttr }];
-}
-
 def CIR_NoThrowAttr : CIR_UnitAttr<"NoThrow", "nothrow"> {
   let storageType = [{ NoThrowAttr }];
 }
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -4104,6 +4104,7 @@ def FuncOp : CIR_Op<"func", [
     OptionalAttr<CIR_InlineKind>:$inline_kind,
     UnitAttr:$lambda,
     UnitAttr:$no_proto,
+    UnitAttr:$opt_none,
     UnitAttr:$dso_local,
     DefaultValuedAttr<
       CIR_GlobalLinkageKind, "GlobalLinkageKind::ExternalLinkage"
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -2932,8 +2932,7 @@ void CIRGenModule::setCIRFunctionAttributesForDefinition(const Decl *decl,
   } else if ((shouldAddOptNone || decl->hasAttr<OptimizeNoneAttr>()) &&
              !isAlwaysInline) {
     // Add optnone, but do so only if the function isn't always_inline.
-    auto optNoneAttr = cir::OptNoneAttr::get(&getMLIRContext());
-    attrs.set(optNoneAttr.getMnemonic(), optNoneAttr);
+    f.setOptNone(true);
 
     // OptimizeNone implies noinline; we should not be inlining such functions.
     f.setInlineKind(cir::InlineKind::NoInline);
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -2686,6 +2686,7 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
   auto lambdaNameAttr = getLambdaAttrName(state.name);
   auto visNameAttr = getSymVisibilityAttrName(state.name);
   auto noProtoNameAttr = getNoProtoAttrName(state.name);
+  auto optNoneNameAttr = getOptNoneAttrName(state.name);
   auto visibilityNameAttr = getGlobalVisibilityAttrName(state.name);
   auto dsoLocalNameAttr = getDsoLocalAttrName(state.name);
   auto annotationsNameAttr = getAnnotationsAttrName(state.name);
@@ -2707,6 +2708,8 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
     state.addAttribute(lambdaNameAttr, parser.getBuilder().getUnitAttr());
   if (parser.parseOptionalKeyword(noProtoNameAttr).succeeded())
     state.addAttribute(noProtoNameAttr, parser.getBuilder().getUnitAttr());
+  if (parser.parseOptionalKeyword("optnone").succeeded())
+    state.addAttribute(optNoneNameAttr, parser.getBuilder().getUnitAttr());
 
   // TODO: Missing comdat
   assert(!cir::MissingFeatures::setComdat());
@@ -2945,6 +2948,9 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
   if (getNoProto())
     p << " no_proto";
 
+  if (getOptNone())
+    p << " optnone";
+
   if (getComdat())
     p << " comdat";
 
@@ -3001,6 +3007,7 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
        getLinkageAttrName(),
        getCallingConvAttrName(),
        getNoProtoAttrName(),
+       getOptNoneAttrName(),
        getSymVisibilityAttrName(),
        getArgAttrsAttrName(),
        getResAttrsAttrName(),
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -2369,6 +2369,7 @@ void CIRToLLVMFuncOpLowering::lowerFuncAttributes(
         name == func.getFunctionTypeAttrName() ||
         name == getLinkageAttrNameString() ||
         name == func.getCallingConvAttrName() ||
+        name == func.getOptNoneAttrName() ||
         name == func.getDsoLocalAttrName() ||
         name == func.getInlineKindAttrName() ||
         (filterArgAndResAttrs && (name == func.getArgAttrsAttrName() ||
@@ -2494,20 +2495,13 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewrite(
                                            mlir::SymbolRefAttr(), attributes);
 
   if (std::optional<cir::InlineKind> inlineKind = op.getInlineKind()) {
-    switch (*inlineKind) {
-    case cir::InlineKind::NoInline:
-      fn.setNoInline(true);
-      break;
-    case cir::InlineKind::AlwaysInline:
-      fn.setAlwaysInline(true);
-      break;
-    case cir::InlineKind::InlineHint:
-      fn.setInlineHint(true);
-      break;
-    default:
-      llvm_unreachable("Unknown inline kind");
-    }
+    fn.setNoInline(*inlineKind == cir::InlineKind::NoInline);
+    fn.setInlineHint(*inlineKind == cir::InlineKind::InlineHint);
+    fn.setAlwaysInline(*inlineKind == cir::InlineKind::AlwaysInline);
   }
+
+  fn.setOptimizeNone(op.getOptNone());
+
   // Lower CIR attributes for arguments.
   for (unsigned index = 0; index < fnType.getNumInputs(); index++) {
     mlir::DictionaryAttr cirAttrs = op.getArgAttrDict(index);
@@ -2540,6 +2534,9 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewrite(
       getContext(), lowerCIRVisibilityToLLVMVisibility(
                         op.getGlobalVisibilityAttr().getValue())));
 
+  // Handle optnone attribute
+  fn.setOptimizeNone(op.getOptNone());
+
   rewriter.inlineRegionBefore(op.getBody(), fn.getBody(), fn.end());
   if (failed(rewriter.convertRegionTypes(&fn.getBody(), *typeConverter,
                                          &signatureConversion)))
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMIR.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMIR.cpp
@@ -100,9 +100,7 @@ class CIRDialectLLVMIRTranslationInterface
     if (auto extraAttr = mlir::dyn_cast<cir::ExtraFuncAttributesAttr>(
             attribute.getValue())) {
       for (auto attr : extraAttr.getElements()) {
-        if (mlir::dyn_cast<cir::OptNoneAttr>(attr.getValue())) {
-          llvmFunc->addFnAttr(llvm::Attribute::OptimizeNone);
-        } else if (mlir::dyn_cast<cir::NoThrowAttr>(attr.getValue())) {
+        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);
diff --git a/clang/test/CIR/CodeGen/call-extra-attrs.cpp b/clang/test/CIR/CodeGen/call-extra-attrs.cpp
@@ -18,14 +18,13 @@ int s2(int a, int b) {
   return s1(a, b);
 }
 
-// CIR: #fn_attr = #cir<extra({nothrow = #cir.nothrow, optnone = #cir.optnone})>
-// CIR: #fn_attr1 = #cir<extra({nothrow = #cir.nothrow})>
+// CIR: #fn_attr = #cir<extra({nothrow = #cir.nothrow})>
 
-// CIR: cir.func{{.*}} no_inline {{.*}} @_Z2s0ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
-// CIR: cir.func{{.*}} no_inline {{.*}} @_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{{.*}})
+// CIR: cir.func{{.*}} no_inline optnone {{.*}} @_Z2s0ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
+// CIR: cir.func{{.*}} no_inline optnone {{.*}} @_Z2s1ii(%{{.*}}, %{{.*}}) -> {{.*}} extra(#fn_attr)
+// CIR: cir.call @_Z2s0ii(%{{.*}}, %{{.*}}) : ({{.*}}, {{.*}}) -> {{.*}} extra(#fn_attr)
+// CIR: cir.func {{.*}} optnone {{.*}} @_Z2s2ii(%{{.*}}, %{{.*}}) -> {{.*}}
+// CHECK-NOT: cir.call @_Z2s1ii(%{{.*}}, %{{.*}}) : ({{.*}}, {{.*}}) -> {{.*}} extra(#fn_attr)
 
 // LLVM: define dso_local i32 @_Z2s0ii(i32 %0, i32 %1) #[[#ATTR1:]]
 // LLVM: define dso_local i32 @_Z2s1ii(i32 %0, i32 %1) #[[#ATTR1:]]
diff --git a/clang/test/CIR/CodeGen/dynamic-cast.mlir b/clang/test/CIR/CodeGen/dynamic-cast.mlir
@@ -21,7 +21,7 @@ module @"/Users/henrichlauko/src/clangir/clang/test/CIR/CodeGen/dynamic-cast.cpp
   cir.global constant external @_ZTI7Derived = #cir.typeinfo<{#cir.global_view<@_ZTVN10__cxxabiv120__si_class_type_infoE, [2 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTS7Derived> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>}> : !rec_anon_struct {alignment = 8 : i64} loc(#loc28)
   cir.func private @__dynamic_cast(!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> loc(#loc)
   cir.func private @__cxa_bad_cast() loc(#loc)
-  cir.func no_inline dso_local @_Z8ptr_castP4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc5, #loc6])) -> !cir.ptr<!rec_Derived> {nothrow = #cir.nothrow, optnone = #cir.optnone} {
+  cir.func no_inline dso_local optnone @_Z8ptr_castP4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc5, #loc6])) -> !cir.ptr<!rec_Derived> {nothrow = #cir.nothrow} {
     %0 = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["b", init] {alignment = 8 : i64} loc(#loc30)
     %1 = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["__retval"] {alignment = 8 : i64} loc(#loc4)
     cir.store %arg0, %0 : !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>> loc(#loc7)
@@ -43,7 +43,7 @@ module @"/Users/henrichlauko/src/clangir/clang/test/CIR/CodeGen/dynamic-cast.cpp
     %5 = cir.load %1 : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived> loc(#loc31)
     cir.return %5 : !cir.ptr<!rec_Derived> loc(#loc31)
   } loc(#loc29)
-  cir.func no_inline dso_local @_Z8ref_castR4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc12, #loc13])) -> !cir.ptr<!rec_Derived> {nothrow = #cir.nothrow, optnone = #cir.optnone} {
+  cir.func no_inline dso_local optnone @_Z8ref_castR4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc12, #loc13])) -> !cir.ptr<!rec_Derived> {nothrow = #cir.nothrow} {
     %0 = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["b", init, const] {alignment = 8 : i64} loc(#loc33)
     %1 = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["__retval"] {alignment = 8 : i64} loc(#loc11)
     cir.store %arg0, %0 : !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>> loc(#loc14)
@@ -64,7 +64,7 @@ module @"/Users/henrichlauko/src/clangir/clang/test/CIR/CodeGen/dynamic-cast.cpp
     %11 = cir.load %1 : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived> loc(#loc35)
     cir.return %11 : !cir.ptr<!rec_Derived> loc(#loc35)
   } loc(#loc32)
-  cir.func no_inline dso_local @_Z20ptr_cast_to_completeP4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc21, #loc22])) -> !cir.ptr<!void> {nothrow = #cir.nothrow, optnone = #cir.optnone} {
+  cir.func no_inline dso_local optnone @_Z20ptr_cast_to_completeP4Base(%arg0: !cir.ptr<!rec_Base> loc(fused[#loc21, #loc22])) -> !cir.ptr<!void> {nothrow = #cir.nothrow} {
     %0 = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["ptr", init] {alignment = 8 : i64} loc(#loc37)
     %1 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"] {alignment = 8 : i64} loc(#loc20)
     cir.store %arg0, %0 : !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>> loc(#loc23)
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
@@ -15,7 +15,7 @@ void fn() {
 //      CHECK-DAG: !rec_anon2E8 = !cir.record<class "anon.8" {!cir.ptr<!rec_A>}>
 //  CHECK-DAG: module
 
-//      CHECK: cir.func no_inline lambda internal private dso_local @_ZZ2fnvENK3$_0clEv{{.*}})
+//      CHECK: cir.func no_inline lambda optnone internal private dso_local @_ZZ2fnvENK3$_0clEv{{.*}})
 
 //      CHECK:   cir.func {{.*}} @_Z2fnv()
 // CHECK-NEXT:     %0 = cir.alloca !rec_anon2E0, !cir.ptr<!rec_anon2E0>, ["a"]
@@ -41,7 +41,7 @@ void l0() {
   a();
 }
 
-// CHECK: cir.func no_inline lambda internal private dso_local @_ZZ2l0vENK3$_0clEv({{.*}})
+// CHECK: cir.func no_inline lambda optnone internal private dso_local @_ZZ2l0vENK3$_0clEv({{.*}})
 
 // CHECK: %0 = cir.alloca !cir.ptr<!rec_anon2E2>, !cir.ptr<!cir.ptr<!rec_anon2E2>>, ["this", init] {alignment = 8 : i64}
 // CHECK: cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_anon2E2>, !cir.ptr<!cir.ptr<!rec_anon2E2>>
@@ -197,13 +197,13 @@ int g3() {
 }
 
 // lambda operator()
-// CHECK: cir.func no_inline lambda internal private dso_local @_ZZ2g3vENK3$_0clERKi{{.*}}!s32i extra
+// CHECK: cir.func no_inline lambda optnone internal private dso_local @_ZZ2g3vENK3$_0clERKi{{.*}}!s32i extra
 
 // lambda __invoke()
-// CHECK:   cir.func no_inline internal private dso_local @_ZZ2g3vEN3$_08__invokeERKi
+// CHECK:   cir.func no_inline optnone internal private dso_local @_ZZ2g3vEN3$_08__invokeERKi
 
 // lambda operator int (*)(int const&)()
-// CHECK:   cir.func no_inline internal private dso_local @_ZZ2g3vENK3$_0cvPFiRKiEEv
+// CHECK:   cir.func no_inline optnone internal private dso_local @_ZZ2g3vENK3$_0cvPFiRKiEEv
 
 // CHECK-LABEL: @_Z2g3v()
 // CHECK:     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
diff --git a/clang/test/CIR/CodeGen/linkage.c b/clang/test/CIR/CodeGen/linkage.c
@@ -14,7 +14,7 @@ int foo(void) {
   return bar(5);
 }
 
-// CIR-O0:   cir.func no_inline internal private {{.*}} @bar
+// CIR-O0:   cir.func no_inline optnone internal private {{.*}} @bar
 // CIR-O1:   cir.func internal private {{.*}} @bar
 // CIR:      cir.func {{.*}} @foo
 
diff --git a/clang/test/CIR/CodeGen/optnone.cpp b/clang/test/CIR/CodeGen/optnone.cpp
@@ -17,10 +17,10 @@ int s0(int a, int b) {
   return x;
 }
 
-// CIR-O0: #fn_attr = #cir<extra({nothrow = #cir.nothrow, optnone = #cir.optnone})>
-// CIR-O0:   cir.func {{.*}} @_Z2s0ii(%arg0:{{.*}}, %arg1:{{.*}} -> {{.*}} extra(#fn_attr)
+// CIR-O0: #fn_attr = #cir<extra({nothrow = #cir.nothrow})>
+// CIR-O0:   cir.func {{.*}} optnone {{.*}} @_Z2s0ii(%arg0:{{.*}}, %arg1:{{.*}} -> {{.*}} extra(#fn_attr)
 
-// CIR-O2-NOT: #fn_attr ={{.*}} optnone
+// CIR-O2-NOT: cir.func optnone
 
 // LLVM-O0: define dso_local i32 @_Z2s0ii(i32 %0, i32 %1) #[[#ATTR:]]
 // LLVM-O0: attributes #[[#ATTR]] = { noinline nounwind optnone }
diff --git a/clang/test/CIR/CodeGen/temporaries.cpp b/clang/test/CIR/CodeGen/temporaries.cpp
@@ -17,7 +17,7 @@ void f() {
 //      CIR: cir.func private @_ZN1EC1Ev(!cir.ptr<!rec_E>) special_member<#cir.cxx_ctor<!rec_E, default>> extra(#fn_attr)
 // CIR-NEXT: cir.func private @_ZN1EntEv(!cir.ptr<!rec_E>) -> !rec_E
 // CIR-NEXT: cir.func private @_ZN1ED1Ev(!cir.ptr<!rec_E>) special_member<#cir.cxx_dtor<!rec_E>> extra(#fn_attr)
-// CIR-NEXT: cir.func {{.*}} @_Z1fv() extra(#fn_attr1) {
+// CIR-NEXT: cir.func {{.*}} @_Z1fv() {{.*}} {
 // CIR-NEXT:   cir.scope {
 // CIR-NEXT:     %[[ONE:[0-9]+]] = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["agg.tmp.ensured"] {alignment = 1 : i64}
 // CIR-NEXT:     %[[TWO:[0-9]+]] = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["ref.tmp0"] {alignment = 1 : i64}
diff --git a/clang/test/CIR/IR/call.cir b/clang/test/CIR/IR/call.cir
@@ -3,26 +3,25 @@
 !s32i = !cir.int<s, 32>
 !fnptr = !cir.ptr<!cir.func<(!s32i) -> !s32i>>
 
-#fn_attr = #cir<extra({ptnone = #cir.optnone})>
-#fn_attr1 = #cir<extra({nothrow = #cir.nothrow})>
+#fn_attr = #cir<extra({nothrow = #cir.nothrow})>
 
 module {
   // Excerpt of std::array<int, 8192ul>::operator[](unsigned long)
-  cir.func no_inline linkonce_odr @_ZNSt5arrayIiLm8192EEixEm(%arg0: !s32i) -> !s32i extra(#fn_attr) {
+  cir.func no_inline optnone linkonce_odr @_ZNSt5arrayIiLm8192EEixEm(%arg0: !s32i) -> !s32i {
     cir.return %arg0 : !s32i
   }
 
-  cir.func private @my_add(%a: !s32i, %b: !s32i) -> !s32i cc(spir_function) extra(#fn_attr)
+  cir.func optnone private @my_add(%a: !s32i, %b: !s32i) -> !s32i cc(spir_function)
 
   cir.func @ind(%fnptr: !fnptr, %a : !s32i) {
     %r = cir.call %fnptr(%a) : (!fnptr, !s32i) -> !s32i
 // CHECK: %0 = cir.call %arg0(%arg1) : (!cir.ptr<!cir.func<(!s32i) -> !s32i>>, !s32i) -> !s32i
     // Check parse->pretty-print round-trip on extra() attribute
-    %7 = cir.call @_ZNSt5arrayIiLm8192EEixEm(%a) : (!s32i) -> !s32i extra(#fn_attr1)
-// CHECK: %1 = cir.call @_ZNSt5arrayIiLm8192EEixEm(%arg1) : (!s32i) -> !s32i extra(#fn_attr1)
+    %7 = cir.call @_ZNSt5arrayIiLm8192EEixEm(%a) : (!s32i) -> !s32i extra(#fn_attr)
+// CHECK: %1 = cir.call @_ZNSt5arrayIiLm8192EEixEm(%arg1) : (!s32i) -> !s32i extra(#fn_attr)
     // Frankenstein's example from clang/test/CIR/Lowering/call-op-call-conv.cir
-    %3 = cir.try_call @my_add(%r, %7) ^continue, ^landing_pad : (!s32i, !s32i) -> !s32i cc(spir_function) extra(#fn_attr1)
-// CHECK: %2 = cir.try_call @my_add(%0, %1) ^bb1, ^bb2 : (!s32i, !s32i) -> !s32i cc(spir_function) extra(#fn_attr1)
+    %3 = cir.try_call @my_add(%r, %7) ^continue, ^landing_pad : (!s32i, !s32i) -> !s32i cc(spir_function) extra(#fn_attr)
+// CHECK: %2 = cir.try_call @my_add(%0, %1) ^bb1, ^bb2 : (!s32i, !s32i) -> !s32i cc(spir_function) extra(#fn_attr)
   ^continue:
     cir.br ^landing_pad
   ^landing_pad:
diff --git a/clang/test/CIR/IR/func-dsolocal-parser.cir b/clang/test/CIR/IR/func-dsolocal-parser.cir
@@ -1,9 +1,9 @@
 // RUN: cir-opt %s --verify-roundtrip | FileCheck %s
 
 !s32i = !cir.int<s, 32>
-#fn_attr = #cir<extra({nothrow = #cir.nothrow, optnone = #cir.optnone})>
+#fn_attr = #cir<extra({nothrow = #cir.nothrow})>
 module {
-    cir.func no_inline dso_local @foo(%arg0: !s32i ) extra(#fn_attr) {
+    cir.func no_inline optnone dso_local @foo(%arg0: !s32i ) extra(#fn_attr) {
         %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
         cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
         cir.return
diff --git a/clang/test/CIR/Lowering/brcond.cir b/clang/test/CIR/Lowering/brcond.cir
@@ -2,9 +2,9 @@
 // RUN: cir-translate %s -cir-to-llvmir --disable-cc-lowering | FileCheck %s -check-prefix=LLVM
 
 !s32i = !cir.int<s, 32>
-#fn_attr = #cir<extra({nothrow = #cir.nothrow, optnone = #cir.optnone})>
+#fn_attr = #cir<extra({nothrow = #cir.nothrow})>
 module { 
-  cir.func no_inline no_proto @test() -> !cir.bool extra(#fn_attr) {
+  cir.func no_inline no_proto optnone @test() -> !cir.bool extra(#fn_attr) {
     %0 = cir.const #cir.int<0> : !s32i
     %1 = cir.cast int_to_bool %0 : !s32i -> !cir.bool
     cir.br ^bb1
diff --git a/clang/test/CIR/Lowering/syncscope.cir b/clang/test/CIR/Lowering/syncscope.cir
@@ -1,9 +1,9 @@
 // RUN: cir-translate %s -cir-to-llvmir --disable-cc-lowering -o -  | FileCheck %s -check-prefix=LLVM
 
 !s32i = !cir.int<s, 32>
-#fn_attr = #cir<extra({nothrow = #cir.nothrow, optnone = #cir.optnone})>
+#fn_attr = #cir<extra({nothrow = #cir.nothrow})>
 module {
-  cir.func no_inline @test(%ptr: !cir.ptr<!s32i>, %expected: !s32i, %desired: !s32i) -> !cir.bool extra(#fn_attr) {
+  cir.func no_inline optnone @test(%ptr: !cir.ptr<!s32i>, %expected: !s32i, %desired: !s32i) -> !cir.bool extra(#fn_attr) {
     %old, %cmp = cir.atomic.cmp_xchg(%ptr : !cir.ptr<!s32i>, %expected : !s32i, %desired : !s32i, success = acquire, failure = acquire) syncscope(single_thread) align(4) : (!s32i, !cir.bool)
     cir.return %cmp: !cir.bool
   }

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ int foo(void) {`
`14`	`14`	`return bar(5);`
`15`	`15`	`}`
`16`	`16`
`17`		`-// CIR-O0: cir.func no_inline internal private {{.*}} @bar`
	`17`	`+// CIR-O0: cir.func no_inline optnone internal private {{.*}} @bar`
`18`	`18`	`// CIR-O1: cir.func internal private {{.*}} @bar`
`19`	`19`	`// CIR: cir.func {{.*}} @foo`
`20`	`20`