Method parse_data_value

cranelift/reader/src/parser.rs:2631–2660

Parse a data value; e.g. `42`, `4.2`, `true`. data-value-list ::= [data-value {"," data-value-list}]

(&mut self, ty: Type)

    ///
    /// data-value-list ::= [data-value {"," data-value-list}]
    fn parse_data_value(&mut self, ty: Type) -> ParseResult<DataValue> {
        let dv = match ty {
            I8 => DataValue::from(self.match_imm8("expected a i8")?),
            I16 => DataValue::from(self.match_imm16("expected an i16")?),
            I32 => DataValue::from(self.match_imm32("expected an i32")?),
            I64 => DataValue::from(Into::<i64>::into(self.match_imm64("expected an i64")?)),
            I128 => DataValue::from(self.match_imm128("expected an i128")?),
            F16 => DataValue::from(self.match_ieee16("expected an f16")?),
            F32 => DataValue::from(self.match_ieee32("expected an f32")?),
            F64 => DataValue::from(self.match_ieee64("expected an f64")?),
            F128 => DataValue::from(self.match_ieee128("expected an f128")?),
            _ if (ty.is_vector() || ty.is_dynamic_vector()) => {
                let as_vec = self.match_uimm128(ty)?.into_vec();
                let slice = as_vec.as_slice();
                match slice.len() {
                    16 => DataValue::V128(slice.try_into().unwrap()),
                    8 => DataValue::V64(slice.try_into().unwrap()),
                    4 => DataValue::V32(slice.try_into().unwrap()),
                    2 => DataValue::V16(slice.try_into().unwrap()),
                    _ => {
                        return Err(
                            self.error("vectors larger than 128 bits are not currently supported")
                        );
                    }
                }
            }
            _ => return Err(self.error(&format!("don't know how to parse data values of: {ty}"))),
        };
        Ok(dv)
    }

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