'hl' Dialect

A high-level verbose program analysis MLIR dialect. This dialect intends capture highevel constructs of C/C++ for further program analysis.

'hl' Dialect

Operations

`hl.access` (::vast::hl::AccessSpecifierOp)

VAST C++ access specifier declaration

Syntax:

operation ::= `hl.access` attr-dict $spec

VAST C++ access specifier declaration

Attributes:

Attribute	MLIR Type	Description
`spec`	::vast::hl::AccessSpecifierAttr	Access specifier

`hl.add` (::vast::hl::AddIOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.add` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Traits: Commutative

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.addressof` (::vast::hl::AddressOf)

VAST addressof operation

Syntax:

operation ::= `hl.addressof` $value attr-dict `:` type($value) `->` type($result)

VAST addressof operation

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.alias` (::vast::hl::TypeAliasOp)

VAST type alias operation

Syntax:

operation ::= `hl.alias` $sym_name attr-dict `:` $type

This operation corresponds to clang::TypeAliasDecl.

Interfaces: Core_Symbol, Core_TypeDefinition, Core_TypeSymbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute

`hl.alignof.expr` (::vast::hl::AlignOfExprOp)

VAST expr alignof operator

Syntax:

operation ::= `hl.alignof.expr` attr-dict `->` type($result) $expr

VAST expr alignof operator Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

Result	Description
`result`

`hl.alignof.type` (::vast::hl::AlignOfTypeOp)

VAST type alignof operator

Syntax:

operation ::= `hl.alignof.type` $arg attr-dict `->` type($result)

VAST type alignof operator Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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

Results:

Result	Description
`result`

`hl.asm` (::vast::hl::AsmOp)

VAST operation for inline assembly

Syntax:

operation ::= `hl.asm` attr-dict $asm_template `(`($output_names $asm_outputs^ `:` $output_constraints)? `)` `(` (`ins` `:`$input_names $asm_inputs^ `:` $input_constraints)? `)` `(`( $clobbers^)?`)` `(`( $labels^)?`)` `:` functional-type(operands, results)

VAST operation mirroring the GCCAsmStmt in clang AST. It prints a name for every operand (either its id or user-supplied string).

Traits: AttrSizedOperandSegments

Attributes:

Attribute	MLIR Type	Description
`asm_template`	::mlir::StringAttr	string attribute
`is_volatile`	::mlir::UnitAttr	unit attribute
`has_goto`	::mlir::UnitAttr	unit attribute
`output_names`	::mlir::ArrayAttr	array attribute
`input_names`	::mlir::ArrayAttr	array attribute
`output_constraints`	::mlir::ArrayAttr	array attribute
`input_constraints`	::mlir::ArrayAttr	array attribute
`clobbers`	::mlir::ArrayAttr	array attribute

Operands:

Operand	Description
`asm_outputs`	variadic of any type
`asm_inputs`	variadic of any type
`labels`	variadic of any type

`hl.assign` (::vast::hl::AssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.add` (::vast::hl::AddIAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.add` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.bin.and` (::vast::hl::BinAndAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.and` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.bin.ashr` (::vast::hl::BinAShrAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.ashr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to
`dst`	any type

Results:

Result	Description
`result`

`hl.assign.bin.lshr` (::vast::hl::BinLShrAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.lshr` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to
`dst`	any type

Results:

Result	Description
`result`

`hl.assign.bin.or` (::vast::hl::BinOrAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.or` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.bin.shl` (::vast::hl::BinShlAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.shl` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to
`dst`	any type

Results:

Result	Description
`result`

`hl.assign.bin.xor` (::vast::hl::BinXorAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.bin.xor` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.fadd` (::vast::hl::AddFAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fadd` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.fdiv` (::vast::hl::DivFAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.fmul` (::vast::hl::MulFAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fmul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.frem` (::vast::hl::RemFAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.frem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.fsub` (::vast::hl::SubFAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.fsub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.mul` (::vast::hl::MulIAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.mul` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.sdiv` (::vast::hl::DivSAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.sdiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.srem` (::vast::hl::RemSAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.srem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.sub` (::vast::hl::SubIAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.sub` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.udiv` (::vast::hl::DivUAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.udiv` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.assign.urem` (::vast::hl::RemUAssignOp)

VAST compound assign operation

Syntax:

operation ::= `hl.assign.urem` $src `to` $dst attr-dict `:` type(operands) `->` type(results)

A compound assign operation represents an assignment operation joined with an arithmetic operation. It requires the same types for both source and destination arguments.

The custom assembly form of the operation is as follows:

%result = src to dst : functional-type(operands, results)

It represents C compound assignment statement:

dst = src;

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`src`	lvalue to any type
`dst`	any type

Results:

Result	Description
`result`	any type

`hl.atomic_expr` (::vast::hl::AtomicExpr)

VAST atomic expr

Syntax:

operation ::= `hl.atomic_expr` $name attr-dict `:` type($result) $subexprs

VAST atomic expr stub Traits: NoTerminator

Attributes:

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

Results:

Result	Description
`result`	any type

`hl.attributed_stmt` (::vast::hl::AttributedStmt)

Attributed stmt operation.

Syntax:

operation ::= `hl.attributed_stmt` attr-dict `:` $body

Traits: NoTerminator

`hl.base` (::vast::hl::CxxBaseSpecifierOp)

VAST base class specifier

Syntax:

operation ::= `hl.base` $type attr-dict $access (`virtual` $is_virtual^)?

VAST base class specifier

Attributes:

Attribute	MLIR Type	Description
`type`	::mlir::TypeAttr	any type attribute
`access`	::vast::hl::AccessSpecifierAttr	Access specifier
`is_virtual`	::mlir::UnitAttr	unit attribute

`hl.bin.and` (::vast::hl::BinAndOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.and` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.bin.ashr` (::vast::hl::BinAShrOp)

VAST binary shift operation

Syntax:

operation ::= `hl.bin.ashr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Operands:

Operand	Description
`lhs`
`rhs`

Results:

Result	Description
`result`

`hl.bin.comma` (::vast::hl::BinComma)

VAST binary operation

Syntax:

operation ::= `hl.bin.comma` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.bin.land` (::vast::hl::BinLAndOp)

VAST logical binary operation

Syntax:

operation ::= `hl.bin.land` $lhs`,` $rhs attr-dict `:` type(results)

High-level logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type

Results:

Result	Description
`result`	any type

`hl.bin.lor` (::vast::hl::BinLOrOp)

VAST logical binary operation

Syntax:

operation ::= `hl.bin.lor` $lhs`,` $rhs attr-dict `:` type(results)

High-level logical binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : type

Results:

Result	Description
`result`	any type

`hl.bin.lshr` (::vast::hl::BinLShrOp)

VAST binary shift operation

Syntax:

operation ::= `hl.bin.lshr` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Operands:

Operand	Description
`lhs`
`rhs`

Results:

Result	Description
`result`

`hl.bin.or` (::vast::hl::BinOrOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.or` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.bin.shl` (::vast::hl::BinShlOp)

VAST binary shift operation

Syntax:

operation ::= `hl.bin.shl` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level binary shift operation. This operation takes two operands and returns one result.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Operands:

Operand	Description
`lhs`
`rhs`

Results:

Result	Description
`result`

`hl.bin.xor` (::vast::hl::BinXorOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.bin.xor` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.binary_cond` (::vast::hl::BinaryCondOp)

VAST binary conditional statement

Syntax:

operation ::= `hl.binary_cond` attr-dict `:` type(results) $commonRegion `,` $condRegion `?` $thenRegion `:` $elseRegion

Binary Conditional operator defined by the GNU extension of C. This operation holds in total 4 regions: 1) The common region holds the common subexpression of the condition and result 2) The cond region takes an argument, which should be the result of common, and yields the condition result. 2) The then region takes an argument, which should be the result of common, and yields the result (it may potentially contain implicit casts). 3) The else region contains the right hand side expression and yields the result.

Traits: NoTerminator

Results:

Result	Description
`result`	any type

`hl.break` (::vast::hl::BreakOp)

VAST break statement

Syntax:

operation ::= `hl.break` attr-dict

VAST break statement Traits: Core_SoftTerminatorTrait, NoRegionArguments, NoTerminator

`hl.builtin_bitcast` (::vast::hl::BuiltinBitCastOp)

VAST cast operation

Syntax:

operation ::= `hl.builtin_bitcast` $value $kind attr-dict `:` type($value) `->` type($result)

VAST cast operation

Attributes:

Attribute	MLIR Type	Description
`kind`	::vast::hl::CastKindAttr	cast kind

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.builtin_types_compatible_p.type` (::vast::hl::BuiltinTypesCompatiblePOp)

VAST representation of __builtin_types_compatible_p

Syntax:

operation ::= `hl.builtin_types_compatible_p.type` $Type1`,` $Type2 `compatible` $compatible attr-dict `->` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface), TypeTraitExprInterface

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`Type1`	::mlir::TypeAttr	any type attribute
`Type2`	::mlir::TypeAttr	any type attribute
`compatible`	::mlir::BoolAttr	bool attribute

Results:

Result	Description
`result`

`hl.call` (::vast::hl::CallOp)

VAST call operation

Syntax:

operation ::= `hl.call` $callee `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )

VAST call operation Interfaces: CallOpInterface, VastCallOpInterface

Attributes:

Attribute	MLIR Type	Description
`callee`	::vast::core::FuncSymbolRefAttr	function symbol reference attribute

Operands:

Operand	Description
`argOperands`	variadic of any type

Results:

Result	Description
`results`	variadic of any type

`hl.case` (::vast::hl::CaseOp)

VAST case statement

Syntax:

operation ::= `hl.case` $lhs $body attr-dict

The operation represents a single case of a switch statement.

The generic form of the operation is as follows:

hl.case { ... / lhs/check region / hl.value.yield %val : !hl.type } { ... / body region / }

It represents a C statement of form case lhs: body;.

Traits: NoRegionArguments, NoTerminator

`hl.choose_expr` (::vast::hl::ChooseExprOp)

Representation of GNU __builtin_choose_expr

Syntax:

operation ::= `hl.choose_expr` attr-dict (`cond` $condTrue^)? `:` type(results) $condRegion `?` $thenRegion `:` $elseRegion

The operation takes builders of three regions -- condition, true branch and false branch. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.cond { ... / condition region / hl.cond.yield %cond : !hl.bool } ? { ... / true region / } : { ... / false region / }

Traits: NoRegionArguments, NoTerminator

Attributes:

Attribute	MLIR Type	Description
`condTrue`	::mlir::BoolAttr	bool attribute

Results:

Result	Description
`result`	any type

`hl.class` (::vast::hl::ClassDeclOp)

VAST C++ class declaration

Syntax:

operation ::= `hl.class` $name attr-dict `:` `bases` $bases $fields

VAST C++ class declaration Traits: NoTerminator

Interfaces: Core_Symbol, Core_TypeSymbol

Attributes:

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

`hl.cmp` (::vast::hl::CmpOp)

VAST comparison operation

Syntax:

operation ::= `hl.cmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)

VAST comparison operation

Attributes:

Attribute	MLIR Type	Description
`predicate`	::vast::hl::PredicateAttr	comparison predicate

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`

`hl.compound_literal` (::vast::hl::CompoundLiteralOp)

VAST compound literals operation

Syntax:

operation ::= `hl.compound_literal` attr-dict `:` type($result) `=` $init

Creates a compound literal that represents an unnamed object and is initialzied by initializer-list.

Is used to represetnt clang::CompoundLiteralExpr.

Results:

Result	Description
`result`	any type

`hl.cond` (::vast::hl::CondOp)

VAST conditional statement

Syntax:

operation ::= `hl.cond` attr-dict `:` type(results) $condRegion `?` $thenRegion `:` $elseRegion

The operation takes builders of three regions -- condition, true branch and false branch. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.cond { ... / condition region / hl.cond.yield %cond : !hl.bool } ? { ... / true region / } : { ... / false region / }

Traits: NoRegionArguments, NoTerminator

Results:

Result	Description
`result`	any type

`hl.cond.yield` (::vast::hl::CondYieldOp)

Condition yield operation

Syntax:

operation ::= `hl.cond.yield` attr-dict $result `:` type($result)

A condition yield operation is used to terminate the region representing condition expression of control flow operations IfOp, WhileOp, ForOp and DoOp. It yields a boolean value for the conditional branch.

The custom assembly form of the operation is as follows:

hl.cond.yield result : BoolType

Traits: HasParent<IfOp, WhileOp, ForOp, DoOp, CondOp, ChooseExprOp, BinaryCondOp>, Terminator

Operands:

Operand	Description
`result`	any type

`hl.const` (::vast::hl::ConstantOp)

VAST value constant

Syntax:

operation ::= `hl.const` $value attr-dict

VAST value constant Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`value`	::mlir::TypedAttr	TypedAttr instance

Results:

Result	Description
`result`	any type

`hl.const.init` (::vast::hl::InitializedConstantOp)

VAST constant with non-trivial initialization

Syntax:

operation ::= `hl.const.init` attr-dict `:` type($result) `=` $init

InitializedConstantOp is used to represent a constant with non-trivial initialization. The initialization is represented by a region that represents initialization expression.

Traits: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

Result	Description
`result`	any type

`hl.continue` (::vast::hl::ContinueOp)

VAST continue statement

Syntax:

operation ::= `hl.continue` attr-dict

VAST continue statement Traits: Core_SoftTerminatorTrait, NoRegionArguments, NoTerminator

`hl.cstyle_cast` (::vast::hl::CStyleCastOp)

VAST cast operation

Syntax:

operation ::= `hl.cstyle_cast` $value $kind attr-dict `:` type($value) `->` type($result)

VAST cast operation

Attributes:

Attribute	MLIR Type	Description
`kind`	::vast::hl::CastKindAttr	cast kind

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.cxxstruct` (::vast::hl::CxxStructDeclOp)

VAST C++ struct declaration

Syntax:

operation ::= `hl.cxxstruct` $name attr-dict `:` `bases` $bases $fields

VAST C++ struct declaration Traits: NoTerminator

Interfaces: Core_Symbol, Core_TypeSymbol

Attributes:

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

`hl.default` (::vast::hl::DefaultOp)

VAST default statement

Syntax:

operation ::= `hl.default` $body attr-dict

VAST default statement Traits: NoRegionArguments, NoTerminator

`hl.deref` (::vast::hl::Deref)

VAST deref operation

Syntax:

operation ::= `hl.deref` $addr attr-dict `:` type($addr) `->` type($result)

VAST deref operation

Operands:

Operand	Description
`addr`	any type

Results:

Result	Description
`result`	lvalue to any type

`hl.do` (::vast::hl::DoOp)

VAST do-while statement

Syntax:

operation ::= `hl.do` $bodyRegion `while` $condRegion attr-dict

The operation represents a do-while statement.

The generic form of the operation is as follows:

hl.do { ... / body region / } cond { ... / cond region / hl.cond.yield %cond : !hl.bool }

Traits: Core_ScopeLikeTrait, NoRegionArguments, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

`hl.empty.decl` (::vast::hl::EmptyDeclOp)

Syntax:

operation ::= `hl.empty.decl` attr-dict

`hl.enum` (::vast::hl::EnumDeclOp)

VAST enum declaration

Enum declaration serves to declare region for enum constant declarations. It also defines an underlying type.

Traits: Core_EmptySymbolTable, NoTerminator

Interfaces: Core_SymbolTableOpInterface, Core_Symbol, Core_TypeDefinition, Core_TypeSymbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute

`hl.enum.const` (::vast::hl::EnumConstantOp)

VAST enum constant declaration

Syntax:

operation ::= `hl.enum.const` $sym_name `=` $value attr-dict (`init` $init^)?

Enumeration constant servers to link name to an enum value. It is required to be scoped in Enum operation. For example:

hl.enum.const @F = 2 : !hl.int

A constant can have a constant expression initializer:

hl.enum.const @G = #core.integer<12> : !hl.int init  {
  %0 = hl.enumref @F : !hl.int
  %1 = hl.enumref @C : !hl.int
  %2 = hl.add %0, %1 : !hl.int
  hl.value.yield %2 : !hl.int
}

Interfaces: Core_EnumConstantSymbol, Core_Symbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`value`	::mlir::TypedAttr	TypedAttr instance

`hl.enumref` (::vast::hl::EnumRefOp)

VAST enum constant reference declaration

Syntax:

operation ::= `hl.enumref` $name attr-dict `:` type($result)

VAST enum constant reference declaration

Attributes:

Attribute	MLIR Type	Description
`name`	::vast::core::EnumConstantSymbolRefAttr	enum constant symbol reference attribute

Results:

Result	Description
`result`	any type

`hl.expr` (::vast::hl::ExprOp)

VAST expression

Syntax:

operation ::= `hl.expr` attr-dict `:` type($result) $subexpr

VAST expression Traits: Core_ScopeLikeTrait, NoTerminator, ShadowingSymbolTable, SingleBlock

Interfaces: Core_SymbolTableOpInterface

Results:

Result	Description
`result`	any type

`hl.fadd` (::vast::hl::AddFOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fadd` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.fcmp` (::vast::hl::FCmpOp)

VAST flaoting point comparison operation

Syntax:

operation ::= `hl.fcmp` $predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)

VAST floating point comparison operation

Attributes:

Attribute	MLIR Type	Description
`predicate`	::vast::hl::FPredicateAttr	floating point comparison predicate

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`

`hl.fdiv` (::vast::hl::DivFOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.field` (::vast::hl::FieldDeclOp)

VAST record field declaration

Syntax:

operation ::= `hl.field` $sym_name attr-dict (`bw` $bits^)? `:` $type

VAST record field declaration Interfaces: Core_MemberVarSymbol, Core_Symbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute
`bits`	::mlir::IntegerAttr	32-bit signless integer attribute

`hl.file_scope_asm` (::vast::hl::FileScopeAsmOp)

VAST operation for file scope assembly

Syntax:

operation ::= `hl.file_scope_asm` attr-dict $asm_string

Attributes:

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

`hl.fmul` (::vast::hl::MulFOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fmul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.for` (::vast::hl::ForOp)

VAST for statement

Syntax:

operation ::= `hl.for` $condRegion `incr` $incrRegion attr-dict `do` $bodyRegion

Operation represents a for-loop statement.

The generic form of the operation is as follows:

hl.for { ... / cond region / hl.cond.yield %cond : !hl.bool } incr { ... / increment/update region / } do { ... / body region / }

Traits: Core_ScopeLikeTrait, NoRegionArguments, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

`hl.frem` (::vast::hl::RemFOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.frem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.fsub` (::vast::hl::SubFOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.fsub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.func` (::vast::hl::FuncOp)

VAST function template

Syntax:

operation ::= `hl.func` $sym_name custom< FunctionSignatureAndBody >($function_type, attr-dict, $body)

Inspired by cir::FuncOp and mlir::func::FuncOp:

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.

The function linkage information is specified by linkage, as defined by GlobalLinkageKind attribute.

Traits: AutomaticAllocationScope, IsolatedFromAbove, NoTerminator, ShadowingSymbolTable

Interfaces: CallableOpInterface, Core_FuncSymbol, Core_FunctionOpInterface, Core_SymbolTableOpInterface, Core_Symbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`function_type`	::mlir::TypeAttr	type attribute of function type
`linkage`	::vast::core::GlobalLinkageKindAttr	global linkage kind
`sym_visibility`	::mlir::StringAttr	string attribute
`arg_attrs`	::mlir::ArrayAttr	Array of dictionary attributes
`res_attrs`	::mlir::ArrayAttr	Array of dictionary attributes

`hl.funcref` (::vast::hl::FuncRefOp)

VAST function reference declaration

Syntax:

operation ::= `hl.funcref` $function attr-dict `:` type($result)

VAST function reference declaration

Attributes:

Attribute	MLIR Type	Description
`function`	::vast::core::FuncSymbolRefAttr	function symbol reference attribute

Results:

Result	Description
`result`	any type

`hl.generic_asoc` (::vast::hl::GenericAssocExpr)

Op representing single case of _Generic expression.

Syntax:

operation ::= `hl.generic_asoc` attr-dict (`match` $matchType^)? `:` $body `->` type($result)

Attributes:

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

Results:

Result	Description
`result`	any type

`hl.generic_expr` (::vast::hl::GenericSelectionExpr)

C11 _Generic expression.

Syntax:

operation ::= `hl.generic_expr` attr-dict `match` (`region` `:` $control^)? (`type` `:` $controlType^)? $body `->` type($result)

Traits: NoTerminator

Attributes:

Attribute	MLIR Type	Description
`controlType`	::mlir::TypeAttr	any type attribute
`selected`	::mlir::IntegerAttr	index attribute

Results:

Result	Description
`result`	any type

`hl.gnu.extension` (::vast::hl::ExtensionOp)

VAST extension (__extension__) keyword

Syntax:

operation ::= `hl.gnu.extension` $value attr-dict `:` type($value) `->` type($result)

VAST op corresponding to GNU extension keyword.

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.goto` (::vast::hl::GotoStmt)

Syntax:

operation ::= `hl.goto` $label attr-dict

Operands:

Operand	Description
`label`

`hl.if` (::vast::hl::IfOp)

VAST if statement

The operation takes builders of two mandatory regions -- condition and then region -- and one builder optional region representing else block of C if statement. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.if { ... / condition region / hl.cond.yield %cond : !hl.bool } then { ... / then region / } else { ... / else region / }

Traits: Core_ScopeLikeTrait, NoRegionArguments, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

`hl.imag` (::vast::hl::ImagOp)

Syntax:

operation ::= `hl.imag` $arg attr-dict `:` type($arg) `->` type($result)

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`result`	any type

`hl.implicit_cast` (::vast::hl::ImplicitCastOp)

VAST cast operation

Syntax:

operation ::= `hl.implicit_cast` $value $kind attr-dict `:` type($value) `->` type($result)

VAST cast operation

Attributes:

Attribute	MLIR Type	Description
`kind`	::vast::hl::CastKindAttr	cast kind

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.indirect_call` (::vast::hl::IndirectCallOp)

VAST call operation

Syntax:

operation ::= `hl.indirect_call` $callee `:` type($callee)  `(` $argOperands `)` attr-dict `:` functional-type( $argOperands, $results )

VAST call operation Interfaces: CallOpInterface

Operands:

Operand	Description
`callee`	any type
`argOperands`	variadic of any type

Results:

Result	Description
`results`	variadic of any type

`hl.indirect_goto` (::vast::hl::IndirectGotoStmt)

Syntax:

operation ::= `hl.indirect_goto` attr-dict `:` $target

`hl.initlist` (::vast::hl::InitListExpr)

VAST initializer list expression

Syntax:

operation ::= `hl.initlist` $elements attr-dict `:` functional-type($elements, results)

VAST initializer list expression

Operands:

Operand	Description
`elements`	variadic of any type

Results:

Result	Description
«unnamed»	variadic of any type

`hl.label` (::vast::hl::LabelStmt)

VAST control flow operation

Syntax:

operation ::= `hl.label` $label $body attr-dict

VAST control flow operation Traits: NoRegionArguments, NoTerminator

Operands:

Operand	Description
`label`

`hl.label.decl` (::vast::hl::LabelDeclOp)

Syntax:

operation ::= `hl.label.decl` $sym_name attr-dict `:` type($result)

Interfaces: Core_LabelSymbol, Core_Symbol, InferTypeOpInterface

Attributes:

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

Results:

Result	Description
`result`

`hl.labeladdr` (::vast::hl::AddrLabelExpr)

VAST address of label extension

Syntax:

operation ::= `hl.labeladdr` $label attr-dict `:` type($result)

VAST address of label extension

Operands:

Operand	Description
`label`

Results:

Result	Description
`result`	pointer like type

`hl.lnot` (::vast::hl::LNotOp)

VAST unary logical operation

Syntax:

operation ::= `hl.lnot` $arg attr-dict `:` type($arg) `->` type($res)

High-level unary logical operation assures that result has the right type.

The custom assembly form of the operation is as follows:

%result = %arg : type -> ret_type

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`res`

`hl.member` (::vast::hl::RecordMemberOp)

VAST record element access operation

Syntax:

operation ::= `hl.member` $record `at` $field attr-dict `:` type($record) `->` type($element)

VAST record element access operation

Attributes:

Attribute	MLIR Type	Description
`field`	::vast::core::MemberVarSymbolRefAttr	member variable symbol reference attribute

Operands:

Operand	Description
`record`	any type

Results:

Result	Description
`element`	any type

`hl.minus` (::vast::hl::MinusOp)

VAST unary type preserving operation

Syntax:

operation ::= `hl.minus` $arg attr-dict `:` type($result)

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`result`	any type

`hl.mul` (::vast::hl::MulIOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.mul` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Traits: Commutative

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.not` (::vast::hl::NotOp)

VAST unary type preserving operation

Syntax:

operation ::= `hl.not` $arg attr-dict `:` type($result)

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`result`	any type

`hl.null` (::vast::hl::NullStmt)

VAST null statement

Syntax:

operation ::= `hl.null` attr-dict

VAST null statement

`hl.offsetof.expr` (::vast::hl::OffsetOfExprOp)

VAST expr offsetof operator

Syntax:

operation ::= `hl.offsetof.expr` attr-dict `type` `:` $source `,` `member` `:` $components `:` type($result) $array_index_exprs

VAST expr offsetof operator. The operation holds an array of components - identifiers or indexes of array indexing expressions and an array of regions - each corresponding to one indexing expression.

Attributes:

Attribute	MLIR Type	Description
`source`	::mlir::TypeAttr	any type attribute
`components`	::mlir::ArrayAttr	array attribute

Results:

Result	Description
`result`	any type

`hl.opaque_expr` (::vast::hl::OpaqueValueExpr)

Opaque value expression from clang AST.

Syntax:

operation ::= `hl.opaque_expr` $arg `:` functional-type(operands, $result) attr-dict

This op takes an argument and returns it. According to clang documentation it is "usually" a copy operation with no special semantings. The current use in VAST is to have the opaque value computed in some region and then using this op to extract the computed value from region argument (see BinaryCondOp).

Operands:

Operand	Description
`arg`	variadic of any type

Results:

Result	Description
`result`	any type

`hl.param` (::vast::hl::ParmVarDeclOp)

VAST parameter declaration

Syntax:

operation ::= `hl.param` $sym_name `=` $param `:` type($param) attr-dict

VAST parameter declaration Interfaces: Core_Symbol, Core_VarSymbol

Attributes:

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

Operands:

Operand	Description
`param`	any type

`hl.plus` (::vast::hl::PlusOp)

VAST unary type preserving operation

Syntax:

operation ::= `hl.plus` $arg attr-dict `:` type($result)

Type preserving high-level unary operation assures that argument and result has the same type.

The custom assembly form of the operation is as follows:

%result = %arg : type

Traits: SameOperandsAndResultType

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`result`	any type

`hl.post.dec` (::vast::hl::PostDecOp)

VAST unary inplace operation

Syntax:

operation ::= `hl.post.dec` $arg attr-dict `:` type($arg) `->` type($result)

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	lvalue to any type

Results:

Result	Description
`result`	any type

`hl.post.inc` (::vast::hl::PostIncOp)

VAST unary inplace operation

Syntax:

operation ::= `hl.post.inc` $arg attr-dict `:` type($arg) `->` type($result)

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	lvalue to any type

Results:

Result	Description
`result`	any type

`hl.pre.dec` (::vast::hl::PreDecOp)

VAST unary inplace operation

Syntax:

operation ::= `hl.pre.dec` $arg attr-dict `:` type($arg) `->` type($result)

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	lvalue to any type

Results:

Result	Description
`result`	any type

`hl.pre.inc` (::vast::hl::PreIncOp)

VAST unary inplace operation

Syntax:

operation ::= `hl.pre.inc` $arg attr-dict `:` type($arg) `->` type($result)

Inplace high-level unary operation changes its single argument in place. It does not produce a new value.

The custom assembly form of the operation is as follows:

%result = %arg : type

Interfaces: InferTypeOpInterface

Operands:

Operand	Description
`arg`	lvalue to any type

Results:

Result	Description
`result`	any type

`hl.predefined.expr` (::vast::hl::PredefinedExpr)

VAT predefined expr ( such as __func__ )

Syntax:

operation ::= `hl.predefined.expr` $value $kind attr-dict `:` type($value) `->` type($result)

VAT predefined expr ( such as func )

Attributes:

Attribute	MLIR Type	Description
`kind`	::vast::hl::IdentKindAttr	ident kind

Operands:

Operand	Description
`value`	any type

Results:

Result	Description
`result`	any type

`hl.preferred_alignof.expr` (::vast::hl::PreferredAlignOfExprOp)

VAST expr alignof operator

Syntax:

operation ::= `hl.preferred_alignof.expr` attr-dict `->` type($result) $expr

VAST expr alignof operator Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

Result	Description
`result`

`hl.preferred_alignof.type` (::vast::hl::PreferredAlignOfTypeOp)

VAST type alignof operator

Syntax:

operation ::= `hl.preferred_alignof.type` $arg attr-dict `->` type($result)

VAST type alignof operator Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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

Results:

Result	Description
`result`

`hl.real` (::vast::hl::RealOp)

Syntax:

operation ::= `hl.real` $arg attr-dict `:` type($arg) `->` type($result)

Operands:

Operand	Description
`arg`	any type

Results:

Result	Description
`result`	any type

`hl.ref` (::vast::hl::DeclRefOp)

VAST variable reference declaration

Syntax:

operation ::= `hl.ref` $name attr-dict `:` type($result)

VAST variable reference declaration

Attributes:

Attribute	MLIR Type	Description
`name`	::vast::core::VarSymbolRefAttr	variable symbol reference attribute

Results:

Result	Description
`result`	any type

`hl.return` (::vast::hl::ReturnOp)

Syntax:

operation ::= `hl.return` ($result^ `:` type($result))? attr-dict

Traits: Core_ReturnLikeTrait, Core_SoftTerminatorTrait

Operands:

Operand	Description
`result`	variadic of any type

`hl.sdiv` (::vast::hl::DivSOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.sdiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.sizeof.expr` (::vast::hl::SizeOfExprOp)

VAST expr sizeof operator

Syntax:

operation ::= `hl.sizeof.expr` attr-dict `->` type($result) $expr

VAST expr sizeof operator Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

Result	Description
`result`

`hl.sizeof.type` (::vast::hl::SizeOfTypeOp)

VAST type sizeof operator

Syntax:

operation ::= `hl.sizeof.type` $arg attr-dict `->` type($result)

Corresponds to sizeof() expression. Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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

Results:

Result	Description
`result`

`hl.srem` (::vast::hl::RemSOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.srem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.static_assert` (::vast::hl::StaticAssertDecl)

Static assert declaration

Syntax:

operation ::= `hl.static_assert` `failed` `:` $failed $assert (`,` $message^)? attr-dict

Attributes:

Attribute	MLIR Type	Description
`failed`	::mlir::BoolAttr	bool attribute

`hl.stmt.expr` (::vast::hl::StmtExprOp)

VAST statement expression

Syntax:

operation ::= `hl.stmt.expr` attr-dict `:` type($result) $substmt

VAST statement expression Traits: SingleBlock

Results:

Result	Description
`result`	any type

`hl.struct` (::vast::hl::StructDeclOp)

VAST struct declaration

Syntax:

operation ::= `hl.struct` $sym_name attr-dict `:` $fields

VAST struct declaration Traits: Core_EmptySymbolTable, NoTerminator

Interfaces: AggregateTypeDefinitionInterface, Core_AggregateTypeDefinition, Core_SymbolTableOpInterface, Core_Symbol, Core_TypeDefinition, Core_TypeSymbol, TypeDefinitionInterface

Attributes:

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

`hl.sub` (::vast::hl::SubIOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.sub` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.subscript` (::vast::hl::SubscriptOp)

VAST array subscript operator

Syntax:

operation ::= `hl.subscript` $array `at` ` ` `[` $index `:` type($index) `]` attr-dict
              `:` type($array) `->` type($result)

VAST array subscript operator

Operands:

Operand	Description
`array`	lvalue to subscriptable type
`index`

Results:

Result	Description
`result`	lvalue to any type

`hl.switch` (::vast::hl::SwitchOp)

VAST switch statement

Syntax:

operation ::= `hl.switch` $condRegion `cases` $cases attr-dict

The operation represents a switch statement.

The generic form of the operation is as follows:

hl.switch { ... / cond region / hl.value.yield %val : !hl.type } cases { ... / casesregion / }

Traits: Core_ScopeLikeTrait, NoRegionArguments, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

`hl.this` (::vast::hl::ThisOp)

VAST this operator

Syntax:

operation ::= `hl.this` attr-dict `:` type($result)

VAST this operator

Results:

Result	Description
`result`	any type

`hl.translation_unit` (::vast::hl::TranslationUnitOp)

VAST translation unit

Syntax:

operation ::= `hl.translation_unit` $body attr-dict

VAST tranaslation unit Traits: IsolatedFromAbove, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

`hl.type` (::vast::hl::TypeDeclOp)

VAST type declaration

Syntax:

operation ::= `hl.type` $sym_name attr-dict `:` $type

VAST type declaration Interfaces: Core_Symbol, Core_TypeSymbol

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute

`hl.type.yield` (::vast::hl::TypeYieldOp)

Type yield operation

Syntax:

operation ::= `hl.type.yield` attr-dict $result `:` type($result)

A type yield operation is used to terminate the underlying expression region of a typeof(expr) statement.

The custom assembly form of the operation is as follows:

hl.type.yield result : type

Traits: Terminator

Operands:

Operand	Description
`result`	any type

`hl.typedef` (::vast::hl::TypeDefOp)

VAST typedef operation

Syntax:

operation ::= `hl.typedef` $sym_name attr-dict `:` $type

Typedef operation servers to declare named types. It creates a new type symbol in the current scope to be referenced as NamedType later.

This operation corresponds to clang::TypedefDecl.

Interfaces: Core_Symbol, Core_TypeDefinition, Core_TypeSymbol, TypeDefinitionInterface

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute

`hl.typeof.expr` (::vast::hl::TypeOfExprOp)

VAST typeof(expr) operation

Syntax:

operation ::= `hl.typeof.expr` $name $expr `:` $type attr-dict

The Typeof operation serves to declare a type using type introspection. It evaluates its underlying expression, creates a new type symbol in the current scope, assigns it to the type of the underlying expression, and returns the type symbol to be referenced later

Traits: SingleBlock

Attributes:

Attribute	MLIR Type	Description
`name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute

`hl.udiv` (::vast::hl::DivUOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.udiv` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.union` (::vast::hl::UnionDeclOp)

VAST record declaration

Syntax:

operation ::= `hl.union` $sym_name attr-dict `:` $fields

VAST record declaration Traits: Core_EmptySymbolTable, NoTerminator

Interfaces: AggregateTypeDefinitionInterface, Core_AggregateTypeDefinition, Core_SymbolTableOpInterface, Core_Symbol, Core_TypeDefinition, Core_TypeSymbol, TypeDefinitionInterface

Attributes:

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

`hl.unreachable` (::vast::hl::UnreachableOp)

VAST unreachable operation

Syntax:

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

VAST unreachable operation Traits: Terminator

`hl.urem` (::vast::hl::RemUOp)

VAST arithmetic binary operation

Syntax:

operation ::= `hl.urem` $lhs `,` $rhs attr-dict `:` functional-type(operands, results)

High-level arithmetic binary operation. This operation takes two operands and returns one result, each of these is required to be of the same type.

The custom assembly form of the operation is as follows:

%result = %lhs, %rhs : functional-type(operands, results)

Interfaces: Core_ArithBinOp

Operands:

Operand	Description
`lhs`	any type
`rhs`	any type

Results:

Result	Description
`result`	any type

`hl.va_arg_expr` (::vast::hl::VAArgExpr)

Fetch next variadic element.

Syntax:

operation ::= `hl.va_arg_expr` $arg_list `:` functional-type(operands, $result) attr-dict

Operands:

Operand	Description
`arg_list`	any type

Results:

Result	Description
`result`	any type

`hl.value.yield` (::vast::hl::ValueYieldOp)

Value yield operation

Syntax:

operation ::= `hl.value.yield` attr-dict $result `:` type($result)

A value yield operation is used to terminate the case region of a switch statement. The yielded value triggers the parent case statement region.

The custom assembly form of the operation is as follows:

hl.value.yield result : type

Traits: Terminator

Operands:

Operand	Description
`result`	any type

`hl.var` (::vast::hl::VarDeclOp)

VAST variable declaration

Syntax:

operation ::= `hl.var` $sym_name attr-dict (`,`$linkage^)? (`constant` $constant^)? custom< StorageClasses >($storageClass, $threadStorageClass)
              `:` $type
              (`=` $initializer^)?
              (`allocation_size` $allocation_size^)?

VAST variable declaration Interfaces: Core_DeclStorageInterface, Core_Symbol, Core_VarSymbol, DeclStorageInterface

Attributes:

Attribute	MLIR Type	Description
`sym_name`	::mlir::StringAttr	string attribute
`type`	::mlir::TypeAttr	any type attribute
`storageClass`	::vast::core::StorageClassAttr	declaration storage class
`threadStorageClass`	::vast::core::TSClassAttr	declaration storage class
`constant`	::mlir::UnitAttr	unit attribute
`linkage`	::vast::core::GlobalLinkageKindAttr	global linkage kind

`hl.while` (::vast::hl::WhileOp)

VAST while statement

Syntax:

operation ::= `hl.while` $condRegion `do` $bodyRegion attr-dict

The operation takes builders of two mandatory regions -- condition and body region. Builders, given the location, build a particular region.

The generic form of the operation is as follows:

hl.while { ... / condition region / hl.cond.yield %cond : !hl.bool } do { ... / body region / }

Traits: Core_ScopeLikeTrait, NoRegionArguments, NoTerminator, ShadowingSymbolTable

Interfaces: Core_SymbolTableOpInterface

Attributes

AliasAttr

Syntax:

#hl.alias<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

AlignedAttr

Syntax: #hl.aligned

AllocAlignAttr

Syntax:

#hl.alloc_align<
  int   # alignment
>

Parameters:

Parameter	C++ type	Description
alignment	`int`

AllocSizeAttr

Syntax:

#hl.alloc_size<
  int,   # size_arg_pos
  int   # num_arg_pos
>

Parameters:

Parameter	C++ type	Description
size_arg_pos	`int`
num_arg_pos	`int`

AllocatingAttr

Syntax: #hl.allocating

AlwaysInlineAttr

Syntax: #hl.always_inline

AnnotationAttr

Syntax:

#hl.annotation<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

ArtificialAttr

Syntax: #hl.artificial

AsmLabelAttr

Syntax:

#hl.asm<
  ::mlir::StringAttr,   # label
  bool   # isLiteral
>

Parameters:

Parameter	C++ type	Description
label	`::mlir::StringAttr`
isLiteral	`bool`

AssumeAlignedAttr

Syntax:

#hl.assume_aligned<
  llvm::APInt,   # alignment
  llvm::APInt   # offset
>

Parameters:

Parameter	C++ type	Description
alignment	`llvm::APInt`
offset	`llvm::APInt`

AvailabilityAttrAttr

Syntax: #hl.availability

AvailableOnlyInDefaultEvalMethodAttr

Syntax: #hl.available_only_in_default_eval_method

BlockingAttr

Syntax: #hl.blocking

BuiltinAttr

Syntax:

#hl.builtin<
  unsigned   # ID
>

Parameters:

Parameter	C++ type	Description
ID	`unsigned`

C11NoReturnAttr

Syntax: #hl._Noreturn

CVQualifiersAttr

Syntax:

#hl.quals<
  bool,   # is_const
  bool   # is_volatile
>

Parameters:

Parameter	C++ type	Description
is_const	`bool`	const qualifier
is_volatile	`bool`	volatile qualifier

CVRQualifiersAttr

Syntax:

#hl.quals<
  bool,   # is_const
  bool,   # is_volatile
  bool   # is_restrict
>

Parameters:

Parameter	C++ type	Description
is_const	`bool`	const qualifier
is_volatile	`bool`	volatile qualifier
is_restrict	`bool`	restrict qualifier

CXX11NoReturnAttr

Syntax: #hl.noreturn

CleanupAttr

Syntax:

#hl.cleanup<
  ::mlir::SymbolRefAttr   # symbol
>

Parameters:

Parameter	C++ type	Description
symbol	`::mlir::SymbolRefAttr`

ColdAttr

Syntax: #hl.cold

CommonAttr

Syntax: #hl.common

ConstAttr

Syntax: #hl.const

ConstInitAttr

Syntax: #hl.constinit

ConstructorAttr

Syntax:

#hl.constructor<
  unsigned   # priority
>

Parameters:

Parameter	C++ type	Description
priority	`unsigned`

ConvergentAttr

Syntax: #hl.convergent

CountedByAttr

Syntax: #hl.counted_by

DeprecatedAttr

Syntax:

#hl.deprecated<
  ::mlir::StringAttr,   # message
  ::mlir::StringAttr   # fixit
>

Parameters:

Parameter	C++ type	Description
message	`::mlir::StringAttr`
fixit	`::mlir::StringAttr`

DestructorAttr

Syntax:

#hl.destructor<
  unsigned   # priority
>

Parameters:

Parameter	C++ type	Description
priority	`unsigned`

DiagnoseIfAttr

Syntax: #hl.diagnose_if

DisableTailCallsAttr

Syntax: #hl.disable_tail_calls

EnableIfAttr

Syntax: #hl.enable_if

ErrorAttr

Syntax:

#hl.error<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

FallthroughAttr

Syntax: #hl.fallthrough

FlattenAttr

Syntax: #hl.flatten

FormatArgAttr

Syntax:

#hl.format_arg<
  unsigned   # format_idx
>

Parameters:

Parameter	C++ type	Description
format_idx	`unsigned`

FormatAttr

Syntax:

#hl.format<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

GNUInlineAttr

Syntax: #hl.gnu_inline

LeafAttr

Syntax: #hl.leaf

LoaderUninitializedAttr

Syntax: #hl.loader_uninitialized

MaxFieldAlignmentAttr

Syntax:

#hl.max_field_alignment<
  unsigned   # alignment
>

Parameters:

Parameter	C++ type	Description
alignment	`unsigned`

MayAliasAttr

Syntax: #hl.may_alias

ModeAttr

Syntax:

#hl.mode<
  ::mlir::StringAttr   # mode
>

Parameters:

Parameter	C++ type	Description
mode	`::mlir::StringAttr`

NoAliasAttr

Syntax: #hl.noalias

NoCfCheckAttr

Syntax: #hl.nocf_check

NoCommonAttr

Syntax: #hl.nocommon

NoDebugAttr

Syntax: #hl.nodebug

NoDuplicateAttr

Syntax: #hl.noduplicate

NoInlineAttr

Syntax: #hl.noinline

NoInstrumentFunctionAttr

Syntax: #hl.no_instrument_function

NoProfileFunctionAttr

Syntax: #hl.no_profile_instrument_function

NoThrowAttr

Syntax: #hl.nothrow

NonAllocatingAttr

Syntax: #hl.nonallocating

NonBlockingAttr

Syntax: #hl.nonblocking

NonNullAttr

Syntax: #hl.nonnull

NotTailCalledAttr

Syntax: #hl.not_tail_called

OffsetOfNodeAttr

VAST expr offsetofnode

This attribute corresponds to OffsetOfExprNode used by Clang AST. It can containt either an index into the list of expressions(regions) that index arrays or a field identifier or base class specifier.

Parameters:

Parameter	C++ type	Description
value	`std::variant< unsigned int, ::mlir::StringAttr >`

OverloadableAttr

Syntax: #hl.overloadable

PackedAttr

Syntax: #hl.packed

PassObjectSizeAttr

Syntax:

#hl.pass_object_size<
  int,   # type
  bool   # dynamic
>

Parameters:

Parameter	C++ type	Description
type	`int`
dynamic	`bool`

PureAttr

Syntax: #hl.pure

RestrictAttr

Syntax: #hl.restrict

ReturnsTwiceAttr

Syntax: #hl.returns_twice

SectionAttr

Syntax:

#hl.section<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

StandaloneDebugAttr

Syntax: #hl.standalone_debug

SwiftAttrAttr

Syntax:

#hl.swift_attr<
  ::mlir::StringAttr   # attribute
>

Parameters:

Parameter	C++ type	Description
attribute	`::mlir::StringAttr`

TargetAttr

Syntax:

#hl.target<
  mlir::StringAttr   # features
>

Parameters:

Parameter	C++ type	Description
features	`mlir::StringAttr`

TransparentUnionAttr

Syntax: #hl.transparent_union

UCVQualifiersAttr

Syntax:

#hl.quals<
  bool,   # is_unsigned
  bool,   # is_const
  bool   # is_volatile
>

Parameters:

Parameter	C++ type	Description
is_unsigned	`bool`	unsigned qualifier
is_const	`bool`	const qualifier
is_volatile	`bool`	volatile qualifier

UnavailableAttr

Syntax:

#hl.unavailable<
  ::mlir::StringAttr   # name
>

Parameters:

Parameter	C++ type	Description
name	`::mlir::StringAttr`

UnusedAttr

Syntax: #hl.unused

UsedAttr

Syntax: #hl.used

VisibilityAttr

Visibility attribute

Syntax:

#hl.visibility<
  ::vast::hl::Visibility   # value
>

Enum cases: * default (Default) * hidden (Hidden) * protected (Protected)

Parameters:

Parameter	C++ type	Description
value	`::vast::hl::Visibility`	an enum of type Visibility

WarnUnusedResultAttr

Syntax: #hl.warn_unused_result

Types

AdjustedType

Syntax:

!hl.adjusted<
  Type,   # original
  Type   # adjusted
>

Parameters:

Parameter	C++ type	Description
original	`Type`
adjusted	`Type`

ArrayType

Syntax:

!hl.array<
  SizeParam,   # size
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
size	`SizeParam`	size parameter for arrays
elementType	`Type`
quals	`CVRQualifiersAttr`

AtomicType

Syntax:

!hl.atomic<
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`
quals	`CVRQualifiersAttr`

AttributedType

Syntax:

!hl.attributed<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

AutoType

Syntax:

!hl.auto<
  Type,   # deducedType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
deducedType	`Type`
quals	`CVRQualifiersAttr`

BFloat16Type

Syntax:

!hl.bfloat16<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

BoolType

Syntax:

!hl.bool<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

CharType

Syntax:

!hl.char<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

ComplexType

Syntax:

!hl.complex<
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`
quals	`CVRQualifiersAttr`

CountAttributedType

Syntax:

!hl.count_attributed<
  ::vast::hl::CountType,   # type
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
type	`::vast::hl::CountType`	an enum of type CountType
elementType	`Type`

DecayedType

Syntax:

!hl.decayed<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

DoubleType

Syntax:

!hl.double<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

ElaboratedType

Syntax:

!hl.elaborated<
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`
quals	`CVRQualifiersAttr`

EnumType

Syntax:

!hl.enum<
  ::llvm::StringRef,   # name
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
name	`::llvm::StringRef`
quals	`CVQualifiersAttr`

Float128Type

Syntax:

!hl.float128<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

FloatType

Syntax:

!hl.float<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

HalfType

Syntax:

!hl.half<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

Int128Type

Syntax:

!hl.int128<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

IntType

Syntax:

!hl.int<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

LValueType

Syntax:

!hl.lvalue<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

LabelType

Syntax: !hl.label

LongDoubleType

Syntax:

!hl.longdouble<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

LongLongType

Syntax:

!hl.longlong<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

LongType

Syntax:

!hl.long<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

MacroQualifiedType

Syntax:

!hl.macro_qualified<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

ParenType

Syntax:

!hl.paren<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

PointerType

Syntax:

!hl.ptr<
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`
quals	`CVRQualifiersAttr`

RValueType

Syntax:

!hl.rvalue<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

RecordType

Syntax:

!hl.record<
  ::llvm::StringRef,   # name
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
name	`::llvm::StringRef`
quals	`CVQualifiersAttr`

ReferenceType

Syntax:

!hl.reference<
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
elementType	`Type`

ShortType

Syntax:

!hl.short<
  UCVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`UCVQualifiersAttr`

TypeOfExprType

Syntax:

!hl.typeof.expr<
  ::llvm::StringRef,   # name
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
name	`::llvm::StringRef`
quals	`CVRQualifiersAttr`

TypeOfTypeType

Syntax:

!hl.typeof.type<
  Type,   # unmodifiedType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
unmodifiedType	`Type`
quals	`CVRQualifiersAttr`

TypedefType

Syntax:

!hl.typedef<
  ::llvm::StringRef,   # name
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
name	`::llvm::StringRef`
quals	`CVRQualifiersAttr`

VectorType

Syntax:

!hl.vector<
  SizeParam,   # size
  Type,   # elementType
  CVRQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
size	`SizeParam`	size parameter for arrays
elementType	`Type`
quals	`CVRQualifiersAttr`

VoidType

Syntax:

!hl.void<
  CVQualifiersAttr   # quals
>

Parameters:

Parameter	C++ type	Description
quals	`CVQualifiersAttr`

Enums

AccessSpecifier

Access specifier

Cases:

Symbol	Value	String
as_public	`0`	public
as_protected	`1`	protected
as_private	`2`	private
as_none	`3`	none

CastKind

cast kind

Cases:

Symbol	Value	String
Dependent	`0`	Dependent
BitCast	`1`	BitCast
LValueBitCast	`2`	LValueBitCast
LValueToRValueBitCast	`3`	LValueToRValueBitCast
LValueToRValue	`4`	LValueToRValue
NoOp	`5`	NoOp
BaseToDerived	`6`	BaseToDerived
DerivedToBase	`7`	DerivedToBase
UncheckedDerivedToBase	`8`	UncheckedDerivedToBase
Dynamic	`9`	Dynamic
ToUnion	`10`	ToUnion
ArrayToPointerDecay	`11`	ArrayToPointerDecay
FunctionToPointerDecay	`12`	FunctionToPointerDecay
NullToPointer	`13`	NullToPointer
NullToMemberPointer	`14`	NullToMemberPointer
BaseToDerivedMemberPointer	`15`	BaseToDerivedMemberPointer
DerivedToBaseMemberPointer	`16`	DerivedToBaseMemberPointer
MemberPointerToBoolean	`17`	MemberPointerToBoolean
ReinterpretMemberPointer	`18`	ReinterpretMemberPointer
UserDefinedConversion	`19`	UserDefinedConversion
ConstructorConversion	`20`	ConstructorConversion
IntegralToPointer	`21`	IntegralToPointer
PointerToIntegral	`22`	PointerToIntegral
PointerToBoolean	`23`	PointerToBoolean
ToVoid	`24`	ToVoid
VectorSplat	`25`	VectorSplat
IntegralCast	`26`	IntegralCast
IntegralToBoolean	`27`	IntegralToBoolean
IntegralToFloating	`28`	IntegralToFloating
FloatingToFixedPoint	`29`	FloatingToFixedPoint
FixedPointToFloating	`30`	FixedPointToFloating
FixedPointCast	`31`	FixedPointCast
FixedPointToIntegral	`32`	FixedPointToIntegral
IntegralToFixedPoint	`33`	IntegralToFixedPoint
FixedPointToBoolean	`34`	FixedPointToBoolean
FloatingToIntegral	`35`	FloatingToIntegral
FloatingToBoolean	`36`	FloatingToBoolean
BooleanToSignedIntegral	`37`	BooleanToSignedIntegral
FloatingCast	`38`	FloatingCast
CPointerToObjCPointerCast	`39`	CPointerToObjCPointerCast
BlockPointerToObjCPointerCast	`40`	BlockPointerToObjCPointerCast
AnyPointerToBlockPointerCast	`41`	AnyPointerToBlockPointerCast
ObjCObjectLValueCast	`42`	ObjCObjectLValueCast
FloatingRealToComplex	`43`	FloatingRealToComplex
FloatingComplexToReal	`44`	FloatingComplexToReal
FloatingComplexToBoolean	`45`	FloatingComplexToBoolean
FloatingComplexCast	`46`	FloatingComplexCast
FloatingComplexToIntegralComplex	`47`	FloatingComplexToIntegralComplex
IntegralRealToComplex	`48`	IntegralRealToComplex
IntegralComplexToReal	`49`	IntegralComplexToReal
IntegralComplexToBoolean	`50`	IntegralComplexToBoolean
IntegralComplexCast	`51`	IntegralComplexCast
IntegralComplexToFloatingComplex	`52`	IntegralComplexToFloatingComplex
ARCProduceObject	`53`	ARCProduceObject
ARCConsumeObject	`54`	ARCConsumeObject
ARCReclaimReturnedObject	`55`	ARCReclaimReturnedObject
ARCExtendBlockObject	`56`	ARCExtendBlockObject
AtomicToNonAtomic	`57`	AtomicToNonAtomic
NonAtomicToAtomic	`58`	NonAtomicToAtomic
CopyAndAutoreleaseBlockObject	`59`	CopyAndAutoreleaseBlockObject
BuiltinFnToFnPtr	`60`	BuiltinFnToFnPtr
ZeroToOCLOpaqueType	`61`	ZeroToOCLOpaqueType
AddressSpaceConversion	`62`	AddressSpaceConversion
IntToOCLSampler	`63`	IntToOCLSampler
MatrixCast	`64`	MatrixCast
HLSLVectorTruncation	`65`	HLSLVectorTruncation
HLSLArrayRValue	`66`	HLSLArrayRValue

CountType

count type

Cases:

Symbol	Value	String
CountedBy	`0`	CountedBy
SizedBy	`1`	SizedBy
CountedByOrNull	`2`	CountedByOrNull
SizedByOrNull	`3`	SizedByOrNull

FPredicate

floating point comparison predicate

Cases:

Symbol	Value	String
ffalse	`0`	ffalse
oeq	`1`	oeq
ogt	`2`	ogt
oge	`3`	oge
olt	`4`	olt
ole	`5`	ole
one	`6`	one
ord	`7`	ord
uno	`8`	uno
ueq	`9`	ueq
ugt	`10`	ugt
uge	`11`	uge
ult	`12`	ult
ule	`13`	ule
une	`14`	une
ftrue	`15`	ftrue

IdentKind

ident kind

Cases:

Symbol	Value	String
Func	`0`	Func
Function	`1`	Function
LFunction	`2`	LFunction
FuncDName	`3`	FuncDName
FuncSig	`4`	FuncSig
LFuncSig	`5`	LFuncSig
PrettyFunction	`6`	PrettyFunction
PrettyFunctionNoVirtual	`7`	PrettyFunctionNoVirtual

Predicate

comparison predicate

Cases:

Symbol	Value	String
eq	`0`	eq
ne	`1`	ne
slt	`2`	slt
sle	`3`	sle
sgt	`4`	sgt
sge	`5`	sge
ult	`6`	ult
ule	`7`	ule
ugt	`8`	ugt
uge	`9`	uge

Visibility

visibility

Cases:

Symbol	Value	String
Default	`0`	default
Hidden	`1`	hidden
Protected	`2`	protected

Symbol	Value	String
eq	`0`	eq
ne	`1`	ne
slt	`2`	slt
sle	`3`	sle
sgt	`4`	sgt
sge	`5`	sge
ult	`6`	ult
ule	`7`	ule
ugt	`8`	ugt
uge	`9`	uge

Symbol	Value	String
eq	`0`	eq
ne	`1`	ne
slt	`2`	slt
sle	`3`	sle
sgt	`4`	sgt
sge	`5`	sge
ult	`6`	ult
ule	`7`	ule
ugt	`8`	ugt
uge	`9`	uge

'hl' Dialect

Operations

hl.access (::vast::hl::AccessSpecifierOp)

Attributes:

hl.add (::vast::hl::AddIOp)

Operands:

Results:

hl.addressof (::vast::hl::AddressOf)

Operands:

Results:

hl.alias (::vast::hl::TypeAliasOp)

Attributes:

hl.alignof.expr (::vast::hl::AlignOfExprOp)

Results:

hl.alignof.type (::vast::hl::AlignOfTypeOp)

Attributes:

Results:

hl.asm (::vast::hl::AsmOp)

Attributes:

Operands:

hl.assign (::vast::hl::AssignOp)

Operands:

Results:

hl.assign.add (::vast::hl::AddIAssignOp)

Operands:

Results:

hl.assign.bin.and (::vast::hl::BinAndAssignOp)

Operands:

Results:

hl.assign.bin.ashr (::vast::hl::BinAShrAssignOp)

Operands:

Results:

hl.assign.bin.lshr (::vast::hl::BinLShrAssignOp)

Operands:

Results:

hl.assign.bin.or (::vast::hl::BinOrAssignOp)

Operands:

Results:

hl.assign.bin.shl (::vast::hl::BinShlAssignOp)

Operands:

Results:

hl.assign.bin.xor (::vast::hl::BinXorAssignOp)

Operands:

Results:

hl.assign.fadd (::vast::hl::AddFAssignOp)

Operands:

Results:

hl.assign.fdiv (::vast::hl::DivFAssignOp)

Operands:

Results:

hl.assign.fmul (::vast::hl::MulFAssignOp)

Operands:

Results:

hl.assign.frem (::vast::hl::RemFAssignOp)

Operands:

Results:

hl.assign.fsub (::vast::hl::SubFAssignOp)

Operands:

Results:

hl.assign.mul (::vast::hl::MulIAssignOp)

Operands:

Results:

hl.assign.sdiv (::vast::hl::DivSAssignOp)

Operands:

Results:

hl.assign.srem (::vast::hl::RemSAssignOp)

Operands:

Results:

hl.assign.sub (::vast::hl::SubIAssignOp)

Operands:

Results:

hl.assign.udiv (::vast::hl::DivUAssignOp)

Operands:

Results:

hl.assign.urem (::vast::hl::RemUAssignOp)

Operands:

Results:

hl.atomic_expr (::vast::hl::AtomicExpr)

Attributes:

Results:

`hl.access` (::vast::hl::AccessSpecifierOp)

`hl.add` (::vast::hl::AddIOp)

`hl.addressof` (::vast::hl::AddressOf)

`hl.alias` (::vast::hl::TypeAliasOp)

`hl.alignof.expr` (::vast::hl::AlignOfExprOp)

`hl.alignof.type` (::vast::hl::AlignOfTypeOp)

`hl.asm` (::vast::hl::AsmOp)

`hl.assign` (::vast::hl::AssignOp)

`hl.assign.add` (::vast::hl::AddIAssignOp)

`hl.assign.bin.and` (::vast::hl::BinAndAssignOp)

`hl.assign.bin.ashr` (::vast::hl::BinAShrAssignOp)

`hl.assign.bin.lshr` (::vast::hl::BinLShrAssignOp)

`hl.assign.bin.or` (::vast::hl::BinOrAssignOp)

`hl.assign.bin.shl` (::vast::hl::BinShlAssignOp)

`hl.assign.bin.xor` (::vast::hl::BinXorAssignOp)

`hl.assign.fadd` (::vast::hl::AddFAssignOp)

`hl.assign.fdiv` (::vast::hl::DivFAssignOp)

`hl.assign.fmul` (::vast::hl::MulFAssignOp)

`hl.assign.frem` (::vast::hl::RemFAssignOp)

`hl.assign.fsub` (::vast::hl::SubFAssignOp)

`hl.assign.mul` (::vast::hl::MulIAssignOp)

`hl.assign.sdiv` (::vast::hl::DivSAssignOp)

`hl.assign.srem` (::vast::hl::RemSAssignOp)

`hl.assign.sub` (::vast::hl::SubIAssignOp)

`hl.assign.udiv` (::vast::hl::DivUAssignOp)

`hl.assign.urem` (::vast::hl::RemUAssignOp)

`hl.atomic_expr` (::vast::hl::AtomicExpr)

`hl.attributed_stmt` (::vast::hl::AttributedStmt)

`hl.base` (::vast::hl::CxxBaseSpecifierOp)

`hl.bin.and` (::vast::hl::BinAndOp)

`hl.bin.ashr` (::vast::hl::BinAShrOp)

`hl.bin.comma` (::vast::hl::BinComma)

`hl.bin.land` (::vast::hl::BinLAndOp)

`hl.bin.lor` (::vast::hl::BinLOrOp)

`hl.bin.lshr` (::vast::hl::BinLShrOp)

`hl.bin.or` (::vast::hl::BinOrOp)

`hl.bin.shl` (::vast::hl::BinShlOp)

`hl.bin.xor` (::vast::hl::BinXorOp)

`hl.binary_cond` (::vast::hl::BinaryCondOp)

`hl.break` (::vast::hl::BreakOp)

`hl.builtin_bitcast` (::vast::hl::BuiltinBitCastOp)

`hl.builtin_types_compatible_p.type` (::vast::hl::BuiltinTypesCompatiblePOp)

`hl.call` (::vast::hl::CallOp)

`hl.case` (::vast::hl::CaseOp)

`hl.choose_expr` (::vast::hl::ChooseExprOp)

`hl.class` (::vast::hl::ClassDeclOp)

`hl.cmp` (::vast::hl::CmpOp)

`hl.compound_literal` (::vast::hl::CompoundLiteralOp)

`hl.cond` (::vast::hl::CondOp)

`hl.cond.yield` (::vast::hl::CondYieldOp)

`hl.const` (::vast::hl::ConstantOp)

`hl.const.init` (::vast::hl::InitializedConstantOp)

`hl.continue` (::vast::hl::ContinueOp)

`hl.cstyle_cast` (::vast::hl::CStyleCastOp)

`hl.cxxstruct` (::vast::hl::CxxStructDeclOp)

Symbol	Value	String
eq	`0`	eq
ne	`1`	ne
slt	`2`	slt
sle	`3`	sle
sgt	`4`	sgt
sge	`5`	sge
ult	`6`	ult
ule	`7`	ule
ugt	`8`	ugt
uge	`9`	uge