[llvm] [LoopPeel] Peel to make Phis loop inductions (PR #121104)

[Ryotaro Kasuga via llvm-commits]

================
@@ -190,6 +221,67 @@ PhiAnalyzer::PhiAnalyzer(const Loop &L, unsigned MaxIterations)
   assert(MaxIterations > 0 && "no peeling is allowed?");
 }
 
+// Test if \p Phi is induction variable or not. It can be checked by using SCEV,
+// but it's expensive to calculate it here. Instead, we perform the cheaper
+// checks, which cannot detect complex one but enough for some cases.
+bool PhiAnalyzer::isInductionPHI(const PHINode *Phi) const {
+  // Currently, we only support loops that consist of one basic block. In this
+  // case, the phi can become an IV if it has an incoming value from the basic
+  // block that this phi is also included.
+  int LoopIdx = -1;
+  for (unsigned I = 0; I != Phi->getNumIncomingValues(); I++) {
+    if (Phi->getIncomingBlock(I) == Phi->getParent()) {
+      LoopIdx = I;
+      break;
+    }
+  }
+  if (LoopIdx == -1)
+    return false;
+
+  Value *Cur = Phi->getIncomingValue(LoopIdx);
+  SmallPtrSet<Value *, 4> Visited;
+  bool VisitBinOp = false;
+
+  // Start at the incoming value of the phi and follow definitions. We consider
+  // the phi to be an IV if we can return to it again by traversing only add,
+  // sub, or cast instructions.
+  while (true) {
+    if (Cur == Phi)
+      break;
+
+    // Avoid infinite loop.
+    if (Visited.contains(Cur))
+      return false;
+
+    Instruction *I = dyn_cast<Instruction>(Cur);
+    if (!I || I->getParent() != Phi->getParent())
+      return false;
+
+    Visited.insert(Cur);
+
+    if (auto *Cast = dyn_cast<CastInst>(I)) {
+      Cur = Cast->getOperand(0);
+    } else if (auto *BinOp = dyn_cast<BinaryOperator>(I)) {
+      if (BinOp->getOpcode() != Instruction::Add &&
+          BinOp->getOpcode() != Instruction::Sub)
+        return false;
+      if (!BinOp->hasNoUnsignedWrap() || !BinOp->hasNoSignedWrap())
----------------
kasuga-fj wrote:

Now I don't think this check is necessary. However, removing them happened undesirable peelings. It seems that this check just happens to work well to deflect undesired loops.

https://github.com/llvm/llvm-project/pull/121104