#include "ircolib/log.hpp"
#include <broadway/utils.hpp>
#include <mem.hpp>

namespace weee::core {
void broadway::add(ircolib::u32 instr) {
    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
    cr0_update(instr & 1, gpr[utils::RD(instr)]);
}

void broadway::addc(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
    cr0_update(instr & 1, sum);
    xer.ca = carry;
    gpr[utils::RD(instr)] = sum;
}

void broadway::adde(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool c0 = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
    cr0_update(instr & 1, sum);
    xer.ca = c0 | c1;
    gpr[utils::RD(instr)] = sum;
}

void broadway::addze(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool c1 = __builtin_add_overflow(gpr[utils::RA(instr)], xer.ca, &sum);
    cr0_update(instr & 1, sum);
    xer.ca = c1;
    gpr[utils::RD(instr)] = sum;
}

void broadway::addi(ircolib::u32 instr) {
    if (utils::RA(instr) == 0) { // li
        gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr));
        return;
    }

    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + (ircolib::s32(utils::SIMM(instr)));
}

void broadway::addic(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
    gpr[utils::RD(instr)] = sum;
    xer.ca = carry;
}

void broadway::addicr(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
    cr0_update(true, sum);
    gpr[utils::RD(instr)] = sum;
    xer.ca = carry;
}

void broadway::addis(ircolib::u32 instr) {
    if (utils::RA(instr) == 0) { // lis
        gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr)) << 16;
        return;
    }

    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + (ircolib::s32(utils::SIMM(instr)) << 16);
}

void broadway::ori(ircolib::u32 instr) { gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | utils::UIMM(instr); }
void broadway::oris(ircolib::u32 instr) {
    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | ((ircolib::u32)utils::UIMM(instr) << 16);
}

void broadway::branch(bool aa, bool lk, ircolib::u32 bd) {
    if (!aa)
        bd += pc - 4;

    if (lk)
        lr = pc;

    pc = bd;
}

void broadway::bx(ircolib::u32 instr) {
    const bool link = instr & 1;
    const bool absolute = instr & 2;

    ircolib::s32 li = (ircolib::s32(instr << 6) >> 6) & 0xFFFFFFFC;
    branch(absolute, link, li);
}

bool broadway::test_cond_and_ctr(ircolib::u32 instr) {
    const ircolib::u8 bo = (instr >> 21) & 0x1f;
    const ircolib::u8 bi = (instr >> 16) & 0x1f;

    const bool ctr_ok = ircolib::is_bit_set(bo, 2) || ((--ctr == 0) == (ircolib::is_bit_set(bo, 1)));
    const bool cond_ok = ircolib::is_bit_set(bo, 4) || (get_cr_bit(0, bi) == ircolib::is_bit_set(bo, 3));

    return cond_ok && ctr_ok;
}

void broadway::bcx(ircolib::u32 instr) {
    const bool link = instr & 1;
    const bool absolute = instr & 2;

    ircolib::s32 bd = (ircolib::s32(instr << 16) >> 16) & 0xFFFFFFFC;
    if (test_cond_and_ctr(instr)) {
        branch(absolute, link, bd);
    }
}

void broadway::mftspr(bool dir, ircolib::u32 instr) {
    const ircolib::u32 spr_field = (instr >> 11) & 0x3FF;

    auto move_to_or_from_spr = [&](ircolib::u32 &spr) {
        if (dir) { // mtspr
            spr = gpr[utils::RS(instr)];
            return;
        }
        // mfspr
        gpr[utils::RD(instr)] = spr;
    };

    switch (spr_field) {
    case 0b0000100000:
        move_to_or_from_spr(xer.raw);
        break;
    case 0b0100000000:
        move_to_or_from_spr(lr);
        break;
    case 0b0100100000:
        move_to_or_from_spr(ctr);
        break;
    case 0b1101000000:
        move_to_or_from_spr(srr0);
        break;
    case 0b1101100000: // srr1
        break;
    case 0b1000011111: // hid0
        break;
    case 0b1100011100: // hid2
        break;
    case 0b1100111111: // l2cr
        break;
    case 0b1000110000:
        move_to_or_from_spr(ibat[BAT_LOWER_OFFSET + 0]);
        break;
    case 0b1000010000:
        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 0]);
        break;
    case 0b1001010000:
        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 1]);
        break;
    case 0b1010010000:
        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 2]);
        break;
    case 0b1011010000:
        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 3]);
        break;
    case 0b1100110000:
        move_to_or_from_spr(dbat[BAT_LOWER_OFFSET + 0]);
        break;
    case 0b1101110000:
        move_to_or_from_spr(dbat[BAT_LOWER_OFFSET + 1]);
        break;
    case 0b1100010000:
        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 0]);
        break;
    case 0b1101010000:
        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 1]);
        break;
    case 0b1110010000:
        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 2]);
        break;
    case 0b1111010000:
        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 3]);
        break;
    default:
        ircolib::warn("broadway::m{}spr with unimplemented spr field of value "
                      "0b{:010b} (0x{:04X}) (pc 0x{:08X})",
                      dir ? 't' : 'f', spr_field, spr_field, pc - 4);
    }
}

void broadway::stwu(ircolib::u32 instr, mem &mem) {
    if (utils::RA(instr) == 0)
        ircolib::panic("broadway::stwu with ra == 0");

    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
             .and_then([&] {
                 gpr[utils::RA(instr)] = EA;
                 return std::expected<void, std::string>();
             })
             .or_else([&](std::string e) {
                 ircolib::panic("stwu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::sthu(ircolib::u32 instr, mem &mem) {
    if (utils::RA(instr) == 0)
        ircolib::panic("broadway::sthu with ra == 0");

    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
    auto _ = mem.write16(EA, gpr[utils::RS(instr)])
             .and_then([&] {
                 gpr[utils::RA(instr)] = EA;
                 return std::expected<void, std::string>();
             })
             .or_else([&](std::string e) {
                 ircolib::panic("sthu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::stbu(ircolib::u32 instr, mem &mem) {
    if (utils::RA(instr) == 0)
        ircolib::panic("broadway::stbu with ra == 0");

    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
    auto _ = mem.write8(EA, gpr[utils::RS(instr)])
             .and_then([&] {
                 gpr[utils::RA(instr)] = EA;
                 return std::expected<void, std::string>();
             })
             .or_else([&](std::string e) {
                 ircolib::panic("stbu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::stw(ircolib::u32 instr, mem &mem) {
    ircolib::s32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    const ircolib::u32 EA = b + utils::SIMM(instr);
    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
             .and_then([&] { return std::expected<void, std::string>(); })
             .or_else([&](std::string e) {
                 ircolib::panic("stw broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::stb(ircolib::u32 instr, mem &mem) {
    ircolib::s32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    const ircolib::u32 EA = b + utils::SIMM(instr);
    auto _ = mem.write8(EA, gpr[utils::RS(instr)])
             .and_then([&] { return std::expected<void, std::string>(); })
             .or_else([&](std::string e) {
                 ircolib::panic("stw broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::sth(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    const ircolib::u32 EA = b + utils::SIMM(instr);

    auto _ = mem.write16(EA, ircolib::u16(gpr[utils::RS(instr)]))
             .and_then([&] { return std::expected<void, std::string>(); })
             .or_else([&](std::string e) {
                 ircolib::panic("sth broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::stwx(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    const ircolib::u32 EA = b + gpr[utils::RB(instr)];
    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
             .and_then([&] { return std::expected<void, std::string>(); })
             .or_else([&](std::string e) {
                 ircolib::panic("stwx broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
                 return std::expected<void, std::string>();
             });
}

void broadway::lwz(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);

    gpr[utils::RD(instr)] = mem.read32(ea)
                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                            .or_else([&](std::string e) {
                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::lwzx(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];

    gpr[utils::RD(instr)] = mem.read32(ea)
                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                            .or_else([&](std::string e) {
                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::lhz(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);

    gpr[utils::RD(instr)] = mem.read16(ea)
                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                            .or_else([&](std::string e) {
                                ircolib::panic("lhz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::lhzx(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];

    gpr[utils::RD(instr)] = mem.read16(ea)
                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                            .or_else([&](std::string e) {
                                ircolib::panic("lhzx broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::lbz(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);

    gpr[utils::RD(instr)] = mem.read8(ea)
                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
                            .or_else([&](std::string e) {
                                ircolib::panic("lbz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::lfd(ircolib::u32 instr, mem &mem) {
    ircolib::u32 b = gpr[utils::RA(instr)];
    if (utils::RA(instr) == 0)
        b = 0;

    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);

    fgrs[utils::RD(instr)].ps0 =
    mem.read64(ea)
    .and_then([&](ircolib::u64 val) { return std::expected<ircolib::u64, std::string>(val); })
    .or_else([&](std::string e) {
        ircolib::panic("lfd broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
        return std::expected<ircolib::u64, std::string>();
    })
    .value();
}

void broadway::bclrx(ircolib::u32 instr) {
    const bool link = instr & 1;

    ircolib::s32 bd = lr & 0xFFFFFFFC;
    if (test_cond_and_ctr(instr)) {
        branch(true, link, bd);
    }
}

void broadway::cmpi(ircolib::u32 instr) {
    const ircolib::s32 a = gpr[utils::RA(instr)];
    const ircolib::s32 simm = utils::SIMM(instr);
    ircolib::u8 c;
    if (a < simm)
        c = 0b001;
    else if (a > simm)
        c = 0b010;
    else
        c = 0b100;

    const ircolib::u8 result = (xer.so << 3) | c;
    set_cr(result, utils::crfD(instr));
}

void broadway::cmpli(ircolib::u32 instr) {
    const ircolib::u32 a = gpr[utils::RA(instr)];
    const ircolib::u32 uimm = utils::UIMM(instr);
    ircolib::u8 c;
    if (a < uimm)
        c = 0b001;
    else if (a > uimm)
        c = 0b010;
    else
        c = 0b100;

    const ircolib::u8 result = (xer.so << 3) | c;
    set_cr(result, utils::crfD(instr));
}

void broadway::cmp(ircolib::u32 instr) {
    const ircolib::s32 a = gpr[utils::RA(instr)];
    const ircolib::s32 b = gpr[utils::RB(instr)];
    ircolib::u8 c;
    if (a < b)
        c = 0b001;
    else if (a > b)
        c = 0b010;
    else
        c = 0b100;

    const ircolib::u8 result = (xer.so << 3) | c;
    set_cr(result, utils::crfD(instr));
}

void broadway::cmpl(ircolib::u32 instr) {
    const ircolib::u32 a = gpr[utils::RA(instr)];
    const ircolib::u32 b = gpr[utils::RB(instr)];
    ircolib::u8 c;
    if (a < b)
        c = 0b001;
    else if (a > b)
        c = 0b010;
    else
        c = 0b100;

    const ircolib::u8 result = (xer.so << 3) | c;
    set_cr(result, utils::crfD(instr));
}

void broadway::rlwinm(ircolib::u32 instr) {
    const ircolib::u8 sh = (instr >> 11) & 0x1f;
    ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
    const ircolib::u8 mb = (instr >> 6) & 0x1f;
    const ircolib::u8 me = (instr >> 1) & 0x1f;
    const ircolib::u32 start = 0xffffffff >> mb;
    const ircolib::u32 end = 0x7fffffff >> me;
    ircolib::u32 mask = start ^ end;
    if (mb > me)
        mask = ~mask;

    r &= mask;
    gpr[utils::RA(instr)] = r;
    cr0_update(instr & 1, r);
}

void broadway::rlwimi(ircolib::u32 instr) {
    const ircolib::u8 sh = (instr >> 11) & 0x1f;
    ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
    const ircolib::u8 mb = (instr >> 6) & 0x1f;
    const ircolib::u8 me = (instr >> 1) & 0x1f;
    const ircolib::u32 start = 0xffffffff >> mb;
    const ircolib::u32 end = 0x7fffffff >> me;
    ircolib::u32 mask = start ^ end;
    if (mb > me)
        mask = ~mask;

    r &= mask;
    r |= (gpr[utils::RA(instr)] & ~mask);
    gpr[utils::RA(instr)] = r;
    cr0_update(instr & 1, r);
}

void broadway::lwzu(ircolib::u32 instr, mem &mem) {
    if (utils::RA(instr) == 0 || utils::RA(instr) == utils::RD(instr))
        ircolib::panic("broadway::lwzu with ra == 0");

    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
    gpr[utils::RD(instr)] = mem.read32(EA)
                            .and_then([&](ircolib::u32 val) {
                                gpr[utils::RA(instr)] = EA;
                                return std::expected<ircolib::u32, std::string>(val);
                            })
                            .or_else([&](std::string e) {
                                ircolib::panic("lwzu broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
                                return std::expected<ircolib::u32, std::string>();
                            })
                            .value();
}

void broadway::rfi(ircolib::u32 instr) {
    pc = srr0;
    ircolib::clear_bit(msr, 13);
}

void broadway::andi(ircolib::u32 instr) {
    const ircolib::s32 result = gpr[utils::RS(instr)] & utils::UIMM(instr);
    gpr[utils::RA(instr)] = result;
    cr0_update(true, result);
}

void broadway::andis(ircolib::u32 instr) {
    const ircolib::s32 result = gpr[utils::RS(instr)] & (ircolib::u32(utils::UIMM(instr)) << 16);
    gpr[utils::RA(instr)] = result;
    cr0_update(true, result);
}

void broadway::and(ircolib::u32 instr) {
    const ircolib::s32 result = gpr[utils::RS(instr)] & gpr[utils::RB(instr)];
    gpr[utils::RA(instr)] = result;
    cr0_update(instr & 1, result);
}

void broadway::mtfsf(ircolib::u32 instr) {
    const ircolib::u8 fm = (instr >> 17) & 0xff;
    ircolib::u8 mask = 0;
    for (int i = 0; i < 8; i++) {
        if (ircolib::is_bit_set(fm, i)) {
            mask |= 0xf << (i * 4);
        }
    }

    ircolib::u32 frb = fgrs[utils::RB(instr)].ps0;
    fpscr = (fpscr & ~mask) | (frb & mask);
    cr1_update(instr & 1);
}

void broadway::mtfsb0(ircolib::u32 instr) {
    ircolib::u32 mask = ~(1 << utils::RD(instr));

    fpscr = fpscr & mask;
    cr1_update(instr & 1);
}

void broadway::mtfsb1(ircolib::u32 instr) {
    ircolib::u32 bit = 1 << utils::RD(instr);
    ircolib::u32 mask = ~bit;

    fpscr = (fpscr & mask) | bit;
    cr1_update(instr & 1);
}

void broadway::mfmsr(ircolib::u32 instr) { gpr[utils::RS(instr)] = msr; }
void broadway::mtmsr(ircolib::u32 instr) { msr = gpr[utils::RS(instr)]; }

void broadway::nand(ircolib::u32 instr) {
    gpr[utils::RA(instr)] = ~(gpr[utils::RS(instr)] & gpr[utils::RB(instr)]);
    cr0_update(instr & 1, gpr[utils::RA(instr)]);
}

void broadway::subf(ircolib::u32 instr) {
    gpr[utils::RD(instr)] = ~gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
    cr0_update(instr & 1, gpr[utils::RD(instr)]);
}

void broadway::subfc(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
    bool c1 = __builtin_add_overflow(sum, gpr[utils::RB(instr)], &sum);
    cr0_update(instr & 1, sum);
    xer.ca = !c0 | c1;
    gpr[utils::RD(instr)] = sum;
}

void broadway::subfic(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
    bool c1 = __builtin_add_overflow(sum, utils::SIMM(instr), &sum);
    xer.ca = !c0 | c1;
    gpr[utils::RD(instr)] = sum;
}

void broadway::subfe(ircolib::u32 instr) {
    ircolib::u32 sum;
    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
    cr0_update(instr & 1, sum);
    xer.ca = c0 | c1;
    gpr[utils::RD(instr)] = sum;
}

void broadway:: or (ircolib::u32 instr) {
    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | gpr[utils::RB(instr)];
    cr0_update(instr & 1, gpr[utils::RA(instr)]);
}

void broadway::xori(ircolib::u32 instr) { gpr[utils::RA(instr)] = gpr[utils::RS(instr)] ^ utils::UIMM(instr); }

void broadway::mullw(ircolib::u32 instr) {
    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(gpr[utils::RB(instr)]);
}

void broadway::mulli(ircolib::u32 instr) {
    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(utils::SIMM(instr));
}

void broadway::mfcr(ircolib::u32 instr) { gpr[utils::RD(instr)] = cr; }

void broadway::mtcrf(ircolib::u32 instr) {
    ircolib::u32 mask = 0;
    const ircolib::u8 crm = (instr >> 13) & 0xff;
    for (int i = 0; i < 7; i++) {
        if (ircolib::is_bit_set(crm, i)) {
            set_cr(gpr[utils::RS(instr)] & (0xffff << i * 4), i);
        }
    }
}

void broadway::divwu(ircolib::u32 instr) {
    ircolib::u32 dividend = gpr[utils::RA(instr)];
    ircolib::u32 divisor = gpr[utils::RB(instr)];
    if (divisor == 0) {
        if ((instr >> 11) & 1)
            xer.ov = true;

        return;
    }

    gpr[utils::RD(instr)] = dividend / divisor;
    cr0_update(instr & 1, gpr[utils::RD(instr)]);
}

void broadway::mftb(ircolib::u32 instr) {
    const ircolib::u32 tbr = (instr >> 11) & 0x3FF;

    if (tbr != 392 && tbr != 424)
        ircolib::panic("broadway::mftb with tbr != 268 && != 269 ({})", tbr);

    if (tbr == 392)
        gpr[utils::RD(instr)] = tbl;

    if (tbr == 424)
        gpr[utils::RD(instr)] = tbu;
}

void broadway::sraw(ircolib::u32 instr) {
    ircolib::u8 shift = std::min(gpr[utils::RB(instr)] & 0x3f, ircolib::u32(31));
    ircolib::s32 rs = gpr[utils::RS(instr)];
    ircolib::s32 result = rs >> shift;
    ircolib::u32 mask = (1 << shift) - 1;
    cr0_update(instr & 1, result);
    xer.ca = (rs < 0) & ((ircolib::u32(rs) & mask) != 0);
    gpr[utils::RA(instr)] = result;
}
} // namespace weee::core