slightly clean up the code

src/elf.rs

@@ -30,7 +30,7 @@ pub struct Phdr {
     pub p_align: u32,
 }
 
-impl<'a> Elf<'a> {
+impl Elf<'_> {
     pub fn header(&self) -> Result<Header> {
         let (ident, rest) = self.content.split_bytes(16)?;
         if ident[..4] != *b"\x7fELF" {

src/emu.rs

@@ -3,7 +3,6 @@ use std::{
     fmt::{Debug, Display},
     io::Write,
     ops::{Index, IndexMut},
-    u32,
 };
 
 pub struct Memory {
@@ -22,20 +21,18 @@ impl Memory {
         }
     }
     pub fn slice(&self, addr: u32, len: u32) -> Result<&[u8], Status> {
-        Ok(self
-            .mem
+        self.mem
             .get((addr as usize)..)
             .ok_or(Status::InvalidMemoryAccess(addr))?
             .get(..(len as usize))
-            .ok_or(Status::InvalidMemoryAccess(addr))?)
+            .ok_or(Status::InvalidMemoryAccess(addr))
     }
     pub fn slice_mut(&mut self, addr: u32, len: u32) -> Result<&mut [u8], Status> {
-        Ok(self
-            .mem
+        self.mem
             .get_mut((addr as usize)..)
             .ok_or(Status::InvalidMemoryAccess(addr))?
             .get_mut(..(len as usize))
-            .ok_or(Status::InvalidMemoryAccess(addr))?)
+            .ok_or(Status::InvalidMemoryAccess(addr))
     }
 
     pub fn load_u8(&self, addr: u32) -> Result<u8, Status> {
@@ -48,21 +45,21 @@ impl Memory {
         Ok(u32::from_le_bytes(self.slice(addr, 4)?.try_into().unwrap()))
     }
     pub fn store_u8(&mut self, addr: u32, value: u8) -> Result<(), Status> {
-        Ok(self
-            .slice_mut(addr, 1)?
-            .copy_from_slice(&value.to_le_bytes()))
+        self.slice_mut(addr, 1)?
+            .copy_from_slice(&value.to_le_bytes());
+        Ok(())
     }
     pub fn store_u16(&mut self, addr: u32, value: u16) -> Result<(), Status> {
         self.check_align(addr, 2)?;
-        Ok(self
-            .slice_mut(addr, 2)?
-            .copy_from_slice(&value.to_le_bytes()))
+        self.slice_mut(addr, 2)?
+            .copy_from_slice(&value.to_le_bytes());
+        Ok(())
     }
     pub fn store_u32(&mut self, addr: u32, value: u32) -> Result<(), Status> {
         self.check_align(addr, 4)?;
-        Ok(self
-            .slice_mut(addr, 4)?
-            .copy_from_slice(&value.to_le_bytes()))
+        self.slice_mut(addr, 4)?
+            .copy_from_slice(&value.to_le_bytes());
+        Ok(())
     }
 }
 
@@ -313,17 +310,17 @@ impl Emulator {
             }
             Inst::Sw { offset, src, base } => {
                 let addr = self[base].wrapping_add(offset);
-                self.mem.store_u32(addr, self[src] as u32)?;
+                self.mem.store_u32(addr, self[src])?;
             }
             Inst::Addi { imm, dest, src1 } => {
-                self[dest] = self[src1].wrapping_add(imm as u32);
+                self[dest] = self[src1].wrapping_add(imm);
             }
             Inst::Slti { imm, dest, src1 } => {
                 let result = (self[src1] as i32) < (imm as i32);
                 self[dest] = result as u32;
             }
             Inst::Sltiu { imm, dest, src1 } => {
-                let result = (self[src1] as u32) < imm as u32;
+                let result = self[src1] < imm;
                 self[dest] = result as u32;
             }
             Inst::Andi { imm, dest, src1 } => {
@@ -377,7 +374,7 @@ impl Emulator {
             }
             Inst::Mulhsu { .. } => todo!("mulhsu"),
             Inst::Mulhu { dest, src1, src2 } => {
-                let shifted = ((self[src1] as u64).wrapping_mul(self[src2] as u64) as u64) >> 32;
+                let shifted = ((self[src1] as u64).wrapping_mul(self[src2] as u64)) >> 32;
                 self[dest] = shifted as u32;
             }
             Inst::Div { dest, src1, src2 } => {

src/inst.rs

@@ -396,12 +396,11 @@ impl Display for AmoOp {
 fn sign_extend(value: u32, size: u32) -> u32 {
     assert!(size <= u32::BITS);
     let sign = value >> (size - 1);
-    let imm = if sign == 1 {
+    if sign == 1 {
         (u32::MAX << size) | value
     } else {
         value
-    };
-    imm
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -487,7 +486,7 @@ impl InstCodeC {
             let value = self.extract(from.clone());
             imm |= value << to;
         }
-        imm as u32
+        imm
     }
     fn immediate_s(self, mappings: &[(RangeInclusive<u32>, u32)]) -> u32 {
         let mut imm = 0;
@@ -512,23 +511,23 @@ impl InstCodeC {
     }
     /// rd/rs1 (7..=11)
     fn rd(self) -> Reg {
-        Reg(self.extract(7..=11) as u32)
+        Reg(self.extract(7..=11))
     }
     /// rs2 (2..=6)
     fn rs2(self) -> Reg {
-        Reg(self.extract(2..=6) as u32)
+        Reg(self.extract(2..=6))
     }
     /// rs1' (7..=9)
     fn rs1_short(self) -> Reg {
         let smol_reg = self.extract(7..=9);
         // map to x8..=x15
-        Reg(smol_reg as u32 + 8)
+        Reg(smol_reg + 8)
     }
     /// rs2' (2..=4)
     fn rs2_short(self) -> Reg {
         let smol_reg = self.extract(2..=4);
         // map to x8..=x15
-        Reg(smol_reg as u32 + 8)
+        Reg(smol_reg + 8)
     }
 }