llzk 0.3.1

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! `pod` dialect operations and helper functions.

use super::r#type::PodType;
use crate::{
    builder::{OpBuilder, OpBuilderLike},
    ident,
    map_operands::MapOperandsBuilder,
    prelude::FlatSymbolRefAttribute,
};
use llzk_sys::{
    LlzkRecordValue, llzkPod_NewPodOpBuild, llzkPod_NewPodOpBuildInferredFromInitialValues,
    llzkPod_NewPodOpBuildWithMapOperands,
};
use melior::StringRef;
use melior::ir::{
    Location, Operation, Type, TypeLike, Value, ValueLike,
    operation::{OperationBuilder, OperationLike},
};
use std::marker::PhantomData;

/// Wrapper around a `LlzkRecordValue`, used to initialize fields in a `pod.new` operation.
#[derive(Debug)]
pub struct RecordValue<'c, 'a> {
    raw: LlzkRecordValue,
    _context: PhantomData<Value<'c, 'a>>,
}

impl<'c, 'a> RecordValue<'c, 'a> {
    /// Creates a new record value.
    pub fn new(name: StringRef, value: Value<'c, 'a>) -> Self {
        Self {
            raw: LlzkRecordValue {
                name: name.to_raw(),
                value: value.to_raw(),
            },
            _context: PhantomData,
        }
    }

    /// Returns the raw representation of the record value.
    pub fn to_raw(&self) -> LlzkRecordValue {
        self.raw
    }

    /// Creates the record value from a raw pointer.
    pub fn from_raw(raw: LlzkRecordValue) -> Self {
        Self {
            raw,
            _context: PhantomData,
        }
    }
}

/// Creates a 'pod.new' operation from a list of initialization values. If the optional type
/// of the result pod is not given, it will be inferred from the provided initialization values.
pub fn new<'c, 'a>(
    builder: &OpBuilder<'c>,
    location: Location<'c>,
    values: &[RecordValue<'c, 'a>],
    r#type: Option<PodType<'c>>,
) -> Operation<'c> {
    let raw_values: Vec<_> = values.iter().map(RecordValue::to_raw).collect();
    if let Some(r#type) = r#type {
        unsafe {
            Operation::from_raw(llzkPod_NewPodOpBuild(
                builder.to_raw(),
                location.to_raw(),
                r#type.to_raw(),
                raw_values.len() as isize,
                raw_values.as_ptr(),
            ))
        }
    } else {
        unsafe {
            Operation::from_raw(llzkPod_NewPodOpBuildInferredFromInitialValues(
                builder.to_raw(),
                location.to_raw(),
                raw_values.len() as isize,
                raw_values.as_ptr(),
            ))
        }
    }
}

/// Creates a 'pod.new' operation from a list of initialization values and a`MapOperandsBuilder`
/// to instantiate top-level `affine_map` attributes appearing in the pod type.
pub fn new_with_affine_init<'c, 'a>(
    builder: &OpBuilder<'c>,
    location: Location<'c>,
    values: &[RecordValue<'c, 'a>],
    r#type: PodType<'c>,
    affine_init: MapOperandsBuilder,
) -> Operation<'c> {
    let raw_values: Vec<_> = values.iter().map(RecordValue::to_raw).collect();
    unsafe {
        Operation::from_raw(llzkPod_NewPodOpBuildWithMapOperands(
            builder.to_raw(),
            location.to_raw(),
            r#type.to_raw(),
            raw_values.len() as isize,
            raw_values.as_ptr(),
            affine_init.to_raw(),
        ))
    }
}

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

/// Creates a 'pod.read' operation.
pub fn read<'c>(
    location: Location<'c>,
    pod_ref: Value<'c, '_>,
    record_name: FlatSymbolRefAttribute<'c>,
    result: Type<'c>,
) -> Operation<'c> {
    let ctx = location.context();
    OperationBuilder::new("pod.read", location)
        .add_attributes(&[(ident!(ctx, "record_name"), record_name.into())])
        .add_operands(&[pod_ref])
        .add_results(&[result])
        .build()
        .expect("valid operation")
}

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

/// Creates a 'pod.write' operation.
pub fn write<'c>(
    location: Location<'c>,
    pod_ref: Value<'c, '_>,
    record_name: FlatSymbolRefAttribute<'c>,
    rvalue: Value<'c, '_>,
) -> Operation<'c> {
    let ctx = location.context();
    OperationBuilder::new("pod.write", location)
        .add_attributes(&[(ident!(ctx, "record_name"), record_name.into())])
        .add_operands(&[pod_ref, rvalue])
        .build()
        .expect("valid operation")
}

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