ab_riscv_primitives/instructions/rv32/
zalasr.rs

1//! RV32 Zalasr extension
2
3#[cfg(test)]
4mod tests;
5
6use crate::instructions::Instruction;
7use crate::registers::general_purpose::Register;
8use ab_riscv_macros::instruction;
9use core::fmt;
10
11/// RISC-V RV32 Zalasr instruction (Load-Acquire/Store-Release).
12///
13/// Load-acquire instructions always carry an acquire annotation (not stored as a field since it
14/// is always `true`), plus an optional release annotation stored in `rl`. Store-release
15/// instructions always carry a release annotation (not stored as a field since it is always
16/// `true`), plus an optional acquire annotation stored in `aq`.
17#[instruction]
18#[derive(Debug, Clone, Copy)]
19#[derive_const(PartialEq, Eq)]
20pub enum Rv32ZalasrInstruction<Reg> {
21    /// Load-acquire byte
22    LbAq { rd: Reg, rs1: Reg, rl: bool },
23    /// Load-acquire halfword
24    LhAq { rd: Reg, rs1: Reg, rl: bool },
25    /// Load-acquire word
26    LwAq { rd: Reg, rs1: Reg, rl: bool },
27    /// Store-release byte
28    SbRl { rs1: Reg, rs2: Reg, aq: bool },
29    /// Store-release halfword
30    ShRl { rs1: Reg, rs2: Reg, aq: bool },
31    /// Store-release word
32    SwRl { rs1: Reg, rs2: Reg, aq: bool },
33}
34
35#[instruction]
36const impl<Reg> Instruction for Rv32ZalasrInstruction<Reg>
37where
38    Reg: [const] Register<Type = u32>,
39{
40    const ALIGNMENT: u8 = align_of::<u32>() as u8;
41
42    type Reg = Reg;
43
44    #[inline(always)]
45    #[cfg_attr(feature = "no-panic", no_panic_const::no_panic(const))]
46    fn try_decode(instruction: u32) -> Option<Self> {
47        let opcode = (instruction & 0b111_1111) as u8;
48        let rd_bits = ((instruction >> 7) & 0x1f) as u8;
49        let funct3 = ((instruction >> 12) & 0b111) as u8;
50        let rs1_bits = ((instruction >> 15) & 0x1f) as u8;
51        let rs2_bits = ((instruction >> 20) & 0x1f) as u8;
52        let funct7 = ((instruction >> 25) & 0b111_1111) as u8;
53        let funct5 = funct7 >> 2;
54        let aq = (funct7 & 0b10) != 0;
55        let rl = (funct7 & 0b01) != 0;
56
57        match (opcode, funct5) {
58            // Load-acquire, `aq` bit is mandatory and `rs2` must be zero
59            (0b010_1111, 0b00110) => match (funct3, rs2_bits, aq) {
60                (0b000, 0, true) => {
61                    let rd = Reg::from_bits(rd_bits)?;
62                    let rs1 = Reg::from_bits(rs1_bits)?;
63                    Some(Self::LbAq { rd, rs1, rl })
64                }
65                (0b001, 0, true) => {
66                    let rd = Reg::from_bits(rd_bits)?;
67                    let rs1 = Reg::from_bits(rs1_bits)?;
68                    Some(Self::LhAq { rd, rs1, rl })
69                }
70                (0b010, 0, true) => {
71                    let rd = Reg::from_bits(rd_bits)?;
72                    let rs1 = Reg::from_bits(rs1_bits)?;
73                    Some(Self::LwAq { rd, rs1, rl })
74                }
75                _ => None,
76            },
77            // Store-release, `rl` bit is mandatory and `rd` must be zero
78            (0b010_1111, 0b00111) => match (funct3, rd_bits, rl) {
79                (0b000, 0, true) => {
80                    let rs1 = Reg::from_bits(rs1_bits)?;
81                    let rs2 = Reg::from_bits(rs2_bits)?;
82                    Some(Self::SbRl { rs1, rs2, aq })
83                }
84                (0b001, 0, true) => {
85                    let rs1 = Reg::from_bits(rs1_bits)?;
86                    let rs2 = Reg::from_bits(rs2_bits)?;
87                    Some(Self::ShRl { rs1, rs2, aq })
88                }
89                (0b010, 0, true) => {
90                    let rs1 = Reg::from_bits(rs1_bits)?;
91                    let rs2 = Reg::from_bits(rs2_bits)?;
92                    Some(Self::SwRl { rs1, rs2, aq })
93                }
94                _ => None,
95            },
96            _ => None,
97        }
98    }
99
100    #[inline(always)]
101    fn size(&self) -> u8 {
102        size_of::<u32>() as u8
103    }
104}
105
106/// Format optional `rl` suffix for load-acquire display
107#[inline(always)]
108fn rl_suffix(rl: &bool) -> &'static str {
109    if *rl { ".aqrl" } else { ".aq" }
110}
111
112/// Format optional `aq` suffix for store-release display
113#[inline(always)]
114fn aq_suffix(aq: &bool) -> &'static str {
115    if *aq { ".aqrl" } else { ".rl" }
116}
117
118#[instruction]
119impl<Reg> fmt::Display for Rv32ZalasrInstruction<Reg>
120where
121    Reg: fmt::Display,
122{
123    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
124        match self {
125            Self::LbAq { rd, rs1, rl } => write!(f, "lb{} {rd}, ({rs1})", rl_suffix(rl)),
126            Self::LhAq { rd, rs1, rl } => write!(f, "lh{} {rd}, ({rs1})", rl_suffix(rl)),
127            Self::LwAq { rd, rs1, rl } => write!(f, "lw{} {rd}, ({rs1})", rl_suffix(rl)),
128            Self::SbRl { rs1, rs2, aq } => write!(f, "sb{} {rs2}, ({rs1})", aq_suffix(aq)),
129            Self::ShRl { rs1, rs2, aq } => write!(f, "sh{} {rs2}, ({rs1})", aq_suffix(aq)),
130            Self::SwRl { rs1, rs2, aq } => write!(f, "sw{} {rs2}, ({rs1})", aq_suffix(aq)),
131        }
132    }
133}
ab_riscv_primitives/instructions/rv32/zalasr.rs

ab_riscv_primitives/instructions/rv32/
zalasr.rs
