| ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3 |
| ; RUN: opt -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s |
| ; RUN: opt -disable-output -passes='print<access-info>' -max-forked-scev-depth=2 %s 2>&1 | FileCheck -check-prefix=RECURSE %s |
| |
| target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" |
| |
| define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr %Dest) { |
| ; CHECK-LABEL: 'forked_ptrs_simple' |
| ; CHECK-NEXT: loop: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP1]]): |
| ; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP1]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop> |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop> |
| ; CHECK-NEXT: Group [[GRP2]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop> |
| ; CHECK-NEXT: Group [[GRP3]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_simple' |
| ; RECURSE-NEXT: loop: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; RECURSE-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP4]]): |
| ; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| ; RECURSE-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP4]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop> |
| ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop> |
| ; RECURSE-NEXT: Group [[GRP5]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%loop> |
| ; RECURSE-NEXT: Group [[GRP6]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%loop> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| %l.Dest = load float, ptr %gep.Dest |
| %cmp = fcmp une float %l.Dest, 0.0 |
| %gep.1 = getelementptr inbounds float, ptr %Base1, i64 %iv |
| %gep.2 = getelementptr inbounds float, ptr %Base2, i64 %iv |
| %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| %sink = load float, ptr %select, align 4 |
| store float %sink, ptr %gep.Dest, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, 100 |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| ;; We have a limit on the recursion depth for finding a loop invariant or |
| ;; addrec term; confirm we won't exceed that depth by forcing a lower |
| ;; limit via -max-forked-scev-depth=2 |
| |
| ;;;; Derived from the following C code |
| ;; void forked_ptrs_different_base_same_offset(float *A, float *B, float *C, int *D) { |
| ;; for (int i=0; i<100; i++) { |
| ;; if (D[i] != 0) { |
| ;; C[i] = A[i]; |
| ;; } else { |
| ;; C[i] = B[i]; |
| ;; } |
| ;; } |
| ;; } |
| |
| define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_different_base_same_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP7]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP7]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP7]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP8]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP9]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP10]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP11]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP13:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP11]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP14:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP11]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP12]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP13]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP14]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| %.sink = load float, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %.sink, ptr %1, align 4 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_64b' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP15:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP16:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP15]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP17:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP15]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP18:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP15]]: |
| ; CHECK-NEXT: (Low: %Dest High: (800 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP16]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP17]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP18]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_64b' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP19:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP20:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP19]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP21:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP19]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP22:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP19]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,8}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP20]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP21]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,8}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP22]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,8}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv |
| %.sink = load double, ptr %.sink.in, align 8 |
| %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv |
| store double %.sink, ptr %1, align 8 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_23b' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP23:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP24:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP23]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP25:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP23]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP26:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP23]]: |
| ; CHECK-NEXT: (Low: %Dest High: (399 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP24]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP25]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP26]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_23b' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP27:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP28:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP27]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP29:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP27]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP30:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP27]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP28]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP29]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP30]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv |
| %.sink = load i23, ptr %.sink.in |
| %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv |
| store i23 %.sink, ptr %1 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_6b' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP31:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP32:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP31]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP33:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP31]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP34:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP31]]: |
| ; CHECK-NEXT: (Low: %Dest High: (100 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP32]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP33]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP34]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_6b' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP35:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP36:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP35]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP37:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP35]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP38:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP35]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,1}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP36]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP37]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,1}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP38]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,1}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv |
| %.sink = load i6, ptr %.sink.in |
| %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv |
| store i6 %.sink, ptr %1 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds, i1 %c) { |
| ; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_possible_poison' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP39:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP40:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP39]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP41:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP39]]): |
| ; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP42:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP39]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP40]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP41]]: |
| ; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP42]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_possible_poison' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP43:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP44:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP43]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP45:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP43]]): |
| ; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP46:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP43]]: |
| ; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; RECURSE-NEXT: Member: {%Dest,+,4}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP44]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP45]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP46]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) |
| ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %latch ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv |
| %.sink = load float, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| br i1 %c, label %then, label %latch |
| |
| then: |
| store float %.sink, ptr %1, align 4 |
| br label %latch |
| |
| latch: |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;;;; Derived from the following C code |
| ;; void forked_ptrs_same_base_different_offset(float *A, float *B, int *C) { |
| ;; int offset; |
| ;; for (int i = 0; i < 100; i++) { |
| ;; if (C[i] != 0) |
| ;; offset = i; |
| ;; else |
| ;; offset = i+1; |
| ;; B[i] = A[offset]; |
| ;; } |
| ;; } |
| |
| define dso_local void @forked_ptrs_same_base_different_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_same_base_different_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_same_base_different_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %i.014 = phi i32 [ 0, %entry ], [ %add, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %add = add nuw nsw i32 %i.014, 1 |
| %1 = trunc i64 %indvars.iv to i32 |
| %offset.0 = select i1 %cmp1.not, i32 %add, i32 %1 |
| %idxprom213 = zext i32 %offset.0 to i64 |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %idxprom213 |
| %2 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %2, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) { |
| ; CHECK-LABEL: 'forked_ptrs_add_to_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP47:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP48:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP47]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP49:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP47]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP48]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP49]]: |
| ; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base)) |
| ; CHECK-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body> |
| ; CHECK-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_add_to_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv |
| %offset = add nuw nsw i64 %sel, %extra_offset |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| %1 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %1, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) { |
| ; CHECK-LABEL: 'forked_ptrs_sub_from_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP50:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP51:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP50]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP52:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP50]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP51]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP52]]: |
| ; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base)) |
| ; CHECK-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body> |
| ; CHECK-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_sub_from_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv |
| %offset = sub nuw nsw i64 %sel, %extra_offset |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| %1 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %1, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %to_add, i64 %to_sub) { |
| ; CHECK-LABEL: 'forked_ptrs_add_sub_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP53:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP54:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP53]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP55:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP53]]: |
| ; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) |
| ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP54]]: |
| ; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP55]]: |
| ; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base)) |
| ; CHECK-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body> |
| ; CHECK-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_add_sub_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv |
| %add = add nuw nsw i64 %sel, %to_add |
| %offset = sub nuw nsw i64 %add, %to_sub |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| %1 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %1, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;;;; Cases that can be handled by a forked pointer but are not currently allowed. |
| |
| define dso_local void @forked_ptrs_mul_by_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) { |
| ; CHECK-LABEL: 'forked_ptrs_mul_by_offset' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_mul_by_offset' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv |
| %offset = mul nuw nsw i64 %sel, %extra_offset |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset |
| %1 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %1, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;;;; Derived from forked_ptrs_same_base_different_offset with a manually |
| ;;;; added uniform offset and a mul to provide a stride |
| |
| define dso_local void @forked_ptrs_uniform_and_strided_forks(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_uniform_and_strided_forks' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_uniform_and_strided_forks' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %i.014 = phi i32 [ 0, %entry ], [ %add, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %add = add nuw nsw i32 %i.014, 1 |
| %1 = trunc i64 %indvars.iv to i32 |
| %mul = mul i32 %1, 3 |
| %offset.0 = select i1 %cmp1.not, i32 4, i32 %mul |
| %idxprom213 = sext i32 %offset.0 to i64 |
| %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %idxprom213 |
| %2 = load float, ptr %arrayidx3, align 4 |
| %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %2, ptr %arrayidx5, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;;;; Derived from forked_ptrs_same_base_different_offset with a gather |
| ;;;; added using Preds as an index array in addition to the per-iteration |
| ;;;; condition. |
| |
| define dso_local void @forked_ptrs_gather_and_contiguous_forks(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_gather_and_contiguous_forks' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_gather_and_contiguous_forks' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.body |
| ret void |
| |
| for.body: ; preds = %entry, %for.body |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %arrayidx9 = getelementptr inbounds float, ptr %Base2, i64 %indvars.iv |
| %idxprom4 = sext i32 %0 to i64 |
| %arrayidx5 = getelementptr inbounds float, ptr %Base1, i64 %idxprom4 |
| %.sink.in = select i1 %cmp1.not, ptr %arrayidx9, ptr %arrayidx5 |
| %.sink = load float, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %.sink, ptr %1, align 4 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;; We don't currently handle a fork in both the base and the offset of a |
| ;; GEP instruction. |
| |
| define dso_local void @forked_ptrs_two_forks_gep(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_two_forks_gep' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_two_forks_gep' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %offset = select i1 %cmp1.not, i64 %indvars.iv.next, i64 %indvars.iv |
| %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %offset |
| %.sink = load float, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %.sink, ptr %1, align 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ;; We don't handle forks as children of a select |
| |
| define void @forked_ptrs_two_select(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture readonly %Base3, ptr %Dest) { |
| ; CHECK-LABEL: 'forked_ptrs_two_select' |
| ; CHECK-NEXT: loop: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_two_select' |
| ; RECURSE-NEXT: loop: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %loop |
| |
| loop: |
| %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv |
| %l.Dest = load float, ptr %gep.Dest |
| %cmp = fcmp une float %l.Dest, 0.0 |
| %cmp1 = fcmp une float %l.Dest, 1.0 |
| %gep.1 = getelementptr inbounds float, ptr %Base1, i64 %iv |
| %gep.2 = getelementptr inbounds float, ptr %Base2, i64 %iv |
| %gep.3 = getelementptr inbounds float, ptr %Base3, i64 %iv |
| %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 |
| %select1 = select i1 %cmp1, ptr %select, ptr %gep.3 |
| %sink = load float, ptr %select1, align 4 |
| store float %sink, ptr %gep.Dest, align 4 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond.not = icmp eq i64 %iv.next, 100 |
| br i1 %exitcond.not, label %exit, label %loop |
| |
| exit: |
| ret void |
| } |
| |
| ;; We don't yet handle geps with more than 2 operands |
| |
| define void @forked_ptrs_too_many_gep_ops(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_too_many_gep_ops' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_too_many_gep_ops' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds [1000 x float], ptr %spec.select, i64 0, i64 %indvars.iv |
| %.sink = load float, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv |
| store float %.sink, ptr %1, align 4 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| } |
| |
| ;; We don't currently handle vector GEPs |
| |
| define void @forked_ptrs_vector_gep(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) { |
| ; CHECK-LABEL: 'forked_ptrs_vector_gep' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_vector_gep' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| br label %for.body |
| |
| for.body: |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %0 = load i32, ptr %arrayidx, align 4 |
| %cmp1.not = icmp eq i32 %0, 0 |
| %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1 |
| %.sink.in = getelementptr inbounds <4 x float>, ptr %spec.select, i64 %indvars.iv |
| %.sink = load <4 x float>, ptr %.sink.in, align 4 |
| %1 = getelementptr inbounds <4 x float>, ptr %Dest, i64 %indvars.iv |
| store <4 x float> %.sink, ptr %1, align 4 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 4 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 100 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| |
| for.cond.cleanup: |
| ret void |
| } |
| |
| ;;; The following test caused an ICE with the initial forked pointers work. |
| ;;; One fork is loop invariant (%Base2 + 0), the other is an scAddExpr that |
| ;;; contains an scAddRecExpr inside it: |
| ;;; ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw> |
| ;;; |
| ;;; RtCheck::insert was expecting either loop invariant or SAR, so asserted |
| ;;; on a plain scAddExpr. For now we restrict to loop invariant or SAR |
| ;;; forks only, but we should be able to do better. |
| |
| define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) { |
| ; CHECK-LABEL: 'sc_add_expr_ice' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP56:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: ptr %Base1 |
| ; CHECK-NEXT: Against group ([[GRP57:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP56]]: |
| ; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1)) |
| ; CHECK-NEXT: Member: %Base1 |
| ; CHECK-NEXT: Group [[GRP57]]: |
| ; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)) |
| ; CHECK-NEXT: Member: {%Base2,+,8}<%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; CHECK-NEXT: [PSE] %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel: |
| ; CHECK-NEXT: ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw> |
| ; CHECK-NEXT: --> {%Base2,+,8}<%for.body> |
| ; |
| ; RECURSE-LABEL: 'sc_add_expr_ice' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP58:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: ptr %Base1 |
| ; RECURSE-NEXT: Against group ([[GRP59:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP58]]: |
| ; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1)) |
| ; RECURSE-NEXT: Member: %Base1 |
| ; RECURSE-NEXT: Group [[GRP59]]: |
| ; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)) |
| ; RECURSE-NEXT: Member: {%Base2,+,8}<%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-NEXT: {0,+,1}<%for.body> Added Flags: <nusw> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; RECURSE-NEXT: [PSE] %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel: |
| ; RECURSE-NEXT: ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw> |
| ; RECURSE-NEXT: --> {%Base2,+,8}<%for.body> |
| ; |
| entry: |
| br label %for.body |
| |
| for.body: |
| %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ] |
| %iv.trunc = trunc i64 %iv to i32 |
| store double 0.000000e+00, ptr %Base1, align 8 |
| %iv.zext = zext i32 %iv.trunc to i64 |
| %sel = select i1 true, i64 %iv.zext, i64 0 |
| %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel |
| %dummy.load = load double, ptr %fptr, align 8 |
| %iv.next = add nuw nsw i64 %iv, 1 |
| %exitcond = icmp eq i64 %iv.next, %N |
| br i1 %exitcond, label %exit, label %for.body |
| |
| exit: |
| ret void |
| } |
| |
| define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr nocapture %a, ptr nocapture %b, ptr nocapture readonly %c) { |
| ; CHECK-LABEL: 'forked_ptrs_with_different_base' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Memory dependences are safe with run-time checks |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Check 0: |
| ; CHECK-NEXT: Comparing group ([[GRP60:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP61:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 1: |
| ; CHECK-NEXT: Comparing group ([[GRP60]]): |
| ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP62:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv |
| ; CHECK-NEXT: Check 2: |
| ; CHECK-NEXT: Comparing group ([[GRP63:0x[0-9a-f]+]]): |
| ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP61]]): |
| ; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; CHECK-NEXT: Check 3: |
| ; CHECK-NEXT: Comparing group ([[GRP63]]): |
| ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; CHECK-NEXT: Against group ([[GRP62]]): |
| ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-NEXT: Group [[GRP60]]: |
| ; CHECK-NEXT: (Low: %1 High: (63992 + %1)) |
| ; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP63]]: |
| ; CHECK-NEXT: (Low: %2 High: (63992 + %2)) |
| ; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body> |
| ; CHECK-NEXT: Group [[GRP61]]: |
| ; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds)) |
| ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; CHECK-NEXT: Group [[GRP62]]: |
| ; CHECK-NEXT: (Low: %0 High: (63992 + %0)) |
| ; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body> |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_with_different_base' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Memory dependences are safe with run-time checks |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Check 0: |
| ; RECURSE-NEXT: Comparing group ([[GRP64:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP65:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 1: |
| ; RECURSE-NEXT: Comparing group ([[GRP64]]): |
| ; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP66:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 2: |
| ; RECURSE-NEXT: Comparing group ([[GRP67:0x[0-9a-f]+]]): |
| ; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP65]]): |
| ; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| ; RECURSE-NEXT: Check 3: |
| ; RECURSE-NEXT: Comparing group ([[GRP67]]): |
| ; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| ; RECURSE-NEXT: Against group ([[GRP66]]): |
| ; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-NEXT: Group [[GRP64]]: |
| ; RECURSE-NEXT: (Low: %1 High: (63992 + %1)) |
| ; RECURSE-NEXT: Member: {%1,+,8}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP67]]: |
| ; RECURSE-NEXT: (Low: %2 High: (63992 + %2)) |
| ; RECURSE-NEXT: Member: {%2,+,8}<nw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP65]]: |
| ; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds)) |
| ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> |
| ; RECURSE-NEXT: Group [[GRP66]]: |
| ; RECURSE-NEXT: (Low: %0 High: (63992 + %0)) |
| ; RECURSE-NEXT: Member: {%0,+,8}<nw><%for.body> |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| %0 = load ptr, ptr %c, align 64 |
| %1 = load ptr, ptr %a, align 64 |
| %2 = load ptr, ptr %b, align 64 |
| br label %for.body |
| |
| for.cond.cleanup: ; preds = %for.inc |
| ret void |
| |
| for.body: ; preds = %entry, %for.inc |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.inc ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %3 = load i32, ptr %arrayidx, align 4 |
| %cmp2.not = icmp eq i32 %3, 0 |
| br i1 %cmp2.not, label %if.else, label %if.then |
| |
| if.then: ; preds = %for.body |
| %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv |
| %4 = load double, ptr %arrayidx5, align 8 |
| %add = fadd fast double %4, 1.000000e+00 |
| br label %for.inc |
| |
| if.else: ; preds = %for.body |
| %5 = mul nuw nsw i64 %indvars.iv, %indvars.iv |
| %6 = trunc i64 %5 to i32 |
| %conv8 = sitofp i32 %6 to double |
| br label %for.inc |
| |
| for.inc: ; preds = %if.then, %if.else |
| %.sink = phi ptr [ %1, %if.then ], [ %2, %if.else ] |
| %add.sink = phi double [ %add, %if.then ], [ %conv8, %if.else ] |
| %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| store double %add.sink, ptr %arrayidx7, align 8 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 7999 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| } |
| |
| ; Negative test: the operator number of PhiNode is not 2. |
| define void @forked_ptrs_with_different_base3(ptr nocapture readonly %Preds, ptr nocapture %a, ptr nocapture %b, ptr nocapture readonly %c) { |
| ; CHECK-LABEL: 'forked_ptrs_with_different_base3' |
| ; CHECK-NEXT: for.body: |
| ; CHECK-NEXT: Report: cannot identify array bounds |
| ; CHECK-NEXT: Dependences: |
| ; CHECK-NEXT: Run-time memory checks: |
| ; CHECK-NEXT: Grouped accesses: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; CHECK-NEXT: SCEV assumptions: |
| ; CHECK-EMPTY: |
| ; CHECK-NEXT: Expressions re-written: |
| ; |
| ; RECURSE-LABEL: 'forked_ptrs_with_different_base3' |
| ; RECURSE-NEXT: for.body: |
| ; RECURSE-NEXT: Report: cannot identify array bounds |
| ; RECURSE-NEXT: Dependences: |
| ; RECURSE-NEXT: Run-time memory checks: |
| ; RECURSE-NEXT: Grouped accesses: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. |
| ; RECURSE-NEXT: SCEV assumptions: |
| ; RECURSE-EMPTY: |
| ; RECURSE-NEXT: Expressions re-written: |
| ; |
| entry: |
| %ld.c = load ptr, ptr %c, align 64 |
| %ld.a = load ptr, ptr %a, align 64 |
| %ld.b = load ptr, ptr %b, align 64 |
| br label %for.body |
| |
| for.body: ; preds = %entry, %for.inc |
| %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.inc ] |
| %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv |
| %ld.preds = load i32, ptr %arrayidx, align 4 |
| switch i32 %ld.preds, label %if.else [ |
| i32 0, label %if.br0 |
| i32 1, label %if.br1 |
| ] |
| |
| if.br0: ; preds = %for.body |
| br label %for.inc |
| |
| if.br1: ; preds = %for.body |
| br label %for.inc |
| |
| if.else: ; preds = %for.body |
| br label %for.inc |
| |
| for.inc: ; preds = %if.br1, %if.br0 |
| %.sink = phi ptr [ %ld.a, %if.br0 ], [ %ld.b, %if.br1 ], [ %ld.c, %if.else ] |
| %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv |
| store double 1.000000e+00, ptr %arrayidx7, align 8 |
| %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 |
| %exitcond.not = icmp eq i64 %indvars.iv.next, 7999 |
| br i1 %exitcond.not, label %for.cond.cleanup, label %for.body |
| |
| for.cond.cleanup: ; preds = %for.inc |
| ret void |
| } |
