add control flags to LICM

[sebpop]

Summary

This patch adds -licm-max-hoist and -licm-max-sink to debug the LICM pass.

[• dberlin]

I swear there was a more generic debug counting proposal a few months ago.

[MatzeB]

In D20984#448768, @dberlin wrote:

I swear there was a more generic debug counting proposal a few months ago.

You probably think of http://reviews.llvm.org/D19172. Maybe it's enough to add some more function to OptBisect there. Andrew Kaylor should know more.

[andrew.w.kaylor]

You definitely could (and I think should) do this with opt-bisect.

I haven't added support anywhere to make the interface pretty, but it would look something like this:

static bool sink(Instruction &I, const LoopInfo *LI, const DominatorTree *DT,
                 const Loop *CurLoop, AliasSetTracker *CurAST,
                 const LICMSafetyInfo *SafetyInfo) {
  const Function *F = L->getHeader()->getParent();
  if (!F)
    return false;
  // Check the opt bisect limit.
  LLVMContext &Context = F->getContext();
  if (!Context.getOptBisect().shouldRunCase("sink instruction: " + I.getName()))
    return false;

Most of the ugliness there is just trying to get the Context from the Loop. The various pass types have helper functions to hide those details, but I don't have anything yet that could be used in a place like this.

I'd like to have an overloaded helper function that would let you do something like this, but it isn't there yet:

static bool sink(Instruction &I, const LoopInfo *LI, const DominatorTree *DT,
                 const Loop *CurLoop, AliasSetTracker *CurAST,
                 const LICMSafetyInfo *SafetyInfo) {
  if (!getOptBisect(L).shouldRunCase("sink instruction: " + I.getName()))
    return false;

Anyway, if you added that code you could use "-opt-bisect-limit=-1" to find the place where the sinks and hoists were occurring and then "-opt-bisect-limit=<n>" to cut it off. You might have other optimizations sneaking in between groups of sinks and hoists, but assuming you have an observable problem that is being caused by a sink or hoist a simple bisect using this option would find it without your having to think about those details.

[sebpop]

In D20984#449941, @andrew.w.kaylor wrote:

You definitely could (and I think should) do this with opt-bisect.

I was trying to completely disable LICM for perf analysis, not bisecting a correctness problem with LICM.
I will modify the patch to use opt-bisect. Thanks for the review.

[andrew.w.kaylor]

In D20984#450220, @sebpop wrote:

I was trying to completely disable LICM for perf analysis, not bisecting a correctness problem with LICM.

In that case, opt-bisect may not do what you need, because it will disable all optimizations after this as well. Several other passes have options to completely disable them apart from the opt-bisect option. It would still be nice to have case-by-case bisect support here, but if that's not what you wanted I can add that later.

llvm/lib/Transforms/Scalar/LICM.cpp

 STATISTIC(NumHoisted, "Number of instructions hoisted out of loop");
 STATISTIC(NumMovedLoads, "Number of load insts hoisted or sunk");
 STATISTIC(NumMovedCalls, "Number of call insts hoisted or sunk");
 STATISTIC(NumPromoted, "Number of memory locations promoted to registers");
 
 static cl::opt<bool>
     DisablePromotion("disable-licm-promotion", cl::Hidden,
                      cl::desc("Disable memory promotion in LICM pass"));
+static cl::opt<int>
+    LICMMaxHoist("licm-max-hoist", cl::Hidden, cl::init(-1),
+                 cl::desc("Max number of instructions to hoist "
+                          "(default unlimited = -1)"));
+static cl::opt<int>
+    LICMMaxSink("licm-max-sink", cl::Hidden, cl::init(-1),
+                cl::desc("Max number of instructions to sink "
+                         "(default unlimited = -1)"));
+static int HoistCtr = 0;
+static int SinkCtr = 0;
 
 static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI);
 static bool isNotUsedInLoop(const Instruction &I, const Loop *CurLoop,
                             const LICMSafetyInfo *SafetyInfo);
 static bool hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                   const LICMSafetyInfo *SafetyInfo);
 static bool sink(Instruction &I, const LoopInfo *LI, const DominatorTree *DT,
                  const Loop *CurLoop, AliasSetTracker *CurAST,

 /// When an instruction is found to only be used outside of the loop, this
 /// function moves it to the exit blocks and patches up SSA form as needed.
 /// This method is guaranteed to remove the original instruction from its
 /// position, and may either delete it or move it to outside of the loop.
 ///
 static bool sink(Instruction &I, const LoopInfo *LI, const DominatorTree *DT,
                  const Loop *CurLoop, AliasSetTracker *CurAST,
                  const LICMSafetyInfo *SafetyInfo) {
+  if (LICMMaxSink != -1) {
+    if (SinkCtr >= LICMMaxSink)
+      return false;
+    ++SinkCtr;
+  }
+
   DEBUG(dbgs() << "LICM sinking instruction: " << I << "\n");
-  bool Changed = false;
   if (isa<LoadInst>(I))
     ++NumMovedLoads;
   else if (isa<CallInst>(I))
     ++NumMovedCalls;
   ++NumSunk;
-  Changed = true;
 
 #ifndef NDEBUG
   SmallVector<BasicBlock *, 32> ExitBlocks;
   CurLoop->getUniqueExitBlocks(ExitBlocks);
   SmallPtrSet<BasicBlock *, 32> ExitBlockSet(ExitBlocks.begin(),
                                              ExitBlocks.end());
 #endif
 
else
           CloneInstructionInExitBlock(I, *ExitBlock, *PN, LI, SafetyInfo);
 
     PN->replaceAllUsesWith(New);
     PN->eraseFromParent();
   }
 
   CurAST->deleteValue(&I);
   I.eraseFromParent();
-  return Changed;
+  return true;
 }
 
-/// When an instruction is found to only use loop invariant operands that
-/// is safe to hoist, this instruction is called to do the dirty work.
+/// When an instruction is found to only use loop invariant operands that is
+/// safe to hoist, this function is called to do the dirty work.
 ///
 static bool hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                   const LICMSafetyInfo *SafetyInfo) {
+  if (LICMMaxHoist != -1) {
+    if (HoistCtr >= LICMMaxHoist)
+      return false;
+    ++HoistCtr;
+  }
+
   auto *Preheader = CurLoop->getLoopPreheader();
   DEBUG(dbgs() << "LICM hoisting to " << Preheader->getName() << ": " << I
                << "\n");
 
   // Metadata can be dependent on conditions we are hoisting above.
   // Conservatively strip all metadata on the instruction unless we were
   // guaranteed to execute I if we entered the loop, in which case the metadata
   // is valid in the loop preheader.