Method to_bytes

crates/fuzzing/src/generators/single_inst_module.rs:55–156

Encode a binary Wasm module with a single exported function, `test`, that executes the single instruction.

(&self)

    /// Encode a binary Wasm module with a single exported function, `test`,
    /// that executes the single instruction.
    pub fn to_bytes(&self) -> Vec<u8> {
        let mut module = Module::new();

        // Encode the type section.
        let mut types = TypeSection::new();
        types.ty().function(
            self.parameters.iter().cloned(),
            self.results.iter().cloned(),
        );
        module.section(&types);

        // Encode the function section.
        let mut functions = FunctionSection::new();
        let type_index = 0;
        functions.function(type_index);
        module.section(&functions);

        // Encode the export section.
        let mut exports = ExportSection::new();
        exports.export(FUNCTION_NAME, ExportKind::Func, 0);
        module.section(&exports);

        // Encode the code section.
        let mut codes = CodeSection::new();

        // Set up the single-instruction function. Note that if we have chosen
        // to canonicalize NaNs, this function will contain more than one
        // instruction and the function will need a scratch local.
        let mut f = if let Some(ty) = &self.canonicalize_nan {
            Function::new(match ty {
                NanType::F32 => vec![(1, ValType::F32)],
                NanType::F64 => vec![(1, ValType::F64)],
                NanType::F32x4 | NanType::F64x2 => vec![(1, ValType::V128)],
            })
        } else {
            Function::new([])
        };

        // Retrieve the input values and execute the chosen instruction.
        for (index, _) in self.parameters.iter().enumerate() {
            f.instruction(&Instruction::LocalGet(index as u32));
        }
        f.instruction(&self.instruction);

        // If we have configured to canonicalize NaNs, we add a sequence that
        // masks off the NaN payload bits to make them 0s (i.e., a canonical
        // NaN). This sequence is adapted from wasm-smiths version; see
        // https://github.com/bytecodealliance/wasm-tools/blob/6c127a6/crates/wasm-smith/src/core/code_builder.rs#L927.
        if let Some(ty) = &self.canonicalize_nan {
            // Save the previous instruction's result into the scratch local.
            // This also leaves a value on the stack as for the `select`
            // instruction.
            let local = self.parameters.len() as u32;
            f.instruction(&Instruction::LocalTee(local));

            // The other input to the `select` below--a canonical NaN. Note how
            // the payload bits of the NaN are cleared.
            const CANON_32BIT_NAN: u32 = 0b01111111110000000000000000000000;