[llvm] b18ebd1 - [LAA] Improve forked-pointers.ll test (#140383)
via llvm-commits
llvm-commits at lists.llvm.org
Sun May 18 01:34:30 PDT 2025
Author: Ramkumar Ramachandra
Date: 2025-05-18T09:34:27+01:00
New Revision: b18ebd17b82db0bdf5bb8cae59c3208288fbef93
URL: https://github.com/llvm/llvm-project/commit/b18ebd17b82db0bdf5bb8cae59c3208288fbef93
DIFF: https://github.com/llvm/llvm-project/commit/b18ebd17b82db0bdf5bb8cae59c3208288fbef93.diff
LOG: [LAA] Improve forked-pointers.ll test (#140383)
Added:
Modified:
llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
Removed:
################################################################################
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
index cd388b4ee87f2..286af49ab1ae6 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
@@ -1,6 +1,6 @@
; 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
+; RUN: opt -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s --check-prefixes=CHECK,FULLDEPTH
+; RUN: opt -disable-output -passes='print<access-info>' -max-forked-scev-depth=2 %s 2>&1 | FileCheck %s --check-prefixes=CHECK,DEPTH2
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
@@ -39,40 +39,6 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea
; 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
@@ -116,31 +82,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset(ptr nocapture read
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP4: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: Against group ([[GRP5: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: Comparing group ([[GRP4]]):
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP6: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: Comparing group ([[GRP4]]):
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP7: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: Group [[GRP4]]:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group [[GRP5]]:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group [[GRP6]]:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group [[GRP7]]:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -149,45 +115,6 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset(ptr nocapture read
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_
diff erent_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
@@ -216,31 +143,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_64b(ptr nocapture
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP15:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP8: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: Against group ([[GRP9: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: Comparing group ([[GRP8]]):
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP17:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP10: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: Comparing group ([[GRP8]]):
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP18:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP11: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: Group [[GRP8]]:
; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP16]]:
+; CHECK-NEXT: Group [[GRP9]]:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP17]]:
+; CHECK-NEXT: Group [[GRP10]]:
; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP18]]:
+; CHECK-NEXT: Group [[GRP11]]:
; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; CHECK-EMPTY:
@@ -249,45 +176,6 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_64b(ptr nocapture
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_
diff erent_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
@@ -316,31 +204,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_23b(ptr nocapture
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP23:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP12: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: Against group ([[GRP13: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: Comparing group ([[GRP12]]):
; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP25:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP14: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: Comparing group ([[GRP12]]):
; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP26:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP15: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: Group [[GRP12]]:
; CHECK-NEXT: (Low: %Dest High: (399 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP24]]:
+; CHECK-NEXT: Group [[GRP13]]:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP25]]:
+; CHECK-NEXT: Group [[GRP14]]:
; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP26]]:
+; CHECK-NEXT: Group [[GRP15]]:
; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -349,45 +237,6 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_23b(ptr nocapture
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_
diff erent_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
@@ -416,31 +265,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_6b(ptr nocapture r
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP31:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP16: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: Against group ([[GRP17: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: Comparing group ([[GRP16]]):
; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP33:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP18: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: Comparing group ([[GRP16]]):
; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP34:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP19: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: Group [[GRP16]]:
; CHECK-NEXT: (Low: %Dest High: (100 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP32]]:
+; CHECK-NEXT: Group [[GRP17]]:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP33]]:
+; CHECK-NEXT: Group [[GRP18]]:
; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP34]]:
+; CHECK-NEXT: Group [[GRP19]]:
; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body>
; CHECK-EMPTY:
@@ -449,45 +298,6 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_6b(ptr nocapture r
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_
diff erent_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
@@ -516,31 +326,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_possible_poison(pt
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP39:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP20: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: Against group ([[GRP21: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: Comparing group ([[GRP20]]):
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP41:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP22: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: Comparing group ([[GRP20]]):
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP42:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP23: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: Group [[GRP20]]:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP40]]:
+; CHECK-NEXT: Group [[GRP21]]:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP41]]:
+; CHECK-NEXT: Group [[GRP22]]:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP42]]:
+; CHECK-NEXT: Group [[GRP23]]:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -549,45 +359,6 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_possible_poison(pt
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_
diff erent_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
@@ -640,18 +411,6 @@ define dso_local void @forked_ptrs_same_base_
diff erent_offset(ptr nocapture read
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_same_base_
diff erent_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
@@ -678,50 +437,50 @@ for.body: ; preds = %entry, %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:
+; FULLDEPTH-LABEL: 'forked_ptrs_add_to_offset'
+; FULLDEPTH-NEXT: for.body:
+; FULLDEPTH-NEXT: Memory dependences are safe with run-time checks
+; FULLDEPTH-NEXT: Dependences:
+; FULLDEPTH-NEXT: Run-time memory checks:
+; FULLDEPTH-NEXT: Check 0:
+; FULLDEPTH-NEXT: Comparing group ([[GRP47:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP48:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; FULLDEPTH-NEXT: Check 1:
+; FULLDEPTH-NEXT: Comparing group ([[GRP47]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP49:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: Grouped accesses:
+; FULLDEPTH-NEXT: Group [[GRP47]]:
+; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
+; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP48]]:
+; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
+; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP49]]:
+; FULLDEPTH-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
+; FULLDEPTH-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; FULLDEPTH-NEXT: SCEV assumptions:
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-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:
+; DEPTH2-LABEL: 'forked_ptrs_add_to_offset'
+; DEPTH2-NEXT: for.body:
+; DEPTH2-NEXT: Report: cannot identify array bounds
+; DEPTH2-NEXT: Dependences:
+; DEPTH2-NEXT: Run-time memory checks:
+; DEPTH2-NEXT: Grouped accesses:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; DEPTH2-NEXT: SCEV assumptions:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Expressions re-written:
;
entry:
br label %for.body
@@ -746,50 +505,50 @@ for.body: ; preds = %entry, %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:
+; FULLDEPTH-LABEL: 'forked_ptrs_sub_from_offset'
+; FULLDEPTH-NEXT: for.body:
+; FULLDEPTH-NEXT: Memory dependences are safe with run-time checks
+; FULLDEPTH-NEXT: Dependences:
+; FULLDEPTH-NEXT: Run-time memory checks:
+; FULLDEPTH-NEXT: Check 0:
+; FULLDEPTH-NEXT: Comparing group ([[GRP50:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP51:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; FULLDEPTH-NEXT: Check 1:
+; FULLDEPTH-NEXT: Comparing group ([[GRP50]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP52:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: Grouped accesses:
+; FULLDEPTH-NEXT: Group [[GRP50]]:
+; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
+; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP51]]:
+; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
+; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP52]]:
+; FULLDEPTH-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base))
+; FULLDEPTH-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; FULLDEPTH-NEXT: SCEV assumptions:
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-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:
+; DEPTH2-LABEL: 'forked_ptrs_sub_from_offset'
+; DEPTH2-NEXT: for.body:
+; DEPTH2-NEXT: Report: cannot identify array bounds
+; DEPTH2-NEXT: Dependences:
+; DEPTH2-NEXT: Run-time memory checks:
+; DEPTH2-NEXT: Grouped accesses:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; DEPTH2-NEXT: SCEV assumptions:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Expressions re-written:
;
entry:
br label %for.body
@@ -814,50 +573,50 @@ for.body: ; preds = %entry, %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:
+; FULLDEPTH-LABEL: 'forked_ptrs_add_sub_offset'
+; FULLDEPTH-NEXT: for.body:
+; FULLDEPTH-NEXT: Memory dependences are safe with run-time checks
+; FULLDEPTH-NEXT: Dependences:
+; FULLDEPTH-NEXT: Run-time memory checks:
+; FULLDEPTH-NEXT: Check 0:
+; FULLDEPTH-NEXT: Comparing group ([[GRP53:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP54:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; FULLDEPTH-NEXT: Check 1:
+; FULLDEPTH-NEXT: Comparing group ([[GRP53]]):
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group ([[GRP55:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: Grouped accesses:
+; FULLDEPTH-NEXT: Group [[GRP53]]:
+; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
+; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP54]]:
+; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
+; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group [[GRP55]]:
+; FULLDEPTH-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base))
+; FULLDEPTH-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
+; FULLDEPTH-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; FULLDEPTH-NEXT: SCEV assumptions:
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-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:
+; DEPTH2-LABEL: 'forked_ptrs_add_sub_offset'
+; DEPTH2-NEXT: for.body:
+; DEPTH2-NEXT: Report: cannot identify array bounds
+; DEPTH2-NEXT: Dependences:
+; DEPTH2-NEXT: Run-time memory checks:
+; DEPTH2-NEXT: Grouped accesses:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; DEPTH2-NEXT: SCEV assumptions:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Expressions re-written:
;
entry:
br label %for.body
@@ -897,18 +656,6 @@ define dso_local void @forked_ptrs_mul_by_offset(ptr nocapture readonly %Base, p
; 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
@@ -947,18 +694,6 @@ define dso_local void @forked_ptrs_uniform_and_strided_forks(ptr nocapture reado
; 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
@@ -1002,18 +737,6 @@ define dso_local void @forked_ptrs_gather_and_contiguous_forks(ptr nocapture rea
; 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
@@ -1053,18 +776,6 @@ define dso_local void @forked_ptrs_two_forks_gep(ptr nocapture readonly %Base1,
; 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
@@ -1102,18 +813,6 @@ define void @forked_ptrs_two_select(ptr nocapture readonly %Base1, ptr nocapture
; 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
@@ -1153,18 +852,6 @@ define void @forked_ptrs_too_many_gep_ops(ptr nocapture readonly %Base1, ptr noc
; 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
@@ -1201,18 +888,6 @@ define void @forked_ptrs_vector_gep(ptr nocapture readonly %Base1, ptr nocapture
; 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
@@ -1250,15 +925,15 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP56:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP24:0x[0-9a-f]+]]):
; CHECK-NEXT: ptr %Base1
-; CHECK-NEXT: Against group ([[GRP57:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP25:0x[0-9a-f]+]]):
; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP56]]:
+; CHECK-NEXT: Group [[GRP24]]:
; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1))
; CHECK-NEXT: Member: %Base1
-; CHECK-NEXT: Group [[GRP57]]:
+; CHECK-NEXT: Group [[GRP25]]:
; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
; CHECK-NEXT: Member: {%Base2,+,8}<%for.body>
; CHECK-EMPTY:
@@ -1271,33 +946,6 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
; 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
@@ -1324,36 +972,36 @@ define void @forked_ptrs_with_
diff erent_base(ptr nocapture readonly %Preds, ptr
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP60:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP26: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: Against group ([[GRP27: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: Comparing group ([[GRP26]]):
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP62:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP28: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: Comparing group ([[GRP29:0x[0-9a-f]+]]):
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP61]]):
+; CHECK-NEXT: Against group ([[GRP27]]):
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP63]]):
+; CHECK-NEXT: Comparing group ([[GRP29]]):
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP62]]):
+; CHECK-NEXT: Against group ([[GRP28]]):
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP60]]:
+; CHECK-NEXT: Group [[GRP26]]:
; CHECK-NEXT: (Low: %1 High: (63992 + %1))
; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP63]]:
+; CHECK-NEXT: Group [[GRP29]]:
; CHECK-NEXT: (Low: %2 High: (63992 + %2))
; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP61]]:
+; CHECK-NEXT: Group [[GRP27]]:
; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP62]]:
+; CHECK-NEXT: Group [[GRP28]]:
; CHECK-NEXT: (Low: %0 High: (63992 + %0))
; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body>
; CHECK-EMPTY:
@@ -1362,50 +1010,6 @@ define void @forked_ptrs_with_
diff erent_base(ptr nocapture readonly %Preds, ptr
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_with_
diff erent_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
@@ -1458,18 +1062,6 @@ define void @forked_ptrs_with_
diff erent_base3(ptr nocapture readonly %Preds, ptr
; CHECK-EMPTY:
; CHECK-NEXT: Expressions re-written:
;
-; RECURSE-LABEL: 'forked_ptrs_with_
diff erent_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
More information about the llvm-commits
mailing list