zkevm-assembly 0.132.0

The zkEVM common utilities
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
81
82

use super::*;

// we use binop for unconditional move with two arguments src, dst
pub(crate) fn parse_mov_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, args)) = parse_mnemonic(input, "mov", 2)?;
    let canonical = format!("binop.xor {}, r0, {}, r0", &args[0], &args[1]);

    Ok((rest, canonical))
}

pub(crate) fn parse_xor_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, modifiers, args)) = parse_mnemonic_allow_modifiers(input, "xor", 3)?;
    let canonical = format!(
        "binop.xor{} {}, {}, {}",
        format_modifiers_into_canonical(modifiers),
        &args[0],
        &args[1],
        &args[2]
    );

    Ok((rest, canonical))
}

pub(crate) fn parse_or_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, modifiers, args)) = parse_mnemonic_allow_modifiers(input, "or", 3)?;
    let canonical = format!(
        "binop.or{} {}, {}, {}",
        format_modifiers_into_canonical(modifiers),
        &args[0],
        &args[1],
        &args[2]
    );

    Ok((rest, canonical))
}

pub(crate) fn parse_and_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, modifiers, args)) = parse_mnemonic_allow_modifiers(input, "and", 3)?;
    let canonical = format!(
        "binop.and{} {}, {}, {}",
        format_modifiers_into_canonical(modifiers),
        &args[0],
        &args[1],
        &args[2]
    );

    Ok((rest, canonical))
}

pub(crate) fn parse_push_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, args)) = parse_mnemonic(input, "push", 1)?;
    let canonical = format!("binop.xor {}, r0, stack+=[1], r0", &args[0]);

    Ok((rest, canonical))
}

pub(crate) fn parse_pop_combinator(input: &str) -> IResult<&str, String> {
    let (rest, (_, args)) = parse_mnemonic(input, "pop", 1)?;
    let canonical = format!("binop.xor stack-=[1], r0, {}, r0", &args[0]);

    Ok((rest, canonical))
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::assembly::SimplifyNomError;

    #[test]
    fn test_parse_mov() {
        let example = "mov r2, r3";
        let r = parse_mov_combinator(example).simplify();
        dbg!(r);
    }

    #[test]
    fn test_parse_xor() {
        let example = "xor.s.set_flags r2, r3, r0";
        let r = parse_xor_combinator(example).simplify();
        dbg!(r);
    }
}