/* ir_opt.c - IR 层优化 pass
 *
 * 通用函数内联（任意大小/形状的 callee，不再限叶子）：
 *   - callee 体内允许 control.call（嵌套调用）、分支/循环、多个返回、unit 返回；
 *   - 参数：克隆体内 Param 的“使用处”替换为调用实参 ref；
 *   - 控制流：克隆体追加到调用者末尾，内部 br/jmp/label 整体 +shift；
 *   - 返回：
 *       * 有返回值：在调用者追加 ret 槽（MemAlloca）与常量 1；每个 Ret 改为
 *         jmp 到“MemStore(槽, val) + jmp(join)”，join 处 MemLoad(槽) 供使用者；
 *       * 无返回值（unit）：每个 Ret 直接 jmp 到调用点之后。
 *   - 调用点改为 jmp 到克隆体入口；其使用者改指到 join 的 MemLoad（或 0）。
 *   - 防环：若 callee（传递）可达 caller，则拒绝内联，保证调用图保持无环、
 *     内联过程终止（直接/间接递归都不会被内联）。
 *   - 迭代到不动点（无环调用图上轮数有上界）。
 * 默认关闭（splc0 --opt 驱动），且只内联显式 `#inline` 标记的 callee。 */

#include "ir_opt.h"

#include <stdlib.h>
#include <string.h>

typedef struct {
    spl_ir_t *ir;
    spl_ir_func_ref_t caller;
    spl_ir_func_ref_t callee;
    spl_ir_node_ref_t shift; /* new = old + shift */
    usize nparams;
    spl_ir_node_ref_t *param_ref;
    spl_ir_node_ref_t *param_arg;
} inline_ctx_t;

static spl_ir_node_t *nd(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_ref_t ref) {
    return spl_ir_node(ir, fid, ref);
}

/* ---- 引用重写（克隆体旧 ref -> 新 ref） ---- */

static spl_ir_node_ref_t rw(inline_ctx_t *c, spl_ir_node_ref_t r) {
    if (r == 0)
        return 0;
    for (usize i = 0; i < c->nparams; i++)
        if (c->param_ref[i] == r)
            return c->param_arg[i];
    return r + c->shift;
}

static void rw_vec(inline_ctx_t *c, spl_ir_node_ref_vec_t *v) {
    for (usize i = 0; i < vec_size(*v); i++)
        vec_at(*v, i) = rw(c, vec_at(*v, i));
}

static void rw_node(inline_ctx_t *c, spl_ir_node_t *n) {
    switch (n->kind) {
    case SPL_IR_ARITH_ADD: case SPL_IR_ARITH_SUB: case SPL_IR_ARITH_MUL:
    case SPL_IR_ARITH_DIV: case SPL_IR_ARITH_REM: case SPL_IR_ARITH_NEG:
    case SPL_IR_ARITH_ABS: case SPL_IR_ARITH_AND: case SPL_IR_ARITH_OR:
    case SPL_IR_ARITH_XOR: case SPL_IR_ARITH_SHL: case SPL_IR_ARITH_SHR:
    case SPL_IR_ARITH_NOT:
        n->arith.left = rw(c, n->arith.left);
        n->arith.right = rw(c, n->arith.right);
        break;
    case SPL_IR_CMP_EQ: case SPL_IR_CMP_NE: case SPL_IR_CMP_LT:
    case SPL_IR_CMP_LE: case SPL_IR_CMP_GT: case SPL_IR_CMP_GE:
        n->cmp.a = rw(c, n->cmp.a);
        n->cmp.b = rw(c, n->cmp.b);
        break;
    case SPL_IR_CAST_TRUNC: case SPL_IR_CAST_ZEXT: case SPL_IR_CAST_SEXT:
    case SPL_IR_CAST_FEXT: case SPL_IR_CAST_FTRUNC: case SPL_IR_CAST_BITCAST:
    case SPL_IR_CAST_PTR2INT: case SPL_IR_CAST_INT2PTR: case SPL_IR_CAST_BOOL2INT:
    case SPL_IR_CASE_INT2FLOAT: case SPL_IR_CASE_FLOAT2INT:
        n->cast.val = rw(c, n->cast.val);
        break;
    case SPL_IR_MEM_ALLOCA:
        n->mem_alloc.count = rw(c, n->mem_alloc.count);
        break;
    case SPL_IR_MEM_GLOBAL_ALLOC:
        n->mem_global_alloc.const_node = rw(c, n->mem_global_alloc.const_node);
        break;
    case SPL_IR_MEM_LOAD:
        n->mem_load.ptr = rw(c, n->mem_load.ptr);
        break;
    case SPL_IR_MEM_STORE:
        n->mem_store.ptr = rw(c, n->mem_store.ptr);
        n->mem_store.val = rw(c, n->mem_store.val);
        break;
    case SPL_IR_MEM_OFFSET:
        n->mem_offset.ptr = rw(c, n->mem_offset.ptr);
        n->mem_offset.offset = rw(c, n->mem_offset.offset);
        break;
    case SPL_IR_MEM_FIELD_PTR:
        n->mem_field_ptr.agg = rw(c, n->mem_field_ptr.agg);
        break;
    case SPL_IR_MEM_COPY:
        n->mem_copy.dst = rw(c, n->mem_copy.dst);
        n->mem_copy.src = rw(c, n->mem_copy.src);
        n->mem_copy.size = rw(c, n->mem_copy.size);
        break;
    case SPL_IR_MEM_SET:
        n->mem_set.dst = rw(c, n->mem_set.dst);
        n->mem_set.val = rw(c, n->mem_set.val);
        n->mem_set.size = rw(c, n->mem_set.size);
        break;
    case SPL_IR_TYPE_OFFSETOF:
        n->ir_offsetof.field_idx = rw(c, n->ir_offsetof.field_idx);
        break;
    case SPL_IR_AGG_CONSTRUCT:
        rw_vec(c, &n->agg_construct.fields);
        break;
    case SPL_IR_AGG_EXTRACT:
        n->agg_extract.val = rw(c, n->agg_extract.val);
        break;
    case SPL_IR_AGG_INSERT:
        n->agg_insert.agg = rw(c, n->agg_insert.agg);
        n->agg_insert.field = rw(c, n->agg_insert.field);
        break;
    case SPL_IR_CONTROL_SELECT:
        n->control_select.cond = rw(c, n->control_select.cond);
        n->control_select.true_val = rw(c, n->control_select.true_val);
        n->control_select.false_val = rw(c, n->control_select.false_val);
        break;
    case SPL_IR_CONTROL_BR:
        n->control_br.cond = rw(c, n->control_br.cond);
        n->control_br.true_label = rw(c, n->control_br.true_label);
        n->control_br.false_label = rw(c, n->control_br.false_label);
        break;
    case SPL_IR_CONTROL_JMP:
        n->control_jmp.label = rw(c, n->control_jmp.label);
        break;
    case SPL_IR_CONTROL_PARAM:
        n->control_param.idx = rw(c, n->control_param.idx);
        break;
    case SPL_IR_CONTROL_RET:
        n->control_ret.val = rw(c, n->control_ret.val);
        break;
    case SPL_IR_CONTROL_CALL:
        n->control_call.func = rw(c, n->control_call.func);
        rw_vec(c, &n->control_call.params);
        break;
    default:
        break;
    }
}

/* ---- 克隆 ---- */

static void clone_ref_vec(spl_ir_node_ref_vec_t *dst, const spl_ir_node_ref_vec_t *src) {
    dst->size = 0;
    dst->cap = 0;
    dst->data = NULL;
    usize n = vec_size(*src);
    if (n == 0)
        return;
    spl_ir_node_ref_t *p = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * n);
    if (!p)
        return;
    memcpy(p, src->data, sizeof(spl_ir_node_ref_t) * n);
    dst->data = p;
    dst->size = n;
    dst->cap = n;
}

static void clone_node(spl_ir_t *ir, spl_ir_func_ref_t caller, spl_ir_node_ref_t dst_ref,
                       const spl_ir_node_t *src) {
    spl_ir_node_t *dst = nd(ir, caller, dst_ref);
    memcpy(dst, src, sizeof(*dst));
    dst->attrs.data = NULL;
    dst->attrs.size = 0;
    dst->attrs.cap = 0;
    if (vec_size(src->attrs) != 0)
        clone_ref_vec((spl_ir_node_ref_vec_t *)&dst->attrs,
                      (const spl_ir_node_ref_vec_t *)&src->attrs);
    if (src->kind == SPL_IR_AGG_CONSTRUCT)
        clone_ref_vec(&dst->agg_construct.fields, &src->agg_construct.fields);
    else if (src->kind == SPL_IR_CONTROL_CALL)
        clone_ref_vec(&dst->control_call.params, &src->control_call.params);
}

/* ---- 调用图可达性（防环） ---- */

static spl_ir_func_ref_t call_callee(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_t *call) {
    spl_ir_node_t *fn = nd(ir, fid, call->control_call.func);
    if (!fn || fn->kind != SPL_IR_TYPE_CONST)
        return 0;
    return fn->type_const.fn;
}

static bool reaches(spl_ir_t *ir, spl_ir_func_ref_t from, spl_ir_func_ref_t target,
                    unsigned char *mark) {
    if (from == 0)
        return false;
    if (from == target)
        return true;
    if (mark[from])
        return false;
    mark[from] = 1;
    spl_ir_func_t *f = spl_ir_func(ir, from);
    if (!f)
        return false;
    usize n = vec_size(f->nodes);
    for (usize i = 1; i < n; i++) {
        spl_ir_node_t *x = nd(ir, from, i);
        if (x && x->kind == SPL_IR_CONTROL_CALL) {
            spl_ir_func_ref_t c = call_callee(ir, from, x);
            if (c != 0 && reaches(ir, c, target, mark))
                return true;
        }
    }
    return false;
}

/* 从 from 的直接被调者出发是否能到达 target（用于判断 from 自身是否递归/自可达）。 */
static bool reaches_succ(spl_ir_t *ir, spl_ir_func_ref_t from, spl_ir_func_ref_t target,
                         unsigned char *mark) {
    spl_ir_func_t *f = spl_ir_func(ir, from);
    if (!f)
        return false;
    usize n = vec_size(f->nodes);
    for (usize i = 1; i < n; i++) {
        spl_ir_node_t *x = nd(ir, from, i);
        if (x && x->kind == SPL_IR_CONTROL_CALL) {
            spl_ir_func_ref_t c = call_callee(ir, from, x);
            if (c != 0 && reaches(ir, c, target, mark))
                return true;
        }
    }
    return false;
}

/* ---- 内联一个调用点 ---- */

typedef struct {
    spl_ir_node_ref_t clone_ref;
    spl_ir_node_ref_t val;
} ret_rec_t;

static bool param_index(spl_ir_t *ir, spl_ir_func_ref_t fid, spl_ir_node_t *p, usize *out) {
    spl_ir_node_t *idx = nd(ir, fid, p->control_param.idx);
    if (!idx || idx->kind != SPL_IR_TYPE_CONST)
        return false;
    *out = idx->type_const.int_lit;
    return true;
}

static spl_ir_node_ref_t find_const_src(spl_ir_t *ir, spl_ir_func_ref_t fid) {
    spl_ir_func_t *f = spl_ir_func(ir, fid);
    if (!f)
        return 0;
    for (usize i = 1; i < vec_size(f->nodes); i++) {
        spl_ir_node_t *x = nd(ir, fid, i);
        if (x && x->kind == SPL_IR_TYPE_CONST)
            return i;
    }
    return 0;
}

static bool try_inline(spl_ir_t *ir, spl_ir_func_ref_t caller, spl_ir_node_ref_t ci,
                       spl_ir_func_ref_t callee) {
    spl_ir_func_t *cf = spl_ir_func(ir, caller);
    spl_ir_func_t *calf = spl_ir_func(ir, callee);
    if (!cf || !calf || callee == caller)
        return false;

    spl_ir_node_t *call = nd(ir, caller, ci);
    if (!call || call->kind != SPL_IR_CONTROL_CALL)
        return false;

    usize orig_len = vec_size(cf->nodes);
    if (ci + 1 >= orig_len)
        return false;

    usize nargs = vec_size(call->control_call.params);

    /* 统计参数与返回，分配动态映射。 */
    usize cnodes = vec_size(calf->nodes);
    usize in_params = 0;
    usize in_rets = 0;
    for (usize i = 1; i < cnodes; i++) {
        spl_ir_node_t *x = nd(ir, callee, i);
        if (!x)
            return false;
        if (x->kind == SPL_IR_CONTROL_PARAM)
            in_params++;
        else if (x->kind == SPL_IR_CONTROL_RET)
            in_rets++;
    }
    if (in_rets == 0 || in_params != nargs)
        return false;

    inline_ctx_t c;
    memset(&c, 0, sizeof(c));
    c.ir = ir;
    c.caller = caller;
    c.callee = callee;
    c.nparams = in_params;
    c.param_ref = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * (in_params ? in_params : 1));
    c.param_arg = (spl_ir_node_ref_t *)malloc(sizeof(spl_ir_node_ref_t) * (in_params ? in_params : 1));
    ret_rec_t *recs = (ret_rec_t *)malloc(sizeof(ret_rec_t) * (in_rets ? in_rets : 1));
    if (!c.param_ref || !c.param_arg || !recs) {
        free(c.param_ref);
        free(c.param_arg);
        free(recs);
        return false;
    }

    spl_type_id_t ret_tid = call->control_call.tid;

    /* 参数映射（旧 ref -> 实参 ref）。 */
    usize pi = 0;
    for (usize i = 1; i < cnodes; i++) {
        spl_ir_node_t *x = nd(ir, callee, i);
        if (x && x->kind == SPL_IR_CONTROL_PARAM) {
            usize idx = 0;
            if (!param_index(ir, callee, x, &idx) || idx >= nargs) {
                free(c.param_ref);
                free(c.param_arg);
                free(recs);
                return false;
            }
            c.param_ref[pi] = i;
            c.param_arg[pi] = vec_at(call->control_call.params, idx);
            pi++;
        }
    }

    bool has_val = false;
    for (usize i = 1; i < cnodes; i++) {
        spl_ir_node_t *x = nd(ir, callee, i);
        if (x && x->kind == SPL_IR_CONTROL_RET && x->control_ret.val != 0)
            has_val = true;
    }
    spl_ir_node_ref_t const_src = find_const_src(ir, callee);
    if (has_val && const_src == 0) {
        free(c.param_ref);
        free(c.param_arg);
        free(recs);
        return false;
    }

    /* 释放调用点原 params（随后 ci 改为 jmp） */
    vec_free(call->control_call.params);

    /* 克隆体入口前置：常量 1 + ret 槽 */
    spl_ir_node_ref_t body_entry = 0;
    spl_ir_node_ref_t slot_ref = 0;
    if (has_val) {
        spl_ir_node_ref_t c_ref = spl_ir_alloc_node(ir, caller);
        clone_node(ir, caller, c_ref, nd(ir, callee, const_src));
        spl_ir_node_t *cn = nd(ir, caller, c_ref);
        cn->kind = SPL_IR_TYPE_CONST;
        cn->type_const.int_lit = 1;

        slot_ref = spl_ir_alloc_node(ir, caller);
        spl_ir_node_t *sn = nd(ir, caller, slot_ref);
        memset(sn, 0, sizeof(*sn));
        sn->kind = SPL_IR_MEM_ALLOCA;
        sn->mem_alloc.tid = ret_tid;
        sn->mem_alloc.count = c_ref;

        body_entry = c_ref;
    }

    c.shift = vec_size(cf->nodes) - 1;
    if (!has_val)
        body_entry = vec_size(cf->nodes);

    /* 克隆体 */
    usize nrec = 0;
    for (usize i = 1; i < cnodes; i++) {
        spl_ir_node_ref_t dst_ref = spl_ir_alloc_node(ir, caller);
        if (dst_ref == 0) {
            free(c.param_ref);
            free(c.param_arg);
            free(recs);
            return false;
        }
        spl_ir_node_t *src = nd(ir, callee, i);
        clone_node(ir, caller, dst_ref, src);
        rw_node(&c, nd(ir, caller, dst_ref));
        spl_ir_node_t *x = nd(ir, caller, dst_ref);
        /* 克隆进来的 Param 使用处已替换为实参，节点本身不能留在调用者里
         * 改变其参数个数；退化为无害常量。 */
        if (src->kind == SPL_IR_CONTROL_PARAM) {
            x->kind = SPL_IR_TYPE_CONST;
            x->type_const.tid = 0;
            x->type_const.int_lit = 0;
            continue;
        }
        if (x->kind == SPL_IR_CONTROL_RET) {
            recs[nrec].clone_ref = dst_ref;
            recs[nrec].val = x->control_ret.val;
            nrec++;
            x->kind = SPL_IR_CONTROL_JMP;
            x->control_jmp.label = 0; /* 稍后回填 */
        }
    }

    spl_ir_node_ref_t ret_new = 0;
    if (has_val) {
        spl_ir_node_ref_t join = spl_ir_alloc_node(ir, caller);
        spl_ir_node_t *jn = nd(ir, caller, join);
        memset(jn, 0, sizeof(*jn));
        jn->kind = SPL_IR_MEM_LOAD;
        jn->mem_load.tid = ret_tid;
        jn->mem_load.ptr = slot_ref;

        /* join 之后跳回调用点的后继（原代码此处靠 fallthrough）。 */
        spl_ir_node_ref_t jc = spl_ir_alloc_node(ir, caller);
        spl_ir_node_t *jcn = nd(ir, caller, jc);
        memset(jcn, 0, sizeof(*jcn));
        jcn->kind = SPL_IR_CONTROL_JMP;
        jcn->control_jmp.label = ci + 1;

        for (usize k = 0; k < nrec; k++) {
            spl_ir_node_ref_t st = spl_ir_alloc_node(ir, caller);
            spl_ir_node_t *stn = nd(ir, caller, st);
            memset(stn, 0, sizeof(*stn));
            stn->kind = SPL_IR_MEM_STORE;
            stn->mem_store.tid = ret_tid;
            stn->mem_store.ptr = slot_ref;
            stn->mem_store.val = recs[k].val;

            spl_ir_node_ref_t jr = spl_ir_alloc_node(ir, caller);
            spl_ir_node_t *jrn = nd(ir, caller, jr);
            memset(jrn, 0, sizeof(*jrn));
            jrn->kind = SPL_IR_CONTROL_JMP;
            jrn->control_jmp.label = join;

            spl_ir_node_t *rn = nd(ir, caller, recs[k].clone_ref);
            rn->control_jmp.label = st;
        }
        ret_new = join;
    } else {
        for (usize k = 0; k < nrec; k++) {
            spl_ir_node_t *rn = nd(ir, caller, recs[k].clone_ref);
            rn->control_jmp.label = ci + 1;
        }
    }

    /* 调用点 -> jmp 到克隆体入口 */
    call = nd(ir, caller, ci);
    call->kind = SPL_IR_CONTROL_JMP;
    call->control_jmp.label = body_entry;

    /* 使用者替换：只把等于 ci 的引用改为 ret_new（不动其它 ref） */
    for (usize j = 1; j < orig_len; j++) {
        spl_ir_node_t *x = nd(ir, caller, j);
        if (!x)
            continue;
        switch (x->kind) {
        case SPL_IR_ARITH_ADD: case SPL_IR_ARITH_SUB: case SPL_IR_ARITH_MUL:
        case SPL_IR_ARITH_DIV: case SPL_IR_ARITH_REM: case SPL_IR_ARITH_NEG:
        case SPL_IR_ARITH_ABS: case SPL_IR_ARITH_AND: case SPL_IR_ARITH_OR:
        case SPL_IR_ARITH_XOR: case SPL_IR_ARITH_SHL: case SPL_IR_ARITH_SHR:
        case SPL_IR_ARITH_NOT:
            if (x->arith.left == ci) x->arith.left = ret_new;
            if (x->arith.right == ci) x->arith.right = ret_new;
            break;
        case SPL_IR_CMP_EQ: case SPL_IR_CMP_NE: case SPL_IR_CMP_LT:
        case SPL_IR_CMP_LE: case SPL_IR_CMP_GT: case SPL_IR_CMP_GE:
            if (x->cmp.a == ci) x->cmp.a = ret_new;
            if (x->cmp.b == ci) x->cmp.b = ret_new;
            break;
        case SPL_IR_CAST_TRUNC: case SPL_IR_CAST_ZEXT: case SPL_IR_CAST_SEXT:
        case SPL_IR_CAST_FEXT: case SPL_IR_CAST_FTRUNC: case SPL_IR_CAST_BITCAST:
        case SPL_IR_CAST_PTR2INT: case SPL_IR_CAST_INT2PTR: case SPL_IR_CAST_BOOL2INT:
        case SPL_IR_CASE_INT2FLOAT: case SPL_IR_CASE_FLOAT2INT:
            if (x->cast.val == ci) x->cast.val = ret_new;
            break;
        case SPL_IR_MEM_ALLOCA:
            if (x->mem_alloc.count == ci) x->mem_alloc.count = ret_new;
            break;
        case SPL_IR_MEM_GLOBAL_ALLOC:
            if (x->mem_global_alloc.const_node == ci) x->mem_global_alloc.const_node = ret_new;
            break;
        case SPL_IR_MEM_LOAD:
            if (x->mem_load.ptr == ci) x->mem_load.ptr = ret_new;
            break;
        case SPL_IR_MEM_STORE:
            if (x->mem_store.ptr == ci) x->mem_store.ptr = ret_new;
            if (x->mem_store.val == ci) x->mem_store.val = ret_new;
            break;
        case SPL_IR_MEM_OFFSET:
            if (x->mem_offset.ptr == ci) x->mem_offset.ptr = ret_new;
            if (x->mem_offset.offset == ci) x->mem_offset.offset = ret_new;
            break;
        case SPL_IR_MEM_FIELD_PTR:
            if (x->mem_field_ptr.agg == ci) x->mem_field_ptr.agg = ret_new;
            break;
        case SPL_IR_MEM_COPY:
            if (x->mem_copy.dst == ci) x->mem_copy.dst = ret_new;
            if (x->mem_copy.src == ci) x->mem_copy.src = ret_new;
            if (x->mem_copy.size == ci) x->mem_copy.size = ret_new;
            break;
        case SPL_IR_MEM_SET:
            if (x->mem_set.dst == ci) x->mem_set.dst = ret_new;
            if (x->mem_set.val == ci) x->mem_set.val = ret_new;
            if (x->mem_set.size == ci) x->mem_set.size = ret_new;
            break;
        case SPL_IR_TYPE_OFFSETOF:
            if (x->ir_offsetof.field_idx == ci) x->ir_offsetof.field_idx = ret_new;
            break;
        case SPL_IR_AGG_CONSTRUCT:
            for (usize k = 0; k < vec_size(x->agg_construct.fields); k++)
                if (vec_at(x->agg_construct.fields, k) == ci)
                    vec_at(x->agg_construct.fields, k) = ret_new;
            break;
        case SPL_IR_AGG_EXTRACT:
            if (x->agg_extract.val == ci) x->agg_extract.val = ret_new;
            break;
        case SPL_IR_AGG_INSERT:
            if (x->agg_insert.agg == ci) x->agg_insert.agg = ret_new;
            if (x->agg_insert.field == ci) x->agg_insert.field = ret_new;
            break;
        case SPL_IR_CONTROL_SELECT:
            if (x->control_select.cond == ci) x->control_select.cond = ret_new;
            if (x->control_select.true_val == ci) x->control_select.true_val = ret_new;
            if (x->control_select.false_val == ci) x->control_select.false_val = ret_new;
            break;
        case SPL_IR_CONTROL_BR:
            if (x->control_br.cond == ci) x->control_br.cond = ret_new;
            break;
        case SPL_IR_CONTROL_CALL:
            if (x->control_call.func == ci) x->control_call.func = ret_new;
            for (usize k = 0; k < vec_size(x->control_call.params); k++)
                if (vec_at(x->control_call.params, k) == ci)
                    vec_at(x->control_call.params, k) = ret_new;
            break;
        case SPL_IR_CONTROL_PARAM:
            if (x->control_param.idx == ci) x->control_param.idx = ret_new;
            break;
        case SPL_IR_CONTROL_RET:
            if (x->control_ret.val == ci) x->control_ret.val = ret_new;
            break;
        default:
            break;
        }
    }

    free(c.param_ref);
    free(c.param_arg);
    free(recs);
    return true;
}

static bool func_has_attr(const spl_attr_t *attr, const spl_ir_func_t *f, const char *name);

static int opt_function(spl_ir_t *ir, spl_ir_func_ref_t fid, const spl_attr_t *attr,
                        unsigned char *mark, usize nfuncs) {
    spl_ir_func_t *f = spl_ir_func(ir, fid);
    if (!f)
        return 0;
    int done = 0;
    usize orig = vec_size(f->nodes);
    for (usize ci = 1; ci < orig; ci++) {
        spl_ir_node_t *x = nd(ir, fid, ci);
        if (!x || x->kind != SPL_IR_CONTROL_CALL)
            continue;
        spl_ir_func_ref_t callee = call_callee(ir, fid, x);
        if (callee == 0 || callee == fid || callee >= nfuncs)
            continue;
        spl_ir_func_t *calf = spl_ir_func(ir, callee);
        if (!func_has_attr(attr, calf, "inline") || func_has_attr(attr, calf, "noinline"))
            continue;
        /* extern 是占位体，绝不能内联。 */
        if (func_has_attr(attr, calf, "extern"))
            continue;
        /* 防环：callee 传递可达 caller 时拒绝（覆盖直接/间接互递归）。 */
        memset(mark, 0, nfuncs);
        if (reaches(ir, callee, fid, mark))
            continue;
        /* 防爆炸：callee 自身递归时拒绝（否则不动点会反复内联其内部调用）。 */
        memset(mark, 0, nfuncs);
        if (reaches_succ(ir, callee, callee, mark))
            continue;
        if (try_inline(ir, fid, ci, callee))
            done++;
    }
    return done;
}

/* 是否带有指定名字的属性/tag。 */
static bool func_has_attr(const spl_attr_t *attr, const spl_ir_func_t *f, const char *name) {
    if (!attr || !f)
        return false;
    for (usize i = 0; i < vec_size(f->attrs); ++i) {
        spl_attr_node_t *a = spl_attr_node((spl_attr_t *)attr, vec_at(f->attrs, i));
        if (!a || !a->info)
            continue;
        if (strcmp(a->info->name, name) == 0)
            return true;
    }
    return false;
}

void spl_ir_opt(spl_ir_t *ir, const spl_attr_t *attr) {
    if (!ir)
        return;
    usize nfuncs = vec_size(ir->funcs);
    unsigned char *mark = (unsigned char *)malloc(nfuncs ? nfuncs : 1);
    if (!mark)
        return;
    /* 无环调用图上，最多 nfuncs 轮即可到不动点。 */
    for (usize pass = 0; pass <= nfuncs; pass++) {
        int total = 0;
        usize n = vec_size(ir->funcs);
        for (spl_ir_func_ref_t fid = 1; fid < n && fid < nfuncs; fid++)
            total += opt_function(ir, fid, attr, mark, nfuncs);
        if (total == 0)
            break;
    }
    free(mark);
}