eeric 0.0.21

An easily embeddable RV64I core with MFDV extensions
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

#[derive(Clone, Default)]
#[cfg_attr(debug_assertions, derive(Debug, PartialEq))]
pub enum SEW {
    #[default]
    E8,
    E16,
    E32,
    E64,
    // Only for widening instructions
    E128
}

impl TryFrom<usize> for SEW {
    type Error = &'static str;

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let sew = match value {
            8 => Self::E8,
            16 => Self::E16,
            32 => Self::E32,
            64 => Self::E64,
            _ => return Err("Incorrect SEW (should be 8b, 16b, 32b or 64b)")
        };

        Ok(sew)
    }
}

impl SEW {
    pub fn double(self) -> Result<Self, &'static str> {
        let doubled = match self {
            Self::E8 => Self::E16,
            Self::E16 => Self::E32,
            Self::E32 => Self::E64,
            Self::E64 => Self::E128,
            Self::E128 => return Err("Doubing 128-bit SEW is not defined")
        };

        Ok(doubled)
    }

    pub fn half(self) -> Result<Self, &'static str> {
        let halved = match self {
            Self::E128 => Self::E64,
            Self::E64 => Self::E32,
            Self::E32 => Self::E16,
            Self::E16 => Self::E8,
            Self::E8 => return Err("Halving 8-bit SEW is not defined"),
        };

        Ok(halved)
    }

    pub fn fourth(self) -> Result<Self, &'static str> {
        let fourthed = match self {
            Self::E128 => Self::E32,
            Self::E64 => Self::E16,
            Self::E32 => Self::E8,
            Self::E16 => return Err("Fourthing 16-bit SEW is not defined"),
            Self::E8 => return Err("Fourthing 8-bit SEW is not defined"),
        };

        Ok(fourthed)
    }

    pub fn eighth(self) -> Result<Self, &'static str> {
        let eighted = match self {
            Self::E128 => Self::E16,
            Self::E64 => Self::E8,
            Self::E32 => return Err("Eighting 32-bit SEW is not defined"),
            Self::E16 => return Err("Eighting 16-bit SEW is not defined"),
            Self::E8 => return Err("Eighting 8-bit SEW is not defined"),
        };

        Ok(eighted)
    }

    pub fn bit_length(&self) -> usize {
        match self {
            Self::E8 => 8,
            Self::E16 => 16,
            Self::E32 => 32,
            Self::E64 => 64,
            Self::E128 => 128
        }
    }

    pub fn byte_length(&self) -> usize {
        self.bit_length() / 8
    }
}