diff --git a/benchmark/bench1.cpp b/benchmark/bench1.cpp
index 16e3aa0..7efde75 100644
--- a/benchmark/bench1.cpp
+++ b/benchmark/bench1.cpp
@@ -73,7 +73,7 @@ int main(int argc, char** argv) {
 
     /* load executable code into RAM at address 0 */
     for (i = 0; i < sizeof(cs_code) / sizeof(cs_code[0]); i++) {
-        mmu_write_vmem<uint32_t>(i*4, cs_code[i]);
+        mmu_write_vmem<uint32_t>(i * 4, 0, cs_code[i]);
     }
 
     srand(0xCAFEBABE);
@@ -83,7 +83,7 @@ int main(int argc, char** argv) {
     bool did_lf = false;
     for (i = 0; i < test_size; i++) {
         uint8_t val = rand() % 256;
-        mmu_write_vmem<uint8_t>(0x1000+i, val);
+        mmu_write_vmem<uint8_t>(0x1000 + i, 0, val);
         if (i < 64) {
             printf("%02x", val);
             did_lf = false;
diff --git a/cpu/ppc/poweropcodes.cpp b/cpu/ppc/poweropcodes.cpp
index ac7226d..74c8da1 100644
--- a/cpu/ppc/poweropcodes.cpp
+++ b/cpu/ppc/poweropcodes.cpp
@@ -54,10 +54,10 @@ void dppc_interpreter::power_abs(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::power_abs<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_abs<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_abs<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_abs<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_abs<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_abs<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_abs<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_abs<RC1, OV1>(uint32_t instr);
 
 void dppc_interpreter::power_clcs(uint32_t instr) {
     uint32_t ppc_result_d;
@@ -123,10 +123,10 @@ void dppc_interpreter::power_div(uint32_t instr) {
     ppc_state.spr[SPR::MQ] = remainder;
 }
 
-template void dppc_interpreter::power_div<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_div<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_div<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_div<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_div<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_div<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_div<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_div<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::power_divs(uint32_t instr) {
@@ -157,10 +157,10 @@ void dppc_interpreter::power_divs(uint32_t instr) {
     ppc_state.spr[SPR::MQ] = remainder;
 }
 
-template void dppc_interpreter::power_divs<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_divs<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_divs<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_divs<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_divs<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_divs<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_divs<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_divs<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::power_doz(uint32_t instr) {
@@ -181,10 +181,10 @@ void dppc_interpreter::power_doz(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::power_doz<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_doz<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_doz<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_doz<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_doz<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_doz<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_doz<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_doz<RC1, OV1>(uint32_t instr);
 
 void dppc_interpreter::power_dozi(uint32_t instr) {
     uint32_t ppc_result_d;
@@ -248,8 +248,8 @@ void dppc_interpreter::power_lscbx(uint32_t instr) {
     }
 }
 
-template void dppc_interpreter::power_lscbx<RC0>(uint32_t);
-template void dppc_interpreter::power_lscbx<RC1>(uint32_t);
+template void dppc_interpreter::power_lscbx<RC0>(uint32_t instr);
+template void dppc_interpreter::power_lscbx<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_maskg(uint32_t instr) {
@@ -276,8 +276,8 @@ void dppc_interpreter::power_maskg(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_maskg<RC0>(uint32_t);
-template void dppc_interpreter::power_maskg<RC1>(uint32_t);
+template void dppc_interpreter::power_maskg<RC0>(uint32_t instr);
+template void dppc_interpreter::power_maskg<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_maskir(uint32_t instr) {
@@ -290,8 +290,8 @@ void dppc_interpreter::power_maskir(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_maskir<RC0>(uint32_t);
-template void dppc_interpreter::power_maskir<RC1>(uint32_t);
+template void dppc_interpreter::power_maskir<RC0>(uint32_t instr);
+template void dppc_interpreter::power_maskir<RC1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::power_mul(uint32_t instr) {
@@ -312,10 +312,10 @@ void dppc_interpreter::power_mul(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::power_mul<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_mul<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_mul<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_mul<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_mul<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_mul<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_mul<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_mul<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::power_nabs(uint32_t instr) {
@@ -330,10 +330,10 @@ void dppc_interpreter::power_nabs(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::power_nabs<RC0, OV0>(uint32_t);
-template void dppc_interpreter::power_nabs<RC0, OV1>(uint32_t);
-template void dppc_interpreter::power_nabs<RC1, OV0>(uint32_t);
-template void dppc_interpreter::power_nabs<RC1, OV1>(uint32_t);
+template void dppc_interpreter::power_nabs<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::power_nabs<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::power_nabs<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::power_nabs<RC1, OV1>(uint32_t instr);
 
 void dppc_interpreter::power_rlmi(uint32_t instr) {
     ppc_grab_regssab(instr);
@@ -369,8 +369,8 @@ void dppc_interpreter::power_rrib(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_rrib<RC0>(uint32_t);
-template void dppc_interpreter::power_rrib<RC1>(uint32_t);
+template void dppc_interpreter::power_rrib<RC0>(uint32_t instr);
+template void dppc_interpreter::power_rrib<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sle(uint32_t instr) {
@@ -388,8 +388,8 @@ void dppc_interpreter::power_sle(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sle<RC0>(uint32_t);
-template void dppc_interpreter::power_sle<RC1>(uint32_t);
+template void dppc_interpreter::power_sle<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sle<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sleq(uint32_t instr) {
@@ -407,8 +407,8 @@ void dppc_interpreter::power_sleq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sleq<RC0>(uint32_t);
-template void dppc_interpreter::power_sleq<RC1>(uint32_t);
+template void dppc_interpreter::power_sleq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sleq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sliq(uint32_t instr) {
@@ -423,8 +423,8 @@ void dppc_interpreter::power_sliq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sliq<RC0>(uint32_t);
-template void dppc_interpreter::power_sliq<RC1>(uint32_t);
+template void dppc_interpreter::power_sliq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sliq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_slliq(uint32_t instr) {
@@ -441,8 +441,8 @@ void dppc_interpreter::power_slliq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_slliq<RC0>(uint32_t);
-template void dppc_interpreter::power_slliq<RC1>(uint32_t);
+template void dppc_interpreter::power_slliq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_slliq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sllq(uint32_t instr) {
@@ -461,8 +461,8 @@ void dppc_interpreter::power_sllq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sllq<RC0>(uint32_t);
-template void dppc_interpreter::power_sllq<RC1>(uint32_t);
+template void dppc_interpreter::power_sllq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sllq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_slq(uint32_t instr) {
@@ -482,8 +482,8 @@ void dppc_interpreter::power_slq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_slq<RC0>(uint32_t);
-template void dppc_interpreter::power_slq<RC1>(uint32_t);
+template void dppc_interpreter::power_slq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_slq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sraiq(uint32_t instr) {
@@ -504,8 +504,8 @@ void dppc_interpreter::power_sraiq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sraiq<RC0>(uint32_t);
-template void dppc_interpreter::power_sraiq<RC1>(uint32_t);
+template void dppc_interpreter::power_sraiq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sraiq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sraq(uint32_t instr) {
@@ -529,8 +529,8 @@ void dppc_interpreter::power_sraq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sraq<RC0>(uint32_t);
-template void dppc_interpreter::power_sraq<RC1>(uint32_t);
+template void dppc_interpreter::power_sraq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sraq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sre(uint32_t instr) {
@@ -547,8 +547,8 @@ void dppc_interpreter::power_sre(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sre<RC0>(uint32_t);
-template void dppc_interpreter::power_sre<RC1>(uint32_t);
+template void dppc_interpreter::power_sre<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sre<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_srea(uint32_t instr) {
@@ -571,8 +571,8 @@ void dppc_interpreter::power_srea(uint32_t instr) {
     ppc_state.spr[SPR::MQ] = r;
 }
 
-template void dppc_interpreter::power_srea<RC0>(uint32_t);
-template void dppc_interpreter::power_srea<RC1>(uint32_t);
+template void dppc_interpreter::power_srea<RC0>(uint32_t instr);
+template void dppc_interpreter::power_srea<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sreq(uint32_t instr) {
@@ -589,8 +589,8 @@ void dppc_interpreter::power_sreq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sreq<RC0>(uint32_t);
-template void dppc_interpreter::power_sreq<RC1>(uint32_t);
+template void dppc_interpreter::power_sreq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sreq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_sriq(uint32_t instr) {
@@ -604,8 +604,8 @@ void dppc_interpreter::power_sriq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_sriq<RC0>(uint32_t);
-template void dppc_interpreter::power_sriq<RC1>(uint32_t);
+template void dppc_interpreter::power_sriq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_sriq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_srliq(uint32_t instr) {
@@ -622,8 +622,8 @@ void dppc_interpreter::power_srliq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_srliq<RC0>(uint32_t);
-template void dppc_interpreter::power_srliq<RC1>(uint32_t);
+template void dppc_interpreter::power_srliq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_srliq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_srlq(uint32_t instr) {
@@ -644,8 +644,8 @@ void dppc_interpreter::power_srlq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_srlq<RC0>(uint32_t);
-template void dppc_interpreter::power_srlq<RC1>(uint32_t);
+template void dppc_interpreter::power_srlq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_srlq<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::power_srq(uint32_t instr) {
@@ -666,5 +666,5 @@ void dppc_interpreter::power_srq(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::power_srq<RC0>(uint32_t);
-template void dppc_interpreter::power_srq<RC1>(uint32_t);
+template void dppc_interpreter::power_srq<RC0>(uint32_t instr);
+template void dppc_interpreter::power_srq<RC1>(uint32_t instr);
diff --git a/cpu/ppc/ppcemu.h b/cpu/ppc/ppcemu.h
index 5a62c80..424f81d 100644
--- a/cpu/ppc/ppcemu.h
+++ b/cpu/ppc/ppcemu.h
@@ -399,7 +399,7 @@ typedef enum {
 extern void ppc_cpu_init(MemCtrlBase* mem_ctrl, uint32_t cpu_version, bool include_601, uint64_t tb_freq);
 extern void ppc_mmu_init();
 
-void ppc_illegalop();
+void ppc_illegalop(uint32_t null_val=0);
 void ppc_fpu_off();
 void ppc_assert_int();
 void ppc_release_int();
diff --git a/cpu/ppc/ppcexec.cpp b/cpu/ppc/ppcexec.cpp
index 7a6116a..f8454c5 100644
--- a/cpu/ppc/ppcexec.cpp
+++ b/cpu/ppc/ppcexec.cpp
@@ -204,7 +204,7 @@ static PPCOpcode SubOpcode63Grabber[2048];
 
 /** Exception helpers. */
 
-void ppc_illegalop() {
+void ppc_illegalop(uint32_t null_val) {
     ppc_exception_handler(Except_Type::EXC_PROGRAM, Exc_Cause::ILLEGAL_OP);
 }
 
diff --git a/cpu/ppc/ppcfpopcodes.cpp b/cpu/ppc/ppcfpopcodes.cpp
index b39d09b..295bab9 100644
--- a/cpu/ppc/ppcfpopcodes.cpp
+++ b/cpu/ppc/ppcfpopcodes.cpp
@@ -168,8 +168,8 @@ void dppc_interpreter::ppc_fadd(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fadd<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fadd<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fadd<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fadd<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fsub(uint32_t instr) {
@@ -186,8 +186,8 @@ void dppc_interpreter::ppc_fsub(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fsub<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fsub<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fsub<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fsub<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fdiv(uint32_t instr) {
@@ -203,8 +203,8 @@ void dppc_interpreter::ppc_fdiv(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fdiv<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fdiv<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fdiv<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fdiv<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmul(uint32_t instr) {
@@ -220,8 +220,8 @@ void dppc_interpreter::ppc_fmul(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmul<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmul<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmul<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmul<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmadd(uint32_t instr) {
@@ -238,8 +238,8 @@ void dppc_interpreter::ppc_fmadd(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmadd<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmadd<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmadd<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmadd<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmsub(uint32_t instr) {
@@ -256,8 +256,8 @@ void dppc_interpreter::ppc_fmsub(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmsub<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmsub<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmsub<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmsub<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fnmadd(uint32_t instr) {
@@ -274,8 +274,8 @@ void dppc_interpreter::ppc_fnmadd(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fnmadd<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fnmadd<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fnmadd<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fnmadd<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fnmsub(uint32_t instr) {
@@ -292,8 +292,8 @@ void dppc_interpreter::ppc_fnmsub(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fnmsub<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fnmsub<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fnmsub<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fnmsub<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fadds(uint32_t instr) {
@@ -310,8 +310,8 @@ void dppc_interpreter::ppc_fadds(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fadds<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fadds<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fadds<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fadds<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fsubs(uint32_t instr) {
@@ -328,8 +328,8 @@ void dppc_interpreter::ppc_fsubs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fsubs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fsubs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fsubs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fsubs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fdivs(uint32_t instr) {
@@ -345,8 +345,8 @@ void dppc_interpreter::ppc_fdivs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fdivs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fdivs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fdivs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fdivs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmuls(uint32_t instr) {
@@ -362,8 +362,8 @@ void dppc_interpreter::ppc_fmuls(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmuls<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmuls<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmuls<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmuls<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmadds(uint32_t instr) {
@@ -380,8 +380,8 @@ void dppc_interpreter::ppc_fmadds(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmadds<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmadds<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmadds<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmadds<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fmsubs(uint32_t instr) {
@@ -398,8 +398,8 @@ void dppc_interpreter::ppc_fmsubs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmsubs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmsubs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmsubs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmsubs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fnmadds(uint32_t instr) {
@@ -416,8 +416,8 @@ void dppc_interpreter::ppc_fnmadds(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fnmadds<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fnmadds<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fnmadds<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fnmadds<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fnmsubs(uint32_t instr) {
@@ -434,8 +434,8 @@ void dppc_interpreter::ppc_fnmsubs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fnmsubs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fnmsubs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fnmsubs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fnmsubs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fabs(uint32_t instr) {
@@ -451,8 +451,8 @@ void dppc_interpreter::ppc_fabs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fabs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fabs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fabs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fabs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fnabs(uint32_t instr) {
@@ -469,8 +469,8 @@ void dppc_interpreter::ppc_fnabs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fnabs<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fnabs<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fnabs<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fnabs<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fneg(uint32_t instr) {
@@ -486,8 +486,8 @@ void dppc_interpreter::ppc_fneg(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fneg<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fneg<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fneg<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fneg<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fsel(uint32_t instr) {
@@ -501,8 +501,8 @@ void dppc_interpreter::ppc_fsel(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fsel<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fsel<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fsel<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fsel<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fsqrt(uint32_t instr) {
@@ -518,8 +518,8 @@ void dppc_interpreter::ppc_fsqrt(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fsqrt<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fsqrt<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fsqrt<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fsqrt<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fsqrts(uint32_t instr) {
@@ -535,8 +535,8 @@ void dppc_interpreter::ppc_fsqrts(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fsqrts<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fsqrts<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fsqrts<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fsqrts<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_frsqrte(uint32_t instr) {
@@ -551,8 +551,8 @@ void dppc_interpreter::ppc_frsqrte(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_frsqrte<RC0>(uint32_t);
-template void dppc_interpreter::ppc_frsqrte<RC1>(uint32_t);
+template void dppc_interpreter::ppc_frsqrte<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_frsqrte<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_frsp(uint32_t instr) {
@@ -566,8 +566,8 @@ void dppc_interpreter::ppc_frsp(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_frsp<RC0>(uint32_t);
-template void dppc_interpreter::ppc_frsp<RC1>(uint32_t);
+template void dppc_interpreter::ppc_frsp<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_frsp<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fres(uint32_t instr) {
@@ -594,8 +594,8 @@ void dppc_interpreter::ppc_fres(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fres<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fres<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fres<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fres<RC1>(uint32_t instr);
 
 static void round_to_int(uint32_t instr, const uint8_t mode, field_rc rec) {
     ppc_grab_regsfpdb(instr);
@@ -659,16 +659,16 @@ void dppc_interpreter::ppc_fctiw(uint32_t instr) {
     round_to_int(instr, ppc_state.fpscr & 0x3, rec);
 }
 
-template void dppc_interpreter::ppc_fctiw<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fctiw<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fctiw<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fctiw<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_fctiwz(uint32_t instr) {
     round_to_int(instr, 1, rec);
 }
 
-template void dppc_interpreter::ppc_fctiwz<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fctiwz<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fctiwz<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fctiwz<RC1>(uint32_t instr);
 
 // Floating Point Store and Load
 
@@ -845,8 +845,8 @@ void dppc_interpreter::ppc_fmr(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_fmr<RC0>(uint32_t);
-template void dppc_interpreter::ppc_fmr<RC1>(uint32_t);
+template void dppc_interpreter::ppc_fmr<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_fmr<RC1>(uint32_t instr);
 
 template <field_601 for601, field_rc rec>
 void dppc_interpreter::ppc_mffs(uint32_t instr) {
@@ -858,10 +858,10 @@ void dppc_interpreter::ppc_mffs(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_mffs<NOT601, RC0>(uint32_t);
-template void dppc_interpreter::ppc_mffs<NOT601, RC1>(uint32_t);
-template void dppc_interpreter::ppc_mffs<IS601, RC0>(uint32_t);
-template void dppc_interpreter::ppc_mffs<IS601, RC1>(uint32_t);
+template void dppc_interpreter::ppc_mffs<NOT601, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mffs<NOT601, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_mffs<IS601, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mffs<IS601, RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mtfsf(uint32_t instr) {
@@ -893,8 +893,8 @@ void dppc_interpreter::ppc_mtfsf(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_mtfsf<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mtfsf<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mtfsf<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mtfsf<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mtfsfi(uint32_t instr) {
@@ -915,8 +915,8 @@ void dppc_interpreter::ppc_mtfsfi(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_mtfsfi<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mtfsfi<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mtfsfi<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mtfsfi<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mtfsb0(uint32_t instr) {
@@ -929,8 +929,8 @@ void dppc_interpreter::ppc_mtfsb0(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_mtfsb0<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mtfsb0<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mtfsb0<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mtfsb0<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mtfsb1(uint32_t instr) {
@@ -943,8 +943,8 @@ void dppc_interpreter::ppc_mtfsb1(uint32_t instr) {
         ppc_update_cr1();
 }
 
-template void dppc_interpreter::ppc_mtfsb1<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mtfsb1<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mtfsb1<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mtfsb1<RC1>(uint32_t instr);
 
 void dppc_interpreter::ppc_mcrfs(uint32_t instr) {
     int crf_d = (instr >> 21) & 0x1C;
diff --git a/cpu/ppc/ppcmmu.cpp b/cpu/ppc/ppcmmu.cpp
index a8abc7b..bc71d97 100644
--- a/cpu/ppc/ppcmmu.cpp
+++ b/cpu/ppc/ppcmmu.cpp
@@ -984,7 +984,7 @@ void mmu_pat_ctx_changed()
 
 // Forward declarations.
 template <class T>
-static T read_unaligned(uint32_t guest_va, uint32_t instr, uint8_t* host_va);
+static T read_unaligned(uint32_t guest_va, uint8_t* host_va, uint32_t instr);
 template <class T>
 static void write_unaligned(uint32_t guest_va, uint8_t* host_va, uint32_t instr, T value);
 
@@ -1059,7 +1059,7 @@ inline T mmu_read_vmem(uint32_t guest_va, uint32_t instr) {
 
     // handle unaligned memory accesses
     if (sizeof(T) > 1 && (guest_va & (sizeof(T) - 1))) {
-        return read_unaligned<T>(guest_va, host_va);
+        return read_unaligned<T>(guest_va, host_va, instr);
     }
 
     // handle aligned memory accesses
@@ -1153,7 +1153,7 @@ inline void mmu_write_vmem(uint32_t guest_va, uint32_t instr, T value) {
 #endif
             if (sizeof(T) == 8) {
                 if (guest_va & 3)
-                    ppc_alignment_exception(guest_va);
+                    ppc_alignment_exception(guest_va, instr);
 
                 tlb2_entry->rgn_desc->devobj->write(tlb2_entry->rgn_desc->start,
                                                     static_cast<uint32_t>(guest_va - tlb2_entry->dev_base_va),
@@ -1176,7 +1176,7 @@ inline void mmu_write_vmem(uint32_t guest_va, uint32_t instr, T value) {
 
     // handle unaligned memory accesses
     if (sizeof(T) > 1 && (guest_va & (sizeof(T) - 1))) {
-        write_unaligned<T>(guest_va, host_va, value);
+        write_unaligned<T>(guest_va, host_va, instr, value);
         return;
     }
 
@@ -1252,7 +1252,7 @@ static void write_unaligned(uint32_t guest_va, uint8_t *host_va, uint32_t instr,
 {
     if ((sizeof(T) == 8) && (guest_va & 3)) {
 #ifndef PPC_TESTS
-        ppc_alignment_exception(guest_va);
+        ppc_alignment_exception(guest_va, instr);
 #endif
     }
 
@@ -1268,7 +1268,7 @@ static void write_unaligned(uint32_t guest_va, uint8_t *host_va, uint32_t instr,
         uint32_t shift = (sizeof(T) - 1) * 8;
 
         for (int i = 0; i < sizeof(T); shift -= 8, guest_va++, i++) {
-            mmu_write_vmem<uint8_t>(guest_va, uint32_t instr, (value >> shift) & 0xFF);
+            mmu_write_vmem<uint8_t>(guest_va, instr, ((value >> shift) & 0xFF));
         }
     } else {
 #ifdef MMU_PROFILING
diff --git a/cpu/ppc/ppcmmu.h b/cpu/ppc/ppcmmu.h
index 0035e1c..7dfaaf7 100644
--- a/cpu/ppc/ppcmmu.h
+++ b/cpu/ppc/ppcmmu.h
@@ -125,7 +125,7 @@ extern void mmu_change_mode(void);
 extern void mmu_pat_ctx_changed();
 extern void tlb_flush_entry(uint32_t ea);
 
-extern uint64_t mem_read_dbg(uint32_t virt_addr, uint32_t size);
+extern uint64_t mem_read_dbg(uint32_t virt_addr, uint32_t instr, uint32_t size);
 uint8_t *mmu_translate_imem(uint32_t vaddr, uint32_t *paddr = nullptr);
 bool mmu_translate_dbg(uint32_t guest_va, uint32_t &guest_pa);
 
diff --git a/cpu/ppc/ppcopcodes.cpp b/cpu/ppc/ppcopcodes.cpp
index 3e33b60..420a943 100644
--- a/cpu/ppc/ppcopcodes.cpp
+++ b/cpu/ppc/ppcopcodes.cpp
@@ -104,8 +104,8 @@ void dppc_interpreter::ppc_addi(uint32_t instr) {
         ppc_state.gpr[reg_d] = (reg_a == 0) ? simm : (ppc_result_a + simm);
 }
 
-template void dppc_interpreter::ppc_addi<SHFT0>(uint32_t);
-template void dppc_interpreter::ppc_addi<SHFT1>(uint32_t);
+template void dppc_interpreter::ppc_addi<SHFT0>(uint32_t instr);
+template void dppc_interpreter::ppc_addi<SHFT1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_addic(uint32_t instr) {
@@ -117,8 +117,8 @@ void dppc_interpreter::ppc_addic(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_addic<RC0>(uint32_t);
-template void dppc_interpreter::ppc_addic<RC1>(uint32_t);
+template void dppc_interpreter::ppc_addic<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_addic<RC1>(uint32_t instr);
 
 template <field_carry carry, field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_add(uint32_t instr) {
@@ -134,14 +134,14 @@ void dppc_interpreter::ppc_add(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_add<CARRY0, RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY0, RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY0, RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY0, RC1, OV1>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY1, RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY1, RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY1, RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_add<CARRY1, RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_add<CARRY0, RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY0, RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY0, RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY0, RC1, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY1, RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY1, RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY1, RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_add<CARRY1, RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_adde(uint32_t instr) {
@@ -163,10 +163,10 @@ void dppc_interpreter::ppc_adde(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_adde<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_adde<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_adde<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_adde<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_adde<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_adde<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_adde<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_adde<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_addme(uint32_t instr) {
@@ -188,10 +188,10 @@ void dppc_interpreter::ppc_addme(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_addme<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_addme<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_addme<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_addme<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_addme<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_addme<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_addme<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_addme<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_addze(uint32_t instr) {
@@ -213,10 +213,10 @@ void dppc_interpreter::ppc_addze(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_addze<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_addze<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_addze<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_addze<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_addze<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_addze<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_addze<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_addze<RC1, OV1>(uint32_t instr);
 
 void dppc_interpreter::ppc_subfic(uint32_t instr) {
     ppc_grab_regsdasimm(instr);
@@ -243,14 +243,14 @@ void dppc_interpreter::ppc_subf(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_subf<CARRY0, RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY0, RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY0, RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY0, RC1, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY1, RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY1, RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY1, RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subf<CARRY1, RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_subf<CARRY0, RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY0, RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY0, RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY0, RC1, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY1, RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY1, RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY1, RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subf<CARRY1, RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_subfe(uint32_t instr) {
@@ -270,10 +270,10 @@ void dppc_interpreter::ppc_subfe(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_subfe<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfe<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subfe<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfe<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_subfe<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfe<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subfe<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfe<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_subfme(uint32_t instr) {
@@ -299,10 +299,10 @@ void dppc_interpreter::ppc_subfme(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_subfme<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfme<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subfme<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfme<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_subfme<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfme<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subfme<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfme<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_subfze(uint32_t instr) {
@@ -328,10 +328,10 @@ void dppc_interpreter::ppc_subfze(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_subfze<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfze<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_subfze<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_subfze<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_subfze<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfze<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_subfze<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_subfze<RC1, OV1>(uint32_t instr);
 
 template <field_shift shift>
 void dppc_interpreter::ppc_andirc(uint32_t instr) {
@@ -341,8 +341,8 @@ void dppc_interpreter::ppc_andirc(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_andirc<SHFT0>(uint32_t);
-template void dppc_interpreter::ppc_andirc<SHFT1>(uint32_t);
+template void dppc_interpreter::ppc_andirc<SHFT0>(uint32_t instr);
+template void dppc_interpreter::ppc_andirc<SHFT1>(uint32_t instr);
 
 template <field_shift shift>
 void dppc_interpreter::ppc_ori(uint32_t instr) {
@@ -351,8 +351,8 @@ void dppc_interpreter::ppc_ori(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_ori<SHFT0>(uint32_t);
-template void dppc_interpreter::ppc_ori<SHFT1>(uint32_t);
+template void dppc_interpreter::ppc_ori<SHFT0>(uint32_t instr);
+template void dppc_interpreter::ppc_ori<SHFT1>(uint32_t instr);
 
 template <field_shift shift>
 void dppc_interpreter::ppc_xori(uint32_t instr) {
@@ -361,8 +361,8 @@ void dppc_interpreter::ppc_xori(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_xori<SHFT0>(uint32_t);
-template void dppc_interpreter::ppc_xori<SHFT1>(uint32_t);
+template void dppc_interpreter::ppc_xori<SHFT0>(uint32_t instr);
+template void dppc_interpreter::ppc_xori<SHFT1>(uint32_t instr);
 
 template <logical_fun logical_op, field_rc rec>
 void dppc_interpreter::ppc_logical(uint32_t instr) {
@@ -390,22 +390,22 @@ void dppc_interpreter::ppc_logical(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_logical<ppc_and, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_andc, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_eqv, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_nand, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_nor, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_or, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_orc, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_xor, RC0>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_and, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_andc, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_eqv, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_nand, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_nor, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_or, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_orc, RC1>(uint32_t);
-template void dppc_interpreter::ppc_logical<ppc_xor, RC1>(uint32_t);
+template void dppc_interpreter::ppc_logical<ppc_and, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_andc, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_eqv, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_nand, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_nor, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_or, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_orc, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_xor, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_and, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_andc, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_eqv, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_nand, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_nor, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_or, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_orc, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_logical<ppc_xor, RC1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_neg(uint32_t instr) {
@@ -425,10 +425,10 @@ void dppc_interpreter::ppc_neg(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_neg<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_neg<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_neg<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_neg<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_neg<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_neg<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_neg<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_neg<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_cntlzw(uint32_t instr) {
@@ -457,8 +457,8 @@ void dppc_interpreter::ppc_cntlzw(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_cntlzw<RC0>(uint32_t);
-template void dppc_interpreter::ppc_cntlzw<RC1>(uint32_t);
+template void dppc_interpreter::ppc_cntlzw<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_cntlzw<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mulhwu(uint32_t instr) {
@@ -472,8 +472,8 @@ void dppc_interpreter::ppc_mulhwu(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_mulhwu<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mulhwu<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mulhwu<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mulhwu<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_mulhw(uint32_t instr) {
@@ -487,8 +487,8 @@ void dppc_interpreter::ppc_mulhw(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_mulhw<RC0>(uint32_t);
-template void dppc_interpreter::ppc_mulhw<RC1>(uint32_t);
+template void dppc_interpreter::ppc_mulhw<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_mulhw<RC1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_mullw(uint32_t instr) {
@@ -511,10 +511,10 @@ void dppc_interpreter::ppc_mullw(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_mullw<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_mullw<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_mullw<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_mullw<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_mullw<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_mullw<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_mullw<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_mullw<RC1, OV1>(uint32_t instr);
 
 void dppc_interpreter::ppc_mulli(uint32_t instr) {
     ppc_grab_regsdasimm(instr);
@@ -554,10 +554,10 @@ void dppc_interpreter::ppc_divw(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_divw<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_divw<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_divw<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_divw<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_divw<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_divw<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_divw<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_divw<RC1, OV1>(uint32_t instr);
 
 template <field_rc rec, field_ov ov>
 void dppc_interpreter::ppc_divwu(uint32_t instr) {
@@ -585,10 +585,10 @@ void dppc_interpreter::ppc_divwu(uint32_t instr) {
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_divwu<RC0, OV0>(uint32_t);
-template void dppc_interpreter::ppc_divwu<RC0, OV1>(uint32_t);
-template void dppc_interpreter::ppc_divwu<RC1, OV0>(uint32_t);
-template void dppc_interpreter::ppc_divwu<RC1, OV1>(uint32_t);
+template void dppc_interpreter::ppc_divwu<RC0, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_divwu<RC0, OV1>(uint32_t instr);
+template void dppc_interpreter::ppc_divwu<RC1, OV0>(uint32_t instr);
+template void dppc_interpreter::ppc_divwu<RC1, OV1>(uint32_t instr);
 
 // Value shifting
 
@@ -609,10 +609,10 @@ void dppc_interpreter::ppc_shift(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_shift<RIGHT0, RC0>(uint32_t);
-template void dppc_interpreter::ppc_shift<RIGHT0, RC1>(uint32_t);
-template void dppc_interpreter::ppc_shift<LEFT1, RC0>(uint32_t);
-template void dppc_interpreter::ppc_shift<LEFT1, RC1>(uint32_t);
+template void dppc_interpreter::ppc_shift<RIGHT0, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_shift<RIGHT0, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_shift<LEFT1, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_shift<LEFT1, RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_sraw(uint32_t instr) {
@@ -639,8 +639,8 @@ void dppc_interpreter::ppc_sraw(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_sraw<RC0>(uint32_t);
-template void dppc_interpreter::ppc_sraw<RC1>(uint32_t);
+template void dppc_interpreter::ppc_sraw<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_sraw<RC1>(uint32_t instr);
 
 template <field_rc rec>
 void dppc_interpreter::ppc_srawi(uint32_t instr) {
@@ -660,8 +660,8 @@ void dppc_interpreter::ppc_srawi(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_srawi<RC0>(uint32_t);
-template void dppc_interpreter::ppc_srawi<RC1>(uint32_t);
+template void dppc_interpreter::ppc_srawi<RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_srawi<RC1>(uint32_t instr);
 
 /** mask generator for rotate and shift instructions (§ 4.2.1.4 PowerpC PEM) */
 static inline uint32_t rot_mask(unsigned rot_mb, unsigned rot_me) {
@@ -1092,10 +1092,10 @@ void dppc_interpreter::ppc_exts(uint32_t instr) {
     ppc_store_iresult_reg(reg_a, ppc_result_a);
 }
 
-template void dppc_interpreter::ppc_exts<int8_t, RC0>(uint32_t);
-template void dppc_interpreter::ppc_exts<int16_t, RC0>(uint32_t);
-template void dppc_interpreter::ppc_exts<int8_t, RC1>(uint32_t);
-template void dppc_interpreter::ppc_exts<int16_t, RC1>(uint32_t);
+template void dppc_interpreter::ppc_exts<int8_t, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_exts<int16_t, RC0>(uint32_t instr);
+template void dppc_interpreter::ppc_exts<int8_t, RC1>(uint32_t instr);
+template void dppc_interpreter::ppc_exts<int16_t, RC1>(uint32_t instr);
 
 // Branching Instructions
 
@@ -1114,10 +1114,10 @@ void dppc_interpreter::ppc_b(uint32_t instr) {
     exec_flags = EXEF_BRANCH;
 }
 
-template void dppc_interpreter::ppc_b<LK0, AA0>(uint32_t);
-template void dppc_interpreter::ppc_b<LK0, AA1>(uint32_t);
-template void dppc_interpreter::ppc_b<LK1, AA0>(uint32_t);
-template void dppc_interpreter::ppc_b<LK1, AA1>(uint32_t);
+template void dppc_interpreter::ppc_b<LK0, AA0>(uint32_t instr);
+template void dppc_interpreter::ppc_b<LK0, AA1>(uint32_t instr);
+template void dppc_interpreter::ppc_b<LK1, AA0>(uint32_t instr);
+template void dppc_interpreter::ppc_b<LK1, AA1>(uint32_t instr);
 
 template <field_lk l, field_aa a>
 void dppc_interpreter::ppc_bc(uint32_t instr) {
@@ -1145,10 +1145,10 @@ void dppc_interpreter::ppc_bc(uint32_t instr) {
         ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-template void dppc_interpreter::ppc_bc<LK0, AA0>(uint32_t);
-template void dppc_interpreter::ppc_bc<LK0, AA1>(uint32_t);
-template void dppc_interpreter::ppc_bc<LK1, AA0>(uint32_t);
-template void dppc_interpreter::ppc_bc<LK1, AA1>(uint32_t);
+template void dppc_interpreter::ppc_bc<LK0, AA0>(uint32_t instr);
+template void dppc_interpreter::ppc_bc<LK0, AA1>(uint32_t instr);
+template void dppc_interpreter::ppc_bc<LK1, AA0>(uint32_t instr);
+template void dppc_interpreter::ppc_bc<LK1, AA1>(uint32_t instr);
 
 template<field_lk l, field_601 for601>
 void dppc_interpreter::ppc_bcctr(uint32_t instr) {
@@ -1180,10 +1180,10 @@ void dppc_interpreter::ppc_bcctr(uint32_t instr) {
         ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-template void dppc_interpreter::ppc_bcctr<LK0, NOT601>(uint32_t);
-template void dppc_interpreter::ppc_bcctr<LK0, IS601>(uint32_t);
-template void dppc_interpreter::ppc_bcctr<LK1, NOT601>(uint32_t);
-template void dppc_interpreter::ppc_bcctr<LK1, IS601>(uint32_t);
+template void dppc_interpreter::ppc_bcctr<LK0, NOT601>(uint32_t instr);
+template void dppc_interpreter::ppc_bcctr<LK0, IS601>(uint32_t instr);
+template void dppc_interpreter::ppc_bcctr<LK1, NOT601>(uint32_t instr);
+template void dppc_interpreter::ppc_bcctr<LK1, IS601>(uint32_t instr);
 
 template <field_lk l>
 void dppc_interpreter::ppc_bclr(uint32_t instr) {
@@ -1207,8 +1207,8 @@ void dppc_interpreter::ppc_bclr(uint32_t instr) {
         ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-template void dppc_interpreter::ppc_bclr<LK0>(uint32_t);
-template void dppc_interpreter::ppc_bclr<LK1>(uint32_t);
+template void dppc_interpreter::ppc_bclr<LK0>(uint32_t instr);
+template void dppc_interpreter::ppc_bclr<LK1>(uint32_t instr);
 
 // Compare Instructions
 
@@ -1495,12 +1495,12 @@ void dppc_interpreter::ppc_st(uint32_t instr) {
     ppc_grab_regssa(instr);
     uint32_t ea = int32_t(int16_t(instr));
     ea += reg_a ? ppc_result_a : 0;
-    mmu_write_vmem<T>(ea, ppc_result_d);
+    mmu_write_vmem<T>(ea, instr, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_st<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_st<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_st<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_st<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_st<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_st<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_stx(uint32_t instr) {
@@ -1509,12 +1509,12 @@ void dppc_interpreter::ppc_stx(uint32_t instr) {
 #endif
     ppc_grab_regssab(instr);
     uint32_t ea = ppc_result_b + (reg_a ? ppc_result_a : 0);
-    mmu_write_vmem<T>(ea, ppc_result_d);
+    mmu_write_vmem<T>(ea, instr, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_stx<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_stx<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_stx<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_stx<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stx<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stx<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_stu(uint32_t instr) {
@@ -1525,16 +1525,16 @@ void dppc_interpreter::ppc_stu(uint32_t instr) {
     if (reg_a != 0) {
         uint32_t ea = int32_t(int16_t(instr));
         ea += ppc_result_a;
-        mmu_write_vmem<T>(ea, ppc_result_d);
+        mmu_write_vmem<T>(ea, instr, ppc_result_d);
         ppc_state.gpr[reg_a] = ea;
     } else {
         ppc_exception_handler(Except_Type::EXC_PROGRAM, Exc_Cause::ILLEGAL_OP);
     }
 }
 
-template void dppc_interpreter::ppc_stu<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_stu<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_stu<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_stu<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stu<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stu<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_stux(uint32_t instr) {
@@ -1544,16 +1544,16 @@ void dppc_interpreter::ppc_stux(uint32_t instr) {
     ppc_grab_regssab(instr);
     if (reg_a != 0) {
         uint32_t ea = ppc_result_a + ppc_result_b;
-        mmu_write_vmem<T>(ea, ppc_result_d);
+        mmu_write_vmem<T>(ea, instr, ppc_result_d);
         ppc_state.gpr[reg_a] = ea;
     } else {
         ppc_exception_handler(Except_Type::EXC_PROGRAM, Exc_Cause::ILLEGAL_OP);
     }
 }
 
-template void dppc_interpreter::ppc_stux<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_stux<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_stux<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_stux<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stux<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_stux<uint32_t>(uint32_t instr);
 
 void dppc_interpreter::ppc_sthbrx(uint32_t instr) {
 #ifdef CPU_PROFILING
@@ -1617,13 +1617,13 @@ void dppc_interpreter::ppc_lz(uint32_t instr) {
     ppc_grab_regsda(instr);
     uint32_t ea = int32_t(int16_t(instr));
     ea += reg_a ? ppc_result_a : 0;
-    uint32_t ppc_result_d = mmu_read_vmem<T>(ea);
+    uint32_t ppc_result_d = mmu_read_vmem<T>(ea, instr);
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_lz<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_lz<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_lz<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_lz<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lz<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lz<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_lzu(uint32_t instr) {
@@ -1634,7 +1634,7 @@ void dppc_interpreter::ppc_lzu(uint32_t instr) {
     uint32_t ea = int32_t(int16_t(instr));
     if ((reg_a != reg_d) && reg_a != 0) {
         ea += ppc_result_a;
-        uint32_t ppc_result_d = mmu_read_vmem<T>(ea);
+        uint32_t ppc_result_d = mmu_read_vmem<T>(ea, instr);
         uint32_t ppc_result_a = ea;
         ppc_store_iresult_reg(reg_d, ppc_result_d);
         ppc_store_iresult_reg(reg_a, ppc_result_a);
@@ -1643,9 +1643,9 @@ void dppc_interpreter::ppc_lzu(uint32_t instr) {
     }
 }
 
-template void dppc_interpreter::ppc_lzu<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_lzu<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_lzu<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_lzu<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzu<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzu<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_lzx(uint32_t instr) {
@@ -1654,13 +1654,13 @@ void dppc_interpreter::ppc_lzx(uint32_t instr) {
 #endif
     ppc_grab_regsdab(instr);
     uint32_t ea = ppc_result_b + (reg_a ? ppc_result_a : 0);
-    uint32_t ppc_result_d = mmu_read_vmem<T>(ea);
+    uint32_t ppc_result_d = mmu_read_vmem<T>(ea, instr);
     ppc_store_iresult_reg(reg_d, ppc_result_d);
 }
 
-template void dppc_interpreter::ppc_lzx<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_lzx<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_lzx<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_lzx<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzx<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzx<uint32_t>(uint32_t instr);
 
 template <class T>
 void dppc_interpreter::ppc_lzux(uint32_t instr) {
@@ -1670,7 +1670,7 @@ void dppc_interpreter::ppc_lzux(uint32_t instr) {
     ppc_grab_regsdab(instr);
     if ((reg_a != reg_d) && reg_a != 0) {
         uint32_t ea = ppc_result_a + ppc_result_b;
-        uint32_t ppc_result_d = mmu_read_vmem<T>(ea);
+        uint32_t ppc_result_d = mmu_read_vmem<T>(ea, instr);
         ppc_result_a          = ea;
         ppc_store_iresult_reg(reg_d, ppc_result_d);
         ppc_store_iresult_reg(reg_a, ppc_result_a);
@@ -1679,9 +1679,9 @@ void dppc_interpreter::ppc_lzux(uint32_t instr) {
     }
 }
 
-template void dppc_interpreter::ppc_lzux<uint8_t>(uint32_t);
-template void dppc_interpreter::ppc_lzux<uint16_t>(uint32_t);
-template void dppc_interpreter::ppc_lzux<uint32_t>(uint32_t);
+template void dppc_interpreter::ppc_lzux<uint8_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzux<uint16_t>(uint32_t instr);
+template void dppc_interpreter::ppc_lzux<uint32_t>(uint32_t instr);
 
 void dppc_interpreter::ppc_lha(uint32_t instr) {
 #ifdef CPU_PROFILING
diff --git a/debugger/debugger.cpp b/debugger/debugger.cpp
index 456e28c..3a4b165 100644
--- a/debugger/debugger.cpp
+++ b/debugger/debugger.cpp
@@ -124,7 +124,7 @@ static uint32_t disasm_68k(uint32_t count, uint32_t address) {
     for (; power_on && count > 0; count--) {
         /* prefetch opcode bytes (a 68k instruction can occupy 2...10 bytes) */
         for (int i = 0; i < sizeof(code); i++) {
-            code[i] = mem_read_dbg(address + i, 1);
+            code[i] = mem_read_dbg(address + i, 0, 1);
         }
 
         const uint8_t *code_ptr  = code;
@@ -161,7 +161,7 @@ print_bin:
 #define EMU_68K_TABLE_SIZE 0x80000
 
 /** Execute one emulated 68k instruction. */
-void exec_single_68k()
+void exec_single_68k(uint32_t instr)
 {
     uint32_t emu_table_virt, cur_68k_pc, cur_instr_tab_entry, ppc_pc;
 
@@ -174,7 +174,7 @@ void exec_single_68k()
 
     /* calculate address of the current opcode table entry as follows:
        get_word(68k_PC) * entry_size + table_base */
-    cur_instr_tab_entry = mmu_read_vmem<uint16_t>(cur_68k_pc) * 8 + emu_table_virt;
+    cur_instr_tab_entry = mmu_read_vmem<uint16_t>(((cur_68k_pc) * 8 + emu_table_virt), instr);
 
     /* grab the PPC PC too */
     ppc_pc = get_reg(string("PC"));
@@ -314,7 +314,7 @@ static void dump_mem(string& params) {
                 cout << endl;
                 chars_per_line = 0;
             }
-            val = mem_read_dbg(addr, cell_size);
+            val = mem_read_dbg(addr, 0, cell_size);
             if (is_char) {
                 cout << (char)val;
                 chars_per_line += cell_size;
@@ -621,7 +621,7 @@ void enter_debugger() {
             if (context == 2) {
 #ifdef ENABLE_68K_DEBUGGER
                 for (; --count >= 0;) {
-                    exec_single_68k();
+                    exec_single_68k(0);
                 }
 #endif
             } else {