Merge pull request #14658 from mikedn/legacy-reg-track

Ifdef out legacy RegTracker code

9 files changed, 51 insertions, 31 deletions

diff --git a/src/jit/codegen.h b/src/jit/codegen.h
index 6261e42a14..879ee7bfa6 100644
--- a/src/jit/codegen.h
+++ b/src/jit/codegen.h
@@ -141,6 +141,7 @@ private:
     }
 #endif // REG_OPT_RSVD
 
+#ifdef LEGACY_BACKEND
     regNumber findStkLclInReg(unsigned lclNum)
     {
 #ifdef DEBUG
@@ -148,6 +149,7 @@ private:
 #endif
         return regTracker.rsLclIsInReg(lclNum);
     }
+#endif
 
     //-------------------------------------------------------------------------
 
@@ -817,7 +819,9 @@ protected:
 public:
     void instInit();
 
+#ifdef LEGACY_BACKEND
     regNumber genGetZeroRegister();
+#endif
 
     void instGen(instruction ins);
 #ifdef _TARGET_XARCH_
diff --git a/src/jit/codegenarm.cpp b/src/jit/codegenarm.cpp
index fdba145dc5..69640b739d 100644
--- a/src/jit/codegenarm.cpp
+++ b/src/jit/codegenarm.cpp
@@ -1720,7 +1720,6 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
     }
 
     regTracker.rsTrashRegSet(RBM_CALLEE_TRASH);
-    regTracker.rsTrashRegsForGCInterruptability();
 }
 
 //------------------------------------------------------------------------
diff --git a/src/jit/codegenarm64.cpp b/src/jit/codegenarm64.cpp
index aabb151561..4aa741558e 100644
--- a/src/jit/codegenarm64.cpp
+++ b/src/jit/codegenarm64.cpp
@@ -3689,7 +3689,6 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
 
     regMaskTP killMask = compiler->compHelperCallKillSet((CorInfoHelpFunc)helper);
     regTracker.rsTrashRegSet(killMask);
-    regTracker.rsTrashRegsForGCInterruptability();
 }
 
 /*****************************************************************************
diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp
index 64f38ae080..d557d42f5e 100644
--- a/src/jit/codegencommon.cpp
+++ b/src/jit/codegencommon.cpp
@@ -1609,10 +1609,12 @@ void CodeGen::genDefineTempLabel(BasicBlock* label)
     label->bbEmitCookie =
         getEmitter()->emitAddLabel(gcInfo.gcVarPtrSetCur, gcInfo.gcRegGCrefSetCur, gcInfo.gcRegByrefSetCur);
 
+#ifdef LEGACY_BACKEND
     /* gcInfo.gcRegGCrefSetCur does not account for redundant load-suppression
        of GC vars, and the emitter will not know about */
 
     regTracker.rsTrackRegClrPtr();
+#endif
 }
 
 /*****************************************************************************
diff --git a/src/jit/codegeninterface.h b/src/jit/codegeninterface.h
index a993ddb629..c1c912ad6a 100644
--- a/src/jit/codegeninterface.h
+++ b/src/jit/codegeninterface.h
@@ -105,10 +105,12 @@ public:
     RegTracker regTracker;
 
 public:
+#ifdef LEGACY_BACKEND
     void trashReg(regNumber reg)
     {
         regTracker.rsTrackRegTrash(reg);
     }
+#endif
 
 protected:
     Compiler* compiler;
diff --git a/src/jit/codegenxarch.cpp b/src/jit/codegenxarch.cpp
index f1730b9999..aff57d98fa 100644
--- a/src/jit/codegenxarch.cpp
+++ b/src/jit/codegenxarch.cpp
@@ -8606,7 +8606,6 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
     // clang-format on
 
     regTracker.rsTrashRegSet(killMask);
-    regTracker.rsTrashRegsForGCInterruptability();
 }
 
 #if !defined(_TARGET_64BIT_)
diff --git a/src/jit/instr.cpp b/src/jit/instr.cpp
index f654455b78..f83bd45719 100644
--- a/src/jit/instr.cpp
+++ b/src/jit/instr.cpp
@@ -1870,18 +1870,13 @@ AGAIN:
     }
 }
 
+#ifdef LEGACY_BACKEND
 regNumber CodeGen::genGetZeroRegister()
 {
-    regNumber zeroReg = REG_NA;
-
-#if REDUNDANT_LOAD
-
     // Is the constant already in some register?
 
-    zeroReg = regTracker.rsIconIsInReg(0);
-#endif
+    regNumber zeroReg = regTracker.rsIconIsInReg(0);
 
-#ifdef LEGACY_BACKEND
     if (zeroReg == REG_NA)
     {
         regMaskTP freeMask = regSet.rsRegMaskFree();
@@ -1906,7 +1901,6 @@ regNumber CodeGen::genGetZeroRegister()
             genSetRegToIcon(zeroReg, 0, TYP_INT);
         }
     }
-#endif // !LEGACY_BACKEND
 
     return zeroReg;
 }
@@ -1916,7 +1910,6 @@ regNumber CodeGen::genGetZeroRegister()
  *  Generate an instruction that has one operand given by a tree (which has
  *  been made addressable) and another that is an integer constant.
  */
-#ifdef LEGACY_BACKEND
 void CodeGen::inst_TT_IV(instruction ins, GenTreePtr tree, ssize_t val, unsigned offs, emitAttr size, insFlags flags)
 {
     bool sizeInferred = false;
@@ -2247,9 +2240,7 @@ AGAIN:
             assert(!"invalid address");
     }
 }
-#endif // LEGACY_BACKEND
 
-#ifdef LEGACY_BACKEND
 /*****************************************************************************
  *
  *  Generate an instruction that has one operand given by a register and the
diff --git a/src/jit/regset.cpp b/src/jit/regset.cpp
index 44312dab42..a42a6cede3 100644
--- a/src/jit/regset.cpp
+++ b/src/jit/regset.cpp
@@ -407,6 +407,7 @@ void RegSet::rsUnlockReg(regMaskTP regMask, regMaskTP usedMask)
 }
 #endif // LEGACY_BACKEND
 
+#ifdef LEGACY_BACKEND
 /*****************************************************************************
  *
  *  Assume all registers contain garbage (called at start of codegen and when
@@ -419,6 +420,7 @@ void RegTracker::rsTrackRegClr()
     assert(RV_TRASH == 0);
     memset(rsRegValues, 0, sizeof(rsRegValues));
 }
+#endif // LEGACY_BACKEND
 
 /*****************************************************************************
  *
@@ -432,11 +434,14 @@ void RegTracker::rsTrackRegTrash(regNumber reg)
 
     regSet->rsSetRegsModified(genRegMask(reg));
 
+#ifdef LEGACY_BACKEND
     /* Record the new value for the register */
 
     rsRegValues[reg].rvdKind = RV_TRASH;
+#endif // LEGACY_BACKEND
 }
 
+#ifdef LEGACY_BACKEND
 /*****************************************************************************
  *
  *  calls rsTrackRegTrash on the set of registers in regmask
@@ -460,6 +465,7 @@ void RegTracker::rsTrackRegMaskTrash(regMaskTP regMask)
         }
     }
 }
+#endif // LEGACY_BACKEND
 
 /*****************************************************************************/
 
@@ -472,12 +478,15 @@ void RegTracker::rsTrackRegIntCns(regNumber reg, ssize_t val)
 
     regSet->rsSetRegsModified(genRegMask(reg));
 
+#ifdef LEGACY_BACKEND
     /* Record the new value for the register */
 
     rsRegValues[reg].rvdKind      = RV_INT_CNS;
     rsRegValues[reg].rvdIntCnsVal = val;
+#endif
 }
 
+#ifdef LEGACY_BACKEND
 /*****************************************************************************/
 
 // inline
@@ -557,8 +566,6 @@ void RegTracker::rsTrackRegAssign(GenTree* op1, GenTree* op2)
     }
 }
 
-#ifdef LEGACY_BACKEND
-
 /*****************************************************************************
  *
  *  Given a regmask, find the best regPairNo that can be formed
@@ -1371,9 +1378,11 @@ void RegTracker::rsTrackRegLclVar(regNumber reg, unsigned var)
 #if CPU_HAS_FP_SUPPORT
     assert(varTypeIsFloating(varDsc->TypeGet()) == false);
 #endif
+#ifdef LEGACY_BACKEND
     // Kill the register before doing anything in case we take a
     // shortcut out of here
     rsRegValues[reg].rvdKind = RV_TRASH;
+#endif
 
     if (compiler->lvaTable[var].lvAddrExposed)
     {
@@ -1384,7 +1393,7 @@ void RegTracker::rsTrackRegLclVar(regNumber reg, unsigned var)
 
     regSet->rsSetRegsModified(genRegMask(reg));
 
-#if REDUNDANT_LOAD
+#ifdef LEGACY_BACKEND
 
     /* Is the variable a pointer? */
 
@@ -1409,8 +1418,6 @@ void RegTracker::rsTrackRegLclVar(regNumber reg, unsigned var)
         return;
     }
 
-#endif
-
 #ifdef DEBUG
     if (compiler->verbose)
     {
@@ -1431,10 +1438,12 @@ void RegTracker::rsTrackRegLclVar(regNumber reg, unsigned var)
     }
 
     rsRegValues[reg].rvdLclVarNum = var;
+#endif // LEGACY_BACKEND
 }
 
 /*****************************************************************************/
 
+#ifdef LEGACY_BACKEND
 void RegTracker::rsTrackRegSwap(regNumber reg1, regNumber reg2)
 {
     RegValDsc tmp;
@@ -1443,6 +1452,7 @@ void RegTracker::rsTrackRegSwap(regNumber reg1, regNumber reg2)
     rsRegValues[reg1] = rsRegValues[reg2];
     rsRegValues[reg2] = tmp;
 }
+#endif // LEGACY_BACKEND
 
 void RegTracker::rsTrackRegCopy(regNumber reg1, regNumber reg2)
 {
@@ -1453,7 +1463,9 @@ void RegTracker::rsTrackRegCopy(regNumber reg1, regNumber reg2)
 
     regSet->rsSetRegsModified(genRegMask(reg1));
 
+#ifdef LEGACY_BACKEND
     rsRegValues[reg1] = rsRegValues[reg2];
+#endif // LEGACY_BACKEND
 }
 
 #ifdef LEGACY_BACKEND
@@ -2904,10 +2916,7 @@ var_types RegSet::rsRmvMultiReg(regNumber reg)
     SpillDsc::freeDsc(this, dsc);
     return type;
 }
-#endif // LEGACY_BACKEND
-
 /*****************************************************************************/
-#if REDUNDANT_LOAD
 /*****************************************************************************
  *
  *  Search for a register which contains the given constant value.
@@ -3173,6 +3182,7 @@ void RegTracker::rsTrashLcl(unsigned var)
         }
     }
 }
+#endif // LEGACY_BACKEND
 
 /*****************************************************************************
  *
@@ -3197,6 +3207,7 @@ void RegTracker::rsTrashRegSet(regMaskTP regMask)
     }
 }
 
+#ifdef LEGACY_BACKEND
 /*****************************************************************************
  *
  *  Return a mask of registers that hold no useful value.
@@ -3222,7 +3233,7 @@ regMaskTP RegTracker::rsUselessRegs()
 }
 
 /*****************************************************************************/
-#endif // REDUNDANT_LOAD
+#endif // LEGACY_BACKEND
 /*****************************************************************************/
 
 /*
@@ -3845,7 +3856,7 @@ void RegSet::rsSpillChk()
 #endif
 
 /*****************************************************************************/
-#if REDUNDANT_LOAD
+#ifdef LEGACY_BACKEND
 
 // inline
 bool RegTracker::rsIconIsInReg(ssize_t val, regNumber reg)
@@ -3862,5 +3873,5 @@ bool RegTracker::rsIconIsInReg(ssize_t val, regNumber reg)
     return false;
 }
 
-#endif // REDUNDANT_LOAD
+#endif // LEGACY_BACKEND
 /*****************************************************************************/
diff --git a/src/jit/regset.h b/src/jit/regset.h
index 9af5200290..d16cd95502 100644
--- a/src/jit/regset.h
+++ b/src/jit/regset.h
@@ -30,6 +30,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 */
 
+#ifdef LEGACY_BACKEND
 /*****************************************************************************
 *
 *  Keep track of the current state of each register. This is intended to be
@@ -45,6 +46,7 @@ enum regValKind
     RV_LCL_VAR_LNG_LO, // lower half of long local variable
     RV_LCL_VAR_LNG_HI,
 };
+#endif // LEGACY_BACKEND
 
 /*****************************************************************************/
 
@@ -403,6 +405,7 @@ private:
 //  Only integer registers are tracked.
 //
 
+#ifdef LEGACY_BACKEND
 struct RegValDsc
 {
     regValKind rvdKind;
@@ -411,32 +414,44 @@ struct RegValDsc
         unsigned rvdLclVarNum; // for rvdKind == RV_LCL_VAR, RV_LCL_VAR_LNG_LO, RV_LCL_VAR_LNG_HI
     };
 };
+#endif // LEGACY_BACKEND
 
 class RegTracker
 {
     Compiler* compiler;
     RegSet*   regSet;
+#ifdef LEGACY_BACKEND
     RegValDsc rsRegValues[REG_COUNT];
+#endif
 
 public:
     void rsTrackInit(Compiler* comp, RegSet* rs)
     {
         compiler = comp;
         regSet   = rs;
+#ifdef LEGACY_BACKEND
         rsTrackRegClr();
+#endif
     }
 
+#ifdef LEGACY_BACKEND
     void rsTrackRegClr();
     void rsTrackRegClrPtr();
+#endif // LEGACY_BACKEND
     void rsTrackRegTrash(regNumber reg);
+#ifdef LEGACY_BACKEND
     void rsTrackRegMaskTrash(regMaskTP regMask);
     regMaskTP rsTrashRegsForGCInterruptability();
+#endif // LEGACY_BACKEND
     void rsTrackRegIntCns(regNumber reg, ssize_t val);
     void rsTrackRegLclVar(regNumber reg, unsigned var);
+#ifdef LEGACY_BACKEND
     void rsTrackRegLclVarLng(regNumber reg, unsigned var, bool low);
     bool rsTrackIsLclVarLng(regValKind rvKind);
     void rsTrackRegClsVar(regNumber reg, GenTreePtr clsVar);
+#endif // LEGACY_BACKEND
     void rsTrackRegCopy(regNumber reg1, regNumber reg2);
+#ifdef LEGACY_BACKEND
     void rsTrackRegSwap(regNumber reg1, regNumber reg2);
     void rsTrackRegAssign(GenTree* op1, GenTree* op2);
 
@@ -445,16 +460,14 @@ public:
     regNumber rsLclIsInReg(unsigned var);
     regPairNo rsLclIsInRegPair(unsigned var);
 
-//---------------------- Load suppression ---------------------------------
-
-#if REDUNDANT_LOAD
+    //---------------------- Load suppression ---------------------------------
 
     void rsTrashLclLong(unsigned var);
     void rsTrashLcl(unsigned var);
+#endif // LEGACY_BACKEND
     void rsTrashRegSet(regMaskTP regMask);
-
+#ifdef LEGACY_BACKEND
     regMaskTP rsUselessRegs();
-
-#endif // REDUNDANT_LOAD
+#endif // LEGACY_BACKEND
 };
 #endif // _REGSET_H