‘emitasc’ Dialect

C++ emission support dialect

Operations

`emitasc.call_opaque` (emitasc::CallOpaqueOp)

Call C++ function by its name

Syntax:

operation ::= `emitasc.call_opaque` $callee `(` $callee_operands `)` attr-dict `:`
              functional-type($callee_operands, $result)

Callee name must be demangled. It may include namespaces and template arguments. Constructor should be represented as its parent class name.

Attributes:

Attribute	MLIR Type	Description
`callee`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`callee_operands`	variadic of any type

Results:

Result	Description
`result`	any type

`emitasc.copy_struct` (emitasc::CopyStructOp)

Create local structure and perform memcpy from another one

Syntax:

operation ::= `emitasc.copy_struct` $base attr-dict `:` type($base) `,` type($result)

Operands:

Operand	Description
`base`	memref of any type values

Results:

Result	Description
`result`	any type

`emitasc.declare_py_struct` (emitasc::DeclarePyStructOp)

Declare custom structure

Syntax:

operation ::= `emitasc.declare_py_struct` $pystruct attr-dict

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`pystruct`	::mlir::TypeAttr	any type attribute

`emitasc.dereference` (emitasc::DereferenceOp)

Dereference pointer to underlying object (unary operator*)

Syntax:

operation ::= `emitasc.dereference` $base attr-dict `:` type($base) `,` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	memref of any type values

Results:

Result	Description
`result`	any type

`emitasc.mask` (emitasc::MaskOp)

Creates a mask in bit-by-bit mode (pair of 64-bit integers)

Syntax:

operation ::= `emitasc.mask` $maskH `,` $maskL attr-dict

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`maskH`	64-bit signless integer
`maskL`	64-bit signless integer

Results:

Result	Description
`mask`

`emitasc.member` (emitasc::MemberOp)

Syntax:

operation ::= `emitasc.member` $base $field attr-dict `:` type($base) `,` type($result)

Attributes:

Attribute	MLIR Type	Description
`field`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`base`	any type

Results:

Result	Description
`result`	any type

`emitasc.member_ptr` (emitasc::MemberPtrOp)

Access pointer-to-struct member (operator->)

Syntax:

operation ::= `emitasc.member_ptr` $base `[` $index `]` ($field^)? attr-dict `:` type($base) `,` type($result)

This operation represents getting an address of a struct member at the given pointer, and it should be emitted as the following:

auto *result = (ResultT *)&base->member;

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`index`	::mlir::IntegerAttr	index attribute
`field`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`base`	memref of any type values

Results:

Result	Description
`result`	memref of any type values

`emitasc.member_ref` (emitasc::MemberRefOp)

Access pointer-to-struct member (emit result as reference)

Syntax:

operation ::= `emitasc.member_ref` $base `[` $index `]` ($field^)? attr-dict `:` type($base) `,` type($result)

This operation represents obtaining a struct member at the given pointer as a reference, and it should be emitted as the following:

ResultT &result = base->member;

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`index`	::mlir::IntegerAttr	index attribute
`field`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`base`	memref of any type values

Results:

Result	Description
`result`	any type

`emitasc.ptr_offset` (emitasc::PtrOffsetOp)

Apply operator+ between pointer and offset

Syntax:

operation ::= `emitasc.ptr_offset` $base `[` ($dynamicOffset^):($staticOffset ` `)? `]` attr-dict `:`
              type($base) `,` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), ViewLikeOpInterface

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`staticOffset`	::mlir::IntegerAttr	index attribute

Operands:

Operand	Description
`base`	memref of any type values
`dynamicOffset`	index

Results:

Result	Description
`result`	memref of any type values

`emitasc.reinterpret_cast` (emitasc::ReinterpretCastOp)

Convert between types by reinterpreting the underlying data

Syntax:

operation ::= `emitasc.reinterpret_cast` $source attr-dict `:` type($source) `to` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: CastOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`source`	any type

Results:

Result	Description
`result`	any type

`emitasc.set_member` (emitasc::SetMemberOp)

Syntax:

operation ::= `emitasc.set_member` $base $field `,` $value attr-dict `:` type($base) `,` type($value)

Attributes:

Attribute	MLIR Type	Description
`field`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`base`	any type
`value`	any type

`emitasc.variable` (emitasc::VariableOp)

Define a mutable variable

Syntax:

operation ::= `emitasc.variable` attr-dict ($dynamicInit^ `:` type($dynamicInit)):($staticInit)? `,` type($result)

This operation combines an allocation and storing a value to memref<1x...>. Its element type must be the same as init type (either static or dynamic).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`staticInit`	::mlir::TypedAttr	TypedAttr instance {{% markdown %}} This interface is used for attributes that have a type. The type of an attribute is understood to represent the type of the data contained in the attribute and is often used as the type of a value with this data. {{% /markdown %}}

Operands:

Operand	Description
`dynamicInit`	any type

Results:

Result	Description
`result`	non-0-ranked.memref of any type values

`emitasc.verbatim` (emitasc::VerbatimOp)

Syntax:

operation ::= `emitasc.verbatim` $value ($args^ `:` type($args))?  attr-dict

Attributes:

Attribute	MLIR Type	Description
`value`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`args`	variadic of any type

Attributes

KernelArgumentAttr

kind of kernel argument for the launcher

Syntax:

#emitasc.kernel_arg<
  ::mlir::emitasc::KernelArgument   # value
>

Describes kind of kernel argument: explicit argument, target specific argument (workspace, ffts address, etc.)

Parameters:

Parameter	C++ type	Description
value	`::mlir::emitasc::KernelArgument`	an enum of type KernelArgument

Types

MaskType

Syntax: !emitasc.mask

Represents 2-element array with high and low mask

PyStructType

Syntax:

!emitasc.py_struct<
  StringAttr,   # nameAttr
  ArrayAttr,   # typesAttr
  ArrayAttr   # namesAttr
>

Parameters:

Parameter	C++ type	Description
nameAttr	`StringAttr`
typesAttr	`ArrayAttr`
namesAttr	`ArrayAttr`

Enums

KernelArgument

kernel argument

Cases:

Symbol	Value	String
Explicit	`0`	explicit
FftsAddr	`1`	ffts_addr

‘emitasc’ Dialect

Operations

emitasc.call_opaque (emitasc::CallOpaqueOp)

Attributes:

Operands:

Results:

emitasc.copy_struct (emitasc::CopyStructOp)

Operands:

Results:

emitasc.declare_py_struct (emitasc::DeclarePyStructOp)

Attributes:

emitasc.dereference (emitasc::DereferenceOp)

Operands:

Results:

emitasc.mask (emitasc::MaskOp)

Operands:

Results:

emitasc.member (emitasc::MemberOp)

Attributes:

Operands:

Results:

emitasc.member_ptr (emitasc::MemberPtrOp)

Attributes:

Operands:

Results:

emitasc.member_ref (emitasc::MemberRefOp)

Attributes:

Operands:

Results:

emitasc.ptr_offset (emitasc::PtrOffsetOp)

Attributes:

Operands:

Results:

emitasc.reinterpret_cast (emitasc::ReinterpretCastOp)

Operands:

Results:

emitasc.set_member (emitasc::SetMemberOp)

Attributes:

Operands:

emitasc.variable (emitasc::VariableOp)

Attributes:

Operands:

Results:

emitasc.verbatim (emitasc::VerbatimOp)

Attributes:

Operands:

Attributes

KernelArgumentAttr

Parameters:

Types

MaskType

PyStructType

Parameters:

Enums

KernelArgument

Cases:

`emitasc.call_opaque` (emitasc::CallOpaqueOp)

`emitasc.copy_struct` (emitasc::CopyStructOp)

`emitasc.declare_py_struct` (emitasc::DeclarePyStructOp)

`emitasc.dereference` (emitasc::DereferenceOp)

`emitasc.mask` (emitasc::MaskOp)

`emitasc.member` (emitasc::MemberOp)

`emitasc.member_ptr` (emitasc::MemberPtrOp)

`emitasc.member_ref` (emitasc::MemberRefOp)

`emitasc.ptr_offset` (emitasc::PtrOffsetOp)

`emitasc.reinterpret_cast` (emitasc::ReinterpretCastOp)

`emitasc.set_member` (emitasc::SetMemberOp)

`emitasc.variable` (emitasc::VariableOp)

`emitasc.verbatim` (emitasc::VerbatimOp)