1//===-- LLVMEnums.td - LLVM IR dialect enum file -----------*- 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 LLVMIR_ENUMS 10#define LLVMIR_ENUMS 11 12include "mlir/Dialect/LLVMIR/LLVMDialect.td" 13include "mlir/IR/EnumAttr.td" 14 15//===----------------------------------------------------------------------===// 16// Base classes for LLVM enum attributes. 17//===----------------------------------------------------------------------===// 18 19// Case of the LLVM enum attribute backed by I64Attr with customized string 20// representation that corresponds to what is visible in the textual IR form. 21// The parameters are as follows: 22// - `cppSym`: name of the C++ enumerant for this case in MLIR API; 23// - `irSym`: keyword used in the custom form of MLIR operation; 24// - `llvmSym`: name of the C++ enumerant for this case in LLVM API. 25// For example, `LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage">` is usable 26// as `<MlirEnumName>::Weak` in MLIR API, `WeakAnyLinkage` in LLVM API and 27// is printed/parsed as `weak` in MLIR custom textual format. 28class LLVM_EnumAttrCase<string cppSym, string irSym, string llvmSym, int val> : 29 I64EnumAttrCase<cppSym, val, irSym> { 30 // The name of the equivalent enumerant in LLVM. 31 string llvmEnumerant = llvmSym; 32} 33 34// LLVM enum attribute backed by I64Attr with string representation 35// corresponding to what is visible in the textual IR form. 36// The parameters are as follows: 37// - `name`: name of the C++ enum class in MLIR API; 38// - `llvmName`: name of the C++ enum in LLVM API; 39// - `description`: textual description for documentation purposes; 40// - `cases`: list of enum cases; 41// - `unsupportedCases`: optional list of unsupported enum cases. 42// For example, `LLVM_EnumAttr<Linkage, "::llvm::GlobalValue::LinkageTypes` 43// produces `mlir::LLVM::Linkage` enum class in MLIR API that corresponds to (a 44// subset of) values in the `llvm::GlobalValue::LinkageTypes` in LLVM API. 45// All unsupported cases are excluded from the MLIR enum and trigger an error 46// during the import from LLVM IR. They are useful to handle sentinel values 47// such as `llvm::AtomicRMWInst::BinOp::BAD_BINOP` that LLVM commonly uses to 48// terminate its enums. 49class LLVM_EnumAttr<string name, string llvmName, string description, 50 list<LLVM_EnumAttrCase> cases, 51 list<LLVM_EnumAttrCase> unsupportedCases = []> : 52 I64EnumAttr<name, description, cases> { 53 // List of unsupported cases that have no conversion to an MLIR value. 54 list<LLVM_EnumAttrCase> unsupported = unsupportedCases; 55 56 // The equivalent enum class name in LLVM. 57 string llvmClassName = llvmName; 58} 59 60// LLVM_CEnumAttr is functionally identical to LLVM_EnumAttr, but to be used for 61// non-class enums. 62class LLVM_CEnumAttr<string name, string llvmNS, string description, 63 list<LLVM_EnumAttrCase> cases> : 64 I64EnumAttr<name, description, cases> { 65 string llvmClassName = llvmNS; 66} 67 68//===----------------------------------------------------------------------===// 69// AsmDialect 70//===----------------------------------------------------------------------===// 71 72def AsmATT : LLVM_EnumAttrCase< 73 /*string cppSym=*/"AD_ATT", /*string irSym=*/"att", 74 /*string llvmSym=*/"AD_ATT", /*int val=*/0>; 75def AsmIntel : LLVM_EnumAttrCase< 76 /*string cppSym=*/"AD_Intel", /*string irSym=*/"intel", 77 /*string llvmSym=*/"AD_Intel", /*int val=*/1>; 78def AsmATTOrIntel : LLVM_EnumAttr< 79 /*string name=*/"AsmDialect", 80 /*string llvmName=*/"::llvm::InlineAsm::AsmDialect", 81 /*string description=*/"ATT (0) or Intel (1) asm dialect", 82 /*list<LLVM_EnumAttrCase> cases=*/[AsmATT, AsmIntel]> { 83 let cppNamespace = "::mlir::LLVM"; 84} 85 86//===----------------------------------------------------------------------===// 87// Atomic Operations 88//===----------------------------------------------------------------------===// 89 90def AtomicBinOpXchg : LLVM_EnumAttrCase<"xchg", "xchg", "Xchg", 0>; 91def AtomicBinOpAdd : LLVM_EnumAttrCase<"add", "add", "Add", 1>; 92def AtomicBinOpSub : LLVM_EnumAttrCase<"sub", "sub", "Sub", 2>; 93def AtomicBinOpAnd : LLVM_EnumAttrCase<"_and", "_and", "And", 3>; 94def AtomicBinOpNand : LLVM_EnumAttrCase<"nand", "nand", "Nand", 4>; 95def AtomicBinOpOr : LLVM_EnumAttrCase<"_or", "_or", "Or", 5>; 96def AtomicBinOpXor : LLVM_EnumAttrCase<"_xor", "_xor", "Xor", 6>; 97def AtomicBinOpMax : LLVM_EnumAttrCase<"max", "max", "Max", 7>; 98def AtomicBinOpMin : LLVM_EnumAttrCase<"min", "min", "Min", 8>; 99def AtomicBinOpUMax : LLVM_EnumAttrCase<"umax", "umax", "UMax", 9>; 100def AtomicBinOpUMin : LLVM_EnumAttrCase<"umin", "umin", "UMin", 10>; 101def AtomicBinOpFAdd : LLVM_EnumAttrCase<"fadd", "fadd", "FAdd", 11>; 102def AtomicBinOpFSub : LLVM_EnumAttrCase<"fsub", "fsub", "FSub", 12>; 103def AtomicBinOpFMax : LLVM_EnumAttrCase<"fmax", "fmax", "FMax", 13>; 104def AtomicBinOpFMin : LLVM_EnumAttrCase<"fmin", "fmin", "FMin", 14>; 105def AtomicBinOpUIncWrap : LLVM_EnumAttrCase<"uinc_wrap", 106 "uinc_wrap", "UIncWrap", 15>; 107def AtomicBinOpUDecWrap : LLVM_EnumAttrCase<"udec_wrap", 108 "udec_wrap", "UDecWrap", 16>; 109def AtomicBinOpUSubCond : LLVM_EnumAttrCase<"usub_cond", 110 "usub_cond", "USubCond", 17>; 111def AtomicBinOpUSubSat : LLVM_EnumAttrCase<"usub_sat", 112 "usub_sat", "USubSat", 18>; 113 114// A sentinel value that has no MLIR counterpart. 115def AtomicBadBinOp : LLVM_EnumAttrCase<"", "", "BAD_BINOP", 0>; 116 117def AtomicBinOp : LLVM_EnumAttr< 118 "AtomicBinOp", 119 "::llvm::AtomicRMWInst::BinOp", 120 "llvm.atomicrmw binary operations", 121 [AtomicBinOpXchg, AtomicBinOpAdd, AtomicBinOpSub, AtomicBinOpAnd, 122 AtomicBinOpNand, AtomicBinOpOr, AtomicBinOpXor, AtomicBinOpMax, 123 AtomicBinOpMin, AtomicBinOpUMax, AtomicBinOpUMin, AtomicBinOpFAdd, 124 AtomicBinOpFSub, AtomicBinOpFMax, AtomicBinOpFMin, AtomicBinOpUIncWrap, 125 AtomicBinOpUDecWrap, AtomicBinOpUSubCond, AtomicBinOpUSubSat], 126 [AtomicBadBinOp]> { 127 let cppNamespace = "::mlir::LLVM"; 128} 129 130def AtomicOrderingNotAtomic : LLVM_EnumAttrCase<"not_atomic", 131 "not_atomic", "NotAtomic", 0>; 132def AtomicOrderingUnordered : LLVM_EnumAttrCase<"unordered", 133 "unordered", "Unordered", 1>; 134def AtomicOrderingMonotonic : LLVM_EnumAttrCase<"monotonic", 135 "monotonic", "Monotonic", 2>; 136def AtomicOrderingAcquire : LLVM_EnumAttrCase<"acquire", 137 "acquire", "Acquire", 4>; 138def AtomicOrderingRelease : LLVM_EnumAttrCase<"release", 139 "release", "Release", 5>; 140def AtomicOrderingAcquireRelease : 141 LLVM_EnumAttrCase<"acq_rel", "acq_rel", "AcquireRelease", 6>; 142def AtomicOrderingSequentiallyConsistent : 143 LLVM_EnumAttrCase<"seq_cst", "seq_cst", "SequentiallyConsistent", 7>; 144def AtomicOrdering : LLVM_EnumAttr< 145 "AtomicOrdering", 146 "::llvm::AtomicOrdering", 147 "Atomic ordering for LLVM's memory model", 148 [AtomicOrderingNotAtomic, AtomicOrderingUnordered, AtomicOrderingMonotonic, 149 AtomicOrderingAcquire, AtomicOrderingRelease, AtomicOrderingAcquireRelease, 150 AtomicOrderingSequentiallyConsistent 151 ]> { 152 let cppNamespace = "::mlir::LLVM"; 153} 154 155//===----------------------------------------------------------------------===// 156// CallingConvention 157//===----------------------------------------------------------------------===// 158 159// These values must match llvm::CallingConv ones. 160// See https://llvm.org/doxygen/namespacellvm_1_1CallingConv.html for full list 161// of supported calling conventions. 162def CConvC : LLVM_EnumAttrCase<"C", "ccc", "C", 0>; 163def CConvFast : LLVM_EnumAttrCase<"Fast", "fastcc", "Fast", 8>; 164def CConvCold : LLVM_EnumAttrCase<"Cold", "coldcc", "Cold", 9>; 165def CConvGHC : LLVM_EnumAttrCase<"GHC", "cc_10", "GHC", 10>; 166def CConvHiPE : LLVM_EnumAttrCase<"HiPE", "cc_11", "HiPE", 11>; 167def CConvAnyReg : LLVM_EnumAttrCase<"AnyReg", "anyregcc", "AnyReg", 13>; 168def CConvPreserveMost : LLVM_EnumAttrCase<"PreserveMost", "preserve_mostcc", 169 "PreserveMost", 14>; 170def CConvPreserveAll : LLVM_EnumAttrCase<"PreserveAll", "preserve_allcc", 171 "PreserveAll", 15>; 172def CConvSwift : LLVM_EnumAttrCase<"Swift", "swiftcc", "Swift", 16>; 173def CConvCXXFastTLS : LLVM_EnumAttrCase<"CXX_FAST_TLS", "cxx_fast_tlscc", 174 "CXX_FAST_TLS", 17>; 175def CConvTail : LLVM_EnumAttrCase<"Tail", "tailcc", "Tail", 18>; 176def CConvCFGuard_Check : LLVM_EnumAttrCase<"CFGuard_Check", 177 "cfguard_checkcc", 178 "CFGuard_Check", 19>; 179def CConvSwiftTail : LLVM_EnumAttrCase<"SwiftTail", "swifttailcc", 180 "SwiftTail", 20>; 181def CConvX86_StdCall : LLVM_EnumAttrCase<"X86_StdCall", "x86_stdcallcc", 182 "X86_StdCall", 64>; 183def CConvX86_FastCall : LLVM_EnumAttrCase<"X86_FastCall", "x86_fastcallcc", 184 "X86_FastCall", 65>; 185def CConvARM_APCS : LLVM_EnumAttrCase<"ARM_APCS", "arm_apcscc", "ARM_APCS", 66>; 186def CConvARM_AAPCS : LLVM_EnumAttrCase<"ARM_AAPCS", "arm_aapcscc", "ARM_AAPCS", 187 67>; 188def CConvARM_AAPCS_VFP : LLVM_EnumAttrCase<"ARM_AAPCS_VFP", "arm_aapcs_vfpcc", 189 "ARM_AAPCS_VFP", 68>; 190def CConvMSP430_INTR : LLVM_EnumAttrCase<"MSP430_INTR", "msp430_intrcc", 191 "MSP430_INTR", 69>; 192def CConvX86_ThisCall : LLVM_EnumAttrCase<"X86_ThisCall", "x86_thiscallcc", 193 "X86_ThisCall", 70>; 194def CConvPTX_Kernel : LLVM_EnumAttrCase<"PTX_Kernel", "ptx_kernelcc", 195 "PTX_Kernel", 71>; 196def CConvPTX_Device : LLVM_EnumAttrCase<"PTX_Device", "ptx_devicecc", 197 "PTX_Device", 72>; 198def CConvSPIR_FUNC : LLVM_EnumAttrCase<"SPIR_FUNC", "spir_funccc", 199 "SPIR_FUNC", 75>; 200def CConvSPIR_KERNEL : LLVM_EnumAttrCase<"SPIR_KERNEL", "spir_kernelcc", 201 "SPIR_KERNEL", 76>; 202def CConvIntel_OCL_BI : LLVM_EnumAttrCase<"Intel_OCL_BI", "intel_ocl_bicc", 203 "Intel_OCL_BI", 77>; 204def CConvX86_64_SysV : LLVM_EnumAttrCase<"X86_64_SysV", "x86_64_sysvcc", 205 "X86_64_SysV", 78>; 206def CConvWin64 : LLVM_EnumAttrCase<"Win64", "win64cc", "Win64", 79>; 207def CConvX86_VectorCall : LLVM_EnumAttrCase<"X86_VectorCall", 208 "x86_vectorcallcc", 209 "X86_VectorCall", 80>; 210def CConvHHVM : LLVM_EnumAttrCase<"DUMMY_HHVM", "hhvmcc", "DUMMY_HHVM", 81>; 211def CConvHHVM_C 212 : LLVM_EnumAttrCase<"DUMMY_HHVM_C", "hhvm_ccc", "DUMMY_HHVM_C", 82>; 213def CConvX86_INTR : LLVM_EnumAttrCase<"X86_INTR", "x86_intrcc", "X86_INTR", 83>; 214def CConvAVR_INTR : LLVM_EnumAttrCase<"AVR_INTR", "avr_intrcc", "AVR_INTR", 84>; 215def CConvAVR_SIGNAL : LLVM_EnumAttrCase<"AVR_SIGNAL", "avr_signalcc", 216 "AVR_SIGNAL", 85>; 217def CConvAVR_BUILTIN : LLVM_EnumAttrCase<"AVR_BUILTIN", "avr_builtincc", 218 "AVR_BUILTIN", 86>; 219def CConvAMDGPU_VS : LLVM_EnumAttrCase<"AMDGPU_VS", "amdgpu_vscc", "AMDGPU_VS", 220 87>; 221def CConvAMDGPU_GS : LLVM_EnumAttrCase<"AMDGPU_GS", "amdgpu_gscc", "AMDGPU_GS", 222 88>; 223def CConvAMDGPU_PS : LLVM_EnumAttrCase<"AMDGPU_PS", "amdgpu_pscc", "AMDGPU_PS", 224 89>; 225def CConvAMDGPU_CS : LLVM_EnumAttrCase<"AMDGPU_CS", "amdgpu_cscc", "AMDGPU_CS", 226 90>; 227def CConvAMDGPU_KERNEL : LLVM_EnumAttrCase<"AMDGPU_KERNEL", "amdgpu_kernelcc", 228 "AMDGPU_KERNEL", 91>; 229def CConvX86_RegCall : LLVM_EnumAttrCase<"X86_RegCall", "x86_regcallcc", 230 "X86_RegCall", 92>; 231def CConvAMDGPU_HS : LLVM_EnumAttrCase<"AMDGPU_HS", "amdgpu_hscc", "AMDGPU_HS", 232 93>; 233def CConvMSP430_BUILTIN : LLVM_EnumAttrCase<"MSP430_BUILTIN", 234 "msp430_builtincc", 235 "MSP430_BUILTIN", 94>; 236def CConvAMDGPU_LS : LLVM_EnumAttrCase<"AMDGPU_LS", "amdgpu_lscc", "AMDGPU_LS", 237 95>; 238def CConvAMDGPU_ES : LLVM_EnumAttrCase<"AMDGPU_ES", "amdgpu_escc", "AMDGPU_ES", 239 96>; 240def CConvAArch64_VectorCall : LLVM_EnumAttrCase<"AArch64_VectorCall", 241 "aarch64_vectorcallcc", 242 "AArch64_VectorCall", 97>; 243def CConvAArch64_SVE_VectorCall : LLVM_EnumAttrCase<"AArch64_SVE_VectorCall", 244 "aarch64_sve_vectorcallcc", 245 "AArch64_SVE_VectorCall", 246 98>; 247def CConvWASM_EmscriptenInvoke : LLVM_EnumAttrCase<"WASM_EmscriptenInvoke", 248 "wasm_emscripten_invokecc", 249 "WASM_EmscriptenInvoke", 99>; 250def CConvAMDGPU_Gfx : LLVM_EnumAttrCase<"AMDGPU_Gfx", "amdgpu_gfxcc", 251 "AMDGPU_Gfx", 100>; 252def CConvM68k_INTR : LLVM_EnumAttrCase<"M68k_INTR", "m68k_intrcc", "M68k_INTR", 253 101>; 254 255def CConvEnum : LLVM_CEnumAttr< 256 "CConv", 257 "::llvm::CallingConv", 258 "Calling Conventions", 259 [CConvC, CConvFast, CConvCold, CConvGHC, CConvHiPE, 260 CConvAnyReg, CConvPreserveMost, CConvPreserveAll, CConvSwift, 261 CConvCXXFastTLS, CConvTail, CConvCFGuard_Check, CConvSwiftTail, 262 CConvX86_StdCall, CConvX86_FastCall, CConvARM_APCS, 263 CConvARM_AAPCS, CConvARM_AAPCS_VFP, CConvMSP430_INTR, CConvX86_ThisCall, 264 CConvPTX_Kernel, CConvPTX_Device, CConvSPIR_FUNC, CConvSPIR_KERNEL, 265 CConvIntel_OCL_BI, CConvX86_64_SysV, CConvWin64, CConvX86_VectorCall, 266 CConvHHVM, CConvHHVM_C, CConvX86_INTR, CConvAVR_INTR, CConvAVR_BUILTIN, 267 CConvAMDGPU_VS, CConvAMDGPU_GS, CConvAMDGPU_CS, CConvAMDGPU_KERNEL, 268 CConvX86_RegCall, CConvAMDGPU_HS, CConvMSP430_BUILTIN, CConvAMDGPU_LS, 269 CConvAMDGPU_ES, CConvAArch64_VectorCall, CConvAArch64_SVE_VectorCall, 270 CConvWASM_EmscriptenInvoke, CConvAMDGPU_Gfx, CConvM68k_INTR 271 ]> { 272 let cppNamespace = "::mlir::LLVM::cconv"; 273} 274 275def CConv : DialectAttr< 276 LLVM_Dialect, 277 CPred<"::llvm::isa<::mlir::LLVM::CConvAttr>($_self)">, 278 "LLVM Calling Convention specification"> { 279 let storageType = "::mlir::LLVM::CConvAttr"; 280 let returnType = "::mlir::LLVM::cconv::CConv"; 281 let convertFromStorage = "$_self.getCallingConv()"; 282 let constBuilderCall = 283 "::mlir::LLVM::CConvAttr::get($_builder.getContext(), $0)"; 284} 285 286//===----------------------------------------------------------------------===// 287// TailCallKind 288//===----------------------------------------------------------------------===// 289 290def TailCallKindNone : LLVM_EnumAttrCase<"None", "none", "TCK_None", 0>; 291def TailCallKindTail : LLVM_EnumAttrCase<"Tail", "tail", "TCK_Tail", 1>; 292def TailCallKindMustTail : LLVM_EnumAttrCase<"MustTail", "musttail", "TCK_MustTail", 2>; 293def TailCallKindNoTailCall : LLVM_EnumAttrCase<"NoTail", "notail", "TCK_NoTail", 3>; 294 295def TailCallKindEnum : LLVM_EnumAttr< 296 "TailCallKind", 297 "::llvm::CallInst::TailCallKind", 298 "Tail Call Kind", 299 [TailCallKindNone, TailCallKindNoTailCall, 300 TailCallKindMustTail, TailCallKindTail]> { 301 let cppNamespace = "::mlir::LLVM::tailcallkind"; 302} 303 304def TailCallKind : DialectAttr< 305 LLVM_Dialect, 306 CPred<"::llvm::isa<::mlir::LLVM::TailCallKindAttr>($_self)">, 307 "LLVM Calling Convention specification"> { 308 let storageType = "::mlir::LLVM::TailCallKindAttr"; 309 let returnType = "::mlir::LLVM::tailcallkind::TailCallKind"; 310 let convertFromStorage = "$_self.getTailCallKind()"; 311 let constBuilderCall = 312 "::mlir::LLVM::TailCallKindAttr::get($_builder.getContext(), $0)"; 313} 314 315//===----------------------------------------------------------------------===// 316// DIEmissionKind 317//===----------------------------------------------------------------------===// 318 319def LLVM_DIEmissionNone : I64EnumAttrCase<"None", 0>; 320def LLVM_DIEmissionFull : I64EnumAttrCase<"Full", 1>; 321def LLVM_DIEmissionLineTablesOnly : I64EnumAttrCase<"LineTablesOnly", 2>; 322def LLVM_DIEmissionDebugDirectivesOnly : I64EnumAttrCase<"DebugDirectivesOnly", 3>; 323 324def LLVM_DIEmissionKind : I64EnumAttr< 325 "DIEmissionKind", 326 "LLVM debug emission kind", [ 327 LLVM_DIEmissionNone, 328 LLVM_DIEmissionFull, 329 LLVM_DIEmissionLineTablesOnly, 330 LLVM_DIEmissionDebugDirectivesOnly, 331 ]> { 332 let cppNamespace = "::mlir::LLVM"; 333} 334 335//===----------------------------------------------------------------------===// 336// DIFlags 337//===----------------------------------------------------------------------===// 338 339def LLVM_DIFlagZero : I32BitEnumAttrCaseNone<"Zero">; 340 341// The first two bits are used for a visibility enum. 342// * Private = 1 343// * Protected = 2 344// * Public = 3 345def LLVM_DIFlagVisibilityBit0 : I32BitEnumAttrCaseBit<"Bit0", 0>; 346def LLVM_DIFlagVisibilityBit1 : I32BitEnumAttrCaseBit<"Bit1", 1>; 347def LLVM_DIFlagPrivate : I32BitEnumAttrCaseGroup<"Private", 348 [LLVM_DIFlagVisibilityBit0] 349>; 350def LLVM_DIFlagProtected : I32BitEnumAttrCaseGroup<"Protected", 351 [LLVM_DIFlagVisibilityBit1] 352>; 353def LLVM_DIFlagPublic : I32BitEnumAttrCaseGroup<"Public", 354 [LLVM_DIFlagVisibilityBit0, LLVM_DIFlagVisibilityBit1] 355>; 356 357// The remaining bits are used for the various flags. 358def LLVM_DIFlagFwdDecl : I32BitEnumAttrCaseBit<"FwdDecl", 2>; 359def LLVM_DIFlagAppleBlock : I32BitEnumAttrCaseBit<"AppleBlock", 3>; 360def LLVM_DIFlagReservedBit4 : I32BitEnumAttrCaseBit<"ReservedBit4", 4>; 361def LLVM_DIFlagVirtual : I32BitEnumAttrCaseBit<"Virtual", 5>; 362def LLVM_DIFlagArtificial : I32BitEnumAttrCaseBit<"Artificial", 6>; 363def LLVM_DIFlagExplicit : I32BitEnumAttrCaseBit<"Explicit", 7>; 364def LLVM_DIFlagPrototyped : I32BitEnumAttrCaseBit<"Prototyped", 8>; 365def LLVM_DIFlagObjcClassComplete : I32BitEnumAttrCaseBit<"ObjcClassComplete", 9>; 366def LLVM_DIFlagObjectPointer : I32BitEnumAttrCaseBit<"ObjectPointer", 10>; 367def LLVM_DIFlagVector : I32BitEnumAttrCaseBit<"Vector", 11>; 368def LLVM_DIFlagStaticMember : I32BitEnumAttrCaseBit<"StaticMember", 12>; 369def LLVM_DIFlagLValueReference : I32BitEnumAttrCaseBit<"LValueReference", 13>; 370def LLVM_DIFlagRValueReference : I32BitEnumAttrCaseBit<"RValueReference", 14>; 371def LLVM_DIFlagExportSymbols : I32BitEnumAttrCaseBit<"ExportSymbols", 15>; 372def LLVM_DIFlagSingleInheritance : I32BitEnumAttrCaseBit<"SingleInheritance", 16>; 373def LLVM_DIFlagMultipleInheritance : I32BitEnumAttrCaseBit<"MultipleInheritance", 16>; 374def LLVM_DIFlagVirtualInheritance : I32BitEnumAttrCaseBit<"VirtualInheritance", 16>; 375def LLVM_DIFlagIntroducedVirtual : I32BitEnumAttrCaseBit<"IntroducedVirtual", 18>; 376def LLVM_DIFlagBitField : I32BitEnumAttrCaseBit<"BitField", 19>; 377def LLVM_DIFlagNoReturn : I32BitEnumAttrCaseBit<"NoReturn", 20>; 378def LLVM_DIFlagTypePassByValue : I32BitEnumAttrCaseBit<"TypePassByValue", 22>; 379def LLVM_DIFlagTypePassByReference : I32BitEnumAttrCaseBit<"TypePassByReference", 23>; 380def LLVM_DIFlagEnumClass : I32BitEnumAttrCaseBit<"EnumClass", 24>; 381def LLVM_DIFlagThunk : I32BitEnumAttrCaseBit<"Thunk", 25>; 382def LLVM_DIFlagNonTrivial : I32BitEnumAttrCaseBit<"NonTrivial", 26>; 383def LLVM_DIFlagBigEndian : I32BitEnumAttrCaseBit<"BigEndian", 27>; 384def LLVM_DIFlagLittleEndian : I32BitEnumAttrCaseBit<"LittleEndian", 28>; 385def LLVM_DIFlagAllCallsDescribed : I32BitEnumAttrCaseBit<"AllCallsDescribed", 29>; 386 387def DIFlags : I32BitEnumAttr< 388 "DIFlags", 389 "LLVM DI flags", [ 390 LLVM_DIFlagZero, 391 LLVM_DIFlagVisibilityBit0, 392 LLVM_DIFlagVisibilityBit1, 393 LLVM_DIFlagPrivate, 394 LLVM_DIFlagProtected, 395 LLVM_DIFlagPublic, 396 LLVM_DIFlagFwdDecl, 397 LLVM_DIFlagAppleBlock, 398 LLVM_DIFlagReservedBit4, 399 LLVM_DIFlagVirtual, 400 LLVM_DIFlagArtificial, 401 LLVM_DIFlagExplicit, 402 LLVM_DIFlagPrototyped, 403 LLVM_DIFlagObjcClassComplete, 404 LLVM_DIFlagObjectPointer, 405 LLVM_DIFlagVector, 406 LLVM_DIFlagStaticMember, 407 LLVM_DIFlagLValueReference, 408 LLVM_DIFlagRValueReference, 409 LLVM_DIFlagExportSymbols, 410 LLVM_DIFlagSingleInheritance, 411 LLVM_DIFlagMultipleInheritance, 412 LLVM_DIFlagVirtualInheritance, 413 LLVM_DIFlagIntroducedVirtual, 414 LLVM_DIFlagBitField, 415 LLVM_DIFlagNoReturn, 416 LLVM_DIFlagTypePassByValue, 417 LLVM_DIFlagTypePassByReference, 418 LLVM_DIFlagEnumClass, 419 LLVM_DIFlagThunk, 420 LLVM_DIFlagNonTrivial, 421 LLVM_DIFlagBigEndian, 422 LLVM_DIFlagLittleEndian, 423 LLVM_DIFlagAllCallsDescribed 424 ]> { 425 let cppNamespace = "::mlir::LLVM"; 426 let printBitEnumPrimaryGroups = 1; 427} 428 429//===----------------------------------------------------------------------===// 430// DINameTableKind 431//===----------------------------------------------------------------------===// 432 433def LLVM_DINameTableDefault : I64EnumAttrCase<"Default", 0>; 434def LLVM_DINameTableGNU : I64EnumAttrCase<"GNU", 1>; 435def LLVM_DINameTableNone : I64EnumAttrCase<"None", 2>; 436def LLVM_DINameTableApple : I64EnumAttrCase<"Apple", 3>; 437 438def LLVM_DINameTableKind : I64EnumAttr< 439 "DINameTableKind", 440 "LLVM debug name table kind", [ 441 LLVM_DINameTableDefault, 442 LLVM_DINameTableGNU, 443 LLVM_DINameTableNone, 444 LLVM_DINameTableApple, 445 ]> { 446 let cppNamespace = "::mlir::LLVM"; 447} 448 449//===----------------------------------------------------------------------===// 450// DISubprogramFlags 451//===----------------------------------------------------------------------===// 452 453def LLVM_DISPVirtual : I32BitEnumAttrCaseBit<"Virtual", 0>; 454def LLVM_DISPPureVirtual : I32BitEnumAttrCaseBit<"PureVirtual", 1>; 455def LLVM_DISPLocalToUnit : I32BitEnumAttrCaseBit<"LocalToUnit", 2>; 456def LLVM_DISPDefinition : I32BitEnumAttrCaseBit<"Definition", 3>; 457def LLVM_DISPOptimized : I32BitEnumAttrCaseBit<"Optimized", 4>; 458def LLVM_DISPPure : I32BitEnumAttrCaseBit<"Pure", 5>; 459def LLVM_DISPElemental : I32BitEnumAttrCaseBit<"Elemental", 6>; 460def LLVM_DISPRecursive : I32BitEnumAttrCaseBit<"Recursive", 7>; 461def LLVM_DISPMainSubprogram : I32BitEnumAttrCaseBit<"MainSubprogram", 8>; 462def LLVM_DISPDeleted : I32BitEnumAttrCaseBit<"Deleted", 9>; 463def LLVM_DISPObjCDirect : I32BitEnumAttrCaseBit<"ObjCDirect", 11>; 464 465def DISubprogramFlags : I32BitEnumAttr< 466 "DISubprogramFlags", 467 "LLVM DISubprogram flags", [ 468 LLVM_DISPVirtual, 469 LLVM_DISPPureVirtual, 470 LLVM_DISPLocalToUnit, 471 LLVM_DISPDefinition, 472 LLVM_DISPOptimized, 473 LLVM_DISPPure, 474 LLVM_DISPElemental, 475 LLVM_DISPRecursive, 476 LLVM_DISPMainSubprogram, 477 LLVM_DISPDeleted, 478 LLVM_DISPObjCDirect 479 ]> { 480 let cppNamespace = "::mlir::LLVM"; 481 let printBitEnumPrimaryGroups = 1; 482} 483 484//===----------------------------------------------------------------------===// 485// IntegerOverflowFlags 486//===----------------------------------------------------------------------===// 487 488def IOFnone : I32BitEnumAttrCaseNone<"none">; 489def IOFnsw : I32BitEnumAttrCaseBit<"nsw", 0>; 490def IOFnuw : I32BitEnumAttrCaseBit<"nuw", 1>; 491 492def IntegerOverflowFlags : I32BitEnumAttr< 493 "IntegerOverflowFlags", 494 "LLVM integer overflow flags", 495 [IOFnone, IOFnsw, IOFnuw]> { 496 let separator = ", "; 497 let cppNamespace = "::mlir::LLVM"; 498 let genSpecializedAttr = 0; 499 let printBitEnumPrimaryGroups = 1; 500} 501 502def LLVM_IntegerOverflowFlagsAttr : 503 EnumAttr<LLVM_Dialect, IntegerOverflowFlags, "overflow"> { 504 let assemblyFormat = "`<` $value `>`"; 505} 506 507//===----------------------------------------------------------------------===// 508// FastmathFlags 509//===----------------------------------------------------------------------===// 510 511def FMFnone : I32BitEnumAttrCaseNone<"none">; 512def FMFnnan : I32BitEnumAttrCaseBit<"nnan", 0>; 513def FMFninf : I32BitEnumAttrCaseBit<"ninf", 1>; 514def FMFnsz : I32BitEnumAttrCaseBit<"nsz", 2>; 515def FMFarcp : I32BitEnumAttrCaseBit<"arcp", 3>; 516def FMFcontract : I32BitEnumAttrCaseBit<"contract", 4>; 517def FMFafn : I32BitEnumAttrCaseBit<"afn", 5>; 518def FMFreassoc : I32BitEnumAttrCaseBit<"reassoc", 6>; 519def FMFfast : I32BitEnumAttrCaseGroup<"fast", 520 [ FMFnnan, FMFninf, FMFnsz, FMFarcp, FMFcontract, FMFafn, FMFreassoc]>; 521 522def FastmathFlags : I32BitEnumAttr< 523 "FastmathFlags", 524 "LLVM fastmath flags", 525 [FMFnone, FMFnnan, FMFninf, FMFnsz, FMFarcp, FMFcontract, FMFafn, 526 FMFreassoc, FMFfast]> { 527 let separator = ", "; 528 let cppNamespace = "::mlir::LLVM"; 529 let genSpecializedAttr = 0; 530 let printBitEnumPrimaryGroups = 1; 531} 532 533def LLVM_FastmathFlagsAttr : 534 EnumAttr<LLVM_Dialect, FastmathFlags, "fastmath"> { 535 let assemblyFormat = "`<` $value `>`"; 536} 537 538//===----------------------------------------------------------------------===// 539// FCmp and ICmp Predicates 540//===----------------------------------------------------------------------===// 541 542// Predicates for float comparisons 543def FCmpPredicateFALSE : LLVM_EnumAttrCase<"_false", "_false", "FCMP_FALSE", 0>; 544def FCmpPredicateOEQ : LLVM_EnumAttrCase<"oeq", "oeq", "FCMP_OEQ", 1>; 545def FCmpPredicateOGT : LLVM_EnumAttrCase<"ogt", "ogt", "FCMP_OGT", 2>; 546def FCmpPredicateOGE : LLVM_EnumAttrCase<"oge", "oge", "FCMP_OGE", 3>; 547def FCmpPredicateOLT : LLVM_EnumAttrCase<"olt", "olt", "FCMP_OLT", 4>; 548def FCmpPredicateOLE : LLVM_EnumAttrCase<"ole", "ole", "FCMP_OLE", 5>; 549def FCmpPredicateONE : LLVM_EnumAttrCase<"one", "one", "FCMP_ONE", 6>; 550def FCmpPredicateORD : LLVM_EnumAttrCase<"ord", "ord", "FCMP_ORD", 7>; 551def FCmpPredicateUEQ : LLVM_EnumAttrCase<"ueq", "ueq", "FCMP_UEQ", 8>; 552def FCmpPredicateUGT : LLVM_EnumAttrCase<"ugt", "ugt", "FCMP_UGT", 9>; 553def FCmpPredicateUGE : LLVM_EnumAttrCase<"uge", "uge", "FCMP_UGE", 10>; 554def FCmpPredicateULT : LLVM_EnumAttrCase<"ult", "ult", "FCMP_ULT", 11>; 555def FCmpPredicateULE : LLVM_EnumAttrCase<"ule", "ule", "FCMP_ULE", 12>; 556def FCmpPredicateUNE : LLVM_EnumAttrCase<"une", "une", "FCMP_UNE", 13>; 557def FCmpPredicateUNO : LLVM_EnumAttrCase<"uno", "uno", "FCMP_UNO", 14>; 558def FCmpPredicateTRUE : LLVM_EnumAttrCase<"_true", "_true", "FCMP_TRUE", 15>; 559 560// A sentinel value that has no MLIR counterpart. 561def ICmpPredicateBad : LLVM_EnumAttrCase<"", "", "BAD_ICMP_PREDICATE", 0>; 562 563// Predicates for integer comparisons. 564def ICmpPredicateEQ : LLVM_EnumAttrCase<"eq", "eq", "ICMP_EQ", 0>; 565def ICmpPredicateNE : LLVM_EnumAttrCase<"ne", "ne", "ICMP_NE", 1>; 566def ICmpPredicateSLT : LLVM_EnumAttrCase<"slt", "slt", "ICMP_SLT", 2>; 567def ICmpPredicateSLE : LLVM_EnumAttrCase<"sle", "sle", "ICMP_SLE", 3>; 568def ICmpPredicateSGT : LLVM_EnumAttrCase<"sgt", "sgt", "ICMP_SGT", 4>; 569def ICmpPredicateSGE : LLVM_EnumAttrCase<"sge", "sge", "ICMP_SGE", 5>; 570def ICmpPredicateULT : LLVM_EnumAttrCase<"ult", "ult", "ICMP_ULT", 6>; 571def ICmpPredicateULE : LLVM_EnumAttrCase<"ule", "ule", "ICMP_ULE", 7>; 572def ICmpPredicateUGT : LLVM_EnumAttrCase<"ugt", "ugt", "ICMP_UGT", 8>; 573def ICmpPredicateUGE : LLVM_EnumAttrCase<"uge", "uge", "ICMP_UGE", 9>; 574 575// A sentinel value that has no MLIR counterpart. 576def FCmpPredicateBad : LLVM_EnumAttrCase<"", "", "BAD_FCMP_PREDICATE", 0>; 577 578// LLVM's predicate enum contains the floating-point and integer comparison 579// cases, while the LLVM dialect uses two separate enums. The floating-point 580// predicate enum thus defines all integer predicates as unsupported and 581// vice versa. 582def FCmpPredicate : LLVM_EnumAttr< 583 "FCmpPredicate", 584 "::llvm::CmpInst::Predicate", 585 "llvm.fcmp comparison predicate", 586 [FCmpPredicateFALSE, FCmpPredicateOEQ, FCmpPredicateOGT, FCmpPredicateOGE, 587 FCmpPredicateOLT, FCmpPredicateOLE, FCmpPredicateONE, FCmpPredicateORD, 588 FCmpPredicateUEQ, FCmpPredicateUGT, FCmpPredicateUGE, FCmpPredicateULT, 589 FCmpPredicateULE, FCmpPredicateUNE, FCmpPredicateUNO, FCmpPredicateTRUE], 590 [ICmpPredicateEQ, ICmpPredicateNE, ICmpPredicateSLT, ICmpPredicateSLE, 591 ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE, 592 ICmpPredicateUGT, ICmpPredicateUGE, FCmpPredicateBad, ICmpPredicateBad 593 ]> { 594 let cppNamespace = "::mlir::LLVM"; 595} 596 597def ICmpPredicate : LLVM_EnumAttr< 598 "ICmpPredicate", 599 "::llvm::CmpInst::Predicate", 600 "lvm.icmp comparison predicate", 601 [ICmpPredicateEQ, ICmpPredicateNE, ICmpPredicateSLT, ICmpPredicateSLE, 602 ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE, 603 ICmpPredicateUGT, ICmpPredicateUGE], 604 [FCmpPredicateFALSE, FCmpPredicateOEQ, FCmpPredicateOGT, FCmpPredicateOGE, 605 FCmpPredicateOLT, FCmpPredicateOLE, FCmpPredicateONE, FCmpPredicateORD, 606 FCmpPredicateUEQ, FCmpPredicateUGT, FCmpPredicateUGE, FCmpPredicateULT, 607 FCmpPredicateULE, FCmpPredicateUNE, FCmpPredicateUNO, FCmpPredicateTRUE, 608 FCmpPredicateBad, ICmpPredicateBad 609 ]> { 610 let cppNamespace = "::mlir::LLVM"; 611} 612 613//===----------------------------------------------------------------------===// 614// Linkage 615//===----------------------------------------------------------------------===// 616 617// Linkage attribute is used on functions and globals. The order follows that of 618// llvm::GlobalValue::LinkageTypes from llvm/IR/GlobalValue.h. The names are 619// equivalent to visible names in the IR rather than to enum values names in 620// llvm::GlobalValue since the latter is easier to change. 621def LinkageExternal 622 : LLVM_EnumAttrCase<"External", "external", "ExternalLinkage", 0>; 623def LinkageAvailableExternally 624 : LLVM_EnumAttrCase<"AvailableExternally", "available_externally", 625 "AvailableExternallyLinkage", 1>; 626def LinkageLinkonce 627 : LLVM_EnumAttrCase<"Linkonce", "linkonce", "LinkOnceAnyLinkage", 2>; 628def LinkageLinkonceODR 629 : LLVM_EnumAttrCase<"LinkonceODR", "linkonce_odr", "LinkOnceODRLinkage", 3>; 630def LinkageWeak 631 : LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage", 4>; 632def LinkageWeakODR 633 : LLVM_EnumAttrCase<"WeakODR", "weak_odr", "WeakODRLinkage", 5>; 634def LinkageAppending 635 : LLVM_EnumAttrCase<"Appending", "appending", "AppendingLinkage", 6>; 636def LinkageInternal 637 : LLVM_EnumAttrCase<"Internal", "internal", "InternalLinkage", 7>; 638def LinkagePrivate 639 : LLVM_EnumAttrCase<"Private", "private", "PrivateLinkage", 8>; 640def LinkageExternWeak 641 : LLVM_EnumAttrCase<"ExternWeak", "extern_weak", "ExternalWeakLinkage", 9>; 642def LinkageCommon 643 : LLVM_EnumAttrCase<"Common", "common", "CommonLinkage", 10>; 644 645def LinkageEnum : LLVM_EnumAttr< 646 "Linkage", 647 "::llvm::GlobalValue::LinkageTypes", 648 "LLVM linkage types", 649 [LinkageExternal, LinkageAvailableExternally, LinkageLinkonce, 650 LinkageLinkonceODR, LinkageWeak, LinkageWeakODR, LinkageAppending, 651 LinkageInternal, LinkagePrivate, LinkageExternWeak, LinkageCommon]> { 652 let cppNamespace = "::mlir::LLVM::linkage"; 653} 654 655def Linkage : DialectAttr< 656 LLVM_Dialect, 657 CPred<"::llvm::isa<::mlir::LLVM::LinkageAttr>($_self)">, 658 "LLVM Linkage specification"> { 659 let storageType = "::mlir::LLVM::LinkageAttr"; 660 let returnType = "::mlir::LLVM::Linkage"; 661 let convertFromStorage = "$_self.getLinkage()"; 662 let constBuilderCall = 663 "::mlir::LLVM::LinkageAttr::get($_builder.getContext(), $0)"; 664} 665 666//===----------------------------------------------------------------------===// 667// Comdat 668//===----------------------------------------------------------------------===// 669 670def ComdatAny 671 : LLVM_EnumAttrCase<"Any", "any", "Any", 0>; 672def ComdatExactMatch 673 : LLVM_EnumAttrCase<"ExactMatch", "exactmatch", "ExactMatch", 1>; 674def ComdatLargest 675 : LLVM_EnumAttrCase<"Largest", "largest", "Largest", 2>; 676def ComdatNoDeduplicate 677 : LLVM_EnumAttrCase<"NoDeduplicate", "nodeduplicate", "NoDeduplicate", 3>; 678def ComdatSameSize 679 : LLVM_EnumAttrCase<"SameSize", "samesize", "SameSize", 4>; 680 681def Comdat : LLVM_EnumAttr< 682 "Comdat", 683 "::llvm::Comdat::SelectionKind", 684 "LLVM Comdat Types", 685 [ComdatAny, ComdatExactMatch, ComdatLargest, 686 ComdatNoDeduplicate, ComdatSameSize]> { 687 let cppNamespace = "::mlir::LLVM::comdat"; 688} 689 690//===----------------------------------------------------------------------===// 691// UnnamedAddr 692//===----------------------------------------------------------------------===// 693 694def UnnamedAddrNone : LLVM_EnumAttrCase<"None", "", "None", 0>; 695def UnnamedAddrLocal : LLVM_EnumAttrCase<"Local", "local_unnamed_addr", "Local", 1>; 696def UnnamedAddrGlobal : LLVM_EnumAttrCase<"Global", "unnamed_addr", "Global", 2>; 697 698def UnnamedAddr : LLVM_EnumAttr< 699 "UnnamedAddr", 700 "::llvm::GlobalValue::UnnamedAddr", 701 "LLVM GlobalValue UnnamedAddr", 702 [UnnamedAddrNone, UnnamedAddrLocal, UnnamedAddrGlobal]> { 703 let cppNamespace = "::mlir::LLVM"; 704} 705 706//===----------------------------------------------------------------------===// 707// Visibility 708//===----------------------------------------------------------------------===// 709 710def VisibilityDefault 711 : LLVM_EnumAttrCase<"Default", "", "DefaultVisibility", 0>; 712def VisibilityHidden 713 : LLVM_EnumAttrCase<"Hidden", "hidden", "HiddenVisibility", 1>; 714def VisibilityProtected 715 : LLVM_EnumAttrCase<"Protected", "protected", "ProtectedVisibility", 2>; 716 717def Visibility : LLVM_EnumAttr< 718 "Visibility", 719 "::llvm::GlobalValue::VisibilityTypes", 720 "LLVM GlobalValue Visibility", 721 [VisibilityDefault, VisibilityHidden, VisibilityProtected]> { 722 let cppNamespace = "::mlir::LLVM"; 723} 724 725//===----------------------------------------------------------------------===// 726// ModRefInfo 727//===----------------------------------------------------------------------===// 728 729def ModRefInfoNoModRef : LLVM_EnumAttrCase<"NoModRef", "none", "NoModRef", 0>; 730def ModRefInfoRef : LLVM_EnumAttrCase<"Ref", "read", "Ref", 1>; 731def ModRefInfoMod : LLVM_EnumAttrCase<"Mod", "write", "Mod", 2>; 732def ModRefInfoModRef : LLVM_EnumAttrCase<"ModRef", "readwrite", "ModRef", 3>; 733 734def ModRefInfoEnum : LLVM_EnumAttr< 735 "ModRefInfo", 736 "::llvm::ModRefInfo", 737 "LLVM ModRefInfo", 738 [ModRefInfoNoModRef, ModRefInfoRef, ModRefInfoMod, ModRefInfoModRef]> { 739 let cppNamespace = "::mlir::LLVM"; 740} 741 742//===----------------------------------------------------------------------===// 743// FramePointerKind 744//===----------------------------------------------------------------------===// 745 746def FramePointerKindNone 747 : LLVM_EnumAttrCase<"None", "none", "None", 0>; 748def FramePointerKindNonLeaf 749 : LLVM_EnumAttrCase<"NonLeaf", "non-leaf", "NonLeaf", 1>; 750def FramePointerKindAll 751 : LLVM_EnumAttrCase<"All", "all", "All", 2>; 752def FramePointerKindReserved 753 : LLVM_EnumAttrCase<"Reserved", "reserved", "Reserved", 3>; 754 755def FramePointerKindEnum : LLVM_EnumAttr< 756 "FramePointerKind", 757 "::llvm::FramePointerKind", 758 "LLVM FramePointerKind", 759 [FramePointerKindNone, FramePointerKindNonLeaf, 760 FramePointerKindAll, FramePointerKindReserved]> { 761 let cppNamespace = "::mlir::LLVM::framePointerKind"; 762} 763 764//===----------------------------------------------------------------------===// 765// RoundingMode 766//===----------------------------------------------------------------------===// 767 768// These values must match llvm::RoundingMode ones. 769// See llvm/include/llvm/ADT/FloatingPointMode.h. 770def RoundTowardZero 771 : LLVM_EnumAttrCase<"TowardZero", "towardzero", "TowardZero", 0>; 772def RoundNearestTiesToEven 773 : LLVM_EnumAttrCase<"NearestTiesToEven", "tonearest", "NearestTiesToEven", 1>; 774def RoundTowardPositive 775 : LLVM_EnumAttrCase<"TowardPositive", "upward", "TowardPositive", 2>; 776def RoundTowardNegative 777 : LLVM_EnumAttrCase<"TowardNegative", "downward", "TowardNegative", 3>; 778def RoundNearestTiesToAway 779 : LLVM_EnumAttrCase<"NearestTiesToAway", "tonearestaway", "NearestTiesToAway", 4>; 780def RoundDynamic 781 : LLVM_EnumAttrCase<"Dynamic", "dynamic", "Dynamic", 7>; 782// Needed as llvm::RoundingMode defines this. 783def RoundInvalid 784 : LLVM_EnumAttrCase<"Invalid", "invalid", "Invalid", -1>; 785 786// RoundingModeAttr should not be used in operations definitions. 787// Use ValidRoundingModeAttr instead. 788def RoundingModeAttr : LLVM_EnumAttr< 789 "RoundingMode", 790 "::llvm::RoundingMode", 791 "LLVM Rounding Mode", 792 [RoundTowardZero, RoundNearestTiesToEven, RoundTowardPositive, 793 RoundTowardNegative, RoundNearestTiesToAway, RoundDynamic, RoundInvalid]> { 794 let cppNamespace = "::mlir::LLVM"; 795} 796 797def ValidRoundingModeAttr : ConfinedAttr<RoundingModeAttr, [IntMinValue<0>]>; 798 799//===----------------------------------------------------------------------===// 800// FPExceptionBehavior 801//===----------------------------------------------------------------------===// 802 803// These values must match llvm::fp::ExceptionBehavior ones. 804// See llvm/include/llvm/IR/FPEnv.h. 805def FPExceptionBehaviorIgnore 806 : LLVM_EnumAttrCase<"Ignore", "ignore", "ebIgnore", 0>; 807def FPExceptionBehaviorMayTrap 808 : LLVM_EnumAttrCase<"MayTrap", "maytrap", "ebMayTrap", 1>; 809def FPExceptionBehaviorStrict 810 : LLVM_EnumAttrCase<"Strict", "strict", "ebStrict", 2>; 811 812def FPExceptionBehaviorAttr : LLVM_EnumAttr< 813 "FPExceptionBehavior", 814 "::llvm::fp::ExceptionBehavior", 815 "LLVM Exception Behavior", 816 [FPExceptionBehaviorIgnore, FPExceptionBehaviorMayTrap, 817 FPExceptionBehaviorStrict]> { 818 let cppNamespace = "::mlir::LLVM"; 819} 820 821#endif // LLVMIR_ENUMS 822