Method visit_br_table

crates/parser/src/visit.rs:349–404

(&mut self, targets: wasmparser::BrTable<'_>)

    }

    fn visit_br_table(&mut self, targets: wasmparser::BrTable<'_>) -> Self::Output {
        let ts = targets
            .targets()
            .collect::<Result<Vec<_>, wasmparser::BinaryReaderError>>()
            .expect("visit_br_table: BrTable targets are invalid");

        let default_depth = targets.default();
        let len = ts.len() as u32;
        let target_depths: Vec<u32> = ts;

        let header_ip = self.instructions.len();
        let branch_table_start = self.data.branch_table_targets.len() as u32;
        self.instructions.push(Instruction::BranchTable(0, branch_table_start, len));

        struct PadInfo {
            depth: u32,
            pad_start: usize,
            jump_or_ret_ip: usize,
            is_return: bool,
        }
        let mut seen = Vec::<(u32, usize)>::new();
        let mut pads: Vec<PadInfo> = Vec::new();

        for &depth in target_depths.iter().chain(core::iter::once(&default_depth)) {
            if seen.iter().any(|&(seen_depth, _)| seen_depth == depth) {
                continue;
            }
            seen.push((depth, pads.len()));

            let (pad_start, jump_or_ret_ip, is_return) = self.emit_br_table_pad(depth);
            pads.push(PadInfo { depth, pad_start, jump_or_ret_ip, is_return });
        }

        for &depth in &target_depths {
            let pad_idx = seen
                .iter()
                .find_map(|&(seen_depth, idx)| (seen_depth == depth).then_some(idx))
                .expect("visit_br_table: missing branch table target");
            self.data.branch_table_targets.push(pads[pad_idx].pad_start as u32);
        }

        let default_pad_idx = seen
            .iter()
            .find_map(|&(seen_depth, idx)| (seen_depth == default_depth).then_some(idx))
            .expect("visit_br_table: missing default branch table target");
        if let Instruction::BranchTable(default_ip, _, _) = &mut self.instructions[header_ip] {
            *default_ip = pads[default_pad_idx].pad_start as u32;
        }

        for pad in &pads {
            if pad.is_return {
                continue;
            }
            self.patch_branch_jump_or_return(pad.depth, pad.jump_or_ret_ip);
        }
    }

    fn visit_f32_const(&mut self, val: wasmparser::Ieee32) -> Self::Output {