llzk-sys 30.1.0

Rust bindings to the LLZK C API.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use std::ptr::null_mut;

use mlir_sys::{
    MlirAttribute, MlirContext, MlirNamedAttribute, MlirOperation, MlirType,
    mlirAttributeGetContext, mlirFlatSymbolRefAttrGet, mlirIdentifierGet, mlirIndexTypeGet,
    mlirIntegerAttrGet, mlirLocationUnknownGet, mlirNamedAttributeGet, mlirOperationCreate,
    mlirOperationDestroy, mlirOperationStateAddAttributes, mlirOperationStateGet, mlirTypeAttrGet,
    mlirUnitAttrGet,
};
use rstest::rstest;

use crate::{
    llzkGlobal_GlobalDefOpIsConstant, llzkOperationIsA_Global_GlobalDefOp,
    mlirGetDialectHandle__llzk__global__,
    sanity_tests::{TestContext, context, str_ref},
};

#[test]
fn test_mlir_get_dialect_handle_llzk_global() {
    unsafe {
        mlirGetDialectHandle__llzk__global__();
    }
}

fn named_attr(s: &'static str, attr: MlirAttribute) -> MlirNamedAttribute {
    unsafe {
        mlirNamedAttributeGet(
            mlirIdentifierGet(mlirAttributeGetContext(attr), str_ref(s)),
            attr,
        )
    }
}

fn create_global_def_op(
    ctx: MlirContext,
    sym_name: &'static str,
    constant: bool,
    r#type: MlirType,
    initial_value: Option<MlirAttribute>,
) -> MlirOperation {
    unsafe {
        let sym_name = mlirFlatSymbolRefAttrGet(ctx, str_ref(sym_name));
        let mut attrs = vec![
            named_attr("sym_name", sym_name),
            named_attr("type", mlirTypeAttrGet(r#type)),
        ];
        if constant {
            attrs.push(named_attr("constant", mlirUnitAttrGet(ctx)));
        }
        if let Some(value) = initial_value {
            attrs.push(named_attr("initial_value", value));
        }
        let name = str_ref("global.def");
        let mut state = mlirOperationStateGet(name, mlirLocationUnknownGet(ctx));
        mlirOperationStateAddAttributes(
            &mut state,
            isize::try_from(attrs.len()).expect("attrs too large"),
            attrs.as_ptr(),
        );

        mlirOperationCreate(&mut state)
    }
}

#[rstest]
fn test_llzk_operation_is_a_global_def_op(context: TestContext) {
    unsafe {
        let op = create_global_def_op(context.ctx, "G", false, mlirIndexTypeGet(context.ctx), None);
        assert_ne!(op.ptr, null_mut());
        assert!(llzkOperationIsA_Global_GlobalDefOp(op));
        mlirOperationDestroy(op);
    }
}

#[rstest]
fn test_llzk_global_def_op_get_is_constant_1(context: TestContext) {
    unsafe {
        let op = create_global_def_op(context.ctx, "G", false, mlirIndexTypeGet(context.ctx), None);
        assert_ne!(op.ptr, null_mut());
        assert!(!llzkGlobal_GlobalDefOpIsConstant(op));
        mlirOperationDestroy(op);
    }
}

#[rstest]
fn test_llzk_global_def_op_get_is_constant_2(context: TestContext) {
    unsafe {
        let op = create_global_def_op(
            context.ctx,
            "G",
            true,
            mlirIndexTypeGet(context.ctx),
            Some(mlirIntegerAttrGet(mlirIndexTypeGet(context.ctx), 1)),
        );
        assert_ne!(op.ptr, null_mut());
        assert!(llzkGlobal_GlobalDefOpIsConstant(op));
        mlirOperationDestroy(op);
    }
}