MLIR

Multi-Level IR Compiler Framework

'llvm' Dialect

This dialect maps LLVM IR into MLIR by defining the corresponding operations and types. LLVM IR metadata is usually represented as MLIR attributes, which offer additional structure verification.

We use “LLVM IR” to designate the intermediate representation of LLVM and “LLVM dialect” or “LLVM IR dialect” to refer to this MLIR dialect.

Unless explicitly stated otherwise, the semantics of the LLVM dialect operations must correspond to the semantics of LLVM IR instructions and any divergence is considered a bug. The dialect also contains auxiliary operations that smoothen the differences in the IR structure, e.g., MLIR does not have phi operations and LLVM IR does not have a constant operation. These auxiliary operations are systematically prefixed with mlir, e.g. llvm.mlir.constant where llvm. is the dialect namespace prefix.

Dependency on LLVM IR 

LLVM dialect is not expected to depend on any object that requires an LLVMContext, such as an LLVM IR instruction or type. Instead, MLIR provides thread-safe alternatives compatible with the rest of the infrastructure. The dialect is allowed to depend on the LLVM IR objects that don’t require a context, such as data layout and triple description.

Module Structure 

IR modules use the built-in MLIR ModuleOp and support all its features. In particular, modules can be named, nested and are subject to symbol visibility. Modules can contain any operations, including LLVM functions and globals.

Data Layout and Triple 

An IR module may have an optional data layout and triple information attached using MLIR attributes llvm.data_layout and llvm.triple, respectively. Both are string attributes with the same syntax as in LLVM IR and are verified to be correct. They can be defined as follows.

module attributes {llvm.data_layout = "e",
                   llvm.target_triple = "aarch64-linux-android"} {
  // module contents
}

Functions 

LLVM functions are represented by a special operation, llvm.func, that has syntax similar to that of the built-in function operation but supports LLVM-related features such as linkage and variadic argument lists. See detailed description in the operation list below.

PHI Nodes and Block Arguments 

MLIR uses block arguments instead of PHI nodes to communicate values between blocks. Therefore, the LLVM dialect has no operation directly equivalent to phi in LLVM IR. Instead, all terminators can pass values as successor operands as these values will be forwarded as block arguments when the control flow is transferred.

For example:

^bb1:
  %0 = llvm.addi %arg0, %cst : i32
  llvm.br ^bb2[%0: i32]

// If the control flow comes from ^bb1, %arg1 == %0.
^bb2(%arg1: i32)
  // ...

is equivalent to LLVM IR

%0:
  %1 = add i32 %arg0, %cst
  br %3

%3:
  %arg1 = phi [%1, %0], //...

Since there is no need to use the block identifier to differentiate the source of different values, the LLVM dialect supports terminators that transfer the control flow to the same block with different arguments. For example:

^bb1:
  llvm.cond_br %cond, ^bb2[%0: i32], ^bb2[%1: i32]

^bb2(%arg0: i32):
  // ...

Context-Level Values 

Some value kinds in LLVM IR, such as constants and undefs, are uniqued in context and used directly in relevant operations. MLIR does not support such values for thread-safety and concept parsimony reasons. Instead, regular values are produced by dedicated operations that have the corresponding semantics: llvm.mlir.constant, llvm.mlir.undef, llvm.mlir.poison, llvm.mlir.zero. Note how these operations are prefixed with mlir. to indicate that they don’t belong to LLVM IR but are only necessary to model it in MLIR. The values produced by these operations are usable just like any other value.

Examples:

// Create an undefined value of structure type with a 32-bit integer followed
// by a float.
%0 = llvm.mlir.undef : !llvm.struct<(i32, f32)>

// Null pointer.
%1 = llvm.mlir.zero : !llvm.ptr

// Create an zero initialized value of structure type with a 32-bit integer
// followed by a float.
%2 = llvm.mlir.zero :  !llvm.struct<(i32, f32)>

// Constant 42 as i32.
%3 = llvm.mlir.constant(42 : i32) : i32

// Splat dense vector constant.
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32>

Note that constants list the type twice. This is an artifact of the LLVM dialect not using built-in types, which are used for typed MLIR attributes. The syntax will be reevaluated after considering composite constants.

Globals 

Global variables are also defined using a special operation, llvm.mlir.global, located at the module level. Globals are MLIR symbols and are identified by their name.

Since functions need to be isolated-from-above, i.e. values defined outside the function cannot be directly used inside the function, an additional operation, llvm.mlir.addressof, is provided to locally define a value containing the address of a global. The actual value can then be loaded from that pointer, or a new value can be stored into it if the global is not declared constant. This is similar to LLVM IR where globals are accessed through name and have a pointer type.

Linkage 

Module-level named objects in the LLVM dialect, namely functions and globals, have an optional linkage attribute derived from LLVM IR linkage types. Linkage is specified by the same keyword as in LLVM IR and is located between the operation name (llvm.func or llvm.global) and the symbol name. If no linkage keyword is present, external linkage is assumed by default. Linkage is distinct from MLIR symbol visibility.

Attribute Pass-Through 

WARNING: this feature MUST NOT be used for any real workload. It is exclusively intended for quick prototyping. After that, attributes must be introduced as proper first-class concepts in the dialect.

The LLVM dialect provides a mechanism to forward function-level attributes to LLVM IR using the passthrough attribute. This is an array attribute containing either string attributes or array attributes. In the former case, the value of the string is interpreted as the name of LLVM IR function attribute. In the latter case, the array is expected to contain exactly two string attributes, the first corresponding to the name of LLVM IR function attribute, and the second corresponding to its value. Note that even integer LLVM IR function attributes have their value represented in the string form.

Example:

llvm.func @func() attributes {
  passthrough = ["noinline",           // value-less attribute
                 ["alignstack", "4"],  // integer attribute with value
                 ["other", "attr"]]    // attribute unknown to LLVM
} {
  llvm.return
}

If the attribute is not known to LLVM IR, it will be attached as a string attribute.

Types 

LLVM dialect uses built-in types whenever possible and defines a set of complementary types, which correspond to the LLVM IR types that cannot be directly represented with built-in types. Similarly to other MLIR context-owned objects, the creation and manipulation of LLVM dialect types is thread-safe.

MLIR does not support module-scoped named type declarations, e.g. %s = type {i32, i32} in LLVM IR. Instead, types must be fully specified at each use, except for recursive types where only the first reference to a named type needs to be fully specified. MLIR type aliases can be used to achieve more compact syntax.

The general syntax of LLVM dialect types is !llvm., followed by a type kind identifier (e.g., ptr for pointer or struct for structure) and by an optional list of type parameters in angle brackets. The dialect follows MLIR style for types with nested angle brackets and keyword specifiers rather than using different bracket styles to differentiate types. Types inside the angle brackets may omit the !llvm. prefix for brevity: the parser first attempts to find a type (starting with ! or a built-in type) and falls back to accepting a keyword. For example, !llvm.struct<(!llvm.ptr, f32)> and !llvm.struct<(ptr, f32)> are equivalent, with the latter being the canonical form, and denote a struct containing a pointer and a float.

Built-in Type Compatibility 

LLVM dialect accepts a subset of built-in types that are referred to as LLVM dialect-compatible types. The following types are compatible:

  • Signless integers - iN (IntegerType).
  • Floating point types - bfloat, half, float, double , f80, f128 (FloatType).
  • 1D vectors of signless integers or floating point types - vector<NxT> (VectorType).

Note that only a subset of types that can be represented by a given class is compatible. For example, signed and unsigned integers are not compatible. LLVM provides a function, bool LLVM::isCompatibleType(Type), that can be used as a compatibility check.

Each LLVM IR type corresponds to exactly one MLIR type, either built-in or LLVM dialect type. For example, because i32 is LLVM-compatible, there is no !llvm.i32 type. However, !llvm.struct<(T, ...)> is defined in the LLVM dialect as there is no corresponding built-in type.

Additional Simple Types 

The following non-parametric types derived from the LLVM IR are available in the LLVM dialect:

  • !llvm.x86_mmx (LLVMX86MMXType) - value held in an MMX register on x86 machine.
  • !llvm.ppc_fp128 (LLVMPPCFP128Type) - 128-bit floating-point value (two 64 bits).
  • !llvm.token (LLVMTokenType) - a non-inspectable value associated with an operation.
  • !llvm.metadata (LLVMMetadataType) - LLVM IR metadata, to be used only if the metadata cannot be represented as structured MLIR attributes.
  • !llvm.void (LLVMVoidType) - does not represent any value; can only appear in function results.

These types represent a single value (or an absence thereof in case of void) and correspond to their LLVM IR counterparts.

Additional Parametric Types 

These types are parameterized by the types they contain, e.g., the pointee or the element type, which can be either compatible built-in or LLVM dialect types.

Pointer Types 

Pointer types specify an address in memory.

Pointers are opaque, i.e., do not indicate the type of the data pointed to, and are intended to simplify LLVM IR by encoding behavior relevant to the pointee type into operations rather than into types. Pointers can optionally be parametrized with an address space. The address space is an integer, but this choice may be reconsidered if MLIR implements named address spaces. The syntax of pointer types is as follows:

  llvm-ptr-type ::= `!llvm.ptr` (`<` integer-literal `>`)?

where the optional group containing the integer literal corresponds to the address space. All cases are represented by LLVMPointerType internally.

Array Types 

Array types represent sequences of elements in memory. Array elements can be addressed with a value unknown at compile time, and can be nested. Only 1D arrays are allowed though.

Array types are parameterized by the fixed size and the element type. Syntactically, their representation is the following:

  llvm-array-type ::= `!llvm.array<` integer-literal `x` type `>`

and they are internally represented as LLVMArrayType.

Function Types 

Function types represent the type of a function, i.e. its signature.

Function types are parameterized by the result type, the list of argument types and by an optional “variadic” flag. Unlike built-in FunctionType, LLVM dialect functions (LLVMFunctionType) always have single result, which may be !llvm.void if the function does not return anything. The syntax is as follows:

  llvm-func-type ::= `!llvm.func<` type `(` type-list (`,` `...`)? `)` `>`

For example,

!llvm.func<void ()>           // a function with no arguments;
!llvm.func<i32 (f32, i32)>    // a function with two arguments and a result;
!llvm.func<void (i32, ...)>   // a variadic function with at least one argument.

In the LLVM dialect, functions are not first-class objects and one cannot have a value of function type. Instead, one can take the address of a function and operate on pointers to functions.

Vector Types 

Vector types represent sequences of elements, typically when multiple data elements are processed by a single instruction (SIMD). Vectors are thought of as stored in registers and therefore vector elements can only be addressed through constant indices.

Vector types are parameterized by the size, which may be either fixed or a multiple of some fixed size in case of scalable vectors, and the element type. Vectors cannot be nested and only 1D vectors are supported. Scalable vectors are still considered 1D.

LLVM dialect uses built-in vector types for fixed-size vectors of built-in types, and provides additional types for fixed-sized vectors of LLVM dialect types (LLVMFixedVectorType) and scalable vectors of any types (LLVMScalableVectorType). These two additional types share the following syntax:

  llvm-vec-type ::= `!llvm.vec<` (`?` `x`)? integer-literal `x` type `>`

Note that the sets of element types supported by built-in and LLVM dialect vector types are mutually exclusive, e.g., the built-in vector type does not accept !llvm.ptr and the LLVM dialect fixed-width vector type does not accept i32.

The following functions are provided to operate on any kind of the vector types compatible with the LLVM dialect:

  • bool LLVM::isCompatibleVectorType(Type) - checks whether a type is a vector type compatible with the LLVM dialect;
  • Type LLVM::getVectorElementType(Type) - returns the element type of any vector type compatible with the LLVM dialect;
  • llvm::ElementCount LLVM::getVectorNumElements(Type) - returns the number of elements in any vector type compatible with the LLVM dialect;
  • Type LLVM::getFixedVectorType(Type, unsigned) - gets a fixed vector type with the given element type and size; the resulting type is either a built-in or an LLVM dialect vector type depending on which one supports the given element type.

Examples of Compatible Vector Types 

vector<42 x i32>                   // Vector of 42 32-bit integers.
!llvm.vec<42 x ptr>                // Vector of 42 pointers.
!llvm.vec<? x 4 x i32>             // Scalable vector of 32-bit integers with
                                   // size divisible by 4.
!llvm.array<2 x vector<2 x i32>>   // Array of 2 vectors of 2 32-bit integers.
!llvm.array<2 x vec<2 x ptr>> // Array of 2 vectors of 2 pointers.

Structure Types 

The structure type is used to represent a collection of data members together in memory. The elements of a structure may be any type that has a size.

Structure types are represented in a single dedicated class mlir::LLVM::LLVMStructType. Internally, the struct type stores a (potentially empty) name, a (potentially empty) list of contained types and a bitmask indicating whether the struct is named, opaque, packed or uninitialized. Structure types that don’t have a name are referred to as literal structs. Such structures are uniquely identified by their contents. Identified structs on the other hand are uniquely identified by the name.

Identified Structure Types 

Identified structure types are uniqued using their name in a given context. Attempting to construct an identified structure with the same name a structure that already exists in the context will result in the existing structure being returned. MLIR does not auto-rename identified structs in case of name conflicts because there is no naming scope equivalent to a module in LLVM IR since MLIR modules can be arbitrarily nested.

Programmatically, identified structures can be constructed in an uninitialized state. In this case, they are given a name but the body must be set up by a later call, using MLIR’s type mutation mechanism. Such uninitialized types can be used in type construction, but must be eventually initialized for IR to be valid. This mechanism allows for constructing recursive or mutually referring structure types: an uninitialized type can be used in its own initialization.

Once the type is initialized, its body cannot be changed anymore. Any further attempts to modify the body will fail and return failure to the caller unless the type is initialized with the exact same body. Type initialization is thread-safe; however, if a concurrent thread initializes the type before the current thread, the initialization may return failure.

The syntax for identified structure types is as follows.

llvm-ident-struct-type ::= `!llvm.struct<` string-literal, `opaque` `>`
                         | `!llvm.struct<` string-literal, `packed`?
                           `(` type-or-ref-list  `)` `>`
type-or-ref-list ::= <maybe empty comma-separated list of type-or-ref>
type-or-ref ::= <any compatible type with optional !llvm.>
              | `!llvm.`? `struct<` string-literal `>`

Literal Structure Types 

Literal structures are uniqued according to the list of elements they contain, and can optionally be packed. The syntax for such structs is as follows.

llvm-literal-struct-type ::= `!llvm.struct<` `packed`? `(` type-list `)` `>`
type-list ::= <maybe empty comma-separated list of types with optional !llvm.>

Literal structs cannot be recursive, but can contain other structs. Therefore, they must be constructed in a single step with the entire list of contained elements provided.

Examples of Structure Types 

!llvm.struct<>                  // NOT allowed
!llvm.struct<()>                // empty, literal
!llvm.struct<(i32)>             // literal
!llvm.struct<(struct<(i32)>)>   // struct containing a struct
!llvm.struct<packed (i8, i32)>  // packed struct
!llvm.struct<"a">               // recursive reference, only allowed within
                                // another struct, NOT allowed at top level
!llvm.struct<"a", ()>           // empty, named (necessary to differentiate from
                                // recursive reference)
!llvm.struct<"a", opaque>       // opaque, named
!llvm.struct<"a", (i32, ptr)>        // named
!llvm.struct<"a", packed (i8, i32)>  // named, packed

Unsupported Types 

LLVM IR label type does not have a counterpart in the LLVM dialect since, in MLIR, blocks are not values and don’t need a type.

Operations 

All operations in the LLVM IR dialect have a custom form in MLIR. The mnemonic of an operation is that used in LLVM IR prefixed with “llvm.”.

source

llvm.ashr (LLVM::AShrOp) 

Syntax:

operation ::= `llvm.ashr` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.add (LLVM::AddOp) 

Syntax:

operation ::= `llvm.add` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags)
              `` custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, Commutative, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, IntegerOverflowFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.addrspacecast (LLVM::AddrSpaceCastOp) 

Syntax:

operation ::= `llvm.addrspacecast` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), PromotableOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

Results: 

ResultDescription
resLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

llvm.mlir.addressof (LLVM::AddressOfOp) 

Creates a pointer pointing to a global or a function

Syntax:

operation ::= `llvm.mlir.addressof` $global_name attr-dict `:` qualified(type($res))

Creates an SSA value containing a pointer to a global variable or constant defined by llvm.mlir.global. The global value can be defined after its first referenced. If the global value is a constant, storing into it is not allowed.

Examples:

func @foo() {
  // Get the address of a global variable.
  %0 = llvm.mlir.addressof @const : !llvm.ptr

  // Use it as a regular pointer.
  %1 = llvm.load %0 : !llvm.ptr -> i32

  // Get the address of a function.
  %2 = llvm.mlir.addressof @foo : !llvm.ptr

  // The function address can be used for indirect calls.
  llvm.call %2() : !llvm.ptr, () -> ()
}

// Define the global.
llvm.mlir.global @const(42 : i32) : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), SymbolUserOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
global_name::mlir::FlatSymbolRefAttrflat symbol reference attribute

Results: 

ResultDescription
resLLVM pointer type

llvm.alloca (LLVM::AllocaOp) 

Interfaces: DestructurableAllocationOpInterface, GetResultPtrElementType, PromotableAllocationOpInterface

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr64-bit signless integer attribute
elem_type::mlir::TypeAttrany type attribute
inalloca::mlir::UnitAttrunit attribute

Operands: 

OperandDescription
arraySizesignless integer

Results: 

ResultDescription
resLLVM pointer type

llvm.and (LLVM::AndOp) 

Syntax:

operation ::= `llvm.and` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.cmpxchg (LLVM::AtomicCmpXchgOp) 

Syntax:

operation ::= `llvm.cmpxchg` (`weak` $weak^)? (`volatile` $volatile_^)? $ptr `,` $cmp `,` $val
              (`syncscope` `(` $syncscope^ `)`)? $success_ordering $failure_ordering
              attr-dict `:` qualified(type($ptr)) `,` type($val)

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, InferTypeOpInterface

Attributes: 

AttributeMLIR TypeDescription
success_ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
failure_ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
syncscope::mlir::StringAttrstring attribute
alignment::mlir::IntegerAttr64-bit signless integer attribute
weak::mlir::UnitAttrunit attribute
volatile_::mlir::UnitAttrunit attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
ptrLLVM pointer type
cmpsignless integer or LLVM pointer type
valsignless integer or LLVM pointer type

Results: 

ResultDescription
resLLVM structure type

llvm.atomicrmw (LLVM::AtomicRMWOp) 

Syntax:

operation ::= `llvm.atomicrmw` (`volatile` $volatile_^)? $bin_op $ptr `,` $val
              (`syncscope` `(` $syncscope^ `)`)? $ordering attr-dict `:`
              qualified(type($ptr)) `,` type($val)

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, InferTypeOpInterface

Attributes: 

AttributeMLIR TypeDescription
bin_op::mlir::LLVM::AtomicBinOpAttr
llvm.atomicrmw binary operations

Enum cases:

  • xchg (xchg)
  • add (add)
  • sub (sub)
  • _and (_and)
  • nand (nand)
  • _or (_or)
  • _xor (_xor)
  • max (max)
  • min (min)
  • umax (umax)
  • umin (umin)
  • fadd (fadd)
  • fsub (fsub)
  • fmax (fmax)
  • fmin (fmin)
  • uinc_wrap (uinc_wrap)
  • udec_wrap (udec_wrap)
ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
syncscope::mlir::StringAttrstring attribute
alignment::mlir::IntegerAttr64-bit signless integer attribute
volatile_::mlir::UnitAttrunit attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
ptrLLVM pointer type
valfloating point LLVM type or LLVM pointer type or signless integer

Results: 

ResultDescription
resfloating point LLVM type or LLVM pointer type or signless integer

llvm.bitcast (LLVM::BitcastOp) 

Syntax:

operation ::= `llvm.bitcast` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), PromotableOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argLLVM-compatible non-aggregate type

Results: 

ResultDescription
resLLVM-compatible non-aggregate type

llvm.br (LLVM::BrOp) 

Syntax:

operation ::= `llvm.br` $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict

Traits: AlwaysSpeculatableImplTrait, Terminator

Interfaces: BranchOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
loop_annotation::mlir::LLVM::LoopAnnotationAttr
This attributes encapsulates "loop metadata". It is meant to decorate
branches that are "latches" (loop backedges) and maps to the `!llvm.loop`
metadatas: https://llvm.org/docs/LangRef.html#llvm-loop
It stores annotations in attribute parameters and groups related options in
nested attributes to provide structured access.

Operands: 

OperandDescription
destOperandsvariadic of LLVM dialect-compatible type

Successors: 

SuccessorDescription
destany successor

llvm.call_intrinsic (LLVM::CallIntrinsicOp) 

Call to an LLVM intrinsic function.

Syntax:

operation ::= `llvm.call_intrinsic` $intrin `(` $args `)` `:` functional-type($args, $results) attr-dict

Call the specified llvm intrinsic. If the intrinsic is overloaded, use the MLIR function type of this op to determine which intrinsic to call.

Interfaces: FastmathFlagsInterface

Attributes: 

AttributeMLIR TypeDescription
intrin::mlir::StringAttrstring attribute
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
argsvariadic of LLVM dialect-compatible type

Results: 

ResultDescription
resultsLLVM dialect-compatible type

llvm.call (LLVM::CallOp) 

Call to an LLVM function.

In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect implements this behavior by providing a variadic call operation for 0- and 1-result functions. Even though MLIR supports multi-result functions, LLVM IR dialect disallows them.

The call instruction supports both direct and indirect calls. Direct calls start with a function name (@-prefixed) and indirect calls start with an SSA value (%-prefixed). The direct callee, if present, is stored as a function attribute callee. For indirect calls, the callee is of !llvm.ptr type and is stored as the first value in callee_operands. If the callee is a variadic function, then the callee_type attribute must carry the function type. The trailing type list contains the optional indirect callee type and the MLIR function type, which differs from the LLVM function type that uses a explicit void type to model functions that do not return a value.

Examples:

// Direct call without arguments and with one result.
%0 = llvm.call @foo() : () -> (f32)

// Direct call with arguments and without a result.
llvm.call @bar(%0) : (f32) -> ()

// Indirect call with an argument and without a result.
%1 = llvm.mlir.addressof @foo : !llvm.ptr
llvm.call %1(%0) : !llvm.ptr, (f32) -> ()

// Direct variadic call.
llvm.call @printf(%0, %1) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i32) -> i32

// Indirect variadic call
llvm.call %1(%0) vararg(!llvm.func<void (...)>) : !llvm.ptr, (i32) -> ()

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, BranchWeightOpInterface, CallOpInterface, FastmathFlagsInterface, SymbolUserOpInterface

Attributes: 

AttributeMLIR TypeDescription
callee_type::mlir::TypeAttrtype attribute of LLVM function type
callee::mlir::FlatSymbolRefAttrflat symbol reference attribute
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)
branch_weights::mlir::DenseI32ArrayAttri32 dense array attribute
CConv::mlir::LLVM::CConvAttrLLVM Calling Convention specification
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
callee_operandsvariadic of LLVM dialect-compatible type

Results: 

ResultDescription
resultLLVM dialect-compatible type

llvm.comdat (LLVM::ComdatOp) 

LLVM dialect comdat region

Syntax:

operation ::= `llvm.comdat` $sym_name $body attr-dict

Provides access to object file COMDAT section/group functionality.

Examples:

llvm.comdat @__llvm_comdat {
  llvm.comdat_selector @any any
}
llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64

Traits: NoRegionArguments, NoTerminator, SymbolTable

Interfaces: Symbol

Attributes: 

AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute

llvm.comdat_selector (LLVM::ComdatSelectorOp) 

LLVM dialect comdat selector declaration

Syntax:

operation ::= `llvm.comdat_selector` $sym_name $comdat attr-dict

Provides access to object file COMDAT section/group functionality.

Examples:

llvm.comdat @__llvm_comdat {
  llvm.comdat_selector @any any
}
llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64

Interfaces: Symbol

Attributes: 

AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
comdat::mlir::LLVM::comdat::ComdatAttr
LLVM Comdat Types

Enum cases:

  • any (Any)
  • exactmatch (ExactMatch)
  • largest (Largest)
  • nodeduplicate (NoDeduplicate)
  • samesize (SameSize)

llvm.cond_br (LLVM::CondBrOp) 

Syntax:

operation ::= `llvm.cond_br` $condition ( `weights` `(` $branch_weights^ `)` )? `,`
              $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
              $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
              attr-dict

Traits: AlwaysSpeculatableImplTrait, AttrSizedOperandSegments, Terminator

Interfaces: BranchOpInterface, BranchWeightOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
branch_weights::mlir::DenseI32ArrayAttri32 dense array attribute
loop_annotation::mlir::LLVM::LoopAnnotationAttr
This attributes encapsulates "loop metadata". It is meant to decorate
branches that are "latches" (loop backedges) and maps to the `!llvm.loop`
metadatas: https://llvm.org/docs/LangRef.html#llvm-loop
It stores annotations in attribute parameters and groups related options in
nested attributes to provide structured access.

Operands: 

OperandDescription
condition1-bit signless integer
trueDestOperandsvariadic of LLVM dialect-compatible type
falseDestOperandsvariadic of LLVM dialect-compatible type

Successors: 

SuccessorDescription
trueDestany successor
falseDestany successor

llvm.mlir.constant (LLVM::ConstantOp) 

Defines a constant of LLVM type.

Syntax:

operation ::= `llvm.mlir.constant` `(` $value `)` attr-dict `:` type($res)

Unlike LLVM IR, MLIR does not have first-class constant values. Therefore, all constants must be created as SSA values before being used in other operations. llvm.mlir.constant creates such values for scalars and vectors. It has a mandatory value attribute, which may be an integer, floating point attribute; dense or sparse attribute containing integers or floats. The type of the attribute is one of the corresponding MLIR builtin types. It may be omitted for i64 and f64 types that are implied. The operation produces a new SSA value of the specified LLVM IR dialect type. The type of that value must correspond to the attribute type converted to LLVM IR.

Examples:

// Integer constant, internal i32 is mandatory
%0 = llvm.mlir.constant(42 : i32) : i32

// It's okay to omit i64.
%1 = llvm.mlir.constant(42) : i64

// Floating point constant.
%2 = llvm.mlir.constant(42.0 : f32) : f32

// Splat dense vector constant.
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32>

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
value::mlir::Attributeany attribute

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.extractelement (LLVM::ExtractElementOp) 

Extract an element from an LLVM vector.

Syntax:

operation ::= `llvm.extractelement` $vector `[` $position `:` type($position) `]` attr-dict `:` type($vector)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
vectorLLVM dialect-compatible vector type
positionsignless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.extractvalue (LLVM::ExtractValueOp) 

Extract a value from an LLVM struct.

Syntax:

operation ::= `llvm.extractvalue` $container `` $position attr-dict `:` type($container)
              custom<InsertExtractValueElementType>(type($res), ref(type($container)),
              ref($position))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
position::mlir::DenseI64ArrayAttri64 dense array attribute

Operands: 

OperandDescription
containerLLVM aggregate type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.fadd (LLVM::FAddOp) 

Syntax:

operation ::= `llvm.fadd` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fcmp (LLVM::FCmpOp) 

Traits: AlwaysSpeculatableImplTrait, SameTypeOperands

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
predicate::mlir::LLVM::FCmpPredicateAttr
llvm.fcmp comparison predicate

Enum cases:

  • _false (_false)
  • oeq (oeq)
  • ogt (ogt)
  • oge (oge)
  • olt (olt)
  • ole (ole)
  • one (one)
  • ord (ord)
  • ueq (ueq)
  • ugt (ugt)
  • uge (uge)
  • ult (ult)
  • ule (ule)
  • une (une)
  • uno (uno)
  • _true (_true)
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
res1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer

llvm.fdiv (LLVM::FDivOp) 

Syntax:

operation ::= `llvm.fdiv` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fmul (LLVM::FMulOp) 

Syntax:

operation ::= `llvm.fmul` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fneg (LLVM::FNegOp) 

Syntax:

operation ::= `llvm.fneg` $operand custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
operandfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fpext (LLVM::FPExtOp) 

Syntax:

operation ::= `llvm.fpext` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fptosi (LLVM::FPToSIOp) 

Syntax:

operation ::= `llvm.fptosi` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.fptoui (LLVM::FPToUIOp) 

Syntax:

operation ::= `llvm.fptoui` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.fptrunc (LLVM::FPTruncOp) 

Syntax:

operation ::= `llvm.fptrunc` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.frem (LLVM::FRemOp) 

Syntax:

operation ::= `llvm.frem` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fsub (LLVM::FSubOp) 

Syntax:

operation ::= `llvm.fsub` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
rhsfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.fence (LLVM::FenceOp) 

Syntax:

operation ::= `llvm.fence` (`syncscope` `(` $syncscope^ `)`)? $ordering attr-dict

Attributes: 

AttributeMLIR TypeDescription
ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
syncscope::mlir::StringAttrstring attribute

llvm.freeze (LLVM::FreezeOp) 

Syntax:

operation ::= `llvm.freeze` $val attr-dict `:` type($val)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valLLVM dialect-compatible type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.getelementptr (LLVM::GEPOp) 

Syntax:

operation ::= `llvm.getelementptr` (`inbounds` $inbounds^)?
              $base `[` custom<GEPIndices>($dynamicIndices, $rawConstantIndices) `]` attr-dict
              `:` functional-type(operands, results) `,` $elem_type

This operation mirrors LLVM IRs ‘getelementptr’ operation that is used to perform pointer arithmetic.

Like in LLVM IR, it is possible to use both constants as well as SSA values as indices. In the case of indexing within a structure, it is required to either use constant indices directly, or supply a constant SSA value.

An optional ‘inbounds’ attribute specifies the low-level pointer arithmetic overflow behavior that LLVM uses after lowering the operation to LLVM IR.

Examples:

// GEP with an SSA value offset
%0 = llvm.getelementptr %1[%2] : (!llvm.ptr, i64) -> !llvm.ptr, f32

// GEP with a constant offset and the inbounds attribute set
%0 = llvm.getelementptr inbounds %1[3] : (!llvm.ptr) -> !llvm.ptr, f32

// GEP with constant offsets into a structure
%0 = llvm.getelementptr %1[0, 1]
   : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, f32)>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, DestructurableAccessorOpInterface, GetResultPtrElementType, NoMemoryEffect (MemoryEffectOpInterface), PromotableOpInterface, SafeMemorySlotAccessOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
rawConstantIndices::mlir::DenseI32ArrayAttri32 dense array attribute
elem_type::mlir::TypeAttrany type attribute
inbounds::mlir::UnitAttrunit attribute

Operands: 

OperandDescription
baseLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type
dynamicIndicesvariadic of signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

llvm.mlir.global_ctors (LLVM::GlobalCtorsOp) 

LLVM dialect global_ctors.

Syntax:

operation ::= `llvm.mlir.global_ctors` attr-dict

Specifies a list of constructor functions and priorities. The functions referenced by this array will be called in ascending order of priority (i.e. lowest first) when the module is loaded. The order of functions with the same priority is not defined. This operation is translated to LLVM’s global_ctors global variable. The initializer functions are run at load time. The data field present in LLVM’s global_ctors variable is not modeled here.

Examples:

llvm.mlir.global_ctors {@ctor}

llvm.func @ctor() {
  ...
  llvm.return
}

Interfaces: SymbolUserOpInterface

Attributes: 

AttributeMLIR TypeDescription
ctors::mlir::ArrayAttrflat symbol ref array attribute
priorities::mlir::ArrayAttr32-bit integer array attribute

llvm.mlir.global_dtors (LLVM::GlobalDtorsOp) 

LLVM dialect global_dtors.

Syntax:

operation ::= `llvm.mlir.global_dtors` attr-dict

Specifies a list of destructor functions and priorities. The functions referenced by this array will be called in descending order of priority (i.e. highest first) when the module is unloaded. The order of functions with the same priority is not defined. This operation is translated to LLVM’s global_dtors global variable. The data field present in LLVM’s global_dtors variable is not modeled here.

Examples:

llvm.func @dtor() {
  llvm.return
}
llvm.mlir.global_dtors {@dtor}

Interfaces: SymbolUserOpInterface

Attributes: 

AttributeMLIR TypeDescription
dtors::mlir::ArrayAttrflat symbol ref array attribute
priorities::mlir::ArrayAttr32-bit integer array attribute

llvm.mlir.global (LLVM::GlobalOp) 

LLVM dialect global.

Since MLIR allows for arbitrary operations to be present at the top level, global variables are defined using the llvm.mlir.global operation. Both global constants and variables can be defined, and the value may also be initialized in both cases.

There are two forms of initialization syntax. Simple constants that can be represented as MLIR attributes can be given in-line:

llvm.mlir.global @variable(32.0 : f32) : f32

This initialization and type syntax is similar to llvm.mlir.constant and may use two types: one for MLIR attribute and another for the LLVM value. These types must be compatible.

More complex constants that cannot be represented as MLIR attributes can be given in an initializer region:

// This global is initialized with the equivalent of:
//   i32* getelementptr (i32* @g2, i32 2)
llvm.mlir.global constant @int_gep() : !llvm.ptr {
  %0 = llvm.mlir.addressof @g2 : !llvm.ptr
  %1 = llvm.mlir.constant(2 : i32) : i32
  %2 = llvm.getelementptr %0[%1]
     : (!llvm.ptr, i32) -> !llvm.ptr, i32
  // The initializer region must end with `llvm.return`.
  llvm.return %2 : !llvm.ptr
}

Only one of the initializer attribute or initializer region may be provided.

llvm.mlir.global must appear at top-level of the enclosing module. It uses an @-identifier for its value, which will be uniqued by the module with respect to other @-identifiers in it.

Examples:

// Global values use @-identifiers.
llvm.mlir.global constant @cst(42 : i32) : i32

// Non-constant values must also be initialized.
llvm.mlir.global @variable(32.0 : f32) : f32

// Strings are expected to be of wrapped LLVM i8 array type and do not
// automatically include the trailing zero.
llvm.mlir.global @string("abc") : !llvm.array<3 x i8>

// For strings globals, the trailing type may be omitted.
llvm.mlir.global constant @no_trailing_type("foo bar")

// A complex initializer is constructed with an initializer region.
llvm.mlir.global constant @int_gep() : !llvm.ptr {
  %0 = llvm.mlir.addressof @g2 : !llvm.ptr
  %1 = llvm.mlir.constant(2 : i32) : i32
  %2 = llvm.getelementptr %0[%1]
     : (!llvm.ptr, i32) -> !llvm.ptr, i32
  llvm.return %2 : !llvm.ptr
}

Similarly to functions, globals have a linkage attribute. In the custom syntax, this attribute is placed between llvm.mlir.global and the optional constant keyword. If the attribute is omitted, external linkage is assumed by default.

Examples:

// A constant with internal linkage will not participate in linking.
llvm.mlir.global internal constant @cst(42 : i32) : i32

// By default, "external" linkage is assumed and the global participates in
// symbol resolution at link-time.
llvm.mlir.global @glob(0 : f32) : f32

// Alignment is optional
llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) : !llvm.array<8 x f32>

Like global variables in LLVM IR, globals can have an (optional) alignment attribute using keyword alignment. The integer value of the alignment must be a positive integer that is a power of 2.

Examples:

// Alignment is optional
llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) { alignment = 32 : i64 } : !llvm.array<8 x f32>

Traits: IsolatedFromAbove, SingleBlockImplicitTerminator<ReturnOp>, SingleBlock

Interfaces: Symbol

Attributes: 

AttributeMLIR TypeDescription
global_type::mlir::TypeAttrany type attribute
constant::mlir::UnitAttrunit attribute
sym_name::mlir::StringAttrstring attribute
linkage::mlir::LLVM::LinkageAttrLLVM Linkage specification
dso_local::mlir::UnitAttrunit attribute
thread_local_::mlir::UnitAttrunit attribute
value::mlir::Attributeany attribute
alignment::mlir::IntegerAttr64-bit signless integer attribute
addr_space::mlir::IntegerAttr32-bit signless integer attribute whose value is non-negative
unnamed_addr::mlir::LLVM::UnnamedAddrAttr
LLVM GlobalValue UnnamedAddr

Enum cases:

  • (None)
  • local_unnamed_addr (Local)
  • unnamed_addr (Global)
section::mlir::StringAttrstring attribute
comdat::mlir::SymbolRefAttrsymbol reference attribute
dbg_expr::mlir::LLVM::DIGlobalVariableExpressionAttr
visibility_::mlir::LLVM::VisibilityAttr
LLVM GlobalValue Visibility

Enum cases:

  • (Default)
  • hidden (Hidden)
  • protected (Protected)

llvm.icmp (LLVM::ICmpOp) 

Traits: AlwaysSpeculatableImplTrait, SameTypeOperands

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
predicate::mlir::LLVM::ICmpPredicateAttr
lvm.icmp comparison predicate

Enum cases:

  • eq (eq)
  • ne (ne)
  • slt (slt)
  • sle (sle)
  • sgt (sgt)
  • sge (sge)
  • ult (ult)
  • ule (ule)
  • ugt (ugt)
  • uge (uge)

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer or LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type
rhssignless integer or LLVM dialect-compatible vector of signless integer or LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

Results: 

ResultDescription
res1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer

llvm.inline_asm (LLVM::InlineAsmOp) 

Syntax:

operation ::= `llvm.inline_asm` (`has_side_effects` $has_side_effects^)?
              (`is_align_stack` $is_align_stack^)?
              (`asm_dialect` `=` $asm_dialect^)?
              (`operand_attrs` `=` $operand_attrs^)?
              attr-dict
              $asm_string `,` $constraints
              operands `:` functional-type(operands, results)

The InlineAsmOp mirrors the underlying LLVM semantics with a notable exception: the embedded asm_string is not allowed to define or reference any symbol or any global variable: only the operands of the op may be read, written, or referenced. Attempting to define or reference any symbol or any global behavior is considered undefined behavior at this time.

Attributes: 

AttributeMLIR TypeDescription
asm_string::mlir::StringAttrstring attribute
constraints::mlir::StringAttrstring attribute
has_side_effects::mlir::UnitAttrunit attribute
is_align_stack::mlir::UnitAttrunit attribute
asm_dialect::mlir::LLVM::AsmDialectAttr
ATT (0) or Intel (1) asm dialect

Enum cases:

  • att (AD_ATT)
  • intel (AD_Intel)
operand_attrs::mlir::ArrayAttrarray attribute

Operands: 

OperandDescription
operandsvariadic of LLVM dialect-compatible type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.insertelement (LLVM::InsertElementOp) 

Insert an element into an LLVM vector.

Syntax:

operation ::= `llvm.insertelement` $value `,` $vector `[` $position `:` type($position) `]` attr-dict `:`
              type($vector)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
vectorLLVM dialect-compatible vector type
valueprimitive LLVM type
positionsignless integer

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.insertvalue (LLVM::InsertValueOp) 

Insert a value into an LLVM struct.

Syntax:

operation ::= `llvm.insertvalue` $value `,` $container `` $position attr-dict `:` type($container)
              custom<InsertExtractValueElementType>(type($value), ref(type($container)),
              ref($position))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
position::mlir::DenseI64ArrayAttri64 dense array attribute

Operands: 

OperandDescription
containerLLVM aggregate type
valueprimitive LLVM type

Results: 

ResultDescription
resLLVM aggregate type

llvm.inttoptr (LLVM::IntToPtrOp) 

Syntax:

operation ::= `llvm.inttoptr` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

llvm.invoke (LLVM::InvokeOp) 

Traits: AttrSizedOperandSegments, Terminator

Interfaces: BranchOpInterface, BranchWeightOpInterface, CallOpInterface

Attributes: 

AttributeMLIR TypeDescription
callee_type::mlir::TypeAttrtype attribute of LLVM function type
callee::mlir::FlatSymbolRefAttrflat symbol reference attribute
branch_weights::mlir::DenseI32ArrayAttri32 dense array attribute
CConv::mlir::LLVM::CConvAttrLLVM Calling Convention specification

Operands: 

OperandDescription
callee_operandsvariadic of LLVM dialect-compatible type
normalDestOperandsvariadic of LLVM dialect-compatible type
unwindDestOperandsvariadic of LLVM dialect-compatible type

Results: 

ResultDescription
«unnamed»variadic of LLVM dialect-compatible type

Successors: 

SuccessorDescription
normalDestany successor
unwindDestany successor

llvm.func (LLVM::LLVMFuncOp) 

LLVM dialect function.

MLIR functions are defined by an operation that is not built into the IR itself. The LLVM dialect provides an llvm.func operation to define functions compatible with LLVM IR. These functions have LLVM dialect function type but use MLIR syntax to express it. They are required to have exactly one result type. LLVM function operation is intended to capture additional properties of LLVM functions, such as linkage and calling convention, that may be modeled differently by the built-in MLIR function.

// The type of @bar is !llvm<"i64 (i64)">
llvm.func @bar(%arg0: i64) -> i64 {
  llvm.return %arg0 : i64
}

// Type type of @foo is !llvm<"void (i64)">
// !llvm.void type is omitted
llvm.func @foo(%arg0: i64) {
  llvm.return
}

// A function with `internal` linkage.
llvm.func internal @internal_func() {
  llvm.return
}

Traits: AutomaticAllocationScope, IsolatedFromAbove

Interfaces: CallableOpInterface, FunctionOpInterface, Symbol

Attributes: 

AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
sym_visibility::mlir::StringAttrstring attribute
function_type::mlir::TypeAttrtype attribute of LLVM function type
linkage::mlir::LLVM::LinkageAttrLLVM Linkage specification
dso_local::mlir::UnitAttrunit attribute
CConv::mlir::LLVM::CConvAttrLLVM Calling Convention specification
comdat::mlir::SymbolRefAttrsymbol reference attribute
personality::mlir::FlatSymbolRefAttrflat symbol reference attribute
garbageCollector::mlir::StringAttrstring attribute
passthrough::mlir::ArrayAttrarray attribute
arg_attrs::mlir::ArrayAttrArray of dictionary attributes
res_attrs::mlir::ArrayAttrArray of dictionary attributes
function_entry_count::mlir::IntegerAttr64-bit signless integer attribute
memory::mlir::LLVM::MemoryEffectsAttr
visibility_::mlir::LLVM::VisibilityAttr
LLVM GlobalValue Visibility

Enum cases:

  • (Default)
  • hidden (Hidden)
  • protected (Protected)
arm_streaming::mlir::UnitAttrunit attribute
arm_locally_streaming::mlir::UnitAttrunit attribute
arm_streaming_compatible::mlir::UnitAttrunit attribute
arm_new_za::mlir::UnitAttrunit attribute
arm_in_za::mlir::UnitAttrunit attribute
arm_out_za::mlir::UnitAttrunit attribute
arm_inout_za::mlir::UnitAttrunit attribute
arm_preserves_za::mlir::UnitAttrunit attribute
section::mlir::StringAttrstring attribute
unnamed_addr::mlir::LLVM::UnnamedAddrAttr
LLVM GlobalValue UnnamedAddr

Enum cases:

  • (None)
  • local_unnamed_addr (Local)
  • unnamed_addr (Global)
alignment::mlir::IntegerAttr64-bit signless integer attribute
vscale_range::mlir::LLVM::VScaleRangeAttr
frame_pointer::mlir::LLVM::FramePointerKindAttr
target_cpu::mlir::StringAttrstring attribute
target_features::mlir::LLVM::TargetFeaturesAttr
LLVM target features attribute
Represents the LLVM target features as a list that can be checked within
passes/rewrites.

Example:

#llvm.target_features&lt;[&quot;+sme&quot;, &quot;+sve&quot;, &quot;+sme-f64f64&quot;]&gt;

Then within a pass or rewrite the features active at an op can be queried:

auto targetFeatures = LLVM::TargetFeaturesAttr::featuresAt(op);

if (!targetFeatures.contains(&quot;+sme-f64f64&quot;))
  return failure();

unsafe_fp_math::mlir::BoolAttrbool attribute
no_infs_fp_math::mlir::BoolAttrbool attribute
no_nans_fp_math::mlir::BoolAttrbool attribute
approx_func_fp_math::mlir::BoolAttrbool attribute
no_signed_zeros_fp_math::mlir::BoolAttrbool attribute

llvm.lshr (LLVM::LShrOp) 

Syntax:

operation ::= `llvm.lshr` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.landingpad (LLVM::LandingpadOp) 

Attributes: 

AttributeMLIR TypeDescription
cleanup::mlir::UnitAttrunit attribute

Operands: 

OperandDescription
«unnamed»variadic of LLVM dialect-compatible type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.linker_options (LLVM::LinkerOptionsOp) 

Options to pass to the linker when the object file is linked

Syntax:

operation ::= `llvm.linker_options` $options attr-dict

Pass the given options to the linker when the resulting object file is linked. This is used extensively on Windows to determine the C runtime that the object files should link against.

Examples:

// Link against the MSVC static threaded CRT.
llvm.linker_options ["/DEFAULTLIB:", "libcmt"]

// Link against aarch64 compiler-rt builtins
llvm.linker_options ["-l", "clang_rt.builtins-aarch64"]

Attributes: 

AttributeMLIR TypeDescription
options::mlir::ArrayAttrstring array attribute

llvm.load (LLVM::LoadOp) 

Syntax:

operation ::= `llvm.load` (`volatile` $volatile_^)? $addr
              (`atomic` (`syncscope` `(` $syncscope^ `)`)? $ordering^)?
              (`invariant` $invariant^)?
              attr-dict `:` qualified(type($addr)) `->` type($res)

The load operation is used to read from memory. A load may be marked as atomic, volatile, and/or nontemporal, and takes a number of optional attributes that specify aliasing information.

An atomic load only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.

Examples:

// A volatile load of a float variable.
%0 = llvm.load volatile %ptr : !llvm.ptr -> f32

// A nontemporal load of a float variable.
%0 = llvm.load %ptr {nontemporal} : !llvm.ptr -> f32

// An atomic load of an integer variable.
%0 = llvm.load %ptr atomic monotonic {alignment = 8 : i64}
    : !llvm.ptr -> i64

See the following link for more details: https://llvm.org/docs/LangRef.html#load-instruction

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, MemoryEffectOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr64-bit signless integer attribute
volatile_::mlir::UnitAttrunit attribute
nontemporal::mlir::UnitAttrunit attribute
invariant::mlir::UnitAttrunit attribute
ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
syncscope::mlir::StringAttrstring attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
addrLLVM pointer type

Results: 

ResultDescription
resLLVM type with size

llvm.mul (LLVM::MulOp) 

Syntax:

operation ::= `llvm.mul` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags)
              `` custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, Commutative, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, IntegerOverflowFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.mlir.none (LLVM::NoneTokenOp) 

Defines a value containing an empty token to LLVM type.

Syntax:

operation ::= `llvm.mlir.none` attr-dict `:` type($res)

Unlike LLVM IR, MLIR does not have first-class token values. They must be explicitly created as SSA values using llvm.mlir.none. This operation has no operands or attributes, and returns a none token value of a wrapped LLVM IR pointer type.

Examples:

%0 = llvm.mlir.none : !llvm.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results: 

ResultDescription
resLLVM token type

llvm.or (LLVM::OrOp) 

Syntax:

operation ::= `llvm.or` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.mlir.poison (LLVM::PoisonOp) 

Creates a poison value of LLVM dialect type.

Syntax:

operation ::= `llvm.mlir.poison` attr-dict `:` type($res)

Unlike LLVM IR, MLIR does not have first-class poison values. Such values must be created as SSA values using llvm.mlir.poison. This operation has no operands or attributes. It creates a poison value of the specified LLVM IR dialect type.

Example:

// Create a poison value for a structure with a 32-bit integer followed
// by a float.
%0 = llvm.mlir.poison : !llvm.struct<(i32, f32)>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.ptrtoint (LLVM::PtrToIntOp) 

Syntax:

operation ::= `llvm.ptrtoint` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argLLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.resume (LLVM::ResumeOp) 

Syntax:

operation ::= `llvm.resume` $value attr-dict `:` type($value)

Traits: Terminator

Operands: 

OperandDescription
valueLLVM dialect-compatible type

llvm.return (LLVM::ReturnOp) 

Syntax:

operation ::= `llvm.return` attr-dict ($arg^ `:` type($arg))?

Traits: AlwaysSpeculatableImplTrait, ReturnLike, Terminator

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), RegionBranchTerminatorOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argLLVM dialect-compatible type

llvm.sdiv (LLVM::SDivOp) 

Syntax:

operation ::= `llvm.sdiv` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.sext (LLVM::SExtOp) 

Syntax:

operation ::= `llvm.sext` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.sitofp (LLVM::SIToFPOp) 

Syntax:

operation ::= `llvm.sitofp` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.srem (LLVM::SRemOp) 

Syntax:

operation ::= `llvm.srem` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.select (LLVM::SelectOp) 

Syntax:

operation ::= `llvm.select` operands attr-dict `:` type($condition) `,` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
condition1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer
trueValueLLVM dialect-compatible type
falseValueLLVM dialect-compatible type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.shl (LLVM::ShlOp) 

Syntax:

operation ::= `llvm.shl` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags)
              `` custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, IntegerOverflowFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.shufflevector (LLVM::ShuffleVectorOp) 

Construct a permutation of two vectors.

Syntax:

operation ::= `llvm.shufflevector` $v1 `,` $v2 $mask attr-dict `:` type($v1)
              custom<ShuffleType>(ref(type($v1)), type($res), ref($mask))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
mask::mlir::DenseI32ArrayAttri32 dense array attribute

Operands: 

OperandDescription
v1LLVM dialect-compatible vector type
v2LLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.store (LLVM::StoreOp) 

Syntax:

operation ::= `llvm.store` (`volatile` $volatile_^)? $value `,` $addr
              (`atomic` (`syncscope` `(` $syncscope^ `)`)? $ordering^)?
              attr-dict `:` type($value) `,` qualified(type($addr))

The store operation is used to write to memory. A store may be marked as atomic, volatile, and/or nontemporal, and takes a number of optional attributes that specify aliasing information.

An atomic store only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.

Examples:

// A volatile store of a float variable.
llvm.store volatile %val, %ptr : f32, !llvm.ptr

// A nontemporal store of a float variable.
llvm.store %val, %ptr {nontemporal} : f32, !llvm.ptr

// An atomic store of an integer variable.
llvm.store %val, %ptr atomic monotonic {alignment = 8 : i64}
    : i64, !llvm.ptr

See the following link for more details: https://llvm.org/docs/LangRef.html#store-instruction

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, MemoryEffectOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr64-bit signless integer attribute
volatile_::mlir::UnitAttrunit attribute
nontemporal::mlir::UnitAttrunit attribute
ordering::mlir::LLVM::AtomicOrderingAttr
Atomic ordering for LLVM's memory model

Enum cases:

  • not_atomic (not_atomic)
  • unordered (unordered)
  • monotonic (monotonic)
  • acquire (acquire)
  • release (release)
  • acq_rel (acq_rel)
  • seq_cst (seq_cst)
syncscope::mlir::StringAttrstring attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
valueLLVM type with size
addrLLVM pointer type

llvm.sub (LLVM::SubOp) 

Syntax:

operation ::= `llvm.sub` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags)
              `` custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, IntegerOverflowFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.switch (LLVM::SwitchOp) 

Syntax:

operation ::= `llvm.switch` $value `:` type($value) `,`
              $defaultDestination (`(` $defaultOperands^ `:` type($defaultOperands) `)`)?
              custom<SwitchOpCases>(ref(type($value)), $case_values, $caseDestinations,
              $caseOperands, type($caseOperands))
              attr-dict

Traits: AlwaysSpeculatableImplTrait, AttrSizedOperandSegments, Terminator

Interfaces: BranchOpInterface, BranchWeightOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
case_values::mlir::DenseIntElementsAttrinteger elements attribute
case_operand_segments::mlir::DenseI32ArrayAttri32 dense array attribute
branch_weights::mlir::DenseI32ArrayAttri32 dense array attribute

Operands: 

OperandDescription
valuesignless integer
defaultOperandsvariadic of any type
caseOperandsvariadic of any type

Successors: 

SuccessorDescription
defaultDestinationany successor
caseDestinationsany successor

llvm.trunc (LLVM::TruncOp) 

Syntax:

operation ::= `llvm.trunc` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.udiv (LLVM::UDivOp) 

Syntax:

operation ::= `llvm.udiv` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.uitofp (LLVM::UIToFPOp) 

Syntax:

operation ::= `llvm.uitofp` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

llvm.urem (LLVM::URemOp) 

Syntax:

operation ::= `llvm.urem` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.mlir.undef (LLVM::UndefOp) 

Creates an undefined value of LLVM dialect type.

Syntax:

operation ::= `llvm.mlir.undef` attr-dict `:` type($res)

Unlike LLVM IR, MLIR does not have first-class undefined values. Such values must be created as SSA values using llvm.mlir.undef. This operation has no operands or attributes. It creates an undefined value of the specified LLVM IR dialect type.

Example:

// Create a structure with a 32-bit integer followed by a float.
%0 = llvm.mlir.undef : !llvm.struct<(i32, f32)>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.unreachable (LLVM::UnreachableOp) 

Syntax:

operation ::= `llvm.unreachable` attr-dict

Traits: Terminator

llvm.xor (LLVM::XOrOp) 

Syntax:

operation ::= `llvm.xor` $lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless integer or LLVM dialect-compatible vector of signless integer
rhssignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.zext (LLVM::ZExtOp) 

Syntax:

operation ::= `llvm.zext` $arg attr-dict `:` type($arg) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
argsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
ressignless integer or LLVM dialect-compatible vector of signless integer

llvm.mlir.zero (LLVM::ZeroOp) 

Creates a zero-initialized value of LLVM dialect type.

Syntax:

operation ::= `llvm.mlir.zero` attr-dict `:` type($res)

Unlike LLVM IR, MLIR does not have first-class zero-initialized values. Such values must be created as SSA values using llvm.mlir.zero. This operation has no operands or attributes. It creates a zero-initialized value of the specified LLVM IR dialect type.

Example:

// Create a zero-initialized value for a structure with a 32-bit integer
// followed by a float.
%0 = llvm.mlir.zero : !llvm.struct<(i32, f32)>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results: 

ResultDescription
resLLVM dialect-compatible type

Operations for LLVM IR Intrinsics 

MLIR operation system is open making it unnecessary to introduce a hard bound between “core” operations and “intrinsics”. General LLVM IR intrinsics are modeled as first-class operations in the LLVM dialect. Target-specific LLVM IR intrinsics, e.g., NVVM or ROCDL, are modeled as separate dialects.

source

llvm.intr.abs (LLVM::AbsOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
is_int_min_poison::mlir::IntegerAttr1-bit signless integer attribute

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.annotation (LLVM::Annotation) 

Interfaces: InferTypeOpInterface

Operands: 

OperandDescription
integersignless integer
annotationLLVM pointer type
fileNameLLVM pointer type
line32-bit signless integer

Results: 

ResultDescription
ressignless integer

llvm.intr.assume (LLVM::AssumeOp) 

Operands: 

OperandDescription
cond1-bit signless integer

llvm.intr.bitreverse (LLVM::BitReverseOp) 

Syntax:

operation ::= `llvm.intr.bitreverse` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.bswap (LLVM::ByteSwapOp) 

Syntax:

operation ::= `llvm.intr.bswap` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.experimental.constrained.fptrunc (LLVM::ConstrainedFPTruncIntr) 

Syntax:

operation ::= `llvm.intr.experimental.constrained.fptrunc` $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, FPExceptionBehaviorOpInterface, NoMemoryEffect (MemoryEffectOpInterface), RoundingModeOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
roundingmode::mlir::LLVM::RoundingModeAttr
LLVM Rounding Mode whose minimum value is 0

Enum cases:

  • towardzero (TowardZero)
  • tonearest (NearestTiesToEven)
  • upward (TowardPositive)
  • downward (TowardNegative)
  • tonearestaway (NearestTiesToAway)
  • dynamic (Dynamic)
  • invalid (Invalid)
fpExceptionBehavior::mlir::LLVM::FPExceptionBehaviorAttr
LLVM Exception Behavior

Enum cases:

  • ignore (Ignore)
  • maytrap (MayTrap)
  • strict (Strict)

Operands: 

OperandDescription
arg_0LLVM dialect-compatible type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.copysign (LLVM::CopySignOp) 

Syntax:

operation ::= `llvm.intr.copysign` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.align (LLVM::CoroAlignOp) 

Syntax:

operation ::= `llvm.intr.coro.align` attr-dict `:` type($res)

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.begin (LLVM::CoroBeginOp) 

Syntax:

operation ::= `llvm.intr.coro.begin` $token `,` $mem attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
tokenLLVM token type
memLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.end (LLVM::CoroEndOp) 

Syntax:

operation ::= `llvm.intr.coro.end` $handle `,` $unwind `,` $retvals attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
handleLLVM pointer type
unwind1-bit signless integer
retvalsLLVM token type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.free (LLVM::CoroFreeOp) 

Syntax:

operation ::= `llvm.intr.coro.free` $id `,` $handle attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
idLLVM token type
handleLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.id (LLVM::CoroIdOp) 

Syntax:

operation ::= `llvm.intr.coro.id` $align `,` $promise `,` $coroaddr `,` $fnaddrs attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
align32-bit signless integer
promiseLLVM pointer type
coroaddrLLVM pointer type
fnaddrsLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.promise (LLVM::CoroPromiseOp) 

Syntax:

operation ::= `llvm.intr.coro.promise` $handle `,` $align `,` $from attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
handleLLVM pointer type
align32-bit signless integer
from1-bit signless integer

Results: 

ResultDescription
resLLVM pointer type

llvm.intr.coro.resume (LLVM::CoroResumeOp) 

Syntax:

operation ::= `llvm.intr.coro.resume` $handle attr-dict `:` qualified(type($handle))

Operands: 

OperandDescription
handleLLVM pointer type

llvm.intr.coro.save (LLVM::CoroSaveOp) 

Syntax:

operation ::= `llvm.intr.coro.save` $handle attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
handleLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.size (LLVM::CoroSizeOp) 

Syntax:

operation ::= `llvm.intr.coro.size` attr-dict `:` type($res)

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.coro.suspend (LLVM::CoroSuspendOp) 

Syntax:

operation ::= `llvm.intr.coro.suspend` $save `,` $final attr-dict `:` type($res)

Operands: 

OperandDescription
saveLLVM token type
final1-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.cos (LLVM::CosOp) 

Syntax:

operation ::= `llvm.intr.cos` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ctlz (LLVM::CountLeadingZerosOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
is_zero_poison::mlir::IntegerAttr1-bit signless integer attribute

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.cttz (LLVM::CountTrailingZerosOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
is_zero_poison::mlir::IntegerAttr1-bit signless integer attribute

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ctpop (LLVM::CtPopOp) 

Syntax:

operation ::= `llvm.intr.ctpop` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
insignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.dbg.declare (LLVM::DbgDeclareOp) 

Describes how the address relates to a source language variable.

Syntax:

operation ::= `llvm.intr.dbg.declare` qualified($varInfo) (qualified($locationExpr)^)? `=` $addr `:` qualified(type($addr)) attr-dict

Interfaces: PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
varInfo::mlir::LLVM::DILocalVariableAttr
locationExpr::mlir::LLVM::DIExpressionAttr

Operands: 

OperandDescription
addrLLVM pointer type

llvm.intr.dbg.label (LLVM::DbgLabelOp) 

Relates the program to a debug information label.

Syntax:

operation ::= `llvm.intr.dbg.label` $label attr-dict

Attributes: 

AttributeMLIR TypeDescription
label::mlir::LLVM::DILabelAttr

llvm.intr.dbg.value (LLVM::DbgValueOp) 

Describes how the value relates to a source language variable.

Syntax:

operation ::= `llvm.intr.dbg.value` qualified($varInfo) (qualified($locationExpr)^)? `=` $value `:` qualified(type($value)) attr-dict

Interfaces: PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
varInfo::mlir::LLVM::DILocalVariableAttr
locationExpr::mlir::LLVM::DIExpressionAttr

Operands: 

OperandDescription
valueLLVM dialect-compatible type

llvm.intr.debugtrap (LLVM::DebugTrap) 

llvm.intr.eh.typeid.for (LLVM::EhTypeidForOp) 

Syntax:

operation ::= `llvm.intr.eh.typeid.for` $type_info attr-dict `:` functional-type(operands, results)

Operands: 

OperandDescription
type_infoLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.exp2 (LLVM::Exp2Op) 

Syntax:

operation ::= `llvm.intr.exp2` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.exp (LLVM::ExpOp) 

Syntax:

operation ::= `llvm.intr.exp` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.expect (LLVM::ExpectOp) 

Syntax:

operation ::= `llvm.intr.expect` $val `,` $expected attr-dict `:` type($val)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valsignless integer
expectedsignless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.expect.with.probability (LLVM::ExpectWithProbabilityOp) 

Syntax:

operation ::= `llvm.intr.expect.with.probability` $val `,` $expected `,` $prob attr-dict `:` type($val)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
prob::mlir::FloatAttr64-bit float attribute

Operands: 

OperandDescription
valsignless integer
expectedsignless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.fabs (LLVM::FAbsOp) 

Syntax:

operation ::= `llvm.intr.fabs` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ceil (LLVM::FCeilOp) 

Syntax:

operation ::= `llvm.intr.ceil` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.floor (LLVM::FFloorOp) 

Syntax:

operation ::= `llvm.intr.floor` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.fma (LLVM::FMAOp) 

Syntax:

operation ::= `llvm.intr.fma` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
cfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.fmuladd (LLVM::FMulAddOp) 

Syntax:

operation ::= `llvm.intr.fmuladd` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
cfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.trunc (LLVM::FTruncOp) 

Syntax:

operation ::= `llvm.intr.trunc` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.fshl (LLVM::FshlOp) 

Syntax:

operation ::= `llvm.intr.fshl` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer
csignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.fshr (LLVM::FshrOp) 

Syntax:

operation ::= `llvm.intr.fshr` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer
csignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.get.active.lane.mask (LLVM::GetActiveLaneMaskOp) 

Syntax:

operation ::= `llvm.intr.get.active.lane.mask` $base `,` $n attr-dict `:` type($base) `,` type($n) `to` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
basesignless integer
nsignless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.invariant.end (LLVM::InvariantEndOp) 

Syntax:

operation ::= `llvm.intr.invariant.end` $start `,` $size `,` $ptr attr-dict `:` qualified(type($ptr))

Interfaces: PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
size::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
startLLVM pointer in address space 0
ptrLLVM pointer type

llvm.intr.invariant.start (LLVM::InvariantStartOp) 

Syntax:

operation ::= `llvm.intr.invariant.start` $size `,` $ptr attr-dict `:` qualified(type($ptr))

Interfaces: InferTypeOpInterface, PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
size::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
ptrLLVM pointer type

Results: 

ResultDescription
resLLVM pointer in address space 0

llvm.intr.is.constant (LLVM::IsConstantOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valLLVM dialect-compatible type

Results: 

ResultDescription
res1-bit signless integer

llvm.intr.is.fpclass (LLVM::IsFPClass) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
bit::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.lifetime.end (LLVM::LifetimeEndOp) 

Syntax:

operation ::= `llvm.intr.lifetime.end` $size `,` $ptr attr-dict `:` qualified(type($ptr))

Interfaces: PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
size::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
ptrLLVM pointer type

llvm.intr.lifetime.start (LLVM::LifetimeStartOp) 

Syntax:

operation ::= `llvm.intr.lifetime.start` $size `,` $ptr attr-dict `:` qualified(type($ptr))

Interfaces: PromotableOpInterface

Attributes: 

AttributeMLIR TypeDescription
size::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
ptrLLVM pointer type

llvm.intr.llrint (LLVM::LlrintOp) 

Syntax:

operation ::= `llvm.intr.llrint` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valfloating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.llround (LLVM::LlroundOp) 

Syntax:

operation ::= `llvm.intr.llround` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valfloating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.log10 (LLVM::Log10Op) 

Syntax:

operation ::= `llvm.intr.log10` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.log2 (LLVM::Log2Op) 

Syntax:

operation ::= `llvm.intr.log2` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.log (LLVM::LogOp) 

Syntax:

operation ::= `llvm.intr.log` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.lrint (LLVM::LrintOp) 

Syntax:

operation ::= `llvm.intr.lrint` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valfloating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.lround (LLVM::LroundOp) 

Syntax:

operation ::= `llvm.intr.lround` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
valfloating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.masked.load (LLVM::MaskedLoadOp) 

Syntax:

operation ::= `llvm.intr.masked.load` operands attr-dict `:` functional-type(operands, results)

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
dataLLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer
pass_thruvariadic of LLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.masked.store (LLVM::MaskedStoreOp) 

Syntax:

operation ::= `llvm.intr.masked.store` $value `,` $data `,` $mask attr-dict `:` type($value) `,` type($mask) `into` qualified(type($data))

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
valueLLVM dialect-compatible vector type
dataLLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer

llvm.intr.matrix.column.major.load (LLVM::MatrixColumnMajorLoadOp) 

Syntax:

operation ::= `llvm.intr.matrix.column.major.load` $data `,` `<` `stride` `=` $stride `>` attr-dict`:` type($res) `from` qualified(type($data)) `stride` type($stride)

Attributes: 

AttributeMLIR TypeDescription
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
rows::mlir::IntegerAttr32-bit signless integer attribute
columns::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
dataLLVM pointer type
stridesignless integer

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.matrix.column.major.store (LLVM::MatrixColumnMajorStoreOp) 

Syntax:

operation ::= `llvm.intr.matrix.column.major.store` $matrix `,` $data `,` `<` `stride` `=` $stride `>` attr-dict`:` type($matrix) `to` qualified(type($data)) `stride` type($stride)

Attributes: 

AttributeMLIR TypeDescription
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
rows::mlir::IntegerAttr32-bit signless integer attribute
columns::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
matrixLLVM dialect-compatible vector type
dataLLVM pointer type
stridesignless integer

llvm.intr.matrix.multiply (LLVM::MatrixMultiplyOp) 

Syntax:

operation ::= `llvm.intr.matrix.multiply` $lhs `,` $rhs attr-dict `:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)

Attributes: 

AttributeMLIR TypeDescription
lhs_rows::mlir::IntegerAttr32-bit signless integer attribute
lhs_columns::mlir::IntegerAttr32-bit signless integer attribute
rhs_columns::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector type
rhsLLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.matrix.transpose (LLVM::MatrixTransposeOp) 

Syntax:

operation ::= `llvm.intr.matrix.transpose` $matrix attr-dict `:` type($matrix) `into` type($res)

Attributes: 

AttributeMLIR TypeDescription
rows::mlir::IntegerAttr32-bit signless integer attribute
columns::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
matrixLLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.maxnum (LLVM::MaxNumOp) 

Syntax:

operation ::= `llvm.intr.maxnum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.maximum (LLVM::MaximumOp) 

Syntax:

operation ::= `llvm.intr.maximum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.memcpy.inline (LLVM::MemcpyInlineOp) 

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
len::mlir::IntegerAttrarbitrary integer attribute
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
dstLLVM pointer type
srcLLVM pointer type

llvm.intr.memcpy (LLVM::MemcpyOp) 

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
dstLLVM pointer type
srcLLVM pointer type
lensignless integer

llvm.intr.memmove (LLVM::MemmoveOp) 

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
dstLLVM pointer type
srcLLVM pointer type
lensignless integer

llvm.intr.memset (LLVM::MemsetOp) 

Interfaces: AccessGroupOpInterface, AliasAnalysisOpInterface, DestructurableAccessorOpInterface, PromotableMemOpInterface, SafeMemorySlotAccessOpInterface

Attributes: 

AttributeMLIR TypeDescription
isVolatile::mlir::IntegerAttr1-bit signless integer attribute
access_groups::mlir::ArrayAttrLLVM dialect access group metadata array
alias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
noalias_scopes::mlir::ArrayAttrLLVM dialect alias scope array
tbaa::mlir::ArrayAttrLLVM dialect TBAA tag metadata array

Operands: 

OperandDescription
dstLLVM pointer type
val8-bit signless integer
lensignless integer

llvm.intr.minnum (LLVM::MinNumOp) 

Syntax:

operation ::= `llvm.intr.minnum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.minimum (LLVM::MinimumOp) 

Syntax:

operation ::= `llvm.intr.minimum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.nearbyint (LLVM::NearbyintOp) 

Syntax:

operation ::= `llvm.intr.nearbyint` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.experimental.noalias.scope.decl (LLVM::NoAliasScopeDeclOp) 

Syntax:

operation ::= `llvm.intr.experimental.noalias.scope.decl` $scope attr-dict

Attributes: 

AttributeMLIR TypeDescription
scope::mlir::LLVM::AliasScopeAttr
LLVM dialect alias scope
Defines an alias scope that can be attached to a memory-accessing operation.
Such scopes can be used in combination with `noalias` metadata to indicate
that sets of memory-affecting operations in one scope do not alias with
memory-affecting operations in another scope.

Example:

#domain = #llvm.alias_scope_domain&lt;id = distinct[1]&lt;&gt;, description = &quot;Optional domain description&quot;&gt;
#scope1 = #llvm.alias_scope&lt;id = distinct[2]&lt;&gt;, domain = #domain&gt;
#scope2 = #llvm.alias_scope&lt;id = distinct[3]&lt;&gt;, domain = #domain, description = &quot;Optional scope description&quot;&gt;
llvm.func @foo(%ptr1 : !llvm.ptr) {
    %c0 = llvm.mlir.constant(0 : i32) : i32
    %c4 = llvm.mlir.constant(4 : i32) : i32
    %1 = llvm.ptrtoint %ptr1 : !llvm.ptr to i32
    %2 = llvm.add %1, %c1 : i32
    %ptr2 = llvm.inttoptr %2 : i32 to !llvm.ptr
    llvm.store %c0, %ptr1 { alias_scopes = [#scope1], llvm.noalias = [#scope2] } : i32, !llvm.ptr
    llvm.store %c4, %ptr2 { alias_scopes = [#scope2], llvm.noalias = [#scope1] } : i32, !llvm.ptr
    llvm.return
}

See the following link for more details: https://llvm.org/docs/LangRef.html#noalias-and-alias-scope-metadata

llvm.intr.powi (LLVM::PowIOp) 

Syntax:

operation ::= `llvm.intr.powi` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
valfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
powersignless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.pow (LLVM::PowOp) 

Syntax:

operation ::= `llvm.intr.pow` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
afloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type
bfloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.prefetch (LLVM::Prefetch) 

Attributes: 

AttributeMLIR TypeDescription
rw::mlir::IntegerAttr32-bit signless integer attribute
hint::mlir::IntegerAttr32-bit signless integer attribute
cache::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
addrLLVM pointer type

llvm.intr.ptr.annotation (LLVM::PtrAnnotation) 

Interfaces: InferTypeOpInterface

Operands: 

OperandDescription
ptrLLVM pointer type
annotationLLVM pointer type
fileNameLLVM pointer type
line32-bit signless integer
attrLLVM pointer type

Results: 

ResultDescription
resLLVM pointer type

llvm.intr.rint (LLVM::RintOp) 

Syntax:

operation ::= `llvm.intr.rint` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.roundeven (LLVM::RoundEvenOp) 

Syntax:

operation ::= `llvm.intr.roundeven` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.round (LLVM::RoundOp) 

Syntax:

operation ::= `llvm.intr.round` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.sadd.sat (LLVM::SAddSat) 

Syntax:

operation ::= `llvm.intr.sadd.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.sadd.with.overflow (LLVM::SAddWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.smax (LLVM::SMaxOp) 

Syntax:

operation ::= `llvm.intr.smax` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.smin (LLVM::SMinOp) 

Syntax:

operation ::= `llvm.intr.smin` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.smul.with.overflow (LLVM::SMulWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ssa.copy (LLVM::SSACopyOp) 

Syntax:

operation ::= `llvm.intr.ssa.copy` $operand attr-dict `:` type($operand)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
operandany type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.sshl.sat (LLVM::SSHLSat) 

Syntax:

operation ::= `llvm.intr.sshl.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ssub.sat (LLVM::SSubSat) 

Syntax:

operation ::= `llvm.intr.ssub.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ssub.with.overflow (LLVM::SSubWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.sin (LLVM::SinOp) 

Syntax:

operation ::= `llvm.intr.sin` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.sqrt (LLVM::SqrtOp) 

Syntax:

operation ::= `llvm.intr.sqrt` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
infloating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.stackrestore (LLVM::StackRestoreOp) 

Syntax:

operation ::= `llvm.intr.stackrestore` $ptr attr-dict `:` qualified(type($ptr))

Operands: 

OperandDescription
ptrLLVM pointer type

llvm.intr.stacksave (LLVM::StackSaveOp) 

Syntax:

operation ::= `llvm.intr.stacksave` attr-dict `:` qualified(type($res))

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.experimental.stepvector (LLVM::StepVectorOp) 

Syntax:

operation ::= `llvm.intr.experimental.stepvector` attr-dict `:` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results: 

ResultDescription
resLLVM dialect-compatible vector of signless integer

llvm.intr.threadlocal.address (LLVM::ThreadlocalAddressOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
globalLLVM pointer type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.trap (LLVM::Trap) 

llvm.intr.uadd.sat (LLVM::UAddSat) 

Syntax:

operation ::= `llvm.intr.uadd.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.uadd.with.overflow (LLVM::UAddWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ubsantrap (LLVM::UBSanTrap) 

Attributes: 

AttributeMLIR TypeDescription
failureKind::mlir::IntegerAttr8-bit signless integer attribute

llvm.intr.umax (LLVM::UMaxOp) 

Syntax:

operation ::= `llvm.intr.umax` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.umin (LLVM::UMinOp) 

Syntax:

operation ::= `llvm.intr.umin` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.umul.with.overflow (LLVM::UMulWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.ushl.sat (LLVM::USHLSat) 

Syntax:

operation ::= `llvm.intr.ushl.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.usub.sat (LLVM::USubSat) 

Syntax:

operation ::= `llvm.intr.usub.sat` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultType

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
asignless integer or LLVM dialect-compatible vector of signless integer
bsignless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.usub.with.overflow (LLVM::USubWithOverflowOp) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer
«unnamed»signless integer or LLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.ashr (LLVM::VPAShrOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.add (LLVM::VPAddOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.and (LLVM::VPAndOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fadd (LLVM::VPFAddOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of floating-point
rhsLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fdiv (LLVM::VPFDivOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of floating-point
rhsLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fmuladd (LLVM::VPFMulAddOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
op1LLVM dialect-compatible vector of floating-point
op2LLVM dialect-compatible vector of floating-point
op3LLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fmul (LLVM::VPFMulOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of floating-point
rhsLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fneg (LLVM::VPFNegOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
opLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fpext (LLVM::VPFPExtOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fptosi (LLVM::VPFPToSIOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fptoui (LLVM::VPFPToUIOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fptrunc (LLVM::VPFPTruncOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.frem (LLVM::VPFRemOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of floating-point
rhsLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fsub (LLVM::VPFSubOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of floating-point
rhsLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.fma (LLVM::VPFmaOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
op1LLVM dialect-compatible vector of floating-point
op2LLVM dialect-compatible vector of floating-point
op3LLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.inttoptr (LLVM::VPIntToPtrOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.lshr (LLVM::VPLShrOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.load (LLVM::VPLoadOp) 

Operands: 

OperandDescription
ptrLLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.merge (LLVM::VPMergeMinOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
condLLVM dialect-compatible vector of 1-bit signless integer
true_valLLVM dialect-compatible vector type
false_valLLVM dialect-compatible vector type
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.mul (LLVM::VPMulOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.or (LLVM::VPOrOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.ptrtoint (LLVM::VPPtrToIntOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of LLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.add (LLVM::VPReduceAddOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.and (LLVM::VPReduceAndOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.fadd (LLVM::VPReduceFAddOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuefloating-point
valLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.fmax (LLVM::VPReduceFMaxOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuefloating-point
valLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.fmin (LLVM::VPReduceFMinOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuefloating-point
valLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.fmul (LLVM::VPReduceFMulOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuefloating-point
valLLVM dialect-compatible vector of floating-point
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.mul (LLVM::VPReduceMulOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.or (LLVM::VPReduceOrOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.smax (LLVM::VPReduceSMaxOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.smin (LLVM::VPReduceSMinOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.umax (LLVM::VPReduceUMaxOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.umin (LLVM::VPReduceUMinOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.reduce.xor (LLVM::VPReduceXorOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
satrt_valuesignless integer
valLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.sdiv (LLVM::VPSDivOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.sext (LLVM::VPSExtOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.sitofp (LLVM::VPSIToFPOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.srem (LLVM::VPSRemOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.select (LLVM::VPSelectMinOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
condLLVM dialect-compatible vector of 1-bit signless integer
true_valLLVM dialect-compatible vector type
false_valLLVM dialect-compatible vector type
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.shl (LLVM::VPShlOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.store (LLVM::VPStoreOp) 

Operands: 

OperandDescription
valLLVM dialect-compatible vector type
ptrLLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

llvm.intr.experimental.vp.strided.load (LLVM::VPStridedLoadOp) 

Operands: 

OperandDescription
ptrLLVM pointer type
stridesignless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.experimental.vp.strided.store (LLVM::VPStridedStoreOp) 

Operands: 

OperandDescription
valLLVM dialect-compatible vector type
ptrLLVM pointer type
stridesignless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

llvm.intr.vp.sub (LLVM::VPSubOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.trunc (LLVM::VPTruncOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.udiv (LLVM::VPUDivOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.uitofp (LLVM::VPUIToFPOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.urem (LLVM::VPURemOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.xor (LLVM::VPXorOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhsLLVM dialect-compatible vector of signless integer
rhsLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vp.zext (LLVM::VPZExtOp) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
srcLLVM dialect-compatible vector of signless integer
maskLLVM dialect-compatible vector of 1-bit signless integer
evl32-bit signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vacopy (LLVM::VaCopyOp) 

Copies the current argument position from src_list to dest_list.

Syntax:

operation ::= `llvm.intr.vacopy` $src_list `to` $dest_list attr-dict `:` type(operands)

Operands: 

OperandDescription
dest_listLLVM pointer type
src_listLLVM pointer type

llvm.intr.vaend (LLVM::VaEndOp) 

Destroys arg_list, which has been initialized by intr.vastart or intr.vacopy.

Syntax:

operation ::= `llvm.intr.vaend` $arg_list attr-dict `:` qualified(type($arg_list))

Operands: 

OperandDescription
arg_listLLVM pointer type

llvm.intr.vastart (LLVM::VaStartOp) 

Initializes arg_list for subsequent variadic argument extractions.

Syntax:

operation ::= `llvm.intr.vastart` $arg_list attr-dict `:` qualified(type($arg_list))

Operands: 

OperandDescription
arg_listLLVM pointer type

llvm.intr.var.annotation (LLVM::VarAnnotation) 

Operands: 

OperandDescription
valLLVM pointer type
annotationLLVM pointer type
fileNameLLVM pointer type
line32-bit signless integer
attrLLVM pointer type

llvm.intr.experimental.vector.interleave2 (LLVM::experimental_vector_interleave2) 

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
vec1LLVM dialect-compatible vector type
vec2LLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.masked.compressstore (LLVM::masked_compressstore) 

Operands: 

OperandDescription
«unnamed»LLVM dialect-compatible vector type
«unnamed»LLVM pointer type
«unnamed»LLVM dialect-compatible vector of 1-bit signless integer

llvm.intr.masked.expandload (LLVM::masked_expandload) 

Operands: 

OperandDescription
«unnamed»LLVM pointer type
«unnamed»LLVM dialect-compatible vector of 1-bit signless integer
«unnamed»LLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.masked.gather (LLVM::masked_gather) 

Syntax:

operation ::= `llvm.intr.masked.gather` operands attr-dict `:` functional-type(operands, results)

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
ptrsLLVM dialect-compatible vector of LLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer
pass_thruvariadic of LLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.masked.scatter (LLVM::masked_scatter) 

Syntax:

operation ::= `llvm.intr.masked.scatter` $value `,` $ptrs `,` $mask attr-dict `:` type($value) `,` type($mask) `into` type($ptrs)

Attributes: 

AttributeMLIR TypeDescription
alignment::mlir::IntegerAttr32-bit signless integer attribute

Operands: 

OperandDescription
valueLLVM dialect-compatible vector type
ptrsLLVM dialect-compatible vector of LLVM pointer type
maskLLVM dialect-compatible vector of 1-bit signless integer

llvm.intr.vector.extract (LLVM::vector_extract) 

Syntax:

operation ::= `llvm.intr.vector.extract` $srcvec `[` $pos `]` attr-dict `:` type($res) `from` type($srcvec)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
pos::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
srcvecLLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.vector.insert (LLVM::vector_insert) 

Syntax:

operation ::= `llvm.intr.vector.insert` $srcvec `,` $dstvec `[` $pos `]` attr-dict `:` type($srcvec) `into` type($res)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
pos::mlir::IntegerAttr64-bit signless integer attribute

Operands: 

OperandDescription
dstvecLLVM dialect-compatible vector type
srcvecLLVM dialect-compatible vector type

Results: 

ResultDescription
resLLVM dialect-compatible vector type

llvm.intr.vector.reduce.add (LLVM::vector_reduce_add) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.and (LLVM::vector_reduce_and) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fadd (LLVM::vector_reduce_fadd) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
start_valuefloating-point
inputLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fmax (LLVM::vector_reduce_fmax) 

Syntax:

operation ::= `llvm.intr.vector.reduce.fmax` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
inLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fmaximum (LLVM::vector_reduce_fmaximum) 

Syntax:

operation ::= `llvm.intr.vector.reduce.fmaximum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
inLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fmin (LLVM::vector_reduce_fmin) 

Syntax:

operation ::= `llvm.intr.vector.reduce.fmin` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
inLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fminimum (LLVM::vector_reduce_fminimum) 

Syntax:

operation ::= `llvm.intr.vector.reduce.fminimum` `(` operands `)` custom<LLVMOpAttrs>(attr-dict) `:` functional-type(operands, results)

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
inLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.fmul (LLVM::vector_reduce_fmul) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, FastmathFlagsInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmathFlags::mlir::LLVM::FastmathFlagsAttr
LLVM fastmath flags

Enum cases:

  • none (none)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • reassoc (reassoc)
  • fast (fast)

Operands: 

OperandDescription
start_valuefloating-point
inputLLVM dialect-compatible vector of floating-point

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.mul (LLVM::vector_reduce_mul) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.or (LLVM::vector_reduce_or) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.smax (LLVM::vector_reduce_smax) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.smin (LLVM::vector_reduce_smin) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.umax (LLVM::vector_reduce_umax) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.umin (LLVM::vector_reduce_umin) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vector.reduce.xor (LLVM::vector_reduce_xor) 

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
inLLVM dialect-compatible vector of signless integer

Results: 

ResultDescription
resLLVM dialect-compatible type

llvm.intr.vscale (LLVM::vscale) 

Results: 

ResultDescription
resLLVM dialect-compatible type

Debug Info 

Debug information within the LLVM dialect is represented using locations in combination with a set of attributes that mirror the DINode structure defined by the debug info metadata within LLVM IR. Debug scoping information is attached to LLVM IR dialect operations using a fused location (FusedLoc) whose metadata holds the DIScopeAttr representing the debug scope. Similarly, the subprogram of LLVM IR dialect FuncOp operations is attached using a fused location whose metadata is a DISubprogramAttr.