vyre-lower 0.6.3

Substrate-neutral lowering: vyre Program → KernelDescriptor consumed by vyre-emit-* crates.
Documentation 
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

use crate::rewrites::commutative_lit_chain::{
    combine_commutative_lit_chain, CommutativeLitChainRule,
};
use crate::KernelDescriptor;
use vyre_foundation::ir::BinOp;

macro_rules! define_commutative_arithmetic_combine {
    (
        module = $module:ident,
        function = $function:ident,
        op = $op:expr,
        combine = $combine:path,
        first = $first:expr,
        second = $second:expr,
        combined = $combined:expr,
        overflow_first = $overflow_first:expr,
        overflow_second = $overflow_second:expr
    ) => {
        pub mod $module {
            use super::*;

            #[must_use]
            pub fn $function(desc: &KernelDescriptor) -> KernelDescriptor {
                combine_commutative_lit_chain(
                    desc,
                    CommutativeLitChainRule {
                        op: $op,
                        combine_literals: $combine,
                    },
                )
            }

            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::rewrites::commutative_lit_chain::test_support::{
                    assert_commutative_lit_chain_contract, CommutativeLitChainContract,
                };

                #[test]
                fn satisfies_commutative_literal_chain_contract() {
                    assert_commutative_lit_chain_contract(CommutativeLitChainContract {
                        rewrite: $function,
                        op: $op,
                        combine_literals: $combine,
                        first: $first,
                        second: $second,
                        combined: $combined,
                        overflow_first: $overflow_first,
                        overflow_second: $overflow_second,
                    });
                }
            }
        }
    };
}

define_commutative_arithmetic_combine!(
    module = add_combine,
    function = add_combine,
    op = BinOp::Add,
    combine = u32::checked_add,
    first = 4,
    second = 6,
    combined = 10,
    overflow_first = 0xFFFF_FFFE,
    overflow_second = 5
);

define_commutative_arithmetic_combine!(
    module = mul_combine,
    function = mul_combine,
    op = BinOp::Mul,
    combine = u32::checked_mul,
    first = 4,
    second = 6,
    combined = 24,
    overflow_first = 0x1_0000,
    overflow_second = 0x1_0000
);