Moving alloy/ into xenia/cpu/ to start simplifying things.

src/xenia/cpu/compiler/compiler.cc

@@ -0,0 +1,49 @@
+/**
+ ******************************************************************************
+ * 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/compiler/compiler.h"
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::runtime::Runtime;
+
+Compiler::Compiler(Runtime* runtime) : runtime_(runtime) {}
+
+Compiler::~Compiler() { Reset(); }
+
+void Compiler::AddPass(std::unique_ptr<CompilerPass> pass) {
+  pass->Initialize(this);
+  passes_.push_back(std::move(pass));
+}
+
+void Compiler::Reset() {}
+
+int Compiler::Compile(HIRBuilder* builder) {
+  // TODO(benvanik): sophisticated stuff. Run passes in parallel, run until they
+  //                 stop changing things, etc.
+  for (size_t i = 0; i < passes_.size(); ++i) {
+    auto& pass = passes_[i];
+    scratch_arena_.Reset();
+    if (pass->Run(builder)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/compiler.h

@@ -0,0 +1,58 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_COMPILER_H_
+#define XENIA_COMPILER_COMPILER_H_
+
+#include <memory>
+#include <vector>
+
+#include "xenia/cpu/hir/hir_builder.h"
+#include "poly/arena.h"
+
+namespace xe {
+namespace cpu {
+namespace runtime {
+class Runtime;
+}  // namespace runtime
+}  // namespace cpu
+}  // namespace xe
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+
+class CompilerPass;
+
+class Compiler {
+ public:
+  Compiler(runtime::Runtime* runtime);
+  ~Compiler();
+
+  runtime::Runtime* runtime() const { return runtime_; }
+  poly::Arena* scratch_arena() { return &scratch_arena_; }
+
+  void AddPass(std::unique_ptr<CompilerPass> pass);
+
+  void Reset();
+
+  int Compile(hir::HIRBuilder* builder);
+
+ private:
+  runtime::Runtime* runtime_;
+  poly::Arena scratch_arena_;
+
+  std::vector<std::unique_ptr<CompilerPass>> passes_;
+};
+
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_COMPILER_H_

src/xenia/cpu/compiler/compiler_pass.cc

@@ -0,0 +1,34 @@
+/**
+ ******************************************************************************
+ * 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/compiler/compiler_pass.h"
+
+#include "xenia/cpu/compiler/compiler.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+
+CompilerPass::CompilerPass() : runtime_(0), compiler_(0) {}
+
+CompilerPass::~CompilerPass() = default;
+
+int CompilerPass::Initialize(Compiler* compiler) {
+  runtime_ = compiler->runtime();
+  compiler_ = compiler;
+  return 0;
+}
+
+poly::Arena* CompilerPass::scratch_arena() const {
+  return compiler_->scratch_arena();
+}
+
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/compiler_pass.h

@@ -0,0 +1,51 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_COMPILER_PASS_H_
+#define XENIA_COMPILER_COMPILER_PASS_H_
+
+#include "xenia/cpu/hir/hir_builder.h"
+#include "poly/arena.h"
+
+namespace xe {
+namespace cpu {
+namespace runtime {
+class Runtime;
+}  // namespace runtime
+}  // namespace cpu
+}  // namespace xe
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+
+class Compiler;
+
+class CompilerPass {
+ public:
+  CompilerPass();
+  virtual ~CompilerPass();
+
+  virtual int Initialize(Compiler* compiler);
+
+  virtual int Run(hir::HIRBuilder* builder) = 0;
+
+ protected:
+  poly::Arena* scratch_arena() const;
+
+ protected:
+  runtime::Runtime* runtime_;
+  Compiler* compiler_;
+};
+
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_COMPILER_PASS_H_

src/xenia/cpu/compiler/compiler_passes.h

@@ -0,0 +1,179 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_COMPILER_PASSES_H_
+#define XENIA_COMPILER_COMPILER_PASSES_H_
+
+#include "xenia/cpu/compiler/passes/constant_propagation_pass.h"
+#include "xenia/cpu/compiler/passes/context_promotion_pass.h"
+#include "xenia/cpu/compiler/passes/control_flow_analysis_pass.h"
+#include "xenia/cpu/compiler/passes/control_flow_simplification_pass.h"
+#include "xenia/cpu/compiler/passes/data_flow_analysis_pass.h"
+#include "xenia/cpu/compiler/passes/dead_code_elimination_pass.h"
+//#include "xenia/cpu/compiler/passes/dead_store_elimination_pass.h"
+#include "xenia/cpu/compiler/passes/finalization_pass.h"
+#include "xenia/cpu/compiler/passes/register_allocation_pass.h"
+#include "xenia/cpu/compiler/passes/simplification_pass.h"
+#include "xenia/cpu/compiler/passes/validation_pass.h"
+#include "xenia/cpu/compiler/passes/value_reduction_pass.h"
+
+// TODO:
+//   - mark_use/mark_set
+//     For now: mark_all_changed on all calls
+//     For external functions:
+//       - load_context/mark_use on all arguments
+//       - mark_set on return argument?
+//     For internal functions:
+//       - if liveness analysis already done, use that
+//       - otherwise, assume everything dirty (ACK!)
+//       - could use scanner to insert mark_use
+//
+//   Maybe:
+//   - v0.xx = load_constant <c>
+//   - v0.xx = load_zero
+//   Would prevent NULL defs on values, and make constant de-duping possible.
+//   Not sure if it's worth it, though, as the extra register allocation
+//   pressure due to de-duped constants seems like it would slow things down
+//   a lot.
+//
+//   - CFG:
+//     Blocks need predecessors()/successor()
+//     phi Instr reference
+//
+//   - block liveness tracking (in/out)
+//     Block gets:
+//       AddIncomingValue(Value* value, Block* src_block) ??
+
+// Potentially interesting passes:
+//
+// Run order:
+//   ContextPromotion
+//   Simplification
+//   ConstantPropagation
+//   TypePropagation
+//   ByteSwapElimination
+//   Simplification
+//   DeadStoreElimination
+//   DeadCodeElimination
+//
+// - TypePropagation
+//    There are many extensions/truncations in generated code right now due to
+//    various load/stores of varying widths. Being able to find and short-
+//    circuit the conversions early on would make following passes cleaner
+//    and faster as they'd have to trace through fewer value definitions.
+//    Example (after ContextPromotion):
+//      v81.i64 = load_context +88
+//      v82.i32 = truncate v81.i64
+//      v84.i32 = and v82.i32, 3F
+//      v85.i64 = zero_extend v84.i32
+//      v87.i64 = load_context +248
+//      v88.i64 = v85.i64
+//      v89.i32 = truncate v88.i64      <-- zero_extend/truncate => v84.i32
+//      v90.i32 = byte_swap v89.i32
+//      store v87.i64, v90.i32
+//    after type propagation / simplification / DCE:
+//      v81.i64 = load_context +88
+//      v82.i32 = truncate v81.i64
+//      v84.i32 = and v82.i32, 3F
+//      v87.i64 = load_context +248
+//      v90.i32 = byte_swap v84.i32
+//      store v87.i64, v90.i32
+//
+// - ByteSwapElimination
+//   Find chained byte swaps and replace with assignments. This is often found
+//   in memcpy paths.
+//   Example:
+//     v0 = load ...
+//     v1 = byte_swap v0
+//     v2 = byte_swap v1
+//     store ..., v2       <-- this could be v0
+//
+//   It may be tricky to detect, though, as often times there are intervening
+//   instructions:
+//     v21.i32 = load v20.i64
+//     v22.i32 = byte_swap v21.i32
+//     v23.i64 = zero_extend v22.i32
+//     v88.i64 = v23.i64 (from ContextPromotion)
+//     v89.i32 = truncate v88.i64
+//     v90.i32 = byte_swap v89.i32
+//     store v87.i64, v90.i32
+//   After type propagation:
+//     v21.i32 = load v20.i64
+//     v22.i32 = byte_swap v21.i32
+//     v89.i32 = v22.i32
+//     v90.i32 = byte_swap v89.i32
+//     store v87.i64, v90.i32
+//   This could ideally become:
+//     v21.i32 = load v20.i64
+//     ... (DCE takes care of this) ...
+//     store v87.i64, v21.i32
+//
+// - DeadStoreElimination
+//   Generic DSE pass, removing all redundant stores. ContextPromotion may be
+//   able to take care of most of these, as the input assembly is generally
+//   pretty optimized already. This pass would mainly be looking for introduced
+//   stores, such as those from comparisons.
+//
+//   Example:
+//   <block0>:
+//     v0 = compare_ult ...     (later removed by DCE)
+//     v1 = compare_ugt ...     (later removed by DCE)
+//     v2 = compare_eq ...
+//     store_context +300, v0   <-- removed
+//     store_context +301, v1   <-- removed
+//     store_context +302, v2   <-- removed
+//     branch_true v1, ...
+//   <block1>:
+//     v3 = compare_ult ...
+//     v4 = compare_ugt ...
+//     v5 = compare_eq ...
+//     store_context +300, v3   <-- these may be required if at end of function
+//     store_context +301, v4       or before a call
+//     store_context +302, v5
+//     branch_true v5, ...
+//
+// - X86Canonicalization
+//   For various opcodes add copies/commute the arguments to match x86
+//   operand semantics. This makes code generation easier and if done
+//   before register allocation can prevent a lot of extra shuffling in
+//   the emitted code.
+//
+//   Example:
+//   <block0>:
+//     v0 = ...
+//     v1 = ...
+//     v2 = add v0, v1          <-- v1 now unused
+//   Becomes:
+//     v0 = ...
+//     v1 = ...
+//     v1 = add v1, v0          <-- src1 = dest/src, so reuse for both
+//                                  by commuting and setting dest = src1
+//
+// - RegisterAllocation
+//   Given a machine description (register classes, counts) run over values
+//   and assign them to registers, adding spills as needed. It should be
+//   possible to directly emit code from this form.
+//
+//   Example:
+//   <block0>:
+//     v0 = load_context +0
+//     v1 = load_context +1
+//     v0 = add v0, v1
+//     ...
+//     v2 = mul v0, v1
+//   Becomes:
+//     reg0 = load_context +0
+//     reg1 = load_context +1
+//     reg2 = add reg0, reg1
+//     store_local +123, reg2  <-- spill inserted
+//     ...
+//     reg0 = load_local +123  <-- load inserted
+//     reg0 = mul reg0, reg1
+
+#endif  // XENIA_COMPILER_COMPILER_PASSES_H_

src/xenia/cpu/compiler/passes/constant_propagation_pass.cc

@@ -0,0 +1,489 @@
+/**
+ ******************************************************************************
+ * 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/compiler/passes/constant_propagation_pass.h"
+
+#include "xenia/cpu/runtime/function.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::TypeName;
+using xe::cpu::hir::Value;
+
+ConstantPropagationPass::ConstantPropagationPass() : CompilerPass() {}
+
+ConstantPropagationPass::~ConstantPropagationPass() {}
+
+int ConstantPropagationPass::Run(HIRBuilder* builder) {
+  // Once ContextPromotion has run there will likely be a whole slew of
+  // constants that can be pushed through the function.
+  // Example:
+  //   store_context +100, 1000
+  //   v0 = load_context +100
+  //   v1 = add v0, v0
+  //   store_context +200, v1
+  // after PromoteContext:
+  //   store_context +100, 1000
+  //   v0 = 1000
+  //   v1 = add v0, v0
+  //   store_context +200, v1
+  // after PropagateConstants:
+  //   store_context +100, 1000
+  //   v0 = 1000
+  //   v1 = add 1000, 1000
+  //   store_context +200, 2000
+  // A DCE run after this should clean up any of the values no longer needed.
+  //
+  // Special care needs to be taken with paired instructions. For example,
+  // DID_CARRY needs to be set as a constant:
+  //   v1 = sub.2 20, 1
+  //   v2 = did_carry v1
+  // should become:
+  //   v1 = 19
+  //   v2 = 0
+
+  auto block = builder->first_block();
+  while (block) {
+    auto i = block->instr_head;
+    while (i) {
+      auto v = i->dest;
+      switch (i->opcode->num) {
+        case OPCODE_DEBUG_BREAK_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              i->Replace(&OPCODE_DEBUG_BREAK_info, i->flags);
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+
+        case OPCODE_TRAP_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              i->Replace(&OPCODE_TRAP_info, i->flags);
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+
+        case OPCODE_CALL_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              auto symbol_info = i->src2.symbol_info;
+              i->Replace(&OPCODE_CALL_info, i->flags);
+              i->src1.symbol_info = symbol_info;
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+        case OPCODE_CALL_INDIRECT:
+          if (i->src1.value->IsConstant()) {
+            runtime::FunctionInfo* symbol_info;
+            if (runtime_->LookupFunctionInfo(
+                    (uint32_t)i->src1.value->constant.i32, &symbol_info)) {
+              break;
+            }
+            i->Replace(&OPCODE_CALL_info, i->flags);
+            i->src1.symbol_info = symbol_info;
+          }
+          break;
+        case OPCODE_CALL_INDIRECT_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              auto value = i->src2.value;
+              i->Replace(&OPCODE_CALL_INDIRECT_info, i->flags);
+              i->set_src1(value);
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+
+        case OPCODE_BRANCH_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              auto label = i->src2.label;
+              i->Replace(&OPCODE_BRANCH_info, i->flags);
+              i->src1.label = label;
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+        case OPCODE_BRANCH_FALSE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantFalse()) {
+              auto label = i->src2.label;
+              i->Replace(&OPCODE_BRANCH_info, i->flags);
+              i->src1.label = label;
+            } else {
+              i->Remove();
+            }
+          }
+          break;
+
+        case OPCODE_CAST:
+          if (i->src1.value->IsConstant()) {
+            TypeName target_type = v->type;
+            v->set_from(i->src1.value);
+            v->Cast(target_type);
+            i->Remove();
+          }
+          break;
+        case OPCODE_ZERO_EXTEND:
+          if (i->src1.value->IsConstant()) {
+            TypeName target_type = v->type;
+            v->set_from(i->src1.value);
+            v->ZeroExtend(target_type);
+            i->Remove();
+          }
+          break;
+        case OPCODE_SIGN_EXTEND:
+          if (i->src1.value->IsConstant()) {
+            TypeName target_type = v->type;
+            v->set_from(i->src1.value);
+            v->SignExtend(target_type);
+            i->Remove();
+          }
+          break;
+        case OPCODE_TRUNCATE:
+          if (i->src1.value->IsConstant()) {
+            TypeName target_type = v->type;
+            v->set_from(i->src1.value);
+            v->Truncate(target_type);
+            i->Remove();
+          }
+          break;
+
+        case OPCODE_SELECT:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              v->set_from(i->src2.value);
+            } else {
+              v->set_from(i->src3.value);
+            }
+            i->Remove();
+          }
+          break;
+        case OPCODE_IS_TRUE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantTrue()) {
+              v->set_constant((int8_t)1);
+            } else {
+              v->set_constant((int8_t)0);
+            }
+            i->Remove();
+          }
+          break;
+        case OPCODE_IS_FALSE:
+          if (i->src1.value->IsConstant()) {
+            if (i->src1.value->IsConstantFalse()) {
+              v->set_constant((int8_t)1);
+            } else {
+              v->set_constant((int8_t)0);
+            }
+            i->Remove();
+          }
+          break;
+
+        // TODO(benvanik): compares
+        case OPCODE_COMPARE_EQ:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantEQ(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_NE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantNE(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_SLT:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantSLT(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_SLE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantSLE(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_SGT:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantSGT(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_SGE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantSGE(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_ULT:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantULT(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_ULE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantULE(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_UGT:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantUGT(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_COMPARE_UGE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            bool value = i->src1.value->IsConstantUGE(i->src2.value);
+            i->dest->set_constant(value);
+            i->Remove();
+          }
+          break;
+
+        case OPCODE_DID_CARRY:
+          assert_true(!i->src1.value->IsConstant());
+          break;
+        case OPCODE_DID_OVERFLOW:
+          assert_true(!i->src1.value->IsConstant());
+          break;
+        case OPCODE_DID_SATURATE:
+          assert_true(!i->src1.value->IsConstant());
+          break;
+
+        case OPCODE_ADD:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            bool did_carry = v->Add(i->src2.value);
+            bool propagate_carry = !!(i->flags & ARITHMETIC_SET_CARRY);
+            i->Remove();
+
+            // If carry is set find the DID_CARRY and fix it.
+            if (propagate_carry) {
+              PropagateCarry(v, did_carry);
+            }
+          }
+          break;
+        // TODO(benvanik): ADD_CARRY (w/ ARITHMETIC_SET_CARRY)
+        case OPCODE_ADD_CARRY:
+          if (i->src1.value->IsConstantZero() &&
+              i->src2.value->IsConstantZero()) {
+            Value* ca = i->src3.value;
+            // If carry is set find the DID_CARRY and fix it.
+            if (!!(i->flags & ARITHMETIC_SET_CARRY)) {
+              auto next = i->dest->use_head;
+              while (next) {
+                auto use = next;
+                next = use->next;
+                if (use->instr->opcode == &OPCODE_DID_CARRY_info) {
+                  // Replace carry value.
+                  use->instr->Replace(&OPCODE_ASSIGN_info, 0);
+                  use->instr->set_src1(ca);
+                }
+              }
+            }
+            if (i->dest->type == ca->type) {
+              i->Replace(&OPCODE_ASSIGN_info, 0);
+              i->set_src1(ca);
+            } else {
+              i->Replace(&OPCODE_ZERO_EXTEND_info, 0);
+              i->set_src1(ca);
+            }
+          }
+          break;
+        case OPCODE_SUB:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            bool did_carry = v->Sub(i->src2.value);
+            bool propagate_carry = !!(i->flags & ARITHMETIC_SET_CARRY);
+            i->Remove();
+
+            // If carry is set find the DID_CARRY and fix it.
+            if (propagate_carry) {
+              PropagateCarry(v, did_carry);
+            }
+          }
+          break;
+        case OPCODE_MUL:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Mul(i->src2.value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_DIV:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Div(i->src2.value);
+            i->Remove();
+          }
+          break;
+        // case OPCODE_MUL_ADD:
+        // case OPCODE_MUL_SUB
+        case OPCODE_NEG:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Neg();
+            i->Remove();
+          }
+          break;
+        case OPCODE_ABS:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Abs();
+            i->Remove();
+          }
+          break;
+        case OPCODE_SQRT:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Sqrt();
+            i->Remove();
+          }
+          break;
+        case OPCODE_RSQRT:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->RSqrt();
+            i->Remove();
+          }
+          break;
+
+        case OPCODE_AND:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->And(i->src2.value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_OR:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Or(i->src2.value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_XOR:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Xor(i->src2.value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_NOT:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Not();
+            i->Remove();
+          }
+          break;
+        case OPCODE_SHL:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Shl(i->src2.value);
+            i->Remove();
+          }
+          break;
+        // TODO(benvanik): VECTOR_SHL
+        case OPCODE_SHR:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Shr(i->src2.value);
+            i->Remove();
+          }
+          break;
+        case OPCODE_SHA:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->Sha(i->src2.value);
+            i->Remove();
+          }
+          break;
+        // TODO(benvanik): ROTATE_LEFT
+        case OPCODE_BYTE_SWAP:
+          if (i->src1.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            v->ByteSwap();
+            i->Remove();
+          }
+          break;
+        case OPCODE_CNTLZ:
+          if (i->src1.value->IsConstant()) {
+            v->set_zero(v->type);
+            v->CountLeadingZeros(i->src1.value);
+            i->Remove();
+          }
+          break;
+        // TODO(benvanik): INSERT/EXTRACT
+        // TODO(benvanik): SPLAT/PERMUTE/SWIZZLE
+        case OPCODE_SPLAT:
+          if (i->src1.value->IsConstant()) {
+            // Quite a few of these, from building vec128s.
+          }
+          break;
+
+        default:
+          // Ignored.
+          break;
+      }
+      i = i->next;
+    }
+
+    block = block->next;
+  }
+
+  return 0;
+}
+
+void ConstantPropagationPass::PropagateCarry(Value* v, bool did_carry) {
+  auto next = v->use_head;
+  while (next) {
+    auto use = next;
+    next = use->next;
+    if (use->instr->opcode == &OPCODE_DID_CARRY_info) {
+      // Replace carry value.
+      use->instr->dest->set_constant(did_carry ? 1 : 0);
+      use->instr->Remove();
+    }
+  }
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/constant_propagation_pass.h

@@ -0,0 +1,36 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_PASSES_CONSTANT_PROPAGATION_PASS_H_
+#define XENIA_COMPILER_PASSES_CONSTANT_PROPAGATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ConstantPropagationPass : public CompilerPass {
+ public:
+  ConstantPropagationPass();
+  ~ConstantPropagationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  void PropagateCarry(hir::Value* v, bool did_carry);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_CONSTANT_PROPAGATION_PASS_H_

src/xenia/cpu/compiler/passes/context_promotion_pass.cc

@@ -0,0 +1,150 @@
+/**
+ ******************************************************************************
+ * 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/compiler/passes/context_promotion_pass.h"
+
+#include <gflags/gflags.h>
+
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+DEFINE_bool(store_all_context_values, false,
+            "Don't strip dead context stores to aid in debugging.");
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::frontend::ContextInfo;
+using xe::cpu::hir::Block;
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::Value;
+
+ContextPromotionPass::ContextPromotionPass() : CompilerPass() {}
+
+ContextPromotionPass::~ContextPromotionPass() {}
+
+int ContextPromotionPass::Initialize(Compiler* compiler) {
+  if (CompilerPass::Initialize(compiler)) {
+    return 1;
+  }
+
+  // This is a terrible implementation.
+  ContextInfo* context_info = runtime_->frontend()->context_info();
+  context_values_.resize(context_info->size());
+  context_validity_.resize(static_cast<uint32_t>(context_info->size()));
+
+  return 0;
+}
+
+int ContextPromotionPass::Run(HIRBuilder* builder) {
+  // Like mem2reg, but because context memory is unaliasable it's easier to
+  // check and convert LoadContext/StoreContext into value operations.
+  // Example of load->value promotion:
+  //   v0 = load_context +100
+  //   store_context +200, v0
+  //   v1 = load_context +100  <-- replace with v1 = v0
+  //   store_context +200, v1
+  //
+  // It'd be possible in this stage to also remove redundant context stores:
+  // Example of dead store elimination:
+  //   store_context +100, v0  <-- removed due to following store
+  //   store_context +100, v1
+  // This is more generally done by DSE, however if it could be done here
+  // instead as it may be faster (at least on the block-level).
+
+  // Promote loads to values.
+  // Process each block independently, for now.
+  auto block = builder->first_block();
+  while (block) {
+    PromoteBlock(block);
+    block = block->next;
+  }
+
+  // Remove all dead stores.
+  if (!FLAGS_store_all_context_values) {
+    block = builder->first_block();
+    while (block) {
+      RemoveDeadStoresBlock(block);
+      block = block->next;
+    }
+  }
+
+  return 0;
+}
+
+void ContextPromotionPass::PromoteBlock(Block* block) {
+  auto& validity = context_validity_;
+  validity.reset();
+
+  Instr* i = block->instr_head;
+  while (i) {
+    auto next = i->next;
+    if (i->opcode->flags & OPCODE_FLAG_VOLATILE) {
+      // Volatile instruction - requires all context values be flushed.
+      validity.reset();
+    } else if (i->opcode == &OPCODE_LOAD_CONTEXT_info) {
+      size_t offset = i->src1.offset;
+      if (validity.test(static_cast<uint32_t>(offset))) {
+        // Legit previous value, reuse.
+        Value* previous_value = context_values_[offset];
+        i->opcode = &hir::OPCODE_ASSIGN_info;
+        i->set_src1(previous_value);
+      } else {
+        // Store the loaded value into the table.
+        context_values_[offset] = i->dest;
+        validity.set(static_cast<uint32_t>(offset));
+      }
+    } else if (i->opcode == &OPCODE_STORE_CONTEXT_info) {
+      size_t offset = i->src1.offset;
+      Value* value = i->src2.value;
+      // Store value into the table for later.
+      context_values_[offset] = value;
+      validity.set(static_cast<uint32_t>(offset));
+    }
+    i = next;
+  }
+}
+
+void ContextPromotionPass::RemoveDeadStoresBlock(Block* block) {
+  auto& validity = context_validity_;
+  validity.reset();
+
+  // Walk backwards and mark offsets that are written to.
+  // If the offset was written to earlier, ignore the store.
+  Instr* i = block->instr_tail;
+  while (i) {
+    Instr* prev = i->prev;
+    if (i->opcode->flags & (OPCODE_FLAG_VOLATILE | OPCODE_FLAG_BRANCH)) {
+      // Volatile instruction - requires all context values be flushed.
+      validity.reset();
+    } else if (i->opcode == &OPCODE_STORE_CONTEXT_info) {
+      size_t offset = i->src1.offset;
+      if (!validity.test(static_cast<uint32_t>(offset))) {
+        // Offset not yet written, mark and continue.
+        validity.set(static_cast<uint32_t>(offset));
+      } else {
+        // Already written to. Remove this store.
+        i->Remove();
+      }
+    }
+    i = prev;
+  }
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/context_promotion_pass.h

@@ -0,0 +1,54 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_PASSES_CONTEXT_PROMOTION_PASS_H_
+#define XENIA_COMPILER_PASSES_CONTEXT_PROMOTION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+#if XE_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4267)
+#include <llvm/ADT/BitVector.h>
+#pragma warning(pop)
+#else
+#include <cmath>
+#include <llvm/ADT/BitVector.h>
+#endif  // XE_COMPILER_MSVC
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ContextPromotionPass : public CompilerPass {
+ public:
+  ContextPromotionPass();
+  virtual ~ContextPromotionPass() override;
+
+  int Initialize(Compiler* compiler) override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  void PromoteBlock(hir::Block* block);
+  void RemoveDeadStoresBlock(hir::Block* block);
+
+ private:
+  std::vector<hir::Value*> context_values_;
+  llvm::BitVector context_validity_;
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_CONTEXT_PROMOTION_PASS_H_

src/xenia/cpu/compiler/passes/control_flow_analysis_pass.cc

@@ -0,0 +1,80 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/control_flow_analysis_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::Edge;
+using xe::cpu::hir::HIRBuilder;
+
+ControlFlowAnalysisPass::ControlFlowAnalysisPass() : CompilerPass() {}
+
+ControlFlowAnalysisPass::~ControlFlowAnalysisPass() {}
+
+int ControlFlowAnalysisPass::Run(HIRBuilder* builder) {
+  // Reset edges for all blocks. Needed to be re-runnable.
+  // Note that this wastes a bunch of arena memory, so we shouldn't
+  // re-run too often.
+  auto block = builder->first_block();
+  while (block) {
+    block->incoming_edge_head = nullptr;
+    block->outgoing_edge_head = nullptr;
+    block = block->next;
+  }
+
+  // Add edges.
+  block = builder->first_block();
+  while (block) {
+    auto instr = block->instr_tail;
+    while (instr) {
+      if ((instr->opcode->flags & OPCODE_FLAG_BRANCH) == 0) {
+        break;
+      }
+      if (instr->opcode == &OPCODE_BRANCH_info) {
+        auto label = instr->src1.label;
+        builder->AddEdge(block, label->block, Edge::UNCONDITIONAL);
+      } else if (instr->opcode == &OPCODE_BRANCH_TRUE_info ||
+                 instr->opcode == &OPCODE_BRANCH_FALSE_info) {
+        auto label = instr->src2.label;
+        builder->AddEdge(block, label->block, 0);
+      }
+      instr = instr->prev;
+    }
+    block = block->next;
+  }
+
+  // Mark dominators.
+  block = builder->first_block();
+  while (block) {
+    if (block->incoming_edge_head &&
+        !block->incoming_edge_head->incoming_next) {
+      block->incoming_edge_head->flags |= Edge::DOMINATES;
+    }
+    block = block->next;
+  }
+
+  return 0;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/control_flow_analysis_pass.h

@@ -0,0 +1,35 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_CONTROL_FLOW_ANALYSIS_PASS_H_
+#define XENIA_COMPILER_PASSES_CONTROL_FLOW_ANALYSIS_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ControlFlowAnalysisPass : public CompilerPass {
+ public:
+  ControlFlowAnalysisPass();
+  ~ControlFlowAnalysisPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_CONTROL_FLOW_ANALYSIS_PASS_H_

src/xenia/cpu/compiler/passes/control_flow_simplification_pass.cc

@@ -0,0 +1,61 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/control_flow_simplification_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::Edge;
+using xe::cpu::hir::HIRBuilder;
+
+ControlFlowSimplificationPass::ControlFlowSimplificationPass()
+    : CompilerPass() {}
+
+ControlFlowSimplificationPass::~ControlFlowSimplificationPass() {}
+
+int ControlFlowSimplificationPass::Run(HIRBuilder* builder) {
+  // Walk backwards and merge blocks if possible.
+  bool merged_any = false;
+  auto block = builder->last_block();
+  while (block) {
+    auto prev_block = block->prev;
+    const uint32_t expected = Edge::DOMINATES | Edge::UNCONDITIONAL;
+    if (block->incoming_edge_head &&
+        (block->incoming_edge_head->flags & expected) == expected) {
+      // Dominated by the incoming block.
+      // If that block comes immediately before us then we can merge the
+      // two blocks (assuming it's not a volatile instruction like Trap).
+      if (block->prev == block->incoming_edge_head->src &&
+          block->prev->instr_tail &&
+          !(block->prev->instr_tail->opcode->flags & OPCODE_FLAG_VOLATILE)) {
+        builder->MergeAdjacentBlocks(block->prev, block);
+        merged_any = true;
+      }
+    }
+    block = prev_block;
+  }
+
+  return 0;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/control_flow_simplification_pass.h

@@ -0,0 +1,35 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_CONTROL_FLOW_SIMPLIFICATION_PASS_H_
+#define XENIA_COMPILER_PASSES_CONTROL_FLOW_SIMPLIFICATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ControlFlowSimplificationPass : public CompilerPass {
+ public:
+  ControlFlowSimplificationPass();
+  ~ControlFlowSimplificationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_CONTROL_FLOW_SIMPLIFICATION_PASS_H_

src/xenia/cpu/compiler/passes/data_flow_analysis_pass.cc

@@ -0,0 +1,211 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/data_flow_analysis_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+#if XE_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4267)
+#include <llvm/ADT/BitVector.h>
+#pragma warning(pop)
+#else
+#include <llvm/ADT/BitVector.h>
+#endif  // XE_COMPILER_MSVC
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::OpcodeSignatureType;
+using xe::cpu::hir::Value;
+
+DataFlowAnalysisPass::DataFlowAnalysisPass() : CompilerPass() {}
+
+DataFlowAnalysisPass::~DataFlowAnalysisPass() {}
+
+int DataFlowAnalysisPass::Run(HIRBuilder* builder) {
+  // Linearize blocks so that we can detect cycles and propagate dependencies.
+  uint32_t block_count = LinearizeBlocks(builder);
+
+  // Analyze value flow and add locals as needed.
+  AnalyzeFlow(builder, block_count);
+
+  return 0;
+}
+
+uint32_t DataFlowAnalysisPass::LinearizeBlocks(HIRBuilder* builder) {
+  // TODO(benvanik): actually do this - we cheat now knowing that they are in
+  //     sequential order.
+  uint32_t block_ordinal = 0;
+  auto block = builder->first_block();
+  while (block) {
+    block->ordinal = block_ordinal++;
+    block = block->next;
+  }
+  return block_ordinal;
+}
+
+void DataFlowAnalysisPass::AnalyzeFlow(HIRBuilder* builder,
+                                       uint32_t block_count) {
+  uint32_t max_value_estimate =
+      builder->max_value_ordinal() + 1 + block_count * 4;
+
+  // Stash for value map. We may want to maintain this during building.
+  auto arena = builder->arena();
+  Value** value_map =
+      (Value**)arena->Alloc(sizeof(Value*) * max_value_estimate);
+
+  // Allocate incoming bitvectors for use by blocks. We don't need outgoing
+  // because they are only used during the block iteration.
+  // Mapped by block ordinal.
+  // TODO(benvanik): cache this list, grow as needed, etc.
+  auto incoming_bitvectors =
+      (llvm::BitVector**)arena->Alloc(sizeof(llvm::BitVector*) * block_count);
+  for (auto n = 0u; n < block_count; n++) {
+    incoming_bitvectors[n] = new llvm::BitVector(max_value_estimate);
+  }
+
+  // Walk blocks in reverse and calculate incoming/outgoing values.
+  auto block = builder->last_block();
+  while (block) {
+    // Allocate bitsets based on max value number.
+    block->incoming_values = incoming_bitvectors[block->ordinal];
+    auto& incoming_values = *block->incoming_values;
+
+    // Walk instructions and gather up incoming values.
+    auto instr = block->instr_head;
+    while (instr) {
+      uint32_t signature = instr->opcode->signature;
+#define SET_INCOMING_VALUE(v)                   \
+  if (v->def && v->def->block != block) {       \
+    incoming_values.set(v->ordinal);            \
+  }                                             \
+  assert_true(v->ordinal < max_value_estimate); \
+  value_map[v->ordinal] = v;
+      if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
+        SET_INCOMING_VALUE(instr->src1.value);
+      }
+      if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
+        SET_INCOMING_VALUE(instr->src2.value);
+      }
+      if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
+        SET_INCOMING_VALUE(instr->src3.value);
+      }
+#undef SET_INCOMING_VALUE
+      instr = instr->next;
+    }
+
+    // Add all successor incoming values to our outgoing, as we need to
+    // pass them through.
+    llvm::BitVector outgoing_values(max_value_estimate);
+    auto outgoing_edge = block->outgoing_edge_head;
+    while (outgoing_edge) {
+      if (outgoing_edge->dest->ordinal > block->ordinal) {
+        outgoing_values |= *outgoing_edge->dest->incoming_values;
+      }
+      outgoing_edge = outgoing_edge->outgoing_next;
+    }
+    incoming_values |= outgoing_values;
+
+    // Add stores for all outgoing values.
+    auto outgoing_ordinal = outgoing_values.find_first();
+    while (outgoing_ordinal != -1) {
+      Value* src_value = value_map[outgoing_ordinal];
+      assert_not_null(src_value);
+      if (!src_value->local_slot) {
+        src_value->local_slot = builder->AllocLocal(src_value->type);
+      }
+      builder->StoreLocal(src_value->local_slot, src_value);
+
+      // If we are in the block the value was defined in:
+      if (src_value->def->block == block) {
+        // Move the store to right after the def, or as soon after
+        // as we can (respecting PAIRED flags).
+        auto def_next = src_value->def->next;
+        while (def_next && def_next->opcode->flags & OPCODE_FLAG_PAIRED_PREV) {
+          def_next = def_next->next;
+        }
+        assert_not_null(def_next);
+        builder->last_instr()->MoveBefore(def_next);
+
+        // We don't need it in the incoming list.
+        incoming_values.reset(outgoing_ordinal);
+      } else {
+        // Eh, just throw at the end, before the first branch.
+        auto tail = block->instr_tail;
+        while (tail && tail->opcode->flags & OPCODE_FLAG_BRANCH) {
+          tail = tail->prev;
+        }
+        assert_not_zero(tail);
+        builder->last_instr()->MoveBefore(tail->next);
+      }
+
+      outgoing_ordinal = outgoing_values.find_next(outgoing_ordinal);
+    }
+
+    // Add loads for all incoming values and rename them in the block.
+    auto incoming_ordinal = incoming_values.find_first();
+    while (incoming_ordinal != -1) {
+      Value* src_value = value_map[incoming_ordinal];
+      assert_not_null(src_value);
+      if (!src_value->local_slot) {
+        src_value->local_slot = builder->AllocLocal(src_value->type);
+      }
+      Value* local_value = builder->LoadLocal(src_value->local_slot);
+      builder->last_instr()->MoveBefore(block->instr_head);
+
+      // Swap uses of original value with the local value.
+      instr = block->instr_head;
+      while (instr) {
+        uint32_t signature = instr->opcode->signature;
+        if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
+          if (instr->src1.value == src_value) {
+            instr->set_src1(local_value);
+          }
+        }
+        if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
+          if (instr->src2.value == src_value) {
+            instr->set_src2(local_value);
+          }
+        }
+        if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
+          if (instr->src3.value == src_value) {
+            instr->set_src3(local_value);
+          }
+        }
+        instr = instr->next;
+      }
+
+      incoming_ordinal = incoming_values.find_next(incoming_ordinal);
+    }
+
+    block = block->prev;
+  }
+
+  // Cleanup bitvectors.
+  for (auto n = 0u; n < block_count; n++) {
+    delete incoming_bitvectors[n];
+  }
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/data_flow_analysis_pass.h

@@ -0,0 +1,37 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_DATA_FLOW_ANALYSIS_PASS_H_
+#define XENIA_COMPILER_PASSES_DATA_FLOW_ANALYSIS_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class DataFlowAnalysisPass : public CompilerPass {
+ public:
+  DataFlowAnalysisPass();
+  ~DataFlowAnalysisPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  uint32_t LinearizeBlocks(hir::HIRBuilder* builder);
+  void AnalyzeFlow(hir::HIRBuilder* builder, uint32_t block_count);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_DATA_FLOW_ANALYSIS_PASS_H_

src/xenia/cpu/compiler/passes/dead_code_elimination_pass.cc

@@ -0,0 +1,218 @@
+/**
+ ******************************************************************************
+ * 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/compiler/passes/dead_code_elimination_pass.h"
+
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::Value;
+
+DeadCodeEliminationPass::DeadCodeEliminationPass() : CompilerPass() {}
+
+DeadCodeEliminationPass::~DeadCodeEliminationPass() {}
+
+int DeadCodeEliminationPass::Run(HIRBuilder* builder) {
+  // ContextPromotion/DSE will likely leave around a lot of dead statements.
+  // Code generated for comparison/testing produces many unused statements and
+  // with proper use analysis it should be possible to remove most of them:
+  // After context promotion/simplification:
+  //   v33.i8 = compare_ult v31.i32, 0
+  //   v34.i8 = compare_ugt v31.i32, 0
+  //   v35.i8 = compare_eq v31.i32, 0
+  //   store_context +300, v33.i8
+  //   store_context +301, v34.i8
+  //   store_context +302, v35.i8
+  //   branch_true v35.i8, loc_8201A484
+  // After DSE:
+  //   v33.i8 = compare_ult v31.i32, 0
+  //   v34.i8 = compare_ugt v31.i32, 0
+  //   v35.i8 = compare_eq v31.i32, 0
+  //   branch_true v35.i8, loc_8201A484
+  // After DCE:
+  //   v35.i8 = compare_eq v31.i32, 0
+  //   branch_true v35.i8, loc_8201A484
+
+  // This also removes useless ASSIGNs:
+  //   v1 = v0
+  //   v2 = add v1, v1
+  // becomes:
+  //   v2 = add v0, v0
+
+  // We process DCE by reverse iterating over instructions and looking at the
+  // use count of the dest value. If it's zero, we can safely remove the
+  // instruction. Once we do that, the use counts of any of the src ops may
+  // go to zero and we recursively kill up the graph. This is kind of
+  // nasty in that we walk randomly and scribble all over memory, but (I think)
+  // it's better than doing passes over all instructions until we quiesce.
+  // To prevent our iteration from getting all messed up we just replace
+  // all removed ops with NOP and then do a single pass that removes them
+  // all.
+
+  bool any_instr_removed = false;
+  bool any_locals_removed = false;
+  auto block = builder->first_block();
+  while (block) {
+    // Walk instructions in reverse.
+    Instr* i = block->instr_tail;
+    while (i) {
+      auto prev = i->prev;
+
+      auto opcode = i->opcode;
+      if (!(opcode->flags & OPCODE_FLAG_VOLATILE) && i->dest &&
+          !i->dest->use_head) {
+        // Has no uses and is not volatile. This instruction can die!
+        MakeNopRecursive(i);
+        any_instr_removed = true;
+      } else if (opcode == &OPCODE_ASSIGN_info) {
+        // Assignment. These are useless, so just try to remove by completely
+        // replacing the value.
+        ReplaceAssignment(i);
+      }
+
+      i = prev;
+    }
+
+    // Walk instructions forward.
+    i = block->instr_head;
+    while (i) {
+      auto next = i->next;
+
+      auto opcode = i->opcode;
+      if (opcode == &OPCODE_STORE_LOCAL_info) {
+        // Check to see if the store has any interceeding uses after the load.
+        // If not, it can be removed (as the local is just passing through the
+        // function).
+        // We do this after the previous pass so that removed code doesn't keep
+        // the local alive.
+        if (!CheckLocalUse(i)) {
+          any_locals_removed = true;
+        }
+      }
+
+      i = next;
+    }
+
+    block = block->next;
+  }
+
+  // Remove all nops.
+  if (any_instr_removed) {
+    block = builder->first_block();
+    while (block) {
+      Instr* i = block->instr_head;
+      while (i) {
+        Instr* next = i->next;
+        if (i->opcode == &OPCODE_NOP_info) {
+          // Nop - remove!
+          i->Remove();
+        }
+        i = next;
+      }
+      block = block->next;
+    }
+  }
+
+  // Remove any locals that no longer have uses.
+  if (any_locals_removed) {
+    // TODO(benvanik): local removal/dealloc.
+    auto locals = builder->locals();
+    for (auto it = locals.begin(); it != locals.end();) {
+      auto next = ++it;
+      auto value = *it;
+      if (!value->use_head) {
+        // Unused, can be removed.
+        locals.erase(it);
+      }
+      it = next;
+    }
+  }
+
+  return 0;
+}
+
+void DeadCodeEliminationPass::MakeNopRecursive(Instr* i) {
+  i->opcode = &hir::OPCODE_NOP_info;
+  i->dest->def = NULL;
+  i->dest = NULL;
+
+#define MAKE_NOP_SRC(n)                                  \
+  if (i->src##n##_use) {                                 \
+    Value::Use* use = i->src##n##_use;                   \
+    Value* value = i->src##n.value;                      \
+    i->src##n##_use = NULL;                              \
+    i->src##n.value = NULL;                              \
+    value->RemoveUse(use);                               \
+    if (!value->use_head) {                              \
+      /* Value is now unused, so recursively kill it. */ \
+      if (value->def && value->def != i) {               \
+        MakeNopRecursive(value->def);                    \
+      }                                                  \
+    }                                                    \
+  }
+  MAKE_NOP_SRC(1);
+  MAKE_NOP_SRC(2);
+  MAKE_NOP_SRC(3);
+}
+
+void DeadCodeEliminationPass::ReplaceAssignment(Instr* i) {
+  auto src = i->src1.value;
+  auto dest = i->dest;
+
+  auto use = dest->use_head;
+  while (use) {
+    auto use_instr = use->instr;
+    if (use_instr->src1.value == dest) {
+      use_instr->set_src1(src);
+    }
+    if (use_instr->src2.value == dest) {
+      use_instr->set_src2(src);
+    }
+    if (use_instr->src3.value == dest) {
+      use_instr->set_src3(src);
+    }
+    use = use->next;
+  }
+
+  i->Remove();
+}
+
+bool DeadCodeEliminationPass::CheckLocalUse(Instr* i) {
+  auto src = i->src2.value;
+
+  auto use = src->use_head;
+  if (use) {
+    auto use_instr = use->instr;
+    if (use_instr->opcode != &OPCODE_LOAD_LOCAL_info) {
+      // A valid use (probably). Keep it.
+      return true;
+    }
+
+    // Load/store are paired. They can both be removed.
+    use_instr->Remove();
+  }
+
+  i->Remove();
+
+  return false;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/dead_code_elimination_pass.h

@@ -0,0 +1,38 @@
+/**
+ ******************************************************************************
+ * 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_COMPILER_PASSES_DEAD_CODE_ELIMINATION_PASS_H_
+#define XENIA_COMPILER_PASSES_DEAD_CODE_ELIMINATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class DeadCodeEliminationPass : public CompilerPass {
+ public:
+  DeadCodeEliminationPass();
+  ~DeadCodeEliminationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  void MakeNopRecursive(hir::Instr* i);
+  void ReplaceAssignment(hir::Instr* i);
+  bool CheckLocalUse(hir::Instr* i);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_DEAD_CODE_ELIMINATION_PASS_H_

src/xenia/cpu/compiler/passes/finalization_pass.cc

@@ -0,0 +1,74 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/finalization_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+
+FinalizationPass::FinalizationPass() : CompilerPass() {}
+
+FinalizationPass::~FinalizationPass() {}
+
+int FinalizationPass::Run(HIRBuilder* builder) {
+  // Process the HIR and prepare it for lowering.
+  // After this is done the HIR should be ready for emitting.
+
+  auto arena = builder->arena();
+
+  uint32_t block_ordinal = 0;
+  auto block = builder->first_block();
+  while (block) {
+    block->ordinal = block_ordinal++;
+
+    // Ensure all labels have names.
+    auto label = block->label_head;
+    while (label) {
+      if (!label->name) {
+        const size_t label_len = 6 + 4 + 1;
+        char* name = (char*)arena->Alloc(label_len);
+        snprintf(name, label_len, "_label%d", label->id);
+        label->name = name;
+      }
+      label = label->next;
+    }
+
+    // Remove unneeded jumps.
+    auto tail = block->instr_tail;
+    if (tail && tail->opcode == &OPCODE_BRANCH_info) {
+      // Jump. Check target.
+      auto target = tail->src1.label;
+      if (target->block == block->next) {
+        // Jumping to subsequent block. Remove.
+        tail->Remove();
+      }
+    }
+
+    block = block->next;
+  }
+
+  return 0;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/finalization_pass.h

@@ -0,0 +1,35 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_FINALIZATION_PASS_H_
+#define XENIA_COMPILER_PASSES_FINALIZATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class FinalizationPass : public CompilerPass {
+ public:
+  FinalizationPass();
+  ~FinalizationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_FINALIZATION_PASS_H_

src/xenia/cpu/compiler/passes/register_allocation_pass.cc

@@ -0,0 +1,564 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/register_allocation_pass.h"
+
+#include <algorithm>
+
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::backend::MachineInfo;
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::OpcodeSignatureType;
+using xe::cpu::hir::RegAssignment;
+using xe::cpu::hir::TypeName;
+using xe::cpu::hir::Value;
+
+#define ASSERT_NO_CYCLES 0
+
+RegisterAllocationPass::RegisterAllocationPass(const MachineInfo* machine_info)
+    : CompilerPass() {
+  // Initialize register sets.
+  // TODO(benvanik): rewrite in a way that makes sense - this is terrible.
+  auto mi_sets = machine_info->register_sets;
+  memset(&usage_sets_, 0, sizeof(usage_sets_));
+  uint32_t n = 0;
+  while (mi_sets[n].count) {
+    auto& mi_set = mi_sets[n];
+    auto usage_set = new RegisterSetUsage();
+    usage_sets_.all_sets[n] = usage_set;
+    usage_set->count = mi_set.count;
+    usage_set->set = &mi_set;
+    if (mi_set.types & MachineInfo::RegisterSet::INT_TYPES) {
+      usage_sets_.int_set = usage_set;
+    }
+    if (mi_set.types & MachineInfo::RegisterSet::FLOAT_TYPES) {
+      usage_sets_.float_set = usage_set;
+    }
+    if (mi_set.types & MachineInfo::RegisterSet::VEC_TYPES) {
+      usage_sets_.vec_set = usage_set;
+    }
+    n++;
+  }
+}
+
+RegisterAllocationPass::~RegisterAllocationPass() {
+  for (size_t n = 0; n < poly::countof(usage_sets_.all_sets); n++) {
+    if (!usage_sets_.all_sets[n]) {
+      break;
+    }
+    delete usage_sets_.all_sets[n];
+  }
+}
+
+int RegisterAllocationPass::Run(HIRBuilder* builder) {
+  // Simple per-block allocator that operates on SSA form.
+  // Registers do not move across blocks, though this could be
+  // optimized with some intra-block analysis (dominators/etc).
+  // Really, it'd just be nice to have someone who knew what they
+  // were doing lower SSA and do this right.
+
+  uint32_t block_ordinal = 0;
+  uint32_t instr_ordinal = 0;
+  auto block = builder->first_block();
+  while (block) {
+    // Sequential block ordinals.
+    block->ordinal = block_ordinal++;
+
+    // Reset all state.
+    PrepareBlockState();
+
+    // Renumber all instructions in the block. This is required so that
+    // we can sort the usage pointers below.
+    auto instr = block->instr_head;
+    while (instr) {
+      // Sequential global instruction ordinals.
+      instr->ordinal = instr_ordinal++;
+      instr = instr->next;
+    }
+
+    instr = block->instr_head;
+    while (instr) {
+      const auto info = instr->opcode;
+      uint32_t signature = info->signature;
+
+      // Update the register use heaps.
+      AdvanceUses(instr);
+
+      // Check sources for retirement. If any are unused after this instruction
+      // we can eagerly evict them to speed up register allocation.
+      // Since X64 (and other platforms) can often take advantage of dest==src1
+      // register mappings we track retired src1 so that we can attempt to
+      // reuse it.
+      // NOTE: these checks require that the usage list be sorted!
+      bool has_preferred_reg = false;
+      RegAssignment preferred_reg = {0};
+      if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V &&
+          !instr->src1.value->IsConstant()) {
+        if (!instr->src1_use->next) {
+          // Pull off preferred register. We will try to reuse this for the
+          // dest.
+          // NOTE: set may be null if this is a store local.
+          if (preferred_reg.set) {
+            has_preferred_reg = true;
+            preferred_reg = instr->src1.value->reg;
+          }
+        }
+      }
+
+      if (GET_OPCODE_SIG_TYPE_DEST(signature) == OPCODE_SIG_TYPE_V) {
+        // Must not have been set already.
+        assert_null(instr->dest->reg.set);
+
+        // Sort the usage list. We depend on this in future uses of this
+        // variable.
+        SortUsageList(instr->dest);
+
+        // If we have a preferred register, use that.
+        // This way we can help along the stupid X86 two opcode instructions.
+        bool allocated;
+        if (has_preferred_reg) {
+          // Allocate with the given preferred register. If the register is in
+          // the wrong set it will not be reused.
+          allocated = TryAllocateRegister(instr->dest, preferred_reg);
+        } else {
+          // Allocate a register. This will either reserve a free one or
+          // spill and reuse an active one.
+          allocated = TryAllocateRegister(instr->dest);
+        }
+        if (!allocated) {
+          // Failed to allocate register -- need to spill and try again.
+          // We spill only those registers we aren't using.
+          if (!SpillOneRegister(builder, block, instr->dest->type)) {
+            // Unable to spill anything - this shouldn't happen.
+            PLOGE("Unable to spill any registers");
+            assert_always();
+            return 1;
+          }
+
+          // Demand allocation.
+          if (!TryAllocateRegister(instr->dest)) {
+            // Boned.
+            PLOGE("Register allocation failed");
+            assert_always();
+            return 1;
+          }
+        }
+      }
+
+      instr = instr->next;
+    }
+    block = block->next;
+  }
+
+  return 0;
+}
+
+void RegisterAllocationPass::DumpUsage(const char* name) {
+#if 0
+  fprintf(stdout, "\n%s:\n", name);
+  for (size_t i = 0; i < poly::countof(usage_sets_.all_sets); ++i) {
+    auto usage_set = usage_sets_.all_sets[i];
+    if (usage_set) {
+      fprintf(stdout, "set %s:\n", usage_set->set->name);
+      fprintf(stdout, "  avail: %s\n", usage_set->availability.to_string().c_str());
+      fprintf(stdout, "  upcoming uses:\n");
+      for (auto it = usage_set->upcoming_uses.begin();
+           it != usage_set->upcoming_uses.end(); ++it) {
+        fprintf(stdout, "    v%d, used at %d\n",
+                it->value->ordinal,
+                it->use->instr->ordinal);
+      }
+    }
+  }
+  fflush(stdout);
+#endif
+}
+
+void RegisterAllocationPass::PrepareBlockState() {
+  for (size_t i = 0; i < poly::countof(usage_sets_.all_sets); ++i) {
+    auto usage_set = usage_sets_.all_sets[i];
+    if (usage_set) {
+      usage_set->availability.set();
+      usage_set->upcoming_uses.clear();
+    }
+  }
+  DumpUsage("PrepareBlockState");
+}
+
+void RegisterAllocationPass::AdvanceUses(Instr* instr) {
+  for (size_t i = 0; i < poly::countof(usage_sets_.all_sets); ++i) {
+    auto usage_set = usage_sets_.all_sets[i];
+    if (!usage_set) {
+      break;
+    }
+    auto& upcoming_uses = usage_set->upcoming_uses;
+    for (auto it = upcoming_uses.begin(); it != upcoming_uses.end();) {
+      if (!it->use) {
+        // No uses at all - we can remove right away.
+        // This comes up from instructions where the dest is never used,
+        // like the ATOMIC ops.
+        MarkRegAvailable(it->value->reg);
+        it = upcoming_uses.erase(it);
+        continue;
+      }
+      if (it->use->instr != instr) {
+        // Not yet at this instruction.
+        ++it;
+        continue;
+      }
+      // The use is from this instruction.
+      if (!it->use->next) {
+        // Last use of the value. We can retire it now.
+        MarkRegAvailable(it->value->reg);
+        it = upcoming_uses.erase(it);
+      } else {
+        // Used again. Push back the next use.
+        // Note that we may be used multiple times this instruction, so
+        // eat those.
+        auto next_use = it->use->next;
+        while (next_use->next && next_use->instr == instr) {
+          next_use = next_use->next;
+        }
+        // Remove the iterator.
+        auto value = it->value;
+        it = upcoming_uses.erase(it);
+        assert_true(next_use->instr->block == instr->block);
+        assert_true(value->def->block == instr->block);
+        upcoming_uses.emplace_back(value, next_use);
+      }
+    }
+  }
+  DumpUsage("AdvanceUses");
+}
+
+bool RegisterAllocationPass::IsRegInUse(const RegAssignment& reg) {
+  RegisterSetUsage* usage_set;
+  if (reg.set == usage_sets_.int_set->set) {
+    usage_set = usage_sets_.int_set;
+  } else if (reg.set == usage_sets_.float_set->set) {
+    usage_set = usage_sets_.float_set;
+  } else {
+    usage_set = usage_sets_.vec_set;
+  }
+  return !usage_set->availability.test(reg.index);
+}
+
+RegisterAllocationPass::RegisterSetUsage* RegisterAllocationPass::MarkRegUsed(
+    const RegAssignment& reg, Value* value, Value::Use* use) {
+  auto usage_set = RegisterSetForValue(value);
+  usage_set->availability.set(reg.index, false);
+  usage_set->upcoming_uses.emplace_back(value, use);
+  DumpUsage("MarkRegUsed");
+  return usage_set;
+}
+
+RegisterAllocationPass::RegisterSetUsage*
+RegisterAllocationPass::MarkRegAvailable(const hir::RegAssignment& reg) {
+  RegisterSetUsage* usage_set;
+  if (reg.set == usage_sets_.int_set->set) {
+    usage_set = usage_sets_.int_set;
+  } else if (reg.set == usage_sets_.float_set->set) {
+    usage_set = usage_sets_.float_set;
+  } else {
+    usage_set = usage_sets_.vec_set;
+  }
+  usage_set->availability.set(reg.index, true);
+  return usage_set;
+}
+
+bool RegisterAllocationPass::TryAllocateRegister(
+    Value* value, const RegAssignment& preferred_reg) {
+  // If the preferred register matches type and is available, use it.
+  auto usage_set = RegisterSetForValue(value);
+  if (usage_set->set == preferred_reg.set) {
+    // Check if available.
+    if (!IsRegInUse(preferred_reg)) {
+      // Mark as in-use and return. Best case.
+      MarkRegUsed(preferred_reg, value, value->use_head);
+      value->reg = preferred_reg;
+      return true;
+    }
+  }
+
+  // Otherwise, fallback to allocating like normal.
+  return TryAllocateRegister(value);
+}
+
+bool RegisterAllocationPass::TryAllocateRegister(Value* value) {
+  // Get the set this register is in.
+  RegisterSetUsage* usage_set = RegisterSetForValue(value);
+
+  // Find the first free register, if any.
+  // We have to ensure it's a valid one (in our count).
+  uint32_t first_unused = 0;
+  bool none_used = poly::bit_scan_forward(
+      static_cast<uint32_t>(usage_set->availability.to_ulong()), &first_unused);
+  if (none_used && first_unused < usage_set->count) {
+    // Available! Use it!
+    value->reg.set = usage_set->set;
+    value->reg.index = first_unused;
+    MarkRegUsed(value->reg, value, value->use_head);
+    return true;
+  }
+
+  // None available! Spill required.
+  return false;
+}
+
+bool RegisterAllocationPass::SpillOneRegister(HIRBuilder* builder, Block* block,
+                                              TypeName required_type) {
+  // Get the set that we will be picking from.
+  RegisterSetUsage* usage_set;
+  if (required_type <= INT64_TYPE) {
+    usage_set = usage_sets_.int_set;
+  } else if (required_type <= FLOAT64_TYPE) {
+    usage_set = usage_sets_.float_set;
+  } else {
+    usage_set = usage_sets_.vec_set;
+  }
+
+  DumpUsage("SpillOneRegister (pre)");
+  // Pick the one with the furthest next use.
+  assert_true(!usage_set->upcoming_uses.empty());
+  auto furthest_usage = std::max_element(usage_set->upcoming_uses.begin(),
+                                         usage_set->upcoming_uses.end(),
+                                         RegisterUsage::Comparer());
+  assert_true(furthest_usage->value->def->block == block);
+  assert_true(furthest_usage->use->instr->block == block);
+  auto spill_value = furthest_usage->value;
+  Value::Use* prev_use = furthest_usage->use->prev;
+  Value::Use* next_use = furthest_usage->use;
+  assert_not_null(next_use);
+  usage_set->upcoming_uses.erase(furthest_usage);
+  DumpUsage("SpillOneRegister (post)");
+  const auto reg = spill_value->reg;
+
+  // We know the spill_value use list is sorted, so we can cut it right now.
+  // This makes it easier down below.
+  auto new_head_use = next_use;
+
+  // Allocate local.
+  if (spill_value->local_slot) {
+    // Value is already assigned a slot. Since we allocate in order and this is
+    // all SSA we know the stored value will be exactly what we want. Yay,
+    // we can prevent the redundant store!
+    // In fact, we may even want to pin this spilled value so that we always
+    // use the spilled value and prevent the need for more locals.
+  } else {
+    // Allocate a local slot.
+    spill_value->local_slot = builder->AllocLocal(spill_value->type);
+
+    // Add store.
+    builder->StoreLocal(spill_value->local_slot, spill_value);
+    auto spill_store = builder->last_instr();
+    auto spill_store_use = spill_store->src2_use;
+    assert_null(spill_store_use->prev);
+    if (prev_use && prev_use->instr->opcode->flags & OPCODE_FLAG_PAIRED_PREV) {
+      // Instruction is paired. This is bad. We will insert the spill after the
+      // paired instruction.
+      assert_not_null(prev_use->instr->next);
+      spill_store->MoveBefore(prev_use->instr->next);
+
+      // Update last use.
+      spill_value->last_use = spill_store;
+    } else if (prev_use) {
+      // We insert the store immediately before the previous use.
+      // If we were smarter we could then re-run allocation and reuse the
+      // register
+      // once dropped.
+      spill_store->MoveBefore(prev_use->instr);
+
+      // Update last use.
+      spill_value->last_use = prev_use->instr;
+    } else {
+      // This is the first use, so the only thing we have is the define.
+      // Move the store to right after that.
+      spill_store->MoveBefore(spill_value->def->next);
+
+      // Update last use.
+      spill_value->last_use = spill_store;
+    }
+  }
+
+#if ASSERT_NO_CYCLES
+  builder->AssertNoCycles();
+  spill_value->def->block->AssertNoCycles();
+#endif  // ASSERT_NO_CYCLES
+
+  // Add load.
+  // Inserted immediately before the next use. Since by definition the next
+  // use is after the instruction requesting the spill we know we haven't
+  // done allocation for that code yet and can let that be handled
+  // automatically when we get to it.
+  auto new_value = builder->LoadLocal(spill_value->local_slot);
+  auto spill_load = builder->last_instr();
+  spill_load->MoveBefore(next_use->instr);
+// Note: implicit first use added.
+
+#if ASSERT_NO_CYCLES
+  builder->AssertNoCycles();
+  spill_value->def->block->AssertNoCycles();
+#endif  // ASSERT_NO_CYCLES
+
+  // Set the local slot of the new value to our existing one. This way we will
+  // reuse that same memory if needed.
+  new_value->local_slot = spill_value->local_slot;
+
+  // Rename all future uses of the SSA value to the new value as loaded
+  // from the local.
+  // We can quickly do this by walking the use list. Because the list is
+  // already sorted we know we are going to end up with a sorted list.
+  auto walk_use = new_head_use;
+  auto new_use_tail = walk_use;
+  while (walk_use) {
+    auto next_walk_use = walk_use->next;
+    auto instr = walk_use->instr;
+
+    uint32_t signature = instr->opcode->signature;
+    if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
+      if (instr->src1.value == spill_value) {
+        instr->set_src1(new_value);
+      }
+    }
+    if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
+      if (instr->src2.value == spill_value) {
+        instr->set_src2(new_value);
+      }
+    }
+    if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
+      if (instr->src3.value == spill_value) {
+        instr->set_src3(new_value);
+      }
+    }
+
+    walk_use = next_walk_use;
+    if (walk_use) {
+      new_use_tail = walk_use;
+    }
+  }
+  new_value->last_use = new_use_tail->instr;
+
+  // Update tracking.
+  MarkRegAvailable(reg);
+
+  return true;
+}
+
+RegisterAllocationPass::RegisterSetUsage*
+RegisterAllocationPass::RegisterSetForValue(const Value* value) {
+  if (value->type <= INT64_TYPE) {
+    return usage_sets_.int_set;
+  } else if (value->type <= FLOAT64_TYPE) {
+    return usage_sets_.float_set;
+  } else {
+    return usage_sets_.vec_set;
+  }
+}
+
+namespace {
+int CompareValueUse(const Value::Use* a, const Value::Use* b) {
+  return a->instr->ordinal - b->instr->ordinal;
+}
+}  // namespace
+void RegisterAllocationPass::SortUsageList(Value* value) {
+  // Modified in-place linked list sort from:
+  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.c
+  if (!value->use_head) {
+    return;
+  }
+  Value::Use* head = value->use_head;
+  Value::Use* tail = nullptr;
+  int insize = 1;
+  while (true) {
+    auto p = head;
+    head = nullptr;
+    tail = nullptr;
+    // count number of merges we do in this pass
+    int nmerges = 0;
+    while (p) {
+      // there exists a merge to be done
+      nmerges++;
+      // step 'insize' places along from p
+      auto q = p;
+      int psize = 0;
+      for (int i = 0; i < insize; i++) {
+        psize++;
+        q = q->next;
+        if (!q) break;
+      }
+      // if q hasn't fallen off end, we have two lists to merge
+      int qsize = insize;
+      // now we have two lists; merge them
+      while (psize > 0 || (qsize > 0 && q)) {
+        // decide whether next element of merge comes from p or q
+        Value::Use* e = nullptr;
+        if (psize == 0) {
+          // p is empty; e must come from q
+          e = q;
+          q = q->next;
+          qsize--;
+        } else if (qsize == 0 || !q) {
+          // q is empty; e must come from p
+          e = p;
+          p = p->next;
+          psize--;
+        } else if (CompareValueUse(p, q) <= 0) {
+          // First element of p is lower (or same); e must come from p
+          e = p;
+          p = p->next;
+          psize--;
+        } else {
+          // First element of q is lower; e must come from q
+          e = q;
+          q = q->next;
+          qsize--;
+        }
+        // add the next element to the merged list
+        if (tail) {
+          tail->next = e;
+        } else {
+          head = e;
+        }
+        // Maintain reverse pointers in a doubly linked list.
+        e->prev = tail;
+        tail = e;
+      }
+      // now p has stepped 'insize' places along, and q has too
+      p = q;
+    }
+    if (tail) {
+      tail->next = nullptr;
+    }
+    // If we have done only one merge, we're finished
+    if (nmerges <= 1) {
+      // allow for nmerges==0, the empty list case
+      break;
+    }
+    // Otherwise repeat, merging lists twice the size
+    insize *= 2;
+  }
+
+  value->use_head = head;
+  value->last_use = tail->instr;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/register_allocation_pass.h

@@ -0,0 +1,87 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_REGISTER_ALLOCATION_PASS_H_
+#define XENIA_COMPILER_PASSES_REGISTER_ALLOCATION_PASS_H_
+
+#include <algorithm>
+#include <bitset>
+#include <vector>
+
+#include "xenia/cpu/backend/machine_info.h"
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class RegisterAllocationPass : public CompilerPass {
+ public:
+  RegisterAllocationPass(const backend::MachineInfo* machine_info);
+  ~RegisterAllocationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  // TODO(benvanik): rewrite all this set shit -- too much indirection, the
+  // complexity is not needed.
+  struct RegisterUsage {
+    hir::Value* value;
+    hir::Value::Use* use;
+    RegisterUsage() : value(nullptr), use(nullptr) {}
+    RegisterUsage(hir::Value* value_, hir::Value::Use* use_)
+        : value(value_), use(use_) {}
+    struct Comparer : std::binary_function<RegisterUsage, RegisterUsage, bool> {
+      bool operator()(const RegisterUsage& a, const RegisterUsage& b) const {
+        return a.use->instr->ordinal < b.use->instr->ordinal;
+      }
+    };
+  };
+  struct RegisterSetUsage {
+    const backend::MachineInfo::RegisterSet* set = nullptr;
+    uint32_t count = 0;
+    std::bitset<32> availability = 0;
+    // TODO(benvanik): another data type.
+    std::vector<RegisterUsage> upcoming_uses;
+  };
+
+  void DumpUsage(const char* name);
+  void PrepareBlockState();
+  void AdvanceUses(hir::Instr* instr);
+  bool IsRegInUse(const hir::RegAssignment& reg);
+  RegisterSetUsage* MarkRegUsed(const hir::RegAssignment& reg,
+                                hir::Value* value, hir::Value::Use* use);
+  RegisterSetUsage* MarkRegAvailable(const hir::RegAssignment& reg);
+
+  bool TryAllocateRegister(hir::Value* value,
+                           const hir::RegAssignment& preferred_reg);
+  bool TryAllocateRegister(hir::Value* value);
+  bool SpillOneRegister(hir::HIRBuilder* builder, hir::Block* block,
+                        hir::TypeName required_type);
+
+  RegisterSetUsage* RegisterSetForValue(const hir::Value* value);
+
+  void SortUsageList(hir::Value* value);
+
+ private:
+  struct {
+    RegisterSetUsage* int_set = nullptr;
+    RegisterSetUsage* float_set = nullptr;
+    RegisterSetUsage* vec_set = nullptr;
+    RegisterSetUsage* all_sets[3];
+  } usage_sets_;
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_REGISTER_ALLOCATION_PASS_H_

src/xenia/cpu/compiler/passes/simplification_pass.cc

@@ -0,0 +1,173 @@
+/**
+ ******************************************************************************
+ * 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/compiler/passes/simplification_pass.h"
+
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::Value;
+
+SimplificationPass::SimplificationPass() : CompilerPass() {}
+
+SimplificationPass::~SimplificationPass() {}
+
+int SimplificationPass::Run(HIRBuilder* builder) {
+  EliminateConversions(builder);
+  SimplifyAssignments(builder);
+  return 0;
+}
+
+void SimplificationPass::EliminateConversions(HIRBuilder* builder) {
+  // First, we check for truncates/extensions that can be skipped.
+  // This generates some assignments which then the second step will clean up.
+  // Both zero/sign extends can be skipped:
+  //   v1.i64 = zero/sign_extend v0.i32
+  //   v2.i32 = truncate v1.i64
+  // becomes:
+  //   v1.i64 = zero/sign_extend v0.i32 (may be dead code removed later)
+  //   v2.i32 = v0.i32
+
+  auto block = builder->first_block();
+  while (block) {
+    auto i = block->instr_head;
+    while (i) {
+      // To make things easier we check in reverse (source of truncate/extend
+      // back to definition).
+      if (i->opcode == &OPCODE_TRUNCATE_info) {
+        // Matches zero/sign_extend + truncate.
+        CheckTruncate(i);
+      } else if (i->opcode == &OPCODE_BYTE_SWAP_info) {
+        // Matches byte swap + byte swap.
+        // This is pretty rare within the same basic block, but is in the
+        // memcpy hot path and (probably) worth it. Maybe.
+        CheckByteSwap(i);
+      }
+      i = i->next;
+    }
+    block = block->next;
+  }
+}
+
+void SimplificationPass::CheckTruncate(Instr* i) {
+  // Walk backward up src's chain looking for an extend. We may have
+  // assigns, so skip those.
+  auto src = i->src1.value;
+  auto def = src->def;
+  while (def && def->opcode == &OPCODE_ASSIGN_info) {
+    // Skip asignments.
+    def = def->src1.value->def;
+  }
+  if (def) {
+    if (def->opcode == &OPCODE_SIGN_EXTEND_info) {
+      // Value comes from a sign extend.
+      if (def->src1.value->type == i->dest->type) {
+        // Types match, use original by turning this into an assign.
+        i->Replace(&OPCODE_ASSIGN_info, 0);
+        i->set_src1(def->src1.value);
+      }
+    } else if (def->opcode == &OPCODE_ZERO_EXTEND_info) {
+      // Value comes from a zero extend.
+      if (def->src1.value->type == i->dest->type) {
+        // Types match, use original by turning this into an assign.
+        i->Replace(&OPCODE_ASSIGN_info, 0);
+        i->set_src1(def->src1.value);
+      }
+    }
+  }
+}
+
+void SimplificationPass::CheckByteSwap(Instr* i) {
+  // Walk backward up src's chain looking for a byte swap. We may have
+  // assigns, so skip those.
+  auto src = i->src1.value;
+  auto def = src->def;
+  while (def && def->opcode == &OPCODE_ASSIGN_info) {
+    // Skip asignments.
+    def = def->src1.value->def;
+  }
+  if (def && def->opcode == &OPCODE_BYTE_SWAP_info) {
+    // Value comes from a byte swap.
+    if (def->src1.value->type == i->dest->type) {
+      // Types match, use original by turning this into an assign.
+      i->Replace(&OPCODE_ASSIGN_info, 0);
+      i->set_src1(def->src1.value);
+    }
+  }
+}
+
+void SimplificationPass::SimplifyAssignments(HIRBuilder* builder) {
+  // Run over the instructions and rename assigned variables:
+  //   v1 = v0
+  //   v2 = v1
+  //   v3 = add v0, v2
+  // becomes:
+  //   v1 = v0
+  //   v2 = v0
+  //   v3 = add v0, v0
+  // This could be run several times, as it could make other passes faster
+  // to compute (for example, ConstantPropagation). DCE will take care of
+  // the useless assigns.
+  //
+  // We do this by walking each instruction. For each value op we
+  // look at its def instr to see if it's an assign - if so, we use the src
+  // of that instr. Because we may have chains, we do this recursively until
+  // we find a non-assign def.
+
+  auto block = builder->first_block();
+  while (block) {
+    auto i = block->instr_head;
+    while (i) {
+      uint32_t signature = i->opcode->signature;
+      if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
+        i->set_src1(CheckValue(i->src1.value));
+      }
+      if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
+        i->set_src2(CheckValue(i->src2.value));
+      }
+      if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
+        i->set_src3(CheckValue(i->src3.value));
+      }
+      i = i->next;
+    }
+    block = block->next;
+  }
+}
+
+Value* SimplificationPass::CheckValue(Value* value) {
+  auto def = value->def;
+  if (def && def->opcode == &OPCODE_ASSIGN_info) {
+    // Value comes from an assignment - recursively find if it comes from
+    // another assignment. It probably doesn't, if we already replaced it.
+    auto replacement = def->src1.value;
+    while (true) {
+      def = replacement->def;
+      if (!def || def->opcode != &OPCODE_ASSIGN_info) {
+        break;
+      }
+      replacement = def->src1.value;
+    }
+    return replacement;
+  }
+  return value;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/simplification_pass.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_COMPILER_PASSES_SIMPLIFICATION_PASS_H_
+#define XENIA_COMPILER_PASSES_SIMPLIFICATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class SimplificationPass : public CompilerPass {
+ public:
+  SimplificationPass();
+  ~SimplificationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  void EliminateConversions(hir::HIRBuilder* builder);
+  void CheckTruncate(hir::Instr* i);
+  void CheckByteSwap(hir::Instr* i);
+
+  void SimplifyAssignments(hir::HIRBuilder* builder);
+  hir::Value* CheckValue(hir::Value* value);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_SIMPLIFICATION_PASS_H_

src/xenia/cpu/compiler/passes/sources.gypi

@@ -0,0 +1,29 @@
+# Copyright 2013 Ben Vanik. All Rights Reserved.
+{
+  'sources': [
+    'constant_propagation_pass.cc',
+    'constant_propagation_pass.h',
+    'context_promotion_pass.cc',
+    'context_promotion_pass.h',
+    'control_flow_analysis_pass.cc',
+    'control_flow_analysis_pass.h',
+    'control_flow_simplification_pass.cc',
+    'control_flow_simplification_pass.h',
+    'data_flow_analysis_pass.cc',
+    'data_flow_analysis_pass.h',
+    'dead_code_elimination_pass.cc',
+    'dead_code_elimination_pass.h',
+    'finalization_pass.cc',
+    'finalization_pass.h',
+    #'dead_store_elimination_pass.cc',
+    #'dead_store_elimination_pass.h',
+    'register_allocation_pass.cc',
+    'register_allocation_pass.h',
+    'simplification_pass.cc',
+    'simplification_pass.h',
+    'validation_pass.cc',
+    'validation_pass.h',
+    'value_reduction_pass.cc',
+    'value_reduction_pass.h',
+  ],
+}

src/xenia/cpu/compiler/passes/validation_pass.cc

@@ -0,0 +1,118 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/validation_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::Block;
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::OpcodeSignatureType;
+using xe::cpu::hir::Value;
+
+ValidationPass::ValidationPass() : CompilerPass() {}
+
+ValidationPass::~ValidationPass() {}
+
+int ValidationPass::Run(HIRBuilder* builder) {
+#if 0
+  StringBuffer str;
+  builder->Dump(&str);
+  printf(str.GetString());
+  fflush(stdout);
+  str.Reset();
+#endif  // 0
+
+  auto block = builder->first_block();
+  while (block) {
+    auto label = block->label_head;
+    while (label) {
+      assert_true(label->block == block);
+      if (label->block != block) {
+        return 1;
+      }
+      label = label->next;
+    }
+
+    auto instr = block->instr_head;
+    while (instr) {
+      if (ValidateInstruction(block, instr)) {
+        return 1;
+      }
+      instr = instr->next;
+    }
+
+    block = block->next;
+  }
+
+  return 0;
+}
+
+int ValidationPass::ValidateInstruction(Block* block, Instr* instr) {
+  assert_true(instr->block == block);
+  if (instr->block != block) {
+    return 1;
+  }
+
+  if (instr->dest) {
+    assert_true(instr->dest->def == instr);
+    auto use = instr->dest->use_head;
+    while (use) {
+      assert_true(use->instr->block == block);
+      use = use->next;
+    }
+  }
+
+  uint32_t signature = instr->opcode->signature;
+  if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
+    if (ValidateValue(block, instr, instr->src1.value)) {
+      return 1;
+    }
+  }
+  if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
+    if (ValidateValue(block, instr, instr->src2.value)) {
+      return 1;
+    }
+  }
+  if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
+    if (ValidateValue(block, instr, instr->src3.value)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+int ValidationPass::ValidateValue(Block* block, Instr* instr, Value* value) {
+  // if (value->def) {
+  //  auto def = value->def;
+  //  assert_true(def->block == block);
+  //  if (def->block != block) {
+  //    return 1;
+  //  }
+  //}
+  return 0;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/validation_pass.h

@@ -0,0 +1,37 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_VALIDATION_PASS_H_
+#define XENIA_COMPILER_PASSES_VALIDATION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ValidationPass : public CompilerPass {
+ public:
+  ValidationPass();
+  ~ValidationPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  int ValidateInstruction(hir::Block* block, hir::Instr* instr);
+  int ValidateValue(hir::Block* block, hir::Instr* instr, hir::Value* value);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_VALIDATION_PASS_H_

src/xenia/cpu/compiler/passes/value_reduction_pass.cc

@@ -0,0 +1,147 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/value_reduction_pass.h"
+
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/runtime/runtime.h"
+#include "xenia/profiling.h"
+
+#if XE_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4267)
+#include <llvm/ADT/BitVector.h>
+#pragma warning(pop)
+#else
+#include <llvm/ADT/BitVector.h>
+#endif  // XE_COMPILER_MSVC
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::OpcodeInfo;
+using xe::cpu::hir::Value;
+
+ValueReductionPass::ValueReductionPass() : CompilerPass() {}
+
+ValueReductionPass::~ValueReductionPass() {}
+
+void ValueReductionPass::ComputeLastUse(Value* value) {
+  // TODO(benvanik): compute during construction?
+  // Note that this list isn't sorted (unfortunately), so we have to scan
+  // them all.
+  uint32_t max_ordinal = 0;
+  Value::Use* last_use = nullptr;
+  auto use = value->use_head;
+  while (use) {
+    if (!last_use || use->instr->ordinal >= max_ordinal) {
+      last_use = use;
+      max_ordinal = use->instr->ordinal;
+    }
+    use = use->next;
+  }
+  value->last_use = last_use ? last_use->instr : nullptr;
+}
+
+int ValueReductionPass::Run(HIRBuilder* builder) {
+  // Walk each block and reuse variable ordinals as much as possible.
+
+  llvm::BitVector ordinals(builder->max_value_ordinal());
+
+  auto block = builder->first_block();
+  while (block) {
+    // Reset used ordinals.
+    ordinals.reset();
+
+    // Renumber all instructions to make liveness tracking easier.
+    uint32_t instr_ordinal = 0;
+    auto instr = block->instr_head;
+    while (instr) {
+      instr->ordinal = instr_ordinal++;
+      instr = instr->next;
+    }
+
+    instr = block->instr_head;
+    while (instr) {
+      const OpcodeInfo* info = instr->opcode;
+      OpcodeSignatureType dest_type = GET_OPCODE_SIG_TYPE_DEST(info->signature);
+      OpcodeSignatureType src1_type = GET_OPCODE_SIG_TYPE_SRC1(info->signature);
+      OpcodeSignatureType src2_type = GET_OPCODE_SIG_TYPE_SRC2(info->signature);
+      OpcodeSignatureType src3_type = GET_OPCODE_SIG_TYPE_SRC3(info->signature);
+      if (src1_type == OPCODE_SIG_TYPE_V) {
+        auto v = instr->src1.value;
+        if (!v->last_use) {
+          ComputeLastUse(v);
+        }
+        if (v->last_use == instr) {
+          // Available.
+          if (!instr->src1.value->IsConstant()) {
+            ordinals.reset(v->ordinal);
+          }
+        }
+      }
+      if (src2_type == OPCODE_SIG_TYPE_V) {
+        auto v = instr->src2.value;
+        if (!v->last_use) {
+          ComputeLastUse(v);
+        }
+        if (v->last_use == instr) {
+          // Available.
+          if (!instr->src2.value->IsConstant()) {
+            ordinals.reset(v->ordinal);
+          }
+        }
+      }
+      if (src3_type == OPCODE_SIG_TYPE_V) {
+        auto v = instr->src3.value;
+        if (!v->last_use) {
+          ComputeLastUse(v);
+        }
+        if (v->last_use == instr) {
+          // Available.
+          if (!instr->src3.value->IsConstant()) {
+            ordinals.reset(v->ordinal);
+          }
+        }
+      }
+      if (dest_type == OPCODE_SIG_TYPE_V) {
+        // Dest values are processed last, as they may be able to reuse a
+        // source value ordinal.
+        auto v = instr->dest;
+        // Find a lower ordinal.
+        for (auto n = 0u; n < ordinals.size(); n++) {
+          if (!ordinals.test(n)) {
+            ordinals.set(n);
+            v->ordinal = n;
+            break;
+          }
+        }
+      }
+
+      instr = instr->next;
+    }
+
+    block = block->next;
+  }
+
+  return 0;
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe

src/xenia/cpu/compiler/passes/value_reduction_pass.h

@@ -0,0 +1,36 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_COMPILER_PASSES_VALUE_REDUCTION_PASS_H_
+#define XENIA_COMPILER_PASSES_VALUE_REDUCTION_PASS_H_
+
+#include "xenia/cpu/compiler/compiler_pass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ValueReductionPass : public CompilerPass {
+ public:
+  ValueReductionPass();
+  ~ValueReductionPass() override;
+
+  int Run(hir::HIRBuilder* builder) override;
+
+ private:
+  void ComputeLastUse(hir::Value* value);
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_COMPILER_PASSES_VALUE_REDUCTION_PASS_H_

src/xenia/cpu/compiler/sources.gypi

@@ -0,0 +1,14 @@
+# Copyright 2013 Ben Vanik. All Rights Reserved.
+{
+  'sources': [
+    'compiler.cc',
+    'compiler.h',
+    'compiler_pass.cc',
+    'compiler_pass.h',
+    'compiler_passes.h',
+  ],
+
+  'includes': [
+    'passes/sources.gypi',
+  ],
+}