cubecl-spirv 0.11.1

SPIR-V compiler for CubeCL
Documentation
use cubecl_ir::{
    NamedRewrite,
    prelude::{
        Context, DialectConversion, DialectConversionRewriter, OperandsInfo, Operation,
        OperationPtrExt, Ptr, Result, Rewriter,
    },
    rewrite::DialectConversionPass,
    verify_op_succ,
};
use pliron::{
    attribute::boxed_attr_cast,
    builtin::ops::{ConstantOp, FuncOp},
    derive::{op_interface, op_interface_impl},
    irbuild::inserter::Inserter,
    op::{Op, op_cast},
    r#type::{TypeHandle, Typed},
};

use crate::{attributes::attr_to_spirv_dialect, types::ty_to_spirv_dialect};

#[op_interface]
pub trait ToSpirvDialectOp {
    verify_op_succ!();
    fn should_convert(&self, _ctx: &Context) -> bool {
        true
    }
    fn to_spirv_dialect(
        &self,
        ctx: &mut Context,
        rewriter: &mut DialectConversionRewriter,
        operands_info: &OperandsInfo,
    ) -> Result<()>;
}

pub type ToSpirvDialectPass = DialectConversionPass<ToSpirvDialect>;

#[derive(Default, NamedRewrite)]
pub struct ToSpirvDialect;

impl DialectConversion for ToSpirvDialect {
    fn can_convert_op(&self, ctx: &Context, op: Ptr<Operation>) -> bool {
        let dyn_op = op.dyn_op(ctx);
        op_cast::<dyn ToSpirvDialectOp>(&*dyn_op).is_some_and(|op| op.should_convert(ctx))
    }

    fn can_convert_type(&self, ctx: &Context, handle: TypeHandle) -> bool {
        ty_to_spirv_dialect(ctx, handle) != handle
    }

    fn rewrite(
        &mut self,
        ctx: &mut Context,
        rewriter: &mut DialectConversionRewriter,
        op: Ptr<Operation>,
        operands_info: &OperandsInfo,
    ) -> Result<()> {
        let dyn_op = op.dyn_op(ctx);
        let to_spirv_dialect = op_cast::<dyn ToSpirvDialectOp>(&*dyn_op).unwrap();
        to_spirv_dialect.to_spirv_dialect(ctx, rewriter, operands_info)
    }

    fn convert_type(&mut self, ctx: &mut Context, handle: TypeHandle) -> Result<TypeHandle> {
        Ok(ty_to_spirv_dialect(ctx, handle))
    }
}

#[op_interface_impl]
impl ToSpirvDialectOp for FuncOp {
    fn should_convert(&self, ctx: &Context) -> bool {
        let ty = self.get_attr_builtin_func_type(ctx).unwrap().get_type(ctx);
        ty_to_spirv_dialect(ctx, ty) != ty
    }

    fn to_spirv_dialect(
        &self,
        ctx: &mut Context,
        _rewriter: &mut DialectConversionRewriter,
        _operands_info: &OperandsInfo,
    ) -> Result<()> {
        let func_ty = self.get_attr_builtin_func_type(ctx).unwrap().get_type(ctx);
        let func_ty = ty_to_spirv_dialect(ctx, func_ty);
        self.set_attr_builtin_func_type(ctx, func_ty.into());

        Ok(())
    }
}

#[op_interface_impl]
impl ToSpirvDialectOp for ConstantOp {
    #[allow(clippy::op_ref, reason = "false positive")]
    fn should_convert(&self, ctx: &Context) -> bool {
        &attr_to_spirv_dialect(ctx, &self.get_attr_builtin_constant_value(ctx).unwrap())
            != &*self.get_attr_builtin_constant_value(ctx).unwrap()
    }

    fn to_spirv_dialect(
        &self,
        ctx: &mut Context,
        rewriter: &mut DialectConversionRewriter,
        _operands_info: &OperandsInfo,
    ) -> Result<()> {
        let attr = attr_to_spirv_dialect(ctx, &self.get_attr_builtin_constant_value(ctx).unwrap());
        let attr = boxed_attr_cast(attr).unwrap();
        let new_const = ConstantOp::new(ctx, attr);
        rewriter.insert_op(ctx, &new_const);
        rewriter.replace_operation(ctx, self.get_operation(), new_const.get_operation());
        Ok(())
    }
}