opcode-macros 0.1.0

Macros for opcodes encoded in bit fields
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use ebpf_consts::*;
use opcode_macros::opcode_match;

#[test]
pub fn match_test() {
    println!("{}", match_number(BPF_ALU | BPF_X | BPF_ADD));
    assert!(match_number(BPF_ALU | BPF_X | BPF_ADD) == 0xFFFFFFFF);
    assert!(match_number(BPF_ALU | BPF_X | BPF_RSH) == 0);
    assert!(match_number(BPF_ALU | BPF_X | BPF_LSH) == 0);
}

pub fn match_number(opcode: u8) -> u64 {
    println!("{opcode:#x}");
    opcode_match! {
        opcode,
        [[BPF_ALU: ALU, BPF_ALU64: ALU64], [BPF_X: X, BPF_K: K],
        [
            BPF_ADD: "+",
            BPF_AND: "&",
            BPF_OR : "|",
            BPF_XOR: "^",
            BPF_LSH: "<<",
            BPF_RSH: ">>",
         ]] => {
            let dst = 0xFFF00FFF0000u64;
            #?((X))   let src = 0x000FF000FFFFu64; ##
            #?((K))   let src = 0u64;              ##
            #?((ALU)) let src = src as u32;        ##
            #?((ALU))
                let dst = dst as u32;
            ##
            #?(("<<")|(">>"))
                let limit = #?((ALU)) 31 ## #?((ALU64)) 63 ##;
                let src = src & limit;
            ##
            let res = dst #=2 src;
            let s = #2;
            println!("Expr: {dst:#x} {s} {src:#x}");
            res #?((ALU)) as u64 ##
        }
        _ => {
            let v = vec![0, 1, 2];
            v[0]
        }
    }
}

#[test]
fn test_replacing_in_parenthesis() {
    let opcode = 0u8;
    let values = vec![1, 2, 3, 4];
    let value = opcode_match! {
        opcode as u8 in ebpf_consts,
        [[BPF_ADD: "+"]] => {
            // (1 + 2) * 3 -> 9
            let value = (1 #=0 2) * 3;
            // 9 + (10 + 10)
            value + if values[1 #=0 2] == 4 {
                10 #=0 10
            } else {
                0
            }
        }
        _ => {
            0
        }
    };
    assert_eq!(value, 29);
}

#[test]
fn test_multiple_aliases() {
    let opcode = 0u8;
    assert_eq!(
        opcode_match! {
            opcode as u8 in ebpf_consts,
            [[BPF_ADD: [1, 2, 3, 4, 5]]] => {
                #:0:=0 * (#:1:=0 + #:2:=0 + #:3:=0) * #:4:=0
            }
            _ => 0,
        },
        45
    );
}

#[test]
fn test_with_same_aliases() {
    mod consts {
        pub const A: u8 = 0;
        pub const B: u8 = 1;
    }
    for i in 0u8..2 {
        opcode_match! {
            i as u8 in consts,
            [[A: ["do_a", "do_final"], B: ["do_b", "do_final"]]] => {
                #?((!do_final)) panic!(); ##
                #?((do_final))
                    assert_eq!(#:1:0, "do_final");
                    assert!(#0.starts_with("do_"));
                ##
            }
            _ => panic!(),
        }
    }
}