setNextConsecutiveRegisterAssignment() no longer checks for areNextCo…

…nsecutiveRegistersFree()

src/coreclr/jit/lsra.cpp

@@ -5398,8 +5398,7 @@ void LinearScan::allocateRegisters()
                         lastAllocatedRefPosition  = &currentRefPosition;
                         regMaskTP copyRegMask     = getRegMask(copyReg, currentInterval->registerType);
                         regMaskTP assignedRegMask = getRegMask(assignedRegister, currentInterval->registerType);
-                        bool consecutiveAssigned  = setNextConsecutiveRegisterAssignment(&currentRefPosition, copyReg);
-                        assert(consecutiveAssigned);
+                        setNextConsecutiveRegisterAssignment(&currentRefPosition, copyReg);
 
                         // For consecutive register, it doesn't matter what the assigned register was.
                         // We have just assigned it `copyRegMask` and that's the one in-use, and not the
@@ -5498,9 +5497,7 @@ void LinearScan::allocateRegisters()
                             // If the first RefPosition was not assigned to the register we wanted and we added
                             // a copyReg for it, then allocate the subsequent RefPositions with the consecutive
                             // registers.
-                            bool consecutiveAssigned =
-                                setNextConsecutiveRegisterAssignment(&currentRefPosition, copyReg);
-                            assert(consecutiveAssigned);
+                            setNextConsecutiveRegisterAssignment(&currentRefPosition, copyReg);
                         }
                         else
                         {
@@ -5586,7 +5583,7 @@ void LinearScan::allocateRegisters()
                     // subsequent registers to the remaining position and skip the allocation for the
                     // 1st refPosition altogether.
 
-                    if (!setNextConsecutiveRegisterAssignment(&currentRefPosition, assignedRegister))
+                    if (!areNextConsecutiveRegistersFree(&currentRefPosition, assignedRegister))
                     {
                         // The consecutive registers are busy. Force to allocate even for the 1st
                         // refPosition
@@ -5680,9 +5677,7 @@ void LinearScan::allocateRegisters()
                         allocateReg<true>(currentInterval, &currentRefPosition DEBUG_ARG(&registerScore));
                     if (currentRefPosition.isFirstRefPositionOfConsecutiveRegisters())
                     {
-                        bool consecutiveAssigned =
-                            setNextConsecutiveRegisterAssignment(&currentRefPosition, assignedRegister);
-                        assert(consecutiveAssigned);
+                        setNextConsecutiveRegisterAssignment(&currentRefPosition, assignedRegister);
                     }
                 }
                 else

src/coreclr/jit/lsra.h

@@ -1197,7 +1197,7 @@ class LinearScan : public LinearScanInterface
 
 #if defined(TARGET_ARM64)
     bool areNextConsecutiveRegistersFree(regNumber regToAssign, int registersToCheck, var_types registerType);
-    bool setNextConsecutiveRegisterAssignment(RefPosition* firstRefPosition, regNumber firstRegAssigned);
+    void setNextConsecutiveRegisterAssignment(RefPosition* firstRefPosition, regNumber firstRegAssigned);
     regMaskTP getFreeCandidates(regMaskTP candidates, RefPosition* refPosition);
 #endif // TARGET_ARM64
 

src/coreclr/jit/lsraarm64.cpp

@@ -56,27 +56,19 @@ RefPosition* LinearScan::getNextConsecutiveRefPosition(RefPosition* refPosition)
 //    firstRefPosition  - First refPosition of the series of consecutive registers.
 //    firstRegAssigned  - Register assigned to the first refposition.
 //
-//  Returns:
-//      True if all the consecutive registers starting from `firstRegAssigned` were free. Even if one
-//      of them is busy, returns false and does not change the registerAssignment of any refPositions.
+//  Note:
+//      This method will set the registerAssignment of subsequent RefPositions with consecutive registers.
+//      Some of the registers could be busy, and they will be spilled. We would end up with busy registers if
+//      we did not find free consecutive registers.
 //
-bool LinearScan::setNextConsecutiveRegisterAssignment(RefPosition* firstRefPosition, regNumber firstRegAssigned)
+void LinearScan::setNextConsecutiveRegisterAssignment(RefPosition* firstRefPosition, regNumber firstRegAssigned)
 {
+    assert(compiler->info.needsConsecutiveRegisters);
     assert(firstRefPosition->assignedReg() == firstRegAssigned);
     assert(isSingleRegister(genRegMask(firstRegAssigned)));
     assert(firstRefPosition->isFirstRefPositionOfConsecutiveRegisters());
     assert(emitter::isVectorRegister(firstRegAssigned));
 
-    // Verify that all the consecutive registers needed are free, if not, return false.
-    // Need to do this before we set registerAssignment of any of the refPositions that
-    // are part of the range.
-
-    if (!areNextConsecutiveRegistersFree(firstRegAssigned, firstRefPosition->regCount,
-                                         firstRefPosition->getInterval()->registerType))
-    {
-        return false;
-    }
-
     RefPosition* consecutiveRefPosition = getNextConsecutiveRefPosition(firstRefPosition);
     regNumber    regToAssign            = firstRegAssigned == REG_FP_LAST ? REG_FP_FIRST : REG_NEXT(firstRegAssigned);
 
@@ -114,8 +106,6 @@ bool LinearScan::setNextConsecutiveRegisterAssignment(RefPosition* firstRefPosit
     }
 
     assert(refPosCount == firstRefPosition->regCount);
-
-    return true;
 }
 
 //------------------------------------------------------------------------