llvm/test/Transforms/LoopVectorize/interleave-and-scalarize-only.ll

   1 ; REQUIRES: asserts
   2
   3 ; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -debug -disable-output %s 2>&1 | FileCheck --check-prefix=DBG %s
   4 ; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -S %s | FileCheck %s
   5
   6 ; DBG-LABEL: 'test_scalarize_call'
   7 ; DBG:      VPlan 'Initial VPlan for VF={1},UF>=1' {
   8 ; DBG-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF
   9 ; DBG-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
  10 ; DBG-NEXT: vp<[[TC:%.+]]> = original trip-count
  11 ; DBG-EMPTY:
  12 ; DBG-NEXT: ph:
  13 ; DBG-NEXT:  EMIT vp<[[TC]]> = EXPAND SCEV (1000 + (-1 * %start))
  14 ; DBG-NEXT: No successors
  15 ; DBG-EMPTY:
  16 ; DBG-NEXT: vector.ph:
  17 ; DBG-NEXT: Successor(s): vector loop
  18 ; DBG-EMPTY:
  19 ; DBG-NEXT: <x1> vector loop: {
  20 ; DBG-NEXT:   vector.body:
  21 ; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
  22 ; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%start> + vp<[[CAN_IV]]> * ir<1>
  23 ; DBG-NEXT:     vp<[[IV_STEPS:%.]]>    = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
  24 ; DBG-NEXT:     CLONE ir<%min> = call @llvm.smin.i32(vp<[[IV_STEPS]]>, ir<65535>)
  25 ; DBG-NEXT:     CLONE ir<%arrayidx> = getelementptr inbounds ir<%dst>, vp<[[IV_STEPS]]>
  26 ; DBG-NEXT:     CLONE store ir<%min>, ir<%arrayidx>
  27 ; DBG-NEXT:     EMIT vp<[[INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
  28 ; DBG-NEXT:     EMIT branch-on-count vp<[[INC]]>, vp<[[VEC_TC]]>
  29 ; DBG-NEXT:   No successors
  30 ; DBG-NEXT: }
  31 ;
  32 define void @test_scalarize_call(i32 %start, ptr %dst) {
  33 ; CHECK-LABEL: @test_scalarize_call(
  34 ; CHECK:       vector.body:
  35 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
  36 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = add i32 %start, [[INDEX]]
  37 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i32 [[OFFSET_IDX]], 0
  38 ; CHECK-NEXT:    [[INDUCTION1:%.*]] = add i32 [[OFFSET_IDX]], 1
  39 ; CHECK-NEXT:    [[TMP1:%.*]] = tail call i32 @llvm.smin.i32(i32 [[INDUCTION]], i32 65535)
  40 ; CHECK-NEXT:    [[TMP2:%.*]] = tail call i32 @llvm.smin.i32(i32 [[INDUCTION1]], i32 65535)
  41 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i32, ptr [[DST:%.*]], i32 [[INDUCTION]]
  42 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i32, ptr [[DST]], i32 [[INDUCTION1]]
  43 ; CHECK-NEXT:    store i32 [[TMP1]], ptr [[TMP3]], align 8
  44 ; CHECK-NEXT:    store i32 [[TMP2]], ptr [[TMP4]], align 8
  45 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 2
  46 ; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i32 [[INDEX_NEXT]], %n.vec
  47 ; CHECK-NEXT:    br i1 [[TMP5]], label %middle.block, label %vector.body
  48 ; CHECK:       middle.block:
  49 ;
  50 entry:
  51   br label %loop
  52
  53 loop:
  54   %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
  55   %min = tail call i32 @llvm.smin.i32(i32 %iv, i32 65535)
  56   %arrayidx = getelementptr inbounds i32 , ptr %dst, i32 %iv
  57   store i32 %min, ptr %arrayidx, align 8
  58   %iv.next = add nsw i32 %iv, 1
  59   %tobool.not = icmp eq i32 %iv.next, 1000
  60   br i1 %tobool.not, label %exit, label %loop
  61
  62 exit:
  63   ret void
  64 }
  65
  66 declare i32 @llvm.smin.i32(i32, i32)
  67
  68
  69 ; DBG-LABEL: 'test_scalarize_with_branch_cond'
  70
  71 ; DBG:       Live-in vp<[[VFxUF:%.+]]> = VF * UF
  72 ; DBG-NEXT:  Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
  73 ; DBG-NEXT:  Live-in ir<1000> = original trip-count
  74 ; DBG-EMPTY:
  75 ; DBG-NEXT: vector.ph:
  76 ; DBG-NEXT: Successor(s): vector loop
  77 ; DBG-EMPTY:
  78 ; DBG-NEXT: <x1> vector loop: {
  79 ; DBG-NEXT:   vector.body:
  80 ; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
  81 ; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<false> + vp<[[CAN_IV]]> * ir<true>
  82 ; DBG-NEXT:     vp<[[STEPS1:%.+]]>    = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<true>
  83 ; DBG-NEXT:   Successor(s): pred.store
  84 ; DBG-EMPTY:
  85 ; DBG-NEXT:   <xVFxUF> pred.store: {
  86 ; DBG-NEXT:     pred.store.entry:
  87 ; DBG-NEXT:       BRANCH-ON-MASK vp<[[STEPS1]]>
  88 ; DBG-NEXT:     Successor(s): pred.store.if, pred.store.continue
  89 ; DBG-EMPTY:
  90 ; DBG-NEXT:     pred.store.if:
  91 ; DBG-NEXT:       vp<[[STEPS2:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
  92 ; DBG-NEXT:       CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[STEPS2]]>
  93 ; DBG-NEXT:       CLONE ir<%l> = load ir<%gep.src>
  94 ; DBG-NEXT:       CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<[[STEPS2]]>
  95 ; DBG-NEXT:       CLONE store ir<%l>, ir<%gep.dst>
  96 ; DBG-NEXT:     Successor(s): pred.store.continue
  97 ; DBG-EMPTY:
  98 ; DBG-NEXT:     pred.store.continue:
  99 ; DBG-NEXT:       PHI-PREDICATED-INSTRUCTION vp<{{.+}}> = ir<%l>
 100 ; DBG-NEXT:     No successors
 101 ; DBG-NEXT:   }
 102 ; DBG-NEXT:   Successor(s): cond.false.1
 103 ; DBG-EMPTY:
 104 ; DBG-NEXT:   cond.false.1:
 105 ; DBG-NEXT:     EMIT vp<[[CAN_IV_INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
 106 ; DBG-NEXT:     EMIT branch-on-count vp<[[CAN_IV_INC]]>, vp<[[VEC_TC]]>
 107 ; DBG-NEXT:   No successors
 108 ; DBG-NEXT: }
 109 ; DBG-NEXT: Successor(s): middle.block
 110 ; DBG-EMPTY:
 111 ; DBG-NEXT: middle.block:
 112 ; DBG-NEXT: No successors
 113 ; DBG-NEXT: }
 114
 115 define void @test_scalarize_with_branch_cond(ptr %src, ptr %dst) {
 116 ; CHECK-LABEL: @test_scalarize_with_branch_cond(
 117 ; CHECK:       vector.body:
 118 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %pred.store.continue5 ]
 119 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i64 [[INDEX]] to i1
 120 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = sub i1 false, [[TMP0]]
 121 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i1 [[OFFSET_IDX]], false
 122 ; CHECK-NEXT:    [[INDUCTION3:%.*]] = add i1 [[OFFSET_IDX]], true
 123 ; CHECK-NEXT:    br i1 [[INDUCTION]], label %pred.store.if, label %pred.store.continue
 124 ; CHECK:       pred.store.if:
 125 ; CHECK-NEXT:    [[INDUCTION4:%.*]] = add i64 [[INDEX]], 0
 126 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i32, ptr %src, i64 [[INDUCTION4]]
 127 ; CHECK-NEXT:    [[TMP4:%.*]] = load i32, ptr [[TMP3]], align 4
 128 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr %dst, i64 [[INDUCTION4]]
 129 ; CHECK-NEXT:    store i32 [[TMP4]], ptr [[TMP1]], align 4
 130 ; CHECK-NEXT:    br label %pred.store.continue
 131 ; CHECK:       pred.store.continue:
 132 ; CHECK-NEXT:    [[TMP5:%.*]] = phi i32 [ poison, %vector.body ], [ [[TMP4]], %pred.store.if ]
 133 ; CHECK-NEXT:    br i1 [[INDUCTION3]], label %pred.store.if4, label %pred.store.continue5
 134 ; CHECK:       pred.store.if4:
 135 ; CHECK-NEXT:    [[INDUCTION5:%.*]] = add i64 [[INDEX]], 1
 136 ; CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i32, ptr %src, i64 [[INDUCTION5]]
 137 ; CHECK-NEXT:    [[TMP7:%.*]] = load i32, ptr [[TMP6]], align 4
 138 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr %dst, i64 [[INDUCTION5]]
 139 ; CHECK-NEXT:    store i32 [[TMP7]], ptr [[TMP2]], align 4
 140 ; CHECK-NEXT:    br label %pred.store.continue5
 141 ; CHECK:       pred.store.continue5:
 142 ; CHECK-NEXT:    [[TMP8:%.*]] = phi i32 [ poison, %pred.store.continue ], [ [[TMP7]], %pred.store.if4 ]
 143 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
 144 ; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1000
 145 ; CHECK-NEXT:    br i1 [[TMP9]], label %middle.block, label %vector.body
 146 ; CHECK:       middle.block:
 147 ;
 148 entry:
 149   br label %loop.header
 150
 151 loop.header:
 152   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
 153   %d = phi i1 [ false, %entry ], [ %d.next, %loop.latch ]
 154   %d.next = xor i1 %d, true
 155   br i1 %d, label %cond.false, label %loop.latch
 156
 157 cond.false:
 158   %gep.src = getelementptr inbounds i32, ptr %src, i64 %iv
 159   %gep.dst = getelementptr inbounds i32, ptr %dst, i64 %iv
 160   %l = load i32, ptr %gep.src, align 4
 161   store i32 %l, ptr %gep.dst
 162   br label %loop.latch
 163
 164 loop.latch:
 165   %iv.next = add nsw i64 %iv, 1
 166   %ec = icmp eq i64 %iv.next, 1000
 167   br i1 %ec, label %exit, label %loop.header
 168
 169 exit:
 170   ret void
 171 }
 172
 173 ; Make sure the widened induction gets replaced by scalar-steps for plans
 174 ; including the scalar VF, if it is used in first-order recurrences.
 175
 176 ; DBG-LABEL: 'first_order_recurrence_using_induction'
 177 ; DBG:      VPlan 'Initial VPlan for VF={1},UF>=1' {
 178 ; DBG-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF
 179 ; DBG-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
 180 ; DBG-NEXT: vp<[[TC:%.+]]> = original trip-count
 181 ; DBG-EMPTY:
 182 ; DBG-NEXT: ph:
 183 ; DBG-NEXT:  EMIT vp<[[TC]]> = EXPAND SCEV (zext i32 (1 smax %n) to i64)
 184 ; DBG-NEXT: No successors
 185 ; DBG-EMPTY:
 186 ; DBG-NEXT: vector.ph:
 187 ; DBG-NEXT: Successor(s): vector loop
 188 ; DBG-EMPTY:
 189 ; DBG-NEXT: <x1> vector loop: {
 190 ; DBG-NEXT:   vector.body:
 191 ; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 192 ; DBG-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<[[SCALAR_STEPS:.+]]>
 193 ; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * ir<1> (truncated to i32)
 194 ; DBG-NEXT:     vp<[[SCALAR_STEPS]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
 195 ; DBG-NEXT:     EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%for>, vp<[[SCALAR_STEPS]]>
 196 ; DBG-NEXT:     CLONE store vp<[[SPLICE]]>, ir<%dst>
 197 ; DBG-NEXT:     EMIT vp<[[IV_INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
 198 ; DBG-NEXT:     EMIT branch-on-count vp<[[IV_INC]]>, vp<[[VTC]]>
 199 ; DBG-NEXT:   No successors
 200 ; DBG-NEXT: }
 201 ; DBG-NEXT: Successor(s): middle.block
 202 ; DBG-EMPTY:
 203 ; DBG-NEXT: middle.block:
 204 ; DBG-NEXT: No successors
 205 ; DBG-NEXT: }
 206
 207 define void @first_order_recurrence_using_induction(i32 %n, ptr %dst) {
 208 ; CHECK-LABEL: @first_order_recurrence_using_induction(
 209 ; CHECK:       vector.body:
 210 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 211 ; CHECK-NEXT:    [[VECTOR_RECUR:%.*]] = phi i32 [ 0, %vector.ph ], [ [[INDUCTION1:%.*]], %vector.body ]
 212 ; CHECK-NEXT:    [[TMP3:%.*]] = trunc i64 [[INDEX]] to i32
 213 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i32 [[TMP3]], 0
 214 ; CHECK-NEXT:    [[INDUCTION1]] = add i32 [[TMP3]], 1
 215 ; CHECK-NEXT:    store i32 [[VECTOR_RECUR]], ptr [[DST:%.*]], align 4
 216 ; CHECK-NEXT:    store i32 [[INDUCTION]], ptr [[DST]], align 4
 217 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
 218 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[INDEX_NEXT]], %n.vec
 219 ; CHECK-NEXT:    br i1 [[TMP4]], label %middle.block, label %vector.body
 220 ; CHECK:       middle.block:
 221 ;
 222 entry:
 223   br label %loop
 224
 225 loop:
 226   %iv = phi i64 [ 0, %entry ],[ %iv.next, %loop ]
 227   %for = phi i32 [ 0, %entry ], [ %iv.trunc, %loop ]
 228   %iv.trunc = trunc i64 %iv to i32
 229   store i32 %for, ptr %dst
 230   %iv.next = add nuw nsw i64 %iv, 1
 231   %iv.next.trunc = trunc i64 %iv.next to i32
 232   %ec = icmp slt i32 %iv.next.trunc, %n
 233   br i1 %ec, label %loop, label %exit
 234
 235 exit:
 236   ret void
 237 }
 238
 239 define i16 @reduction_with_casts() {
 240 ; CHECK-LABEL: define i16 @reduction_with_casts() {
 241 ; CHECK:       vector.body:
 242 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH:%.+]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY:%.+]] ]
 243 ; CHECK-NEXT:    [[VEC_PHI:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[TMP2:%.*]], [[VECTOR_BODY]] ]
 244 ; CHECK-NEXT:    [[VEC_PHI1:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[TMP3:%.*]], [[VECTOR_BODY]] ]
 245 ; CHECK-NEXT:    [[TMP0:%.*]] = and i32 [[VEC_PHI]], 65535
 246 ; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[VEC_PHI1]], 65535
 247 ; CHECK-NEXT:    [[TMP2]] = add i32 [[TMP0]], 1
 248 ; CHECK-NEXT:    [[TMP3]] = add i32 [[TMP1]], 1
 249 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 2
 250 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[INDEX_NEXT]], 9998
 251 ; CHECK-NEXT:    br i1 [[TMP4]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]]
 252 ; CHECK:       middle.block:
 253 ; CHECK-NEXT:    [[BIN_RDX:%.*]] = add i32 [[TMP3]], [[TMP2]]
 254 ; CHECK-NEXT:    br i1 false, label [[EXIT:%.*]], label %scalar.ph
 255 ;
 256 entry:
 257   br label %loop
 258
 259 loop:
 260   %count.0.in1 = phi i32 [ 0, %entry ], [ %add, %loop ]
 261   %iv = phi i16 [ 1, %entry ], [ %iv.next, %loop ]
 262   %conv1 = and i32 %count.0.in1, 65535
 263   %add = add nuw nsw i32 %conv1, 1
 264   %iv.next = add i16 %iv, 1
 265   %cmp = icmp eq i16 %iv.next, 10000
 266   br i1 %cmp, label %exit, label %loop
 267
 268 exit:
 269   %add.lcssa = phi i32 [ %add, %loop ]
 270   %count.0 = trunc i32 %add.lcssa to i16
 271   ret i16 %count.0
 272 }
 273
 274 define void @scalarize_ptrtoint(ptr %src, ptr %dst) {
 275 ; CHECK:       vector.body:
 276 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 277 ; CHECK-NEXT:    [[TMP0:%.*]] = add i64 [[INDEX]], 0
 278 ; CHECK-NEXT:    [[TMP1:%.*]] = add i64 [[INDEX]], 1
 279 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr ptr, ptr %src, i64 [[TMP0]]
 280 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr ptr, ptr %src, i64 [[TMP1]]
 281 ; CHECK-NEXT:    [[TMP4:%.*]] = load ptr, ptr [[TMP2]], align 8
 282 ; CHECK-NEXT:    [[TMP5:%.*]] = load ptr, ptr [[TMP3]], align 8
 283 ; CHECK-NEXT:    [[TMP6:%.*]] = ptrtoint ptr [[TMP4]] to i64
 284 ; CHECK-NEXT:    [[TMP7:%.*]] = ptrtoint ptr [[TMP5]] to i64
 285 ; CHECK-NEXT:    [[TMP8:%.*]] = add i64 [[TMP6]], 10
 286 ; CHECK-NEXT:    [[TMP9:%.*]] = add i64 [[TMP7]], 10
 287 ; CHECK-NEXT:    [[TMP10:%.*]] = inttoptr i64 [[TMP8]] to ptr
 288 ; CHECK-NEXT:    [[TMP11:%.*]] = inttoptr i64 [[TMP9]] to ptr
 289 ; CHECK-NEXT:    store ptr [[TMP10]], ptr %dst, align 8
 290 ; CHECK-NEXT:    store ptr [[TMP11]], ptr %dst, align 8
 291 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
 292 ; CHECK-NEXT:    [[TMP12:%.*]] = icmp eq i64 [[INDEX_NEXT]], 0
 293 ; CHECK-NEXT:    br i1 [[TMP12]], label %middle.block, label %vector.body
 294
 295 entry:
 296   br label %loop
 297
 298 loop:
 299   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
 300   %gep = getelementptr ptr, ptr %src, i64 %iv
 301   %l = load ptr, ptr %gep, align 8
 302   %cast = ptrtoint ptr %l to i64
 303   %add = add i64 %cast, 10
 304   %cast.2 = inttoptr i64 %add to ptr
 305   store ptr %cast.2, ptr %dst, align 8
 306   %iv.next = add i64 %iv, 1
 307   %ec = icmp eq i64 %iv.next, 0
 308   br i1 %ec, label %exit, label %loop
 309
 310 exit:
 311   ret void
 312 }
 313
 314 define void @pr76986_trunc_sext_interleaving_only(i16 %arg, ptr noalias %src, ptr noalias %dst) {
 315 ; CHECK-LABEL: define void @pr76986_trunc_sext_interleaving_only(
 316 ; CHECK:       vector.body:
 317 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 318 ; CHECK-NEXT:    [[TMP0:%.*]] = add i64 [[INDEX]], 0
 319 ; CHECK-NEXT:    [[TMP1:%.*]] = add i64 [[INDEX]], 1
 320 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, ptr %src, i64 [[TMP0]]
 321 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8, ptr %src, i64 [[TMP1]]
 322 ; CHECK-NEXT:    [[TMP4:%.*]] = load i8, ptr [[TMP2]], align 1
 323 ; CHECK-NEXT:    [[TMP5:%.*]] = load i8, ptr [[TMP3]], align 1
 324 ; CHECK-NEXT:    [[TMP6:%.*]] = sext i8 [[TMP4]] to i32
 325 ; CHECK-NEXT:    [[TMP7:%.*]] = sext i8 [[TMP5]] to i32
 326 ; CHECK-NEXT:    [[TMP8:%.*]] = trunc i32 [[TMP6]] to i16
 327 ; CHECK-NEXT:    [[TMP9:%.*]] = trunc i32 [[TMP7]] to i16
 328 ; CHECK-NEXT:    [[TMP10:%.*]] = sdiv i16 [[TMP8]], %arg
 329 ; CHECK-NEXT:    [[TMP11:%.*]] = sdiv i16 [[TMP9]], %arg
 330 ; CHECK-NEXT:    [[TMP12:%.*]] = getelementptr inbounds i16, ptr %dst, i64 [[TMP0]]
 331 ; CHECK-NEXT:    [[TMP13:%.*]] = getelementptr inbounds i16, ptr %dst, i64 [[TMP1]]
 332 ; CHECK-NEXT:    store i16 [[TMP10]], ptr [[TMP12]], align 2
 333 ; CHECK-NEXT:    store i16 [[TMP11]], ptr [[TMP13]], align 2
 334 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
 335 ; CHECK-NEXT:    [[TMP14:%.*]] = icmp eq i64 [[INDEX_NEXT]], 14934
 336 ; CHECK-NEXT:    br i1 [[TMP14]], label %middle.block, label %vector.body
 337 ;
 338 bb:
 339   br label %loop
 340
 341 loop:
 342   %iv = phi i64 [ 0, %bb ], [ %iv.next, %loop ]
 343   %gep.src = getelementptr inbounds i8, ptr %src, i64 %iv
 344   %l = load i8, ptr %gep.src
 345   %sext = sext i8 %l to i32
 346   %trunc = trunc i32 %sext to i16
 347   %sdiv = sdiv i16 %trunc, %arg
 348   %gep.dst = getelementptr inbounds i16, ptr %dst, i64 %iv
 349   store i16 %sdiv, ptr %gep.dst
 350   %iv.next = add i64 %iv, 1
 351   %icmp = icmp ult i64 %iv, 14933
 352   br i1 %icmp, label %loop, label %exit
 353
 354 exit:
 355   ret void
 356 }
 357