llvm/test/Transforms/LoopVectorize/first-order-recurrence-sink-replicate-region.ll

   1 ; REQUIRES: asserts
   2 ; RUN: opt < %s -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -force-widen-divrem-via-safe-divisor=0 -disable-output -debug-only=loop-vectorize 2>&1 | FileCheck %s
   3
   4 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
   5
   6 ; Test cases for PR50009, which require sinking a replicate-region due to a
   7 ; first-order recurrence.
   8
   9 define void @sink_replicate_region_1(i32 %x, ptr %ptr, ptr noalias %dst) optsize {
  10 ; CHECK-LABEL: sink_replicate_region_1
  11 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
  12 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
  13 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
  14 ; CHECK-NEXT: Live-in ir<20001> = original trip-count
  15 ; CHECK-EMPTY:
  16 ; CHECK-NEXT: vector.ph:
  17 ; CHECK-NEXT: Successor(s): vector loop
  18 ; CHECK-EMPTY:
  19 ; CHECK-NEXT: <x1> vector loop: {
  20 ; CHECK-NEXT: vector.body:
  21 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
  22 ; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
  23 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
  24 ; CHECK-NEXT:   vp<[[STEPS:%.]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  25 ; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv>, vp<[[BTC]]>
  26 ; CHECK-NEXT: Successor(s): pred.load
  27 ; CHECK-EMPTY:
  28 ; CHECK-NEXT: <xVFxUF> pred.load: {
  29 ; CHECK-NEXT:   pred.load.entry:
  30 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
  31 ; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
  32 ; CHECK-EMPTY:
  33 ; CHECK-NEXT:   pred.load.if:
  34 ; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
  35 ; CHECK-NEXT:     REPLICATE ir<%lv> = load ir<%gep> (S->V)
  36 ; CHECK-NEXT:   Successor(s): pred.load.continue
  37 ; CHECK-EMPTY:
  38 ; CHECK-NEXT:   pred.load.continue:
  39 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%lv>
  40 ; CHECK-NEXT:   No successors
  41 ; CHECK-NEXT: }
  42 ; CHECK-NEXT: Successor(s): loop.0
  43 ; CHECK-EMPTY:
  44 ; CHECK-NEXT: loop.0:
  45 ; CHECK-NEXT:   WIDEN-CAST ir<%conv> = sext vp<[[PRED1]]> to i32
  46 ; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%0>, ir<%conv>
  47 ; CHECK-NEXT: Successor(s): pred.store
  48 ; CHECK-EMPTY:
  49 ; CHECK-NEXT: <xVFxUF> pred.store: {
  50 ; CHECK-NEXT:   pred.store.entry:
  51 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
  52 ; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
  53 ; CHECK-EMPTY:
  54 ; CHECK-NEXT:   pred.store.if:
  55 ; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
  56 ; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
  57 ; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%conv>, ir<%rem>
  58 ; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.dst>
  59 ; CHECK-NEXT:   Successor(s): pred.store.continue
  60 ; CHECK-EMPTY:
  61 ; CHECK-NEXT:   pred.store.continue:
  62 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%rem>
  63 ; CHECK-NEXT:   No successors
  64 ; CHECK-NEXT: }
  65 ; CHECK-NEXT: Successor(s): loop.2
  66 ; CHECK-EMPTY:
  67 ; CHECK-NEXT: loop.2:
  68 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
  69 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
  70 ; CHECK-NEXT: No successors
  71 ; CHECK-NEXT: }
  72 ; CHECK-NEXT: Successor(s): middle.block
  73 ; CHECK-EMPTY:
  74 ; CHECK-NEXT: middle.block:
  75 ; CHECK-NEXT: No successors
  76 ; CHECK-NEXT: }
  77 ;
  78 entry:
  79   br label %loop
  80
  81 loop:
  82   %0 = phi i32 [ 0, %entry ], [ %conv, %loop ]
  83   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
  84   %rem = srem i32 %0, %x
  85   %gep = getelementptr i8, ptr %ptr, i32 %iv
  86   %lv = load i8, ptr %gep
  87   %conv = sext i8 %lv to i32
  88   %add = add i32 %conv, %rem
  89   %gep.dst = getelementptr i32, ptr %dst, i32 %iv
  90   store i32 %add, ptr %gep.dst
  91   %iv.next = add nsw i32 %iv, 1
  92   %ec = icmp eq i32 %iv.next, 20001
  93   br i1 %ec, label %exit, label %loop
  94
  95 exit:
  96   ret void
  97 }
  98
  99 define void @sink_replicate_region_2(i32 %x, i8 %y, ptr %ptr) optsize {
 100 ; CHECK-LABEL: sink_replicate_region_2
 101 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
 102 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 103 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
 104 ; CHECK-NEXT: Live-in ir<20001> = original trip-count
 105 ; CHECK-EMPTY:
 106 ; CHECK-NEXT: vector.ph:
 107 ; CHECK-NEXT: Successor(s): vector loop
 108 ; CHECK-EMPTY:
 109 ; CHECK-NEXT: <x1> vector loop: {
 110 ; CHECK-NEXT: vector.body:
 111 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 112 ; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
 113 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
 114 ; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv>, vp<[[BTC]]>
 115 ; CHECK-NEXT:   WIDEN-CAST ir<%recur.next> = sext ir<%y> to i32
 116 ; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur>, ir<%recur.next>
 117 ; CHECK-NEXT:   Successor(s): pred.store
 118 ; CHECK-EMPTY:
 119 ; CHECK-NEXT: <xVFxUF> pred.store: {
 120 ; CHECK-NEXT:  pred.store.entry:
 121 ; CHECK-NEXT:    BRANCH-ON-MASK vp<[[MASK]]>
 122 ; CHECK-NEXT:  Successor(s): pred.store.if, pred.store.continue
 123 ; CHECK-EMPTY:
 124 ; CHECK-NEXT:  pred.store.if:
 125 ; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
 126 ; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 127 ; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
 128 ; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%rem>, ir<%recur.next>
 129 ; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep>
 130 ; CHECK-NEXT:   Successor(s): pred.store.continue
 131 ; CHECK-EMPTY:
 132 ; CHECK-NEXT:   pred.store.continue:
 133 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
 134 ; CHECK-NEXT:   No successors
 135 ; CHECK-NEXT: }
 136 ; CHECK-NEXT: Successor(s): loop.1
 137 ; CHECK-EMPTY:
 138 ; CHECK-NEXT: loop.1:
 139 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
 140 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 141 ; CHECK-NEXT: No successors
 142 ; CHECK-NEXT: }
 143 ; CHECK-NEXT: Successor(s): middle.block
 144 ; CHECK-EMPTY:
 145 ; CHECK-NEXT: middle.block:
 146 ; CHECK-NEXT: No successors
 147 ; CHECK-NEXT: }
 148 ;
 149 entry:
 150   br label %loop
 151
 152 loop:
 153   %recur = phi i32 [ 0, %entry ], [ %recur.next, %loop ]
 154   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 155   %rem = srem i32 %recur, %x
 156   %recur.next = sext i8 %y to i32
 157   %add = add i32 %rem, %recur.next
 158   %gep = getelementptr i32, ptr %ptr, i32 %iv
 159   store i32 %add, ptr %gep
 160   %iv.next = add nsw i32 %iv, 1
 161   %ec = icmp eq i32 %iv.next, 20001
 162   br i1 %ec, label %exit, label %loop
 163
 164 exit:
 165   ret void
 166 }
 167
 168 define i32 @sink_replicate_region_3_reduction(i32 %x, i8 %y, ptr %ptr) optsize {
 169 ; CHECK-LABEL: sink_replicate_region_3_reduction
 170 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
 171 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 172 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
 173 ; CHECK-NEXT: Live-in ir<20001> = original trip-count
 174 ; CHECK-EMPTY:
 175 ; CHECK-NEXT: vector.ph:
 176 ; CHECK-NEXT: Successor(s): vector loop
 177 ; CHECK-EMPTY:
 178 ; CHECK-NEXT: <x1> vector loop: {
 179 ; CHECK-NEXT: vector.body:
 180 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 181 ; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
 182 ; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%and.red> = phi ir<1234>, ir<%and.red.next>
 183 ; CHECK-NEXT:   EMIT vp<[[WIDEN_CAN:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
 184 ; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule vp<[[WIDEN_CAN]]>, vp<[[BTC]]>
 185 ; CHECK-NEXT:   WIDEN-CAST ir<%recur.next> = sext ir<%y> to i32
 186 ; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur>, ir<%recur.next>
 187 ; CHECK-NEXT: Successor(s): pred.srem
 188 ; CHECK-EMPTY:
 189 ; CHECK-NEXT: <xVFxUF> pred.srem: {
 190 ; CHECK-NEXT:   pred.srem.entry:
 191 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
 192 ; CHECK-NEXT:   Successor(s): pred.srem.if, pred.srem.continue
 193 ; CHECK-EMPTY:
 194 ; CHECK-NEXT:   pred.srem.if:
 195 ; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x> (S->V)
 196 ; CHECK-NEXT:   Successor(s): pred.srem.continue
 197 ; CHECK-EMPTY:
 198 ; CHECK-NEXT:   pred.srem.continue:
 199 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
 200 ; CHECK-NEXT:   No successors
 201 ; CHECK-NEXT: }
 202 ; CHECK-NEXT: Successor(s): loop.0
 203 ; CHECK-EMPTY:
 204 ; CHECK-NEXT: loop.0:
 205 ; CHECK-NEXT:   WIDEN ir<%add> = add vp<[[PRED]]>, ir<%recur.next>
 206 ; CHECK-NEXT:   WIDEN ir<%and.red.next> = and ir<%and.red>, ir<%add>
 207 ; CHECK-NEXT:   EMIT vp<[[SEL:%.+]]> = select vp<[[MASK]]>, ir<%and.red.next>, ir<%and.red>
 208 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
 209 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 210 ; CHECK-NEXT: No successors
 211 ; CHECK-NEXT: }
 212 ; CHECK-NEXT: Successor(s): middle.block
 213 ; CHECK-EMPTY:
 214 ; CHECK-NEXT: middle.block:
 215 ; CHECK-NEXT: No successors
 216 ; CHECK-EMPTY:
 217 ; CHECK-NEXT: Live-out i32 %res = ir<%and.red.next>
 218 ; CHECK-NEXT: }
 219 ;
 220 entry:
 221   br label %loop
 222
 223 loop:
 224   %recur = phi i32 [ 0, %entry ], [ %recur.next, %loop ]
 225   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 226   %and.red = phi i32 [ 1234, %entry ], [ %and.red.next, %loop ]
 227   %rem = srem i32 %recur, %x
 228   %recur.next = sext i8 %y to i32
 229   %add = add i32 %rem, %recur.next
 230   %and.red.next = and i32 %and.red, %add
 231   %iv.next = add nsw i32 %iv, 1
 232   %ec = icmp eq i32 %iv.next, 20001
 233   br i1 %ec, label %exit, label %loop
 234
 235 exit:
 236   %res = phi i32 [ %and.red.next, %loop ]
 237   ret i32 %res
 238 }
 239
 240 ; To sink the replicate region containing %rem, we need to split the block
 241 ; containing %conv at the end, because %conv is the last recipe in the block.
 242 define void @sink_replicate_region_4_requires_split_at_end_of_block(i32 %x, ptr %ptr, ptr noalias %dst) optsize {
 243 ; CHECK-LABEL: sink_replicate_region_4_requires_split_at_end_of_block
 244 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
 245 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 246 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
 247 ; CHECK-NEXT: Live-in ir<20001> = original trip-count
 248 ; CHECK-EMPTY:
 249 ; CHECK-NEXT: vector.ph:
 250 ; CHECK-NEXT: Successor(s): vector loop
 251 ; CHECK-EMPTY:
 252 ; CHECK-NEXT: <x1> vector loop: {
 253 ; CHECK-NEXT: vector.body:
 254 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 255 ; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
 256 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
 257 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 258 ; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv>, vp<[[BTC]]>
 259 ; CHECK-NEXT:   REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
 260 ; CHECK-NEXT: Successor(s): pred.load
 261 ; CHECK-EMPTY:
 262 ; CHECK-NEXT: <xVFxUF> pred.load: {
 263 ; CHECK-NEXT:   pred.load.entry:
 264 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
 265 ; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
 266 ; CHECK-EMPTY:
 267 ; CHECK-NEXT:   pred.load.if:
 268 ; CHECK-NEXT:     REPLICATE ir<%lv> = load ir<%gep> (S->V)
 269 ; CHECK-NEXT:   Successor(s): pred.load.continue
 270 ; CHECK-EMPTY:
 271 ; CHECK-NEXT:   pred.load.continue:
 272 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv>
 273 ; CHECK-NEXT:   No successors
 274 ; CHECK-NEXT: }
 275 ; CHECK-NEXT: Successor(s): loop.0
 276 ; CHECK-EMPTY:
 277 ; CHECK-NEXT: loop.0:
 278 ; CHECK-NEXT:   WIDEN-CAST ir<%conv> = sext vp<[[PRED]]> to i32
 279 ; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%0>, ir<%conv>
 280 ; CHECK-NEXT: Successor(s): pred.store
 281 ; CHECK-EMPTY:
 282 ; CHECK:      <xVFxUF> pred.store: {
 283 ; CHECK-NEXT:   pred.store.entry:
 284 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
 285 ; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
 286 ; CHECK-EMPTY:
 287 ; CHECK:        pred.store.if:
 288 ; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
 289 ; CHECK-NEXT:     REPLICATE ir<%lv.2> = load ir<%gep>
 290 ; CHECK-NEXT:     REPLICATE ir<%conv.lv.2> = sext ir<%lv.2>
 291 ; CHECK-NEXT:     REPLICATE ir<%add.1> = add ir<%conv>, ir<%rem>
 292 ; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
 293 ; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%add.1>, ir<%conv.lv.2>
 294 ; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.dst>
 295 ; CHECK-NEXT:   Successor(s): pred.store.continue
 296 ; CHECK-EMPTY:
 297 ; CHECK:        pred.store.continue:
 298 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%rem>
 299 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%lv.2>
 300 ; CHECK-NEXT:   No successors
 301 ; CHECK-NEXT: }
 302 ; CHECK-NEXT:   Successor(s): loop.3
 303 ; CHECK-EMPTY:
 304 ; CHECK:      loop.3:
 305 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
 306 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 307 ; CHECK-NEXT: No successors
 308 ; CHECK-NEXT: }
 309 ; CHECK-NEXT: Successor(s): middle.block
 310 ; CHECK-EMPTY:
 311 ; CHECK-NEXT: middle.block:
 312 ; CHECK-NEXT: No successors
 313 ; CHECK-NEXT: }
 314 ;
 315 entry:
 316   br label %loop
 317
 318 loop:
 319   %0 = phi i32 [ 0, %entry ], [ %conv, %loop ]
 320   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 321   %gep = getelementptr i8, ptr %ptr, i32 %iv
 322   %rem = srem i32 %0, %x
 323   %lv = load i8, ptr %gep
 324   %conv = sext i8 %lv to i32
 325   %lv.2 = load i8, ptr %gep
 326   %add.1 = add i32 %conv, %rem
 327   %conv.lv.2 = sext i8 %lv.2 to i32
 328   %add = add i32 %add.1, %conv.lv.2
 329   %gep.dst = getelementptr i32, ptr %dst, i32 %iv
 330   store i32 %add, ptr %gep.dst
 331   %iv.next = add nsw i32 %iv, 1
 332   %ec = icmp eq i32 %iv.next, 20001
 333   br i1 %ec, label %exit, label %loop
 334
 335 exit:
 336   ret void
 337 }
 338
 339 ; Test case that requires sinking a recipe in a replicate region after another replicate region.
 340 define void @sink_replicate_region_after_replicate_region(ptr %ptr, ptr noalias %dst.2, i32 %x, i8 %y) optsize {
 341 ; CHECK-LABEL: sink_replicate_region_after_replicate_region
 342 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
 343 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 344 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
 345 ; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count
 346 ; CHECK-EMPTY:
 347 ; CHECK-NEXT: ph:
 348 ; CHECK-NEXT:  EMIT vp<[[TC]]> = EXPAND SCEV (1 smax (1 + (sext i8 %y to i32))<nsw>)
 349 ; CHECK-NEXT: No successors
 350 ; CHECK-EMPTY:
 351 ; CHECK-NEXT: vector.ph:
 352 ; CHECK-NEXT: Successor(s): vector loop
 353 ; CHECK-EMPTY:
 354 ; CHECK-NEXT: <x1> vector loop: {
 355 ; CHECK-NEXT: vector.body:
 356 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 357 ; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
 358 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
 359 ; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv>, vp<[[BTC]]>
 360 ; CHECK-NEXT:   WIDEN-CAST ir<%recur.next> = sext ir<%y> to i32
 361 ; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur>, ir<%recur.next>
 362 ; CHECK-NEXT: Successor(s): pred.store
 363 ; CHECK-EMPTY:
 364 ; CHECK-NEXT: <xVFxUF> pred.store: {
 365 ; CHECK-NEXT:   pred.store.entry:
 366 ; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
 367 ; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
 368 ; CHECK-EMPTY:
 369 ; CHECK-NEXT:   pred.store.if:
 370 ; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 371 ; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
 372 ; CHECK-NEXT:     REPLICATE ir<%rem.div> = sdiv ir<20>, ir<%rem>
 373 ; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
 374 ; CHECK-NEXT:     REPLICATE store ir<%rem.div>, ir<%gep>
 375 ; CHECK-NEXT:     REPLICATE ir<%gep.2> = getelementptr ir<%dst.2>, vp<[[STEPS]]>
 376 ; CHECK-NEXT:     REPLICATE store ir<%rem.div>, ir<%gep.2>
 377 ; CHECK-NEXT:   Successor(s): pred.store.continue
 378 ; CHECK-EMPTY:
 379 ; CHECK-NEXT:   pred.store.continue:
 380 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
 381 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%rem.div>
 382 ; CHECK-NEXT:   No successors
 383 ; CHECK-NEXT: }
 384 ; CHECK-NEXT: Successor(s): loop.3
 385 ; CHECK-EMPTY:
 386 ; CHECK-NEXT: loop.3:
 387 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
 388 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 389 ; CHECK-NEXT: No successors
 390 ; CHECK-NEXT: }
 391 ; CHECK-NEXT: Successor(s): middle.block
 392 ; CHECK-EMPTY:
 393 ; CHECK-NEXT: middle.block:
 394 ; CHECK-NEXT: No successors
 395 ; CHECK-NEXT: }
 396 ;
 397 entry:
 398   br label %loop
 399
 400 loop:                                             ; preds = %loop, %entry
 401   %recur = phi i32 [ 0, %entry ], [ %recur.next, %loop ]
 402   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 403   %rem = srem i32 %recur, %x
 404   %rem.div = sdiv i32 20, %rem
 405   %recur.next = sext i8 %y to i32
 406   %gep = getelementptr i32, ptr %ptr, i32 %iv
 407   store i32 %rem.div, ptr %gep
 408   %gep.2 = getelementptr i32, ptr %dst.2, i32 %iv
 409   store i32 %rem.div, ptr %gep.2
 410   %iv.next = add nsw i32 %iv, 1
 411   %C = icmp sgt i32 %iv.next, %recur.next
 412   br i1 %C, label %exit, label %loop
 413
 414 exit:                                             ; preds = %loop
 415   ret void
 416 }
 417
 418 define void @need_new_block_after_sinking_pr56146(i32 %x, ptr %src, ptr noalias %dst) {
 419 ; CHECK-LABEL: need_new_block_after_sinking_pr56146
 420 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
 421 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 422 ; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
 423 ; CHECK-NEXT: Live-in ir<3> = original trip-count
 424 ; CHECK-EMPTY:
 425 ; CHECK-NEXT: vector.ph:
 426 ; CHECK-NEXT: Successor(s): vector loop
 427 ; CHECK-EMPTY:
 428 ; CHECK-NEXT: <x1> vector loop: {
 429 ; CHECK-NEXT:   vector.body:
 430 ; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 431 ; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%.pn> = phi ir<0>, ir<[[L:%.+]]>
 432 ; CHECK-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<2> + vp<[[CAN_IV]]> * ir<1>
 433 ; CHECK-NEXT:     EMIT vp<[[WIDE_IV:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
 434 ; CHECK-NEXT:     EMIT vp<[[CMP:%.+]]> = icmp ule vp<[[WIDE_IV]]>, vp<[[BTC]]>
 435 ; CHECK-NEXT:     CLONE ir<[[L]]> = load ir<%src>
 436 ; CHECK-NEXT:     EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%.pn>, ir<[[L]]>
 437 ; CHECK-NEXT:  Successor(s): pred.store
 438 ; CHECK-EMPTY:
 439 ; CHECK-NEXT:   <xVFxUF> pred.store: {
 440 ; CHECK-NEXT:     pred.store.entry:
 441 ; CHECK-NEXT:       BRANCH-ON-MASK vp<[[CMP]]>
 442 ; CHECK-NEXT:     Successor(s): pred.store.if, pred.store.continue
 443 ; CHECK-EMPTY:
 444 ; CHECK-NEXT:     pred.store.if:
 445 ; CHECK-NEXT:       REPLICATE ir<%val> = sdiv vp<[[SPLICE]]>, ir<%x>
 446 ; CHECK-NEXT:       vp<[[SCALAR_STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
 447 ; CHECK-NEXT:       REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[SCALAR_STEPS]]>
 448 ; CHECK-NEXT:       REPLICATE store ir<%val>, ir<%gep.dst>
 449 ; CHECK-NEXT:     Successor(s): pred.store.continue
 450 ; CHECK-EMPTY:
 451 ; CHECK-NEXT:     pred.store.continue:
 452 ; CHECK-NEXT:       PHI-PREDICATED-INSTRUCTION vp<[[P_VAL:%.+]]> = ir<%val>
 453 ; CHECK-NEXT:     No successors
 454 ; CHECK-NEXT:   }
 455 ; CHECK-NEXT:   Successor(s): loop.1
 456 ; CHECK-EMPTY:
 457 ; CHECK-NEXT:   loop.1:
 458 ; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
 459 ; CHECK-NEXT:     EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 460 ; CHECK-NEXT:   No successors
 461 ; CHECK-NEXT: }
 462 ; CHECK-NEXT: Successor(s): middle.block
 463 ; CHECK-EMPTY:
 464 ; CHECK-NEXT: middle.block:
 465 ; CHECK-NEXT: No successors
 466 ; CHECK-NEXT: }
 467 ;
 468 entry:
 469   br label %loop
 470
 471 loop:
 472   %iv = phi i64 [ 2, %entry ], [ %iv.next, %loop ]
 473   %.pn = phi i32 [ 0, %entry ], [ %l, %loop ]
 474   %val = sdiv i32 %.pn, %x
 475   %l = load i32, ptr %src, align 4
 476   %gep.dst = getelementptr i32, ptr %dst, i64 %iv
 477   store i32 %val, ptr %gep.dst
 478   %iv.next = add nuw nsw i64 %iv, 1
 479   %ec = icmp ugt i64 %iv, 3
 480   br i1 %ec, label %exit, label %loop
 481
 482 exit:
 483   ret void
 484 }