llvm/test/Transforms/LoopUnroll/peel-loop-conditions.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -S -loop-unroll -unroll-peel-max-count=4 -verify-dom-info | FileCheck %s
   3
   4 declare void @f1()
   5 declare void @f2()
   6
   7 ; Check that we can peel off iterations that make conditions true.
   8 define void @test1(i32 %k) {
   9 ; CHECK-LABEL: @test1(
  10 ; CHECK-NEXT:  for.body.lr.ph:
  11 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
  12 ; CHECK:       for.body.peel.begin:
  13 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
  14 ; CHECK:       for.body.peel:
  15 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ult i32 0, 2
  16 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_ELSE_PEEL:%.*]]
  17 ; CHECK:       if.else.peel:
  18 ; CHECK-NEXT:    call void @f2()
  19 ; CHECK-NEXT:    br label [[FOR_INC_PEEL:%.*]]
  20 ; CHECK:       if.then.peel:
  21 ; CHECK-NEXT:    call void @f1()
  22 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
  23 ; CHECK:       for.inc.peel:
  24 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
  25 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
  26 ; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
  27 ; Verify that MD_loop metadata is dropped.
  28 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
  29 ; CHECK:       for.body.peel.next:
  30 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
  31 ; CHECK:       for.body.peel2:
  32 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ult i32 [[INC_PEEL]], 2
  33 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
  34 ; CHECK:       if.else.peel4:
  35 ; CHECK-NEXT:    call void @f2()
  36 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6:%.*]]
  37 ; CHECK:       if.then.peel5:
  38 ; CHECK-NEXT:    call void @f1()
  39 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6]]
  40 ; CHECK:       for.inc.peel6:
  41 ; CHECK-NEXT:    [[INC_PEEL7:%.*]] = add nsw i32 [[INC_PEEL]], 1
  42 ; CHECK-NEXT:    [[CMP_PEEL8:%.*]] = icmp slt i32 [[INC_PEEL7]], [[K]]
  43 ; CHECK-NEXT:    br i1 [[CMP_PEEL8]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
  44 ; Verify that MD_loop metadata is dropped.
  45 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
  46 ; CHECK:       for.body.peel.next1:
  47 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT9:%.*]]
  48 ; CHECK:       for.body.peel.next9:
  49 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
  50 ; CHECK:       for.body.lr.ph.peel.newph:
  51 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
  52 ; CHECK:       for.body:
  53 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL7]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
  54 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
  55 ; CHECK:       if.then:
  56 ; CHECK-NEXT:    call void @f1()
  57 ; CHECK-NEXT:    br label [[FOR_INC]]
  58 ; CHECK:       if.else:
  59 ; CHECK-NEXT:    call void @f2()
  60 ; CHECK-NEXT:    br label [[FOR_INC]]
  61 ; CHECK:       for.inc:
  62 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
  63 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
  64 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
  65 ; CHECK:       for.end.loopexit:
  66 ; CHECK-NEXT:    br label [[FOR_END]]
  67 ; CHECK:       for.end:
  68 ; CHECK-NEXT:    ret void
  69 ;
  70 for.body.lr.ph:
  71   br label %for.body
  72
  73 for.body:
  74   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
  75   %cmp1 = icmp ult i32 %i.05, 2
  76   br i1 %cmp1, label %if.then, label %if.else
  77
  78 if.then:
  79   call void @f1()
  80   br label %for.inc
  81
  82 if.else:
  83   call void @f2()
  84   br label %for.inc
  85
  86 for.inc:
  87   %inc = add nsw i32 %i.05, 1
  88   %cmp = icmp slt i32 %inc, %k
  89   br i1 %cmp, label %for.body, label %for.end, !llvm.loop !1
  90
  91 for.end:
  92   ret void
  93 }
  94
  95 !1 = distinct !{!1}
  96
  97 ; Check we peel off the maximum number of iterations that make conditions true.
  98 define void @test2(i32 %k) {
  99 ; CHECK-LABEL: @test2(
 100 ; CHECK-NEXT:  for.body.lr.ph:
 101 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 102 ; CHECK:       for.body.peel.begin:
 103 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 104 ; CHECK:       for.body.peel:
 105 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ult i32 0, 2
 106 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_ELSE_PEEL:%.*]]
 107 ; CHECK:       if.else.peel:
 108 ; CHECK-NEXT:    call void @f2()
 109 ; CHECK-NEXT:    br label [[IF2_PEEL:%.*]]
 110 ; CHECK:       if.then.peel:
 111 ; CHECK-NEXT:    call void @f1()
 112 ; CHECK-NEXT:    br label [[IF2_PEEL]]
 113 ; CHECK:       if2.peel:
 114 ; CHECK-NEXT:    [[CMP2_PEEL:%.*]] = icmp ult i32 0, 4
 115 ; CHECK-NEXT:    br i1 [[CMP2_PEEL]], label [[IF_THEN2_PEEL:%.*]], label [[FOR_INC_PEEL:%.*]]
 116 ; CHECK:       if.then2.peel:
 117 ; CHECK-NEXT:    call void @f1()
 118 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 119 ; CHECK:       for.inc.peel:
 120 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 121 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
 122 ; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
 123 ; Verify that MD_loop metadata is dropped.
 124 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 125 ; CHECK:       for.body.peel.next:
 126 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 127 ; CHECK:       for.body.peel2:
 128 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ult i32 [[INC_PEEL]], 2
 129 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
 130 ; CHECK:       if.else.peel4:
 131 ; CHECK-NEXT:    call void @f2()
 132 ; CHECK-NEXT:    br label [[IF2_PEEL6:%.*]]
 133 ; CHECK:       if.then.peel5:
 134 ; CHECK-NEXT:    call void @f1()
 135 ; CHECK-NEXT:    br label [[IF2_PEEL6]]
 136 ; CHECK:       if2.peel6:
 137 ; CHECK-NEXT:    [[CMP2_PEEL7:%.*]] = icmp ult i32 [[INC_PEEL]], 4
 138 ; CHECK-NEXT:    br i1 [[CMP2_PEEL7]], label [[IF_THEN2_PEEL8:%.*]], label [[FOR_INC_PEEL9:%.*]]
 139 ; CHECK:       if.then2.peel8:
 140 ; CHECK-NEXT:    call void @f1()
 141 ; CHECK-NEXT:    br label [[FOR_INC_PEEL9]]
 142 ; CHECK:       for.inc.peel9:
 143 ; CHECK-NEXT:    [[INC_PEEL10:%.*]] = add nsw i32 [[INC_PEEL]], 1
 144 ; CHECK-NEXT:    [[CMP_PEEL11:%.*]] = icmp slt i32 [[INC_PEEL10]], [[K]]
 145 ; CHECK-NEXT:    br i1 [[CMP_PEEL11]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
 146 ; Verify that MD_loop metadata is dropped.
 147 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 148 ; CHECK:       for.body.peel.next1:
 149 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL13:%.*]]
 150 ; CHECK:       for.body.peel13:
 151 ; CHECK-NEXT:    [[CMP1_PEEL14:%.*]] = icmp ult i32 [[INC_PEEL10]], 2
 152 ; CHECK-NEXT:    br i1 [[CMP1_PEEL14]], label [[IF_THEN_PEEL16:%.*]], label [[IF_ELSE_PEEL15:%.*]]
 153 ; CHECK:       if.else.peel15:
 154 ; CHECK-NEXT:    call void @f2()
 155 ; CHECK-NEXT:    br label [[IF2_PEEL17:%.*]]
 156 ; CHECK:       if.then.peel16:
 157 ; CHECK-NEXT:    call void @f1()
 158 ; CHECK-NEXT:    br label [[IF2_PEEL17]]
 159 ; CHECK:       if2.peel17:
 160 ; CHECK-NEXT:    [[CMP2_PEEL18:%.*]] = icmp ult i32 [[INC_PEEL10]], 4
 161 ; CHECK-NEXT:    br i1 [[CMP2_PEEL18]], label [[IF_THEN2_PEEL19:%.*]], label [[FOR_INC_PEEL20:%.*]]
 162 ; CHECK:       if.then2.peel19:
 163 ; CHECK-NEXT:    call void @f1()
 164 ; CHECK-NEXT:    br label [[FOR_INC_PEEL20]]
 165 ; CHECK:       for.inc.peel20:
 166 ; CHECK-NEXT:    [[INC_PEEL21:%.*]] = add nsw i32 [[INC_PEEL10]], 1
 167 ; CHECK-NEXT:    [[CMP_PEEL22:%.*]] = icmp slt i32 [[INC_PEEL21]], [[K]]
 168 ; CHECK-NEXT:    br i1 [[CMP_PEEL22]], label [[FOR_BODY_PEEL_NEXT12:%.*]], label [[FOR_END]]
 169 ; Verify that MD_loop metadata is dropped.
 170 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 171 ; CHECK:       for.body.peel.next12:
 172 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL24:%.*]]
 173 ; CHECK:       for.body.peel24:
 174 ; CHECK-NEXT:    [[CMP1_PEEL25:%.*]] = icmp ult i32 [[INC_PEEL21]], 2
 175 ; CHECK-NEXT:    br i1 [[CMP1_PEEL25]], label [[IF_THEN_PEEL27:%.*]], label [[IF_ELSE_PEEL26:%.*]]
 176 ; CHECK:       if.else.peel26:
 177 ; CHECK-NEXT:    call void @f2()
 178 ; CHECK-NEXT:    br label [[IF2_PEEL28:%.*]]
 179 ; CHECK:       if.then.peel27:
 180 ; CHECK-NEXT:    call void @f1()
 181 ; CHECK-NEXT:    br label [[IF2_PEEL28]]
 182 ; CHECK:       if2.peel28:
 183 ; CHECK-NEXT:    [[CMP2_PEEL29:%.*]] = icmp ult i32 [[INC_PEEL21]], 4
 184 ; CHECK-NEXT:    br i1 [[CMP2_PEEL29]], label [[IF_THEN2_PEEL30:%.*]], label [[FOR_INC_PEEL31:%.*]]
 185 ; CHECK:       if.then2.peel30:
 186 ; CHECK-NEXT:    call void @f1()
 187 ; CHECK-NEXT:    br label [[FOR_INC_PEEL31]]
 188 ; CHECK:       for.inc.peel31:
 189 ; CHECK-NEXT:    [[INC_PEEL32:%.*]] = add nsw i32 [[INC_PEEL21]], 1
 190 ; CHECK-NEXT:    [[CMP_PEEL33:%.*]] = icmp slt i32 [[INC_PEEL32]], [[K]]
 191 ; CHECK-NEXT:    br i1 [[CMP_PEEL33]], label [[FOR_BODY_PEEL_NEXT23:%.*]], label [[FOR_END]]
 192 ; Verify that MD_loop metadata is dropped.
 193 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 194 ; CHECK:       for.body.peel.next23:
 195 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT34:%.*]]
 196 ; CHECK:       for.body.peel.next34:
 197 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
 198 ; CHECK:       for.body.lr.ph.peel.newph:
 199 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 200 ; CHECK:       for.body:
 201 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL32]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 202 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 203 ; CHECK:       if.then:
 204 ; CHECK-NEXT:    call void @f1()
 205 ; CHECK-NEXT:    br label [[IF2:%.*]]
 206 ; CHECK:       if.else:
 207 ; CHECK-NEXT:    call void @f2()
 208 ; CHECK-NEXT:    br label [[IF2]]
 209 ; CHECK:       if2:
 210 ; CHECK-NEXT:    br i1 false, label [[IF_THEN2:%.*]], label [[FOR_INC]]
 211 ; CHECK:       if.then2:
 212 ; CHECK-NEXT:    call void @f1()
 213 ; CHECK-NEXT:    br label [[FOR_INC]]
 214 ; CHECK:       for.inc:
 215 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 216 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
 217 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
 218 ; CHECK:       for.end.loopexit:
 219 ; CHECK-NEXT:    br label [[FOR_END]]
 220 ; CHECK:       for.end:
 221 ; CHECK-NEXT:    ret void
 222 ;
 223 for.body.lr.ph:
 224   br label %for.body
 225
 226 for.body:
 227   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 228   %cmp1 = icmp ult i32 %i.05, 2
 229   br i1 %cmp1, label %if.then, label %if.else
 230
 231 if.then:
 232   call void @f1()
 233   br label %if2
 234
 235 if.else:
 236   call void @f2()
 237   br label %if2
 238
 239 if2:
 240   %cmp2 = icmp ult i32 %i.05, 4
 241   br i1 %cmp2, label %if.then2, label %for.inc
 242
 243 if.then2:
 244   call void @f1()
 245   br label %for.inc
 246
 247 for.inc:
 248   %inc = add nsw i32 %i.05, 1
 249   %cmp = icmp slt i32 %inc, %k
 250   br i1 %cmp, label %for.body, label %for.end, !llvm.loop !2
 251
 252 for.end:
 253   ret void
 254 }
 255
 256 !2 = distinct !{!2}
 257
 258 ; Check that we can peel off iterations that make a condition false.
 259 define void @test3(i32 %k) {
 260 ; CHECK-LABEL: @test3(
 261 ; CHECK-NEXT:  for.body.lr.ph:
 262 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 263 ; CHECK:       for.body.peel.begin:
 264 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 265 ; CHECK:       for.body.peel:
 266 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ugt i32 0, 2
 267 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_ELSE_PEEL:%.*]]
 268 ; CHECK:       if.else.peel:
 269 ; CHECK-NEXT:    call void @f2()
 270 ; CHECK-NEXT:    br label [[FOR_INC_PEEL:%.*]]
 271 ; CHECK:       if.then.peel:
 272 ; CHECK-NEXT:    call void @f1()
 273 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 274 ; CHECK:       for.inc.peel:
 275 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 276 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
 277 ; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%[^,]*]]
 278 ; Verify that MD_loop metadata is dropped.
 279 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 280 ; CHECK:       for.body.peel.next:
 281 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 282 ; CHECK:       for.body.peel2:
 283 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ugt i32 [[INC_PEEL]], 2
 284 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL5:%.*]], label [[IF_ELSE_PEEL4:%.*]]
 285 ; CHECK:       if.else.peel4:
 286 ; CHECK-NEXT:    call void @f2()
 287 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6:%.*]]
 288 ; CHECK:       if.then.peel5:
 289 ; CHECK-NEXT:    call void @f1()
 290 ; CHECK-NEXT:    br label [[FOR_INC_PEEL6]]
 291 ; CHECK:       for.inc.peel6:
 292 ; CHECK-NEXT:    [[INC_PEEL7:%.*]] = add nsw i32 [[INC_PEEL]], 1
 293 ; CHECK-NEXT:    [[CMP_PEEL8:%.*]] = icmp slt i32 [[INC_PEEL7]], [[K]]
 294 ; CHECK-NEXT:    br i1 [[CMP_PEEL8]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
 295 ; Verify that MD_loop metadata is dropped.
 296 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 297 ; CHECK:       for.body.peel.next1:
 298 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL10:%.*]]
 299 ; CHECK:       for.body.peel10:
 300 ; CHECK-NEXT:    [[CMP1_PEEL11:%.*]] = icmp ugt i32 [[INC_PEEL7]], 2
 301 ; CHECK-NEXT:    br i1 [[CMP1_PEEL11]], label [[IF_THEN_PEEL13:%.*]], label [[IF_ELSE_PEEL12:%.*]]
 302 ; CHECK:       if.else.peel12:
 303 ; CHECK-NEXT:    call void @f2()
 304 ; CHECK-NEXT:    br label [[FOR_INC_PEEL14:%.*]]
 305 ; CHECK:       if.then.peel13:
 306 ; CHECK-NEXT:    call void @f1()
 307 ; CHECK-NEXT:    br label [[FOR_INC_PEEL14]]
 308 ; CHECK:       for.inc.peel14:
 309 ; CHECK-NEXT:    [[INC_PEEL15:%.*]] = add nsw i32 [[INC_PEEL7]], 1
 310 ; CHECK-NEXT:    [[CMP_PEEL16:%.*]] = icmp slt i32 [[INC_PEEL15]], [[K]]
 311 ; CHECK-NEXT:    br i1 [[CMP_PEEL16]], label [[FOR_BODY_PEEL_NEXT9:%.*]], label [[FOR_END]]
 312 ; Verify that MD_loop metadata is dropped.
 313 ; CHECK-NOT:   , !llvm.loop !{{[0-9]*}}
 314 ; CHECK:       for.body.peel.next9:
 315 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT17:%.*]]
 316 ; CHECK:       for.body.peel.next17:
 317 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
 318 ; CHECK:       for.body.lr.ph.peel.newph:
 319 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 320 ; CHECK:       for.body:
 321 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL15]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 322 ; CHECK-NEXT:    br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 323 ; CHECK:       if.then:
 324 ; CHECK-NEXT:    call void @f1()
 325 ; CHECK-NEXT:    br label [[FOR_INC]]
 326 ; CHECK:       if.else:
 327 ; CHECK-NEXT:    call void @f2()
 328 ; CHECK-NEXT:    br label [[FOR_INC]]
 329 ; CHECK:       for.inc:
 330 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 331 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
 332 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !{{.*}}
 333 ; CHECK:       for.end.loopexit:
 334 ; CHECK-NEXT:    br label [[FOR_END]]
 335 ; CHECK:       for.end:
 336 ; CHECK-NEXT:    ret void
 337 ;
 338 for.body.lr.ph:
 339   br label %for.body
 340
 341 for.body:
 342   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 343   %cmp1 = icmp ugt i32 %i.05, 2
 344   br i1 %cmp1, label %if.then, label %if.else
 345
 346 if.then:
 347   call void @f1()
 348   br label %for.inc
 349
 350 if.else:
 351   call void @f2()
 352   br label %for.inc
 353
 354 for.inc:
 355   %inc = add nsw i32 %i.05, 1
 356   %cmp = icmp slt i32 %inc, %k
 357   br i1 %cmp, label %for.body, label %for.end, !llvm.loop !3
 358
 359 for.end:
 360   ret void
 361 }
 362
 363 !3 = distinct !{!3}
 364
 365 ; Test that we only peel off iterations if it simplifies a condition in the
 366 ; loop body after peeling at most MaxPeelCount iterations.
 367 define void @test4(i32 %k) {
 368 ; CHECK-LABEL: @test4(
 369 ; CHECK-NEXT:  for.body.lr.ph:
 370 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 371 ; CHECK:       for.body:
 372 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 373 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i32 [[I_05]], 9999
 374 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
 375 ; CHECK:       if.then:
 376 ; CHECK-NEXT:    call void @f1()
 377 ; CHECK-NEXT:    br label [[FOR_INC]]
 378 ; CHECK:       for.inc:
 379 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[I_05]], 1
 380 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K:%.*]]
 381 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 382 ; CHECK:       for.end:
 383 ; CHECK-NEXT:    ret void
 384 ;
 385 for.body.lr.ph:
 386   br label %for.body
 387
 388 for.body:
 389   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 390   %cmp1 = icmp ugt i32 %i.05, 9999
 391   br i1 %cmp1, label %if.then, label %for.inc
 392
 393 if.then:
 394   call void @f1()
 395   br label %for.inc
 396
 397 for.inc:
 398   %inc = add nsw i32 %i.05, 1
 399   %cmp = icmp slt i32 %inc, %k
 400   br i1 %cmp, label %for.body, label %for.end
 401
 402 for.end:
 403   ret void
 404 }
 405
 406 ; In this test, the condition involves 2 AddRecs. Without evaluating both
 407 ; AddRecs, we cannot prove that the condition becomes known in the loop body
 408 ; after peeling.
 409 define void @test5(i32 %k) {
 410 ; CHECK-LABEL: @test5(
 411 ; CHECK-NEXT:  entry:
 412 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 413 ; CHECK:       for.body:
 414 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 415 ; CHECK-NEXT:    [[J:%.*]] = phi i32 [ 4, [[ENTRY]] ], [ [[J_INC:%.*]], [[FOR_INC]] ]
 416 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i32 [[I_05]], [[J]]
 417 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 418 ; CHECK:       if.then:
 419 ; CHECK-NEXT:    call void @f1()
 420 ; CHECK-NEXT:    br label [[FOR_INC]]
 421 ; CHECK:       if.else:
 422 ; CHECK-NEXT:    call void @f2()
 423 ; CHECK-NEXT:    br label [[FOR_INC]]
 424 ; CHECK:       for.inc:
 425 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[I_05]], 2
 426 ; CHECK-NEXT:    [[J_INC]] = add nsw i32 [[J]], 1
 427 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K:%.*]]
 428 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 429 ; CHECK:       for.end:
 430 ; CHECK-NEXT:    ret void
 431 ;
 432 entry:
 433   br label %for.body
 434
 435 for.body:
 436   %i.05 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
 437   %j = phi i32 [ 4, %entry ], [ %j.inc, %for.inc ]
 438   %cmp1 = icmp ult i32 %i.05, %j
 439   br i1 %cmp1, label %if.then, label %if.else
 440
 441 if.then:
 442   call void @f1()
 443   br label %for.inc
 444
 445 if.else:
 446   call void @f2()
 447   br label %for.inc
 448
 449 for.inc:
 450   %inc = add nsw i32 %i.05, 2
 451   %j.inc = add nsw i32 %j, 1
 452   %cmp = icmp slt i32 %inc, %k
 453   br i1 %cmp, label %for.body, label %for.end
 454
 455 for.end:
 456   ret void
 457 }
 458
 459 define void @test6(i32 %k) {
 460 ; CHECK-LABEL: @test6(
 461 ; CHECK-NEXT:  for.body.lr.ph:
 462 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 463 ; CHECK:       for.body.peel.begin:
 464 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 465 ; CHECK:       for.body.peel:
 466 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ne i32 0, 3
 467 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[FOR_INC_PEEL:%.*]]
 468 ; CHECK:       if.then.peel:
 469 ; CHECK-NEXT:    call void @f1()
 470 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 471 ; CHECK:       for.inc.peel:
 472 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 473 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
 474 ; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%.*]]
 475 ; CHECK:       for.body.peel.next:
 476 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 477 ; CHECK:       for.body.peel2:
 478 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp ne i32 [[INC_PEEL]], 3
 479 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL4:%.*]], label [[FOR_INC_PEEL5:%.*]]
 480 ; CHECK:       if.then.peel4:
 481 ; CHECK-NEXT:    call void @f1()
 482 ; CHECK-NEXT:    br label [[FOR_INC_PEEL5]]
 483 ; CHECK:       for.inc.peel5:
 484 ; CHECK-NEXT:    [[INC_PEEL6:%.*]] = add nsw i32 [[INC_PEEL]], 1
 485 ; CHECK-NEXT:    [[CMP_PEEL7:%.*]] = icmp slt i32 [[INC_PEEL6]], [[K]]
 486 ; CHECK-NEXT:    br i1 [[CMP_PEEL7]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
 487 ; CHECK:       for.body.peel.next1:
 488 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL9:%.*]]
 489 ; CHECK:       for.body.peel9:
 490 ; CHECK-NEXT:    [[CMP1_PEEL10:%.*]] = icmp ne i32 [[INC_PEEL6]], 3
 491 ; CHECK-NEXT:    br i1 [[CMP1_PEEL10]], label [[IF_THEN_PEEL11:%.*]], label [[FOR_INC_PEEL12:%.*]]
 492 ; CHECK:       if.then.peel11:
 493 ; CHECK-NEXT:    call void @f1()
 494 ; CHECK-NEXT:    br label [[FOR_INC_PEEL12]]
 495 ; CHECK:       for.inc.peel12:
 496 ; CHECK-NEXT:    [[INC_PEEL13:%.*]] = add nsw i32 [[INC_PEEL6]], 1
 497 ; CHECK-NEXT:    [[CMP_PEEL14:%.*]] = icmp slt i32 [[INC_PEEL13]], [[K]]
 498 ; CHECK-NEXT:    br i1 [[CMP_PEEL14]], label [[FOR_BODY_PEEL_NEXT8:%.*]], label [[FOR_END]]
 499 ; CHECK:       for.body.peel.next8:
 500 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL16:%.*]]
 501 ; CHECK:       for.body.peel16:
 502 ; CHECK-NEXT:    [[CMP1_PEEL17:%.*]] = icmp ne i32 [[INC_PEEL13]], 3
 503 ; CHECK-NEXT:    br i1 [[CMP1_PEEL17]], label [[IF_THEN_PEEL18:%.*]], label [[FOR_INC_PEEL19:%.*]]
 504 ; CHECK:       if.then.peel18:
 505 ; CHECK-NEXT:    call void @f1()
 506 ; CHECK-NEXT:    br label [[FOR_INC_PEEL19]]
 507 ; CHECK:       for.inc.peel19:
 508 ; CHECK-NEXT:    [[INC_PEEL20:%.*]] = add nsw i32 [[INC_PEEL13]], 1
 509 ; CHECK-NEXT:    [[CMP_PEEL21:%.*]] = icmp slt i32 [[INC_PEEL20]], [[K]]
 510 ; CHECK-NEXT:    br i1 [[CMP_PEEL21]], label [[FOR_BODY_PEEL_NEXT15:%.*]], label [[FOR_END]]
 511 ; CHECK:       for.body.peel.next15:
 512 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT22:%.*]]
 513 ; CHECK:       for.body.peel.next22:
 514 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
 515 ; CHECK:       for.body.lr.ph.peel.newph:
 516 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 517 ; CHECK:       for.body:
 518 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL20]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 519 ; CHECK-NEXT:    br i1 true, label [[IF_THEN:%.*]], label [[FOR_INC]]
 520 ; CHECK:       if.then:
 521 ; CHECK-NEXT:    call void @f1()
 522 ; CHECK-NEXT:    br label [[FOR_INC]]
 523 ; CHECK:       for.inc:
 524 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 525 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
 526 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !6
 527 ; CHECK:       for.end.loopexit:
 528 ; CHECK-NEXT:    br label [[FOR_END]]
 529 ; CHECK:       for.end:
 530 ; CHECK-NEXT:    ret void
 531 ;
 532 for.body.lr.ph:
 533   br label %for.body
 534
 535 for.body:
 536   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 537   %cmp1 = icmp ne i32 %i.05, 3
 538   br i1 %cmp1, label %if.then, label %for.inc
 539
 540 if.then:
 541   call void @f1()
 542   br label %for.inc
 543
 544 for.inc:
 545   %inc = add nsw i32 %i.05, 1
 546   %cmp = icmp slt i32 %inc, %k
 547   br i1 %cmp, label %for.body, label %for.end
 548
 549 for.end:
 550   ret void
 551 }
 552
 553 define void @test7(i32 %k) {
 554 ; CHECK-LABEL: @test7(
 555 ; CHECK-NEXT:  for.body.lr.ph:
 556 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 557 ; CHECK:       for.body.peel.begin:
 558 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 559 ; CHECK:       for.body.peel:
 560 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp eq i32 0, 3
 561 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[FOR_INC_PEEL:%.*]]
 562 ; CHECK:       if.then.peel:
 563 ; CHECK-NEXT:    call void @f1()
 564 ; CHECK-NEXT:    br label [[FOR_INC_PEEL]]
 565 ; CHECK:       for.inc.peel:
 566 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nsw i32 0, 1
 567 ; CHECK-NEXT:    [[CMP_PEEL:%.*]] = icmp slt i32 [[INC_PEEL]], [[K:%.*]]
 568 ; CHECK-NEXT:    br i1 [[CMP_PEEL]], label [[FOR_BODY_PEEL_NEXT:%.*]], label [[FOR_END:%.*]]
 569 ; CHECK:       for.body.peel.next:
 570 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL2:%.*]]
 571 ; CHECK:       for.body.peel2:
 572 ; CHECK-NEXT:    [[CMP1_PEEL3:%.*]] = icmp eq i32 [[INC_PEEL]], 3
 573 ; CHECK-NEXT:    br i1 [[CMP1_PEEL3]], label [[IF_THEN_PEEL4:%.*]], label [[FOR_INC_PEEL5:%.*]]
 574 ; CHECK:       if.then.peel4:
 575 ; CHECK-NEXT:    call void @f1()
 576 ; CHECK-NEXT:    br label [[FOR_INC_PEEL5]]
 577 ; CHECK:       for.inc.peel5:
 578 ; CHECK-NEXT:    [[INC_PEEL6:%.*]] = add nsw i32 [[INC_PEEL]], 1
 579 ; CHECK-NEXT:    [[CMP_PEEL7:%.*]] = icmp slt i32 [[INC_PEEL6]], [[K]]
 580 ; CHECK-NEXT:    br i1 [[CMP_PEEL7]], label [[FOR_BODY_PEEL_NEXT1:%.*]], label [[FOR_END]]
 581 ; CHECK:       for.body.peel.next1:
 582 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL9:%.*]]
 583 ; CHECK:       for.body.peel9:
 584 ; CHECK-NEXT:    [[CMP1_PEEL10:%.*]] = icmp eq i32 [[INC_PEEL6]], 3
 585 ; CHECK-NEXT:    br i1 [[CMP1_PEEL10]], label [[IF_THEN_PEEL11:%.*]], label [[FOR_INC_PEEL12:%.*]]
 586 ; CHECK:       if.then.peel11:
 587 ; CHECK-NEXT:    call void @f1()
 588 ; CHECK-NEXT:    br label [[FOR_INC_PEEL12]]
 589 ; CHECK:       for.inc.peel12:
 590 ; CHECK-NEXT:    [[INC_PEEL13:%.*]] = add nsw i32 [[INC_PEEL6]], 1
 591 ; CHECK-NEXT:    [[CMP_PEEL14:%.*]] = icmp slt i32 [[INC_PEEL13]], [[K]]
 592 ; CHECK-NEXT:    br i1 [[CMP_PEEL14]], label [[FOR_BODY_PEEL_NEXT8:%.*]], label [[FOR_END]]
 593 ; CHECK:       for.body.peel.next8:
 594 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL16:%.*]]
 595 ; CHECK:       for.body.peel16:
 596 ; CHECK-NEXT:    [[CMP1_PEEL17:%.*]] = icmp eq i32 [[INC_PEEL13]], 3
 597 ; CHECK-NEXT:    br i1 [[CMP1_PEEL17]], label [[IF_THEN_PEEL18:%.*]], label [[FOR_INC_PEEL19:%.*]]
 598 ; CHECK:       if.then.peel18:
 599 ; CHECK-NEXT:    call void @f1()
 600 ; CHECK-NEXT:    br label [[FOR_INC_PEEL19]]
 601 ; CHECK:       for.inc.peel19:
 602 ; CHECK-NEXT:    [[INC_PEEL20:%.*]] = add nsw i32 [[INC_PEEL13]], 1
 603 ; CHECK-NEXT:    [[CMP_PEEL21:%.*]] = icmp slt i32 [[INC_PEEL20]], [[K]]
 604 ; CHECK-NEXT:    br i1 [[CMP_PEEL21]], label [[FOR_BODY_PEEL_NEXT15:%.*]], label [[FOR_END]]
 605 ; CHECK:       for.body.peel.next15:
 606 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT22:%.*]]
 607 ; CHECK:       for.body.peel.next22:
 608 ; CHECK-NEXT:    br label [[FOR_BODY_LR_PH_PEEL_NEWPH:%.*]]
 609 ; CHECK:       for.body.lr.ph.peel.newph:
 610 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 611 ; CHECK:       for.body:
 612 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ [[INC_PEEL20]], [[FOR_BODY_LR_PH_PEEL_NEWPH]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 613 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[FOR_INC]]
 614 ; CHECK:       if.then:
 615 ; CHECK-NEXT:    call void @f1()
 616 ; CHECK-NEXT:    br label [[FOR_INC]]
 617 ; CHECK:       for.inc:
 618 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_05]], 1
 619 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K]]
 620 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]], !llvm.loop !7
 621 ; CHECK:       for.end.loopexit:
 622 ; CHECK-NEXT:    br label [[FOR_END]]
 623 ; CHECK:       for.end:
 624 ; CHECK-NEXT:    ret void
 625 ;
 626 for.body.lr.ph:
 627   br label %for.body
 628
 629 for.body:
 630   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 631   %cmp1 = icmp eq i32 %i.05, 3
 632   br i1 %cmp1, label %if.then, label %for.inc
 633
 634 if.then:
 635   call void @f1()
 636   br label %for.inc
 637
 638 for.inc:
 639   %inc = add nsw i32 %i.05, 1
 640   %cmp = icmp slt i32 %inc, %k
 641   br i1 %cmp, label %for.body, label %for.end
 642
 643 for.end:
 644   ret void
 645 }
 646
 647 ; Comparison with non-monotonic predicate due to possible wrapping, loop
 648 ; body cannot be simplified.
 649 define void @test8(i32 %k) {
 650 ; CHECK-LABEL: @test8(
 651 ; CHECK-NEXT:  for.body.lr.ph:
 652 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 653 ; CHECK:       for.body:
 654 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
 655 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[I_05]], 3
 656 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
 657 ; CHECK:       if.then:
 658 ; CHECK-NEXT:    call void @f1()
 659 ; CHECK-NEXT:    br label [[FOR_INC]]
 660 ; CHECK:       for.inc:
 661 ; CHECK-NEXT:    [[INC]] = add i32 [[I_05]], 1
 662 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K:%.*]]
 663 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 664 ; CHECK:       for.end:
 665 ; CHECK-NEXT:    ret void
 666 ;
 667 for.body.lr.ph:
 668   br label %for.body
 669
 670 for.body:
 671   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
 672   %cmp1 = icmp slt i32 %i.05, 3
 673   br i1 %cmp1, label %if.then, label %for.inc
 674
 675 if.then:
 676   call void @f1()
 677   br label %for.inc
 678
 679 for.inc:
 680   %inc = add i32 %i.05, 1
 681   %cmp = icmp slt i32 %inc, %k
 682   br i1 %cmp, label %for.body, label %for.end
 683
 684 for.end:
 685   ret void
 686 }
 687 ; CHECK-NOT: llvm.loop.unroll.disable
 688
 689 define void @test_9__peel_first_iter_via_slt_pred(i32 %len) {
 690 ; CHECK-LABEL: @test_9__peel_first_iter_via_slt_pred(
 691 ; CHECK-NEXT:  entry:
 692 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
 693 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 694 ; CHECK:       for.body.preheader:
 695 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 696 ; CHECK:       for.body.peel.begin:
 697 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 698 ; CHECK:       for.body.peel:
 699 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp slt i32 0, 1
 700 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_END_PEEL:%.*]]
 701 ; CHECK:       if.then.peel:
 702 ; CHECK-NEXT:    call void @init()
 703 ; CHECK-NEXT:    br label [[IF_END_PEEL]]
 704 ; CHECK:       if.end.peel:
 705 ; CHECK-NEXT:    call void @sink()
 706 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nuw nsw i32 0, 1
 707 ; CHECK-NEXT:    [[EXITCOND_PEEL:%.*]] = icmp eq i32 [[INC_PEEL]], [[LEN]]
 708 ; CHECK-NEXT:    br i1 [[EXITCOND_PEEL]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY_PEEL_NEXT:%.*]]
 709 ; CHECK:       for.body.peel.next:
 710 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT1:%.*]]
 711 ; CHECK:       for.body.peel.next1:
 712 ; CHECK-NEXT:    br label [[FOR_BODY_PREHEADER_PEEL_NEWPH:%.*]]
 713 ; CHECK:       for.body.preheader.peel.newph:
 714 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 715 ; CHECK:       for.cond.cleanup.loopexit.loopexit:
 716 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP_LOOPEXIT]]
 717 ; CHECK:       for.cond.cleanup.loopexit:
 718 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
 719 ; CHECK:       for.cond.cleanup:
 720 ; CHECK-NEXT:    ret void
 721 ; CHECK:       for.body:
 722 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ [[INC_PEEL]], [[FOR_BODY_PREHEADER_PEEL_NEWPH]] ]
 723 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_END]]
 724 ; CHECK:       if.then:
 725 ; CHECK-NEXT:    call void @init()
 726 ; CHECK-NEXT:    br label [[IF_END]]
 727 ; CHECK:       if.end:
 728 ; CHECK-NEXT:    call void @sink()
 729 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
 730 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
 731 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT_LOOPEXIT:%.*]], label [[FOR_BODY]], !llvm.loop !8
 732 ;
 733 entry:
 734   %cmp5 = icmp sgt i32 %len, 0
 735   br i1 %cmp5, label %for.body, label %for.cond.cleanup
 736
 737 for.cond.cleanup:                                 ; preds = %if.end, %entry
 738   ret void
 739
 740 for.body:                                         ; preds = %entry, %if.end
 741   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
 742   %cmp1 = icmp slt i32 %i.06, 1
 743   br i1 %cmp1, label %if.then, label %if.end
 744
 745 if.then:                                          ; preds = %for.body
 746   call void @init()
 747   br label %if.end
 748
 749 if.end:                                           ; preds = %if.then, %for.body
 750   call void @sink()
 751   %inc = add nuw nsw i32 %i.06, 1
 752   %exitcond = icmp eq i32 %inc, %len
 753   br i1 %exitcond, label %for.cond.cleanup, label %for.body
 754 }
 755
 756 define void @test_10__peel_first_iter_via_sgt_pred(i32 %len) {
 757 ; CHECK-LABEL: @test_10__peel_first_iter_via_sgt_pred(
 758 ; CHECK-NEXT:  entry:
 759 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
 760 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 761 ; CHECK:       for.body.preheader:
 762 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 763 ; CHECK:       for.body.peel.begin:
 764 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 765 ; CHECK:       for.body.peel:
 766 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp sgt i32 0, 0
 767 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_END_PEEL:%.*]], label [[IF_THEN_PEEL:%.*]]
 768 ; CHECK:       if.then.peel:
 769 ; CHECK-NEXT:    call void @init()
 770 ; CHECK-NEXT:    br label [[IF_END_PEEL]]
 771 ; CHECK:       if.end.peel:
 772 ; CHECK-NEXT:    call void @sink()
 773 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nuw nsw i32 0, 1
 774 ; CHECK-NEXT:    [[EXITCOND_PEEL:%.*]] = icmp eq i32 [[INC_PEEL]], [[LEN]]
 775 ; CHECK-NEXT:    br i1 [[EXITCOND_PEEL]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY_PEEL_NEXT:%.*]]
 776 ; CHECK:       for.body.peel.next:
 777 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT1:%.*]]
 778 ; CHECK:       for.body.peel.next1:
 779 ; CHECK-NEXT:    br label [[FOR_BODY_PREHEADER_PEEL_NEWPH:%.*]]
 780 ; CHECK:       for.body.preheader.peel.newph:
 781 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 782 ; CHECK:       for.cond.cleanup.loopexit.loopexit:
 783 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP_LOOPEXIT]]
 784 ; CHECK:       for.cond.cleanup.loopexit:
 785 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
 786 ; CHECK:       for.cond.cleanup:
 787 ; CHECK-NEXT:    ret void
 788 ; CHECK:       for.body:
 789 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ [[INC_PEEL]], [[FOR_BODY_PREHEADER_PEEL_NEWPH]] ]
 790 ; CHECK-NEXT:    br i1 true, label [[IF_END]], label [[IF_THEN:%.*]]
 791 ; CHECK:       if.then:
 792 ; CHECK-NEXT:    call void @init()
 793 ; CHECK-NEXT:    br label [[IF_END]]
 794 ; CHECK:       if.end:
 795 ; CHECK-NEXT:    call void @sink()
 796 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
 797 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
 798 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT_LOOPEXIT:%.*]], label [[FOR_BODY]], !llvm.loop !10
 799 ;
 800 entry:
 801   %cmp5 = icmp sgt i32 %len, 0
 802   br i1 %cmp5, label %for.body, label %for.cond.cleanup
 803
 804 for.cond.cleanup:                                 ; preds = %if.end, %entry
 805   ret void
 806
 807 for.body:                                         ; preds = %entry, %if.end
 808   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
 809   %cmp1 = icmp sgt i32 %i.06, 0
 810   br i1 %cmp1, label %if.end, label %if.then
 811
 812 if.then:                                          ; preds = %for.body
 813   call void @init()
 814   br label %if.end
 815
 816 if.end:                                           ; preds = %if.then, %for.body
 817   call void @sink()
 818   %inc = add nuw nsw i32 %i.06, 1
 819   %exitcond = icmp eq i32 %inc, %len
 820   br i1 %exitcond, label %for.cond.cleanup, label %for.body
 821 }
 822
 823 ; NOTE: here we should only peel the first iteration,
 824 ;       i.e. all calls to sink() must stay in loop.
 825 define void @test11__peel_first_iter_via_eq_pred(i32 %len) {
 826 ; CHECK-LABEL: @test11__peel_first_iter_via_eq_pred(
 827 ; CHECK-NEXT:  entry:
 828 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
 829 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 830 ; CHECK:       for.body.preheader:
 831 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 832 ; CHECK:       for.body.peel.begin:
 833 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 834 ; CHECK:       for.body.peel:
 835 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp eq i32 0, 0
 836 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_THEN_PEEL:%.*]], label [[IF_END_PEEL:%.*]]
 837 ; CHECK:       if.then.peel:
 838 ; CHECK-NEXT:    call void @init()
 839 ; CHECK-NEXT:    br label [[IF_END_PEEL]]
 840 ; CHECK:       if.end.peel:
 841 ; CHECK-NEXT:    call void @sink()
 842 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nuw nsw i32 0, 1
 843 ; CHECK-NEXT:    [[EXITCOND_PEEL:%.*]] = icmp eq i32 [[INC_PEEL]], [[LEN]]
 844 ; CHECK-NEXT:    br i1 [[EXITCOND_PEEL]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY_PEEL_NEXT:%.*]]
 845 ; CHECK:       for.body.peel.next:
 846 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT1:%.*]]
 847 ; CHECK:       for.body.peel.next1:
 848 ; CHECK-NEXT:    br label [[FOR_BODY_PREHEADER_PEEL_NEWPH:%.*]]
 849 ; CHECK:       for.body.preheader.peel.newph:
 850 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 851 ; CHECK:       for.cond.cleanup.loopexit.loopexit:
 852 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP_LOOPEXIT]]
 853 ; CHECK:       for.cond.cleanup.loopexit:
 854 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
 855 ; CHECK:       for.cond.cleanup:
 856 ; CHECK-NEXT:    ret void
 857 ; CHECK:       for.body:
 858 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ [[INC_PEEL]], [[FOR_BODY_PREHEADER_PEEL_NEWPH]] ]
 859 ; CHECK-NEXT:    br i1 false, label [[IF_THEN:%.*]], label [[IF_END]]
 860 ; CHECK:       if.then:
 861 ; CHECK-NEXT:    call void @init()
 862 ; CHECK-NEXT:    br label [[IF_END]]
 863 ; CHECK:       if.end:
 864 ; CHECK-NEXT:    call void @sink()
 865 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
 866 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
 867 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT_LOOPEXIT:%.*]], label [[FOR_BODY]], !llvm.loop !11
 868 ;
 869 entry:
 870   %cmp5 = icmp sgt i32 %len, 0
 871   br i1 %cmp5, label %for.body, label %for.cond.cleanup
 872
 873 for.cond.cleanup:                                 ; preds = %if.end, %entry
 874   ret void
 875
 876 for.body:                                         ; preds = %entry, %if.end
 877   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
 878   %cmp1 = icmp eq i32 %i.06, 0
 879   br i1 %cmp1, label %if.then, label %if.end
 880
 881 if.then:                                          ; preds = %for.body
 882   call void @init()
 883   br label %if.end
 884
 885 if.end:                                           ; preds = %if.then, %for.body
 886   call void @sink()
 887   %inc = add nuw nsw i32 %i.06, 1
 888   %exitcond = icmp eq i32 %inc, %len
 889   br i1 %exitcond, label %for.cond.cleanup, label %for.body
 890 }
 891
 892 ; NOTE: here we should only peel the first iteration,
 893 ;       i.e. all calls to sink() must stay in loop.
 894 define void @test12__peel_first_iter_via_ne_pred(i32 %len) {
 895 ; CHECK-LABEL: @test12__peel_first_iter_via_ne_pred(
 896 ; CHECK-NEXT:  entry:
 897 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
 898 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 899 ; CHECK:       for.body.preheader:
 900 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_BEGIN:%.*]]
 901 ; CHECK:       for.body.peel.begin:
 902 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL:%.*]]
 903 ; CHECK:       for.body.peel:
 904 ; CHECK-NEXT:    [[CMP1_PEEL:%.*]] = icmp ne i32 0, 0
 905 ; CHECK-NEXT:    br i1 [[CMP1_PEEL]], label [[IF_END_PEEL:%.*]], label [[IF_THEN_PEEL:%.*]]
 906 ; CHECK:       if.then.peel:
 907 ; CHECK-NEXT:    call void @init()
 908 ; CHECK-NEXT:    br label [[IF_END_PEEL]]
 909 ; CHECK:       if.end.peel:
 910 ; CHECK-NEXT:    call void @sink()
 911 ; CHECK-NEXT:    [[INC_PEEL:%.*]] = add nuw nsw i32 0, 1
 912 ; CHECK-NEXT:    [[EXITCOND_PEEL:%.*]] = icmp eq i32 [[INC_PEEL]], [[LEN]]
 913 ; CHECK-NEXT:    br i1 [[EXITCOND_PEEL]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY_PEEL_NEXT:%.*]]
 914 ; CHECK:       for.body.peel.next:
 915 ; CHECK-NEXT:    br label [[FOR_BODY_PEEL_NEXT1:%.*]]
 916 ; CHECK:       for.body.peel.next1:
 917 ; CHECK-NEXT:    br label [[FOR_BODY_PREHEADER_PEEL_NEWPH:%.*]]
 918 ; CHECK:       for.body.preheader.peel.newph:
 919 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 920 ; CHECK:       for.cond.cleanup.loopexit.loopexit:
 921 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP_LOOPEXIT]]
 922 ; CHECK:       for.cond.cleanup.loopexit:
 923 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
 924 ; CHECK:       for.cond.cleanup:
 925 ; CHECK-NEXT:    ret void
 926 ; CHECK:       for.body:
 927 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ [[INC_PEEL]], [[FOR_BODY_PREHEADER_PEEL_NEWPH]] ]
 928 ; CHECK-NEXT:    br i1 true, label [[IF_END]], label [[IF_THEN:%.*]]
 929 ; CHECK:       if.then:
 930 ; CHECK-NEXT:    call void @init()
 931 ; CHECK-NEXT:    br label [[IF_END]]
 932 ; CHECK:       if.end:
 933 ; CHECK-NEXT:    call void @sink()
 934 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
 935 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
 936 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT_LOOPEXIT:%.*]], label [[FOR_BODY]], !llvm.loop !12
 937 ;
 938 entry:
 939   %cmp5 = icmp sgt i32 %len, 0
 940   br i1 %cmp5, label %for.body, label %for.cond.cleanup
 941
 942 for.cond.cleanup:                                 ; preds = %if.end, %entry
 943   ret void
 944
 945 for.body:                                         ; preds = %entry, %if.end
 946   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
 947   %cmp1 = icmp ne i32 %i.06, 0
 948   br i1 %cmp1, label %if.end, label %if.then
 949
 950 if.then:                                          ; preds = %for.body
 951   call void @init()
 952   br label %if.end
 953
 954 if.end:                                           ; preds = %if.then, %for.body
 955   call void @sink()
 956   %inc = add nuw nsw i32 %i.06, 1
 957   %exitcond = icmp eq i32 %inc, %len
 958   br i1 %exitcond, label %for.cond.cleanup, label %for.body
 959 }
 960
 961 ; No peeling is profitable here.
 962 define void @test13__ivar_mod2_is_1(i32 %len) {
 963 ; CHECK-LABEL: @test13__ivar_mod2_is_1(
 964 ; CHECK-NEXT:  entry:
 965 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
 966 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 967 ; CHECK:       for.body.preheader:
 968 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 969 ; CHECK:       for.cond.cleanup.loopexit:
 970 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
 971 ; CHECK:       for.cond.cleanup:
 972 ; CHECK-NEXT:    ret void
 973 ; CHECK:       for.body:
 974 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
 975 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[I_06]], 1
 976 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[AND]], 1
 977 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_END]], label [[IF_THEN:%.*]]
 978 ; CHECK:       if.then:
 979 ; CHECK-NEXT:    call void @init()
 980 ; CHECK-NEXT:    br label [[IF_END]]
 981 ; CHECK:       if.end:
 982 ; CHECK-NEXT:    call void @sink()
 983 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
 984 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
 985 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY]]
 986 ;
 987 entry:
 988   %cmp5 = icmp sgt i32 %len, 0
 989   br i1 %cmp5, label %for.body, label %for.cond.cleanup
 990
 991 for.cond.cleanup:                                 ; preds = %if.end, %entry
 992   ret void
 993
 994 for.body:                                         ; preds = %entry, %if.end
 995   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
 996   %and = and i32 %i.06, 1
 997   %cmp1 = icmp eq i32 %and, 1
 998   br i1 %cmp1, label %if.end, label %if.then
 999
1000 if.then:                                          ; preds = %for.body
1001   call void @init()
1002   br label %if.end
1003
1004 if.end:                                           ; preds = %if.then, %for.body
1005   call void @sink()
1006   %inc = add nuw nsw i32 %i.06, 1
1007   %exitcond = icmp eq i32 %inc, %len
1008   br i1 %exitcond, label %for.cond.cleanup, label %for.body
1009 }
1010
1011 ; No peeling is profitable here.
1012 define void @test14__ivar_mod2_is_0(i32 %len) {
1013 ; CHECK-LABEL: @test14__ivar_mod2_is_0(
1014 ; CHECK-NEXT:  entry:
1015 ; CHECK-NEXT:    [[CMP5:%.*]] = icmp sgt i32 [[LEN:%.*]], 0
1016 ; CHECK-NEXT:    br i1 [[CMP5]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
1017 ; CHECK:       for.body.preheader:
1018 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
1019 ; CHECK:       for.cond.cleanup.loopexit:
1020 ; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
1021 ; CHECK:       for.cond.cleanup:
1022 ; CHECK-NEXT:    ret void
1023 ; CHECK:       for.body:
1024 ; CHECK-NEXT:    [[I_06:%.*]] = phi i32 [ [[INC:%.*]], [[IF_END:%.*]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
1025 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[I_06]], 1
1026 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[AND]], 0
1027 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_END]], label [[IF_THEN:%.*]]
1028 ; CHECK:       if.then:
1029 ; CHECK-NEXT:    call void @init()
1030 ; CHECK-NEXT:    br label [[IF_END]]
1031 ; CHECK:       if.end:
1032 ; CHECK-NEXT:    call void @sink()
1033 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_06]], 1
1034 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[LEN]]
1035 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY]]
1036 ;
1037 entry:
1038   %cmp5 = icmp sgt i32 %len, 0
1039   br i1 %cmp5, label %for.body, label %for.cond.cleanup
1040
1041 for.cond.cleanup:                                 ; preds = %if.end, %entry
1042   ret void
1043
1044 for.body:                                         ; preds = %entry, %if.end
1045   %i.06 = phi i32 [ %inc, %if.end ], [ 0, %entry ]
1046   %and = and i32 %i.06, 1
1047   %cmp1 = icmp eq i32 %and, 0
1048   br i1 %cmp1, label %if.end, label %if.then
1049
1050 if.then:                                          ; preds = %for.body
1051   call void @init()
1052   br label %if.end
1053
1054 if.end:                                           ; preds = %if.then, %for.body
1055   call void @sink()
1056   %inc = add nuw nsw i32 %i.06, 1
1057   %exitcond = icmp eq i32 %inc, %len
1058   br i1 %exitcond, label %for.cond.cleanup, label %for.body
1059 }
1060
1061 ; Similar to @test6, we need to peel one extra iteration, and we can't do that
1062 ; as per the -unroll-peel-max-count=4, so this shouldn't be peeled at all.
1063 define void @test15(i32 %k) {
1064 ; CHECK-LABEL: @test15(
1065 ; CHECK-NEXT:  for.body.lr.ph:
1066 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
1067 ; CHECK:       for.body:
1068 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
1069 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i32 [[I_05]], 4
1070 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
1071 ; CHECK:       if.then:
1072 ; CHECK-NEXT:    call void @f1()
1073 ; CHECK-NEXT:    br label [[FOR_INC]]
1074 ; CHECK:       for.inc:
1075 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[I_05]], 1
1076 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K:%.*]]
1077 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
1078 ; CHECK:       for.end:
1079 ; CHECK-NEXT:    ret void
1080 ;
1081 for.body.lr.ph:
1082   br label %for.body
1083
1084 for.body:
1085   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
1086   %cmp1 = icmp ne i32 %i.05, 4
1087   br i1 %cmp1, label %if.then, label %for.inc
1088
1089 if.then:
1090   call void @f1()
1091   br label %for.inc
1092
1093 for.inc:
1094   %inc = add nsw i32 %i.05, 1
1095   %cmp = icmp slt i32 %inc, %k
1096   br i1 %cmp, label %for.body, label %for.end
1097
1098 for.end:
1099   ret void
1100 }
1101
1102 ; Similar to @test7, we need to peel one extra iteration, and we can't do that
1103 ; as per the -unroll-peel-max-count=4, so this shouldn't be peeled at all.
1104 define void @test16(i32 %k) {
1105 ; CHECK-LABEL: @test16(
1106 ; CHECK-NEXT:  for.body.lr.ph:
1107 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
1108 ; CHECK:       for.body:
1109 ; CHECK-NEXT:    [[I_05:%.*]] = phi i32 [ 0, [[FOR_BODY_LR_PH:%.*]] ], [ [[INC:%.*]], [[FOR_INC:%.*]] ]
1110 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[I_05]], 4
1111 ; CHECK-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
1112 ; CHECK:       if.then:
1113 ; CHECK-NEXT:    call void @f1()
1114 ; CHECK-NEXT:    br label [[FOR_INC]]
1115 ; CHECK:       for.inc:
1116 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[I_05]], 1
1117 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[INC]], [[K:%.*]]
1118 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
1119 ; CHECK:       for.end:
1120 ; CHECK-NEXT:    ret void
1121 ;
1122 for.body.lr.ph:
1123   br label %for.body
1124
1125 for.body:
1126   %i.05 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
1127   %cmp1 = icmp eq i32 %i.05, 4
1128   br i1 %cmp1, label %if.then, label %for.inc
1129
1130 if.then:
1131   call void @f1()
1132   br label %for.inc
1133
1134 for.inc:
1135   %inc = add nsw i32 %i.05, 1
1136   %cmp = icmp slt i32 %inc, %k
1137   br i1 %cmp, label %for.body, label %for.end
1138
1139 for.end:
1140   ret void
1141 }
1142
1143 ; Invoke is not a conditional branch that we can optimize,
1144 ; so this shouldn't be peeled at all.  This is a reproducer
1145 ; for a bug where evaluating the loop would fail an assertion.
1146 define void @test17() personality i8* undef{
1147 ; CHECK-LABEL: @test17(
1148 ; CHECK-NEXT:  body:
1149 ; CHECK-NEXT:    br label [[LOOP:%.*]]
1150 ; CHECK:       loop:
1151 ; CHECK-NEXT:    [[CONST:%.*]] = phi i64 [ -33, [[LOOP]] ], [ -20, [[BODY:%.*]] ]
1152 ; CHECK-NEXT:    invoke void @f1()
1153 ; CHECK-NEXT:    to label [[LOOP]] unwind label [[EH_UNW_LOOPEXIT:%.*]]
1154 ; CHECK:       eh.Unw.loopexit:
1155 ; CHECK-NEXT:    [[LPAD_LOOPEXIT:%.*]] = landingpad { i8*, i32 }
1156 ; CHECK-NEXT:    catch i8* null
1157 ; CHECK-NEXT:    ret void
1158 ;
1159 body:
1160   br label %loop
1161
1162 loop:
1163   %const = phi i64 [ -33, %loop ], [ -20, %body ]
1164   invoke void @f1()
1165   to label %loop unwind label %eh.Unw.loopexit
1166
1167 eh.Unw.loopexit:
1168   %lpad.loopexit = landingpad { i8*, i32 }
1169   catch i8* null
1170   ret void
1171 }
1172
1173 ; Testcase reduced from PR48812.  We expect no peeling
1174 ; because the latch terminator is a switch.
1175 define void @test18(i32* %p) {
1176 ; CHECK-LABEL: @test18(
1177 ; CHECK-NEXT:  init:
1178 ; CHECK-NEXT:    br label [[LOOP:%.*]]
1179 ; CHECK:       loop:
1180 ; CHECK-NEXT:    [[CONST:%.*]] = phi i32 [ 40, [[INIT:%.*]] ], [ 0, [[LATCH:%.*]] ]
1181 ; CHECK-NEXT:    br label [[LATCH]]
1182 ; CHECK:       latch:
1183 ; CHECK-NEXT:    [[CONTROL:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
1184 ; CHECK-NEXT:    switch i32 [[CONTROL]], label [[EXIT:%.*]] [
1185 ; CHECK-NEXT:    i32 2, label [[LOOP]]
1186 ; CHECK-NEXT:    ]
1187 ; CHECK:       exit:
1188 ; CHECK-NEXT:    ret void
1189 ;
1190 init:
1191   br label %loop
1192
1193 loop:
1194   %const = phi i32 [ 40, %init ], [ 0, %latch ]
1195   br label %latch
1196
1197 latch:
1198   %control = load volatile i32, i32* %p
1199   switch i32 %control, label %exit [
1200   i32 2, label %loop
1201   ]
1202
1203 exit:
1204   ret void
1205 }
1206
1207 declare void @init()
1208 declare void @sink()