958 lines
43 KiB
TableGen
958 lines
43 KiB
TableGen
//===-- LLVMEnums.td - LLVM IR dialect enum file -----------*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVMIR_ENUMS
|
|
#define LLVMIR_ENUMS
|
|
|
|
include "mlir/Dialect/LLVMIR/LLVMDialect.td"
|
|
include "mlir/IR/EnumAttr.td"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Base classes for LLVM enum attributes.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Case of the LLVM enum attribute backed by I64Attr with customized string
|
|
// representation that corresponds to what is visible in the textual IR form.
|
|
// The parameters are as follows:
|
|
// - `cppSym`: name of the C++ enumerant for this case in MLIR API;
|
|
// - `irSym`: keyword used in the custom form of MLIR operation;
|
|
// - `llvmSym`: name of the C++ enumerant for this case in LLVM API.
|
|
// For example, `LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage">` is usable
|
|
// as `<MlirEnumName>::Weak` in MLIR API, `WeakAnyLinkage` in LLVM API and
|
|
// is printed/parsed as `weak` in MLIR custom textual format.
|
|
class LLVM_EnumAttrCase<string cppSym, string irSym, string llvmSym, int val> :
|
|
I64EnumAttrCase<cppSym, val, irSym> {
|
|
// The name of the equivalent enumerant in LLVM.
|
|
string llvmEnumerant = llvmSym;
|
|
}
|
|
|
|
// LLVM enum attribute backed by I64Attr with string representation
|
|
// corresponding to what is visible in the textual IR form.
|
|
// The parameters are as follows:
|
|
// - `name`: name of the C++ enum class in MLIR API;
|
|
// - `llvmName`: name of the C++ enum in LLVM API;
|
|
// - `description`: textual description for documentation purposes;
|
|
// - `cases`: list of enum cases;
|
|
// - `unsupportedCases`: optional list of unsupported enum cases.
|
|
// For example, `LLVM_EnumAttr<Linkage, "::llvm::GlobalValue::LinkageTypes`
|
|
// produces `mlir::LLVM::Linkage` enum class in MLIR API that corresponds to (a
|
|
// subset of) values in the `llvm::GlobalValue::LinkageTypes` in LLVM API.
|
|
// All unsupported cases are excluded from the MLIR enum and trigger an error
|
|
// during the import from LLVM IR. They are useful to handle sentinel values
|
|
// such as `llvm::AtomicRMWInst::BinOp::BAD_BINOP` that LLVM commonly uses to
|
|
// terminate its enums.
|
|
class LLVM_EnumAttr<string name, string llvmName, string description,
|
|
list<LLVM_EnumAttrCase> cases,
|
|
list<LLVM_EnumAttrCase> unsupportedCases = []> :
|
|
I64EnumAttr<name, description, cases> {
|
|
// List of unsupported cases that have no conversion to an MLIR value.
|
|
list<LLVM_EnumAttrCase> unsupported = unsupportedCases;
|
|
|
|
// The equivalent enum class name in LLVM.
|
|
string llvmClassName = llvmName;
|
|
}
|
|
|
|
// LLVM_CEnumAttr is functionally identical to LLVM_EnumAttr, but to be used for
|
|
// non-class enums.
|
|
class LLVM_CEnumAttr<string name, string llvmNS, string description,
|
|
list<LLVM_EnumAttrCase> cases> :
|
|
I64EnumAttr<name, description, cases> {
|
|
string llvmClassName = llvmNS;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// AsmDialect
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def AsmATT : LLVM_EnumAttrCase<
|
|
/*string cppSym=*/"AD_ATT", /*string irSym=*/"att",
|
|
/*string llvmSym=*/"AD_ATT", /*int val=*/0>;
|
|
def AsmIntel : LLVM_EnumAttrCase<
|
|
/*string cppSym=*/"AD_Intel", /*string irSym=*/"intel",
|
|
/*string llvmSym=*/"AD_Intel", /*int val=*/1>;
|
|
def AsmATTOrIntel : LLVM_EnumAttr<
|
|
/*string name=*/"AsmDialect",
|
|
/*string llvmName=*/"::llvm::InlineAsm::AsmDialect",
|
|
/*string description=*/"ATT (0) or Intel (1) asm dialect",
|
|
/*list<LLVM_EnumAttrCase> cases=*/[AsmATT, AsmIntel]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Atomic Operations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def AtomicBinOpXchg : LLVM_EnumAttrCase<"xchg", "xchg", "Xchg", 0>;
|
|
def AtomicBinOpAdd : LLVM_EnumAttrCase<"add", "add", "Add", 1>;
|
|
def AtomicBinOpSub : LLVM_EnumAttrCase<"sub", "sub", "Sub", 2>;
|
|
def AtomicBinOpAnd : LLVM_EnumAttrCase<"_and", "_and", "And", 3>;
|
|
def AtomicBinOpNand : LLVM_EnumAttrCase<"nand", "nand", "Nand", 4>;
|
|
def AtomicBinOpOr : LLVM_EnumAttrCase<"_or", "_or", "Or", 5>;
|
|
def AtomicBinOpXor : LLVM_EnumAttrCase<"_xor", "_xor", "Xor", 6>;
|
|
def AtomicBinOpMax : LLVM_EnumAttrCase<"max", "max", "Max", 7>;
|
|
def AtomicBinOpMin : LLVM_EnumAttrCase<"min", "min", "Min", 8>;
|
|
def AtomicBinOpUMax : LLVM_EnumAttrCase<"umax", "umax", "UMax", 9>;
|
|
def AtomicBinOpUMin : LLVM_EnumAttrCase<"umin", "umin", "UMin", 10>;
|
|
def AtomicBinOpFAdd : LLVM_EnumAttrCase<"fadd", "fadd", "FAdd", 11>;
|
|
def AtomicBinOpFSub : LLVM_EnumAttrCase<"fsub", "fsub", "FSub", 12>;
|
|
def AtomicBinOpFMax : LLVM_EnumAttrCase<"fmax", "fmax", "FMax", 13>;
|
|
def AtomicBinOpFMin : LLVM_EnumAttrCase<"fmin", "fmin", "FMin", 14>;
|
|
def AtomicBinOpUIncWrap : LLVM_EnumAttrCase<"uinc_wrap",
|
|
"uinc_wrap", "UIncWrap", 15>;
|
|
def AtomicBinOpUDecWrap : LLVM_EnumAttrCase<"udec_wrap",
|
|
"udec_wrap", "UDecWrap", 16>;
|
|
def AtomicBinOpUSubCond : LLVM_EnumAttrCase<"usub_cond",
|
|
"usub_cond", "USubCond", 17>;
|
|
def AtomicBinOpUSubSat : LLVM_EnumAttrCase<"usub_sat",
|
|
"usub_sat", "USubSat", 18>;
|
|
def AtomicBinOpFMaximum : LLVM_EnumAttrCase<"fmaximum", "fmaximum", "FMaximum", 19>;
|
|
def AtomicBinOpFMinimum : LLVM_EnumAttrCase<"fminimum", "fminimum", "FMinimum", 20>;
|
|
def AtomicBinOpFMaximumNum : LLVM_EnumAttrCase<"fmaximumnum", "fmaximumnum", "FMaximumNum", 21>;
|
|
def AtomicBinOpFMinimumNum : LLVM_EnumAttrCase<"fminimumnum", "fminimumnum", "FMinimumNum", 22>;
|
|
|
|
// A sentinel value that has no MLIR counterpart.
|
|
def AtomicBadBinOp : LLVM_EnumAttrCase<"", "", "BAD_BINOP", 0>;
|
|
|
|
def AtomicBinOp : LLVM_EnumAttr<
|
|
"AtomicBinOp",
|
|
"::llvm::AtomicRMWInst::BinOp",
|
|
"llvm.atomicrmw binary operations",
|
|
[AtomicBinOpXchg, AtomicBinOpAdd, AtomicBinOpSub, AtomicBinOpAnd,
|
|
AtomicBinOpNand, AtomicBinOpOr, AtomicBinOpXor, AtomicBinOpMax,
|
|
AtomicBinOpMin, AtomicBinOpUMax, AtomicBinOpUMin, AtomicBinOpFAdd,
|
|
AtomicBinOpFSub, AtomicBinOpFMax, AtomicBinOpFMin, AtomicBinOpUIncWrap,
|
|
AtomicBinOpUDecWrap, AtomicBinOpUSubCond, AtomicBinOpUSubSat,
|
|
AtomicBinOpFMaximum, AtomicBinOpFMinimum, AtomicBinOpFMaximumNum,
|
|
AtomicBinOpFMinimumNum],
|
|
[AtomicBadBinOp]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
def AtomicOrderingNotAtomic : LLVM_EnumAttrCase<"not_atomic",
|
|
"not_atomic", "NotAtomic", 0>;
|
|
def AtomicOrderingUnordered : LLVM_EnumAttrCase<"unordered",
|
|
"unordered", "Unordered", 1>;
|
|
def AtomicOrderingMonotonic : LLVM_EnumAttrCase<"monotonic",
|
|
"monotonic", "Monotonic", 2>;
|
|
def AtomicOrderingAcquire : LLVM_EnumAttrCase<"acquire",
|
|
"acquire", "Acquire", 4>;
|
|
def AtomicOrderingRelease : LLVM_EnumAttrCase<"release",
|
|
"release", "Release", 5>;
|
|
def AtomicOrderingAcquireRelease :
|
|
LLVM_EnumAttrCase<"acq_rel", "acq_rel", "AcquireRelease", 6>;
|
|
def AtomicOrderingSequentiallyConsistent :
|
|
LLVM_EnumAttrCase<"seq_cst", "seq_cst", "SequentiallyConsistent", 7>;
|
|
def AtomicOrdering : LLVM_EnumAttr<
|
|
"AtomicOrdering",
|
|
"::llvm::AtomicOrdering",
|
|
"Atomic ordering for LLVM's memory model",
|
|
[AtomicOrderingNotAtomic, AtomicOrderingUnordered, AtomicOrderingMonotonic,
|
|
AtomicOrderingAcquire, AtomicOrderingRelease, AtomicOrderingAcquireRelease,
|
|
AtomicOrderingSequentiallyConsistent
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// CallingConvention
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// These values must match llvm::CallingConv ones.
|
|
// See https://llvm.org/doxygen/namespacellvm_1_1CallingConv.html for full list
|
|
// of supported calling conventions.
|
|
def CConvC : LLVM_EnumAttrCase<"C", "ccc", "C", 0>;
|
|
def CConvFast : LLVM_EnumAttrCase<"Fast", "fastcc", "Fast", 8>;
|
|
def CConvCold : LLVM_EnumAttrCase<"Cold", "coldcc", "Cold", 9>;
|
|
def CConvGHC : LLVM_EnumAttrCase<"GHC", "cc_10", "GHC", 10>;
|
|
def CConvHiPE : LLVM_EnumAttrCase<"HiPE", "cc_11", "HiPE", 11>;
|
|
def CConvAnyReg : LLVM_EnumAttrCase<"AnyReg", "anyregcc", "AnyReg", 13>;
|
|
def CConvPreserveMost : LLVM_EnumAttrCase<"PreserveMost", "preserve_mostcc",
|
|
"PreserveMost", 14>;
|
|
def CConvPreserveAll : LLVM_EnumAttrCase<"PreserveAll", "preserve_allcc",
|
|
"PreserveAll", 15>;
|
|
def CConvSwift : LLVM_EnumAttrCase<"Swift", "swiftcc", "Swift", 16>;
|
|
def CConvCXXFastTLS : LLVM_EnumAttrCase<"CXX_FAST_TLS", "cxx_fast_tlscc",
|
|
"CXX_FAST_TLS", 17>;
|
|
def CConvTail : LLVM_EnumAttrCase<"Tail", "tailcc", "Tail", 18>;
|
|
def CConvCFGuard_Check : LLVM_EnumAttrCase<"CFGuard_Check",
|
|
"cfguard_checkcc",
|
|
"CFGuard_Check", 19>;
|
|
def CConvSwiftTail : LLVM_EnumAttrCase<"SwiftTail", "swifttailcc",
|
|
"SwiftTail", 20>;
|
|
def CConvX86_StdCall : LLVM_EnumAttrCase<"X86_StdCall", "x86_stdcallcc",
|
|
"X86_StdCall", 64>;
|
|
def CConvX86_FastCall : LLVM_EnumAttrCase<"X86_FastCall", "x86_fastcallcc",
|
|
"X86_FastCall", 65>;
|
|
def CConvARM_APCS : LLVM_EnumAttrCase<"ARM_APCS", "arm_apcscc", "ARM_APCS", 66>;
|
|
def CConvARM_AAPCS : LLVM_EnumAttrCase<"ARM_AAPCS", "arm_aapcscc", "ARM_AAPCS",
|
|
67>;
|
|
def CConvARM_AAPCS_VFP : LLVM_EnumAttrCase<"ARM_AAPCS_VFP", "arm_aapcs_vfpcc",
|
|
"ARM_AAPCS_VFP", 68>;
|
|
def CConvMSP430_INTR : LLVM_EnumAttrCase<"MSP430_INTR", "msp430_intrcc",
|
|
"MSP430_INTR", 69>;
|
|
def CConvX86_ThisCall : LLVM_EnumAttrCase<"X86_ThisCall", "x86_thiscallcc",
|
|
"X86_ThisCall", 70>;
|
|
def CConvPTX_Kernel : LLVM_EnumAttrCase<"PTX_Kernel", "ptx_kernelcc",
|
|
"PTX_Kernel", 71>;
|
|
def CConvPTX_Device : LLVM_EnumAttrCase<"PTX_Device", "ptx_devicecc",
|
|
"PTX_Device", 72>;
|
|
def CConvSPIR_FUNC : LLVM_EnumAttrCase<"SPIR_FUNC", "spir_funccc",
|
|
"SPIR_FUNC", 75>;
|
|
def CConvSPIR_KERNEL : LLVM_EnumAttrCase<"SPIR_KERNEL", "spir_kernelcc",
|
|
"SPIR_KERNEL", 76>;
|
|
def CConvIntel_OCL_BI : LLVM_EnumAttrCase<"Intel_OCL_BI", "intel_ocl_bicc",
|
|
"Intel_OCL_BI", 77>;
|
|
def CConvX86_64_SysV : LLVM_EnumAttrCase<"X86_64_SysV", "x86_64_sysvcc",
|
|
"X86_64_SysV", 78>;
|
|
def CConvWin64 : LLVM_EnumAttrCase<"Win64", "win64cc", "Win64", 79>;
|
|
def CConvX86_VectorCall : LLVM_EnumAttrCase<"X86_VectorCall",
|
|
"x86_vectorcallcc",
|
|
"X86_VectorCall", 80>;
|
|
def CConvHHVM : LLVM_EnumAttrCase<"DUMMY_HHVM", "hhvmcc", "DUMMY_HHVM", 81>;
|
|
def CConvHHVM_C
|
|
: LLVM_EnumAttrCase<"DUMMY_HHVM_C", "hhvm_ccc", "DUMMY_HHVM_C", 82>;
|
|
def CConvX86_INTR : LLVM_EnumAttrCase<"X86_INTR", "x86_intrcc", "X86_INTR", 83>;
|
|
def CConvAVR_INTR : LLVM_EnumAttrCase<"AVR_INTR", "avr_intrcc", "AVR_INTR", 84>;
|
|
def CConvAVR_SIGNAL : LLVM_EnumAttrCase<"AVR_SIGNAL", "avr_signalcc",
|
|
"AVR_SIGNAL", 85>;
|
|
def CConvAVR_BUILTIN : LLVM_EnumAttrCase<"AVR_BUILTIN", "avr_builtincc",
|
|
"AVR_BUILTIN", 86>;
|
|
def CConvAMDGPU_VS : LLVM_EnumAttrCase<"AMDGPU_VS", "amdgpu_vscc", "AMDGPU_VS",
|
|
87>;
|
|
def CConvAMDGPU_GS : LLVM_EnumAttrCase<"AMDGPU_GS", "amdgpu_gscc", "AMDGPU_GS",
|
|
88>;
|
|
def CConvAMDGPU_PS : LLVM_EnumAttrCase<"AMDGPU_PS", "amdgpu_pscc", "AMDGPU_PS",
|
|
89>;
|
|
def CConvAMDGPU_CS : LLVM_EnumAttrCase<"AMDGPU_CS", "amdgpu_cscc", "AMDGPU_CS",
|
|
90>;
|
|
def CConvAMDGPU_KERNEL : LLVM_EnumAttrCase<"AMDGPU_KERNEL", "amdgpu_kernelcc",
|
|
"AMDGPU_KERNEL", 91>;
|
|
def CConvX86_RegCall : LLVM_EnumAttrCase<"X86_RegCall", "x86_regcallcc",
|
|
"X86_RegCall", 92>;
|
|
def CConvAMDGPU_HS : LLVM_EnumAttrCase<"AMDGPU_HS", "amdgpu_hscc", "AMDGPU_HS",
|
|
93>;
|
|
def CConvMSP430_BUILTIN : LLVM_EnumAttrCase<"MSP430_BUILTIN",
|
|
"msp430_builtincc",
|
|
"MSP430_BUILTIN", 94>;
|
|
def CConvAMDGPU_LS : LLVM_EnumAttrCase<"AMDGPU_LS", "amdgpu_lscc", "AMDGPU_LS",
|
|
95>;
|
|
def CConvAMDGPU_ES : LLVM_EnumAttrCase<"AMDGPU_ES", "amdgpu_escc", "AMDGPU_ES",
|
|
96>;
|
|
def CConvAArch64_VectorCall : LLVM_EnumAttrCase<"AArch64_VectorCall",
|
|
"aarch64_vectorcallcc",
|
|
"AArch64_VectorCall", 97>;
|
|
def CConvAArch64_SVE_VectorCall : LLVM_EnumAttrCase<"AArch64_SVE_VectorCall",
|
|
"aarch64_sve_vectorcallcc",
|
|
"AArch64_SVE_VectorCall",
|
|
98>;
|
|
def CConvWASM_EmscriptenInvoke : LLVM_EnumAttrCase<"WASM_EmscriptenInvoke",
|
|
"wasm_emscripten_invokecc",
|
|
"WASM_EmscriptenInvoke", 99>;
|
|
def CConvAMDGPU_Gfx : LLVM_EnumAttrCase<"AMDGPU_Gfx", "amdgpu_gfxcc",
|
|
"AMDGPU_Gfx", 100>;
|
|
def CConvM68k_INTR : LLVM_EnumAttrCase<"M68k_INTR", "m68k_intrcc", "M68k_INTR",
|
|
101>;
|
|
|
|
def CConvEnum : LLVM_CEnumAttr<
|
|
"CConv",
|
|
"::llvm::CallingConv",
|
|
"Calling Conventions",
|
|
[CConvC, CConvFast, CConvCold, CConvGHC, CConvHiPE,
|
|
CConvAnyReg, CConvPreserveMost, CConvPreserveAll, CConvSwift,
|
|
CConvCXXFastTLS, CConvTail, CConvCFGuard_Check, CConvSwiftTail,
|
|
CConvX86_StdCall, CConvX86_FastCall, CConvARM_APCS,
|
|
CConvARM_AAPCS, CConvARM_AAPCS_VFP, CConvMSP430_INTR, CConvX86_ThisCall,
|
|
CConvPTX_Kernel, CConvPTX_Device, CConvSPIR_FUNC, CConvSPIR_KERNEL,
|
|
CConvIntel_OCL_BI, CConvX86_64_SysV, CConvWin64, CConvX86_VectorCall,
|
|
CConvHHVM, CConvHHVM_C, CConvX86_INTR, CConvAVR_INTR, CConvAVR_BUILTIN,
|
|
CConvAMDGPU_VS, CConvAMDGPU_GS, CConvAMDGPU_CS, CConvAMDGPU_KERNEL,
|
|
CConvX86_RegCall, CConvAMDGPU_HS, CConvMSP430_BUILTIN, CConvAMDGPU_LS,
|
|
CConvAMDGPU_ES, CConvAArch64_VectorCall, CConvAArch64_SVE_VectorCall,
|
|
CConvWASM_EmscriptenInvoke, CConvAMDGPU_Gfx, CConvM68k_INTR
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM::cconv";
|
|
}
|
|
|
|
def CConv : DialectAttr<
|
|
LLVM_Dialect,
|
|
CPred<"::llvm::isa<::mlir::LLVM::CConvAttr>($_self)">,
|
|
"LLVM Calling Convention specification"> {
|
|
let storageType = "::mlir::LLVM::CConvAttr";
|
|
let returnType = "::mlir::LLVM::cconv::CConv";
|
|
let convertFromStorage = "$_self.getCallingConv()";
|
|
let constBuilderCall =
|
|
"::mlir::LLVM::CConvAttr::get($_builder.getContext(), $0)";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// TailCallKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def TailCallKindNone : LLVM_EnumAttrCase<"None", "none", "TCK_None", 0>;
|
|
def TailCallKindTail : LLVM_EnumAttrCase<"Tail", "tail", "TCK_Tail", 1>;
|
|
def TailCallKindMustTail : LLVM_EnumAttrCase<"MustTail", "musttail", "TCK_MustTail", 2>;
|
|
def TailCallKindNoTailCall : LLVM_EnumAttrCase<"NoTail", "notail", "TCK_NoTail", 3>;
|
|
|
|
def TailCallKindEnum : LLVM_EnumAttr<
|
|
"TailCallKind",
|
|
"::llvm::CallInst::TailCallKind",
|
|
"Tail Call Kind",
|
|
[TailCallKindNone, TailCallKindNoTailCall,
|
|
TailCallKindMustTail, TailCallKindTail]> {
|
|
let cppNamespace = "::mlir::LLVM::tailcallkind";
|
|
}
|
|
|
|
def TailCallKind : DialectAttr<
|
|
LLVM_Dialect,
|
|
CPred<"::llvm::isa<::mlir::LLVM::TailCallKindAttr>($_self)">,
|
|
"LLVM Calling Convention specification"> {
|
|
let storageType = "::mlir::LLVM::TailCallKindAttr";
|
|
let returnType = "::mlir::LLVM::tailcallkind::TailCallKind";
|
|
let convertFromStorage = "$_self.getTailCallKind()";
|
|
let constBuilderCall =
|
|
"::mlir::LLVM::TailCallKindAttr::get($_builder.getContext(), $0)";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIEmissionKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def LLVM_DIEmissionNone : I64EnumAttrCase<"None", 0>;
|
|
def LLVM_DIEmissionFull : I64EnumAttrCase<"Full", 1>;
|
|
def LLVM_DIEmissionLineTablesOnly : I64EnumAttrCase<"LineTablesOnly", 2>;
|
|
def LLVM_DIEmissionDebugDirectivesOnly : I64EnumAttrCase<"DebugDirectivesOnly", 3>;
|
|
|
|
def LLVM_DIEmissionKind : I64EnumAttr<
|
|
"DIEmissionKind",
|
|
"LLVM debug emission kind", [
|
|
LLVM_DIEmissionNone,
|
|
LLVM_DIEmissionFull,
|
|
LLVM_DIEmissionLineTablesOnly,
|
|
LLVM_DIEmissionDebugDirectivesOnly,
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIFlags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def LLVM_DIFlagZero : I32BitEnumAttrCaseNone<"Zero">;
|
|
|
|
// The first two bits are used for a visibility enum.
|
|
// * Private = 1
|
|
// * Protected = 2
|
|
// * Public = 3
|
|
def LLVM_DIFlagVisibilityBit0 : I32BitEnumAttrCaseBit<"Bit0", 0>;
|
|
def LLVM_DIFlagVisibilityBit1 : I32BitEnumAttrCaseBit<"Bit1", 1>;
|
|
def LLVM_DIFlagPrivate : I32BitEnumAttrCaseGroup<"Private",
|
|
[LLVM_DIFlagVisibilityBit0]
|
|
>;
|
|
def LLVM_DIFlagProtected : I32BitEnumAttrCaseGroup<"Protected",
|
|
[LLVM_DIFlagVisibilityBit1]
|
|
>;
|
|
def LLVM_DIFlagPublic : I32BitEnumAttrCaseGroup<"Public",
|
|
[LLVM_DIFlagVisibilityBit0, LLVM_DIFlagVisibilityBit1]
|
|
>;
|
|
|
|
// The remaining bits are used for the various flags.
|
|
def LLVM_DIFlagFwdDecl : I32BitEnumAttrCaseBit<"FwdDecl", 2>;
|
|
def LLVM_DIFlagAppleBlock : I32BitEnumAttrCaseBit<"AppleBlock", 3>;
|
|
def LLVM_DIFlagReservedBit4 : I32BitEnumAttrCaseBit<"ReservedBit4", 4>;
|
|
def LLVM_DIFlagVirtual : I32BitEnumAttrCaseBit<"Virtual", 5>;
|
|
def LLVM_DIFlagArtificial : I32BitEnumAttrCaseBit<"Artificial", 6>;
|
|
def LLVM_DIFlagExplicit : I32BitEnumAttrCaseBit<"Explicit", 7>;
|
|
def LLVM_DIFlagPrototyped : I32BitEnumAttrCaseBit<"Prototyped", 8>;
|
|
def LLVM_DIFlagObjcClassComplete : I32BitEnumAttrCaseBit<"ObjcClassComplete", 9>;
|
|
def LLVM_DIFlagObjectPointer : I32BitEnumAttrCaseBit<"ObjectPointer", 10>;
|
|
def LLVM_DIFlagVector : I32BitEnumAttrCaseBit<"Vector", 11>;
|
|
def LLVM_DIFlagStaticMember : I32BitEnumAttrCaseBit<"StaticMember", 12>;
|
|
def LLVM_DIFlagLValueReference : I32BitEnumAttrCaseBit<"LValueReference", 13>;
|
|
def LLVM_DIFlagRValueReference : I32BitEnumAttrCaseBit<"RValueReference", 14>;
|
|
def LLVM_DIFlagExportSymbols : I32BitEnumAttrCaseBit<"ExportSymbols", 15>;
|
|
def LLVM_DIFlagSingleInheritance : I32BitEnumAttrCaseBit<"SingleInheritance", 16>;
|
|
def LLVM_DIFlagMultipleInheritance : I32BitEnumAttrCaseBit<"MultipleInheritance", 16>;
|
|
def LLVM_DIFlagVirtualInheritance : I32BitEnumAttrCaseBit<"VirtualInheritance", 16>;
|
|
def LLVM_DIFlagIntroducedVirtual : I32BitEnumAttrCaseBit<"IntroducedVirtual", 18>;
|
|
def LLVM_DIFlagBitField : I32BitEnumAttrCaseBit<"BitField", 19>;
|
|
def LLVM_DIFlagNoReturn : I32BitEnumAttrCaseBit<"NoReturn", 20>;
|
|
def LLVM_DIFlagTypePassByValue : I32BitEnumAttrCaseBit<"TypePassByValue", 22>;
|
|
def LLVM_DIFlagTypePassByReference : I32BitEnumAttrCaseBit<"TypePassByReference", 23>;
|
|
def LLVM_DIFlagEnumClass : I32BitEnumAttrCaseBit<"EnumClass", 24>;
|
|
def LLVM_DIFlagThunk : I32BitEnumAttrCaseBit<"Thunk", 25>;
|
|
def LLVM_DIFlagNonTrivial : I32BitEnumAttrCaseBit<"NonTrivial", 26>;
|
|
def LLVM_DIFlagBigEndian : I32BitEnumAttrCaseBit<"BigEndian", 27>;
|
|
def LLVM_DIFlagLittleEndian : I32BitEnumAttrCaseBit<"LittleEndian", 28>;
|
|
def LLVM_DIFlagAllCallsDescribed : I32BitEnumAttrCaseBit<"AllCallsDescribed", 29>;
|
|
|
|
def DIFlags : I32BitEnumAttr<
|
|
"DIFlags",
|
|
"LLVM DI flags", [
|
|
LLVM_DIFlagZero,
|
|
LLVM_DIFlagVisibilityBit0,
|
|
LLVM_DIFlagVisibilityBit1,
|
|
LLVM_DIFlagPrivate,
|
|
LLVM_DIFlagProtected,
|
|
LLVM_DIFlagPublic,
|
|
LLVM_DIFlagFwdDecl,
|
|
LLVM_DIFlagAppleBlock,
|
|
LLVM_DIFlagReservedBit4,
|
|
LLVM_DIFlagVirtual,
|
|
LLVM_DIFlagArtificial,
|
|
LLVM_DIFlagExplicit,
|
|
LLVM_DIFlagPrototyped,
|
|
LLVM_DIFlagObjcClassComplete,
|
|
LLVM_DIFlagObjectPointer,
|
|
LLVM_DIFlagVector,
|
|
LLVM_DIFlagStaticMember,
|
|
LLVM_DIFlagLValueReference,
|
|
LLVM_DIFlagRValueReference,
|
|
LLVM_DIFlagExportSymbols,
|
|
LLVM_DIFlagSingleInheritance,
|
|
LLVM_DIFlagMultipleInheritance,
|
|
LLVM_DIFlagVirtualInheritance,
|
|
LLVM_DIFlagIntroducedVirtual,
|
|
LLVM_DIFlagBitField,
|
|
LLVM_DIFlagNoReturn,
|
|
LLVM_DIFlagTypePassByValue,
|
|
LLVM_DIFlagTypePassByReference,
|
|
LLVM_DIFlagEnumClass,
|
|
LLVM_DIFlagThunk,
|
|
LLVM_DIFlagNonTrivial,
|
|
LLVM_DIFlagBigEndian,
|
|
LLVM_DIFlagLittleEndian,
|
|
LLVM_DIFlagAllCallsDescribed
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
let printBitEnumPrimaryGroups = 1;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DINameTableKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def LLVM_DINameTableDefault : I64EnumAttrCase<"Default", 0>;
|
|
def LLVM_DINameTableGNU : I64EnumAttrCase<"GNU", 1>;
|
|
def LLVM_DINameTableNone : I64EnumAttrCase<"None", 2>;
|
|
def LLVM_DINameTableApple : I64EnumAttrCase<"Apple", 3>;
|
|
|
|
def LLVM_DINameTableKind : I64EnumAttr<
|
|
"DINameTableKind",
|
|
"LLVM debug name table kind", [
|
|
LLVM_DINameTableDefault,
|
|
LLVM_DINameTableGNU,
|
|
LLVM_DINameTableNone,
|
|
LLVM_DINameTableApple,
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DISubprogramFlags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def LLVM_DISPVirtual : I32BitEnumAttrCaseBit<"Virtual", 0>;
|
|
def LLVM_DISPPureVirtual : I32BitEnumAttrCaseBit<"PureVirtual", 1>;
|
|
def LLVM_DISPLocalToUnit : I32BitEnumAttrCaseBit<"LocalToUnit", 2>;
|
|
def LLVM_DISPDefinition : I32BitEnumAttrCaseBit<"Definition", 3>;
|
|
def LLVM_DISPOptimized : I32BitEnumAttrCaseBit<"Optimized", 4>;
|
|
def LLVM_DISPPure : I32BitEnumAttrCaseBit<"Pure", 5>;
|
|
def LLVM_DISPElemental : I32BitEnumAttrCaseBit<"Elemental", 6>;
|
|
def LLVM_DISPRecursive : I32BitEnumAttrCaseBit<"Recursive", 7>;
|
|
def LLVM_DISPMainSubprogram : I32BitEnumAttrCaseBit<"MainSubprogram", 8>;
|
|
def LLVM_DISPDeleted : I32BitEnumAttrCaseBit<"Deleted", 9>;
|
|
def LLVM_DISPObjCDirect : I32BitEnumAttrCaseBit<"ObjCDirect", 11>;
|
|
|
|
def DISubprogramFlags : I32BitEnumAttr<
|
|
"DISubprogramFlags",
|
|
"LLVM DISubprogram flags", [
|
|
LLVM_DISPVirtual,
|
|
LLVM_DISPPureVirtual,
|
|
LLVM_DISPLocalToUnit,
|
|
LLVM_DISPDefinition,
|
|
LLVM_DISPOptimized,
|
|
LLVM_DISPPure,
|
|
LLVM_DISPElemental,
|
|
LLVM_DISPRecursive,
|
|
LLVM_DISPMainSubprogram,
|
|
LLVM_DISPDeleted,
|
|
LLVM_DISPObjCDirect
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
let printBitEnumPrimaryGroups = 1;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// IntegerOverflowFlags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def IOFnone : I32BitEnumCaseNone<"none">;
|
|
def IOFnsw : I32BitEnumCaseBit<"nsw", 0>;
|
|
def IOFnuw : I32BitEnumCaseBit<"nuw", 1>;
|
|
|
|
def IntegerOverflowFlags : I32BitEnum<
|
|
"IntegerOverflowFlags",
|
|
"LLVM integer overflow flags",
|
|
[IOFnone, IOFnsw, IOFnuw]> {
|
|
let separator = ", ";
|
|
let cppNamespace = "::mlir::LLVM";
|
|
let printBitEnumPrimaryGroups = 1;
|
|
}
|
|
|
|
def LLVM_IntegerOverflowFlagsAttr :
|
|
EnumAttr<LLVM_Dialect, IntegerOverflowFlags, "overflow"> {
|
|
let assemblyFormat = "`<` $value `>`";
|
|
}
|
|
|
|
def LLVM_IntegerOverflowFlagsProp :
|
|
NamedEnumPropWithAttrForm<IntegerOverflowFlags, "overflow", LLVM_IntegerOverflowFlagsAttr> {
|
|
let defaultValue = enum.cppType # "::" # "none";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FastmathFlags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def FMFnone : I32BitEnumAttrCaseNone<"none">;
|
|
def FMFnnan : I32BitEnumAttrCaseBit<"nnan", 0>;
|
|
def FMFninf : I32BitEnumAttrCaseBit<"ninf", 1>;
|
|
def FMFnsz : I32BitEnumAttrCaseBit<"nsz", 2>;
|
|
def FMFarcp : I32BitEnumAttrCaseBit<"arcp", 3>;
|
|
def FMFcontract : I32BitEnumAttrCaseBit<"contract", 4>;
|
|
def FMFafn : I32BitEnumAttrCaseBit<"afn", 5>;
|
|
def FMFreassoc : I32BitEnumAttrCaseBit<"reassoc", 6>;
|
|
def FMFfast : I32BitEnumAttrCaseGroup<"fast",
|
|
[ FMFnnan, FMFninf, FMFnsz, FMFarcp, FMFcontract, FMFafn, FMFreassoc]>;
|
|
|
|
def FastmathFlags : I32BitEnumAttr<
|
|
"FastmathFlags",
|
|
"LLVM fastmath flags",
|
|
[FMFnone, FMFnnan, FMFninf, FMFnsz, FMFarcp, FMFcontract, FMFafn,
|
|
FMFreassoc, FMFfast]> {
|
|
let separator = ", ";
|
|
let cppNamespace = "::mlir::LLVM";
|
|
let genSpecializedAttr = 0;
|
|
let printBitEnumPrimaryGroups = 1;
|
|
}
|
|
|
|
def LLVM_FastmathFlagsAttr :
|
|
EnumAttr<LLVM_Dialect, FastmathFlags, "fastmath"> {
|
|
let assemblyFormat = "`<` $value `>`";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FCmp and ICmp Predicates
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Predicates for float comparisons
|
|
def FCmpPredicateFALSE : LLVM_EnumAttrCase<"_false", "_false", "FCMP_FALSE", 0>;
|
|
def FCmpPredicateOEQ : LLVM_EnumAttrCase<"oeq", "oeq", "FCMP_OEQ", 1>;
|
|
def FCmpPredicateOGT : LLVM_EnumAttrCase<"ogt", "ogt", "FCMP_OGT", 2>;
|
|
def FCmpPredicateOGE : LLVM_EnumAttrCase<"oge", "oge", "FCMP_OGE", 3>;
|
|
def FCmpPredicateOLT : LLVM_EnumAttrCase<"olt", "olt", "FCMP_OLT", 4>;
|
|
def FCmpPredicateOLE : LLVM_EnumAttrCase<"ole", "ole", "FCMP_OLE", 5>;
|
|
def FCmpPredicateONE : LLVM_EnumAttrCase<"one", "one", "FCMP_ONE", 6>;
|
|
def FCmpPredicateORD : LLVM_EnumAttrCase<"ord", "ord", "FCMP_ORD", 7>;
|
|
def FCmpPredicateUEQ : LLVM_EnumAttrCase<"ueq", "ueq", "FCMP_UEQ", 8>;
|
|
def FCmpPredicateUGT : LLVM_EnumAttrCase<"ugt", "ugt", "FCMP_UGT", 9>;
|
|
def FCmpPredicateUGE : LLVM_EnumAttrCase<"uge", "uge", "FCMP_UGE", 10>;
|
|
def FCmpPredicateULT : LLVM_EnumAttrCase<"ult", "ult", "FCMP_ULT", 11>;
|
|
def FCmpPredicateULE : LLVM_EnumAttrCase<"ule", "ule", "FCMP_ULE", 12>;
|
|
def FCmpPredicateUNE : LLVM_EnumAttrCase<"une", "une", "FCMP_UNE", 13>;
|
|
def FCmpPredicateUNO : LLVM_EnumAttrCase<"uno", "uno", "FCMP_UNO", 14>;
|
|
def FCmpPredicateTRUE : LLVM_EnumAttrCase<"_true", "_true", "FCMP_TRUE", 15>;
|
|
|
|
// A sentinel value that has no MLIR counterpart.
|
|
def ICmpPredicateBad : LLVM_EnumAttrCase<"", "", "BAD_ICMP_PREDICATE", 0>;
|
|
|
|
// Predicates for integer comparisons.
|
|
def ICmpPredicateEQ : LLVM_EnumAttrCase<"eq", "eq", "ICMP_EQ", 0>;
|
|
def ICmpPredicateNE : LLVM_EnumAttrCase<"ne", "ne", "ICMP_NE", 1>;
|
|
def ICmpPredicateSLT : LLVM_EnumAttrCase<"slt", "slt", "ICMP_SLT", 2>;
|
|
def ICmpPredicateSLE : LLVM_EnumAttrCase<"sle", "sle", "ICMP_SLE", 3>;
|
|
def ICmpPredicateSGT : LLVM_EnumAttrCase<"sgt", "sgt", "ICMP_SGT", 4>;
|
|
def ICmpPredicateSGE : LLVM_EnumAttrCase<"sge", "sge", "ICMP_SGE", 5>;
|
|
def ICmpPredicateULT : LLVM_EnumAttrCase<"ult", "ult", "ICMP_ULT", 6>;
|
|
def ICmpPredicateULE : LLVM_EnumAttrCase<"ule", "ule", "ICMP_ULE", 7>;
|
|
def ICmpPredicateUGT : LLVM_EnumAttrCase<"ugt", "ugt", "ICMP_UGT", 8>;
|
|
def ICmpPredicateUGE : LLVM_EnumAttrCase<"uge", "uge", "ICMP_UGE", 9>;
|
|
|
|
// A sentinel value that has no MLIR counterpart.
|
|
def FCmpPredicateBad : LLVM_EnumAttrCase<"", "", "BAD_FCMP_PREDICATE", 0>;
|
|
|
|
// LLVM's predicate enum contains the floating-point and integer comparison
|
|
// cases, while the LLVM dialect uses two separate enums. The floating-point
|
|
// predicate enum thus defines all integer predicates as unsupported and
|
|
// vice versa.
|
|
def FCmpPredicate : LLVM_EnumAttr<
|
|
"FCmpPredicate",
|
|
"::llvm::CmpInst::Predicate",
|
|
"llvm.fcmp comparison predicate",
|
|
[FCmpPredicateFALSE, FCmpPredicateOEQ, FCmpPredicateOGT, FCmpPredicateOGE,
|
|
FCmpPredicateOLT, FCmpPredicateOLE, FCmpPredicateONE, FCmpPredicateORD,
|
|
FCmpPredicateUEQ, FCmpPredicateUGT, FCmpPredicateUGE, FCmpPredicateULT,
|
|
FCmpPredicateULE, FCmpPredicateUNE, FCmpPredicateUNO, FCmpPredicateTRUE],
|
|
[ICmpPredicateEQ, ICmpPredicateNE, ICmpPredicateSLT, ICmpPredicateSLE,
|
|
ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE,
|
|
ICmpPredicateUGT, ICmpPredicateUGE, FCmpPredicateBad, ICmpPredicateBad
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
def ICmpPredicate : LLVM_EnumAttr<
|
|
"ICmpPredicate",
|
|
"::llvm::CmpInst::Predicate",
|
|
"llvm.icmp comparison predicate",
|
|
[ICmpPredicateEQ, ICmpPredicateNE, ICmpPredicateSLT, ICmpPredicateSLE,
|
|
ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE,
|
|
ICmpPredicateUGT, ICmpPredicateUGE],
|
|
[FCmpPredicateFALSE, FCmpPredicateOEQ, FCmpPredicateOGT, FCmpPredicateOGE,
|
|
FCmpPredicateOLT, FCmpPredicateOLE, FCmpPredicateONE, FCmpPredicateORD,
|
|
FCmpPredicateUEQ, FCmpPredicateUGT, FCmpPredicateUGE, FCmpPredicateULT,
|
|
FCmpPredicateULE, FCmpPredicateUNE, FCmpPredicateUNO, FCmpPredicateTRUE,
|
|
FCmpPredicateBad, ICmpPredicateBad
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Linkage
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Linkage attribute is used on functions and globals. The order follows that of
|
|
// llvm::GlobalValue::LinkageTypes from llvm/IR/GlobalValue.h. The names are
|
|
// equivalent to visible names in the IR rather than to enum values names in
|
|
// llvm::GlobalValue since the latter is easier to change.
|
|
def LinkageExternal
|
|
: LLVM_EnumAttrCase<"External", "external", "ExternalLinkage", 0>;
|
|
def LinkageAvailableExternally
|
|
: LLVM_EnumAttrCase<"AvailableExternally", "available_externally",
|
|
"AvailableExternallyLinkage", 1>;
|
|
def LinkageLinkonce
|
|
: LLVM_EnumAttrCase<"Linkonce", "linkonce", "LinkOnceAnyLinkage", 2>;
|
|
def LinkageLinkonceODR
|
|
: LLVM_EnumAttrCase<"LinkonceODR", "linkonce_odr", "LinkOnceODRLinkage", 3>;
|
|
def LinkageWeak
|
|
: LLVM_EnumAttrCase<"Weak", "weak", "WeakAnyLinkage", 4>;
|
|
def LinkageWeakODR
|
|
: LLVM_EnumAttrCase<"WeakODR", "weak_odr", "WeakODRLinkage", 5>;
|
|
def LinkageAppending
|
|
: LLVM_EnumAttrCase<"Appending", "appending", "AppendingLinkage", 6>;
|
|
def LinkageInternal
|
|
: LLVM_EnumAttrCase<"Internal", "internal", "InternalLinkage", 7>;
|
|
def LinkagePrivate
|
|
: LLVM_EnumAttrCase<"Private", "private", "PrivateLinkage", 8>;
|
|
def LinkageExternWeak
|
|
: LLVM_EnumAttrCase<"ExternWeak", "extern_weak", "ExternalWeakLinkage", 9>;
|
|
def LinkageCommon
|
|
: LLVM_EnumAttrCase<"Common", "common", "CommonLinkage", 10>;
|
|
|
|
def LinkageEnum : LLVM_EnumAttr<
|
|
"Linkage",
|
|
"::llvm::GlobalValue::LinkageTypes",
|
|
"LLVM linkage types",
|
|
[LinkageExternal, LinkageAvailableExternally, LinkageLinkonce,
|
|
LinkageLinkonceODR, LinkageWeak, LinkageWeakODR, LinkageAppending,
|
|
LinkageInternal, LinkagePrivate, LinkageExternWeak, LinkageCommon]> {
|
|
let cppNamespace = "::mlir::LLVM::linkage";
|
|
}
|
|
|
|
def Linkage : DialectAttr<
|
|
LLVM_Dialect,
|
|
CPred<"::llvm::isa<::mlir::LLVM::LinkageAttr>($_self)">,
|
|
"LLVM Linkage specification"> {
|
|
let storageType = "::mlir::LLVM::LinkageAttr";
|
|
let returnType = "::mlir::LLVM::Linkage";
|
|
let convertFromStorage = "$_self.getLinkage()";
|
|
let constBuilderCall =
|
|
"::mlir::LLVM::LinkageAttr::get($_builder.getContext(), $0)";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Comdat
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def ComdatAny
|
|
: LLVM_EnumAttrCase<"Any", "any", "Any", 0>;
|
|
def ComdatExactMatch
|
|
: LLVM_EnumAttrCase<"ExactMatch", "exactmatch", "ExactMatch", 1>;
|
|
def ComdatLargest
|
|
: LLVM_EnumAttrCase<"Largest", "largest", "Largest", 2>;
|
|
def ComdatNoDeduplicate
|
|
: LLVM_EnumAttrCase<"NoDeduplicate", "nodeduplicate", "NoDeduplicate", 3>;
|
|
def ComdatSameSize
|
|
: LLVM_EnumAttrCase<"SameSize", "samesize", "SameSize", 4>;
|
|
|
|
def Comdat : LLVM_EnumAttr<
|
|
"Comdat",
|
|
"::llvm::Comdat::SelectionKind",
|
|
"LLVM Comdat Types",
|
|
[ComdatAny, ComdatExactMatch, ComdatLargest,
|
|
ComdatNoDeduplicate, ComdatSameSize]> {
|
|
let cppNamespace = "::mlir::LLVM::comdat";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// UnnamedAddr
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def UnnamedAddrNone : LLVM_EnumAttrCase<"None", "", "None", 0>;
|
|
def UnnamedAddrLocal : LLVM_EnumAttrCase<"Local", "local_unnamed_addr", "Local", 1>;
|
|
def UnnamedAddrGlobal : LLVM_EnumAttrCase<"Global", "unnamed_addr", "Global", 2>;
|
|
|
|
def UnnamedAddr : LLVM_EnumAttr<
|
|
"UnnamedAddr",
|
|
"::llvm::GlobalValue::UnnamedAddr",
|
|
"LLVM GlobalValue UnnamedAddr",
|
|
[UnnamedAddrNone, UnnamedAddrLocal, UnnamedAddrGlobal]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Visibility
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def VisibilityDefault
|
|
: LLVM_EnumAttrCase<"Default", "", "DefaultVisibility", 0>;
|
|
def VisibilityHidden
|
|
: LLVM_EnumAttrCase<"Hidden", "hidden", "HiddenVisibility", 1>;
|
|
def VisibilityProtected
|
|
: LLVM_EnumAttrCase<"Protected", "protected", "ProtectedVisibility", 2>;
|
|
|
|
def Visibility : LLVM_EnumAttr<
|
|
"Visibility",
|
|
"::llvm::GlobalValue::VisibilityTypes",
|
|
"LLVM GlobalValue Visibility",
|
|
[VisibilityDefault, VisibilityHidden, VisibilityProtected]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ModRefInfo
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def ModRefInfoNoModRef : LLVM_EnumAttrCase<"NoModRef", "none", "NoModRef", 0>;
|
|
def ModRefInfoRef : LLVM_EnumAttrCase<"Ref", "read", "Ref", 1>;
|
|
def ModRefInfoMod : LLVM_EnumAttrCase<"Mod", "write", "Mod", 2>;
|
|
def ModRefInfoModRef : LLVM_EnumAttrCase<"ModRef", "readwrite", "ModRef", 3>;
|
|
|
|
def ModRefInfoEnum : LLVM_EnumAttr<
|
|
"ModRefInfo",
|
|
"::llvm::ModRefInfo",
|
|
"LLVM ModRefInfo",
|
|
[ModRefInfoNoModRef, ModRefInfoRef, ModRefInfoMod, ModRefInfoModRef]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FramePointerKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def FramePointerKindNone
|
|
: LLVM_EnumAttrCase<"None", "none", "None", 0>;
|
|
def FramePointerKindNonLeaf
|
|
: LLVM_EnumAttrCase<"NonLeaf", "non-leaf", "NonLeaf", 1>;
|
|
def FramePointerKindAll
|
|
: LLVM_EnumAttrCase<"All", "all", "All", 2>;
|
|
def FramePointerKindReserved
|
|
: LLVM_EnumAttrCase<"Reserved", "reserved", "Reserved", 3>;
|
|
def FramePointerKindNonLeafNoReserve
|
|
: LLVM_EnumAttrCase<"NonLeafNoReserve", "non-leaf-no-reserve", "NonLeafNoReserve", 4>;
|
|
|
|
def FramePointerKindEnum : LLVM_EnumAttr<
|
|
"FramePointerKind",
|
|
"::llvm::FramePointerKind",
|
|
"LLVM FramePointerKind",
|
|
[FramePointerKindNone, FramePointerKindNonLeaf,
|
|
FramePointerKindAll, FramePointerKindReserved,
|
|
FramePointerKindNonLeafNoReserve]> {
|
|
let cppNamespace = "::mlir::LLVM::framePointerKind";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// RoundingMode
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// These values must match llvm::RoundingMode ones.
|
|
// See llvm/include/llvm/ADT/FloatingPointMode.h.
|
|
def RoundTowardZero
|
|
: LLVM_EnumAttrCase<"TowardZero", "towardzero", "TowardZero", 0>;
|
|
def RoundNearestTiesToEven
|
|
: LLVM_EnumAttrCase<"NearestTiesToEven", "tonearest", "NearestTiesToEven", 1>;
|
|
def RoundTowardPositive
|
|
: LLVM_EnumAttrCase<"TowardPositive", "upward", "TowardPositive", 2>;
|
|
def RoundTowardNegative
|
|
: LLVM_EnumAttrCase<"TowardNegative", "downward", "TowardNegative", 3>;
|
|
def RoundNearestTiesToAway
|
|
: LLVM_EnumAttrCase<"NearestTiesToAway", "tonearestaway", "NearestTiesToAway", 4>;
|
|
def RoundDynamic
|
|
: LLVM_EnumAttrCase<"Dynamic", "dynamic", "Dynamic", 7>;
|
|
// Needed as llvm::RoundingMode defines this.
|
|
def RoundInvalid
|
|
: LLVM_EnumAttrCase<"Invalid", "invalid", "Invalid", -1>;
|
|
|
|
// RoundingModeAttr should not be used in operations definitions.
|
|
// Use ValidRoundingModeAttr instead.
|
|
def RoundingModeAttr : LLVM_EnumAttr<
|
|
"RoundingMode",
|
|
"::llvm::RoundingMode",
|
|
"LLVM Rounding Mode",
|
|
[RoundTowardZero, RoundNearestTiesToEven, RoundTowardPositive,
|
|
RoundTowardNegative, RoundNearestTiesToAway, RoundDynamic, RoundInvalid]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
def ValidRoundingModeAttr : ConfinedAttr<RoundingModeAttr, [IntMinValue<0>]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DenormalModeKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def DenormalModeIEEE : LLVM_EnumAttrCase<"IEEE", "ieee", "IEEE", 0>;
|
|
def DenormalModePreserveSign
|
|
: LLVM_EnumAttrCase<"PreserveSign", "preservesign", "PreserveSign", 1>;
|
|
def DenormalModePositiveZero
|
|
: LLVM_EnumAttrCase<"PositiveZero", "positivezero", "PositiveZero", 2>;
|
|
def DenormalModeDynamic : LLVM_EnumAttrCase<"Dynamic", "dynamic", "Dynamic", 3>;
|
|
// Needed as llvm::DenormalModeKind defines this.
|
|
def DenormalModeInvalid
|
|
: LLVM_EnumAttrCase<"Invalid", "invalid", "Invalid", -1>;
|
|
|
|
def DenormalModeKindAttr : LLVM_EnumAttr<
|
|
"DenormalModeKind",
|
|
"::llvm::DenormalMode::DenormalModeKind",
|
|
"LLVM Denormal Mode Kinds",
|
|
[DenormalModeIEEE,
|
|
DenormalModePreserveSign,
|
|
DenormalModePositiveZero,
|
|
DenormalModeDynamic,
|
|
DenormalModeInvalid]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FPExceptionBehavior
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// These values must match llvm::fp::ExceptionBehavior ones.
|
|
// See llvm/include/llvm/IR/FPEnv.h.
|
|
def FPExceptionBehaviorIgnore
|
|
: LLVM_EnumAttrCase<"Ignore", "ignore", "ebIgnore", 0>;
|
|
def FPExceptionBehaviorMayTrap
|
|
: LLVM_EnumAttrCase<"MayTrap", "maytrap", "ebMayTrap", 1>;
|
|
def FPExceptionBehaviorStrict
|
|
: LLVM_EnumAttrCase<"Strict", "strict", "ebStrict", 2>;
|
|
|
|
def FPExceptionBehaviorAttr : LLVM_EnumAttr<
|
|
"FPExceptionBehavior",
|
|
"::llvm::fp::ExceptionBehavior",
|
|
"LLVM Exception Behavior",
|
|
[FPExceptionBehaviorIgnore, FPExceptionBehaviorMayTrap,
|
|
FPExceptionBehaviorStrict]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Module Flags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// These values must match llvm::Module::ModFlagBehavior ones.
|
|
// See llvm/include/llvm/IR/Module.h.
|
|
def ModFlagBehaviorError
|
|
: LLVM_EnumAttrCase<"Error", "error", "Error", 1>;
|
|
def ModFlagBehaviorWarning
|
|
: LLVM_EnumAttrCase<"Warning", "warning", "Warning", 2>;
|
|
def ModFlagBehaviorRequire
|
|
: LLVM_EnumAttrCase<"Require", "require", "Require", 3>;
|
|
def ModFlagBehaviorOverride
|
|
: LLVM_EnumAttrCase<"Override", "override", "Override", 4>;
|
|
def ModFlagBehaviorAppend
|
|
: LLVM_EnumAttrCase<"Append", "append", "Append", 5>;
|
|
def ModFlagBehaviorAppendUnique
|
|
: LLVM_EnumAttrCase<"AppendUnique", "append_unique", "AppendUnique", 6>;
|
|
def ModFlagBehaviorMax
|
|
: LLVM_EnumAttrCase<"Max", "max", "Max", 7>;
|
|
def ModFlagBehaviorMin
|
|
: LLVM_EnumAttrCase<"Min", "min", "Min", 8>;
|
|
|
|
def ModFlagBehaviorAttr : LLVM_EnumAttr<
|
|
"ModFlagBehavior",
|
|
"::llvm::Module::ModFlagBehavior",
|
|
"LLVM Module Flag Behavior",
|
|
[ModFlagBehaviorError, ModFlagBehaviorWarning, ModFlagBehaviorRequire,
|
|
ModFlagBehaviorOverride, ModFlagBehaviorAppend,
|
|
ModFlagBehaviorAppendUnique, ModFlagBehaviorMax, ModFlagBehaviorMin]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
def LLVM_ProfileSummaryFormatSampleProfile : I64EnumAttrCase<"SampleProfile",
|
|
0>;
|
|
def LLVM_ProfileSummaryFormatInstrProf : I64EnumAttrCase<"InstrProf", 1>;
|
|
def LLVM_ProfileSummaryFormatCSInstrProf : I64EnumAttrCase<"CSInstrProf", 2>;
|
|
|
|
def LLVM_ProfileSummaryFormatKind : I64EnumAttr<
|
|
"ProfileSummaryFormatKind",
|
|
"LLVM ProfileSummary format kinds", [
|
|
LLVM_ProfileSummaryFormatSampleProfile,
|
|
LLVM_ProfileSummaryFormatInstrProf,
|
|
LLVM_ProfileSummaryFormatCSInstrProf,
|
|
]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// UWTableKind
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def UWTableKindNone
|
|
: LLVM_EnumAttrCase<"None", "none", "None", 0>;
|
|
def UWTableKindSync
|
|
: LLVM_EnumAttrCase<"Sync", "sync", "Sync", 1>;
|
|
def UWTableKindAsync
|
|
: LLVM_EnumAttrCase<"Async", "async", "Async", 2>;
|
|
|
|
// UWTableKind::Default is unsupported as the llvm enum value is the same as async
|
|
// which the generated enum converters can't deal with.
|
|
def UWTableKindEnum : LLVM_EnumAttr<
|
|
"UWTableKind",
|
|
"::llvm::UWTableKind",
|
|
"LLVM Unwind Behavior",
|
|
[UWTableKindNone, UWTableKindSync, UWTableKindAsync]> {
|
|
let cppNamespace = "::mlir::LLVM::uwtable";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// GEPNoWrapFlags
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// These values must match llvm::GEPNoWrapFlags ones.
|
|
// See llvm/include/llvm/IR/GEPNoWrapFlags.h.
|
|
// Since inbounds implies nusw, create an inboundsFlag that represents the
|
|
// concept of raw inbounds with no nusw implication and the actual inbounds
|
|
// literal will be captured as the combination of inboundsFlag and nusw.
|
|
|
|
def GEPNone : I32BitEnumCaseNone<"none">;
|
|
def GEPInboundsFlag : I32BitEnumCaseBit<"inboundsFlag", 0, "inbounds_flag">;
|
|
def GEPNusw : I32BitEnumCaseBit<"nusw", 1>;
|
|
def GEPNuw : I32BitEnumCaseBit<"nuw", 2>;
|
|
def GEPInbounds : BitEnumCaseGroup<"inbounds", [GEPInboundsFlag, GEPNusw]>;
|
|
|
|
def GEPNoWrapFlags : I32BitEnum<
|
|
"GEPNoWrapFlags",
|
|
"::mlir::LLVM::GEPNoWrapFlags",
|
|
[GEPNone, GEPInboundsFlag, GEPNusw, GEPNuw, GEPInbounds]> {
|
|
let cppNamespace = "::mlir::LLVM";
|
|
let printBitEnumPrimaryGroups = 1;
|
|
}
|
|
|
|
def GEPNoWrapFlagsProp : EnumProp<GEPNoWrapFlags> {
|
|
let defaultValue = interfaceType # "::none";
|
|
}
|
|
|
|
#endif // LLVMIR_ENUMS
|