llvm/test/Transforms/LoopVectorize/vplan-printing.ll

   1 ; REQUIRES: asserts
   2
   3 ; RUN: opt -passes=loop-vectorize -debug-only=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -prefer-inloop-reductions -enable-interleaved-mem-accesses=true -enable-masked-interleaved-mem-accesses -force-widen-divrem-via-safe-divisor=0 -disable-output %s 2>&1 | FileCheck %s
   4
   5 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
   6
   7 ; Tests for printing VPlans.
   8
   9 define void @print_call_and_memory(i64 %n, ptr noalias %y, ptr noalias %x) nounwind uwtable {
  10 ; CHECK-LABEL: Checking a loop in 'print_call_and_memory'
  11 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
  12 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
  13 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
  14 ; CHECK-EMPTY:
  15 ; CHECK-NEXT: vector.ph:
  16 ; CHECK-NEXT: Successor(s): vector loop
  17 ; CHECK-EMPTY:
  18 ; CHECK-NEXT: <x1> vector loop: {
  19 ; CHECK-NEXT: vector.body:
  20 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
  21 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  22 ; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[STEPS]]>
  23 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
  24 ; CHECK-NEXT:   WIDEN-CALL ir<%call> = call @llvm.sqrt.f32(ir<%lv>)
  25 ; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>
  26 ; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%call>
  27 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
  28 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
  29 ; CHECK-NEXT: No successors
  30 ; CHECK-NEXT: }
  31 ; CHECK-NEXT: Successor(s): middle.block
  32 ; CHECK-EMPTY:
  33 ; CHECK-NEXT: middle.block:
  34 ; CHECK-NEXT: No successors
  35 ; CHECK-NEXT: }
  36 ;
  37 entry:
  38   %cmp6 = icmp sgt i64 %n, 0
  39   br i1 %cmp6, label %for.body, label %for.end
  40
  41 for.body:                                         ; preds = %entry, %for.body
  42   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
  43   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
  44   %lv = load float, ptr %arrayidx, align 4
  45   %call = tail call float @llvm.sqrt.f32(float %lv) nounwind readnone
  46   %arrayidx2 = getelementptr inbounds float, ptr %x, i64 %iv
  47   store float %call, ptr %arrayidx2, align 4
  48   %iv.next = add i64 %iv, 1
  49   %exitcond = icmp eq i64 %iv.next, %n
  50   br i1 %exitcond, label %for.end, label %for.body
  51
  52 for.end:                                          ; preds = %for.body, %entry
  53   ret void
  54 }
  55
  56 define void @print_widen_gep_and_select(i64 %n, ptr noalias %y, ptr noalias %x, ptr %z) nounwind uwtable {
  57 ; CHECK-LABEL: Checking a loop in 'print_widen_gep_and_select'
  58 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
  59 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
  60 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
  61 ; CHECK-EMPTY:
  62 ; CHECK-NEXT: vector.ph:
  63 ; CHECK-NEXT: Successor(s): vector loop
  64 ; CHECK-EMPTY:
  65 ; CHECK-NEXT: <x1> vector loop: {
  66 ; CHECK-NEXT: vector.body:
  67 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
  68 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi %iv.next, 0, ir<1>
  69 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  70 ; CHECK-NEXT:   WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr inbounds ir<%y>, ir<%iv>
  71 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
  72 ; CHECK-NEXT:   WIDEN ir<%cmp> = icmp eq ir<%arrayidx>, ir<%z>
  73 ; CHECK-NEXT:   WIDEN-SELECT ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>
  74 ; CHECK-NEXT:   WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>
  75 ; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>
  76 ; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%add>
  77 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
  78 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
  79 ; CHECK-NEXT: No successors
  80 ; CHECK-NEXT: }
  81 ; CHECK-NEXT: Successor(s): middle.block
  82 ; CHECK-EMPTY:
  83 ; CHECK-NEXT: middle.block:
  84 ; CHECK-NEXT: No successors
  85 ; CHECK-NEXT: }
  86 ;
  87 entry:
  88   %cmp6 = icmp sgt i64 %n, 0
  89   br i1 %cmp6, label %for.body, label %for.end
  90
  91 for.body:                                         ; preds = %entry, %for.body
  92   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
  93   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
  94   %lv = load float, ptr %arrayidx, align 4
  95   %cmp = icmp eq ptr %arrayidx, %z
  96   %sel = select i1 %cmp, float 10.0, float 20.0
  97   %add = fadd float %lv, %sel
  98   %arrayidx2 = getelementptr inbounds float, ptr %x, i64 %iv
  99   store float %add, ptr %arrayidx2, align 4
 100   %iv.next = add i64 %iv, 1
 101   %exitcond = icmp eq i64 %iv.next, %n
 102   br i1 %exitcond, label %for.end, label %for.body
 103
 104 for.end:                                          ; preds = %for.body, %entry
 105   ret void
 106 }
 107
 108 define float @print_reduction(i64 %n, ptr noalias %y) {
 109 ; CHECK-LABEL: Checking a loop in 'print_reduction'
 110 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 111 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 112 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 113 ; CHECK-EMPTY:
 114 ; CHECK-NEXT: vector.ph:
 115 ; CHECK-NEXT: Successor(s): vector loop
 116 ; CHECK-EMPTY:
 117 ; CHECK-NEXT: <x1> vector loop: {
 118 ; CHECK-NEXT: vector.body:
 119 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 120 ; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
 121 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 122 ; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[STEPS]]>
 123 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
 124 ; CHECK-NEXT:   REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
 125 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 126 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 127 ; CHECK-NEXT: No successors
 128 ; CHECK-NEXT: }
 129 ; CHECK-NEXT: Successor(s): middle.block
 130 ; CHECK-EMPTY:
 131 ; CHECK-NEXT: middle.block:
 132 ; CHECK-NEXT: No successors
 133 ; CHECK-EMPTY:
 134 ; CHECK-NEXT: Live-out float %red.next.lcssa = ir<%red.next>
 135 ; CHECK-NEXT: }
 136 ;
 137 entry:
 138   br label %for.body
 139
 140 for.body:                                         ; preds = %entry, %for.body
 141   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
 142   %red = phi float [ %red.next, %for.body ], [ 0.0, %entry ]
 143   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
 144   %lv = load float, ptr %arrayidx, align 4
 145   %red.next = fadd fast float %lv, %red
 146   %iv.next = add i64 %iv, 1
 147   %exitcond = icmp eq i64 %iv.next, %n
 148   br i1 %exitcond, label %for.end, label %for.body
 149
 150 for.end:                                          ; preds = %for.body, %entry
 151   ret float %red.next
 152 }
 153
 154 define void @print_reduction_with_invariant_store(i64 %n, ptr noalias %y, ptr noalias %dst) {
 155 ; CHECK-LABEL: Checking a loop in 'print_reduction_with_invariant_store'
 156 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 157 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 158 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 159 ; CHECK-EMPTY:
 160 ; CHECK-NEXT: vector.ph:
 161 ; CHECK-NEXT: Successor(s): vector loop
 162 ; CHECK-EMPTY:
 163 ; CHECK-NEXT: <x1> vector loop: {
 164 ; CHECK-NEXT: vector.body:
 165 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 166 ; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
 167 ; CHECK-NEXT:   vp<[[IV:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 168 ; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[IV]]>
 169 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
 170 ; CHECK-NEXT:   REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>) (with final reduction value stored in invariant address sank outside of loop)
 171 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 172 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 173 ; CHECK-NEXT: No successors
 174 ; CHECK-NEXT: }
 175 ; CHECK-NEXT: Successor(s): middle.block
 176 ; CHECK-EMPTY:
 177 ; CHECK-NEXT: middle.block:
 178 ; CHECK-NEXT: No successors
 179 ; CHECK-NEXT: }
 180 ;
 181 entry:
 182   br label %for.body
 183
 184 for.body:                                         ; preds = %entry, %for.body
 185   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
 186   %red = phi float [ %red.next, %for.body ], [ 0.0, %entry ]
 187   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
 188   %lv = load float, ptr %arrayidx, align 4
 189   %red.next = fadd fast float %lv, %red
 190   store float %red.next, ptr %dst, align 4
 191   %iv.next = add i64 %iv, 1
 192   %exitcond = icmp eq i64 %iv.next, %n
 193   br i1 %exitcond, label %for.end, label %for.body
 194
 195 for.end:                                          ; preds = %for.body, %entry
 196   ret void
 197 }
 198
 199 define void @print_replicate_predicated_phi(i64 %n, ptr %x) {
 200 ; CHECK-LABEL: Checking a loop in 'print_replicate_predicated_phi'
 201 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 202 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 203 ; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count
 204 ; CHECK-EMPTY:
 205 ; CHECK-NEXT: ph:
 206 ; CHECK-NEXT:  EMIT vp<[[TC]]> = EXPAND SCEV (1 smax %n)
 207 ; CHECK-NEXT: No successors
 208 ; CHECK-EMPTY:
 209 ; CHECK-NEXT: vector.ph:
 210 ; CHECK-NEXT: Successor(s): vector loop
 211 ; CHECK-EMPTY:
 212 ; CHECK-NEXT: <x1> vector loop: {
 213 ; CHECK-NEXT: vector.body:
 214 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 215 ; CHECK-NEXT:   WIDEN-INDUCTION %i = phi 0, %i.next, ir<1>
 216 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 217 ; CHECK-NEXT:   WIDEN ir<%cmp> = icmp ult ir<%i>, ir<5>
 218 ; CHECK-NEXT: Successor(s): pred.udiv
 219 ; CHECK-EMPTY:
 220 ; CHECK-NEXT: <xVFxUF> pred.udiv: {
 221 ; CHECK-NEXT:   pred.udiv.entry:
 222 ; CHECK-NEXT:     BRANCH-ON-MASK ir<%cmp>
 223 ; CHECK-NEXT:   Successor(s): pred.udiv.if, pred.udiv.continue
 224 ; CHECK-EMPTY:
 225 ; CHECK-NEXT:   pred.udiv.if:
 226 ; CHECK-NEXT:     REPLICATE ir<%tmp4> = udiv ir<%n>, vp<[[STEPS]]> (S->V)
 227 ; CHECK-NEXT:   Successor(s): pred.udiv.continue
 228 ; CHECK-EMPTY:
 229 ; CHECK-NEXT:   pred.udiv.continue:
 230 ; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%tmp4>
 231 ; CHECK-NEXT:   No successors
 232 ; CHECK-NEXT: }
 233 ; CHECK-NEXT: Successor(s): if.then.0
 234 ; CHECK-EMPTY:
 235 ; CHECK-NEXT: if.then.0:
 236 ; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%cmp>
 237 ; CHECK-NEXT:   BLEND ir<%d> = ir<0>/vp<[[NOT]]> vp<[[PRED]]>/ir<%cmp>
 238 ; CHECK-NEXT:   CLONE ir<%idx> = getelementptr ir<%x>, vp<[[STEPS]]>
 239 ; CHECK-NEXT:   WIDEN store ir<%idx>, ir<%d>
 240 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 241 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 242 ; CHECK-NEXT: No successors
 243 ; CHECK-NEXT: }
 244 ; CHECK-NEXT: Successor(s): middle.block
 245 ; CHECK-EMPTY:
 246 ; CHECK-NEXT: middle.block:
 247 ; CHECK-NEXT: No successors
 248 ; CHECK-NEXT: }
 249 ;
 250 entry:
 251   br label %for.body
 252
 253 for.body:                                         ; preds = %for.inc, %entry
 254   %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ]
 255   %cmp = icmp ult i64 %i, 5
 256   br i1 %cmp, label %if.then, label %for.inc
 257
 258 if.then:                                          ; preds = %for.body
 259   %tmp4 = udiv i64 %n, %i
 260   br label %for.inc
 261
 262 for.inc:                                          ; preds = %if.then, %for.body
 263   %d = phi i64 [ 0, %for.body ], [ %tmp4, %if.then ]
 264   %idx = getelementptr i64, ptr %x, i64 %i
 265   store i64 %d, ptr %idx
 266   %i.next = add nuw nsw i64 %i, 1
 267   %cond = icmp slt i64 %i.next, %n
 268   br i1 %cond, label %for.body, label %for.end
 269
 270 for.end:                                          ; preds = %for.inc
 271   ret void
 272 }
 273
 274 @AB = common global [1024 x i32] zeroinitializer, align 4
 275 @CD = common global [1024 x i32] zeroinitializer, align 4
 276
 277 define void @print_interleave_groups(i32 %C, i32 %D) {
 278 ; CHECK-LABEL: Checking a loop in 'print_interleave_groups'
 279 ; CHECK:       VPlan 'Initial VPlan for VF={4},UF>=1' {
 280 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 281 ; CHECK-NEXT: Live-in ir<256> = original trip-count
 282 ; CHECK-EMPTY:
 283 ; CHECK-NEXT: vector.ph:
 284 ; CHECK-NEXT: Successor(s): vector loop
 285 ; CHECK-EMPTY:
 286 ; CHECK-NEXT: <x1> vector loop: {
 287 ; CHECK-NEXT:  vector.body:
 288 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 289 ; CHECK-NEXT:   vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * ir<4>
 290 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<4>
 291 ; CHECK-NEXT:   CLONE ir<%gep.AB.0> = getelementptr inbounds ir<@AB>, ir<0>, vp<[[STEPS]]>
 292 ; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at %AB.0, ir<%gep.AB.0>
 293 ; CHECK-NEXT:     ir<%AB.0> = load from index 0
 294 ; CHECK-NEXT:     ir<%AB.1> = load from index 1
 295 ; CHECK-NEXT:     ir<%AB.3> = load from index 3
 296 ; CHECK-NEXT:   CLONE ir<%iv.plus.3> = add vp<[[STEPS]]>, ir<3>
 297 ; CHECK-NEXT:   WIDEN ir<%add> = add nsw ir<%AB.0>, ir<%AB.1>
 298 ; CHECK-NEXT:   CLONE ir<%gep.CD.3> = getelementptr inbounds ir<@CD>, ir<0>, ir<%iv.plus.3>
 299 ; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at <badref>, ir<%gep.CD.3>
 300 ; CHECK-NEXT:     store ir<%add> to index 0
 301 ; CHECK-NEXT:     store ir<1> to index 1
 302 ; CHECK-NEXT:     store ir<2> to index 2
 303 ; CHECK-NEXT:     store ir<%AB.3> to index 3
 304 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 305 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 306 ; CHECK-NEXT: No successors
 307 ; CHECK-NEXT: }
 308 ; CHECK-NEXT: Successor(s): middle.block
 309 ; CHECK-EMPTY:
 310 ; CHECK-NEXT: middle.block:
 311 ; CHECK-NEXT: No successors
 312 ; CHECK-NEXT: }
 313 ;
 314 entry:
 315   br label %for.body
 316
 317 for.body:
 318   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
 319   %gep.AB.0= getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv
 320   %AB.0 = load i32, ptr %gep.AB.0, align 4
 321   %iv.plus.1 = add i64 %iv, 1
 322   %gep.AB.1 = getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv.plus.1
 323   %AB.1 = load i32, ptr %gep.AB.1, align 4
 324   %iv.plus.2 = add i64 %iv, 2
 325   %iv.plus.3 = add i64 %iv, 3
 326   %gep.AB.3 = getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv.plus.3
 327   %AB.3 = load i32, ptr %gep.AB.3, align 4
 328   %add = add nsw i32 %AB.0, %AB.1
 329   %gep.CD.0 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv
 330   store i32 %add, ptr %gep.CD.0, align 4
 331   %gep.CD.1 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.1
 332   store i32 1, ptr %gep.CD.1, align 4
 333   %gep.CD.2 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.2
 334   store i32 2, ptr %gep.CD.2, align 4
 335   %gep.CD.3 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.3
 336   store i32 %AB.3, ptr %gep.CD.3, align 4
 337   %iv.next = add nuw nsw i64 %iv, 4
 338   %cmp = icmp slt i64 %iv.next, 1024
 339   br i1 %cmp, label %for.body, label %for.end
 340
 341 for.end:
 342   ret void
 343 }
 344
 345 define float @print_fmuladd_strict(ptr %a, ptr %b, i64 %n) {
 346 ; CHECK-LABEL: Checking a loop in 'print_fmuladd_strict'
 347 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 348 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 349 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 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:   WIDEN-REDUCTION-PHI ir<%sum.07> = phi ir<0.000000e+00>, ir<%muladd>
 358 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 359 ; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
 360 ; CHECK-NEXT:   WIDEN ir<%l.a> = load ir<%arrayidx>
 361 ; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr inbounds ir<%b>, vp<[[STEPS]]>
 362 ; CHECK-NEXT:   WIDEN ir<%l.b> = load ir<%arrayidx2>
 363 ; CHECK-NEXT:   EMIT vp<[[FMUL:%.+]]> = fmul nnan ninf nsz ir<%l.a>, ir<%l.b>
 364 ; CHECK-NEXT:   REDUCE ir<[[MULADD:%.+]]> = ir<%sum.07> + nnan ninf nsz reduce.fadd (vp<[[FMUL]]>)
 365 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 366 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 367 ; CHECK-NEXT:   No successors
 368 ; CHECK-NEXT: }
 369 ; CHECK-NEXT: Successor(s): middle.block
 370 ; CHECK-EMPTY:
 371 ; CHECK-NEXT: middle.block:
 372 ; CHECK-NEXT: No successors
 373 ; CHECK-EMPTY:
 374 ; CHECK-NEXT: Live-out float %muladd.lcssa = ir<%muladd>
 375 ; CHECK-NEXT:}
 376
 377 entry:
 378   br label %for.body
 379
 380 for.body:
 381   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
 382   %sum.07 = phi float [ 0.000000e+00, %entry ], [ %muladd, %for.body ]
 383   %arrayidx = getelementptr inbounds float, ptr %a, i64 %iv
 384   %l.a = load float, ptr %arrayidx, align 4
 385   %arrayidx2 = getelementptr inbounds float, ptr %b, i64 %iv
 386   %l.b = load float, ptr %arrayidx2, align 4
 387   %muladd = tail call nnan ninf nsz float @llvm.fmuladd.f32(float %l.a, float %l.b, float %sum.07)
 388   %iv.next = add nuw nsw i64 %iv, 1
 389   %exitcond.not = icmp eq i64 %iv.next, %n
 390   br i1 %exitcond.not, label %for.end, label %for.body
 391
 392 for.end:
 393   ret float %muladd
 394 }
 395
 396 define void @debug_loc_vpinstruction(ptr nocapture %asd, ptr nocapture %bsd) !dbg !5 {
 397 ; CHECK-LABEL: Checking a loop in 'debug_loc_vpinstruction'
 398 ; CHECK:    VPlan 'Initial VPlan for VF={4},UF>=1' {
 399 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 400 ; CHECK-NEXT: Live-in ir<128> = original trip-count
 401 ; CHECK-EMPTY:
 402 ; CHECK-NEXT: vector.ph:
 403 ; CHECK-NEXT: Successor(s): vector loop
 404 ; CHECK-EMPTY:
 405 ; CHECK-NEXT: <x1> vector loop: {
 406 ; CHECK-NEXT:  vector.body:
 407 ; CHECK-NEXT:    EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 408 ; CHECK-NEXT:    vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 409 ; CHECK-NEXT:    CLONE ir<%isd> = getelementptr inbounds ir<%asd>, vp<[[STEPS]]>
 410 ; CHECK-NEXT:    WIDEN ir<%lsd> = load ir<%isd>
 411 ; CHECK-NEXT:    WIDEN ir<%psd> = add nuw nsw ir<%lsd>, ir<23>
 412 ; CHECK-NEXT:    WIDEN ir<%cmp1> = icmp slt ir<%lsd>, ir<100>
 413 ; CHECK-NEXT:    WIDEN ir<%cmp2> = icmp sge ir<%lsd>, ir<200>
 414 ; CHECK-NEXT:    EMIT vp<[[NOT1:%.+]]> = not ir<%cmp1>, !dbg /tmp/s.c:5:3
 415 ; CHECK-NEXT:    EMIT vp<[[SEL1:%.+]]> = select vp<[[NOT1]]>, ir<%cmp2>, ir<false>, !dbg /tmp/s.c:5:21
 416 ; CHECK-NEXT:    EMIT vp<[[OR1:%.+]]> = or vp<[[SEL1]]>, ir<%cmp1>
 417 ; CHECK-NEXT:  Successor(s): pred.sdiv
 418 ; CHECK-EMPTY:
 419 ; CHECK-NEXT:  <xVFxUF> pred.sdiv: {
 420 ; CHECK-NEXT:    pred.sdiv.entry:
 421 ; CHECK-NEXT:      BRANCH-ON-MASK vp<[[OR1]]>
 422 ; CHECK-NEXT:    Successor(s): pred.sdiv.if, pred.sdiv.continue
 423 ; CHECK-EMPTY:
 424 ; CHECK-NEXT:    pred.sdiv.if:
 425 ; CHECK-NEXT:      REPLICATE ir<%sd1> = sdiv ir<%psd>, ir<%lsd> (S->V)
 426 ; CHECK-NEXT:    Successor(s): pred.sdiv.continue
 427 ; CHECK-EMPTY:
 428 ; CHECK-NEXT:    pred.sdiv.continue:
 429 ; CHECK-NEXT:      PHI-PREDICATED-INSTRUCTION vp<[[PHI:%.+]]> = ir<%sd1>
 430 ; CHECK-NEXT:    No successors
 431 ; CHECK-NEXT:  }
 432 ; CHECK-NEXT:  Successor(s): if.then.0
 433 ; CHECK-EMPTY:
 434 ; CHECK-NEXT:  if.then.0:
 435 ; CHECK-NEXT:    EMIT vp<[[NOT2:%.+]]> = not ir<%cmp2>
 436 ; CHECK-NEXT:    EMIT vp<[[SEL2:%.+]]> = select vp<[[NOT1]]>, vp<[[NOT2]]>, ir<false>
 437 ; CHECK-NEXT:    BLEND ir<%ysd.0> = vp<[[PHI]]>/vp<[[OR1]]> ir<%psd>/vp<[[SEL2]]>
 438 ; CHECK-NEXT:    WIDEN store ir<%isd>, ir<%ysd.0>
 439 ; CHECK-NEXT:    EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 440 ; CHECK-NEXT:    EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 441 ; CHECK-NEXT:  No successors
 442 ; CHECK-NEXT:}
 443 ; CHECK-NEXT: Successor(s): middle.block
 444 ; CHECK-EMPTY:
 445 ; CHECK-NEXT: middle.block:
 446 ; CHECK-NEXT: No successors
 447 ; CHECK-NEXT:}
 448 ;
 449 entry:
 450   br label %loop
 451
 452 loop:
 453   %iv = phi i64 [ 0, %entry ], [ %iv.next, %if.end ]
 454   %isd = getelementptr inbounds i32, ptr %asd, i64 %iv
 455   %lsd = load i32, ptr %isd, align 4
 456   %psd = add nuw nsw i32 %lsd, 23
 457   %cmp1 = icmp slt i32 %lsd, 100
 458   br i1 %cmp1, label %if.then, label %check, !dbg !7
 459
 460 check:
 461   %cmp2 = icmp sge i32 %lsd, 200
 462   br i1 %cmp2, label %if.then, label %if.end, !dbg !8
 463
 464 if.then:
 465   %sd1 = sdiv i32 %psd, %lsd
 466   br label %if.end
 467
 468 if.end:
 469   %ysd.0 = phi i32 [ %sd1, %if.then ], [ %psd, %check ]
 470   store i32 %ysd.0, ptr %isd, align 4
 471   %iv.next = add nuw nsw i64 %iv, 1
 472   %exitcond = icmp eq i64 %iv.next, 128
 473   br i1 %exitcond, label %exit, label %loop
 474
 475 exit:
 476   ret void
 477 }
 478
 479 declare float @llvm.sqrt.f32(float) nounwind readnone
 480 declare float @llvm.fmuladd.f32(float, float, float)
 481
 482 define void @print_expand_scev(i64 %y, ptr %ptr) {
 483 ; CHECK-LABEL: Checking a loop in 'print_expand_scev'
 484 ; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
 485 ; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
 486 ; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count
 487 ; CHECK-EMPTY:
 488 ; CHECK-NEXT: ph:
 489 ; CHECK-NEXT:   EMIT vp<[[TC]]> = EXPAND SCEV (1 + ((15 + (%y /u 492802768830814060))<nuw><nsw> /u (1 + (%y /u 492802768830814060))<nuw><nsw>))<nuw><nsw>
 490 ; CHECK-NEXT:   EMIT vp<[[EXP_SCEV:%.+]]> = EXPAND SCEV (1 + (%y /u 492802768830814060))<nuw><nsw>
 491 ; CHECK-NEXT: No successors
 492 ; CHECK-EMPTY:
 493 ; CHECK-NEXT: vector.ph:
 494 ; CHECK-NEXT: Successor(s): vector loop
 495 ; CHECK-EMPTY:
 496 ; CHECK-NEXT: <x1> vector loop: {
 497 ; CHECK-NEXT:   vector.body:
 498 ; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 499 ; CHECK-NEXT:     WIDEN-INDUCTION\l" +
 500 ; CHECK-NEXT:     "  %iv = phi %iv.next, 0\l" +
 501 ; CHECK-NEXT:     "  ir<%v2>, vp<[[EXP_SCEV]]>
 502 ; CHECK-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * vp<[[EXP_SCEV]]>
 503 ; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, vp<[[EXP_SCEV]]>
 504 ; CHECK-NEXT:     WIDEN ir<%v3> = add nuw ir<%v2>, ir<1>
 505 ; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr inbounds ir<%ptr>, vp<[[STEPS]]>
 506 ; CHECK-NEXT:     REPLICATE store ir<%v3>, ir<%gep>
 507 ; CHECK-NEXT:     EMIT vp<[[CAN_INC:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 508 ; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_INC]]>, vp<[[VTC]]>
 509 ; CHECK-NEXT:   No successors
 510 ; CHECK-NEXT: }
 511 ; CHECK-NEXT: Successor(s): middle.block
 512 ; CHECK-EMPTY:
 513 ; CHECK-NEXT: middle.block:
 514 ; CHECK-NEXT: No successors
 515 ; CHECK-NEXT: }
 516 ;
 517 entry:
 518   %div = udiv i64 %y, 492802768830814060
 519   %inc = add i64 %div, 1
 520   br label %loop
 521
 522 loop:                                             ; preds = %loop, %entry
 523   %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
 524   %v2 = trunc i64 %iv to i8
 525   %v3 = add nuw i8 %v2, 1
 526   %gep = getelementptr inbounds i8, ptr %ptr, i64 %iv
 527   store i8 %v3, ptr %gep
 528
 529   %cmp15 = icmp slt i8 %v3, 10000
 530   %iv.next = add i64 %iv, %inc
 531   br i1 %cmp15, label %loop, label %loop.exit
 532
 533 loop.exit:
 534   ret void
 535 }
 536
 537 define i32 @print_exit_value(ptr %ptr, i32 %off) {
 538 ; CHECK-LABEL: Checking a loop in 'print_exit_value'
 539 ; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
 540 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 541 ; CHECK-NEXT: Live-in ir<1000> = original trip-count
 542 ; CHECK-EMPTY:
 543 ; CHECK-NEXT: vector.ph:
 544 ; CHECK-NEXT: Successor(s): vector loop
 545 ; CHECK-EMPTY:
 546 ; CHECK-NEXT: <x1> vector loop: {
 547 ; CHECK-NEXT:   vector.body:
 548 ; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 549 ; CHECK-NEXT:     WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
 550 ; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 551 ; CHECK-NEXT:     CLONE ir<%gep> = getelementptr inbounds ir<%ptr>, vp<[[STEPS]]>
 552 ; CHECK-NEXT:     WIDEN ir<%add> = add ir<%iv>, ir<%off>
 553 ; CHECK-NEXT:     WIDEN store ir<%gep>, ir<0>
 554 ; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw  vp<[[CAN_IV]]>
 555 ; CHECK-NEXT:     EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 556 ; CHECK-NEXT:   No successors
 557 ; CHECK-NEXT: }
 558 ; CHECK-NEXT: Successor(s): middle.block
 559 ; CHECK-EMPTY:
 560 ; CHECK-NEXT: middle.block:
 561 ; CHECK-NEXT: No successors
 562 ; CHECK-EMPTY:
 563 ; CHECK-NEXT: Live-out i32 %lcssa = ir<%add>
 564 ; CHECK-NEXT: }
 565 ;
 566 entry:
 567   br label %loop
 568
 569 loop:
 570   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 571   %gep = getelementptr inbounds i8, ptr %ptr, i32 %iv
 572   %add = add i32 %iv, %off
 573   store i8 0, ptr %gep
 574   %iv.next = add nsw i32 %iv, 1
 575   %ec = icmp eq i32 %iv.next, 1000
 576   br i1 %ec, label %exit, label %loop
 577
 578 exit:
 579   %lcssa = phi i32 [ %add, %loop ]
 580   ret i32 %lcssa
 581 }
 582
 583 define void @print_fast_math_flags(i64 %n, ptr noalias %y, ptr noalias %x, ptr %z) {
 584 ; CHECK-LABEL: Checking a loop in 'print_fast_math_flags'
 585 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 586 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 587 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 588 ; CHECK-EMPTY:
 589 ; CHECK-NEXT: vector.ph:
 590 ; CHECK-NEXT: Successor(s): vector loop
 591 ; CHECK-EMPTY:
 592 ; CHECK-NEXT: <x1> vector loop: {
 593 ; CHECK-NEXT: vector.body:
 594 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 595 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 596 ; CHECK-NEXT:   CLONE ir<%gep.y> = getelementptr inbounds ir<%y>, vp<[[STEPS]]>
 597 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%gep.y>
 598 ; CHECK-NEXT:   WIDEN ir<%add> = fadd nnan ir<%lv>, ir<1.000000e+00>
 599 ; CHECK-NEXT:   WIDEN ir<%mul> = fmul reassoc nnan ninf nsz arcp contract afn ir<%add>, ir<2.000000e+00>
 600 ; CHECK-NEXT:   WIDEN ir<%div> = fdiv reassoc nsz contract ir<%mul>, ir<2.000000e+00>
 601 ; CHECK-NEXT:   CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>
 602 ; CHECK-NEXT:   WIDEN store ir<%gep.x>, ir<%div>
 603 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 604 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 605 ; CHECK-NEXT: No successors
 606 ; CHECK-NEXT: }
 607 ; CHECK-NEXT: Successor(s): middle.block
 608 ; CHECK-EMPTY:
 609 ; CHECK-NEXT: middle.block:
 610 ; CHECK-NEXT: No successors
 611 ; CHECK-NEXT: }
 612 ;
 613 entry:
 614   br label %loop
 615
 616 loop:
 617   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
 618   %gep.y = getelementptr inbounds float, ptr %y, i64 %iv
 619   %lv = load float, ptr %gep.y, align 4
 620   %add = fadd nnan float %lv, 1.0
 621   %mul = fmul fast float %add, 2.0
 622   %div = fdiv nsz reassoc contract float %mul, 2.0
 623   %gep.x = getelementptr inbounds float, ptr %x, i64 %iv
 624   store float %div, ptr %gep.x, align 4
 625   %iv.next = add i64 %iv, 1
 626   %exitcond = icmp eq i64 %iv.next, %n
 627   br i1 %exitcond, label %exit, label %loop
 628
 629 exit:
 630   ret void
 631 }
 632
 633 define void @print_exact_flags(i64 %n, ptr noalias %x) {
 634 ; CHECK-LABEL: Checking a loop in 'print_exact_flags'
 635 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 636 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 637 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 638 ; CHECK-EMPTY:
 639 ; CHECK-NEXT: vector.ph:
 640 ; CHECK-NEXT: Successor(s): vector loop
 641 ; CHECK-EMPTY:
 642 ; CHECK-NEXT: <x1> vector loop: {
 643 ; CHECK-NEXT: vector.body:
 644 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 645 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 646 ; CHECK-NEXT:   CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>
 647 ; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%gep.x>
 648 ; CHECK-NEXT:   WIDEN ir<%div.1> = udiv exact ir<%lv>, ir<20>
 649 ; CHECK-NEXT:   WIDEN ir<%div.2> = udiv ir<%lv>, ir<60>
 650 ; CHECK-NEXT:   WIDEN ir<%add> = add nuw nsw ir<%div.1>, ir<%div.2>
 651 ; CHECK-NEXT:   WIDEN store ir<%gep.x>, ir<%add>
 652 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 653 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 654 ; CHECK-NEXT: No successors
 655 ; CHECK-NEXT: }
 656 ; CHECK-NEXT: Successor(s): middle.block
 657 ; CHECK-EMPTY:
 658 ; CHECK-NEXT: middle.block:
 659 ; CHECK-NEXT: No successors
 660 ; CHECK-NEXT: }
 661 ;
 662 entry:
 663   br label %loop
 664
 665 loop:
 666   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
 667   %gep.x = getelementptr inbounds i32, ptr %x, i64 %iv
 668   %lv = load i32, ptr %gep.x, align 4
 669   %div.1 = udiv exact i32 %lv, 20
 670   %div.2 = udiv i32 %lv, 60
 671   %add = add nsw nuw i32 %div.1, %div.2
 672   store i32 %add, ptr %gep.x, align 4
 673   %iv.next = add i64 %iv, 1
 674   %exitcond = icmp eq i64 %iv.next, %n
 675   br i1 %exitcond, label %exit, label %loop
 676
 677 exit:
 678   ret void
 679 }
 680
 681 define void @print_call_flags(ptr readonly %src, ptr noalias %dest, i64 %n) {
 682 ; CHECK-LABEL: Checking a loop in 'print_call_flags'
 683 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
 684 ; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
 685 ; CHECK-NEXT: Live-in ir<%n> = original trip-count
 686 ; CHECK-EMPTY:
 687 ; CHECK-NEXT: vector.ph:
 688 ; CHECK-NEXT: Successor(s): vector loop
 689 ; CHECK-EMPTY:
 690 ; CHECK-NEXT: <x1> vector loop: {
 691 ; CHECK-NEXT: vector.body:
 692 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 693 ; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
 694 ; CHECK-NEXT:   CLONE ir<%ld.addr> = getelementptr inbounds ir<%src>, vp<%2>
 695 ; CHECK-NEXT:   WIDEN ir<%ld.value> = load ir<%ld.addr>
 696 ; CHECK-NEXT:   WIDEN ir<%ifcond> = fcmp oeq ir<%ld.value>, ir<5.000000e+00>
 697 ; CHECK-NEXT:  Successor(s): pred.call
 698 ; CHECK-EMPTY:
 699 ; CHECK-NEXT:  <xVFxUF> pred.call: {
 700 ; CHECK-NEXT:    pred.call.entry:
 701 ; CHECK-NEXT:      BRANCH-ON-MASK ir<%ifcond>
 702 ; CHECK-NEXT:    Successor(s): pred.call.if, pred.call.continue
 703 ; CHECK-EMPTY:
 704 ; CHECK-NEXT:    pred.call.if:
 705 ; CHECK-NEXT:      REPLICATE ir<%foo.ret.1> = call nnan ninf nsz @foo(ir<%ld.value>) (S->V)
 706 ; CHECK-NEXT:      REPLICATE ir<%foo.ret.2> = call @foo(ir<%ld.value>) (S->V)
 707 ; CHECK-NEXT:    Successor(s): pred.call.continue
 708 ; CHECK-EMPTY:
 709 ; CHECK-NEXT:    pred.call.continue:
 710 ; CHECK-NEXT:      PHI-PREDICATED-INSTRUCTION vp<%8> = ir<%foo.ret.1>
 711 ; CHECK-NEXT:      PHI-PREDICATED-INSTRUCTION vp<%9> = ir<%foo.ret.2>
 712 ; CHECK-NEXT:    No successors
 713 ; CHECK-NEXT:  }
 714 ; CHECK-NEXT:  Successor(s): if.then.1
 715 ; CHECK-EMPTY:
 716 ; CHECK-NEXT:  if.then.1:
 717 ; CHECK-NEXT:    WIDEN ir<%fadd> = fadd vp<%8>, vp<%9>
 718 ; CHECK-NEXT:    EMIT vp<%11> = not ir<%ifcond>
 719 ; CHECK-NEXT:    BLEND ir<%st.value> = ir<%ld.value>/vp<%11> ir<%fadd>/ir<%ifcond>
 720 ; CHECK-NEXT:    CLONE ir<%st.addr> = getelementptr inbounds ir<%dest>, vp<%2>
 721 ; CHECK-NEXT:    WIDEN store ir<%st.addr>, ir<%st.value>
 722 ; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + nuw vp<[[CAN_IV]]>
 723 ; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VEC_TC]]>
 724 ; CHECK-NEXT: No successors
 725 ; CHECK-NEXT: }
 726 ; CHECK-NEXT: Successor(s): middle.block
 727 ; CHECK-EMPTY:
 728 ; CHECK-NEXT: middle.block:
 729 ; CHECK-NEXT: No successors
 730 ; CHECK-NEXT: }
 731 ;
 732 entry:
 733   br label %for.body
 734
 735 for.body:
 736   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.loop ]
 737   %ld.addr = getelementptr inbounds float, ptr %src, i64 %iv
 738   %ld.value = load float , ptr %ld.addr, align 8
 739   %ifcond = fcmp oeq float %ld.value, 5.0
 740   br i1 %ifcond, label %if.then, label %for.loop
 741
 742 if.then:
 743   %foo.ret.1 = call nnan nsz ninf float @foo(float %ld.value) #0
 744   %foo.ret.2 = call float @foo(float %ld.value) #0
 745   %fadd = fadd float %foo.ret.1, %foo.ret.2
 746   br label %for.loop
 747
 748 for.loop:
 749   %st.value = phi float [ %ld.value, %for.body ], [ %fadd, %if.then ]
 750   %st.addr = getelementptr inbounds float, ptr %dest, i64 %iv
 751   store float %st.value, ptr %st.addr, align 8
 752   %iv.next = add nsw nuw i64 %iv, 1
 753   %loopcond = icmp eq i64 %iv.next, %n
 754   br i1 %loopcond, label %end, label %for.body
 755
 756 end:
 757   ret void
 758 }
 759
 760 !llvm.dbg.cu = !{!0}
 761 !llvm.module.flags = !{!3, !4}
 762
 763 declare float @foo(float) #0
 764 declare <2 x float> @vector_foo(<2 x float>, <2 x i1>)
 765
 766 ; We need a vector variant in order to allow for vectorization at present, but
 767 ; we want to test scalarization of conditional calls. If we provide a variant
 768 ; with a different number of lanes than the VF we force via
 769 ; "-force-vector-width=4", then it should pass the legality checks but
 770 ; scalarize. TODO: Remove the requirement to have a variant.
 771 attributes #0 = { readonly nounwind "vector-function-abi-variant"="_ZGV_LLVM_M2v_foo(vector_foo)" }
 772
 773 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: NoDebug, enums: !2)
 774 !1 = !DIFile(filename: "/tmp/s.c", directory: "/tmp")
 775 !2 = !{}
 776 !3 = !{i32 2, !"Debug Info Version", i32 3}
 777 !4 = !{i32 7, !"PIC Level", i32 2}
 778 !5 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 4, type: !6, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
 779 !6 = !DISubroutineType(types: !2)
 780 !7 = !DILocation(line: 5, column: 3, scope: !5)
 781 !8 = !DILocation(line: 5, column: 21, scope: !5)