Method trap

crates/wasmtime/src/runtime/vm/interpreter.rs:457–500

Handles an interpreter trap. This will initialize the trap state stored in TLS via the `test_if_trap` helper below by reading the pc/fp of the interpreter and seeing if that's a valid opcode to trap at.

(&mut self, pc: NonNull<u8>, kind: Option<TrapKind>)

    /// in TLS via the `test_if_trap` helper below by reading the pc/fp of the
    /// interpreter and seeing if that's a valid opcode to trap at.
    fn trap(&mut self, pc: NonNull<u8>, kind: Option<TrapKind>) -> NonNull<u8> {
        let regs = TrapRegisters {
            pc: pc.as_ptr() as usize,
            fp: self.vm().fp() as usize,
        };
        let handler = tls::with(|s| {
            let s = s.unwrap();
            match kind {
                Some(kind) => {
                    let trap = match kind {
                        TrapKind::IntegerOverflow => Trap::IntegerOverflow.into(),
                        TrapKind::DivideByZero => Trap::IntegerDivisionByZero.into(),
                        TrapKind::BadConversionToInteger => Trap::BadConversionToInteger.into(),
                        TrapKind::MemoryOutOfBounds => Trap::MemoryOutOfBounds.into(),
                        TrapKind::DisabledOpcode => Trap::DisabledOpcode.into(),
                        TrapKind::StackOverflow => Trap::StackOverflow.into(),
                    };
                    s.set_jit_trap(regs, None, trap);
                    s.entry_trap_handler()
                }
                None => {
                    match s.test_if_trap(regs, None, |_| false) {
                        // This shouldn't be possible, so this is a fatal error
                        // if it happens.
                        TrapTest::NotWasm => {
                            panic!("pulley trap at {pc:?} without trap code registered")
                        }

                        // Not possible with our closure above returning `false`.
                        #[cfg(has_native_signals)]
                        TrapTest::HandledByEmbedder => unreachable!(),

                        // Trap was handled, yay! Configure interpreter state
                        // to resume at the exception handler.
                        TrapTest::Trap(handler) => handler,
                    }
                }
            }
        });
        unsafe {
            self.resume_to_exception_handler(&handler, 0, 0);
        }
        self.take_resume_at_pc()
    }

    fn take_resume_at_pc(&mut self) -> NonNull<u8> {
        let pc = self.vm_state().resume_at_pc.take().unwrap();