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

   1 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
   2 ; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
   3
   4 ; Test cases that require rewriting zext SCEV expression with infomration from
   5 ; the loop guards.
   6
   7 define void @rewrite_zext(i32 %n) {
   8 ; CHECK-LABEL: 'rewrite_zext'
   9 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext
  10 ; CHECK-NEXT:    %ext = zext i32 %n to i64
  11 ; CHECK-NEXT:    --> (zext i32 %n to i64) U: [0,4294967296) S: [0,4294967296)
  12 ; CHECK-NEXT:    %n.vec = and i64 %ext, -8
  13 ; CHECK-NEXT:    --> (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw> U: [0,4294967289) S: [0,4294967289)
  14 ; CHECK-NEXT:    %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
  15 ; CHECK-NEXT:    --> {0,+,8}<nuw><nsw><%loop> U: [0,17) S: [0,17) Exits: (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw> LoopDispositions: { %loop: Computable }
  16 ; CHECK-NEXT:    %index.next = add nuw nsw i64 %index, 8
  17 ; CHECK-NEXT:    --> {8,+,8}<nuw><nsw><%loop> U: [8,25) S: [8,25) Exits: (8 + (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw>) LoopDispositions: { %loop: Computable }
  18 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext
  19 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
  20 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 2
  21 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
  22 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
  23 ; CHECK-NEXT:   Predicates:
  24 ; CHECK:       Loop %loop: Trip multiple is 1
  25 ;
  26 entry:
  27   %ext = zext i32 %n to i64
  28   %cmp5 = icmp ule i64 %ext, 24
  29   br i1 %cmp5, label %check, label %exit
  30
  31 check:                                 ; preds = %entry
  32   %min.iters.check = icmp ult i64 %ext, 8
  33   %n.vec = and i64 %ext, -8
  34   br i1 %min.iters.check, label %exit, label %loop
  35
  36 loop:
  37   %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
  38   %index.next = add nuw nsw i64 %index, 8
  39   %ec = icmp eq i64 %index.next, %n.vec
  40   br i1 %ec, label %exit, label %loop
  41
  42 exit:
  43   ret void
  44 }
  45
  46 ; Test case from PR40961.
  47 define i32 @rewrite_zext_min_max(i32 %N, ptr %arr) {
  48 ; CHECK-LABEL: 'rewrite_zext_min_max'
  49 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_min_max
  50 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
  51 ; CHECK-NEXT:    --> (16 umin %N) U: [0,17) S: [0,17)
  52 ; CHECK-NEXT:    %ext = zext i32 %umin to i64
  53 ; CHECK-NEXT:    --> (16 umin (zext i32 %N to i64)) U: [0,17) S: [0,17)
  54 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
  55 ; CHECK-NEXT:    --> (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw> U: [0,17) S: [0,17)
  56 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
  57 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
  58 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
  59 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
  60 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
  61 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
  62 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_min_max
  63 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
  64 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
  65 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
  66 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
  67 ; CHECK-NEXT:   Predicates:
  68 ; CHECK:       Loop %loop: Trip multiple is 1
  69 ;
  70 entry:
  71   %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
  72   %ext = zext i32 %umin to i64
  73   %min.iters.check = icmp ult i64 %ext, 4
  74   br i1 %min.iters.check, label %exit, label %loop.ph
  75
  76 loop.ph:
  77   %n.vec = and i64 %ext, 28
  78   br label %loop
  79
  80 ; %n.vec is [4, 16) and a multiple of 4.
  81 loop:
  82   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
  83   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
  84   store i32 0, ptr %gep
  85   %index.next = add nuw i64 %index, 4
  86   %ec = icmp eq i64 %index.next, %n.vec
  87   br i1 %ec, label %exit, label %loop
  88
  89 exit:
  90   ret i32 0
  91 }
  92
  93 ; This is same as rewrite_zext_min_max, but zext and umin are swapped.
  94 ; It should be able to prove the same exit count.
  95 define i32 @rewrite_min_max_zext(i32 %N, ptr %arr) {
  96 ; CHECK-LABEL: 'rewrite_min_max_zext'
  97 ; CHECK-NEXT:  Classifying expressions for: @rewrite_min_max_zext
  98 ; CHECK-NEXT:    %N.wide = zext i32 %N to i64
  99 ; CHECK-NEXT:    --> (zext i32 %N to i64) U: [0,4294967296) S: [0,4294967296)
 100 ; CHECK-NEXT:    %umin = call i64 @llvm.umin.i64(i64 %N.wide, i64 16)
 101 ; CHECK-NEXT:    --> (16 umin (zext i32 %N to i64)) U: [0,17) S: [0,17)
 102 ; CHECK-NEXT:    %n.vec = and i64 %umin, 28
 103 ; CHECK-NEXT:    --> (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw> U: [0,17) S: [0,17)
 104 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 105 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 106 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 107 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 108 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 109 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 110 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_min_max_zext
 111 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 112 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 113 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 114 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 115 ; CHECK-NEXT:   Predicates:
 116 ; CHECK:       Loop %loop: Trip multiple is 1
 117 ;
 118 entry:
 119   %N.wide = zext i32 %N to i64
 120   %umin = call i64 @llvm.umin.i64(i64 %N.wide, i64 16)
 121   %min.iters.check = icmp ult i64 %umin, 4
 122   br i1 %min.iters.check, label %exit, label %loop.ph
 123
 124 loop.ph:
 125   %n.vec = and i64 %umin, 28
 126   br label %loop
 127
 128 ; %n.vec is [4, 16) and a multiple of 4.
 129 loop:
 130   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 131   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 132   store i32 0, ptr %gep
 133   %index.next = add nuw i64 %index, 4
 134   %ec = icmp eq i64 %index.next, %n.vec
 135   br i1 %ec, label %exit, label %loop
 136
 137 exit:
 138   ret i32 0
 139 }
 140
 141 ; same as rewrite_zext_min_max, but everything is signed.
 142 ; It should be able to prove the same exit count.
 143 define i32 @rewrite_sext_min_max(i32 %N, ptr %arr) {
 144 ; CHECK-LABEL: 'rewrite_sext_min_max'
 145 ; CHECK-NEXT:  Classifying expressions for: @rewrite_sext_min_max
 146 ; CHECK-NEXT:    %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 147 ; CHECK-NEXT:    --> (16 smin %N) U: [-2147483648,17) S: [-2147483648,17)
 148 ; CHECK-NEXT:    %ext = sext i32 %smin to i64
 149 ; CHECK-NEXT:    --> (16 smin (sext i32 %N to i64)) U: [-2147483648,17) S: [-2147483648,17)
 150 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 151 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 152 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 153 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 154 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 155 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 156 ; CHECK-NEXT:    %index.next = add nsw i64 %index, 4
 157 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 158 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_sext_min_max
 159 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 160 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 161 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 162 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 163 ; CHECK-NEXT:   Predicates:
 164 ; CHECK:       Loop %loop: Trip multiple is 1
 165 ;
 166 entry:
 167   %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 168   %ext = sext i32 %smin to i64
 169   %min.iters.check = icmp slt i64 %ext, 4
 170   br i1 %min.iters.check, label %exit, label %loop.ph
 171
 172 loop.ph:
 173   %n.vec = and i64 %ext, 28
 174   br label %loop
 175
 176 ; %n.vec is [4, 16) and a multiple of 4.
 177 loop:
 178   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 179   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 180   store i32 0, ptr %gep
 181   %index.next = add nsw i64 %index, 4
 182   %ec = icmp eq i64 %index.next, %n.vec
 183   br i1 %ec, label %exit, label %loop
 184
 185 exit:
 186   ret i32 0
 187 }
 188
 189 ; This is a signed version of rewrite_min_max_zext.
 190 ; It should be able to prove the same exit count.
 191 define i32 @rewrite_min_max_sext(i32 %N, ptr %arr) {
 192 ; CHECK-LABEL: 'rewrite_min_max_sext'
 193 ; CHECK-NEXT:  Classifying expressions for: @rewrite_min_max_sext
 194 ; CHECK-NEXT:    %N.wide = sext i32 %N to i64
 195 ; CHECK-NEXT:    --> (sext i32 %N to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
 196 ; CHECK-NEXT:    %smin = call i64 @llvm.smin.i64(i64 %N.wide, i64 16)
 197 ; CHECK-NEXT:    --> (16 smin (sext i32 %N to i64)) U: [-2147483648,17) S: [-2147483648,17)
 198 ; CHECK-NEXT:    %n.vec = and i64 %smin, 28
 199 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 200 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 201 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 202 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 203 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 204 ; CHECK-NEXT:    %index.next = add nsw i64 %index, 4
 205 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 206 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_min_max_sext
 207 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 208 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 209 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 210 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 211 ; CHECK-NEXT:   Predicates:
 212 ; CHECK:       Loop %loop: Trip multiple is 1
 213 ;
 214 entry:
 215   %N.wide = sext i32 %N to i64
 216   %smin = call i64 @llvm.smin.i64(i64 %N.wide, i64 16)
 217   %min.iters.check = icmp slt i64 %smin, 4
 218   br i1 %min.iters.check, label %exit, label %loop.ph
 219
 220 loop.ph:
 221   %n.vec = and i64 %smin, 28
 222   br label %loop
 223
 224 ; %n.vec is [4, 16) and a multiple of 4.
 225 loop:
 226   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 227   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 228   store i32 0, ptr %gep
 229   %index.next = add nsw i64 %index, 4
 230   %ec = icmp eq i64 %index.next, %n.vec
 231   br i1 %ec, label %exit, label %loop
 232
 233 exit:
 234   ret i32 0
 235 }
 236
 237 ; Test case from PR52464. applyLoopGuards needs to apply information about %and
 238 ; to %ext, which requires rewriting the zext.
 239 define i32 @rewrite_zext_with_info_from_icmp_ne(i32 %N) {
 240 ; CHECK-LABEL: 'rewrite_zext_with_info_from_icmp_ne'
 241 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_with_info_from_icmp_ne
 242 ; CHECK-NEXT:    %and = and i32 %N, 3
 243 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %N to i2) to i32) U: [0,4) S: [0,4)
 244 ; CHECK-NEXT:    %and.sub.1 = add nsw i32 %and, -1
 245 ; CHECK-NEXT:    --> (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> U: [-1,3) S: [-1,3)
 246 ; CHECK-NEXT:    %ext = zext i32 %and.sub.1 to i64
 247 ; CHECK-NEXT:    --> (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64) U: [0,4294967296) S: [0,4294967296)
 248 ; CHECK-NEXT:    %n.rnd.up = add nuw nsw i64 %ext, 4
 249 ; CHECK-NEXT:    --> (4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> U: [4,4294967300) S: [4,4294967300)
 250 ; CHECK-NEXT:    %n.vec = and i64 %n.rnd.up, 8589934588
 251 ; CHECK-NEXT:    --> (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw> U: [4,4294967297) S: [4,4294967297)
 252 ; CHECK-NEXT:    %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
 253 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,1) S: [0,1) Exits: 0 LoopDispositions: { %loop: Computable }
 254 ; CHECK-NEXT:    %iv.next = add i64 %iv, 4
 255 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,5) S: [4,5) Exits: 4 LoopDispositions: { %loop: Computable }
 256 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_with_info_from_icmp_ne
 257 ; CHECK-NEXT:  Loop %loop: backedge-taken count is 0
 258 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 0
 259 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is 0
 260 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is 0
 261 ; CHECK-NEXT:   Predicates:
 262 ; CHECK:       Loop %loop: Trip multiple is 1
 263 ;
 264 entry:
 265   %and = and i32 %N, 3
 266   %cmp6.not = icmp eq i32 %and, 0
 267   br i1 %cmp6.not, label %exit, label %loop.ph
 268
 269 loop.ph:
 270   %and.sub.1 = add nsw i32 %and, -1
 271   %ext = zext i32 %and.sub.1 to i64
 272   %n.rnd.up = add nuw nsw i64 %ext, 4
 273   %n.vec = and i64 %n.rnd.up, 8589934588
 274   br label %loop
 275
 276 loop:
 277   %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
 278   %iv.next = add i64 %iv, 4
 279   call void @use(i64 %iv.next)
 280   %ec = icmp eq i64 %iv.next, %n.vec
 281   br i1 %ec, label %exit, label %loop
 282
 283 exit:
 284   ret i32 0
 285 }
 286
 287 ; Similar to @rewrite_zext_with_info_from_icmp_ne, but the loop is not guarded by %and != 0,
 288 ; hence the subsequent subtraction may yield a negative number.
 289 define i32 @rewrite_zext_no_icmp_ne(i32 %N) {
 290 ; CHECK-LABEL: 'rewrite_zext_no_icmp_ne'
 291 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_no_icmp_ne
 292 ; CHECK-NEXT:    %and = and i32 %N, 3
 293 ; CHECK-NEXT:    --> (zext i2 (trunc i32 %N to i2) to i32) U: [0,4) S: [0,4)
 294 ; CHECK-NEXT:    %and.sub.1 = add nsw i32 %and, -1
 295 ; CHECK-NEXT:    --> (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> U: [-1,3) S: [-1,3)
 296 ; CHECK-NEXT:    %ext = zext i32 %and.sub.1 to i64
 297 ; CHECK-NEXT:    --> (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64) U: [0,4294967296) S: [0,4294967296)
 298 ; CHECK-NEXT:    %n.rnd.up = add nuw nsw i64 %ext, 4
 299 ; CHECK-NEXT:    --> (4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> U: [4,4294967300) S: [4,4294967300)
 300 ; CHECK-NEXT:    %n.vec = and i64 %n.rnd.up, 8589934588
 301 ; CHECK-NEXT:    --> (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw> U: [4,4294967297) S: [4,4294967297)
 302 ; CHECK-NEXT:    %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
 303 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4))<nuw><nsw> LoopDispositions: { %loop: Computable }
 304 ; CHECK-NEXT:    %iv.next = add i64 %iv, 4
 305 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,4294967297) S: [4,4294967297) Exits: (4 + (4 * ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4))<nuw><nsw>)<nuw><nsw> LoopDispositions: { %loop: Computable }
 306 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_no_icmp_ne
 307 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
 308 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 1073741823
 309 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
 310 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
 311 ; CHECK-NEXT:   Predicates:
 312 ; CHECK:       Loop %loop: Trip multiple is 1
 313 ;
 314 entry:
 315   %and = and i32 %N, 3
 316   br label %loop.ph
 317
 318 loop.ph:
 319   %and.sub.1 = add nsw i32 %and, -1
 320   %ext = zext i32 %and.sub.1 to i64
 321   %n.rnd.up = add nuw nsw i64 %ext, 4
 322   %n.vec = and i64 %n.rnd.up, 8589934588
 323   br label %loop
 324
 325 loop:
 326   %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
 327   %iv.next = add i64 %iv, 4
 328   call void @use(i64 %iv.next)
 329   %ec = icmp eq i64 %iv.next, %n.vec
 330   br i1 %ec, label %exit, label %loop
 331
 332 exit:
 333   ret i32 0
 334 }
 335
 336 ; Make sure no information is lost for conditions on both %n and (zext %n).
 337 define void @rewrite_zext_and_base_1(i32 %n) {
 338 ; CHECK-LABEL: 'rewrite_zext_and_base_1'
 339 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_and_base_1
 340 ; CHECK-NEXT:    %ext = zext i32 %n to i64
 341 ; CHECK-NEXT:    --> (zext i32 %n to i64) U: [0,4294967296) S: [0,4294967296)
 342 ; CHECK-NEXT:    %n.vec = and i64 %ext, -8
 343 ; CHECK-NEXT:    --> (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw> U: [0,4294967289) S: [0,4294967289)
 344 ; CHECK-NEXT:    %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
 345 ; CHECK-NEXT:    --> {0,+,8}<nuw><nsw><%loop> U: [0,25) S: [0,25) Exits: (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw> LoopDispositions: { %loop: Computable }
 346 ; CHECK-NEXT:    %index.next = add nuw nsw i64 %index, 8
 347 ; CHECK-NEXT:    --> {8,+,8}<nuw><nsw><%loop> U: [8,33) S: [8,33) Exits: (8 + (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw>) LoopDispositions: { %loop: Computable }
 348 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_and_base_1
 349 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 350 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 351 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 352 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 353 ; CHECK-NEXT:   Predicates:
 354 ; CHECK:       Loop %loop: Trip multiple is 1
 355 ;
 356 entry:
 357   %ext = zext i32 %n to i64
 358   %cmp5 = icmp ule i64 %ext, 48
 359   br i1 %cmp5, label %check.1, label %exit
 360
 361 check.1:
 362   %cmp.2 = icmp ule i32 %n, 32
 363   br i1 %cmp.2, label %check, label %exit
 364
 365
 366 check:                                 ; preds = %entry
 367   %min.iters.check = icmp ult i64 %ext, 8
 368   %n.vec = and i64 %ext, -8
 369   br i1 %min.iters.check, label %exit, label %loop
 370
 371 loop:
 372   %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
 373   %index.next = add nuw nsw i64 %index, 8
 374   %ec = icmp eq i64 %index.next, %n.vec
 375   br i1 %ec, label %exit, label %loop
 376
 377 exit:
 378   ret void
 379 }
 380
 381 ; Make sure no information is lost for conditions on both %n and (zext %n).
 382 define void @rewrite_zext_and_base_2(i32 %n) {
 383 ; CHECK-LABEL: 'rewrite_zext_and_base_2'
 384 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_and_base_2
 385 ; CHECK-NEXT:    %ext = zext i32 %n to i64
 386 ; CHECK-NEXT:    --> (zext i32 %n to i64) U: [0,4294967296) S: [0,4294967296)
 387 ; CHECK-NEXT:    %n.vec = and i64 %ext, -8
 388 ; CHECK-NEXT:    --> (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw> U: [0,4294967289) S: [0,4294967289)
 389 ; CHECK-NEXT:    %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
 390 ; CHECK-NEXT:    --> {0,+,8}<nuw><nsw><%loop> U: [0,25) S: [0,25) Exits: (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw> LoopDispositions: { %loop: Computable }
 391 ; CHECK-NEXT:    %index.next = add nuw nsw i64 %index, 8
 392 ; CHECK-NEXT:    --> {8,+,8}<nuw><nsw><%loop> U: [8,33) S: [8,33) Exits: (8 + (8 * ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8))<nuw>) LoopDispositions: { %loop: Computable }
 393 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_and_base_2
 394 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 395 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 396 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 397 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
 398 ; CHECK-NEXT:   Predicates:
 399 ; CHECK:       Loop %loop: Trip multiple is 1
 400 ;
 401 entry:
 402   %ext = zext i32 %n to i64
 403   %cmp5 = icmp ule i64 %ext, 32
 404   br i1 %cmp5, label %check.1, label %exit
 405
 406 check.1:
 407   %cmp.2 = icmp ule i32 %n, 48
 408   br i1 %cmp.2, label %check, label %exit
 409
 410 check:                                 ; preds = %entry
 411   %min.iters.check = icmp ult i64 %ext, 8
 412   %n.vec = and i64 %ext, -8
 413   br i1 %min.iters.check, label %exit, label %loop
 414
 415 loop:
 416   %index = phi i64 [ 0, %check ], [ %index.next, %loop ]
 417   %index.next = add nuw nsw i64 %index, 8
 418   %ec = icmp eq i64 %index.next, %n.vec
 419   br i1 %ec, label %exit, label %loop
 420
 421 exit:
 422   ret void
 423 }
 424
 425 define void @guard_pessimizes_analysis_step2(i1 %c, i32 %N) {
 426 ; CHECK-LABEL: 'guard_pessimizes_analysis_step2'
 427 ; CHECK-NEXT:  Classifying expressions for: @guard_pessimizes_analysis_step2
 428 ; CHECK-NEXT:    %N.ext = zext i32 %N to i64
 429 ; CHECK-NEXT:    --> (zext i32 %N to i64) U: [0,4294967296) S: [0,4294967296)
 430 ; CHECK-NEXT:    %init = phi i64 [ 2, %entry ], [ 4, %bb1 ]
 431 ; CHECK-NEXT:    --> %init U: [2,5) S: [2,5)
 432 ; CHECK-NEXT:    %iv = phi i64 [ %iv.next, %loop ], [ %init, %loop.ph ]
 433 ; CHECK-NEXT:    --> {%init,+,2}<nuw><nsw><%loop> U: [2,17) S: [2,17) Exits: ((2 * ((14 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
 434 ; CHECK-NEXT:    %iv.next = add i64 %iv, 2
 435 ; CHECK-NEXT:    --> {(2 + %init)<nuw><nsw>,+,2}<nuw><nsw><%loop> U: [4,19) S: [4,19) Exits: (2 + (2 * ((14 + (-1 * %init)<nsw>)<nsw> /u 2))<nuw><nsw> + %init) LoopDispositions: { %loop: Computable }
 436 ; CHECK-NEXT:  Determining loop execution counts for: @guard_pessimizes_analysis_step2
 437 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
 438 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 6
 439 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
 440 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
 441 ; CHECK-NEXT:   Predicates:
 442 ; CHECK:       Loop %loop: Trip multiple is 1
 443 ;
 444 entry:
 445   %N.ext = zext i32 %N to i64
 446   br i1 %c, label %bb1, label %guard
 447
 448 bb1:
 449   br label %guard
 450
 451 guard:
 452   %init = phi i64 [ 2, %entry ], [ 4, %bb1 ]
 453   %c.1 = icmp ult i64 %init, %N.ext
 454   br i1 %c.1, label %loop.ph, label %exit
 455
 456 loop.ph:
 457   br label %loop
 458
 459 loop:
 460   %iv = phi i64 [ %iv.next, %loop ], [ %init, %loop.ph ]
 461   %iv.next = add i64 %iv, 2
 462   %exitcond = icmp eq i64 %iv.next, 16
 463   br i1 %exitcond, label %exit, label %loop
 464
 465 exit:
 466   ret void
 467 }
 468
 469 define i32 @rewrite_sext_slt_narrow_check(i32 %N, ptr %arr) {
 470 ; CHECK-LABEL: 'rewrite_sext_slt_narrow_check'
 471 ; CHECK-NEXT:  Classifying expressions for: @rewrite_sext_slt_narrow_check
 472 ; CHECK-NEXT:    %smin = call i32 @llvm.smax.i32(i32 %N, i32 4)
 473 ; CHECK-NEXT:    --> (4 smax %N) U: [4,-2147483648) S: [4,-2147483648)
 474 ; CHECK-NEXT:    %ext = sext i32 %smin to i64
 475 ; CHECK-NEXT:    --> (zext i32 (4 smax %N) to i64) U: [4,2147483648) S: [4,2147483648)
 476 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 477 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 478 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 479 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 480 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 481 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 482 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 483 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 484 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_sext_slt_narrow_check
 485 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 486 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 487 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 488 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 489 ; CHECK-NEXT:   Predicates:
 490 ; CHECK:       Loop %loop: Trip multiple is 1
 491 ;
 492 entry:
 493   %smin = call i32 @llvm.smax.i32(i32 %N, i32 4)
 494   %ext = sext i32 %smin to i64
 495   %min.iters.check = icmp slt i32 %smin, 17
 496   br i1 %min.iters.check, label %loop.ph, label %exit
 497
 498 loop.ph:
 499   %n.vec = and i64 %ext, 28
 500   br label %loop
 501
 502 ; %n.vec is [4, 16] and a multiple of 4.
 503 loop:
 504   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 505   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 506   store i32 0, ptr %gep
 507   %index.next = add nuw i64 %index, 4
 508   %ec = icmp eq i64 %index.next, %n.vec
 509   br i1 %ec, label %exit, label %loop
 510
 511 exit:
 512   ret i32 0
 513 }
 514
 515 define i32 @rewrite_zext_ult_narrow_check(i32 %N, ptr %arr) {
 516 ; CHECK-LABEL: 'rewrite_zext_ult_narrow_check'
 517 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_ult_narrow_check
 518 ; CHECK-NEXT:    %umin = call i32 @llvm.umax.i32(i32 %N, i32 4)
 519 ; CHECK-NEXT:    --> (4 umax %N) U: [4,0) S: [4,0)
 520 ; CHECK-NEXT:    %ext = zext i32 %umin to i64
 521 ; CHECK-NEXT:    --> (4 umax (zext i32 %N to i64)) U: [4,4294967296) S: [4,4294967296)
 522 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 523 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 524 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 525 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 526 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 527 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 528 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 529 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 530 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_ult_narrow_check
 531 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 532 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 533 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 534 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 535 ; CHECK-NEXT:   Predicates:
 536 ; CHECK:       Loop %loop: Trip multiple is 1
 537 ;
 538 entry:
 539   %umin = call i32 @llvm.umax.i32(i32 %N, i32 4)
 540   %ext = zext i32 %umin to i64
 541   %min.iters.check = icmp ult i32 %umin, 17
 542   br i1 %min.iters.check, label %loop.ph, label %exit
 543
 544 loop.ph:
 545   %n.vec = and i64 %ext, 28
 546   br label %loop
 547
 548 ; %n.vec is [4, 16] and a multiple of 4.
 549 loop:
 550   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 551   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 552   store i32 0, ptr %gep
 553   %index.next = add nuw i64 %index, 4
 554   %ec = icmp eq i64 %index.next, %n.vec
 555   br i1 %ec, label %exit, label %loop
 556
 557 exit:
 558   ret i32 0
 559 }
 560
 561 define i32 @rewrite_zext_ule_narrow_check(i32 %N, ptr %arr) {
 562 ; CHECK-LABEL: 'rewrite_zext_ule_narrow_check'
 563 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_ule_narrow_check
 564 ; CHECK-NEXT:    %umin = call i32 @llvm.umax.i32(i32 %N, i32 4)
 565 ; CHECK-NEXT:    --> (4 umax %N) U: [4,0) S: [4,0)
 566 ; CHECK-NEXT:    %ext = zext i32 %umin to i64
 567 ; CHECK-NEXT:    --> (4 umax (zext i32 %N to i64)) U: [4,4294967296) S: [4,4294967296)
 568 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 569 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 570 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 571 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 572 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 573 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 574 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 575 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 576 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_ule_narrow_check
 577 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 578 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 579 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 580 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 581 ; CHECK-NEXT:   Predicates:
 582 ; CHECK:       Loop %loop: Trip multiple is 1
 583 ;
 584 entry:
 585   %umin = call i32 @llvm.umax.i32(i32 %N, i32 4)
 586   %ext = zext i32 %umin to i64
 587   %min.iters.check = icmp ule i32 %umin, 16
 588   br i1 %min.iters.check, label %loop.ph, label %exit
 589
 590 loop.ph:
 591   %n.vec = and i64 %ext, 28
 592   br label %loop
 593
 594 ; %n.vec is [4, 16] and a multiple of 4.
 595 loop:
 596   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 597   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 598   store i32 0, ptr %gep
 599   %index.next = add nuw i64 %index, 4
 600   %ec = icmp eq i64 %index.next, %n.vec
 601   br i1 %ec, label %exit, label %loop
 602
 603 exit:
 604   ret i32 0
 605 }
 606
 607 define i32 @rewrite_zext_sle_narrow_check(i32 %N, ptr %arr) {
 608 ; CHECK-LABEL: 'rewrite_zext_sle_narrow_check'
 609 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_sle_narrow_check
 610 ; CHECK-NEXT:    %smin = call i32 @llvm.smax.i32(i32 %N, i32 4)
 611 ; CHECK-NEXT:    --> (4 smax %N) U: [4,-2147483648) S: [4,-2147483648)
 612 ; CHECK-NEXT:    %ext = sext i32 %smin to i64
 613 ; CHECK-NEXT:    --> (zext i32 (4 smax %N) to i64) U: [4,2147483648) S: [4,2147483648)
 614 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 615 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 616 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 617 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 618 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 619 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 620 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 621 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 622 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_sle_narrow_check
 623 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 624 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 625 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 626 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 627 ; CHECK-NEXT:   Predicates:
 628 ; CHECK:       Loop %loop: Trip multiple is 1
 629 ;
 630 entry:
 631   %smin = call i32 @llvm.smax.i32(i32 %N, i32 4)
 632   %ext = sext i32 %smin to i64
 633   %min.iters.check = icmp sle i32 %smin, 17
 634   br i1 %min.iters.check, label %loop.ph, label %exit
 635
 636 loop.ph:
 637   %n.vec = and i64 %ext, 28
 638   br label %loop
 639
 640 ; %n.vec is [4, 16] and a multiple of 4.
 641 loop:
 642   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 643   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 644   store i32 0, ptr %gep
 645   %index.next = add nuw i64 %index, 4
 646   %ec = icmp eq i64 %index.next, %n.vec
 647   br i1 %ec, label %exit, label %loop
 648
 649 exit:
 650   ret i32 0
 651 }
 652
 653 define i32 @rewrite_zext_uge_narrow_check(i32 %N, ptr %arr) {
 654 ; CHECK-LABEL: 'rewrite_zext_uge_narrow_check'
 655 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_uge_narrow_check
 656 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
 657 ; CHECK-NEXT:    --> (16 umin %N) U: [0,17) S: [0,17)
 658 ; CHECK-NEXT:    %ext = zext i32 %umin to i64
 659 ; CHECK-NEXT:    --> (16 umin (zext i32 %N to i64)) U: [0,17) S: [0,17)
 660 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 661 ; CHECK-NEXT:    --> (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw> U: [0,17) S: [0,17)
 662 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 663 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 664 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 665 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 666 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 667 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 668 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_uge_narrow_check
 669 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 670 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 671 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 672 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 673 ; CHECK-NEXT:   Predicates:
 674 ; CHECK:       Loop %loop: Trip multiple is 1
 675 ;
 676 entry:
 677   %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
 678   %ext = zext i32 %umin to i64
 679   %min.iters.check = icmp uge i32 %umin, 4
 680   br i1 %min.iters.check, label %loop.ph, label %exit
 681
 682 loop.ph:
 683   %n.vec = and i64 %ext, 28
 684   br label %loop
 685
 686 ; %n.vec is [4, 16] and a multiple of 4.
 687 loop:
 688   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 689   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 690   store i32 0, ptr %gep
 691   %index.next = add nuw i64 %index, 4
 692   %ec = icmp eq i64 %index.next, %n.vec
 693   br i1 %ec, label %exit, label %loop
 694
 695 exit:
 696   ret i32 0
 697 }
 698
 699 define i32 @rewrite_sext_sge_narrow_check(i32 %N, ptr %arr) {
 700 ; CHECK-LABEL: 'rewrite_sext_sge_narrow_check'
 701 ; CHECK-NEXT:  Classifying expressions for: @rewrite_sext_sge_narrow_check
 702 ; CHECK-NEXT:    %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 703 ; CHECK-NEXT:    --> (16 smin %N) U: [-2147483648,17) S: [-2147483648,17)
 704 ; CHECK-NEXT:    %ext = sext i32 %smin to i64
 705 ; CHECK-NEXT:    --> (16 smin (sext i32 %N to i64)) U: [-2147483648,17) S: [-2147483648,17)
 706 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 707 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 708 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 709 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 710 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 711 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 712 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 713 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 714 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_sext_sge_narrow_check
 715 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 716 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 717 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 718 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 719 ; CHECK-NEXT:   Predicates:
 720 ; CHECK:       Loop %loop: Trip multiple is 1
 721 ;
 722 entry:
 723   %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 724   %ext = sext i32 %smin to i64
 725   %min.iters.check = icmp sge i32 %smin, 4
 726   br i1 %min.iters.check, label %loop.ph, label %exit
 727
 728 loop.ph:
 729   %n.vec = and i64 %ext, 28
 730   br label %loop
 731
 732 ; %n.vec is [4, 16] and a multiple of 4.
 733 loop:
 734   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 735   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 736   store i32 0, ptr %gep
 737   %index.next = add nuw i64 %index, 4
 738   %ec = icmp eq i64 %index.next, %n.vec
 739   br i1 %ec, label %exit, label %loop
 740
 741 exit:
 742   ret i32 0
 743 }
 744
 745 define i32 @rewrite_zext_ugt_narrow_check(i32 %N, ptr %arr) {
 746 ; CHECK-LABEL: 'rewrite_zext_ugt_narrow_check'
 747 ; CHECK-NEXT:  Classifying expressions for: @rewrite_zext_ugt_narrow_check
 748 ; CHECK-NEXT:    %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
 749 ; CHECK-NEXT:    --> (16 umin %N) U: [0,17) S: [0,17)
 750 ; CHECK-NEXT:    %ext = zext i32 %umin to i64
 751 ; CHECK-NEXT:    --> (16 umin (zext i32 %N to i64)) U: [0,17) S: [0,17)
 752 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 753 ; CHECK-NEXT:    --> (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw> U: [0,17) S: [0,17)
 754 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 755 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 756 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 757 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 758 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 759 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 760 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_zext_ugt_narrow_check
 761 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 762 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 763 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 764 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
 765 ; CHECK-NEXT:   Predicates:
 766 ; CHECK:       Loop %loop: Trip multiple is 1
 767 ;
 768 entry:
 769   %umin = call i32 @llvm.umin.i32(i32 %N, i32 16)
 770   %ext = zext i32 %umin to i64
 771   %min.iters.check = icmp ugt i32 %umin, 3
 772   br i1 %min.iters.check, label %loop.ph, label %exit
 773
 774 loop.ph:
 775   %n.vec = and i64 %ext, 28
 776   br label %loop
 777
 778 ; %n.vec is [4, 16] and a multiple of 4.
 779 loop:
 780   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 781   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 782   store i32 0, ptr %gep
 783   %index.next = add nuw i64 %index, 4
 784   %ec = icmp eq i64 %index.next, %n.vec
 785   br i1 %ec, label %exit, label %loop
 786
 787 exit:
 788   ret i32 0
 789 }
 790
 791 define i32 @rewrite_sext_sgt_narrow_check(i32 %N, ptr %arr) {
 792 ; CHECK-LABEL: 'rewrite_sext_sgt_narrow_check'
 793 ; CHECK-NEXT:  Classifying expressions for: @rewrite_sext_sgt_narrow_check
 794 ; CHECK-NEXT:    %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 795 ; CHECK-NEXT:    --> (16 smin %N) U: [-2147483648,17) S: [-2147483648,17)
 796 ; CHECK-NEXT:    %ext = sext i32 %smin to i64
 797 ; CHECK-NEXT:    --> (16 smin (sext i32 %N to i64)) U: [-2147483648,17) S: [-2147483648,17)
 798 ; CHECK-NEXT:    %n.vec = and i64 %ext, 28
 799 ; CHECK-NEXT:    --> (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw> U: [0,29) S: [0,29)
 800 ; CHECK-NEXT:    %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 801 ; CHECK-NEXT:    --> {0,+,4}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw> LoopDispositions: { %loop: Computable }
 802 ; CHECK-NEXT:    %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 803 ; CHECK-NEXT:    --> {%arr,+,16}<nuw><%loop> U: full-set S: full-set Exits: ((16 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)) + %arr) LoopDispositions: { %loop: Computable }
 804 ; CHECK-NEXT:    %index.next = add nuw i64 %index, 4
 805 ; CHECK-NEXT:    --> {4,+,4}<nuw><nsw><%loop> U: [4,17) S: [4,17) Exits: (4 + (4 * ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4))<nuw>) LoopDispositions: { %loop: Computable }
 806 ; CHECK-NEXT:  Determining loop execution counts for: @rewrite_sext_sgt_narrow_check
 807 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 808 ; CHECK-NEXT:  Loop %loop: constant max backedge-taken count is 3
 809 ; CHECK-NEXT:  Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 810 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
 811 ; CHECK-NEXT:   Predicates:
 812 ; CHECK:       Loop %loop: Trip multiple is 1
 813 ;
 814 entry:
 815   %smin = call i32 @llvm.smin.i32(i32 %N, i32 16)
 816   %ext = sext i32 %smin to i64
 817   %min.iters.check = icmp sgt i32 %smin, 3
 818   br i1 %min.iters.check, label %loop.ph, label %exit
 819
 820 loop.ph:
 821   %n.vec = and i64 %ext, 28
 822   br label %loop
 823
 824 ; %n.vec is [4, 16) and a multiple of 4.
 825 loop:
 826   %index = phi i64 [ 0, %loop.ph ], [ %index.next, %loop ]
 827   %gep = getelementptr inbounds i32, ptr %arr, i64 %index
 828   store i32 0, ptr %gep
 829   %index.next = add nuw i64 %index, 4
 830   %ec = icmp eq i64 %index.next, %n.vec
 831   br i1 %ec, label %exit, label %loop
 832
 833 exit:
 834   ret i32 0
 835 }
 836
 837 declare void @use(i64)
 838
 839 declare i32 @llvm.umin.i32(i32, i32)
 840 declare i64 @llvm.umin.i64(i64, i64)
 841 declare i32 @llvm.smin.i32(i32, i32)
 842 declare i64 @llvm.smin.i64(i64, i64)
 843
 844 declare i32 @llvm.umax.i32(i32, i32)
 845 declare i32 @llvm.smax.i32(i32, i32)