weirflow 0.1.0

#![cfg(any(test, feature = "cpu-parity"))]

/// Reference oracle for callgraph construction.
#[must_use]
#[allow(deprecated)]
pub fn callgraph_build(
    direct_calls_in: &[u32],
    indirect_calls_in: &[u32],
    points_to_in: &[u32],
    function_count: u32,
) -> Vec<u32> {
    crate::callgraph::callgraph_build_cpu(
        direct_calls_in,
        indirect_calls_in,
        points_to_in,
        function_count,
    )
}

/// Parity helper for callgraph construction using borrowed dispatch inputs.
pub fn callgraph_build_borrowed_via<F>(
    dispatch: &F,
    direct_calls_in: &[u32],
    indirect_calls_in: &[u32],
    points_to_in: &[u32],
    function_count: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::callgraph::callgraph_build_borrowed_via(
        dispatch,
        direct_calls_in,
        indirect_calls_in,
        points_to_in,
        function_count,
    )
}

/// Reference oracle for cross-language reachability.
#[must_use]
#[allow(deprecated)]
pub fn cross_language(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    edge_is_ffi: &[u32],
    source: &[u32],
    sink: &[u32],
) -> Vec<u32> {
    crate::cross_language::cpu_ref(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        edge_is_ffi,
        source,
        sink,
    )
}

/// Reference oracle for byte-serialized dominator bitmaps.
#[must_use]
#[allow(deprecated)]
pub fn dominator_bitmap_bytes(node_count: u32, succ: &[Vec<u32>], entry: u32) -> Vec<u8> {
    crate::dominators::compute_bitmap_bytes(node_count, succ, entry)
}

/// Reference oracle for row-major dominator sets.
#[must_use]
#[allow(deprecated)]
pub fn dominator_sets(node_count: u32, succ: &[Vec<u32>], entry: u32) -> Vec<u32> {
    crate::dominators::compute_cpu(node_count, succ, entry)
}

/// Reference/parity helper that CPU-builds dominator sets and dispatches
/// the GPU dominator query program for projection evidence.
///
/// This is not a production GPU dominator solver.
#[allow(deprecated)]
pub fn dominator_sets_via<F>(
    dispatch: &F,
    node_count: u32,
    succ: &[Vec<u32>],
    entry: u32,
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[Vec<u8>], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::dominators::compute_via(dispatch, node_count, succ, entry, max_iterations)
}

/// Reference oracle for IFDS reachability closure.
#[must_use]
#[allow(deprecated)]
pub fn ifds_reach_closure(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
) -> Vec<u32> {
    crate::ifds::ifds_reach_closure_cpu(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
    )
}

/// Parity helper for IFDS reachability closure using borrowed dispatch inputs.
pub fn ifds_reach_closure_borrowed_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::ifds::ifds_reach_closure_borrowed_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}

/// Reference oracle for exploded IFDS solving.
#[must_use]
#[allow(deprecated)]
pub fn ifds_solve(
    function_count: u32,
    blocks_per_function: u32,
    fact_count: u32,
    intra: &[(u32, u32, u32)],
    inter: &[(u32, u32, u32, u32)],
    gen_set: &[(u32, u32, u32)],
    kill: &[(u32, u32, u32)],
    seed: &[(u32, u32, u32)],
) -> Vec<u32> {
    crate::ifds_gpu::solve_cpu(
        function_count,
        blocks_per_function,
        fact_count,
        intra,
        inter,
        gen_set,
        kill,
        seed,
    )
}

/// Reference oracle for live-variable closure.
#[must_use]
#[allow(deprecated)]
pub fn live_closure(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
) -> Vec<u32> {
    crate::live::live_closure_cpu(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
    )
}

/// Parity helper for live-variable closure using borrowed dispatch inputs.
///
/// Invariant graph buffers are packed once and reused across fixpoint
/// iterations; production callers with borrowed dispatch support should
/// prefer this over the owning compatibility adapter.
pub fn live_closure_borrowed_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::live::live_closure_borrowed_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}

/// Reference oracle for points-to subset closure.
#[must_use]
#[allow(deprecated)]
pub fn points_to_subset_closure(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
) -> Vec<u32> {
    crate::points_to::cpu_subset_closure(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
    )
}

/// Parity helper for points-to subset closure round-tripped
/// through the GPU points-to Program.
pub fn points_to_subset_closure_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[Vec<u8>], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::points_to::subset_closure_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}

/// Parity helper for points-to subset closure using borrowed dispatch inputs.
pub fn points_to_subset_closure_borrowed_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::points_to::subset_closure_borrowed_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}

/// Reference oracle for reaching-definition closure.
#[must_use]
#[allow(deprecated)]
pub fn reaching_closure(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
) -> Vec<u32> {
    crate::reaching::reaching_closure_cpu(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
    )
}

/// Parity helper for reaching-definition closure using borrowed dispatch inputs.
pub fn reaching_closure_borrowed_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::reaching::reaching_closure_borrowed_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}

/// Reference oracle for backward slicing closure.
#[must_use]
#[allow(deprecated)]
pub fn slice_closure(
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
) -> Vec<u32> {
    crate::slice::slice_closure_cpu(
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
    )
}

/// Parity helper for backward slicing closure using borrowed dispatch inputs.
pub fn slice_closure_borrowed_via<F>(
    dispatch: &F,
    node_count: u32,
    edge_offsets: &[u32],
    edge_targets: &[u32],
    edge_kind_mask: &[u32],
    seed_bits: &[u32],
    max_iterations: u32,
) -> Result<Vec<u32>, String>
where
    F: Fn(&vyre::ir::Program, &[&[u8]], Option<[u32; 3]>) -> Result<Vec<Vec<u8>>, String>,
{
    crate::slice::slice_closure_borrowed_via(
        dispatch,
        node_count,
        edge_offsets,
        edge_targets,
        edge_kind_mask,
        seed_bits,
        max_iterations,
    )
}