From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/bytemuck/src/internal.rs | 402 ---------------------------------------- 1 file changed, 402 deletions(-) delete mode 100644 vendor/bytemuck/src/internal.rs (limited to 'vendor/bytemuck/src/internal.rs') diff --git a/vendor/bytemuck/src/internal.rs b/vendor/bytemuck/src/internal.rs deleted file mode 100644 index 3ede50f..0000000 --- a/vendor/bytemuck/src/internal.rs +++ /dev/null @@ -1,402 +0,0 @@ -//! Internal implementation of casting functions not bound by marker traits -//! and therefore marked as unsafe. This is used so that we don't need to -//! duplicate the business logic contained in these functions between the -//! versions exported in the crate root, `checked`, and `relaxed` modules. -#![allow(unused_unsafe)] - -use crate::PodCastError; -use core::{marker::*, mem::*}; - -/* - -Note(Lokathor): We've switched all of the `unwrap` to `match` because there is -apparently a bug: https://github.com/rust-lang/rust/issues/68667 -and it doesn't seem to show up in simple godbolt examples but has been reported -as having an impact when there's a cast mixed in with other more complicated -code around it. Rustc/LLVM ends up missing that the `Err` can't ever happen for -particular type combinations, and then it doesn't fully eliminated the panic -possibility code branch. - -*/ - -/// Immediately panics. -#[cfg(not(target_arch = "spirv"))] -#[cold] -#[inline(never)] -pub(crate) fn something_went_wrong( - _src: &str, _err: D, -) -> ! { - // Note(Lokathor): Keeping the panic here makes the panic _formatting_ go - // here too, which helps assembly readability and also helps keep down - // the inline pressure. - panic!("{src}>{err}", src = _src, err = _err); -} - -/// Immediately panics. -#[cfg(target_arch = "spirv")] -#[cold] -#[inline(never)] -pub(crate) fn something_went_wrong(_src: &str, _err: D) -> ! { - // Note: On the spirv targets from [rust-gpu](https://github.com/EmbarkStudios/rust-gpu) - // panic formatting cannot be used. We we just give a generic error message - // The chance that the panicking version of these functions will ever get - // called on spir-v targets with invalid inputs is small, but giving a - // simple error message is better than no error message at all. - panic!("Called a panicing helper from bytemuck which paniced"); -} - -/// Re-interprets `&T` as `&[u8]`. -/// -/// Any ZST becomes an empty slice, and in that case the pointer value of that -/// empty slice might not match the pointer value of the input reference. -#[inline(always)] -pub(crate) unsafe fn bytes_of(t: &T) -> &[u8] { - if size_of::() == 0 { - &[] - } else { - match try_cast_slice::(core::slice::from_ref(t)) { - Ok(s) => s, - Err(_) => unreachable!(), - } - } -} - -/// Re-interprets `&mut T` as `&mut [u8]`. -/// -/// Any ZST becomes an empty slice, and in that case the pointer value of that -/// empty slice might not match the pointer value of the input reference. -#[inline] -pub(crate) unsafe fn bytes_of_mut(t: &mut T) -> &mut [u8] { - if size_of::() == 0 { - &mut [] - } else { - match try_cast_slice_mut::(core::slice::from_mut(t)) { - Ok(s) => s, - Err(_) => unreachable!(), - } - } -} - -/// Re-interprets `&[u8]` as `&T`. -/// -/// ## Panics -/// -/// This is [`try_from_bytes`] but will panic on error. -#[inline] -pub(crate) unsafe fn from_bytes(s: &[u8]) -> &T { - match try_from_bytes(s) { - Ok(t) => t, - Err(e) => something_went_wrong("from_bytes", e), - } -} - -/// Re-interprets `&mut [u8]` as `&mut T`. -/// -/// ## Panics -/// -/// This is [`try_from_bytes_mut`] but will panic on error. -#[inline] -pub(crate) unsafe fn from_bytes_mut(s: &mut [u8]) -> &mut T { - match try_from_bytes_mut(s) { - Ok(t) => t, - Err(e) => something_went_wrong("from_bytes_mut", e), - } -} - -/// Reads from the bytes as if they were a `T`. -/// -/// ## Failure -/// * If the `bytes` length is not equal to `size_of::()`. -#[inline] -pub(crate) unsafe fn try_pod_read_unaligned( - bytes: &[u8], -) -> Result { - if bytes.len() != size_of::() { - Err(PodCastError::SizeMismatch) - } else { - Ok(unsafe { (bytes.as_ptr() as *const T).read_unaligned() }) - } -} - -/// Reads the slice into a `T` value. -/// -/// ## Panics -/// * This is like `try_pod_read_unaligned` but will panic on failure. -#[inline] -pub(crate) unsafe fn pod_read_unaligned(bytes: &[u8]) -> T { - match try_pod_read_unaligned(bytes) { - Ok(t) => t, - Err(e) => something_went_wrong("pod_read_unaligned", e), - } -} - -/// Checks if `ptr` is aligned to an `align` memory boundary. -/// -/// ## Panics -/// * If `align` is not a power of two. This includes when `align` is zero. -#[inline] -pub(crate) fn is_aligned_to(ptr: *const (), align: usize) -> bool { - #[cfg(feature = "align_offset")] - { - // This is in a way better than `ptr as usize % align == 0`, - // because casting a pointer to an integer has the side effect that it - // exposes the pointer's provenance, which may theoretically inhibit - // some compiler optimizations. - ptr.align_offset(align) == 0 - } - #[cfg(not(feature = "align_offset"))] - { - ((ptr as usize) % align) == 0 - } -} - -/// Re-interprets `&[u8]` as `&T`. -/// -/// ## Failure -/// -/// * If the slice isn't aligned for the new type -/// * If the slice's length isn’t exactly the size of the new type -#[inline] -pub(crate) unsafe fn try_from_bytes( - s: &[u8], -) -> Result<&T, PodCastError> { - if s.len() != size_of::() { - Err(PodCastError::SizeMismatch) - } else if !is_aligned_to(s.as_ptr() as *const (), align_of::()) { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else { - Ok(unsafe { &*(s.as_ptr() as *const T) }) - } -} - -/// Re-interprets `&mut [u8]` as `&mut T`. -/// -/// ## Failure -/// -/// * If the slice isn't aligned for the new type -/// * If the slice's length isn’t exactly the size of the new type -#[inline] -pub(crate) unsafe fn try_from_bytes_mut( - s: &mut [u8], -) -> Result<&mut T, PodCastError> { - if s.len() != size_of::() { - Err(PodCastError::SizeMismatch) - } else if !is_aligned_to(s.as_ptr() as *const (), align_of::()) { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else { - Ok(unsafe { &mut *(s.as_mut_ptr() as *mut T) }) - } -} - -/// Cast `T` into `U` -/// -/// ## Panics -/// -/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch. -#[inline] -pub(crate) unsafe fn cast(a: A) -> B { - if size_of::() == size_of::() { - unsafe { transmute!(a) } - } else { - something_went_wrong("cast", PodCastError::SizeMismatch) - } -} - -/// Cast `&mut T` into `&mut U`. -/// -/// ## Panics -/// -/// This is [`try_cast_mut`] but will panic on error. -#[inline] -pub(crate) unsafe fn cast_mut(a: &mut A) -> &mut B { - if size_of::() == size_of::() && align_of::() >= align_of::() { - // Plz mr compiler, just notice that we can't ever hit Err in this case. - match try_cast_mut(a) { - Ok(b) => b, - Err(_) => unreachable!(), - } - } else { - match try_cast_mut(a) { - Ok(b) => b, - Err(e) => something_went_wrong("cast_mut", e), - } - } -} - -/// Cast `&T` into `&U`. -/// -/// ## Panics -/// -/// This is [`try_cast_ref`] but will panic on error. -#[inline] -pub(crate) unsafe fn cast_ref(a: &A) -> &B { - if size_of::() == size_of::() && align_of::() >= align_of::() { - // Plz mr compiler, just notice that we can't ever hit Err in this case. - match try_cast_ref(a) { - Ok(b) => b, - Err(_) => unreachable!(), - } - } else { - match try_cast_ref(a) { - Ok(b) => b, - Err(e) => something_went_wrong("cast_ref", e), - } - } -} - -/// Cast `&[A]` into `&[B]`. -/// -/// ## Panics -/// -/// This is [`try_cast_slice`] but will panic on error. -#[inline] -pub(crate) unsafe fn cast_slice(a: &[A]) -> &[B] { - match try_cast_slice(a) { - Ok(b) => b, - Err(e) => something_went_wrong("cast_slice", e), - } -} - -/// Cast `&mut [T]` into `&mut [U]`. -/// -/// ## Panics -/// -/// This is [`try_cast_slice_mut`] but will panic on error. -#[inline] -pub(crate) unsafe fn cast_slice_mut(a: &mut [A]) -> &mut [B] { - match try_cast_slice_mut(a) { - Ok(b) => b, - Err(e) => something_went_wrong("cast_slice_mut", e), - } -} - -/// Try to cast `T` into `U`. -/// -/// Note that for this particular type of cast, alignment isn't a factor. The -/// input value is semantically copied into the function and then returned to a -/// new memory location which will have whatever the required alignment of the -/// output type is. -/// -/// ## Failure -/// -/// * If the types don't have the same size this fails. -#[inline] -pub(crate) unsafe fn try_cast( - a: A, -) -> Result { - if size_of::() == size_of::() { - Ok(unsafe { transmute!(a) }) - } else { - Err(PodCastError::SizeMismatch) - } -} - -/// Try to convert a `&T` into `&U`. -/// -/// ## Failure -/// -/// * If the reference isn't aligned in the new type -/// * If the source type and target type aren't the same size. -#[inline] -pub(crate) unsafe fn try_cast_ref( - a: &A, -) -> Result<&B, PodCastError> { - // Note(Lokathor): everything with `align_of` and `size_of` will optimize away - // after monomorphization. - if align_of::() > align_of::() - && !is_aligned_to(a as *const A as *const (), align_of::()) - { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else if size_of::() == size_of::() { - Ok(unsafe { &*(a as *const A as *const B) }) - } else { - Err(PodCastError::SizeMismatch) - } -} - -/// Try to convert a `&mut T` into `&mut U`. -/// -/// As [`try_cast_ref`], but `mut`. -#[inline] -pub(crate) unsafe fn try_cast_mut( - a: &mut A, -) -> Result<&mut B, PodCastError> { - // Note(Lokathor): everything with `align_of` and `size_of` will optimize away - // after monomorphization. - if align_of::() > align_of::() - && !is_aligned_to(a as *const A as *const (), align_of::()) - { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else if size_of::() == size_of::() { - Ok(unsafe { &mut *(a as *mut A as *mut B) }) - } else { - Err(PodCastError::SizeMismatch) - } -} - -/// Try to convert `&[A]` into `&[B]` (possibly with a change in length). -/// -/// * `input.as_ptr() as usize == output.as_ptr() as usize` -/// * `input.len() * size_of::() == output.len() * size_of::()` -/// -/// ## Failure -/// -/// * If the target type has a greater alignment requirement and the input slice -/// isn't aligned. -/// * If the target element type is a different size from the current element -/// type, and the output slice wouldn't be a whole number of elements when -/// accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so -/// that's a failure). -/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) -/// and a non-ZST. -#[inline] -pub(crate) unsafe fn try_cast_slice( - a: &[A], -) -> Result<&[B], PodCastError> { - // Note(Lokathor): everything with `align_of` and `size_of` will optimize away - // after monomorphization. - if align_of::() > align_of::() - && !is_aligned_to(a.as_ptr() as *const (), align_of::()) - { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else if size_of::() == size_of::() { - Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, a.len()) }) - } else if size_of::() == 0 || size_of::() == 0 { - Err(PodCastError::SizeMismatch) - } else if core::mem::size_of_val(a) % size_of::() == 0 { - let new_len = core::mem::size_of_val(a) / size_of::(); - Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, new_len) }) - } else { - Err(PodCastError::OutputSliceWouldHaveSlop) - } -} - -/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in -/// length). -/// -/// As [`try_cast_slice`], but `&mut`. -#[inline] -pub(crate) unsafe fn try_cast_slice_mut( - a: &mut [A], -) -> Result<&mut [B], PodCastError> { - // Note(Lokathor): everything with `align_of` and `size_of` will optimize away - // after monomorphization. - if align_of::() > align_of::() - && !is_aligned_to(a.as_ptr() as *const (), align_of::()) - { - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - } else if size_of::() == size_of::() { - Ok(unsafe { - core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, a.len()) - }) - } else if size_of::() == 0 || size_of::() == 0 { - Err(PodCastError::SizeMismatch) - } else if core::mem::size_of_val(a) % size_of::() == 0 { - let new_len = core::mem::size_of_val(a) / size_of::(); - Ok(unsafe { - core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, new_len) - }) - } else { - Err(PodCastError::OutputSliceWouldHaveSlop) - } -} -- cgit v1.2.3