llvm-native-core 0.1.10

//! Hexagon Instruction Information — complete instruction set descriptor
//! table covering Hexagon V5/V6 VLIW DSP instructions.
//!
//! Each instruction is described by a `HexagonInstrDesc`.
//!
//! Instruction set coverage:
//! - ALU: ADD, SUB, AND, OR, XOR, COMBINE, EXTRACT, INSERT, SXT, ZXT
//! - Shift: LSL, LSR, ASR, ROR, ROL
//! - Multiply: MPY, MPYU, MPYI, MPYIH, MPYH
//! - Memory: LDW, STW, LDB, STB, LDH, STH, LDD, STD, MEMW, MEMD
//! - Branch: JUMP, JUMPR, JUMPr, CALL, CALLR, JMP, JMPR
//! - Compare: CMPEQ, CMPGT, CMPGTU, CMPLT, CMPLTU
//! - Predicated: IF p0, IF !p0 (conditional execution via predicate registers)
//! - Vector: VADD, VSUB, VMPY, VMPA, VSHUFF, VSHUFFE, VSHUFFO
//!
//! Clean-room reconstruction from the Hexagon V5/V6 Programmer's
//! Reference Manual. Zero LLVM source code consultation.

use super::hexagon_register_info::*;
use std::collections::HashMap;

// ============================================================================
// HexagonOpcode
// ============================================================================

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum HexagonOpcode {
    // ALU
    ADD = 0,
    SUB,
    AND,
    OR,
    XOR,
    NEG,
    NOT,
    COMBINE,
    EXTRACT,
    INSERT,
    SXT,
    ZXT,
    ABS,

    // Shift
    LSL = 20,
    LSR,
    ASR,
    ROR,
    ROL,

    // Multiply
    MPY = 30,
    MPYU,
    MPYI,
    MPYIH,
    MPYH,
    MPYHH,
    MPYSAT,

    // Memory — Load
    LDW = 50,
    LDB,
    LDH,
    LDD,
    LDUW,

    // Memory — Store
    STW = 60,
    STB,
    STH,
    STD,
    MEMW,
    MEMD,
    ALLOCFRAME,
    DEALLOCFRAME,

    // Branch
    JUMP = 80,
    JUMPR,
    JUMPr,
    CALL,
    CALLR,
    JMP,
    JMPR,
    LOOP0,
    LOOP1,
    ENDLOOP0,
    ENDLOOP1,

    // Compare
    CMPEQ = 100,
    CMPGT,
    CMPGTU,
    CMPLT,
    CMPLTU,

    // Predicated move/alu
    MUX = 110,
    TSTBIT,

    // Vector
    VADD = 120,
    VSUB,
    VMPY,
    VMPA,
    VSHUFF,
    VSHUFFE,
    VSHUFFO,
    VALIGN,
    VLUT32,
    VSPLAT,
    VEXTRACT,

    // Pseudo
    NOP = 140,
    LI,
    MOV,

    // ========================================================================
    // HVX — Hexagon Vector eXtensions (128-byte vectors)
    // ========================================================================
    VADDW,
    VSUBW,
    VMULW,
    VMADDW,
    VMPYIEW,
    VMPYIEW_ACC,
    VMPYOW,
    VMPYOW_ACC,
    VABSW,
    VNEGW,
    VNOT,
    VAND,
    VOR,
    VXOR,
    VAVGW,
    VAVGW_RND,
    VNAVGW,
    VMINW,
    VMAXW,
    VCMPEQW,
    VCMPGTW,
    VCMPGTUW,
    VCMPEQH,
    VCMPGTH,
    VCMPGTUH,
    VSHIFTW,
    VSHIFTH,
    VSHIFTB,
    VROTATE,
    VASLW,
    VASRW,
    VLSRW,
    VPERMUTE,
    VSPLATB,
    VSPLATH,
    VINSERT,
    VLUT16,
    VLUT32B,
    VHIST,
    VDEAL,
    VPACK,
    VUNPACK,
    VTRUNCP,
    VROUNDP,
    VFLOAT,
    VFIX,
    VFSADD,
    VFSMUL,
    VFSMAX,
    VFSMIN,

    // ========================================================================
    // Compound instructions (mem + ALU)
    // ========================================================================
    LDW_ADD,
    LDW_SUB,
    STW_ADD,
    STW_SUB,
    LDD_POSTINC,
    STD_POSTINC,

    // ========================================================================
    // Duplex / Solo packet instructions
    // ========================================================================
    DUPLEX_ADD_SUB,
    DUPLEX_LD_ST,
    SOLO_ALU,
    SOLO_MEM,

    // ========================================================================
    // Hardware loop extended
    // ========================================================================
    LOOP0_DUAL,
    LOOP1_DUAL,
    ENDLOOP0_DUAL,
    ENDLOOP1_DUAL,
    SETVLI,
}

// ============================================================================
// HexagonOperandType
// ============================================================================

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HexagonOperandType {
    RegDef,
    RegUse1,
    RegUse2,
    RegBase,
    RegStore,
    PredDef,
    PredUse,
    VecDef,
    VecUse1,
    VecUse2,
    Imm16,
    Imm8,
    Imm5,
    UImm16,
    UImm8,
    BranchOffset,
    CallTarget,
}

// ============================================================================
// HexagonInstrDesc
// ============================================================================

#[derive(Debug, Clone)]
pub struct HexagonInstrDesc {
    pub opcode: HexagonOpcode,
    pub mnemonic: String,
    pub is_terminator: bool,
    pub is_branch: bool,
    pub is_call: bool,
    pub is_return: bool,
    pub may_load: bool,
    pub may_store: bool,
    pub has_side_effects: bool,
    pub is_compare: bool,
    pub is_commutative: bool,
    pub is_cond_branch: bool,
    pub is_predicated: bool,
    pub operand_types: Vec<HexagonOperandType>,
    pub slot_type: u8, // 0=ALU, 1=LD/ST, 2=J, 3=XTYPE
}

// ============================================================================
// HexagonInstrInfo
// ============================================================================

pub struct HexagonInstrInfo {
    pub desc_map: HashMap<HexagonOpcode, HexagonInstrDesc>,
}

impl HexagonInstrInfo {
    pub fn new() -> Self {
        let mut info = HexagonInstrInfo {
            desc_map: HashMap::new(),
        };
        info.register_all();
        info
    }

    pub fn get_desc(&self, opcode: HexagonOpcode) -> Option<&HexagonInstrDesc> {
        self.desc_map.get(&opcode)
    }

    pub fn get_mnemonic(&self, opcode: HexagonOpcode) -> String {
        self.desc_map
            .get(&opcode)
            .map(|d| d.mnemonic.clone())
            .unwrap_or_else(|| "INVALID".into())
    }

    fn add(
        &mut self,
        opcode: HexagonOpcode,
        mnemonic: &str,
        is_terminator: bool,
        is_branch: bool,
        is_call: bool,
        is_return: bool,
        may_load: bool,
        may_store: bool,
        has_side_effects: bool,
        is_compare: bool,
        is_commutative: bool,
        is_cond_branch: bool,
        is_predicated: bool,
        operand_types: Vec<HexagonOperandType>,
        slot_type: u8,
    ) {
        self.desc_map.insert(
            opcode,
            HexagonInstrDesc {
                opcode,
                mnemonic: mnemonic.to_string(),
                is_terminator,
                is_branch,
                is_call,
                is_return,
                may_load,
                may_store,
                has_side_effects,
                is_compare,
                is_commutative,
                is_cond_branch,
                is_predicated,
                operand_types,
                slot_type,
            },
        );
    }

    fn register_all(&mut self) {
        use HexagonOperandType::*;

        let alu_3r = vec![RegDef, RegUse1, RegUse2];
        let alu_2r = vec![RegDef, RegUse1];

        self.add(
            HexagonOpcode::ADD,
            "add",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::SUB,
            "sub",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::AND,
            "and",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::OR,
            "or",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::XOR,
            "xor",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::NEG,
            "neg",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_2r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::NOT,
            "not",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_2r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::COMBINE,
            "combine",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            vec![RegDef, RegUse1, RegUse2],
            0,
        );
        self.add(
            HexagonOpcode::EXTRACT,
            "extract",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            vec![RegDef, RegUse1, UImm8],
            0,
        );
        self.add(
            HexagonOpcode::INSERT,
            "insert",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            vec![RegDef, RegUse1, UImm8],
            0,
        );
        self.add(
            HexagonOpcode::SXT,
            "sxt",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_2r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::ZXT,
            "zxt",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_2r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::ABS,
            "abs",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_2r.clone(),
            0,
        );

        // Shift
        let shift_3r = vec![RegDef, RegUse1, RegUse2];
        self.add(
            HexagonOpcode::LSL,
            "lsl",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            shift_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::LSR,
            "lsr",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            shift_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::ASR,
            "asr",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            shift_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::ROR,
            "ror",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            shift_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::ROL,
            "rol",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            shift_3r.clone(),
            0,
        );

        // Multiply
        self.add(
            HexagonOpcode::MPY,
            "mpy",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::MPYU,
            "mpyu",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::MPYI,
            "mpyi",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::MPYIH,
            "mpyih",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            alu_3r.clone(),
            0,
        );
        self.add(
            HexagonOpcode::MPYH,
            "mpyh",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            true,
            alu_3r.clone(),
            0,
        );

        // Memory — Load
        let mem_load = vec![RegDef, RegBase, UImm16];
        self.add(
            HexagonOpcode::LDW,
            "ldw",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            mem_load.clone(),
            1,
        );
        self.add(
            HexagonOpcode::LDB,
            "ldb",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            mem_load.clone(),
            1,
        );
        self.add(
            HexagonOpcode::LDH,
            "ldh",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            mem_load.clone(),
            1,
        );
        self.add(
            HexagonOpcode::LDD,
            "ldd",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            mem_load.clone(),
            1,
        );

        // Memory — Store
        let mem_store = vec![RegStore, RegBase, UImm16];
        self.add(
            HexagonOpcode::STW,
            "stw",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            mem_store.clone(),
            1,
        );
        self.add(
            HexagonOpcode::STB,
            "stb",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            mem_store.clone(),
            1,
        );
        self.add(
            HexagonOpcode::STH,
            "sth",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            mem_store.clone(),
            1,
        );
        self.add(
            HexagonOpcode::STD,
            "std",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            mem_store.clone(),
            1,
        );
        self.add(
            HexagonOpcode::MEMW,
            "memw",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            1,
        );
        self.add(
            HexagonOpcode::MEMD,
            "memd",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            1,
        );

        // Branch
        self.add(
            HexagonOpcode::JUMP,
            "jump",
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![BranchOffset],
            2,
        );
        self.add(
            HexagonOpcode::JUMPR,
            "jumpr",
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegUse1],
            2,
        );
        self.add(
            HexagonOpcode::JUMPr,
            "jumpr",
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            vec![RegUse1],
            2,
        );
        self.add(
            HexagonOpcode::CALL,
            "call",
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![CallTarget],
            2,
        );
        self.add(
            HexagonOpcode::CALLR,
            "callr",
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegUse1],
            2,
        );
        self.add(
            HexagonOpcode::JMP,
            "jmp",
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![BranchOffset],
            2,
        );
        self.add(
            HexagonOpcode::JMPR,
            "jmpr",
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegUse1],
            2,
        );
        self.add(
            HexagonOpcode::LOOP0,
            "loop0",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![BranchOffset, Imm8],
            2,
        );
        self.add(
            HexagonOpcode::LOOP1,
            "loop1",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![BranchOffset, Imm8],
            2,
        );
        self.add(
            HexagonOpcode::ENDLOOP0,
            "endloop0",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            2,
        );
        self.add(
            HexagonOpcode::ENDLOOP1,
            "endloop1",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            2,
        );

        // Compare
        let cmp_3op = vec![PredDef, RegUse1, RegUse2];
        self.add(
            HexagonOpcode::CMPEQ,
            "cmpeq",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            cmp_3op.clone(),
            0,
        );
        self.add(
            HexagonOpcode::CMPGT,
            "cmpgt",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            cmp_3op.clone(),
            0,
        );
        self.add(
            HexagonOpcode::CMPGTU,
            "cmpgtu",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            cmp_3op.clone(),
            0,
        );
        self.add(
            HexagonOpcode::CMPLT,
            "cmplt",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            cmp_3op.clone(),
            0,
        );
        self.add(
            HexagonOpcode::CMPLTU,
            "cmpltu",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            cmp_3op.clone(),
            0,
        );

        // MUX
        self.add(
            HexagonOpcode::MUX,
            "mux",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            vec![RegDef, PredUse, RegUse1, RegUse2],
            0,
        );

        // Vector
        let vec_3op = vec![VecDef, VecUse1, VecUse2];
        self.add(
            HexagonOpcode::VADD,
            "vadd",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            vec_3op.clone(),
            3,
        );
        self.add(
            HexagonOpcode::VSUB,
            "vsub",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec_3op.clone(),
            3,
        );
        self.add(
            HexagonOpcode::VMPY,
            "vmpy",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            vec_3op.clone(),
            3,
        );
        self.add(
            HexagonOpcode::VMPA,
            "vmpa",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2, RegUse1],
            3,
        );
        self.add(
            HexagonOpcode::VSHUFF,
            "vshuff",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec_3op.clone(),
            3,
        );
        self.add(
            HexagonOpcode::VSHUFFE,
            "vshuffe",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec_3op.clone(),
            3,
        );
        self.add(
            HexagonOpcode::VSHUFFO,
            "vshuffo",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec_3op.clone(),
            3,
        );

        // Pseudo
        self.add(
            HexagonOpcode::NOP,
            "nop",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![],
            0,
        );
        self.add(
            HexagonOpcode::LI,
            "li",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, Imm16],
            0,
        );
        self.add(
            HexagonOpcode::MOV,
            "mov",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegUse1],
            0,
        );

        // ================================================================
        // HVX — 128-byte vector operations
        // ================================================================
        let hvx_3r: Vec<(&str, HexagonOpcode)> = vec![
            ("vaddw", HexagonOpcode::VADDW),
            ("vsubw", HexagonOpcode::VSUBW),
            ("vmulw", HexagonOpcode::VMULW),
            ("vmaddw", HexagonOpcode::VMADDW),
            ("vand", HexagonOpcode::VAND),
            ("vor", HexagonOpcode::VOR),
            ("vxor", HexagonOpcode::VXOR),
            ("vavgw", HexagonOpcode::VAVGW),
            ("vavgw.rnd", HexagonOpcode::VAVGW_RND),
            ("vnavgw", HexagonOpcode::VNAVGW),
            ("vminw", HexagonOpcode::VMINW),
            ("vmaxw", HexagonOpcode::VMAXW),
            ("vshiftw", HexagonOpcode::VSHIFTW),
            ("vshifth", HexagonOpcode::VSHIFTH),
            ("vshiftb", HexagonOpcode::VSHIFTB),
            ("vrotate", HexagonOpcode::VROTATE),
            ("vaslw", HexagonOpcode::VASLW),
            ("vasrw", HexagonOpcode::VASRW),
            ("vlsrw", HexagonOpcode::VLSRW),
        ];
        for (mn, op) in hvx_3r {
            self.add(
                op,
                mn,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                vec![VecDef, VecUse1, VecUse2],
                3,
            );
        }
        let hvx_2r: Vec<(&str, HexagonOpcode)> = vec![
            ("vabsw", HexagonOpcode::VABSW),
            ("vnegw", HexagonOpcode::VNEGW),
            ("vnot", HexagonOpcode::VNOT),
            ("vpermute", HexagonOpcode::VPERMUTE),
            ("vdeal", HexagonOpcode::VDEAL),
            ("vshuff", HexagonOpcode::VSHUFF),
            ("vpack", HexagonOpcode::VPACK),
            ("vunpack", HexagonOpcode::VUNPACK),
            ("vtruncp", HexagonOpcode::VTRUNCP),
            ("vroundp", HexagonOpcode::VROUNDP),
            ("vfloat", HexagonOpcode::VFLOAT),
            ("vfix", HexagonOpcode::VFIX),
        ];
        for (mn, op) in hvx_2r {
            self.add(
                op,
                mn,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                vec![VecDef, VecUse1],
                3,
            );
        }
        let hvx_compare: Vec<(&str, HexagonOpcode)> = vec![
            ("vcmpeqw", HexagonOpcode::VCMPEQW),
            ("vcmpgtw", HexagonOpcode::VCMPGTW),
            ("vcmpgtuw", HexagonOpcode::VCMPGTUW),
            ("vcmpeqh", HexagonOpcode::VCMPEQH),
            ("vcmpgth", HexagonOpcode::VCMPGTH),
            ("vcmpgtuh", HexagonOpcode::VCMPGTUH),
        ];
        for (mn, op) in hvx_compare {
            self.add(
                op,
                mn,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                false,
                vec![VecDef, VecUse1, VecUse2],
                3,
            );
        }
        // HVX specialized
        self.add(
            HexagonOpcode::VSPLATB,
            "vsplatb",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, RegUse1],
            3,
        );
        self.add(
            HexagonOpcode::VSPLATH,
            "vsplath",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, RegUse1],
            3,
        );
        self.add(
            HexagonOpcode::VINSERT,
            "vinsert",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, RegUse1],
            3,
        );
        self.add(
            HexagonOpcode::VLUT16,
            "vlut16",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, RegUse2],
            3,
        );
        self.add(
            HexagonOpcode::VLUT32B,
            "vlut32b",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, RegUse2],
            3,
        );
        self.add(
            HexagonOpcode::VHIST,
            "vhist",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1],
            3,
        );
        self.add(
            HexagonOpcode::VFSADD,
            "vfsadd",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2],
            3,
        );
        self.add(
            HexagonOpcode::VFSMUL,
            "vfsmul",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2],
            3,
        );
        self.add(
            HexagonOpcode::VFSMAX,
            "vfsmax",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2],
            3,
        );
        self.add(
            HexagonOpcode::VFSMIN,
            "vfsmin",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2],
            3,
        );

        // Compound instructions
        self.add(
            HexagonOpcode::LDW_ADD,
            "ldw_add",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegBase, RegUse2],
            1,
        );
        self.add(
            HexagonOpcode::LDW_SUB,
            "ldw_sub",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegBase, RegUse2],
            1,
        );
        self.add(
            HexagonOpcode::STW_ADD,
            "stw_add",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            vec![RegBase, RegStore, RegUse2],
            1,
        );
        self.add(
            HexagonOpcode::STW_SUB,
            "stw_sub",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            vec![RegBase, RegStore, RegUse2],
            1,
        );
        self.add(
            HexagonOpcode::LDD_POSTINC,
            "ldd++",
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegBase],
            1,
        );
        self.add(
            HexagonOpcode::STD_POSTINC,
            "std++",
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            false,
            vec![RegBase, RegStore],
            1,
        );

        // Duplex / Solo packets
        self.add(
            HexagonOpcode::DUPLEX_ADD_SUB,
            "duplex_add_sub",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![RegDef, RegUse1, RegUse2],
            0,
        );
        self.add(
            HexagonOpcode::DUPLEX_LD_ST,
            "duplex_ld_st",
            false,
            false,
            false,
            false,
            true,
            true,
            true,
            false,
            false,
            false,
            false,
            vec![VecDef, VecUse1, VecUse2],
            0,
        );
        self.add(
            HexagonOpcode::SOLO_ALU,
            "solo_alu",
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegUse1, RegUse2],
            0,
        );
        self.add(
            HexagonOpcode::SOLO_MEM,
            "solo_mem",
            false,
            false,
            false,
            false,
            true,
            true,
            false,
            false,
            false,
            false,
            false,
            vec![RegDef, RegBase],
            0,
        );

        // Hardware loop extended
        self.add(
            HexagonOpcode::LOOP0_DUAL,
            "loop0_dual",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![RegUse1, Imm16],
            2,
        );
        self.add(
            HexagonOpcode::LOOP1_DUAL,
            "loop1_dual",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![RegUse1, Imm16],
            2,
        );
        self.add(
            HexagonOpcode::ENDLOOP0_DUAL,
            "endloop0_dual",
            true,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            2,
        );
        self.add(
            HexagonOpcode::ENDLOOP1_DUAL,
            "endloop1_dual",
            true,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![],
            2,
        );
        self.add(
            HexagonOpcode::SETVLI,
            "setvli",
            false,
            false,
            false,
            false,
            false,
            false,
            true,
            false,
            false,
            false,
            false,
            vec![RegUse1],
            0,
        );
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_hexagon_opcode_count() {
        let info = HexagonInstrInfo::new();
        assert!(info.get_desc(HexagonOpcode::ADD).is_some());
        assert!(info.get_desc(HexagonOpcode::VADDW).is_some());
        assert!(info.get_desc(HexagonOpcode::LDW_ADD).is_some());
        assert!(info.get_desc(HexagonOpcode::DUPLEX_ADD_SUB).is_some());
    }

    #[test]
    fn test_hexagon_branch() {
        let info = HexagonInstrInfo::new();
        let j = info.get_desc(HexagonOpcode::JUMP).unwrap();
        assert!(j.is_branch);
        assert!(j.is_terminator);
    }

    #[test]
    fn test_hvx_present() {
        let info = HexagonInstrInfo::new();
        assert!(info.get_desc(HexagonOpcode::VADDW).is_some());
        assert!(info.get_desc(HexagonOpcode::VMULW).is_some());
        assert!(info.get_desc(HexagonOpcode::VSPLATB).is_some());
    }
}