diff --git a/src/xenia/core/path_posix.cc b/src/xenia/core/path_posix.cc
index c5a764dd9..b8bedda56 100644
--- a/src/xenia/core/path_posix.cc
+++ b/src/xenia/core/path_posix.cc
@@ -12,4 +12,5 @@
 
 const xechar_t* xe_path_get_tmp(const xechar_t* prefix) {
   //
+  XEASSERTALWAYS();
 }
diff --git a/src/xenia/cpu/codegen/emit.h b/src/xenia/cpu/codegen/emit.h
index 1b9909ad7..6f489dee4 100644
--- a/src/xenia/cpu/codegen/emit.h
+++ b/src/xenia/cpu/codegen/emit.h
@@ -24,14 +24,10 @@ void RegisterEmitCategoryFPU();
 void RegisterEmitCategoryMemory();
 
 
-#define XEDISASMR(name, opcode, format) int InstrDisasm_##name
 #define XEEMITTER(name, opcode, format) int InstrEmit_##name
 
 #define XEREGISTERINSTR(name, opcode) \
-  RegisterInstrDisassemble(opcode, (InstrDisassembleFn)InstrDisasm_##name); \
-  RegisterInstrEmit(opcode, (InstrEmitFn)InstrEmit_##name);
-#define XEREGISTEREMITTER(name, opcode) \
-  RegisterInstrEmit(opcode, (InstrEmitFn)InstrEmit_##name);
+    RegisterInstrEmit(opcode, (InstrEmitFn)InstrEmit_##name);
 
 #define XEINSTRNOTIMPLEMENTED()
 //#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
diff --git a/src/xenia/cpu/codegen/emit_alu.cc b/src/xenia/cpu/codegen/emit_alu.cc
index 1860f506d..74f91cdce 100644
--- a/src/xenia/cpu/codegen/emit_alu.cc
+++ b/src/xenia/cpu/codegen/emit_alu.cc
@@ -26,14 +26,6 @@ namespace codegen {
 
 // Integer arithmetic (A-3)
 
-XEDISASMR(addx,         0x7C000214, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("add", "Add",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(addx,         0x7C000214, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RD <- (RA) + (RB)
 
@@ -69,44 +61,16 @@ XEEMITTER(addx,         0x7C000214, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   }
 }
 
-XEDISASMR(addcx,        0x7C000014, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("addcx", "Add Carrying",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(addcx,        0x7C000014, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(addex,        0x7C000114, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("adde", "Add Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(addex,        0x7C000114, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(addi,         0x38000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("addi", "Add Immediate", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddSImmOperand(0, 4);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(addi,         0x38000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   RT <- EXTS(SI)
@@ -122,13 +86,6 @@ XEEMITTER(addi,         0x38000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(addic,        0x30000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("addic", "Add Immediate Carrying", InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(addic,        0x30000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- (RA) + EXTS(SI)
 
@@ -142,30 +99,11 @@ XEEMITTER(addic,        0x30000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(addicx,       0x34000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("addic", "Add Immediate Carrying and Record",
-         InstrDisasm::kRc | InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(addicx,       0x34000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(addis,        0x3C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("addis", "Add Immediate Shifted", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddSImmOperand(0, 4);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(addis,        0x3C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   RT <- EXTS(SI) || i16.0
@@ -181,27 +119,11 @@ XEEMITTER(addis,        0x3C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(addmex,       0x7C0001D4, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("addme", "Add to Minus One Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(addmex,       0x7C0001D4, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(addzex,       0x7C000194, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("addze", "Add to Zero Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(addzex,       0x7C000194, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- (RA) + CA
 
@@ -228,40 +150,16 @@ XEEMITTER(addzex,       0x7C000194, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(divdx,        0x7C0003D2, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("divd", "Divide Doubleword",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(divdx,        0x7C0003D2, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(divdux,       0x7C000392, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("divdu", "Divide Doubleword Unsigned",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(divdux,       0x7C000392, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(divwx,        0x7C0003D6, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("divw", "Divide Word",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(divwx,        0x7C0003D6, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // dividend[0:31] <- (RA)[32:63]
   // divisor[0:31] <- (RB)[32:63]
@@ -315,14 +213,6 @@ XEEMITTER(divwx,        0x7C0003D6, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(divwux,       0x7C000396, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("divwu", "Divide Word Unsigned",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(divwux,       0x7C000396, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // dividend[0:31] <- (RA)[32:63]
   // divisor[0:31] <- (RB)[32:63]
@@ -376,76 +266,31 @@ XEEMITTER(divwux,       0x7C000396, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(mulhdx,       0x7C000092, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulhd", "Multiply High Doubleword", i.XO.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mulhdx,       0x7C000092, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(mulhdux,      0x7C000012, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulhdu", "Multiply High Doubleword Unsigned",
-         i.XO.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mulhdux,      0x7C000012, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(mulhwx,       0x7C000096, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulhw", "Multiply High Word", i.XO.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mulhwx,       0x7C000096, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(mulhwux,      0x7C000016, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulhwu", "Multiply High Word Unsigned",
-         i.XO.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mulhwux,      0x7C000016, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(mulldx,       0x7C0001D2, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulld", "Multiply Low Doubleword",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mulldx,       0x7C0001D2, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(mulli,        0x1C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("mulli", "Multiply Low Immediate", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(mulli,        0x1C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // prod[0:127] <- (RA) × EXTS(SI)
   // RT <- prod[64:127]
@@ -460,14 +305,6 @@ XEEMITTER(mulli,        0x1C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(mullwx,       0x7C0001D6, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("mullw", "Multiply Low Word",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mullwx,       0x7C0001D6, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- (RA)[32:63] × (RB)[32:63]
 
@@ -489,13 +326,6 @@ XEEMITTER(mullwx,       0x7C0001D6, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(negx,         0x7C0000D0, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("neg", "Negate",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(negx,         0x7C0000D0, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- ¬(RA) + 1
 
@@ -534,14 +364,6 @@ XEEMITTER(negx,         0x7C0000D0, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   }
 }
 
-XEDISASMR(subfx,        0x7C000050, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("subf", "Subtract From",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subfx,        0x7C000050, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- ¬(RA) + (RB) + 1
 
@@ -577,27 +399,11 @@ XEEMITTER(subfx,        0x7C000050, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   }
 }
 
-XEDISASMR(subfcx,       0x7C000010, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("subfc", "Subtract From Carrying",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subfcx,       0x7C000010, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(subficx,      0x20000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("subfic", "Subtract From Immediate Carrying", InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subficx,      0x20000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- ¬(RA) + EXTS(SI) + 1
 
@@ -611,15 +417,6 @@ XEEMITTER(subficx,      0x20000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(subfex,       0x7C000110, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("subfe", "Subtract From Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subfex,       0x7C000110, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RT <- ¬(RA) + (RB) + CA
 
@@ -650,27 +447,11 @@ XEEMITTER(subfex,       0x7C000110, XO )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(subfmex,      0x7C0001D0, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("subfme", "Subtract From Minus One Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subfmex,      0x7C0001D0, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(subfzex,      0x7C000190, XO )(InstrData& i, InstrDisasm& d) {
-  d.Init("subfze", "Subtract From Zero Extended",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
-         InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(subfzex,      0x7C000190, XO )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
@@ -679,15 +460,6 @@ XEEMITTER(subfzex,      0x7C000190, XO )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Integer compare (A-4)
 
-XEDISASMR(cmp,          0x7C000000, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cmp", "Compare", 0);
-  d.AddCR(i.X.RT >> 2, InstrRegister::kWrite);
-  d.AddUImmOperand(i.X.RT >> 2, 1);
-  d.AddUImmOperand(i.X.RT & 1, 1);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(cmp,          0x7C000000, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if L = 0 then
   //   a <- EXTS((RA)[32:63])
@@ -721,15 +493,6 @@ XEEMITTER(cmp,          0x7C000000, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(cmpi,         0x2C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cmpi", "Compare Immediate", 0);
-  d.AddCR(i.D.RT >> 2, InstrRegister::kWrite);
-  d.AddUImmOperand(i.D.RT >> 2, 1);
-  d.AddUImmOperand(i.D.RT & 1, 1);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(cmpi,         0x2C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if L = 0 then
   //   a <- EXTS((RA)[32:63])
@@ -759,15 +522,6 @@ XEEMITTER(cmpi,         0x2C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(cmpl,         0x7C000040, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cmpl", "Compare Logical", 0);
-  d.AddCR(i.X.RT >> 2, InstrRegister::kWrite);
-  d.AddUImmOperand(i.X.RT >> 2, 1);
-  d.AddUImmOperand(i.X.RT & 1, 1);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(cmpl,         0x7C000040, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if L = 0 then
   //   a <- i32.0 || (RA)[32:63]
@@ -801,15 +555,6 @@ XEEMITTER(cmpl,         0x7C000040, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(cmpli,        0x28000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cmpli", "Compare Logical Immediate", 0);
-  d.AddCR(i.D.RT >> 2, InstrRegister::kWrite);
-  d.AddUImmOperand(i.D.RT >> 2, 1);
-  d.AddUImmOperand(i.D.RT & 1, 1);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  d.AddSImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(cmpli,        0x28000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if L = 0 then
   //   a <- i32.0 || (RA)[32:63]
@@ -842,13 +587,6 @@ XEEMITTER(cmpli,        0x28000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Integer logical (A-5)
 
-XEDISASMR(andx,         0x7C000038, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("and", "AND", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(andx,         0x7C000038, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) & (RB)
 
@@ -863,13 +601,6 @@ XEEMITTER(andx,         0x7C000038, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(andcx,        0x7C000078, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("andc", "AND with Complement", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(andcx,        0x7C000078, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) & ¬(RB)
 
@@ -885,14 +616,6 @@ XEEMITTER(andcx,        0x7C000078, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(andix,        0x70000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("andi", "AND Immediate", 0);
-  d.AddCR(0, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(andix,        0x70000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) & (i48.0 || UI)
 
@@ -905,14 +628,6 @@ XEEMITTER(andix,        0x70000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(andisx,       0x74000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("andi", "AND Immediate Shifted", 0);
-  d.AddCR(0, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(andisx,       0x74000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) & (i32.0 || UI || i16.0)
 
@@ -925,25 +640,11 @@ XEEMITTER(andisx,       0x74000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(cntlzdx,      0x7C000074, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cntlzd", "Count Leading Zeros Doubleword",
-         i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(cntlzdx,      0x7C000074, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(cntlzwx,      0x7C000034, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("cntlzw", "Count Leading Zeros Word",
-         i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(cntlzwx,      0x7C000034, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- 32
   // do while n < 64
@@ -971,24 +672,11 @@ XEEMITTER(cntlzwx,      0x7C000034, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(eqvx,         0x7C000238, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("eqv", "Equivalent", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(eqvx,         0x7C000238, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(extsbx,       0x7C000774, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("extsb", "Extend Sign Byte", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(extsbx,       0x7C000774, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // s <- (RS)[56]
   // RA[56:63] <- (RS)[56:63]
@@ -1007,47 +695,21 @@ XEEMITTER(extsbx,       0x7C000774, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(extshx,       0x7C000734, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("extsh", "Extend Sign Halfword", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(extshx,       0x7C000734, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(extswx,       0x7C0007B4, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("extsw", "Extend Sign Word", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(extswx,       0x7C0007B4, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(nandx,        0x7C0003B8, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("nand", "NAND", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(nandx,        0x7C0003B8, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(norx,         0x7C0000F8, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("nor", "NOR", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(norx,         0x7C0000F8, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- ¬((RS) | (RB))
 
@@ -1063,13 +725,6 @@ XEEMITTER(norx,         0x7C0000F8, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(orx,          0x7C000378, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("or", "OR", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(orx,          0x7C000378, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) | (RB)
 
@@ -1084,29 +739,11 @@ XEEMITTER(orx,          0x7C000378, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(orcx,         0x7C000338, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("orc", "OR with Complement", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(orcx,         0x7C000338, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(ori,          0x60000000, D  )(InstrData& i, InstrDisasm& d) {
-  if (!i.D.RA && !i.D.RT && !i.D.DS) {
-    d.Init("no-op", "OR Immediate", 0);
-  } else {
-    d.Init("ori", "OR Immediate", 0);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(ori,          0x60000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) | (i48.0 || UI)
 
@@ -1116,13 +753,6 @@ XEEMITTER(ori,          0x60000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(oris,         0x64000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("oris", "OR Immediate Shifted", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(oris,         0x64000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) | (i32.0 || UI || i16.0)
 
@@ -1132,13 +762,6 @@ XEEMITTER(oris,         0x64000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(xorx,         0x7C000278, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("xor", "XOR", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(xorx,         0x7C000278, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) XOR (RB)
 
@@ -1153,17 +776,6 @@ XEEMITTER(xorx,         0x7C000278, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(xori,         0x68000000, D  )(InstrData& i, InstrDisasm& d) {
-  if (!i.D.RA && !i.D.RT && !i.D.DS) {
-    d.Init("xnop", "XOR Immediate", 0);
-  } else {
-    d.Init("xori", "XOR Immediate", 0);
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-    d.AddUImmOperand(i.D.DS, 2);
-  }
-  return d.Finish();
-}
 XEEMITTER(xori,         0x68000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) XOR (i48.0 || UI)
 
@@ -1173,13 +785,6 @@ XEEMITTER(xori,         0x68000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(xoris,        0x6C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("xoris", "XOR Immediate Shifted", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.D.DS, 2);
-  return d.Finish();
-}
 XEEMITTER(xoris,        0x6C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // RA <- (RS) XOR (i32.0 || UI || i16.0)
 
@@ -1192,57 +797,21 @@ XEEMITTER(xoris,        0x6C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Integer rotate (A-6)
 
-XEDISASMR(rldclx,       0x78000010, MDS)(InstrData& i, InstrDisasm& d) {
-  d.Init("rldcl", "Rotate Left Doubleword then Clear Left",
-         i.MDS.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RB, InstrRegister::kRead);
-  d.AddUImmOperand((i.MDS.MB5 << 5) | i.MDS.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldclx,       0x78000010, MDS)(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(rldcrx,       0x78000012, MDS)(InstrData& i, InstrDisasm& d) {
-  d.Init("rldcr", "Rotate Left Doubleword then Clear Right",
-         i.MDS.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RB, InstrRegister::kRead);
-  d.AddUImmOperand((i.MDS.MB5 << 5) | i.MDS.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldcrx,       0x78000012, MDS)(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(rldicx,       0x78000008, MD )(InstrData& i, InstrDisasm& d) {
-  d.Init("rldic", "Rotate Left Doubleword Immediate then Clear",
-         i.MD.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
-  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
-  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldicx,       0x78000008, MD )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(rldiclx,      0x78000000, MD )(InstrData& i, InstrDisasm& d) {
-  d.Init("rldicl", "Rotate Left Doubleword Immediate then Clear Left",
-         i.MD.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
-  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
-  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldiclx,      0x78000000, MD )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- sh[5] || sh[0:4]
   // r <- ROTL64((RS), n)
@@ -1271,44 +840,16 @@ XEEMITTER(rldiclx,      0x78000000, MD )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(rldicrx,      0x78000004, MD )(InstrData& i, InstrDisasm& d) {
-  d.Init("rldicr", "Rotate Left Doubleword Immediate then Clear Right",
-         i.MD.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
-  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
-  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldicrx,      0x78000004, MD )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(rldimix,      0x7800000C, MD )(InstrData& i, InstrDisasm& d) {
-  d.Init("rldimi", "Rotate Left Doubleword Immediate then Mask Insert",
-         i.MD.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
-  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
-  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
-  return d.Finish();
-}
 XEEMITTER(rldimix,      0x7800000C, MD )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(rlwimix,      0x50000000, M  )(InstrData& i, InstrDisasm& d) {
-  d.Init("rlwimi", "Rotate Left Word Immediate then Mask Insert",
-         i.M.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.M.SH, 1);
-  d.AddUImmOperand(i.M.MB, 1);
-  d.AddUImmOperand(i.M.ME, 1);
-  return d.Finish();
-}
 XEEMITTER(rlwimix,      0x50000000, M  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- SH
   // r <- ROTL32((RS)[32:63], n)
@@ -1333,16 +874,6 @@ XEEMITTER(rlwimix,      0x50000000, M  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(rlwinmx,      0x54000000, M  )(InstrData& i, InstrDisasm& d) {
-  d.Init("rlwinm", "Rotate Left Word Immediate then AND with Mask",
-         i.M.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.M.SH, 1);
-  d.AddUImmOperand(i.M.MB, 1);
-  d.AddUImmOperand(i.M.ME, 1);
-  return d.Finish();
-}
 XEEMITTER(rlwinmx,      0x54000000, M  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- SH
   // r <- ROTL32((RS)[32:63], n)
@@ -1381,16 +912,6 @@ XEEMITTER(rlwinmx,      0x54000000, M  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(rlwnmx,       0x5C000000, M  )(InstrData& i, InstrDisasm& d) {
-  d.Init("rlwnm", "Rotate Left Word then AND with Mask",
-         i.M.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.M.SH, InstrRegister::kRead);
-  d.AddUImmOperand(i.M.MB, 1);
-  d.AddUImmOperand(i.M.ME, 1);
-  return d.Finish();
-}
 XEEMITTER(rlwnmx,       0x5C000000, M  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
@@ -1399,25 +920,11 @@ XEEMITTER(rlwnmx,       0x5C000000, M  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Integer shift (A-7)
 
-XEDISASMR(sldx,         0x7C000036, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sld", "Shift Left Doubleword", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(sldx,         0x7C000036, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(slwx,         0x7C000030, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("slw", "Shift Left Word", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(slwx,         0x7C000030, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- (RB)[59:63]
   // r <- ROTL32((RS)[32:63], n)
@@ -1439,53 +946,21 @@ XEEMITTER(slwx,         0x7C000030, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(sradx,        0x7C000634, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("srad", "Shift Right Algebraic Doubleword",
-         i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(sradx,        0x7C000634, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(sradix,       0x7C000674, XS )(InstrData& i, InstrDisasm& d) {
-  d.Init("sradi", "Shift Right Algebraic Doubleword Immediate",
-         (i.XS.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.XS.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XS.RT, InstrRegister::kRead);
-  d.AddUImmOperand((i.XS.SH5 << 5) | i.XS.SH, 1);
-  return d.Finish();
-}
 XEEMITTER(sradix,       0x7C000674, XS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(srawx,        0x7C000630, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sraw", "Shift Right Algebraic Word",
-         (i.X.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(srawx,        0x7C000630, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(srawix,       0x7C000670, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("srawi", "Shift Right Algebraic Word Immediate",
-         (i.X.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddUImmOperand(i.X.RB, 1);
-  return d.Finish();
-}
 XEEMITTER(srawix,       0x7C000670, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- SH
   // r <- ROTL32((RS)[32:63], 64-n)
@@ -1523,25 +998,11 @@ XEEMITTER(srawix,       0x7C000670, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(srdx,         0x7C000436, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("srd", "Shift Right Doubleword", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(srdx,         0x7C000436, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
 }
 
-XEDISASMR(srwx,         0x7C000430, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("srw", "Shift Right Word", i.X.Rc ? InstrDisasm::kRc : 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(srwx,         0x7C000430, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   XEINSTRNOTIMPLEMENTED();
   return 1;
diff --git a/src/xenia/cpu/codegen/emit_control.cc b/src/xenia/cpu/codegen/emit_control.cc
index c3ab7984f..5b62de531 100644
--- a/src/xenia/cpu/codegen/emit_control.cc
+++ b/src/xenia/cpu/codegen/emit_control.cc
@@ -129,17 +129,6 @@ int XeEmitBranchTo(
 }
 
 
-XEDISASMR(bx,           0x48000000, I  )(InstrData& i, InstrDisasm& d) {
-  d.Init("b", "Branch", i.I.LK ? InstrDisasm::kLR : 0);
-  uint32_t nia;
-  if (i.I.AA) {
-    nia = XEEXTS26(i.I.LI << 2);
-  } else {
-    nia = i.address + XEEXTS26(i.I.LI << 2);
-  }
-  d.AddUImmOperand(nia, 4);
-  return d.Finish();
-}
 XEEMITTER(bx,           0x48000000, I  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if AA then
   //   NIA <- EXTS(LI || 0b00)
@@ -161,19 +150,6 @@ XEEMITTER(bx,           0x48000000, I  )(FunctionGenerator& g, IRBuilder<>& b, I
   return XeEmitBranchTo(g, b, "bx", i.address, i.I.LK);
 }
 
-XEDISASMR(bcx,          0x40000000, B  )(InstrData& i, InstrDisasm& d) {
-  // TODO(benvanik): mnemonics
-  d.Init("bc", "Branch Conditional", i.B.LK ? InstrDisasm::kLR : 0);
-  if (!XESELECTBITS(i.B.BO, 2, 2)) {
-    d.AddCTR(InstrRegister::kReadWrite);
-  }
-  if (!XESELECTBITS(i.B.BO, 4, 4)) {
-    d.AddCR(i.B.BI >> 2, InstrRegister::kRead);
-  }
-  d.AddUImmOperand(i.B.BO, 1);
-  d.AddUImmOperand(i.B.BI, 1);
-  return d.Finish();
-}
 XEEMITTER(bcx,          0x40000000, B  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if ¬BO[2] then
   //   CTR <- CTR - 1
@@ -266,19 +242,6 @@ XEEMITTER(bcx,          0x40000000, B  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-
-XEDISASMR(bcctrx,       0x4C000420, XL )(InstrData& i, InstrDisasm& d) {
-  // TODO(benvanik): mnemonics
-  d.Init("bcctr", "Branch Conditional to Count Register",
-      i.XL.LK ? InstrDisasm::kLR : 0);
-  if (!XESELECTBITS(i.XL.BO, 4, 4)) {
-    d.AddCR(i.XL.BI >> 2, InstrRegister::kRead);
-  }
-  d.AddUImmOperand(i.XL.BO, 1);
-  d.AddUImmOperand(i.XL.BI, 1);
-  d.AddCTR(InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(bcctrx,       0x4C000420, XL )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // cond_ok <- BO[0] | (CR[BI+32] ≡ BO[1])
   // if cond_ok then
@@ -339,24 +302,6 @@ XEEMITTER(bcctrx,       0x4C000420, XL )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(bclrx,        0x4C000020, XL )(InstrData& i, InstrDisasm& d) {
-  std::string name = "bclr";
-  if (i.code == 0x4E800020) {
-    name = "blr";
-  }
-  d.Init(name, "Branch Conditional to Link Register",
-      i.XL.LK ? InstrDisasm::kLR : 0);
-  if (!XESELECTBITS(i.B.BO, 2, 2)) {
-    d.AddCTR(InstrRegister::kReadWrite);
-  }
-  if (!XESELECTBITS(i.B.BO, 4, 4)) {
-    d.AddCR(i.B.BI >> 2, InstrRegister::kRead);
-  }
-  d.AddUImmOperand(i.XL.BO, 1);
-  d.AddUImmOperand(i.XL.BI, 1);
-  d.AddLR(InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(bclrx,        0x4C000020, XL )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if ¬BO[2] then
   //   CTR <- CTR - 1
@@ -594,12 +539,6 @@ int XeEmitTrap(FunctionGenerator& g, IRBuilder<>& b, InstrData& i,
   return 0;
 }
 
-XEDISASMR(td,           0x7C000088, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("td", "Trap Doubleword", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(td,           0x7C000088, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // a <- (RA)
   // b <- (RB)
@@ -614,11 +553,6 @@ XEEMITTER(td,           0x7C000088, X  )(FunctionGenerator& g, IRBuilder<>& b, I
                     i.X.RT);
 }
 
-XEDISASMR(tdi,          0x08000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("tdi", "Trap Doubleword Immediate", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(tdi,          0x08000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // a <- (RA)
   // if (a < EXTS(SI)) & TO[0] then TRAP
@@ -632,12 +566,6 @@ XEEMITTER(tdi,          0x08000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
                     i.D.RT);
 }
 
-XEDISASMR(tw,           0x7C000008, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("tw", "Trap Word", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(tw,           0x7C000008, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // a <- EXTS((RA)[32:63])
   // b <- EXTS((RB)[32:63])
@@ -656,11 +584,6 @@ XEEMITTER(tw,           0x7C000008, X  )(FunctionGenerator& g, IRBuilder<>& b, I
                     i.X.RT);
 }
 
-XEDISASMR(twi,          0x0C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("twi", "Trap Word Immediate", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(twi,          0x0C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // a <- EXTS((RA)[32:63])
   // if (a < EXTS(SI)) & TO[0] then TRAP
@@ -684,23 +607,6 @@ XEEMITTER(mfcr,         0x7C000026, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(mfspr,        0x7C0002A6, XFX)(InstrData& i, InstrDisasm& d) {
-  d.Init("mfspr", "Move From Special Purpose Register", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.XFX.RT, InstrRegister::kWrite);
-  const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
-  switch (n) {
-  case 1:
-    d.AddRegOperand(InstrRegister::kXER, 0, InstrRegister::kRead);
-    break;
-  case 8:
-    d.AddRegOperand(InstrRegister::kLR, 0, InstrRegister::kRead);
-    break;
-  case 9:
-    d.AddRegOperand(InstrRegister::kCTR, 0, InstrRegister::kRead);
-    break;
-  }
-  return d.Finish();
-}
 XEEMITTER(mfspr,        0x7C0002A6, XFX)(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- spr[5:9] || spr[0:4]
   // if length(SPR(n)) = 64 then
@@ -743,23 +649,6 @@ XEEMITTER(mtcrf,        0x7C000120, XFX)(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(mtspr,        0x7C0003A6, XFX)(InstrData& i, InstrDisasm& d) {
-  d.Init("mtspr", "Move To Special Purpose Register", 0);
-  const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
-  switch (n) {
-  case 1:
-    d.AddRegOperand(InstrRegister::kXER, 0, InstrRegister::kWrite);
-    break;
-  case 8:
-    d.AddRegOperand(InstrRegister::kLR, 0, InstrRegister::kWrite);
-    break;
-  case 9:
-    d.AddRegOperand(InstrRegister::kCTR, 0, InstrRegister::kWrite);
-    break;
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.XFX.RT, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(mtspr,        0x7C0003A6, XFX)(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // n <- spr[5:9] || spr[0:4]
   // if length(SPR(n)) = 64 then
@@ -797,24 +686,24 @@ void RegisterEmitCategoryControl() {
   XEREGISTERINSTR(bcx,          0x40000000);
   XEREGISTERINSTR(bcctrx,       0x4C000420);
   XEREGISTERINSTR(bclrx,        0x4C000020);
-  XEREGISTEREMITTER(crand,        0x4C000202);
-  XEREGISTEREMITTER(crandc,       0x4C000102);
-  XEREGISTEREMITTER(creqv,        0x4C000242);
-  XEREGISTEREMITTER(crnand,       0x4C0001C2);
-  XEREGISTEREMITTER(crnor,        0x4C000042);
-  XEREGISTEREMITTER(cror,         0x4C000382);
-  XEREGISTEREMITTER(crorc,        0x4C000342);
-  XEREGISTEREMITTER(crxor,        0x4C000182);
-  XEREGISTEREMITTER(mcrf,         0x4C000000);
-  XEREGISTEREMITTER(sc,           0x44000002);
+  XEREGISTERINSTR(crand,        0x4C000202);
+  XEREGISTERINSTR(crandc,       0x4C000102);
+  XEREGISTERINSTR(creqv,        0x4C000242);
+  XEREGISTERINSTR(crnand,       0x4C0001C2);
+  XEREGISTERINSTR(crnor,        0x4C000042);
+  XEREGISTERINSTR(cror,         0x4C000382);
+  XEREGISTERINSTR(crorc,        0x4C000342);
+  XEREGISTERINSTR(crxor,        0x4C000182);
+  XEREGISTERINSTR(mcrf,         0x4C000000);
+  XEREGISTERINSTR(sc,           0x44000002);
   XEREGISTERINSTR(td,           0x7C000088);
   XEREGISTERINSTR(tdi,          0x08000000);
   XEREGISTERINSTR(tw,           0x7C000008);
   XEREGISTERINSTR(twi,          0x0C000000);
-  XEREGISTEREMITTER(mfcr,         0x7C000026);
+  XEREGISTERINSTR(mfcr,         0x7C000026);
   XEREGISTERINSTR(mfspr,        0x7C0002A6);
-  XEREGISTEREMITTER(mftb,         0x7C0002E6);
-  XEREGISTEREMITTER(mtcrf,        0x7C000120);
+  XEREGISTERINSTR(mftb,         0x7C0002E6);
+  XEREGISTERINSTR(mtcrf,        0x7C000120);
   XEREGISTERINSTR(mtspr,        0x7C0003A6);
 }
 
diff --git a/src/xenia/cpu/codegen/emit_fpu.cc b/src/xenia/cpu/codegen/emit_fpu.cc
index cef4e1437..060999eb0 100644
--- a/src/xenia/cpu/codegen/emit_fpu.cc
+++ b/src/xenia/cpu/codegen/emit_fpu.cc
@@ -173,14 +173,6 @@ XEEMITTER(fcmpo,        0xFC000040, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(fcmpu,        0xFC000000, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("fcmpu", "Floating Compare Unordered",
-         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(fcmpu,        0xFC000000, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if (FRA) is a NaN or (FRB) is a NaN then
   //   c <- 0b0001
@@ -257,45 +249,45 @@ XEEMITTER(fnegx,        0xFC000050, X  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 
 void RegisterEmitCategoryFPU() {
-  XEREGISTEREMITTER(faddx,        0xFC00002A);
-  XEREGISTEREMITTER(faddsx,       0xEC00002A);
-  XEREGISTEREMITTER(fdivx,        0xFC000024);
-  XEREGISTEREMITTER(fdivsx,       0xEC000024);
-  XEREGISTEREMITTER(fmulx,        0xFC000032);
-  XEREGISTEREMITTER(fmulsx,       0xEC000032);
-  XEREGISTEREMITTER(fresx,        0xEC000030);
-  XEREGISTEREMITTER(frsqrtex,     0xFC000034);
-  XEREGISTEREMITTER(fsubx,        0xFC000028);
-  XEREGISTEREMITTER(fsubsx,       0xEC000028);
-  XEREGISTEREMITTER(fselx,        0xFC00002E);
-  XEREGISTEREMITTER(fsqrtx,       0xFC00002C);
-  XEREGISTEREMITTER(fsqrtsx,      0xEC00002C);
-  XEREGISTEREMITTER(fmaddx,       0xFC00003A);
-  XEREGISTEREMITTER(fmaddsx,      0xEC00003A);
-  XEREGISTEREMITTER(fmsubx,       0xFC000038);
-  XEREGISTEREMITTER(fmsubsx,      0xEC000038);
-  XEREGISTEREMITTER(fnmaddx,      0xFC00003E);
-  XEREGISTEREMITTER(fnmaddsx,     0xEC00003E);
-  XEREGISTEREMITTER(fnmsubx,      0xFC00003C);
-  XEREGISTEREMITTER(fnmsubsx,     0xEC00003C);
-  XEREGISTEREMITTER(fcfidx,       0xFC00069C);
-  XEREGISTEREMITTER(fctidx,       0xFC00065C);
-  XEREGISTEREMITTER(fctidzx,      0xFC00065E);
-  XEREGISTEREMITTER(fctiwx,       0xFC00001C);
-  XEREGISTEREMITTER(fctiwzx,      0xFC00001E);
-  XEREGISTEREMITTER(frspx,        0xFC000018);
-  XEREGISTEREMITTER(fcmpo,        0xFC000040);
-  XEREGISTEREMITTER(fcmpu,        0xFC000000);
-  XEREGISTEREMITTER(mcrfs,        0xFC000080);
-  XEREGISTEREMITTER(mffsx,        0xFC00048E);
-  XEREGISTEREMITTER(mtfsb0x,      0xFC00008C);
-  XEREGISTEREMITTER(mtfsb1x,      0xFC00004C);
-  XEREGISTEREMITTER(mtfsfx,       0xFC00058E);
-  XEREGISTEREMITTER(mtfsfix,      0xFC00010C);
-  XEREGISTEREMITTER(fabsx,        0xFC000210);
-  XEREGISTEREMITTER(fmrx,         0xFC000090);
-  XEREGISTEREMITTER(fnabsx,       0xFC000110);
-  XEREGISTEREMITTER(fnegx,        0xFC000050);
+  XEREGISTERINSTR(faddx,        0xFC00002A);
+  XEREGISTERINSTR(faddsx,       0xEC00002A);
+  XEREGISTERINSTR(fdivx,        0xFC000024);
+  XEREGISTERINSTR(fdivsx,       0xEC000024);
+  XEREGISTERINSTR(fmulx,        0xFC000032);
+  XEREGISTERINSTR(fmulsx,       0xEC000032);
+  XEREGISTERINSTR(fresx,        0xEC000030);
+  XEREGISTERINSTR(frsqrtex,     0xFC000034);
+  XEREGISTERINSTR(fsubx,        0xFC000028);
+  XEREGISTERINSTR(fsubsx,       0xEC000028);
+  XEREGISTERINSTR(fselx,        0xFC00002E);
+  XEREGISTERINSTR(fsqrtx,       0xFC00002C);
+  XEREGISTERINSTR(fsqrtsx,      0xEC00002C);
+  XEREGISTERINSTR(fmaddx,       0xFC00003A);
+  XEREGISTERINSTR(fmaddsx,      0xEC00003A);
+  XEREGISTERINSTR(fmsubx,       0xFC000038);
+  XEREGISTERINSTR(fmsubsx,      0xEC000038);
+  XEREGISTERINSTR(fnmaddx,      0xFC00003E);
+  XEREGISTERINSTR(fnmaddsx,     0xEC00003E);
+  XEREGISTERINSTR(fnmsubx,      0xFC00003C);
+  XEREGISTERINSTR(fnmsubsx,     0xEC00003C);
+  XEREGISTERINSTR(fcfidx,       0xFC00069C);
+  XEREGISTERINSTR(fctidx,       0xFC00065C);
+  XEREGISTERINSTR(fctidzx,      0xFC00065E);
+  XEREGISTERINSTR(fctiwx,       0xFC00001C);
+  XEREGISTERINSTR(fctiwzx,      0xFC00001E);
+  XEREGISTERINSTR(frspx,        0xFC000018);
+  XEREGISTERINSTR(fcmpo,        0xFC000040);
+  XEREGISTERINSTR(fcmpu,        0xFC000000);
+  XEREGISTERINSTR(mcrfs,        0xFC000080);
+  XEREGISTERINSTR(mffsx,        0xFC00048E);
+  XEREGISTERINSTR(mtfsb0x,      0xFC00008C);
+  XEREGISTERINSTR(mtfsb1x,      0xFC00004C);
+  XEREGISTERINSTR(mtfsfx,       0xFC00058E);
+  XEREGISTERINSTR(mtfsfix,      0xFC00010C);
+  XEREGISTERINSTR(fabsx,        0xFC000210);
+  XEREGISTERINSTR(fmrx,         0xFC000090);
+  XEREGISTERINSTR(fnabsx,       0xFC000110);
+  XEREGISTERINSTR(fnegx,        0xFC000050);
 }
 
 
diff --git a/src/xenia/cpu/codegen/emit_memory.cc b/src/xenia/cpu/codegen/emit_memory.cc
index 19d9434c7..75b799b5e 100644
--- a/src/xenia/cpu/codegen/emit_memory.cc
+++ b/src/xenia/cpu/codegen/emit_memory.cc
@@ -24,17 +24,6 @@ namespace codegen {
 
 // Integer load (A-13)
 
-XEDISASMR(lbz,          0x88000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lbz", "Load Byte and Zero", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lbz,          0x88000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -53,13 +42,6 @@ XEEMITTER(lbz,          0x88000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lbzu,         0x8C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lbzu", "Load Byte and Zero with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lbzu,         0x8C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // RT <- i56.0 || MEM(EA, 1)
@@ -73,13 +55,6 @@ XEEMITTER(lbzu,         0x8C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lbzux,        0x7C0000EE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lbzux", "Load Byte and Zero with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lbzux,        0x7C0000EE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // RT <- i56.0 || MEM(EA, 1)
@@ -93,17 +68,6 @@ XEEMITTER(lbzux,        0x7C0000EE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lbzx,         0x7C0000AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lbzx", "Load Byte and Zero Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lbzx,         0x7C0000AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -122,17 +86,6 @@ XEEMITTER(lbzx,         0x7C0000AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(ld,           0xE8000000, DS )(InstrData& i, InstrDisasm& d) {
-  d.Init("ld", "Load Doubleword", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
-  if (i.DS.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
-  return d.Finish();
-}
 XEEMITTER(ld,           0xE8000000, DS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -151,13 +104,6 @@ XEEMITTER(ld,           0xE8000000, DS )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(ldu,          0xE8000001, DS )(InstrData& i, InstrDisasm& d) {
-  d.Init("ldu", "Load Doubleword with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
-  return d.Finish();
-}
 XEEMITTER(ldu,          0xE8000001, DS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(DS || 0b00)
   // RT <- MEM(EA, 8)
@@ -182,17 +128,6 @@ XEEMITTER(ldx,          0x7C00002A, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(lha,          0xA8000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lha", "Load Halfword Algebraic", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lha,          0xA8000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -222,17 +157,6 @@ XEEMITTER(lhaux,        0x7C0002EE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(lhax,         0x7C0002AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lhax", "Load Halfword Algebraic Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lhax,         0x7C0002AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -252,17 +176,6 @@ XEEMITTER(lhax,         0x7C0002AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lhz,          0xA0000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lhz", "Load Halfword and Zero", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lhz,          0xA0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -281,13 +194,6 @@ XEEMITTER(lhz,          0xA0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lhzu,         0xA4000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lhzu", "Load Halfword and Zero with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lhzu,         0xA4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // RT <- i48.0 || MEM(EA, 2)
@@ -301,13 +207,6 @@ XEEMITTER(lhzu,         0xA4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lhzux,        0x7C00026E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lhzux", "Load Halfword and Zero with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lhzux,        0x7C00026E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // RT <- i48.0 || MEM(EA, 2)
@@ -321,17 +220,6 @@ XEEMITTER(lhzux,        0x7C00026E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lhzx,         0x7C00022E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lhzx", "Load Halfword and Zero Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lhzx,         0x7C00022E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -350,17 +238,6 @@ XEEMITTER(lhzx,         0x7C00022E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwa,          0xE8000002, DS )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwa", "Load Word Algebraic", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
-  return d.Finish();
-}
 XEEMITTER(lwa,          0xE8000002, DS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -380,13 +257,6 @@ XEEMITTER(lwa,          0xE8000002, DS )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwaux,        0x7C0002EA, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwaux", "Load Word Algebraic with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lwaux,        0x7C0002EA, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // RT <- EXTS(MEM(EA, 4))
@@ -401,17 +271,6 @@ XEEMITTER(lwaux,        0x7C0002EA, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwax,         0x7C0002AA, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwax", "Load Word Algebraic Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lwax,         0x7C0002AA, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -431,17 +290,6 @@ XEEMITTER(lwax,         0x7C0002AA, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwz,          0x80000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwz", "Load Word and Zero", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lwz,          0x80000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -460,13 +308,6 @@ XEEMITTER(lwz,          0x80000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwzu,         0x84000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwzu", "Load Word and Zero with Udpate", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lwzu,         0x84000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // RT <- i32.0 || MEM(EA, 4)
@@ -480,13 +321,6 @@ XEEMITTER(lwzu,         0x84000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwzux,        0x7C00006E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwzux", "Load Word and Zero with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lwzux,        0x7C00006E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // RT <- i32.0 || MEM(EA, 4)
@@ -500,17 +334,6 @@ XEEMITTER(lwzux,        0x7C00006E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lwzx,         0x7C00002E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwzx", "Load Word and Zero Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lwzx,         0x7C00002E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -532,17 +355,6 @@ XEEMITTER(lwzx,         0x7C00002E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Integer store (A-14)
 
-XEDISASMR(stb,          0x98000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stb", "Store Byte", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stb,          0x98000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -561,13 +373,6 @@ XEEMITTER(stb,          0x98000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stbu,         0x9C000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stbu", "Store Byte with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stbu,         0x9C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // MEM(EA, 1) <- (RS)[56:63]
@@ -581,13 +386,6 @@ XEEMITTER(stbu,         0x9C000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stbux,        0x7C0001EE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stbux", "Store Byte with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stbux,        0x7C0001EE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 1) <- (RS)[56:63]
@@ -601,17 +399,6 @@ XEEMITTER(stbux,        0x7C0001EE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stbx,         0x7C0001AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stbx", "Store Byte Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  if (i.DS.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stbx,         0x7C0001AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -630,17 +417,6 @@ XEEMITTER(stbx,         0x7C0001AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(std,          0xF8000000, DS )(InstrData& i, InstrDisasm& d) {
-  d.Init("std", "Store Doubleword", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kRead);
-  if (i.DS.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
-  return d.Finish();
-}
 XEEMITTER(std,          0xF8000000, DS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -659,13 +435,6 @@ XEEMITTER(std,          0xF8000000, DS )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stdu,         0xF8000001, DS )(InstrData& i, InstrDisasm& d) {
-  d.Init("stdu", "Store Doubleword with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
-  return d.Finish();
-}
 XEEMITTER(stdu,         0xF8000001, DS )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(DS || 0b00)
   // MEM(EA, 8) <- (RS)
@@ -680,17 +449,6 @@ XEEMITTER(stdu,         0xF8000001, DS )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stdux,        0x7C00016A, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stdux", "Store Doubleword with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-    if (i.DS.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stdux,        0x7C00016A, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -709,13 +467,6 @@ XEEMITTER(stdux,        0x7C00016A, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stdx,         0x7C00012A, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stdx", "Store Doubleword Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stdx,         0x7C00012A, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 8) <- (RS)
@@ -729,17 +480,6 @@ XEEMITTER(stdx,         0x7C00012A, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(sth,          0xB0000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sth", "Store Halfword", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(sth,          0xB0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -758,13 +498,6 @@ XEEMITTER(sth,          0xB0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(sthu,         0xB4000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sthu", "Store Halfword with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(sthu,         0xB4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // MEM(EA, 2) <- (RS)[48:63]
@@ -779,13 +512,6 @@ XEEMITTER(sthu,         0xB4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(sthux,        0x7C00036E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sthux", "Store Halfword with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(sthux,        0x7C00036E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 2) <- (RS)[48:63]
@@ -799,17 +525,6 @@ XEEMITTER(sthux,        0x7C00036E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(sthx,         0x7C00032E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("sth", "Store Halfword Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(sthx,         0x7C00032E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -828,17 +543,6 @@ XEEMITTER(sthx,         0x7C00032E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stw,          0x90000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stw", "Store Word", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stw,          0x90000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -857,13 +561,6 @@ XEEMITTER(stw,          0x90000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stwu,         0x94000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stwu", "Store Word with Update", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stwu,         0x94000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // MEM(EA, 4) <- (RS)[32:63]
@@ -878,13 +575,6 @@ XEEMITTER(stwu,         0x94000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stwux,        0x7C00016E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stwux", "Store Word with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stwux,        0x7C00016E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 4) <- (RS)[32:63]
@@ -898,17 +588,6 @@ XEEMITTER(stwux,        0x7C00016E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stwx,         0x7C00012E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stwx", "Store Word Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stwx,         0x7C00012E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1014,17 +693,6 @@ XEEMITTER(ldarx,        0x7C0000A8, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(lwarx,        0x7C000028, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lwarx", "Load Word And Reserve Indexed", 0);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lwarx,        0x7C000028, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1053,18 +721,6 @@ XEEMITTER(stdcx,        0x7C0001AD, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(stwcx,        0x7C00012D, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stwcx", "Store Word Conditional Indexed",
-      InstrDisasm::kRc);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stwcx,        0x7C00012D, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1099,17 +755,6 @@ XEEMITTER(sync,         0x7C0004AC, X  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Floating-point load (A-19)
 
-XEDISASMR(lfd,          0xC8000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfd", "Load Floating-Point Double", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lfd,          0xC8000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1129,13 +774,6 @@ XEEMITTER(lfd,          0xC8000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfdu,         0xCC000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfdu", "Load Floating-Point Double with Update", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lfdu,         0xCC000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // FRT <- MEM(EA, 8)
@@ -1150,13 +788,6 @@ XEEMITTER(lfdu,         0xCC000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfdux,        0x7C0004EE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfdux", "Load Floating-Point Double with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lfdux,        0x7C0004EE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // FRT <- MEM(EA, 8)
@@ -1171,17 +802,6 @@ XEEMITTER(lfdux,        0x7C0004EE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfdx,         0x7C0004AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfdx", "Load Floating-Point Double Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lfdx,         0x7C0004AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1201,17 +821,6 @@ XEEMITTER(lfdx,         0x7C0004AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfs,          0xC0000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfs", "Load Floating-Point Single", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lfs,          0xC0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1231,13 +840,6 @@ XEEMITTER(lfs,          0xC0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfsu,         0xC4000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfsu", "Load Floating-Point Single with Update", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(lfsu,         0xC4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // FRT <- DOUBLE(MEM(EA, 4))
@@ -1252,13 +854,6 @@ XEEMITTER(lfsu,         0xC4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfsux,        0x7C00046E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfsux", "Load Floating-Point Single with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lfsux,        0x7C00046E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // FRT <- DOUBLE(MEM(EA, 4))
@@ -1273,17 +868,6 @@ XEEMITTER(lfsux,        0x7C00046E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(lfsx,         0x7C00042E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("lfsx", "Load Floating-Point Single Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(lfsx,         0x7C00042E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1306,17 +890,6 @@ XEEMITTER(lfsx,         0x7C00042E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
 
 // Floating-point store (A-20)
 
-XEDISASMR(stfd,         0xD8000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfd", "Store Floating-Point Double", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stfd,         0xD8000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1336,13 +909,6 @@ XEEMITTER(stfd,         0xD8000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfdu,        0xDC000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfdu", "Store Floating-Point Double with Update", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stfdu,        0xDC000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // MEM(EA, 8) <- (FRS)
@@ -1358,13 +924,6 @@ XEEMITTER(stfdu,        0xDC000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfdux,       0x7C0005EE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfdux", "Store Floating-Point Double with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stfdux,       0x7C0005EE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 8) <- (FRS)
@@ -1379,17 +938,6 @@ XEEMITTER(stfdux,       0x7C0005EE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfdx,        0x7C0005AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfdx", "Store Floating-Point Double Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stfdx,        0x7C0005AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1409,17 +957,6 @@ XEEMITTER(stfdx,        0x7C0005AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfiwx,       0x7C0007AE, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfiwx", "Store Floating-Point as Integer Word Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stfiwx,       0x7C0007AE, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1439,17 +976,6 @@ XEEMITTER(stfiwx,       0x7C0007AE, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfs,         0xD0000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfs", "Store Floating-Point Single", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
-  if (i.D.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stfs,         0xD0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1469,13 +995,6 @@ XEEMITTER(stfs,         0xD0000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfsu,        0xD4000000, D  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfsu", "Store Floating-Point Single with Update", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
-  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
-  return d.Finish();
-}
 XEEMITTER(stfsu,        0xD4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + EXTS(D)
   // MEM(EA, 4) <- SINGLE(FRS)
@@ -1491,13 +1010,6 @@ XEEMITTER(stfsu,        0xD4000000, D  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfsux,       0x7C00056E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfsux", "Store Floating-Point Single with Update Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stfsux,       0x7C00056E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // EA <- (RA) + (RB)
   // MEM(EA, 4) <- SINGLE(FRS)
@@ -1512,17 +1024,6 @@ XEEMITTER(stfsux,       0x7C00056E, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 0;
 }
 
-XEDISASMR(stfsx,        0x7C00052E, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("stfsx", "Store Floating-Point Single Indexed", 0);
-  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
-  if (i.X.RA) {
-    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
-  } else {
-    d.AddUImmOperand(0, 1);
-  }
-  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
-  return d.Finish();
-}
 XEEMITTER(stfsx,        0x7C00052E, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // if RA = 0 then
   //   b <- 0
@@ -1555,22 +1056,12 @@ XEEMITTER(dcbst,        0x7C00006C, X  )(FunctionGenerator& g, IRBuilder<>& b, I
   return 1;
 }
 
-XEDISASMR(dcbt,         0x7C00022C, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("dcbt", "Data Cache Block Touch", 0);
-  // TODO
-  return d.Finish();
-}
 XEEMITTER(dcbt,         0x7C00022C, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // No-op for now.
   // TODO(benvanik): use @llvm.prefetch
   return 0;
 }
 
-XEDISASMR(dcbtst,       0x7C0001EC, X  )(InstrData& i, InstrDisasm& d) {
-  d.Init("dcbtst", "Data Cache Block Touch for Store", 0);
-  // TODO
-  return d.Finish();
-}
 XEEMITTER(dcbtst,       0x7C0001EC, X  )(FunctionGenerator& g, IRBuilder<>& b, InstrData& i) {
   // No-op for now.
   // TODO(benvanik): use @llvm.prefetch
@@ -1596,11 +1087,11 @@ void RegisterEmitCategoryMemory() {
   XEREGISTERINSTR(lbzx,         0x7C0000AE);
   XEREGISTERINSTR(ld,           0xE8000000);
   XEREGISTERINSTR(ldu,          0xE8000001);
-  XEREGISTEREMITTER(ldux,         0x7C00006A);
-  XEREGISTEREMITTER(ldx,          0x7C00002A);
+  XEREGISTERINSTR(ldux,         0x7C00006A);
+  XEREGISTERINSTR(ldx,          0x7C00002A);
   XEREGISTERINSTR(lha,          0xA8000000);
-  XEREGISTEREMITTER(lhau,         0xAC000000);
-  XEREGISTEREMITTER(lhaux,        0x7C0002EE);
+  XEREGISTERINSTR(lhau,         0xAC000000);
+  XEREGISTERINSTR(lhaux,        0x7C0002EE);
   XEREGISTERINSTR(lhax,         0x7C0002AE);
   XEREGISTERINSTR(lhz,          0xA0000000);
   XEREGISTERINSTR(lhzu,         0xA4000000);
@@ -1629,25 +1120,25 @@ void RegisterEmitCategoryMemory() {
   XEREGISTERINSTR(stwu,         0x94000000);
   XEREGISTERINSTR(stwux,        0x7C00016E);
   XEREGISTERINSTR(stwx,         0x7C00012E);
-  XEREGISTEREMITTER(lhbrx,        0x7C00062C);
-  XEREGISTEREMITTER(lwbrx,        0x7C00042C);
-  XEREGISTEREMITTER(ldbrx,        0x7C000428);
-  XEREGISTEREMITTER(sthbrx,       0x7C00072C);
-  XEREGISTEREMITTER(stwbrx,       0x7C00052C);
-  XEREGISTEREMITTER(stdbrx,       0x7C000528);
-  XEREGISTEREMITTER(lmw,          0xB8000000);
-  XEREGISTEREMITTER(stmw,         0xBC000000);
-  XEREGISTEREMITTER(lswi,         0x7C0004AA);
-  XEREGISTEREMITTER(lswx,         0x7C00042A);
-  XEREGISTEREMITTER(stswi,        0x7C0005AA);
-  XEREGISTEREMITTER(stswx,        0x7C00052A);
-  XEREGISTEREMITTER(eieio,        0x7C0006AC);
-  XEREGISTEREMITTER(isync,        0x4C00012C);
-  XEREGISTEREMITTER(ldarx,        0x7C0000A8);
+  XEREGISTERINSTR(lhbrx,        0x7C00062C);
+  XEREGISTERINSTR(lwbrx,        0x7C00042C);
+  XEREGISTERINSTR(ldbrx,        0x7C000428);
+  XEREGISTERINSTR(sthbrx,       0x7C00072C);
+  XEREGISTERINSTR(stwbrx,       0x7C00052C);
+  XEREGISTERINSTR(stdbrx,       0x7C000528);
+  XEREGISTERINSTR(lmw,          0xB8000000);
+  XEREGISTERINSTR(stmw,         0xBC000000);
+  XEREGISTERINSTR(lswi,         0x7C0004AA);
+  XEREGISTERINSTR(lswx,         0x7C00042A);
+  XEREGISTERINSTR(stswi,        0x7C0005AA);
+  XEREGISTERINSTR(stswx,        0x7C00052A);
+  XEREGISTERINSTR(eieio,        0x7C0006AC);
+  XEREGISTERINSTR(isync,        0x4C00012C);
+  XEREGISTERINSTR(ldarx,        0x7C0000A8);
   XEREGISTERINSTR(lwarx,        0x7C000028);
-  XEREGISTEREMITTER(stdcx,        0x7C0001AD);
+  XEREGISTERINSTR(stdcx,        0x7C0001AD);
   XEREGISTERINSTR(stwcx,        0x7C00012D);
-  XEREGISTEREMITTER(sync,         0x7C0004AC);
+  XEREGISTERINSTR(sync,         0x7C0004AC);
   XEREGISTERINSTR(lfd,          0xC8000000);
   XEREGISTERINSTR(lfdu,         0xCC000000);
   XEREGISTERINSTR(lfdux,        0x7C0004EE);
@@ -1665,12 +1156,12 @@ void RegisterEmitCategoryMemory() {
   XEREGISTERINSTR(stfsu,        0xD4000000);
   XEREGISTERINSTR(stfsux,       0x7C00056E);
   XEREGISTERINSTR(stfsx,        0x7C00052E);
-  XEREGISTEREMITTER(dcbf,         0x7C0000AC);
-  XEREGISTEREMITTER(dcbst,        0x7C00006C);
+  XEREGISTERINSTR(dcbf,         0x7C0000AC);
+  XEREGISTERINSTR(dcbst,        0x7C00006C);
   XEREGISTERINSTR(dcbt,         0x7C00022C);
   XEREGISTERINSTR(dcbtst,       0x7C0001EC);
-  XEREGISTEREMITTER(dcbz,         0x7C0007EC);
-  XEREGISTEREMITTER(icbi,         0x7C0007AC);
+  XEREGISTERINSTR(dcbz,         0x7C0007EC);
+  XEREGISTERINSTR(icbi,         0x7C0007AC);
 }
 
 
diff --git a/src/xenia/cpu/ppc/disasm.h b/src/xenia/cpu/ppc/disasm.h
new file mode 100644
index 000000000..3fb5a5b14
--- /dev/null
+++ b/src/xenia/cpu/ppc/disasm.h
@@ -0,0 +1,41 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_CPU_PPC_DISASM_H_
+#define XENIA_CPU_PPC_DISASM_H_
+
+#include <xenia/cpu/ppc/instr.h>
+
+
+namespace xe {
+namespace cpu {
+namespace ppc {
+
+
+void RegisterDisasmCategoryALU();
+void RegisterDisasmCategoryControl();
+void RegisterDisasmCategoryFPU();
+void RegisterDisasmCategoryMemory();
+
+
+#define XEDISASMR(name, opcode, format) int InstrDisasm_##name
+
+#define XEREGISTERINSTR(name, opcode) \
+    RegisterInstrDisassemble(opcode, (InstrDisassembleFn)InstrDisasm_##name);
+
+#define XEINSTRNOTIMPLEMENTED()
+//#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
+
+
+}  // namespace ppc
+}  // namespace cpu
+}  // namespace xe
+
+
+#endif  // XENIA_CPU_PPC_DISASM_H_
diff --git a/src/xenia/cpu/ppc/disasm_alu.cc b/src/xenia/cpu/ppc/disasm_alu.cc
new file mode 100644
index 000000000..861b1c4d3
--- /dev/null
+++ b/src/xenia/cpu/ppc/disasm_alu.cc
@@ -0,0 +1,715 @@
+/*
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/cpu/ppc/disasm.h>
+
+
+using namespace xe::cpu::ppc;
+
+
+namespace xe {
+namespace cpu {
+namespace ppc {
+
+
+// Integer arithmetic (A-3)
+
+XEDISASMR(addx,         0x7C000214, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("add", "Add",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(addcx,        0x7C000014, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("addcx", "Add Carrying",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(addex,        0x7C000114, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("adde", "Add Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(addi,         0x38000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("addi", "Add Immediate", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddSImmOperand(0, 4);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(addic,        0x30000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("addic", "Add Immediate Carrying", InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(addicx,       0x34000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("addic", "Add Immediate Carrying and Record",
+         InstrDisasm::kRc | InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(addis,        0x3C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("addis", "Add Immediate Shifted", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddSImmOperand(0, 4);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(addmex,       0x7C0001D4, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("addme", "Add to Minus One Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(addzex,       0x7C000194, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("addze", "Add to Zero Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(divdx,        0x7C0003D2, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("divd", "Divide Doubleword",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(divdux,       0x7C000392, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("divdu", "Divide Doubleword Unsigned",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(divwx,        0x7C0003D6, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("divw", "Divide Word",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(divwux,       0x7C000396, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("divwu", "Divide Word Unsigned",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulhdx,       0x7C000092, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulhd", "Multiply High Doubleword", i.XO.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulhdux,      0x7C000012, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulhdu", "Multiply High Doubleword Unsigned",
+         i.XO.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulhwx,       0x7C000096, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulhw", "Multiply High Word", i.XO.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulhwux,      0x7C000016, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulhwu", "Multiply High Word Unsigned",
+         i.XO.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulldx,       0x7C0001D2, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulld", "Multiply Low Doubleword",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(mulli,        0x1C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("mulli", "Multiply Low Immediate", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(mullwx,       0x7C0001D6, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("mullw", "Multiply Low Word",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(negx,         0x7C0000D0, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("neg", "Negate",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subfx,        0x7C000050, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("subf", "Subtract From",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subfcx,       0x7C000010, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("subfc", "Subtract From Carrying",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subficx,      0x20000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("subfic", "Subtract From Immediate Carrying", InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subfex,       0x7C000110, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("subfe", "Subtract From Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subfmex,      0x7C0001D0, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("subfme", "Subtract From Minus One Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(subfzex,      0x7C000190, XO )(InstrData& i, InstrDisasm& d) {
+  d.Init("subfze", "Subtract From Zero Extended",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0) |
+         InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Integer compare (A-4)
+
+XEDISASMR(cmp,          0x7C000000, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cmp", "Compare", 0);
+  d.AddCR(i.X.RT >> 2, InstrRegister::kWrite);
+  d.AddUImmOperand(i.X.RT >> 2, 1);
+  d.AddUImmOperand(i.X.RT & 1, 1);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(cmpi,         0x2C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cmpi", "Compare Immediate", 0);
+  d.AddCR(i.D.RT >> 2, InstrRegister::kWrite);
+  d.AddUImmOperand(i.D.RT >> 2, 1);
+  d.AddUImmOperand(i.D.RT & 1, 1);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(cmpl,         0x7C000040, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cmpl", "Compare Logical", 0);
+  d.AddCR(i.X.RT >> 2, InstrRegister::kWrite);
+  d.AddUImmOperand(i.X.RT >> 2, 1);
+  d.AddUImmOperand(i.X.RT & 1, 1);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(cmpli,        0x28000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cmpli", "Compare Logical Immediate", 0);
+  d.AddCR(i.D.RT >> 2, InstrRegister::kWrite);
+  d.AddUImmOperand(i.D.RT >> 2, 1);
+  d.AddUImmOperand(i.D.RT & 1, 1);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  d.AddSImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+
+// Integer logical (A-5)
+
+XEDISASMR(andx,         0x7C000038, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("and", "AND", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(andcx,        0x7C000078, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("andc", "AND with Complement", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(andix,        0x70000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("andi", "AND Immediate", 0);
+  d.AddCR(0, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+XEDISASMR(andisx,       0x74000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("andi", "AND Immediate Shifted", 0);
+  d.AddCR(0, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+XEDISASMR(cntlzdx,      0x7C000074, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cntlzd", "Count Leading Zeros Doubleword",
+         i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(cntlzwx,      0x7C000034, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("cntlzw", "Count Leading Zeros Word",
+         i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(eqvx,         0x7C000238, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("eqv", "Equivalent", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(extsbx,       0x7C000774, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("extsb", "Extend Sign Byte", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(extshx,       0x7C000734, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("extsh", "Extend Sign Halfword", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(extswx,       0x7C0007B4, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("extsw", "Extend Sign Word", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(nandx,        0x7C0003B8, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("nand", "NAND", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(norx,         0x7C0000F8, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("nor", "NOR", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(orx,          0x7C000378, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("or", "OR", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(orcx,         0x7C000338, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("orc", "OR with Complement", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(ori,          0x60000000, D  )(InstrData& i, InstrDisasm& d) {
+  if (!i.D.RA && !i.D.RT && !i.D.DS) {
+    d.Init("no-op", "OR Immediate", 0);
+  } else {
+    d.Init("ori", "OR Immediate", 0);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+XEDISASMR(oris,         0x64000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("oris", "OR Immediate Shifted", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+XEDISASMR(xorx,         0x7C000278, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("xor", "XOR", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(xori,         0x68000000, D  )(InstrData& i, InstrDisasm& d) {
+  if (!i.D.RA && !i.D.RT && !i.D.DS) {
+    d.Init("xnop", "XOR Immediate", 0);
+  } else {
+    d.Init("xori", "XOR Immediate", 0);
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+    d.AddUImmOperand(i.D.DS, 2);
+  }
+  return d.Finish();
+}
+
+XEDISASMR(xoris,        0x6C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("xoris", "XOR Immediate Shifted", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.D.DS, 2);
+  return d.Finish();
+}
+
+
+// Integer rotate (A-6)
+
+XEDISASMR(rldclx,       0x78000010, MDS)(InstrData& i, InstrDisasm& d) {
+  d.Init("rldcl", "Rotate Left Doubleword then Clear Left",
+         i.MDS.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RB, InstrRegister::kRead);
+  d.AddUImmOperand((i.MDS.MB5 << 5) | i.MDS.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rldcrx,       0x78000012, MDS)(InstrData& i, InstrDisasm& d) {
+  d.Init("rldcr", "Rotate Left Doubleword then Clear Right",
+         i.MDS.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.MDS.RB, InstrRegister::kRead);
+  d.AddUImmOperand((i.MDS.MB5 << 5) | i.MDS.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rldicx,       0x78000008, MD )(InstrData& i, InstrDisasm& d) {
+  d.Init("rldic", "Rotate Left Doubleword Immediate then Clear",
+         i.MD.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
+  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
+  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rldiclx,      0x78000000, MD )(InstrData& i, InstrDisasm& d) {
+  d.Init("rldicl", "Rotate Left Doubleword Immediate then Clear Left",
+         i.MD.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
+  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
+  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rldicrx,      0x78000004, MD )(InstrData& i, InstrDisasm& d) {
+  d.Init("rldicr", "Rotate Left Doubleword Immediate then Clear Right",
+         i.MD.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
+  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
+  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rldimix,      0x7800000C, MD )(InstrData& i, InstrDisasm& d) {
+  d.Init("rldimi", "Rotate Left Doubleword Immediate then Mask Insert",
+         i.MD.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.MD.RT, InstrRegister::kRead);
+  d.AddUImmOperand((i.MD.SH5 << 5) | i.MD.SH, 1);
+  d.AddUImmOperand((i.MD.MB5 << 5) | i.MD.MB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rlwimix,      0x50000000, M  )(InstrData& i, InstrDisasm& d) {
+  d.Init("rlwimi", "Rotate Left Word Immediate then Mask Insert",
+         i.M.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.M.SH, 1);
+  d.AddUImmOperand(i.M.MB, 1);
+  d.AddUImmOperand(i.M.ME, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rlwinmx,      0x54000000, M  )(InstrData& i, InstrDisasm& d) {
+  d.Init("rlwinm", "Rotate Left Word Immediate then AND with Mask",
+         i.M.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.M.SH, 1);
+  d.AddUImmOperand(i.M.MB, 1);
+  d.AddUImmOperand(i.M.ME, 1);
+  return d.Finish();
+}
+
+XEDISASMR(rlwnmx,       0x5C000000, M  )(InstrData& i, InstrDisasm& d) {
+  d.Init("rlwnm", "Rotate Left Word then AND with Mask",
+         i.M.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.M.SH, InstrRegister::kRead);
+  d.AddUImmOperand(i.M.MB, 1);
+  d.AddUImmOperand(i.M.ME, 1);
+  return d.Finish();
+}
+
+
+// Integer shift (A-7)
+
+XEDISASMR(sldx,         0x7C000036, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sld", "Shift Left Doubleword", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(slwx,         0x7C000030, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("slw", "Shift Left Word", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(sradx,        0x7C000634, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("srad", "Shift Right Algebraic Doubleword",
+         i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(sradix,       0x7C000674, XS )(InstrData& i, InstrDisasm& d) {
+  d.Init("sradi", "Shift Right Algebraic Doubleword Immediate",
+         (i.XS.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.XS.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XS.RT, InstrRegister::kRead);
+  d.AddUImmOperand((i.XS.SH5 << 5) | i.XS.SH, 1);
+  return d.Finish();
+}
+
+XEDISASMR(srawx,        0x7C000630, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sraw", "Shift Right Algebraic Word",
+         (i.X.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(srawix,       0x7C000670, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("srawi", "Shift Right Algebraic Word Immediate",
+         (i.X.Rc ? InstrDisasm::kRc : 0) | InstrDisasm::kCA);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddUImmOperand(i.X.RB, 1);
+  return d.Finish();
+}
+
+XEDISASMR(srdx,         0x7C000436, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("srd", "Shift Right Doubleword", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(srwx,         0x7C000430, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("srw", "Shift Right Word", i.X.Rc ? InstrDisasm::kRc : 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+void RegisterDisasmCategoryALU() {
+  XEREGISTERINSTR(addx,         0x7C000214);
+  XEREGISTERINSTR(addcx,        0X7C000014);
+  XEREGISTERINSTR(addex,        0x7C000114);
+  XEREGISTERINSTR(addi,         0x38000000);
+  XEREGISTERINSTR(addic,        0x30000000);
+  XEREGISTERINSTR(addicx,       0x34000000);
+  XEREGISTERINSTR(addis,        0x3C000000);
+  XEREGISTERINSTR(addmex,       0x7C0001D4);
+  XEREGISTERINSTR(addzex,       0x7C000194);
+  XEREGISTERINSTR(divdx,        0x7C0003D2);
+  XEREGISTERINSTR(divdux,       0x7C000392);
+  XEREGISTERINSTR(divwx,        0x7C0003D6);
+  XEREGISTERINSTR(divwux,       0x7C000396);
+  XEREGISTERINSTR(mulhdx,       0x7C000092);
+  XEREGISTERINSTR(mulhdux,      0x7C000012);
+  XEREGISTERINSTR(mulhwx,       0x7C000096);
+  XEREGISTERINSTR(mulhwux,      0x7C000016);
+  XEREGISTERINSTR(mulldx,       0x7C0001D2);
+  XEREGISTERINSTR(mulli,        0x1C000000);
+  XEREGISTERINSTR(mullwx,       0x7C0001D6);
+  XEREGISTERINSTR(negx,         0x7C0000D0);
+  XEREGISTERINSTR(subfx,        0x7C000050);
+  XEREGISTERINSTR(subfcx,       0x7C000010);
+  XEREGISTERINSTR(subficx,      0x20000000);
+  XEREGISTERINSTR(subfex,       0x7C000110);
+  XEREGISTERINSTR(subfmex,      0x7C0001D0);
+  XEREGISTERINSTR(subfzex,      0x7C000190);
+  XEREGISTERINSTR(cmp,          0x7C000000);
+  XEREGISTERINSTR(cmpi,         0x2C000000);
+  XEREGISTERINSTR(cmpl,         0x7C000040);
+  XEREGISTERINSTR(cmpli,        0x28000000);
+  XEREGISTERINSTR(andx,         0x7C000038);
+  XEREGISTERINSTR(andcx,        0x7C000078);
+  XEREGISTERINSTR(andix,        0x70000000);
+  XEREGISTERINSTR(andisx,       0x74000000);
+  XEREGISTERINSTR(cntlzdx,      0x7C000074);
+  XEREGISTERINSTR(cntlzwx,      0x7C000034);
+  XEREGISTERINSTR(eqvx,         0x7C000238);
+  XEREGISTERINSTR(extsbx,       0x7C000774);
+  XEREGISTERINSTR(extshx,       0x7C000734);
+  XEREGISTERINSTR(extswx,       0x7C0007B4);
+  XEREGISTERINSTR(nandx,        0x7C0003B8);
+  XEREGISTERINSTR(norx,         0x7C0000F8);
+  XEREGISTERINSTR(orx,          0x7C000378);
+  XEREGISTERINSTR(orcx,         0x7C000338);
+  XEREGISTERINSTR(ori,          0x60000000);
+  XEREGISTERINSTR(oris,         0x64000000);
+  XEREGISTERINSTR(xorx,         0x7C000278);
+  XEREGISTERINSTR(xori,         0x68000000);
+  XEREGISTERINSTR(xoris,        0x6C000000);
+  XEREGISTERINSTR(rldclx,       0x78000010);
+  XEREGISTERINSTR(rldcrx,       0x78000012);
+  XEREGISTERINSTR(rldicx,       0x78000008);
+  XEREGISTERINSTR(rldiclx,      0x78000000);
+  XEREGISTERINSTR(rldicrx,      0x78000004);
+  XEREGISTERINSTR(rldimix,      0x7800000C);
+  XEREGISTERINSTR(rlwimix,      0x50000000);
+  XEREGISTERINSTR(rlwinmx,      0x54000000);
+  XEREGISTERINSTR(rlwnmx,       0x5C000000);
+  XEREGISTERINSTR(sldx,         0x7C000036);
+  XEREGISTERINSTR(slwx,         0x7C000030);
+  XEREGISTERINSTR(sradx,        0x7C000634);
+  XEREGISTERINSTR(sradix,       0x7C000674);
+  XEREGISTERINSTR(srawx,        0x7C000630);
+  XEREGISTERINSTR(srawix,       0x7C000670);
+  XEREGISTERINSTR(srdx,         0x7C000436);
+  XEREGISTERINSTR(srwx,         0x7C000430);
+}
+
+
+}  // namespace ppc
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/ppc/disasm_control.cc b/src/xenia/cpu/ppc/disasm_control.cc
new file mode 100644
index 000000000..e013530a3
--- /dev/null
+++ b/src/xenia/cpu/ppc/disasm_control.cc
@@ -0,0 +1,248 @@
+/*
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/cpu/ppc/disasm.h>
+
+
+using namespace xe::cpu::ppc;
+
+
+namespace xe {
+namespace cpu {
+namespace ppc {
+
+
+XEDISASMR(bx,           0x48000000, I  )(InstrData& i, InstrDisasm& d) {
+  d.Init("b", "Branch", i.I.LK ? InstrDisasm::kLR : 0);
+  uint32_t nia;
+  if (i.I.AA) {
+    nia = XEEXTS26(i.I.LI << 2);
+  } else {
+    nia = i.address + XEEXTS26(i.I.LI << 2);
+  }
+  d.AddUImmOperand(nia, 4);
+  return d.Finish();
+}
+
+XEDISASMR(bcx,          0x40000000, B  )(InstrData& i, InstrDisasm& d) {
+  // TODO(benvanik): mnemonics
+  d.Init("bc", "Branch Conditional", i.B.LK ? InstrDisasm::kLR : 0);
+  if (!XESELECTBITS(i.B.BO, 2, 2)) {
+    d.AddCTR(InstrRegister::kReadWrite);
+  }
+  if (!XESELECTBITS(i.B.BO, 4, 4)) {
+    d.AddCR(i.B.BI >> 2, InstrRegister::kRead);
+  }
+  d.AddUImmOperand(i.B.BO, 1);
+  d.AddUImmOperand(i.B.BI, 1);
+  return d.Finish();
+}
+
+XEDISASMR(bcctrx,       0x4C000420, XL )(InstrData& i, InstrDisasm& d) {
+  // TODO(benvanik): mnemonics
+  d.Init("bcctr", "Branch Conditional to Count Register",
+      i.XL.LK ? InstrDisasm::kLR : 0);
+  if (!XESELECTBITS(i.XL.BO, 4, 4)) {
+    d.AddCR(i.XL.BI >> 2, InstrRegister::kRead);
+  }
+  d.AddUImmOperand(i.XL.BO, 1);
+  d.AddUImmOperand(i.XL.BI, 1);
+  d.AddCTR(InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(bclrx,        0x4C000020, XL )(InstrData& i, InstrDisasm& d) {
+  std::string name = "bclr";
+  if (i.code == 0x4E800020) {
+    name = "blr";
+  }
+  d.Init(name, "Branch Conditional to Link Register",
+      i.XL.LK ? InstrDisasm::kLR : 0);
+  if (!XESELECTBITS(i.B.BO, 2, 2)) {
+    d.AddCTR(InstrRegister::kReadWrite);
+  }
+  if (!XESELECTBITS(i.B.BO, 4, 4)) {
+    d.AddCR(i.B.BI >> 2, InstrRegister::kRead);
+  }
+  d.AddUImmOperand(i.XL.BO, 1);
+  d.AddUImmOperand(i.XL.BI, 1);
+  d.AddLR(InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Condition register logical (A-23)
+
+XEDISASMR(crand,        0x4C000202, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(crandc,       0x4C000102, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(creqv,        0x4C000242, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(crnand,       0x4C0001C2, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(crnor,        0x4C000042, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(cror,         0x4C000382, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(crorc,        0x4C000342, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(crxor,        0x4C000182, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mcrf,         0x4C000000, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// System linkage (A-24)
+
+XEDISASMR(sc,           0x44000002, SC )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Trap (A-25)
+
+XEDISASMR(td,           0x7C000088, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("td", "Trap Doubleword", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(tdi,          0x08000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("tdi", "Trap Doubleword Immediate", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(tw,           0x7C000008, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("tw", "Trap Word", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(twi,          0x0C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("twi", "Trap Word Immediate", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Processor control (A-26)
+
+XEDISASMR(mfcr,         0x7C000026, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mfspr,        0x7C0002A6, XFX)(InstrData& i, InstrDisasm& d) {
+  d.Init("mfspr", "Move From Special Purpose Register", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.XFX.RT, InstrRegister::kWrite);
+  const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
+  switch (n) {
+  case 1:
+    d.AddRegOperand(InstrRegister::kXER, 0, InstrRegister::kRead);
+    break;
+  case 8:
+    d.AddRegOperand(InstrRegister::kLR, 0, InstrRegister::kRead);
+    break;
+  case 9:
+    d.AddRegOperand(InstrRegister::kCTR, 0, InstrRegister::kRead);
+    break;
+  }
+  return d.Finish();
+}
+
+XEDISASMR(mftb,         0x7C0002E6, XFX)(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtcrf,        0x7C000120, XFX)(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtspr,        0x7C0003A6, XFX)(InstrData& i, InstrDisasm& d) {
+  d.Init("mtspr", "Move To Special Purpose Register", 0);
+  const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
+  switch (n) {
+  case 1:
+    d.AddRegOperand(InstrRegister::kXER, 0, InstrRegister::kWrite);
+    break;
+  case 8:
+    d.AddRegOperand(InstrRegister::kLR, 0, InstrRegister::kWrite);
+    break;
+  case 9:
+    d.AddRegOperand(InstrRegister::kCTR, 0, InstrRegister::kWrite);
+    break;
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.XFX.RT, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+void RegisterDisasmCategoryControl() {
+  XEREGISTERINSTR(bx,           0x48000000);
+  XEREGISTERINSTR(bcx,          0x40000000);
+  XEREGISTERINSTR(bcctrx,       0x4C000420);
+  XEREGISTERINSTR(bclrx,        0x4C000020);
+  XEREGISTERINSTR(crand,        0x4C000202);
+  XEREGISTERINSTR(crandc,       0x4C000102);
+  XEREGISTERINSTR(creqv,        0x4C000242);
+  XEREGISTERINSTR(crnand,       0x4C0001C2);
+  XEREGISTERINSTR(crnor,        0x4C000042);
+  XEREGISTERINSTR(cror,         0x4C000382);
+  XEREGISTERINSTR(crorc,        0x4C000342);
+  XEREGISTERINSTR(crxor,        0x4C000182);
+  XEREGISTERINSTR(mcrf,         0x4C000000);
+  XEREGISTERINSTR(sc,           0x44000002);
+  XEREGISTERINSTR(td,           0x7C000088);
+  XEREGISTERINSTR(tdi,          0x08000000);
+  XEREGISTERINSTR(tw,           0x7C000008);
+  XEREGISTERINSTR(twi,          0x0C000000);
+  XEREGISTERINSTR(mfcr,         0x7C000026);
+  XEREGISTERINSTR(mfspr,        0x7C0002A6);
+  XEREGISTERINSTR(mftb,         0x7C0002E6);
+  XEREGISTERINSTR(mtcrf,        0x7C000120);
+  XEREGISTERINSTR(mtspr,        0x7C0003A6);
+}
+
+
+}  // namespace ppc
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/ppc/disasm_fpu.cc b/src/xenia/cpu/ppc/disasm_fpu.cc
new file mode 100644
index 000000000..3406c73c2
--- /dev/null
+++ b/src/xenia/cpu/ppc/disasm_fpu.cc
@@ -0,0 +1,283 @@
+/*
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/cpu/ppc/disasm.h>
+
+
+using namespace xe::cpu::ppc;
+
+
+namespace xe {
+namespace cpu {
+namespace ppc {
+
+
+// Floating-point arithmetic (A-8)
+
+XEDISASMR(faddx,        0xFC00002A, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(faddsx,       0xEC00002A, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fdivx,        0xFC000024, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fdivsx,       0xEC000024, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmulx,        0xFC000032, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmulsx,       0xEC000032, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fresx,        0xEC000030, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(frsqrtex,     0xFC000034, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fsubx,        0xFC000028, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fsubsx,       0xEC000028, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fselx,        0xFC00002E, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fsqrtx,       0xFC00002C, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fsqrtsx,      0xEC00002C, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Floating-point multiply-add (A-9)
+
+XEDISASMR(fmaddx,       0xFC00003A, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmaddsx,      0xEC00003A, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmsubx,       0xFC000038, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmsubsx,      0xEC000038, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnmaddx,      0xFC00003E, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnmaddsx,     0xEC00003E, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnmsubx,      0xFC00003C, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnmsubsx,     0xEC00003C, A  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Floating-point rounding and conversion (A-10)
+
+XEDISASMR(fcfidx,       0xFC00069C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fctidx,       0xFC00065C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fctidzx,      0xFC00065E, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fctiwx,       0xFC00001C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fctiwzx,      0xFC00001E, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(frspx,        0xFC000018, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Floating-point compare (A-11)
+
+XEDISASMR(fcmpo,        0xFC000040, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fcmpu,        0xFC000000, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("fcmpu", "Floating Compare Unordered",
+         (i.XO.OE ? InstrDisasm::kOE : 0) | (i.XO.Rc ? InstrDisasm::kRc : 0));
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RA, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.XO.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Floating-point status and control register (A
+
+XEDISASMR(mcrfs,        0xFC000080, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mffsx,        0xFC00048E, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtfsb0x,      0xFC00008C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtfsb1x,      0xFC00004C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtfsfx,       0xFC00058E, XFL)(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(mtfsfix,      0xFC00010C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Floating-point move (A-21)
+
+XEDISASMR(fabsx,        0xFC000210, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fmrx,         0xFC000090, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnabsx,       0xFC000110, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(fnegx,        0xFC000050, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+void RegisterDisasmCategoryFPU() {
+  XEREGISTERINSTR(faddx,        0xFC00002A);
+  XEREGISTERINSTR(faddsx,       0xEC00002A);
+  XEREGISTERINSTR(fdivx,        0xFC000024);
+  XEREGISTERINSTR(fdivsx,       0xEC000024);
+  XEREGISTERINSTR(fmulx,        0xFC000032);
+  XEREGISTERINSTR(fmulsx,       0xEC000032);
+  XEREGISTERINSTR(fresx,        0xEC000030);
+  XEREGISTERINSTR(frsqrtex,     0xFC000034);
+  XEREGISTERINSTR(fsubx,        0xFC000028);
+  XEREGISTERINSTR(fsubsx,       0xEC000028);
+  XEREGISTERINSTR(fselx,        0xFC00002E);
+  XEREGISTERINSTR(fsqrtx,       0xFC00002C);
+  XEREGISTERINSTR(fsqrtsx,      0xEC00002C);
+  XEREGISTERINSTR(fmaddx,       0xFC00003A);
+  XEREGISTERINSTR(fmaddsx,      0xEC00003A);
+  XEREGISTERINSTR(fmsubx,       0xFC000038);
+  XEREGISTERINSTR(fmsubsx,      0xEC000038);
+  XEREGISTERINSTR(fnmaddx,      0xFC00003E);
+  XEREGISTERINSTR(fnmaddsx,     0xEC00003E);
+  XEREGISTERINSTR(fnmsubx,      0xFC00003C);
+  XEREGISTERINSTR(fnmsubsx,     0xEC00003C);
+  XEREGISTERINSTR(fcfidx,       0xFC00069C);
+  XEREGISTERINSTR(fctidx,       0xFC00065C);
+  XEREGISTERINSTR(fctidzx,      0xFC00065E);
+  XEREGISTERINSTR(fctiwx,       0xFC00001C);
+  XEREGISTERINSTR(fctiwzx,      0xFC00001E);
+  XEREGISTERINSTR(frspx,        0xFC000018);
+  XEREGISTERINSTR(fcmpo,        0xFC000040);
+  XEREGISTERINSTR(fcmpu,        0xFC000000);
+  XEREGISTERINSTR(mcrfs,        0xFC000080);
+  XEREGISTERINSTR(mffsx,        0xFC00048E);
+  XEREGISTERINSTR(mtfsb0x,      0xFC00008C);
+  XEREGISTERINSTR(mtfsb1x,      0xFC00004C);
+  XEREGISTERINSTR(mtfsfx,       0xFC00058E);
+  XEREGISTERINSTR(mtfsfix,      0xFC00010C);
+  XEREGISTERINSTR(fabsx,        0xFC000210);
+  XEREGISTERINSTR(fmrx,         0xFC000090);
+  XEREGISTERINSTR(fnabsx,       0xFC000110);
+  XEREGISTERINSTR(fnegx,        0xFC000050);
+}
+
+
+}  // namespace ppc
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/ppc/disasm_memory.cc b/src/xenia/cpu/ppc/disasm_memory.cc
new file mode 100644
index 000000000..e15ef8f3d
--- /dev/null
+++ b/src/xenia/cpu/ppc/disasm_memory.cc
@@ -0,0 +1,836 @@
+/*
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/cpu/ppc/disasm.h>
+
+
+using namespace xe::cpu::ppc;
+
+
+namespace xe {
+namespace cpu {
+namespace ppc {
+
+
+// Integer load (A-13)
+
+XEDISASMR(lbz,          0x88000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lbz", "Load Byte and Zero", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lbzu,         0x8C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lbzu", "Load Byte and Zero with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lbzux,        0x7C0000EE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lbzux", "Load Byte and Zero with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lbzx,         0x7C0000AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lbzx", "Load Byte and Zero Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(ld,           0xE8000000, DS )(InstrData& i, InstrDisasm& d) {
+  d.Init("ld", "Load Doubleword", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
+  if (i.DS.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
+  return d.Finish();
+}
+
+XEDISASMR(ldu,          0xE8000001, DS )(InstrData& i, InstrDisasm& d) {
+  d.Init("ldu", "Load Doubleword with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
+  return d.Finish();
+}
+
+XEDISASMR(ldux,         0x7C00006A, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(ldx,          0x7C00002A, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lha,          0xA8000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lha", "Load Halfword Algebraic", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lhau,         0xAC000000, D  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lhaux,        0x7C0002EE, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lhax,         0x7C0002AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lhax", "Load Halfword Algebraic Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lhz,          0xA0000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lhz", "Load Halfword and Zero", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lhzu,         0xA4000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lhzu", "Load Halfword and Zero with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lhzux,        0x7C00026E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lhzux", "Load Halfword and Zero with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lhzx,         0x7C00022E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lhzx", "Load Halfword and Zero Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lwa,          0xE8000002, DS )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwa", "Load Word Algebraic", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lwaux,        0x7C0002EA, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwaux", "Load Word Algebraic with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lwax,         0x7C0002AA, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwax", "Load Word Algebraic Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lwz,          0x80000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwz", "Load Word and Zero", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lwzu,         0x84000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwzu", "Load Word and Zero with Udpate", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lwzux,        0x7C00006E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwzux", "Load Word and Zero with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lwzx,         0x7C00002E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwzx", "Load Word and Zero Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Integer store (A-14)
+
+XEDISASMR(stb,          0x98000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stb", "Store Byte", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stbu,         0x9C000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stbu", "Store Byte with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stbux,        0x7C0001EE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stbux", "Store Byte with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stbx,         0x7C0001AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stbx", "Store Byte Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  if (i.DS.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(std,          0xF8000000, DS )(InstrData& i, InstrDisasm& d) {
+  d.Init("std", "Store Doubleword", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kRead);
+  if (i.DS.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stdu,         0xF8000001, DS )(InstrData& i, InstrDisasm& d) {
+  d.Init("stdu", "Store Doubleword with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.DS.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.DS.DS << 2), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stdux,        0x7C00016A, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stdux", "Store Doubleword with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+    if (i.DS.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stdx,         0x7C00012A, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stdx", "Store Doubleword Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(sth,          0xB0000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sth", "Store Halfword", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(sthu,         0xB4000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sthu", "Store Halfword with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(sthux,        0x7C00036E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sthux", "Store Halfword with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(sthx,         0x7C00032E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("sth", "Store Halfword Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stw,          0x90000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stw", "Store Word", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stwu,         0x94000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stwu", "Store Word with Update", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stwux,        0x7C00016E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stwux", "Store Word with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stwx,         0x7C00012E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stwx", "Store Word Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Integer load and store with byte reverse (A-1
+
+XEDISASMR(lhbrx,        0x7C00062C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lwbrx,        0x7C00042C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(ldbrx,        0x7C000428, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(sthbrx,       0x7C00072C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stwbrx,       0x7C00052C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stdbrx,       0x7C000528, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Integer load and store multiple (A-16)
+
+XEDISASMR(lmw,          0xB8000000, D  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stmw,         0xBC000000, D  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Integer load and store string (A-17)
+
+XEDISASMR(lswi,         0x7C0004AA, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lswx,         0x7C00042A, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stswi,        0x7C0005AA, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stswx,        0x7C00052A, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Memory synchronization (A-18)
+
+XEDISASMR(eieio,        0x7C0006AC, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(isync,        0x4C00012C, XL )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(ldarx,        0x7C0000A8, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(lwarx,        0x7C000028, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lwarx", "Load Word And Reserve Indexed", 0);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stdcx,        0x7C0001AD, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(stwcx,        0x7C00012D, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stwcx", "Store Word Conditional Indexed",
+      InstrDisasm::kRc);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(sync,         0x7C0004AC, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+// Floating-point load (A-19)
+
+XEDISASMR(lfd,          0xC8000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfd", "Load Floating-Point Double", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lfdu,         0xCC000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfdu", "Load Floating-Point Double with Update", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lfdux,        0x7C0004EE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfdux", "Load Floating-Point Double with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lfdx,         0x7C0004AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfdx", "Load Floating-Point Double Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lfs,          0xC0000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfs", "Load Floating-Point Single", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lfsu,         0xC4000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfsu", "Load Floating-Point Single with Update", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(lfsux,        0x7C00046E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfsux", "Load Floating-Point Single with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(lfsx,         0x7C00042E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("lfsx", "Load Floating-Point Single Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kWrite);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Floating-point store (A-20)
+
+XEDISASMR(stfd,         0xD8000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfd", "Store Floating-Point Double", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stfdu,        0xDC000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfdu", "Store Floating-Point Double with Update", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stfdux,       0x7C0005EE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfdux", "Store Floating-Point Double with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stfdx,        0x7C0005AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfdx", "Store Floating-Point Double Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stfiwx,       0x7C0007AE, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfiwx", "Store Floating-Point as Integer Word Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stfs,         0xD0000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfs", "Store Floating-Point Single", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
+  if (i.D.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stfsu,        0xD4000000, D  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfsu", "Store Floating-Point Single with Update", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.D.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.D.RA, InstrRegister::kReadWrite);
+  d.AddSImmOperand(XEEXTS16(i.D.DS), 2);
+  return d.Finish();
+}
+
+XEDISASMR(stfsux,       0x7C00056E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfsux", "Store Floating-Point Single with Update Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kReadWrite);
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+XEDISASMR(stfsx,        0x7C00052E, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("stfsx", "Store Floating-Point Single Indexed", 0);
+  d.AddRegOperand(InstrRegister::kFPR, i.X.RT, InstrRegister::kRead);
+  if (i.X.RA) {
+    d.AddRegOperand(InstrRegister::kGPR, i.X.RA, InstrRegister::kRead);
+  } else {
+    d.AddUImmOperand(0, 1);
+  }
+  d.AddRegOperand(InstrRegister::kGPR, i.X.RB, InstrRegister::kRead);
+  return d.Finish();
+}
+
+
+// Cache management (A-27)
+
+XEDISASMR(dcbf,         0x7C0000AC, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(dcbst,        0x7C00006C, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(dcbt,         0x7C00022C, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("dcbt", "Data Cache Block Touch", 0);
+  // TODO
+  return d.Finish();
+}
+XEDISASMR(dcbt,         0x7C00022C, X  )(InstrData& i, InstrDisasm& d) {
+  // No-op for now.
+  // TODO(benvanik): use @llvm.prefetch
+  return 0;
+}
+
+XEDISASMR(dcbtst,       0x7C0001EC, X  )(InstrData& i, InstrDisasm& d) {
+  d.Init("dcbtst", "Data Cache Block Touch for Store", 0);
+  // TODO
+  return d.Finish();
+}
+XEDISASMR(dcbtst,       0x7C0001EC, X  )(InstrData& i, InstrDisasm& d) {
+  // No-op for now.
+  // TODO(benvanik): use @llvm.prefetch
+  return 0;
+}
+
+XEDISASMR(dcbz,         0x7C0007EC, X  )(InstrData& i, InstrDisasm& d) {
+  // or dcbz128 0x7C2007EC
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+XEDISASMR(icbi,         0x7C0007AC, X  )(InstrData& i, InstrDisasm& d) {
+  XEINSTRNOTIMPLEMENTED();
+  return 1;
+}
+
+
+void RegisterDisasmCategoryMemory() {
+  XEREGISTERINSTR(lbz,          0x88000000);
+  XEREGISTERINSTR(lbzu,         0x8C000000);
+  XEREGISTERINSTR(lbzux,        0x7C0000EE);
+  XEREGISTERINSTR(lbzx,         0x7C0000AE);
+  XEREGISTERINSTR(ld,           0xE8000000);
+  XEREGISTERINSTR(ldu,          0xE8000001);
+  XEREGISTERINSTR(ldux,         0x7C00006A);
+  XEREGISTERINSTR(ldx,          0x7C00002A);
+  XEREGISTERINSTR(lha,          0xA8000000);
+  XEREGISTERINSTR(lhau,         0xAC000000);
+  XEREGISTERINSTR(lhaux,        0x7C0002EE);
+  XEREGISTERINSTR(lhax,         0x7C0002AE);
+  XEREGISTERINSTR(lhz,          0xA0000000);
+  XEREGISTERINSTR(lhzu,         0xA4000000);
+  XEREGISTERINSTR(lhzux,        0x7C00026E);
+  XEREGISTERINSTR(lhzx,         0x7C00022E);
+  XEREGISTERINSTR(lwa,          0xE8000002);
+  XEREGISTERINSTR(lwaux,        0x7C0002EA);
+  XEREGISTERINSTR(lwax,         0x7C0002AA);
+  XEREGISTERINSTR(lwz,          0x80000000);
+  XEREGISTERINSTR(lwzu,         0x84000000);
+  XEREGISTERINSTR(lwzux,        0x7C00006E);
+  XEREGISTERINSTR(lwzx,         0x7C00002E);
+  XEREGISTERINSTR(stb,          0x98000000);
+  XEREGISTERINSTR(stbu,         0x9C000000);
+  XEREGISTERINSTR(stbux,        0x7C0001EE);
+  XEREGISTERINSTR(stbx,         0x7C0001AE);
+  XEREGISTERINSTR(std,          0xF8000000);
+  XEREGISTERINSTR(stdu,         0xF8000001);
+  XEREGISTERINSTR(stdux,        0x7C00016A);
+  XEREGISTERINSTR(stdx,         0x7C00012A);
+  XEREGISTERINSTR(sth,          0xB0000000);
+  XEREGISTERINSTR(sthu,         0xB4000000);
+  XEREGISTERINSTR(sthux,        0x7C00036E);
+  XEREGISTERINSTR(sthx,         0x7C00032E);
+  XEREGISTERINSTR(stw,          0x90000000);
+  XEREGISTERINSTR(stwu,         0x94000000);
+  XEREGISTERINSTR(stwux,        0x7C00016E);
+  XEREGISTERINSTR(stwx,         0x7C00012E);
+  XEREGISTERINSTR(lhbrx,        0x7C00062C);
+  XEREGISTERINSTR(lwbrx,        0x7C00042C);
+  XEREGISTERINSTR(ldbrx,        0x7C000428);
+  XEREGISTERINSTR(sthbrx,       0x7C00072C);
+  XEREGISTERINSTR(stwbrx,       0x7C00052C);
+  XEREGISTERINSTR(stdbrx,       0x7C000528);
+  XEREGISTERINSTR(lmw,          0xB8000000);
+  XEREGISTERINSTR(stmw,         0xBC000000);
+  XEREGISTERINSTR(lswi,         0x7C0004AA);
+  XEREGISTERINSTR(lswx,         0x7C00042A);
+  XEREGISTERINSTR(stswi,        0x7C0005AA);
+  XEREGISTERINSTR(stswx,        0x7C00052A);
+  XEREGISTERINSTR(eieio,        0x7C0006AC);
+  XEREGISTERINSTR(isync,        0x4C00012C);
+  XEREGISTERINSTR(ldarx,        0x7C0000A8);
+  XEREGISTERINSTR(lwarx,        0x7C000028);
+  XEREGISTERINSTR(stdcx,        0x7C0001AD);
+  XEREGISTERINSTR(stwcx,        0x7C00012D);
+  XEREGISTERINSTR(sync,         0x7C0004AC);
+  XEREGISTERINSTR(lfd,          0xC8000000);
+  XEREGISTERINSTR(lfdu,         0xCC000000);
+  XEREGISTERINSTR(lfdux,        0x7C0004EE);
+  XEREGISTERINSTR(lfdx,         0x7C0004AE);
+  XEREGISTERINSTR(lfs,          0xC0000000);
+  XEREGISTERINSTR(lfsu,         0xC4000000);
+  XEREGISTERINSTR(lfsux,        0x7C00046E);
+  XEREGISTERINSTR(lfsx,         0x7C00042E);
+  XEREGISTERINSTR(stfd,         0xD8000000);
+  XEREGISTERINSTR(stfdu,        0xDC000000);
+  XEREGISTERINSTR(stfdux,       0x7C0005EE);
+  XEREGISTERINSTR(stfdx,        0x7C0005AE);
+  XEREGISTERINSTR(stfiwx,       0x7C0007AE);
+  XEREGISTERINSTR(stfs,         0xD0000000);
+  XEREGISTERINSTR(stfsu,        0xD4000000);
+  XEREGISTERINSTR(stfsux,       0x7C00056E);
+  XEREGISTERINSTR(stfsx,        0x7C00052E);
+  XEREGISTERINSTR(dcbf,         0x7C0000AC);
+  XEREGISTERINSTR(dcbst,        0x7C00006C);
+  XEREGISTERINSTR(dcbt,         0x7C00022C);
+  XEREGISTERINSTR(dcbtst,       0x7C0001EC);
+  XEREGISTERINSTR(dcbz,         0x7C0007EC);
+  XEREGISTERINSTR(icbi,         0x7C0007AC);
+}
+
+
+}  // namespace ppc
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/ppc/sources.gypi b/src/xenia/cpu/ppc/sources.gypi
index 5a63f8d25..db3494381 100644
--- a/src/xenia/cpu/ppc/sources.gypi
+++ b/src/xenia/cpu/ppc/sources.gypi
@@ -1,6 +1,11 @@
 # Copyright 2013 Ben Vanik. All Rights Reserved.
 {
   'sources': [
+    'disasm.h',
+    'disasm_alu.cc',
+    'disasm_control.cc',
+    'disasm_fpu.cc',
+    'disasm_memory.cc',
     'instr.cc',
     'instr.h',
     'instr_tables.h',
diff --git a/src/xenia/cpu/processor.cc b/src/xenia/cpu/processor.cc
index 91673996c..01ed04460 100644
--- a/src/xenia/cpu/processor.cc
+++ b/src/xenia/cpu/processor.cc
@@ -45,6 +45,11 @@ namespace {
 
     llvm_start_multithreaded();
 
+    ppc::RegisterDisasmCategoryALU();
+    ppc::RegisterDisasmCategoryControl();
+    ppc::RegisterDisasmCategoryFPU();
+    ppc::RegisterDisasmCategoryMemory();
+
     // TODO(benvanik): only do this once
     codegen::RegisterEmitCategoryALU();
     codegen::RegisterEmitCategoryControl();