Enum StackDirection

Source

pub enum StackDirection {
    Ascending = 1,
    Descending = 2,
}

Expand description

The direction into which stack grows as stack frames are made.

This is a target-specific property that can be obtained at runtime by calling StackDirection::new().

Variants§

§

Ascending = 1

§

Descending = 2

Implementations§

Source §

impl StackDirection

Source

pub fn new() -> StackDirection

Obtain the stack growth direction.

Examples found in repository ?

examples/info.rs (line 7)

        fn main() {
            println!("Stack is {:?} and is at {:p} currently",
                     psm::StackDirection::new(), psm::stack_pointer());
        }

More examples

Hide additional examples

examples/on_stack_fibo.rs (line 43)

        fn main() {
            let mut stack_size = 1024 * 128;
            unsafe {
                for &(n, expected) in FIB_COUNTS.iter() {
                    loop {
                        println!("fib({}) with {} bytes of stack", n, stack_size - STACK_REDLINE);
                        let layout = alloc::Layout::from_size_align(stack_size, STACK_ALIGN).unwrap();
                        let new_stack = alloc::alloc(layout);
                        assert!(!new_stack.is_null(), "allocations must succeed!");
                        let max_stack = match psm::StackDirection::new() {
                            psm::StackDirection::Ascending =>
                                new_stack.offset((stack_size - STACK_REDLINE) as isize),
                            psm::StackDirection::Descending =>
                                new_stack.offset(STACK_REDLINE as isize),
                        };
                        let result = psm::on_stack(new_stack, stack_size, || {
                            fib(n, max_stack)
                        });
                        alloc::dealloc(new_stack, layout);
                        if let Some(res) = result {
                            assert_eq!(res, expected);
                            println!("fib({}) = {}", n, res);
                            break;
                        } else {
                            println!("Stack not large enough!");
                            stack_size *= 2;
                        }
                    }
                }
            }
        }