From a691731515eeae6846e99a6f4f38412be0ae8e8c Mon Sep 17 00:00:00 2001 From: Nicholas Bishop Date: Fri, 30 Dec 2022 16:20:38 -0500 Subject: [PATCH] Drop unstable `maybe_uninit_slice` and `vec_into_raw_parts` features The functionality we need from those features can be provided with a few pretty simple one-liner functions. Add those functions to the uefi crate in a new polyfill module. --- uefi/src/data_types/owned_strs.rs | 3 +- uefi/src/data_types/strs.rs | 3 +- uefi/src/lib.rs | 4 +- uefi/src/polyfill.rs | 29 +++++ uefi/src/proto/device_path/build.rs | 5 +- uefi/src/proto/device_path/device_path_gen.rs | 113 +++++++++--------- xtask/src/device_path/mod.rs | 1 + xtask/src/device_path/node.rs | 2 +- xtask/src/device_path/spec.rs | 4 +- 9 files changed, 99 insertions(+), 65 deletions(-) create mode 100644 uefi/src/polyfill.rs diff --git a/uefi/src/data_types/owned_strs.rs b/uefi/src/data_types/owned_strs.rs index 8c681da98..030ac9a4f 100644 --- a/uefi/src/data_types/owned_strs.rs +++ b/uefi/src/data_types/owned_strs.rs @@ -3,6 +3,7 @@ use super::strs::{CStr16, FromSliceWithNulError}; use crate::alloc::vec::Vec; use crate::data_types::strs::EqStrUntilNul; use crate::data_types::UnalignedSlice; +use crate::polyfill::vec_into_raw_parts; use core::fmt; use core::ops; @@ -92,7 +93,7 @@ impl TryFrom> for CString16 { // Safety: `Char16` is a transparent struct wrapping `u16`, so // the types are compatible. The pattern used here matches the // example in the docs for `into_raw_parts`. - let (ptr, len, cap) = input.into_raw_parts(); + let (ptr, len, cap) = vec_into_raw_parts(input); let rebuilt = unsafe { let ptr = ptr.cast::(); Vec::from_raw_parts(ptr, len, cap) diff --git a/uefi/src/data_types/strs.rs b/uefi/src/data_types/strs.rs index 9ba9d8f0f..68863f83c 100644 --- a/uefi/src/data_types/strs.rs +++ b/uefi/src/data_types/strs.rs @@ -1,5 +1,6 @@ use super::chars::{Char16, Char8, NUL_16, NUL_8}; use super::UnalignedSlice; +use crate::polyfill::maybe_uninit_slice_assume_init_ref; use core::ffi::CStr; use core::fmt; use core::iter::Iterator; @@ -300,7 +301,7 @@ impl CStr16 { src.copy_to_maybe_uninit(buf); let buf = unsafe { // Safety: `copy_buf` fully initializes the slice. - MaybeUninit::slice_assume_init_ref(buf) + maybe_uninit_slice_assume_init_ref(buf) }; CStr16::from_u16_with_nul(buf).map_err(|e| match e { FromSliceWithNulError::InvalidChar(v) => UnalignedCStr16Error::InvalidChar(v), diff --git a/uefi/src/lib.rs b/uefi/src/lib.rs index a8d30f4cf..b44e7b9ea 100644 --- a/uefi/src/lib.rs +++ b/uefi/src/lib.rs @@ -59,8 +59,6 @@ //! [unstable features]: https://doc.rust-lang.org/unstable-book/ #![feature(abi_efiapi)] -#![feature(maybe_uninit_slice)] -#![cfg_attr(feature = "alloc", feature(vec_into_raw_parts))] #![cfg_attr(feature = "unstable", feature(error_in_core))] #![cfg_attr(all(feature = "unstable", feature = "alloc"), feature(allocator_api))] #![cfg_attr(docsrs, feature(doc_auto_cfg))] @@ -105,3 +103,5 @@ pub mod logger; // As long as this is behind "alloc", we can simplify cfg-feature attributes in this module. #[cfg(feature = "alloc")] pub(crate) mod mem; + +pub(crate) mod polyfill; diff --git a/uefi/src/polyfill.rs b/uefi/src/polyfill.rs new file mode 100644 index 000000000..435481b24 --- /dev/null +++ b/uefi/src/polyfill.rs @@ -0,0 +1,29 @@ +//! Polyfills for functions in the standard library that are currently gated +//! behind unstable features. + +use core::mem::MaybeUninit; +#[cfg(feature = "alloc")] +use {alloc::vec::Vec, core::mem::ManuallyDrop}; + +/// Polyfill for the unstable `MaybeUninit::slice_assume_init_ref` function. +/// +/// See . +pub const unsafe fn maybe_uninit_slice_assume_init_ref(s: &[MaybeUninit]) -> &[T] { + unsafe { &*(s as *const [MaybeUninit] as *const [T]) } +} + +/// Polyfill for the unstable `MaybeUninit::slice_as_mut_ptr` function. +/// +/// See . +pub fn maybe_uninit_slice_as_mut_ptr(s: &mut [MaybeUninit]) -> *mut T { + s.as_mut_ptr().cast::() +} + +/// Polyfill for the unstable `Vec::into_raw_parts` function. +/// +/// See . +#[cfg(feature = "alloc")] +pub fn vec_into_raw_parts(v: Vec) -> (*mut T, usize, usize) { + let mut v = ManuallyDrop::new(v); + (v.as_mut_ptr(), v.len(), v.capacity()) +} diff --git a/uefi/src/proto/device_path/build.rs b/uefi/src/proto/device_path/build.rs index 4233380eb..71eada32f 100644 --- a/uefi/src/proto/device_path/build.rs +++ b/uefi/src/proto/device_path/build.rs @@ -7,6 +7,7 @@ pub use uefi::proto::device_path::device_path_gen::build::*; +use crate::polyfill::{maybe_uninit_slice_as_mut_ptr, maybe_uninit_slice_assume_init_ref}; use crate::proto::device_path::{DevicePath, DevicePathNode}; use core::mem::MaybeUninit; @@ -131,7 +132,7 @@ impl<'a> DevicePathBuilder<'a> { let data: &[u8] = match &this.storage { BuilderStorage::Buf { buf, offset } => unsafe { - MaybeUninit::slice_assume_init_ref(&buf[..*offset]) + maybe_uninit_slice_assume_init_ref(&buf[..*offset]) }, #[cfg(feature = "alloc")] BuilderStorage::Vec(vec) => vec, @@ -206,7 +207,7 @@ unsafe impl BuildNode for &DevicePathNode { fn write_data(&self, out: &mut [MaybeUninit]) { let src: *const u8 = self.as_ffi_ptr().cast(); - let dst: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let dst: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { dst.copy_from_nonoverlapping(src, out.len()); } diff --git a/uefi/src/proto/device_path/device_path_gen.rs b/uefi/src/proto/device_path/device_path_gen.rs index 0c74d5585..f94c2d954 100644 --- a/uefi/src/proto/device_path/device_path_gen.rs +++ b/uefi/src/proto/device_path/device_path_gen.rs @@ -6,6 +6,7 @@ // See `/xtask/src/device_path/README.md` for more details. use crate::data_types::UnalignedSlice; +use crate::polyfill::maybe_uninit_slice_as_mut_ptr; use crate::proto::device_path::{ DevicePathHeader, DevicePathNode, DeviceSubType, DeviceType, NodeConversionError, }; @@ -3333,7 +3334,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3359,7 +3360,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3393,7 +3394,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3429,7 +3430,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3465,7 +3466,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3507,7 +3508,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3546,7 +3547,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3583,7 +3584,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3627,7 +3628,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3682,7 +3683,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3730,7 +3731,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3762,7 +3763,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3824,7 +3825,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3866,7 +3867,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3904,7 +3905,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3943,7 +3944,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -3981,7 +3982,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4016,7 +4017,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4059,7 +4060,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4105,7 +4106,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4152,7 +4153,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4192,7 +4193,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4240,7 +4241,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4275,7 +4276,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4326,7 +4327,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4401,7 +4402,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4461,7 +4462,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4503,7 +4504,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4557,7 +4558,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4604,7 +4605,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4649,7 +4650,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4706,7 +4707,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4761,7 +4762,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4797,7 +4798,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4831,7 +4832,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4867,7 +4868,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4899,7 +4900,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4931,7 +4932,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4963,7 +4964,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -4997,7 +4998,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5035,7 +5036,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5071,7 +5072,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5109,7 +5110,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5151,7 +5152,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5206,12 +5207,12 @@ pub mod build { == crate::proto::device_path::messaging::RestServiceType::VENDOR ); let (guid_out, data_out) = out.split_at_mut(size_of::()); - let guid_out_ptr: *mut Guid = MaybeUninit::slice_as_mut_ptr(guid_out).cast(); + let guid_out_ptr: *mut Guid = maybe_uninit_slice_as_mut_ptr(guid_out).cast(); unsafe { guid_out_ptr.write_unaligned(src.vendor_guid); } - let data_out_ptr = MaybeUninit::slice_as_mut_ptr(data_out); + let data_out_ptr = maybe_uninit_slice_as_mut_ptr(data_out); unsafe { src.vendor_defined_data .as_ptr() @@ -5248,7 +5249,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5305,7 +5306,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5347,7 +5348,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5386,7 +5387,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5418,7 +5419,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5450,7 +5451,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5482,7 +5483,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5516,7 +5517,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5559,7 +5560,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() @@ -5639,7 +5640,7 @@ pub mod build { fn write_data(&self, out: &mut [MaybeUninit]) { let size = usize::from(self.size_in_bytes().unwrap()); assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr .cast::() diff --git a/xtask/src/device_path/mod.rs b/xtask/src/device_path/mod.rs index f3626c61c..b72319e70 100644 --- a/xtask/src/device_path/mod.rs +++ b/xtask/src/device_path/mod.rs @@ -23,6 +23,7 @@ fn gen_code_as_string(groups: &[NodeGroup]) -> Result { use bitflags::bitflags; use crate::data_types::UnalignedSlice; use crate::{guid, Guid}; + use crate::polyfill::maybe_uninit_slice_as_mut_ptr; use crate::proto::device_path::{ DevicePathHeader, DevicePathNode, DeviceSubType, DeviceType, NodeConversionError, diff --git a/xtask/src/device_path/node.rs b/xtask/src/device_path/node.rs index bc9cb1b93..9d0b97683 100644 --- a/xtask/src/device_path/node.rs +++ b/xtask/src/device_path/node.rs @@ -429,7 +429,7 @@ impl Node { // the length of `out` matches the node's size. assert_eq!(size, out.len()); - let out_ptr: *mut u8 = MaybeUninit::slice_as_mut_ptr(out); + let out_ptr: *mut u8 = maybe_uninit_slice_as_mut_ptr(out); unsafe { out_ptr.cast::().write_unaligned(DevicePathHeader { device_type: DeviceType::#device_type, diff --git a/xtask/src/device_path/spec.rs b/xtask/src/device_path/spec.rs index a1ec474d6..555700d4b 100644 --- a/xtask/src/device_path/spec.rs +++ b/xtask/src/device_path/spec.rs @@ -973,12 +973,12 @@ mod messaging { let (guid_out, data_out) = out.split_at_mut(size_of::()); - let guid_out_ptr: *mut Guid = MaybeUninit::slice_as_mut_ptr(guid_out).cast(); + let guid_out_ptr: *mut Guid = maybe_uninit_slice_as_mut_ptr(guid_out).cast(); unsafe { guid_out_ptr.write_unaligned(src.vendor_guid); } - let data_out_ptr = MaybeUninit::slice_as_mut_ptr(data_out); + let data_out_ptr = maybe_uninit_slice_as_mut_ptr(data_out); unsafe { src.vendor_defined_data .as_ptr()