Melior Documentation

When using the Melior macro system to generate code for MLIR operations, the TypeInference enum determines how the generated builder populates result types. This is crucial for understanding how the builder handles result type derivation:

• Interface: The operation implements InferTypeOpInterface. The builder relies on the interface's logic to infer types.
• SameOperands: The operation has the SameOperandsAndResultType trait. The builder copies the type of the first operand to all results in the first-operand setter.
• FirstAttrDerived: The operation has the FirstAttrDerivedResultType trait. The builder derives the result type from the first attribute in the first-attribute setter.

pub enum TypeInference {
    /// Op implements `InferTypeOpInterface` — call `enable_result_type_inference()`.
    Interface,
    /// Op has `SameOperandsAndResultType` — copy `operands[0].type()` to all results in the first-operand setter.
    SameOperands,
    /// Op has `FirstAttrDerivedResultType` — derive result type from the first attribute in the first-attribute setter.
    FirstAttrDerived,
}

To write a custom MLIR pass in Rust, implement the RunExternalPass<'c> trait for a type that is Sized and Clone. This allows you to define the lifecycle and execution logic of a pass that can be integrated into the MLIR pipeline.

Key lifecycle methods:

• construct(): Called when the pass is created.
• destruct(): Called when the pass is destroyed.
• initialize(&mut self, context: ContextRef<'c>): Called to set up the pass using the provided MLIR context.
• run(&mut self, operation: OperationRef<'c, '_>, pass: ExternalPass<'_>): The core logic where you manipulate the IR. The operation argument is the operation this pass is targeting, and pass provides a handle to the external pass itself.

Alternatively, you can implement a pass using a simple closure that implements FnMut(OperationRef<'c, '_>, ExternalPass<'_>) + Clone.

use melior::{
    ContextRef,
    ir::{OperationRef, operation::OperationLike},
    pass::{ExternalPass, RunExternalPass},
};

#[derive(Clone, Debug)]
struct ExamplePass;

impl<'c> RunExternalPass<'c> for ExamplePass {
    fn construct(&mut self) {
        println!("Constructed pass!");
    }

    fn initialize(&mut self, context: ContextRef<'c>) {
        println!("Initialize called!");
    }

    fn run(&mut self, operation: OperationRef<'c, '_>, _pass: ExternalPass<'_>) {
        operation.dump();
    }
}

This example demonstrates how to use Melior to construct an MLIR module containing a function that adds two integers using the arith and func dialects. It covers context initialization, dialect registration, type creation, and operation building within a block.

use melior::{
    Context,
    dialect::{DialectRegistry, arith, func},
    ir::{
        attribute::{StringAttribute, TypeAttribute},
        operation::OperationLike,
        r::type::FunctionType,
        *,
    },
    utility::register_all_dialects,
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);
let module = Module::new(location);

let index_type = Type::index(&context);

module.body().append_operation(func::func(
    &context,
    StringAttribute::new(&context, "add"),
    TypeAttribute::new(
        FunctionType::new(&context, &[index_type, index_type], &[index_type]).into(),
    ),
    {
        let block = Block::new(&[(index_type, location), (index_type, location)]);

        let sum = block
            .append_operation(arith::addi(
                block.argument(0).unwrap().into(),
                block.argument(1).unwrap().into(),
                location,
            ))
            .result(0)
            .unwrap();

        block.append_operation(func::r#return(&[sum.into()], location));

        let region = Region::new();
        region.append_block(block);
        region
    },
    &[],
    location,
));

assert!(module.as_operation().verify());

This example demonstrates how to use Melior to construct a basic MLIR module containing a function that adds two 64-bit integers using the arith and func dialects.

let context = Context::new();
load_all_dialects(&context);

let location = Location::unknown(&context);
let module = Module::new(location);

let integer_type = IntegerType::new(&context, 64).into();

let function = {
    let block = Block::new(&[(integer_type, location), (integer_type, location)]);

    let sum = block.append_operation(arith::addi(
        block.argument(0).unwrap().into(),
        block.argument(1).unwrap().into(),
        location,
    ));

    block.append_operation(func::r#return(&[sum.result(0).unwrap().into()], location));

    let region = Region::new();
    region.append_block(block);
    region
};

func::func(
    &context,
    StringAttribute::new(&context, "add"),
    TypeAttribute::new(
        FunctionType::new(&context, &[integer_type, integer_type], &[integer_type])
            .into(),
    ),
    function,
    &[],
    Location::unknown(&context),
);

module.body().append_operation(function);
assert!(module.as_operation().verify());