generation of add and extraction of flags

Signed-off-by: lizzie <lizzie@eden-emu.dev>

externals/powah/powah_emit.hpp

@@ -254,14 +254,15 @@ struct Context {
         );
     }
     void emit_M(uint32_t op, GPR const rs, GPR const ra, uint32_t sh, uint32_t mb, uint32_t me, bool rc) {
-        (void)op;
-        (void)rs;
-        (void)ra;
-        (void)sh;
-        (void)mb;
-        (void)me;
-        (void)rc;
-        std::abort();
+        assert(sh <= 0x3f && mb <= 0x3f);
+        base[offset++] = (op |
+            bitExt(ra.index, 6, 5)
+            | bitExt(rs.index, 11, 5)
+            | bitExt(sh, 16, 5)
+            | bitExt(mb, 21, 4)
+            | bitExt(me, 26, 4)
+            | bitExt(rc, 31, 1)
+        );
     }
     void emit_MD(uint32_t op, GPR const rs, GPR const ra, GPR const rb, uint32_t mb, bool rc) {
         assert(mb <= 0x3f);

src/dynarmic/src/dynarmic/backend/ppc64/abi.h

@@ -8,7 +8,7 @@
 
 namespace Dynarmic::Backend::PPC64 {
 
-constexpr powah::GPR RJIT = powah::R31;
+constexpr powah::GPR RJIT = powah::R3; //yeah it's param, so what?
 
 constexpr powah::GPR ABI_PARAM1 = powah::R3;
 constexpr powah::GPR ABI_PARAM2 = powah::R4;
@@ -20,4 +20,12 @@ constexpr std::initializer_list<u32> GPR_ORDER{
     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
 };
 
+constexpr std::initializer_list<powah::GPR> ABI_CALLEE_SAVED{
+    powah::R14, powah::R15, powah::R16, powah::R17,
+    powah::R18, powah::R19, powah::R20, powah::R21,
+    powah::R22, powah::R23, powah::R24, powah::R25,
+    powah::R26, powah::R27, powah::R28, powah::R29,
+    powah::R30, powah::R31
+};
+
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64.cpp

@@ -24,76 +24,76 @@ void EmitIR<IR::Opcode::Void>(powah::Context&, EmitContext&, IR::Inst*) {}
 
 template<>
 void EmitIR<IR::Opcode::Identity>(powah::Context&, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::Breakpoint>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CallHostFunction>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PushRSB>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetCarryFromOp>(powah::Context&, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetOverflowFromOp>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetGEFromOp>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetNZCVFromOp>(powah::Context&, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::GetNZFromOp>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::GetNZFromOp>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetUpperFromOp>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::GetLowerFromOp>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::GetCFlagFromNZCV>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::GetCFlagFromNZCV>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::NZCVFromPackedFlags>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 EmittedBlockInfo EmitPPC64(powah::Context& code, IR::Block block, const EmitConfig& emit_conf) {
     EmittedBlockInfo ebi;
     RegAlloc reg_alloc{code};
     EmitContext ctx{block, reg_alloc, emit_conf, ebi};
-    ebi.entry_point = CodePtr(code.base + code.offset);
 
-    code.BLR();
+    auto const start_offset = code.offset;
+    ebi.entry_point = CodePtr(code.base + start_offset);
 
     // Non-volatile saves
     std::vector<u32> gpr_order{GPR_ORDER};
@@ -127,12 +127,20 @@ EmittedBlockInfo EmitPPC64(powah::Context& code, IR::Block block, const EmitConf
     for (size_t i = 0; i < gpr_order.size(); ++i)
         code.LD(powah::GPR{gpr_order[i]}, powah::R1, -(i * 8));
     code.BLR();
-    ebi.size = code.offset;
+
+    /*
+    llvm-objcopy -I binary -O elf64-powerpc --rename-section=.data=.text,code test.bin test.elf
+    llvm-objdump -d test.elf
+    */
+    static FILE* fp = fopen("test.bin", "ab");
+    fwrite(code.base, code.offset - start_offset, sizeof(uint32_t), fp);
+
+    ebi.size = code.offset - start_offset;
     return ebi;
 }
 
-void EmitRelocation(powah::Context& as, EmitContext& ctx, LinkTarget link_target) {
-    UNREACHABLE();
+void EmitRelocation(powah::Context& code, EmitContext& ctx, LinkTarget link_target) {
+    ASSERT(false && "unimp");
 }
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64.h

@@ -45,12 +45,12 @@ struct EmitConfig {
 
 struct EmitContext;
 
-EmittedBlockInfo EmitPPC64(powah::Context& as, IR::Block block, const EmitConfig& emit_conf);
+EmittedBlockInfo EmitPPC64(powah::Context& code, IR::Block block, const EmitConfig& emit_conf);
 
 template<IR::Opcode op>
-void EmitIR(powah::Context& as, EmitContext& ctx, IR::Inst* inst);
-void EmitRelocation(powah::Context& as, EmitContext& ctx, LinkTarget link_target);
-void EmitA32Cond(powah::Context& as, EmitContext& ctx, IR::Cond cond, powah::Label* label);
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx);
+void EmitIR(powah::Context& code, EmitContext& ctx, IR::Inst* inst);
+void EmitRelocation(powah::Context& code, EmitContext& ctx, LinkTarget link_target);
+void EmitA32Cond(powah::Context& code, EmitContext& ctx, IR::Cond cond, powah::Label* label);
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx);
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64_a32.cpp

@@ -15,340 +15,355 @@
 
 namespace Dynarmic::Backend::PPC64 {
 
-void EmitA32Cond(powah::Context& as, EmitContext&, IR::Cond cond, powah::Label* label) {
-    UNREACHABLE();
+void EmitA32Cond(powah::Context& code, EmitContext&, IR::Cond cond, powah::Label* label) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
 
 void EmitA32Terminal(powah::Context&, EmitContext&, IR::Term::Interpret, IR::LocationDescriptor, bool) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
-    EmitRelocation(as, ctx, LinkTarget::ReturnFromRunCode);
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
+    EmitRelocation(code, ctx, LinkTarget::ReturnFromRunCode);
 }
 
-void EmitSetUpperLocationDescriptor(powah::Context& as, EmitContext& ctx, IR::LocationDescriptor new_location, IR::LocationDescriptor old_location) {
-    UNREACHABLE();
+void EmitSetUpperLocationDescriptor(powah::Context& code, EmitContext& ctx, IR::LocationDescriptor new_location, IR::LocationDescriptor old_location) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location, bool) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location, bool) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location, bool) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location, bool) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::PopRSBHint, IR::LocationDescriptor, bool) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::PopRSBHint, IR::LocationDescriptor, bool) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    ASSERT(false && "unimp");
 }
 
-void EmitA32Terminal(powah::Context& as, EmitContext& ctx) {
-    UNREACHABLE();
+void EmitA32Terminal(powah::Context& code, EmitContext& ctx) {
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetCheckBit>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::A32GetRegister>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::A32GetRegister>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    auto args = ctx.reg_alloc.GetArgumentInfo(inst);
+    powah::GPR const result = ctx.reg_alloc.ScratchGpr();
+    powah::GPR const index = ctx.reg_alloc.UseScratchGpr(args[1]);
+    code.SLDI(index, index, 3);
+    code.ADD(result, PPC64::RJIT, index);
+    code.LD(result, result, offsetof(A32JitState, regs));
+    ctx.reg_alloc.DefineValue(inst, result);
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetExtendedRegister32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetExtendedRegister64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetVector>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::A32SetRegister>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::A32SetRegister>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    auto args = ctx.reg_alloc.GetArgumentInfo(inst);
+    powah::GPR const result = ctx.reg_alloc.ScratchGpr();
+    powah::GPR const index = ctx.reg_alloc.UseScratchGpr(args[1]);
+    code.SLDI(index, index, 3);
+    code.ADD(result, PPC64::RJIT, index);
+    code.STD(result, result, offsetof(A32JitState, regs));
+    ctx.reg_alloc.DefineValue(inst, result);
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetExtendedRegister32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetExtendedRegister64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetVector>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetCpsr>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetCpsr>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::A32SetCpsrNZCV>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::A32SetCpsrNZCV>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetCpsrNZCVRaw>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetCpsrNZCVQ>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetCpsrNZ>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::A32SetCpsrNZC>(powah::Context& as, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::A32SetCpsrNZC>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    ASSERT(false && "unimp");
 }
 
 template<>
-void EmitIR<IR::Opcode::A32GetCFlag>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+void EmitIR<IR::Opcode::A32GetCFlag>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
+    powah::GPR const result = ctx.reg_alloc.ScratchGpr();
+    code.LD(result, PPC64::RJIT, offsetof(A32JitState, cpsr_nzcv));
+    code.RLWINM(result, result, 31, 31, 31);
+    ctx.reg_alloc.DefineValue(inst, result);
 }
 
 template<>
 void EmitIR<IR::Opcode::A32OrQFlag>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetGEFlags>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetGEFlags>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetGEFlagsCompressed>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32BXWritePC>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32UpdateUpperLocationDescriptor>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CallSupervisor>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExceptionRaised>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32DataSynchronizationBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32DataMemoryBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32InstructionSynchronizationBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetFpscr>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetFpscr>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32GetFpscrNZCV>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32SetFpscrNZCV>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // Memory
 template<>
 void EmitIR<IR::Opcode::A32ClearExclusive>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ReadMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ReadMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ReadMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ReadMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveReadMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveReadMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveReadMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveReadMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32WriteMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32WriteMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32WriteMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32WriteMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveWriteMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveWriteMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveWriteMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32ExclusiveWriteMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // Coprocesor
 template<>
 void EmitIR<IR::Opcode::A32CoprocInternalOperation>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocSendOneWord>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocSendTwoWords>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocGetOneWord>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocGetTwoWords>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocLoadWords>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A32CoprocStoreWords>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64_a64.cpp

@@ -17,288 +17,288 @@ namespace Dynarmic::Backend::PPC64 {
 
 template<>
 void EmitIR<IR::Opcode::A64SetCheckBit>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetCFlag>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetNZCVRaw>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetNZCVRaw>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetNZCV>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetW>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetX>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetS>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetD>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetQ>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetSP>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetFPCR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetFPSR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetW>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetX>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetS>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetD>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetQ>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetSP>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetFPCR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetFPSR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetPC>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64CallSupervisor>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExceptionRaised>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64DataCacheOperationRaised>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64InstructionCacheOperationRaised>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64DataSynchronizationBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64DataMemoryBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64InstructionSynchronizationBarrier>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetCNTFRQ>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetCNTPCT>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetCTR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetDCZID>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetTPIDR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64GetTPIDRRO>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64SetTPIDR>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // Memory
 template<>
 void EmitIR<IR::Opcode::A64ClearExclusive>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ReadMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ReadMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ReadMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ReadMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ReadMemory128>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveReadMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveReadMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveReadMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveReadMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveReadMemory128>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64WriteMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64WriteMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64WriteMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64WriteMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64WriteMemory128>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveWriteMemory8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveWriteMemory16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveWriteMemory32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveWriteMemory64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::A64ExclusiveWriteMemory128>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64_data_processing.cpp

@@ -18,17 +18,17 @@ namespace Dynarmic::Backend::PPC64 {
 
 template<>
 void EmitIR<IR::Opcode::Pack2x32To1x64>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::Pack2x64To1x128>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::LeastSignificantWord>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 /*
@@ -119,7 +119,7 @@ void EmitIR<IR::Opcode::TestBit>(powah::Context& code, EmitContext& ctx, IR::Ins
             code.RLDICL(result, source, (64 - shift - 1) & 0x3f, 63);
         }
     } else {
-        UNREACHABLE();
+        ASSERT(false && "unimp");
     }
     ctx.reg_alloc.DefineValue(inst, result);
 }
@@ -244,7 +244,7 @@ static powah::GPR EmitConditionalSelectX(powah::Context& code, EmitContext& ctx,
         code.MR(nzcv, then_);
     } break;
     default:
-        UNREACHABLE();
+        ASSERT(false && "unimp");
     }
     return nzcv;
 }
@@ -773,7 +773,7 @@ void EmitIR<IR::Opcode::ZeroExtendWordToLong>(powah::Context& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::ZeroExtendLongToQuad>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // __builtin_bswap32
@@ -856,22 +856,22 @@ void EmitIR<IR::Opcode::CountLeadingZeros64>(powah::Context& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::ExtractRegister32>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::ExtractRegister64>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::ReplicateBit32>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::ReplicateBit64>(powah::Context& code, EmitContext& ctx, IR::Inst* inst) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64_floating_point.cpp

@@ -17,442 +17,442 @@ namespace Dynarmic::Backend::PPC64 {
 
 template<>
 void EmitIR<IR::Opcode::FPAbs16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPAbs32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPAbs64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPAdd32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPAdd64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPCompare32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPCompare64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDiv32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDiv64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMax32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMax64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMaxNumeric32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMaxNumeric64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMin32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMin64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMinNumeric32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMinNumeric64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMul32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMul64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulAdd16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulAdd32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulAdd64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulSub16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulSub32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulSub64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulX32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPMulX64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPNeg16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPNeg32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPNeg64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipEstimate16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipEstimate32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipEstimate64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipExponent16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipExponent32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipExponent64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipStepFused16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipStepFused32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRecipStepFused64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRoundInt16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRoundInt32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRoundInt64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtEstimate16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtEstimate32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtEstimate64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtStepFused16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtStepFused32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPRSqrtStepFused64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSqrt32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSqrt64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSub32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSub64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToHalf>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToHalf>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedS32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedS64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedU32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPDoubleToFixedU64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedS32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedS64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedU32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPHalfToFixedU64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedS32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedS64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedU32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPSingleToFixedU64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU16ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS16ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU16ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS16ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU32ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS32ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU32ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS32ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU64ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedU64ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS64ToDouble>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::FPFixedS64ToSingle>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/emit_ppc64_misc.cpp

@@ -17,364 +17,364 @@ namespace Dynarmic::Backend::PPC64 {
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedAddWithFlag32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedSubWithFlag32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturation>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturation>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedAdd8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedAdd16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedAdd32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedAdd64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedDoublingMultiplyReturnHigh16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedDoublingMultiplyReturnHigh32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedSub8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedSub16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedSub32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SignedSaturatedSub64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedAdd8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedAdd16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedAdd32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedAdd64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedSub8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedSub16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedSub32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::UnsignedSaturatedSub64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // Packed
 template<>
 void EmitIR<IR::Opcode::PackedAddU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAddS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAddU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAddS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAddSubU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAddSubS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubAddU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSubAddS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddSubU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingAddSubS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubAddU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedHalvingSubAddS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedAddU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedAddS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedSubU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedSubS8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedAddU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedAddS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedSubU16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSaturatedSubS16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedAbsDiffSumU8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::PackedSelect>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 // Crypto
 template<>
 void EmitIR<IR::Opcode::CRC32Castagnoli8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32Castagnoli16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32Castagnoli32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32Castagnoli64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32ISO8>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32ISO16>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32ISO32>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::CRC32ISO64>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::AESDecryptSingleRound>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::AESEncryptSingleRound>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::AESInverseMixColumns>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::AESMixColumns>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SM4AccessSubstitutionBox>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SHA256Hash>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SHA256MessageSchedule0>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 template<>
 void EmitIR<IR::Opcode::SHA256MessageSchedule1>(powah::Context&, EmitContext&, IR::Inst*) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/reg_alloc.cpp

@@ -1,16 +1,15 @@
 // SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "dynarmic/backend/ppc64/reg_alloc.h"
 
 #include <algorithm>
 #include <array>
 #include <ranges>
 
+#include "dynarmic/backend/ppc64/reg_alloc.h"
+#include "dynarmic/backend/ppc64/abi.h"
 #include "dynarmic/common/assert.h"
-#include <mcl/mp/metavalue/lift_value.hpp>
 #include "dynarmic/common/common_types.h"
-
 #include "dynarmic/common/always_false.h"
 
 namespace Dynarmic::Backend::PPC64 {
@@ -22,67 +21,9 @@ static bool IsValuelessType(IR::Type type) {
     return type == IR::Type::Table;
 }
 
-IR::Type Argument::GetType() const {
-    return value.GetType();
-}
-
-bool Argument::IsImmediate() const {
-    return value.IsImmediate();
-}
-
-bool Argument::GetImmediateU1() const {
-    return value.GetU1();
-}
-
-u8 Argument::GetImmediateU8() const {
-    const u64 imm = value.GetImmediateAsU64();
-    ASSERT(imm < 0x100);
-    return u8(imm);
-}
-
-u16 Argument::GetImmediateU16() const {
-    const u64 imm = value.GetImmediateAsU64();
-    ASSERT(imm < 0x10000);
-    return u16(imm);
-}
-
-u32 Argument::GetImmediateU32() const {
-    const u64 imm = value.GetImmediateAsU64();
-    ASSERT(imm < 0x100000000);
-    return u32(imm);
-}
-
-u64 Argument::GetImmediateU64() const {
-    return value.GetImmediateAsU64();
-}
-
-IR::Cond Argument::GetImmediateCond() const {
-    ASSERT(IsImmediate() && GetType() == IR::Type::Cond);
-    return value.GetCond();
-}
-
-IR::AccType Argument::GetImmediateAccType() const {
-    ASSERT(IsImmediate() && GetType() == IR::Type::AccType);
-    return value.GetAccType();
-}
-
-bool HostLocInfo::Contains(const IR::Inst* value) const {
-    return std::find(values.begin(), values.end(), value) != values.end();
-}
-
-void HostLocInfo::SetupScratchLocation() {
-    ASSERT(IsCompletelyEmpty());
-    realized = true;
-}
-
-bool HostLocInfo::IsCompletelyEmpty() const {
-    return values.empty() && !locked && !realized && !accumulated_uses && !expected_uses && !uses_this_inst;
-}
-
 void HostLocInfo::UpdateUses() {
     accumulated_uses += uses_this_inst;
     uses_this_inst = 0;
-
     if (accumulated_uses == expected_uses) {
         values.clear();
         accumulated_uses = 0;
@@ -139,34 +80,32 @@ void RegAlloc::AssertNoMoreUses() const {
     ASSERT(std::all_of(spills.begin(), spills.end(), is_empty));
 }
 
-u32 RegAlloc::AllocateRegister(const std::array<HostLocInfo, 32>& regs, const std::vector<u32>& order) const {
-    const auto empty = std::find_if(order.begin(), order.end(), [&](u32 i) { return regs[i].values.empty() && !regs[i].locked; });
-    if (empty != order.end())
-        return *empty;
-
+std::optional<u32> RegAlloc::AllocateRegister(const std::array<HostLocInfo, 32>& regs, const std::vector<u32>& order) const {
+    if (auto const it = std::find_if(order.begin(), order.end(), [&](u32 i) {
+        return regs[i].values.empty() && !regs[i].locked;
+    }); it != order.end())
+        return *it;
     std::vector<u32> candidates;
     std::copy_if(order.begin(), order.end(), std::back_inserter(candidates), [&](u32 i) { return !regs[i].locked; });
-    // TODO: LRU
-    return candidates[0];
+    return candidates.empty() ? std::nullopt : std::optional<u32>{candidates[0]}; // TODO: LRU
 }
 
 void RegAlloc::SpillGpr(u32 index) {
     ASSERT(!gprs[index].locked && !gprs[index].realized);
-    if (gprs[index].values.empty())
-        return;
-    const u32 new_location_index = FindFreeSpill();
-    //as.SD(powah::GPR{index}, spill_offset + new_location_index * spill_slot_size, powah::sp);
-    spills[new_location_index] = std::exchange(gprs[index], {});
+    if (!gprs[index].values.empty()) {
+        const u32 new_location_index = FindFreeSpill();
+        code.STD(powah::GPR{index}, powah::R1, spill_offset + new_location_index * spill_slot_size);
+        spills[new_location_index] = std::exchange(gprs[index], {});
+    }
 }
 
 void RegAlloc::SpillFpr(u32 index) {
     ASSERT(!fprs[index].locked && !fprs[index].realized);
-    if (fprs[index].values.empty()) {
-        return;
+    if (!fprs[index].values.empty()) {
+        const u32 new_location_index = FindFreeSpill();
+        //code.FSD(powah::FPR{index}, spill_offset + new_location_index * spill_slot_size, powah::sp);
+        spills[new_location_index] = std::exchange(fprs[index], {});
     }
-    const u32 new_location_index = FindFreeSpill();
-    //as.FSD(powah::FPR{index}, spill_offset + new_location_index * spill_slot_size, powah::sp);
-    spills[new_location_index] = std::exchange(fprs[index], {});
 }
 
 u32 RegAlloc::FindFreeSpill() const {
@@ -190,16 +129,22 @@ std::optional<HostLoc> RegAlloc::ValueLocation(const IR::Inst* value) const {
     return std::nullopt;
 }
 
-HostLocInfo& RegAlloc::ValueInfo(HostLoc host_loc) {
-    // switch (host_loc.kind) {
-    // case HostLoc::Kind::Gpr:
-    //     return gprs[size_t(host_loc.index)];
-    // case HostLoc::Kind::Fpr:
-    //     return fprs[size_t(host_loc.index)];
-    // case HostLoc::Kind::Spill:
-    //     return spills[size_t(host_loc.index)];
-    // }
-    UNREACHABLE();
+static powah::GPR HostLocToReg(HostLoc h) noexcept {
+    if (u8(h) >= u8(HostLoc::R0) && u8(h) <= u8(HostLoc::R31))
+        return powah::GPR{uint32_t(h)};
+    ASSERT(false && "unimp");
+}
+
+HostLocInfo& RegAlloc::ValueInfo(HostLoc h) {
+    if (u8(h) >= u8(HostLoc::R0) && u8(h) <= u8(HostLoc::R31))
+        return gprs[size_t(h)];
+    else if (u8(h) >= u8(HostLoc::FR0) && u8(h) <= u8(HostLoc::FR31))
+        return gprs[size_t(h) - size_t(HostLoc::FR0)];
+    else if (u8(h) >= u8(HostLoc::VR0) && u8(h) <= u8(HostLoc::VR31))
+        return vprs[size_t(h) - size_t(HostLoc::VR0)];
+    auto const index = size_t(h) - size_t(HostLoc::FirstSpill);
+    ASSERT(index <= spills.size());
+    return spills[index];
 }
 
 HostLocInfo& RegAlloc::ValueInfo(const IR::Inst* value) {
@@ -212,35 +157,49 @@ HostLocInfo& RegAlloc::ValueInfo(const IR::Inst* value) {
         return *iter;
     else if (const auto iter = std::find_if(spills.begin(), spills.end(), fn); iter != spills.end())
         return *iter;
-    UNREACHABLE();
-}
-
-powah::GPR RegAlloc::ScratchGpr(std::optional<std::initializer_list<HostLoc>> desired_locations) {
-    UNREACHABLE();
+    ASSERT(false && "unimp");
 }
 
-void RegAlloc::Use(Argument& arg, HostLoc host_loc) {
-    UNREACHABLE();
-}
-
-void RegAlloc::UseScratch(Argument& arg, HostLoc host_loc) {
-    UNREACHABLE();
+powah::GPR RegAlloc::ScratchGpr() {
+    auto const r = AllocateRegister(gprs, PPC64::GPR_ORDER);
+    return powah::GPR{*r};
 }
 
 powah::GPR RegAlloc::UseGpr(Argument& arg) {
-    UNREACHABLE();
+    ASSERT(!arg.allocated);
+    arg.allocated = true;
+    return ScratchGpr();
 }
 
 powah::GPR RegAlloc::UseScratchGpr(Argument& arg) {
-    UNREACHABLE();
+    ASSERT(!arg.allocated);
+    arg.allocated = true;
+    return ScratchGpr();
 }
 
 void RegAlloc::DefineValue(IR::Inst* inst, powah::GPR const gpr) noexcept {
-    UNREACHABLE();
+    ASSERT(!ValueLocation(inst) && "inst has already been defined");
+    ValueInfo(HostLoc(gpr.index)).values.push_back(inst);
 }
 
 void RegAlloc::DefineValue(IR::Inst* inst, Argument& arg) noexcept {
-    UNREACHABLE();
+    ASSERT(!arg.allocated);
+    arg.allocated = true;
+    ASSERT(!ValueLocation(inst) && "inst has already been defined");
+    if (arg.value.IsImmediate()) {
+        HostLoc const loc{u8(ScratchGpr().index)};
+        ValueInfo(loc).values.push_back(inst);
+        auto const value = arg.value.GetImmediateAsU64();
+        if (value >= 0x7fff) {
+            ASSERT(false && "unimp");
+        } else {
+            //code.LI(HostLocToReg(loc), value);
+        }
+    } else {
+        ASSERT(ValueLocation(arg.value.GetInst()) && "arg.value must already be defined");
+        const HostLoc loc = *ValueLocation(arg.value.GetInst());
+        ValueInfo(loc).values.push_back(inst);
+    }
 }
 
 }  // namespace Dynarmic::Backend::RV64

src/dynarmic/src/dynarmic/backend/ppc64/reg_alloc.h

@@ -26,27 +26,47 @@ class RegAlloc;
 
 struct Argument {
 public:
-    using copyable_reference = std::reference_wrapper<Argument>;
-
-    IR::Type GetType() const;
-    bool IsImmediate() const;
-
-    bool GetImmediateU1() const;
-    u8 GetImmediateU8() const;
-    u16 GetImmediateU16() const;
-    u32 GetImmediateU32() const;
-    u64 GetImmediateU64() const;
-    IR::Cond GetImmediateCond() const;
-    IR::AccType GetImmediateAccType() const;
-
+    IR::Type GetType() const {
+        return value.GetType();
+    }
+    bool IsImmediate() const {
+        return value.IsImmediate();
+    }
+    bool GetImmediateU1() const {
+        return value.GetU1();
+    }
+    u8 GetImmediateU8() const {
+        const u64 imm = value.GetImmediateAsU64();
+        ASSERT(imm < 0x100);
+        return u8(imm);
+    }
+    u16 GetImmediateU16() const {
+        const u64 imm = value.GetImmediateAsU64();
+        ASSERT(imm < 0x10000);
+        return u16(imm);
+    }
+    u32 GetImmediateU32() const {
+        const u64 imm = value.GetImmediateAsU64();
+        ASSERT(imm < 0x100000000);
+        return u32(imm);
+    }
+    u64 GetImmediateU64() const {
+        return value.GetImmediateAsU64();
+    }
+    IR::Cond GetImmediateCond() const {
+        ASSERT(IsImmediate() && GetType() == IR::Type::Cond);
+        return value.GetCond();
+    }
+    IR::AccType GetImmediateAccType() const {
+        ASSERT(IsImmediate() && GetType() == IR::Type::AccType);
+        return value.GetAccType();
+    }
 private:
     friend class RegAlloc;
-    explicit Argument(RegAlloc& reg_alloc)
-            : reg_alloc{reg_alloc} {}
-
-    bool allocated = false;
+    explicit Argument(RegAlloc& reg_alloc) : reg_alloc{reg_alloc} {}
     RegAlloc& reg_alloc;
     IR::Value value;
+    bool allocated = false;
 };
 
 struct HostLocInfo final {
@@ -57,9 +77,16 @@ struct HostLocInfo final {
     size_t expected_uses = 0;
     bool realized = false;
 
-    bool Contains(const IR::Inst*) const;
-    void SetupScratchLocation();
-    bool IsCompletelyEmpty() const;
+    bool Contains(const IR::Inst* value) const {
+        return std::find(values.begin(), values.end(), value) != values.end();
+    }
+    void SetupScratchLocation() {
+        ASSERT(IsCompletelyEmpty());
+        realized = true;
+    }
+    bool IsCompletelyEmpty() const {
+        return values.empty() && !locked && !realized && !accumulated_uses && !expected_uses && !uses_this_inst;
+    }
     void UpdateUses();
 };
 
@@ -67,7 +94,7 @@ class RegAlloc {
 public:
     using ArgumentInfo = std::array<Argument, IR::max_arg_count>;
 
-    explicit RegAlloc(powah::Context& as) : as{as} {}
+    explicit RegAlloc(powah::Context& code) : code{code} {}
 
     ArgumentInfo GetArgumentInfo(IR::Inst* inst);
     bool IsValueLive(IR::Inst* inst) const;
@@ -77,15 +104,13 @@ public:
     void UpdateAllUses();
     void AssertNoMoreUses() const;
 
-    powah::GPR ScratchGpr(std::optional<std::initializer_list<HostLoc>> desired_locations = {});
-    void Use(Argument& arg, HostLoc host_loc);
-    void UseScratch(Argument& arg, HostLoc host_loc);
+    powah::GPR ScratchGpr();
     powah::GPR UseGpr(Argument& arg);
     powah::GPR UseScratchGpr(Argument& arg);
     void DefineValue(IR::Inst* inst, powah::GPR const gpr) noexcept;
     void DefineValue(IR::Inst* inst, Argument& arg) noexcept;
 private:
-    u32 AllocateRegister(const std::array<HostLocInfo, 32>& regs, const std::vector<u32>& order) const;
+    std::optional<u32> AllocateRegister(const std::array<HostLocInfo, 32>& regs, const std::vector<u32>& order) const;
     void SpillGpr(u32 index);
     void SpillFpr(u32 index);
     u32 FindFreeSpill() const;
@@ -94,7 +119,7 @@ private:
     HostLocInfo& ValueInfo(HostLoc host_loc);
     HostLocInfo& ValueInfo(const IR::Inst* value);
 
-    powah::Context& as;
+    powah::Context& code;
     std::array<HostLocInfo, 32> gprs;
     std::array<HostLocInfo, 32> fprs;
     std::array<HostLocInfo, 32> vprs;