Delete code comments for impossible bugs

[Peakulorain]

Summary

Since Step from AddRec which analyzed from GEP is SCEVConstant,
and Step is not Zero also, the GEP for load/storage will not be
a narrow GEP in inferring loop bound from array access.

Related patch: https://reviews.llvm.org/D109821

[reames]

What prevents:
base = some alloc
%iv = {0, +, 1} as i8
%gep = getelementptr i32, i32 *%base, i8 %iv

I would strongly prefer to see *test cases* which cover the piece you think is impossible. Otherwise, we're both having to reason about possibilities in code. An example helps to make that reasoning much more concrete.

llvm/lib/Analysis/ScalarEvolution.cpp

for (Instruction &Inst : *BB) {
 
       // Only handle { %array + step },
       // FIXME: {(SCEVAddRecExpr) + step } could not be analysed here.
       if (AddRec->getStart() != ArrBase)
         continue;
 
       // Memory operation pattern which have gaps.
       // Or repeat memory opreation.
-      // And index of GEP wraps arround.
       if (Step->getAPInt().getActiveBits() > 32 ||
           Step->getAPInt().getZExtValue() !=
               ElemSize->getAPInt().getZExtValue() ||
           Step->isZero() || Step->getAPInt().isNegative())
         continue;
 
       // Only infer from stack array which has certain size.
       // Make sure alloca instruction is not excuted in loop.
       AllocaInst *AllocateInst = dyn_cast<AllocaInst>(ArrBase->getValue());
       if (!AllocateInst || L->contains(AllocateInst->getParent()))
         continue;
 
       // Make sure only handle normal array.
       auto *Ty = dyn_cast<ArrayType>(AllocateInst->getAllocatedType());
       auto *ArrSize = dyn_cast<ConstantInt>(AllocateInst->getArraySize());
       if (!Ty || !ArrSize || !ArrSize->isOne())
         continue;
       // Also make sure step was increased the same with sizeof allocated
       // element type.
       const PointerType *GEPT = dyn_cast<PointerType>(GEP->getType());
       if (Ty->getElementType() != GEPT->getElementType())
         continue;
 
-      // FIXME: Since gep indices are silently zext to the indexing type,
-      // we will have a narrow gep index which wraps around rather than
-      // increasing strictly, we shoule ensure that step is increasing
-      // strictly by the loop iteration.
       // Now we can infer a max execution time by MemLength/StepLength.
       const SCEV *MemSize =
           getConstant(Step->getType(), DL.getTypeAllocSize(Ty));
       auto *MaxExeCount =
           dyn_cast<SCEVConstant>(getUDivCeilSCEV(MemSize, Step));
       if (!MaxExeCount || MaxExeCount->getAPInt().getActiveBits() > 32)
         continue;