'use strict';
const builtin_dialect = require('./dialect/builtin');
const func_dialect = require('./dialect/func');
const llvm_dialect = require('./dialect/llvm');
const arith_dialect = require('./dialect/arith');
const math_dialect = require('./dialect/math');
const cf_dialect = require('./dialect/cf');
const scf_dialect = require('./dialect/scf');
const memref_dialect = require('./dialect/memref');
const vector_dialect = require('./dialect/vector');
const tensor_dialect = require('./dialect/tensor');
const bufferization_dialect = require('./dialect/bufferization');
const affine_dialect = require('./dialect/affine');
const linalg_dialect = require('./dialect/linalg');
const common = {
// Top level production:
// (operation | attribute-alias-def | type-alias-def)
toplevel : $ => seq($._toplevel, repeat($._toplevel)),
_toplevel : $ => choice($.operation, $.attribute_alias_def, $.type_alias_def),
// Common syntax (lang-ref)
// digit ::= [0-9]
// hex_digit ::= [0-9a-fA-F]
// letter ::= [a-zA-Z]
// id-punct ::= [$._-]
//
// integer-literal ::= decimal-literal | hexadecimal-literal
// decimal-literal ::= digit+
// hexadecimal-literal ::= `0x` hex_digit+
// float-literal ::= [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
// string-literal ::= `"` [^"\n\f\v\r]* `"` TODO: define escaping rules
//
_digit : $ => /[0-9]/,
integer_literal : $ => choice($._decimal_literal, $._hexadecimal_literal),
_decimal_literal : $ => token(seq(optional(/[-+]/), repeat1(/[0-9]/))),
_hexadecimal_literal : $ => token(seq('0x', repeat1(/[0-9a-fA-F]/))),
float_literal : $ =>
token(seq(optional(/[-+]/), repeat1(/[0-9]/), '.', repeat(/[0-9]/),
optional(seq(/[eE]/, optional(/[-+]/), repeat1(/[0-9]/))))),
string_literal : $ => token(seq('"', repeat(/[^\\"\n\f\v\r]+/), '"')),
bool_literal : $ => token(choice('true', 'false')),
unit_literal : $ => token('unit'),
complex_literal : $ =>
seq('(', choice($.integer_literal, $.float_literal), ',',
choice($.integer_literal, $.float_literal), ')'),
tensor_literal : $ =>
seq(token(choice('dense', 'sparse')), '<',
optional(choice(
seq($.nested_idx_list, repeat(seq(',', $.nested_idx_list))),
$._primitive_idx_literal)),
'>'),
array_literal : $ => seq(token('array'), '<', $.type, ':', $._idx_list, '>'),
_literal : $ => choice($.integer_literal, $.float_literal, $.string_literal,
$.bool_literal, $.tensor_literal, $.array_literal,
$.complex_literal, $.unit_literal),
nested_idx_list : $ =>
seq('[', optional(choice($.nested_idx_list, $._idx_list)),
repeat(seq(',', $.nested_idx_list)), ']'),
_idx_list : $ => prec.right(seq($._primitive_idx_literal,
repeat(seq(',', $._primitive_idx_literal)))),
_primitive_idx_literal : $ => choice($.integer_literal, $.float_literal,
$.bool_literal, $.complex_literal),
// Identifiers
// bare-id ::= (letter|[_]) (letter|digit|[_$.])*
// bare-id-list ::= bare-id (`,` bare-id)*
// value-id ::= `%` suffix-id
// suffix-id ::= (digit+ | ((letter|id-punct) (letter|id-punct|digit)*))
// alias-name :: = bare-id
//
// symbol-ref-id ::= `@` (suffix-id | string-literal) (`::`
// symbol-ref-id)?
// value-id-list ::= value-id (`,` value-id)*
//
// // Uses of value, e.g. in an operand list to an operation.
// value-use ::= value-id
// value-use-list ::= value-use (`,` value-use)*
bare_id : $ => token(seq(/[a-zA-Z_]/, repeat(/[a-zA-Z0-9_$.]/))),
_alias_or_dialect_id : $ => token(seq(/[a-zA-Z_]/, repeat(/[a-zA-Z0-9_$]/))),
bare_id_list : $ => seq($.bare_id, repeat(seq(',', $.bare_id))),
value_use : $ => seq('%', $._suffix_id),
_suffix_id : $ => token(seq(
choice(repeat1(/[0-9]/), seq(/[a-zA-Z_$.-]/, repeat(/[a-zA-Z0-9_$.-]/))),
optional(seq(choice(':', '#'), repeat1(/[0-9]/))))),
symbol_ref_id : $ => seq('@', choice($._suffix_id, $.string_literal),
optional(seq('::', $.symbol_ref_id))),
_value_use_list : $ => seq($.value_use, repeat(seq(',', $.value_use))),
// Operations
// operation ::= op-result-list? (generic-operation |
// custom-operation)
// trailing-location?
// generic-operation ::= string-literal `(` value-use-list? `)`
// successor-list? region-list?
// dictionary-attribute? `:` function-type
// custom-operation ::= bare-id custom-operation-format
// op-result-list ::= op-result (`,` op-result)* `=`
// op-result ::= value-id (`:` integer-literal)
// successor-list ::= `[` successor (`,` successor)* `]`
// successor ::= caret-id (`:` bb-arg-list)?
// region-list ::= `(` region (`,` region)* `)`
// dictionary-attribute ::= `{` (attribute-entry (`,` attribute-entry)*)?
// `}`
// trailing-location ::= (`loc` `(` location `)`)?
operation : $ =>
seq(field('lhs', optional($._op_result_list)),
field('rhs', choice($.generic_operation, $.custom_operation)),
field('location', optional($.trailing_location))),
generic_operation : $ => seq(
$.string_literal, $._value_use_list_parens, optional($._successor_list),
optional($._region_list), optional($.attribute), ':', $.function_type),
// custom-operation rule is defined later in the grammar, post the generic.
_op_result_list : $ => seq($.op_result, repeat(seq(',', $.op_result)), '='),
op_result : $ => seq($.value_use, optional(seq(':', $.integer_literal))),
_successor_list : $ =>
seq('[', $.successor, repeat(seq(',', $.successor)), ']'),
successor : $ => seq($.caret_id, optional($._value_arg_list)),
_region_list : $ => seq('(', $.region, repeat(seq(',', $.region)), ')'),
dictionary_attribute : $ => seq('{', optional($.attribute_entry),
repeat(seq(',', $.attribute_entry)), '}'),
trailing_location : $ => seq(token('loc'), '(', $.location, ')'),
// TODO: Complete location forms.
location : $ => $.string_literal,
// Blocks
// block ::= block-label operation+
// block-label ::= block-id block-arg-list? `:`
// block-id ::= caret-id
// caret-id ::= `^` suffix-id
// value-id-and-type ::= value-id `:` type
//
// // Non-empty list of names and types.
// value-id-and-type-list ::= value-id-and-type (`,` value-id-and-type)*
//
// block-arg-list ::= `(` value-id-and-type-list? `)`
block : $ => seq($.block_label, repeat1($.operation)),
block_label : $ => seq($._block_id, optional($.block_arg_list), ':'),
_block_id : $ => $.caret_id,
caret_id : $ => seq('^', $._suffix_id),
_value_use_and_type : $ => seq($.value_use, optional(seq(':', $.type))),
_value_use_and_type_list : $ =>
seq($._value_use_and_type, repeat(seq(',', $._value_use_and_type))),
block_arg_list : $ => seq('(', optional($._value_use_and_type_list), ')'),
_value_arg_list : $ => seq('(', optional($._value_use_type_list), ')'),
_value_use_type_list : $ => seq($._value_use_list, $._type_annotation),
// Regions
// region ::= `{` entry-block? block* `}`
// entry-block ::= operation+
region : $ => seq('{', optional($.entry_block), repeat($.block), '}'),
entry_block : $ => repeat1($.operation),
// Types
// type ::= type-alias | dialect-type | builtin-type
//
// type-list-no-parens ::= type (`,` type)*
// type-list-parens ::= `(` type-list-no-parens? `)`
//
// // This is a common way to refer to a value with a specified type.
// ssa-use-and-type ::= ssa-use `:` type
// ssa-use ::= value-use
//
// // Non-empty list of names and types.
// ssa-use-and-type-list ::= ssa-use-and-type (`,` ssa-use-and-type)*
//
// function-type ::= (type | type-list-parens) `->` (type |
// type-list-parens)
type : $ => choice($.type_alias, $.dialect_type, $.builtin_type),
_type_list_no_parens : $ => prec.left(seq($.type, repeat(seq(',', $.type)))),
_type_list_parens : $ => seq('(', optional($._type_list_no_parens), ')'),
function_type : $ =>
seq(choice($.type, $._type_list_parens), $._function_return),
_function_return : $ => seq(token('->'), choice($.type, $._type_list_parens)),
_type_annotation : $ =>
seq(':', choice(seq($.type, choice('from', 'into', 'to'), $.type),
$._type_list_no_parens)),
_function_type_annotation : $ => seq(':', $.function_type),
_literal_and_type : $ => seq($._literal, optional($._type_annotation)),
// Type aliases
// type-alias-def ::= '!' alias-name '=' type
// type-alias ::= '!' alias-name
type_alias_def : $ => seq('!', $._alias_or_dialect_id, '=', $.type),
type_alias : $ => seq('!', $._alias_or_dialect_id),
// Dialect Types
// dialect-namespace ::= bare-id
//
// opaque-dialect-item ::= dialect-namespace '<' string-literal '>'
//
// pretty-dialect-item ::= dialect-namespace '.'
// pretty-dialect-item-lead-ident pretty-dialect-item-body?
//
// pretty-dialect-item-lead-ident ::= '[A-Za-z][A-Za-z0-9._]*'
// pretty-dialect-item-body ::= '<' pretty-dialect-item-contents+ '>'
// pretty-dialect-item-contents ::= pretty-dialect-item-body
// | '(' pretty-dialect-item-contents+ ')'
// | '[' pretty-dialect-item-contents+ ']'
// | '{' pretty-dialect-item-contents+ '}'
// | '[^[<({>\])}\0]+'
//
// dialect-type ::= '!' (opaque-dialect-item | pretty-dialect-item)
dialect_type : $ =>
seq('!', choice($.opaque_dialect_item, $.pretty_dialect_item)),
dialect_namespace : $ => $._alias_or_dialect_id,
dialect_ident : $ => $._alias_or_dialect_id,
opaque_dialect_item : $ =>
seq($.dialect_namespace, '<', $.string_literal, '>'),
pretty_dialect_item : $ => seq($.dialect_namespace, '.', $.dialect_ident,
optional($.pretty_dialect_item_body)),
pretty_dialect_item_body : $ =>
seq('<', repeat($._pretty_dialect_item_contents), '>'),
_pretty_dialect_item_contents : $ =>
prec.left(choice($.pretty_dialect_item_body, repeat1(/[^<>]/))),
// Builtin types
builtin_type : $ => choice(
// TODO: Add opaque_type
$.integer_type, $.float_type, $.complex_type, $.index_type, $.memref_type,
$.none_type, $.tensor_type, $.vector_type, $.tuple_type),
// signed-integer-type ::= `si`[1-9][0-9]*
// unsigned-integer-type ::= `ui`[1-9][0-9]*
// signless-integer-type ::= `i`[1-9][0-9]*
// integer-type ::= signed-integer-type | unsigned-integer-type |
// signless-integer-type
integer_type : $ =>
token(seq(choice('si', 'ui', 'i'), /[1-9]/, repeat(/[0-9]/))),
float_type : $ => token(
choice('f16', 'f32', 'f64', 'f80', 'f128', 'bf16', 'f8E3M4', 'f8E4M3FN',
'f8E4M3', 'f8E5M2', 'f4E2M1FN', 'f6E2M3FN', 'f6E3M2FN',
'f8E8M0FNU')),
index_type : $ => token('index'),
none_type : $ => token('none'),
complex_type : $ => seq(token('complex'), '<', $._prim_type, '>'),
_prim_type : $ =>
choice($.integer_type, $.float_type, $.index_type, $.complex_type,
$.none_type, $.memref_type, $.vector_type, $.tensor_type),
// memref-type ::= `memref` `<` dimension-list-ranked type
// (`,` layout-specification)? (`,` memory-space)? `>`
// layout-specification ::= attribute-value
// memory-space ::= attribute-value
memref_type : $ =>
seq(token('memref'), '<', field('dimension_list', $.dim_list),
optional(seq(',', $.attribute_value)),
optional(seq(',', $.attribute_value)), '>'),
dim_list : $ => seq($._dim_primitive, repeat(seq('x', $._dim_primitive))),
_dim_primitive : $ => choice($._prim_type, repeat1($._digit), '?', '*'),
// tensor-type ::= `tensor` `<` dimension-list type (`,` encoding)? `>`
// dimension-list ::= (dimension `x`)*
// dimension ::= `?` | decimal-literal
// encoding ::= attribute-value
// tensor-type ::= `tensor` `<` `*` `x` type `>`
tensor_type : $ => seq(token('tensor'), '<', $.dim_list,
optional(seq(',', $.tensor_encoding)), '>'),
tensor_encoding : $ => $.attribute_value,
// vector-type ::= `vector` `<` vector-dim-list vector-element-type `>`
// vector-element-type ::= float-type | integer-type | index-type
// vector-dim-list := (static-dim-list `x`)? (`[` static-dim-list `]` `x`)?
// static-dim-list ::= decimal-literal (`x` decimal-literal)*
vector_type : $ =>
seq(token('vector'), '<', optional($.vector_dim_list), $._prim_type, '>'),
vector_dim_list : $ =>
choice(seq($._static_dim_list, 'x',
optional(seq('[', $._static_dim_list, ']', 'x'))),
seq('[', $._static_dim_list, ']', 'x')),
_static_dim_list : $ =>
seq(repeat1($._digit), repeat(seq('x', repeat1($._digit)))),
// tuple-type ::= `tuple` `<` (type ( `,` type)*)? `>`
tuple_type : $ =>
seq(token('tuple'), '<', $.tuple_dim, repeat(seq(',', $.tuple_dim)), '>'),
tuple_dim : $ => $._prim_type,
// Attributes
// attribute-entry ::= (bare-id | string-literal) `=` attribute-value
// attribute-value ::= attribute-alias | dialect-attribute |
// builtin-attribute
attribute_entry : $ => seq(choice($.bare_id, $.string_literal),
optional(seq('=', $.attribute_value))),
attribute_value : $ =>
choice(seq('[', optional($._attribute_value_nobracket),
repeat(seq(',', $._attribute_value_nobracket)), ']'),
$._attribute_value_nobracket),
_attribute_value_nobracket : $ =>
choice($.attribute_alias, $.dialect_attribute, $.builtin_attribute,
$.dictionary_attribute, $._literal_and_type, $.type),
attribute : $ => choice($.attribute_alias, $.dialect_attribute,
$.builtin_attribute, $.dictionary_attribute),
// Attribute Value Aliases
// attribute-alias-def ::= '#' alias-name '=' attribute-value
// attribute-alias ::= '#' alias-name
attribute_alias_def : $ =>
seq('#', $._alias_or_dialect_id, '=', $.attribute_value),
attribute_alias : $ => seq('#', $._alias_or_dialect_id),
// Dialect Attribute Values
dialect_attribute : $ =>
seq('#', choice($.opaque_dialect_item, $.pretty_dialect_item)),
// Builtin Attribute Values
builtin_attribute : $ => choice(
// TODO
$.strided_layout, $.affine_map, $.affine_set),
strided_layout : $ => seq(token('strided'), '<', '[', $._dim_list_comma, ']',
optional(seq(',', token('offset'), ':',
choice($.integer_literal, '?', '*'))),
'>'),
_dim_list_comma : $ =>
seq($._dim_primitive, repeat(seq(',', $._dim_primitive))),
affine_map : $ =>
seq(token('affine_map'), '<', $._multi_dim_affine_expr_parens,
optional($._multi_dim_affine_expr_sq), token('->'),
$._multi_dim_affine_expr_parens, '>'),
affine_set : $ =>
seq(token('affine_set'), '<', $._multi_dim_affine_expr_parens,
optional($._multi_dim_affine_expr_sq), ':',
$._multi_dim_affine_expr_parens, '>'),
_multi_dim_affine_expr_parens : $ =>
seq('(', optional($._multi_dim_affine_expr), ')'),
_multi_dim_affine_expr_sq : $ =>
seq('[', optional($._multi_dim_affine_expr), ']'),
// affine-expr ::= `(` affine-expr `)`
// | affine-expr `+` affine-expr
// | affine-expr `-` affine-expr
// | `-`? integer-literal `*` affine-expr
// | affine-expr `ceildiv` integer-literal
// | affine-expr `floordiv` integer-literal
// | affine-expr `mod` integer-literal
// | `-`affine-expr
// | bare-id
// | `-`? integer-literal
// multi-dim-affine-expr ::= `(` `)`
// | `(` affine-expr (`,` affine-expr)* `)`
// semi-affine-expr ::= `(` semi-affine-expr `)`
// | semi-affine-expr `+` semi-affine-expr
// | semi-affine-expr `-` semi-affine-expr
// | symbol-or-const `*` semi-affine-expr
// | semi-affine-expr `ceildiv` symbol-or-const
// | semi-affine-expr `floordiv` symbol-or-const
// | semi-affine-expr `mod` symbol-or-const
// | bare-id
// | `-`? integer-literal
// symbol-or-const ::= `-`? integer-literal | symbol-id
// multi-dim-semi-affine-expr ::= `(` semi-affine-expr (`,` semi-affine-expr)*
// `)`
// affine-constraint ::= affine-expr `>=` `affine-expr`
// | affine-expr `<=` `affine-expr`
// | affine-expr `==` `affine-expr`
// affine-constraint-conjunction ::= affine-constraint (`,`
// affine-constraint)*
_multi_dim_affine_expr : $ =>
seq($._affine_expr, repeat(seq(',', $._affine_expr))),
_affine_expr : $ => prec.right(choice(
seq('(', $._affine_expr, ')'), seq('-', $._affine_expr),
seq($._affine_expr, $._affine_token, $._affine_expr), $._affine_prim)),
_affine_prim : $ =>
choice($.integer_literal, $.value_use, $.bare_id,
seq('symbol', '(', $.value_use, ')'),
seq(choice('max', 'min'), '(', $._value_use_list, ')')),
_affine_token : $ => token(
choice('+', '-', '*', 'ceildiv', 'floordiv', 'mod', '==', '>=', '<=')),
func_return : $ => seq(token('->'), $.type_list_attr_parens),
func_arg_list : $ => seq(
'(', optional(choice($.variadic, $._value_id_and_type_attr_list)), ')'),
_value_id_and_type_attr_list : $ => seq(
$._value_id_and_type_attr, repeat(seq(',', $._value_id_and_type_attr)),
optional(seq(',', $.variadic))),
_value_id_and_type_attr : $ => seq($._function_arg, optional($.attribute)),
_function_arg : $ =>
choice(seq($.value_use, ':', $.type), $.value_use, $.type),
type_list_attr_parens : $ =>
choice($.type,
seq('(', $.type, optional($.attribute),
repeat(seq(',', $.type, optional($.attribute))), ')'),
seq('(', ')')),
variadic : $ => token('...'),
// (func.func|llvm.func) takes arguments, an optional return type, and and
// optional body
_op_func : $ =>
seq(field('visibility', optional('private')),
field('name', $.symbol_ref_id), field('arguments', $.func_arg_list),
field('return', optional($.func_return)),
field('attributes', optional(seq(token('attributes'), $.attribute))),
field('body', optional($.region))),
// dim-use-list ::= `(` ssa-use-list? `)`
// symbol-use-list ::= `[` ssa-use-list? `]`
// dim-and-symbol-use-list ::= dim-use-list symbol-use-list?
_value_use_list_parens : $ => seq('(', optional($._value_use_list), ')'),
_dim_and_symbol_use_list : $ =>
seq($._value_use_list_parens, optional($._dense_idx_list)),
// assignment-list ::= assignment | assignment `,` assignment-list
// assignment ::= ssa-value `=` ssa-value
_value_assignment_list : $ => seq('(', optional($._value_assignment),
repeat(seq(',', $._value_assignment)), ')'),
_value_assignment : $ => seq($.value_use, '=', $.value_use),
_dense_idx_list : $ => seq(
'[',
optional(seq(choice($.integer_literal, $.value_use),
repeat(seq(',', choice($.integer_literal, $.value_use))))),
']'),
// lower-bound ::= `max`? affine-map-attribute dim-and-symbol-use-list |
// shorthand-bound
// upper-bound ::= `min`? affine-map-attribute dim-and-symbol-use-list |
// shorthand-bound
// shorthand-bound ::= ssa-id | `-`? integer-literal
_bound : $ =>
choice(seq($.attribute, $._dim_and_symbol_use_list), $._shorthand_bound),
_shorthand_bound : $ => choice($.value_use, $.integer_literal),
// Dialect-specific attributes
restrict_attr : $ => token('restrict'),
writable_attr : $ => token('writable'),
gather_dims_attr : $ =>
seq(token('gather_dims'), '(', $._dense_idx_list, ')'),
scatter_dims_attr : $ =>
seq(token('scatter_dims'), '(', $._dense_idx_list, ')'),
unique_attr : $ => token('unique'),
nofold_attr : $ => token('nofold'),
outer_dims_perm_attr : $ =>
seq(token('outer_dims_perm'), '=', $._dense_idx_list),
inner_dims_pos_attr : $ =>
seq(token('inner_dims_pos'), '=', $._dense_idx_list),
inner_tiles_attr : $ => seq(token('inner_tiles'), '=', $._dense_idx_list),
isWrite_attr : $ => token(choice('read', 'write')),
localityHint_attr : $ => seq(token('locality'), '<', $.integer_literal, '>'),
isDataCache_attr : $ => token(choice('data', 'instr')),
fastmath_attr : $ =>
seq(token('fastmath'), '<',
seq($._fastmath_flag, repeat(seq(',', $._fastmath_flag))), '>'),
_fastmath_flag : $ => token(choice('none', 'reassoc', 'nnan', 'ninf', 'nsz',
'arcp', 'contract', 'afn', 'fast')),
// Comment (standard BCPL)
comment : $ => token(seq('//', /.*/)),
// TODO: complete
custom_operation : $ =>
choice($.builtin_dialect, $.func_dialect, $.llvm_dialect, $.arith_dialect,
$.math_dialect, $.cf_dialect, $.scf_dialect, $.memref_dialect,
$.vector_dialect, $.tensor_dialect, $.bufferization_dialect,
$.affine_dialect, $.linalg_dialect)
}
module.exports = grammar({
name : 'mlir',
extras : $ => [/\s/, $.comment],
conflicts : $ => [[ $._static_dim_list, $._static_dim_list ],
[ $.dictionary_attribute, $.region ]],
rules : Object.assign(common, builtin_dialect, func_dialect, llvm_dialect,
arith_dialect, math_dialect, cf_dialect, scf_dialect,
memref_dialect, vector_dialect, tensor_dialect,
bufferization_dialect, affine_dialect, linalg_dialect)
});
Codebase Browser
llvm