debug: Add DebugAddressRegisterNumber

Author: mkroening

src/registers/debug.rs

@@ -49,6 +49,44 @@ debug_address_register_impl!(Dr1, "DR1");
 debug_address_register_impl!(Dr2, "DR2");
 debug_address_register_impl!(Dr3, "DR3");
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct DebugAddressRegisterNumber(u8);
+
+impl DebugAddressRegisterNumber {
+    pub const unsafe fn new_unchecked(n: u8) -> Self {
+        Self(n)
+    }
+
+    pub const fn new(n: u8) -> Option<Self> {
+        match n {
+            0..=3 => Some(Self(n as u8)),
+            _ => None,
+        }
+    }
+
+    pub const fn get(self) -> u8 {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TryFromIntError(());
+
+impl From<core::num::TryFromIntError> for TryFromIntError {
+    fn from(_: core::num::TryFromIntError) -> Self {
+        Self(())
+    }
+}
+
+impl TryFrom<u8> for DebugAddressRegisterNumber {
+    type Error = TryFromIntError;
+
+    fn try_from(n: u8) -> Result<Self, Self::Error> {
+        Self::new(n).ok_or(TryFromIntError(()))
+    }
+}
+
 /// Debug Status Register (DR6).
 ///
 /// Reports debug conditions from the last debug exception.
@@ -96,6 +134,18 @@ bitflags! {
     }
 }
 
+impl Dr6Flags {
+    pub const fn trap(n: DebugAddressRegisterNumber) -> Self {
+        match n.0 {
+            0 => Self::TRAP0,
+            1 => Self::TRAP1,
+            2 => Self::TRAP2,
+            3 => Self::TRAP3,
+            _ => unreachable!(),
+        }
+    }
+}
+
 impl Dr6 {
     /// Read the current set of DR6 flags.
     #[inline]
@@ -143,6 +193,28 @@ bitflags! {
     }
 }
 
+impl Dr7Flags {
+    pub const fn local_breakpoint_enable(n: DebugAddressRegisterNumber) -> Self {
+        match n.0 {
+            0 => Self::LOCAL_BREAKPOINT_0_ENABLE,
+            1 => Self::LOCAL_BREAKPOINT_1_ENABLE,
+            2 => Self::LOCAL_BREAKPOINT_2_ENABLE,
+            3 => Self::LOCAL_BREAKPOINT_3_ENABLE,
+            _ => unreachable!(),
+        }
+    }
+
+    pub const fn global_breakpoint_enable(n: DebugAddressRegisterNumber) -> Self {
+        match n.0 {
+            0 => Self::GLOBAL_BREAKPOINT_0_ENABLE,
+            1 => Self::GLOBAL_BREAKPOINT_1_ENABLE,
+            2 => Self::GLOBAL_BREAKPOINT_2_ENABLE,
+            3 => Self::GLOBAL_BREAKPOINT_3_ENABLE,
+            _ => unreachable!(),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[repr(u8)]
 pub enum HwBreakpointCondition {
@@ -153,8 +225,8 @@ pub enum HwBreakpointCondition {
 }
 
 impl HwBreakpointCondition {
-    const fn bit_position(n: u8) -> u8 {
-        16 + 4 * n
+    const fn bit_position(n: DebugAddressRegisterNumber) -> u8 {
+        16 + 4 * n.0
     }
 }
 
@@ -168,31 +240,26 @@ pub enum HwBreakpointSize {
 }
 
 impl HwBreakpointSize {
-    const fn bit_position(n: u8) -> u8 {
-        18 + 4 * n
+    pub const fn new(size: usize) -> Option<Self> {
+        match size {
+            1 => Some(Self::Length1B),
+            2 => Some(Self::Length2B),
+            8 => Some(Self::Length8B),
+            4 => Some(Self::Length4B),
+            _ => None,
+        }
     }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TryFromIntError(());
 
-impl From<core::num::TryFromIntError> for TryFromIntError {
-    fn from(_: core::num::TryFromIntError) -> Self {
-        Self(())
+    const fn bit_position(n: DebugAddressRegisterNumber) -> u8 {
+        18 + 4 * n.0
     }
 }
 
 impl TryFrom<usize> for HwBreakpointSize {
     type Error = TryFromIntError;
 
     fn try_from(size: usize) -> Result<Self, Self::Error> {
-        match size {
-            1 => Ok(Self::Length1B),
-            2 => Ok(Self::Length2B),
-            8 => Ok(Self::Length8B),
-            4 => Ok(Self::Length4B),
-            _ => Err(TryFromIntError(())),
-        }
+        Self::new(size).ok_or(TryFromIntError(()))
     }
 }
 
@@ -207,46 +274,6 @@ impl From<Dr7Flags> for Dr7Value {
     }
 }
 
-macro_rules! set_condition_impl {
-    ($f:ident, $n:expr) => {
-        #[inline]
-        pub const fn $f(&mut self, condition: HwBreakpointCondition) {
-            unsafe {
-                self.set_condition($n, condition);
-            }
-        }
-    };
-}
-
-macro_rules! get_condition_impl {
-    ($f:ident, $n:expr) => {
-        #[inline]
-        pub fn $f(&self) -> HwBreakpointCondition {
-            unsafe { self.get_condition($n) }
-        }
-    };
-}
-
-macro_rules! set_size_impl {
-    ($f:ident, $n:expr) => {
-        #[inline]
-        pub const fn $f(&mut self, size: HwBreakpointSize) {
-            unsafe {
-                self.set_size($n, size);
-            }
-        }
-    };
-}
-
-macro_rules! get_size_impl {
-    ($f:ident, $n:expr) => {
-        #[inline]
-        pub fn $f(&self) -> HwBreakpointSize {
-            unsafe { self.get_size($n) }
-        }
-    };
-}
-
 impl Dr7Value {
     const fn mask() -> u64 {
         let field_mask = (1 << 32) - (1 << 16);
@@ -291,67 +318,35 @@ impl Dr7Value {
         unsafe { mem::transmute(self.bits) }
     }
 
-    /// # Safety
-    ///
-    /// `n` must be in `0..=3`.
-    const unsafe fn set_condition(&mut self, n: u8, condition: HwBreakpointCondition) {
+    pub const fn set_condition(&mut self, n: DebugAddressRegisterNumber, condition: HwBreakpointCondition) {
         let pos = HwBreakpointCondition::bit_position(n);
         // Clear value
         self.bits &= !(0b11 << pos);
         // Insert value
         self.bits |= (condition as u64) << pos;
     }
 
-    set_condition_impl!(set_condition_0, 0);
-    set_condition_impl!(set_condition_1, 1);
-    set_condition_impl!(set_condition_2, 2);
-    set_condition_impl!(set_condition_3, 3);
-
-    /// # Safety
-    ///
-    /// `n` must be in `0..=3`.
-    unsafe fn get_condition(&self, n: u8) -> HwBreakpointCondition {
+    pub fn get_condition(&self, n: DebugAddressRegisterNumber) -> HwBreakpointCondition {
         let pos = HwBreakpointCondition::bit_position(n);
         let condition = (self.bits >> pos) & 0b11;
         // SAFETY: All two bit patterns are valid variants
         unsafe { mem::transmute(condition as u8) }
     }
 
-    get_condition_impl!(get_condition_0, 0);
-    get_condition_impl!(get_condition_1, 1);
-    get_condition_impl!(get_condition_2, 2);
-    get_condition_impl!(get_condition_3, 3);
-
-    /// # Safety
-    ///
-    /// `n` must be in `0..=3`.
-    const unsafe fn set_size(&mut self, n: u8, size: HwBreakpointSize) {
+    pub const fn set_size(&mut self, n: DebugAddressRegisterNumber, size: HwBreakpointSize) {
         let pos = HwBreakpointSize::bit_position(n);
         // Clear value
         self.bits &= !(0b11 << pos);
         // Insert value
         self.bits |= (size as u64) << pos;
     }
 
-    set_size_impl!(set_size_0, 0);
-    set_size_impl!(set_size_1, 1);
-    set_size_impl!(set_size_2, 2);
-    set_size_impl!(set_size_3, 3);
-
-    /// # Safety
-    ///
-    /// `n` must be in `0..=3`.
-    unsafe fn get_size(&self, n: u8) -> HwBreakpointSize {
+    pub fn get_size(&self, n: DebugAddressRegisterNumber) -> HwBreakpointSize {
         let pos = HwBreakpointSize::bit_position(n);
         let size = (self.bits >> pos) & 0b11;
         // SAFETY: All two bit patterns are valid variants
         unsafe { mem::transmute(size as u8) }
     }
-
-    get_size_impl!(get_size_0, 0);
-    get_size_impl!(get_size_1, 1);
-    get_size_impl!(get_size_2, 2);
-    get_size_impl!(get_size_3, 3);
 }
 
 /// Debug Control Register (DR7).