[clang] [CIR] Reformat Ops to use common `CIR_` prefix and definition traits style (PR #148865)
Henrich Lauko via cfe-commits
cfe-commits at lists.llvm.org
Tue Jul 15 08:17:20 PDT 2025
https://github.com/xlauko created https://github.com/llvm/llvm-project/pull/148865
- This adds common CIR_ prefix to all operation disambiguating them when used with other dialects.
- Unifies traits style in operation definitions.
This mirrors incubator changes from https://github.com/llvm/clangir/pull/1741
>From 9147993ba1014968d153f3b43ce48bd21879db06 Mon Sep 17 00:00:00 2001
From: xlauko <xlauko at mail.muni.cz>
Date: Tue, 15 Jul 2025 17:00:08 +0200
Subject: [PATCH] [CIR] Reformat Ops to use common `CIR_` prefix and definition
traits style
- This adds common CIR_ prefix to all operation disambiguating them when used with other dialects.
- Unifies traits style in operation definitions.
This mirrors incubator changes from https://github.com/llvm/clangir/pull/1741
---
clang/include/clang/CIR/Dialect/IR/CIROps.td | 321 +++++++++++--------
1 file changed, 179 insertions(+), 142 deletions(-)
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 676ff76dff661..2ce23dbb27ec6 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -159,9 +159,9 @@ def CIR_CastKind : CIR_I32EnumAttr<"CastKind", "cast kind", [
I32EnumAttrCase<"bool_to_float", 1000>,
]>;
-def CastOp : CIR_Op<"cast",
- [Pure,
- DeclareOpInterfaceMethods<PromotableOpInterface>]> {
+def CIR_CastOp : CIR_Op<"cast", [
+ Pure, DeclareOpInterfaceMethods<PromotableOpInterface>
+]> {
// FIXME: not all conversions are free of side effects.
let summary = "Conversion between values of different types";
let description = [{
@@ -225,8 +225,9 @@ def CastOp : CIR_Op<"cast",
// PtrStrideOp
//===----------------------------------------------------------------------===//
-def PtrStrideOp : CIR_Op<"ptr_stride",
- [Pure, AllTypesMatch<["base", "result"]>]> {
+def CIR_PtrStrideOp : CIR_Op<"ptr_stride", [
+ Pure, AllTypesMatch<["base", "result"]>
+]> {
let summary = "Pointer access with stride";
let description = [{
Given a base pointer as first operand, provides a new pointer after applying
@@ -262,8 +263,9 @@ def PtrStrideOp : CIR_Op<"ptr_stride",
// ConstantOp
//===----------------------------------------------------------------------===//
-def ConstantOp : CIR_Op<"const",
- [ConstantLike, Pure, AllTypesMatch<["value", "res"]>]> {
+def CIR_ConstantOp : CIR_Op<"const", [
+ ConstantLike, Pure, AllTypesMatch<["value", "res"]>
+]> {
let summary = "Defines a CIR constant";
let description = [{
The `cir.const` operation turns a literal into an SSA value. The data is
@@ -298,22 +300,23 @@ def ConstantOp : CIR_Op<"const",
// AllocaOp
//===----------------------------------------------------------------------===//
-class AllocaTypesMatchWith<string summary, string lhsArg, string rhsArg,
- string transform, string comparator = "std::equal_to<>()">
- : PredOpTrait<summary, CPred<
- comparator # "(" #
+class CIR_AllocaTypesMatchWith<
+ string summary, string lhsArg, string rhsArg, string transform,
+ string comparator = "std::equal_to<>()"
+> : PredOpTrait<summary, CPred<comparator # "(" #
!subst("$_self", "$" # lhsArg # ".getType()", transform) #
- ", $" # rhsArg # ")">> {
+ ", $" # rhsArg # ")">
+> {
string lhs = lhsArg;
string rhs = rhsArg;
string transformer = transform;
}
-def AllocaOp : CIR_Op<"alloca", [
- AllocaTypesMatchWith<"'allocaType' matches pointee type of 'addr'",
- "addr", "allocaType",
- "cast<PointerType>($_self).getPointee()">,
- DeclareOpInterfaceMethods<PromotableAllocationOpInterface>]> {
+def CIR_AllocaOp : CIR_Op<"alloca", [
+ CIR_AllocaTypesMatchWith<"'allocaType' matches pointee type of 'addr'",
+ "addr", "allocaType", "mlir::cast<cir::PointerType>($_self).getPointee()">,
+ DeclareOpInterfaceMethods<PromotableAllocationOpInterface>
+]> {
let summary = "Defines a scope-local variable";
let description = [{
The `cir.alloca` operation defines a scope-local variable.
@@ -374,12 +377,11 @@ def AllocaOp : CIR_Op<"alloca", [
// LoadOp
//===----------------------------------------------------------------------===//
-def LoadOp : CIR_Op<"load", [
+def CIR_LoadOp : CIR_Op<"load", [
TypesMatchWith<"type of 'result' matches pointee type of 'addr'",
- "addr", "result",
- "cast<PointerType>($_self).getPointee()">,
- DeclareOpInterfaceMethods<PromotableMemOpInterface>]> {
-
+ "addr", "result", "mlir::cast<cir::PointerType>($_self).getPointee()">,
+ DeclareOpInterfaceMethods<PromotableMemOpInterface>
+]> {
let summary = "Load value from memory adddress";
let description = [{
`cir.load` reads a value (lvalue to rvalue conversion) given an address
@@ -420,12 +422,11 @@ def LoadOp : CIR_Op<"load", [
// StoreOp
//===----------------------------------------------------------------------===//
-def StoreOp : CIR_Op<"store", [
+def CIR_StoreOp : CIR_Op<"store", [
TypesMatchWith<"type of 'value' matches pointee type of 'addr'",
- "addr", "value",
- "cast<PointerType>($_self).getPointee()">,
- DeclareOpInterfaceMethods<PromotableMemOpInterface>]> {
-
+ "addr", "value", "mlir::cast<cir::PointerType>($_self).getPointee()">,
+ DeclareOpInterfaceMethods<PromotableMemOpInterface>
+]> {
let summary = "Store value to memory address";
let description = [{
`cir.store` stores a value (first operand) to the memory address specified
@@ -461,10 +462,14 @@ def StoreOp : CIR_Op<"store", [
// ReturnOp
//===----------------------------------------------------------------------===//
-def ReturnOp : CIR_Op<"return", [ParentOneOf<["FuncOp", "ScopeOp", "IfOp",
- "SwitchOp", "DoWhileOp","WhileOp",
- "ForOp", "CaseOp"]>,
- Terminator]> {
+defvar CIR_ReturnableScopes = [
+ "FuncOp", "ScopeOp", "IfOp", "SwitchOp", "CaseOp",
+ "DoWhileOp", "WhileOp", "ForOp"
+];
+
+def CIR_ReturnOp : CIR_Op<"return", [
+ ParentOneOf<CIR_ReturnableScopes>, Terminator
+]> {
let summary = "Return from function";
let description = [{
The "return" operation represents a return operation within a function.
@@ -504,10 +509,10 @@ def ReturnOp : CIR_Op<"return", [ParentOneOf<["FuncOp", "ScopeOp", "IfOp",
// IfOp
//===----------------------------------------------------------------------===//
-def IfOp : CIR_Op<"if",
- [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
- RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments]>{
-
+def CIR_IfOp : CIR_Op<"if", [
+ DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+ RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments
+]> {
let summary = "the if-then-else operation";
let description = [{
The `cir.if` operation represents an if-then-else construct for
@@ -555,10 +560,11 @@ def IfOp : CIR_Op<"if",
// ConditionOp
//===----------------------------------------------------------------------===//
-def ConditionOp : CIR_Op<"condition", [
+def CIR_ConditionOp : CIR_Op<"condition", [
Terminator,
- DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface,
- ["getSuccessorRegions"]>
+ DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface, [
+ "getSuccessorRegions"
+ ]>
]> {
let summary = "Loop continuation condition.";
let description = [{
@@ -600,10 +606,14 @@ def ConditionOp : CIR_Op<"condition", [
// YieldOp
//===----------------------------------------------------------------------===//
-def YieldOp : CIR_Op<"yield", [ReturnLike, Terminator,
- ParentOneOf<["CaseOp", "DoWhileOp", "ForOp",
- "IfOp", "ScopeOp", "SwitchOp",
- "TernaryOp", "WhileOp"]>]> {
+defvar CIR_YieldableScopes = [
+ "CaseOp", "DoWhileOp", "ForOp", "IfOp", "ScopeOp", "SwitchOp",
+ "TernaryOp", "WhileOp"
+];
+
+def CIR_YieldOp : CIR_Op<"yield", [
+ ReturnLike, Terminator, ParentOneOf<CIR_YieldableScopes>
+]> {
let summary = "Represents the default branching behaviour of a region";
let description = [{
The `cir.yield` operation terminates regions on different CIR operations,
@@ -663,7 +673,7 @@ def YieldOp : CIR_Op<"yield", [ReturnLike, Terminator,
// BreakOp
//===----------------------------------------------------------------------===//
-def BreakOp : CIR_Op<"break", [Terminator]> {
+def CIR_BreakOp : CIR_Op<"break", [Terminator]> {
let summary = "C/C++ `break` statement equivalent";
let description = [{
The `cir.break` operation is used to cease the execution of the current loop
@@ -678,7 +688,7 @@ def BreakOp : CIR_Op<"break", [Terminator]> {
// ContinueOp
//===----------------------------------------------------------------------===//
-def ContinueOp : CIR_Op<"continue", [Terminator]> {
+def CIR_ContinueOp : CIR_Op<"continue", [Terminator]> {
let summary = "C/C++ `continue` statement equivalent";
let description = [{
The `cir.continue` operation is used to end execution of the current
@@ -693,9 +703,10 @@ def ContinueOp : CIR_Op<"continue", [Terminator]> {
// ScopeOp
//===----------------------------------------------------------------------===//
-def ScopeOp : CIR_Op<"scope", [
- DeclareOpInterfaceMethods<RegionBranchOpInterface>,
- RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments]> {
+def CIR_ScopeOp : CIR_Op<"scope", [
+ DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+ RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments
+]> {
let summary = "Represents a C/C++ scope";
let description = [{
`cir.scope` contains one region and defines a strict "scope" for all new
@@ -757,9 +768,10 @@ def CIR_CaseOpKind : CIR_I32EnumAttr<"CaseOpKind", "case kind", [
I32EnumAttrCase<"Range", 3, "range">
]>;
-def CaseOp : CIR_Op<"case", [
- DeclareOpInterfaceMethods<RegionBranchOpInterface>,
- RecursivelySpeculatable, AutomaticAllocationScope]> {
+def CIR_CaseOp : CIR_Op<"case", [
+ DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+ RecursivelySpeculatable, AutomaticAllocationScope
+]> {
let summary = "Case operation";
let description = [{
The `cir.case` operation represents a case within a C/C++ switch.
@@ -791,10 +803,11 @@ def CaseOp : CIR_Op<"case", [
];
}
-def SwitchOp : CIR_Op<"switch",
- [SameVariadicOperandSize,
- DeclareOpInterfaceMethods<RegionBranchOpInterface>,
- RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments]> {
+def CIR_SwitchOp : CIR_Op<"switch", [
+ SameVariadicOperandSize,
+ DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+ RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments
+]> {
let summary = "Switch operation";
let description = [{
The `cir.switch` operation represents C/C++ switch functionality for
@@ -959,8 +972,10 @@ def SwitchOp : CIR_Op<"switch",
// SwitchFlatOp
//===----------------------------------------------------------------------===//
-def SwitchFlatOp : CIR_Op<"switch.flat", [AttrSizedOperandSegments,
- Terminator]> {
+def CIR_SwitchFlatOp : CIR_Op<"switch.flat", [
+ AttrSizedOperandSegments, Terminator
+]> {
+ let summary = "A flattened version of cir.switch";
let description = [{
The `cir.switch.flat` operation is a region-less and simplified
@@ -1005,9 +1020,10 @@ def SwitchFlatOp : CIR_Op<"switch.flat", [AttrSizedOperandSegments,
// BrOp
//===----------------------------------------------------------------------===//
-def BrOp : CIR_Op<"br",
- [DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
- Pure, Terminator]> {
+def CIR_BrOp : CIR_Op<"br",[
+ DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
+ Pure, Terminator
+]> {
let summary = "Unconditional branch";
let description = [{
The `cir.br` branches unconditionally to a block. Used to represent C/C++
@@ -1053,7 +1069,7 @@ def CIR_UnaryOpKind : CIR_I32EnumAttr<"UnaryOpKind", "unary operation kind", [
I32EnumAttrCase<"Not", 4, "not">
]>;
-def UnaryOp : CIR_Op<"unary", [Pure, SameOperandsAndResultType]> {
+def CIR_UnaryOp : CIR_Op<"unary", [Pure, SameOperandsAndResultType]> {
let summary = "Unary operations";
let description = [{
`cir.unary` performs the unary operation according to
@@ -1093,9 +1109,10 @@ def UnaryOp : CIR_Op<"unary", [Pure, SameOperandsAndResultType]> {
// BrCondOp
//===----------------------------------------------------------------------===//
-def BrCondOp : CIR_Op<"brcond",
- [DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
- Pure, Terminator, AttrSizedOperandSegments]> {
+def CIR_BrCondOp : CIR_Op<"brcond", [
+ DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
+ Pure, Terminator, AttrSizedOperandSegments
+]> {
let summary = "Conditional branch";
let description = [{
The `cir.brcond %cond, ^bb0, ^bb1` branches to 'bb0' block in case
@@ -1140,9 +1157,8 @@ def BrCondOp : CIR_Op<"brcond",
// Common loop op definitions
//===----------------------------------------------------------------------===//
-class LoopOpBase<string mnemonic> : CIR_Op<mnemonic, [
- LoopOpInterface,
- NoRegionArguments,
+class CIR_LoopOpBase<string mnemonic> : CIR_Op<mnemonic, [
+ LoopOpInterface, NoRegionArguments
]> {
let extraClassDefinition = [{
void $cppClass::getSuccessorRegions(
@@ -1160,7 +1176,7 @@ class LoopOpBase<string mnemonic> : CIR_Op<mnemonic, [
// While & DoWhileOp
//===----------------------------------------------------------------------===//
-class WhileOpBase<string mnemonic> : LoopOpBase<mnemonic> {
+class CIR_WhileOpBase<string mnemonic> : CIR_LoopOpBase<mnemonic> {
defvar isWhile = !eq(mnemonic, "while");
let summary = "C/C++ " # !if(isWhile, "while", "do-while") # " loop";
let builders = [
@@ -1180,7 +1196,7 @@ class WhileOpBase<string mnemonic> : LoopOpBase<mnemonic> {
];
}
-def WhileOp : WhileOpBase<"while"> {
+def CIR_WhileOp : CIR_WhileOpBase<"while"> {
let regions = (region SizedRegion<1>:$cond, MinSizedRegion<1>:$body);
let assemblyFormat = "$cond `do` $body attr-dict";
@@ -1205,7 +1221,7 @@ def WhileOp : WhileOpBase<"while"> {
}];
}
-def DoWhileOp : WhileOpBase<"do"> {
+def CIR_DoWhileOp : CIR_WhileOpBase<"do"> {
let regions = (region MinSizedRegion<1>:$body, SizedRegion<1>:$cond);
let assemblyFormat = " $body `while` $cond attr-dict";
@@ -1235,7 +1251,7 @@ def DoWhileOp : WhileOpBase<"do"> {
// ForOp
//===----------------------------------------------------------------------===//
-def ForOp : LoopOpBase<"for"> {
+def CIR_ForOp : CIR_LoopOpBase<"for"> {
let summary = "C/C++ for loop counterpart";
let description = [{
Represents a C/C++ for loop. It consists of three regions:
@@ -1311,8 +1327,7 @@ def CIR_CmpOpKind : CIR_I32EnumAttr<"CmpOpKind", "compare operation kind", [
I32EnumAttrCase<"ne", 5>
]>;
-def CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
-
+def CIR_CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
let summary = "Compare values two values and produce a boolean result";
let description = [{
`cir.cmp` compares two input operands of the same type and produces a
@@ -1355,9 +1370,9 @@ def CIR_BinOpKind : CIR_I32EnumAttr<
I32EnumAttrCase<"Max", 8, "max">
]>;
-def BinOp : CIR_Op<"binop", [Pure,
- SameTypeOperands, SameOperandsAndResultType]> {
-
+def CIR_BinOp : CIR_Op<"binop", [
+ Pure, SameTypeOperands, SameOperandsAndResultType
+]> {
let summary = "Binary operations (arith and logic)";
let description = [{
cir.binop performs the binary operation according to
@@ -1411,7 +1426,7 @@ def BinOp : CIR_Op<"binop", [Pure,
// ShiftOp
//===----------------------------------------------------------------------===//
-def ShiftOp : CIR_Op<"shift", [Pure]> {
+def CIR_ShiftOp : CIR_Op<"shift", [Pure]> {
let summary = "Shift";
let description = [{
The `cir.shift` operation performs a bitwise shift, either to the left or to
@@ -1452,8 +1467,9 @@ def ShiftOp : CIR_Op<"shift", [Pure]> {
// SelectOp
//===----------------------------------------------------------------------===//
-def SelectOp : CIR_Op<"select", [Pure,
- AllTypesMatch<["true_value", "false_value", "result"]>]> {
+def CIR_SelectOp : CIR_Op<"select", [
+ Pure, AllTypesMatch<["true_value", "false_value", "result"]>
+]> {
let summary = "Yield one of two values based on a boolean value";
let description = [{
The `cir.select` operation takes three operands. The first operand
@@ -1492,9 +1508,10 @@ def SelectOp : CIR_Op<"select", [Pure,
// TernaryOp
//===----------------------------------------------------------------------===//
-def TernaryOp : CIR_Op<"ternary",
- [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
- RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments]> {
+def CIR_TernaryOp : CIR_Op<"ternary", [
+ DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+ RecursivelySpeculatable, AutomaticAllocationScope, NoRegionArguments
+]> {
let summary = "The `cond ? a : b` C/C++ ternary operation";
let description = [{
The `cir.ternary` operation represents C/C++ ternary, much like a `select`
@@ -1583,8 +1600,9 @@ def CIR_GlobalLinkageKind : CIR_I32EnumAttr<
// properties of a global variable will be added over time as more of ClangIR
// is upstreamed.
-def GlobalOp : CIR_Op<"global",
- [DeclareOpInterfaceMethods<CIRGlobalValueInterface>]> {
+def CIR_GlobalOp : CIR_Op<"global", [
+ DeclareOpInterfaceMethods<CIRGlobalValueInterface>
+]> {
let summary = "Declare or define a global variable";
let description = [{
The `cir.global` operation declares or defines a named global variable.
@@ -1645,8 +1663,9 @@ def GlobalOp : CIR_Op<"global",
// GetGlobalOp
//===----------------------------------------------------------------------===//
-def GetGlobalOp : CIR_Op<"get_global",
- [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+def CIR_GetGlobalOp : CIR_Op<"get_global", [
+ Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>
+]> {
let summary = "Get the address of a global variable";
let description = [{
The `cir.get_global` operation retrieves the address pointing to a
@@ -1673,7 +1692,7 @@ def GetGlobalOp : CIR_Op<"get_global",
// SetBitfieldOp
//===----------------------------------------------------------------------===//
-def SetBitfieldOp : CIR_Op<"set_bitfield"> {
+def CIR_SetBitfieldOp : CIR_Op<"set_bitfield"> {
let summary = "Set the value of a bitfield member";
let description = [{
The `cir.set_bitfield` operation provides a store-like access to
@@ -1761,7 +1780,7 @@ def SetBitfieldOp : CIR_Op<"set_bitfield"> {
// GetBitfieldOp
//===----------------------------------------------------------------------===//
-def GetBitfieldOp : CIR_Op<"get_bitfield"> {
+def CIR_GetBitfieldOp : CIR_Op<"get_bitfield"> {
let summary = "Get the information for a bitfield member";
let description = [{
The `cir.get_bitfield` operation provides a load-like access to
@@ -1843,7 +1862,7 @@ def GetBitfieldOp : CIR_Op<"get_bitfield"> {
// GetMemberOp
//===----------------------------------------------------------------------===//
-def GetMemberOp : CIR_Op<"get_member"> {
+def CIR_GetMemberOp : CIR_Op<"get_member"> {
let summary = "Get the address of a member of a record";
let description = [{
The `cir.get_member` operation gets the address of a particular named
@@ -1905,7 +1924,7 @@ def GetMemberOp : CIR_Op<"get_member"> {
// TODO(CIR): FuncOp is still a tiny shell of what it will become. Many more
// properties and attributes will be added as upstreaming continues.
-def FuncOp : CIR_Op<"func", [
+def CIR_FuncOp : CIR_Op<"func", [
AutomaticAllocationScope, CallableOpInterface, FunctionOpInterface,
DeclareOpInterfaceMethods<CIRGlobalValueInterface>,
IsolatedFromAbove
@@ -2029,10 +2048,10 @@ def CIR_SideEffect : CIR_I32EnumAttr<
}
class CIR_CallOpBase<string mnemonic, list<Trait> extra_traits = []>
- : Op<CIR_Dialect, mnemonic,
- !listconcat(extra_traits,
- [DeclareOpInterfaceMethods<CIRCallOpInterface>,
- DeclareOpInterfaceMethods<SymbolUserOpInterface>])> {
+ : CIR_Op<mnemonic, !listconcat(extra_traits, [
+ DeclareOpInterfaceMethods<CIRCallOpInterface>,
+ DeclareOpInterfaceMethods<SymbolUserOpInterface>
+ ])> {
let extraClassDeclaration = [{
/// Get the argument operands to the called function.
mlir::OperandRange getArgOperands();
@@ -2086,7 +2105,7 @@ class CIR_CallOpBase<string mnemonic, list<Trait> extra_traits = []>
DefaultValuedAttr<CIR_SideEffect, "SideEffect::All">:$side_effect);
}
-def CallOp : CIR_CallOpBase<"call", [NoRegionArguments]> {
+def CIR_CallOp : CIR_CallOpBase<"call", [NoRegionArguments]> {
let summary = "call a function";
let description = [{
The `cir.call` operation represents a function call. It could represent
@@ -2127,7 +2146,7 @@ def CallOp : CIR_CallOpBase<"call", [NoRegionArguments]> {
// StackSaveOp & StackRestoreOp
//===----------------------------------------------------------------------===//
-def StackSaveOp : CIR_Op<"stacksave"> {
+def CIR_StackSaveOp : CIR_Op<"stacksave"> {
let summary = "remembers the current state of the function stack";
let description = [{
Saves current state of the function stack. Returns a pointer to an opaque object
@@ -2145,7 +2164,7 @@ def StackSaveOp : CIR_Op<"stacksave"> {
let assemblyFormat = "attr-dict `:` qualified(type($result))";
}
-def StackRestoreOp : CIR_Op<"stackrestore"> {
+def CIR_StackRestoreOp : CIR_Op<"stackrestore"> {
let summary = "restores the state of the function stack";
let description = [{
Restore the state of the function stack to the state it was
@@ -2171,7 +2190,7 @@ def StackRestoreOp : CIR_Op<"stackrestore"> {
// UnreachableOp
//===----------------------------------------------------------------------===//
-def UnreachableOp : CIR_Op<"unreachable", [Terminator]> {
+def CIR_UnreachableOp : CIR_Op<"unreachable", [Terminator]> {
let summary = "invoke immediate undefined behavior";
let description = [{
If the program control flow reaches a `cir.unreachable` operation, the
@@ -2187,7 +2206,7 @@ def UnreachableOp : CIR_Op<"unreachable", [Terminator]> {
// TrapOp
//===----------------------------------------------------------------------===//
-def TrapOp : CIR_Op<"trap", [Terminator]> {
+def CIR_TrapOp : CIR_Op<"trap", [Terminator]> {
let summary = "Exit the program abnormally";
let description = [{
The cir.trap operation causes the program to exit abnormally. The
@@ -2204,8 +2223,7 @@ def TrapOp : CIR_Op<"trap", [Terminator]> {
// VecCreate
//===----------------------------------------------------------------------===//
-def VecCreateOp : CIR_Op<"vec.create", [Pure]> {
-
+def CIR_VecCreateOp : CIR_Op<"vec.create", [Pure]> {
let summary = "Create a vector value";
let description = [{
The `cir.vec.create` operation creates a vector value with the given element
@@ -2229,11 +2247,12 @@ def VecCreateOp : CIR_Op<"vec.create", [Pure]> {
// VecInsertOp
//===----------------------------------------------------------------------===//
-def VecInsertOp : CIR_Op<"vec.insert", [Pure,
- TypesMatchWith<"argument type matches vector element type", "vec", "value",
- "cast<VectorType>($_self).getElementType()">,
- AllTypesMatch<["result", "vec"]>]> {
-
+def CIR_VecInsertOp : CIR_Op<"vec.insert", [
+ Pure,
+ TypesMatchWith<"argument type matches vector element type",
+ "vec", "value", "mlir::cast<cir::VectorType>($_self).getElementType()">,
+ AllTypesMatch<["result", "vec"]>
+]> {
let summary = "Insert one element into a vector object";
let description = [{
The `cir.vec.insert` operation produces a new vector by replacing
@@ -2265,10 +2284,11 @@ def VecInsertOp : CIR_Op<"vec.insert", [Pure,
// VecExtractOp
//===----------------------------------------------------------------------===//
-def VecExtractOp : CIR_Op<"vec.extract", [Pure,
- TypesMatchWith<"type of 'result' matches element type of 'vec'", "vec",
- "result", "cast<VectorType>($_self).getElementType()">]> {
-
+def CIR_VecExtractOp : CIR_Op<"vec.extract", [
+ Pure,
+ TypesMatchWith<"type of 'result' matches element type of 'vec'",
+ "vec", "result", "mlir::cast<cir::VectorType>($_self).getElementType()">
+]> {
let summary = "Extract one element from a vector object";
let description = [{
The `cir.vec.extract` operation extracts the element at the given index
@@ -2295,8 +2315,7 @@ def VecExtractOp : CIR_Op<"vec.extract", [Pure,
// VecCmpOp
//===----------------------------------------------------------------------===//
-def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
-
+def CIR_VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
let summary = "Compare two vectors";
let description = [{
The `cir.vec.cmp` operation does an element-wise comparison of two vectors
@@ -2334,8 +2353,9 @@ def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
// implement. This could be useful for passes that don't care how the vector
// shuffle was specified.
-def VecShuffleOp : CIR_Op<"vec.shuffle",
- [Pure, AllTypesMatch<["vec1", "vec2"]>]> {
+def CIR_VecShuffleOp : CIR_Op<"vec.shuffle", [
+ Pure, AllTypesMatch<["vec1", "vec2"]>
+]> {
let summary = "Combine two vectors using indices passed as constant integers";
let description = [{
The `cir.vec.shuffle` operation implements the documented form of Clang's
@@ -2378,8 +2398,9 @@ def VecShuffleOp : CIR_Op<"vec.shuffle",
// VecShuffleDynamicOp
//===----------------------------------------------------------------------===//
-def VecShuffleDynamicOp : CIR_Op<"vec.shuffle.dynamic",
- [Pure, AllTypesMatch<["vec", "result"]>]> {
+def CIR_VecShuffleDynamicOp : CIR_Op<"vec.shuffle.dynamic", [
+ Pure, AllTypesMatch<["vec", "result"]>
+]> {
let summary = "Shuffle a vector using indices in another vector";
let description = [{
The `cir.vec.shuffle.dynamic` operation implements the undocumented form of
@@ -2413,8 +2434,9 @@ def VecShuffleDynamicOp : CIR_Op<"vec.shuffle.dynamic",
// VecTernaryOp
//===----------------------------------------------------------------------===//
-def VecTernaryOp : CIR_Op<"vec.ternary",
- [Pure, AllTypesMatch<["result", "lhs", "rhs"]>]> {
+def CIR_VecTernaryOp : CIR_Op<"vec.ternary", [
+ Pure, AllTypesMatch<["result", "lhs", "rhs"]>
+]> {
let summary = "The `cond ? a : b` ternary operator for vector types";
let description = [{
The `cir.vec.ternary` operation represents the C/C++ ternary operator,
@@ -2451,10 +2473,11 @@ def VecTernaryOp : CIR_Op<"vec.ternary",
// VecSplatOp
//===----------------------------------------------------------------------===//
-def VecSplatOp : CIR_Op<"vec.splat", [Pure,
- TypesMatchWith<"type of 'value' matches element type of 'result'", "result",
- "value", "cast<VectorType>($_self).getElementType()">]> {
-
+def CIR_VecSplatOp : CIR_Op<"vec.splat", [
+ Pure,
+ TypesMatchWith<"type of 'value' matches element type of 'result'",
+ "result", "value", "mlir::cast<cir::VectorType>($_self).getElementType()">
+]> {
let summary = "Convert a scalar into a vector";
let description = [{
The `cir.vec.splat` operation creates a vector value from a scalar value.
@@ -2483,7 +2506,7 @@ def VecSplatOp : CIR_Op<"vec.splat", [Pure,
// BaseClassAddrOp
//===----------------------------------------------------------------------===//
-def BaseClassAddrOp : CIR_Op<"base_class_addr"> {
+def CIR_BaseClassAddrOp : CIR_Op<"base_class_addr"> {
let summary = "Get the base class address for a class/struct";
let description = [{
The `cir.base_class_addr` operaration gets the address of a particular
@@ -2526,7 +2549,7 @@ def BaseClassAddrOp : CIR_Op<"base_class_addr"> {
// ComplexCreateOp
//===----------------------------------------------------------------------===//
-def ComplexCreateOp : CIR_Op<"complex.create", [Pure, SameTypeOperands]> {
+def CIR_ComplexCreateOp : CIR_Op<"complex.create", [Pure, SameTypeOperands]> {
let summary = "Create a complex value from its real and imaginary parts";
let description = [{
The `cir.complex.create` operation takes two operands that represent the
@@ -2558,7 +2581,7 @@ def ComplexCreateOp : CIR_Op<"complex.create", [Pure, SameTypeOperands]> {
// ComplexRealOp
//===----------------------------------------------------------------------===//
-def ComplexRealOp : CIR_Op<"complex.real", [Pure]> {
+def CIR_ComplexRealOp : CIR_Op<"complex.real", [Pure]> {
let summary = "Extract the real part of a complex value";
let description = [{
`cir.complex.real` operation takes an operand of `!cir.complex` type and
@@ -2587,7 +2610,7 @@ def ComplexRealOp : CIR_Op<"complex.real", [Pure]> {
// ComplexImagOp
//===----------------------------------------------------------------------===//
-def ComplexImagOp : CIR_Op<"complex.imag", [Pure]> {
+def CIR_ComplexImagOp : CIR_Op<"complex.imag", [Pure]> {
let summary = "Extract the imaginary part of a complex value";
let description = [{
`cir.complex.imag` operation takes an operand of `!cir.complex` type and
@@ -2616,7 +2639,7 @@ def ComplexImagOp : CIR_Op<"complex.imag", [Pure]> {
// ComplexRealPtrOp
//===----------------------------------------------------------------------===//
-def ComplexRealPtrOp : CIR_Op<"complex.real_ptr", [Pure]> {
+def CIR_ComplexRealPtrOp : CIR_Op<"complex.real_ptr", [Pure]> {
let summary = "Derive a pointer to the real part of a complex value";
let description = [{
`cir.complex.real_ptr` operation takes a pointer operand that points to a
@@ -2646,7 +2669,7 @@ def ComplexRealPtrOp : CIR_Op<"complex.real_ptr", [Pure]> {
// ComplexImagPtrOp
//===----------------------------------------------------------------------===//
-def ComplexImagPtrOp : CIR_Op<"complex.imag_ptr", [Pure]> {
+def CIR_ComplexImagPtrOp : CIR_Op<"complex.imag_ptr", [Pure]> {
let summary = "Derive a pointer to the imaginary part of a complex value";
let description = [{
`cir.complex.imag_ptr` operation takes a pointer operand that points to a
@@ -2676,7 +2699,9 @@ def ComplexImagPtrOp : CIR_Op<"complex.imag_ptr", [Pure]> {
// ComplexAddOp
//===----------------------------------------------------------------------===//
-def ComplexAddOp : CIR_Op<"complex.add", [Pure, SameOperandsAndResultType]> {
+def CIR_ComplexAddOp : CIR_Op<"complex.add", [
+ Pure, SameOperandsAndResultType
+]> {
let summary = "Complex addition";
let description = [{
The `cir.complex.add` operation takes two complex numbers and returns
@@ -2702,7 +2727,9 @@ def ComplexAddOp : CIR_Op<"complex.add", [Pure, SameOperandsAndResultType]> {
// ComplexSubOp
//===----------------------------------------------------------------------===//
-def ComplexSubOp : CIR_Op<"complex.sub", [Pure, SameOperandsAndResultType]> {
+def CIR_ComplexSubOp : CIR_Op<"complex.sub", [
+ Pure, SameOperandsAndResultType
+]> {
let summary = "Complex subtraction";
let description = [{
The `cir.complex.sub` operation takes two complex numbers and returns
@@ -2730,7 +2757,7 @@ def ComplexSubOp : CIR_Op<"complex.sub", [Pure, SameOperandsAndResultType]> {
//===----------------------------------------------------------------------===//
class CIR_BitOpBase<string mnemonic, TypeConstraint operandTy>
- : CIR_Op<mnemonic, [Pure, SameOperandsAndResultType]> {
+ : CIR_Op<mnemonic, [Pure, SameOperandsAndResultType]> {
let arguments = (ins operandTy:$input);
let results = (outs operandTy:$result);
@@ -2740,7 +2767,7 @@ class CIR_BitOpBase<string mnemonic, TypeConstraint operandTy>
}
class CIR_BitZeroCountOpBase<string mnemonic, TypeConstraint operandTy>
- : CIR_BitOpBase<mnemonic, operandTy> {
+ : CIR_BitOpBase<mnemonic, operandTy> {
let arguments = (ins operandTy:$input, UnitAttr:$poison_zero);
let assemblyFormat = [{
@@ -2749,7 +2776,7 @@ class CIR_BitZeroCountOpBase<string mnemonic, TypeConstraint operandTy>
}];
}
-def BitClrsbOp : CIR_BitOpBase<"clrsb", CIR_SIntOfWidths<[32, 64]>> {
+def CIR_BitClrsbOp : CIR_BitOpBase<"clrsb", CIR_SIntOfWidths<[32, 64]>> {
let summary = "Get the number of leading redundant sign bits in the input";
let description = [{
Compute the number of leading redundant sign bits in the input integer.
@@ -2779,7 +2806,9 @@ def BitClrsbOp : CIR_BitOpBase<"clrsb", CIR_SIntOfWidths<[32, 64]>> {
}];
}
-def BitClzOp : CIR_BitZeroCountOpBase<"clz", CIR_UIntOfWidths<[16, 32, 64]>> {
+def CIR_BitClzOp : CIR_BitZeroCountOpBase<"clz",
+ CIR_UIntOfWidths<[16, 32, 64]>
+> {
let summary = "Get the number of leading 0-bits in the input";
let description = [{
Compute the number of leading 0-bits in the input.
@@ -2802,7 +2831,9 @@ def BitClzOp : CIR_BitZeroCountOpBase<"clz", CIR_UIntOfWidths<[16, 32, 64]>> {
}];
}
-def BitCtzOp : CIR_BitZeroCountOpBase<"ctz", CIR_UIntOfWidths<[16, 32, 64]>> {
+def CIR_BitCtzOp : CIR_BitZeroCountOpBase<"ctz",
+ CIR_UIntOfWidths<[16, 32, 64]>
+> {
let summary = "Get the number of trailing 0-bits in the input";
let description = [{
Compute the number of trailing 0-bits in the input.
@@ -2825,7 +2856,7 @@ def BitCtzOp : CIR_BitZeroCountOpBase<"ctz", CIR_UIntOfWidths<[16, 32, 64]>> {
}];
}
-def BitParityOp : CIR_BitOpBase<"parity", CIR_UIntOfWidths<[32, 64]>> {
+def CIR_BitParityOp : CIR_BitOpBase<"parity", CIR_UIntOfWidths<[32, 64]>> {
let summary = "Get the parity of input";
let description = [{
Compute the parity of the input. The parity of an integer is the number of
@@ -2844,7 +2875,9 @@ def BitParityOp : CIR_BitOpBase<"parity", CIR_UIntOfWidths<[32, 64]>> {
}];
}
-def BitPopcountOp : CIR_BitOpBase<"popcount", CIR_UIntOfWidths<[16, 32, 64]>> {
+def CIR_BitPopcountOp : CIR_BitOpBase<"popcount",
+ CIR_UIntOfWidths<[16, 32, 64]>
+> {
let summary = "Get the number of 1-bits in input";
let description = [{
Compute the number of 1-bits in the input.
@@ -2862,8 +2895,9 @@ def BitPopcountOp : CIR_BitOpBase<"popcount", CIR_UIntOfWidths<[16, 32, 64]>> {
}];
}
-def BitReverseOp : CIR_BitOpBase<"bitreverse",
- CIR_UIntOfWidths<[8, 16, 32, 64]>> {
+def CIR_BitReverseOp : CIR_BitOpBase<"bitreverse",
+ CIR_UIntOfWidths<[8, 16, 32, 64]>
+> {
let summary = "Reverse the bit pattern of the operand integer";
let description = [{
The `cir.bitreverse` operation reverses the bits of the operand integer. Its
@@ -2877,7 +2911,9 @@ def BitReverseOp : CIR_BitOpBase<"bitreverse",
}];
}
-def ByteSwapOp : CIR_BitOpBase<"byte_swap", CIR_UIntOfWidths<[16, 32, 64]>> {
+def CIR_ByteSwapOp : CIR_BitOpBase<"byte_swap",
+ CIR_UIntOfWidths<[16, 32, 64]>
+> {
let summary = "Reverse the bytes in the object representation of the operand";
let description = [{
The `cir.byte_swap` operation takes an integer as operand, reverse the bytes
@@ -2902,7 +2938,7 @@ def ByteSwapOp : CIR_BitOpBase<"byte_swap", CIR_UIntOfWidths<[16, 32, 64]>> {
// Assume Operations
//===----------------------------------------------------------------------===//
-def AssumeOp : CIR_Op<"assume"> {
+def CIR_AssumeOp : CIR_Op<"assume"> {
let summary = "Tell the optimizer that a boolean value is true";
let description = [{
The `cir.assume` operation takes a single boolean prediate as its only
@@ -2924,8 +2960,9 @@ def AssumeOp : CIR_Op<"assume"> {
// Branch Probability Operations
//===----------------------------------------------------------------------===//
-def ExpectOp : CIR_Op<"expect",
- [Pure, AllTypesMatch<["result", "val", "expected"]>]> {
+def CIR_ExpectOp : CIR_Op<"expect", [
+ Pure, AllTypesMatch<["result", "val", "expected"]>
+]> {
let summary = "Tell the optimizer that two values are likely to be equal.";
let description = [{
The `cir.expect` operation may take 2 or 3 arguments.
More information about the cfe-commits
mailing list