Method encode

crates/fuzzing/src/generators/exception_ops.rs:197–493

Module layout: Types: 0..num_tags tag signatures: (params) -> () num_tags..2*num_tags catch block types: () -> (params) 2*num_tags () -> (i32) (run & relay functions) 2*num_tags + 1 (i32, i32) -> () (check_i32) 2*num_tags + 2 () -> () (thrower functions) Tags: 0..num_tags (using type indices 0..nu

(&self)

    /// Functions:  per-scenario call chains + "run"
    /// Exports:  "run"
    fn encode(&self) -> Vec<u8> {
        let num_tags = self.limits.num_tags;
        let call_depth = self.limits.call_depth;
        let num_scenarios = u32::try_from(self.scenarios.len()).unwrap();

        let mut module = Module::new();

        let mut types = TypeSection::new();

        // Type indices 0..num_tags: tag signatures (params -> [])
        for sig in &self.tag_sigs {
            let params: Vec<ValType> = sig.params.iter().map(|t| t.to_val_type()).collect();
            types.ty().function(params, vec![]);
        }

        // Type indices num_tags..2*num_tags: catch block types ([] -> params)
        // These are used as block types for the catch target blocks, since
        // `catch $tag $label` delivers the tag's param types at the label.
        let catch_block_type_base = num_tags;
        for sig in &self.tag_sigs {
            let results: Vec<ValType> = sig.params.iter().map(|t| t.to_val_type()).collect();
            types.ty().function(vec![], results);
        }

        // Utility function types
        let fn_type_void_to_i32 = types.len();
        types.ty().function(vec![], vec![ValType::I32]);

        let fn_type_check = types.len();
        types
            .ty()
            .function(vec![ValType::I32, ValType::I32], vec![]);

        let fn_type_void_to_void = types.len();
        types.ty().function(vec![], vec![]);

        let mut tags = TagSection::new();
        for i in 0..num_tags {
            tags.tag(TagType {
                kind: TagKind::Exception,
                func_type_idx: i,
            });
        }

        let mut imports = ImportSection::new();
        let check_func_idx: u32 = 0;
        imports.import("", "check_i32", EntityType::Function(fn_type_check));
        let import_count: u32 = imports.len();

        // For each scenario: (call_depth + 1) functions at depths 0..=call_depth.
        //   - depth == catch_depth: handler function () -> (i32)
        //   - depth == throw_depth: thrower function () -> ()
        //   - other depths < throw_depth: relay function () -> (i32)
        //   - other depths > throw_depth: unreachable () -> ()
        //
        // Plus one "run" function that calls each scenario's depth-0 function.

        let funcs_per_scenario = call_depth + 1;