382 lines
12 KiB
C++
382 lines
12 KiB
C++
#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)]; }
|
|
|
|
void broadway::addi(ircolib::u32 instr) {
|
|
if (utils::RA(instr) == 0) { // lis
|
|
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::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 size_t 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([&] { return std::expected<void, std::string>(); })
|
|
.or_else([&](std::string e) {
|
|
ircolib::panic("broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
|
|
return std::expected<void, std::string>();
|
|
});
|
|
gpr[utils::RA(instr)] = EA;
|
|
}
|
|
|
|
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([&] { return std::expected<void, std::string>(); })
|
|
.or_else([&](std::string e) {
|
|
ircolib::panic("broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
|
|
return std::expected<void, std::string>();
|
|
});
|
|
gpr[utils::RA(instr)] = EA;
|
|
}
|
|
|
|
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("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::s32 d = utils::SIMM(instr);
|
|
const ircolib::u32 EA = b + d;
|
|
|
|
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("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("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);
|
|
double val;
|
|
ircolib::u64 read = mem.read64(ea)
|
|
.and_then([&](ircolib::u64 val) { return std::expected<ircolib::u64, std::string>(val); })
|
|
.or_else([&](std::string e) {
|
|
ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
|
|
return std::expected<ircolib::u64, std::string>();
|
|
})
|
|
.value();
|
|
memcpy(&val, &read, 8);
|
|
fgrs[utils::RD(instr)].ps0 = val;
|
|
}
|
|
|
|
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;
|
|
|
|
r &= ~((0xFFFF'FFFF >> mb) << me);
|
|
gpr[utils::RA(instr)] = 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) { return std::expected<ircolib::u32, std::string>(val); })
|
|
.or_else([&](std::string e) {
|
|
ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
|
|
return std::expected<ircolib::u32, std::string>();
|
|
})
|
|
.value();
|
|
gpr[utils::RA(instr)] = EA;
|
|
}
|
|
|
|
void broadway::rfi(ircolib::u32 instr) { pc = srr0; }
|
|
|
|
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::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::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)] + 1);
|
|
cr0_update(instr & 1, gpr[utils::RD(instr)]);
|
|
}
|
|
|
|
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)]);
|
|
}
|
|
} // namespace weee::core
|