[ValueTracking][ScalarEvolution] improving llvm.assume's support for the argument value without context & reducing the result range of ScalarEvolution::getRange using computeConstantRange

[CaprYang]

Summary

When optimizing the following code using the HardwareLoops pass, I found that due to the inability to determine the range of the 'step' variable, conservative behavior was applied and the hardware loop was not generated.

opt -passes='hardware-loops<force-hardware-loops>' test.ll -S -o test_opt.ll

define void @TestHWLoops(ptr %out, i32 %step) {
entry:
  %gt0 = icmp sgt i32 %step, 0
  %lt10 = icmp slt i32 %step, 10
  tail call void @llvm.assume(i1 %gt0)
  tail call void @llvm.assume(i1 %lt10)
  br label %for.body

for.body:                                         ; preds = %for.body, %entry
  %i = phi i32 [ 0, %entry ], [ %i.next, %for.body ]
  %arrayidx = getelementptr inbounds i32, ptr %out, i32 %i
  store i32 0, ptr %arrayidx, align 4
  %i.next = add i32 %i, %step
  %cmp = icmp slt i32 %i.next, 10
  br i1 %cmp, label %for.body, label %for.cond.cleanup

for.cond.cleanup:                                 ; preds = %for.body
  ret void
}

declare void @llvm.assume(i1)

I tried to add an assume statement to 'step' to ensure its range is [1,10), but it still did not take effect.

I observed two reasons for this:

1. When checking if it is safe to transform the loop, ScalarEvolution::isKnownPositive is used, which ultimately calls ScalarEvolution::getRangeRef. However, in the case of scUnknown, assume is not effectively utilized to obtain range information. Therefore, I used ValueTracking's computeConstantRange here.
2. In computeConstantRange, Arguments cannot set CtxI to themselves like regular Instructions. Additionally, Arguments do not need to worry about being deleted like regular instructions.

Using the following changes can correctly generate hardware loops:

define void @TestHWLoops(ptr %out, i32 %step) {
entry:
  %gt0 = icmp sgt i32 %step, 0
  %lt10 = icmp slt i32 %step, 10
  tail call void @llvm.assume(i1 %gt0)
  tail call void @llvm.assume(i1 %lt10)
  %0 = udiv i32 9, %step
  %1 = add nuw nsw i32 %0, 1
  call void @llvm.set.loop.iterations.i32(i32 %1)
  br label %for.body

for.body:                                         ; preds = %for.body, %entry
  %i = phi i32 [ 0, %entry ], [ %i.next, %for.body ]
  %arrayidx = getelementptr inbounds i32, ptr %out, i32 %i
  store i32 0, ptr %arrayidx, align 4
  %i.next = add i32 %i, %step
  %2 = call i1 @llvm.loop.decrement.i32(i32 1)
  br i1 %2, label %for.body, label %for.cond.cleanup

for.cond.cleanup:                                 ; preds = %for.body
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
declare void @llvm.assume(i1 noundef) #0

; Function Attrs: nocallback noduplicate nofree nosync nounwind willreturn
declare void @llvm.set.loop.iterations.i32(i32) #1

; Function Attrs: nocallback noduplicate nofree nosync nounwind willreturn
declare i1 @llvm.loop.decrement.i32(i32) #1

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
attributes #1 = { nocallback noduplicate nofree nosync nounwind willreturn }

[CaprYang]

I'm not sure if my current changes are reasonable. If possible, I will add with tests and support more functions.

[arsenm]

llvm/lib/Analysis/ScalarEvolution.cpp

6868–6873 ↗

(On Diff #541030)

This is a separate change

llvm/lib/Analysis/ValueTracking.cpp

103

An empty block isn't well formed IR, does it really need to handle that

120

Instead of pretending arguments are at the first instruction, could we just directly attach ranges to Arguments (by an attribute)

[CaprYang]

llvm/lib/Analysis/ScalarEvolution.cpp

6868–6873 ↗

(On Diff #541030)

okey, i will split it into a separate commit at later

llvm/lib/Analysis/ValueTracking.cpp

103

improved

120

Use the attribute to set MD_range? Because the value range constraint may be influenced by other variable values, I think "assume" is more appropriate. Also, I think "assume" should be effective for all values, and the Arguments should not be an exception.
CtxI is set as the first instruction, because if it is effective for the first instruction, it will definitely be effective for subsequent instructions? maybe? And what would be the downside of doing this?

[nikic]

Please see D93974, D97077, D97099 and D97092 for existing attempts to tackle this problem. In particular, you'll want to read the discussion on the last one of these.

[arsenm]

Should consider previous attempts

[goldstein.w.n]

In D155389#4545120, @nikic wrote:

Please see D93974, D97077, D97099 and D97092 for existing attempts to tackle this problem. In particular, you'll want to read the discussion on the last one of these.

IIUC the fundemental issue in D97092 is there is no way to guarantee the assume won't be used to influence the condition actually being assumed. But if the scope of the change is limited to arguments, which have no dependencies that can be modified, isn't that concern voided. I get that that makes it so that we can literally make this work for i1 arguments, but maybe there is a separate way forward that protects assume(condition(arg)). Probably too big a hammer, but something like the lines of @llvm.icmp.<pred>.assume(lhs, rhs) seems like it would allow for assumes on arguments.

llvm/include/llvm/Analysis/ValueTracking.h

 /// Return true if it is an intrinsic that cannot be speculated but also
 /// cannot trap.
 bool isAssumeLikeIntrinsic(const Instruction *I);
 
 /// Return true if it is valid to use the assumptions provided by an
 /// assume intrinsic, I, at the point in the control-flow identified by the
 /// context instruction, CxtI.
 bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI,
-                             const DominatorTree *DT = nullptr);
+                             const DominatorTree *DT = nullptr,
+                             bool AllowEphemeral = false);
 
 enum class OverflowResult {
   /// Always overflows in the direction of signed/unsigned min value.
   AlwaysOverflowsLow,
   /// Always overflows in the direction of signed/unsigned max value.
   AlwaysOverflowsHigh,
   /// May or may not overflow.
   MayOverflow,

llvm/lib/Analysis/ValueTracking.cpp

 /// returns the element type's bitwidth.
 static unsigned getBitWidth(Type *Ty, const DataLayout &DL) {
   if (unsigned BitWidth = Ty->getScalarSizeInBits())
     return BitWidth;
 
   return DL.getPointerTypeSizeInBits(Ty);
 }
 
+static const Instruction *getArgCxtI(const Argument *A) {
+  if (!A)
+    return nullptr;
+
+  const BasicBlock &B = A->getParent()->getEntryBlock();
+  assert(!B.empty());
+  return &B.front();
+}
+
 // Given the provided Value and, potentially, a context instruction, return
 // the preferred context instruction (if any).
 static const Instruction *safeCxtI(const Value *V, const Instruction *CxtI) {
   // If we've been provided with a context instruction, then use that (provided
   // it has been inserted).
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   // If the value is really an already-inserted instruction, then use that.
   CxtI = dyn_cast<Instruction>(V);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
+  CxtI = getArgCxtI(dyn_cast<Argument>(V));
+  if (CxtI && CxtI->getParent())
+    return CxtI;
+
   return nullptr;
 }
 
 static const Instruction *safeCxtI(const Value *V1, const Value *V2, const Instruction *CxtI) {
   // If we've been provided with a context instruction, then use that (provided
   // it has been inserted).
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   // If the value is really an already-inserted instruction, then use that.
   CxtI = dyn_cast<Instruction>(V1);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   CxtI = dyn_cast<Instruction>(V2);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
+  CxtI = getArgCxtI(dyn_cast<Argument>(V1));
+  if (CxtI && CxtI->getParent())
+    return CxtI;
+
+  CxtI = getArgCxtI(dyn_cast<Argument>(V2));
+  if (CxtI && CxtI->getParent())
+    return CxtI;
+
   return nullptr;
 }
 
 static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf,
                                    const APInt &DemandedElts,
                                    APInt &DemandedLHS, APInt &DemandedRHS) {
   if (isa<ScalableVectorType>(Shuf->getType())) {
     assert(DemandedElts == APInt(1,1));
bool llvm::isAssumeLikeIntrinsic(const Instruction *I) {
   if (const IntrinsicInst *CI = dyn_cast<IntrinsicInst>(I))
     return CI->isAssumeLikeIntrinsic();
 
   return false;
 }
 
 bool llvm::isValidAssumeForContext(const Instruction *Inv,
                                    const Instruction *CxtI,
-                                   const DominatorTree *DT) {
+                                   const DominatorTree *DT,
+                                   bool AllowEphemeral) {
   // There are two restrictions on the use of an assume:
   //  1. The assume must dominate the context (or the control flow must
   //     reach the assume whenever it reaches the context).
   //  2. The context must not be in the assume's set of ephemeral values
   //     (otherwise we will use the assume to prove that the condition
   //     feeding the assume is trivially true, thus causing the removal of
   //     the assume).
 
if (Inv->getParent() == CxtI->getParent()) {
     // the control flow, not even CxtI itself.
     // We limit the scan distance between the assume and its context instruction
     // to avoid a compile-time explosion. This limit is chosen arbitrarily, so
     // it can be adjusted if needed (could be turned into a cl::opt).
     auto Range = make_range(CxtI->getIterator(), Inv->getIterator());
     if (!isGuaranteedToTransferExecutionToSuccessor(Range, 15))
       return false;
 
-    return !isEphemeralValueOf(Inv, CxtI);
+    return AllowEphemeral || !isEphemeralValueOf(Inv, CxtI);
   }
 
   // Inv and CxtI are in different blocks.
   if (DT) {
     if (DT->dominates(Inv, CxtI))
       return true;
   } else if (Inv->getParent() == CxtI->getParent()->getSinglePredecessor()) {
     // We don't have a DT, but this trivially dominates.
ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
 
   if (Depth == MaxAnalysisRecursionDepth)
     return ConstantRange::getFull(V->getType()->getScalarSizeInBits());
 
   const APInt *C;
   if (match(V, m_APInt(C)))
     return ConstantRange(*C);
 
+  CtxI = safeCxtI(V, CtxI);
+
   InstrInfoQuery IIQ(UseInstrInfo);
   unsigned BitWidth = V->getType()->getScalarSizeInBits();
   ConstantRange CR = ConstantRange::getFull(BitWidth);
   if (auto *BO = dyn_cast<BinaryOperator>(V)) {
     APInt Lower = APInt(BitWidth, 0);
     APInt Upper = APInt(BitWidth, 0);
     // TODO: Return ConstantRange.
     setLimitsForBinOp(*BO, Lower, Upper, IIQ, ForSigned);
for (auto &AssumeVH : AC->assumptionsFor(V)) {
       if (!AssumeVH)
         continue;
       CallInst *I = cast<CallInst>(AssumeVH);
       assert(I->getParent()->getParent() == CtxI->getParent()->getParent() &&
              "Got assumption for the wrong function!");
       assert(I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
              "must be an assume intrinsic");
 
-      if (!isValidAssumeForContext(I, CtxI, DT))
+      if (!isValidAssumeForContext(I, CtxI, DT, isa<Argument>(V)))
         continue;
       Value *Arg = I->getArgOperand(0);
       ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
       // Currently we just use information from comparisons.
       if (!Cmp || Cmp->getOperand(0) != V)
         continue;
       // TODO: Set "ForSigned" parameter via Cmp->isSigned()?
       ConstantRange RHS =

llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll

 
 ; Test case for PR47247. Both the guard condition and the assume limit the
 ; constant max backedge-taken count.
 
 define void @test_guard_and_assume(ptr nocapture readonly %data, i64 %count) {
 ; CHECK-LABEL: 'test_guard_and_assume'
 ; CHECK-NEXT:  Classifying expressions for: @test_guard_and_assume
 ; CHECK-NEXT:    %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count)<nsw> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %idx = getelementptr inbounds i32, ptr %data, i64 %iv
-; CHECK-NEXT:    --> {%data,+,4}<nuw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %data) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {%data,+,4}<nuw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count)<nuw><nsw> + %data) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add nuw i64 %iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%loop> U: [1,5) S: [1,5) Exits: %count LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_guard_and_assume
-; CHECK-NEXT:  Loop %loop: backedge-taken count is (-1 + %count)
+; CHECK-NEXT:  Loop %loop: backedge-taken count is (-1 + %count)<nsw>
 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
-; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is (-1 + %count)
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %count)
+; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is (-1 + %count)<nsw>
+; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %count)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1
 ;
 entry:
   %cmp = icmp ult i64 %count, 5
   tail call void @llvm.assume(i1 %cmp)
   %cmp18.not = icmp eq i64 %count, 0
   br i1 %cmp18.not, label %exit, label %loop

llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll

 }
 
 define i64 @sext_like_noop(i32 %n) {
 ; PTR64_IDX64-LABEL: 'sext_like_noop'
 ; PTR64_IDX64-NEXT:  Classifying expressions for: @sext_like_noop
 ; PTR64_IDX64-NEXT:    %ii = sext i32 %i to i64
 ; PTR64_IDX64-NEXT:    --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
 ; PTR64_IDX64-NEXT:    %div = sdiv i64 55555, %ii
-; PTR64_IDX64-NEXT:    --> %div U: full-set S: full-set
+; PTR64_IDX64-NEXT:    --> %div U: [-55555,55556) S: [-55555,55556)
 ; PTR64_IDX64-NEXT:    %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
 ; PTR64_IDX64-NEXT:    --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable }
 ; PTR64_IDX64-NEXT:    %inc = add nuw i32 %i, 1
 ; PTR64_IDX64-NEXT:    --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32) LoopDispositions: { %for.body: Computable }
 ; PTR64_IDX64-NEXT:  Determining loop execution counts for: @sext_like_noop
 ; PTR64_IDX64-NEXT:  Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
 ; PTR64_IDX64-NEXT:  Loop %for.body: constant max backedge-taken count is -1
 ; PTR64_IDX64-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
 ; PTR64_IDX64-NEXT:  Loop %for.body: Predicated backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
 ; PTR64_IDX64-NEXT:   Predicates:
 ; PTR64_IDX64:       Loop %for.body: Trip multiple is 1
 ;
 ; PTR64_IDX32-LABEL: 'sext_like_noop'
 ; PTR64_IDX32-NEXT:  Classifying expressions for: @sext_like_noop
 ; PTR64_IDX32-NEXT:    %ii = sext i32 %i to i64
 ; PTR64_IDX32-NEXT:    --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (ptr @sext_like_noop to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
 ; PTR64_IDX32-NEXT:    %div = sdiv i64 55555, %ii
-; PTR64_IDX32-NEXT:    --> %div U: full-set S: full-set
+; PTR64_IDX32-NEXT:    --> %div U: [-55555,55556) S: [-55555,55556)
 ; PTR64_IDX32-NEXT:    %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
 ; PTR64_IDX32-NEXT:    --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable }
 ; PTR64_IDX32-NEXT:    %inc = add nuw i32 %i, 1
 ; PTR64_IDX32-NEXT:    --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable }
 ; PTR64_IDX32-NEXT:  Determining loop execution counts for: @sext_like_noop
 ; PTR64_IDX32-NEXT:  Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
 ; PTR64_IDX32-NEXT:  Loop %for.body: constant max backedge-taken count is -1
 ; PTR64_IDX32-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
 ; PTR64_IDX32-NEXT:  Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
 ; PTR64_IDX32-NEXT:   Predicates:
 ; PTR64_IDX32:       Loop %for.body: Trip multiple is 1
 ;
 ; PTR16_IDX16-LABEL: 'sext_like_noop'
 ; PTR16_IDX16-NEXT:  Classifying expressions for: @sext_like_noop
 ; PTR16_IDX16-NEXT:    %ii = sext i32 %i to i64
 ; PTR16_IDX16-NEXT:    --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i64))<nsw> U: [-1,65535) S: [-1,65535)
 ; PTR16_IDX16-NEXT:    %div = sdiv i64 55555, %ii
-; PTR16_IDX16-NEXT:    --> %div U: full-set S: full-set
+; PTR16_IDX16-NEXT:    --> %div U: [-55555,55556) S: [-55555,55556)
 ; PTR16_IDX16-NEXT:    %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
 ; PTR16_IDX16-NEXT:    --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
 ; PTR16_IDX16-NEXT:    %inc = add nuw i32 %i, 1
 ; PTR16_IDX16-NEXT:    --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32) LoopDispositions: { %for.body: Computable }
 ; PTR16_IDX16-NEXT:  Determining loop execution counts for: @sext_like_noop
 ; PTR16_IDX16-NEXT:  Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
 ; PTR16_IDX16-NEXT:  Loop %for.body: constant max backedge-taken count is -1
 ; PTR16_IDX16-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
 ; PTR16_IDX16-NEXT:  Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
 ; PTR16_IDX16-NEXT:   Predicates:
 ; PTR16_IDX16:       Loop %for.body: Trip multiple is 1
 ;
 ; PTR16_IDX32-LABEL: 'sext_like_noop'
 ; PTR16_IDX32-NEXT:  Classifying expressions for: @sext_like_noop
 ; PTR16_IDX32-NEXT:    %ii = sext i32 %i to i64
 ; PTR16_IDX32-NEXT:    --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (ptr @sext_like_noop to i32) to i64))<nsw> U: [-1,65535) S: [-1,65535)
 ; PTR16_IDX32-NEXT:    %div = sdiv i64 55555, %ii
-; PTR16_IDX32-NEXT:    --> %div U: full-set S: full-set
+; PTR16_IDX32-NEXT:    --> %div U: [-55555,55556) S: [-55555,55556)
 ; PTR16_IDX32-NEXT:    %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
 ; PTR16_IDX32-NEXT:    --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32))<nsw> LoopDispositions: { %for.body: Computable }
 ; PTR16_IDX32-NEXT:    %inc = add nuw i32 %i, 1
 ; PTR16_IDX32-NEXT:    --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable }
 ; PTR16_IDX32-NEXT:  Determining loop execution counts for: @sext_like_noop
 ; PTR16_IDX32-NEXT:  Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
 ; PTR16_IDX32-NEXT:  Loop %for.body: constant max backedge-taken count is -1
 ; PTR16_IDX32-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>

llvm/test/Analysis/ScalarEvolution/ranges.ll

;
   ret i64 %ashr
 }
 
 
 define i32 @shl(i32 %a) {
 ; CHECK-LABEL: 'shl'
 ; CHECK-NEXT:  Classifying expressions for: @shl
 ; CHECK-NEXT:    %res = shl i32 %a, 2
-; CHECK-NEXT:    --> (4 * %a) U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT:    --> (4 * %a)<nuw><nsw> U: [0,4093) S: [0,4093)
 ; CHECK-NEXT:  Determining loop execution counts for: @shl
 ;
   %res = shl i32 %a, 2
   %pos = icmp ult i32 %a, 1024
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i32 @lshr(i32 %a) {
 ; CHECK-LABEL: 'lshr'
 ; CHECK-NEXT:  Classifying expressions for: @lshr
 ; CHECK-NEXT:    %res = lshr i32 %a, 31
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @lshr
 ;
   %res = lshr i32 %a, 31
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 
 define i32 @udiv(i32 %a) {
 ; CHECK-LABEL: 'udiv'
 ; CHECK-NEXT:  Classifying expressions for: @udiv
 ; CHECK-NEXT:    %res = udiv i32 %a, -2147483648
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @udiv
 ;
   %res = udiv i32 %a, 2147483648
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i64 @sext(i8 %a) {
 ; CHECK-LABEL: 'sext'
 ; CHECK-NEXT:  Classifying expressions for: @sext
 ; CHECK-NEXT:    %res = sext i8 %a to i64
-; CHECK-NEXT:    --> (sext i8 %a to i64) U: [-128,128) S: [-128,128)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @sext
 ;
   %res = sext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }
 
 define i64 @zext(i8 %a) {
 ; CHECK-LABEL: 'zext'
 ; CHECK-NEXT:  Classifying expressions for: @zext
 ; CHECK-NEXT:    %res = zext i8 %a to i64
-; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,256) S: [0,256)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @zext
 ;
   %res = zext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }
 

llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll

 }
 
 define void @test_trip_multiple_4_sgt_5(i32 %num) {
 ; CHECK-LABEL: 'test_trip_multiple_4_sgt_5'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_sgt_5
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_sgt_5
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 2147483646
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %u = urem i32 %num, 4
   %cmp = icmp eq i32 %u, 0
   tail call void @llvm.assume(i1 %cmp)
   %cmp.1 = icmp sgt i32 %num, 5

 
 define void @test_trip_multiple_4_sgt_5_order_swapped(i32 %num) {
 ; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
 ; CHECK-LABEL: 'test_trip_multiple_4_sgt_5_order_swapped'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_sgt_5_order_swapped
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_sgt_5_order_swapped
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 2147483646
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %u = urem i32 %num, 4
   %cmp.1 = icmp sgt i32 %num, 5
   tail call void @llvm.assume(i1 %cmp.1)
   %cmp = icmp eq i32 %u, 0

 
 define void @test_trip_multiple_4_sge_5(i32 %num) {
 ; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
 ; CHECK-LABEL: 'test_trip_multiple_4_sge_5'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_sge_5
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_sge_5
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 2147483646
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %u = urem i32 %num, 4
   %cmp = icmp eq i32 %u, 0
   tail call void @llvm.assume(i1 %cmp)
   %cmp.1 = icmp sge i32 %num, 5

 }
 
 define void @test_trip_multiple_4_sge_5_order_swapped(i32 %num) {
 ; CHECK-LABEL: 'test_trip_multiple_4_sge_5_order_swapped'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_sge_5_order_swapped
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_sge_5_order_swapped
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 2147483646
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %u = urem i32 %num, 4
   %cmp = icmp eq i32 %u, 0
   %cmp.1 = icmp sge i32 %num, 5
   tail call void @llvm.assume(i1 %cmp.1)

 }
 
 define void @test_trip_multiple_4_upper_lower_bounds(i32 %num) {
 ; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,58999) S: [0,58999) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
-; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,59000) S: [1,59000) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is -2
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 58998
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %cmp.1 = icmp uge i32 %num, 5
   tail call void @llvm.assume(i1 %cmp.1)
   %u = urem i32 %num, 4
   %cmp = icmp eq i32 %u, 0

 }
 
 define void @test_trip_multiple_4_upper_lower_bounds_swapped1(i32 %num) {
 ; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds_swapped1'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds_swapped1
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,58999) S: [0,58999) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
-; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,59000) S: [1,59000) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds_swapped1
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is -2
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 58998
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %cmp.1 = icmp uge i32 %num, 5
   tail call void @llvm.assume(i1 %cmp.1)
   %u = urem i32 %num, 4
   %cmp = icmp eq i32 %u, 0

 }
 
 define void @test_trip_multiple_4_upper_lower_bounds_swapped2(i32 %num) {
 ; CHECK-LABEL: 'test_trip_multiple_4_upper_lower_bounds_swapped2'
 ; CHECK-NEXT:  Classifying expressions for: @test_trip_multiple_4_upper_lower_bounds_swapped2
 ; CHECK-NEXT:    %u = urem i32 %num, 4
 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
 ; CHECK-NEXT:    %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><nsw><%for.body> U: [0,58999) S: [0,58999) Exits: (-1 + %num)<nsw> LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:    %inc = add nuw nsw i32 %i.010, 1
-; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT:    --> {1,+,1}<nuw><nsw><%for.body> U: [1,59000) S: [1,59000) Exits: %num LoopDispositions: { %for.body: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_trip_multiple_4_upper_lower_bounds_swapped2
-; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is -2
-; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
-; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT:  Loop %for.body: backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: constant max backedge-taken count is 58998
+; CHECK-NEXT:  Loop %for.body: symbolic max backedge-taken count is (-1 + %num)<nsw>
+; CHECK-NEXT:  Loop %for.body: Predicated backedge-taken count is (-1 + %num)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %for.body: Trip multiple is 4
 ;
 entry:
   %cmp.1 = icmp uge i32 %num, 5
   tail call void @llvm.assume(i1 %cmp.1)
   %cmp.2 = icmp ult i32 %num, 59000
   tail call void @llvm.assume(i1 %cmp.2)

llvm/test/CodeGen/Thumb2/mve-float16regloops.ll

 for.cond.cleanup:                                 ; preds = %vector.body, %entry
   ret void
 }
 
 
 define dso_local void @test_nested(ptr noalias nocapture %pInT1, ptr noalias nocapture readonly %pOutT1, ptr noalias nocapture readonly %pPRT_in, ptr noalias nocapture readnone %pPRT_pDst, i32 %numRows, i32 %numCols, i32 %l) local_unnamed_addr {
 ; CHECK-LABEL: test_nested:
 ; CHECK:       @ %bb.0: @ %for.body.us.preheader
-; CHECK-NEXT:    .save {r4, r5, r6, lr}
-; CHECK-NEXT:    push {r4, r5, r6, lr}
-; CHECK-NEXT:    ldrd lr, r12, [sp, #16]
-; CHECK-NEXT:    lsl.w r3, r12, #1
+; CHECK-NEXT:    .save {r4, r5, r6, r7, lr}
+; CHECK-NEXT:    push {r4, r5, r6, r7, lr}
+; CHECK-NEXT:    ldrd r12, r3, [sp, #20]
+; CHECK-NEXT:    sub.w r7, r3, #8
+; CHECK-NEXT:    movs r6, #1
+; CHECK-NEXT:    lsls r3, r3, #1
+; CHECK-NEXT:    add.w r5, r6, r7, lsr #3
+; CHECK-NEXT:    movs r4, #0
 ; CHECK-NEXT:  .LBB14_1: @ %for.body.us
 ; CHECK-NEXT:    @ =>This Loop Header: Depth=1
 ; CHECK-NEXT:    @ Child Loop BB14_2 Depth 2
-; CHECK-NEXT:    ldrh r4, [r1]
-; CHECK-NEXT:    mov r5, r2
-; CHECK-NEXT:    mov r6, r12
-; CHECK-NEXT:    vdup.16 q0, r4
-; CHECK-NEXT:    mov r4, r0
+; CHECK-NEXT:    ldrh r7, [r1]
+; CHECK-NEXT:    dls lr, r5
+; CHECK-NEXT:    mov r6, r0
+; CHECK-NEXT:    vdup.16 q0, r7
+; CHECK-NEXT:    mov r7, r2
 ; CHECK-NEXT:  .LBB14_2: @ %vector.body
 ; CHECK-NEXT:    @ Parent Loop BB14_1 Depth=1
 ; CHECK-NEXT:    @ => This Inner Loop Header: Depth=2
-; CHECK-NEXT:    vldrw.u32 q1, [r5], #16
-; CHECK-NEXT:    vldrw.u32 q2, [r4]
-; CHECK-NEXT:    subs r6, #8
+; CHECK-NEXT:    vldrw.u32 q1, [r7], #16
+; CHECK-NEXT:    vldrw.u32 q2, [r6]
 ; CHECK-NEXT:    vfms.f16 q2, q1, q0
-; CHECK-NEXT:    vstrb.8 q2, [r4], #16
-; CHECK-NEXT:    bne .LBB14_2
+; CHECK-NEXT:    vstrb.8 q2, [r6], #16
+; CHECK-NEXT:    le lr, .LBB14_2
 ; CHECK-NEXT:  @ %bb.3: @ %for.cond6.for.end_crit_edge.us
 ; CHECK-NEXT:    @ in Loop: Header=BB14_1 Depth=1
+; CHECK-NEXT:    adds r4, #1
 ; CHECK-NEXT:    add r0, r3
 ; CHECK-NEXT:    add r2, r3
 ; CHECK-NEXT:    adds r1, #2
-; CHECK-NEXT:    le lr, .LBB14_1
+; CHECK-NEXT:    cmp r4, r12
+; CHECK-NEXT:    bne .LBB14_1
 ; CHECK-NEXT:  @ %bb.4: @ %for.end14
-; CHECK-NEXT:    pop {r4, r5, r6, pc}
+; CHECK-NEXT:    pop {r4, r5, r6, r7, pc}
 for.body.us.preheader:
   %cmp = icmp sgt i32 %numRows, 0
   tail call void @llvm.assume(i1 %cmp)
   %cmp1 = icmp sgt i32 %numCols, 0
   tail call void @llvm.assume(i1 %cmp1)
   %rem = and i32 %numCols, 7
   %cmp2 = icmp eq i32 %rem, 0
   tail call void @llvm.assume(i1 %cmp2)

llvm/test/CodeGen/Thumb2/mve-float32regloops.ll

 for.cond.cleanup:                                 ; preds = %vector.body, %entry
   ret void
 }
 
 
 define dso_local void @test_nested(ptr noalias nocapture %pInT1, ptr noalias nocapture readonly %pOutT1, ptr noalias nocapture readonly %pPRT_in, ptr noalias nocapture readnone %pPRT_pDst, i32 %numRows, i32 %numCols, i32 %l) local_unnamed_addr {
 ; CHECK-LABEL: test_nested:
 ; CHECK:       @ %bb.0: @ %for.body.us.preheader
-; CHECK-NEXT:    .save {r4, r5, r6, lr}
-; CHECK-NEXT:    push {r4, r5, r6, lr}
-; CHECK-NEXT:    ldrd lr, r12, [sp, #16]
-; CHECK-NEXT:    lsl.w r3, r12, #2
+; CHECK-NEXT:    .save {r4, r5, r6, r7, lr}
+; CHECK-NEXT:    push {r4, r5, r6, r7, lr}
+; CHECK-NEXT:    ldrd r12, r3, [sp, #20]
+; CHECK-NEXT:    subs r7, r3, #4
+; CHECK-NEXT:    movs r6, #1
+; CHECK-NEXT:    lsls r3, r3, #2
+; CHECK-NEXT:    add.w r5, r6, r7, lsr #2
+; CHECK-NEXT:    movs r4, #0
 ; CHECK-NEXT:  .LBB14_1: @ %for.body.us
 ; CHECK-NEXT:    @ =>This Loop Header: Depth=1
 ; CHECK-NEXT:    @ Child Loop BB14_2 Depth 2
-; CHECK-NEXT:    ldr r4, [r1]
-; CHECK-NEXT:    mov r5, r2
-; CHECK-NEXT:    mov r6, r12
-; CHECK-NEXT:    vdup.32 q0, r4
-; CHECK-NEXT:    mov r4, r0
+; CHECK-NEXT:    ldr r7, [r1]
+; CHECK-NEXT:    dls lr, r5
+; CHECK-NEXT:    mov r6, r0
+; CHECK-NEXT:    vdup.32 q0, r7
+; CHECK-NEXT:    mov r7, r2
 ; CHECK-NEXT:  .LBB14_2: @ %vector.body
 ; CHECK-NEXT:    @ Parent Loop BB14_1 Depth=1
 ; CHECK-NEXT:    @ => This Inner Loop Header: Depth=2
-; CHECK-NEXT:    vldrw.u32 q1, [r5], #16
-; CHECK-NEXT:    vldrw.u32 q2, [r4]
-; CHECK-NEXT:    subs r6, #4
+; CHECK-NEXT:    vldrw.u32 q1, [r7], #16
+; CHECK-NEXT:    vldrw.u32 q2, [r6]
 ; CHECK-NEXT:    vfms.f32 q2, q1, q0
-; CHECK-NEXT:    vstrb.8 q2, [r4], #16
-; CHECK-NEXT:    bne .LBB14_2
+; CHECK-NEXT:    vstrb.8 q2, [r6], #16
+; CHECK-NEXT:    le lr, .LBB14_2
 ; CHECK-NEXT:  @ %bb.3: @ %for.cond6.for.end_crit_edge.us
 ; CHECK-NEXT:    @ in Loop: Header=BB14_1 Depth=1
+; CHECK-NEXT:    adds r4, #1
 ; CHECK-NEXT:    add r0, r3
 ; CHECK-NEXT:    add r2, r3
 ; CHECK-NEXT:    adds r1, #4
-; CHECK-NEXT:    le lr, .LBB14_1
+; CHECK-NEXT:    cmp r4, r12
+; CHECK-NEXT:    bne .LBB14_1
 ; CHECK-NEXT:  @ %bb.4: @ %for.end14
-; CHECK-NEXT:    pop {r4, r5, r6, pc}
+; CHECK-NEXT:    pop {r4, r5, r6, r7, pc}
 for.body.us.preheader:
   %cmp = icmp sgt i32 %numRows, 0
   tail call void @llvm.assume(i1 %cmp)
   %cmp1 = icmp sgt i32 %numCols, 0
   tail call void @llvm.assume(i1 %cmp1)
   %rem = and i32 %numCols, 7
   %cmp2 = icmp eq i32 %rem, 0
   tail call void @llvm.assume(i1 %cmp2)

llvm/test/Transforms/IndVarSimplify/invalidate-modified-lcssa-phi.ll

 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP186_NOT]])
 ; CHECK-NEXT:    br label [[OUTER_HEADER:%.*]]
 ; CHECK:       outer.header:
 ; CHECK-NEXT:    [[P_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[LCSSA:%.*]], [[OUTER_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[XOR:%.*]] = xor i32 [[P_0]], 0
 ; CHECK-NEXT:    br label [[INNER:%.*]]
 ; CHECK:       inner:
 ; CHECK-NEXT:    store i16 0, ptr [[DST:%.*]], align 1
-; CHECK-NEXT:    br i1 false, label [[INNER]], label [[OUTER_LATCH]]
+; CHECK-NEXT:    br label [[OUTER_LATCH]]
 ; CHECK:       outer.latch:
 ; CHECK-NEXT:    [[LCSSA]] = phi i32 [ [[XOR]], [[INNER]] ]
 ; CHECK-NEXT:    br i1 [[C_0:%.*]], label [[OUTER_HEADER]], label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[LCSSA_LCSSA:%.*]] = phi i32 [ [[LCSSA]], [[OUTER_LATCH]] ]
 ; CHECK-NEXT:    ret i32 [[LCSSA_LCSSA]]
 ;
 entry:

llvm/unittests/Analysis/ScalarEvolutionTest.cpp

std::unique_ptr<Module> M = parseAssemblyString(
       Err, C);
 
   ASSERT_TRUE(M && "Could not parse module?");
   ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
 
   runWithSE(*M, "test", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
     auto *TCScev = SE.getSCEV(getArgByName(F, "num"));
     auto *ApplyLoopGuardsTC = SE.applyLoopGuards(TCScev, *LI.begin());
-    // Assert that the new TC is (4 * ((4 umax %num) /u 4))
+    // Assert that the new TC is (4 * (%num /u 4)), We can deduce %num >= 4 with
+    // llvm.assume
     APInt Four(32, 4);
     auto *Constant4 = SE.getConstant(Four);
-    auto *Max = SE.getUMaxExpr(TCScev, Constant4);
-    auto *Mul = SE.getMulExpr(SE.getUDivExpr(Max, Constant4), Constant4);
+    auto *Mul = SE.getMulExpr(SE.getUDivExpr(TCScev, Constant4), Constant4);
     ASSERT_TRUE(Mul == ApplyLoopGuardsTC);
   });
 }
 
 }  // end namespace llvm

llvm/unittests/Analysis/ValueTrackingTest.cpp

define i32 @test(i32 %stride) {
     %stride.plus.one = add nsw nuw i32 %stride, 1
     ret i32 %stride.plus.one
   })");
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
     ConstantRange CR1 = computeConstantRange(Stride, false, true, &AC, nullptr);
-    EXPECT_TRUE(CR1.isFullSet());
+    EXPECT_EQ(5, CR1.getLower());
+    EXPECT_EQ(10, CR1.getUpper());
 
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
     ConstantRange CR2 = computeConstantRange(Stride, false, true, &AC, I);
     EXPECT_EQ(5, CR2.getLower());
     EXPECT_EQ(10, CR2.getUpper());
   }
 
   {
bb2:
     ret i32 0
   })");
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
     Instruction *GT2 = &findInstructionByName(F, "gt.2");
     ConstantRange CR = computeConstantRange(Stride, false, true, &AC, GT2);
-    EXPECT_EQ(5, CR.getLower());
+    EXPECT_EQ(50, CR.getLower());
     EXPECT_EQ(0, CR.getUpper());
 
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
     ConstantRange CR2 = computeConstantRange(Stride, false, true, &AC, I);
     EXPECT_EQ(50, CR2.getLower());
     EXPECT_EQ(100, CR2.getUpper());
   }
 

polly/test/ScopInfo/user_provided_assumptions_2.ll

 ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
 ;
 ; CHECK:      remark: <unknown>:0:0: SCoP begins here.
 ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: { : }
 ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
 
 ; SCOP:      Context:
-; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 }
+; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and 0 < M <= 2147483647 }
 ; SCOP:      Assumed Context:
 ; SCOP-NEXT: [N, M] -> { : }
 ; SCOP:      Invalid Context:
 ; SCOP-NEXT: [N, M] -> { : false }
 ;
 ;
 ; This test checks that assumptions over parameters not used in the Scop are
 ; not modeled. There is no benefit in knowing about parameters that are