Function host_always_has_some_stack

tests/all/stack_overflow.rs:8–121

()

#[test]
fn host_always_has_some_stack() -> Result<()> {
    static HITS: AtomicUsize = AtomicUsize::new(0);
    // assume hosts always have at least 128k of stack
    const HOST_STACK: usize = 128 * 1024;

    let mut store = if cfg!(target_arch = "x86_64") {
        let mut config = Config::new();
        // Force cranelift-based libcalls to show up by ensuring that platform
        // support is turned off.
        unsafe {
            config.cranelift_flag_set("has_avx", "false");
            config.cranelift_flag_set("has_sse42", "false");
            config.cranelift_flag_set("has_sse41", "false");
            config.cranelift_flag_set("has_ssse3", "false");
            config.cranelift_flag_set("has_sse3", "false");
        }
        Store::new(&Engine::new(&config)?, ())
    } else {
        Store::<()>::default()
    };

    // Create a module that's infinitely recursive, but calls the host on each
    // level of wasm stack to always test how much host stack we have left.
    //
    // Each of the function exports of this module calls out to the host in a
    // different way, and each one is tested below to make sure that the way of
    // exiting out to the host is tested thoroughly.
    let module = Module::new(
        store.engine(),
        r#"
            (module
                (import "" "" (func $host1))
                (import "" "" (func $host2))

                ;; exit via wasm-to-native trampoline
                (func $recursive1 (export "f1")
                    call $host1
                    call $recursive1)

                ;; exit via wasm-to-array trampoline
                (func $recursive2 (export "f2")
                    call $host2
                    call $recursive2)

                ;; exit via a wasmtime-based libcall
                (memory 1)
                (func $recursive3 (export "f3")
                    (drop (memory.grow (i32.const 0)))
                    call $recursive3)

                ;; exit via a cranelift-based libcall
                (func $recursive4 (export "f4")
                    (drop (call $f32_ceil (f32.const 0)))
                    call $recursive4)
                (func $f32_ceil (param f32) (result f32)
                    (f32.ceil (local.get 0)))
            )
        "#,