Function process_const_operators

crates/parser/src/conversion.rs:228–271

(ops: OperatorsReader<'_>)

}

pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<Box<[ConstInstruction]>> {
    let ops = ops.into_iter().collect::<wasmparser::Result<Vec<_>>>()?;
    // In practice, the len can never be something other than 2,
    // but we'll keep this here since it's part of the spec
    // Invalid modules will be rejected by the validator anyway (there are also tests for this in the testsuite)
    debug_assert!(ops.len() >= 2);
    debug_assert!(matches!(ops[ops.len() - 1], wasmparser::Operator::End));

    let mut out = Vec::with_capacity(ops.len().saturating_sub(1));
    for op in ops.iter().take(ops.len() - 1) {
        let instr = match op {
            wasmparser::Operator::RefNull { hty } => match convert_heaptype(*hty)? {
                WasmType::RefFunc => ConstInstruction::RefFunc(None),
                WasmType::RefExtern => ConstInstruction::RefExtern(None),
                other => {
                    return Err(crate::ParseError::UnsupportedOperator(format!(
                        "Unsupported ref.null heap type lowered to {other:?}"
                    )));
                }
            },
            wasmparser::Operator::RefFunc { function_index } => ConstInstruction::RefFunc(Some(*function_index)),
            wasmparser::Operator::I32Const { value } => ConstInstruction::I32Const(*value),
            wasmparser::Operator::I64Const { value } => ConstInstruction::I64Const(*value),
            wasmparser::Operator::F32Const { value } => ConstInstruction::F32Const(f32::from_bits(value.bits())),
            wasmparser::Operator::F64Const { value } => ConstInstruction::F64Const(f64::from_bits(value.bits())),
            wasmparser::Operator::V128Const { value } => ConstInstruction::V128Const(*value.bytes()),
            wasmparser::Operator::GlobalGet { global_index } => ConstInstruction::GlobalGet(*global_index),
            wasmparser::Operator::I32Add => ConstInstruction::I32Add,
            wasmparser::Operator::I32Sub => ConstInstruction::I32Sub,
            wasmparser::Operator::I32Mul => ConstInstruction::I32Mul,
            wasmparser::Operator::I64Add => ConstInstruction::I64Add,
            wasmparser::Operator::I64Sub => ConstInstruction::I64Sub,
            wasmparser::Operator::I64Mul => ConstInstruction::I64Mul,
            other => {
                return Err(crate::ParseError::UnsupportedOperator(format!(
                    "Unsupported const instruction: {other:?}"
                )));
            }
        };
        out.push(instr);
    }

    Ok(out.into_boxed_slice())
}

pub(crate) fn convert_heaptype(heap: wasmparser::HeapType) -> Result<WasmType> {
    match heap {