[clang] 8f64d44 - [CIR] Apply 'side-effect' attribute logic to the function as well. (#177242)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Jan 26 06:08:47 PST 2026
Author: Erich Keane
Date: 2026-01-26T06:08:42-08:00
New Revision: 8f64d44ab4df06f9613152a5187615672f8d5359
URL: https://github.com/llvm/llvm-project/commit/8f64d44ab4df06f9613152a5187615672f8d5359
DIFF: https://github.com/llvm/llvm-project/commit/8f64d44ab4df06f9613152a5187615672f8d5359.diff
LOG: [CIR] Apply 'side-effect' attribute logic to the function as well. (#177242)
Previous efforts in both the incubator and upstreamed added the 'pure'
and 'const' attribute lowering to calls. This patch completes that
effort by making it also appear on functions with this attribute.
Added:
clang/test/CIR/CodeGen/side-effect.cpp
Modified:
clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
clang/include/clang/CIR/Dialect/IR/CIROps.td
clang/lib/CIR/CodeGen/CIRGenModule.cpp
clang/lib/CIR/Dialect/IR/CIRDialect.cpp
clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
index 9447ae629b445..d7938bc350925 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -1253,4 +1253,38 @@ def CIR_BlockAddrInfoAttr : CIR_Attr<"BlockAddrInfo", "block_addr_info"> {
];
}
+//===----------------------------------------------------------------------===//
+// Side Effect
+//===----------------------------------------------------------------------===//
+
+def CIR_SideEffect : CIR_I32EnumAttr<
+ "SideEffect", "allowed side effects of a function", [
+ I32EnumAttrCase<"All", 0, "all">,
+ I32EnumAttrCase<"Pure", 1, "pure">,
+ I32EnumAttrCase<"Const", 2, "const">
+]> {
+ let description = [{
+ The side effect attribute specifies the possible side effects of a function
+ or the target of a call operation. This is an enumeration attribute with
+ the following possible values:
+
+ - all: The function or callee can have any side effects. This is the default
+ if no side effects are explicitly listed.
+ - pure: The function or callee may read data from memory, but it cannot
+ write data to memory. This has the same effect as the GNU C/C++ attribute
+ `__attribute__((pure))`.
+ - const: The function or callee may not read or write data from memory. This
+ has the same effect as the GNU C/C++ attribute `__attribute__((const))`.
+
+ Examples:
+
+ ```mlir
+ %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i
+ %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i side_effect(pure)
+ %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i side_effect(const)
+ ```
+ }];
+}
+
+
#endif // CLANG_CIR_DIALECT_IR_CIRATTRS_TD
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index fe35ab305f4ba..a6de91b2eda01 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -2941,7 +2941,7 @@ def CIR_FuncOp : CIR_Op<"func", [
```
}];
- let arguments = (ins
+ let arguments = (ins
SymbolNameAttr:$sym_name,
CIR_VisibilityAttr:$global_visibility,
TypeAttrOf<CIR_FuncType>:$function_type,
@@ -2960,6 +2960,7 @@ def CIR_FuncOp : CIR_Op<"func", [
OptionalAttr<DictArrayAttr>:$arg_attrs,
OptionalAttr<DictArrayAttr>:$res_attrs,
OptionalAttr<FlatSymbolRefAttr>:$aliasee,
+ OptionalAttr<CIR_SideEffect>:$side_effect,
OptionalAttr<FlatSymbolRefAttr>:$personality,
CIR_OptionalPriorityAttr:$global_ctor_priority,
CIR_OptionalPriorityAttr:$global_dtor_priority,
@@ -3086,35 +3087,6 @@ def CIR_LLVMIntrinsicCallOp : CIR_Op<"call_llvm_intrinsic"> {
// CallOp and TryCallOp
//===----------------------------------------------------------------------===//
-def CIR_SideEffect : CIR_I32EnumAttr<
- "SideEffect", "allowed side effects of a function", [
- I32EnumAttrCase<"All", 0, "all">,
- I32EnumAttrCase<"Pure", 1, "pure">,
- I32EnumAttrCase<"Const", 2, "const">
-]> {
- let description = [{
- The side effect attribute specifies the possible side effects of the callee
- of a call operation. This is an enumeration attribute and all possible
- enumerators are:
-
- - all: The callee can have any side effects. This is the default if no side
- effects are explicitly listed.
- - pure: The callee may read data from memory, but it cannot write data to
- memory. This has the same effect as the GNU C/C++ attribute
- `__attribute__((pure))`.
- - const: The callee may not read or write data from memory. This has the
- same effect as the GNU C/C++ attribute `__attribute__((const))`.
-
- Examples:
-
- ```mlir
- %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i
- %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i side_effect(pure)
- %2 = cir.call @add(%0, %1) : (!s32i, !s32i) -> !s32i side_effect(const)
- ```
- }];
-}
-
class CIR_CallOpBase<string mnemonic, list<Trait> extra_traits = []>
: CIR_Op<mnemonic, !listconcat(extra_traits, [
DeclareOpInterfaceMethods<CIRCallOpInterface>,
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index 5aa9ce02aa832..cf49f44f795b2 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -2143,8 +2143,9 @@ void CIRGenModule::setCIRFunctionAttributes(GlobalDecl globalDecl,
constructAttributeList(func.getName(), info, globalDecl, pal, callingConv,
sideEffect,
/*attrOnCallSite=*/false, isThunk);
- // TODO(cir): we need to set Extra Attrs here when that gets implemented.
- assert(!cir::MissingFeatures::opFuncExtraAttrs());
+
+ for (mlir::NamedAttribute attr : pal)
+ func->setAttr(attr.getName(), attr.getValue());
// TODO(cir): Check X86_VectorCall incompatibility wiht WinARM64EC
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index 7b9fc83403f71..9e8859f583142 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -2054,6 +2054,18 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
}).failed())
return failure();
+ if (parser.parseOptionalKeyword("side_effect").succeeded()) {
+ cir::SideEffect sideEffect;
+
+ if (parser.parseLParen().failed() ||
+ parseCIRKeyword<cir::SideEffect>(parser, sideEffect).failed() ||
+ parser.parseRParen().failed())
+ return failure();
+
+ auto attr = cir::SideEffectAttr::get(parser.getContext(), sideEffect);
+ state.addAttribute(CIRDialect::getSideEffectAttrName(), attr);
+ }
+
// Parse the rest of the attributes.
NamedAttrList parsedAttrs;
if (parser.parseOptionalAttrDictWithKeyword(parsedAttrs))
@@ -2225,6 +2237,13 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
p << "(" << globalDtorPriority.value() << ")";
}
+ if (std::optional<cir::SideEffect> sideEffect = getSideEffect();
+ sideEffect && *sideEffect != cir::SideEffect::All) {
+ p << " side_effect(";
+ p << stringifySideEffect(*sideEffect);
+ p << ")";
+ }
+
function_interface_impl::printFunctionAttributes(
p, *this, cir::FuncOp::getAttributeNames());
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index a774b0dcc6ba8..4877508b1c3da 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -2035,6 +2035,7 @@ void CIRToLLVMFuncOpLowering::lowerFuncAttributes(
attr.getName() == func.getGlobalVisibilityAttrName() ||
attr.getName() == func.getDsoLocalAttrName() ||
attr.getName() == func.getInlineKindAttrName() ||
+ attr.getName() == func.getSideEffectAttrName() ||
(filterArgAndResAttrs &&
(attr.getName() == func.getArgAttrsAttrName() ||
attr.getName() == func.getResAttrsAttrName())))
@@ -2119,6 +2120,37 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewrite(
assert(!cir::MissingFeatures::opFuncMultipleReturnVals());
+ if (std::optional<cir::SideEffect> sideEffectKind = op.getSideEffect()) {
+ switch (*sideEffectKind) {
+ case cir::SideEffect::All:
+ break;
+ case cir::SideEffect::Pure:
+ fn.setMemoryEffectsAttr(mlir::LLVM::MemoryEffectsAttr::get(
+ fn.getContext(),
+ /*other=*/mlir::LLVM::ModRefInfo::Ref,
+ /*argMem=*/mlir::LLVM::ModRefInfo::Ref,
+ /*inaccessibleMem=*/mlir::LLVM::ModRefInfo::Ref,
+ /*errnoMem=*/mlir::LLVM::ModRefInfo::Ref,
+ /*targetMem0=*/mlir::LLVM::ModRefInfo::Ref,
+ /*targetMem1=*/mlir::LLVM::ModRefInfo::Ref));
+ fn.setNoUnwind(true);
+ fn.setWillReturn(true);
+ break;
+ case cir::SideEffect::Const:
+ fn.setMemoryEffectsAttr(mlir::LLVM::MemoryEffectsAttr::get(
+ fn.getContext(),
+ /*other=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*argMem=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*inaccessibleMem=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*errnoMem=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*targetMem0=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*targetMem1=*/mlir::LLVM::ModRefInfo::NoModRef));
+ fn.setNoUnwind(true);
+ fn.setWillReturn(true);
+ break;
+ }
+ }
+
if (std::optional<cir::InlineKind> inlineKind = op.getInlineKind()) {
fn.setNoInline(*inlineKind == cir::InlineKind::NoInline);
fn.setInlineHint(*inlineKind == cir::InlineKind::InlineHint);
diff --git a/clang/test/CIR/CodeGen/side-effect.cpp b/clang/test/CIR/CodeGen/side-effect.cpp
new file mode 100644
index 0000000000000..870e8d8d58ed1
--- /dev/null
+++ b/clang/test/CIR/CodeGen/side-effect.cpp
@@ -0,0 +1,43 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG
+extern "C" {
+
+// FIXME: We should figure out how to better print this on functions in the
+// future.
+// CIR: cir.func{{.*}}@pure_func() -> !s32i side_effect(pure) {
+// LLVM: Function Attrs: {{.*}}nounwind{{.*}}willreturn{{.*}}memory(read)
+// LLVM: define{{.*}} @pure_func() #{{.*}} {
+// OGCG: Function Attrs: {{.*}}nounwind{{.*}}willreturn{{.*}}memory(read)
+// OGCG: define{{.*}} @pure_func() #{{.*}} {
+__attribute__((pure))
+int pure_func() { return 2;}
+
+// CIR: cir.func{{.*}}@const_func() -> !s32i side_effect(const) {
+// LLVM: Function Attrs: {{.*}}nounwind{{.*}}willreturn{{.*}}memory(none)
+// LLVM: define{{.*}} @const_func() #{{.*}} {
+// OGCG: Function Attrs: {{.*}}nounwind{{.*}}willreturn{{.*}}memory(none)
+// OGCG: define{{.*}} @const_func() #{{.*}} {
+__attribute__((const))
+int const_func() { return 1;}
+
+void use() {
+ // CIR: cir.call @pure_func() side_effect(pure) : () -> !s32i
+ // LLVM: call i32 @pure_func() #[[PURE_ATTR:.*]]
+ // OGCG: call i32 @pure_func() #[[PURE_ATTR:.*]]
+ pure_func();
+ // CIR: cir.call @const_func() side_effect(const) : () -> !s32i
+ // LLVM: call i32 @const_func() #[[CONST_ATTR:.*]]
+ // OGCG: call i32 @const_func() #[[CONST_ATTR:.*]]
+ const_func();
+}
+
+// LLVM: attributes #[[PURE_ATTR]] = {{{.*}}nounwind{{.*}}willreturn{{.*}}memory(read) }
+// OGCG: attributes #[[PURE_ATTR]] = {{{.*}}nounwind{{.*}}willreturn{{.*}}memory(read) }
+// LLVM: attributes #[[CONST_ATTR]] = {{{.*}}nounwind{{.*}}willreturn{{.*}}memory(none) }
+// OGCG: attributes #[[CONST_ATTR]] = {{{.*}}nounwind{{.*}}willreturn{{.*}}memory(none) }
+}
+
More information about the cfe-commits
mailing list