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

   1 ; RUN: opt -passes=loop-vectorize -force-vector-width=8 -force-vector-interleave=2 -disable-output -debug -S %s 2>&1 | FileCheck --check-prefixes=CHECK %s
   2
   3 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   4
   5 ; REQUIRES: asserts
   6
   7 ; Check if the vector loop condition can be simplified to true for a given
   8 ; VF/IC combination.
   9 define void @test_tc_less_than_16(ptr %A, i64 %N) {
  10 ; CHECK:      LV: Scalarizing:  %cmp =
  11 ; CHECK:      VPlan 'Initial VPlan for VF={8},UF>=1' {
  12 ; CHECK-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF
  13 ; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
  14 ; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count
  15 ; CHECK-EMPTY:
  16 ; CHECK-NEXT: ir-bb<entry>:
  17 ; CHECK-NEXT:   IR %and = and i64 %N, 15
  18 ; CHECK-NEXT:   EMIT vp<[[TC]]> = EXPAND SCEV (zext i4 (trunc i64 %N to i4) to i64)
  19 ; CHECK-NEXT: No successors
  20 ; CHECK-EMPTY:
  21 ; CHECK-NEXT: vector.ph:
  22 ; CHECK-NEXT: Successor(s): vector loop
  23 ; CHECK-EMPTY:
  24 ; CHECK-NEXT: <x1> vector loop: {
  25 ; CHECK-NEXT:   vector.body:
  26 ; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>
  27 ; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  28 ; CHECK-NEXT:     EMIT vp<[[PADD:%.+]]> = ptradd ir<%A>, vp<[[STEPS]]>
  29 ; CHECK-NEXT:     vp<[[VPTR:%.]]> = vector-pointer vp<[[PADD]]>
  30 ; CHECK-NEXT:     WIDEN ir<%l> = load vp<[[VPTR]]>
  31 ; CHECK-NEXT:     WIDEN ir<%add> = add nsw ir<%l>, ir<10>
  32 ; CHECK-NEXT:     vp<[[VPTR2:%.+]]> = vector-pointer vp<[[PADD]]>
  33 ; CHECK-NEXT:     WIDEN store vp<[[VPTR2]]>, ir<%add>
  34 ; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV:%.+]]>, vp<[[VFxUF]]>
  35 ; CHECK-NEXT:     EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>
  36 ; CHECK-NEXT:   No successors
  37 ; CHECK-NEXT: }
  38 ; CHECK-NEXT: Successor(s): middle.block
  39 ; CHECK-EMPTY:
  40 ; CHECK-NEXT: middle.block:
  41 ; CHECK-NEXT:   EMIT vp<[[C:%.+]]> = icmp eq vp<[[TC]]>, vp<[[VTC]]>
  42 ; CHECK-NEXT:   EMIT branch-on-cond vp<[[C]]>
  43 ; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph
  44 ; CHECK-EMPTY:
  45 ; CHECK-NEXT: ir-bb<exit>:
  46 ; CHECK-NEXT: No successors
  47 ; CHECK-EMPTY:
  48 ; CHECK-NEXT: scalar.ph:
  49 ; CHECK-NEXT: Successor(s): ir-bb<loop>
  50 ; CHECK-EMPTY:
  51 ; CHECK-NEXT: ir-bb<loop>:
  52 ; CHECK-NEXT:   IR   %iv = phi i64 [ %and, %entry ], [ %iv.next, %loop ]
  53 ; CHECK-NEXT:   IR   %p.src = phi ptr [ %A, %entry ], [ %p.src.next, %loop ]
  54 ; CHECK:        IR   %cmp = icmp eq i64 %iv.next, 0
  55 ; CHECK-NEXT: No successors
  56 ; CHECK-NEXT: }
  57 ;
  58 ; CHECK: Executing best plan with VF=8, UF=2
  59 ; CHECK-NEXT: VPlan 'Final VPlan for VF={8},UF={2}' {
  60 ; CHECK-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF
  61 ; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
  62 ; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count
  63 ; CHECK-EMPTY:
  64 ; CHECK-NEXT: ir-bb<entry>:
  65 ; CHECK-NEXT:   IR %and = and i64 %N, 15
  66 ; CHECK-NEXT:   EMIT vp<[[TC]]> = EXPAND SCEV (zext i4 (trunc i64 %N to i4) to i64)
  67 ; CHECK-NEXT: No successors
  68 ; CHECK-EMPTY:
  69 ; CHECK-NEXT: vector.ph:
  70 ; CHECK-NEXT: Successor(s): vector loop
  71 ; CHECK-EMPTY:
  72 ; CHECK-NEXT: <x1> vector loop: {
  73 ; CHECK-NEXT:   vector.body:
  74 ; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>
  75 ; CHECK-NEXT:     vp<[[STEPS1:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  76 ; CHECK-NEXT:     EMIT vp<[[PADD1:%.+]]> = ptradd ir<%A>, vp<[[STEPS1]]>
  77 ; CHECK-NEXT:     vp<[[VPTR1:%.]]> = vector-pointer vp<[[PADD1]]>
  78 ; CHECK-NEXT:     vp<[[VPTR2:%.]]> = vector-pointer vp<[[PADD1]]>, ir<1>
  79 ; CHECK-NEXT:     WIDEN ir<%l> = load vp<[[VPTR1]]>
  80 ; CHECK-NEXT:     WIDEN ir<%l>.1 = load vp<[[VPTR2]]>
  81 ; CHECK-NEXT:     WIDEN ir<%add> = add nsw ir<%l>, ir<10>
  82 ; CHECK-NEXT:     WIDEN ir<%add>.1 = add nsw ir<%l>.1, ir<10>
  83 ; CHECK-NEXT:     vp<[[VPTR3:%.+]]> = vector-pointer vp<[[PADD1]]>
  84 ; CHECK-NEXT:     vp<[[VPTR4:%.+]]> = vector-pointer vp<[[PADD1]]>, ir<1>
  85 ; CHECK-NEXT:     WIDEN store vp<[[VPTR3]]>, ir<%add>
  86 ; CHECK-NEXT:     WIDEN store vp<[[VPTR4]]>, ir<%add>.1
  87 ; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV:%.+]]>, vp<[[VFxUF]]>
  88 ; CHECK-NEXT:     EMIT branch-on-cond ir<true>
  89 ; CHECK-NEXT:   No successors
  90 ; CHECK-NEXT: }
  91 ; CHECK-NEXT: Successor(s): middle.block
  92 ; CHECK-EMPTY:
  93 ; CHECK-NEXT: middle.block:
  94 ; CHECK-NEXT:   EMIT vp<[[C:%.+]]> = icmp eq vp<[[TC]]>, vp<[[VTC]]>
  95 ; CHECK-NEXT:   EMIT branch-on-cond vp<[[C]]>
  96 ; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph
  97 ; CHECK-EMPTY:
  98 ; CHECK-NEXT: ir-bb<exit>:
  99 ; CHECK-NEXT: No successors
 100 ; CHECK-EMPTY:
 101 ; CHECK-NEXT: scalar.ph:
 102 ; CHECK-NEXT: Successor(s): ir-bb<loop>
 103 ; CHECK-EMPTY:
 104 ; CHECK-NEXT: ir-bb<loop>:
 105 ; CHECK-NEXT:   IR   %iv = phi i64 [ %and, %entry ], [ %iv.next, %loop ]
 106 ; CHECK-NEXT:   IR   %p.src = phi ptr [ %A, %entry ], [ %p.src.next, %loop ]
 107 ; CHECK:        IR   %cmp = icmp eq i64 %iv.next, 0
 108 ; CHECK-NEXT: No successors
 109 ; CHECK-NEXT: }
 110 ;
 111 entry:
 112   %and = and i64 %N, 15
 113   br label %loop
 114
 115 loop:
 116   %iv = phi i64 [ %and, %entry ], [ %iv.next, %loop ]
 117   %p.src = phi ptr [ %A, %entry ], [ %p.src.next, %loop ]
 118   %p.src.next = getelementptr inbounds i8, ptr %p.src, i64 1
 119   %l = load i8, ptr %p.src, align 1
 120   %add = add nsw i8 %l, 10
 121   store i8 %add, ptr %p.src
 122   %iv.next = add nsw i64 %iv, -1
 123   %cmp = icmp eq i64 %iv.next, 0
 124   br i1 %cmp, label %exit, label %loop
 125
 126 exit:
 127   ret void
 128 }