llvm-native-core-ext 0.1.0

//! LLVM IR Intrinsics Database — Part 2 — extended intrinsic families.
//!
//! Covers intrinsics not covered in the primary llvm_intrinsics.rs:
//! - Matrix intrinsics
//! - Vector predication (vp.*) intrinsics
//! - Constrained FP intrinsics
//! - Hardware loop intrinsics
//! - Stackmap / patchpoint / statepoint intrinsics
//! - Assume bundles
//! - Debug info intrinsics (extended)
//! - ObjC ARC intrinsics
//! - Pointer authentication intrinsics
//! - Convergence control intrinsics
//!
//! Clean-room behavioral reconstruction from the LLVM Language Reference.
//! No LLVM source code is consulted.

use std::collections::HashMap;
use std::fmt;

// ═══════════════════════════════════════════════════════════════════════════
// Intrinsic Descriptor (mirrors llvm_intrinsics.rs types for self-containment)
// ═══════════════════════════════════════════════════════════════════════════

/// Extended intrinsic descriptor.
#[derive(Debug, Clone)]
pub struct IntrinsicDesc2 {
    pub name: String,
    pub return_type: String,
    pub param_types: Vec<String>,
    pub attributes: Vec<IntrinsicAttribute2>,
    pub targets: Vec<String>,
    pub category: IntrinsicCategory2,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IntrinsicAttribute2 {
    NoUnwind,
    ReadNone,
    ReadOnly,
    NoMem,
    ArgMemOnly,
    WillReturn,
    NoSync,
    NoFree,
    InaccessibleMemOnly,
    Speculatable,
    Convergent,
    NoDuplicate,
    IntrNoMem,
    IntrReadMem,
    IntrWriteMem,
    IntrArgMemOnly,
    IntrWillReturn,
    IntrNoCallback,
    IntrCold,
}

impl fmt::Display for IntrinsicAttribute2 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum IntrinsicCategory2 {
    Matrix,
    VectorPredication,
    ConstrainedFP,
    HardwareLoop,
    StackMap,
    AssumeBundles,
    DebugInfo,
    ObjCARC,
    PointerAuth,
    ConvergenceControl,
}

impl fmt::Display for IntrinsicCategory2 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Matrix Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Built-in matrix multiply intrinsic: `llvm.matrix.multiply.*`
///
/// Performs a matrix multiplication of two matrices.
/// Signature: dst = llvm.matrix.multiply(A, B, M, N, K)
///   A: M×K matrix (column major), B: K×N matrix (column major)
///   Result: M×N matrix (column major)
pub fn matrix_multiply(
    return_type: &str,
    a_type: &str,
    b_type: &str,
    m: u32,
    n: u32,
    k: u32,
) -> IntrinsicDesc2 {
    IntrinsicDesc2 {
        name: format!(
            "llvm.matrix.multiply.{}.{}.{}.{}.{}",
            return_type, a_type, b_type, m, n
        ),
        return_type: return_type.to_string(),
        param_types: vec![
            a_type.to_string(),
            b_type.to_string(),
            "i32".to_string(),
            "i32".to_string(),
            "i32".to_string(),
        ],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::ArgMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::Matrix,
    }
}

/// Built-in matrix transpose intrinsic: `llvm.matrix.transpose.*`
///
/// Transposes a matrix.
/// Signature: dst = llvm.matrix.transpose(Src, M, N)
///   Src: M×N matrix, Result: N×M matrix
pub fn matrix_transpose(return_type: &str, src_type: &str, rows: u32, cols: u32) -> IntrinsicDesc2 {
    IntrinsicDesc2 {
        name: format!(
            "llvm.matrix.transpose.{}.{}.{}.{}",
            return_type, src_type, rows, cols
        ),
        return_type: return_type.to_string(),
        param_types: vec![src_type.to_string(), "i32".to_string(), "i32".to_string()],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::ArgMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::Matrix,
    }
}

/// Built-in matrix column-major load: `llvm.matrix.column.major.load.*`
///
/// Loads a matrix from memory in column-major order.
/// Signature: result = llvm.matrix.column.major.load(Ptr, Stride, IsVolatile, Rows, Cols)
pub fn matrix_column_major_load(
    return_type: &str,
    ptr_type: &str,
    stride: u64,
    is_volatile: bool,
    rows: u32,
    cols: u32,
) -> IntrinsicDesc2 {
    IntrinsicDesc2 {
        name: format!(
            "llvm.matrix.column.major.load.{}.{}.{}.{}.{}",
            return_type,
            ptr_type,
            stride,
            if is_volatile { 1 } else { 0 },
            rows
        ),
        return_type: return_type.to_string(),
        param_types: vec![
            ptr_type.to_string(),
            "i64".to_string(),
            "i1".to_string(),
            "i32".to_string(),
            "i32".to_string(),
        ],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            if is_volatile {
                IntrinsicAttribute2::ArgMemOnly
            } else {
                IntrinsicAttribute2::ReadOnly
            },
        ],
        targets: vec![],
        category: IntrinsicCategory2::Matrix,
    }
}

/// Built-in matrix column-major store: `llvm.matrix.column.major.store.*`
///
/// Stores a matrix to memory in column-major order.
/// Signature: llvm.matrix.column.major.store(Matrix, Ptr, Stride, IsVolatile, Rows, Cols)
pub fn matrix_column_major_store(
    matrix_type: &str,
    ptr_type: &str,
    stride: u64,
    is_volatile: bool,
    rows: u32,
    cols: u32,
) -> IntrinsicDesc2 {
    IntrinsicDesc2 {
        name: format!(
            "llvm.matrix.column.major.store.{}.{}.{}.{}.{}",
            matrix_type,
            ptr_type,
            stride,
            if is_volatile { 1 } else { 0 },
            rows
        ),
        return_type: "void".to_string(),
        param_types: vec![
            matrix_type.to_string(),
            ptr_type.to_string(),
            "i64".to_string(),
            "i1".to_string(),
            "i32".to_string(),
            "i32".to_string(),
        ],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::ArgMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::Matrix,
    }
}

/// Return all matrix intrinsics.
pub fn all_matrix_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    // Common matrix multiply configurations
    for m in [2u32, 4, 8] {
        for n in [2u32, 4, 8] {
            for k in [2u32, 4, 8] {
                result.push(matrix_multiply(
                    &format!("<{} x float>", m * n),
                    &format!("<{} x float>", m * k),
                    &format!("<{} x float>", k * n),
                    m,
                    n,
                    k,
                ));
            }
        }
    }

    // Matrix transpose
    for rows in [2u32, 4, 8, 16] {
        for cols in [2u32, 4, 8, 16] {
            if rows != cols {
                result.push(matrix_transpose(
                    &format!("<{} x float>", rows * cols),
                    &format!("<{} x float>", rows * cols),
                    rows,
                    cols,
                ));
            }
        }
    }

    // Column major loads/stores
    for rows in [2u32, 4, 8] {
        for cols in [2u32, 4, 8] {
            result.push(matrix_column_major_load(
                &format!("<{} x float>", rows * cols),
                "ptr",
                cols as u64 * 4,
                false,
                rows,
                cols,
            ));
            result.push(matrix_column_major_store(
                &format!("<{} x float>", rows * cols),
                "ptr",
                cols as u64 * 4,
                false,
                rows,
                cols,
            ));
        }
    }

    result
}

// ═══════════════════════════════════════════════════════════════════════════
// Vector Predication (VP) Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Descriptor for VP intrinsic family.
#[derive(Debug, Clone)]
pub struct VPIntrinsicFamily {
    pub base_name: String,
    pub has_mask: bool,
    pub has_passthru: bool,
    pub operand_count: u8,
    pub is_commutative: bool,
}

/// Generate all VP intrinsic descriptors for a given family.
pub fn make_vp_intrinsics(family: &VPIntrinsicFamily) -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    let type_variants = [
        "i8",
        "i16",
        "i32",
        "i64",
        "half",
        "float",
        "double",
        "<2 x i32>",
        "<4 x i32>",
        "<8 x i32>",
        "<2 x float>",
        "<4 x float>",
        "<8 x float>",
        "<2 x double>",
        "<4 x double>",
    ];

    for ty in &type_variants {
        let mut param_types = Vec::new();

        // Mask parameter
        param_types.push(format!("<vscale x {} x i1>", get_element_count_str(ty)));

        // EVL parameter
        param_types.push("i32".to_string());

        // Operands based on family
        for _ in 0..family.operand_count {
            param_types.push(format!("<vscale x {} x {}>", get_element_count_str(ty), ty));
        }

        let attr = vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
        ];

        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.{}.{}", family.base_name, mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types,
            attributes: attr,
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    result
}

fn get_element_count_str(ty: &str) -> String {
    if ty.starts_with('<') {
        let parts: Vec<&str> = ty.split('x').collect();
        parts[0].trim().to_string()
    } else {
        "1".to_string()
    }
}

fn mangle_type(ty: &str) -> String {
    ty.replace('<', "_").replace('>', "_").replace(' ', "")
}

/// VP integer arithmetic: llvm.vp.add, llvm.vp.sub, llvm.vp.mul, etc.
pub fn vp_integer_arith_intrinsics() -> Vec<IntrinsicDesc2> {
    let families = [
        ("add", 2, true),
        ("sub", 2, false),
        ("mul", 2, true),
        ("sdiv", 2, false),
        ("udiv", 2, false),
        ("srem", 2, false),
        ("urem", 2, false),
        ("and", 2, true),
        ("or", 2, true),
        ("xor", 2, true),
        ("ashr", 2, false),
        ("lshr", 2, false),
        ("shl", 2, false),
        ("smin", 2, true),
        ("smax", 2, true),
        ("umin", 2, true),
        ("umax", 2, true),
    ];

    let mut result = Vec::new();
    for (name, ops, comm) in &families {
        let family = VPIntrinsicFamily {
            base_name: name.to_string(),
            has_mask: true,
            has_passthru: true,
            operand_count: *ops,
            is_commutative: *comm,
        };
        result.extend(make_vp_intrinsics(&family));
    }
    result
}

/// VP floating-point arithmetic: llvm.vp.fadd, llvm.vp.fsub, etc.
pub fn vp_fp_arith_intrinsics() -> Vec<IntrinsicDesc2> {
    let families = [
        ("fadd", 2, true),
        ("fsub", 2, false),
        ("fmul", 2, true),
        ("fdiv", 2, false),
        ("frem", 2, false),
        ("fneg", 1, false),
        ("fabs", 1, false),
        ("fminnum", 2, true),
        ("fmaxnum", 2, true),
        ("fcopysign", 2, false),
        ("sqrt", 1, false),
    ];

    let mut result = Vec::new();
    for (name, ops, comm) in &families {
        let family = VPIntrinsicFamily {
            base_name: name.to_string(),
            has_mask: true,
            has_passthru: true,
            operand_count: *ops,
            is_commutative: *comm,
        };
        result.extend(make_vp_fp_intrinsics(&family));
    }
    result
}

fn make_vp_fp_intrinsics(family: &VPIntrinsicFamily) -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    let type_variants = [
        "half",
        "float",
        "double",
        "<2 x float>",
        "<4 x float>",
        "<8 x float>",
        "<2 x double>",
        "<4 x double>",
    ];

    for ty in &type_variants {
        let mut param_types = Vec::new();
        param_types.push(format!("<vscale x {} x i1>", get_element_count_str(ty)));
        param_types.push("i32".to_string());
        for _ in 0..family.operand_count {
            param_types.push(format!("<vscale x {} x {}>", get_element_count_str(ty), ty));
        }

        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.{}.{}", family.base_name, mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types,
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }
    result
}

/// VP memory intrinsics: llvm.vp.load, llvm.vp.store, llvm.vp.gather, llvm.vp.scatter
pub fn vp_memory_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    let load_store_types = [
        "i8",
        "i16",
        "i32",
        "i64",
        "half",
        "float",
        "double",
        "<2 x i32>",
        "<4 x i32>",
        "<8 x i32>",
        "<2 x float>",
        "<4 x float>",
        "<8 x float>",
    ];

    // VP load: llvm.vp.load(Ty, Ptr, Mask, EVL)
    for ty in &load_store_types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.load.{}", mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types: vec![
                "ptr".to_string(),
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadOnly,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    // VP store: llvm.vp.store(Val, Ptr, Mask, EVL)
    for ty in &load_store_types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.store.{}", mangle_type(ty)),
            return_type: "void".to_string(),
            param_types: vec![
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                "ptr".to_string(),
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    // VP gather: llvm.vp.gather(Val, Ptr, Mask, EVL)
    for ty in &load_store_types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.gather.{}", mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types: vec![
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                "ptr".to_string(),
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadOnly,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    // VP scatter: llvm.vp.scatter(Val, Ptr, Mask, EVL)
    for ty in &load_store_types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.scatter.{}", mangle_type(ty)),
            return_type: "void".to_string(),
            param_types: vec![
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                "ptr".to_string(),
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    result
}

/// VP reduction intrinsics: llvm.vp.reduce.add, llvm.vp.reduce.mul, etc.
pub fn vp_reduce_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();
    let reduce_ops = [
        "add", "mul", "and", "or", "xor", "smin", "smax", "umin", "umax", "fadd", "fmul", "fmin",
        "fmax",
    ];

    let types = [
        "i32",
        "i64",
        "float",
        "double",
        "<2 x i32>",
        "<4 x i32>",
        "<8 x i32>",
        "<2 x float>",
        "<4 x float>",
        "<8 x float>",
    ];

    for op in &reduce_ops {
        for ty in &types {
            let is_fp = op.starts_with('f') || ty.contains("float") || ty.contains("double");
            let elem_ty = if ty.starts_with('<') {
                ty.split("x ").nth(1).unwrap_or("i32")
            } else {
                ty
            };

            result.push(IntrinsicDesc2 {
                name: format!("llvm.vp.reduce.{}.{}", op, mangle_type(ty)),
                return_type: if is_fp {
                    format!("<vscale x 1 x {}>", elem_ty)
                } else {
                    format!("<vscale x 1 x {}>", elem_ty)
                },
                param_types: vec![
                    format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                    format!("<vscale x {} x i1>", get_element_count_str(ty)),
                    "i32".to_string(),
                ],
                attributes: vec![
                    IntrinsicAttribute2::NoUnwind,
                    IntrinsicAttribute2::WillReturn,
                ],
                targets: vec![],
                category: IntrinsicCategory2::VectorPredication,
            });
        }
    }

    result
}

/// VP merge intrinsic: llvm.vp.merge
pub fn vp_merge_selection_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    // VP merge: llvm.vp.merge(Mask, TrueVal, FalseVal, EVL)
    let types = [
        "i32",
        "i64",
        "float",
        "double",
        "<2 x i32>",
        "<4 x i32>",
        "<8 x i32>",
        "<2 x float>",
        "<4 x float>",
        "<8 x float>",
    ];

    for ty in &types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.merge.{}", mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types: vec![
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    // VP select: llvm.vp.select(Mask, TrueVal, FalseVal, EVL)
    for ty in &types {
        result.push(IntrinsicDesc2 {
            name: format!("llvm.vp.select.{}", mangle_type(ty)),
            return_type: format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
            param_types: vec![
                format!("<vscale x {} x i1>", get_element_count_str(ty)),
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                format!("<vscale x {} x {}>", get_element_count_str(ty), ty),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::VectorPredication,
        });
    }

    result
}

/// Get all VP intrinsics.
pub fn all_vp_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();
    result.extend(vp_integer_arith_intrinsics());
    result.extend(vp_fp_arith_intrinsics());
    result.extend(vp_memory_intrinsics());
    result.extend(vp_reduce_intrinsics());
    result.extend(vp_merge_selection_intrinsics());
    result
}

// ═══════════════════════════════════════════════════════════════════════════
// Constrained Floating-Point Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Rounding mode variants for constrained FP intrinsics.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FPRoundingMode {
    /// Round to nearest, ties to even (default).
    Dynamic = 0,
    /// Round to nearest, ties away from zero.
    Tonearest = 1,
    /// Round toward negative infinity.
    Downward = 2,
    /// Round toward positive infinity.
    Upward = 3,
    /// Round toward zero.
    Towardzero = 4,
}

/// Exception behavior for constrained FP intrinsics.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FPExceptionBehavior {
    /// Ignore exception status (default).
    Ignore = 0,
    /// May trap on exception.
    Maytrap = 1,
    /// Strict exception handling.
    Strict = 2,
}

/// Build a constrained FP intrinsic descriptor.
pub fn constrained_fp_intrinsic(
    op: &str,
    return_type: &str,
    operand_types: &[&str],
) -> IntrinsicDesc2 {
    let mut param_types = Vec::new();
    for ot in operand_types {
        param_types.push(ot.to_string());
    }
    param_types.push("metadata".to_string()); // rounding mode
    param_types.push("metadata".to_string()); // exception behavior

    IntrinsicDesc2 {
        name: format!("llvm.experimental.constrained.{}", op),
        return_type: return_type.to_string(),
        param_types,
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
        ],
        targets: vec![],
        category: IntrinsicCategory2::ConstrainedFP,
    }
}

/// Get all constrained FP intrinsics.
pub fn all_constrained_fp_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    let fp_types = ["half", "float", "double", "fp128", "x86_fp80"];
    let binary_ops = ["fadd", "fsub", "fmul", "fdiv", "frem"];
    let unary_ops = [
        "sqrt",
        "fabs",
        "ceil",
        "floor",
        "trunc",
        "round",
        "roundeven",
        "nearbyint",
        "rint",
        "lrint",
        "llrint",
        "lround",
        "llround",
        "fptrunc",
        "fpext",
        "fptoui",
        "fptosi",
        "uitofp",
        "sitofp",
        "fma",
    ];
    let compare_ops = ["fcmps", "fcmp", "fcmps_unordered", "fcmp_unordered"];

    // Binary ops
    for op in &binary_ops {
        for ty in &fp_types {
            result.push(constrained_fp_intrinsic(op, ty, &[ty, ty]));
        }
    }

    // Unary ops
    for op in &unary_ops {
        for ty in &fp_types {
            match *op {
                "fptrunc" => {
                    result.push(constrained_fp_intrinsic("fptrunc", "half", &["float"]));
                    result.push(constrained_fp_intrinsic("fptrunc", "float", &["double"]));
                }
                "fpext" => {
                    result.push(constrained_fp_intrinsic("fpext", "float", &["half"]));
                    result.push(constrained_fp_intrinsic("fpext", "double", &["float"]));
                }
                "fptoui" | "fptosi" => {
                    for int_ty in &["i32", "i64"] {
                        result.push(constrained_fp_intrinsic(op, int_ty, &[ty]));
                    }
                }
                "uitofp" | "sitofp" => {
                    for int_ty in &["i32", "i64"] {
                        result.push(constrained_fp_intrinsic(op, ty, &[int_ty]));
                    }
                }
                "fma" => {
                    result.push(constrained_fp_intrinsic("fma", ty, &[ty, ty, ty]));
                }
                _ => {
                    result.push(constrained_fp_intrinsic(op, ty, &[ty]));
                }
            }
        }
    }

    // Compare ops
    for op in &compare_ops {
        for ty in &fp_types {
            result.push(constrained_fp_intrinsic(op, "i1", &[ty, ty]));
        }
    }

    // Special: pow, powi, exp, exp2, log, log2, log10, sin, cos
    let special_ops = [
        "pow", "powi", "exp", "exp2", "log", "log2", "log10", "sin", "cos",
    ];
    for op in &special_ops {
        for ty in &["float", "double"] {
            if *op == "pow" || *op == "powi" {
                let second_ty = if *op == "powi" { "i32" } else { *ty };
                result.push(constrained_fp_intrinsic(op, ty, &[ty, second_ty]));
            } else {
                result.push(constrained_fp_intrinsic(op, ty, &[ty]));
            }
        }
    }

    result
}

// ═══════════════════════════════════════════════════════════════════════════
// Hardware Loop Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Return hardware loop intrinsics.
pub fn hardware_loop_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.set.loop.iterations: set the iteration count for a hardware loop
        IntrinsicDesc2 {
            name: "llvm.set.loop.iterations.i32".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["i32".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
        IntrinsicDesc2 {
            name: "llvm.set.loop.iterations.i64".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["i64".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
        // llvm.loop.decrement: decrement the loop counter and branch if not zero
        IntrinsicDesc2 {
            name: "llvm.loop.decrement.i32".to_string(),
            return_type: "i32".to_string(),
            param_types: vec!["i32".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
        IntrinsicDesc2 {
            name: "llvm.loop.decrement.i64".to_string(),
            return_type: "i64".to_string(),
            param_types: vec!["i64".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
        // llvm.loop.decrement.reg: decrement a register loop counter
        IntrinsicDesc2 {
            name: "llvm.loop.decrement.reg.i32.i32".to_string(),
            return_type: "i32".to_string(),
            param_types: vec!["i32".to_string(), "i32".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
        IntrinsicDesc2 {
            name: "llvm.loop.decrement.reg.i64.i64".to_string(),
            return_type: "i64".to_string(),
            param_types: vec!["i64".to_string(), "i64".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::HardwareLoop,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Stackmap / Patchpoint Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get stackmap intrinsics.
pub fn stackmap_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.experimental.stackmap: emit a stack map for GC/JIT
        IntrinsicDesc2 {
            name: "llvm.experimental.stackmap".to_string(),
            return_type: "void".to_string(),
            param_types: vec![
                "i64".to_string(), // ID
                "i32".to_string(), // nBytes of shadow
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        // llvm.experimental.patchpoint.void: emit a patchable call site
        IntrinsicDesc2 {
            name: "llvm.experimental.patchpoint.void".to_string(),
            return_type: "void".to_string(),
            param_types: vec![
                "i64".to_string(), // ID
                "i32".to_string(), // nBytes of encoded call instruction
                "ptr".to_string(), // target function
                "i32".to_string(), // nArgs
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        // llvm.experimental.patchpoint.iN: patchpoint returning a value
        IntrinsicDesc2 {
            name: "llvm.experimental.patchpoint.i64".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(),
                "i32".to_string(),
                "ptr".to_string(),
                "i32".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        // llvm.experimental.gc.statepoint: record a GC safepoint call
        IntrinsicDesc2 {
            name: "llvm.experimental.gc.statepoint.p0".to_string(),
            return_type: "token".to_string(),
            param_types: vec![
                "i64".to_string(), // ID
                "i32".to_string(), // number of patch bytes
                "ptr".to_string(), // target function
                "i32".to_string(), // number of call arguments
                "i32".to_string(), // flags
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
    ]
}

/// Get GC relocation intrinsics.
pub fn gc_relocation_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.experimental.gc.result: extract the call result from a statepoint
        IntrinsicDesc2 {
            name: "llvm.experimental.gc.result.ptr".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadNone,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        IntrinsicDesc2 {
            name: "llvm.experimental.gc.result.i32".to_string(),
            return_type: "i32".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadNone,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        IntrinsicDesc2 {
            name: "llvm.experimental.gc.result.i64".to_string(),
            return_type: "i64".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadNone,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
        // llvm.experimental.gc.relocate: relocate a pointer at a statepoint
        IntrinsicDesc2 {
            name: "llvm.experimental.gc.relocate".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec![
                "token".to_string(), // statepoint token
                "i32".to_string(),   // base offset
                "i32".to_string(),   // derived offset
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ReadNone,
            ],
            targets: vec![],
            category: IntrinsicCategory2::StackMap,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Assume Bundles
// ═══════════════════════════════════════════════════════════════════════════

/// Operand bundle tag values for llvm.assume.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AssumeBundleTag {
    /// Align(Ptr, Alignment, Offset): pointer is aligned.
    Align,
    /// Dereferenceable(Ptr, Size): pointer is dereferenceable.
    Dereferenceable,
    /// DereferenceableOrNull(Ptr, Size): pointer is dereferenceable or null.
    DereferenceableOrNull,
    /// NonNull(Ptr): pointer is non-null.
    NonNull,
    /// SeparateStorage(Ptr1, Ptr2): pointers don't alias.
    SeparateStorage,
}

impl AssumeBundleTag {
    pub fn tag_string(&self) -> &'static str {
        match self {
            AssumeBundleTag::Align => "align",
            AssumeBundleTag::Dereferenceable => "dereferenceable",
            AssumeBundleTag::DereferenceableOrNull => "dereferenceable_or_null",
            AssumeBundleTag::NonNull => "nonnull",
            AssumeBundleTag::SeparateStorage => "separate_storage",
        }
    }
}

/// An assume operand bundle.
#[derive(Debug, Clone)]
pub struct AssumeBundle {
    pub tag: AssumeBundleTag,
    pub args: Vec<AssumeBundleArg>,
}

/// An argument to an assume bundle.
#[derive(Debug, Clone)]
pub enum AssumeBundleArg {
    Value(String),
    Integer(u64),
    Constant(String),
}

/// Build assume intrinsic descriptors with common operand bundles.
pub fn assume_bundle_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();

    // Base llvm.assume (already covered in llvm_intrinsics.rs, but extended here)
    result.push(IntrinsicDesc2 {
        name: "llvm.assume".to_string(),
        return_type: "void".to_string(),
        param_types: vec!["i1".to_string()],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::InaccessibleMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::AssumeBundles,
    });

    // Build assume bundle factory methods for documentation
    result.push(IntrinsicDesc2 {
        name: "llvm.assume [\"align\"(ptr, i64, i64)]".to_string(),
        return_type: "void".to_string(),
        param_types: vec![
            "i1".to_string(),
            "ptr".to_string(),
            "i64".to_string(),
            "i64".to_string(),
        ],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::InaccessibleMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::AssumeBundles,
    });

    result.push(IntrinsicDesc2 {
        name: "llvm.assume [\"dereferenceable\"(ptr, i64)]".to_string(),
        return_type: "void".to_string(),
        param_types: vec!["i1".to_string(), "ptr".to_string(), "i64".to_string()],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::InaccessibleMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::AssumeBundles,
    });

    result.push(IntrinsicDesc2 {
        name: "llvm.assume [\"nonnull\"(ptr)]".to_string(),
        return_type: "void".to_string(),
        param_types: vec!["i1".to_string(), "ptr".to_string()],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::InaccessibleMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::AssumeBundles,
    });

    result.push(IntrinsicDesc2 {
        name: "llvm.assume [\"separate_storage\"(ptr, ptr)]".to_string(),
        return_type: "void".to_string(),
        param_types: vec!["i1".to_string(), "ptr".to_string(), "ptr".to_string()],
        attributes: vec![
            IntrinsicAttribute2::NoUnwind,
            IntrinsicAttribute2::WillReturn,
            IntrinsicAttribute2::InaccessibleMemOnly,
        ],
        targets: vec![],
        category: IntrinsicCategory2::AssumeBundles,
    });

    result
}

// ═══════════════════════════════════════════════════════════════════════════
// Debug Info Intrinsics (Extended)
// ═══════════════════════════════════════════════════════════════════════════

/// Get extended debug info intrinsics not in the primary set.
pub fn debug_info_intrinsics_extended() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.dbg.addr: records the address of a local variable
        IntrinsicDesc2 {
            name: "llvm.dbg.addr".to_string(),
            return_type: "void".to_string(),
            param_types: vec![
                "metadata".to_string(), // DILocalVariable
                "metadata".to_string(), // DIExpression
                "metadata".to_string(), // DILocation
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::NoFree,
            ],
            targets: vec![],
            category: IntrinsicCategory2::DebugInfo,
        },
        // llvm.dbg.assign: records a value assignment to a local variable
        IntrinsicDesc2 {
            name: "llvm.dbg.assign".to_string(),
            return_type: "void".to_string(),
            param_types: vec![
                "metadata".to_string(), // value
                "metadata".to_string(), // DILocalVariable
                "metadata".to_string(), // DIExpression
                "metadata".to_string(), // DIAssignID
                "metadata".to_string(), // value address
                "metadata".to_string(), // DIExpression for address
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::NoFree,
            ],
            targets: vec![],
            category: IntrinsicCategory2::DebugInfo,
        },
        // llvm.dbg.label: marks a label in the debug info
        IntrinsicDesc2 {
            name: "llvm.dbg.label".to_string(),
            return_type: "void".to_string(),
            param_types: vec![
                "metadata".to_string(), // DILabel
                "metadata".to_string(), // DILocation
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::NoFree,
            ],
            targets: vec![],
            category: IntrinsicCategory2::DebugInfo,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// ObjC Automatic Reference Counting (ARC) Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Clang ARC use intrinsic: marks a value as "used" for ARC.
pub fn objc_arc_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.objc.clang.arc.use: marks a pointer as used (prevents optimization)
        IntrinsicDesc2 {
            name: "llvm.objc.clang.arc.use".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec![
                "aarch64".to_string(),
                "x86_64".to_string(),
                "arm64".to_string(),
            ],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.retain: increment reference count
        IntrinsicDesc2 {
            name: "llvm.objc.retain".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.release: decrement reference count
        IntrinsicDesc2 {
            name: "llvm.objc.release".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.autorelease: add to autorelease pool
        IntrinsicDesc2 {
            name: "llvm.objc.autorelease".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.storeStrong: store with proper reference counting
        IntrinsicDesc2 {
            name: "llvm.objc.storeStrong".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["ptr".to_string(), "ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.storeWeak: store weak reference
        IntrinsicDesc2 {
            name: "llvm.objc.storeWeak".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["ptr".to_string(), "ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
        // llvm.objc.loadWeak: load weak reference
        IntrinsicDesc2 {
            name: "llvm.objc.loadWeak".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::ArgMemOnly,
            ],
            targets: vec!["aarch64".to_string(), "x86_64".to_string()],
            category: IntrinsicCategory2::ObjCARC,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Pointer Authentication Intrinsics (AArch64 PAC)
// ═══════════════════════════════════════════════════════════════════════════

/// Get pointer authentication intrinsics.
pub fn pointer_auth_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.ptrauth.sign: sign a pointer with a key and discriminator
        IntrinsicDesc2 {
            name: "llvm.ptrauth.sign".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // pointer to sign
                "i32".to_string(), // key
                "i64".to_string(), // discriminator/intrinsically-discriminated
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
        // llvm.ptrauth.auth: authenticate a signed pointer
        IntrinsicDesc2 {
            name: "llvm.ptrauth.auth".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // signed pointer
                "i32".to_string(), // key
                "i64".to_string(), // discriminator
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
        // llvm.ptrauth.resign: re-sign a pointer (auth with old key, sign with new)
        IntrinsicDesc2 {
            name: "llvm.ptrauth.resign".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // signed pointer
                "i32".to_string(), // old key
                "i64".to_string(), // old discriminator
                "i32".to_string(), // new key
                "i64".to_string(), // new discriminator
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
        // llvm.ptrauth.strip: strip the PAC from a signed pointer
        IntrinsicDesc2 {
            name: "llvm.ptrauth.strip".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // signed pointer
                "i32".to_string(), // key (for compat, often ignored)
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
        // llvm.ptrauth.blend: combine address and integer discriminator
        IntrinsicDesc2 {
            name: "llvm.ptrauth.blend".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // address
                "i64".to_string(), // integer discriminator
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
        // llvm.ptrauth.sign.generic: sign generic data (not a code pointer)
        IntrinsicDesc2 {
            name: "llvm.ptrauth.sign.generic".to_string(),
            return_type: "i64".to_string(),
            param_types: vec![
                "i64".to_string(), // data value
                "i64".to_string(), // discriminator
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec!["aarch64".to_string()],
            category: IntrinsicCategory2::PointerAuth,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Convergence Control Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get convergence control intrinsics.
pub fn convergence_control_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        // llvm.experimental.convergence.entry: marks a convergence region entry
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.entry".to_string(),
            return_type: "token".to_string(),
            param_types: vec![],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        // llvm.experimental.convergence.loop: marks a convergence loop
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.loop".to_string(),
            return_type: "token".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        // llvm.experimental.convergence.anchor: convergence anchor point
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.anchor".to_string(),
            return_type: "token".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        // llvm.experimental.convergence.control: convergence control dependency
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.control".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        // llvm.experimental.convergence.begin: begins a convergence scope
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.begin".to_string(),
            return_type: "token".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
                IntrinsicAttribute2::IntrNoMem,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        // llvm.experimental.convergence.end: ends a convergence scope
        IntrinsicDesc2 {
            name: "llvm.experimental.convergence.end".to_string(),
            return_type: "void".to_string(),
            param_types: vec!["token".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
                IntrinsicAttribute2::Convergent,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Intrinsic Database
// ═══════════════════════════════════════════════════════════════════════════

/// Complete intrinsics database for all Part 2 families.
pub struct IntrinsicDatabase2 {
    pub matrix: Vec<IntrinsicDesc2>,
    pub vp: Vec<IntrinsicDesc2>,
    pub constrained_fp: Vec<IntrinsicDesc2>,
    pub hw_loop: Vec<IntrinsicDesc2>,
    pub stackmap: Vec<IntrinsicDesc2>,
    pub gc: Vec<IntrinsicDesc2>,
    pub assume: Vec<IntrinsicDesc2>,
    pub debug: Vec<IntrinsicDesc2>,
    pub objc_arc: Vec<IntrinsicDesc2>,
    pub ptrauth: Vec<IntrinsicDesc2>,
    pub convergence: Vec<IntrinsicDesc2>,
}

impl IntrinsicDatabase2 {
    /// Create a fully populated database.
    pub fn new() -> Self {
        IntrinsicDatabase2 {
            matrix: all_matrix_intrinsics(),
            vp: all_vp_intrinsics(),
            constrained_fp: all_constrained_fp_intrinsics(),
            hw_loop: hardware_loop_intrinsics(),
            stackmap: stackmap_intrinsics(),
            gc: gc_relocation_intrinsics(),
            assume: assume_bundle_intrinsics(),
            debug: debug_info_intrinsics_extended(),
            objc_arc: objc_arc_intrinsics(),
            ptrauth: pointer_auth_intrinsics(),
            convergence: convergence_control_intrinsics(),
        }
    }

    /// Total number of intrinsics in the database.
    pub fn total_count(&self) -> usize {
        self.matrix.len()
            + self.vp.len()
            + self.constrained_fp.len()
            + self.hw_loop.len()
            + self.stackmap.len()
            + self.gc.len()
            + self.assume.len()
            + self.debug.len()
            + self.objc_arc.len()
            + self.ptrauth.len()
            + self.convergence.len()
    }

    /// Find an intrinsic by exact name.
    pub fn find_by_name(&self, name: &str) -> Option<&IntrinsicDesc2> {
        for list in [
            &self.matrix,
            &self.vp,
            &self.constrained_fp,
            &self.hw_loop,
            &self.stackmap,
            &self.gc,
            &self.assume,
            &self.debug,
            &self.objc_arc,
            &self.ptrauth,
            &self.convergence,
        ] {
            for desc in list {
                if desc.name == name {
                    return Some(desc);
                }
            }
        }
        None
    }

    /// Find all intrinsics matching a prefix.
    pub fn find_by_prefix(&self, prefix: &str) -> Vec<&IntrinsicDesc2> {
        let mut result = Vec::new();
        for list in [
            &self.matrix,
            &self.vp,
            &self.constrained_fp,
            &self.hw_loop,
            &self.stackmap,
            &self.gc,
            &self.assume,
            &self.debug,
            &self.objc_arc,
            &self.ptrauth,
            &self.convergence,
        ] {
            for desc in list {
                if desc.name.starts_with(prefix) {
                    result.push(desc);
                }
            }
        }
        result
    }

    /// Find all intrinsics in a given category.
    pub fn find_by_category(&self, category: IntrinsicCategory2) -> Vec<&IntrinsicDesc2> {
        let list = match category {
            IntrinsicCategory2::Matrix => &self.matrix,
            IntrinsicCategory2::VectorPredication => &self.vp,
            IntrinsicCategory2::ConstrainedFP => &self.constrained_fp,
            IntrinsicCategory2::HardwareLoop => &self.hw_loop,
            IntrinsicCategory2::StackMap => {
                let mut result: Vec<&IntrinsicDesc2> = self.stackmap.iter().collect();
                result.extend(self.gc.iter());
                return result;
            }
            IntrinsicCategory2::AssumeBundles => &self.assume,
            IntrinsicCategory2::DebugInfo => &self.debug,
            IntrinsicCategory2::ObjCARC => &self.objc_arc,
            IntrinsicCategory2::PointerAuth => &self.ptrauth,
            IntrinsicCategory2::ConvergenceControl => &self.convergence,
        };
        list.iter().collect()
    }
}

impl Default for IntrinsicDatabase2 {
    fn default() -> Self {
        Self::new()
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Extended Coroutine Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get extended coroutine intrinsics (await/suspend).
pub fn extended_coroutine_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        IntrinsicDesc2 {
            name: "llvm.coro.async.size.replace".to_string(),
            return_type: "i32".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        IntrinsicDesc2 {
            name: "llvm.coro.prepare.async".to_string(),
            return_type: "ptr".to_string(),
            param_types: vec!["ptr".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
        IntrinsicDesc2 {
            name: "llvm.coro.suspend.async".to_string(),
            return_type: "i8".to_string(),
            param_types: vec!["ptr".to_string(), "ptr".to_string(), "ptr".to_string()],
            attributes: vec![IntrinsicAttribute2::NoUnwind],
            targets: vec![],
            category: IntrinsicCategory2::ConvergenceControl,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// AArch64 SVE Vector Predication Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get AArch64 SVE target-specific VP intrinsics.
pub fn aarch64_sve_vp_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();
    let sve_ops = [
        "fadd", "fsub", "fmul", "fdiv", "add", "sub", "mul", "sdiv", "and", "or", "xor",
    ];
    let pred_types = ["nxv4i1", "nxv2i1", "nxv8i1"];
    let vec_types = ["nxv4i32", "nxv2i64", "nxv8i16", "nxv4f32", "nxv2f64"];

    for op in &sve_ops {
        for vt in &vec_types {
            for pt in &pred_types {
                result.push(IntrinsicDesc2 {
                    name: format!("llvm.aarch64.sve.{}.{}.{}", op, vt, pt),
                    return_type: vt.to_string(),
                    param_types: vec![vt.to_string(), vt.to_string(), pt.to_string()],
                    attributes: vec![
                        IntrinsicAttribute2::NoUnwind,
                        IntrinsicAttribute2::WillReturn,
                    ],
                    targets: vec!["aarch64".to_string()],
                    category: IntrinsicCategory2::VectorPredication,
                });
            }
        }
    }
    result
}

// ═══════════════════════════════════════════════════════════════════════════
// RISC-V Vector Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get RISC-V vector (RVV) intrinsics.
pub fn riscv_vector_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();
    let rvv_ops = [
        "vadd",
        "vsub",
        "vmul",
        "vdiv",
        "vand",
        "vor",
        "vxor",
        "vfadd",
        "vfsub",
        "vfmul",
        "vfdiv",
        "vle",
        "vse",
        "vlse",
        "vsse",
        "vrgather",
        "vcompress",
        "vmerge",
        "vredsum",
        "vredmax",
        "vredmin",
    ];
    let lmul_variants = ["v", "v2", "v4", "v8"];

    for op in &rvv_ops {
        for lmul in &lmul_variants {
            result.push(IntrinsicDesc2 {
                name: format!("llvm.riscv.{}.{}.i32.{}", op, lmul, lmul),
                return_type: format!("<{} x i32>", lmul),
                param_types: vec![
                    format!("<{} x i32>", lmul),
                    format!("<{} x i32>", lmul),
                    "i64".to_string(),
                ],
                attributes: vec![
                    IntrinsicAttribute2::NoUnwind,
                    IntrinsicAttribute2::WillReturn,
                ],
                targets: vec!["riscv64".to_string()],
                category: IntrinsicCategory2::VectorPredication,
            });
        }
    }
    result
}

// ═══════════════════════════════════════════════════════════════════════════
// WebAssembly SIMD Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get WebAssembly SIMD intrinsics.
pub fn wasm_simd_intrinsics() -> Vec<IntrinsicDesc2> {
    vec![
        IntrinsicDesc2 {
            name: "llvm.wasm.swizzle".to_string(),
            return_type: "<16 x i8>".to_string(),
            param_types: vec!["<16 x i8>".to_string(), "<16 x i8>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.bitselect".to_string(),
            return_type: "<4 x i32>".to_string(),
            param_types: vec![
                "<4 x i32>".to_string(),
                "<4 x i32>".to_string(),
                "<4 x i32>".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.avgr.unsigned".to_string(),
            return_type: "<16 x i8>".to_string(),
            param_types: vec!["<16 x i8>".to_string(), "<16 x i8>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.narrow.signed".to_string(),
            return_type: "<8 x i16>".to_string(),
            param_types: vec!["<4 x i32>".to_string(), "<4 x i32>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.extend.high.signed".to_string(),
            return_type: "<4 x i32>".to_string(),
            param_types: vec!["<8 x i16>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.trunc.saturate.signed".to_string(),
            return_type: "<4 x i32>".to_string(),
            param_types: vec!["<4 x f32>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.dot".to_string(),
            return_type: "<4 x i32>".to_string(),
            param_types: vec!["<8 x i16>".to_string(), "<8 x i16>".to_string()],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
        IntrinsicDesc2 {
            name: "llvm.wasm.shuffle".to_string(),
            return_type: "<16 x i8>".to_string(),
            param_types: vec![
                "<16 x i8>".to_string(),
                "<16 x i8>".to_string(),
                "<16 x i8>".to_string(),
            ],
            attributes: vec![
                IntrinsicAttribute2::NoUnwind,
                IntrinsicAttribute2::WillReturn,
            ],
            targets: vec!["wasm32".to_string()],
            category: IntrinsicCategory2::VectorPredication,
        },
    ]
}

// ═══════════════════════════════════════════════════════════════════════════
// Element-wise Atomic Memory Intrinsics
// ═══════════════════════════════════════════════════════════════════════════

/// Get element-wise atomic intrinsics.
pub fn elementwise_atomic_intrinsics() -> Vec<IntrinsicDesc2> {
    let mut result = Vec::new();
    let ops = [
        "add", "sub", "and", "or", "xor", "xchg", "max", "min", "umax", "umin",
    ];
    let types = ["i8", "i16", "i32", "i64"];

    for op in &ops {
        for ty in &types {
            result.push(IntrinsicDesc2 {
                name: format!("llvm.memcpy.element.unordered.atomic.{}.{}", op, ty),
                return_type: "void".to_string(),
                param_types: vec![
                    "ptr".to_string(),
                    "ptr".to_string(),
                    "i64".to_string(),
                    "i32".to_string(),
                ],
                attributes: vec![
                    IntrinsicAttribute2::NoUnwind,
                    IntrinsicAttribute2::WillReturn,
                    IntrinsicAttribute2::ArgMemOnly,
                ],
                targets: vec![],
                category: IntrinsicCategory2::VectorPredication,
            });
        }
    }
    result
}

// ═══════════════════════════════════════════════════════════════════════════
// Tests
// ═══════════════════════════════════════════════════════════════════════════

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

    #[test]
    fn test_matrix_intrinsics() {
        let intrinsics = all_matrix_intrinsics();
        assert!(intrinsics.len() > 20);
        // Check we have multiply intrinsics
        let has_multiply = intrinsics.iter().any(|i| i.name.contains("multiply"));
        assert!(has_multiply);
        let has_transpose = intrinsics.iter().any(|i| i.name.contains("transpose"));
        assert!(has_transpose);
        let has_load = intrinsics
            .iter()
            .any(|i| i.name.contains("column.major.load"));
        assert!(has_load);
        let has_store = intrinsics
            .iter()
            .any(|i| i.name.contains("column.major.store"));
        assert!(has_store);
    }

    #[test]
    fn test_vp_intrinsics() {
        let vp = all_vp_intrinsics();
        assert!(vp.len() > 50);
        let has_add = vp.iter().any(|i| i.name.starts_with("llvm.vp.add"));
        assert!(has_add);
        let has_load = vp.iter().any(|i| i.name.starts_with("llvm.vp.load"));
        assert!(has_load);
        let has_store = vp.iter().any(|i| i.name.starts_with("llvm.vp.store"));
        assert!(has_store);
        let has_gather = vp.iter().any(|i| i.name.starts_with("llvm.vp.gather"));
        assert!(has_gather);
        let has_reduce = vp.iter().any(|i| i.name.starts_with("llvm.vp.reduce"));
        assert!(has_reduce);
        let has_merge = vp.iter().any(|i| i.name.starts_with("llvm.vp.merge"));
        assert!(has_merge);
        let has_select = vp.iter().any(|i| i.name.starts_with("llvm.vp.select"));
        assert!(has_select);
    }

    #[test]
    fn test_constrained_fp_intrinsics() {
        let cfp = all_constrained_fp_intrinsics();
        assert!(cfp.len() > 30);
        let has_fadd = cfp.iter().any(|i| i.name.contains("fadd"));
        assert!(has_fadd);
        let has_sqrt = cfp.iter().any(|i| i.name.contains("sqrt"));
        assert!(has_sqrt);
        let has_pow = cfp.iter().any(|i| i.name.contains("pow"));
        assert!(has_pow);
    }

    #[test]
    fn test_hardware_loop_intrinsics() {
        let hw = hardware_loop_intrinsics();
        assert!(hw.len() >= 3);
        let has_set_iter = hw.iter().any(|i| i.name.contains("set.loop.iterations"));
        assert!(has_set_iter);
        let has_decrement = hw.iter().any(|i| i.name.contains("loop.decrement"));
        assert!(has_decrement);
    }

    #[test]
    fn test_stackmap_intrinsics() {
        let sm = stackmap_intrinsics();
        assert!(sm.len() >= 3);
        let has_stackmap = sm.iter().any(|i| i.name.contains("stackmap"));
        assert!(has_stackmap);
        let has_patchpoint = sm.iter().any(|i| i.name.contains("patchpoint"));
        assert!(has_patchpoint);
        let has_statepoint = sm.iter().any(|i| i.name.contains("statepoint"));
        assert!(has_statepoint);
    }

    #[test]
    fn test_gc_relocation_intrinsics() {
        let gc = gc_relocation_intrinsics();
        assert!(gc.len() >= 2);
        let has_result = gc.iter().any(|i| i.name.contains("gc.result"));
        assert!(has_result);
        let has_relocate = gc.iter().any(|i| i.name.contains("gc.relocate"));
        assert!(has_relocate);
    }

    #[test]
    fn test_assume_bundles() {
        let assume = assume_bundle_intrinsics();
        assert!(assume.len() >= 4);
    }

    #[test]
    fn test_debug_info_extended() {
        let dbg = debug_info_intrinsics_extended();
        assert!(!dbg.is_empty());
        let has_addr = dbg.iter().any(|i| i.name.contains("dbg.addr"));
        assert!(has_addr);
        let has_assign = dbg.iter().any(|i| i.name.contains("dbg.assign"));
        assert!(has_assign);
    }

    #[test]
    fn test_objc_arc_intrinsics() {
        let arc = objc_arc_intrinsics();
        assert!(arc.len() >= 6);
        let has_retain = arc.iter().any(|i| i.name.contains("objc.retain"));
        assert!(has_retain);
        let has_release = arc.iter().any(|i| i.name.contains("objc.release"));
        assert!(has_release);
    }

    #[test]
    fn test_pointer_auth_intrinsics() {
        let pa = pointer_auth_intrinsics();
        assert!(pa.len() >= 5);
        let has_sign = pa.iter().any(|i| i.name.contains("ptrauth.sign"));
        assert!(has_sign);
        let has_auth = pa.iter().any(|i| i.name.contains("ptrauth.auth"));
        assert!(has_auth);
    }

    #[test]
    fn test_convergence_intrinsics() {
        let cc = convergence_control_intrinsics();
        assert!(cc.len() >= 3);
    }

    #[test]
    fn test_database_creation() {
        let db = IntrinsicDatabase2::new();
        assert!(db.total_count() > 100);
    }

    #[test]
    fn test_database_find_by_name() {
        let db = IntrinsicDatabase2::new();
        let found = db.find_by_name("llvm.objc.retain");
        assert!(found.is_some());
        assert_eq!(found.unwrap().category, IntrinsicCategory2::ObjCARC);
    }

    #[test]
    fn test_database_find_by_prefix() {
        let db = IntrinsicDatabase2::new();
        let results = db.find_by_prefix("llvm.ptrauth");
        assert!(results.len() >= 3);
    }

    #[test]
    fn test_database_find_by_category() {
        let db = IntrinsicDatabase2::new();
        let results = db.find_by_category(IntrinsicCategory2::PointerAuth);
        assert!(results.len() >= 4);
    }

    #[test]
    fn test_extended_coroutine_intrinsics() {
        let coros = extended_coroutine_intrinsics();
        assert!(coros.len() >= 2);
        let has_suspend = coros.iter().any(|i| i.name.contains("suspend"));
        assert!(has_suspend);
    }

    #[test]
    fn test_aarch64_sve_vp_intrinsics() {
        let sve = aarch64_sve_vp_intrinsics();
        assert!(sve.len() >= 50);
        let has_fadd = sve.iter().any(|i| i.name.contains("fadd"));
        assert!(has_fadd);
        let all_aarch64 = sve
            .iter()
            .all(|i| i.targets.contains(&"aarch64".to_string()));
        assert!(all_aarch64);
    }

    #[test]
    fn test_riscv_vector_intrinsics() {
        let rvv = riscv_vector_intrinsics();
        assert!(rvv.len() >= 30);
        let has_vadd = rvv.iter().any(|i| i.name.contains("vadd"));
        assert!(has_vadd);
    }

    #[test]
    fn test_wasm_simd_intrinsics() {
        let wasm = wasm_simd_intrinsics();
        assert!(wasm.len() >= 5);
        let has_swizzle = wasm.iter().any(|i| i.name.contains("swizzle"));
        assert!(has_swizzle);
    }

    #[test]
    fn test_elementwise_atomic_intrinsics() {
        let atomics = elementwise_atomic_intrinsics();
        assert!(atomics.len() >= 20);
        let has_add = atomics.iter().any(|i| i.name.contains("add"));
        assert!(has_add);
    }
}