rmm: Assert constants at compile time

rmm/src/arch/aarch64.rs

@@ -103,27 +103,20 @@ impl Arch for AArch64Arch {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::AArch64Arch;
-    use crate::Arch;
+const _: () = {
+    assert!(AArch64Arch::PAGE_SIZE == 4096);
+    assert!(AArch64Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(AArch64Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(AArch64Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(AArch64Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(AArch64Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(AArch64Arch::PAGE_ENTRIES == 512);
+    assert!(AArch64Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(AArch64Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
 
-    #[test]
-    fn constants() {
-        assert_eq!(AArch64Arch::PAGE_SIZE, 4096);
-        assert_eq!(AArch64Arch::PAGE_OFFSET_MASK, 0xFFF);
-        assert_eq!(AArch64Arch::PAGE_ADDRESS_SHIFT, 48);
-        assert_eq!(AArch64Arch::PAGE_ADDRESS_SIZE, 0x0001_0000_0000_0000);
-        assert_eq!(AArch64Arch::PAGE_ADDRESS_MASK, 0x0000_FFFF_FFFF_F000);
-        assert_eq!(AArch64Arch::PAGE_ENTRY_SIZE, 8);
-        assert_eq!(AArch64Arch::PAGE_ENTRIES, 512);
-        assert_eq!(AArch64Arch::PAGE_ENTRY_MASK, 0x1FF);
-        assert_eq!(AArch64Arch::PAGE_NEGATIVE_MASK, 0xFFFF_0000_0000_0000);
+    assert!(AArch64Arch::ENTRY_ADDRESS_SIZE == 0x0000_0100_0000_0000);
+    assert!(AArch64Arch::ENTRY_ADDRESS_MASK == 0x0000_00FF_FFFF_FFFF);
+    assert!(AArch64Arch::ENTRY_FLAGS_MASK == 0xFFF0_0000_0000_0FFF);
 
-        assert_eq!(AArch64Arch::ENTRY_ADDRESS_SIZE, 0x0000_0100_0000_0000);
-        assert_eq!(AArch64Arch::ENTRY_ADDRESS_MASK, 0x0000_00FF_FFFF_FFFF);
-        assert_eq!(AArch64Arch::ENTRY_FLAGS_MASK, 0xFFF0_0000_0000_0FFF);
-
-        assert_eq!(AArch64Arch::PHYS_OFFSET, 0xFFFF_8000_0000_0000);
-    }
-}
+    assert!(AArch64Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};

rmm/src/arch/riscv64/sv39.rs

@@ -79,29 +79,29 @@ impl Arch for RiscV64Sv39Arch {
     }
 }
 
+const _: () = {
+    assert!(RiscV64Sv39Arch::PAGE_SIZE == 4096);
+    assert!(RiscV64Sv39Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_SHIFT == 39);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_SIZE == 0x0000_0080_0000_0000);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_MASK == 0x0000_007F_FFFF_F000);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRIES == 512);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(RiscV64Sv39Arch::PAGE_NEGATIVE_MASK == 0xFFFF_FF80_0000_0000);
+
+    assert!(RiscV64Sv39Arch::ENTRY_ADDRESS_SIZE == 0x0000_1000_0000_0000);
+    assert!(RiscV64Sv39Arch::ENTRY_ADDRESS_MASK == 0x0000_0FFF_FFFF_FFFF);
+    assert!(RiscV64Sv39Arch::ENTRY_FLAGS_MASK == 0xFFC0_0000_0000_03FF);
+
+    assert!(RiscV64Sv39Arch::PHYS_OFFSET == 0xFFFF_FFC0_0000_0000);
+};
+
 #[cfg(test)]
 mod tests {
     use super::RiscV64Sv39Arch;
     use crate::Arch;
 
-    #[test]
-    fn constants() {
-        assert_eq!(RiscV64Sv39Arch::PAGE_SIZE, 4096);
-        assert_eq!(RiscV64Sv39Arch::PAGE_OFFSET_MASK, 0xFFF);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ADDRESS_SHIFT, 39);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ADDRESS_SIZE, 0x0000_0080_0000_0000);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ADDRESS_MASK, 0x0000_007F_FFFF_F000);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ENTRY_SIZE, 8);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ENTRIES, 512);
-        assert_eq!(RiscV64Sv39Arch::PAGE_ENTRY_MASK, 0x1FF);
-        assert_eq!(RiscV64Sv39Arch::PAGE_NEGATIVE_MASK, 0xFFFF_FF80_0000_0000);
-
-        assert_eq!(RiscV64Sv39Arch::ENTRY_ADDRESS_SIZE, 0x0000_1000_0000_0000);
-        assert_eq!(RiscV64Sv39Arch::ENTRY_ADDRESS_MASK, 0x0000_0FFF_FFFF_FFFF);
-        assert_eq!(RiscV64Sv39Arch::ENTRY_FLAGS_MASK, 0xFFC0_0000_0000_03FF);
-
-        assert_eq!(RiscV64Sv39Arch::PHYS_OFFSET, 0xFFFF_FFC0_0000_0000);
-    }
     #[test]
     fn is_canonical() {
         use super::VirtualAddress;

rmm/src/arch/riscv64/sv48.rs

@@ -76,29 +76,29 @@ impl Arch for RiscV64Sv48Arch {
     }
 }
 
+const _: () = {
+    assert!(RiscV64Sv48Arch::PAGE_SIZE == 4096);
+    assert!(RiscV64Sv48Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRIES == 512);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(RiscV64Sv48Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
+
+    assert!(RiscV64Sv48Arch::ENTRY_ADDRESS_SIZE == 0x0000_1000_0000_0000);
+    assert!(RiscV64Sv48Arch::ENTRY_ADDRESS_MASK == 0x0000_0FFF_FFFF_FFFF);
+    assert!(RiscV64Sv48Arch::ENTRY_FLAGS_MASK == 0xFFC0_0000_0000_03FF);
+
+    assert!(RiscV64Sv48Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};
+
 #[cfg(test)]
 mod tests {
     use super::RiscV64Sv48Arch;
     use crate::Arch;
 
-    #[test]
-    fn constants() {
-        assert_eq!(RiscV64Sv48Arch::PAGE_SIZE, 4096);
-        assert_eq!(RiscV64Sv48Arch::PAGE_OFFSET_MASK, 0xFFF);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ADDRESS_SHIFT, 48);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ADDRESS_SIZE, 0x0001_0000_0000_0000);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ADDRESS_MASK, 0x0000_FFFF_FFFF_F000);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ENTRY_SIZE, 8);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ENTRIES, 512);
-        assert_eq!(RiscV64Sv48Arch::PAGE_ENTRY_MASK, 0x1FF);
-        assert_eq!(RiscV64Sv48Arch::PAGE_NEGATIVE_MASK, 0xFFFF_0000_0000_0000);
-
-        assert_eq!(RiscV64Sv48Arch::ENTRY_ADDRESS_SIZE, 0x0000_1000_0000_0000);
-        assert_eq!(RiscV64Sv48Arch::ENTRY_ADDRESS_MASK, 0x0000_0FFF_FFFF_FFFF);
-        assert_eq!(RiscV64Sv48Arch::ENTRY_FLAGS_MASK, 0xFFC0_0000_0000_03FF);
-
-        assert_eq!(RiscV64Sv48Arch::PHYS_OFFSET, 0xFFFF_8000_0000_0000);
-    }
     #[test]
     fn is_canonical() {
         use super::VirtualAddress;

rmm/src/arch/x86.rs

@@ -54,27 +54,20 @@ impl Arch for X86Arch {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::{VirtualAddress, X86Arch};
-    use crate::Arch;
+const _: () = {
+    assert!(X86Arch::PAGE_SIZE == 4096);
+    assert!(X86Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(X86Arch::PAGE_ADDRESS_SHIFT == 32);
+    assert!(X86Arch::PAGE_ADDRESS_SIZE == 0x0000_0001_0000_0000);
+    assert!(X86Arch::PAGE_ADDRESS_MASK == 0xFFFF_F000);
+    assert!(X86Arch::PAGE_ENTRY_SIZE == 4);
+    assert!(X86Arch::PAGE_ENTRIES == 1024);
+    assert!(X86Arch::PAGE_ENTRY_MASK == 0x3FF);
+    assert!(X86Arch::PAGE_NEGATIVE_MASK == 0x0000_0000_0000);
 
-    #[test]
-    fn constants() {
-        assert_eq!(X86Arch::PAGE_SIZE, 4096);
-        assert_eq!(X86Arch::PAGE_OFFSET_MASK, 0xFFF);
-        assert_eq!(X86Arch::PAGE_ADDRESS_SHIFT, 32);
-        assert_eq!(X86Arch::PAGE_ADDRESS_SIZE, 0x0000_0001_0000_0000);
-        assert_eq!(X86Arch::PAGE_ADDRESS_MASK, 0xFFFF_F000);
-        assert_eq!(X86Arch::PAGE_ENTRY_SIZE, 4);
-        assert_eq!(X86Arch::PAGE_ENTRIES, 1024);
-        assert_eq!(X86Arch::PAGE_ENTRY_MASK, 0x3FF);
-        assert_eq!(X86Arch::PAGE_NEGATIVE_MASK, 0x0000_0000_0000);
+    assert!(X86Arch::ENTRY_ADDRESS_SIZE == 0x0000_0000_0010_0000);
+    assert!(X86Arch::ENTRY_ADDRESS_MASK == 0x000F_FFFF);
+    assert!(X86Arch::ENTRY_FLAGS_MASK == 0x0000_0FFF);
 
-        assert_eq!(X86Arch::ENTRY_ADDRESS_SIZE, 0x0000_0000_0010_0000);
-        assert_eq!(X86Arch::ENTRY_ADDRESS_MASK, 0x000F_FFFF);
-        assert_eq!(X86Arch::ENTRY_FLAGS_MASK, 0x0000_0FFF);
-
-        assert_eq!(X86Arch::PHYS_OFFSET, 0x8000_0000);
-    }
-}
+    assert!(X86Arch::PHYS_OFFSET == 0x8000_0000);
+};

rmm/src/arch/x86_64.rs

@@ -63,29 +63,29 @@ impl Arch for X8664Arch {
     }
 }
 
+const _: () = {
+    assert!(X8664Arch::PAGE_SIZE == 4096);
+    assert!(X8664Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(X8664Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(X8664Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(X8664Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(X8664Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(X8664Arch::PAGE_ENTRIES == 512);
+    assert!(X8664Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(X8664Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
+
+    assert!(X8664Arch::ENTRY_ADDRESS_SIZE == 0x0000_0100_0000_0000);
+    assert!(X8664Arch::ENTRY_ADDRESS_MASK == 0x0000_00FF_FFFF_FFFF);
+    assert!(X8664Arch::ENTRY_FLAGS_MASK == 0xFFF0_0000_0000_0FFF);
+
+    assert!(X8664Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};
+
 #[cfg(test)]
 mod tests {
     use super::{VirtualAddress, X8664Arch};
     use crate::Arch;
 
-    #[test]
-    fn constants() {
-        assert_eq!(X8664Arch::PAGE_SIZE, 4096);
-        assert_eq!(X8664Arch::PAGE_OFFSET_MASK, 0xFFF);
-        assert_eq!(X8664Arch::PAGE_ADDRESS_SHIFT, 48);
-        assert_eq!(X8664Arch::PAGE_ADDRESS_SIZE, 0x0001_0000_0000_0000);
-        assert_eq!(X8664Arch::PAGE_ADDRESS_MASK, 0x0000_FFFF_FFFF_F000);
-        assert_eq!(X8664Arch::PAGE_ENTRY_SIZE, 8);
-        assert_eq!(X8664Arch::PAGE_ENTRIES, 512);
-        assert_eq!(X8664Arch::PAGE_ENTRY_MASK, 0x1FF);
-        assert_eq!(X8664Arch::PAGE_NEGATIVE_MASK, 0xFFFF_0000_0000_0000);
-
-        assert_eq!(X8664Arch::ENTRY_ADDRESS_SIZE, 0x0000_0100_0000_0000);
-        assert_eq!(X8664Arch::ENTRY_ADDRESS_MASK, 0x0000_00FF_FFFF_FFFF);
-        assert_eq!(X8664Arch::ENTRY_FLAGS_MASK, 0xFFF0_0000_0000_0FFF);
-
-        assert_eq!(X8664Arch::PHYS_OFFSET, 0xFFFF_8000_0000_0000);
-    }
     #[test]
     fn is_canonical() {
         fn yes(address: usize) {