llzk 0.4.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

//! `global` dialect.

use llzk_sys::mlirGetDialectHandle__llzk__global__;
use melior::{
    dialect::DialectHandle,
    ir::{
        Attribute, Location, Operation, Type, Value,
        attribute::{StringAttribute, TypeAttribute},
        operation::{OperationBuilder, OperationLike},
    },
};

use crate::{ident, symbol_ref::SymbolRefAttribute};

/// Returns a handle to the `global` dialect.
pub fn handle() -> DialectHandle {
    unsafe { DialectHandle::from_raw(mlirGetDialectHandle__llzk__global__()) }
}

/// Constructs a 'global.def' operation.
pub fn def<'c>(
    location: Location<'c>,
    name: &str,
    r#type: Type<'c>,
    constant: bool,
    initial_value: Option<Attribute<'c>>,
) -> Operation<'c> {
    let ctx = location.context();
    let mut attrs = vec![
        (
            ident!(ctx, "sym_name"),
            StringAttribute::new(unsafe { ctx.to_ref() }, name).into(),
        ),
        (ident!(ctx, "type"), TypeAttribute::new(r#type).into()),
    ];
    if constant {
        attrs.push((
            ident!(ctx, "constant"),
            Attribute::unit(unsafe { ctx.to_ref() }),
        ));
    }
    if let Some(initial_value) = initial_value {
        attrs.push((ident!(ctx, "initial_value"), initial_value));
    }
    OperationBuilder::new("global.def", location)
        .add_attributes(&attrs)
        .build()
        .expect("valid operation")
}

/// Return `true` iff the given op is `global.def`.
#[inline]
pub fn is_global_def<'c: 'a, 'a>(op: &impl OperationLike<'c, 'a>) -> bool {
    crate::operation::isa(op, "global.def")
}

/// Constructs a 'global.read' operation.
pub fn read<'c>(
    location: Location<'c>,
    name: SymbolRefAttribute<'c>,
    result: Type<'c>,
) -> Operation<'c> {
    let ctx = location.context();
    OperationBuilder::new("global.read", location)
        .add_attributes(&[(ident!(ctx, "name_ref"), name.into())])
        .add_results(&[result])
        .build()
        .expect("valid operation")
}

/// Return `true` iff the given op is `global.read`.
#[inline]
pub fn is_global_read<'c: 'a, 'a>(op: &impl OperationLike<'c, 'a>) -> bool {
    crate::operation::isa(op, "global.read")
}

/// Constructs a 'global.write' operation.
pub fn write<'c>(
    location: Location<'c>,
    name: SymbolRefAttribute<'c>,
    value: Value<'c, '_>,
) -> Operation<'c> {
    let ctx = location.context();
    OperationBuilder::new("global.write", location)
        .add_attributes(&[(ident!(ctx, "name_ref"), name.into())])
        .add_operands(&[value])
        .build()
        .expect("valid operation")
}

/// Return `true` iff the given op is `global.write`.
#[inline]
pub fn is_global_write<'c: 'a, 'a>(op: &impl OperationLike<'c, 'a>) -> bool {
    crate::operation::isa(op, "global.write")
}