ab-riscv-interpreter 0.0.3

Composable and generic RISC-V interpreter
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
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

use crate::rv64::test_utils::{execute, initialize_state};
use ab_riscv_primitives::prelude::*;

// xperm4 tests

#[test]
fn test_xperm4_basic() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm4 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    // Nibbles 0–15 of rs1: nibble i = i (nibble 0 = 0x0, nibble 15 = 0xF)
    state.regs.write(Reg::A0, 0xFEDCBA9876543210u64);
    // Identity: each nibble of rs2 selects nibble i
    state.regs.write(Reg::A1, 0xFEDCBA9876543210u64);

    execute(&mut state).unwrap();

    // xperm4 of a value with itself: nibble i of rs2 is i, so we look up nibble i of rs1
    // which is also i - identity maps through identity lut back to the lut itself
    assert_eq!(state.regs.read(Reg::A2), 0xFEDCBA9876543210u64);
}

#[test]
fn test_xperm4_constant_index() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm4 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    // rs1 nibble 3 = 0xA
    state.regs.write(Reg::A0, 0x000000000000A000u64);
    // All 16 nibbles of rs2 are index 3
    state.regs.write(Reg::A1, 0x3333333333333333u64);

    execute(&mut state).unwrap();

    // Every output nibble should be 0xA
    assert_eq!(state.regs.read(Reg::A2), 0xAAAAAAAAAAAAAAAAu64);
}

#[test]
fn test_xperm4_no_out_of_bounds() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm4 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    state.regs.write(Reg::A0, 0xFEDCBA9876543210u64);
    // Maximum nibble index is 0xF = 15, which is the last nibble - always in bounds
    state.regs.write(Reg::A1, 0xFFFFFFFFFFFFFFFFu64);

    execute(&mut state).unwrap();

    // Every output nibble = nibble 15 of rs1 = 0xF
    assert_eq!(state.regs.read(Reg::A2), 0xFFFFFFFFFFFFFFFFu64);
}

#[test]
fn test_xperm4_zero_lut() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm4 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    state.regs.write(Reg::A0, 0x0u64);
    state.regs.write(Reg::A1, 0xFEDCBA9876543210u64);

    execute(&mut state).unwrap();

    assert_eq!(state.regs.read(Reg::A2), 0x0u64);
}

// xperm8 tests

#[test]
fn test_xperm8_basic() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm8 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    // rs1 bytes (index -> value): 0->0x10, 1->0x20, 2->0x30, 3->0x40, ...
    state.regs.write(Reg::A0, 0x80_70_60_50_40_30_20_10u64);
    // rs2 indices: select bytes 0,1,2,3 in order
    state.regs.write(Reg::A1, 0x03_02_01_00_03_02_01_00u64);

    execute(&mut state).unwrap();

    // Each index picks a byte from rs1
    assert_eq!(state.regs.read(Reg::A2), 0x40_30_20_10_40_30_20_10u64);
}

#[test]
fn test_xperm8_out_of_bounds_zeroed() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm8 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    state.regs.write(Reg::A0, 0x08_07_06_05_04_03_02_01u64);
    // Indices 8–255 are out of bounds and must produce 0
    state.regs.write(Reg::A1, 0xFF_10_09_08_00_00_00_00u64);

    execute(&mut state).unwrap();

    // First four lanes: index 0->0x01, 0->0x01, 0->0x01, 0->0x01
    // Upper three lanes: indices 8,9,16 -> all out of bounds -> 0x00
    // Highest lane: index 0xFF -> out of bounds -> 0x00
    assert_eq!(state.regs.read(Reg::A2), 0x00_00_00_00_01_01_01_01u64);
}

#[test]
fn test_xperm8_identity() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm8 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    let lut = 0xDE_AD_BE_EF_CA_FE_BA_BEu64;
    state.regs.write(Reg::A0, lut);
    // Identity permutation: index i selects byte i
    state.regs.write(Reg::A1, 0x07_06_05_04_03_02_01_00u64);

    execute(&mut state).unwrap();

    assert_eq!(state.regs.read(Reg::A2), lut);
}

#[test]
fn test_xperm8_reverse() {
    let mut state = initialize_state([Rv64ZbkxInstruction::Xperm8 {
        rd: Reg::A2,
        rs1: Reg::A0,
        rs2: Reg::A1,
    }]);

    state.regs.write(Reg::A0, 0x08_07_06_05_04_03_02_01u64);
    // Reverse permutation
    state.regs.write(Reg::A1, 0x00_01_02_03_04_05_06_07u64);

    execute(&mut state).unwrap();

    assert_eq!(state.regs.read(Reg::A2), 0x01_02_03_04_05_06_07_08u64);
}