func
(::mlir::FuncOp) ¶
An operation with a name containing a single SSACFG
region
Operations within the function cannot implicitly capture values defined
outside of the function, i.e. Functions are IsolatedFromAbove
. All
external references must use function arguments or attributes that establish
a symbolic connection (e.g. symbols referenced by name via a string
attribute like SymbolRefAttr). An external function declaration (used when
referring to a function declared in some other module) has no body. While
the MLIR textual form provides a nice inline syntax for function arguments,
they are internally represented as “block arguments” to the first block in
the region.
Only dialect attribute names may be specified in the attribute dictionaries for function arguments, results, or the function itself.
Example:
// External function definitions.
func @abort()
func @scribble(i32, i64, memref<? x 128 x f32, #layout_map0>) -> f64
// A function that returns its argument twice:
func @count(%x: i64) -> (i64, i64)
attributes {fruit: "banana"} {
return %x, %x: i64, i64
}
// A function with an argument attribute
func @example_fn_arg(%x: i32 {swift.self = unit})
// A function with a result attribute
func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
// A function with an attribute
func @example_fn_attr() attributes {dialectName.attrName = false}
Attributes: ¶
Attribute | MLIR Type | Description |
---|---|---|
sym_name | ::mlir::StringAttr | string attribute |
type | ::mlir::TypeAttr | any type attribute |
sym_visibility | ::mlir::StringAttr | string attribute |
module
(::mlir::ModuleOp) ¶
A top level container operation
Syntax:
operation ::= `module` ($sym_name^)? attr-dict-with-keyword $body
A module
represents a top-level container operation. It contains a single
SSACFG region containing a single block which can contain any
operations. Operations within this region cannot implicitly capture values
defined outside the module, i.e. Modules are IsolatedFromAbove
. Modules
have an optional symbol name which can be used to refer to them in
operations.
Example:
module {
func @foo()
}
Attributes: ¶
Attribute | MLIR Type | Description |
---|---|---|
sym_name | ::mlir::StringAttr | string attribute |
sym_visibility | ::mlir::StringAttr | string attribute |
module_terminator
(::mlir::ModuleTerminatorOp) ¶
A pseudo op that marks the end of a module
Syntax:
operation ::= `module_terminator` attr-dict
module_terminator
is a special terminator operation for the body of a
module
, it has no semantic meaning beyond keeping the body of a module
well-formed.
unrealized_conversion_cast
(::mlir::UnrealizedConversionCastOp) ¶
An unrealized conversion from one set of types to another
Syntax:
operation ::= `unrealized_conversion_cast` ($inputs^ `:` type($inputs))? `to` type($outputs) attr-dict
An unrealized_conversion_cast
operation represents an unrealized
conversion from one set of types to another, that is used to enable the
inter-mixing of different type systems. This operation should not be
attributed any special representational or execution semantics, and is
generally only intended to be used to satisfy the temporary intermixing of
type systems during the conversion of one type system to another.
This operation may produce results of arity 1-N, and accept as input operands of arity 0-N.
Example:
// An unrealized 0-1 conversion. These types of conversions are useful in
// cases where a type is removed from the type system, but not all uses have
// been converted. For example, imagine we have a tuple type that is
// expanded to its element types. If only some uses of an empty tuple type
// instance are converted we still need an instance of the tuple type, but
// have no inputs to the unrealized conversion.
%result = unrealized_conversion_cast to !bar.tuple_type<>
// An unrealized 1-1 conversion.
%result1 = unrealized_conversion_cast %operand : !foo.type to !bar.lowered_type
// An unrealized 1-N conversion.
%results2:2 = unrealized_conversion_cast %tuple_operand : !foo.tuple_type<!foo.type, !foo.type> to !foo.type, !foo.type
// An unrealized N-1 conversion.
%result3 = unrealized_conversion_cast %operand, %operand : !foo.type, !foo.type to !bar.tuple_type<!foo.type, !foo.type>
Operands: ¶
Operand | Description |
---|---|
inputs | any type |
Results: ¶
Result | Description |
---|---|
outputs | any type |