[TPDE][NFC] Remove unused exclusion_mask parameter

As alloc_reg is not inlined, the always-zero exclusion mask still must
be merged into the register mask. Removing the mask therefore removes
one instruction from the critical path.

Author: aengelke

tpde/include/tpde/CompilerBase.hpp

@@ -438,19 +438,19 @@ struct CompilerBase {
 
 private:
   /// @internal Select register when a value needs to be evicted.
-  Reg select_reg_evict(RegBank bank, u64 exclusion_mask) noexcept;
+  Reg select_reg_evict(RegBank bank) noexcept;
 
 public:
   /// \name Low-Level Assignment Register Handling
   /// @{
 
   /// Select an available register, evicting loaded values if needed.
-  Reg select_reg(RegBank bank, u64 exclusion_mask) noexcept {
-    Reg res = register_file.find_first_free_excluding(bank, exclusion_mask);
+  Reg select_reg(RegBank bank) noexcept {
+    Reg res = register_file.find_first_free_excluding(bank, 0);
     if (res.valid()) [[likely]] {
       return res;
     }
-    return select_reg_evict(bank, exclusion_mask);
+    return select_reg_evict(bank);
   }
 
   /// Reload a value part from memory or recompute variable address.
@@ -1393,10 +1393,9 @@ typename CompilerBase<Adaptor, Derived, Config>::AsmReg
 
 template <IRAdaptor Adaptor, typename Derived, CompilerConfig Config>
 Reg CompilerBase<Adaptor, Derived, Config>::select_reg_evict(
-    RegBank bank, u64 exclusion_mask) noexcept {
+    RegBank bank) noexcept {
   TPDE_LOG_DBG("select_reg_evict for bank {}", bank.id());
-  auto candidates =
-      register_file.used & register_file.bank_regs(bank) & ~exclusion_mask;
+  auto candidates = register_file.used & register_file.bank_regs(bank);
 
   Reg candidate = Reg::make_invalid();
   u32 max_score = 0;

tpde/include/tpde/ScratchReg.hpp

@@ -113,7 +113,7 @@ CompilerBase<Adaptor, Derived, Config>::AsmReg
     return reg;
   }
 
-  reg = compiler->select_reg(bank, /*exclusion_mask=*/0);
+  reg = compiler->select_reg(bank);
   reg_file.mark_used(reg, INVALID_VAL_LOCAL_IDX, 0);
   reg_file.mark_clobbered(reg);
   reg_file.mark_fixed(reg);

tpde/include/tpde/ValuePartRef.hpp

@@ -167,24 +167,24 @@ class CompilerBase<Adaptor, Derived, Config>::ValuePart {
 
 private:
   template <bool Reload>
-  void alloc_reg_impl(CompilerBase *compiler, u64 exclusion_mask) noexcept;
+  void alloc_reg_impl(CompilerBase *compiler) noexcept;
   AsmReg alloc_specific_impl(CompilerBase *compiler,
                              AsmReg reg,
                              bool reload) noexcept;
 
 public:
   /// Allocate and lock a register for the value part, *without* reloading the
   /// value. Asserts that no register is currently allocated.
-  AsmReg alloc_reg(CompilerBase *compiler, u64 exclusion_mask = 0) noexcept {
-    alloc_reg_impl</*Reload=*/false>(compiler, exclusion_mask);
+  AsmReg alloc_reg(CompilerBase *compiler) noexcept {
+    alloc_reg_impl</*Reload=*/false>(compiler);
     return cur_reg();
   }
 
   /// Allocate and lock a register for the value part, *without* reloading the
   /// value. Does nothing if a register is already allocated.
   AsmReg cur_reg_or_alloc(CompilerBase *compiler) noexcept {
     if (!has_reg()) {
-      alloc_reg_impl</*Reload=*/false>(compiler, 0);
+      alloc_reg_impl</*Reload=*/false>(compiler);
     }
     return cur_reg();
   }
@@ -232,7 +232,7 @@ class CompilerBase<Adaptor, Derived, Config>::ValuePart {
   /// the stack or materializing the constant if necessary. Requires that the
   /// value is currently unlocked (i.e., has_reg() is false).
   AsmReg load_to_reg(CompilerBase *compiler) noexcept {
-    alloc_reg_impl</*Reload=*/true>(compiler, 0);
+    alloc_reg_impl</*Reload=*/true>(compiler);
     return cur_reg();
   }
 
@@ -402,7 +402,7 @@ class CompilerBase<Adaptor, Derived, Config>::ValuePart {
 template <IRAdaptor Adaptor, typename Derived, CompilerConfig Config>
 template <bool Reload>
 void CompilerBase<Adaptor, Derived, Config>::ValuePart::alloc_reg_impl(
-    CompilerBase *compiler, u64 exclusion_mask) noexcept {
+    CompilerBase *compiler) noexcept {
   // The caller has no control over the selected register, so it must assume
   // that this function evicts some register. This is not permitted if the value
   // state ought to be the same.
@@ -414,9 +414,6 @@ void CompilerBase<Adaptor, Derived, Config>::ValuePart::alloc_reg_impl(
     auto ap = assignment();
     if (ap.register_valid()) {
       lock(compiler);
-      // TODO: implement this if needed
-      assert((exclusion_mask & (1ull << state.v.reg.id())) == 0 &&
-             "moving registers in alloc_reg is unsupported");
       return;
     }
 
@@ -425,7 +422,7 @@ void CompilerBase<Adaptor, Derived, Config>::ValuePart::alloc_reg_impl(
     bank = state.c.bank;
   }
 
-  Reg reg = compiler->select_reg(bank, exclusion_mask);
+  Reg reg = compiler->select_reg(bank);
   auto &reg_file = compiler->register_file;
   reg_file.mark_clobbered(reg);
   if (has_assignment()) {
@@ -870,9 +867,7 @@ struct CompilerBase<Adaptor, Derived, Config>::ValuePartRef : ValuePart {
     return *this;
   }
 
-  AsmReg alloc_reg(u64 exclusion_mask = 0) noexcept {
-    return ValuePart::alloc_reg(compiler, exclusion_mask);
-  }
+  AsmReg alloc_reg() noexcept { return ValuePart::alloc_reg(compiler); }
 
   AsmReg cur_reg_or_alloc() noexcept {
     return ValuePart::cur_reg_or_alloc(compiler);