diff --git a/src/xenia/cpu/ppc/instr.cc b/src/xenia/cpu/ppc/instr.cc
index fb9aa53bd..815fa19b3 100644
--- a/src/xenia/cpu/ppc/instr.cc
+++ b/src/xenia/cpu/ppc/instr.cc
@@ -354,40 +354,40 @@ InstrType* xe::cpu::ppc::GetInstrType(uint32_t code) {
   switch (code >> 26) {
   case 4:
     // Opcode = 4, index = bits 5-0 (6)
-    slot = &xe::cpu::ppc::tables::instr_table_4[XESELECTBITS(code, 0, 5)];
+    slot = xe::cpu::ppc::tables::instr_table_4[XESELECTBITS(code, 0, 5)];
     break;
   case 19:
     // Opcode = 19, index = bits 10-1 (10)
-    slot = &xe::cpu::ppc::tables::instr_table_19[XESELECTBITS(code, 1, 10)];
+    slot = xe::cpu::ppc::tables::instr_table_19[XESELECTBITS(code, 1, 10)];
     break;
   case 30:
     // Opcode = 30, index = bits 4-1 (4)
     // Special cased to an uber instruction.
-    slot = &xe::cpu::ppc::tables::instr_table_30[XESELECTBITS(code, 0, 0)];
+    slot = xe::cpu::ppc::tables::instr_table_30[XESELECTBITS(code, 0, 0)];
     // slot = &xe::cpu::ppc::tables::instr_table_30[XESELECTBITS(code, 1, 4)];
     break;
   case 31:
     // Opcode = 31, index = bits 10-1 (10)
-    slot = &xe::cpu::ppc::tables::instr_table_31[XESELECTBITS(code, 1, 10)];
+    slot = xe::cpu::ppc::tables::instr_table_31[XESELECTBITS(code, 1, 10)];
     break;
   case 58:
     // Opcode = 58, index = bits 1-0 (2)
-    slot = &xe::cpu::ppc::tables::instr_table_58[XESELECTBITS(code, 0, 1)];
+    slot = xe::cpu::ppc::tables::instr_table_58[XESELECTBITS(code, 0, 1)];
     break;
   case 59:
     // Opcode = 59, index = bits 5-1 (5)
-    slot = &xe::cpu::ppc::tables::instr_table_59[XESELECTBITS(code, 1, 5)];
+    slot = xe::cpu::ppc::tables::instr_table_59[XESELECTBITS(code, 1, 5)];
     break;
   case 62:
     // Opcode = 62, index = bits 1-0 (2)
-    slot = &xe::cpu::ppc::tables::instr_table_62[XESELECTBITS(code, 0, 1)];
+    slot = xe::cpu::ppc::tables::instr_table_62[XESELECTBITS(code, 0, 1)];
     break;
   case 63:
     // Opcode = 63, index = bits 10-1 (10)
-    slot = &xe::cpu::ppc::tables::instr_table_63[XESELECTBITS(code, 1, 10)];
+    slot = xe::cpu::ppc::tables::instr_table_63[XESELECTBITS(code, 1, 10)];
     break;
   default:
-    slot = &xe::cpu::ppc::tables::instr_table[XESELECTBITS(code, 26, 31)];
+    slot = xe::cpu::ppc::tables::instr_table[XESELECTBITS(code, 26, 31)];
     break;
   }
   if (!slot || !slot->opcode) {
diff --git a/src/xenia/cpu/ppc/instr_tables.h b/src/xenia/cpu/ppc/instr_tables.h
index 20199cec4..1f693c719 100644
--- a/src/xenia/cpu/ppc/instr_tables.h
+++ b/src/xenia/cpu/ppc/instr_tables.h
@@ -19,31 +19,31 @@ namespace ppc {
 namespace tables {
 
 
-static InstrType* instr_table_prep(
+static InstrType** instr_table_prep(
     InstrType* unprep, int unprep_count, int a, int b) {
   int prep_count = (int)pow(2.0, b - a + 1);
-  InstrType* prep = (InstrType*)xe_calloc(prep_count * sizeof(InstrType));
+  InstrType** prep = (InstrType**)xe_calloc(prep_count * sizeof(void*));
   for (int n = 0; n < unprep_count; n++) {
     int ordinal = XESELECTBITS(unprep[n].opcode, a, b);
-    prep[ordinal] = unprep[n];
+    prep[ordinal] = &unprep[n];
   }
   return prep;
 }
 
-static InstrType* instr_table_prep_63(
+static InstrType** instr_table_prep_63(
     InstrType* unprep, int unprep_count, int a, int b) {
   // Special handling for A format instructions.
   int prep_count = (int)pow(2.0, b - a + 1);
-  InstrType* prep = (InstrType*)xe_calloc(prep_count * sizeof(InstrType));
+  InstrType** prep = (InstrType**)xe_calloc(prep_count * sizeof(void*));
   for (int n = 0; n < unprep_count; n++) {
     int ordinal = XESELECTBITS(unprep[n].opcode, a, b);
     if (unprep[n].format == kXEPPCInstrFormatA) {
       // Must splat this into all of the slots that it could be in.
       for (int m = 0; m < 32; m++) {
-        prep[ordinal + (m << 5)] = unprep[n];
+        prep[ordinal + (m << 5)] = &unprep[n];
       }
     } else {
-      prep[ordinal] = unprep[n];
+      prep[ordinal] = &unprep[n];
     }
   }
   return prep;
@@ -70,7 +70,7 @@ static InstrType instr_table_4_unprep[] = {
   // TODO: all of the vector ops
   INSTRUCTION(vperm,          0x1000002B, VA , General        , 0),
 };
-static InstrType* instr_table_4 = instr_table_prep(
+static InstrType** instr_table_4 = instr_table_prep(
     instr_table_4_unprep, XECOUNT(instr_table_4_unprep), 0, 5);
 
 // Opcode = 19, index = bits 10-1 (10)
@@ -88,7 +88,7 @@ static InstrType instr_table_19_unprep[] = {
   INSTRUCTION(cror,           0x4C000382, XL , General        , 0),
   INSTRUCTION(bcctrx,         0x4C000420, XL , BranchCond     , 0),
 };
-static InstrType* instr_table_19 = instr_table_prep(
+static InstrType** instr_table_19 = instr_table_prep(
     instr_table_19_unprep, XECOUNT(instr_table_19_unprep), 1, 10);
 
 // Opcode = 30, index = bits 4-1 (4)
@@ -104,7 +104,7 @@ static InstrType instr_table_30_unprep[] = {
   // INSTRUCTION(rldclx,         0x78000010, MDS, General        , 0),
   // INSTRUCTION(rldcrx,         0x78000012, MDS, General        , 0),
 };
-static InstrType* instr_table_30 = instr_table_prep(
+static InstrType** instr_table_30 = instr_table_prep(
     instr_table_30_unprep, XECOUNT(instr_table_30_unprep), 0, 0);
 
 // Opcode = 31, index = bits 10-1 (10)
@@ -230,7 +230,7 @@ static InstrType instr_table_31_unprep[] = {
   INSTRUCTION(extswx,         0x7C0007B4, X  , General        , 0),
   INSTRUCTION(dcbz,           0x7C0007EC, X  , General        , 0), // 0x7C2007EC = DCBZ128
 };
-static InstrType* instr_table_31 = instr_table_prep(
+static InstrType** instr_table_31 = instr_table_prep(
     instr_table_31_unprep, XECOUNT(instr_table_31_unprep), 1, 10);
 
 // Opcode = 58, index = bits 1-0 (2)
@@ -239,7 +239,7 @@ static InstrType instr_table_58_unprep[] = {
   INSTRUCTION(ldu,            0xE8000001, DS , General        , 0),
   INSTRUCTION(lwa,            0xE8000002, DS , General        , 0),
 };
-static InstrType* instr_table_58 = instr_table_prep(
+static InstrType** instr_table_58 = instr_table_prep(
     instr_table_58_unprep, XECOUNT(instr_table_58_unprep), 0, 1);
 
 // Opcode = 59, index = bits 5-1 (5)
@@ -255,7 +255,7 @@ static InstrType instr_table_59_unprep[] = {
   INSTRUCTION(fnmsubsx,       0xEC00003C, A  , General        , 0),
   INSTRUCTION(fnmaddsx,       0xEC00003E, A  , General        , 0),
 };
-static InstrType* instr_table_59 = instr_table_prep(
+static InstrType** instr_table_59 = instr_table_prep(
     instr_table_59_unprep, XECOUNT(instr_table_59_unprep), 1, 5);
 
 // Opcode = 62, index = bits 1-0 (2)
@@ -263,7 +263,7 @@ static InstrType instr_table_62_unprep[] = {
   INSTRUCTION(std,            0xF8000000, DS , General        , 0),
   INSTRUCTION(stdu,           0xF8000001, DS , General        , 0),
 };
-static InstrType* instr_table_62 = instr_table_prep(
+static InstrType** instr_table_62 = instr_table_prep(
     instr_table_62_unprep, XECOUNT(instr_table_62_unprep), 0, 1);
 
 // Opcode = 63, index = bits 10-1 (10)
@@ -300,7 +300,7 @@ static InstrType instr_table_63_unprep[] = {
   INSTRUCTION(fctidzx,        0xFC00065E, X  , General        , 0),
   INSTRUCTION(fcfidx,         0xFC00069C, X  , General        , 0),
 };
-static InstrType* instr_table_63 = instr_table_prep_63(
+static InstrType** instr_table_63 = instr_table_prep_63(
     instr_table_63_unprep, XECOUNT(instr_table_63_unprep), 1, 10);
 
 // Main table, index = bits 31-26 (6) : (code >> 26)
@@ -352,7 +352,7 @@ static InstrType instr_table_unprep[64] = {
   INSTRUCTION(stfd,           0xD8000000, D  , General        , 0),
   INSTRUCTION(stfdu,          0xDC000000, D  , General        , 0),
 };
-static InstrType* instr_table = instr_table_prep(
+static InstrType** instr_table = instr_table_prep(
     instr_table_unprep, XECOUNT(instr_table_unprep), 26, 31);