weeemu/weee
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: weeemu/weee:7d706e703fa793a7d54e34b2d4e36c406f465c0e
Branches Tags
weeemu/weee:main
..
compare: weeemu/weee:main
Branches Tags
weeemu/weee:main

4 Commits
7d706e703f .. main

Author SHA1 Message Date
iris 35f20a16b8 i should implement DSP DMA... 2026-05-20 17:55:07 +02:00
iris f9ab690ccd i need to start caring about carry >.< 2026-05-19 12:26:51 +02:00
iris 8824b6b75a Merge commit 'f070e484cdac8a6d6a2e6f039aa69555e0739133' 2026-05-19 08:51:06 +02:00
iris f070e484cd Squashed 'external/ircolib/' changes from bb3f168e1..d611a21e5 
d611a21e5 imma stop using size_t

git-subtree-dir: external/ircolib
git-subtree-split: d611a21e50fcfdfb5f34a7f79c4c690c50d85c5f
 2026-05-19 08:51:06 +02:00
24 changed files with 1061 additions and 48 deletions
Expand all files Collapse all files
CMakeLists.txt
+7 -1
View File
@@ -28,6 +28,12 @@ add_executable(weee main.cpp core/mem.cpp core/loaders/elf.cpp
core/loaders/dol.cpp
core/broadway.cpp
core/broadway/instructions.cpp
core/broadway/mmio/vi.cpp)
core/broadway/mmio/vi.cpp
core/broadway/mmio/pi.cpp
core/broadway/mmio/mi.cpp
core/broadway/mmio/dsp.cpp
core/broadway/mmio/ai.cpp
core/broadway/mmio/exi.cpp
core/broadway/mmio/si.cpp)
target_link_libraries(weee PUBLIC SDL3::SDL3 capstone)
target_include_directories(weee PUBLIC core)
core/broadway.cpp
+98 -9
View File
@@ -16,9 +16,10 @@ broadway::broadway() {
void broadway::set_pc(ircolib::u32 value) { pc = value; }
void broadway::run(mem &mem) {
for (int i = 0; i < 12150000; i++) {
// std::println("pc: 0x{:08X}", pc);
execute(fetch(mem), mem);
std::println("pc: 0x{:08X}", pc);
for (int i = 0; i < 1000000; i++) {
ircolib::u32 instr = fetch(mem);
execute(instr, mem);
}
}
@@ -45,7 +46,10 @@ void broadway::decode_special3(ircolib::u32 instr, mem &mem) {
mtfsf(instr);
break;
default:
ircolib::panic("broadway unknown special3 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
std::println("broadway unknown special3 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
std::println("disassembly:");
print_disasm(instr);
ircolib::panic("LR: 0x{:08X}", lr);
}
}
@@ -55,6 +59,21 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
case 0x000:
cmp(instr);
break;
case 0x008:
subfc(instr);
break;
case 0x00A:
addc(instr);
break;
case 0x013:
mfcr(instr);
break;
case 0x017:
lwzx(instr, mem);
break;
case 0x01C:
and(instr);
break;
case 0x020:
cmpl(instr);
break;
@@ -64,9 +83,36 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
case 0x053:
mfmsr(instr);
break;
case 0x088:
subfe(instr);
break;
case 0x08A:
adde(instr);
break;
case 0x090:
mtcrf(instr);
break;
case 0x092:
mtmsr(instr);
break;
case 0x097:
stwx(instr, mem);
break;
case 0x0CA:
addze(instr);
break;
case 0x0D2:
ircolib::warn("broadway TODO mtsr (pc 0x{:08X})", pc - 4);
break;
case 0x0EB:
mullw(instr);
break;
case 0x117:
lhzx(instr, mem);
break;
case 0x173:
mftb(instr);
break;
case 0x1BC:
or (instr);
break;
@@ -80,10 +126,19 @@ void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
case 0x10A:
add(instr);
break;
case 0x1CB:
divwu(instr);
break;
case 0x256: // sync
break;
case 0x318:
sraw(instr);
break;
default:
ircolib::panic("broadway unknown special2 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
std::println("broadway unknown special2 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
std::println("disassembly:");
print_disasm(instr);
ircolib::panic("LR: 0x{:08X}", lr);
}
}
@@ -98,19 +153,35 @@ void broadway::decode_special1(ircolib::u32 instr, mem &mem) {
case 0x96: // isync
break;
default:
ircolib::panic("broadway unknown special1 {} (0x{:04X}) (pc 0x{:08X})", utils::secondary(instr),
utils::secondary(instr), pc - 4);
std::println("broadway unknown special1 {} (0x{:04X}) (pc 0x{:08X})", utils::secondary(instr),
utils::secondary(instr), pc - 4);
std::println("disassembly:");
print_disasm(instr);
ircolib::panic("LR: 0x{:08X}", lr);
}
}
void broadway::execute(ircolib::u32 instr, mem &mem) {
switch (utils::primary(instr)) {
const auto primary = utils::primary(instr);
switch (primary) {
case 7:
mulli(instr);
break;
case 8:
subfic(instr);
break;
case 10:
cmpli(instr);
break;
case 11:
cmpi(instr);
break;
case 12:
addic(instr);
break;
case 13:
addicr(instr);
break;
case 14:
addi(instr);
break;
@@ -126,6 +197,9 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
case 19:
decode_special1(instr, mem);
break;
case 20:
rlwimi(instr);
break;
case 21:
rlwinm(instr);
break;
@@ -135,9 +209,15 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
case 25:
oris(instr);
break;
case 26:
xori(instr);
break;
case 28:
andi(instr);
break;
case 29:
andis(instr);
break;
case 31:
decode_special2(instr, mem);
break;
@@ -156,12 +236,21 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
case 37:
stwu(instr, mem);
break;
case 38:
stb(instr, mem);
break;
case 39:
stbu(instr, mem);
break;
case 40:
lhz(instr, mem);
break;
case 44:
sth(instr, mem);
break;
case 45:
sthu(instr, mem);
break;
case 50:
lfd(instr, mem);
break;
@@ -169,7 +258,7 @@ void broadway::execute(ircolib::u32 instr, mem &mem) {
decode_special3(instr, mem);
break;
default:
std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b}", instr, instr);
std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b} ({})", instr, instr, primary);
std::println("disassembly:");
print_disasm(instr);
ircolib::panic("LR: 0x{:08X}", lr);
core/broadway.hpp
+27 -1
View File
@@ -17,7 +17,7 @@ struct broadway {
void execute(ircolib::u32, mem &);
bool disasm_available = true;
ircolib::u32 pc = 0, lr = 0, ctr = 0, cr = 0, srr0 = 0, fpscr = 0, msr = 0;
ircolib::u32 pc = 0, lr = 0, ctr = 0, cr = 0, srr0 = 0, fpscr = 0, msr = 0, tbl = 0, tbu = 0;
union {
struct {
unsigned bytecount : 7;
@@ -63,20 +63,34 @@ struct broadway {
bool test_cond_and_ctr(ircolib::u32);
void andi(ircolib::u32);
void andis(ircolib::u32);
void and(ircolib::u32);
void add(ircolib::u32);
void addc(ircolib::u32);
void adde(ircolib::u32);
void addze(ircolib::u32);
void addis(ircolib::u32);
void addi(ircolib::u32);
void addic(ircolib::u32);
void addicr(ircolib::u32);
void ori(ircolib::u32);
void oris(ircolib::u32);
void bx(ircolib::u32);
void bcx(ircolib::u32);
void mftspr(bool, ircolib::u32);
void mtcrf(ircolib::u32);
void stw(ircolib::u32, mem &);
void stb(ircolib::u32, mem &);
void stwu(ircolib::u32, mem &);
void sthu(ircolib::u32, mem &);
void stwx(ircolib::u32, mem &);
void stbu(ircolib::u32, mem &);
void sth(ircolib::u32, mem &);
void lbz(ircolib::u32, mem &);
void lwz(ircolib::u32, mem &);
void lwzx(ircolib::u32, mem &);
void lhz(ircolib::u32, mem &);
void lhzx(ircolib::u32, mem &);
void lfd(ircolib::u32, mem &);
void bclrx(ircolib::u32);
void cmpi(ircolib::u32);
@@ -84,15 +98,27 @@ struct broadway {
void cmp(ircolib::u32);
void cmpl(ircolib::u32);
void rlwinm(ircolib::u32);
void rlwimi(ircolib::u32);
void lwzu(ircolib::u32, mem &);
void rfi(ircolib::u32);
void mfcr(ircolib::u32);
void mtfsf(ircolib::u32);
void mtfsb1(ircolib::u32);
void mtfsb0(ircolib::u32);
void mfmsr(ircolib::u32);
void mtmsr(ircolib::u32);
void mullw(ircolib::u32);
void mulli(ircolib::u32);
void nand(ircolib::u32);
void subf(ircolib::u32);
void subfc(ircolib::u32);
void subfic(ircolib::u32);
void subfe(ircolib::u32);
void or (ircolib::u32);
void xori(ircolib::u32);
void divwu(ircolib::u32);
void mftb(ircolib::u32);
void sraw(ircolib::u32);
inline void cr0_update(bool condition, ircolib::s32 result) {
if (condition) {
core/broadway/instructions.cpp
+251 -4
View File
@@ -8,6 +8,31 @@ void broadway::add(ircolib::u32 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));
@@ -17,6 +42,21 @@ void broadway::addi(ircolib::u32 instr) {
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;
@@ -158,6 +198,22 @@ void broadway::stwu(ircolib::u32 instr, mem &mem) {
});
}
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");
@@ -188,6 +244,20 @@ void broadway::stw(ircolib::u32 instr, mem &mem) {
});
}
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)
@@ -203,6 +273,20 @@ void broadway::sth(ircolib::u32 instr, mem &mem) {
});
}
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)
@@ -213,7 +297,55 @@ void broadway::lwz(ircolib::u32 instr, mem &mem) {
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);
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();
@@ -229,7 +361,7 @@ void broadway::lbz(ircolib::u32 instr, mem &mem) {
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("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
ircolib::panic("lbz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
return std::expected<ircolib::u32, std::string>();
})
.value();
@@ -246,7 +378,7 @@ void broadway::lfd(ircolib::u32 instr, mem &mem) {
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);
ircolib::panic("lfd broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
return std::expected<ircolib::u64, std::string>();
})
.value();
@@ -337,6 +469,23 @@ void broadway::rlwinm(ircolib::u32 instr) {
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");
@@ -348,7 +497,7 @@ void broadway::lwzu(ircolib::u32 instr, mem &mem) {
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);
ircolib::panic("lwzu broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
return std::expected<ircolib::u32, std::string>();
})
.value();
@@ -365,6 +514,18 @@ void broadway::andi(ircolib::u32 instr) {
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;
@@ -395,6 +556,7 @@ void broadway::mtfsb1(ircolib::u32 instr) {
}
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)]);
@@ -406,8 +568,93 @@ void broadway::subf(ircolib::u32 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
core/broadway/mmio/ai.cpp
+31
View File
@@ -0,0 +1,31 @@
#include <broadway/mmio/ai.hpp>
#include <mem.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
audio_interface::audio_interface(mem &mem) {
mem.register_read32_handler(0x0c006c00, 0x0c006c1f, [&](ircolib::u32 addr) { return read32(addr); });
mem.register_write32_handler(0x0c006c00, 0x0c006c1f,
[&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
}
ircolib::u32 audio_interface::read32(ircolib::u32 addr) {
switch (addr) {
case 0:
return ctrl.raw;
default:
ircolib::panic("audio_interface::read32 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
void audio_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
switch (addr) {
case 0:
ctrl.raw = value;
break;
default:
ircolib::panic("audio_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
}
}
} // namespace weee::core
core/broadway/mmio/ai.hpp
+26
View File
@@ -0,0 +1,26 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct audio_interface {
audio_interface(mem &);
ircolib::u32 read32(ircolib::u32);
void write32(ircolib::u32, ircolib::u32);
union {
struct {
unsigned pstat : 1;
unsigned afr : 1;
unsigned aiintmsk : 1;
unsigned aiint : 1;
unsigned aiintvld : 1;
unsigned screset : 1;
unsigned dsp_sr : 1;
unsigned : 25;
};
ircolib::u32 raw;
} ctrl;
};
} // namespace weee::core
core/broadway/mmio/dsp.cpp
+152
View File
@@ -0,0 +1,152 @@
#include <broadway/mmio/dsp.hpp>
#include <mem.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
dsp::dsp(mem &mem) {
mem.register_read16_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read16(addr); });
mem.register_write16_handler(0x0c005000, 0x0c0051ff,
[&](ircolib::u32 addr, ircolib::u16 value) { return write16(addr, value); });
mem.register_read32_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read32(addr); });
mem.register_write32_handler(0x0c005000, 0x0c0051ff,
[&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
}
ircolib::u32 dsp::read32(ircolib::u32 addr) {
switch (addr) {
case 0x20:
return ar_dma_mmaddr.whole;
case 0x24:
return ar_dma_araddr.whole;
case 0x28:
return ar_dma_cnt.whole;
case 0x30:
return dma_start_addr.whole;
default:
ircolib::panic("dsp::read32 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
void dsp::write32(ircolib::u32 addr, ircolib::u32 value) {
switch (addr) {
case 0x20:
ar_dma_mmaddr.whole = value;
break;
case 0x24:
ar_dma_araddr.whole = value;
break;
case 0x28:
ar_dma_cnt.whole = value;
break;
case 0x30:
dma_start_addr.whole = value;
break;
default:
ircolib::panic("dsp::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
}
}
ircolib::u16 dsp::read16(ircolib::u32 addr) {
switch (addr) {
case 0x00:
return dsp_mail_hi;
case 0x02:
return dsp_mail_lo;
case 0x04:
return cpu_mail_hi;
case 0x06:
return cpu_mail_lo;
case 0x0a:
return csr.raw;
case 0x12:
return ar_size;
case 0x20:
return ar_dma_mmaddr.hi;
case 0x22:
return ar_dma_mmaddr.lo;
case 0x24:
return ar_dma_araddr.hi;
case 0x26:
return ar_dma_araddr.lo;
case 0x28:
return ar_dma_cnt.hi;
case 0x2a:
return ar_dma_cnt.lo;
case 0x30:
return dma_start_addr.hi;
case 0x32:
return dma_start_addr.lo;
default:
ircolib::panic("dsp::read16 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
void dsp::write16(ircolib::u32 addr, ircolib::u16 value) {
switch (addr) {
case 0x00:
dsp_mail_hi = value;
break;
case 0x02:
dsp_mail_lo = value;
break;
case 0x0a:
{
Csr ccsr = {.raw = value};
Csr ocsr = csr;
csr = ccsr;
if (csr.res || (ocsr.boot_mode != ccsr.boot_mode && ccsr.boot_mode)) {
cpu_mail_hi = 0;
cpu_mail_lo = 0;
dsp_mail_hi = 0;
dsp_mail_lo = 0;
}
if (csr.piint)
csr.piint = false;
if (csr.aidint)
csr.aidint = false;
if (csr.arint)
csr.arint = false;
if (csr.dspint)
csr.dspint = false;
}
break;
case 0x12:
ar_size = value;
break;
case 0x20:
ar_dma_mmaddr.hi = value;
break;
case 0x22:
ar_dma_mmaddr.lo = value;
break;
case 0x24:
ar_dma_araddr.hi = value;
break;
case 0x26:
ar_dma_araddr.lo = value;
break;
case 0x28:
ar_dma_cnt.hi = value;
break;
case 0x2a:
ar_dma_cnt.lo = value;
csr.arint = true;
break;
case 0x30:
dma_start_addr.hi = value;
break;
case 0x32:
dma_start_addr.lo = value;
break;
default:
ircolib::panic("dsp::write16 from unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
}
}
} // namespace weee::core
core/broadway/mmio/dsp.hpp
+43
View File
@@ -0,0 +1,43 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct dsp {
dsp(mem &);
ircolib::u16 read16(ircolib::u32);
void write16(ircolib::u32, ircolib::u16);
ircolib::u32 read32(ircolib::u32);
void write32(ircolib::u32, ircolib::u32);
union Csr {
struct {
unsigned res : 1;
unsigned piint : 1;
unsigned halt : 1;
unsigned aidint : 1;
unsigned aidint_mask : 1;
unsigned arint : 1;
unsigned arint_mask : 1;
unsigned dspint : 1;
unsigned dspint_mask : 1;
unsigned int_status : 1;
unsigned : 1;
unsigned boot_mode : 1;
unsigned : 4;
};
ircolib::u16 raw;
} csr;
union {
struct {
ircolib::u32 lo;
ircolib::u32 hi;
};
ircolib::u64 whole;
} ar_dma_mmaddr, ar_dma_araddr, ar_dma_cnt, dma_start_addr;
ircolib::u16 ar_size;
ircolib::u16 dsp_mail_hi = 0, dsp_mail_lo = 0, cpu_mail_hi = 0, cpu_mail_lo = 0;
};
} // namespace weee::core
core/broadway/mmio/exi.cpp
+41
View File
@@ -0,0 +1,41 @@
#include <broadway/mmio/exi.hpp>
#include <mem.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
exi::exi(mem &mem) {
mem.register_read32_handler(0x0c006800, 0x0c00683f, [&](ircolib::u32 addr) { return read32(addr); });
mem.register_write32_handler(0x0c006800, 0x0c00683f,
[&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
}
ircolib::u32 exi::read32(ircolib::u32 addr) {
switch (addr) {
case 0:
return param0.raw;
case 0x14:
return param1.raw;
case 0x28:
return param2.raw;
default:
ircolib::panic("exi::read32 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
void exi::write32(ircolib::u32 addr, ircolib::u32 value) {
switch (addr) {
case 0:
param0.raw = value;
break;
case 0x14:
param1.raw = value;
break;
case 0x28:
param2.raw = value;
break;
default:
ircolib::panic("exi::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
}
}
} // namespace weee::core
core/broadway/mmio/exi.hpp
+30
View File
@@ -0,0 +1,30 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct exi {
exi(mem &);
ircolib::u32 read32(ircolib::u32);
void write32(ircolib::u32, ircolib::u32);
union {
struct {
unsigned ext_int_mask : 1;
unsigned ext_int : 1;
unsigned tc_int_mask : 1;
unsigned tc_int : 1;
unsigned clk : 3;
unsigned cs : 3;
unsigned ext_int_mask2 : 1;
unsigned ext_int2 : 1;
unsigned ext : 1;
unsigned romdis : 1;
unsigned : 18;
};
ircolib::u32 raw;
} param0, param1, param2;
};
} // namespace weee::core
core/broadway/mmio/mi.cpp
+20
View File
@@ -0,0 +1,20 @@
#include <mem.hpp>
#include <broadway/mmio/mi.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
memory_interface::memory_interface(mem &mem) {
mem.register_write16_handler(0x0c004000, 0x0c00407f,
[&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
}
void memory_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
switch (addr) {
case 0x1C:
int_mask.raw = value;
break;
default:
ircolib::panic("memory_interface::write16 to unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
}
}
} // namespace weee::core
core/broadway/mmio/mi.hpp
+23
View File
@@ -0,0 +1,23 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct memory_interface {
union {
struct {
unsigned mem0 : 1;
unsigned mem1 : 1;
unsigned mem2 : 1;
unsigned mem3 : 1;
unsigned all : 1;
unsigned : 27;
};
ircolib::u32 raw;
} int_mask;
memory_interface(mem &);
void write16(ircolib::u32, ircolib::u16);
};
} // namespace weee::core
core/broadway/mmio/pi.cpp
+31
View File
@@ -0,0 +1,31 @@
#include <mem.hpp>
#include <broadway/mmio/pi.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
processor_interface::processor_interface(mem &mem) {
mem.register_write32_handler(0x0c003000, 0x0c0030ff,
[&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
mem.register_read32_handler(0x0c003000, 0x0c0030ff, [&](ircolib::u32 addr) { return read32(addr); });
}
void processor_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
switch (addr) {
case 0x04:
intmr.raw = value;
break;
default:
ircolib::panic("processor_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
}
}
ircolib::u32 processor_interface::read32(ircolib::u32 addr) {
switch (addr) {
case 0x2c:
return 2;
default:
ircolib::panic("processor_interface::read32 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
} // namespace weee::core
core/broadway/mmio/pi.hpp
+33
View File
@@ -0,0 +1,33 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct processor_interface {
union {
struct {
unsigned error : 1;
unsigned rsw : 1;
unsigned di : 1;
unsigned si : 1;
unsigned exi : 1;
unsigned ai : 1;
unsigned dsp : 1;
unsigned mem : 1;
unsigned vi : 1;
unsigned pe_token : 1;
unsigned pe_finish : 1;
unsigned cp : 1;
unsigned debug : 1;
unsigned hsp : 1;
unsigned : 18;
};
ircolib::u32 raw;
} intmr;
processor_interface(mem &);
void write32(ircolib::u32, ircolib::u32);
ircolib::u32 read32(ircolib::u32);
};
} // namespace weee::core
core/broadway/mmio/si.cpp
+46
View File
@@ -0,0 +1,46 @@
#include <broadway/mmio/si.hpp>
#include <mem.hpp>
#include <ircolib/log.hpp>
namespace weee::core {
serial_interface::serial_interface(mem &mem) {
mem.register_read32_handler(0x0c006400, 0x0c0064ff, [&](ircolib::u32 addr) { return read32(addr); });
mem.register_write32_handler(0x0c006400, 0x0c0064ff,
[&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
}
ircolib::u32 serial_interface::read32(ircolib::u32 addr) {
switch (addr) {
case 0x30:
return sipoll.raw;
case 0x34:
return sicomcsr.raw;
case 0x38:
return sisr.raw;
case 0x3C:
return clock_lk.raw;
default:
ircolib::panic("serial_interface::read32 from unimplemented addr 0x{:08X}", addr);
return 0;
}
}
void serial_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
switch (addr) {
case 0x30:
sipoll.raw = value;
break;
case 0x34:
sicomcsr.raw = value;
break;
case 0x38:
sisr.raw = value;
break;
case 0x3C:
clock_lk.raw = value;
break;
default:
ircolib::panic("serial_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
}
}
} // namespace weee::core
core/broadway/mmio/si.hpp
+75
View File
@@ -0,0 +1,75 @@
#pragma once
#include <ircolib/types.hpp>
namespace weee::core {
struct mem;
struct serial_interface {
serial_interface(mem &);
ircolib::u32 read32(ircolib::u32);
void write32(ircolib::u32, ircolib::u32);
union {
struct {
unsigned vbcpy : 4;
unsigned en : 4;
unsigned y : 8;
unsigned x : 8;
unsigned : 8;
};
ircolib::u32 raw;
} sipoll;
union {
struct {
unsigned tstart : 1;
unsigned channel : 2;
unsigned cben : 1;
unsigned cmden : 1;
unsigned inlength : 7;
unsigned : 1;
unsigned outlength : 7;
unsigned : 1;
unsigned chen : 1;
unsigned chnum : 2;
unsigned rdstintmsk : 1;
unsigned rdstint : 1;
unsigned comerr : 1;
unsigned tcintmsk : 1;
unsigned tcint : 1;
};
ircolib::u32 raw;
} sicomcsr;
union {
struct {
unsigned : 31;
unsigned lock : 1;
};
ircolib::u32 raw;
} clock_lk;
union {
struct {
unsigned joy3 : 6;
unsigned : 2;
unsigned joy2 : 6;
unsigned : 2;
unsigned joy1 : 6;
unsigned : 2;
unsigned unrun : 1;
unsigned ovrun0 : 1;
unsigned coll0 : 1;
unsigned norep0 : 1;
unsigned wrst0 : 1;
unsigned rdst0 : 1;
unsigned : 1;
unsigned wr : 1;
};
ircolib::u32 raw;
} sisr;
};
} // namespace weee::core
core/broadway/mmio/vi.cpp
+55
View File
@@ -4,12 +4,67 @@
namespace weee::core {
video_interface::video_interface(mem &mem) {
mem.register_read16_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read16(addr); });
mem.register_read32_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read32(addr); });
mem.register_write16_handler(0x0c002000, 0x0c0020ff,
[&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
mem.register_write32_handler(0x0c002000, 0x0c0020ff,
[&](ircolib::u32 addr, ircolib::u32 value) { write32(addr, value); });
}
ircolib::u16 video_interface::read16(ircolib::u32 addr) {
switch (addr) {
case 0x00:
return vtr.raw;
case 0x02:
return dcr.raw;
case 0x4a:
return hsr.raw;
case 0x6c:
return viclk & 1;
case 0x70:
return 0x0280;
default:
ircolib::panic("video_interface::read16 from unimplemented addr 0x{:04X}", addr);
return 0;
}
}
ircolib::u32 video_interface::read32(ircolib::u32 addr) {
switch (addr) {
case 0x02:
return dcr.raw;
case 0x04:
return htr0.raw;
case 0x08:
return htr1.raw;
case 0x0c:
return vto.raw;
case 0x10:
return vte.raw;
case 0x14:
return bbei.raw;
case 0x18:
return bboi.raw;
case 0x1c:
return tfbl.raw & 0x1ffffe00;
case 0x24:
return bfbl.raw & 0x10fffe00;
case 0x4c:
case 0x50:
case 0x54:
return fct0[addr - 0x4c].raw;
case 0x58:
case 0x5c:
case 0x60:
case 0x64:
return fct1[addr - 0x58].raw;
default:
ircolib::panic("video_interface::read32 from unimplemented addr 0x{:04X}", addr);
return 0;
}
}
void video_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
switch (addr) {
case 0x00:
core/broadway/mmio/vi.hpp
+4 -1
View File
@@ -8,6 +8,9 @@ struct video_interface {
video_interface(mem &);
void write16(ircolib::u32, ircolib::u16);
void write32(ircolib::u32, ircolib::u32);
ircolib::u16 read16(ircolib::u32);
ircolib::u32 read32(ircolib::u32);
ircolib::u32 xfb_top_addr() {
auto addr = tfbl.fbb;
if (tfbl.page) {
@@ -96,7 +99,7 @@ struct video_interface {
unsigned fbb : 24;
};
ircolib::u32 raw;
} tfbl, bfbl;
} tfbl{}, bfbl{};
union FCT012 {
struct {
core/mem.cpp
+29 -2
View File
@@ -4,9 +4,11 @@
#include <ircolib/mem_access.hpp>
namespace weee::core {
mem::mem() : vi(*this) {
mem::mem() : vi(*this), pi(*this), mi(*this), dsp(*this), ai(*this), exi(*this), si(*this) {
mem1.resize(24_mib);
std::fill(mem1.begin(), mem1.end(), 0);
ipl.resize(1_mib);
std::fill(ipl.begin(), ipl.end(), 0);
register_read8_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr) { return mem1[addr]; });
@@ -29,9 +31,34 @@ mem::mem() : vi(*this) {
ircolib::write_access<ircolib::u32>(mem1, addr, value);
});
register_write64_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr, ircolib::u32 value) {
register_write64_handler(0x00000000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
ircolib::write_access<ircolib::u64>(mem1, addr, value);
});
register_read8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr) { return ipl[addr]; });
register_read16_handler(0x0ff00000, 0x0fffffff,
[&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u16>(ipl, addr); });
register_read32_handler(0x0ff00000, 0x0fffffff,
[&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u32>(ipl, addr); });
register_read64_handler(0x0ff00000, 0x0fffffff,
[&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u64>(ipl, addr); });
register_write8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u8 value) { ipl[addr] = value; });
register_write16_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u16 value) {
ircolib::write_access<ircolib::u16>(ipl, addr, value);
});
register_write32_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
ircolib::write_access<ircolib::u32>(ipl, addr, value);
});
register_write64_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
ircolib::write_access<ircolib::u64>(ipl, addr, value);
});
}
void mem::copy(std::vector<ircolib::u8> &src, const ircolib::u32 offset) {
core/mem.hpp
+13
View File
@@ -3,6 +3,12 @@
#include <vector>
#include <ircolib/types.hpp>
#include <broadway/mmio/vi.hpp>
#include <broadway/mmio/pi.hpp>
#include <broadway/mmio/mi.hpp>
#include <broadway/mmio/dsp.hpp>
#include <broadway/mmio/ai.hpp>
#include <broadway/mmio/exi.hpp>
#include <broadway/mmio/si.hpp>
#include <functional>
#include <expected>
@@ -69,6 +75,7 @@ struct mem {
void set(const ircolib::u8 val, const ircolib::u32 size, const ircolib::u32 offset);
std::vector<ircolib::u8> mem1;
std::vector<ircolib::u8> ipl{};
private:
std::vector<read_handler<ircolib::u8>> read8_handlers{};
@@ -82,5 +89,11 @@ struct mem {
public:
video_interface vi;
processor_interface pi;
memory_interface mi;
dsp dsp;
exi exi;
audio_interface ai;
serial_interface si;
};
} // namespace weee::core
external/ircolib/file.hpp
Vendored
+4 -5
View File
@@ -4,9 +4,8 @@
#include <vector>
#include <filesystem>
namespace fs = std::filesystem;
namespace ircolib {
namespace fs = std::filesystem;
static inline std::vector<u8> read_file_binary(const std::string &path) {
std::ifstream file(path, std::ios::binary);
return {std::istreambuf_iterator{file}, {}};
@@ -17,19 +16,19 @@ static inline void write_file_binary(const std::vector<u8> &data, const std::str
std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
}
static inline void write_file_binary(const u8 *data, const size_t size, const std::string &path) {
static inline void write_file_binary(const u8 *data, const u32 size, const std::string &path) {
FILE *out = fopen(path.c_str(), "wb");
fwrite(data, size, 1, out);
fclose(out);
}
template <size_t Size>
template <u32 Size>
static inline void write_file_binary(const std::array<u8, Size> &data, const std::string &path) {
std::ofstream file(path, std::ios::binary);
std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
}
static inline size_t next_pow2(size_t num) {
static inline u32 next_pow2(u32 num) {
// Taken from "Bit Twiddling Hacks" by Sean Anderson:
// https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
--num;
external/ircolib/mem_access.hpp
Vendored
+13 -13
View File
@@ -35,14 +35,14 @@ template <typename T>
static constexpr inline T read_access(const u8 *data, const u32 index);
template <typename T>
static constexpr inline T read_access(const std::vector<u8> &data, const u32 index);
template <typename T, size_t Size>
template <typename T, u32 Size>
static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index);
template <typename T>
static constexpr inline void write_access(u8 *data, const u32 index, const T val);
template <typename T>
static constexpr inline void write_access(std::vector<u8> &data, const u32 index, const T val);
template <typename T, size_t Size>
template <typename T, u32 Size>
static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val);
template <>
@@ -70,19 +70,19 @@ static constexpr inline T read_access(const std::vector<u8> &data, const u32 ind
return *reinterpret_cast<const T *>(&data[index]);
}
template <size_t Size>
template <u32 Size>
constexpr inline u64 read_access(const std::array<u8, Size> &data, const u32 index) {
u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
return static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
}
template <typename T, size_t Size>
template <typename T, u32 Size>
static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index) {
return *reinterpret_cast<const T *>(&data[index]);
}
template <size_t Size>
template <u32 Size>
constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const u64 val) {
const u32 hi = val >> 32;
const u32 lo = val;
@@ -91,7 +91,7 @@ constexpr inline void write_access(std::array<u8, Size> &data, const u32 index,
*reinterpret_cast<u32 *>(&data[index + 4]) = lo;
}
template <typename T, size_t Size>
template <typename T, u32 Size>
static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val) {
*reinterpret_cast<T *>(&data[index]) = val;
}
@@ -126,34 +126,34 @@ static constexpr inline void write_access(u8 *data, const u32 index, const T val
template <typename T>
static constexpr inline void swap_buffer(std::vector<u8> &data) {
for (size_t i = 0; i < data.size(); i += sizeof(T)) {
for (u32 i = 0; i < data.size(); i += sizeof(T)) {
const T original = *reinterpret_cast<T *>(&data[i]);
*reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
}
}
template <typename T, size_t Size>
template <typename T, u32 Size>
static constexpr inline void swap_buffer(std::array<u8, Size> &data) {
for (size_t i = 0; i < data.size(); i += sizeof(T)) {
for (u32 i = 0; i < data.size(); i += sizeof(T)) {
const T original = *reinterpret_cast<T *>(&data[i]);
*reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
}
}
template <typename T>
static constexpr inline void swap_buffer(u8 *data, size_t size) {
for (size_t i = 0; i < size; i += sizeof(T)) {
static constexpr inline void swap_buffer(u8 *data, u32 size) {
for (u32 i = 0; i < size; i += sizeof(T)) {
const T original = *reinterpret_cast<T *>(&data[i]);
*reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
}
}
#ifdef _WIN32
inline void *aligned_alloc(const size_t alignment, const size_t size) { return _aligned_malloc(size, alignment); }
inline void *aligned_alloc(const u32 alignment, const u32 size) { return _aligned_malloc(size, alignment); }
inline void aligned_free(void *ptr) { _aligned_free(ptr); }
#else
inline void *aligned_alloc(const size_t alignment, const size_t size) { return std::aligned_alloc(alignment, size); }
inline void *aligned_alloc(const u32 alignment, const u32 size) { return std::aligned_alloc(alignment, size); }
inline void aligned_free(void *ptr) { std::free(ptr); }
#endif
external/ircolib/types.hpp
Vendored
+5 -6
View File
@@ -1,6 +1,5 @@
#pragma once
#include <cstdint>
#include <cstddef>
namespace ircolib {
using u8 = uint8_t;
@@ -12,28 +11,28 @@ using s16 = int16_t;
using s32 = int32_t;
using s64 = int64_t;
template <typename T, std::size_t bit>
template <typename T, u32 bit>
static constexpr bool is_bit_set(const T &val) {
return val & (1 << bit);
}
template <typename T, std::size_t bit>
template <typename T, u32 bit>
static constexpr void set_bit(T &val) {
val |= 1 << bit;
}
template <typename T>
inline bool is_bit_set(const T &val, const std::size_t &bit) {
inline bool is_bit_set(const T &val, const u32 &bit) {
return val & (1 << bit);
}
template <typename T>
inline void set_bit(T &val, const std::size_t &bit) {
inline void set_bit(T &val, const u32 &bit) {
val |= 1 << bit;
}
template <typename T>
inline void clear_bit(T &val, const std::size_t &bit) {
inline void clear_bit(T &val, const u32 &bit) {
val &= ~(1 << bit);
}
} // namespace ircolib
main.cpp
+4 -6
View File
@@ -1,14 +1,12 @@
#include <cflags.hpp>
#include <ircolib/mem_access.hpp>
#include <ircolib/file.hpp>
#include <loaders/elf.hpp>
#include <loaders/dol.hpp>
#include <ircolib/log.hpp>
#include <mem.hpp>
#include <broadway.hpp>
#include <SDL3/SDL.h>
#include <filesystem>
namespace fs = std::filesystem;
int main(int argc, char **argv) {
weee::core::mem mem;
@@ -20,7 +18,7 @@ int main(int argc, char **argv) {
flags.add_string_callback(
'\0', "elf",
[&](const std::string &v) {
binName = fs::path(v).filename().string();
binName = ircolib::fs::path(v).filename().string();
if (!weee::core::load_elf(v, mem, broadway))
ircolib::panic("Could not load '{}'", v);
},
@@ -29,7 +27,7 @@ int main(int argc, char **argv) {
flags.add_string_callback(
'\0', "dol",
[&](const std::string &v) {
binName = fs::path(v).filename().string();
binName = ircolib::fs::path(v).filename().string();
if (!weee::core::load_dol(v, mem, broadway))
ircolib::panic("Could not load '{}'", v);
},
@@ -69,7 +67,7 @@ int main(int argc, char **argv) {
open = false;
}
SDL_ConvertPixels(640, 240, SDL_PIXELFORMAT_UYVY, &mem.mem1[vi.xfb_top_addr()], 640 * 4, SDL_PIXELFORMAT_BGR24,
SDL_ConvertPixels(640, 240, SDL_PIXELFORMAT_UYVY, &mem.mem1[0], 640 * 4, SDL_PIXELFORMAT_BGR24,
rgbTexture.data(), 640 * 3);
SDL_RenderClear(renderer);