squid 2.0.3

A RISC-V emulator with AOT compilation for fuzzing
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

use crate::frontend::ao::{
    Function,
    Op,
    Register,
    Var,
};

const REGISTER_COUNT: usize = 32 + 32 + 1;
fn register_index(reg: &Register) -> usize {
    match reg {
        Register::Gp(reg) => *reg as usize,
        Register::Fp(reg) => 32 + *reg as usize,
        Register::Csr(_) => 64,
    }
}

pub(crate) struct RegisterCachingPass {
    registers: [Option<Var>; REGISTER_COUNT],
}

impl RegisterCachingPass {
    #[allow(clippy::new_without_default)]
    pub(crate) fn new() -> Self {
        Self {
            registers: [None; REGISTER_COUNT],
        }
    }

    pub(crate) fn run(&mut self, func: &mut Function) -> Result<(), String> {
        for bb in func.cfg_mut().iter_basic_blocks_mut() {
            for reg in &mut self.registers {
                *reg = None;
            }

            bb.set_cursor(0);

            while let Some(op) = bb.cursor_op() {
                match op {
                    Op::StoreRegister {
                        reg,
                        var,
                    } => {
                        self.registers[register_index(reg)] = Some(*var);
                    },
                    Op::LoadRegister {
                        var,
                        reg,
                    } => {
                        if let Some(orig_var) = &self.registers[register_index(reg)] {
                            bb.replace_op(Op::Copy {
                                dst: *var,
                                src: *orig_var,
                            });
                        }
                    },
                    _ => {},
                }

                if !bb.move_cursor_forward() {
                    break;
                }
            }
        }

        Ok(())
    }
}