Function convert_module_code

crates/parser/src/conversion.rs:136–183

(
    func: wasmparser::FunctionBody<'_>,
    mut validator: FuncValidator<ValidatorResources>,
    reader_allocs: OperatorsReaderAllocations,
)

}

pub(crate) fn convert_module_code(
    func: wasmparser::FunctionBody<'_>,
    mut validator: FuncValidator<ValidatorResources>,
    reader_allocs: OperatorsReaderAllocations,
) -> Result<(FunctionCode, FuncValidatorAllocations, OperatorsReaderAllocations)> {
    let locals_reader = func.get_locals_reader()?;
    let count = locals_reader.get_count();
    let pos = locals_reader.original_position();

    // maps a local's address to the index in the type's locals array
    let mut local_addr_map = Vec::with_capacity(count as usize);
    let mut local_counts = ValueCounts::default();

    for (i, local) in locals_reader.into_iter().enumerate() {
        let local = local?;
        validator.define_locals(pos + i, local.0, local.1)?;
    }

    for i in 0..validator.len_locals() {
        match validator.get_local_type(i) {
            Some(wasmparser::ValType::I32 | wasmparser::ValType::F32) => {
                local_addr_map.push(local_counts.c32);
                local_counts.c32 += 1;
            }
            Some(wasmparser::ValType::I64 | wasmparser::ValType::F64) => {
                local_addr_map.push(local_counts.c64);
                local_counts.c64 += 1;
            }
            Some(wasmparser::ValType::V128) => {
                local_addr_map.push(local_counts.c128);
                local_counts.c128 += 1;
            }
            Some(wasmparser::ValType::Ref(_)) => {
                local_addr_map.push(local_counts.c32);
                local_counts.c32 += 1;
            }
            None => return Err(crate::ParseError::UnsupportedOperator("Unknown local type".to_string())),
        }
    }

    let (body, data, validator_allocs, reader_allocs) =
        process_operators_and_validate(validator, func, local_addr_map, reader_allocs)?;
    Ok((
        FunctionCode { instructions: body, data, locals: local_counts, uses_local_memory: false },
        validator_allocs,
        reader_allocs,
    ))
}

pub(crate) fn convert_module_type(ty: wasmparser::RecGroup) -> Result<Arc<FuncType>> {
    let mut types = ty.types();