use crate::{optimization_barrier, volatile_write};
use core::slice;
const HAS_ASM: bool = cfg!(any(
target_arch = "aarch64",
target_arch = "arm",
target_arch = "arm64ec",
target_arch = "loongarch64",
target_arch = "riscv32",
target_arch = "riscv64",
target_arch = "s390x",
target_arch = "x86",
target_arch = "x86_64",
));
#[inline]
pub(crate) fn fill_slice<T: Copy>(dst: &mut [T], src: T) {
if size_of::<T>() == 0 {
return;
}
if HAS_ASM {
dst.fill(src);
optimization_barrier(dst);
} else {
volatile_fill_slice(dst, src);
}
}
#[inline]
pub(crate) unsafe fn zeroize_byte_ptr(dst: *mut u8, len: usize) {
if HAS_ASM {
unsafe {
core::ptr::write_bytes(dst, 0, len);
optimization_barrier(slice::from_raw_parts(dst, len));
}
} else {
use core::mem::MaybeUninit;
let bytes = unsafe { slice::from_raw_parts_mut(dst.cast::<MaybeUninit<u8>>(), len) };
volatile_fill_slice(bytes, MaybeUninit::new(0));
}
}
#[inline(always)]
fn volatile_fill_slice<T: Copy>(dst: &mut [T], src: T) {
match size_of::<T>() {
0 => {}
1 => volatile_fill_chunked::<_, 16>(dst, src),
2 => volatile_fill_chunked::<_, 8>(dst, src),
4 => volatile_fill_chunked::<_, 4>(dst, src),
8 => volatile_fill_chunked::<_, 2>(dst, src),
_ => volatile_fill_iterative(dst, src),
}
}
#[inline(always)]
fn volatile_fill_chunked<T: Copy, const N: usize>(dst: &mut [T], src: T) {
let (chunks, tail) = as_chunks_mut::<T, N>(dst);
if !chunks.is_empty() {
volatile_fill_iterative(chunks, [src; N]);
}
volatile_fill_iterative(tail, src);
}
#[inline(always)]
fn volatile_fill_iterative<T: Copy>(dst: &mut [T], src: T) {
for item in dst {
volatile_write(item, src);
}
}
#[inline]
#[track_caller]
#[must_use]
const fn as_chunks_mut<T, const N: usize>(slice: &mut [T]) -> (&mut [[T; N]], &mut [T]) {
assert!(N != 0, "chunk size must be non-zero");
let len_rounded_down = slice.len() / N * N;
let (multiple_of_n, remainder) = unsafe { slice.split_at_mut_unchecked(len_rounded_down) };
let array_slice = unsafe {
slice::from_raw_parts_mut(multiple_of_n.as_mut_ptr().cast(), multiple_of_n.len() / N)
};
(array_slice, remainder)
}