1093 lines · plain
1; REQUIRES: asserts2 3; RUN: opt -passes=loop-vectorize -debug-only=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-interleaved-mem-accesses=true -enable-masked-interleaved-mem-accesses -force-widen-divrem-via-safe-divisor=0 -disable-output %s 2>&1 | FileCheck %s4 5target 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 9define 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<[[VF:%.]]> = VF13; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF14; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count15; CHECK-NEXT: Live-in ir<%n> = original trip-count16; CHECK-EMPTY:17; CHECK-NEXT: ir-bb<for.body.preheader>:18; CHECK-NEXT: Successor(s): scalar.ph, vector.ph19; CHECK-EMPTY:20; CHECK-NEXT: vector.ph:21; CHECK-NEXT: Successor(s): vector loop22; CHECK-EMPTY:23; CHECK-NEXT: <x1> vector loop: {24; CHECK-NEXT: vector.body:25; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>26; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>27; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[STEPS]]>28; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%arrayidx>29; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VEC_PTR]]>30; CHECK-NEXT: WIDEN-INTRINSIC ir<%call> = call llvm.sqrt(ir<%lv>)31; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>32; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%arrayidx2>33; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>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 successors37; CHECK-NEXT: }38; CHECK-NEXT: Successor(s): middle.block39; CHECK-EMPTY:40; CHECK-NEXT: middle.block:41; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>42; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>43; CHECK-NEXT: Successor(s): ir-bb<for.end.loopexit>, scalar.ph44; CHECK-EMPTY:45; CHECK-NEXT: ir-bb<for.end.loopexit>46; CHECK-NEXT: No successors47; CHECK-EMPTY:48; CHECK-NEXT: scalar.ph49; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<for.body.preheader> ]50; CHECK-NEXT: Successor(s): ir-bb<for.body>51; CHECK-EMPTY:52; CHECK-NEXT: ir-bb<for.body>:53; CHECK-NEXT: IR %iv = phi i64 [ %iv.next, %for.body ], [ 0, %for.body.preheader ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)54; CHECK: IR %exitcond = icmp eq i64 %iv.next, %n55; CHECK-NEXT: No successors56; CHECK-NEXT: }57;58entry:59 %cmp6 = icmp sgt i64 %n, 060 br i1 %cmp6, label %for.body, label %for.end61 62for.body: ; preds = %entry, %for.body63 %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]64 %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv65 %lv = load float, ptr %arrayidx, align 466 %call = tail call float @llvm.sqrt.f32(float %lv) nounwind readnone67 %arrayidx2 = getelementptr inbounds float, ptr %x, i64 %iv68 store float %call, ptr %arrayidx2, align 469 %iv.next = add i64 %iv, 170 %exitcond = icmp eq i64 %iv.next, %n71 br i1 %exitcond, label %for.end, label %for.body72 73for.end: ; preds = %for.body, %entry74 ret void75}76 77define void @print_widen_gep_and_select(i64 %n, ptr noalias %y, ptr noalias %x, ptr %z) nounwind uwtable {78; CHECK-LABEL: Checking a loop in 'print_widen_gep_and_select'79; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {80; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF81; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF82; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count83; CHECK-NEXT: Live-in ir<%n> = original trip-count84; CHECK-EMPTY:85; CHECK-NEXT: ir-bb<for.body.preheader>:86; CHECK-NEXT: Successor(s): scalar.ph, vector.ph87; CHECK-EMPTY:88; CHECK-NEXT: vector.ph:89; CHECK-NEXT: Successor(s): vector loop90; CHECK-EMPTY:91; CHECK-NEXT: <x1> vector loop: {92; CHECK-NEXT: vector.body:93; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>94; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VF]]>95; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>96; CHECK-NEXT: WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr inbounds ir<%y>, ir<%iv>97; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%arrayidx>98; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VEC_PTR]]>99; CHECK-NEXT: WIDEN ir<%cmp> = icmp eq ir<%arrayidx>, ir<%z>100; CHECK-NEXT: WIDEN-SELECT ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>101; CHECK-NEXT: WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>102; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>103; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%arrayidx2>104; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%add>105; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>106; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>107; CHECK-NEXT: No successors108; CHECK-NEXT: }109; CHECK-NEXT: Successor(s): middle.block110; CHECK-EMPTY:111; CHECK-NEXT: middle.block:112; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>113; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>114; CHECK-NEXT: Successor(s): ir-bb<for.end.loopexit>, scalar.ph115; CHECK-EMPTY:116; CHECK-NEXT: ir-bb<for.end.loopexit>117; CHECK-NEXT: No successors118; CHECK-EMPTY:119; CHECK-NEXT: scalar.ph120; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<for.body.preheader> ]121; CHECK-NEXT: Successor(s): ir-bb<for.body>122; CHECK-EMPTY:123; CHECK-NEXT: ir-bb<for.body>:124; CHECK-NEXT: IR %iv = phi i64 [ %iv.next, %for.body ], [ 0, %for.body.preheader ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)125; CHECK: IR %exitcond = icmp eq i64 %iv.next, %n126; CHECK-NEXT: No successors127; CHECK-NEXT: }128;129entry:130 %cmp6 = icmp sgt i64 %n, 0131 br i1 %cmp6, label %for.body, label %for.end132 133for.body: ; preds = %entry, %for.body134 %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]135 %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv136 %lv = load float, ptr %arrayidx, align 4137 %cmp = icmp eq ptr %arrayidx, %z138 %sel = select i1 %cmp, float 10.0, float 20.0139 %add = fadd float %lv, %sel140 %arrayidx2 = getelementptr inbounds float, ptr %x, i64 %iv141 store float %add, ptr %arrayidx2, align 4142 %iv.next = add i64 %iv, 1143 %exitcond = icmp eq i64 %iv.next, %n144 br i1 %exitcond, label %for.end, label %for.body145 146for.end: ; preds = %for.body, %entry147 ret void148}149 150define void @print_replicate_predicated_phi(i64 %n, ptr %x) {151; CHECK-LABEL: Checking a loop in 'print_replicate_predicated_phi'152; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {153; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF154; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF155; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count156; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count157; CHECK-EMPTY:158; CHECK-NEXT: ir-bb<entry>:159; CHECK-NEXT: EMIT vp<[[TC]]> = EXPAND SCEV (1 smax %n)160; CHECK-NEXT: Successor(s): scalar.ph, vector.ph161; CHECK-EMPTY:162; CHECK-NEXT: vector.ph:163; CHECK-NEXT: Successor(s): vector loop164; CHECK-EMPTY:165; CHECK-NEXT: <x1> vector loop: {166; CHECK-NEXT: vector.body:167; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>168; CHECK-NEXT: ir<%i> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VF]]>169; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>170; CHECK-NEXT: WIDEN ir<%cmp> = icmp ult ir<%i>, ir<5>171; CHECK-NEXT: Successor(s): pred.udiv172; CHECK-EMPTY:173; CHECK-NEXT: <xVFxUF> pred.udiv: {174; CHECK-NEXT: pred.udiv.entry:175; CHECK-NEXT: BRANCH-ON-MASK ir<%cmp>176; CHECK-NEXT: Successor(s): pred.udiv.if, pred.udiv.continue177; CHECK-EMPTY:178; CHECK-NEXT: pred.udiv.if:179; CHECK-NEXT: vp<[[STEPS2:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>180; CHECK-NEXT: REPLICATE ir<%tmp4> = udiv ir<%n>, vp<[[STEPS2]]> (S->V)181; CHECK-NEXT: Successor(s): pred.udiv.continue182; CHECK-EMPTY:183; CHECK-NEXT: pred.udiv.continue:184; CHECK-NEXT: PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%tmp4>185; CHECK-NEXT: No successors186; CHECK-NEXT: }187; CHECK-NEXT: Successor(s): if.then.0188; CHECK-EMPTY:189; CHECK-NEXT: if.then.0:190; CHECK-NEXT: BLEND ir<%d> = ir<0> vp<[[PRED]]>/ir<%cmp>191; CHECK-NEXT: CLONE ir<%idx> = getelementptr ir<%x>, vp<[[STEPS]]>192; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer ir<%idx>193; CHECK-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<%d>194; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>195; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>196; CHECK-NEXT: No successors197; CHECK-NEXT: }198; CHECK-NEXT: Successor(s): middle.block199; CHECK-EMPTY:200; CHECK-NEXT: middle.block:201; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq vp<[[TC]]>, vp<[[VTC]]>202; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>203; CHECK-NEXT: Successor(s): ir-bb<for.end>, scalar.ph204; CHECK-EMPTY:205; CHECK-NEXT: ir-bb<for.end>206; CHECK-NEXT: No successors207; CHECK-EMPTY:208; CHECK-NEXT: scalar.ph209; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]210; CHECK-NEXT: Successor(s): ir-bb<for.body>211; CHECK-EMPTY:212; CHECK-NEXT: ir-bb<for.body>:213; CHECK-NEXT: IR %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)214; CHECK-NEXT: IR %cmp = icmp ult i64 %i, 5215; CHECK-NEXT: No successors216; CHECK-NEXT: }217;218entry:219 br label %for.body220 221for.body: ; preds = %for.inc, %entry222 %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ]223 %cmp = icmp ult i64 %i, 5224 br i1 %cmp, label %if.then, label %for.inc225 226if.then: ; preds = %for.body227 %tmp4 = udiv i64 %n, %i228 br label %for.inc229 230for.inc: ; preds = %if.then, %for.body231 %d = phi i64 [ 0, %for.body ], [ %tmp4, %if.then ]232 %idx = getelementptr i64, ptr %x, i64 %i233 store i64 %d, ptr %idx234 %i.next = add nuw nsw i64 %i, 1235 %cond = icmp slt i64 %i.next, %n236 br i1 %cond, label %for.body, label %for.end237 238for.end: ; preds = %for.inc239 ret void240}241 242@AB = common global [1024 x i32] zeroinitializer, align 4243@CD = common global [1024 x i32] zeroinitializer, align 4244 245define void @print_interleave_groups(i32 %C, i32 %D) {246; CHECK-LABEL: Checking a loop in 'print_interleave_groups'247; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {248; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF249; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF250; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count251; CHECK-NEXT: Live-in ir<256> = original trip-count252; CHECK-EMPTY:253; CHECK-NEXT: ir-bb<entry>:254; CHECK-NEXT: Successor(s): scalar.ph, vector.ph255; CHECK-EMPTY:256; CHECK-NEXT: vector.ph:257; CHECK-NEXT: vp<[[IV_END:%.+]]> = DERIVED-IV ir<0> + vp<[[VTC]]> * ir<4>258; CHECK-NEXT: Successor(s): vector loop259; CHECK-EMPTY:260; CHECK-NEXT: <x1> vector loop: {261; CHECK-NEXT: vector.body:262; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>263; CHECK-NEXT: vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * ir<4>264; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<4>, vp<[[VF]]>265; CHECK-NEXT: CLONE ir<%gep.AB.0> = getelementptr inbounds ir<@AB>, ir<0>, vp<[[STEPS]]>266; CHECK-NEXT: INTERLEAVE-GROUP with factor 4 at %AB.0, ir<%gep.AB.0>267; CHECK-NEXT: ir<%AB.0> = load from index 0268; CHECK-NEXT: ir<%AB.1> = load from index 1269; CHECK-NEXT: ir<%AB.3> = load from index 3270; CHECK-NEXT: WIDEN ir<%add> = add nsw ir<%AB.0>, ir<%AB.1>271; CHECK-NEXT: CLONE ir<%gep.CD.0> = getelementptr inbounds ir<@CD>, ir<0>, vp<[[STEPS]]>272; CHECK-NEXT: INTERLEAVE-GROUP with factor 4 at <badref>, ir<%gep.CD.0>273; CHECK-NEXT: store ir<%add> to index 0274; CHECK-NEXT: store ir<1> to index 1275; CHECK-NEXT: store ir<2> to index 2276; CHECK-NEXT: store ir<%AB.3> to index 3277; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>278; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>279; CHECK-NEXT: No successors280; CHECK-NEXT: }281; CHECK-NEXT: Successor(s): middle.block282; CHECK-EMPTY:283; CHECK-NEXT: middle.block:284; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<256>, vp<[[VTC]]>285; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>286; CHECK-NEXT: Successor(s): ir-bb<for.end>, scalar.ph287; CHECK-EMPTY:288; CHECK-NEXT: ir-bb<for.end>289; CHECK-NEXT: No successors290; CHECK-EMPTY:291; CHECK-NEXT: scalar.ph292; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[IV_END]]>, middle.block ], [ ir<0>, ir-bb<entry> ]293; CHECK-NEXT: Successor(s): ir-bb<for.body>294; CHECK-EMPTY:295; CHECK-NEXT: ir-bb<for.body>:296; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)297; CHECK: IR %cmp = icmp slt i64 %iv.next, 1024298; CHECK-NEXT: No successors299; CHECK-NEXT: }300;301entry:302 br label %for.body303 304for.body:305 %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]306 %gep.AB.0= getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv307 %AB.0 = load i32, ptr %gep.AB.0, align 4308 %iv.plus.1 = add i64 %iv, 1309 %gep.AB.1 = getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv.plus.1310 %AB.1 = load i32, ptr %gep.AB.1, align 4311 %iv.plus.2 = add i64 %iv, 2312 %iv.plus.3 = add i64 %iv, 3313 %gep.AB.3 = getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv.plus.3314 %AB.3 = load i32, ptr %gep.AB.3, align 4315 %add = add nsw i32 %AB.0, %AB.1316 %gep.CD.0 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv317 store i32 %add, ptr %gep.CD.0, align 4318 %gep.CD.1 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.1319 store i32 1, ptr %gep.CD.1, align 4320 %gep.CD.2 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.2321 store i32 2, ptr %gep.CD.2, align 4322 %gep.CD.3 = getelementptr inbounds [1024 x i32], ptr @CD, i64 0, i64 %iv.plus.3323 store i32 %AB.3, ptr %gep.CD.3, align 4324 %iv.next = add nuw nsw i64 %iv, 4325 %cmp = icmp slt i64 %iv.next, 1024326 br i1 %cmp, label %for.body, label %for.end327 328for.end:329 ret void330}331 332define void @recipe_debug_loc_location(ptr nocapture %src) !dbg !5 {333; CHECK-LABEL: Checking a loop in 'recipe_debug_loc_location'334; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {335; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF336; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF337; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count338; CHECK-NEXT: Live-in ir<128> = original trip-count339; CHECK-EMPTY:340; CHECK-NEXT: ir-bb<entry>:341; CHECK-NEXT: Successor(s): scalar.ph, vector.ph342; CHECK-EMPTY:343; CHECK-NEXT: vector.ph:344; CHECK-NEXT: Successor(s): vector loop345; CHECK-EMPTY:346; CHECK-NEXT: <x1> vector loop: {347; CHECK-NEXT: vector.body:348; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>349; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>350; CHECK-NEXT: CLONE ir<%isd> = getelementptr inbounds ir<%src>, vp<[[STEPS]]>, !dbg /tmp/s.c:5:3351; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%isd>, !dbg /tmp/s.c:6:3352; CHECK-NEXT: WIDEN ir<%lsd> = load vp<[[VEC_PTR]]>, !dbg /tmp/s.c:6:3353; CHECK-NEXT: WIDEN ir<%psd> = add nuw nsw ir<%lsd>, ir<23>, !dbg /tmp/s.c:7:3354; CHECK-NEXT: WIDEN ir<%cmp1> = icmp slt ir<%lsd>, ir<100>, !dbg /tmp/s.c:8:3355; CHECK-NEXT: EMIT vp<[[NOT1:%.+]]> = not ir<%cmp1>, !dbg /tmp/s.c:9:3356; CHECK-NEXT: WIDEN ir<%cmp2> = icmp sge ir<%lsd>, ir<200>, !dbg /tmp/s.c:10:3357; CHECK-NEXT: EMIT vp<[[SEL1:%.+]]> = logical-and vp<[[NOT1]]>, ir<%cmp2>, !dbg /tmp/s.c:11:3358; CHECK-NEXT: EMIT vp<[[OR1:%.+]]> = or vp<[[SEL1]]>, ir<%cmp1>359; CHECK-NEXT: Successor(s): pred.sdiv360; CHECK-EMPTY:361; CHECK-NEXT: <xVFxUF> pred.sdiv: {362; CHECK-NEXT: pred.sdiv.entry:363; CHECK-NEXT: BRANCH-ON-MASK vp<[[OR1]]>364; CHECK-NEXT: Successor(s): pred.sdiv.if, pred.sdiv.continue365; CHECK-EMPTY:366; CHECK-NEXT: pred.sdiv.if:367; CHECK-NEXT: REPLICATE ir<%sd1> = sdiv ir<%psd>, ir<%lsd> (S->V), !dbg /tmp/s.c:12:3368; CHECK-NEXT: Successor(s): pred.sdiv.continue369; CHECK-EMPTY:370; CHECK-NEXT: pred.sdiv.continue:371; CHECK-NEXT: PHI-PREDICATED-INSTRUCTION vp<[[PHI:%.+]]> = ir<%sd1>, !dbg /tmp/s.c:12:3372; CHECK-NEXT: No successors373; CHECK-NEXT: }374; CHECK-NEXT: Successor(s): if.then.0375; CHECK-EMPTY:376; CHECK-NEXT: if.then.0:377; CHECK-NEXT: BLEND ir<%ysd.0> = ir<%psd> vp<[[PHI]]>/vp<[[OR1]]>, !dbg /tmp/s.c:14:3378; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%isd>, !dbg /tmp/s.c:15:3379; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%ysd.0>, !dbg /tmp/s.c:15:3380; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>381; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>382; CHECK-NEXT: No successors383; CHECK-NEXT:}384; CHECK-NEXT: Successor(s): middle.block385; CHECK-EMPTY:386; CHECK-NEXT: middle.block:387; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<128>, vp<[[VTC]]>388; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>389; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph390; CHECK-EMPTY:391; CHECK-NEXT: ir-bb<exit>392; CHECK-NEXT: No successors393; CHECK-EMPTY:394; CHECK-NEXT: scalar.ph:395; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]396; CHECK-NEXT: Successor(s): ir-bb<loop>397; CHECK-EMPTY:398; CHECK-NEXT: ir-bb<loop>:399; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %if.end ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)400; CHECK: IR %cmp1 = icmp slt i32 %lsd, 100401; CHECK-NEXT: No successors402; CHECK-NEXT:}403;404entry:405 br label %loop406 407loop:408 %iv = phi i64 [ 0, %entry ], [ %iv.next, %if.end ]409 %isd = getelementptr inbounds i32, ptr %src, i64 %iv, !dbg !7410 %lsd = load i32, ptr %isd, align 4, !dbg !8411 %psd = add nuw nsw i32 %lsd, 23, !dbg !9412 %cmp1 = icmp slt i32 %lsd, 100, !dbg !10413 br i1 %cmp1, label %if.then, label %check, !dbg !11414 415check:416 %cmp2 = icmp sge i32 %lsd, 200, !dbg !12417 br i1 %cmp2, label %if.then, label %if.end, !dbg !13418 419if.then:420 %sd1 = sdiv i32 %psd, %lsd, !dbg !14421 br label %if.end422 423if.end:424 %ysd.0 = phi i32 [ %sd1, %if.then ], [ %psd, %check ], !dbg !16425 store i32 %ysd.0, ptr %isd, align 4, !dbg !17426 %iv.next = add nuw nsw i64 %iv, 1427 %exitcond = icmp eq i64 %iv.next, 128428 br i1 %exitcond, label %exit, label %loop429 430exit:431 ret void432}433 434declare float @llvm.sqrt.f32(float) nounwind readnone435declare float @llvm.fmuladd.f32(float, float, float)436 437define void @print_expand_scev(i64 %y, ptr %ptr) {438; CHECK-LABEL: Checking a loop in 'print_expand_scev'439; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {440; CHECK-NEXT: Live-in vp<[[VF:%.*]]> = VF441; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF442; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count443; CHECK-NEXT: vp<[[TC:%.+]]> = original trip-count444; CHECK-EMPTY:445; CHECK-NEXT: ir-bb<entry>:446; CHECK-NEXT: IR %div = udiv i64 %y, 492802768830814060447; CHECK-NEXT: IR %inc = add i64 %div, 1448; CHECK-NEXT: EMIT vp<[[TC]]> = EXPAND SCEV (1 + ((15 + (%y /u 492802768830814060))<nuw><nsw> /u (1 + (%y /u 492802768830814060))<nuw><nsw>))<nuw><nsw>449; CHECK-NEXT: EMIT vp<[[EXP_SCEV:%.+]]> = EXPAND SCEV (1 + (%y /u 492802768830814060))<nuw><nsw>450; CHECK-NEXT: Successor(s): scalar.ph, vector.ph451; CHECK-EMPTY:452; CHECK-NEXT: vector.ph:453; CHECK-NEXT: vp<[[IV_END:%.+]]> = DERIVED-IV ir<0> + vp<[[VTC]]> * vp<[[EXP_SCEV]]>454; CHECK-NEXT: Successor(s): vector loop455; CHECK-EMPTY:456; CHECK-NEXT: <x1> vector loop: {457; CHECK-NEXT: vector.body:458; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>459; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, vp<[[EXP_SCEV]]>, vp<[[VF]]> (truncated to i8)460; CHECK-NEXT: vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * vp<[[EXP_SCEV]]>461; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, vp<[[EXP_SCEV]]>462; CHECK-NEXT: WIDEN ir<%v3> = add nuw ir<%iv>, ir<1>463; CHECK-NEXT: REPLICATE ir<%gep> = getelementptr inbounds ir<%ptr>, vp<[[STEPS]]>464; CHECK-NEXT: REPLICATE store ir<%v3>, ir<%gep>465; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>466; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>467; CHECK-NEXT: No successors468; CHECK-NEXT: }469; CHECK-NEXT: Successor(s): middle.block470; CHECK-EMPTY:471; CHECK-NEXT: middle.block:472; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq vp<[[TC]]>, vp<[[VTC]]>473; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>474; CHECK-NEXT: Successor(s): ir-bb<loop.exit>, scalar.ph475; CHECK-EMPTY:476; CHECK-NEXT: ir-bb<loop.exit>477; CHECK-NEXT: No successors478; CHECK-EMPTY:479; CHECK-NEXT: scalar.ph480; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[IV_END]]>, middle.block ], [ ir<0>, ir-bb<entry> ]481; CHECK-NEXT: Successor(s): ir-bb<loop>482; CHECK-EMPTY:483; CHECK-NEXT: ir-bb<loop>:484; CHECK-NEXT: IR %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)485; CHECK: IR %iv.next = add i64 %iv, %inc486; CHECK-NEXT: No successors487; CHECK-NEXT: }488;489entry:490 %div = udiv i64 %y, 492802768830814060491 %inc = add i64 %div, 1492 br label %loop493 494loop: ; preds = %loop, %entry495 %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]496 %v2 = trunc i64 %iv to i8497 %v3 = add nuw i8 %v2, 1498 %gep = getelementptr inbounds i8, ptr %ptr, i64 %iv499 store i8 %v3, ptr %gep500 501 %cmp15 = icmp slt i8 %v3, 10000502 %iv.next = add i64 %iv, %inc503 br i1 %cmp15, label %loop, label %loop.exit504 505loop.exit:506 ret void507}508 509define i32 @print_exit_value(ptr %ptr, i32 %off) {510; CHECK-LABEL: Checking a loop in 'print_exit_value'511; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {512; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF513; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF514; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count515; CHECK-NEXT: Live-in ir<1000> = original trip-count516; CHECK-EMPTY:517; CHECK-NEXT: ir-bb<entry>:518; CHECK-NEXT: Successor(s): scalar.ph, vector.ph519; CHECK-EMPTY:520; CHECK-NEXT: vector.ph:521; CHECK-NEXT: Successor(s): vector loop522; CHECK-EMPTY:523; CHECK-NEXT: <x1> vector loop: {524; CHECK-NEXT: vector.body:525; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>526; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VF]]>527; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>528; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%ptr>, vp<[[STEPS]]>529; CHECK-NEXT: WIDEN ir<%add> = add ir<%iv>, ir<%off>530; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep>531; CHECK-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<0>532; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>533; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>534; CHECK-NEXT: No successors535; CHECK-NEXT: }536; CHECK-NEXT: Successor(s): middle.block537; CHECK-EMPTY:538; CHECK-NEXT: middle.block:539; CHECK-NEXT: EMIT vp<[[EXIT:%.+]]> = extract-last-element ir<%add>540; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<1000>, vp<[[VTC]]>541; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>542; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph543; CHECK-EMPTY:544; CHECK-NEXT: ir-bb<exit>545; CHECK-NEXT: IR %lcssa = phi i32 [ %add, %loop ] (extra operand: vp<[[EXIT]]> from middle.block)546; CHECK-NEXT: No successors547; CHECK-EMPTY:548; CHECK-NEXT: scalar.ph549; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]550; CHECK-NEXT: Successor(s): ir-bb<loop>551; CHECK-EMPTY:552; CHECK-NEXT: ir-bb<loop>:553; CHECK-NEXT: IR %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)554; CHECK: IR %ec = icmp eq i32 %iv.next, 1000555; CHECK-NEXT: No successors556; CHECK-NEXT: }557;558entry:559 br label %loop560 561loop:562 %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]563 %gep = getelementptr inbounds i8, ptr %ptr, i32 %iv564 %add = add i32 %iv, %off565 store i8 0, ptr %gep566 %iv.next = add nsw i32 %iv, 1567 %ec = icmp eq i32 %iv.next, 1000568 br i1 %ec, label %exit, label %loop569 570exit:571 %lcssa = phi i32 [ %add, %loop ]572 ret i32 %lcssa573}574 575define void @print_fast_math_flags(i64 %n, ptr noalias %y, ptr noalias %x, ptr %z) {576; CHECK-LABEL: Checking a loop in 'print_fast_math_flags'577; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {578; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF579; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF580; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count581; CHECK-NEXT: Live-in ir<%n> = original trip-count582; CHECK-EMPTY:583; CHECK-NEXT: ir-bb<entry>:584; CHECK-NEXT: Successor(s): scalar.ph, vector.ph585; CHECK-EMPTY:586; CHECK-NEXT: vector.ph:587; CHECK-NEXT: Successor(s): vector loop588; CHECK-EMPTY:589; CHECK-NEXT: <x1> vector loop: {590; CHECK-NEXT: vector.body:591; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>592; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>593; CHECK-NEXT: CLONE ir<%gep.y> = getelementptr inbounds ir<%y>, vp<[[STEPS]]>594; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.y>595; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VEC_PTR]]>596; CHECK-NEXT: WIDEN ir<%add> = fadd nnan ir<%lv>, ir<1.000000e+00>597; CHECK-NEXT: WIDEN ir<%mul> = fmul fast ir<%add>, ir<2.000000e+00>598; CHECK-NEXT: WIDEN ir<%div> = fdiv reassoc nsz contract ir<%mul>, ir<2.000000e+00>599; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>600; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.x>601; CHECK-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<%div>602; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>603; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>604; CHECK-NEXT: No successors605; CHECK-NEXT: }606; CHECK-NEXT: Successor(s): middle.block607; CHECK-EMPTY:608; CHECK-NEXT: middle.block:609; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>610; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>611; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph612; CHECK-EMPTY:613; CHECK-NEXT: ir-bb<exit>614; CHECK-NEXT: No successors615; CHECK-EMPTY:616; CHECK-NEXT: scalar.ph617; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]618; CHECK-NEXT: Successor(s): ir-bb<loop>619; CHECK-EMPTY:620; CHECK-NEXT: ir-bb<loop>:621; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]622; CHECK: IR %exitcond = icmp eq i64 %iv.next, %n623; CHECK-NEXT: No successors624; CHECK-NEXT: }625;626entry:627 br label %loop628 629loop:630 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]631 %gep.y = getelementptr inbounds float, ptr %y, i64 %iv632 %lv = load float, ptr %gep.y, align 4633 %add = fadd nnan float %lv, 1.0634 %mul = fmul fast float %add, 2.0635 %div = fdiv nsz reassoc contract float %mul, 2.0636 %gep.x = getelementptr inbounds float, ptr %x, i64 %iv637 store float %div, ptr %gep.x, align 4638 %iv.next = add i64 %iv, 1639 %exitcond = icmp eq i64 %iv.next, %n640 br i1 %exitcond, label %exit, label %loop641 642exit:643 ret void644}645 646define void @print_exact_flags(i64 %n, ptr noalias %x) {647; CHECK-LABEL: Checking a loop in 'print_exact_flags'648; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {649; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF650; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF651; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count652; CHECK-NEXT: Live-in ir<%n> = original trip-count653; CHECK-EMPTY:654; CHECK-NEXT: ir-bb<entry>:655; CHECK-NEXT: Successor(s): scalar.ph, vector.ph656; CHECK-EMPTY:657; CHECK-NEXT: vector.ph:658; CHECK-NEXT: Successor(s): vector loop659; CHECK-EMPTY:660; CHECK-NEXT: <x1> vector loop: {661; CHECK-NEXT: vector.body:662; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>663; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>664; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>665; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.x>666; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VEC_PTR]]>667; CHECK-NEXT: WIDEN ir<%div.1> = udiv exact ir<%lv>, ir<20>668; CHECK-NEXT: WIDEN ir<%div.2> = udiv ir<%lv>, ir<60>669; CHECK-NEXT: WIDEN ir<%add> = add nuw nsw ir<%div.1>, ir<%div.2>670; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%gep.x>671; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%add>672; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>673; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>674; CHECK-NEXT: No successors675; CHECK-NEXT: }676; CHECK-NEXT: Successor(s): middle.block677; CHECK-EMPTY:678; CHECK-NEXT: middle.block:679; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>680; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>681; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph682; CHECK-EMPTY:683; CHECK-NEXT: ir-bb<exit>684; CHECK-NEXT: No successors685; CHECK-EMPTY:686; CHECK-NEXT: scalar.ph687; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]688; CHECK-NEXT: Successor(s): ir-bb<loop>689; CHECK-EMPTY:690; CHECK-NEXT: ir-bb<loop>:691; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)692; CHECK: IR %exitcond = icmp eq i64 %iv.next, %n693; CHECK-NEXT: No successors694; ; CHECK-NEXT: }695;696entry:697 br label %loop698 699loop:700 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]701 %gep.x = getelementptr inbounds i32, ptr %x, i64 %iv702 %lv = load i32, ptr %gep.x, align 4703 %div.1 = udiv exact i32 %lv, 20704 %div.2 = udiv i32 %lv, 60705 %add = add nsw nuw i32 %div.1, %div.2706 store i32 %add, ptr %gep.x, align 4707 %iv.next = add i64 %iv, 1708 %exitcond = icmp eq i64 %iv.next, %n709 br i1 %exitcond, label %exit, label %loop710 711exit:712 ret void713}714 715define void @print_call_flags(ptr readonly %src, ptr noalias %dest, i64 %n) {716; CHECK-LABEL: Checking a loop in 'print_call_flags'717; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {718; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF719; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF720; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count721; CHECK-NEXT: Live-in ir<%n> = original trip-count722; CHECK-EMPTY:723; CHECK-NEXT: ir-bb<entry>:724; CHECK-NEXT: Successor(s): scalar.ph, vector.ph725; CHECK-EMPTY:726; CHECK-NEXT: vector.ph:727; CHECK-NEXT: Successor(s): vector loop728; CHECK-EMPTY:729; CHECK-NEXT: <x1> vector loop: {730; CHECK-NEXT: vector.body:731; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>732; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>733; CHECK-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%src>, vp<[[STEPS]]>734; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%ld.addr>735; CHECK-NEXT: WIDEN ir<%ld.value> = load vp<[[VEC_PTR]]>736; CHECK-NEXT: WIDEN ir<%ifcond> = fcmp oeq ir<%ld.value>, ir<5.000000e+00>737; CHECK-NEXT: Successor(s): pred.call738; CHECK-EMPTY:739; CHECK-NEXT: <xVFxUF> pred.call: {740; CHECK-NEXT: pred.call.entry:741; CHECK-NEXT: BRANCH-ON-MASK ir<%ifcond>742; CHECK-NEXT: Successor(s): pred.call.if, pred.call.continue743; CHECK-EMPTY:744; CHECK-NEXT: pred.call.if:745; CHECK-NEXT: REPLICATE ir<%foo.ret.1> = call nnan ninf nsz @foo(ir<%ld.value>) (S->V)746; CHECK-NEXT: REPLICATE ir<%foo.ret.2> = call @foo(ir<%ld.value>) (S->V)747; CHECK-NEXT: Successor(s): pred.call.continue748; CHECK-EMPTY:749; CHECK-NEXT: pred.call.continue:750; CHECK-NEXT: PHI-PREDICATED-INSTRUCTION vp<[[PHI1:%.+]]> = ir<%foo.ret.1>751; CHECK-NEXT: PHI-PREDICATED-INSTRUCTION vp<[[PHI2:%.+]]> = ir<%foo.ret.2>752; CHECK-NEXT: No successors753; CHECK-NEXT: }754; CHECK-NEXT: Successor(s): if.then.1755; CHECK-EMPTY:756; CHECK-NEXT: if.then.1:757; CHECK-NEXT: WIDEN ir<%fadd> = fadd vp<[[PHI1]]>, vp<[[PHI2]]>758; CHECK-NEXT: BLEND ir<%st.value> = ir<%ld.value> ir<%fadd>/ir<%ifcond>759; CHECK-NEXT: CLONE ir<%st.addr> = getelementptr inbounds ir<%dest>, vp<[[STEPS]]>760; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%st.addr>761; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%st.value>762; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>763; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>764; CHECK-NEXT: No successors765; CHECK-NEXT: }766; CHECK-NEXT: Successor(s): middle.block767; CHECK-EMPTY:768; CHECK-NEXT: middle.block:769; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>770; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>771; CHECK-NEXT: Successor(s): ir-bb<end>, scalar.ph772; CHECK-EMPTY:773; CHECK-NEXT: ir-bb<end>774; CHECK-NEXT: No successors775; CHECK-EMPTY:776; CHECK-NEXT: scalar.ph777; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]778; CHECK-NEXT: Successor(s): ir-bb<for.body>779; CHECK-EMPTY:780; CHECK-NEXT: ir-bb<for.body>:781; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)782; CHECK: IR %ifcond = fcmp oeq float %ld.value, 5.0783; CHECK-NEXT: No successors784; CHECK-NEXT: }785;786entry:787 br label %for.body788 789for.body:790 %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.loop ]791 %ld.addr = getelementptr inbounds float, ptr %src, i64 %iv792 %ld.value = load float , ptr %ld.addr, align 8793 %ifcond = fcmp oeq float %ld.value, 5.0794 br i1 %ifcond, label %if.then, label %for.loop795 796if.then:797 %foo.ret.1 = call nnan nsz ninf float @foo(float %ld.value) #0798 %foo.ret.2 = call float @foo(float %ld.value) #0799 %fadd = fadd float %foo.ret.1, %foo.ret.2800 br label %for.loop801 802for.loop:803 %st.value = phi float [ %ld.value, %for.body ], [ %fadd, %if.then ]804 %st.addr = getelementptr inbounds float, ptr %dest, i64 %iv805 store float %st.value, ptr %st.addr, align 8806 %iv.next = add nsw nuw i64 %iv, 1807 %loopcond = icmp eq i64 %iv.next, %n808 br i1 %loopcond, label %end, label %for.body809 810end:811 ret void812}813 814; FIXME: Preserve disjoint flag on OR recipe.815define void @print_disjoint_flags(i64 %n, ptr noalias %x) {816; CHECK-LABEL: Checking a loop in 'print_disjoint_flags'817; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {818; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF819; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF820; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count821; CHECK-NEXT: Live-in ir<%n> = original trip-count822; CHECK-EMPTY:823; CHECK-NEXT: ir-bb<entry>:824; CHECK-NEXT: Successor(s): scalar.ph, vector.ph825; CHECK-EMPTY:826; CHECK-NEXT: vector.ph:827; CHECK-NEXT: Successor(s): vector loop828; CHECK-EMPTY:829; CHECK-NEXT: <x1> vector loop: {830; CHECK-NEXT: vector.body:831; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>832; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>833; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[STEPS]]>834; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.x>835; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VEC_PTR]]>836; CHECK-NEXT: WIDEN ir<%or.1> = or disjoint ir<%lv>, ir<1>837; CHECK-NEXT: WIDEN ir<%or.2> = or ir<%lv>, ir<3>838; CHECK-NEXT: WIDEN ir<%add> = add nuw nsw ir<%or.1>, ir<%or.2>839; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.x>840; CHECK-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<%add>841; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>842; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>843; CHECK-NEXT: No successors844; CHECK-NEXT: }845; CHECK-NEXT: Successor(s): middle.block846; CHECK-EMPTY:847; CHECK-NEXT: middle.block:848; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<%n>, vp<[[VTC]]>849; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>850; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph851; CHECK-EMPTY:852; CHECK-NEXT: ir-bb<exit>853; CHECK-NEXT: No successors854; CHECK-EMPTY:855; CHECK-NEXT: scalar.ph856; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]857; CHECK-NEXT: Successor(s): ir-bb<loop>858; CHECK-EMPTY:859; CHECK-NEXT: ir-bb<loop>:860; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)861; CHECK: IR %exitcond = icmp eq i64 %iv.next, %n862; CHECK-NEXT: No successors863; CHECK-NEXT: }864;865entry:866 br label %loop867 868loop:869 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]870 %gep.x = getelementptr inbounds i32, ptr %x, i64 %iv871 %lv = load i32, ptr %gep.x, align 4872 %or.1 = or disjoint i32 %lv, 1873 %or.2 = or i32 %lv, 3874 %add = add nsw nuw i32 %or.1, %or.2875 store i32 %add, ptr %gep.x, align 4876 %iv.next = add i64 %iv, 1877 %exitcond = icmp eq i64 %iv.next, %n878 br i1 %exitcond, label %exit, label %loop879 880exit:881 ret void882}883 884define void @zext_nneg(ptr noalias %p, ptr noalias %p1) {885; CHECK-LABEL: LV: Checking a loop in 'zext_nneg'886; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {887; CHECK-NEXT: Live-in vp<[[VF:%.]]> = VF888; CHECK-NEXT: Live-in vp<[[VFxUF:%.]]> = VF * UF889; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count890; CHECK-NEXT: Live-in ir<1000> = original trip-count891; CHECK-EMPTY:892; CHECK-NEXT: ir-bb<entry>:893; CHECK-NEXT: Successor(s): scalar.ph, vector.ph894; CHECK-EMPTY:895; CHECK-NEXT: vector.ph:896; CHECK-NEXT: Successor(s): vector loop897; CHECK-EMPTY:898; CHECK-NEXT: <x1> vector loop: {899; CHECK-NEXT: vector.body:900; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[CAN_IV_NEXT:%.+]]>901; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>902; CHECK-NEXT: CLONE ir<%idx> = getelementptr ir<%p>, vp<[[STEPS]]>903; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer ir<%idx>904; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VEC_PTR]]>905; CHECK-NEXT: WIDEN-CAST ir<%zext> = zext nneg ir<%l>906; CHECK-NEXT: EMIT vp<[[EXT:%.+]]> = extract-last-element ir<%zext>907; CHECK-NEXT: CLONE store vp<[[EXT]]>, ir<%p1>908; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT]]> = add nuw vp<[[CAN_IV]]>909; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>910; CHECK-NEXT: No successors911; CHECK-NEXT: }912;913entry:914 br label %body915 916body:917 %iv = phi i64 [ %next, %body ], [ 0, %entry ]918 %idx = getelementptr i32, ptr %p, i64 %iv919 %l = load i32, ptr %idx, align 8920 %zext = zext nneg i32 %l to i64921 store i64 %zext, ptr %p1, align 8922 %next = add i64 %iv, 1923 %cmp = icmp eq i64 %next, 1000924 br i1 %cmp, label %exit, label %body925 926exit:927 ret void928}929 930define i16 @print_first_order_recurrence_and_result(ptr %ptr) {931; CHECK-LABEL: 'print_first_order_recurrence_and_result'932; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {933; CHECK-NEXT: Live-in vp<[[VF:%.+]]> = VF934; CHECK-NEXT: Live-in vp<[[VFxUF:%.+]]> = VF * UF935; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count936; CHECK-NEXT: Live-in ir<1000> = original trip-count937; CHECK-EMPTY:938; CHECK-NEXT: ir-bb<entry>:939; CHECK-NEXT: Successor(s): scalar.ph, vector.ph940; CHECK-EMPTY:941; CHECK-NEXT: vector.ph:942; CHECK-NEXT: Successor(s): vector loop943; CHECK-EMPTY:944; CHECK-NEXT: <x1> vector loop: {945; CHECK-NEXT: vector.body:946; CHECK-NEXT: EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION947; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>948; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>949; CHECK-NEXT: CLONE ir<%gep.ptr> = getelementptr inbounds ir<%ptr>, vp<[[STEPS]]>950; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds ir<%gep.ptr>951; CHECK-NEXT: WIDEN ir<%for.1.next> = load vp<[[VEC_PTR]]>952; CHECK-NEXT: EMIT vp<[[FOR1_SPLICE:%.+]]> = first-order splice ir<%for.1>, ir<%for.1.next>953; CHECK-NEXT: WIDEN ir<%add> = add vp<[[FOR1_SPLICE]]>, ir<1>954; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds ir<%gep.ptr>955; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%add>956; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>957; CHECK-NEXT: EMIT branch-on-count vp<[[CAN_IV_NEXT]]>, vp<[[VTC]]>958; CHECK-NEXT: No successors959; CHECK-NEXT: }960; CHECK-NEXT: Successor(s): middle.block961; CHECK-EMPTY:962; CHECK-NEXT: middle.block:963; CHECK-NEXT: EMIT vp<[[RESUME_1:%.+]]> = extract-last-element ir<%for.1.next>964; CHECK-NEXT: EMIT vp<[[FOR_RESULT:%.+]]> = extract-penultimate-element ir<%for.1.next>965; CHECK-NEXT: EMIT vp<[[CMP:%.+]]> = icmp eq ir<1000>, vp<[[VTC]]>966; CHECK-NEXT: EMIT branch-on-cond vp<[[CMP]]>967; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph968; CHECK-EMPTY:969; CHECK-NEXT: ir-bb<exit>970; CHECK-NEXT: IR %for.1.lcssa = phi i16 [ %for.1, %loop ] (extra operand: vp<[[FOR_RESULT]]> from middle.block)971; CHECK-NEXT: No successors972; CHECK-EMPTY:973; CHECK-NEXT: scalar.ph974; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_P:%.*]]> = phi [ vp<[[RESUME_1]]>, middle.block ], [ ir<22>, ir-bb<entry> ]975; CHECK-NEXT: EMIT-SCALAR vp<[[RESUME_IV:%.+]]> = phi [ vp<[[VTC]]>, middle.block ], [ ir<0>, ir-bb<entry> ]976; CHECK-NEXT: Successor(s): ir-bb<loop>977; CHECK-EMPTY:978; CHECK-NEXT: ir-bb<loop>:979; CHECK-NEXT: IR %for.1 = phi i16 [ 22, %entry ], [ %for.1.next, %loop ] (extra operand: vp<[[RESUME_P]]> from scalar.ph)980; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<[[RESUME_IV]]> from scalar.ph)981; CHECK: IR %exitcond.not = icmp eq i64 %iv.next, 1000982; CHECK-NEXT: No successors983; CHECK-NEXT: }984;985entry:986 br label %loop987 988loop:989 %for.1 = phi i16 [ 22, %entry ], [ %for.1.next, %loop ]990 %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]991 %iv.next = add nuw nsw i64 %iv, 1992 %gep.ptr = getelementptr inbounds i16, ptr %ptr, i64 %iv993 %for.1.next = load i16, ptr %gep.ptr, align 2994 %add = add i16 %for.1, 1995 store i16 %add, ptr %gep.ptr996 %exitcond.not = icmp eq i64 %iv.next, 1000997 br i1 %exitcond.not, label %exit, label %loop998 999exit:1000 ret i16 %for.11001}1002 1003define void @print_select_with_fastmath_flags(ptr noalias %a, ptr noalias %b, ptr noalias %c, i64 %N) {1004; CHECK-LABEL: 'print_select_with_fastmath_flags'1005; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1'1006; CHECK-NEXT: Live-in vp<[[VF:%.+]]> = VF1007; CHECK-NEXT: Live-in vp<[[VFUF:%.+]]> = VF * UF1008; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count1009; CHECK-NEXT: Live-in ir<%N> = original trip-count1010; CHECK-EMPTY:1011; CHECK-NEXT: ir-bb<entry>:1012; CHECK-NEXT: Successor(s): scalar.ph, vector.ph1013; CHECK-EMPTY:1014; CHECK-NEXT: vector.ph:1015; CHECK-NEXT: Successor(s): vector loop1016; CHECK-EMPTY:1017; CHECK: <x1> vector loop: {1018; CHECK-NEXT: vector.body:1019; CHECK-NEXT: EMIT vp<[[IV:%.+]]> = CANONICAL-INDUCTION ir<0>, vp<[[IV_NEXT_EXIT:%.+]]>1020; CHECK-NEXT: vp<[[ST:%.+]]> = SCALAR-STEPS vp<[[IV]]>, ir<1>, vp<[[VF]]>1021; CHECK-NEXT: CLONE ir<[[GEP1:%.+]]> = getelementptr inbounds nuw ir<%b>, vp<[[ST]]>1022; CHECK-NEXT: vp<[[PTR1:%.+]]> = vector-pointer inbounds nuw ir<[[GEP1]]>1023; CHECK-NEXT: WIDEN ir<[[LD1:%.+]]> = load vp<[[PTR1]]>1024; CHECK-NEXT: CLONE ir<[[GEP2:%.+]]> = getelementptr inbounds nuw ir<%c>, vp<[[ST]]>1025; CHECK-NEXT: vp<[[PTR2:%.+]]> = vector-pointer inbounds nuw ir<[[GEP2]]>1026; CHECK-NEXT: WIDEN ir<[[LD2:%.+]]> = load vp<[[PTR2]]>1027; CHECK-NEXT: WIDEN ir<[[FCMP:%.+]]> = fcmp ogt fast ir<[[LD1]]>, ir<[[LD2]]>1028; CHECK-NEXT: WIDEN ir<[[FADD:%.+]]> = fadd fast ir<[[LD1]]>, ir<1.000000e+01>1029; CHECK-NEXT: WIDEN-SELECT ir<[[SELECT:%.+]]> = select fast ir<[[FCMP]]>, ir<[[FADD]]>, ir<[[LD2]]>1030; CHECK-NEXT: CLONE ir<[[GEP3:%.+]]> = getelementptr inbounds nuw ir<%a>, vp<[[ST]]>1031; CHECK-NEXT: vp<[[PTR3:%.+]]> = vector-pointer inbounds nuw ir<[[GEP3]]>1032; CHECK-NEXT: WIDEN store vp<[[PTR3]]>, ir<[[SELECT]]>1033; CHECK-NEXT: EMIT vp<[[IV_NEXT_EXIT]]> = add nuw vp<[[IV]]>, vp<[[VFUF]]>1034; CHECK-NEXT: EMIT branch-on-count vp<[[IV_NEXT_EXIT]]>, vp<[[VTC]]>1035; CHECK-NEXT: No successors1036; CHECK-NEXT: }1037 1038entry:1039 br label %for.body1040 1041for.body:1042 %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]1043 %gep = getelementptr inbounds nuw float, ptr %b, i64 %iv1044 %0 = load float, ptr %gep, align 41045 %gep3 = getelementptr inbounds nuw float, ptr %c, i64 %iv1046 %1 = load float, ptr %gep3, align 41047 %cmp4 = fcmp fast ogt float %0, %11048 %add = fadd fast float %0, 1.000000e+011049 %cond = select fast i1 %cmp4, float %add, float %11050 %gep11 = getelementptr inbounds nuw float, ptr %a, i64 %iv1051 store float %cond, ptr %gep11, align 41052 %iv.next = add nuw nsw i64 %iv, 11053 %exitcond.not = icmp eq i64 %iv.next, %N1054 br i1 %exitcond.not, label %exit, label %for.body1055 1056exit:1057 ret void1058}1059 1060!llvm.dbg.cu = !{!0}1061!llvm.module.flags = !{!3, !4}1062 1063declare float @foo(float) #01064declare <2 x float> @vector_foo(<2 x float>, <2 x i1>)1065 1066; We need a vector variant in order to allow for vectorization at present, but1067; we want to test scalarization of conditional calls. If we provide a variant1068; with a different number of lanes than the VF we force via1069; "-force-vector-width=4", then it should pass the legality checks but1070; scalarize. TODO: Remove the requirement to have a variant.1071attributes #0 = { readonly nounwind "vector-function-abi-variant"="_ZGV_LLVM_M2v_foo(vector_foo)" }1072 1073!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: NoDebug, enums: !2)1074!1 = !DIFile(filename: "/tmp/s.c", directory: "/tmp")1075!2 = !{}1076!3 = !{i32 2, !"Debug Info Version", i32 3}1077!4 = !{i32 7, !"PIC Level", i32 2}1078!5 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 4, type: !6, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)1079!6 = !DISubroutineType(types: !2)1080!7 = !DILocation(line: 5, column: 3, scope: !5)1081!8 = !DILocation(line: 6, column: 3, scope: !5)1082!9 = !DILocation(line: 7, column: 3, scope: !5)1083!10 = !DILocation(line: 8, column: 3, scope: !5)1084!11 = !DILocation(line: 9, column: 3, scope: !5)1085!12 = !DILocation(line: 10, column: 3, scope: !5)1086!13 = !DILocation(line: 11, column: 3, scope: !5)1087!14 = !DILocation(line: 12, column: 3, scope: !5)1088!15 = !DILocation(line: 13, column: 3, scope: !5)1089!16 = !DILocation(line: 14, column: 3, scope: !5)1090!17 = !DILocation(line: 15, column: 3, scope: !5)1091!18 = !DILocation(line: 16, column: 3, scope: !5)1092!19 = !DILocation(line: 17, column: 3, scope: !5)1093