383 lines · plain
1; REQUIRES: asserts2 3; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -debug -disable-output %s 2>&1 | FileCheck --check-prefix=DBG %s4; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -S %s | FileCheck %s5 6; DBG-LABEL: 'test_scalarize_call'7; DBG: VPlan 'Initial VPlan for VF={1},UF>=1' {8; DBG-NEXT: Live-in vp<[[VF:%.+]]> = VF9; DBG-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF10; DBG-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count11; DBG-NEXT: vp<[[TC:%.+]]> = original trip-count12; DBG-EMPTY:13; DBG-NEXT: ir-bb<entry>:14; DBG-NEXT: EMIT vp<[[TC]]> = EXPAND SCEV (1000 + (-1 * %start))15; DBG-NEXT: Successor(s): scalar.ph, vector.ph16; DBG-EMPTY:17; DBG-NEXT: vector.ph:18; DBG-NEXT: vp<[[END:%.+]]> = DERIVED-IV ir<%start> + vp<[[VEC_TC]]> * ir<1>19; DBG-NEXT: Successor(s): vector loop20; DBG-EMPTY:21; DBG-NEXT: <x1> vector loop: {22; DBG-NEXT: vector.body:23; DBG-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION24; DBG-NEXT: vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%start> + vp<[[CAN_IV]]> * ir<1>25; DBG-NEXT: vp<[[IV_STEPS:%.]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>, vp<[[VF]]>26; DBG-NEXT: CLONE ir<%min> = call @llvm.smin.i32(vp<[[IV_STEPS]]>, ir<65535>)27; DBG-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%dst>, vp<[[IV_STEPS]]>28; DBG-NEXT: CLONE store ir<%min>, ir<%arrayidx>29; DBG-NEXT: EMIT vp<[[INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>30; DBG-NEXT: EMIT branch-on-count vp<[[INC]]>, vp<[[VEC_TC]]>31; DBG-NEXT: No successors32; DBG-NEXT: }33;34define void @test_scalarize_call(i32 %start, ptr %dst) {35; CHECK-LABEL: @test_scalarize_call(36; CHECK: vector.body:37; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]38; CHECK-NEXT: [[OFFSET_IDX:%.*]] = add i32 %start, [[INDEX]]39; CHECK-NEXT: [[INDUCTION1:%.*]] = add i32 [[OFFSET_IDX]], 140; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.smin.i32(i32 [[OFFSET_IDX]], i32 65535)41; CHECK-NEXT: [[TMP2:%.*]] = tail call i32 @llvm.smin.i32(i32 [[INDUCTION1]], i32 65535)42; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i32, ptr [[DST:%.*]], i32 [[OFFSET_IDX]]43; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i32, ptr [[DST]], i32 [[INDUCTION1]]44; CHECK-NEXT: store i32 [[TMP1]], ptr [[TMP3]], align 845; CHECK-NEXT: store i32 [[TMP2]], ptr [[TMP4]], align 846; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 247; CHECK-NEXT: [[TMP5:%.*]] = icmp eq i32 [[INDEX_NEXT]], %n.vec48; CHECK-NEXT: br i1 [[TMP5]], label %middle.block, label %vector.body49; CHECK: middle.block:50;51entry:52 br label %loop53 54loop:55 %iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]56 %min = tail call i32 @llvm.smin.i32(i32 %iv, i32 65535)57 %arrayidx = getelementptr inbounds i32 , ptr %dst, i32 %iv58 store i32 %min, ptr %arrayidx, align 859 %iv.next = add nsw i32 %iv, 160 %tobool.not = icmp eq i32 %iv.next, 100061 br i1 %tobool.not, label %exit, label %loop62 63exit:64 ret void65}66 67declare i32 @llvm.smin.i32(i32, i32)68 69 70; DBG-LABEL: 'test_scalarize_with_branch_cond'71 72; DBG: Live-in vp<[[VFxUF:%.+]]> = VF * UF73; DBG-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count74; DBG-NEXT: Live-in ir<1000> = original trip-count75; DBG-EMPTY:76; DBG-NEXT: ir-bb<entry>:77; DBG-NEXT: Successor(s): scalar.ph, vector.ph78; DBG-EMPTY:79; DBG-NEXT: vector.ph:80; DBG-NEXT: vp<[[END:%.+]]> = DERIVED-IV ir<false> + vp<[[VEC_TC]]> * ir<true>81; DBG-NEXT: Successor(s): vector loop82; DBG-EMPTY:83; DBG-NEXT: <x1> vector loop: {84; DBG-NEXT: vector.body:85; DBG-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION86; DBG-NEXT: vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<false> + vp<[[CAN_IV]]> * ir<true>87; DBG-NEXT: vp<[[STEPS1:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<true>88; DBG-NEXT: Successor(s): pred.store89; DBG-EMPTY:90; DBG-NEXT: <xVFxUF> pred.store: {91; DBG-NEXT: pred.store.entry:92; DBG-NEXT: BRANCH-ON-MASK vp<[[STEPS1]]>93; DBG-NEXT: Successor(s): pred.store.if, pred.store.continue94; DBG-EMPTY:95; DBG-NEXT: pred.store.if:96; DBG-NEXT: vp<[[STEPS2:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>97; DBG-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[STEPS2]]>98; DBG-NEXT: CLONE ir<%l> = load ir<%gep.src>99; DBG-NEXT: CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<[[STEPS2]]>100; DBG-NEXT: CLONE store ir<%l>, ir<%gep.dst>101; DBG-NEXT: Successor(s): pred.store.continue102; DBG-EMPTY:103; DBG-NEXT: pred.store.continue:104; DBG-NEXT: No successors105; DBG-NEXT: }106; DBG-NEXT: Successor(s): cond.false.1107; DBG-EMPTY:108; DBG-NEXT: cond.false.1:109; DBG-NEXT: EMIT vp<[[CAN_IV_INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>110; DBG-NEXT: EMIT branch-on-count vp<[[CAN_IV_INC]]>, vp<[[VEC_TC]]>111; DBG-NEXT: No successors112; DBG-NEXT: }113; DBG-NEXT: Successor(s): middle.block114; DBG-EMPTY:115; DBG-NEXT: middle.block:116; DBG-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<1000>, vp<[[VEC_TC]]>117; DBG-NEXT: EMIT branch-on-cond vp<[[CMP]]>118; DBG-NEXT: Successor(s): ir-bb<exit>, scalar.ph119; DBG-EMPTY:120; DBG-NEXT: ir-bb<exit>:121; DBG-NEXT: No successors122; DBG-EMPTY:123; DBG-NEXT: scalar.ph:124; DBG-NEXT: EMIT-SCALAR vp<[[RESUME1:%.+]]> = phi [ vp<[[VEC_TC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]125; DBG-NEXT: EMIT-SCALAR vp<[[RESUME2:%.+]]>.1 = phi [ vp<[[END]]>, middle.block ], [ ir<false>, ir-bb<entry> ]126; DBG-NEXT: Successor(s): ir-bb<loop.header>127; DBG-EMPTY:128; DBG-NEXT: ir-bb<loop.header>:129; DBG-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ] (extra operand: vp<[[RESUME1]]> from scalar.ph)130; DBG-NEXT: IR %d = phi i1 [ false, %entry ], [ %d.next, %loop.latch ] (extra operand: vp<[[RESUME2]]>.1 from scalar.ph)131; DBG-NEXT: IR %d.next = xor i1 %d, true132; DBG-NEXT: No successors133; DBG-NEXT: }134 135define void @test_scalarize_with_branch_cond(ptr %src, ptr %dst) {136; CHECK-LABEL: @test_scalarize_with_branch_cond(137; CHECK: vector.body:138; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %pred.store.continue4 ]139; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[INDEX]] to i1140; CHECK-NEXT: [[OFFSET_IDX:%.*]] = sub i1 false, [[TMP0]]141; CHECK-NEXT: [[INDUCTION:%.*]] = add i1 [[OFFSET_IDX]], false142; CHECK-NEXT: [[INDUCTION3:%.*]] = add i1 [[OFFSET_IDX]], true143; CHECK-NEXT: br i1 [[INDUCTION]], label %pred.store.if, label %pred.store.continue144; CHECK: pred.store.if:145; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i32, ptr %src, i64 [[INDEX]]146; CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[TMP3]], align 4147; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr %dst, i64 [[INDEX]]148; CHECK-NEXT: store i32 [[TMP4]], ptr [[TMP1]], align 4149; CHECK-NEXT: br label %pred.store.continue150; CHECK: pred.store.continue:151; CHECK-NEXT: br i1 [[INDUCTION3]], label %pred.store.if3, label %pred.store.continue4152; CHECK: pred.store.if3:153; CHECK-NEXT: [[INDUCTION5:%.*]] = add i64 [[INDEX]], 1154; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds i32, ptr %src, i64 [[INDUCTION5]]155; CHECK-NEXT: [[TMP7:%.*]] = load i32, ptr [[TMP6]], align 4156; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr %dst, i64 [[INDUCTION5]]157; CHECK-NEXT: store i32 [[TMP7]], ptr [[TMP2]], align 4158; CHECK-NEXT: br label %pred.store.continue4159; CHECK: pred.store.continue4:160; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2161; CHECK-NEXT: [[TMP9:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1000162; CHECK-NEXT: br i1 [[TMP9]], label %middle.block, label %vector.body163; CHECK: middle.block:164;165entry:166 br label %loop.header167 168loop.header:169 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]170 %d = phi i1 [ false, %entry ], [ %d.next, %loop.latch ]171 %d.next = xor i1 %d, true172 br i1 %d, label %cond.false, label %loop.latch173 174cond.false:175 %gep.src = getelementptr inbounds i32, ptr %src, i64 %iv176 %gep.dst = getelementptr inbounds i32, ptr %dst, i64 %iv177 %l = load i32, ptr %gep.src, align 4178 store i32 %l, ptr %gep.dst179 br label %loop.latch180 181loop.latch:182 %iv.next = add nsw i64 %iv, 1183 %ec = icmp eq i64 %iv.next, 1000184 br i1 %ec, label %exit, label %loop.header185 186exit:187 ret void188}189 190; Make sure the widened induction gets replaced by scalar-steps for plans191; including the scalar VF, if it is used in first-order recurrences.192 193; DBG-LABEL: 'first_order_recurrence_using_induction'194; DBG: VPlan 'Initial VPlan for VF={1},UF>=1' {195; DBG-NEXT: Live-in vp<[[VF:%.+]]> = VF196; DBG-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF197; DBG-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count198; DBG-NEXT: vp<[[TC:%.+]]> = original trip-count199; DBG-EMPTY:200; DBG-NEXT: ir-bb<entry>:201; DBG-NEXT: EMIT vp<[[TC]]> = EXPAND SCEV (zext i32 (1 smax %n) to i64)202; DBG-NEXT: Successor(s): scalar.ph, vector.ph203; DBG-EMPTY:204; DBG-NEXT: vector.ph:205; DBG-NEXT: Successor(s): vector loop206; DBG-EMPTY:207; DBG-NEXT: <x1> vector loop: {208; DBG-NEXT: vector.body:209; DBG-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION210; DBG-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<[[SCALAR_STEPS:.+]]>211; DBG-NEXT: EMIT-SCALAR vp<[[TRUNC_IV:%.+]]> = trunc vp<[[CAN_IV]]> to i32212; DBG-NEXT: vp<[[SCALAR_STEPS]]> = SCALAR-STEPS vp<[[TRUNC_IV]]>, ir<1>, vp<[[VF]]213; DBG-NEXT: EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%for>, vp<[[SCALAR_STEPS]]>214; DBG-NEXT: CLONE store vp<[[SPLICE]]>, ir<%dst>215; DBG-NEXT: EMIT vp<[[IV_INC:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>216; DBG-NEXT: EMIT branch-on-count vp<[[IV_INC]]>, vp<[[VTC]]>217; DBG-NEXT: No successors218; DBG-NEXT: }219; DBG-NEXT: Successor(s): middle.block220; DBG-EMPTY:221; DBG-NEXT: middle.block:222; DBG-NEXT: EMIT vp<[[RESUME_1:%.+]]> = extract-last-element vp<[[SCALAR_STEPS]]>223; DBG-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq vp<[[TC]]>, vp<[[VEC_TC]]>224; DBG-NEXT: EMIT branch-on-cond vp<[[CMP]]>225; DBG-NEXT: Successor(s): ir-bb<exit>, scalar.ph226; DBG-EMPTY:227; DBG-NEXT: ir-bb<exit>:228; DBG-NEXT: No successors229; DBG-EMPTY:230; DBG-NEXT: scalar.ph:231; DBG-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]232; DBG-NEXT: EMIT-SCALAR vp<[[RESUME_P:%.*]]> = phi [ vp<[[RESUME_1]]>, middle.block ], [ ir<0>, ir-bb<entry> ]233; DBG-NEXT: Successor(s): ir-bb<loop>234; DBG-EMPTY:235; DBG-NEXT: ir-bb<loop>:236; DBG-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)237; DBG-NEXT: IR %for = phi i32 [ 0, %entry ], [ %iv.trunc, %loop ] (extra operand: vp<[[RESUME_P]]> from scalar.ph)238; DBG: IR %ec = icmp slt i32 %iv.next.trunc, %n239; DBG-NEXT: No successors240; DBG-NEXT: }241 242define void @first_order_recurrence_using_induction(i32 %n, ptr %dst) {243; CHECK-LABEL: @first_order_recurrence_using_induction(244; CHECK: vector.body:245; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]246; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[INDEX]] to i32247; CHECK-NEXT: [[INDUCTION:%.*]] = add i32 [[TMP3]], 0248; CHECK-NEXT: [[INDUCTION1:%.*]] = add i32 [[TMP3]], 1249; CHECK-NEXT: store i32 [[INDUCTION]], ptr [[DST]], align 4250; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2251; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i64 [[INDEX_NEXT]], %n.vec252; CHECK-NEXT: br i1 [[TMP4]], label %middle.block, label %vector.body253; CHECK: middle.block:254;255entry:256 br label %loop257 258loop:259 %iv = phi i64 [ 0, %entry ],[ %iv.next, %loop ]260 %for = phi i32 [ 0, %entry ], [ %iv.trunc, %loop ]261 %iv.trunc = trunc i64 %iv to i32262 store i32 %for, ptr %dst263 %iv.next = add nuw nsw i64 %iv, 1264 %iv.next.trunc = trunc i64 %iv.next to i32265 %ec = icmp slt i32 %iv.next.trunc, %n266 br i1 %ec, label %loop, label %exit267 268exit:269 ret void270}271 272define i16 @reduction_with_casts() {273; CHECK-LABEL: define i16 @reduction_with_casts() {274; CHECK: vector.body:275; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH:%.+]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY:%.+]] ]276; CHECK-NEXT: [[VEC_PHI:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[TMP2:%.*]], [[VECTOR_BODY]] ]277; CHECK-NEXT: [[VEC_PHI1:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[TMP3:%.*]], [[VECTOR_BODY]] ]278; CHECK-NEXT: [[TMP0:%.*]] = and i32 [[VEC_PHI]], 65535279; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[VEC_PHI1]], 65535280; CHECK-NEXT: [[TMP2]] = add i32 [[TMP0]], 1281; CHECK-NEXT: [[TMP3]] = add i32 [[TMP1]], 1282; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 2283; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i32 [[INDEX_NEXT]], 9998284; CHECK-NEXT: br i1 [[TMP4]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]]285; CHECK: middle.block:286; CHECK-NEXT: [[BIN_RDX:%.*]] = add i32 [[TMP3]], [[TMP2]]287; CHECK-NEXT: br label %scalar.ph288;289entry:290 br label %loop291 292loop:293 %count.0.in1 = phi i32 [ 0, %entry ], [ %add, %loop ]294 %iv = phi i16 [ 1, %entry ], [ %iv.next, %loop ]295 %conv1 = and i32 %count.0.in1, 65535296 %add = add nuw nsw i32 %conv1, 1297 %iv.next = add i16 %iv, 1298 %cmp = icmp eq i16 %iv.next, 10000299 br i1 %cmp, label %exit, label %loop300 301exit:302 %add.lcssa = phi i32 [ %add, %loop ]303 %count.0 = trunc i32 %add.lcssa to i16304 ret i16 %count.0305}306 307define void @scalarize_ptrtoint(ptr %src, ptr %dst) {308; CHECK: vector.body:309; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]310; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[INDEX]], 1311; CHECK-NEXT: [[TMP3:%.*]] = getelementptr ptr, ptr %src, i64 [[TMP1]]312; CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TMP3]], align 8313; CHECK-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[TMP5]] to i64314; CHECK-NEXT: [[TMP9:%.*]] = add i64 [[TMP7]], 10315; CHECK-NEXT: [[TMP11:%.*]] = inttoptr i64 [[TMP9]] to ptr316; CHECK-NEXT: store ptr [[TMP11]], ptr %dst, align 8317; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2318; CHECK-NEXT: [[TMP12:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024319; CHECK-NEXT: br i1 [[TMP12]], label %middle.block, label %vector.body320 321entry:322 br label %loop323 324loop:325 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]326 %gep = getelementptr ptr, ptr %src, i64 %iv327 %l = load ptr, ptr %gep, align 8328 %cast = ptrtoint ptr %l to i64329 %add = add i64 %cast, 10330 %cast.2 = inttoptr i64 %add to ptr331 store ptr %cast.2, ptr %dst, align 8332 %iv.next = add i64 %iv, 1333 %ec = icmp eq i64 %iv.next, 1024334 br i1 %ec, label %exit, label %loop335 336exit:337 ret void338}339 340define void @pr76986_trunc_sext_interleaving_only(i16 %arg, ptr noalias %src, ptr noalias %dst) {341; CHECK-LABEL: define void @pr76986_trunc_sext_interleaving_only(342; CHECK: vector.body:343; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]344; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[INDEX]], 1345; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr %src, i64 [[INDEX]]346; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr %src, i64 [[TMP1]]347; CHECK-NEXT: [[TMP4:%.*]] = load i8, ptr [[TMP2]], align 1348; CHECK-NEXT: [[TMP5:%.*]] = load i8, ptr [[TMP3]], align 1349; CHECK-NEXT: [[TMP6:%.*]] = sext i8 [[TMP4]] to i32350; CHECK-NEXT: [[TMP7:%.*]] = sext i8 [[TMP5]] to i32351; CHECK-NEXT: [[TMP8:%.*]] = trunc i32 [[TMP6]] to i16352; CHECK-NEXT: [[TMP9:%.*]] = trunc i32 [[TMP7]] to i16353; CHECK-NEXT: [[TMP10:%.*]] = sdiv i16 [[TMP8]], %arg354; CHECK-NEXT: [[TMP11:%.*]] = sdiv i16 [[TMP9]], %arg355; CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds i16, ptr %dst, i64 [[INDEX]]356; CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds i16, ptr %dst, i64 [[TMP1]]357; CHECK-NEXT: store i16 [[TMP10]], ptr [[TMP12]], align 2358; CHECK-NEXT: store i16 [[TMP11]], ptr [[TMP13]], align 2359; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2360; CHECK-NEXT: [[TMP14:%.*]] = icmp eq i64 [[INDEX_NEXT]], 14934361; CHECK-NEXT: br i1 [[TMP14]], label %middle.block, label %vector.body362;363bb:364 br label %loop365 366loop:367 %iv = phi i64 [ 0, %bb ], [ %iv.next, %loop ]368 %gep.src = getelementptr inbounds i8, ptr %src, i64 %iv369 %l = load i8, ptr %gep.src370 %sext = sext i8 %l to i32371 %trunc = trunc i32 %sext to i16372 %sdiv = sdiv i16 %trunc, %arg373 %gep.dst = getelementptr inbounds i16, ptr %dst, i64 %iv374 store i16 %sdiv, ptr %gep.dst375 %iv.next = add i64 %iv, 1376 %icmp = icmp ult i64 %iv, 14933377 br i1 %icmp, label %loop, label %exit378 379exit:380 ret void381}382 383