diff options
| author | Stephen Hines <srhines@google.com> | 2015-03-23 12:10:34 -0700 |
|---|---|---|
| committer | Stephen Hines <srhines@google.com> | 2015-03-23 12:10:34 -0700 |
| commit | ebe69fe11e48d322045d5949c83283927a0d790b (patch) | |
| tree | c92f1907a6b8006628a4b01615f38264d29834ea /test/Analysis | |
| parent | b7d2e72b02a4cb8034f32f8247a2558d2434e121 (diff) | |
| download | external_llvm-ebe69fe11e48d322045d5949c83283927a0d790b.zip external_llvm-ebe69fe11e48d322045d5949c83283927a0d790b.tar.gz external_llvm-ebe69fe11e48d322045d5949c83283927a0d790b.tar.bz2 | |
Update aosp/master LLVM for rebase to r230699.
Change-Id: I2b5be30509658cb8266be782de0ab24f9099f9b9
Diffstat (limited to 'test/Analysis')
61 files changed, 1788 insertions, 257 deletions
diff --git a/test/Analysis/AssumptionCache/basic.ll b/test/Analysis/AssumptionCache/basic.ll new file mode 100644 index 0000000..bd4e7b6 --- /dev/null +++ b/test/Analysis/AssumptionCache/basic.ll @@ -0,0 +1,22 @@ +; RUN: opt < %s -disable-output -passes='print<assumptions>' 2>&1 | FileCheck %s + +target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" + +declare void @llvm.assume(i1) + +define void @test1(i32 %a) { +; CHECK-LABEL: Cached assumptions for function: test1 +; CHECK-NEXT: icmp ne i32 %{{.*}}, 0 +; CHECK-NEXT: icmp slt i32 %{{.*}}, 0 +; CHECK-NEXT: icmp sgt i32 %{{.*}}, 0 + +entry: + %cond1 = icmp ne i32 %a, 0 + call void @llvm.assume(i1 %cond1) + %cond2 = icmp slt i32 %a, 0 + call void @llvm.assume(i1 %cond2) + %cond3 = icmp sgt i32 %a, 0 + call void @llvm.assume(i1 %cond3) + + ret void +} diff --git a/test/Analysis/BasicAA/2003-11-04-SimpleCases.ll b/test/Analysis/BasicAA/2003-11-04-SimpleCases.ll index 768411e..f2b06cb 100644 --- a/test/Analysis/BasicAA/2003-11-04-SimpleCases.ll +++ b/test/Analysis/BasicAA/2003-11-04-SimpleCases.ll @@ -3,10 +3,12 @@ ; RUN: opt < %s -basicaa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + %T = type { i32, [10 x i8] } ; CHECK: Function: test -; CHECK-NOT: May: +; CHECK-NOT: MayAlias: define void @test(%T* %P) { %A = getelementptr %T* %P, i64 0 diff --git a/test/Analysis/BasicAA/2003-12-11-ConstExprGEP.ll b/test/Analysis/BasicAA/2003-12-11-ConstExprGEP.ll index b7bbf77..42512b8 100644 --- a/test/Analysis/BasicAA/2003-12-11-ConstExprGEP.ll +++ b/test/Analysis/BasicAA/2003-12-11-ConstExprGEP.ll @@ -3,12 +3,14 @@ ; RUN: opt < %s -basicaa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + %T = type { i32, [10 x i8] } @G = external global %T ; CHECK: Function: test -; CHECK-NOT: May: +; CHECK-NOT: MayAlias: define void @test() { %D = getelementptr %T* @G, i64 0, i32 0 diff --git a/test/Analysis/BasicAA/2007-08-01-NoAliasAndGEP.ll b/test/Analysis/BasicAA/2007-08-01-NoAliasAndGEP.ll index 4be793e..d11e75d 100644 --- a/test/Analysis/BasicAA/2007-08-01-NoAliasAndGEP.ll +++ b/test/Analysis/BasicAA/2007-08-01-NoAliasAndGEP.ll @@ -1,9 +1,11 @@ ; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + ; CHECK: Function: foo -; CHECK: MayAlias: i32* %Ipointer, i32* %Jpointer +; CHECK: PartialAlias: i32* %Ipointer, i32* %Jpointer ; CHECK: 9 no alias responses -; CHECK: 6 may alias responses +; CHECK: 6 partial alias responses define void @foo(i32* noalias %p, i32* noalias %q, i32 %i, i32 %j) { %Ipointer = getelementptr i32* %p, i32 %i diff --git a/test/Analysis/BasicAA/constant-over-index.ll b/test/Analysis/BasicAA/constant-over-index.ll index 232533c..aeb068b 100644 --- a/test/Analysis/BasicAA/constant-over-index.ll +++ b/test/Analysis/BasicAA/constant-over-index.ll @@ -1,10 +1,13 @@ ; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; PR4267 -; CHECK: MayAlias: double* %p.0.i.0, double* %p3 +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + +; CHECK: PartialAlias: double* %p.0.i.0, double* %p3 ; %p3 is equal to %p.0.i.0 on the second iteration of the loop, -; so MayAlias is needed. +; so MayAlias is needed. In practice, basicaa returns PartialAlias +; for GEPs to ignore TBAA. define void @foo([3 x [3 x double]]* noalias %p) { entry: diff --git a/test/Analysis/BasicAA/full-store-partial-alias.ll b/test/Analysis/BasicAA/full-store-partial-alias.ll index 4de2daf..9699d92 100644 --- a/test/Analysis/BasicAA/full-store-partial-alias.ll +++ b/test/Analysis/BasicAA/full-store-partial-alias.ll @@ -29,9 +29,9 @@ entry: ret i32 %tmp5.lobit } -!0 = metadata !{metadata !4, metadata !4, i64 0} -!1 = metadata !{metadata !"omnipotent char", metadata !2} -!2 = metadata !{metadata !"Simple C/C++ TBAA", null} -!3 = metadata !{metadata !5, metadata !5, i64 0} -!4 = metadata !{metadata !"double", metadata !1} -!5 = metadata !{metadata !"int", metadata !1} +!0 = !{!4, !4, i64 0} +!1 = !{!"omnipotent char", !2} +!2 = !{!"Simple C/C++ TBAA", null} +!3 = !{!5, !5, i64 0} +!4 = !{!"double", !1} +!5 = !{!"int", !1} diff --git a/test/Analysis/BasicAA/invariant_load.ll b/test/Analysis/BasicAA/invariant_load.ll index 09b5401..bc629cd 100644 --- a/test/Analysis/BasicAA/invariant_load.ll +++ b/test/Analysis/BasicAA/invariant_load.ll @@ -23,4 +23,4 @@ entry: ; CHECK: %add = add nsw i32 %0, 1 } -!3 = metadata !{} +!3 = !{} diff --git a/test/Analysis/BasicAA/struct-geps.ll b/test/Analysis/BasicAA/struct-geps.ll new file mode 100644 index 0000000..3764d48 --- /dev/null +++ b/test/Analysis/BasicAA/struct-geps.ll @@ -0,0 +1,164 @@ +; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + +%struct = type { i32, i32, i32 } + +; CHECK-LABEL: test_simple + +; CHECK-DAG: PartialAlias: %struct* %st, i32* %x +; CHECK-DAG: PartialAlias: %struct* %st, i32* %y +; CHECK-DAG: PartialAlias: %struct* %st, i32* %z + +; CHECK-DAG: NoAlias: i32* %x, i32* %y +; CHECK-DAG: NoAlias: i32* %x, i32* %z +; CHECK-DAG: NoAlias: i32* %y, i32* %z + +; CHECK-DAG: PartialAlias: %struct* %st, %struct* %y_12 +; CHECK-DAG: PartialAlias: %struct* %y_12, i32* %x +; CHECK-DAG: PartialAlias: i32* %x, i80* %y_10 + +; CHECK-DAG: PartialAlias: %struct* %st, i64* %y_8 +; CHECK-DAG: PartialAlias: i32* %z, i64* %y_8 +; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 + +; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y +; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 +; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 + +define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) { + %x = getelementptr %struct* %st, i64 %i, i32 0 + %y = getelementptr %struct* %st, i64 %j, i32 1 + %z = getelementptr %struct* %st, i64 %k, i32 2 + %y_12 = bitcast i32* %y to %struct* + %y_10 = bitcast i32* %y to i80* + %y_8 = bitcast i32* %y to i64* + ret void +} + +; CHECK-LABEL: test_in_array + +; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %x +; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %y +; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %z + +; CHECK-DAG: NoAlias: i32* %x, i32* %y +; CHECK-DAG: NoAlias: i32* %x, i32* %z +; CHECK-DAG: NoAlias: i32* %y, i32* %z + +; CHECK-DAG: PartialAlias: %struct* %y_12, [1 x %struct]* %st +; CHECK-DAG: PartialAlias: %struct* %y_12, i32* %x +; CHECK-DAG: PartialAlias: i32* %x, i80* %y_10 + +; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i64* %y_8 +; CHECK-DAG: PartialAlias: i32* %z, i64* %y_8 +; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 + +; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y +; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 +; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 + +define void @test_in_array([1 x %struct]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1) { + %x = getelementptr [1 x %struct]* %st, i64 %i, i64 %i1, i32 0 + %y = getelementptr [1 x %struct]* %st, i64 %j, i64 %j1, i32 1 + %z = getelementptr [1 x %struct]* %st, i64 %k, i64 %k1, i32 2 + %y_12 = bitcast i32* %y to %struct* + %y_10 = bitcast i32* %y to i80* + %y_8 = bitcast i32* %y to i64* + ret void +} + +; CHECK-LABEL: test_in_3d_array + +; CHECK-DAG: PartialAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %x +; CHECK-DAG: PartialAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %y +; CHECK-DAG: PartialAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %z + +; CHECK-DAG: NoAlias: i32* %x, i32* %y +; CHECK-DAG: NoAlias: i32* %x, i32* %z +; CHECK-DAG: NoAlias: i32* %y, i32* %z + +; CHECK-DAG: PartialAlias: %struct* %y_12, [1 x [1 x [1 x %struct]]]* %st +; CHECK-DAG: PartialAlias: %struct* %y_12, i32* %x +; CHECK-DAG: PartialAlias: i32* %x, i80* %y_10 + +; CHECK-DAG: PartialAlias: [1 x [1 x [1 x %struct]]]* %st, i64* %y_8 +; CHECK-DAG: PartialAlias: i32* %z, i64* %y_8 +; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 + +; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y +; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 +; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 + +define void @test_in_3d_array([1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %j2, i64 %k2, i64 %i3, i64 %j3, i64 %k3) { + %x = getelementptr [1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %i1, i64 %i2, i64 %i3, i32 0 + %y = getelementptr [1 x [1 x [1 x %struct]]]* %st, i64 %j, i64 %j1, i64 %j2, i64 %j3, i32 1 + %z = getelementptr [1 x [1 x [1 x %struct]]]* %st, i64 %k, i64 %k1, i64 %k2, i64 %k3, i32 2 + %y_12 = bitcast i32* %y to %struct* + %y_10 = bitcast i32* %y to i80* + %y_8 = bitcast i32* %y to i64* + ret void +} + +; CHECK-LABEL: test_same_underlying_object_same_indices + +; CHECK-DAG: NoAlias: i32* %x, i32* %x2 +; CHECK-DAG: NoAlias: i32* %y, i32* %y2 +; CHECK-DAG: NoAlias: i32* %z, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x, i32* %y2 +; CHECK-DAG: PartialAlias: i32* %x, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x2, i32* %y +; CHECK-DAG: PartialAlias: i32* %y, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x2, i32* %z +; CHECK-DAG: PartialAlias: i32* %y2, i32* %z + +define void @test_same_underlying_object_same_indices(%struct* %st, i64 %i, i64 %j, i64 %k) { + %st2 = getelementptr %struct* %st, i32 10 + %x2 = getelementptr %struct* %st2, i64 %i, i32 0 + %y2 = getelementptr %struct* %st2, i64 %j, i32 1 + %z2 = getelementptr %struct* %st2, i64 %k, i32 2 + %x = getelementptr %struct* %st, i64 %i, i32 0 + %y = getelementptr %struct* %st, i64 %j, i32 1 + %z = getelementptr %struct* %st, i64 %k, i32 2 + ret void +} + +; CHECK-LABEL: test_same_underlying_object_different_indices + +; CHECK-DAG: PartialAlias: i32* %x, i32* %x2 +; CHECK-DAG: PartialAlias: i32* %y, i32* %y2 +; CHECK-DAG: PartialAlias: i32* %z, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x, i32* %y2 +; CHECK-DAG: PartialAlias: i32* %x, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x2, i32* %y +; CHECK-DAG: PartialAlias: i32* %y, i32* %z2 + +; CHECK-DAG: PartialAlias: i32* %x2, i32* %z +; CHECK-DAG: PartialAlias: i32* %y2, i32* %z + +define void @test_same_underlying_object_different_indices(%struct* %st, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %k2, i64 %j2) { + %st2 = getelementptr %struct* %st, i32 10 + %x2 = getelementptr %struct* %st2, i64 %i2, i32 0 + %y2 = getelementptr %struct* %st2, i64 %j2, i32 1 + %z2 = getelementptr %struct* %st2, i64 %k2, i32 2 + %x = getelementptr %struct* %st, i64 %i1, i32 0 + %y = getelementptr %struct* %st, i64 %j1, i32 1 + %z = getelementptr %struct* %st, i64 %k1, i32 2 + ret void +} + + +%struct2 = type { [1 x { i32, i32 }], [2 x { i32 }] } + +; CHECK-LABEL: test_struct_in_array +; CHECK-DAG: MustAlias: i32* %x, i32* %y +define void @test_struct_in_array(%struct2* %st, i64 %i, i64 %j, i64 %k) { + %x = getelementptr %struct2* %st, i32 0, i32 1, i32 1, i32 0 + %y = getelementptr %struct2* %st, i32 0, i32 0, i32 1, i32 1 + ret void +} diff --git a/test/Analysis/BlockFrequencyInfo/bad_input.ll b/test/Analysis/BlockFrequencyInfo/bad_input.ll index bcdc1e6..da62dca 100644 --- a/test/Analysis/BlockFrequencyInfo/bad_input.ll +++ b/test/Analysis/BlockFrequencyInfo/bad_input.ll @@ -23,7 +23,7 @@ for.end: ret void } -!0 = metadata !{metadata !"branch_weights", i32 0, i32 3} +!0 = !{!"branch_weights", i32 0, i32 3} ; CHECK-LABEL: Printing analysis {{.*}} for function 'infinite_loop' ; CHECK-NEXT: block-frequency-info: infinite_loop @@ -47,4 +47,4 @@ for.end: ret void } -!1 = metadata !{metadata !"branch_weights", i32 1, i32 1} +!1 = !{!"branch_weights", i32 1, i32 1} diff --git a/test/Analysis/BlockFrequencyInfo/basic.ll b/test/Analysis/BlockFrequencyInfo/basic.ll index 006e6ab..1c24176 100644 --- a/test/Analysis/BlockFrequencyInfo/basic.ll +++ b/test/Analysis/BlockFrequencyInfo/basic.ll @@ -47,7 +47,7 @@ exit: ret i32 %result } -!0 = metadata !{metadata !"branch_weights", i32 64, i32 4} +!0 = !{!"branch_weights", i32 64, i32 4} define i32 @test3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) { ; CHECK-LABEL: Printing analysis {{.*}} for function 'test3': @@ -90,7 +90,7 @@ exit: ret i32 %result } -!1 = metadata !{metadata !"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4} +!1 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4} define void @nested_loops(i32 %a) { ; CHECK-LABEL: Printing analysis {{.*}} for function 'nested_loops': @@ -138,4 +138,4 @@ for.end13: declare void @g(i32) -!2 = metadata !{metadata !"branch_weights", i32 1, i32 4000} +!2 = !{!"branch_weights", i32 1, i32 4000} diff --git a/test/Analysis/BlockFrequencyInfo/double_backedge.ll b/test/Analysis/BlockFrequencyInfo/double_backedge.ll index df8217c..597bf83 100644 --- a/test/Analysis/BlockFrequencyInfo/double_backedge.ll +++ b/test/Analysis/BlockFrequencyInfo/double_backedge.ll @@ -23,5 +23,5 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!0 = metadata !{metadata !"branch_weights", i32 1, i32 9} -!1 = metadata !{metadata !"branch_weights", i32 4, i32 5} +!0 = !{!"branch_weights", i32 1, i32 9} +!1 = !{!"branch_weights", i32 4, i32 5} diff --git a/test/Analysis/BlockFrequencyInfo/double_exit.ll b/test/Analysis/BlockFrequencyInfo/double_exit.ll index 75f664d..3063ba7 100644 --- a/test/Analysis/BlockFrequencyInfo/double_exit.ll +++ b/test/Analysis/BlockFrequencyInfo/double_exit.ll @@ -66,9 +66,9 @@ exit: ret i32 %Return.2 } -!0 = metadata !{metadata !"branch_weights", i32 1, i32 3} -!1 = metadata !{metadata !"branch_weights", i32 4, i32 1} -!2 = metadata !{metadata !"branch_weights", i32 2, i32 1} +!0 = !{!"branch_weights", i32 1, i32 3} +!1 = !{!"branch_weights", i32 4, i32 1} +!2 = !{!"branch_weights", i32 2, i32 1} declare i32 @c2(i32, i32) declare i32 @logic2(i32, i32, i32) @@ -159,7 +159,7 @@ exit: ret i32 %Return.0 } -!3 = metadata !{metadata !"branch_weights", i32 1, i32 1} +!3 = !{!"branch_weights", i32 1, i32 1} declare i32 @c3(i32, i32, i32) declare i32 @logic3(i32, i32, i32, i32) diff --git a/test/Analysis/BlockFrequencyInfo/extremely-likely-loop-successor.ll b/test/Analysis/BlockFrequencyInfo/extremely-likely-loop-successor.ll new file mode 100644 index 0000000..e55deaf --- /dev/null +++ b/test/Analysis/BlockFrequencyInfo/extremely-likely-loop-successor.ll @@ -0,0 +1,40 @@ +; RUN: opt < %s -analyze -block-freq | FileCheck %s + +; PR21622: Check for a crasher when the sum of exits to the same successor of a +; loop overflows. + +; CHECK-LABEL: Printing analysis {{.*}} for function 'extremely_likely_loop_successor': +; CHECK-NEXT: block-frequency-info: extremely_likely_loop_successor +define void @extremely_likely_loop_successor() { +; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]] +entry: + br label %loop + +; CHECK-NEXT: loop: float = 1.0, +loop: + %exit.1.cond = call i1 @foo() + br i1 %exit.1.cond, label %exit, label %loop.2, !prof !0 + +; CHECK-NEXT: loop.2: float = 0.0000000 +loop.2: + %exit.2.cond = call i1 @foo() + br i1 %exit.2.cond, label %exit, label %loop.3, !prof !0 + +; CHECK-NEXT: loop.3: float = 0.0000000 +loop.3: + %exit.3.cond = call i1 @foo() + br i1 %exit.3.cond, label %exit, label %loop.4, !prof !0 + +; CHECK-NEXT: loop.4: float = 0.0, +loop.4: + %exit.4.cond = call i1 @foo() + br i1 %exit.4.cond, label %exit, label %loop, !prof !0 + +; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] +exit: + ret void +} + +declare i1 @foo() + +!0 = !{!"branch_weights", i32 4294967295, i32 1} diff --git a/test/Analysis/BlockFrequencyInfo/irreducible.ll b/test/Analysis/BlockFrequencyInfo/irreducible.ll index af4ad15..b275aae 100644 --- a/test/Analysis/BlockFrequencyInfo/irreducible.ll +++ b/test/Analysis/BlockFrequencyInfo/irreducible.ll @@ -31,8 +31,8 @@ return: ret void } -!0 = metadata !{metadata !"branch_weights", i32 1, i32 7} -!1 = metadata !{metadata !"branch_weights", i32 3, i32 4} +!0 = !{!"branch_weights", i32 1, i32 7} +!1 = !{!"branch_weights", i32 3, i32 4} ; Irreducible control flow ; ======================== @@ -112,7 +112,7 @@ exit: ret void } -!2 = metadata !{metadata !"branch_weights", i32 3, i32 1} +!2 = !{!"branch_weights", i32 3, i32 1} ; Testcase #2 ; =========== @@ -156,7 +156,7 @@ exit: ret void } -!3 = metadata !{metadata !"branch_weights", i32 2, i32 2, i32 2} +!3 = !{!"branch_weights", i32 2, i32 2, i32 2} ; A true loop with irreducible control flow inside. define void @loop_around_irreducible(i1 %x) { @@ -186,8 +186,8 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!4 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!5 = metadata !{metadata !"branch_weights", i32 3, i32 1} +!4 = !{!"branch_weights", i32 1, i32 1} +!5 = !{!"branch_weights", i32 3, i32 1} ; Two unrelated irreducible SCCs. define void @two_sccs(i1 %x) { @@ -225,9 +225,9 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!6 = metadata !{metadata !"branch_weights", i32 3, i32 1} -!7 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!8 = metadata !{metadata !"branch_weights", i32 4, i32 1} +!6 = !{!"branch_weights", i32 3, i32 1} +!7 = !{!"branch_weights", i32 1, i32 1} +!8 = !{!"branch_weights", i32 4, i32 1} ; A true loop inside irreducible control flow. define void @loop_inside_irreducible(i1 %x) { @@ -257,9 +257,9 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!9 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!10 = metadata !{metadata !"branch_weights", i32 3, i32 1} -!11 = metadata !{metadata !"branch_weights", i32 2, i32 1} +!9 = !{!"branch_weights", i32 1, i32 1} +!10 = !{!"branch_weights", i32 3, i32 1} +!11 = !{!"branch_weights", i32 2, i32 1} ; Irreducible control flow in a branch that's in a true loop. define void @loop_around_branch_with_irreducible(i1 %x) { @@ -301,8 +301,8 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!12 = metadata !{metadata !"branch_weights", i32 3, i32 1} -!13 = metadata !{metadata !"branch_weights", i32 1, i32 1} +!12 = !{!"branch_weights", i32 3, i32 1} +!13 = !{!"branch_weights", i32 1, i32 1} ; Irreducible control flow between two true loops. define void @loop_around_branch_with_irreducible_around_loop(i1 %x) { @@ -348,10 +348,10 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!14 = metadata !{metadata !"branch_weights", i32 2, i32 1} -!15 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!16 = metadata !{metadata !"branch_weights", i32 3, i32 1} -!17 = metadata !{metadata !"branch_weights", i32 4, i32 1} +!14 = !{!"branch_weights", i32 2, i32 1} +!15 = !{!"branch_weights", i32 1, i32 1} +!16 = !{!"branch_weights", i32 3, i32 1} +!17 = !{!"branch_weights", i32 4, i32 1} ; An irreducible SCC with a non-header. define void @nonheader(i1 %x) { @@ -377,9 +377,9 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!18 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!19 = metadata !{metadata !"branch_weights", i32 1, i32 3} -!20 = metadata !{metadata !"branch_weights", i32 3, i32 1} +!18 = !{!"branch_weights", i32 1, i32 1} +!19 = !{!"branch_weights", i32 1, i32 3} +!20 = !{!"branch_weights", i32 3, i32 1} ; An irreducible SCC with an irreducible sub-SCC. In the current version of ; -block-freq, this means an extra header. @@ -416,6 +416,6 @@ exit: ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]] ret void } -!21 = metadata !{metadata !"branch_weights", i32 2, i32 1} -!22 = metadata !{metadata !"branch_weights", i32 1, i32 1} -!23 = metadata !{metadata !"branch_weights", i32 8, i32 1, i32 3, i32 12} +!21 = !{!"branch_weights", i32 2, i32 1} +!22 = !{!"branch_weights", i32 1, i32 1} +!23 = !{!"branch_weights", i32 8, i32 1, i32 3, i32 12} diff --git a/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll b/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll index 9d27b6b..9a86564 100644 --- a/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll +++ b/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll @@ -40,5 +40,5 @@ exit: declare i1 @foo0(i32) declare i2 @foo1(i32) -!0 = metadata !{metadata !"branch_weights", i32 1, i32 3} -!1 = metadata !{metadata !"branch_weights", i32 1, i32 2, i32 3} +!0 = !{!"branch_weights", i32 1, i32 3} +!1 = !{!"branch_weights", i32 1, i32 2, i32 3} diff --git a/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll b/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll index d93ffce..19d1658 100644 --- a/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll +++ b/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll @@ -55,5 +55,5 @@ declare i1 @foo4(i32) declare i1 @foo5(i32) declare i1 @foo6(i32) -!0 = metadata !{metadata !"branch_weights", i32 1, i32 3} -!1 = metadata !{metadata !"branch_weights", i32 3, i32 1} +!0 = !{!"branch_weights", i32 1, i32 3} +!1 = !{!"branch_weights", i32 3, i32 1} diff --git a/test/Analysis/BranchProbabilityInfo/basic.ll b/test/Analysis/BranchProbabilityInfo/basic.ll index 05cb31d..5915ed1 100644 --- a/test/Analysis/BranchProbabilityInfo/basic.ll +++ b/test/Analysis/BranchProbabilityInfo/basic.ll @@ -43,7 +43,7 @@ exit: ret i32 %result } -!0 = metadata !{metadata !"branch_weights", i32 64, i32 4} +!0 = !{!"branch_weights", i32 64, i32 4} define i32 @test3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) { ; CHECK: Printing analysis {{.*}} for function 'test3' @@ -87,7 +87,7 @@ exit: ret i32 %result } -!1 = metadata !{metadata !"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4} +!1 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4} define i32 @test4(i32 %x) nounwind uwtable readnone ssp { ; CHECK: Printing analysis {{.*}} for function 'test4' @@ -114,7 +114,7 @@ return: ret i32 %retval.0 } -!2 = metadata !{metadata !"branch_weights", i32 7, i32 6, i32 4, i32 4, i32 64} +!2 = !{!"branch_weights", i32 7, i32 6, i32 4, i32 4, i32 64} declare void @coldfunc() cold diff --git a/test/Analysis/CFLAliasAnalysis/asm-global-bugfix.ll b/test/Analysis/CFLAliasAnalysis/asm-global-bugfix.ll new file mode 100644 index 0000000..d8ee94b --- /dev/null +++ b/test/Analysis/CFLAliasAnalysis/asm-global-bugfix.ll @@ -0,0 +1,16 @@ +; Test case for a bug where we would crash when we were requested to report +; whether two values that didn't belong to a function (i.e. two globals, etc) +; aliased. + +; RUN: opt < %s -cfl-aa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s + +@G = private unnamed_addr constant [1 x i8] c"\00", align 1 + +; CHECK: Function: test_no_crash +; CHECK: 1 no alias responses +define void @test_no_crash() #0 { +entry: + call i8* asm "nop", "=r,r"( + i8* getelementptr inbounds ([1 x i8]* @G, i64 0, i64 0)) + ret void +} diff --git a/test/Analysis/CFLAliasAnalysis/full-store-partial-alias.ll b/test/Analysis/CFLAliasAnalysis/full-store-partial-alias.ll index 155fe13..21edfc2 100644 --- a/test/Analysis/CFLAliasAnalysis/full-store-partial-alias.ll +++ b/test/Analysis/CFLAliasAnalysis/full-store-partial-alias.ll @@ -2,8 +2,9 @@ ; RUN: opt -S -tbaa -gvn < %s | FileCheck %s ; Adapted from the BasicAA full-store-partial-alias.ll test. -; CFL AA should notice that the store stores to the entire %u object, +; CFL AA could notice that the store stores to the entire %u object, ; so the %tmp5 load is PartialAlias with the store and suppress TBAA. +; FIXME: However, right now, CFLAA cannot prove PartialAlias here ; Without CFL AA, TBAA should say that %tmp5 is NoAlias with the store. target datalayout = "e-p:64:64:64" @@ -14,8 +15,9 @@ target datalayout = "e-p:64:64:64" @endianness_test = global i64 1, align 8 define i32 @signbit(double %x) nounwind { -; CFLAA: ret i32 %tmp5.lobit -; CHECK: ret i32 0 +; FIXME: This would be ret i32 %tmp5.lobit if CFLAA could prove PartialAlias +; CFLAA: ret i32 0 +; CHECK: ret i32 0 entry: %u = alloca %union.anon, align 8 %tmp9 = getelementptr inbounds %union.anon* %u, i64 0, i32 0 @@ -29,9 +31,9 @@ entry: ret i32 %tmp5.lobit } -!0 = metadata !{metadata !4, metadata !4, i64 0} -!1 = metadata !{metadata !"omnipotent char", metadata !2} -!2 = metadata !{metadata !"Simple C/C++ TBAA", null} -!3 = metadata !{metadata !5, metadata !5, i64 0} -!4 = metadata !{metadata !"double", metadata !1} -!5 = metadata !{metadata !"int", metadata !1} +!0 = !{!4, !4, i64 0} +!1 = !{!"omnipotent char", !2} +!2 = !{!"Simple C/C++ TBAA", null} +!3 = !{!5, !5, i64 0} +!4 = !{!"double", !1} +!5 = !{!"int", !1} diff --git a/test/Analysis/CFLAliasAnalysis/gep-signed-arithmetic.ll b/test/Analysis/CFLAliasAnalysis/gep-signed-arithmetic.ll index a0195d7..19d251c 100644 --- a/test/Analysis/CFLAliasAnalysis/gep-signed-arithmetic.ll +++ b/test/Analysis/CFLAliasAnalysis/gep-signed-arithmetic.ll @@ -3,9 +3,11 @@ target datalayout = "e-p:32:32:32" -; CHECK: 1 partial alias response +; FIXME: This could be PartialAlias but CFLAA can't currently prove it +; CHECK: 1 may alias response -define i32 @test(i32* %tab, i32 %indvar) nounwind { +define i32 @test(i32 %indvar) nounwind { + %tab = alloca i32, align 4 %tmp31 = mul i32 %indvar, -2 %tmp32 = add i32 %tmp31, 30 %t.5 = getelementptr i32* %tab, i32 %tmp32 diff --git a/test/Analysis/CFLAliasAnalysis/must-and-partial.ll b/test/Analysis/CFLAliasAnalysis/must-and-partial.ll index df7de38..163a6c3 100644 --- a/test/Analysis/CFLAliasAnalysis/must-and-partial.ll +++ b/test/Analysis/CFLAliasAnalysis/must-and-partial.ll @@ -1,14 +1,15 @@ ; RUN: opt < %s -cfl-aa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s - ; When merging MustAlias and PartialAlias, merge to PartialAlias ; instead of MayAlias. target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" -; CHECK: PartialAlias: i16* %bigbase0, i8* %phi -define i8 @test0(i8* %base, i1 %x) { +; FIXME: This could be PartialAlias but CFLAA can't currently prove it +; CHECK: MayAlias: i16* %bigbase0, i8* %phi +define i8 @test0(i1 %x) { entry: + %base = alloca i8, align 4 %baseplusone = getelementptr i8* %base, i64 1 br i1 %x, label %red, label %green red: @@ -24,9 +25,11 @@ green: ret i8 %loaded } -; CHECK: PartialAlias: i16* %bigbase1, i8* %sel -define i8 @test1(i8* %base, i1 %x) { +; FIXME: This could be PartialAlias but CFLAA can't currently prove it +; CHECK: MayAlias: i16* %bigbase1, i8* %sel +define i8 @test1(i1 %x) { entry: + %base = alloca i8, align 4 %baseplusone = getelementptr i8* %base, i64 1 %sel = select i1 %x, i8* %baseplusone, i8* %base store i8 0, i8* %sel @@ -37,3 +40,15 @@ entry: %loaded = load i8* %sel ret i8 %loaded } + +; Incoming pointer arguments should not be PartialAlias because we do not know their initial state +; even if they are nocapture +; CHECK: MayAlias: double* %A, double* %Index +define void @testr2(double* nocapture readonly %A, double* nocapture readonly %Index) { + %arrayidx22 = getelementptr inbounds double* %Index, i64 2 + %1 = load double* %arrayidx22 + %arrayidx25 = getelementptr inbounds double* %A, i64 2 + %2 = load double* %arrayidx25 + %mul26 = fmul double %1, %2 + ret void +} diff --git a/test/Analysis/CFLAliasAnalysis/stratified-attrs-indexing.ll b/test/Analysis/CFLAliasAnalysis/stratified-attrs-indexing.ll new file mode 100644 index 0000000..8afedf2 --- /dev/null +++ b/test/Analysis/CFLAliasAnalysis/stratified-attrs-indexing.ll @@ -0,0 +1,33 @@ +; This testcase ensures that CFLAA doesn't try to access out of bounds indices +; when given functions with large amounts of arguments (specifically, more +; arguments than the StratifiedAttrs bitset can handle) +; +; Because the result on failure is effectively crashing the compiler, output +; checking is minimal. + +; RUN: opt < %s -cfl-aa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s + +; CHECK: Function: test +define void @test(i1 %cond, + i32* %arg1, i32* %arg2, i32* %arg3, i32* %arg4, i32* %arg5, + i32* %arg6, i32* %arg7, i32* %arg8, i32* %arg9, i32* %arg10, + i32* %arg11, i32* %arg12, i32* %arg13, i32* %arg14, i32* %arg15, + i32* %arg16, i32* %arg17, i32* %arg18, i32* %arg19, i32* %arg20, + i32* %arg21, i32* %arg22, i32* %arg23, i32* %arg24, i32* %arg25, + i32* %arg26, i32* %arg27, i32* %arg28, i32* %arg29, i32* %arg30, + i32* %arg31, i32* %arg32, i32* %arg33, i32* %arg34, i32* %arg35) { + + ; CHECK: 946 Total Alias Queries Performed + ; CHECK: 810 no alias responses (85.6%) + %a = alloca i32, align 4 + %b = select i1 %cond, i32* %arg35, i32* %arg34 + %c = select i1 %cond, i32* %arg34, i32* %arg33 + %d = select i1 %cond, i32* %arg33, i32* %arg32 + %e = select i1 %cond, i32* %arg32, i32* %arg31 + %f = select i1 %cond, i32* %arg31, i32* %arg30 + %g = select i1 %cond, i32* %arg30, i32* %arg29 + %h = select i1 %cond, i32* %arg29, i32* %arg28 + %i = select i1 %cond, i32* %arg28, i32* %arg27 + + ret void +} diff --git a/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll b/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll new file mode 100644 index 0000000..4683c43 --- /dev/null +++ b/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll @@ -0,0 +1,89 @@ +; RUN: opt -S -mtriple=x86_64-apple-darwin -mcpu=core-avx2 -cost-model -analyze < %s | FileCheck %s -check-prefix=AVX2 + + +; AVX2-LABEL: test1 +; AVX2: Found an estimated cost of 4 {{.*}}.masked +define <2 x double> @test1(<2 x i64> %trigger, <2 x double>* %addr, <2 x double> %dst) { + %mask = icmp eq <2 x i64> %trigger, zeroinitializer + %res = call <2 x double> @llvm.masked.load.v2f64(<2 x double>* %addr, i32 4, <2 x i1>%mask, <2 x double>%dst) + ret <2 x double> %res +} + +; AVX2-LABEL: test2 +; AVX2: Found an estimated cost of 4 {{.*}}.masked +define <4 x i32> @test2(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %dst) { + %mask = icmp eq <4 x i32> %trigger, zeroinitializer + %res = call <4 x i32> @llvm.masked.load.v4i32(<4 x i32>* %addr, i32 4, <4 x i1>%mask, <4 x i32>%dst) + ret <4 x i32> %res +} + +; AVX2-LABEL: test3 +; AVX2: Found an estimated cost of 4 {{.*}}.masked +define void @test3(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %val) { + %mask = icmp eq <4 x i32> %trigger, zeroinitializer + call void @llvm.masked.store.v4i32(<4 x i32>%val, <4 x i32>* %addr, i32 4, <4 x i1>%mask) + ret void +} + +; AVX2-LABEL: test4 +; AVX2: Found an estimated cost of 4 {{.*}}.masked +define <8 x float> @test4(<8 x i32> %trigger, <8 x float>* %addr, <8 x float> %dst) { + %mask = icmp eq <8 x i32> %trigger, zeroinitializer + %res = call <8 x float> @llvm.masked.load.v8f32(<8 x float>* %addr, i32 4, <8 x i1>%mask, <8 x float>%dst) + ret <8 x float> %res +} + +; AVX2-LABEL: test5 +; AVX2: Found an estimated cost of 5 {{.*}}.masked +define void @test5(<2 x i32> %trigger, <2 x float>* %addr, <2 x float> %val) { + %mask = icmp eq <2 x i32> %trigger, zeroinitializer + call void @llvm.masked.store.v2f32(<2 x float>%val, <2 x float>* %addr, i32 4, <2 x i1>%mask) + ret void +} + +; AVX2-LABEL: test6 +; AVX2: Found an estimated cost of 6 {{.*}}.masked +define void @test6(<2 x i32> %trigger, <2 x i32>* %addr, <2 x i32> %val) { + %mask = icmp eq <2 x i32> %trigger, zeroinitializer + call void @llvm.masked.store.v2i32(<2 x i32>%val, <2 x i32>* %addr, i32 4, <2 x i1>%mask) + ret void +} + +; AVX2-LABEL: test7 +; AVX2: Found an estimated cost of 5 {{.*}}.masked +define <2 x float> @test7(<2 x i32> %trigger, <2 x float>* %addr, <2 x float> %dst) { + %mask = icmp eq <2 x i32> %trigger, zeroinitializer + %res = call <2 x float> @llvm.masked.load.v2f32(<2 x float>* %addr, i32 4, <2 x i1>%mask, <2 x float>%dst) + ret <2 x float> %res +} + +; AVX2-LABEL: test8 +; AVX2: Found an estimated cost of 6 {{.*}}.masked +define <2 x i32> @test8(<2 x i32> %trigger, <2 x i32>* %addr, <2 x i32> %dst) { + %mask = icmp eq <2 x i32> %trigger, zeroinitializer + %res = call <2 x i32> @llvm.masked.load.v2i32(<2 x i32>* %addr, i32 4, <2 x i1>%mask, <2 x i32>%dst) + ret <2 x i32> %res +} + + +declare <16 x i32> @llvm.masked.load.v16i32(<16 x i32>*, i32, <16 x i1>, <16 x i32>) +declare <4 x i32> @llvm.masked.load.v4i32(<4 x i32>*, i32, <4 x i1>, <4 x i32>) +declare <2 x i32> @llvm.masked.load.v2i32(<2 x i32>*, i32, <2 x i1>, <2 x i32>) +declare void @llvm.masked.store.v16i32(<16 x i32>, <16 x i32>*, i32, <16 x i1>) +declare void @llvm.masked.store.v8i32(<8 x i32>, <8 x i32>*, i32, <8 x i1>) +declare void @llvm.masked.store.v4i32(<4 x i32>, <4 x i32>*, i32, <4 x i1>) +declare void @llvm.masked.store.v2f32(<2 x float>, <2 x float>*, i32, <2 x i1>) +declare void @llvm.masked.store.v2i32(<2 x i32>, <2 x i32>*, i32, <2 x i1>) +declare void @llvm.masked.store.v16f32(<16 x float>, <16 x float>*, i32, <16 x i1>) +declare void @llvm.masked.store.v16f32p(<16 x float>*, <16 x float>**, i32, <16 x i1>) +declare <16 x float> @llvm.masked.load.v16f32(<16 x float>*, i32, <16 x i1>, <16 x float>) +declare <8 x float> @llvm.masked.load.v8f32(<8 x float>*, i32, <8 x i1>, <8 x float>) +declare <4 x float> @llvm.masked.load.v4f32(<4 x float>*, i32, <4 x i1>, <4 x float>) +declare <2 x float> @llvm.masked.load.v2f32(<2 x float>*, i32, <2 x i1>, <2 x float>) +declare <8 x double> @llvm.masked.load.v8f64(<8 x double>*, i32, <8 x i1>, <8 x double>) +declare <4 x double> @llvm.masked.load.v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>) +declare <2 x double> @llvm.masked.load.v2f64(<2 x double>*, i32, <2 x i1>, <2 x double>) +declare void @llvm.masked.store.v8f64(<8 x double>, <8 x double>*, i32, <8 x i1>) +declare void @llvm.masked.store.v2f64(<2 x double>, <2 x double>*, i32, <2 x i1>) +declare void @llvm.masked.store.v2i64(<2 x i64>, <2 x i64>*, i32, <2 x i1>) + diff --git a/test/Analysis/CostModel/X86/vselect-cost.ll b/test/Analysis/CostModel/X86/vselect-cost.ll index 2416777..b7e56ef 100644 --- a/test/Analysis/CostModel/X86/vselect-cost.ll +++ b/test/Analysis/CostModel/X86/vselect-cost.ll @@ -11,7 +11,7 @@ define <2 x i64> @test_2i64(<2 x i64> %a, <2 x i64> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_2i64': -; SSE2: Cost Model: {{.*}} 4 for instruction: %sel = select <2 x i1> +; SSE2: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; SSE41: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> @@ -21,7 +21,7 @@ define <2 x i64> @test_2i64(<2 x i64> %a, <2 x i64> %b) { define <2 x double> @test_2double(<2 x double> %a, <2 x double> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_2double': -; SSE2: Cost Model: {{.*}} 3 for instruction: %sel = select <2 x i1> +; SSE2: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; SSE41: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <2 x i1> @@ -31,7 +31,7 @@ define <2 x double> @test_2double(<2 x double> %a, <2 x double> %b) { define <4 x i32> @test_4i32(<4 x i32> %a, <4 x i32> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_4i32': -; SSE2: Cost Model: {{.*}} 8 for instruction: %sel = select <4 x i1> +; SSE2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; SSE41: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> @@ -41,7 +41,7 @@ define <4 x i32> @test_4i32(<4 x i32> %a, <4 x i32> %b) { define <4 x float> @test_4float(<4 x float> %a, <4 x float> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_4float': -; SSE2: Cost Model: {{.*}} 7 for instruction: %sel = select <4 x i1> +; SSE2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; SSE41: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> @@ -51,7 +51,7 @@ define <4 x float> @test_4float(<4 x float> %a, <4 x float> %b) { define <16 x i8> @test_16i8(<16 x i8> %a, <16 x i8> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_16i8': -; SSE2: Cost Model: {{.*}} 32 for instruction: %sel = select <16 x i1> +; SSE2: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> ; SSE41: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> @@ -63,7 +63,7 @@ define <16 x i8> @test_16i8(<16 x i8> %a, <16 x i8> %b) { ; <8 x float>. Integers of the same size should also use those instructions. define <4 x i64> @test_4i64(<4 x i64> %a, <4 x i64> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_4i64': -; SSE2: Cost Model: {{.*}} 8 for instruction: %sel = select <4 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <4 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <4 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> @@ -73,7 +73,7 @@ define <4 x i64> @test_4i64(<4 x i64> %a, <4 x i64> %b) { define <4 x double> @test_4double(<4 x double> %a, <4 x double> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_4double': -; SSE2: Cost Model: {{.*}} 6 for instruction: %sel = select <4 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <4 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <4 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <4 x i1> @@ -83,7 +83,7 @@ define <4 x double> @test_4double(<4 x double> %a, <4 x double> %b) { define <8 x i32> @test_8i32(<8 x i32> %a, <8 x i32> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_8i32': -; SSE2: Cost Model: {{.*}} 16 for instruction: %sel = select <8 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <8 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <8 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <8 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <8 x i1> @@ -93,7 +93,7 @@ define <8 x i32> @test_8i32(<8 x i32> %a, <8 x i32> %b) { define <8 x float> @test_8float(<8 x float> %a, <8 x float> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_8float': -; SSE2: Cost Model: {{.*}} 14 for instruction: %sel = select <8 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <8 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <8 x i1> ; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <8 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <8 x i1> @@ -104,10 +104,9 @@ define <8 x float> @test_8float(<8 x float> %a, <8 x float> %b) { ; AVX2 define <16 x i16> @test_16i16(<16 x i16> %a, <16 x i16> %b) { ; CHECK:Printing analysis 'Cost Model Analysis' for function 'test_16i16': -; SSE2: Cost Model: {{.*}} 32 for instruction: %sel = select <16 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <16 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <16 x i1> -;;; FIXME: This AVX cost is obviously wrong. We shouldn't be scalarizing. -; AVX: Cost Model: {{.*}} 32 for instruction: %sel = select <16 x i1> +; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <16 x i1> %sel = select <16 x i1> <i1 true, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 false>, <16 x i16> %a, <16 x i16> %b ret <16 x i16> %sel @@ -115,10 +114,9 @@ define <16 x i16> @test_16i16(<16 x i16> %a, <16 x i16> %b) { define <32 x i8> @test_32i8(<32 x i8> %a, <32 x i8> %b) { ; CHECK: Printing analysis 'Cost Model Analysis' for function 'test_32i8': -; SSE2: Cost Model: {{.*}} 64 for instruction: %sel = select <32 x i1> +; SSE2: Cost Model: {{.*}} 2 for instruction: %sel = select <32 x i1> ; SSE41: Cost Model: {{.*}} 2 for instruction: %sel = select <32 x i1> -;;; FIXME: This AVX cost is obviously wrong. We shouldn't be scalarizing. -; AVX: Cost Model: {{.*}} 64 for instruction: %sel = select <32 x i1> +; AVX: Cost Model: {{.*}} 1 for instruction: %sel = select <32 x i1> ; AVX2: Cost Model: {{.*}} 1 for instruction: %sel = select <32 x i1> %sel = select <32 x i1> <i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true>, <32 x i8> %a, <32 x i8> %b ret <32 x i8> %sel diff --git a/test/Analysis/CostModel/no_info.ll b/test/Analysis/CostModel/no_info.ll index f3f165b..5f3b56a 100644 --- a/test/Analysis/CostModel/no_info.ll +++ b/test/Analysis/CostModel/no_info.ll @@ -1,11 +1,12 @@ ; RUN: opt < %s -cost-model -analyze | FileCheck %s -; The cost model does not have any target information so it can't make a decision. +; The cost model does not have any target information so it just makes boring +; assumptions. ; -- No triple in this module -- -;CHECK: Unknown cost {{.*}} add -;CHECK: Unknown cost {{.*}} ret +;CHECK: cost of 1 {{.*}} add +;CHECK: cost of 1 {{.*}} ret define i32 @no_info(i32 %arg) { %e = add i32 %arg, %arg ret i32 %e diff --git a/test/Analysis/Dominators/basic.ll b/test/Analysis/Dominators/basic.ll new file mode 100644 index 0000000..353c339 --- /dev/null +++ b/test/Analysis/Dominators/basic.ll @@ -0,0 +1,60 @@ +; RUN: opt < %s -domtree -analyze | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-OLDPM +; RUN: opt < %s -disable-output -passes='print<domtree>' 2>&1 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-NEWPM + +define void @test1() { +; CHECK-OLDPM-LABEL: 'Dominator Tree Construction' for function 'test1': +; CHECK-NEWPM-LABEL: DominatorTree for function: test1 +; CHECK: [1] %entry +; CHECK-NEXT: [2] %a +; CHECK-NEXT: [2] %c +; CHECK-NEXT: [3] %d +; CHECK-NEXT: [3] %e +; CHECK-NEXT: [2] %b + +entry: + br i1 undef, label %a, label %b + +a: + br label %c + +b: + br label %c + +c: + br i1 undef, label %d, label %e + +d: + ret void + +e: + ret void +} + +define void @test2() { +; CHECK-OLDPM-LABEL: 'Dominator Tree Construction' for function 'test2': +; CHECK-NEWPM-LABEL: DominatorTree for function: test2 +; CHECK: [1] %entry +; CHECK-NEXT: [2] %a +; CHECK-NEXT: [3] %b +; CHECK-NEXT: [4] %c +; CHECK-NEXT: [5] %d +; CHECK-NEXT: [5] %ret + +entry: + br label %a + +a: + br label %b + +b: + br i1 undef, label %a, label %c + +c: + br i1 undef, label %d, label %ret + +d: + br i1 undef, label %a, label %ret + +ret: + ret void +} diff --git a/test/Analysis/Lint/cppeh-catch-intrinsics-clean.ll b/test/Analysis/Lint/cppeh-catch-intrinsics-clean.ll new file mode 100644 index 0000000..e398d71 --- /dev/null +++ b/test/Analysis/Lint/cppeh-catch-intrinsics-clean.ll @@ -0,0 +1,109 @@ +; RUN: opt -lint -disable-output < %s + +; This test is meant to prove that the verifier does not report errors for correct +; use of the llvm.eh.begincatch and llvm.eh.endcatch intrinsics. + +target triple = "x86_64-pc-windows-msvc" + +declare i8* @llvm.eh.begincatch(i8*) + +declare void @llvm.eh.endcatch() + +@_ZTIi = external constant i8* + +; Function Attrs: uwtable +define void @test_ref_clean() { +entry: + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + +catch: ; preds = %lpad + %2 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @_Z10handle_intv() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + resume { i8*, i32 } %0 +} + +; Function Attrs: uwtable +define void @test_ref_clean_multibranch() { +entry: + invoke void @_Z9may_throwv() + to label %invoke.cont unwind label %lpad + +invoke.cont: + invoke void @_Z9may_throwv() + to label %invoke.cont unwind label %lpad1 + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad1: ; preds = %entry + %l1.0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + cleanup + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn1 = extractvalue { i8*, i32 } %l1.0, 0 + %sel1 = extractvalue { i8*, i32 } %l1.0, 1 + %l1.1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matchesl1 = icmp eq i32 %sel1, %l1.1 + br i1 %matchesl1, label %catch, label %eh.resume + +catch: ; preds = %lpad, %lpad1 + %exn2 = phi i8* [%exn, %lpad], [%exn1, %lpad1] + %sel2 = phi i32 [%sel, %lpad], [%sel1, %lpad1] + %3 = call i8* @llvm.eh.begincatch(i8* %exn2) + call void @_Z10handle_intv() + %matches1 = icmp eq i32 %sel2, 0 + br i1 %matches1, label %invoke.cont2, label %invoke.cont3 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +invoke.cont3: ; preds = %catch + call void @llvm.eh.endcatch() + br label %eh.resume + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + %lpad.val = insertvalue { i8*, i32 } undef, i32 0, 1 + resume { i8*, i32 } %lpad.val +} + +declare void @_Z9may_throwv() + +declare i32 @__CxxFrameHandler3(...) + +; Function Attrs: nounwind readnone +declare i32 @llvm.eh.typeid.for(i8*) + +declare void @_Z10handle_intv() + diff --git a/test/Analysis/Lint/cppeh-catch-intrinsics.ll b/test/Analysis/Lint/cppeh-catch-intrinsics.ll new file mode 100644 index 0000000..5ab73e35 --- /dev/null +++ b/test/Analysis/Lint/cppeh-catch-intrinsics.ll @@ -0,0 +1,278 @@ +; RUN: opt -lint -disable-output < %s 2>&1 | FileCheck %s + +; This test is meant to prove that the Verifier is able to identify a variety +; of errors with the llvm.eh.begincatch and llvm.eh.endcatch intrinsics. +; See cppeh-catch-intrinsics-clean for correct uses. + +target triple = "x86_64-pc-windows-msvc" + +declare i8* @llvm.eh.begincatch(i8*) + +declare void @llvm.eh.endcatch() + +@_ZTIi = external constant i8* + +; Function Attrs: uwtable +define void @test_missing_endcatch() { +; CHECK: Some paths from llvm.eh.begincatch may not reach llvm.eh.endcatch +; CHECK-NEXT: %2 = call i8* @llvm.eh.begincatch(i8* %exn) +entry: + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + +catch: ; preds = %lpad + %2 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @_Z10handle_intv() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + resume { i8*, i32 } %0 +} + +; Function Attrs: uwtable +define void @test_missing_begincatch() { +; CHECK: llvm.eh.endcatch may be reachable without passing llvm.eh.begincatch +; CHECK-NEXT: call void @llvm.eh.endcatch() +entry: + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + +catch: ; preds = %lpad + call void @_Z10handle_intv() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + resume { i8*, i32 } %0 +} + +; Function Attrs: uwtable +define void @test_multiple_begin() { +; CHECK: llvm.eh.begincatch may be called a second time before llvm.eh.endcatch +; CHECK-NEXT: %2 = call i8* @llvm.eh.begincatch(i8* %exn) +; CHECK-NEXT: %3 = call i8* @llvm.eh.begincatch(i8* %exn) +entry: + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + +catch: ; preds = %lpad + %2 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @_Z10handle_intv() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + %3 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @llvm.eh.endcatch() + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + resume { i8*, i32 } %0 +} + +; Function Attrs: uwtable +define void @test_multiple_end() { +; CHECK: llvm.eh.endcatch may be called a second time after llvm.eh.begincatch +; CHECK-NEXT: call void @llvm.eh.endcatch() +; CHECK-NEXT: call void @llvm.eh.endcatch() +entry: + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + +catch: ; preds = %lpad + %2 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @_Z10handle_intv() + call void @llvm.eh.endcatch() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + resume { i8*, i32 } %0 +} + + +; Function Attrs: uwtable +define void @test_begincatch_without_lpad() { +; CHECK: llvm.eh.begincatch may be reachable without passing a landingpad +; CHECK-NEXT: %0 = call i8* @llvm.eh.begincatch(i8* %exn) +entry: + %exn = alloca i8 + %0 = call i8* @llvm.eh.begincatch(i8* %exn) + call void @_Z10handle_intv() + br label %invoke.cont2 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +try.cont: ; preds = %invoke.cont2, %entry + ret void +} + +; Function Attrs: uwtable +define void @test_branch_to_begincatch_with_no_lpad(i32 %fake.sel) { +; CHECK: llvm.eh.begincatch may be reachable without passing a landingpad +; CHECK-NEXT: %3 = call i8* @llvm.eh.begincatch(i8* %exn2) +entry: + %fake.exn = alloca i8 + invoke void @_Z9may_throwv() + to label %catch unwind label %lpad + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +catch: ; preds = %lpad, %entry + %exn2 = phi i8* [%exn, %lpad], [%fake.exn, %entry] + %sel2 = phi i32 [%sel, %lpad], [%fake.sel, %entry] + %3 = call i8* @llvm.eh.begincatch(i8* %exn2) + call void @_Z10handle_intv() + %matches1 = icmp eq i32 %sel2, 0 + br i1 %matches1, label %invoke.cont2, label %invoke.cont3 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +invoke.cont3: ; preds = %catch + call void @llvm.eh.endcatch() + br label %eh.resume + +try.cont: ; preds = %invoke.cont2 + ret void + +eh.resume: ; preds = %catch.dispatch + %lpad.val = insertvalue { i8*, i32 } undef, i32 0, 1 + resume { i8*, i32 } %lpad.val +} + +; Function Attrs: uwtable +define void @test_branch_missing_endcatch() { +; CHECK: Some paths from llvm.eh.begincatch may not reach llvm.eh.endcatch +; CHECK-NEXT: %3 = call i8* @llvm.eh.begincatch(i8* %exn2) +entry: + invoke void @_Z9may_throwv() + to label %invoke.cont unwind label %lpad + +invoke.cont: + invoke void @_Z9may_throwv() + to label %invoke.cont unwind label %lpad1 + +lpad: ; preds = %entry + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn = extractvalue { i8*, i32 } %0, 0 + %sel = extractvalue { i8*, i32 } %0, 1 + %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matches = icmp eq i32 %sel, %1 + br i1 %matches, label %catch, label %eh.resume + + invoke void @_Z9may_throwv() + to label %try.cont unwind label %lpad + +lpad1: ; preds = %entry + %l1.0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) + cleanup + catch i8* bitcast (i8** @_ZTIi to i8*) + %exn1 = extractvalue { i8*, i32 } %l1.0, 0 + %sel1 = extractvalue { i8*, i32 } %l1.0, 1 + %l1.1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) + %matchesl1 = icmp eq i32 %sel1, %l1.1 + br i1 %matchesl1, label %catch, label %eh.resume + +catch: ; preds = %lpad, %lpad1 + %exn2 = phi i8* [%exn, %lpad], [%exn1, %lpad1] + %sel2 = phi i32 [%sel, %lpad], [%sel1, %lpad1] + %3 = call i8* @llvm.eh.begincatch(i8* %exn2) + call void @_Z10handle_intv() + %matches1 = icmp eq i32 %sel2, 0 + br i1 %matches1, label %invoke.cont2, label %invoke.cont3 + +invoke.cont2: ; preds = %catch + call void @llvm.eh.endcatch() + br label %try.cont + +invoke.cont3: ; preds = %catch + br label %eh.resume + +try.cont: ; preds = %invoke.cont2, %entry + ret void + +eh.resume: ; preds = %catch.dispatch + %lpad.val = insertvalue { i8*, i32 } undef, i32 0, 1 + resume { i8*, i32 } %lpad.val +} + +declare void @_Z9may_throwv() + +declare i32 @__CxxFrameHandler3(...) + +; Function Attrs: nounwind readnone +declare i32 @llvm.eh.typeid.for(i8*) + +declare void @_Z10handle_intv() + diff --git a/test/Analysis/LoopAccessAnalysis/backward-dep-different-types.ll b/test/Analysis/LoopAccessAnalysis/backward-dep-different-types.ll new file mode 100644 index 0000000..f503a5c --- /dev/null +++ b/test/Analysis/LoopAccessAnalysis/backward-dep-different-types.ll @@ -0,0 +1,50 @@ +; RUN: opt -loop-accesses -analyze < %s | FileCheck %s + +; In this loop just because we access A through different types (int, float) +; we still have a dependence cycle: +; +; for (i = 0; i < n; i++) { +; A_float = (float *) A; +; A_float[i + 1] = A[i] * B[i]; +; } + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.10.0" + +; CHECK: Report: unsafe dependent memory operations in loop +; CHECK-NOT: Memory dependences are safe + +@n = global i32 20, align 4 +@B = common global i32* null, align 8 +@A = common global i32* null, align 8 + +define void @f() { +entry: + %a = load i32** @A, align 8 + %b = load i32** @B, align 8 + br label %for.body + +for.body: ; preds = %for.body, %entry + %storemerge3 = phi i64 [ 0, %entry ], [ %add, %for.body ] + + %arrayidxA = getelementptr inbounds i32* %a, i64 %storemerge3 + %loadA = load i32* %arrayidxA, align 2 + + %arrayidxB = getelementptr inbounds i32* %b, i64 %storemerge3 + %loadB = load i32* %arrayidxB, align 2 + + %mul = mul i32 %loadB, %loadA + + %add = add nuw nsw i64 %storemerge3, 1 + + %a_float = bitcast i32* %a to float* + %arrayidxA_plus_2 = getelementptr inbounds float* %a_float, i64 %add + %mul_float = sitofp i32 %mul to float + store float %mul_float, float* %arrayidxA_plus_2, align 2 + + %exitcond = icmp eq i64 %add, 20 + br i1 %exitcond, label %for.end, label %for.body + +for.end: ; preds = %for.body + ret void +} diff --git a/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-no-dbg.ll b/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-no-dbg.ll new file mode 100644 index 0000000..62291d5 --- /dev/null +++ b/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-no-dbg.ll @@ -0,0 +1,60 @@ +; RUN: opt -loop-accesses -analyze < %s | FileCheck %s + +; FIXME: This is the non-debug version of unsafe-and-rt-checks.ll not +; requiring "asserts". Once we can check memory dependences without -debug, +; we should remove this test. + +; Analyze this loop: +; for (i = 0; i < n; i++) +; A[i + 1] = A[i] * B[i] * C[i]; + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.10.0" + +; CHECK: Report: unsafe dependent memory operations in loop + +; CHECK: Run-time memory checks: +; CHECK-NEXT: 0: +; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add +; CHECK-NEXT: %arrayidxB = getelementptr inbounds i16* %b, i64 %storemerge3 +; CHECK-NEXT: 1: +; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add +; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16* %c, i64 %storemerge3 + +@n = global i32 20, align 4 +@B = common global i16* null, align 8 +@A = common global i16* null, align 8 +@C = common global i16* null, align 8 + +define void @f() { +entry: + %a = load i16** @A, align 8 + %b = load i16** @B, align 8 + %c = load i16** @C, align 8 + br label %for.body + +for.body: ; preds = %for.body, %entry + %storemerge3 = phi i64 [ 0, %entry ], [ %add, %for.body ] + + %arrayidxA = getelementptr inbounds i16* %a, i64 %storemerge3 + %loadA = load i16* %arrayidxA, align 2 + + %arrayidxB = getelementptr inbounds i16* %b, i64 %storemerge3 + %loadB = load i16* %arrayidxB, align 2 + + %arrayidxC = getelementptr inbounds i16* %c, i64 %storemerge3 + %loadC = load i16* %arrayidxC, align 2 + + %mul = mul i16 %loadB, %loadA + %mul1 = mul i16 %mul, %loadC + + %add = add nuw nsw i64 %storemerge3, 1 + %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add + store i16 %mul1, i16* %arrayidxA_plus_2, align 2 + + %exitcond = icmp eq i64 %add, 20 + br i1 %exitcond, label %for.end, label %for.body + +for.end: ; preds = %for.body + ret void +} diff --git a/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll b/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll new file mode 100644 index 0000000..4769a3a --- /dev/null +++ b/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll @@ -0,0 +1,61 @@ +; RUN: opt -loop-accesses -analyze < %s | FileCheck %s +; RUN: opt -loop-accesses -analyze -debug-only=loop-accesses < %s 2>&1 | FileCheck %s --check-prefix=DEBUG +; REQUIRES: asserts + +; Analyze this loop: +; for (i = 0; i < n; i++) +; A[i + 1] = A[i] * B[i] * C[i]; + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.10.0" + +; CHECK: Report: unsafe dependent memory operations in loop + +; DEBUG: LAA: Distance for %loadA = load i16* %arrayidxA, align 2 to store i16 %mul1, i16* %arrayidxA_plus_2, align 2: 2 +; DEBUG-NEXT: LAA: Failure because of Positive distance 2 + +; CHECK: Run-time memory checks: +; CHECK-NEXT: 0: +; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add +; CHECK-NEXT: %arrayidxB = getelementptr inbounds i16* %b, i64 %storemerge3 +; CHECK-NEXT: 1: +; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add +; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16* %c, i64 %storemerge3 + +@n = global i32 20, align 4 +@B = common global i16* null, align 8 +@A = common global i16* null, align 8 +@C = common global i16* null, align 8 + +define void @f() { +entry: + %a = load i16** @A, align 8 + %b = load i16** @B, align 8 + %c = load i16** @C, align 8 + br label %for.body + +for.body: ; preds = %for.body, %entry + %storemerge3 = phi i64 [ 0, %entry ], [ %add, %for.body ] + + %arrayidxA = getelementptr inbounds i16* %a, i64 %storemerge3 + %loadA = load i16* %arrayidxA, align 2 + + %arrayidxB = getelementptr inbounds i16* %b, i64 %storemerge3 + %loadB = load i16* %arrayidxB, align 2 + + %arrayidxC = getelementptr inbounds i16* %c, i64 %storemerge3 + %loadC = load i16* %arrayidxC, align 2 + + %mul = mul i16 %loadB, %loadA + %mul1 = mul i16 %mul, %loadC + + %add = add nuw nsw i64 %storemerge3, 1 + %arrayidxA_plus_2 = getelementptr inbounds i16* %a, i64 %add + store i16 %mul1, i16* %arrayidxA_plus_2, align 2 + + %exitcond = icmp eq i64 %add, 20 + br i1 %exitcond, label %for.end, label %for.body + +for.end: ; preds = %for.body + ret void +} diff --git a/test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll b/test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll index a87bab7..599b3e4 100644 --- a/test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll +++ b/test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll @@ -2,6 +2,7 @@ ; not a child of the loopentry.6 loop. ; ; RUN: opt < %s -analyze -loops | FileCheck %s +; RUN: opt < %s -passes='print<loops>' -disable-output 2>&1 | FileCheck %s ; CHECK: Loop at depth 4 containing: %loopentry.7<header><latch><exiting> diff --git a/test/Analysis/ScalarEvolution/incorrect-nsw.ll b/test/Analysis/ScalarEvolution/incorrect-nsw.ll new file mode 100644 index 0000000..dd981c4 --- /dev/null +++ b/test/Analysis/ScalarEvolution/incorrect-nsw.ll @@ -0,0 +1,26 @@ +; RUN: opt -analyze -scalar-evolution -scalar-evolution < %s | FileCheck %s + +define void @bad.nsw() { +; CHECK-LABEL: Classifying expressions for: @bad.nsw +; CHECK-LABEL: Classifying expressions for: @bad.nsw + entry: + br label %loop + + loop: + %i = phi i8 [ -1, %entry ], [ %i.inc, %loop ] +; CHECK: %i = phi i8 [ -1, %entry ], [ %i.inc, %loop ] +; CHECK-NEXT: --> {-1,+,-128}<nw><%loop> +; CHECK-NOT: --> {-1,+,-128}<nsw><%loop> + + %counter = phi i8 [ 0, %entry ], [ %counter.inc, %loop ] + + %i.inc = add i8 %i, -128 + %i.sext = sext i8 %i to i16 + + %counter.inc = add i8 %counter, 1 + %continue = icmp eq i8 %counter, 1 + br i1 %continue, label %exit, label %loop + + exit: + ret void +} diff --git a/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll b/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll new file mode 100644 index 0000000..c9689f7 --- /dev/null +++ b/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll @@ -0,0 +1,101 @@ +; ; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s + +define void @infer.sext.0(i1* %c, i32 %start) { +; CHECK-LABEL: Classifying expressions for: @infer.sext.0 + entry: + br label %loop + + loop: + %counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ] + %idx = phi i32 [ %start, %entry ], [ %idx.inc, %loop ] + %idx.inc = add nsw i32 %idx, 1 + %idx.inc.sext = sext i32 %idx.inc to i64 +; CHECK: %idx.inc.sext = sext i32 %idx.inc to i64 +; CHECK-NEXT: --> {(1 + (sext i32 %start to i64)),+,1}<nsw><%loop> + %condition = icmp eq i32 %counter, 1 + %counter.inc = add i32 %counter, 1 + br i1 %condition, label %exit, label %loop + + exit: + ret void +} + +define void @infer.zext.0(i1* %c, i32 %start) { +; CHECK-LABEL: Classifying expressions for: @infer.zext.0 + entry: + br label %loop + + loop: + %counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ] + %idx = phi i32 [ %start, %entry ], [ %idx.inc, %loop ] + %idx.inc = add nuw i32 %idx, 1 + %idx.inc.sext = zext i32 %idx.inc to i64 +; CHECK: %idx.inc.sext = zext i32 %idx.inc to i64 +; CHECK-NEXT: --> {(1 + (zext i32 %start to i64)),+,1}<nuw><%loop> + %condition = icmp eq i32 %counter, 1 + %counter.inc = add i32 %counter, 1 + br i1 %condition, label %exit, label %loop + + exit: + ret void +} + +define void @infer.sext.1(i32 %start, i1* %c) { +; CHECK-LABEL: Classifying expressions for: @infer.sext.1 + entry: + %start.mul = mul i32 %start, 4 + %start.real = add i32 %start.mul, 2 + br label %loop + + loop: + %idx = phi i32 [ %start.real, %entry ], [ %idx.inc, %loop ] + %idx.sext = sext i32 %idx to i64 +; CHECK: %idx.sext = sext i32 %idx to i64 +; CHECK-NEXT: --> {(2 + (sext i32 (4 * %start) to i64)),+,2}<nsw><%loop> + %idx.inc = add nsw i32 %idx, 2 + %condition = load i1* %c + br i1 %condition, label %exit, label %loop + + exit: + ret void +} + +define void @infer.sext.2(i1* %c, i8 %start) { +; CHECK-LABEL: Classifying expressions for: @infer.sext.2 + entry: + %start.inc = add i8 %start, 1 + %entry.condition = icmp slt i8 %start, 127 + br i1 %entry.condition, label %loop, label %exit + + loop: + %idx = phi i8 [ %start.inc, %entry ], [ %idx.inc, %loop ] + %idx.sext = sext i8 %idx to i16 +; CHECK: %idx.sext = sext i8 %idx to i16 +; CHECK-NEXT: --> {(1 + (sext i8 %start to i16)),+,1}<nsw><%loop> + %idx.inc = add nsw i8 %idx, 1 + %condition = load volatile i1* %c + br i1 %condition, label %exit, label %loop + + exit: + ret void +} + +define void @infer.zext.1(i1* %c, i8 %start) { +; CHECK-LABEL: Classifying expressions for: @infer.zext.1 + entry: + %start.inc = add i8 %start, 1 + %entry.condition = icmp ult i8 %start, 255 + br i1 %entry.condition, label %loop, label %exit + + loop: + %idx = phi i8 [ %start.inc, %entry ], [ %idx.inc, %loop ] + %idx.zext = zext i8 %idx to i16 +; CHECK: %idx.zext = zext i8 %idx to i16 +; CHECK-NEXT: --> {(1 + (zext i8 %start to i16)),+,1}<nuw><%loop> + %idx.inc = add nuw i8 %idx, 1 + %condition = load volatile i1* %c + br i1 %condition, label %exit, label %loop + + exit: + ret void +} diff --git a/test/Analysis/ScalarEvolution/load-with-range-metadata.ll b/test/Analysis/ScalarEvolution/load-with-range-metadata.ll index 2f6dcd0..32c1074 100644 --- a/test/Analysis/ScalarEvolution/load-with-range-metadata.ll +++ b/test/Analysis/ScalarEvolution/load-with-range-metadata.ll @@ -34,4 +34,4 @@ define i32 @ult_trip_count_with_range(i32 *%ptr0, i32 *%ptr1) { ret i32 0 } -!0 = metadata !{i32 1, i32 100} +!0 = !{i32 1, i32 100} diff --git a/test/Analysis/ScalarEvolution/min-max-exprs.ll b/test/Analysis/ScalarEvolution/min-max-exprs.ll new file mode 100644 index 0000000..3e0a35d --- /dev/null +++ b/test/Analysis/ScalarEvolution/min-max-exprs.ll @@ -0,0 +1,53 @@ +; RUN: opt -scalar-evolution -analyze < %s | FileCheck %s +; +; This checks if the min and max expressions are properly recognized by +; ScalarEvolution even though they the ICmpInst and SelectInst have different +; types. +; +; #define max(a, b) (a > b ? a : b) +; #define min(a, b) (a < b ? a : b) +; +; void f(int *A, int N) { +; for (int i = 0; i < N; i++) { +; A[max(0, i - 3)] = A[min(N, i + 3)] * 2; +; } +; } +; +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + +define void @f(i32* %A, i32 %N) { +bb: + br label %bb1 + +bb1: ; preds = %bb2, %bb + %i.0 = phi i32 [ 0, %bb ], [ %tmp23, %bb2 ] + %i.0.1 = sext i32 %i.0 to i64 + %tmp = icmp slt i32 %i.0, %N + br i1 %tmp, label %bb2, label %bb24 + +bb2: ; preds = %bb1 + %tmp3 = add nuw nsw i32 %i.0, 3 + %tmp4 = icmp slt i32 %tmp3, %N + %tmp5 = sext i32 %tmp3 to i64 + %tmp6 = sext i32 %N to i64 + %tmp9 = select i1 %tmp4, i64 %tmp5, i64 %tmp6 +; min(N, i+3) +; CHECK: select i1 %tmp4, i64 %tmp5, i64 %tmp6 +; CHECK-NEXT: --> (-1 + (-1 * ((-1 + (-1 * (sext i32 {3,+,1}<nw><%bb1> to i64))) smax (-1 + (-1 * (sext i32 %N to i64)))))) + %tmp11 = getelementptr inbounds i32* %A, i64 %tmp9 + %tmp12 = load i32* %tmp11, align 4 + %tmp13 = shl nsw i32 %tmp12, 1 + %tmp14 = icmp sge i32 3, %i.0 + %tmp17 = add nsw i64 %i.0.1, -3 + %tmp19 = select i1 %tmp14, i64 0, i64 %tmp17 +; max(0, i - 3) +; CHECK: select i1 %tmp14, i64 0, i64 %tmp17 +; CHECK-NEXT: --> (-3 + (3 smax {0,+,1}<nuw><nsw><%bb1>)) + %tmp21 = getelementptr inbounds i32* %A, i64 %tmp19 + store i32 %tmp13, i32* %tmp21, align 4 + %tmp23 = add nuw nsw i32 %i.0, 1 + br label %bb1 + +bb24: ; preds = %bb1 + ret void +} diff --git a/test/Analysis/ScalarEvolution/nw-sub-is-not-nw-add.ll b/test/Analysis/ScalarEvolution/nw-sub-is-not-nw-add.ll new file mode 100644 index 0000000..41b07d5 --- /dev/null +++ b/test/Analysis/ScalarEvolution/nw-sub-is-not-nw-add.ll @@ -0,0 +1,41 @@ +; RUN: opt -S -indvars < %s | FileCheck %s + +; Check that SCEV does not assume sub nuw X Y == add nuw X, -Y +define void @f(i32* %loc) { +; CHECK-LABEL: @f + entry: + br label %loop + + loop: + %idx = phi i32 [ 6, %entry ], [ %idx.dec, %loop ] + store i32 %idx, i32* %loc + %idx.dec = sub nuw i32 %idx, 1 + %cond = icmp uge i32 %idx.dec, 5 + br i1 %cond, label %loop, label %exit +; CHECK-NOT: br i1 true, label %loop, label %exit + + exit: + ret void +} + +declare void @use_i1(i1) + +; Check that SCEV does not assume sub nsw X Y == add nsw X, -Y +define void @g(i32 %lim) { +; CHECK-LABEL: @g + entry: + br label %loop + + loop: + %idx = phi i32 [ -1, %entry ], [ %idx.dec, %loop ] + %t = icmp sgt i32 %idx, 0 +; CHECK-NOT: call void @use_i1(i1 false) +; CHECK: call void @use_i1(i1 %t) + call void @use_i1(i1 %t) + %idx.dec = sub nsw i32 %idx, -2147483648 + %cond = icmp eq i32 %idx.dec, %lim + br i1 %cond, label %loop, label %exit + + exit: + ret void +} diff --git a/test/Analysis/ScalarEvolution/pr22179.ll b/test/Analysis/ScalarEvolution/pr22179.ll new file mode 100644 index 0000000..d9fb510 --- /dev/null +++ b/test/Analysis/ScalarEvolution/pr22179.ll @@ -0,0 +1,28 @@ +; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s + +%struct.anon = type { i8 } +%struct.S = type { i32 } + +@a = common global %struct.anon zeroinitializer, align 1 +@b = common global %struct.S zeroinitializer, align 4 + +; Function Attrs: nounwind ssp uwtable +define i32 @main() { +; CHECK-LABEL: Classifying expressions for: @main + store i8 0, i8* getelementptr inbounds (%struct.anon* @a, i64 0, i32 0), align 1 + br label %loop + +loop: + %storemerge1 = phi i8 [ 0, %0 ], [ %inc, %loop ] + %m = load volatile i32* getelementptr inbounds (%struct.S* @b, i64 0, i32 0), align 4 + %inc = add nuw i8 %storemerge1, 1 +; CHECK: %inc = add nuw i8 %storemerge1, 1 +; CHECK-NEXT: --> {1,+,1}<nuw><%loop> +; CHECK-NOT: --> {1,+,1}<nuw><nsw><%loop> + %exitcond = icmp eq i8 %inc, -128 + br i1 %exitcond, label %exit, label %loop + +exit: + store i8 -128, i8* getelementptr inbounds (%struct.anon* @a, i64 0, i32 0), align 1 + ret i32 0 +} diff --git a/test/Analysis/ScalarEvolution/pr22641.ll b/test/Analysis/ScalarEvolution/pr22641.ll new file mode 100644 index 0000000..3b55afe --- /dev/null +++ b/test/Analysis/ScalarEvolution/pr22641.ll @@ -0,0 +1,25 @@ +; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s + +define i1 @main(i16 %a) { +; CHECK-LABEL: Classifying expressions for: @main +entry: + br label %body + +body: + %dec2 = phi i16 [ %a, %entry ], [ %dec, %cond ] + %dec = add i16 %dec2, -1 + %conv2 = zext i16 %dec2 to i32 + %conv = zext i16 %dec to i32 +; CHECK: %conv = zext i16 %dec to i32 +; CHECK-NEXT: --> {(zext i16 (-1 + %a) to i32),+,65535}<nuw><%body> +; CHECK-NOT: --> {(65535 + (zext i16 %a to i32)),+,65535}<nuw><%body> + + br label %cond + +cond: + br i1 false, label %body, label %exit + +exit: + %ret = icmp ne i32 %conv, 0 + ret i1 %ret +} diff --git a/test/Analysis/ScalarEvolution/pr22674.ll b/test/Analysis/ScalarEvolution/pr22674.ll new file mode 100644 index 0000000..7defcb9 --- /dev/null +++ b/test/Analysis/ScalarEvolution/pr22674.ll @@ -0,0 +1,101 @@ +; RUN: opt -loop-reduce -S %s + + +target datalayout = "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-linux-gnux32" + +%"class.llvm::AttributeSetNode.230.2029.3828.6141.6912.7683.8454.9482.9996.10253.18506" = type { %"class.llvm::FoldingSetImpl::Node.1.1801.3600.5913.6684.7455.8226.9254.9768.10025.18505", i32 } +%"class.llvm::FoldingSetImpl::Node.1.1801.3600.5913.6684.7455.8226.9254.9768.10025.18505" = type { i8* } +%"struct.std::pair.241.2040.3839.6152.6923.7694.8465.9493.10007.10264.18507" = type { i32, %"class.llvm::AttributeSetNode.230.2029.3828.6141.6912.7683.8454.9482.9996.10253.18506"* } +%"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509" = type { %"class.llvm::AttributeImpl.2.1802.3601.5914.6685.7456.8227.9255.9769.10026.18508"* } +%"class.llvm::AttributeImpl.2.1802.3601.5914.6685.7456.8227.9255.9769.10026.18508" = type <{ i32 (...)**, %"class.llvm::FoldingSetImpl::Node.1.1801.3600.5913.6684.7455.8226.9254.9768.10025.18505", i8, [3 x i8] }> + +; Function Attrs: nounwind uwtable +define void @_ZNK4llvm11AttrBuilder13hasAttributesENS_12AttributeSetEy() #0 align 2 { +entry: + br i1 undef, label %cond.false, label %_ZNK4llvm12AttributeSet11getNumSlotsEv.exit + +_ZNK4llvm12AttributeSet11getNumSlotsEv.exit: ; preds = %entry + br i1 undef, label %cond.false, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge + +for.body.lr.ph.for.body.lr.ph.split_crit_edge: ; preds = %_ZNK4llvm12AttributeSet11getNumSlotsEv.exit + br label %land.lhs.true.i + +land.lhs.true.i: ; preds = %for.inc, %for.body.lr.ph.for.body.lr.ph.split_crit_edge + %I.099 = phi i32 [ 0, %for.body.lr.ph.for.body.lr.ph.split_crit_edge ], [ %inc, %for.inc ] + %cmp.i = icmp ugt i32 undef, %I.099 + br i1 %cmp.i, label %_ZNK4llvm12AttributeSet12getSlotIndexEj.exit, label %cond.false.i.split + +cond.false.i.split: ; preds = %land.lhs.true.i + unreachable + +_ZNK4llvm12AttributeSet12getSlotIndexEj.exit: ; preds = %land.lhs.true.i + br i1 undef, label %for.end, label %for.inc + +for.inc: ; preds = %_ZNK4llvm12AttributeSet12getSlotIndexEj.exit + %inc = add i32 %I.099, 1 + br i1 undef, label %cond.false, label %land.lhs.true.i + +for.end: ; preds = %_ZNK4llvm12AttributeSet12getSlotIndexEj.exit + %I.099.lcssa129 = phi i32 [ %I.099, %_ZNK4llvm12AttributeSet12getSlotIndexEj.exit ] + br i1 undef, label %cond.false, label %_ZNK4llvm12AttributeSet3endEj.exit + +cond.false: ; preds = %for.end, %for.inc, %_ZNK4llvm12AttributeSet11getNumSlotsEv.exit, %entry + unreachable + +_ZNK4llvm12AttributeSet3endEj.exit: ; preds = %for.end + %second.i.i.i = getelementptr inbounds %"struct.std::pair.241.2040.3839.6152.6923.7694.8465.9493.10007.10264.18507"* undef, i32 %I.099.lcssa129, i32 1 + %0 = load %"class.llvm::AttributeSetNode.230.2029.3828.6141.6912.7683.8454.9482.9996.10253.18506"** %second.i.i.i, align 4, !tbaa !2 + %NumAttrs.i.i.i = getelementptr inbounds %"class.llvm::AttributeSetNode.230.2029.3828.6141.6912.7683.8454.9482.9996.10253.18506"* %0, i32 0, i32 1 + %1 = load i32* %NumAttrs.i.i.i, align 4, !tbaa !8 + %add.ptr.i.i.i55 = getelementptr inbounds %"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509"* undef, i32 %1 + br i1 undef, label %return, label %for.body11 + +for.cond9: ; preds = %_ZNK4llvm9Attribute13getKindAsEnumEv.exit + %cmp10 = icmp eq %"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509"* %incdec.ptr, %add.ptr.i.i.i55 + br i1 %cmp10, label %return, label %for.body11 + +for.body11: ; preds = %for.cond9, %_ZNK4llvm12AttributeSet3endEj.exit + %I5.096 = phi %"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509"* [ %incdec.ptr, %for.cond9 ], [ undef, %_ZNK4llvm12AttributeSet3endEj.exit ] + %2 = bitcast %"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509"* %I5.096 to i32* + %3 = load i32* %2, align 4, !tbaa !10 + %tobool.i59 = icmp eq i32 %3, 0 + br i1 %tobool.i59, label %cond.false21, label %_ZNK4llvm9Attribute15isEnumAttributeEv.exit + +_ZNK4llvm9Attribute15isEnumAttributeEv.exit: ; preds = %for.body11 + switch i8 undef, label %cond.false21 [ + i8 0, label %_ZNK4llvm9Attribute13getKindAsEnumEv.exit + i8 1, label %_ZNK4llvm9Attribute13getKindAsEnumEv.exit + i8 2, label %_ZNK4llvm9Attribute15getKindAsStringEv.exit + ] + +_ZNK4llvm9Attribute13getKindAsEnumEv.exit: ; preds = %_ZNK4llvm9Attribute15isEnumAttributeEv.exit, %_ZNK4llvm9Attribute15isEnumAttributeEv.exit + %incdec.ptr = getelementptr inbounds %"class.llvm::Attribute.222.2021.3820.6133.6904.7675.8446.9474.9988.10245.18509"* %I5.096, i32 1 + br i1 undef, label %for.cond9, label %return + +cond.false21: ; preds = %_ZNK4llvm9Attribute15isEnumAttributeEv.exit, %for.body11 + unreachable + +_ZNK4llvm9Attribute15getKindAsStringEv.exit: ; preds = %_ZNK4llvm9Attribute15isEnumAttributeEv.exit + unreachable + +return: ; preds = %_ZNK4llvm9Attribute13getKindAsEnumEv.exit, %for.cond9, %_ZNK4llvm12AttributeSet3endEj.exit + ret void +} + +attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } + +!llvm.module.flags = !{!0} +!llvm.ident = !{!1} + +!0 = !{i32 1, !"PIC Level", i32 2} +!1 = !{!"clang version 3.7.0 (ssh://llvm@gnu-4.sc.intel.com/export/server/git/llvm/clang 4c31740d4f81614b6d278c7825cfdae5a1c78799) (llvm/llvm.git b693958bd09144aed90312709a7e2ccf7124eb53)"} +!2 = !{!3, !7, i64 4} +!3 = !{!"_ZTSSt4pairIjPN4llvm16AttributeSetNodeEE", !4, i64 0, !7, i64 4} +!4 = !{!"int", !5, i64 0} +!5 = !{!"omnipotent char", !6, i64 0} +!6 = !{!"Simple C/C++ TBAA"} +!7 = !{!"any pointer", !5, i64 0} +!8 = !{!9, !4, i64 4} +!9 = !{!"_ZTSN4llvm16AttributeSetNodeE", !4, i64 4} +!10 = !{!7, !7, i64 0} diff --git a/test/Analysis/ScalarEvolution/scev-expander-incorrect-nowrap.ll b/test/Analysis/ScalarEvolution/scev-expander-incorrect-nowrap.ll new file mode 100644 index 0000000..012cad7 --- /dev/null +++ b/test/Analysis/ScalarEvolution/scev-expander-incorrect-nowrap.ll @@ -0,0 +1,30 @@ +; RUN: opt -indvars -S < %s | FileCheck %s + +declare void @use(i32) +declare void @use.i8(i8) + +define void @f() { +; CHECK-LABEL: @f + entry: + br label %loop + + loop: +; The only use for idx.mirror is to induce an nuw for %idx. It does +; not induce an nuw for %idx.inc + %idx.mirror = phi i8 [ -6, %entry ], [ %idx.mirror.inc, %loop ] + %idx = phi i8 [ -5, %entry ], [ %idx.inc, %loop ] + + %idx.sext = sext i8 %idx to i32 + call void @use(i32 %idx.sext) + + %idx.mirror.inc = add nuw i8 %idx.mirror, 1 + call void @use.i8(i8 %idx.mirror.inc) + + %idx.inc = add i8 %idx, 1 +; CHECK-NOT: %indvars.iv.next = add nuw nsw i32 %indvars.iv, 1 + %cmp = icmp ugt i8 %idx.inc, 0 + br i1 %cmp, label %loop, label %exit + + exit: + ret void +} diff --git a/test/Analysis/ScalarEvolution/scev-prestart-nowrap.ll b/test/Analysis/ScalarEvolution/scev-prestart-nowrap.ll new file mode 100644 index 0000000..3ca32bd --- /dev/null +++ b/test/Analysis/ScalarEvolution/scev-prestart-nowrap.ll @@ -0,0 +1,82 @@ +; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s + +; An example run where SCEV(%postinc)->getStart() may overflow: +; +; %start = INT_SMAX +; %low.limit = INT_SMIN +; %high.limit = < not used > +; +; >> entry: +; %postinc.start = INT_SMIN +; +; >> loop: +; %idx = %start +; %postinc = INT_SMIN +; %postinc.inc = INT_SMIN + 1 +; %postinc.sext = sext(INT_SMIN) = i64 INT32_SMIN +; %break.early = INT_SMIN `slt` INT_SMIN = false +; br i1 false, ___, %early.exit +; +; >> early.exit: +; ret i64 INT32_SMIN + + +define i64 @bad.0(i32 %start, i32 %low.limit, i32 %high.limit) { +; CHECK-LABEL: Classifying expressions for: @bad.0 + entry: + %postinc.start = add i32 %start, 1 + br label %loop + + loop: + %idx = phi i32 [ %start, %entry ], [ %idx.inc, %continue ] + %postinc = phi i32 [ %postinc.start, %entry ], [ %postinc.inc, %continue ] + %postinc.inc = add nsw i32 %postinc, 1 + %postinc.sext = sext i32 %postinc to i64 +; CHECK: %postinc.sext = sext i32 %postinc to i64 +; CHECK-NEXT: --> {(sext i32 (1 + %start) to i64),+,1}<nsw><%loop> + %break.early = icmp slt i32 %postinc, %low.limit + br i1 %break.early, label %continue, label %early.exit + + continue: + %idx.inc = add nsw i32 %idx, 1 + %cmp = icmp slt i32 %idx.inc, %high.limit + br i1 %cmp, label %loop, label %exit + + exit: + ret i64 0 + + early.exit: + ret i64 %postinc.sext +} + +define i64 @bad.1(i32 %start, i32 %low.limit, i32 %high.limit, i1* %unknown) { +; CHECK-LABEL: Classifying expressions for: @bad.1 + entry: + %postinc.start = add i32 %start, 1 + br label %loop + + loop: + %idx = phi i32 [ %start, %entry ], [ %idx.inc, %continue ], [ %idx.inc, %continue.1 ] + %postinc = phi i32 [ %postinc.start, %entry ], [ %postinc.inc, %continue ], [ %postinc.inc, %continue.1 ] + %postinc.inc = add nsw i32 %postinc, 1 + %postinc.sext = sext i32 %postinc to i64 +; CHECK: %postinc.sext = sext i32 %postinc to i64 +; CHECK-NEXT: --> {(sext i32 (1 + %start) to i64),+,1}<nsw><%loop> + %break.early = icmp slt i32 %postinc, %low.limit + br i1 %break.early, label %continue.1, label %early.exit + + continue.1: + %cond = load volatile i1* %unknown + %idx.inc = add nsw i32 %idx, 1 + br i1 %cond, label %loop, label %continue + + continue: + %cmp = icmp slt i32 %idx.inc, %high.limit + br i1 %cmp, label %loop, label %exit + + exit: + ret i64 0 + + early.exit: + ret i64 %postinc.sext +} diff --git a/test/Analysis/ScalarEvolution/zext-signed-addrec.ll b/test/Analysis/ScalarEvolution/zext-signed-addrec.ll index 27aed3b..4369820 100644 --- a/test/Analysis/ScalarEvolution/zext-signed-addrec.ll +++ b/test/Analysis/ScalarEvolution/zext-signed-addrec.ll @@ -43,7 +43,7 @@ if.end: ; preds = %if.end, %for.cond1. %shl = and i32 %conv7, 510 store i32 %shl, i32* @c, align 4 -; CHECK: %lsr.iv.next = add i32 %lsr.iv, -258 +; CHECK: %lsr.iv.next = add nsw i32 %lsr.iv, -258 %dec = add i8 %2, -1 %cmp2 = icmp sgt i8 %dec, -1 diff --git a/test/Analysis/ScopedNoAliasAA/basic-domains.ll b/test/Analysis/ScopedNoAliasAA/basic-domains.ll index d88a496..7633a6d 100644 --- a/test/Analysis/ScopedNoAliasAA/basic-domains.ll +++ b/test/Analysis/ScopedNoAliasAA/basic-domains.ll @@ -22,25 +22,25 @@ entry: attributes #0 = { nounwind uwtable } -!0 = metadata !{metadata !0, metadata !"some domain"} -!1 = metadata !{metadata !1, metadata !"some other domain"} +!0 = !{!0, !"some domain"} +!1 = !{!1, !"some other domain"} ; Two scopes (which must be self-referential to avoid being "uniqued"): -!2 = metadata !{metadata !2, metadata !0, metadata !"a scope in dom0"} -!3 = metadata !{metadata !2} +!2 = !{!2, !0, !"a scope in dom0"} +!3 = !{!2} -!4 = metadata !{metadata !4, metadata !0, metadata !"another scope in dom0"} -!5 = metadata !{metadata !4} +!4 = !{!4, !0, !"another scope in dom0"} +!5 = !{!4} ; A list of the two scopes. -!6 = metadata !{metadata !2, metadata !4} +!6 = !{!2, !4} ; Another scope in the second domain -!7 = metadata !{metadata !7, metadata !1, metadata !"another scope in dom1"} -!8 = metadata !{metadata !7} +!7 = !{!7, !1, !"another scope in dom1"} +!8 = !{!7} ; A list of scopes from both domains. -!9 = metadata !{metadata !2, metadata !4, metadata !7} +!9 = !{!2, !4, !7} ; CHECK: NoAlias: %0 = load float* %c, align 4, !alias.scope !0 <-> store float %0, float* %arrayidx.i, align 4, !noalias !6 ; CHECK: NoAlias: %0 = load float* %c, align 4, !alias.scope !0 <-> store float %1, float* %arrayidx.i2, align 4, !noalias !6 diff --git a/test/Analysis/ScopedNoAliasAA/basic.ll b/test/Analysis/ScopedNoAliasAA/basic.ll index 73fe333..bb232b5 100644 --- a/test/Analysis/ScopedNoAliasAA/basic.ll +++ b/test/Analysis/ScopedNoAliasAA/basic.ll @@ -22,6 +22,6 @@ entry: attributes #0 = { nounwind uwtable } -!0 = metadata !{metadata !0, metadata !"some domain"} -!1 = metadata !{metadata !1, metadata !0, metadata !"some scope"} +!0 = !{!0, !"some domain"} +!1 = !{!1, !0, !"some scope"} diff --git a/test/Analysis/ScopedNoAliasAA/basic2.ll b/test/Analysis/ScopedNoAliasAA/basic2.ll index 37b0add..a154b13 100644 --- a/test/Analysis/ScopedNoAliasAA/basic2.ll +++ b/test/Analysis/ScopedNoAliasAA/basic2.ll @@ -32,10 +32,10 @@ entry: attributes #0 = { nounwind uwtable } -!0 = metadata !{metadata !1, metadata !3} -!1 = metadata !{metadata !1, metadata !2, metadata !"some scope"} -!2 = metadata !{metadata !2, metadata !"some domain"} -!3 = metadata !{metadata !3, metadata !2, metadata !"some other scope"} -!4 = metadata !{metadata !1} -!5 = metadata !{metadata !3} +!0 = !{!1, !3} +!1 = !{!1, !2, !"some scope"} +!2 = !{!2, !"some domain"} +!3 = !{!3, !2, !"some other scope"} +!4 = !{!1} +!5 = !{!3} diff --git a/test/Analysis/TypeBasedAliasAnalysis/PR17620.ll b/test/Analysis/TypeBasedAliasAnalysis/PR17620.ll index 9051139..920d6f5 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/PR17620.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/PR17620.ll @@ -32,14 +32,14 @@ attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "n !llvm.ident = !{!0} -!0 = metadata !{metadata !"clang version 3.4"} -!1 = metadata !{metadata !2, metadata !2, i64 0} -!2 = metadata !{metadata !"any pointer", metadata !3, i64 0} -!3 = metadata !{metadata !"omnipotent char", metadata !4, i64 0} -!4 = metadata !{metadata !"Simple C/C++ TBAA"} -!5 = metadata !{metadata !6, metadata !2, i64 8} -!6 = metadata !{metadata !"_ZTSN12_GLOBAL__N_11RINS_1FIPi8TreeIterN1I1S1LENS_1KINS_1DIKS2_S3_EEEEE1GEPSD_EE", metadata !7, i64 8} -!7 = metadata !{metadata !"_ZTSN12_GLOBAL__N_11FIPi8TreeIterN1I1S1LENS_1KINS_1DIKS1_S2_EEEEE1GE", metadata !8, i64 0} -!8 = metadata !{metadata !"_ZTSN12_GLOBAL__N_11DIKPi8TreeIterEE", metadata !2, i64 0, metadata !9, i64 8} -!9 = metadata !{metadata !"_ZTS8TreeIter", metadata !2, i64 8, metadata !10, i64 16} -!10 = metadata !{metadata !"bool", metadata !3, i64 0} +!0 = !{!"clang version 3.4"} +!1 = !{!2, !2, i64 0} +!2 = !{!"any pointer", !3, i64 0} +!3 = !{!"omnipotent char", !4, i64 0} +!4 = !{!"Simple C/C++ TBAA"} +!5 = !{!6, !2, i64 8} +!6 = !{!"_ZTSN12_GLOBAL__N_11RINS_1FIPi8TreeIterN1I1S1LENS_1KINS_1DIKS2_S3_EEEEE1GEPSD_EE", !7, i64 8} +!7 = !{!"_ZTSN12_GLOBAL__N_11FIPi8TreeIterN1I1S1LENS_1KINS_1DIKS1_S2_EEEEE1GE", !8, i64 0} +!8 = !{!"_ZTSN12_GLOBAL__N_11DIKPi8TreeIterEE", !2, i64 0, !9, i64 8} +!9 = !{!"_ZTS8TreeIter", !2, i64 8, !10, i64 16} +!10 = !{!"bool", !3, i64 0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/aliastest.ll b/test/Analysis/TypeBasedAliasAnalysis/aliastest.ll index 76a88c8..10da13a 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/aliastest.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/aliastest.ll @@ -45,23 +45,23 @@ define i8 @test1_no(i8* %a, i8* %b) nounwind { } ; Root note. -!0 = metadata !{ } +!0 = !{ } ; Some type. -!1 = metadata !{metadata !7, metadata !7, i64 0} +!1 = !{!7, !7, i64 0} ; Some other non-aliasing type. -!2 = metadata !{metadata !8, metadata !8, i64 0} +!2 = !{!8, !8, i64 0} ; Some type. -!3 = metadata !{metadata !9, metadata !9, i64 0} +!3 = !{!9, !9, i64 0} ; Some type in a different type system. -!4 = metadata !{metadata !10, metadata !10, i64 0} +!4 = !{!10, !10, i64 0} ; Invariant memory. -!5 = metadata !{metadata !11, metadata !11, i64 0, i1 1} +!5 = !{!11, !11, i64 0, i1 1} ; Not invariant memory. -!6 = metadata !{metadata !11, metadata !11, i64 0, i1 0} -!7 = metadata !{ metadata !"foo", metadata !0 } -!8 = metadata !{ metadata !"bar", metadata !0 } -!9 = metadata !{ metadata !"foo", metadata !0 } -!10 = metadata !{ metadata !"bar", metadata !"different" } -!11 = metadata !{ metadata !"qux", metadata !0} +!6 = !{!11, !11, i64 0, i1 0} +!7 = !{ !"foo", !0 } +!8 = !{ !"bar", !0 } +!9 = !{ !"foo", !0 } +!10 = !{ !"bar", !"different" } +!11 = !{ !"qux", !0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/argument-promotion.ll b/test/Analysis/TypeBasedAliasAnalysis/argument-promotion.ll index 14bbeac..31f775e 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/argument-promotion.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/argument-promotion.ll @@ -32,8 +32,8 @@ define i32 @callercaller(i32* %Q) { ret i32 %X } -!0 = metadata !{metadata !"test"} -!1 = metadata !{metadata !3, metadata !3, i64 0} -!2 = metadata !{metadata !4, metadata !4, i64 0} -!3 = metadata !{metadata !"green", metadata !0} -!4 = metadata !{metadata !"blue", metadata !0} +!0 = !{!"test"} +!1 = !{!3, !3, i64 0} +!2 = !{!4, !4, i64 0} +!3 = !{!"green", !0} +!4 = !{!"blue", !0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/dse.ll b/test/Analysis/TypeBasedAliasAnalysis/dse.ll index 9032fad..09f8feb 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/dse.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/dse.ll @@ -50,23 +50,23 @@ define i8 @test1_no(i8* %a, i8* %b) nounwind { } ; Root note. -!0 = metadata !{ } +!0 = !{ } ; Some type. -!1 = metadata !{metadata !7, metadata !7, i64 0} +!1 = !{!7, !7, i64 0} ; Some other non-aliasing type. -!2 = metadata !{metadata !8, metadata !8, i64 0} +!2 = !{!8, !8, i64 0} ; Some type. -!3 = metadata !{metadata !9, metadata !9, i64 0} +!3 = !{!9, !9, i64 0} ; Some type in a different type system. -!4 = metadata !{metadata !10, metadata !10, i64 0} +!4 = !{!10, !10, i64 0} ; Invariant memory. -!5 = metadata !{metadata !11, metadata !11, i64 0, i1 1} +!5 = !{!11, !11, i64 0, i1 1} ; Not invariant memory. -!6 = metadata !{metadata !11, metadata !11, i64 0, i1 0} -!7 = metadata !{ metadata !"foo", metadata !0 } -!8 = metadata !{ metadata !"bar", metadata !0 } -!9 = metadata !{ metadata !"foo", metadata !0 } -!10 = metadata !{ metadata !"bar", metadata !"different" } -!11 = metadata !{ metadata !"qux", metadata !0} +!6 = !{!11, !11, i64 0, i1 0} +!7 = !{ !"foo", !0 } +!8 = !{ !"bar", !0 } +!9 = !{ !"foo", !0 } +!10 = !{ !"bar", !"different" } +!11 = !{ !"qux", !0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/dynamic-indices.ll b/test/Analysis/TypeBasedAliasAnalysis/dynamic-indices.ll index 4dc4073..732f5d7 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/dynamic-indices.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/dynamic-indices.ll @@ -123,15 +123,15 @@ for.end: ; preds = %for.body ret float %tmp10 } -; CHECK: [[TAG]] = metadata !{metadata [[TYPE_LL:!.*]], metadata [[TYPE_LL]], i64 0} -; CHECK: [[TYPE_LL]] = metadata !{metadata !"long long", metadata {{!.*}}} -!0 = metadata !{metadata !6, metadata !6, i64 0} -!1 = metadata !{metadata !"omnipotent char", metadata !2} -!2 = metadata !{metadata !"Simple C/C++ TBAA", null} -!3 = metadata !{metadata !7, metadata !7, i64 0} -!4 = metadata !{metadata !8, metadata !8, i64 0} -!5 = metadata !{metadata !9, metadata !9, i64 0} -!6 = metadata !{metadata !"short", metadata !1} -!7 = metadata !{metadata !"long long", metadata !1} -!8 = metadata !{metadata !"int", metadata !1} -!9 = metadata !{metadata !"float", metadata !1} +; CHECK: [[TAG]] = !{[[TYPE_LL:!.*]], [[TYPE_LL]], i64 0} +; CHECK: [[TYPE_LL]] = !{!"long long", {{!.*}}} +!0 = !{!6, !6, i64 0} +!1 = !{!"omnipotent char", !2} +!2 = !{!"Simple C/C++ TBAA", null} +!3 = !{!7, !7, i64 0} +!4 = !{!8, !8, i64 0} +!5 = !{!9, !9, i64 0} +!6 = !{!"short", !1} +!7 = !{!"long long", !1} +!8 = !{!"int", !1} +!9 = !{!"float", !1} diff --git a/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll b/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll index e9fb941..6c9439a 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll @@ -77,10 +77,10 @@ declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i32, i1) nounwind ; CHECK: attributes #2 = { nounwind readonly } ; Root note. -!0 = metadata !{ } +!0 = !{ } ; Invariant memory. -!1 = metadata !{metadata !3, metadata !3, i64 0, i1 1 } +!1 = !{!3, !3, i64 0, i1 1 } ; Not invariant memory. -!2 = metadata !{metadata !3, metadata !3, i64 0, i1 0 } -!3 = metadata !{ metadata !"foo", metadata !0 } +!2 = !{!3, !3, i64 0, i1 0 } +!3 = !{ !"foo", !0 } diff --git a/test/Analysis/TypeBasedAliasAnalysis/gvn-nonlocal-type-mismatch.ll b/test/Analysis/TypeBasedAliasAnalysis/gvn-nonlocal-type-mismatch.ll index 90e1abb..edea6d0 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/gvn-nonlocal-type-mismatch.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/gvn-nonlocal-type-mismatch.ll @@ -46,12 +46,12 @@ entry: br i1 %c, label %if.else, label %if.then if.then: - %t = load i32* %p, !tbaa !4 + %t = load i32* %p, !tbaa !3 store i32 %t, i32* %q ret void if.else: - %u = load i32* %p, !tbaa !3 + %u = load i32* %p, !tbaa !4 store i32 %u, i32* %q ret void } @@ -61,11 +61,11 @@ if.else: ; CHECK: @watch_out_for_another_type_change ; CHECK: if.then: -; CHECK: %t = load i32* %p -; CHECK: store i32 %t, i32* %q +; CHECK: store i32 0, i32* %q ; CHECK: ret void ; CHECK: if.else: -; CHECK: store i32 0, i32* %q +; CHECK: %u = load i32* %p +; CHECK: store i32 %u, i32* %q define void @watch_out_for_another_type_change(i1 %c, i32* %p, i32* %p1, i32* %q) nounwind { entry: @@ -74,22 +74,22 @@ entry: br i1 %c, label %if.else, label %if.then if.then: - %t = load i32* %p, !tbaa !3 + %t = load i32* %p, !tbaa !4 store i32 %t, i32* %q ret void if.else: - %u = load i32* %p, !tbaa !4 + %u = load i32* %p, !tbaa !3 store i32 %u, i32* %q ret void } -!0 = metadata !{} -!1 = metadata !{metadata !5, metadata !5, i64 0} -!2 = metadata !{metadata !6, metadata !6, i64 0} -!3 = metadata !{metadata !7, metadata !7, i64 0} -!4 = metadata !{metadata !8, metadata !8, i64 0} -!5 = metadata !{metadata !"red", metadata !0} -!6 = metadata !{metadata !"blu", metadata !0} -!7 = metadata !{metadata !"outer space"} -!8 = metadata !{metadata !"brick red", metadata !5} +!0 = !{} +!1 = !{!5, !5, i64 0} +!2 = !{!6, !6, i64 0} +!3 = !{!7, !7, i64 0} +!4 = !{!8, !8, i64 0} +!5 = !{!"red", !0} +!6 = !{!"blu", !0} +!7 = !{!"outer space"} +!8 = !{!"brick red", !5} diff --git a/test/Analysis/TypeBasedAliasAnalysis/intrinsics.ll b/test/Analysis/TypeBasedAliasAnalysis/intrinsics.ll index 93b8e50..0c12cac 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/intrinsics.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/intrinsics.ll @@ -25,8 +25,8 @@ declare void @llvm.arm.neon.vst1.v8i16(i8*, <8 x i16>, i32) nounwind ; CHECK: attributes #0 = { nounwind readonly } ; CHECK: attributes [[NUW]] = { nounwind } -!0 = metadata !{metadata !"tbaa root", null} -!1 = metadata !{metadata !3, metadata !3, i64 0} -!2 = metadata !{metadata !4, metadata !4, i64 0} -!3 = metadata !{metadata !"A", metadata !0} -!4 = metadata !{metadata !"B", metadata !0} +!0 = !{!"tbaa root", null} +!1 = !{!3, !3, i64 0} +!2 = !{!4, !4, i64 0} +!3 = !{!"A", !0} +!4 = !{!"B", !0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/licm.ll b/test/Analysis/TypeBasedAliasAnalysis/licm.ll index e45fc85..0722a2c 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/licm.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/licm.ll @@ -29,9 +29,9 @@ for.end: ; preds = %for.body, %entry ret void } -!0 = metadata !{metadata !"root", null} -!1 = metadata !{metadata !6, metadata !6, i64 0} -!2 = metadata !{metadata !7, metadata !7, i64 0} +!0 = !{!"root", null} +!1 = !{!6, !6, i64 0} +!2 = !{!7, !7, i64 0} ; LICM shouldn't hoist anything here. @@ -56,10 +56,10 @@ loop: br label %loop } -!3 = metadata !{metadata !"pointer", metadata !8} -!4 = metadata !{metadata !8, metadata !8, i64 0} -!5 = metadata !{metadata !9, metadata !9, i64 0} -!6 = metadata !{metadata !"pointer", metadata !0} -!7 = metadata !{metadata !"double", metadata !0} -!8 = metadata !{metadata !"char", metadata !9} -!9 = metadata !{metadata !"root", null} +!3 = !{!"pointer", !8} +!4 = !{!8, !8, i64 0} +!5 = !{!9, !9, i64 0} +!6 = !{!"pointer", !0} +!7 = !{!"double", !0} +!8 = !{!"char", !9} +!9 = !{!"root", null} diff --git a/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.ll b/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.ll index cdf7281..9fc9e42 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.ll @@ -18,10 +18,10 @@ define void @foo(i8* nocapture %p, i8* nocapture %q, i8* nocapture %s) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind -; CHECK: [[TAGA]] = metadata !{metadata [[TYPEA:!.*]], metadata [[TYPEA]], i64 0} -; CHECK: [[TYPEA]] = metadata !{metadata !"A", metadata !{{.*}}} -!0 = metadata !{metadata !"tbaa root", null} -!1 = metadata !{metadata !3, metadata !3, i64 0} -!2 = metadata !{metadata !4, metadata !4, i64 0} -!3 = metadata !{metadata !"A", metadata !0} -!4 = metadata !{metadata !"B", metadata !0} +; CHECK: [[TAGA]] = !{[[TYPEA:!.*]], [[TYPEA]], i64 0} +; CHECK: [[TYPEA]] = !{!"A", !{{.*}}} +!0 = !{!"tbaa root", null} +!1 = !{!3, !3, i64 0} +!2 = !{!4, !4, i64 0} +!3 = !{!"A", !0} +!4 = !{!"B", !0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll b/test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll index a027841..fd05dbe 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll @@ -97,14 +97,14 @@ declare noalias i8* @_Znwm(i64) attributes #0 = { nounwind } -!0 = metadata !{metadata !1, metadata !1, i64 0} -!1 = metadata !{metadata !"int", metadata !2, i64 0} -!2 = metadata !{metadata !"omnipotent char", metadata !3, i64 0} -!3 = metadata !{metadata !"Simple C/C++ TBAA"} -!4 = metadata !{metadata !5, metadata !5, i64 0} -!5 = metadata !{metadata !"any pointer", metadata !2, i64 0} -!6 = metadata !{metadata !7, metadata !8, i64 0} -!7 = metadata !{metadata !"_ZTS3Foo", metadata !8, i64 0} -!8 = metadata !{metadata !"long", metadata !2, i64 0} -!9 = metadata !{metadata !10, metadata !5, i64 0} -!10 = metadata !{metadata !"_ZTS3Bar", metadata !5, i64 0} +!0 = !{!1, !1, i64 0} +!1 = !{!"int", !2, i64 0} +!2 = !{!"omnipotent char", !3, i64 0} +!3 = !{!"Simple C/C++ TBAA"} +!4 = !{!5, !5, i64 0} +!5 = !{!"any pointer", !2, i64 0} +!6 = !{!7, !8, i64 0} +!7 = !{!"_ZTS3Foo", !8, i64 0} +!8 = !{!"long", !2, i64 0} +!9 = !{!10, !5, i64 0} +!10 = !{!"_ZTS3Bar", !5, i64 0} diff --git a/test/Analysis/TypeBasedAliasAnalysis/precedence.ll b/test/Analysis/TypeBasedAliasAnalysis/precedence.ll index b219ef1..0b697b2 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/precedence.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/precedence.ll @@ -39,12 +39,12 @@ entry: ret i64 %tmp3 } -!0 = metadata !{metadata !2, metadata !2, i64 0} -!1 = metadata !{metadata !"simple"} -!2 = metadata !{metadata !"int", metadata !1} -!3 = metadata !{metadata !6, metadata !6, i64 0} -!4 = metadata !{metadata !7, metadata !7, i64 0} -!5 = metadata !{metadata !8, metadata !8, i64 0} -!6 = metadata !{metadata !"float", metadata !1} -!7 = metadata !{metadata !"long", metadata !1} -!8 = metadata !{metadata !"small", metadata !1} +!0 = !{!2, !2, i64 0} +!1 = !{!"simple"} +!2 = !{!"int", !1} +!3 = !{!6, !6, i64 0} +!4 = !{!7, !7, i64 0} +!5 = !{!8, !8, i64 0} +!6 = !{!"float", !1} +!7 = !{!"long", !1} +!8 = !{!"small", !1} diff --git a/test/Analysis/TypeBasedAliasAnalysis/sink.ll b/test/Analysis/TypeBasedAliasAnalysis/sink.ll index 726da6c..1a124b8 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/sink.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/sink.ll @@ -15,10 +15,10 @@ b: ret void } -; CHECK: [[TAGA]] = metadata !{metadata [[TYPEA:!.*]], metadata [[TYPEA]], i64 0} -; CHECK: [[TYPEA]] = metadata !{metadata !"A", metadata !{{.*}}} -!0 = metadata !{metadata !3, metadata !3, i64 0} -!1 = metadata !{metadata !4, metadata !4, i64 0} -!2 = metadata !{metadata !"test"} -!3 = metadata !{metadata !"A", metadata !2} -!4 = metadata !{metadata !"B", metadata !2} +; CHECK: [[TAGA]] = !{[[TYPEA:!.*]], [[TYPEA]], i64 0} +; CHECK: [[TYPEA]] = !{!"A", !{{.*}}} +!0 = !{!3, !3, i64 0} +!1 = !{!4, !4, i64 0} +!2 = !{!"test"} +!3 = !{!"A", !2} +!4 = !{!"B", !2} diff --git a/test/Analysis/TypeBasedAliasAnalysis/tbaa-path.ll b/test/Analysis/TypeBasedAliasAnalysis/tbaa-path.ll index 38bece7..3c035af 100644 --- a/test/Analysis/TypeBasedAliasAnalysis/tbaa-path.ll +++ b/test/Analysis/TypeBasedAliasAnalysis/tbaa-path.ll @@ -363,30 +363,30 @@ entry: attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" } -!0 = metadata !{metadata !1, metadata !1, i64 0} -!1 = metadata !{metadata !"any pointer", metadata !2} -!2 = metadata !{metadata !"omnipotent char", metadata !3} -!3 = metadata !{metadata !"Simple C/C++ TBAA"} -!4 = metadata !{metadata !5, metadata !5, i64 0} -!5 = metadata !{metadata !"long long", metadata !2} -!6 = metadata !{metadata !7, metadata !7, i64 0} -!7 = metadata !{metadata !"int", metadata !2} -!8 = metadata !{metadata !9, metadata !7, i64 4} -!9 = metadata !{metadata !"_ZTS7StructA", metadata !10, i64 0, metadata !7, i64 4, metadata !10, i64 8, metadata !7, i64 12} -!10 = metadata !{metadata !"short", metadata !2} -!11 = metadata !{metadata !9, metadata !10, i64 0} -!12 = metadata !{metadata !13, metadata !7, i64 8} -!13 = metadata !{metadata !"_ZTS7StructB", metadata !10, i64 0, metadata !9, i64 4, metadata !7, i64 20} -!14 = metadata !{metadata !13, metadata !10, i64 4} -!15 = metadata !{metadata !13, metadata !7, i64 20} -!16 = metadata !{metadata !13, metadata !7, i64 16} -!17 = metadata !{metadata !18, metadata !7, i64 4} -!18 = metadata !{metadata !"_ZTS7StructS", metadata !10, i64 0, metadata !7, i64 4} -!19 = metadata !{metadata !18, metadata !10, i64 0} -!20 = metadata !{metadata !21, metadata !7, i64 4} -!21 = metadata !{metadata !"_ZTS8StructS2", metadata !10, i64 0, metadata !7, i64 4} -!22 = metadata !{metadata !21, metadata !10, i64 0} -!23 = metadata !{metadata !24, metadata !7, i64 12} -!24 = metadata !{metadata !"_ZTS7StructC", metadata !10, i64 0, metadata !13, i64 4, metadata !7, i64 28} -!25 = metadata !{metadata !26, metadata !7, i64 12} -!26 = metadata !{metadata !"_ZTS7StructD", metadata !10, i64 0, metadata !13, i64 4, metadata !7, i64 28, metadata !2, i64 32} +!0 = !{!1, !1, i64 0} +!1 = !{!"any pointer", !2} +!2 = !{!"omnipotent char", !3} +!3 = !{!"Simple C/C++ TBAA"} +!4 = !{!5, !5, i64 0} +!5 = !{!"long long", !2} +!6 = !{!7, !7, i64 0} +!7 = !{!"int", !2} +!8 = !{!9, !7, i64 4} +!9 = !{!"_ZTS7StructA", !10, i64 0, !7, i64 4, !10, i64 8, !7, i64 12} +!10 = !{!"short", !2} +!11 = !{!9, !10, i64 0} +!12 = !{!13, !7, i64 8} +!13 = !{!"_ZTS7StructB", !10, i64 0, !9, i64 4, !7, i64 20} +!14 = !{!13, !10, i64 4} +!15 = !{!13, !7, i64 20} +!16 = !{!13, !7, i64 16} +!17 = !{!18, !7, i64 4} +!18 = !{!"_ZTS7StructS", !10, i64 0, !7, i64 4} +!19 = !{!18, !10, i64 0} +!20 = !{!21, !7, i64 4} +!21 = !{!"_ZTS8StructS2", !10, i64 0, !7, i64 4} +!22 = !{!21, !10, i64 0} +!23 = !{!24, !7, i64 12} +!24 = !{!"_ZTS7StructC", !10, i64 0, !13, i64 4, !7, i64 28} +!25 = !{!26, !7, i64 12} +!26 = !{!"_ZTS7StructD", !10, i64 0, !13, i64 4, !7, i64 28, !2, i64 32} diff --git a/test/Analysis/ValueTracking/memory-dereferenceable.ll b/test/Analysis/ValueTracking/memory-dereferenceable.ll new file mode 100644 index 0000000..1c55efc --- /dev/null +++ b/test/Analysis/ValueTracking/memory-dereferenceable.ll @@ -0,0 +1,34 @@ +; RUN: opt -print-memderefs -analyze -S <%s | FileCheck %s + +; Uses the print-deref (+ analyze to print) pass to run +; isDereferenceablePointer() on many load instruction operands + +target datalayout = "e" + +declare zeroext i1 @return_i1() + +@globalstr = global [6 x i8] c"hello\00" + +define void @test(i32 addrspace(1)* dereferenceable(8) %dparam) { +; CHECK: The following are dereferenceable: +; CHECK: %globalptr +; CHECK: %alloca +; CHECK: %dparam +; CHECK: %relocate +; CHECK-NOT: %nparam +entry: + %globalptr = getelementptr inbounds [6 x i8]* @globalstr, i32 0, i32 0 + %load1 = load i8* %globalptr + %alloca = alloca i1 + %load2 = load i1* %alloca + %load3 = load i32 addrspace(1)* %dparam + %tok = tail call i32 (i1 ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam) + %relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %tok, i32 4, i32 4) + %load4 = load i32 addrspace(1)* %relocate + %nparam = getelementptr i32 addrspace(1)* %dparam, i32 5 + %load5 = load i32 addrspace(1)* %nparam + ret void +} + +declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...) +declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) |