Trying out a new style of JIT pattern matching.

src/alloy/compiler/passes/register_allocation_pass.h

@@ -10,6 +10,10 @@
 #ifndef ALLOY_COMPILER_PASSES_REGISTER_ALLOCATION_PASS_H_
 #define ALLOY_COMPILER_PASSES_REGISTER_ALLOCATION_PASS_H_
 
+#include <algorithm>
+#include <bitset>
+#include <vector>
+
 #include <alloy/backend/machine_info.h>
 #include <alloy/compiler/compiler_pass.h>
 
@@ -27,28 +31,53 @@ public:
   virtual int Run(hir::HIRBuilder* builder);
 
 private:
-  struct Interval;
-  struct Intervals;
-  void ComputeLastUse(hir::Value* value);
-  bool TryAllocateFreeReg(Interval* current, Intervals& intervals);
-  void AllocateBlockedReg(hir::HIRBuilder* builder,
-                          Interval* current, Intervals& intervals);
+  // 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::TypeName required_type);
+
+  RegisterSetUsage* RegisterSetForValue(const hir::Value* value);
+
+  void SortUsageList(hir::Value* value);
 
 private:
   const backend::MachineInfo* machine_info_;
-
-  struct RegisterFreeUntilSet {
-    uint32_t count;
-    uint32_t pos[32];
-    const backend::MachineInfo::RegisterSet* set;
-  };
-  struct RegisterFreeUntilSets {
-    RegisterFreeUntilSet* int_set;
-    RegisterFreeUntilSet* float_set;
-    RegisterFreeUntilSet* vec_set;
-    RegisterFreeUntilSet* all_sets[3];
-  };
-  RegisterFreeUntilSets free_until_sets_;
+  struct {
+    RegisterSetUsage* int_set = nullptr;
+    RegisterSetUsage* float_set = nullptr;
+    RegisterSetUsage* vec_set = nullptr;
+    RegisterSetUsage* all_sets[3];
+  } usage_sets_;
 };