Merge pull request #1498 from nicholasbishop/bishop-mem-cleanup

Use size_of/size_of_val/align_of/align_of_val from the prelude

Author: phip1611

uefi-raw/src/status.rs

@@ -98,7 +98,7 @@ pub enum Status: usize => {
 
 impl Status {
     /// Bit indicating that an UEFI status code is an error.
-    pub const ERROR_BIT: usize = 1 << (core::mem::size_of::<usize>() * 8 - 1);
+    pub const ERROR_BIT: usize = 1 << (usize::BITS - 1);
 
     /// Returns true if status code indicates success.
     #[inline]

uefi-raw/src/table/system.rs

@@ -4,7 +4,7 @@ use crate::table::configuration::ConfigurationTable;
 use crate::table::runtime::RuntimeServices;
 use crate::table::Header;
 use crate::{Char16, Handle};
-use core::{mem, ptr};
+use core::ptr;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[repr(C)]
@@ -44,7 +44,7 @@ impl Default for SystemTable {
         Self {
             header: Header {
                 signature: Self::SIGNATURE,
-                size: u32::try_from(mem::size_of::<Self>()).unwrap(),
+                size: u32::try_from(size_of::<Self>()).unwrap(),
                 ..Header::default()
             },
 

uefi-test-runner/examples/sierpinski.rs

@@ -6,7 +6,6 @@ extern crate alloc;
 
 use alloc::vec;
 use alloc::vec::Vec;
-use core::mem;
 use uefi::prelude::*;
 use uefi::proto::console::gop::{BltOp, BltPixel, BltRegion, GraphicsOutput};
 use uefi::proto::rng::Rng;
@@ -77,7 +76,7 @@ impl Buffer {
 
 /// Get a random `usize` value.
 fn get_random_usize(rng: &mut Rng) -> usize {
-    let mut buf = [0; mem::size_of::<usize>()];
+    let mut buf = [0; size_of::<usize>()];
     rng.get_rng(None, &mut buf).expect("get_rng failed");
     usize::from_le_bytes(buf)
 }

uefi-test-runner/src/boot/misc.rs

@@ -1,5 +1,4 @@
 use core::ffi::c_void;
-use core::mem;
 use core::ptr::{self, NonNull};
 
 use uefi::boot::{
@@ -121,13 +120,11 @@ fn test_register_protocol_notify() {
 fn test_install_protocol_interface() {
     info!("Installing TestProtocol");
 
-    let alloc: *mut TestProtocol = boot::allocate_pool(
-        MemoryType::BOOT_SERVICES_DATA,
-        mem::size_of::<TestProtocol>(),
-    )
-    .unwrap()
-    .cast()
-    .as_ptr();
+    let alloc: *mut TestProtocol =
+        boot::allocate_pool(MemoryType::BOOT_SERVICES_DATA, size_of::<TestProtocol>())
+            .unwrap()
+            .cast()
+            .as_ptr();
     unsafe { alloc.write(TestProtocol { data: 123 }) };
 
     let _ = unsafe {

uefi/src/boot.rs

@@ -277,7 +277,7 @@ pub(crate) fn get_memory_map(buf: &mut [u8]) -> Result<MemoryMapMeta> {
     let mut desc_version = 0;
 
     assert_eq!(
-        (map_buffer as usize) % mem::align_of::<MemoryDescriptor>(),
+        (map_buffer as usize) % align_of::<MemoryDescriptor>(),
         0,
         "Memory map buffers must be aligned like a MemoryDescriptor"
     );
@@ -793,11 +793,11 @@ pub fn locate_handle<'buf>(
         SearchType::ByProtocol(guid) => (2, ptr::from_ref(guid), ptr::null()),
     };
 
-    let mut buffer_size = buffer.len() * mem::size_of::<Handle>();
+    let mut buffer_size = buffer.len() * size_of::<Handle>();
     let status =
         unsafe { (bt.locate_handle)(ty, guid, key, &mut buffer_size, buffer.as_mut_ptr().cast()) };
 
-    let num_handles = buffer_size / mem::size_of::<Handle>();
+    let num_handles = buffer_size / size_of::<Handle>();
 
     match status {
         Status::SUCCESS => {

uefi/src/data_types/mod.rs

@@ -99,8 +99,8 @@ impl Event {
 /// Trait for querying the alignment of a struct.
 ///
 /// For a statically-sized type the alignment can be retrieved with
-/// [`core::mem::align_of`]. For a dynamically-sized type (DST),
-/// [`core::mem::align_of_val`] provides the alignment given a reference. But in
+/// [`align_of`]. For a dynamically-sized type (DST),
+/// [`align_of_val`] provides the alignment given a reference. But in
 /// some cases it's helpful to know the alignment of a DST prior to having a
 /// value, meaning there's no reference to pass to `align_of_val`. For example,
 /// when using an API that creates a value using a `[u8]` buffer, the alignment

uefi/src/mem/memory_map/impl_.rs

@@ -5,8 +5,8 @@ use super::*;
 use crate::boot;
 use core::fmt::{Debug, Display, Formatter};
 use core::ops::{Index, IndexMut};
+use core::ptr;
 use core::ptr::NonNull;
-use core::{mem, ptr};
 use uefi_raw::PhysicalAddress;
 
 /// Errors that may happen when constructing a [`MemoryMapRef`] or
@@ -283,7 +283,7 @@ impl MemoryMapBackingMemory {
 
         // Should be fine as UEFI always has  allocations with a guaranteed
         // alignment of 8 bytes.
-        assert_eq!(ptr.align_offset(mem::align_of::<MemoryDescriptor>()), 0);
+        assert_eq!(ptr.align_offset(align_of::<MemoryDescriptor>()), 0);
 
         // If this panics, the UEFI implementation is broken.
         assert_eq!(memory_map_meta.map_size % memory_map_meta.desc_size, 0);
@@ -292,7 +292,7 @@ impl MemoryMapBackingMemory {
     }
 
     unsafe fn from_raw(ptr: *mut u8, len: usize) -> Self {
-        assert_eq!(ptr.align_offset(mem::align_of::<MemoryDescriptor>()), 0);
+        assert_eq!(ptr.align_offset(align_of::<MemoryDescriptor>()), 0);
 
         let ptr = NonNull::new(ptr).expect("UEFI should never return a null ptr. An error should have been reflected via an Err earlier.");
         let slice = NonNull::slice_from_raw_parts(ptr, len);
@@ -366,7 +366,7 @@ impl MemoryMapOwned {
     /// (stored inside the provided buffer) and the corresponding
     /// [`MemoryMapMeta`].
     pub(crate) fn from_initialized_mem(buf: MemoryMapBackingMemory, meta: MemoryMapMeta) -> Self {
-        assert!(meta.desc_size >= mem::size_of::<MemoryDescriptor>());
+        assert!(meta.desc_size >= size_of::<MemoryDescriptor>());
         let len = meta.entry_count();
         Self { buf, meta, len }
     }
@@ -430,7 +430,7 @@ impl IndexMut<usize> for MemoryMapOwned {
 mod tests {
     use super::*;
     use alloc::vec::Vec;
-    use core::mem::size_of;
+    use size_of;
 
     const BASE_MMAP_UNSORTED: [MemoryDescriptor; 3] = [
         MemoryDescriptor {

uefi/src/mem/memory_map/mod.rs

@@ -41,11 +41,10 @@ pub use iter::*;
 pub use uefi_raw::table::boot::{MemoryAttribute, MemoryDescriptor, MemoryType};
 
 use crate::data_types::Align;
-use core::mem;
 
 impl Align for MemoryDescriptor {
     fn alignment() -> usize {
-        mem::align_of::<Self>()
+        align_of::<Self>()
     }
 }
 
@@ -90,7 +89,7 @@ impl MemoryMapMeta {
         // extended by a future UEFI revision by a significant amount, we
         // update the struct, but an old UEFI implementation reports a small
         // size.
-        assert!(self.desc_size >= mem::size_of::<MemoryDescriptor>());
+        assert!(self.desc_size >= size_of::<MemoryDescriptor>());
         assert!(self.map_size > 0);
 
         // Ensure the mmap size is (somehow) sane.
@@ -238,8 +237,8 @@ mod tests_mmap_artificial {
 mod tests_mmap_real {
     use super::*;
     use alloc::vec::Vec;
-    use core::mem::size_of;
     use core::slice;
+    use size_of;
 
     const MMAP_META: MemoryMapMeta = MemoryMapMeta {
         map_size: MMAP_RAW.len() * size_of::<u64>(),

uefi/src/proto/console/gop.rs

@@ -55,7 +55,6 @@ use crate::util::usize_from_u32;
 use crate::{boot, Result, StatusExt};
 use core::fmt::{Debug, Formatter};
 use core::marker::PhantomData;
-use core::mem;
 use core::ptr::{self, NonNull};
 use uefi_raw::protocol::console::{
     GraphicsOutputBltOperation, GraphicsOutputModeInformation, GraphicsOutputProtocol,
@@ -181,7 +180,7 @@ impl GraphicsOutput {
                             dest_y,
                             width,
                             height,
-                            px_stride * core::mem::size_of::<BltPixel>(),
+                            px_stride * size_of::<BltPixel>(),
                         )
                         .to_result(),
                     }
@@ -221,7 +220,7 @@ impl GraphicsOutput {
                             dest_y,
                             width,
                             height,
-                            px_stride * core::mem::size_of::<BltPixel>(),
+                            px_stride * size_of::<BltPixel>(),
                         )
                         .to_result(),
                     }
@@ -620,7 +619,7 @@ impl FrameBuffer<'_> {
     #[inline]
     pub unsafe fn write_value<T>(&mut self, index: usize, value: T) {
         debug_assert!(
-            index.saturating_add(mem::size_of::<T>()) <= self.size,
+            index.saturating_add(size_of::<T>()) <= self.size,
             "Frame buffer accessed out of bounds"
         );
         let ptr = self.base.add(index).cast::<T>();
@@ -643,7 +642,7 @@ impl FrameBuffer<'_> {
     #[must_use]
     pub unsafe fn read_value<T>(&self, index: usize) -> T {
         debug_assert!(
-            index.saturating_add(mem::size_of::<T>()) <= self.size,
+            index.saturating_add(size_of::<T>()) <= self.size,
             "Frame buffer accessed out of bounds"
         );
         (self.base.add(index) as *const T).read_volatile()

uefi/src/proto/device_path/build.rs

@@ -244,10 +244,10 @@ mod tests {
     use crate::proto::device_path::messaging::{
         Ipv4AddressOrigin, IscsiLoginOptions, IscsiProtocol, RestServiceAccessMode, RestServiceType,
     };
-    use core::{mem, slice};
+    use core::slice;
 
     fn path_to_bytes(path: &DevicePath) -> &[u8] {
-        unsafe { slice::from_raw_parts(path.as_ffi_ptr().cast::<u8>(), mem::size_of_val(path)) }
+        unsafe { slice::from_raw_parts(path.as_ffi_ptr().cast::<u8>(), size_of_val(path)) }
     }
 
     /// Test building an ACPI ADR node.