wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/wasmtime-internal-cranelift-38.0.4/src/func_environ/stack_switching/instructions.rs

@@ -0,0 +1,1917 @@
+use cranelift_codegen::ir::BlockArg;
+use itertools::{Either, Itertools};
+
+use cranelift_codegen::ir::condcodes::*;
+use cranelift_codegen::ir::types::*;
+use cranelift_codegen::ir::{self, MemFlags};
+use cranelift_codegen::ir::{Block, BlockCall, InstBuilder, JumpTableData};
+use cranelift_frontend::FunctionBuilder;
+use wasmtime_environ::{PtrSize, TagIndex, TypeIndex, WasmResult, WasmValType, wasm_unsupported};
+
+fn control_context_size(triple: &target_lexicon::Triple) -> WasmResult<u8> {
+    match (triple.architecture, triple.operating_system) {
+        (target_lexicon::Architecture::X86_64, target_lexicon::OperatingSystem::Linux) => Ok(24),
+        _ => Err(wasm_unsupported!(
+            "stack switching not supported on {triple}"
+        )),
+    }
+}
+
+use super::control_effect::ControlEffect;
+use super::fatpointer;
+
+/// This module contains compile-time counterparts to types defined elsewhere.
+pub(crate) mod stack_switching_helpers {
+    use core::marker::PhantomData;
+    use cranelift_codegen::ir;
+    use cranelift_codegen::ir::InstBuilder;
+    use cranelift_codegen::ir::condcodes::IntCC;
+    use cranelift_codegen::ir::types::*;
+    use cranelift_codegen::ir::{StackSlot, StackSlotKind::*};
+    use cranelift_frontend::FunctionBuilder;
+    use wasmtime_environ::PtrSize;
+
+    /// Provides information about the layout of a type when it is used as an
+    /// element in a host array. This is used for `VMHostArrayRef`.
+    pub(crate) trait VMHostArrayEntry {
+        /// Returns `(align, size)` in bytes.
+        fn vmhostarray_entry_layout<P: wasmtime_environ::PtrSize>(p: &P) -> (u8, u32);
+    }
+
+    impl VMHostArrayEntry for u128 {
+        fn vmhostarray_entry_layout<P: wasmtime_environ::PtrSize>(_p: &P) -> (u8, u32) {
+            (16, 16)
+        }
+    }
+
+    impl<T> VMHostArrayEntry for *mut T {
+        fn vmhostarray_entry_layout<P: wasmtime_environ::PtrSize>(p: &P) -> (u8, u32) {
+            (p.size(), p.size().into())
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    pub struct VMContRef {
+        pub address: ir::Value,
+    }
+
+    #[derive(Copy, Clone)]
+    pub struct VMHostArrayRef<T> {
+        /// Address of the VMHostArray we are referencing
+        address: ir::Value,
+
+        /// The type parameter T is never used in the fields above. We still
+        /// want to have it for consistency with
+        /// `wasmtime_environ::Vector` and to use it in the associated
+        /// functions.
+        phantom: PhantomData<T>,
+    }
+
+    pub type VMPayloads = VMHostArrayRef<u128>;
+
+    // Actually a vector of *mut VMTagDefinition
+    pub type VMHandlerList = VMHostArrayRef<*mut u8>;
+
+    /// Compile-time representation of wasmtime_environ::VMStackChain,
+    /// consisting of two `ir::Value`s.
+    pub struct VMStackChain {
+        discriminant: ir::Value,
+        payload: ir::Value,
+    }
+
+    pub struct VMCommonStackInformation {
+        pub address: ir::Value,
+    }
+
+    /// Compile-time representation of `crate::runtime::vm::stack::VMContinuationStack`.
+    pub struct VMContinuationStack {
+        /// This is NOT the "top of stack" address of the stack itself. In line
+        /// with how the (runtime) `FiberStack` type works, this is a pointer to
+        /// the TOS address.
+        tos_ptr: ir::Value,
+    }
+
+    impl VMContRef {
+        pub fn new(address: ir::Value) -> VMContRef {
+            VMContRef { address }
+        }
+
+        pub fn args<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMPayloads {
+            let offset: i64 = env.offsets.ptr.vmcontref_args().into();
+            let address = builder.ins().iadd_imm(self.address, offset);
+            VMPayloads::new(address)
+        }
+
+        pub fn values<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMPayloads {
+            let offset: i64 = env.offsets.ptr.vmcontref_values().into();
+            let address = builder.ins().iadd_imm(self.address, offset);
+            VMPayloads::new(address)
+        }
+
+        pub fn common_stack_information<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMCommonStackInformation {
+            let offset: i64 = env.offsets.ptr.vmcontref_common_stack_information().into();
+            let address = builder.ins().iadd_imm(self.address, offset);
+            VMCommonStackInformation { address }
+        }
+
+        /// Stores the parent of this continuation, which may either be another
+        /// continuation or the initial stack. It is therefore represented as a
+        /// `VMStackChain` element.
+        pub fn set_parent_stack_chain<'a>(
+            &mut self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            new_stack_chain: &VMStackChain,
+        ) {
+            let offset = env.offsets.ptr.vmcontref_parent_chain().into();
+            new_stack_chain.store(env, builder, self.address, offset)
+        }
+
+        /// Loads the parent of this continuation, which may either be another
+        /// continuation or the initial stack. It is therefore represented as a
+        /// `VMStackChain` element.
+        pub fn get_parent_stack_chain<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMStackChain {
+            let offset = env.offsets.ptr.vmcontref_parent_chain().into();
+            VMStackChain::load(env, builder, self.address, offset, env.pointer_type())
+        }
+
+        pub fn set_last_ancestor<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            last_ancestor: ir::Value,
+        ) {
+            let offset: i32 = env.offsets.ptr.vmcontref_last_ancestor().into();
+            let mem_flags = ir::MemFlags::trusted();
+            builder
+                .ins()
+                .store(mem_flags, last_ancestor, self.address, offset);
+        }
+
+        pub fn get_last_ancestor<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let offset: i32 = env.offsets.ptr.vmcontref_last_ancestor().into();
+            let mem_flags = ir::MemFlags::trusted();
+            builder
+                .ins()
+                .load(env.pointer_type(), mem_flags, self.address, offset)
+        }
+
+        /// Gets the revision counter the a given continuation
+        /// reference.
+        pub fn get_revision<'a>(
+            &mut self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let mem_flags = ir::MemFlags::trusted();
+            let offset: i32 = env.offsets.ptr.vmcontref_revision().into();
+            let revision = builder.ins().load(I64, mem_flags, self.address, offset);
+            revision
+        }
+
+        /// Sets the revision counter on the given continuation
+        /// reference to `revision + 1`.
+
+        pub fn incr_revision<'a>(
+            &mut self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            revision: ir::Value,
+        ) -> ir::Value {
+            let mem_flags = ir::MemFlags::trusted();
+            let offset: i32 = env.offsets.ptr.vmcontref_revision().into();
+            let revision_plus1 = builder.ins().iadd_imm(revision, 1);
+            builder
+                .ins()
+                .store(mem_flags, revision_plus1, self.address, offset);
+            revision_plus1
+        }
+
+        pub fn get_fiber_stack<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMContinuationStack {
+            // The top of stack field is stored at offset 0 of the `FiberStack`.
+            let offset: i64 = env.offsets.ptr.vmcontref_stack().into();
+            let fiber_stack_top_of_stack_ptr = builder.ins().iadd_imm(self.address, offset);
+            VMContinuationStack::new(fiber_stack_top_of_stack_ptr)
+        }
+    }
+
+    impl<T: VMHostArrayEntry> VMHostArrayRef<T> {
+        pub(crate) fn new(address: ir::Value) -> Self {
+            Self {
+                address,
+                phantom: PhantomData::default(),
+            }
+        }
+
+        fn get(&self, builder: &mut FunctionBuilder, ty: ir::Type, offset: i32) -> ir::Value {
+            let mem_flags = ir::MemFlags::trusted();
+            builder.ins().load(ty, mem_flags, self.address, offset)
+        }
+
+        fn set<U>(&self, builder: &mut FunctionBuilder, offset: i32, value: ir::Value) {
+            debug_assert_eq!(
+                builder.func.dfg.value_type(value),
+                Type::int_with_byte_size(u16::try_from(core::mem::size_of::<U>()).unwrap())
+                    .unwrap()
+            );
+            let mem_flags = ir::MemFlags::trusted();
+            builder.ins().store(mem_flags, value, self.address, offset);
+        }
+
+        pub fn get_data<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let offset = env.offsets.ptr.vmhostarray_data().into();
+            self.get(builder, env.pointer_type(), offset)
+        }
+
+        pub fn get_length<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            // Array length is stored as u32.
+            let offset = env.offsets.ptr.vmhostarray_length().into();
+            self.get(builder, I32, offset)
+        }
+
+        fn set_length<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            length: ir::Value,
+        ) {
+            // Array length is stored as u32.
+            let offset = env.offsets.ptr.vmhostarray_length().into();
+            self.set::<u32>(builder, offset, length);
+        }
+
+        fn set_capacity<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            capacity: ir::Value,
+        ) {
+            // Array capacity is stored as u32.
+            let offset = env.offsets.ptr.vmhostarray_capacity().into();
+            self.set::<u32>(builder, offset, capacity);
+        }
+
+        fn set_data<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            data: ir::Value,
+        ) {
+            debug_assert_eq!(builder.func.dfg.value_type(data), env.pointer_type());
+            let offset: i32 = env.offsets.ptr.vmhostarray_data().into();
+            let mem_flags = ir::MemFlags::trusted();
+            builder.ins().store(mem_flags, data, self.address, offset);
+        }
+
+        /// Returns pointer to next empty slot in data buffer and marks the
+        /// subsequent `arg_count` slots as occupied.
+        pub fn occupy_next_slots<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            arg_count: i32,
+        ) -> ir::Value {
+            let data = self.get_data(env, builder);
+            let original_length = self.get_length(env, builder);
+            let new_length = builder
+                .ins()
+                .iadd_imm(original_length, i64::from(arg_count));
+            self.set_length(env, builder, new_length);
+
+            let (_align, entry_size) = T::vmhostarray_entry_layout(&env.offsets.ptr);
+            let original_length = builder.ins().uextend(I64, original_length);
+            let byte_offset = builder
+                .ins()
+                .imul_imm(original_length, i64::from(entry_size));
+            builder.ins().iadd(data, byte_offset)
+        }
+
+        pub fn allocate_or_reuse_stack_slot<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            required_capacity: u32,
+            existing_slot: Option<StackSlot>,
+        ) -> StackSlot {
+            let (align, entry_size) = T::vmhostarray_entry_layout(&env.offsets.ptr);
+            let required_size = required_capacity * entry_size;
+
+            match existing_slot {
+                Some(slot) if builder.func.sized_stack_slots[slot].size >= required_size => {
+                    let slot_data = &builder.func.sized_stack_slots[slot];
+                    debug_assert!(align <= slot_data.align_shift);
+                    debug_assert_eq!(slot_data.kind, ExplicitSlot);
+                    let existing_capacity = slot_data.size / entry_size;
+
+                    let capacity_value = builder.ins().iconst(I32, i64::from(existing_capacity));
+                    let existing_data = builder.ins().stack_addr(env.pointer_type(), slot, 0);
+
+                    self.set_capacity(env, builder, capacity_value);
+                    self.set_data(env, builder, existing_data);
+
+                    slot
+                }
+                _ => {
+                    let capacity_value = builder.ins().iconst(I32, i64::from(required_capacity));
+                    let slot_size = ir::StackSlotData::new(
+                        ir::StackSlotKind::ExplicitSlot,
+                        required_size,
+                        align,
+                    );
+                    let slot = builder.create_sized_stack_slot(slot_size);
+                    let new_data = builder.ins().stack_addr(env.pointer_type(), slot, 0);
+
+                    self.set_capacity(env, builder, capacity_value);
+                    self.set_data(env, builder, new_data);
+
+                    slot
+                }
+            }
+        }
+
+        /// Loads n entries from this Vector object, where n is the length of
+        /// `load_types`, which also gives the types of the values to load.
+        /// Loading starts at index 0 of the Vector object.
+        pub fn load_data_entries<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            load_types: &[ir::Type],
+        ) -> Vec<ir::Value> {
+            let memflags = ir::MemFlags::trusted();
+
+            let data_start_pointer = self.get_data(env, builder);
+            let mut values = vec![];
+            let mut offset = 0;
+            let (_align, entry_size) = T::vmhostarray_entry_layout(&env.offsets.ptr);
+            for valtype in load_types {
+                let val = builder
+                    .ins()
+                    .load(*valtype, memflags, data_start_pointer, offset);
+                values.push(val);
+                offset += i32::try_from(entry_size).unwrap();
+            }
+            values
+        }
+
+        /// Stores the given `values` in this Vector object, beginning at
+        /// index 0. This expects the Vector object to be empty (i.e., current
+        /// length is 0), and to be of sufficient capacity to store |`values`|
+        /// entries.
+        pub fn store_data_entries<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            values: &[ir::Value],
+        ) {
+            let store_count = builder
+                .ins()
+                .iconst(I32, i64::try_from(values.len()).unwrap());
+
+            let (_align, entry_size) = T::vmhostarray_entry_layout(&env.offsets.ptr);
+
+            debug_assert!(values.iter().all(|val| {
+                let ty = builder.func.dfg.value_type(*val);
+                let size = ty.bytes();
+                size <= entry_size
+            }));
+
+            let memflags = ir::MemFlags::trusted();
+
+            let data_start_pointer = self.get_data(env, builder);
+
+            let mut offset = 0;
+            for value in values {
+                builder
+                    .ins()
+                    .store(memflags, *value, data_start_pointer, offset);
+                offset += i32::try_from(entry_size).unwrap();
+            }
+
+            self.set_length(env, builder, store_count);
+        }
+
+        pub fn clear<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            discard_buffer: bool,
+        ) {
+            let zero32 = builder.ins().iconst(I32, 0);
+            self.set_length(env, builder, zero32);
+
+            if discard_buffer {
+                let zero32 = builder.ins().iconst(I32, 0);
+                self.set_capacity(env, builder, zero32);
+
+                let zero_ptr = builder.ins().iconst(env.pointer_type(), 0);
+                self.set_data(env, builder, zero_ptr);
+            }
+        }
+    }
+
+    impl VMStackChain {
+        /// Creates a `Self` corresponding to `VMStackChain::Continuation(contref)`.
+        pub fn from_continuation<'a>(
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            contref: ir::Value,
+        ) -> VMStackChain {
+            debug_assert_eq!(
+                env.offsets.ptr.size_of_vmstack_chain(),
+                2 * env.offsets.ptr.size()
+            );
+            let discriminant = wasmtime_environ::STACK_CHAIN_CONTINUATION_DISCRIMINANT;
+            let discriminant = builder
+                .ins()
+                .iconst(env.pointer_type(), i64::try_from(discriminant).unwrap());
+            VMStackChain {
+                discriminant,
+                payload: contref,
+            }
+        }
+
+        /// Creates a `Self` corresponding to `VMStackChain::Absent`.
+        pub fn absent<'a>(
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMStackChain {
+            debug_assert_eq!(
+                env.offsets.ptr.size_of_vmstack_chain(),
+                2 * env.offsets.ptr.size()
+            );
+            let discriminant = wasmtime_environ::STACK_CHAIN_ABSENT_DISCRIMINANT;
+            let discriminant = builder
+                .ins()
+                .iconst(env.pointer_type(), i64::try_from(discriminant).unwrap());
+            let zero_filler = builder.ins().iconst(env.pointer_type(), 0i64);
+            VMStackChain {
+                discriminant,
+                payload: zero_filler,
+            }
+        }
+
+        pub fn is_initial_stack<'a>(
+            &self,
+            _env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            builder.ins().icmp_imm(
+                IntCC::Equal,
+                self.discriminant,
+                i64::try_from(wasmtime_environ::STACK_CHAIN_INITIAL_STACK_DISCRIMINANT).unwrap(),
+            )
+        }
+
+        /// Return the two raw `ir::Value`s that represent this VMStackChain.
+        pub fn to_raw_parts(&self) -> [ir::Value; 2] {
+            [self.discriminant, self.payload]
+        }
+
+        /// Construct a `Self` from two raw `ir::Value`s.
+        pub fn from_raw_parts(raw_data: [ir::Value; 2]) -> VMStackChain {
+            VMStackChain {
+                discriminant: raw_data[0],
+                payload: raw_data[1],
+            }
+        }
+
+        /// Load a `VMStackChain` object from the given address.
+        pub fn load<'a>(
+            _env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            pointer: ir::Value,
+            initial_offset: i32,
+            pointer_type: ir::Type,
+        ) -> VMStackChain {
+            let memflags = ir::MemFlags::trusted();
+            let mut offset = initial_offset;
+            let mut data = vec![];
+            for _ in 0..2 {
+                data.push(builder.ins().load(pointer_type, memflags, pointer, offset));
+                offset += i32::try_from(pointer_type.bytes()).unwrap();
+            }
+            let data = <[ir::Value; 2]>::try_from(data).unwrap();
+            Self::from_raw_parts(data)
+        }
+
+        /// Store this `VMStackChain` object at the given address.
+        pub fn store<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            target_pointer: ir::Value,
+            initial_offset: i32,
+        ) {
+            let memflags = ir::MemFlags::trusted();
+            let mut offset = initial_offset;
+            let data = self.to_raw_parts();
+
+            for value in data {
+                debug_assert_eq!(builder.func.dfg.value_type(value), env.pointer_type());
+                builder.ins().store(memflags, value, target_pointer, offset);
+                offset += i32::try_from(env.pointer_type().bytes()).unwrap();
+            }
+        }
+
+        /// Use this only if you've already checked that `self` corresponds to a `VMStackChain::Continuation`.
+        pub fn unchecked_get_continuation(&self) -> ir::Value {
+            self.payload
+        }
+
+        /// Must only be called if `self` represents a `InitialStack` or
+        /// `Continuation` variant. Returns a pointer to the associated
+        /// `CommonStackInformation` object.
+        pub fn get_common_stack_information<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            _builder: &mut FunctionBuilder,
+        ) -> VMCommonStackInformation {
+            // `self` corresponds to a VMStackChain::InitialStack or
+            // VMStackChain::Continuation.
+            // In both cases, the payload is a pointer.
+            let address = self.payload;
+
+            // `obj` is now a pointer to the beginning of either
+            // 1. A `VMContRef` struct (in the case of a
+            // VMStackChain::Continuation)
+            // 2. A CommonStackInformation struct (in the case of
+            // VMStackChain::InitialStack)
+            //
+            // Since a `VMContRef` starts with an (inlined) CommonStackInformation
+            // object at offset 0, we actually have in both cases that `ptr` is
+            // now the address of the beginning of a VMStackLimits object.
+            debug_assert_eq!(env.offsets.ptr.vmcontref_common_stack_information(), 0);
+            VMCommonStackInformation { address }
+        }
+    }
+
+    impl VMCommonStackInformation {
+        fn get_state_ptr<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let offset: i64 = env.offsets.ptr.vmcommon_stack_information_state().into();
+
+            builder.ins().iadd_imm(self.address, offset)
+        }
+
+        fn get_stack_limits_ptr<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let offset: i64 = env.offsets.ptr.vmcommon_stack_information_limits().into();
+
+            builder.ins().iadd_imm(self.address, offset)
+        }
+
+        fn load_state<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let mem_flags = ir::MemFlags::trusted();
+            let state_ptr = self.get_state_ptr(env, builder);
+
+            builder.ins().load(I32, mem_flags, state_ptr, 0)
+        }
+
+        fn set_state_no_payload<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            discriminant: u32,
+        ) {
+            let discriminant = builder.ins().iconst(I32, i64::from(discriminant));
+            let mem_flags = ir::MemFlags::trusted();
+            let state_ptr = self.get_state_ptr(env, builder);
+
+            builder.ins().store(mem_flags, discriminant, state_ptr, 0);
+        }
+
+        pub fn set_state_running<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) {
+            let discriminant = wasmtime_environ::STACK_STATE_RUNNING_DISCRIMINANT;
+            self.set_state_no_payload(env, builder, discriminant);
+        }
+
+        pub fn set_state_parent<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) {
+            let discriminant = wasmtime_environ::STACK_STATE_PARENT_DISCRIMINANT;
+            self.set_state_no_payload(env, builder, discriminant);
+        }
+
+        pub fn set_state_returned<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) {
+            let discriminant = wasmtime_environ::STACK_STATE_RETURNED_DISCRIMINANT;
+            self.set_state_no_payload(env, builder, discriminant);
+        }
+
+        pub fn set_state_suspended<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) {
+            let discriminant = wasmtime_environ::STACK_STATE_SUSPENDED_DISCRIMINANT;
+            self.set_state_no_payload(env, builder, discriminant);
+        }
+
+        /// Checks whether the `VMStackState` reflects that the stack has ever been
+        /// active (instead of just having been allocated, but never resumed).
+        pub fn was_invoked<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let actual_state = self.load_state(env, builder);
+            let allocated = wasmtime_environ::STACK_STATE_FRESH_DISCRIMINANT;
+            builder
+                .ins()
+                .icmp_imm(IntCC::NotEqual, actual_state, i64::from(allocated))
+        }
+
+        pub fn get_handler_list<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> VMHandlerList {
+            let offset: i64 = env.offsets.ptr.vmcommon_stack_information_handlers().into();
+            let address = builder.ins().iadd_imm(self.address, offset);
+            VMHandlerList::new(address)
+        }
+
+        pub fn get_first_switch_handler_index<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            // Field first_switch_handler_index has type u32
+            let memflags = ir::MemFlags::trusted();
+            let offset: i32 = env
+                .offsets
+                .ptr
+                .vmcommon_stack_information_first_switch_handler_index()
+                .into();
+            builder.ins().load(I32, memflags, self.address, offset)
+        }
+
+        pub fn set_first_switch_handler_index<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            value: ir::Value,
+        ) {
+            // Field first_switch_handler_index has type u32
+            let memflags = ir::MemFlags::trusted();
+            let offset: i32 = env
+                .offsets
+                .ptr
+                .vmcommon_stack_information_first_switch_handler_index()
+                .into();
+            builder.ins().store(memflags, value, self.address, offset);
+        }
+
+        /// Sets `last_wasm_entry_sp` and `stack_limit` fields in
+        /// `VMRuntimelimits` using the values from the `VMStackLimits` of this
+        /// object.
+        pub fn write_limits_to_vmcontext<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            vmruntime_limits_ptr: ir::Value,
+        ) {
+            let stack_limits_ptr = self.get_stack_limits_ptr(env, builder);
+
+            let memflags = ir::MemFlags::trusted();
+
+            let mut copy_to_vm_runtime_limits = |our_offset, their_offset| {
+                let our_value = builder.ins().load(
+                    env.pointer_type(),
+                    memflags,
+                    stack_limits_ptr,
+                    i32::from(our_offset),
+                );
+                builder.ins().store(
+                    memflags,
+                    our_value,
+                    vmruntime_limits_ptr,
+                    i32::from(their_offset),
+                );
+            };
+
+            let pointer_size = u8::try_from(env.pointer_type().bytes()).unwrap();
+            let stack_limit_offset = env.offsets.ptr.vmstack_limits_stack_limit();
+            let last_wasm_entry_fp_offset = env.offsets.ptr.vmstack_limits_last_wasm_entry_fp();
+            copy_to_vm_runtime_limits(
+                stack_limit_offset,
+                pointer_size.vmstore_context_stack_limit(),
+            );
+            copy_to_vm_runtime_limits(
+                last_wasm_entry_fp_offset,
+                pointer_size.vmstore_context_last_wasm_entry_fp(),
+            );
+        }
+
+        /// Overwrites the `last_wasm_entry_fp` field of the `VMStackLimits`
+        /// object in the `VMStackLimits` of this object by loading the corresponding
+        /// field from the `VMRuntimeLimits`.
+        /// If `load_stack_limit` is true, we do the same for the `stack_limit`
+        /// field.
+        pub fn load_limits_from_vmcontext<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+            vmruntime_limits_ptr: ir::Value,
+            load_stack_limit: bool,
+        ) {
+            let stack_limits_ptr = self.get_stack_limits_ptr(env, builder);
+
+            let memflags = ir::MemFlags::trusted();
+            let pointer_size = u8::try_from(env.pointer_type().bytes()).unwrap();
+
+            let mut copy = |runtime_limits_offset, stack_limits_offset| {
+                let from_vm_runtime_limits = builder.ins().load(
+                    env.pointer_type(),
+                    memflags,
+                    vmruntime_limits_ptr,
+                    runtime_limits_offset,
+                );
+                builder.ins().store(
+                    memflags,
+                    from_vm_runtime_limits,
+                    stack_limits_ptr,
+                    stack_limits_offset,
+                );
+            };
+
+            let last_wasm_entry_fp_offset = env.offsets.ptr.vmstack_limits_last_wasm_entry_fp();
+            copy(
+                pointer_size.vmstore_context_last_wasm_entry_fp(),
+                last_wasm_entry_fp_offset,
+            );
+
+            if load_stack_limit {
+                let stack_limit_offset = env.offsets.ptr.vmstack_limits_stack_limit();
+                copy(
+                    pointer_size.vmstore_context_stack_limit(),
+                    stack_limit_offset,
+                );
+            }
+        }
+    }
+
+    impl VMContinuationStack {
+        /// The parameter is NOT the "top of stack" address of the stack itself. In line
+        /// with how the (runtime) `FiberStack` type works, this is a pointer to
+        /// the TOS address.
+        pub fn new(tos_ptr: ir::Value) -> Self {
+            Self { tos_ptr }
+        }
+
+        fn load_top_of_stack<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let mem_flags = ir::MemFlags::trusted();
+            builder
+                .ins()
+                .load(env.pointer_type(), mem_flags, self.tos_ptr, 0)
+        }
+
+        /// Returns address of the control context stored in the stack memory,
+        /// as used by stack_switch instructions.
+        pub fn load_control_context<'a>(
+            &self,
+            env: &mut crate::func_environ::FuncEnvironment<'a>,
+            builder: &mut FunctionBuilder,
+        ) -> ir::Value {
+            let tos = self.load_top_of_stack(env, builder);
+            // Control context begins 24 bytes below top of stack (see unix.rs)
+            builder.ins().iadd_imm(tos, -0x18)
+        }
+    }
+}
+
+use helpers::VMStackChain;
+use stack_switching_helpers as helpers;
+
+/// Stores the given arguments in the appropriate `VMPayloads` object in the
+/// continuation. If the continuation was never invoked, use the `args` object.
+/// Otherwise, use the `values` object.
+pub(crate) fn vmcontref_store_payloads<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    values: &[ir::Value],
+    contref: ir::Value,
+) {
+    let count =
+        i32::try_from(values.len()).expect("Number of stack switching payloads should fit in i32");
+    if values.len() > 0 {
+        let use_args_block = builder.create_block();
+        let use_payloads_block = builder.create_block();
+        let store_data_block = builder.create_block();
+        builder.append_block_param(store_data_block, env.pointer_type());
+
+        let co = helpers::VMContRef::new(contref);
+        let csi = co.common_stack_information(env, builder);
+        let was_invoked = csi.was_invoked(env, builder);
+        builder
+            .ins()
+            .brif(was_invoked, use_payloads_block, &[], use_args_block, &[]);
+
+        {
+            builder.switch_to_block(use_args_block);
+            builder.seal_block(use_args_block);
+
+            let args = co.args(env, builder);
+            let ptr = args.occupy_next_slots(env, builder, count);
+
+            builder
+                .ins()
+                .jump(store_data_block, &[BlockArg::Value(ptr)]);
+        }
+
+        {
+            builder.switch_to_block(use_payloads_block);
+            builder.seal_block(use_payloads_block);
+
+            let payloads = co.values(env, builder);
+
+            // This also checks that the buffer is large enough to hold
+            // `values.len()` more elements.
+            let ptr = payloads.occupy_next_slots(env, builder, count);
+            builder
+                .ins()
+                .jump(store_data_block, &[BlockArg::Value(ptr)]);
+        }
+
+        {
+            builder.switch_to_block(store_data_block);
+            builder.seal_block(store_data_block);
+
+            let ptr = builder.block_params(store_data_block)[0];
+
+            // Store the values.
+            let memflags = ir::MemFlags::trusted();
+            let mut offset = 0;
+            for value in values {
+                builder.ins().store(memflags, *value, ptr, offset);
+                offset += i32::from(env.offsets.ptr.maximum_value_size());
+            }
+        }
+    }
+}
+
+pub(crate) fn tag_address<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    index: u32,
+) -> ir::Value {
+    let vmctx = env.vmctx_val(&mut builder.cursor());
+    let tag_index = wasmtime_environ::TagIndex::from_u32(index);
+    let pointer_type = env.pointer_type();
+    if let Some(def_index) = env.module.defined_tag_index(tag_index) {
+        let offset = i32::try_from(env.offsets.vmctx_vmtag_definition(def_index)).unwrap();
+        builder.ins().iadd_imm(vmctx, i64::from(offset))
+    } else {
+        let offset = i32::try_from(env.offsets.vmctx_vmtag_import_from(tag_index)).unwrap();
+        builder.ins().load(
+            pointer_type,
+            ir::MemFlags::trusted().with_readonly(),
+            vmctx,
+            ir::immediates::Offset32::new(offset),
+        )
+    }
+}
+
+/// Returns the stack chain saved in the given `VMContext`. Note that the
+/// head of the list is the actively running stack (initial stack or
+/// continuation).
+pub fn vmctx_load_stack_chain<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    vmctx: ir::Value,
+) -> VMStackChain {
+    let stack_chain_offset = env.offsets.ptr.vmstore_context_stack_chain().into();
+
+    // First we need to get the `VMStoreContext`.
+    let vm_store_context_offset = env.offsets.ptr.vmctx_store_context();
+    let vm_store_context = builder.ins().load(
+        env.pointer_type(),
+        MemFlags::trusted(),
+        vmctx,
+        vm_store_context_offset,
+    );
+
+    VMStackChain::load(
+        env,
+        builder,
+        vm_store_context,
+        stack_chain_offset,
+        env.pointer_type(),
+    )
+}
+
+/// Stores the given stack chain saved in the `VMContext`, overwriting the
+/// existing one.
+pub fn vmctx_store_stack_chain<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    vmctx: ir::Value,
+    stack_chain: &VMStackChain,
+) {
+    let stack_chain_offset = env.offsets.ptr.vmstore_context_stack_chain().into();
+
+    // First we need to get the `VMStoreContext`.
+    let vm_store_context_offset = env.offsets.ptr.vmctx_store_context();
+    let vm_store_context = builder.ins().load(
+        env.pointer_type(),
+        MemFlags::trusted(),
+        vmctx,
+        vm_store_context_offset,
+    );
+
+    stack_chain.store(env, builder, vm_store_context, stack_chain_offset)
+}
+
+/// Similar to `vmctx_store_stack_chain`, but instead of storing an arbitrary
+/// `VMStackChain`, stores VMStackChain::Continuation(contref)`.
+pub fn vmctx_set_active_continuation<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    vmctx: ir::Value,
+    contref: ir::Value,
+) {
+    let chain = VMStackChain::from_continuation(env, builder, contref);
+    vmctx_store_stack_chain(env, builder, vmctx, &chain)
+}
+
+pub fn vmctx_load_vm_runtime_limits_ptr<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    vmctx: ir::Value,
+) -> ir::Value {
+    let pointer_type = env.pointer_type();
+    let offset = i32::from(env.offsets.ptr.vmctx_store_context());
+
+    // The *pointer* to the VMRuntimeLimits does not change within the
+    // same function, allowing us to set the `read_only` flag.
+    let flags = ir::MemFlags::trusted().with_readonly();
+
+    builder.ins().load(pointer_type, flags, vmctx, offset)
+}
+
+/// This function generates code that searches for a handler for `tag_address`,
+/// which must be a `*mut VMTagDefinition`. The search walks up the chain of
+/// continuations beginning at `start`.
+///
+/// The flag `search_suspend_handlers` determines whether we search for a
+/// suspend or switch handler. Concretely, this influences which part of each
+/// handler list we will search.
+///
+/// We trap if no handler was found.
+///
+/// The returned values are:
+/// 1. The stack (continuation or initial stack, represented as a VMStackChain) in
+///    whose handler list we found the tag (i.e., the stack that performed the
+///    resume instruction that installed handler for the tag).
+/// 2. The continuation whose parent is the stack mentioned in 1.
+/// 3. The index of the handler in the handler list.
+///
+/// In pseudo-code, the generated code's behavior can be expressed as
+/// follows:
+///
+/// chain_link = start
+/// while !chain_link.is_initial_stack() {
+///   contref = chain_link.get_contref()
+///   parent_link = contref.parent
+///   parent_csi = parent_link.get_common_stack_information();
+///   handlers = parent_csi.handlers;
+///   (begin_range, end_range) = if search_suspend_handlers {
+///     (0, parent_csi.first_switch_handler_index)
+///   } else {
+///     (parent_csi.first_switch_handler_index, handlers.length)
+///   };
+///   for index in begin_range..end_range {
+///     if handlers[index] == tag_address {
+///       goto on_match(contref, index)
+///     }
+///   }
+///   chain_link = parent_link
+/// }
+/// trap(unhandled_tag)
+///
+/// on_match(conref : VMContRef, handler_index : u32)
+/// ... execution continues here here ...
+///
+fn search_handler<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    start: &helpers::VMStackChain,
+    tag_address: ir::Value,
+    search_suspend_handlers: bool,
+) -> (VMStackChain, ir::Value, ir::Value) {
+    let handle_link = builder.create_block();
+    let begin_search_handler_list = builder.create_block();
+    let try_index = builder.create_block();
+    let compare_tags = builder.create_block();
+    let on_match = builder.create_block();
+    let on_no_match = builder.create_block();
+    let block_args = start.to_raw_parts().map(|v| BlockArg::Value(v));
+
+    // Terminate previous block:
+    builder.ins().jump(handle_link, &block_args);
+
+    // Block handle_link
+    let chain_link = {
+        builder.append_block_param(handle_link, env.pointer_type());
+        builder.append_block_param(handle_link, env.pointer_type());
+        builder.switch_to_block(handle_link);
+
+        let raw_parts = builder.block_params(handle_link);
+        let chain_link = helpers::VMStackChain::from_raw_parts([raw_parts[0], raw_parts[1]]);
+        let is_initial_stack = chain_link.is_initial_stack(env, builder);
+        builder.ins().brif(
+            is_initial_stack,
+            on_no_match,
+            &[],
+            begin_search_handler_list,
+            &[],
+        );
+        chain_link
+    };
+
+    // Block begin_search_handler_list
+    let (contref, parent_link, handler_list_data_ptr, end_range) = {
+        builder.switch_to_block(begin_search_handler_list);
+        let contref = chain_link.unchecked_get_continuation();
+        let contref = helpers::VMContRef::new(contref);
+
+        let parent_link = contref.get_parent_stack_chain(env, builder);
+        let parent_csi = parent_link.get_common_stack_information(env, builder);
+
+        let handlers = parent_csi.get_handler_list(env, builder);
+        let handler_list_data_ptr = handlers.get_data(env, builder);
+
+        let first_switch_handler_index = parent_csi.get_first_switch_handler_index(env, builder);
+
+        // Note that these indices are inclusive-exclusive, i.e. [begin_range, end_range).
+        let (begin_range, end_range) = if search_suspend_handlers {
+            let zero = builder.ins().iconst(I32, 0);
+            (zero, first_switch_handler_index)
+        } else {
+            let length = handlers.get_length(env, builder);
+            (first_switch_handler_index, length)
+        };
+
+        builder
+            .ins()
+            .jump(try_index, &[BlockArg::Value(begin_range)]);
+
+        (contref, parent_link, handler_list_data_ptr, end_range)
+    };
+
+    // Block try_index
+    let index = {
+        builder.append_block_param(try_index, I32);
+        builder.switch_to_block(try_index);
+        let index = builder.block_params(try_index)[0];
+
+        let in_bounds = builder
+            .ins()
+            .icmp(IntCC::UnsignedLessThan, index, end_range);
+        let block_args = parent_link.to_raw_parts().map(|v| BlockArg::Value(v));
+        builder
+            .ins()
+            .brif(in_bounds, compare_tags, &[], handle_link, &block_args);
+        index
+    };
+
+    // Block compare_tags
+    {
+        builder.switch_to_block(compare_tags);
+
+        let base = handler_list_data_ptr;
+        let entry_size = env.pointer_type().bytes();
+        let offset = builder.ins().imul_imm(index, i64::from(entry_size));
+        let offset = builder.ins().uextend(I64, offset);
+        let entry_address = builder.ins().iadd(base, offset);
+
+        let memflags = ir::MemFlags::trusted();
+
+        let handled_tag = builder
+            .ins()
+            .load(env.pointer_type(), memflags, entry_address, 0);
+
+        let tags_match = builder.ins().icmp(IntCC::Equal, handled_tag, tag_address);
+        let incremented_index = builder.ins().iadd_imm(index, 1);
+        builder.ins().brif(
+            tags_match,
+            on_match,
+            &[],
+            try_index,
+            &[BlockArg::Value(incremented_index)],
+        );
+    }
+
+    // Block on_no_match
+    {
+        builder.switch_to_block(on_no_match);
+        builder.set_cold_block(on_no_match);
+        builder.ins().trap(crate::TRAP_UNHANDLED_TAG);
+    }
+
+    builder.seal_block(handle_link);
+    builder.seal_block(begin_search_handler_list);
+    builder.seal_block(try_index);
+    builder.seal_block(compare_tags);
+    builder.seal_block(on_match);
+    builder.seal_block(on_no_match);
+
+    // final block: on_match
+    builder.switch_to_block(on_match);
+
+    (parent_link, contref.address, index)
+}
+
+pub(crate) fn translate_cont_bind<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    contobj: ir::Value,
+    args: &[ir::Value],
+) -> ir::Value {
+    let (witness, contref) = fatpointer::deconstruct(env, &mut builder.cursor(), contobj);
+
+    // The typing rules for cont.bind allow a null reference to be passed to it.
+    builder.ins().trapz(contref, crate::TRAP_NULL_REFERENCE);
+
+    let mut vmcontref = helpers::VMContRef::new(contref);
+    let revision = vmcontref.get_revision(env, builder);
+    let evidence = builder.ins().icmp(IntCC::Equal, witness, revision);
+    builder
+        .ins()
+        .trapz(evidence, crate::TRAP_CONTINUATION_ALREADY_CONSUMED);
+
+    vmcontref_store_payloads(env, builder, args, contref);
+
+    let revision = vmcontref.incr_revision(env, builder, revision);
+    let contobj = fatpointer::construct(env, &mut builder.cursor(), revision, contref);
+    contobj
+}
+
+pub(crate) fn translate_cont_new<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    func: ir::Value,
+    arg_types: &[WasmValType],
+    return_types: &[WasmValType],
+) -> WasmResult<ir::Value> {
+    // The typing rules for cont.new allow a null reference to be passed to it.
+    builder.ins().trapz(func, crate::TRAP_NULL_REFERENCE);
+
+    let nargs = builder
+        .ins()
+        .iconst(I32, i64::try_from(arg_types.len()).unwrap());
+    let nreturns = builder
+        .ins()
+        .iconst(I32, i64::try_from(return_types.len()).unwrap());
+
+    let cont_new_func = super::builtins::cont_new(env, &mut builder.func)?;
+    let vmctx = env.vmctx_val(&mut builder.cursor());
+    let call_inst = builder
+        .ins()
+        .call(cont_new_func, &[vmctx, func, nargs, nreturns]);
+    let contref = *builder.func.dfg.inst_results(call_inst).first().unwrap();
+
+    let tag = helpers::VMContRef::new(contref).get_revision(env, builder);
+    let contobj = fatpointer::construct(env, &mut builder.cursor(), tag, contref);
+    Ok(contobj)
+}
+
+pub(crate) fn translate_resume<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    type_index: u32,
+    resume_contobj: ir::Value,
+    resume_args: &[ir::Value],
+    resumetable: &[(u32, Option<ir::Block>)],
+) -> WasmResult<Vec<ir::Value>> {
+    // The resume instruction is the most involved instruction to
+    // compile as it is responsible for both continuation application
+    // and control tag dispatch.
+    //
+    // Here we translate a resume instruction into several basic
+    // blocks as follows:
+    //
+    //        previous block
+    //              |
+    //              |
+    //        resume_block
+    //         /           \
+    //        /             \
+    //        |             |
+    //  return_block        |
+    //                suspend block
+    //                      |
+    //                dispatch block
+    //
+    // * resume_block handles continuation arguments and performs
+    //   actual stack switch. On ordinary return from resume, it jumps
+    //   to the `return_block`, whereas on suspension it jumps to the
+    //   `suspend_block`.
+    // * suspend_block is used on suspension, jumps onward to
+    //   `dispatch_block`.
+    // * dispatch_block uses a jump table to dispatch to actual
+    //   user-defined handler blocks, based on the handler index
+    //   provided on suspension. Note that we do not jump to the
+    //   handler blocks directly. Instead, each handler block has a
+    //   corresponding premable block, which we jump to in order to
+    //   reach a particular handler block. The preamble block prepares
+    //   the arguments and continuation object to be passed to the
+    //   actual handler block.
+    //
+    let resume_block = builder.create_block();
+    let return_block = builder.create_block();
+    let suspend_block = builder.create_block();
+    let dispatch_block = builder.create_block();
+
+    let vmctx = env.vmctx_val(&mut builder.cursor());
+
+    // Split the resumetable into suspend handlers (each represented by the tag
+    // index and handler block) and the switch handlers (represented just by the
+    // tag index). Note that we currently don't remove duplicate tags.
+    let (suspend_handlers, switch_tags): (Vec<(u32, Block)>, Vec<u32>) = resumetable
+        .iter()
+        .partition_map(|(tag_index, block_opt)| match block_opt {
+            Some(block) => Either::Left((*tag_index, *block)),
+            None => Either::Right(*tag_index),
+        });
+
+    // Technically, there is no need to have a dedicated resume block, we could
+    // just put all of its contents into the current block.
+    builder.ins().jump(resume_block, &[]);
+
+    // Resume block: actually resume the continuation chain ending at `resume_contref`.
+    let (resume_result, vm_runtime_limits_ptr, original_stack_chain, new_stack_chain) = {
+        builder.switch_to_block(resume_block);
+        builder.seal_block(resume_block);
+
+        let (witness, resume_contref) =
+            fatpointer::deconstruct(env, &mut builder.cursor(), resume_contobj);
+
+        // The typing rules for resume allow a null reference to be passed to it.
+        builder
+            .ins()
+            .trapz(resume_contref, crate::TRAP_NULL_REFERENCE);
+
+        let mut vmcontref = helpers::VMContRef::new(resume_contref);
+
+        let revision = vmcontref.get_revision(env, builder);
+        let evidence = builder.ins().icmp(IntCC::Equal, revision, witness);
+        builder
+            .ins()
+            .trapz(evidence, crate::TRAP_CONTINUATION_ALREADY_CONSUMED);
+        let _next_revision = vmcontref.incr_revision(env, builder, revision);
+
+        if resume_args.len() > 0 {
+            // We store the arguments in the `VMContRef` to be resumed.
+            vmcontref_store_payloads(env, builder, resume_args, resume_contref);
+        }
+
+        // Splice together stack chains:
+        // Connect the end of the chain starting at `resume_contref` to the currently active chain.
+        let mut last_ancestor = helpers::VMContRef::new(vmcontref.get_last_ancestor(env, builder));
+
+        // Make the currently running continuation (if any) the parent of the one we are about to resume.
+        let original_stack_chain = vmctx_load_stack_chain(env, builder, vmctx);
+        last_ancestor.set_parent_stack_chain(env, builder, &original_stack_chain);
+
+        // Just for consistency: `vmcontref` is about to get state Running, so let's zero out its last_ancestor field.
+        let zero = builder.ins().iconst(env.pointer_type(), 0);
+        vmcontref.set_last_ancestor(env, builder, zero);
+
+        // We mark `resume_contref` as the currently running one
+        vmctx_set_active_continuation(env, builder, vmctx, resume_contref);
+
+        // Note that the resume_contref libcall a few lines further below
+        // manipulates the stack limits as follows:
+        // 1. Copy stack_limit, last_wasm_entry_sp and last_wasm_exit* values from
+        // VMRuntimeLimits into the currently active continuation (i.e., the
+        // one that will become the parent of the to-be-resumed one)
+        //
+        // 2. Copy `stack_limit` and `last_wasm_entry_sp` in the
+        // `VMStackLimits` of `resume_contref` into the `VMRuntimeLimits`.
+        //
+        // See the comment on `wasmtime_environ::VMStackChain` for a
+        // description of the invariants that we maintain for the various stack
+        // limits.
+
+        // `resume_contref` is now active, and its parent is suspended.
+        let resume_contref = helpers::VMContRef::new(resume_contref);
+        let resume_csi = resume_contref.common_stack_information(env, builder);
+        let parent_csi = original_stack_chain.get_common_stack_information(env, builder);
+        resume_csi.set_state_running(env, builder);
+        parent_csi.set_state_parent(env, builder);
+
+        // We update the `VMStackLimits` of the parent of the continuation to be resumed
+        // as well as the `VMRuntimeLimits`.
+        // See the comment on `wasmtime_environ::VMStackChain` for a description
+        // of the invariants that we maintain for the various stack limits.
+        let vm_runtime_limits_ptr = vmctx_load_vm_runtime_limits_ptr(env, builder, vmctx);
+        parent_csi.load_limits_from_vmcontext(env, builder, vm_runtime_limits_ptr, true);
+        resume_csi.write_limits_to_vmcontext(env, builder, vm_runtime_limits_ptr);
+
+        // Install handlers in (soon to be) parent's VMHandlerList:
+        // Let the i-th handler clause be (on $tag $block).
+        // Then the i-th entry of the VMHandlerList will be the address of $tag.
+        let handler_list = parent_csi.get_handler_list(env, builder);
+
+        if resumetable.len() > 0 {
+            // Total number of handlers (suspend and switch).
+            let handler_count = u32::try_from(resumetable.len()).unwrap();
+            // Populate the Array's data ptr with a pointer to a sufficiently
+            // large area on this stack.
+            env.stack_switching_handler_list_buffer =
+                Some(handler_list.allocate_or_reuse_stack_slot(
+                    env,
+                    builder,
+                    handler_count,
+                    env.stack_switching_handler_list_buffer,
+                ));
+
+            let suspend_handler_count = suspend_handlers.len();
+
+            // All handlers, represented by the indices of the tags they handle.
+            // All the suspend handlers come first, followed by all the switch handlers.
+            let all_handlers = suspend_handlers
+                .iter()
+                .map(|(tag_index, _block)| *tag_index)
+                .chain(switch_tags);
+
+            // Translate all tag indices to tag addresses (i.e., the corresponding *mut VMTagDefinition).
+            let all_tag_addresses: Vec<ir::Value> = all_handlers
+                .map(|tag_index| tag_address(env, builder, tag_index))
+                .collect();
+
+            // Store all tag addresses in the handler list.
+            handler_list.store_data_entries(env, builder, &all_tag_addresses);
+
+            // To enable distinguishing switch and suspend handlers when searching the handler list:
+            // Store at which index the switch handlers start.
+            let first_switch_handler_index = builder
+                .ins()
+                .iconst(I32, i64::try_from(suspend_handler_count).unwrap());
+            parent_csi.set_first_switch_handler_index(env, builder, first_switch_handler_index);
+        }
+
+        let resume_payload = ControlEffect::encode_resume(builder).to_u64();
+
+        // Note that the control context we use for switching is not the one in
+        // (the stack of) resume_contref, but in (the stack of) last_ancestor!
+        let fiber_stack = last_ancestor.get_fiber_stack(env, builder);
+        let control_context_ptr = fiber_stack.load_control_context(env, builder);
+
+        let result =
+            builder
+                .ins()
+                .stack_switch(control_context_ptr, control_context_ptr, resume_payload);
+
+        // At this point we know nothing about the continuation that just
+        // suspended or returned. In particular, it does not have to be what we
+        // called `resume_contref` earlier on. We must reload the information
+        // about the now active continuation from the VMContext.
+        let new_stack_chain = vmctx_load_stack_chain(env, builder, vmctx);
+
+        // Now the parent contref (or initial stack) is active again
+        vmctx_store_stack_chain(env, builder, vmctx, &original_stack_chain);
+        parent_csi.set_state_running(env, builder);
+
+        // Just for consistency: Clear the handler list.
+        handler_list.clear(env, builder, true);
+        parent_csi.set_first_switch_handler_index(env, builder, zero);
+
+        // Extract the result and signal bit.
+        let result = ControlEffect::from_u64(result);
+        let signal = result.signal(builder);
+
+        // Jump to the return block if the result signal is 0, otherwise jump to
+        // the suspend block.
+        builder
+            .ins()
+            .brif(signal, suspend_block, &[], return_block, &[]);
+
+        (
+            result,
+            vm_runtime_limits_ptr,
+            original_stack_chain,
+            new_stack_chain,
+        )
+    };
+
+    // The suspend block: Only used when we suspended, not for returns.
+    // Here we extract the index of the handler to use.
+    let (handler_index, suspended_contref, suspended_contobj) = {
+        builder.switch_to_block(suspend_block);
+        builder.seal_block(suspend_block);
+
+        let suspended_continuation = new_stack_chain.unchecked_get_continuation();
+        let mut suspended_continuation = helpers::VMContRef::new(suspended_continuation);
+        let suspended_csi = suspended_continuation.common_stack_information(env, builder);
+
+        // Note that at the suspend site, we already
+        // 1. Set the state of suspended_continuation to Suspended
+        // 2. Set suspended_continuation.last_ancestor
+        // 3. Broke the continuation chain at suspended_continuation.last_ancestor
+
+        // We store parts of the VMRuntimeLimits into the continuation that just suspended.
+        suspended_csi.load_limits_from_vmcontext(env, builder, vm_runtime_limits_ptr, false);
+
+        // Afterwards (!), restore parts of the VMRuntimeLimits from the
+        // parent of the suspended continuation (which is now active).
+        let parent_csi = original_stack_chain.get_common_stack_information(env, builder);
+        parent_csi.write_limits_to_vmcontext(env, builder, vm_runtime_limits_ptr);
+
+        // Extract the handler index
+        let handler_index = resume_result.handler_index(builder);
+
+        let revision = suspended_continuation.get_revision(env, builder);
+        let suspended_contobj = fatpointer::construct(
+            env,
+            &mut builder.cursor(),
+            revision,
+            suspended_continuation.address,
+        );
+
+        // We need to terminate this block before being allowed to switch to
+        // another one.
+        builder.ins().jump(dispatch_block, &[]);
+
+        (handler_index, suspended_continuation, suspended_contobj)
+    };
+
+    // For technical reasons, the jump table needs to have a default
+    // block. In our case, it should be unreachable, since the handler
+    // index we dispatch on should correspond to a an actual handler
+    // block in the jump table.
+    let jt_default_block = builder.create_block();
+    {
+        builder.switch_to_block(jt_default_block);
+        builder.set_cold_block(jt_default_block);
+
+        builder.ins().trap(crate::TRAP_UNREACHABLE);
+    }
+
+    // We create a preamble block for each of the actual handler blocks: It
+    // reads the necessary arguments and passes them to the actual handler
+    // block, together with the continuation object.
+    let target_preamble_blocks = {
+        let mut preamble_blocks = vec![];
+
+        for &(handle_tag, target_block) in &suspend_handlers {
+            let preamble_block = builder.create_block();
+            preamble_blocks.push(preamble_block);
+            builder.switch_to_block(preamble_block);
+
+            let param_types = env.tag_params(TagIndex::from_u32(handle_tag));
+            let param_types: Vec<ir::Type> = param_types
+                .iter()
+                .map(|wty| crate::value_type(env.isa(), *wty))
+                .collect();
+
+            let values = suspended_contref.values(env, builder);
+            let mut suspend_args: Vec<BlockArg> = values
+                .load_data_entries(env, builder, &param_types)
+                .into_iter()
+                .map(|v| BlockArg::Value(v))
+                .collect();
+
+            // At the suspend site, we store the suspend args in the the
+            // `values` buffer of the VMContRef that was active at the time that
+            // the suspend instruction was performed.
+            suspend_args.push(BlockArg::Value(suspended_contobj));
+
+            // We clear the suspend args. This is mostly for consistency. Note
+            // that we don't zero out the data buffer, we still need it for the
+
+            values.clear(env, builder, false);
+
+            builder.ins().jump(target_block, &suspend_args);
+        }
+
+        preamble_blocks
+    };
+
+    // Dispatch block. All it does is jump to the right premable block based on
+    // the handler index.
+    {
+        builder.switch_to_block(dispatch_block);
+        builder.seal_block(dispatch_block);
+
+        let default_bc = builder.func.dfg.block_call(jt_default_block, &[]);
+
+        let adapter_bcs: Vec<BlockCall> = target_preamble_blocks
+            .iter()
+            .map(|b| builder.func.dfg.block_call(*b, &[]))
+            .collect();
+
+        let jt_data = JumpTableData::new(default_bc, &adapter_bcs);
+        let jt = builder.create_jump_table(jt_data);
+
+        builder.ins().br_table(handler_index, jt);
+
+        for preamble_block in target_preamble_blocks {
+            builder.seal_block(preamble_block);
+        }
+        builder.seal_block(jt_default_block);
+    }
+
+    // Return block: Jumped to by resume block if continuation
+    // returned normally.
+    {
+        builder.switch_to_block(return_block);
+        builder.seal_block(return_block);
+
+        // If we got a return signal, a continuation must have been running.
+        let returned_contref = new_stack_chain.unchecked_get_continuation();
+        let returned_contref = helpers::VMContRef::new(returned_contref);
+
+        // Restore parts of the VMRuntimeLimits from the parent of the
+        // returned continuation (which is now active).
+        let parent_csi = original_stack_chain.get_common_stack_information(env, builder);
+        parent_csi.write_limits_to_vmcontext(env, builder, vm_runtime_limits_ptr);
+
+        let returned_csi = returned_contref.common_stack_information(env, builder);
+        returned_csi.set_state_returned(env, builder);
+
+        // Load the values returned by the continuation.
+        let return_types: Vec<_> = env
+            .continuation_returns(TypeIndex::from_u32(type_index))
+            .iter()
+            .map(|ty| crate::value_type(env.isa(), *ty))
+            .collect();
+        let payloads = returned_contref.args(env, builder);
+        let return_values = payloads.load_data_entries(env, builder, &return_types);
+        payloads.clear(env, builder, true);
+
+        Ok(return_values)
+    }
+}
+
+pub(crate) fn translate_suspend<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    tag_index: u32,
+    suspend_args: &[ir::Value],
+    tag_return_types: &[ir::Type],
+) -> Vec<ir::Value> {
+    let tag_addr = tag_address(env, builder, tag_index);
+
+    let vmctx = env.vmctx_val(&mut builder.cursor());
+    let active_stack_chain = vmctx_load_stack_chain(env, builder, vmctx);
+
+    let (_, end_of_chain_contref, handler_index) =
+        search_handler(env, builder, &active_stack_chain, tag_addr, true);
+
+    // If we get here, the search_handler logic succeeded (i.e., did not trap).
+    // Thus, there is at least one parent, so we are not on the initial stack.
+    // Can therefore extract continuation directly.
+    let active_contref = active_stack_chain.unchecked_get_continuation();
+    let active_contref = helpers::VMContRef::new(active_contref);
+    let mut end_of_chain_contref = helpers::VMContRef::new(end_of_chain_contref);
+
+    active_contref.set_last_ancestor(env, builder, end_of_chain_contref.address);
+
+    // In the active_contref's `values` buffer, stack-allocate enough room so that we can
+    // later store the following:
+    // 1. The suspend arguments
+    // 2. Afterwards, the tag return values
+    let values = active_contref.values(env, builder);
+    let required_capacity =
+        u32::try_from(std::cmp::max(suspend_args.len(), tag_return_types.len()))
+            .expect("Number of stack switching payloads should fit in u32");
+
+    if required_capacity > 0 {
+        env.stack_switching_values_buffer = Some(values.allocate_or_reuse_stack_slot(
+            env,
+            builder,
+            required_capacity,
+            env.stack_switching_values_buffer,
+        ));
+    }
+
+    if suspend_args.len() > 0 {
+        values.store_data_entries(env, builder, suspend_args);
+    }
+
+    // Set current continuation to suspended and break up handler chain.
+    let active_contref_csi = active_contref.common_stack_information(env, builder);
+    active_contref_csi.set_state_suspended(env, builder);
+    let absent_chain_link = VMStackChain::absent(env, builder);
+    end_of_chain_contref.set_parent_stack_chain(env, builder, &absent_chain_link);
+
+    let suspend_payload = ControlEffect::encode_suspend(builder, handler_index).to_u64();
+
+    // Note that the control context we use for switching is the one
+    // at the end of the chain, not the one in active_contref!
+    // This also means that stack_switch saves the information about
+    // the current stack in the control context located in the stack
+    // of end_of_chain_contref.
+    let fiber_stack = end_of_chain_contref.get_fiber_stack(env, builder);
+    let control_context_ptr = fiber_stack.load_control_context(env, builder);
+
+    builder
+        .ins()
+        .stack_switch(control_context_ptr, control_context_ptr, suspend_payload);
+
+    // The return values of the suspend instruction are the tag return values, saved in the `args` buffer.
+    let values = active_contref.values(env, builder);
+    let return_values = values.load_data_entries(env, builder, tag_return_types);
+    // We effectively consume the values and discard the stack allocated buffer.
+    values.clear(env, builder, true);
+
+    return_values
+}
+
+pub(crate) fn translate_switch<'a>(
+    env: &mut crate::func_environ::FuncEnvironment<'a>,
+    builder: &mut FunctionBuilder,
+    tag_index: u32,
+    switchee_contobj: ir::Value,
+    switch_args: &[ir::Value],
+    return_types: &[ir::Type],
+) -> WasmResult<Vec<ir::Value>> {
+    let vmctx = env.vmctx_val(&mut builder.cursor());
+
+    // Check and increment revision on switchee continuation object (i.e., the
+    // one being switched to). Logically, the switchee continuation extends from
+    // `switchee_contref` to `switchee_contref.last_ancestor` (i.e., the end of
+    // the parent chain starting at `switchee_contref`).
+    let switchee_contref = {
+        let (witness, target_contref) =
+            fatpointer::deconstruct(env, &mut builder.cursor(), switchee_contobj);
+
+        // The typing rules for switch allow a null reference to be passed to it.
+        builder
+            .ins()
+            .trapz(target_contref, crate::TRAP_NULL_REFERENCE);
+
+        let mut target_contref = helpers::VMContRef::new(target_contref);
+
+        let revision = target_contref.get_revision(env, builder);
+        let evidence = builder.ins().icmp(IntCC::Equal, revision, witness);
+        builder
+            .ins()
+            .trapz(evidence, crate::TRAP_CONTINUATION_ALREADY_CONSUMED);
+        let _next_revision = target_contref.incr_revision(env, builder, revision);
+        target_contref
+    };
+
+    // We create the "switcher continuation" (i.e., the one executing switch)
+    // from the current execution context: Logically, it extends from the
+    // continuation reference executing `switch` (subsequently called
+    // `switcher_contref`) to the immediate child (called
+    // `switcher_contref_last_ancestor`) of the stack with the corresponding
+    // handler (saved in `handler_stack_chain`).
+    let (
+        switcher_contref,
+        switcher_contobj,
+        switcher_contref_last_ancestor,
+        handler_stack_chain,
+        vm_runtime_limits_ptr,
+    ) = {
+        let tag_addr = tag_address(env, builder, tag_index);
+        let active_stack_chain = vmctx_load_stack_chain(env, builder, vmctx);
+        let (handler_stack_chain, last_ancestor, _handler_index) =
+            search_handler(env, builder, &active_stack_chain, tag_addr, false);
+        let mut last_ancestor = helpers::VMContRef::new(last_ancestor);
+
+        // If we get here, the search_handler logic succeeded (i.e., did not trap).
+        // Thus, there is at least one parent, so we are not on the initial stack.
+        // Can therefore extract continuation directly.
+        let switcher_contref = active_stack_chain.unchecked_get_continuation();
+        let mut switcher_contref = helpers::VMContRef::new(switcher_contref);
+
+        switcher_contref.set_last_ancestor(env, builder, last_ancestor.address);
+
+        // In the switcher_contref's `values` buffer, stack-allocate enough room so that we can
+        // later store `tag_return_types.len()` when resuming the continuation.
+        let values = switcher_contref.values(env, builder);
+        let required_capacity = u32::try_from(return_types.len()).unwrap();
+        if required_capacity > 0 {
+            env.stack_switching_values_buffer = Some(values.allocate_or_reuse_stack_slot(
+                env,
+                builder,
+                required_capacity,
+                env.stack_switching_values_buffer,
+            ));
+        }
+
+        let switcher_contref_csi = switcher_contref.common_stack_information(env, builder);
+        switcher_contref_csi.set_state_suspended(env, builder);
+        // We break off `switcher_contref` from the chain of active
+        // continuations, by separating the link between `last_ancestor` and its
+        // parent stack.
+        let absent = VMStackChain::absent(env, builder);
+        last_ancestor.set_parent_stack_chain(env, builder, &absent);
+
+        // Load current runtime limits from `VMContext` and store in the
+        // switcher continuation.
+        let vm_runtime_limits_ptr = vmctx_load_vm_runtime_limits_ptr(env, builder, vmctx);
+        switcher_contref_csi.load_limits_from_vmcontext(env, builder, vm_runtime_limits_ptr, false);
+
+        let revision = switcher_contref.get_revision(env, builder);
+        let new_contobj = fatpointer::construct(
+            env,
+            &mut builder.cursor(),
+            revision,
+            switcher_contref.address,
+        );
+
+        (
+            switcher_contref,
+            new_contobj,
+            last_ancestor,
+            handler_stack_chain,
+            vm_runtime_limits_ptr,
+        )
+    };
+
+    // Prepare switchee continuation:
+    // - Store "ordinary" switch arguments as well as the contobj just
+    //   synthesized from the current context (i.e., `switcher_contobj`) in the
+    //   switchee continuation's payload buffer.
+    // - Splice switchee's continuation chain with handler stack to form new
+    //   overall chain of active continuations.
+    let (switchee_contref_csi, switchee_contref_last_ancestor) = {
+        let mut combined_payloads = switch_args.to_vec();
+        combined_payloads.push(switcher_contobj);
+        vmcontref_store_payloads(env, builder, &combined_payloads, switchee_contref.address);
+
+        let switchee_contref_csi = switchee_contref.common_stack_information(env, builder);
+        switchee_contref_csi.set_state_running(env, builder);
+
+        let switchee_contref_last_ancestor = switchee_contref.get_last_ancestor(env, builder);
+        let mut switchee_contref_last_ancestor =
+            helpers::VMContRef::new(switchee_contref_last_ancestor);
+
+        switchee_contref_last_ancestor.set_parent_stack_chain(env, builder, &handler_stack_chain);
+
+        (switchee_contref_csi, switchee_contref_last_ancestor)
+    };
+
+    // Update VMContext/Store: Update active continuation and `VMRuntimeLimits`.
+    {
+        vmctx_set_active_continuation(env, builder, vmctx, switchee_contref.address);
+
+        switchee_contref_csi.write_limits_to_vmcontext(env, builder, vm_runtime_limits_ptr);
+    }
+
+    // Perform actual stack switch
+    {
+        let switcher_last_ancestor_fs =
+            switcher_contref_last_ancestor.get_fiber_stack(env, builder);
+        let switcher_last_ancestor_cc =
+            switcher_last_ancestor_fs.load_control_context(env, builder);
+
+        let switchee_last_ancestor_fs =
+            switchee_contref_last_ancestor.get_fiber_stack(env, builder);
+        let switchee_last_ancestor_cc =
+            switchee_last_ancestor_fs.load_control_context(env, builder);
+
+        // The stack switch involves the following control contexts (e.g., IP,
+        // SP, FP, ...):
+        // - `switchee_last_ancestor_cc` contains the information to continue
+        //    execution in the switchee/target continuation.
+        // - `switcher_last_ancestor_cc` contains the information about how to
+        //    continue execution once we suspend/return to the stack with the
+        //    switch handler.
+        //
+        // In total, the following needs to happen:
+        // 1. Load control context at `switchee_last_ancestor_cc` to perform
+        //    stack switch.
+        // 2. Move control context at `switcher_last_ancestor_cc` over to
+        //    `switchee_last_ancestor_cc`.
+        // 3. Upon actual switch, save current control context at
+        //    `switcher_last_ancestor_cc`.
+        //
+        // We implement this as follows:
+        // 1. We copy `switchee_last_ancestor_cc` to a temporary area on the
+        //    stack (`tmp_control_context`).
+        // 2. We copy `switcher_last_ancestor_cc` over to
+        //    `switchee_last_ancestor_cc`.
+        // 3. We invoke the stack switch instruction such that it reads from the
+        //    temporary area, and writes to `switcher_last_ancestor_cc`.
+        //
+        // Note that the temporary area is only accessed once by the
+        // `stack_switch` instruction emitted later in this block, meaning that we
+        // don't have to worry about its lifetime.
+        //
+        // NOTE(frank-emrich) The implementation below results in one stack slot
+        // being created per switch instruction, even though multiple switch
+        // instructions in the same function could safely re-use the same stack
+        // slot. Thus, we could implement logic for sharing the stack slot by
+        // adding an appropriate field to `FuncEnvironment`.
+        //
+        // NOTE(frank-emrich) We could avoid the copying to a temporary area by
+        // making `stack_switch` do all of the necessary moving itself. However,
+        // that would be a rather ad-hoc change to how the instruction uses the
+        // two pointers given to it.
+
+        let cctx_size = control_context_size(env.isa().triple())?;
+        let slot_size = ir::StackSlotData::new(
+            ir::StackSlotKind::ExplicitSlot,
+            u32::from(cctx_size),
+            u8::try_from(env.pointer_type().bytes()).unwrap(),
+        );
+        let slot = builder.create_sized_stack_slot(slot_size);
+        let tmp_control_context = builder.ins().stack_addr(env.pointer_type(), slot, 0);
+
+        let flags = MemFlags::trusted();
+        let mut offset: i32 = 0;
+        while offset < i32::from(cctx_size) {
+            // switchee_last_ancestor_cc -> tmp control context
+            let tmp1 =
+                builder
+                    .ins()
+                    .load(env.pointer_type(), flags, switchee_last_ancestor_cc, offset);
+            builder
+                .ins()
+                .store(flags, tmp1, tmp_control_context, offset);
+
+            // switcher_last_ancestor_cc -> switchee_last_ancestor_cc
+            let tmp2 =
+                builder
+                    .ins()
+                    .load(env.pointer_type(), flags, switcher_last_ancestor_cc, offset);
+            builder
+                .ins()
+                .store(flags, tmp2, switchee_last_ancestor_cc, offset);
+
+            offset += i32::try_from(env.pointer_type().bytes()).unwrap();
+        }
+
+        let switch_payload = ControlEffect::encode_switch(builder).to_u64();
+
+        let _result = builder.ins().stack_switch(
+            switcher_last_ancestor_cc,
+            tmp_control_context,
+            switch_payload,
+        );
+    }
+
+    // After switching back to the original stack: Load return values, they are
+    // stored on the switcher continuation.
+    let return_values = {
+        let payloads = switcher_contref.values(env, builder);
+        let return_values = payloads.load_data_entries(env, builder, return_types);
+        // We consume the values and discard the buffer (allocated on this stack)
+        payloads.clear(env, builder, true);
+        return_values
+    };
+
+    Ok(return_values)
+}