Rename a few LSRAs to RegAllocs

Addressing the factoring TODO.

Author: SingleAccretion

src/coreclr/jit/codegencommon.cpp

@@ -2156,7 +2156,7 @@ void CodeGen::genEmitMachineCode()
 #if TRACK_LSRA_STATS
         if (JitConfig.DisplayLsraStats() == 3)
         {
-            compiler->m_pLinearScan->dumpLsraStatsSummary(jitstdout());
+            compiler->m_regAlloc->dumpLsraStatsSummary(jitstdout());
         }
 #endif // TRACK_LSRA_STATS
 
@@ -4524,7 +4524,7 @@ void CodeGen::genFinalizeFrame()
     // of the first basic block, so load those up. In particular, the determination
     // of whether or not to use block init in the prolog is dependent on the variable
     // locations on entry to the function.
-    compiler->m_pLinearScan->recordVarLocationsAtStartOfBB(compiler->fgFirstBB);
+    compiler->m_regAlloc->recordVarLocationsAtStartOfBB(compiler->fgFirstBB);
 
     genCheckUseBlockInit();
 
@@ -5794,7 +5794,7 @@ void CodeGen::genGeneratePrologsAndEpilogs()
 
     // Before generating the prolog, we need to reset the variable locations to what they will be on entry.
     // This affects our code that determines which untracked locals need to be zero initialized.
-    compiler->m_pLinearScan->recordVarLocationsAtStartOfBB(compiler->fgFirstBB);
+    compiler->m_regAlloc->recordVarLocationsAtStartOfBB(compiler->fgFirstBB);
 
     // Tell the emitter we're done with main code generation, and are going to start prolog and epilog generation.
 

src/coreclr/jit/codegenlinear.cpp

@@ -187,7 +187,7 @@ void CodeGen::genCodeForBBlist()
         gcInfo.gcRegGCrefSetCur = RBM_NONE;
         gcInfo.gcRegByrefSetCur = RBM_NONE;
 
-        compiler->m_pLinearScan->recordVarLocationsAtStartOfBB(block);
+        compiler->m_regAlloc->recordVarLocationsAtStartOfBB(block);
 
         // Updating variable liveness after last instruction of previous block was emitted
         // and before first of the current block is emitted

src/coreclr/jit/compiler.cpp

@@ -4965,14 +4965,14 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
 
     // Assign registers to variables, etc.
 
-    // Create LinearScan before Lowering, so that Lowering can call LinearScan methods
-    // for determining whether locals are register candidates and (for xarch) whether
+    // Create the RA before Lowering, so that Lowering can call RA methods for
+    // determining whether locals are register candidates and (for xarch) whether
     // a node is a containable memory op.
-    m_pLinearScan = getLinearScanAllocator(this);
+    m_regAlloc = GetRegisterAllocator(this);
 
     // Lower
     //
-    m_pLowering = new (this, CMK_LSRA) Lowering(this, m_pLinearScan); // PHASE_LOWERING
+    m_pLowering = new (this, CMK_LSRA) Lowering(this, m_regAlloc); // PHASE_LOWERING
     m_pLowering->Run();
 
     // Set stack levels and analyze throw helper usage.
@@ -4988,7 +4988,7 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
     // Now that lowering is completed we can proceed to perform register allocation
     //
     auto linearScanPhase = [this] {
-        m_pLinearScan->doLinearScan();
+        m_regAlloc->doRegisterAllocation();
     };
     DoPhase(this, PHASE_LINEAR_SCAN, linearScanPhase);
 
@@ -5027,7 +5027,7 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
 #if TRACK_LSRA_STATS
     if (JitConfig.DisplayLsraStats() == 2)
     {
-        m_pLinearScan->dumpLsraStatsCsv(jitstdout());
+        m_regAlloc->dumpLsraStatsCsv(jitstdout());
     }
 #endif // TRACK_LSRA_STATS
 

src/coreclr/jit/compiler.h

@@ -1363,19 +1363,22 @@ enum class PhaseStatus : unsigned
 };
 
 // interface to hide linearscan implementation from rest of compiler
-class LinearScanInterface
+class RegAllocInterface
 {
 public:
-    virtual PhaseStatus doLinearScan()                                = 0;
+    virtual PhaseStatus doRegisterAllocation()                        = 0;
     virtual void        recordVarLocationsAtStartOfBB(BasicBlock* bb) = 0;
     virtual bool        willEnregisterLocalVars() const               = 0;
 #if TRACK_LSRA_STATS
     virtual void dumpLsraStatsCsv(FILE* file)     = 0;
     virtual void dumpLsraStatsSummary(FILE* file) = 0;
 #endif // TRACK_LSRA_STATS
+
+    virtual bool isRegCandidate(LclVarDsc* varDsc) = 0;
+    virtual bool isContainableMemoryOp(GenTree* node) = 0;
 };
 
-LinearScanInterface* getLinearScanAllocator(Compiler* comp);
+RegAllocInterface* GetRegisterAllocator(Compiler* comp);
 
 // This enumeration names the phases into which we divide compilation.  The phases should completely
 // partition a compilation.
@@ -5572,7 +5575,7 @@ class Compiler
 
     bool backendRequiresLocalVarLifetimes()
     {
-        return !opts.MinOpts() || m_pLinearScan->willEnregisterLocalVars();
+        return !opts.MinOpts() || m_regAlloc->willEnregisterLocalVars();
     }
 
     void fgLocalVarLiveness();
@@ -8230,8 +8233,8 @@ class Compiler
     bool rpMustCreateEBPFrame(INDEBUG(const char** wbReason));
 
 private:
-    Lowering*            m_pLowering = nullptr; // Lowering; needed to Lower IR that's added or modified after Lowering.
-    LinearScanInterface* m_pLinearScan = nullptr; // Linear Scan allocator
+    Lowering*          m_pLowering = nullptr; // Lowering; needed to Lower IR that's added or modified after Lowering.
+    RegAllocInterface* m_regAlloc = nullptr;  // Register allocator
 
 public:
     ArrayStack<ParameterRegisterLocalMapping>* m_paramRegLocalMappings = nullptr;

src/coreclr/jit/lower.h

@@ -29,23 +29,23 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 class Lowering final : public Phase
 {
 public:
-    inline Lowering(Compiler* compiler, LinearScanInterface* lsra)
+    inline Lowering(Compiler* compiler, RegAllocInterface* regAlloc)
         : Phase(compiler, PHASE_LOWERING)
         , vtableCallTemp(BAD_VAR_NUM)
 #ifdef TARGET_ARM64
         , m_blockIndirs(compiler->getAllocator(CMK_ArrayStack))
 #endif
     {
-        m_lsra = (LinearScan*)lsra;
-        assert(m_lsra);
+        m_regAlloc = static_cast<RegAllocImpl*>(regAlloc);
+        assert(m_regAlloc != nullptr);
     }
     virtual PhaseStatus DoPhase() override;
 
     // This variant of LowerRange is called from outside of the main Lowering pass,
     // so it creates its own instance of Lowering to do so.
     void LowerRange(BasicBlock* block, LIR::ReadOnlyRange& range)
     {
-        Lowering lowerer(comp, m_lsra);
+        Lowering lowerer(comp, m_regAlloc);
         lowerer.m_block = block;
 
         lowerer.LowerRange(range);
@@ -489,7 +489,7 @@ class Lowering final : public Phase
     // Return true if 'node' is a containable memory op.
     bool IsContainableMemoryOp(GenTree* node) const
     {
-        return m_lsra->isContainableMemoryOp(node);
+        return m_regAlloc->isContainableMemoryOp(node);
     }
 
     // Return true if 'childNode' is a containable memory op by its size relative to the 'parentNode'.
@@ -594,14 +594,14 @@ class Lowering final : public Phase
         // do an expensive check here. For non-candidates it is not harmful to set lvDoNotEnregister.
         if (varDsc->lvTracked && !varDsc->lvDoNotEnregister)
         {
-            assert(!m_lsra->isRegCandidate(varDsc));
+            assert(!m_regAlloc->isRegCandidate(varDsc));
             comp->lvaSetVarDoNotEnregister(lclNum DEBUG_ARG(DoNotEnregisterReason::LocalField));
         }
     }
 
     void RequireOutgoingArgSpace(GenTree* node, unsigned numBytes);
 
-    LinearScan*           m_lsra;
+    RegAllocImpl*         m_regAlloc;
     unsigned              vtableCallTemp;       // local variable we use as a temp for vtable calls
     mutable SideEffectSet m_scratchSideEffects; // SideEffectSet used for IsSafeToContainMem and isRMWIndirCandidate
     BasicBlock*           m_block;

src/coreclr/jit/lsra.cpp

@@ -36,7 +36,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
       That is, the destination register is one of the sources.  In this case, we must not use the same register for
       the non-RMW operand as for the destination.
 
-  Overview (doLinearScan):
+  Overview (doRegisterAllocation):
     - Walk all blocks, building intervals and RefPositions (buildIntervals)
     - Allocate registers (allocateRegisters)
     - Annotate nodes with register assignments (resolveRegisters)
@@ -824,7 +824,7 @@ void LinearScan::dumpOutVarToRegMap(BasicBlock* block)
 
 #endif // DEBUG
 
-LinearScanInterface* getLinearScanAllocator(Compiler* comp)
+RegAllocInterface* GetRegisterAllocator(Compiler* comp)
 {
     return new (comp, CMK_LSRA) LinearScan(comp);
 }
@@ -1314,15 +1314,15 @@ BasicBlock* LinearScan::getNextBlock()
 }
 
 //------------------------------------------------------------------------
-// doLinearScan: The main method for register allocation.
+// doRegisterAllocation: The main method for register allocation.
 //
 // Arguments:
 //    None
 //
 // Return Value:
 //    Suitable phase status
 //
-PhaseStatus LinearScan::doLinearScan()
+PhaseStatus LinearScan::doRegisterAllocation()
 {
     // Check to see whether we have any local variables to enregister.
     // We initialize this in the constructor based on opt settings,

src/coreclr/jit/lsra.h

@@ -622,7 +622,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 // to the next RefPosition in code order
 // THIS IS THE OPTION CURRENTLY BEING PURSUED
 
-class LinearScan : public LinearScanInterface
+class LinearScan : public RegAllocInterface
 {
     friend class RefPosition;
     friend class Interval;
@@ -634,7 +634,7 @@ class LinearScan : public LinearScanInterface
     LinearScan(Compiler* theCompiler);
 
     // This is the main driver
-    virtual PhaseStatus doLinearScan();
+    virtual PhaseStatus doRegisterAllocation();
 
     static bool isSingleRegister(SingleTypeRegSet regMask)
     {
@@ -983,9 +983,9 @@ class LinearScan : public LinearScanInterface
 
 public:
     // Used by Lowering when considering whether to split Longs, as well as by identifyCandidates().
-    bool isRegCandidate(LclVarDsc* varDsc);
+    virtual bool isRegCandidate(LclVarDsc* varDsc);
 
-    bool isContainableMemoryOp(GenTree* node);
+    virtual bool isContainableMemoryOp(GenTree* node);
 
 private:
     // Determine which locals are candidates for allocation
@@ -2199,6 +2199,8 @@ class LinearScan : public LinearScanInterface
     }
 };
 
+using RegAllocImpl = LinearScan;
+
 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XX                                                                           XX

src/coreclr/jit/regalloc.h

@@ -25,5 +25,4 @@ enum CanDoubleAlign
     DEFAULT_DOUBLE_ALIGN = CAN_DOUBLE_ALIGN
 };
 #endif
-
 #endif // REGALLOC_H_

src/coreclr/jit/regallocwasm.cpp

@@ -8,48 +8,48 @@
 
 #include "regallocwasm.h"
 
-LinearScanInterface* getLinearScanAllocator(Compiler* compiler)
+RegAllocInterface* GetRegisterAllocator(Compiler* compiler)
 {
-    return new (compiler->getAllocator(CMK_LSRA)) LinearScan(compiler);
+    return new (compiler->getAllocator(CMK_LSRA)) WasmRegAlloc(compiler);
 }
 
-LinearScan::LinearScan(Compiler* compiler)
+WasmRegAlloc::WasmRegAlloc(Compiler* compiler)
     : m_compiler(compiler)
 {
 }
 
-PhaseStatus LinearScan::doLinearScan()
+PhaseStatus WasmRegAlloc::doRegisterAllocation()
 {
     m_compiler->codeGen->setFramePointerUsed(false);
     return PhaseStatus::MODIFIED_NOTHING;
 }
 
-void LinearScan::recordVarLocationsAtStartOfBB(BasicBlock* bb)
+void WasmRegAlloc::recordVarLocationsAtStartOfBB(BasicBlock* bb)
 {
 }
 
-bool LinearScan::willEnregisterLocalVars() const
+bool WasmRegAlloc::willEnregisterLocalVars() const
 {
     return m_compiler->compEnregLocals();
 }
 
 #if TRACK_LSRA_STATS
-void LinearScan::dumpLsraStatsCsv(FILE* file)
+void WasmRegAlloc::dumpLsraStatsCsv(FILE* file)
 {
 }
 
-void LinearScan::dumpLsraStatsSummary(FILE* file)
+void WasmRegAlloc::dumpLsraStatsSummary(FILE* file)
 {
 }
 #endif // TRACK_LSRA_STATS
 
-bool LinearScan::isRegCandidate(LclVarDsc* varDsc)
+bool WasmRegAlloc::isRegCandidate(LclVarDsc* varDsc)
 {
     NYI_WASM("isRegCandidate");
     return false;
 }
 
-bool LinearScan::isContainableMemoryOp(GenTree* node)
+bool WasmRegAlloc::isContainableMemoryOp(GenTree* node)
 {
     NYI_WASM("isContainableMemoryOp");
     return false;

src/coreclr/jit/regallocwasm.h

@@ -3,15 +3,14 @@
 
 #pragma once
 
-// TODO-WASM-Factoring: rename the abstractions related to register allocation to make them less LSRA-specific.
-class LinearScan : public LinearScanInterface
+class WasmRegAlloc : public RegAllocInterface
 {
     Compiler* m_compiler;
 
 public:
-    LinearScan(Compiler* compiler);
+    WasmRegAlloc(Compiler* compiler);
 
-    virtual PhaseStatus doLinearScan();
+    virtual PhaseStatus doRegisterAllocation();
     virtual void        recordVarLocationsAtStartOfBB(BasicBlock* bb);
     virtual bool        willEnregisterLocalVars() const;
 #if TRACK_LSRA_STATS
@@ -22,3 +21,5 @@ class LinearScan : public LinearScanInterface
     bool isRegCandidate(LclVarDsc* varDsc);
     bool isContainableMemoryOp(GenTree* node);
 };
+
+using RegAllocImpl = WasmRegAlloc;