execute_unit.cpp

module xfvm;

import xfvm.base;
import xfvm.error;
import xfvm.bytecode;

import std;

using base::u16
    , base::u32
    , base::u64
    , base::i8
    , base::i64
    , base::i64
    , base::i16
    , error::ErrorKind
    , bytecode::OpCode
    , bytecode::KValue
;

using enum ErrorKind;

using enum OpCode;

namespace xfvm {


/// binary operator
auto VM::exec_binary(auto op) -> void {
    u32 rd  = bytecode_.op_pool[pc_++];
    u32 rs1 = bytecode_.op_pool[pc_++];
    u32 rs2 = bytecode_.op_pool[pc_++];
    u64 v1  = read_register(rs1);
    u64 v2  = read_register(rs2);
    u64 res = op(v1, v2);
    write_register(rd, res);
}


/// unary operator
auto VM::exec_unary(auto op) -> void {
    u32 rd = bytecode_.op_pool[pc_++];
    u32 rs = bytecode_.op_pool[pc_++];
    u64 v  = read_register(rs);
    u64 res = op(v);
    write_register(rd, res);
}


/// compare
auto VM::exec_compare(auto pred) -> void {
    u32 rd  = bytecode_.op_pool[pc_++];
    u32 rs1 = bytecode_.op_pool[pc_++];
    u32 rs2 = bytecode_.op_pool[pc_++];
    u64 v1  = read_register(rs1);
    u64 v2  = read_register(rs2);
    bool cond = pred(v1, v2);
    write_register(rd, cond ? 1 : 0);
}


/// jump
auto VM::exec_jump() -> void {
    i32 off;
    std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
    pc_ += 4;
    pc_ = pc_ + off;
}


/// indirect jump
auto VM::exec_indirect_jump() -> void {
    u32 rs = bytecode_.op_pool[pc_++];
    pc_ = (u32) read_register(rs);
}


/// cond jump
auto VM::exec_jump_if(auto pred) -> void {
    u32 rs = bytecode_.op_pool[pc_++];
    i32 off;
    std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
    pc_ += 4;
    u64 v = read_register(rs);
    if (pred(v)) pc_ = pc_ + off;
}


/// jump compare
auto VM::exec_jump_compare(auto pred) -> void {
    u32 rs1 = bytecode_.op_pool[pc_++];
    u32 rs2 = bytecode_.op_pool[pc_++];
    i32 off;
    std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
    pc_ += 4;
    u64 v1 = read_register(rs1);
    u64 v2 = read_register(rs2);
    if (pred(v1, v2)) pc_ = pc_ + off;
}

/// Execute Unit
auto VM::execute() -> ErrorKind {
    while (true) {
        if (pc_ >= bytecode_.op_pool_size) [[unlikely]]
            return IllegalInstruction;

        auto op = (OpCode) bytecode_.op_pool[pc_++];
        instr_count_++;

        switch (op) {

        // Arithmetic & logic (rd = rs1 op rs2)
        case Add: {
            exec_binary(std::plus<u64>());
            break;
        }
        case Sub: {
            exec_binary(std::minus<u64>());
            break;
        }
        case Mul: {
            exec_binary(std::multiplies<u64>());
            break;
        }
        case Div: {
            exec_binary([](u64 a, u64 b) { return (u64)((i64)a / (i64)b); });
            break;
        }
        case Rem: {
            exec_binary([](u64 a, u64 b) { return (u64)((i64)a % (i64)b); });
            break;
        }
        case DivU: {
            exec_binary(std::divides<u64>());
            break;
        }
        case RemU: {
            exec_binary(std::modulus<u64>());
            break;
        }
        case BitAnd: {
            exec_binary(std::bit_and<u64>());
            break;
        }
        case BitOr: {
            exec_binary(std::bit_or<u64>());
            break;
        }
        case BitXor: {
            exec_binary(std::bit_xor<u64>());
            break;
        }
        case BitSll: {
            exec_binary([](u64 a, u64 b) { return a << b; });
            break;
        }
        case BitSrl: {
            exec_binary([](u64 a, u64 b) { return a >> b; });
            break;
        }
        case BitSra: {
            exec_binary([](u64 a, u64 b) { return (u64)((i64)a >> b); });
            break;
        }

        case BitNot: {
            exec_unary(std::bit_not<u64>());
            break;
        }

        // Set‑on‑comparison (rd = (rs1 cond rs2) ? 1 : 0)
        // Layout: [op][rd][rs1][rs2]
        case SetIfEq: {
            exec_compare(std::equal_to<u64>());
            break;
        }
        case SetIfNe: {
            exec_compare(std::not_equal_to<u64>());
            break;
        }
        case SetIfLt: {
            exec_compare([](u64 a, u64 b) { return (i64)a < (i64)b; });
            break;
        }
        case SetIfGe: {
            exec_compare([](u64 a, u64 b) { return (i64)a >= (i64)b; });
            break;
        }
        case SetIfLtU: {
            exec_compare(std::less<u64>());
            break;
        }
        case SetIfGeU: {
            exec_compare(std::greater_equal<u64>());
            break;
        }

        case JumpIfTrue: {
            exec_jump_if([](u64 v) { return v != 0; });
            break;
        }
        case JumpIfFalse: {
            exec_jump_if([](u64 v) { return v == 0; });
            break;
        }
        case JumpIfLe: {
            exec_jump_compare([](u64 a, u64 b) { return (i64)a <= (i64)b; });
            break;
        }
        case JumpIfGe: {
            exec_jump_compare([](u64 a, u64 b) { return (i64)a >= (i64)b; });
            break;
        }
        case JumpIfGt: {
            exec_jump_compare([](u64 a, u64 b) { return (i64)a >  (i64)b; });
            break;
        }
        case JumpIfLt: {
            exec_jump_compare([](u64 a, u64 b) { return (i64)a <  (i64)b; });
            break;
        }
        case Jump: {
            exec_jump();
            break;
        }
        case IndirectJump: {
            exec_indirect_jump();
            break;
        }

        // Subroutine
        case Call: {
            i32 off;
            std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
            pc_ += 4;
            set_ra(pc_);
            pc_ = pc_ + off;
            break;
        }
        case Return: {
            pc_ = (u32) get_ra();
            break;
        }

        // Memory (rd = mem[rs1 + offset], or mem[rs1 + offset] = rs2)
        // Layout: Load/LoadU/Store [op][rd][rs1][offset:i16]
        // Load: load 8 bytes from memory into rd
        case Load: {

            u32 rd  = bytecode_.op_pool[pc_++];
            u32 rs1 = bytecode_.op_pool[pc_++];
            i16 off;
            std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
            pc_ += 2;

            u64 base = read_register(rs1);
            u8* addr = (u8*)(base) + off;

            // Boundary check: address must lie inside global or stack area
            if (!((addr >= gp_base_ && addr + 8 <= gp_base_ + gp_size_) ||
                  (addr >= stack_base_ && addr + 8 <= stack_base_ + stack_size_)))
                [[unlikely]]
                return MemoryAccessViolation;

            u64 val;
            std::memcpy(&val, addr, sizeof(val));
            write_register(rd, val);
            break;
        }

        // LoadU: load 4 bytes, zero‑extend to 64 bits
        case LoadU: {

            u32 rd  = bytecode_.op_pool[pc_++];
            u32 rs1 = bytecode_.op_pool[pc_++];
            i16 off;
            std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
            pc_ += 2;

            u64 base = read_register(rs1);
            u8* addr = (u8*)(base) + off;

            if (!((addr >= gp_base_ && addr + 4 <= gp_base_ + gp_size_) ||
                  (addr >= stack_base_ && addr + 4 <= stack_base_ + stack_size_)))
                [[unlikely]]
                return MemoryAccessViolation;

            u32 val;
            std::memcpy(&val, addr, sizeof(val));

            // write_register stores u64, u32 implicitly zero‑extended
            write_register(rd, val);
            break;
        }

        // Store: store 8 bytes from rd to memory
        case Store: {

            u32 rd  = bytecode_.op_pool[pc_++];
            u32 rs1 = bytecode_.op_pool[pc_++];
            i16 off;
            std::memcpy(&off, bytecode_.op_pool + pc_, sizeof(off));
            pc_ += 2;

            u64 val  = read_register(rd);      // rd is the source register for Store
            u64 base = read_register(rs1);
            u8* addr = (u8*)(base) + off;

            if (!((addr >= gp_base_ && addr + 8 <= gp_base_ + gp_size_) ||
                  (addr >= stack_base_ && addr + 8 <= stack_base_ + stack_size_)))
                [[unlikely]]
                return MemoryAccessViolation;

            std::memcpy(addr, &val, sizeof(val));
            break;
        }

        case LoadConst: {
            u32 rd = bytecode_.op_pool[pc_++];
            u32 idx;
            std::memcpy(&idx, bytecode_.op_pool + pc_, sizeof(idx)); pc_ += 4;
            if (idx >= bytecode_.constant_pool_size) [[unlikely]]
                return ConstantPoolOverflow;
            KValue cv = bytecode_.constant_pool[idx];
            write_register(rd, cv.u64_val); // assume 64-bit constants
            break;
        }

        case LoadImmediate: {
            u32 rd  = bytecode_.op_pool[pc_++];
            u8  imm = bytecode_.op_pool[pc_++];
            write_register(rd, imm);
            break;
        }

        // Data conversion
        // Layout: [op][rd][rs]
        case SignExtendB: {
            exec_unary([](u64 v) { return (u64)( (i64)( (i8)v ) ); });
            break;
        }
        case SignExtendH: {
            exec_unary([](u64 v) { return (u64)( (i64)( (i16)v ) ); });
            break;
        }
        case ZeroExtendB: {
            exec_unary([](u64 v) { return v & 0xFF; });
            break;
        }
        case ZeroExtendH: {
            exec_unary([](u64 v) { return v & 0xFFFF; });
            break;
        }
        case TruncateW: {
            exec_unary([](u64 v) {
                return (u64)( (i64)( (i32)v ) );
            });
            break;
        }

        // System
        case ECall: {
            // todo
            break;
        }
        case EBreak: {
            // todo
            break;
        }
        case Halt: {
            return NoError;
        }
        } // switch
    } // while
}


}