Method parse_inst_operands

cranelift/reader/src/parser.rs:2664–3069

Parse the operands following the instruction opcode. This depends on the format of the opcode.

(
        &mut self,
        ctx: &mut Context,
        opcode: Opcode,
        explicit_control_type: Option<Type>,
    )

    // Parse the operands following the instruction opcode.
    // This depends on the format of the opcode.
    fn parse_inst_operands(
        &mut self,
        ctx: &mut Context,
        opcode: Opcode,
        explicit_control_type: Option<Type>,
    ) -> ParseResult<InstructionData> {
        let idata = match opcode.format() {
            InstructionFormat::Unary => InstructionData::Unary {
                opcode,
                arg: self.match_value("expected SSA value operand")?,
            },
            InstructionFormat::UnaryImm => {
                let msg = |bits| format!("expected immediate {bits}-bit integer operand");
                let unsigned = match explicit_control_type {
                    Some(types::I8) => self.match_imm8(&msg(8))? as u8 as i64,
                    Some(types::I16) => self.match_imm16(&msg(16))? as u16 as i64,
                    Some(types::I32) => self.match_imm32(&msg(32))? as u32 as i64,
                    Some(types::I64) => self.match_imm64(&msg(64))?.bits(),
                    _ => {
                        return err!(
                            self.loc,
                            "expected one of the following type: i8, i16, i32 or i64"
                        );
                    }
                };
                InstructionData::UnaryImm {
                    opcode,
                    imm: Imm64::new(unsigned),
                }
            }
            InstructionFormat::UnaryIeee16 => InstructionData::UnaryIeee16 {
                opcode,
                imm: self.match_ieee16("expected immediate 16-bit float operand")?,
            },
            InstructionFormat::UnaryIeee32 => InstructionData::UnaryIeee32 {
                opcode,
                imm: self.match_ieee32("expected immediate 32-bit float operand")?,
            },
            InstructionFormat::UnaryIeee64 => InstructionData::UnaryIeee64 {
                opcode,
                imm: self.match_ieee64("expected immediate 64-bit float operand")?,
            },
            InstructionFormat::UnaryConst => {
                let constant_handle = if let Some(Token::Constant(_)) = self.token() {
                    // If handed a `const?`, use that.
                    let c = self.match_constant()?;
                    ctx.check_constant(c, self.loc)?;
                    c
                } else if opcode == Opcode::F128const {
                    let ieee128 = self.match_ieee128("expected immediate 128-bit float operand")?;
                    ctx.function.dfg.constants.insert(ieee128.into())
                } else if let Some(controlling_type) = explicit_control_type {
                    // If an explicit control type is present, we expect a sized value and insert
                    // it in the constant pool.
                    let uimm128 = self.match_uimm128(controlling_type)?;
                    ctx.function.dfg.constants.insert(uimm128)
                } else {
                    return err!(