JIT: Eliminate RegTracker (#18179) (#18230)

* Replace regTracker.rsTrackRegTrash with regSet.verifyRegUsed

* Replace regTracker.rsTrackRegCopy with regSet.verifyRegUsed

* Replace regTracker.rsTrackRegIntCns with regSet.verifyRegUsed

* Replace regTracker.rsTrashRegSet with regSet.verifyRegistersUsed

* Move verifyReg* method implementation from header file to implementation file

* Replace regTracker.rsTrackRegLclVar with regSet.verifyRegistersUsed

* Eliminate RegTracker

* Fixed the funclet prolog special case

* Experiment - Changing the verification code to actually set the mask

* Adding function headers

* Removed a few trailing spaces

diff --git a/src/jit/codegenarm.cpp b/src/jit/codegenarm.cpp
index d361c3d..a378545 100644 (file)
--- a/src/jit/codegenarm.cpp
+++ b/src/jit/codegenarm.cpp
@@ -119,7 +119,7 @@ void CodeGen::instGen_Set_Reg_To_Imm(emitAttr size, regNumber reg, ssize_t imm,
         }
     }
 
-    regTracker.rsTrackRegIntCns(reg, imm);
+    regSet.verifyRegUsed(reg);
 }
 
 //------------------------------------------------------------------------
@@ -143,7 +143,7 @@ void CodeGen::genSetRegToConst(regNumber targetReg, var_types targetType, GenTre
             if (con->ImmedValNeedsReloc(compiler))
             {
                 instGen_Set_Reg_To_Imm(EA_HANDLE_CNS_RELOC, targetReg, cnsVal);
-                regTracker.rsTrackRegTrash(targetReg);
+                regSet.verifyRegUsed(targetReg);
             }
             else
             {
@@ -1599,7 +1599,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
         else
         {
             getEmitter()->emitIns_R_AI(INS_ldr, EA_PTR_DSP_RELOC, callTargetReg, (ssize_t)pAddr);
-            regTracker.rsTrackRegTrash(callTargetReg);
+            regSet.verifyRegUsed(callTargetReg);
         }
 
         getEmitter()->emitIns_Call(emitter::EC_INDIR_R, compiler->eeFindHelper(helper),
@@ -1624,7 +1624,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
                                    (CorInfoHelpFunc)helper == CORINFO_HELP_PROF_FCN_LEAVE);
     }
 
-    regTracker.rsTrashRegSet(RBM_CALLEE_TRASH);
+    regSet.verifyRegistersUsed(RBM_CALLEE_TRASH);
 }
 
 //------------------------------------------------------------------------

diff --git a/src/jit/codegenarm64.cpp b/src/jit/codegenarm64.cpp
index eaaf5ba..400c550 100644 (file)
--- a/src/jit/codegenarm64.cpp
+++ b/src/jit/codegenarm64.cpp
@@ -118,7 +118,7 @@ bool CodeGen::genInstrWithConstant(instruction ins,
 
         // first we load the immediate into tmpReg
         instGen_Set_Reg_To_Imm(size, tmpReg, imm);
-        regTracker.rsTrackRegTrash(tmpReg);
+        regSet.verifyRegUsed(tmpReg);
 
         // when we are in an unwind code region
         // we record the extra instructions using unwindPadding()
@@ -1002,7 +1002,7 @@ void CodeGen::genFuncletProlog(BasicBlock* block)
         // Load the CallerSP of the main function (stored in the PSP of the dynamically containing funclet or function)
         genInstrWithConstant(ins_Load(TYP_I_IMPL), EA_PTRSIZE, REG_R1, REG_R1,
                              genFuncletInfo.fiCallerSP_to_PSP_slot_delta, REG_R2, false);
-        regTracker.rsTrackRegTrash(REG_R1);
+        regSet.verifyRegUsed(REG_R1);
 
         // Store the PSP value (aka CallerSP)
         genInstrWithConstant(ins_Store(TYP_I_IMPL), EA_PTRSIZE, REG_R1, REG_SPBASE,
@@ -1019,7 +1019,7 @@ void CodeGen::genFuncletProlog(BasicBlock* block)
         // compute the CallerSP, given the frame pointer. x3 is scratch.
         genInstrWithConstant(INS_add, EA_PTRSIZE, REG_R3, REG_FPBASE, -genFuncletInfo.fiFunction_CallerSP_to_FP_delta,
                              REG_R2, false);
-        regTracker.rsTrackRegTrash(REG_R3);
+        regSet.verifyRegUsed(REG_R3);
 
         genInstrWithConstant(ins_Store(TYP_I_IMPL), EA_PTRSIZE, REG_R3, REG_SPBASE,
                              genFuncletInfo.fiSP_to_PSP_slot_delta, REG_R2, false);
@@ -1425,7 +1425,7 @@ void CodeGen::instGen_Set_Reg_To_Imm(emitAttr size, regNumber reg, ssize_t imm,
         }
     }
 
-    regTracker.rsTrackRegIntCns(reg, imm);
+    regSet.verifyRegUsed(reg);
 }
 
 /***********************************************************************************
@@ -1448,7 +1448,7 @@ void CodeGen::genSetRegToConst(regNumber targetReg, var_types targetType, GenTre
             if (con->ImmedValNeedsReloc(compiler))
             {
                 instGen_Set_Reg_To_Imm(EA_HANDLE_CNS_RELOC, targetReg, cnsVal);
-                regTracker.rsTrackRegTrash(targetReg);
+                regSet.verifyRegUsed(targetReg);
             }
             else
             {
@@ -3663,7 +3663,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
                                emitter::emitNoGChelper(helper));
 
     regMaskTP killMask = compiler->compHelperCallKillSet((CorInfoHelpFunc)helper);
-    regTracker.rsTrashRegSet(killMask);
+    regSet.verifyRegistersUsed(killMask);
 }
 
 #ifdef FEATURE_SIMD

diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp
index d595143..7f43fee 100644 (file)
--- a/src/jit/codegencommon.cpp
+++ b/src/jit/codegencommon.cpp
@@ -112,7 +112,6 @@ CodeGen::CodeGen(Compiler* theCompiler) : CodeGenInterface(theCompiler)
     maxNestedAlignment = 0;
 #endif
 
-    regTracker.rsTrackInit(compiler, &regSet);
     gcInfo.regSet        = &regSet;
     m_cgEmitter          = new (compiler->getAllocator()) emitter();
     m_cgEmitter->codeGen = this;
@@ -4173,8 +4172,8 @@ void CodeGen::genFnPrologCalleeRegArgs(regNumber xtraReg, bool* pXtraRegClobbere
                 noway_assert(varDscDest->lvArgReg == varDscSrc->lvRegNum);
 
                 getEmitter()->emitIns_R_R(INS_xchg, size, varDscSrc->lvRegNum, varDscSrc->lvArgReg);
-                regTracker.rsTrackRegTrash(varDscSrc->lvRegNum);
-                regTracker.rsTrackRegTrash(varDscSrc->lvArgReg);
+                regSet.verifyRegUsed(varDscSrc->lvRegNum);
+                regSet.verifyRegUsed(varDscSrc->lvArgReg);
 
                 /* mark both arguments as processed */
                 regArgTab[destReg].processed = true;
@@ -4243,7 +4242,7 @@ void CodeGen::genFnPrologCalleeRegArgs(regNumber xtraReg, bool* pXtraRegClobbere
 
                 getEmitter()->emitIns_R_R(insCopy, size, xtraReg, begRegNum);
 
-                regTracker.rsTrackRegCopy(xtraReg, begRegNum);
+                regSet.verifyRegUsed(xtraReg);
 
                 *pXtraRegClobbered = true;
 
@@ -4260,7 +4259,7 @@ void CodeGen::genFnPrologCalleeRegArgs(regNumber xtraReg, bool* pXtraRegClobbere
 
                     getEmitter()->emitIns_R_R(insCopy, size, destRegNum, srcRegNum);
 
-                    regTracker.rsTrackRegCopy(destRegNum, srcRegNum);
+                    regSet.verifyRegUsed(destRegNum);
 
                     /* mark 'src' as processed */
                     noway_assert(srcReg < argMax);
@@ -4312,7 +4311,7 @@ void CodeGen::genFnPrologCalleeRegArgs(regNumber xtraReg, bool* pXtraRegClobbere
 
                 getEmitter()->emitIns_R_R(insCopy, size, destRegNum, xtraReg);
 
-                regTracker.rsTrackRegCopy(destRegNum, xtraReg);
+                regSet.verifyRegUsed(destRegNum);
 
                 psiMoveToReg(varNumSrc);
 
@@ -4632,7 +4631,7 @@ void CodeGen::genEnregisterIncomingStackArgs()
         assert(regNum != REG_STK);
 
         getEmitter()->emitIns_R_S(ins_Load(type), emitTypeSize(type), regNum, varNum, 0);
-        regTracker.rsTrackRegTrash(regNum);
+        regSet.verifyRegUsed(regNum);
 
         psiMoveToReg(varNum);
     }
@@ -5328,7 +5327,7 @@ void CodeGen::genAllocLclFrame(unsigned frameSize, regNumber initReg, bool* pIni
 #if CPU_LOAD_STORE_ARCH
         instGen_Set_Reg_To_Imm(EA_PTRSIZE, initReg, -(ssize_t)pageSize);
         getEmitter()->emitIns_R_R_R(INS_ldr, EA_4BYTE, initReg, REG_SPBASE, initReg);
-        regTracker.rsTrackRegTrash(initReg);
+        regSet.verifyRegUsed(initReg);
         *pInitRegZeroed = false; // The initReg does not contain zero
 #else
         getEmitter()->emitIns_AR_R(INS_TEST, EA_PTRSIZE, REG_EAX, REG_SPBASE, -(int)pageSize);
@@ -5339,7 +5338,7 @@ void CodeGen::genAllocLclFrame(unsigned frameSize, regNumber initReg, bool* pIni
 #if CPU_LOAD_STORE_ARCH
             instGen_Set_Reg_To_Imm(EA_PTRSIZE, initReg, -2 * (ssize_t)pageSize);
             getEmitter()->emitIns_R_R_R(INS_ldr, EA_4BYTE, initReg, REG_SPBASE, initReg);
-            regTracker.rsTrackRegTrash(initReg);
+            regSet.verifyRegUsed(initReg);
 #else
             getEmitter()->emitIns_AR_R(INS_TEST, EA_PTRSIZE, REG_EAX, REG_SPBASE, -2 * (int)pageSize);
 #endif
@@ -5426,7 +5425,7 @@ void CodeGen::genAllocLclFrame(unsigned frameSize, regNumber initReg, bool* pIni
         noway_assert((ssize_t)(int)frameSize == (ssize_t)frameSize); // make sure framesize safely fits within an int
         instGen_Set_Reg_To_Imm(EA_PTRSIZE, rLimit, -(int)frameSize);
         getEmitter()->emitIns_R_R_R(INS_ldr, EA_4BYTE, rTemp, REG_SPBASE, rOffset);
-        regTracker.rsTrackRegTrash(rTemp);
+        regSet.verifyRegUsed(rTemp);
 #if defined(_TARGET_ARM_)
         getEmitter()->emitIns_R_I(INS_sub, EA_PTRSIZE, rOffset, pageSize);
 #elif defined(_TARGET_ARM64_)
@@ -5540,7 +5539,7 @@ void CodeGen::genAllocLclFrame(unsigned frameSize, regNumber initReg, bool* pIni
         {
             // pop eax
             inst_RV(INS_pop, REG_SECRET_STUB_PARAM, TYP_I_IMPL);
-            regTracker.rsTrackRegTrash(REG_SECRET_STUB_PARAM);
+            regSet.verifyRegUsed(REG_SECRET_STUB_PARAM);
         }
 #endif // _TARGET_XARCH_
 
@@ -6455,14 +6454,14 @@ void CodeGen::genZeroInitFrame(int untrLclHi, int untrLclLo, regNumber initReg,
         {
             noway_assert(regSet.rsRegsModified(RBM_R12));
             inst_RV_RV(INS_mov, REG_R12, REG_RCX);
-            regTracker.rsTrackRegTrash(REG_R12);
+            regSet.verifyRegUsed(REG_R12);
         }
 
         if (intRegState.rsCalleeRegArgMaskLiveIn & RBM_RDI)
         {
             noway_assert(regSet.rsRegsModified(RBM_R13));
             inst_RV_RV(INS_mov, REG_R13, REG_RDI);
-            regTracker.rsTrackRegTrash(REG_R13);
+            regSet.verifyRegUsed(REG_R13);
         }
 #else  // !UNIX_AMD64_ABI
         // For register arguments we may have to save ECX
@@ -6470,14 +6469,14 @@ void CodeGen::genZeroInitFrame(int untrLclHi, int untrLclLo, regNumber initReg,
         {
             noway_assert(regSet.rsRegsModified(RBM_ESI));
             inst_RV_RV(INS_mov, REG_ESI, REG_ECX);
-            regTracker.rsTrackRegTrash(REG_ESI);
+            regSet.verifyRegUsed(REG_ESI);
         }
 #endif // !UNIX_AMD64_ABI
 
         noway_assert((intRegState.rsCalleeRegArgMaskLiveIn & RBM_EAX) == 0);
 
         getEmitter()->emitIns_R_AR(INS_lea, EA_PTRSIZE, REG_EDI, genFramePointerReg(), untrLclLo);
-        regTracker.rsTrackRegTrash(REG_EDI);
+        regSet.verifyRegUsed(REG_EDI);
 
         inst_RV_IV(INS_mov, REG_ECX, (untrLclHi - untrLclLo) / sizeof(int), EA_4BYTE);
         instGen_Set_Reg_To_Zero(EA_PTRSIZE, REG_EAX);
@@ -6671,7 +6670,7 @@ void CodeGen::genReportGenericContextArg(regNumber initReg, bool* pInitRegZeroed
 
         // mov reg, [compiler->info.compTypeCtxtArg]
         getEmitter()->emitIns_R_AR(ins_Load(TYP_I_IMPL), EA_PTRSIZE, reg, genFramePointerReg(), varDsc->lvStkOffs);
-        regTracker.rsTrackRegTrash(reg);
+        regSet.verifyRegUsed(reg);
     }
 
 #if CPU_LOAD_STORE_ARCH
@@ -6729,12 +6728,12 @@ void CodeGen::genSetGSSecurityCookie(regNumber initReg, bool* pInitRegZeroed)
 #if CPU_LOAD_STORE_ARCH
         instGen_Set_Reg_To_Imm(EA_PTR_DSP_RELOC, reg, (ssize_t)compiler->gsGlobalSecurityCookieAddr);
         getEmitter()->emitIns_R_R_I(ins_Load(TYP_I_IMPL), EA_PTRSIZE, reg, reg, 0);
-        regTracker.rsTrackRegTrash(reg);
+        regSet.verifyRegUsed(reg);
 #else
         //  mov   reg, dword ptr [compiler->gsGlobalSecurityCookieAddr]
         //  mov   dword ptr [frame.GSSecurityCookie], reg
         getEmitter()->emitIns_R_AI(INS_mov, EA_PTR_DSP_RELOC, reg, (ssize_t)compiler->gsGlobalSecurityCookieAddr);
-        regTracker.rsTrackRegTrash(reg);
+        regSet.verifyRegUsed(reg);
 #endif
         getEmitter()->emitIns_S_R(ins_Store(TYP_I_IMPL), EA_PTRSIZE, reg, compiler->lvaGSSecurityCookie, 0);
     }
@@ -6987,7 +6986,7 @@ void CodeGen::genProfilingEnterCallback(regNumber initReg, bool* pInitRegZeroed)
     if (compiler->compProfilerMethHndIndirected)
     {
         getEmitter()->emitIns_R_AI(INS_ldr, EA_PTR_DSP_RELOC, argReg, (ssize_t)compiler->compProfilerMethHnd);
-        regTracker.rsTrackRegTrash(argReg);
+        regSet.verifyRegUsed(argReg);
     }
     else
     {
@@ -7261,7 +7260,7 @@ void CodeGen::genProfilingLeaveCallback(unsigned helper /*= CORINFO_HELP_PROF_FC
         }
 
         getEmitter()->emitIns_R_R(INS_mov, attr, REG_PROFILER_RET_SCRATCH, REG_ARG_0);
-        regTracker.rsTrackRegTrash(REG_PROFILER_RET_SCRATCH);
+        regSet.verifyRegUsed(REG_PROFILER_RET_SCRATCH);
         gcInfo.gcMarkRegSetNpt(RBM_ARG_0);
         r0Trashed = true;
     }
@@ -7269,7 +7268,7 @@ void CodeGen::genProfilingLeaveCallback(unsigned helper /*= CORINFO_HELP_PROF_FC
     if (compiler->compProfilerMethHndIndirected)
     {
         getEmitter()->emitIns_R_AI(INS_ldr, EA_PTR_DSP_RELOC, REG_ARG_0, (ssize_t)compiler->compProfilerMethHnd);
-        regTracker.rsTrackRegTrash(REG_ARG_0);
+        regSet.verifyRegUsed(REG_ARG_0);
     }
     else
     {
@@ -7284,7 +7283,7 @@ void CodeGen::genProfilingLeaveCallback(unsigned helper /*= CORINFO_HELP_PROF_FC
     if (r0Trashed)
     {
         getEmitter()->emitIns_R_R(INS_mov, attr, REG_ARG_0, REG_PROFILER_RET_SCRATCH);
-        regTracker.rsTrackRegTrash(REG_ARG_0);
+        regSet.verifyRegUsed(REG_ARG_0);
         gcInfo.gcMarkRegSetNpt(RBM_PROFILER_RET_SCRATCH);
     }
 
@@ -8250,7 +8249,7 @@ void CodeGen::genFnProlog()
     if (compiler->compLocallocUsed)
     {
         getEmitter()->emitIns_R_R(INS_mov, EA_4BYTE, REG_SAVED_LOCALLOC_SP, REG_SPBASE);
-        regTracker.rsTrackRegTrash(REG_SAVED_LOCALLOC_SP);
+        regSet.verifyRegUsed(REG_SAVED_LOCALLOC_SP);
         compiler->unwindSetFrameReg(REG_SAVED_LOCALLOC_SP, 0);
     }
 #endif // _TARGET_ARMARCH_
@@ -8545,7 +8544,7 @@ void CodeGen::genFnProlog()
 
         // MOV EAX, <VARARGS HANDLE>
         getEmitter()->emitIns_R_S(ins_Load(TYP_I_IMPL), EA_PTRSIZE, REG_EAX, compiler->info.compArgsCount - 1, 0);
-        regTracker.rsTrackRegTrash(REG_EAX);
+        regSet.verifyRegUsed(REG_EAX);
 
         // MOV EAX, [EAX]
         getEmitter()->emitIns_R_AR(ins_Load(TYP_I_IMPL), EA_PTRSIZE, REG_EAX, REG_EAX, 0);
@@ -8567,7 +8566,7 @@ void CodeGen::genFnProlog()
             if (varDsc->lvRegNum != REG_EAX)
             {
                 getEmitter()->emitIns_R_R(INS_mov, EA_PTRSIZE, varDsc->lvRegNum, REG_EAX);
-                regTracker.rsTrackRegTrash(varDsc->lvRegNum);
+                regSet.verifyRegUsed(varDsc->lvRegNum);
             }
         }
         else
@@ -8770,7 +8769,7 @@ void CodeGen::genFnEpilog(BasicBlock* block)
                     if (addrInfo.accessType == IAT_PVALUE)
                     {
                         getEmitter()->emitIns_R_R_I(INS_ldr, EA_PTRSIZE, indCallReg, indCallReg, 0);
-                        regTracker.rsTrackRegTrash(indCallReg);
+                        regSet.verifyRegUsed(indCallReg);
                     }
                     break;
 
@@ -8942,7 +8941,7 @@ void CodeGen::genFnEpilog(BasicBlock* block)
             if ((compiler->compLclFrameSize == TARGET_POINTER_SIZE) && !compiler->compJmpOpUsed)
             {
                 inst_RV(INS_pop, REG_ECX, TYP_I_IMPL);
-                regTracker.rsTrackRegTrash(REG_ECX);
+                regSet.verifyRegUsed(REG_ECX);
             }
             else
 #endif // _TARGET_X86
@@ -9013,7 +9012,7 @@ void CodeGen::genFnEpilog(BasicBlock* block)
             {
                 // "pop ecx" will make ESP point to the callee-saved registers
                 inst_RV(INS_pop, REG_ECX, TYP_I_IMPL);
-                regTracker.rsTrackRegTrash(REG_ECX);
+                regSet.verifyRegUsed(REG_ECX);
             }
 #endif // _TARGET_X86
             else
@@ -9354,7 +9353,7 @@ void CodeGen::genFuncletProlog(BasicBlock* block)
 
         getEmitter()->emitIns_R_R_I(ins_Load(TYP_I_IMPL), EA_PTRSIZE, REG_R1, REG_R1,
                                     genFuncletInfo.fiPSP_slot_CallerSP_offset);
-        regTracker.rsTrackRegTrash(REG_R1);
+        regSet.verifyRegUsed(REG_R1);
         getEmitter()->emitIns_R_R_I(ins_Store(TYP_I_IMPL), EA_PTRSIZE, REG_R1, REG_SPBASE,
                                     genFuncletInfo.fiPSP_slot_SP_offset);
         getEmitter()->emitIns_R_R_I(INS_sub, EA_PTRSIZE, REG_FPBASE, REG_R1,
@@ -9365,7 +9364,7 @@ void CodeGen::genFuncletProlog(BasicBlock* block)
         // This is a non-filter funclet
         getEmitter()->emitIns_R_R_I(INS_add, EA_PTRSIZE, REG_R3, REG_FPBASE,
                                     genFuncletInfo.fiFunctionCallerSPtoFPdelta);
-        regTracker.rsTrackRegTrash(REG_R3);
+        regSet.verifyRegUsed(REG_R3);
         getEmitter()->emitIns_R_R_I(ins_Store(TYP_I_IMPL), EA_PTRSIZE, REG_R3, REG_SPBASE,
                                     genFuncletInfo.fiPSP_slot_SP_offset);
     }
@@ -9655,7 +9654,7 @@ void CodeGen::genFuncletProlog(BasicBlock* block)
 
     getEmitter()->emitIns_R_AR(INS_mov, EA_PTRSIZE, REG_FPBASE, REG_ARG_0, genFuncletInfo.fiPSP_slot_InitialSP_offset);
 
-    regTracker.rsTrackRegTrash(REG_FPBASE);
+    regSet.verifyRegUsed(REG_FPBASE);
 
     getEmitter()->emitIns_AR_R(INS_mov, EA_PTRSIZE, REG_FPBASE, REG_SPBASE, genFuncletInfo.fiPSP_slot_InitialSP_offset);
 

diff --git a/src/jit/codegeninterface.h b/src/jit/codegeninterface.h
index e6948ad..508386c 100644 (file)
--- a/src/jit/codegeninterface.h
+++ b/src/jit/codegeninterface.h
@@ -96,10 +96,6 @@ public:
     RegState intRegState;
     RegState floatRegState;
 
-    // TODO-Cleanup: The only reason that regTracker needs to live in CodeGenInterface is that
-    // in RegSet::rsUnspillOneReg, it needs to mark the new register as "trash"
-    RegTracker regTracker;
-
 protected:
     Compiler* compiler;
     bool      m_genAlignLoops;

diff --git a/src/jit/codegenlinear.cpp b/src/jit/codegenlinear.cpp
index 0d70ba0..8d4cd55 100644 (file)
--- a/src/jit/codegenlinear.cpp
+++ b/src/jit/codegenlinear.cpp
@@ -116,7 +116,11 @@ void CodeGen::genCodeForBBlist()
 
         /* Mark the register as holding the variable */
 
-        regTracker.rsTrackRegLclVar(varDsc->lvRegNum, varNum);
+        assert(varDsc->lvRegNum != REG_STK);
+        if (!varDsc->lvAddrExposed)
+        {
+            regSet.verifyRegUsed(varDsc->lvRegNum);
+        }
     }
 
     unsigned finallyNesting = 0;

diff --git a/src/jit/codegenxarch.cpp b/src/jit/codegenxarch.cpp
index a98c9e3..1fe34fa 100644 (file)
--- a/src/jit/codegenxarch.cpp
+++ b/src/jit/codegenxarch.cpp
@@ -427,7 +427,7 @@ void CodeGen::instGen_Set_Reg_To_Imm(emitAttr size, regNumber reg, ssize_t imm,
             getEmitter()->emitIns_R_I(INS_mov, size, reg, imm);
         }
     }
-    regTracker.rsTrackRegIntCns(reg, imm);
+    regSet.verifyRegUsed(reg);
 }
 
 /***********************************************************************************
@@ -450,7 +450,7 @@ void CodeGen::genSetRegToConst(regNumber targetReg, var_types targetType, GenTre
             if (con->ImmedValNeedsReloc(compiler))
             {
                 instGen_Set_Reg_To_Imm(EA_HANDLE_CNS_RELOC, targetReg, cnsVal);
-                regTracker.rsTrackRegTrash(targetReg);
+                regSet.verifyRegUsed(targetReg);
             }
             else
             {
@@ -867,7 +867,7 @@ void CodeGen::genCodeForBinary(GenTree* treeNode)
     else
     {
         inst_RV_RV(ins_Copy(targetType), targetReg, op1reg, targetType);
-        regTracker.rsTrackRegCopy(targetReg, op1reg);
+        regSet.verifyRegUsed(targetReg);
         gcInfo.gcMarkRegPtrVal(targetReg, targetType);
         dst = treeNode;
         src = op2;
@@ -8597,7 +8597,7 @@ void CodeGen::genEmitHelperCall(unsigned helper, int argSize, emitAttr retSize,
                                emitter::emitNoGChelper(helper));
     // clang-format on
 
-    regTracker.rsTrashRegSet(killMask);
+    regSet.verifyRegistersUsed(killMask);
 }
 
 #if !defined(_TARGET_64BIT_)

diff --git a/src/jit/instr.cpp b/src/jit/instr.cpp
index f440744..057cb00 100644 (file)
--- a/src/jit/instr.cpp
+++ b/src/jit/instr.cpp
@@ -706,7 +706,7 @@ AGAIN:
                 getEmitter()->emitIns_R_R(ins, size, regTmp, reg, flags);
                 getEmitter()->emitIns_S_R(ins_Store(tree->TypeGet()), size, regTmp, varNum, offs);
 
-                regTracker.rsTrackRegTrash(regTmp);
+                regSet.verifyRegUsed(regTmp);
             }
             else
 #endif
@@ -868,7 +868,7 @@ AGAIN:
                     getEmitter()->emitIns_R_S(ins_Load(tree->TypeGet()), size, regTmp, varNum, offs);
                     getEmitter()->emitIns_R_R(ins, size, reg, regTmp, flags);
 
-                    regTracker.rsTrackRegTrash(regTmp);
+                    regSet.verifyRegUsed(regTmp);
                     return;
             }
 #else  // !_TARGET_ARM_
@@ -2133,7 +2133,7 @@ void CodeGen::instGen_Set_Reg_To_Zero(emitAttr size, regNumber reg, insFlags fla
 #else
 #error "Unknown _TARGET_"
 #endif
-    regTracker.rsTrackRegIntCns(reg, 0);
+    regSet.verifyRegUsed(reg);
 }
 
 /*****************************************************************************
@@ -2262,7 +2262,7 @@ void CodeGen::instGen_Store_Imm_Into_Lcl(
     instGen_Store_Reg_Into_Lcl(dstType, immReg, varNum, offs);
     if (EA_IS_RELOC(sizeAttr))
     {
-        regTracker.rsTrackRegTrash(immReg);
+        regSet.verifyRegUsed(immReg);
     }
 #else // _TARGET_*
 #error "Unknown _TARGET_"

diff --git a/src/jit/regset.cpp b/src/jit/regset.cpp
index 3bef88a..2bec96f 100644 (file)
--- a/src/jit/regset.cpp
+++ b/src/jit/regset.cpp
@@ -45,6 +45,61 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 */
 
+//------------------------------------------------------------------------
+// verifyRegUsed: verify that the register is marked as used.
+//
+// Arguments:
+//    reg - The register to verify.
+//
+// Return Value:
+//   None.
+//
+// Assumptions:
+//    The caller must have ensured that the register is already marked
+//    as used.
+//
+// Notes:
+//     This method is intended to be called during code generation, and
+//     should simply validate that the register (or registers) have
+//     already been added to the modified set.
+
+void RegSet::verifyRegUsed(regNumber reg)
+{
+    // TODO-Cleanup: we need to identify the places where the register
+    //               is not marked as used when this is called.
+    rsSetRegsModified(genRegMask(reg));
+}
+
+//------------------------------------------------------------------------
+// verifyRegistersUsed: verify that the registers are marked as used.
+//
+// Arguments:
+//    regs - The registers to verify.
+//
+// Return Value:
+//   None.
+//
+// Assumptions:
+//    The caller must have ensured that the registers are already marked
+//    as used.
+//
+// Notes:
+//     This method is intended to be called during code generation, and
+//     should simply validate that the register (or registers) have
+//     already been added to the modified set.
+
+void RegSet::verifyRegistersUsed(regMaskTP regMask)
+{
+    if (m_rsCompiler->opts.MinOpts() || m_rsCompiler->opts.compDbgCode)
+    {
+        return;
+    }
+
+    // TODO-Cleanup: we need to identify the places where the registers
+    //               are not marked as used when this is called.
+    rsSetRegsModified(regMask);
+}
+
 void RegSet::rsClearRegsModified()
 {
     assert(m_rsCompiler->lvaDoneFrameLayout < Compiler::FINAL_FRAME_LAYOUT);
@@ -153,31 +208,6 @@ void RegSet::SetMaskVars(regMaskTP newMaskVars)
     _rsMaskVars = newMaskVars;
 }
 
-/*****************************************************************************
- *
- *  Trash the rsRegValues associated with a register
- */
-
-// inline
-void RegTracker::rsTrackRegTrash(regNumber reg)
-{
-    /* Keep track of which registers we ever touch */
-
-    regSet->rsSetRegsModified(genRegMask(reg));
-}
-
-/*****************************************************************************/
-
-// inline
-void RegTracker::rsTrackRegIntCns(regNumber reg, ssize_t val)
-{
-    assert(genIsValidIntReg(reg));
-
-    /* Keep track of which registers we ever touch */
-
-    regSet->rsSetRegsModified(genRegMask(reg));
-}
-
 /*****************************************************************************/
 
 RegSet::RegSet(Compiler* compiler, GCInfo& gcInfo) : m_rsCompiler(compiler), m_rsGCInfo(gcInfo)
@@ -237,44 +267,6 @@ RegSet::SpillDsc* RegSet::rsGetSpillInfo(GenTree* tree, regNumber reg, SpillDsc*
     return dsc;
 }
 
-/*****************************************************************************
- *
- *  Record the fact that the given register now contains the given local
- *  variable. Pointers are handled specially since reusing the register
- *  will extend the lifetime of a pointer register which is not a register
- *  variable.
- */
-
-void RegTracker::rsTrackRegLclVar(regNumber reg, unsigned var)
-{
-    LclVarDsc* varDsc = &compiler->lvaTable[var];
-    assert(reg != REG_STK);
-#if CPU_HAS_FP_SUPPORT
-    assert(varTypeIsFloating(varDsc->TypeGet()) == false);
-#endif
-
-    if (compiler->lvaTable[var].lvAddrExposed)
-    {
-        return;
-    }
-
-    /* Keep track of which registers we ever touch */
-
-    regSet->rsSetRegsModified(genRegMask(reg));
-}
-
-/*****************************************************************************/
-
-void RegTracker::rsTrackRegCopy(regNumber reg1, regNumber reg2)
-{
-    /* Keep track of which registers we ever touch */
-
-    assert(reg1 < REG_COUNT);
-    assert(reg2 < REG_COUNT);
-
-    regSet->rsSetRegsModified(genRegMask(reg1));
-}
-
 //------------------------------------------------------------
 // rsSpillTree: Spill the tree held in 'reg'.
 //
@@ -591,29 +583,6 @@ void RegSet::rsMarkSpill(GenTree* tree, regNumber reg)
     tree->gtFlags |= GTF_SPILLED;
 }
 
-/*****************************************************************************
- *
- *  A little helper to trash the given set of registers.
- *  Usually used after a call has been generated.
- */
-
-void RegTracker::rsTrashRegSet(regMaskTP regMask)
-{
-    if (compiler->opts.MinOpts() || compiler->opts.compDbgCode)
-    {
-        return;
-    }
-    regMaskTP regBit = 1;
-    for (regNumber regNum = REG_FIRST; regMask != 0; regNum = REG_NEXT(regNum), regBit <<= 1)
-    {
-        if (regBit & regMask)
-        {
-            rsTrackRegTrash(regNum);
-            regMask -= regBit;
-        }
-    }
-}
-
 /*****************************************************************************/
 
 /*

diff --git a/src/jit/regset.h b/src/jit/regset.h
index c50c23a..88889d9 100644 (file)
--- a/src/jit/regset.h
+++ b/src/jit/regset.h
@@ -94,6 +94,10 @@ public:
         return (rsModifiedRegsMask & mask) != 0;
     }
 
+    void verifyRegUsed(regNumber reg);
+
+    void verifyRegistersUsed(regMaskTP regMask);
+
 public: // TODO-Cleanup: Should be private, but GCInfo uses them
     __declspec(property(get = GetMaskVars, put = SetMaskVars)) regMaskTP rsMaskVars; // mask of registers currently
                                                                                      // allocated to variables
@@ -170,30 +174,4 @@ private:
     void rsMarkSpill(GenTree* tree, regNumber reg);
 };
 
-//-------------------------------------------------------------------------
-//
-//  These are used to track the contents of the registers during
-//  code generation.
-//
-//  Only integer registers are tracked.
-//
-
-class RegTracker
-{
-    Compiler* compiler;
-    RegSet*   regSet;
-
-public:
-    void rsTrackInit(Compiler* comp, RegSet* rs)
-    {
-        compiler = comp;
-        regSet   = rs;
-    }
-
-    void rsTrackRegTrash(regNumber reg);
-    void rsTrackRegIntCns(regNumber reg, ssize_t val);
-    void rsTrackRegLclVar(regNumber reg, unsigned var);
-    void rsTrackRegCopy(regNumber reg1, regNumber reg2);
-    void rsTrashRegSet(regMaskTP regMask);
-};
 #endif // _REGSET_H