Changed filter function for a flag to override rotation profitability check

Author: Marek Sedlacek

llvm/include/llvm/Transforms/Utils/LoopRotationUtils.h

@@ -38,9 +38,7 @@ LLVM_ABI bool LoopRotation(
     Loop *L, LoopInfo *LI, const TargetTransformInfo *TTI, AssumptionCache *AC,
     DominatorTree *DT, ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
     const SimplifyQuery &SQ, bool RotationOnly, unsigned Threshold,
-    bool IsUtilMode, bool PrepareForLTO = false,
-    function_ref<bool(Loop *, ScalarEvolution *)> ProfitabilityCheck =
-        [](Loop *, ScalarEvolution *) { return false; });
+    bool IsUtilMode, bool PrepareForLTO = false, bool ForceRotation=false);
 
 } // namespace llvm
 

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

@@ -69,19 +69,19 @@ class LoopRotate {
   bool RotationOnly;
   bool IsUtilMode;
   bool PrepareForLTO;
-  function_ref<bool(Loop *, ScalarEvolution *)> ProfitabilityCheck;
+  bool ForceRotation;
 
 public:
   LoopRotate(unsigned MaxHeaderSize, LoopInfo *LI,
              const TargetTransformInfo *TTI, AssumptionCache *AC,
              DominatorTree *DT, ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
              const SimplifyQuery &SQ, bool RotationOnly, bool IsUtilMode,
              bool PrepareForLTO,
-             function_ref<bool(Loop *, ScalarEvolution *)> ProfitabilityCheck)
+             bool ForceRotation)
       : MaxHeaderSize(MaxHeaderSize), LI(LI), TTI(TTI), AC(AC), DT(DT), SE(SE),
         MSSAU(MSSAU), SQ(SQ), RotationOnly(RotationOnly),
         IsUtilMode(IsUtilMode), PrepareForLTO(PrepareForLTO),
-        ProfitabilityCheck(ProfitabilityCheck) {}
+        ForceRotation(ForceRotation) {}
   bool processLoop(Loop *L);
 
 private:
@@ -445,7 +445,7 @@ bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) {
     // latch was just simplified. Or if we think it will be profitable.
     if (L->isLoopExiting(OrigLatch) && !SimplifiedLatch &&
         IsUtilMode == false && !profitableToRotateLoopExitingLatch(L) &&
-        !canRotateDeoptimizingLatchExit(L) && !ProfitabilityCheck(L, SE))
+        !canRotateDeoptimizingLatchExit(L) && !ForceRotation)
       return Rotated;
 
     // Check size of original header and reject loop if it is very big or we can't
@@ -1061,9 +1061,8 @@ bool llvm::LoopRotation(
     DominatorTree *DT, ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
     const SimplifyQuery &SQ, bool RotationOnly = true,
     unsigned Threshold = unsigned(-1), bool IsUtilMode = true,
-    bool PrepareForLTO,
-    function_ref<bool(Loop *, ScalarEvolution *)> ProfitabilityCheck) {
+    bool PrepareForLTO, bool ForceRotation) {
   LoopRotate LR(Threshold, LI, TTI, AC, DT, SE, MSSAU, SQ, RotationOnly,
-                IsUtilMode, PrepareForLTO, ProfitabilityCheck);
+                IsUtilMode, PrepareForLTO, ForceRotation);
   return LR.processLoop(L);
 }

llvm/lib/Transforms/Utils/LoopUnroll.cpp

@@ -564,7 +564,7 @@ llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
                                /*MemorySSAUpdater*/ nullptr, SQ,
                                /*RotationOnly*/ false, /*Threshold*/ 16,
                                /*IsUtilMode*/ false, /*PrepareForLTO*/ false,
-                               [](Loop *, ScalarEvolution *) { return true; });
+                               /*ForceRotation*/ true);
       }
       if (LoopRotated) {
         // Loop was rotated, try unrolling.