Struct static_alloc::leaked::Alloca

pub struct Alloca<T> { /* fields omitted */ }

Zero-sized marker struct that allows running one or several methods.

This ensures that allocation does not exceed certain limits that would likely blow the stack and run into Rust's canary, this aborting the process.

Implementations

impl<T> Alloca<T>

pub fn new(len: usize) -> Option<Self>

Try to create a representation, that allows functions with dynamically stack-allocated slices.

pub fn run<R>(&self, run: impl FnOnce(&mut [MaybeUninit<T>]) -> R) -> R

Allocate a slice of elements.

Please note that instantiating this method relies on the optimizer, to an extent. In particular we will create stack slots of differing sizes depending on the internal size. This shouldn't have an effect other than moving the stack pointer for various amounts and should never have more than one T in overhead. However, we can't enforce this. In theory llvm might still reserve stack space for all variants including a probe and thus prematurely assume we have hit the bottom of the available stack space. This is not very likely to occur in practice.