uefi: allocator: use match{} arms to separate cases

This prepares changes in upcoming commits.

Author: phip1611

uefi/src/allocator.rs

@@ -63,60 +63,70 @@ unsafe impl GlobalAlloc for Allocator {
         let align = layout.align();
         let memory_type = get_memory_type();
 
-        if align > 8 {
-            // The requested alignment is greater than 8, but `allocate_pool` is
-            // only guaranteed to provide eight-byte alignment. Allocate extra
-            // space so that we can return an appropriately-aligned pointer
-            // within the allocation.
-            let full_alloc_ptr = if let Ok(ptr) = boot::allocate_pool(memory_type, size + align) {
-                ptr.as_ptr()
-            } else {
-                return ptr::null_mut();
-            };
-
-            // Calculate the offset needed to get an aligned pointer within the
-            // full allocation. If that offset is zero, increase it to `align`
-            // so that we still have space to store the extra pointer described
-            // below.
-            let mut offset = full_alloc_ptr.align_offset(align);
-            if offset == 0 {
-                offset = align;
+        match align {
+            0..=8 /* UEFI default alignment */ => {
+                // The requested alignment is less than or equal to eight, and
+                // `allocate_pool` always provides eight-byte alignment, so we can
+                // use `allocate_pool` directly.
+                boot::allocate_pool(memory_type, size)
+                    .map(|ptr| ptr.as_ptr())
+                    .unwrap_or(ptr::null_mut())
             }
+            9.. => {
+                // The requested alignment is greater than 8, but `allocate_pool` is
+                // only guaranteed to provide eight-byte alignment. Allocate extra
+                // space so that we can return an appropriately-aligned pointer
+                // within the allocation.
+                let full_alloc_ptr = boot::allocate_pool(memory_type, size + align);
+                let full_alloc_ptr = if let Ok(ptr) = full_alloc_ptr
+                {
+                    ptr.as_ptr()
+                } else {
+                    return ptr::null_mut();
+                };
+
+                // Calculate the offset needed to get an aligned pointer within the
+                // full allocation. If that offset is zero, increase it to `align`
+                // so that we still have space to store the extra pointer described
+                // below.
+                let mut offset = full_alloc_ptr.align_offset(align);
+                if offset == 0 {
+                    offset = align;
+                }
 
-            // Before returning the aligned allocation, store a pointer to the
-            // full unaligned allocation in the bytes just before the aligned
-            // allocation. We know we have at least eight bytes there due to
-            // adding `align` to the memory allocation size. We also know the
-            // write is appropriately aligned for a `*mut u8` pointer because
-            // `align_ptr` is aligned, and alignments are always powers of two
-            // (as enforced by the `Layout` type).
-            unsafe {
-                let aligned_ptr = full_alloc_ptr.add(offset);
-                (aligned_ptr.cast::<*mut u8>()).sub(1).write(full_alloc_ptr);
-                aligned_ptr
+                // Before returning the aligned allocation, store a pointer to the
+                // full unaligned allocation in the bytes just before the aligned
+                // allocation. We know we have at least eight bytes there due to
+                // adding `align` to the memory allocation size. We also know the
+                // write is appropriately aligned for a `*mut u8` pointer because
+                // `align_ptr` is aligned, and alignments are always powers of two
+                // (as enforced by the `Layout` type).
+                unsafe {
+                    let aligned_ptr = full_alloc_ptr.add(offset);
+                    (aligned_ptr.cast::<*mut u8>()).sub(1).write(full_alloc_ptr);
+                    aligned_ptr
+                }
             }
-        } else {
-            // The requested alignment is less than or equal to eight, and
-            // `allocate_pool` always provides eight-byte alignment, so we can
-            // use `allocate_pool` directly.
-            boot::allocate_pool(memory_type, size)
-                .map(|ptr| ptr.as_ptr())
-                .unwrap_or(ptr::null_mut())
         }
     }
 
     /// Deallocate memory using [`boot::free_pool`].
-    unsafe fn dealloc(&self, mut ptr: *mut u8, layout: Layout) {
-        if layout.align() > 8 {
-            // Retrieve the pointer to the full allocation that was packed right
-            // before the aligned allocation in `alloc`.
-            ptr = unsafe { (ptr as *const *mut u8).sub(1).read() };
+    ///
+    /// This will panic after exiting boot services.
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        match layout.align() {
+            0..=8 => {
+                // OK to unwrap: `ptr` is required to be a valid allocation by the trait API.
+                let ptr = NonNull::new(ptr).unwrap();
+                unsafe { boot::free_pool(ptr) }.unwrap();
+            }
+            9.. => {
+                // Retrieve the pointer to the full allocation that was packed right
+                // before the aligned allocation in `alloc`.
+                let ptr = unsafe { (ptr as *const *mut u8).sub(1).read() };
+                let ptr = NonNull::new(ptr).unwrap();
+                unsafe { boot::free_pool(ptr) }.unwrap();
+            }
         }
-
-        // OK to unwrap: `ptr` is required to be a valid allocation by the trait API.
-        let ptr = NonNull::new(ptr).unwrap();
-
-        // Warning: this will panic after exiting boot services.
-        unsafe { boot::free_pool(ptr) }.unwrap();
     }
 }