[IRCE][NFC] Introduce parameters for making lightweight IRCE

[mkazantsev]

Summary

This patch introduces two parameters AllowPreLoopInsertion and AllowPostLoopInsertion
which allow to reject IRCE transformation in case if we need a pre- or postloop insertion.

This allows to make a lightweight version of IRCE that does not duplicate loop body and
does not increase code size.

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

public:
   extractRangeChecksFromBranch(BranchInst *BI, Loop *L, ScalarEvolution &SE,
                                BranchProbabilityInfo &BPI,
                                SmallVectorImpl<InductiveRangeCheck> &Checks);
 };
 
 class InductiveRangeCheckElimination : public LoopPass {
 public:
   static char ID;
-  InductiveRangeCheckElimination() : LoopPass(ID) {
+  InductiveRangeCheckElimination(bool AllowPreLoopInsertion = true,
+                                 bool AllowPostLoopInsertion = true)
+      : LoopPass(ID), AllowPreLoopInsertion(AllowPreLoopInsertion),
+        AllowPostLoopInsertion(AllowPostLoopInsertion) {
     initializeInductiveRangeCheckEliminationPass(
         *PassRegistry::getPassRegistry());
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<BranchProbabilityInfoWrapperPass>();
     getLoopAnalysisUsage(AU);
   }
 
   bool runOnLoop(Loop *L, LPPassManager &LPM) override;
+
+private:
+  // Whether or not this pass run allows inserting of pre- and postloop. In case
+  // if either of them is not allowed but required, the whole transform gets
+  // rejected.
+  bool AllowPreLoopInsertion;
+  bool AllowPostLoopInsertion;
 };
 
 char InductiveRangeCheckElimination::ID = 0;
 }
 
 INITIALIZE_PASS_BEGIN(InductiveRangeCheckElimination, "irce",
                       "Inductive range check elimination", false, false)
 INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)
class LoopConstrainer {
 
   // The range we need to run the main loop in.
   InductiveRangeCheck::Range Range;
 
   // The structure of the main loop (see comment at the beginning of this class
   // for a definition)
   LoopStructure MainLoopStructure;
 
+  // Whether or not we are allowed to insert pre- and postloop constraining.
+  bool AllowPreLoopInsertion;
+  bool AllowPostLoopInsertion;
+
 public:
   LoopConstrainer(Loop &L, LoopInfo &LI, LPPassManager &LPM,
                   const LoopStructure &LS, ScalarEvolution &SE,
-                  DominatorTree &DT, InductiveRangeCheck::Range R)
+                  DominatorTree &DT, InductiveRangeCheck::Range R,
+                  bool AllowPreLoopInsertion, bool AllowPostLoopInsertion)
       : F(*L.getHeader()->getParent()), Ctx(L.getHeader()->getContext()),
         SE(SE), DT(DT), LPM(LPM), LI(LI), OriginalLoop(L),
         LatchTakenCount(nullptr), OriginalPreheader(nullptr),
-        MainLoopPreheader(nullptr), Range(R), MainLoopStructure(LS) {}
+        MainLoopPreheader(nullptr), Range(R), MainLoopStructure(LS),
+        AllowPreLoopInsertion(AllowPreLoopInsertion),
+        AllowPostLoopInsertion(AllowPostLoopInsertion) {}
 
   // Entry point for the algorithm.  Returns true on success.
   bool run();
 };
 
 }
 
 void LoopConstrainer::replacePHIBlock(PHINode *PN, BasicBlock *Block,
bool LoopConstrainer::run() {
   // `Optional<ClonedLoop>'s, but `ValueToValueMapTy' does not have a copy
   // constructor.
   ClonedLoop PreLoop, PostLoop;
   bool NeedsPreLoop =
       Increasing ? SR.LowLimit.hasValue() : SR.HighLimit.hasValue();
   bool NeedsPostLoop =
       Increasing ? SR.HighLimit.hasValue() : SR.LowLimit.hasValue();
 
+  // Check if we have prohibited insertion of pre- and postloop explicitly.
+  if (NeedsPreLoop && !AllowPreLoopInsertion) {
+    DEBUG(dbgs() << "irce: could not insert a preloop because it was explicitly"
+                 << " prohibited\n");
+    return false;
+  }
+
+  if (NeedsPostLoop && !AllowPostLoopInsertion) {
+    DEBUG(dbgs() << "irce: could not insert a postloop because it was"
+                 << " explicitly prohibited\n");
+    return false;
+  }
+
   Value *ExitPreLoopAt = nullptr;
   Value *ExitMainLoopAt = nullptr;
   const SCEVConstant *MinusOneS =
       cast<SCEVConstant>(SE.getConstant(IVTy, -1, true /* isSigned */));
 
   if (NeedsPreLoop) {
     const SCEV *ExitPreLoopAtSCEV = nullptr;
 
for (InductiveRangeCheck &IRC : RangeChecks) {
     }
   }
 
   if (!SafeIterRange.hasValue())
     return false;
 
   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   LoopConstrainer LC(*L, getAnalysis<LoopInfoWrapperPass>().getLoopInfo(), LPM,
-                     LS, SE, DT, SafeIterRange.getValue());
+                     LS, SE, DT, SafeIterRange.getValue(),
+                     AllowPreLoopInsertion, AllowPostLoopInsertion);
   bool Changed = LC.run();
 
   if (Changed) {
     auto PrintConstrainedLoopInfo = [L]() {
       dbgs() << "irce: in function ";
       dbgs() << L->getHeader()->getParent()->getName() << ": ";
       dbgs() << "constrained ";
       L->print(dbgs());