1//===- ArithBase.td - Base defs for arith dialect -----------*- tablegen -*-==// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#ifndef ARITH_BASE 10#define ARITH_BASE 11 12include "mlir/IR/EnumAttr.td" 13include "mlir/IR/OpBase.td" 14 15def Arith_Dialect : Dialect { 16 let name = "arith"; 17 let cppNamespace = "::mlir::arith"; 18 let description = [{ 19 The arith dialect is intended to hold basic integer and floating point 20 mathematical operations. This includes unary, binary, and ternary arithmetic 21 ops, bitwise and shift ops, cast ops, and compare ops. Operations in this 22 dialect also accept vectors and tensors of integers or floats. The dialect 23 assumes integers are represented by bitvectors with a two's complement 24 representation. Unless otherwise stated, the operations within this dialect 25 propagate poison values, i.e., if any of its inputs are poison, then the 26 output is poison. Unless otherwise stated, operations applied to `vector` 27 and `tensor` values propagates poison elementwise. 28 }]; 29 30 let hasConstantMaterializer = 1; 31 let useDefaultAttributePrinterParser = 1; 32} 33 34// The predicate indicates the type of the comparison to perform: 35// (un)orderedness, (in)equality and less/greater than (or equal to) as 36// well as predicates that are always true or false. 37def Arith_CmpFPredicateAttr : I64EnumAttr< 38 "CmpFPredicate", "", 39 [ 40 I64EnumAttrCase<"AlwaysFalse", 0, "false">, 41 I64EnumAttrCase<"OEQ", 1, "oeq">, 42 I64EnumAttrCase<"OGT", 2, "ogt">, 43 I64EnumAttrCase<"OGE", 3, "oge">, 44 I64EnumAttrCase<"OLT", 4, "olt">, 45 I64EnumAttrCase<"OLE", 5, "ole">, 46 I64EnumAttrCase<"ONE", 6, "one">, 47 I64EnumAttrCase<"ORD", 7, "ord">, 48 I64EnumAttrCase<"UEQ", 8, "ueq">, 49 I64EnumAttrCase<"UGT", 9, "ugt">, 50 I64EnumAttrCase<"UGE", 10, "uge">, 51 I64EnumAttrCase<"ULT", 11, "ult">, 52 I64EnumAttrCase<"ULE", 12, "ule">, 53 I64EnumAttrCase<"UNE", 13, "une">, 54 I64EnumAttrCase<"UNO", 14, "uno">, 55 I64EnumAttrCase<"AlwaysTrue", 15, "true">, 56 ]> { 57 let cppNamespace = "::mlir::arith"; 58} 59 60def Arith_CmpIPredicateAttr : I64EnumAttr< 61 "CmpIPredicate", "", 62 [ 63 I64EnumAttrCase<"eq", 0>, 64 I64EnumAttrCase<"ne", 1>, 65 I64EnumAttrCase<"slt", 2>, 66 I64EnumAttrCase<"sle", 3>, 67 I64EnumAttrCase<"sgt", 4>, 68 I64EnumAttrCase<"sge", 5>, 69 I64EnumAttrCase<"ult", 6>, 70 I64EnumAttrCase<"ule", 7>, 71 I64EnumAttrCase<"ugt", 8>, 72 I64EnumAttrCase<"uge", 9>, 73 ]> { 74 let cppNamespace = "::mlir::arith"; 75} 76 77def ATOMIC_RMW_KIND_ADDF : I64EnumAttrCase<"addf", 0>; 78def ATOMIC_RMW_KIND_ADDI : I64EnumAttrCase<"addi", 1>; 79def ATOMIC_RMW_KIND_ASSIGN : I64EnumAttrCase<"assign", 2>; 80def ATOMIC_RMW_KIND_MAXIMUMF : I64EnumAttrCase<"maximumf", 3>; 81def ATOMIC_RMW_KIND_MAXS : I64EnumAttrCase<"maxs", 4>; 82def ATOMIC_RMW_KIND_MAXU : I64EnumAttrCase<"maxu", 5>; 83def ATOMIC_RMW_KIND_MINIMUMF : I64EnumAttrCase<"minimumf", 6>; 84def ATOMIC_RMW_KIND_MINS : I64EnumAttrCase<"mins", 7>; 85def ATOMIC_RMW_KIND_MINU : I64EnumAttrCase<"minu", 8>; 86def ATOMIC_RMW_KIND_MULF : I64EnumAttrCase<"mulf", 9>; 87def ATOMIC_RMW_KIND_MULI : I64EnumAttrCase<"muli", 10>; 88def ATOMIC_RMW_KIND_ORI : I64EnumAttrCase<"ori", 11>; 89def ATOMIC_RMW_KIND_ANDI : I64EnumAttrCase<"andi", 12>; 90def ATOMIC_RMW_KIND_MAXNUMF : I64EnumAttrCase<"maxnumf", 13>; 91def ATOMIC_RMW_KIND_MINNUMF : I64EnumAttrCase<"minnumf", 14>; 92 93def AtomicRMWKindAttr : I64EnumAttr< 94 "AtomicRMWKind", "", 95 [ATOMIC_RMW_KIND_ADDF, ATOMIC_RMW_KIND_ADDI, ATOMIC_RMW_KIND_ASSIGN, 96 ATOMIC_RMW_KIND_MAXIMUMF, ATOMIC_RMW_KIND_MAXS, ATOMIC_RMW_KIND_MAXU, 97 ATOMIC_RMW_KIND_MINIMUMF, ATOMIC_RMW_KIND_MINS, ATOMIC_RMW_KIND_MINU, 98 ATOMIC_RMW_KIND_MULF, ATOMIC_RMW_KIND_MULI, ATOMIC_RMW_KIND_ORI, 99 ATOMIC_RMW_KIND_ANDI, ATOMIC_RMW_KIND_MAXNUMF, ATOMIC_RMW_KIND_MINNUMF]> { 100 let cppNamespace = "::mlir::arith"; 101} 102 103def FASTMATH_NONE : I32BitEnumAttrCaseNone<"none" >; 104def FASTMATH_REASSOC : I32BitEnumAttrCaseBit<"reassoc", 0>; 105def FASTMATH_NO_NANS : I32BitEnumAttrCaseBit<"nnan", 1>; 106def FASTMATH_NO_INFS : I32BitEnumAttrCaseBit<"ninf", 2>; 107def FASTMATH_NO_SIGNED_ZEROS : I32BitEnumAttrCaseBit<"nsz", 3>; 108def FASTMATH_ALLOW_RECIP : I32BitEnumAttrCaseBit<"arcp", 4>; 109def FASTMATH_ALLOW_CONTRACT : I32BitEnumAttrCaseBit<"contract", 5>; 110def FASTMATH_APPROX_FUNC : I32BitEnumAttrCaseBit<"afn", 6>; 111def FASTMATH_FAST : I32BitEnumAttrCaseGroup< 112 "fast", 113 [ 114 FASTMATH_REASSOC, FASTMATH_NO_NANS, FASTMATH_NO_INFS, 115 FASTMATH_NO_SIGNED_ZEROS, FASTMATH_ALLOW_RECIP, FASTMATH_ALLOW_CONTRACT, 116 FASTMATH_APPROX_FUNC]>; 117 118def FastMathFlags : I32BitEnumAttr< 119 "FastMathFlags", 120 "Floating point fast math flags", 121 [ 122 FASTMATH_NONE, FASTMATH_REASSOC, FASTMATH_NO_NANS, 123 FASTMATH_NO_INFS, FASTMATH_NO_SIGNED_ZEROS, FASTMATH_ALLOW_RECIP, 124 FASTMATH_ALLOW_CONTRACT, FASTMATH_APPROX_FUNC, FASTMATH_FAST]> { 125 let separator = ","; 126 let cppNamespace = "::mlir::arith"; 127 let genSpecializedAttr = 0; 128 let printBitEnumPrimaryGroups = 1; 129} 130 131def Arith_FastMathAttr : 132 EnumAttr<Arith_Dialect, FastMathFlags, "fastmath"> { 133 let assemblyFormat = "`<` $value `>`"; 134} 135 136//===----------------------------------------------------------------------===// 137// Arith_IntegerOverflowFlags 138//===----------------------------------------------------------------------===// 139 140def Arith_IOFnone : I32BitEnumAttrCaseNone<"none">; 141def Arith_IOFnsw : I32BitEnumAttrCaseBit<"nsw", 0>; 142def Arith_IOFnuw : I32BitEnumAttrCaseBit<"nuw", 1>; 143 144def Arith_IntegerOverflowFlags : I32BitEnumAttr< 145 "IntegerOverflowFlags", 146 "Integer overflow arith flags", 147 [Arith_IOFnone, Arith_IOFnsw, Arith_IOFnuw]> { 148 let separator = ", "; 149 let cppNamespace = "::mlir::arith"; 150 let genSpecializedAttr = 0; 151 let printBitEnumPrimaryGroups = 1; 152} 153 154def Arith_IntegerOverflowAttr : 155 EnumAttr<Arith_Dialect, Arith_IntegerOverflowFlags, "overflow"> { 156 let assemblyFormat = "`<` $value `>`"; 157} 158 159//===----------------------------------------------------------------------===// 160// Arith_RoundingMode 161//===----------------------------------------------------------------------===// 162 163// These correspond to LLVM's values defined in: 164// llvm/include/llvm/ADT/FloatingPointMode.h 165 166def Arith_RToNearestTiesToEven // Round to nearest, ties to even 167 : I32EnumAttrCase<"to_nearest_even", 0>; 168def Arith_RDownward // Round toward -inf 169 : I32EnumAttrCase<"downward", 1>; 170def Arith_RUpward // Round toward +inf 171 : I32EnumAttrCase<"upward", 2>; 172def Arith_RTowardZero // Round toward 0 173 : I32EnumAttrCase<"toward_zero", 3>; 174def Arith_RToNearestTiesAwayFromZero // Round to nearest, ties away from zero 175 : I32EnumAttrCase<"to_nearest_away", 4>; 176 177def Arith_RoundingModeAttr : I32EnumAttr< 178 "RoundingMode", "Floating point rounding mode", 179 [Arith_RToNearestTiesToEven, Arith_RDownward, Arith_RUpward, 180 Arith_RTowardZero, Arith_RToNearestTiesAwayFromZero]> { 181 let cppNamespace = "::mlir::arith"; 182} 183 184#endif // ARITH_BASE 185