Add a configurable spill-everything register allocator

Summary:
Adds `SpillAllocator`, a deliberately naive register allocator that spills every
virtual register to its own stack slot, and makes the register allocator
selectable from the command line / environment.  It's meant for testing and
isolating the rest of the JIT pipeline from the optimizing linear scan
allocator.

Configuration:

- New `-X cinderx-jit-reg-alloc=<linear-scan|spill>` option (and
  `CINDERX_JIT_REG_ALLOC` env var), parsed in `pyjit.cpp` into a new
  `RegAllocKind` config enum.  The default is `linear-scan`.  Any other value
  raises a `ValueError` during CinderX initialization.

- `gen_asm.cpp` selects the allocator through the `RegisterAllocator` interface
  based on `getConfig().reg_alloc`.

SpillAllocator (`cinderx/Jit/lir/spill_alloc.{cpp,h}`, new `:spill-alloc`
library):
- Gives every vreg a home stack slot it keeps for the whole function, so a
  value defined in one block and used in another is just re-read from the same
  slot -- no live intervals, interval splitting, or cross-block location
  bookkeeping.

- Rewrites each instruction to refer only to physical locations, loading
  operands that must be in registers (per `getInputPhyRegUse` /
  `getOutputPhyRegUse`) into caller-save scratch registers around the
  instruction and leaving everything else in its slot.

- Lowers phis to copies on the incoming edges (phi-output slots are unique, so
  no critical-edge splitting is needed) and strips the `kReturn` /
  `kBranchToYieldExit` pseudo-terminators for PostRegAllocRewrite.

- Handles `kBind` (store the bound register into the slot), calls (operands
  stay in slots; PostRegAllocRewrite applies the calling convention), and
  read-modify-write `kInc`/`kDec`.

- Because nothing is ever live in a register across an instruction boundary,
  caller-save registers are always free at calls and no callee-saved register
  is ever clobbered.

Generators and coroutines are supported.  A generator runs with the frame
pointer swapped between the machine stack and a heap-allocated generator frame,
so a value produced on one side of a `Move` into the frame-pointer register but
read on the other is stale once spilled.  `handleFramePointerSwitch` carries
those values across the switch in a register: the frame-setup call's result on
the forward switch (stack -> heap), and the return-value exit phi on the
reverse switch (heap -> stack, including the extra deferred-refcount step on
free-threaded builds).

Reviewed By: DinoV

Differential Revision: D112574130

fbshipit-source-id: 06c4c72bd9ebc3480dcd67533cd13071e190d940

Author: alexmalyshev

cinderx/Jit/codegen/gen_asm.cpp

@@ -33,6 +33,8 @@
 #include "cinderx/Jit/lir/postalloc.h"
 #include "cinderx/Jit/lir/postgen.h"
 #include "cinderx/Jit/lir/printer.h"
+#include "cinderx/Jit/lir/regalloc.h"
+#include "cinderx/Jit/lir/spill_alloc.h"
 #include "cinderx/Jit/lir/target_select.h"
 #include "cinderx/Jit/lir/verify.h"
 #include "cinderx/Jit/perf_jitdump.h"
@@ -845,15 +847,25 @@ void* NativeGenerator::getVectorcallEntry() {
   reserved_stack_space += 16;
 #endif
 
-  LinearScanAllocator lsalloc(lir_func.get(), reserved_stack_space);
+  std::unique_ptr<RegisterAllocator> allocator;
+  switch (getConfig().reg_alloc) {
+    case RegAllocKind::kLinearScan:
+      allocator = std::make_unique<LinearScanAllocator>(
+          lir_func.get(), reserved_stack_space);
+      break;
+    case RegAllocKind::kSpill:
+      allocator = std::make_unique<SpillAllocator>(
+          lir_func.get(), reserved_stack_space);
+      break;
+  }
 
   COMPILE_TIMER(
       getFunction()->compilation_phase_timer,
       "Register Allocation",
-      lsalloc.run())
+      allocator->run())
 
-  env_.shadow_frames_and_spill_size = lsalloc.getFrameSize();
-  env_.changed_regs = lsalloc.getChangedRegs();
+  env_.shadow_frames_and_spill_size = allocator->getFrameSize();
+  env_.changed_regs = allocator->getChangedRegs();
   env_.exit_label = as_->newLabel();
   env_.can_deopt = getFunction()->canDeopt();
 

cinderx/Jit/config.h

@@ -115,6 +115,16 @@ enum class AsmSyntax : uint8_t {
   Intel,
 };
 
+// Which register allocator the JIT should use to lower LIR virtual registers to
+// physical locations.
+enum class RegAllocKind : uint8_t {
+  // Optimizing linear scan allocator (the default).
+  kLinearScan,
+  // Trivial allocator that spills everything to the stack.  Intended for
+  // testing and isolating the rest of the JIT pipeline.
+  kSpill,
+};
+
 // Collection of configuration values for the JIT.
 //
 // Note: It's fine to store non-trivially destructible objects like std::string
@@ -221,6 +231,9 @@ struct Config {
   // The ASM syntax the JIT should use when disassembling.
   AsmSyntax asm_syntax{AsmSyntax::ATT};
 
+  // The register allocator the JIT should use.
+  RegAllocKind reg_alloc{RegAllocKind::kLinearScan};
+
   // List of function name patterns for which to capture compilation times.
   std::vector<std::string> capture_compilation_times_for;