charm 0.0.1

//! # BFM
//!
//! This instruction is usually accessed via one of its aliases, which are always preferred for disassembly.

#![allow(non_snake_case)]
#![allow(unused)]
use crate::error::Result;
use crate::utils::*;
use super::super::formatter::*;
use super::super::instruction::*;
use super::super::operand::*;
use super::super::consts::*;
use super::super::config::*;
use super::super::decoder::*;

// ---------------------------------------------------------------------------
// Iclass IclassBfm32mBitfield
// ---------------------------------------------------------------------------

/// Type that represents the IclassBfm32mBitfield instruction class.
pub(crate) struct IclassBfm32mBitfield;

impl IclassBfm32mBitfield {
    /// Tries to decode the instruction in `data`.
    pub(crate) fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        let immr = (data >> 16) & 63;
        let immr_post = immr;
        let N = (data >> 22) & 1;
        let N_post = N;
        let Rn = (data >> 5) & 31;
        let Rn_post = Rn;
        let opc = (data >> 29) & 3;
        let opc_post = opc;
        let field_28 = (data >> 23) & 63;
        let field_28_post = field_28;
        let sf = (data >> 31) & 1;
        let sf_post = sf;
        let Rd = (data >> 0) & 31;
        let Rd_post = Rd;
        let imms = (data >> 10) & 63;
        let imms_post = imms;


        if ((sf_post == 0) && (N_post == 0)) {
            return Bfm32mBitfield::decode(data as u32, decoder);
        }

        if ((sf_post == 1) && (N_post == 1)) {
            return Bfm64mBitfield::decode(data as u32, decoder);
        }

        unreachable!()
    }
}

/// 32-bit encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
/// <td style="text-align: center" colspan="1">sf</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">N</td>
/// <td style="text-align: center" colspan="6">immr</td>
/// <td style="text-align: center" colspan="6">imms</td>
/// <td style="text-align: center" colspan="5">Rn</td>
/// <td style="text-align: center" colspan="5">Rd</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
///     </tr>
/// </table>
pub struct Bfm32mBitfield;

impl Bfm32mBitfield {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::BFM
    }

    /// Returns the instruction size.
    pub fn size(_instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let immr = (data >> 16) & 63;
        let immr_post = immr;
        let imms = (data >> 10) & 63;
        let imms_post = imms;
        let Rn = (data >> 5) & 31;
        let Rn_post = Rn;
        let Rd = (data >> 0) & 31;
        let Rd_post = Rd;
        
        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.bfm_32m_bitfield.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm32mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm32mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm32mBitfield::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::BfcBfm32mBitfield::decode(data, decoder);
                    return super::BfiBfm32mBitfield::decode(data, decoder);
                    return super::BfxilBfm32mBitfield::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm32mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm32mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm32mBitfield::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        Bfm32mBitfieldAliases::BfcBfm32mBitfield => {
                            if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                                return super::BfcBfm32mBitfield::decode(data, decoder);
                            }
                        }
                        Bfm32mBitfieldAliases::BfiBfm32mBitfield => {
                            if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                                return super::BfiBfm32mBitfield::decode(data, decoder);
                            }
                        }
                        Bfm32mBitfieldAliases::BfxilBfm32mBitfield => {
                            if ((imms_post) >= (immr_post)) {
                                return super::BfxilBfm32mBitfield::decode(data, decoder);
                            }
                        }
                    };
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm32mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm32mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm32mBitfield::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        Bfm32mBitfieldAliases::BfcBfm32mBitfield => return super::BfcBfm32mBitfield::decode(data, decoder),
                        Bfm32mBitfieldAliases::BfiBfm32mBitfield => return super::BfiBfm32mBitfield::decode(data, decoder),
                        Bfm32mBitfieldAliases::BfxilBfm32mBitfield => return super::BfxilBfm32mBitfield::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let Rd_post = Rd;
        let op_0 = Register::aarch32(Rd_post, false)?;
        let Rn_post = Rn;
        let op_1 = Register::aarch32(Rn_post, false)?;
        let immr_post = immr;
        let op_2 = immr_post as u32;
        let imms_post = imms;
        let op_3 = imms_post as u32;

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::BFM_32M_bitfield)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let Rd_pre = instr.op0().as_register()?.encode();
        let Rn_pre = instr.op1().as_register()?.encode();
        let immr_pre = instr.op2().as_unsigned_immediate()? as u32;
        let imms_pre = instr.op3().as_unsigned_immediate()? as u32;

        // Compute all instruction fields from the operand values.
        let Rd = (Rd_pre & 31);
        let Rn = (Rn_pre & 31);
        let immr_pre = immr_pre;
        let immr = (immr_pre & 63);
        let imms_pre = imms_pre;
        let imms = (imms_pre & 63);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b00110011000000000000000000000000;
        instr |= (Rd & 31) << 0;
        instr |= (Rn & 31) << 5;
        instr |= (immr & 63) << 16;
        instr |= (imms & 63) << 10;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            if !r.is_aarch32() {
                todo!()
            }
            if *r == Register::WSP {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            if !r.is_aarch32() {
                todo!()
            }
            if *r == Register::WSP {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::UnsignedImmediate(i) = op {
            if !(0..=31).contains(i) {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::UnsignedImmediate(i) = op {
            if !(0..=31).contains(i) {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.bfm_32m_bitfield, instr)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, 0)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::NumSign)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, FormatterTextKind::NumSign)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_32m_bitfield, instr, 3)?;
        Ok(())
    }
}

/// Type that represents alias identifiers for [`Bfm32mBitfield`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum Bfm32mBitfieldAliases {
    BfcBfm32mBitfield,
    BfiBfm32mBitfield,
    BfxilBfm32mBitfield,
}

/// 64-bit encoding.
///
/// # Encoding
///
/// <table style="font-family: courier, monospace">
///     <tr>
///         <td style="border: none">31</td>
///         <td style="border: none">30</td>
///         <td style="border: none">29</td>
///         <td style="border: none">28</td>
///         <td style="border: none">27</td>
///         <td style="border: none">26</td>
///         <td style="border: none">25</td>
///         <td style="border: none">24</td>
///         <td style="border: none">23</td>
///         <td style="border: none">22</td>
///         <td style="border: none">21</td>
///         <td style="border: none">20</td>
///         <td style="border: none">19</td>
///         <td style="border: none">18</td>
///         <td style="border: none">17</td>
///         <td style="border: none">16</td>
///         <td style="border: none">15</td>
///         <td style="border: none">14</td>
///         <td style="border: none">13</td>
///         <td style="border: none">12</td>
///         <td style="border: none">11</td>
///         <td style="border: none">10</td>
///         <td style="border: none">9</td>
///         <td style="border: none">8</td>
///         <td style="border: none">7</td>
///         <td style="border: none">6</td>
///         <td style="border: none">5</td>
///         <td style="border: none">4</td>
///         <td style="border: none">3</td>
///         <td style="border: none">2</td>
///         <td style="border: none">1</td>
///         <td style="border: none">0</td>
///     </tr>
///     <tr>
/// <td style="text-align: center" colspan="1">sf</td>
///          <td style="text-align: center; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none" colspan="1">1</td>
///          <td style="text-align: center; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">0</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none; border-right: none" colspan="1">1</td>
///          <td style="text-align: center; border-left: none" colspan="1">0</td>
/// <td style="text-align: center" colspan="1">N</td>
/// <td style="text-align: center" colspan="6">immr</td>
/// <td style="text-align: center" colspan="6">imms</td>
/// <td style="text-align: center" colspan="5">Rn</td>
/// <td style="text-align: center" colspan="5">Rd</td>
///     </tr>
///     <tr>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="2">opc</td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="1"></td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="6"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
/// <td style="text-align: center; border: none" colspan="5"></td>
///     </tr>
/// </table>
pub struct Bfm64mBitfield;

impl Bfm64mBitfield {
    /// Returns the instruction mnemonic.
    pub fn mnemonic(_instr: &Instruction) -> Mnemonic {
        Mnemonic::BFM
    }

    /// Returns the instruction size.
    pub fn size(_instr: &Instruction) -> usize {
        4
    }

    /// Decodes the instruction in `data`.
    pub fn decode(data: u32, decoder: &mut Decoder) -> Result<Instruction> {
        // Fields are extracted from the input value.
        let immr = (data >> 16) & 63;
        let immr_post = immr;
        let imms = (data >> 10) & 63;
        let imms_post = imms;
        let Rn = (data >> 5) & 31;
        let Rn_post = Rn;
        let Rd = (data >> 0) & 31;
        let Rd_post = Rd;
        
        /// Checks are performed in case an alias should be used instead of the current encoding.
        match decoder.config.instructions.bfm_64m_bitfield.aliases {
            // No alias configuration for this instruction, we default to the global one.
            None => match decoder.config.global.aliases {
                // We skip the alias checks and use the base encoding.
                FormatAliasGlobal::Never => {},
                // We go through each alias and their conditions, returning the first
                // one that matches.
                FormatAliasGlobal::Recommended => {
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm64mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm64mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm64mBitfield::decode(data, decoder);
                    }
                },
                // We always use the alias, regardless of its condition.
                FormatAliasGlobal::Always => {
                    return super::BfcBfm64mBitfield::decode(data, decoder);
                    return super::BfiBfm64mBitfield::decode(data, decoder);
                    return super::BfxilBfm64mBitfield::decode(data, decoder);
                }
            }
            Some(pref) => match pref {
                FormatAliasInstruction::Never => {},
                FormatAliasInstruction::Recommended => {
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm64mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm64mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm64mBitfield::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Preferred(alias) => {
                    match alias {
                        Bfm64mBitfieldAliases::BfcBfm64mBitfield => {
                            if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                                return super::BfcBfm64mBitfield::decode(data, decoder);
                            }
                        }
                        Bfm64mBitfieldAliases::BfiBfm64mBitfield => {
                            if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                                return super::BfiBfm64mBitfield::decode(data, decoder);
                            }
                        }
                        Bfm64mBitfieldAliases::BfxilBfm64mBitfield => {
                            if ((imms_post) >= (immr_post)) {
                                return super::BfxilBfm64mBitfield::decode(data, decoder);
                            }
                        }
                    };
                    if ((Rn_post == 31) && ((((imms_post) < (immr_post)) || (immr_post == 0)))) {
                        return super::BfcBfm64mBitfield::decode(data, decoder);
                    }
                    if ((Rn_post != 31) && ((imms_post) < (immr_post))) {
                        return super::BfiBfm64mBitfield::decode(data, decoder);
                    }
                    if ((imms_post) >= (immr_post)) {
                        return super::BfxilBfm64mBitfield::decode(data, decoder);
                    }
                },
                FormatAliasInstruction::Always(alias) => {
                    match alias {
                        Bfm64mBitfieldAliases::BfcBfm64mBitfield => return super::BfcBfm64mBitfield::decode(data, decoder),
                        Bfm64mBitfieldAliases::BfiBfm64mBitfield => return super::BfiBfm64mBitfield::decode(data, decoder),
                        Bfm64mBitfieldAliases::BfxilBfm64mBitfield => return super::BfxilBfm64mBitfield::decode(data, decoder),
                    }
                },
            }
        }

        // Operand values are computed from the base fields.
        let Rd_post = Rd;
        let op_0 = Register::aarch64(Rd_post, false)?;
        let Rn_post = Rn;
        let op_1 = Register::aarch64(Rn_post, false)?;
        let immr_post = immr;
        let op_2 = immr_post as u32;
        let imms_post = imms;
        let op_3 = imms_post as u32;

        // Instruction creation from the operands.
        let mut instr = Instruction::builder(Code::BFM_64M_bitfield)
            .operand(0, op_0)?
            .operand(1, op_1)?
            .operand(2, op_2)?
            .operand(3, op_3)?
            .build();
        
        Ok(instr)
    }

    /// Encodes the instruction into `buf`.
    pub fn encode(instr: &Instruction, buf: &mut Vec<u8>) -> Result<usize> {
        // Retrieve all operand values.
        let Rd_pre = instr.op0().as_register()?.encode();
        let Rn_pre = instr.op1().as_register()?.encode();
        let immr_pre = instr.op2().as_unsigned_immediate()? as u32;
        let imms_pre = instr.op3().as_unsigned_immediate()? as u32;

        // Compute all instruction fields from the operand values.
        let Rd = (Rd_pre & 31);
        let Rn = (Rn_pre & 31);
        let immr_pre = immr_pre;
        let immr = (immr_pre & 63);
        let imms_pre = imms_pre;
        let imms = (imms_pre & 63);

        // Add all fields to the base instruction encoding.
        let mut instr: u32 = 0b10110011010000000000000000000000;
        instr |= (Rd & 31) << 0;
        instr |= (Rn & 31) << 5;
        instr |= (immr & 63) << 16;
        instr |= (imms & 63) << 10;

        let bytes = instr.to_le_bytes();
        let len = bytes.len();
        buf.extend(bytes);
        Ok(len)
    }

    /// Encode an instruction part of an instruction block into `buf`.
    pub fn encode_block(instr: &mut Instruction, buf: &mut Vec<u8>, labels: &std::collections::HashMap<u64, u64>) -> Result<usize> {
        Self::encode(instr, buf)
    }
    
    /// Verifies that operand #0 is valid.
    pub fn check_op0(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            if !r.is_aarch64() {
                todo!()
            }
            
            if *r == Register::SP {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #1 is valid.
    pub fn check_op1(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::Register(r) = op {
            if !r.is_aarch64() {
                todo!()
            }
            
            if *r == Register::SP {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #2 is valid.
    pub fn check_op2(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::UnsignedImmediate(i) = op {
            if !(0..=63).contains(i) {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #3 is valid.
    pub fn check_op3(instr: &Instruction, op: &Operand) -> Result<()> {
        if let Operand::UnsignedImmediate(i) = op {
            if !(0..=63).contains(i) {
                todo!()
            }
            return Ok(())
        }
        todo!()
    }
    
    /// Verifies that operand #4 is valid.
    pub fn check_op4(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #5 is valid.
    pub fn check_op5(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }
    
    /// Verifies that operand #6 is valid.
    pub fn check_op6(instr: &Instruction, op: &Operand) -> Result<()> {
        todo!()
    }

    /// Formats the instruction.
    pub fn format(instr: &Instruction, fmt: &mut impl Formatter, output: &mut impl FormatterOutput, config: &Config) -> Result<()> {
        fmt.format_mnemonic(output, &config.global, &config.instructions.bfm_64m_bitfield, instr)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::Space)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, 0)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, 1)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::NumSign)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, 2)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::Comma)?;
        fmt.format_punctuation(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, FormatterTextKind::NumSign)?;
        fmt.format_operand(output, &config.global, &config.instructions.bfm_64m_bitfield, instr, 3)?;
        Ok(())
    }
}

/// Type that represents alias identifiers for [`Bfm64mBitfield`].
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
pub enum Bfm64mBitfieldAliases {
    BfcBfm64mBitfield,
    BfiBfm64mBitfield,
    BfxilBfm64mBitfield,
}