Make most basic memory type functions const (theseus-os#973)

* The following functions in `memory_structs` are now `const`:
  * `is_canonical_virtual_address()`
  * `is_canonical_physical_address()`
  * `PageRange::from_virtual_address()`
  * `FrameRange::from_physical_address()`
  * `PageRange::contains_address()`
  * `FrameRange::contains_address()`
  
* Fix docs and implementation of `PageRange::address_at_offset()`
  and `FrameRange::address_at_offset()`

Author: kevinaboos

Cargo.lock

@@ -6,7 +6,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bit_field = "0.7.0"
 zerocopy = "0.5.0"
 derive_more = "0.99.0"
 paste = "1.0.5"

kernel/memory_structs/Cargo.toml

@@ -121,13 +121,23 @@ macro_rules! implement_address {
 
 #[cfg(target_arch = "x86_64")]
 mod canonical_address {
-    use bit_field::BitField;
+    const CANONICAL_VIRT_ADDR_MASK: usize = 0x0000_7FFF_FFFF_FFFF;
+    const CANONICAL_PHYS_ADDR_MASK: usize = 0x000F_FFFF_FFFF_FFFF;
 
+    /// Returns whether the given virtual address value is canonical.
+    ///
+    /// On x86_64, virtual addresses must have their 16 most-significant bits
+    /// be sign-extended from bit 47.
     #[inline]
-    pub fn is_canonical_virtual_address(virt_addr: usize) -> bool {
-        matches!(virt_addr.get_bits(47..64), 0 | 0b1_1111_1111_1111_1111)
+    pub const fn is_canonical_virtual_address(virt_addr: usize) -> bool {
+        let upper17 = virt_addr & !CANONICAL_VIRT_ADDR_MASK;
+        upper17 == 0 || upper17 == !CANONICAL_VIRT_ADDR_MASK
     }
 
+    /// Returns a canonicalized instance of the given virtual address value.
+    ///
+    /// On x86_64, virtual addresses must have their 16 most-significant bits
+    /// be sign-extended from bit 47.
     #[inline]
     pub const fn canonicalize_virtual_address(virt_addr: usize) -> usize {
         // match virt_addr.get_bit(47) {
@@ -139,57 +149,72 @@ mod canonical_address {
         ((virt_addr << 16) as isize >> 16) as usize
     }
 
+    /// Returns whether the given phyiscal address value is canonical.
+    ///
+    /// On x86_64, physical addresses are 52 bits long,
+    /// so their 12 most-significant bits must be cleared.
     #[inline]
-    pub fn is_canonical_physical_address(phys_addr: usize) -> bool {
-        matches!(phys_addr.get_bits(52..64), 0)
+    pub const fn is_canonical_physical_address(phys_addr: usize) -> bool {
+        phys_addr & !CANONICAL_PHYS_ADDR_MASK == 0
     }
 
+    /// Returns a canonicalized instance of the given phyiscal address value.
+    ///
+    /// On x86_64, physical addresses are 52 bits long,
+    /// so their 12 most-significant bits must be cleared.
     #[inline]
     pub const fn canonicalize_physical_address(phys_addr: usize) -> usize {
-        phys_addr & 0x000F_FFFF_FFFF_FFFF
+        phys_addr & CANONICAL_PHYS_ADDR_MASK
     }
 }
 
 #[cfg(target_arch = "aarch64")]
 mod canonical_address {
-    use bit_field::BitField;
-
-    /// On aarch64, VAs are composed of an ASID
-    /// which is 8 or 16 bits long depending
-    /// on MMU config. In Theseus, we use 8-bits
-    /// and the next 8 bits are unused.
-    /// Our ASID is zero, so a "canonical" VA has
-    /// the 16 most significant bits cleared.
+    const CANONICAL_VIRT_ADDR_MASK: usize = 0x0000_FFFF_FFFF_FFFF;
+    const CANONICAL_PHYS_ADDR_MASK: usize = 0x0000_FFFF_FFFF_FFFF;
+
+    /// Returns whether the given virtual address value is canonical.
+    ///
+    /// On aarch64, virtual addresses contain an address space ID (ASID),
+    /// which is 8 or 16 bits long, depending on MMU config.
+    ///
+    /// In Theseus, we use 8-bit ASIDs, with the next 8 bits are unused.
+    /// Theseus's ASID is zero, so a canonical virtual address has its
+    /// 16 most-significant bits cleared (set to zero).
     #[inline]
-    pub fn is_canonical_virtual_address(virt_addr: usize) -> bool {
-        matches!(virt_addr.get_bits(48..64), 0)
+    pub const fn is_canonical_virtual_address(virt_addr: usize) -> bool {
+        virt_addr & !CANONICAL_VIRT_ADDR_MASK == 0
     }
 
-    /// On aarch64, VAs are composed of an ASID
-    /// which is 8 or 16 bits long depending
-    /// on MMU config. In Theseus, we use 8-bits
-    /// and the next 8 bits are unused.
-    /// Our ASID is zero, so a "canonical" VA has
-    /// the 16 most significant bits cleared.
+    /// Returns a canonicalized instance of the given virtual address value.
+    ///
+    /// On aarch64, virtual addresses contain an address space ID (ASID),
+    /// which is 8 or 16 bits long, depending on MMU config.
+    ///
+    /// In Theseus, we use 8-bit ASIDs, with the next 8 bits are unused.
+    /// Theseus's ASID is zero, so a virtual address is canonicalized
+    /// by clearing (setting to zero) its 16 most-significant bits.
     #[inline]
     pub const fn canonicalize_virtual_address(virt_addr: usize) -> usize {
-        virt_addr & 0x0000_FFFF_FFFF_FFFF
+        virt_addr & CANONICAL_VIRT_ADDR_MASK
     }
 
-    /// On aarch64, we configure the MMU to use 48-bit
-    /// physical addresses; "canonical" physical addresses
-    /// have the 16 most significant bits cleared.
+    /// Returns whether the given physical address value is canonical.
+    ///
+    /// On aarch64, Theseus configures the MMU to use 48-bit physical addresses.
+    /// Thus, a canonical physical address has its 16 most-significant bits cleared.
     #[inline]
-    pub fn is_canonical_physical_address(phys_addr: usize) -> bool {
-        matches!(phys_addr.get_bits(48..64), 0)
+    pub const fn is_canonical_physical_address(phys_addr: usize) -> bool {
+        phys_addr & !CANONICAL_PHYS_ADDR_MASK == 0
     }
 
-    /// On aarch64, we configure the MMU to use 48-bit
-    /// physical addresses; "canonical" physical addresses
-    /// have the 16 most significant bits cleared.
+    /// Returns a canonicalized instance of the given physical address value.
+    ///
+    /// On aarch64, Theseus configures the MMU to use 48-bit physical addresses.
+    /// Thus, a physical address is canonicalized by clearing its 16 most-significant bits.
     #[inline]
     pub const fn canonicalize_physical_address(phys_addr: usize) -> usize {
-        phys_addr & 0x0000_FFFF_FFFF_FFFF
+        phys_addr & CANONICAL_PHYS_ADDR_MASK
     }
 }
 
@@ -355,13 +380,15 @@ macro_rules! implement_page_frame_range {
 
                 #[doc = "A convenience method for creating a new `" $TypeName "` that spans \
                     all [`" $chunk "`]s from the given [`" $address "`] to an end bound based on the given size."]
-                pub fn [<from_ $short _addr>](starting_addr: $address, size_in_bytes: usize) -> $TypeName {
+                pub const fn [<from_ $short _addr>](starting_addr: $address, size_in_bytes: usize) -> $TypeName {
                     if size_in_bytes == 0 {
                         $TypeName::empty()
                     } else {
                         let start = $chunk::containing_address(starting_addr);
                         // The end bound is inclusive, hence the -1. Parentheses are needed to avoid overflow.
-                        let end = $chunk::containing_address(starting_addr + (size_in_bytes - 1));
+                        let end = $chunk::containing_address(
+                            $address::new_canonical(starting_addr.value() + (size_in_bytes - 1))
+                        );
                         $TypeName::new(start, end)
                     }
                 }
@@ -385,16 +412,18 @@ macro_rules! implement_page_frame_range {
                 }
 
                 #[doc = "Returns `true` if this `" $TypeName "` contains the given [`" $address "`]."]
-                pub fn contains_address(&self, addr: $address) -> bool {
-                    self.0.contains(&$chunk::containing_address(addr))
+                pub const fn contains_address(&self, addr: $address) -> bool {
+                    let c = $chunk::containing_address(addr);
+                    self.0.start().number <= c.number
+                        && c.number <= self.0.end().number
                 }
 
                 #[doc = "Returns the offset of the given [`" $address "`] within this `" $TypeName "`, \
                     i.e., `addr - self.start_address()`.\n\n \
                     If the given `addr` is not covered by this range of [`" $chunk "`]s, this returns `None`.\n\n \
                     # Examples\n \
                     If the range covers addresses `0x2000` to `0x4000`, then `offset_of_address(0x3500)` would return `Some(0x1500)`."]
-                pub fn offset_of_address(&self, addr: $address) -> Option<usize> {
+                pub const fn offset_of_address(&self, addr: $address) -> Option<usize> {
                     if self.contains_address(addr) {
                         Some(addr.value() - self.start_address().value())
                     } else {
@@ -403,13 +432,14 @@ macro_rules! implement_page_frame_range {
                 }
 
                 #[doc = "Returns the [`" $address "`] at the given `offset` into this `" $TypeName "`within this `" $TypeName "`, \
-                    i.e., `addr - self.start_address()`.\n\n \
+                    i.e., `self.start_address() + offset`.\n\n \
                     If the given `offset` is not within this range of [`" $chunk "`]s, this returns `None`.\n\n \
                     # Examples\n \
-                    If the range covers addresses `0x2000` to `0x4000`, then `address_at_offset(0x1500)` would return `Some(0x3500)`."]
-                pub fn address_at_offset(&self, offset: usize) -> Option<$address> {
-                    if offset <= self.size_in_bytes() {
-                        Some(self.start_address() + offset)
+                    If the range covers addresses `0x2000` through `0x3FFF`, then `address_at_offset(0x1500)` would return `Some(0x3500)`, \
+                    and `address_at_offset(0x2000)` would return `None`."]
+                pub const fn address_at_offset(&self, offset: usize) -> Option<$address> {
+                    if offset < self.size_in_bytes() {
+                        Some($address::new_canonical(self.start_address().value() + offset))
                     }
                     else {
                         None