This is an archive of the discontinued LLVM Phabricator instance.

Differential D82683

[NewPM][BasicAA] basicaa -> basic-aa in Analysis/BasicAA
ClosedPublic

Authored by aeubanks on Jun 26 2020, 1:18 PM.

Details

Reviewers
ychen
Commits
rGfeeed16a5f81: [NewPM][BasicAA] basicaa -> basic-aa in Analysis/BasicAA
Summary

Following https://reviews.llvm.org/D82607.

Diff Detail

Event Timeline

aeubanks created this revision.Jun 26 2020, 1:18 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 26 2020, 1:18 PM
Herald added subscribers: llvm-commits, arphaman. · View Herald Transcript
ychen accepted this revision.Jun 26 2020, 2:34 PM

LGTM

This revision is now accepted and ready to land.Jun 26 2020, 2:34 PM
Closed by commit rGfeeed16a5f81: [NewPM][BasicAA] basicaa -> basic-aa in Analysis/BasicAA (authored by aeubanks). · Explain WhyJun 26 2020, 3:12 PM
This revision was automatically updated to reflect the committed changes.
Harbormaster failed remote builds in B61985: Diff 273827!Jun 26 2020, 3:18 PM
MaskRay mentioned this in rGf31811f2dcbe: [BasicAA] Rename deprecated -basicaa to -basic-aa.Jun 26 2020, 8:42 PM

Revision Contents

PathSize
llvm/
test/
Analysis/
BasicAA/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 273845

llvm/test/Analysis/BasicAA/128-bit-ptr.ll

; This testcase consists of alias relations on 128-bit pointers that ; This testcase consists of alias relations on 128-bit pointers that
; should be completely resolvable by basicaa. ; should be completely resolvable by basicaa.
; RUN: opt < %s -basicaa -aa-eval -print-no-aliases -print-may-aliases -print-must-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-no-aliases -print-may-aliases -print-must-aliases -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128-p100:128:64:64-p101:128:64:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128-p100:128:64:64-p101:128:64:64"
; test0 is similar to SimpleCases.ll ; test0 is similar to SimpleCases.ll
%T = type { i32, [10 x i8] } %T = type { i32, [10 x i8] }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/2003-02-26-AccessSizeTest.ll

; This testcase makes sure that size is taken to account when alias analysis ; This testcase makes sure that size is taken to account when alias analysis
; is performed. It is not legal to delete the second load instruction because ; is performed. It is not legal to delete the second load instruction because
; the value computed by the first load instruction is changed by the store. ; the value computed by the first load instruction is changed by the store.
; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
define i32 @test() { define i32 @test() {
; CHECK: %Y.DONOTREMOVE = load i32, i32* %A ; CHECK: %Y.DONOTREMOVE = load i32, i32* %A
; CHECK: %Z = sub i32 0, %Y.DONOTREMOVE ; CHECK: %Z = sub i32 0, %Y.DONOTREMOVE
%A = alloca i32 %A = alloca i32
store i32 0, i32* %A store i32 0, i32* %A
%X = load i32, i32* %A %X = load i32, i32* %A
%B = bitcast i32* %A to i8* %B = bitcast i32* %A to i8*
%C = getelementptr i8, i8* %B, i64 1 %C = getelementptr i8, i8* %B, i64 1
store i8 1, i8* %C ; Aliases %A store i8 1, i8* %C ; Aliases %A
%Y.DONOTREMOVE = load i32, i32* %A %Y.DONOTREMOVE = load i32, i32* %A
%Z = sub i32 %X, %Y.DONOTREMOVE %Z = sub i32 %X, %Y.DONOTREMOVE
ret i32 %Z ret i32 %Z
} }

llvm/test/Analysis/BasicAA/2003-03-04-GEPCrash.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>/dev/null
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2 ; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
define void @test({[2 x i32],[2 x i32]}* %A, i64 %X, i64 %Y) { define void @test({[2 x i32],[2 x i32]}* %A, i64 %X, i64 %Y) {
%P1 = getelementptr {[2 x i32],[2 x i32]}, {[2 x i32],[2 x i32]}* %A, i64 0, i32 0, i64 %X %P1 = getelementptr {[2 x i32],[2 x i32]}, {[2 x i32],[2 x i32]}* %A, i64 0, i32 0, i64 %X
%P2 = getelementptr {[2 x i32],[2 x i32]}, {[2 x i32],[2 x i32]}* %A, i64 0, i32 1, i64 %Y %P2 = getelementptr {[2 x i32],[2 x i32]}, {[2 x i32],[2 x i32]}* %A, i64 0, i32 1, i64 %Y
ret void ret void
} }

llvm/test/Analysis/BasicAA/2003-04-22-GEPProblem.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; BasicAA was incorrectly concluding that P1 and P2 didn't conflict! ; BasicAA was incorrectly concluding that P1 and P2 didn't conflict!
define i32 @test(i32 *%Ptr, i64 %V) { define i32 @test(i32 *%Ptr, i64 %V) {
; CHECK: sub i32 %X, %Y ; CHECK: sub i32 %X, %Y
%P2 = getelementptr i32, i32* %Ptr, i64 1 %P2 = getelementptr i32, i32* %Ptr, i64 1
%P1 = getelementptr i32, i32* %Ptr, i64 %V %P1 = getelementptr i32, i32* %Ptr, i64 %V
%X = load i32, i32* %P1 %X = load i32, i32* %P1
store i32 5, i32* %P2 store i32 5, i32* %P2
%Y = load i32, i32* %P1 %Y = load i32, i32* %P1
%Z = sub i32 %X, %Y %Z = sub i32 %X, %Y
ret i32 %Z ret i32 %Z
} }

llvm/test/Analysis/BasicAA/2003-04-25-GEPCrash.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>/dev/null
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2 ; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
define void @test([17 x i16]* %mask_bits) { define void @test([17 x i16]* %mask_bits) {
%P1 = getelementptr [17 x i16], [17 x i16]* %mask_bits, i64 0, i64 0 %P1 = getelementptr [17 x i16], [17 x i16]* %mask_bits, i64 0, i64 0
%P2 = getelementptr [17 x i16], [17 x i16]* %mask_bits, i64 252645134, i64 0 %P2 = getelementptr [17 x i16], [17 x i16]* %mask_bits, i64 252645134, i64 0
ret void ret void
} }

llvm/test/Analysis/BasicAA/2003-05-21-GEP-Problem.ll

; RUN: opt < %s -basicaa -licm -disable-output ; RUN: opt < %s -basic-aa -licm -disable-output
%struct..apr_array_header_t = type { i32*, i32, i32, i32, i8* } %struct..apr_array_header_t = type { i32*, i32, i32, i32, i8* }
%struct..apr_table_t = type { %struct..apr_array_header_t, i32, [32 x i32], [32 x i32] } %struct..apr_table_t = type { %struct..apr_array_header_t, i32, [32 x i32], [32 x i32] }
define void @table_reindex(%struct..apr_table_t* %t.1) { ; No predecessors! define void @table_reindex(%struct..apr_table_t* %t.1) { ; No predecessors!
br label %loopentry br label %loopentry
loopentry: ; preds = %0, %no_exit loopentry: ; preds = %0, %no_exit
%tmp.101 = getelementptr %struct..apr_table_t, %struct..apr_table_t* %t.1, i64 0, i32 0, i32 2 %tmp.101 = getelementptr %struct..apr_table_t, %struct..apr_table_t* %t.1, i64 0, i32 0, i32 2
Show All 12 Lines

llvm/test/Analysis/BasicAA/2003-06-01-AliasCrash.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>/dev/null
define i32 @MTConcat([3 x i32]* %a.1) { define i32 @MTConcat([3 x i32]* %a.1) {
%tmp.961 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 0, i64 4 %tmp.961 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 0, i64 4
%tmp.97 = load i32, i32* %tmp.961 %tmp.97 = load i32, i32* %tmp.961
%tmp.119 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 1, i64 0 %tmp.119 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 1, i64 0
%tmp.120 = load i32, i32* %tmp.119 %tmp.120 = load i32, i32* %tmp.119
%tmp.1541 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 0, i64 4 %tmp.1541 = getelementptr [3 x i32], [3 x i32]* %a.1, i64 0, i64 4
%tmp.155 = load i32, i32* %tmp.1541 %tmp.155 = load i32, i32* %tmp.1541
ret i32 0 ret i32 0
} }

llvm/test/Analysis/BasicAA/2003-07-03-BasicAACrash.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>/dev/null
%struct..RefPoint = type { i32, { i32, i8, i8 } } %struct..RefPoint = type { i32, { i32, i8, i8 } }
%struct..RefRect = type { %struct..RefPoint, %struct..RefPoint } %struct..RefRect = type { %struct..RefPoint, %struct..RefPoint }
define i32 @BMT_CommitPartDrawObj() { define i32 @BMT_CommitPartDrawObj() {
%tmp.19111 = getelementptr %struct..RefRect, %struct..RefRect* null, i64 0, i32 0, i32 1, i32 2 %tmp.19111 = getelementptr %struct..RefRect, %struct..RefRect* null, i64 0, i32 0, i32 1, i32 2
%tmp.20311 = getelementptr %struct..RefRect, %struct..RefRect* null, i64 0, i32 1, i32 1, i32 2 %tmp.20311 = getelementptr %struct..RefRect, %struct..RefRect* null, i64 0, i32 1, i32 1, i32 2
ret i32 0 ret i32 0
} }

llvm/test/Analysis/BasicAA/2003-09-19-LocalArgument.ll

; In this test, a local alloca cannot alias an incoming argument. ; In this test, a local alloca cannot alias an incoming argument.
; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; CHECK: define i32 @test ; CHECK: define i32 @test
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
define i32 @test(i32* %P) { define i32 @test(i32* %P) {
%X = alloca i32 %X = alloca i32
%V1 = load i32, i32* %P %V1 = load i32, i32* %P
store i32 0, i32* %X store i32 0, i32* %X
%V2 = load i32, i32* %P %V2 = load i32, i32* %P
%Diff = sub i32 %V1, %V2 %Diff = sub i32 %V1, %V2
ret i32 %Diff ret i32 %Diff
} }

llvm/test/Analysis/BasicAA/2003-11-04-SimpleCases.ll

; This testcase consists of alias relations which should be completely ; This testcase consists of alias relations which should be completely
; resolvable by basicaa. ; resolvable by basicaa.
; RUN: opt < %s -basicaa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%T = type { i32, [10 x i8] } %T = type { i32, [10 x i8] }
; CHECK: Function: test ; CHECK: Function: test
; CHECK-NOT: MayAlias: ; CHECK-NOT: MayAlias:
define void @test(%T* %P) { define void @test(%T* %P) {
%A = getelementptr %T, %T* %P, i64 0 %A = getelementptr %T, %T* %P, i64 0
%B = getelementptr %T, %T* %P, i64 0, i32 0 %B = getelementptr %T, %T* %P, i64 0, i32 0
%C = getelementptr %T, %T* %P, i64 0, i32 1 %C = getelementptr %T, %T* %P, i64 0, i32 1
%D = getelementptr %T, %T* %P, i64 0, i32 1, i64 0 %D = getelementptr %T, %T* %P, i64 0, i32 1, i64 0
%E = getelementptr %T, %T* %P, i64 0, i32 1, i64 5 %E = getelementptr %T, %T* %P, i64 0, i32 1, i64 5
ret void ret void
} }

llvm/test/Analysis/BasicAA/2003-12-11-ConstExprGEP.ll

; This testcase consists of alias relations which should be completely ; This testcase consists of alias relations which should be completely
; resolvable by basicaa, but require analysis of getelementptr constant exprs. ; resolvable by basicaa, but require analysis of getelementptr constant exprs.
; RUN: opt < %s -basicaa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%T = type { i32, [10 x i8] } %T = type { i32, [10 x i8] }
@G = external global %T @G = external global %T
; CHECK: Function: test ; CHECK: Function: test
Show All 10 Lines

llvm/test/Analysis/BasicAA/2004-07-28-MustAliasbug.ll

; RUN: opt < %s -basicaa -dse -S | FileCheck %s ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
define void @test({i32,i32 }* %P) { define void @test({i32,i32 }* %P) {
; CHECK: store i32 0, i32* %X ; CHECK: store i32 0, i32* %X
%Q = getelementptr {i32,i32}, {i32,i32}* %P, i32 1 %Q = getelementptr {i32,i32}, {i32,i32}* %P, i32 1
%X = getelementptr {i32,i32}, {i32,i32}* %Q, i32 0, i32 1 %X = getelementptr {i32,i32}, {i32,i32}* %Q, i32 0, i32 1
%Y = getelementptr {i32,i32}, {i32,i32}* %Q, i32 1, i32 1 %Y = getelementptr {i32,i32}, {i32,i32}* %Q, i32 1, i32 1
store i32 0, i32* %X store i32 0, i32* %X
store i32 1, i32* %Y store i32 1, i32* %Y
ret void ret void
} }

llvm/test/Analysis/BasicAA/2006-03-03-BadArraySubscript.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>&1 | FileCheck %s
; TEST that A[1][0] may alias A[0][i]. ; TEST that A[1][0] may alias A[0][i].
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; CHECK: 2 no alias responses ; CHECK: 2 no alias responses
define void @test(i32 %N) { define void @test(i32 %N) {
entry: entry:
%X = alloca [3 x [3 x i32]] ; <[3 x [3 x i32]]*> [#uses=4] %X = alloca [3 x [3 x i32]] ; <[3 x [3 x i32]]*> [#uses=4]
Show All 24 Lines

llvm/test/Analysis/BasicAA/2006-11-03-BasicAAVectorCrash.ll

; RUN: opt < %s -basicaa -licm -disable-output ; RUN: opt < %s -basic-aa -licm -disable-output
target datalayout = "E-p:32:32" target datalayout = "E-p:32:32"
target triple = "powerpc-unknown-linux-gnu" target triple = "powerpc-unknown-linux-gnu"
define void @glgRunProcessor() { define void @glgRunProcessor() {
entry: entry:
br i1 false, label %bb2037.i, label %cond_true.i18 br i1 false, label %bb2037.i, label %cond_true.i18
cond_true.i18: ; preds = %entry cond_true.i18: ; preds = %entry
Show All 39 Lines

llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; PR1109 ; PR1109
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin8" target triple = "i686-apple-darwin8"
%struct.CONSTRAINT = type { i32, i32, i32, i32 } %struct.CONSTRAINT = type { i32, i32, i32, i32 }
%struct.FILE_POS = type { i8, i8, i16, i32 } %struct.FILE_POS = type { i8, i8, i16, i32 }
%struct.FIRST_UNION = type { %struct.FILE_POS } %struct.FIRST_UNION = type { %struct.FILE_POS }
%struct.FOURTH_UNION = type { %struct.CONSTRAINT } %struct.FOURTH_UNION = type { %struct.CONSTRAINT }
Show All 25 Lines

llvm/test/Analysis/BasicAA/2007-08-01-NoAliasAndCalls.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Function: foo ; CHECK: Function: foo
; CHECK: MayAlias: i32* %x, i32* %y ; CHECK: MayAlias: i32* %x, i32* %y
define void @foo(i32* noalias %x) { define void @foo(i32* noalias %x) {
%y = call i32* @unclear(i32* %x) %y = call i32* @unclear(i32* %x)
store i32 0, i32* %x store i32 0, i32* %x
store i32 0, i32* %y store i32 0, i32* %y
ret void ret void
} }
declare i32* @unclear(i32* %a) declare i32* @unclear(i32* %a)

llvm/test/Analysis/BasicAA/2007-08-01-NoAliasAndGEP.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Function: foo ; CHECK: Function: foo
; CHECK: MayAlias: i32* %Ipointer, i32* %Jpointer ; CHECK: MayAlias: i32* %Ipointer, i32* %Jpointer
; CHECK: 9 no alias responses ; CHECK: 9 no alias responses
; CHECK: 6 may alias responses ; CHECK: 6 may alias responses
Show All 13 Lines

llvm/test/Analysis/BasicAA/2007-08-05-GetOverloadedModRef.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; PR1600 ; PR1600
declare i16 @llvm.cttz.i16(i16, i1) declare i16 @llvm.cttz.i16(i16, i1)
define i32 @test(i32* %P, i16* %Q) { define i32 @test(i32* %P, i16* %Q) {
; CHECK: ret i32 0 ; CHECK: ret i32 0
%A = load i16, i16* %Q ; <i16> [#uses=1] %A = load i16, i16* %Q ; <i16> [#uses=1]
%x = load i32, i32* %P ; <i32> [#uses=1] %x = load i32, i32* %P ; <i32> [#uses=1]
%B = call i16 @llvm.cttz.i16( i16 %A, i1 true ) ; <i16> [#uses=1] %B = call i16 @llvm.cttz.i16( i16 %A, i1 true ) ; <i16> [#uses=1]
%y = load i32, i32* %P ; <i32> [#uses=1] %y = load i32, i32* %P ; <i32> [#uses=1]
store i16 %B, i16* %Q store i16 %B, i16* %Q
%z = sub i32 %x, %y ; <i32> [#uses=1] %z = sub i32 %x, %y ; <i32> [#uses=1]
ret i32 %z ret i32 %z
} }

llvm/test/Analysis/BasicAA/2007-10-24-ArgumentsGlobals.ll

; RUN: opt < %s -basicaa -gvn -dce -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -dce -S | FileCheck %s
%struct.A = type { i32 } %struct.A = type { i32 }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
@a = global %struct.B zeroinitializer ; <%struct.B*> [#uses=2] @a = global %struct.B zeroinitializer ; <%struct.B*> [#uses=2]
define i32 @_Z3fooP1A(%struct.A* %b) { define i32 @_Z3fooP1A(%struct.A* %b) {
; CHECK: %tmp7 = load ; CHECK: %tmp7 = load
; CHECK: ret i32 %tmp7 ; CHECK: ret i32 %tmp7
entry: entry:
store i32 1, i32* getelementptr (%struct.B, %struct.B* @a, i32 0, i32 0, i32 0), align 8 store i32 1, i32* getelementptr (%struct.B, %struct.B* @a, i32 0, i32 0, i32 0), align 8
%tmp4 = getelementptr %struct.A, %struct.A* %b, i32 0, i32 0 ;<i32*> [#uses=1] %tmp4 = getelementptr %struct.A, %struct.A* %b, i32 0, i32 0 ;<i32*> [#uses=1]
store i32 0, i32* %tmp4, align 4 store i32 0, i32* %tmp4, align 4
%tmp7 = load i32, i32* getelementptr (%struct.B, %struct.B* @a, i32 0, i32 0, i32 0), align 8 ; <i32> [#uses=1] %tmp7 = load i32, i32* getelementptr (%struct.B, %struct.B* @a, i32 0, i32 0, i32 0), align 8 ; <i32> [#uses=1]
ret i32 %tmp7 ret i32 %tmp7
} }

llvm/test/Analysis/BasicAA/2007-11-05-SizeCrash.ll

; RUN: opt < %s -basicaa -gvn -disable-output ; RUN: opt < %s -basic-aa -gvn -disable-output
; PR1774 ; PR1774
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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.device = type { [20 x i8] } %struct.device = type { [20 x i8] }
%struct.pci_device_id = type { i32, i32, i32, i32, i32, i32, i64 } %struct.pci_device_id = type { i32, i32, i32, i32, i32, i32, i64 }
%struct.usb_bus = type { %struct.device* } %struct.usb_bus = type { %struct.device* }
%struct.usb_hcd = type { %struct.usb_bus, i64, [0 x i64] } %struct.usb_hcd = type { %struct.usb_bus, i64, [0 x i64] }
Show All 25 Lines

llvm/test/Analysis/BasicAA/2007-12-08-OutOfBoundsCrash.ll

; RUN: opt < %s -basicaa -gvn -disable-output ; RUN: opt < %s -basic-aa -gvn -disable-output
; PR1782 ; PR1782
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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.device = type { [20 x i8] } %struct.device = type { [20 x i8] }
%struct.pci_device_id = type { i32, i32, i32, i32, i32, i32, i64 } %struct.pci_device_id = type { i32, i32, i32, i32, i32, i32, i64 }
%struct.usb_bus = type { %struct.device* } %struct.usb_bus = type { %struct.device* }
%struct.usb_hcd = type { %struct.usb_bus, [0 x i64] } %struct.usb_hcd = type { %struct.usb_bus, [0 x i64] }
Show All 22 Lines

llvm/test/Analysis/BasicAA/2008-06-02-GEPTailCrash.ll

; RUN: opt < %s -basicaa -gvn -disable-output ; RUN: opt < %s -basic-aa -gvn -disable-output
; PR2395 ; PR2395
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
target triple = "i686-pc-linux-gnu" target triple = "i686-pc-linux-gnu"
%struct.S291 = type <{ %union.anon, i32 }> %struct.S291 = type <{ %union.anon, i32 }>
%union.anon = type { } %union.anon = type { }
@a291 = external global [5 x %struct.S291] ; <[5 x %struct.S291]*> [#uses=2] @a291 = external global [5 x %struct.S291] ; <[5 x %struct.S291]*> [#uses=2]
define void @test291() nounwind { define void @test291() nounwind {
entry: entry:
store i32 1138410269, i32* getelementptr ([5 x %struct.S291], [5 x %struct.S291]* @a291, i32 0, i32 2, i32 1) store i32 1138410269, i32* getelementptr ([5 x %struct.S291], [5 x %struct.S291]* @a291, i32 0, i32 2, i32 1)
%tmp54 = load i32, i32* bitcast (%struct.S291* getelementptr ([5 x %struct.S291], [5 x %struct.S291]* @a291, i32 0, i32 2) to i32*), align 4 ; <i32> [#uses=0] %tmp54 = load i32, i32* bitcast (%struct.S291* getelementptr ([5 x %struct.S291], [5 x %struct.S291]* @a291, i32 0, i32 2) to i32*), align 4 ; <i32> [#uses=0]
unreachable unreachable
} }

llvm/test/Analysis/BasicAA/2008-11-23-NoaliasRet.ll

; RUN: opt < %s -basicaa -aa-eval -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -disable-output 2>&1 | FileCheck %s
declare noalias i32* @_Znwj(i32 %x) nounwind declare noalias i32* @_Znwj(i32 %x) nounwind
; CHECK: 1 no alias response ; CHECK: 1 no alias response
define i32 @foo() { define i32 @foo() {
%A = call i32* @_Znwj(i32 4) %A = call i32* @_Znwj(i32 4)
%B = call i32* @_Znwj(i32 4) %B = call i32* @_Znwj(i32 4)
store i32 1, i32* %A store i32 1, i32* %A
store i32 2, i32* %B store i32 2, i32* %B
%C = load i32, i32* %A %C = load i32, i32* %A
ret i32 %C ret i32 %C
} }

llvm/test/Analysis/BasicAA/2009-03-04-GEPNoalias.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
declare noalias i32* @noalias() declare noalias i32* @noalias()
define i32 @test(i32 %x) { define i32 @test(i32 %x) {
; CHECK: load i32, i32* %a ; CHECK: load i32, i32* %a
%a = call i32* @noalias() %a = call i32* @noalias()
store i32 1, i32* %a store i32 1, i32* %a
%b = getelementptr i32, i32* %a, i32 %x %b = getelementptr i32, i32* %a, i32 %x
store i32 2, i32* %b store i32 2, i32* %b
%c = load i32, i32* %a %c = load i32, i32* %a
ret i32 %c ret i32 %c
} }

llvm/test/Analysis/BasicAA/2009-10-13-AtomicModRef.ll

; RUN: opt -basicaa -gvn -instcombine -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -instcombine -S < %s | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define i8 @foo(i8* %ptr) { define i8 @foo(i8* %ptr) {
%P = getelementptr i8, i8* %ptr, i32 0 %P = getelementptr i8, i8* %ptr, i32 0
%Q = getelementptr i8, i8* %ptr, i32 1 %Q = getelementptr i8, i8* %ptr, i32 1
; CHECK: getelementptr ; CHECK: getelementptr
%X = load i8, i8* %P %X = load i8, i8* %P
%Y = atomicrmw add i8* %Q, i8 1 monotonic %Y = atomicrmw add i8* %Q, i8 1 monotonic
%Z = load i8, i8* %P %Z = load i8, i8* %P
; CHECK-NOT: = load ; CHECK-NOT: = load
%A = sub i8 %X, %Z %A = sub i8 %X, %Z
ret i8 %A ret i8 %A
; CHECK: ret i8 0 ; CHECK: ret i8 0
} }

llvm/test/Analysis/BasicAA/2009-10-13-GEP-BaseNoAlias.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; If GEP base doesn't alias Z, then GEP doesn't alias Z. ; If GEP base doesn't alias Z, then GEP doesn't alias Z.
; rdar://7282591 ; rdar://7282591
@Y = common global i32 0 @Y = common global i32 0
@Z = common global i32 0 @Z = common global i32 0
; CHECK: Function: foo ; CHECK: Function: foo
; CHECK: NoAlias: i32* %P, i32* @Z ; CHECK: NoAlias: i32* %P, i32* @Z
Show All 24 Lines

llvm/test/Analysis/BasicAA/2010-09-15-GEP-SignedArithmetic.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; PR7959 ; PR7959
target datalayout = "e-p:32:32:32" target datalayout = "e-p:32:32:32"
; CHECK: 1 may alias responses ; CHECK: 1 may alias responses
define i32 @test(i32* %tab, i32 %indvar) nounwind { define i32 @test(i32* %tab, i32 %indvar) nounwind {
%tmp31 = mul i32 %indvar, -2 %tmp31 = mul i32 %indvar, -2
%tmp32 = add i32 %tmp31, 30 %tmp32 = add i32 %tmp31, 30
%t.5 = getelementptr i32, i32* %tab, i32 %tmp32 %t.5 = getelementptr i32, i32* %tab, i32 %tmp32
%loada = load i32, i32* %tab %loada = load i32, i32* %tab
store i32 0, i32* %t.5 store i32 0, i32* %t.5
%loadb = load i32, i32* %tab %loadb = load i32, i32* %tab
%rval = add i32 %loada, %loadb %rval = add i32 %loada, %loadb
ret i32 %rval ret i32 %rval
} }

llvm/test/Analysis/BasicAA/2014-03-18-Maxlookup-reached.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; PR15967 ; PR15967
; BasicAA claims no alias when there is (due to a problem when the MaxLookup ; BasicAA claims no alias when there is (due to a problem when the MaxLookup
; limit was reached). ; limit was reached).
target datalayout = "e" target datalayout = "e"
%struct.foo = type { i32, i32 } %struct.foo = type { i32, i32 }
Show All 27 Lines

llvm/test/Analysis/BasicAA/aligned-overread.ll

; RUN: opt < %s -basicaa -dse -S | FileCheck %s ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
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-S128" 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-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.S0 = type <{ i8, [4 x i8] }> %struct.S0 = type <{ i8, [4 x i8] }>
@a = global { i8, i8, i8, i8, i8 } { i8 undef, i8 0, i8 0, i8 0, i8 0 }, align 8 @a = global { i8, i8, i8, i8, i8 } { i8 undef, i8 0, i8 0, i8 0, i8 0 }, align 8
Show All 16 Lines

llvm/test/Analysis/BasicAA/args-rets-allocas-loads.ll

; RUN: opt -basicaa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
declare void @callee(double* %callee_arg) declare void @callee(double* %callee_arg)
declare void @nocap_callee(double* nocapture %nocap_callee_arg) declare void @nocap_callee(double* nocapture %nocap_callee_arg)
declare double* @normal_returner() declare double* @normal_returner()
declare noalias double* @noalias_returner() declare noalias double* @noalias_returner()
define void @caller_a(double* %arg_a0, define void @caller_a(double* %arg_a0,
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/assume-index-positive.ll

; RUN: opt -basicaa -aa-eval -print-all-alias-modref-info %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info %s 2>&1 | FileCheck %s
; %col.ptr.1 and %col.ptr.2 do not alias, if we know that %skip >= 0, because ; %col.ptr.1 and %col.ptr.2 do not alias, if we know that %skip >= 0, because
; the distance between %col.ptr.1 and %col.ptr.2 is %skip + 6 and we load 6 ; the distance between %col.ptr.1 and %col.ptr.2 is %skip + 6 and we load 6
; elements. ; elements.
define void @test1(double* %ptr, i32 %skip) { define void @test1(double* %ptr, i32 %skip) {
; CHECK-LABEL: Function: test1: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test1: 4 pointers, 1 call sites
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr ; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr
; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr ; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/assume.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0
declare void @llvm.assume(i1) #0 declare void @llvm.assume(i1) #0
define void @test1(i8* %P, i8* %Q) nounwind ssp { define void @test1(i8* %P, i8* %Q) nounwind ssp {
tail call void @llvm.assume(i1 true) tail call void @llvm.assume(i1 true)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
Show All 14 Lines

llvm/test/Analysis/BasicAA/bug.23540.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@c = external global i32 @c = external global i32
; CHECK-LABEL: f ; CHECK-LABEL: f
; CHECK: MayAlias: i32* %arrayidx, i32* %arrayidx6 ; CHECK: MayAlias: i32* %arrayidx, i32* %arrayidx6
define void @f() { define void @f() {
%idxprom = zext i32 undef to i64 %idxprom = zext i32 undef to i64
%add4 = add i32 0, 1 %add4 = add i32 0, 1
%idxprom5 = zext i32 %add4 to i64 %idxprom5 = zext i32 %add4 to i64
%arrayidx6 = getelementptr inbounds i32, i32* @c, i64 %idxprom5 %arrayidx6 = getelementptr inbounds i32, i32* @c, i64 %idxprom5
%arrayidx = getelementptr inbounds i32, i32* @c, i64 %idxprom %arrayidx = getelementptr inbounds i32, i32* @c, i64 %idxprom
ret void ret void
} }

llvm/test/Analysis/BasicAA/bug.23626.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-darwin13.4.0" target triple = "x86_64-apple-darwin13.4.0"
; CHECK-LABEL: compute1 ; CHECK-LABEL: compute1
; CHECK: MayAlias: i32* %arrayidx8, i32* %out ; CHECK: MayAlias: i32* %arrayidx8, i32* %out
; CHECK: MayAlias: i32* %arrayidx11, i32* %out ; CHECK: MayAlias: i32* %arrayidx11, i32* %out
; CHECK: MayAlias: i32* %arrayidx11, i32* %arrayidx8 ; CHECK: MayAlias: i32* %arrayidx11, i32* %arrayidx8
; CHECK: MayAlias: i32* %arrayidx14, i32* %out ; CHECK: MayAlias: i32* %arrayidx14, i32* %out
Show All 22 Lines

llvm/test/Analysis/BasicAA/byval.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i686-apple-darwin8" target triple = "i686-apple-darwin8"
%struct.x = type { i32, i32, i32, i32 } %struct.x = type { i32, i32, i32, i32 }
@g = weak global i32 0 ; <i32*> [#uses=1] @g = weak global i32 0 ; <i32*> [#uses=1]
define i32 @foo(%struct.x* byval %a) nounwind { define i32 @foo(%struct.x* byval %a) nounwind {
; CHECK: ret i32 1 ; CHECK: ret i32 1
%tmp1 = tail call i32 (...) @bar( %struct.x* %a ) nounwind ; <i32> [#uses=0] %tmp1 = tail call i32 (...) @bar( %struct.x* %a ) nounwind ; <i32> [#uses=0]
Show All 9 Lines

llvm/test/Analysis/BasicAA/call-attrs.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @readonly_attr(i8* readonly nocapture) declare void @readonly_attr(i8* readonly nocapture)
declare void @writeonly_attr(i8* writeonly nocapture) declare void @writeonly_attr(i8* writeonly nocapture)
declare void @readnone_attr(i8* readnone nocapture) declare void @readnone_attr(i8* readnone nocapture)
declare void @readonly_func(i8* nocapture) readonly declare void @readonly_func(i8* nocapture) readonly
declare void @writeonly_func(i8* nocapture) writeonly declare void @writeonly_func(i8* nocapture) writeonly
declare void @readnone_func(i8* nocapture) readnone declare void @readnone_func(i8* nocapture) readnone
Show All 33 Lines

llvm/test/Analysis/BasicAA/cas.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
@flag0 = internal global i32 zeroinitializer @flag0 = internal global i32 zeroinitializer
@turn = internal global i32 zeroinitializer @turn = internal global i32 zeroinitializer
; CHECK: ret i32 0 ; CHECK: ret i32 0
define i32 @main() { define i32 @main() {
%a = load i32, i32* @flag0 %a = load i32, i32* @flag0
%b = atomicrmw xchg i32* @turn, i32 1 monotonic %b = atomicrmw xchg i32* @turn, i32 1 monotonic
%c = load i32, i32* @flag0 %c = load i32, i32* @flag0
%d = sub i32 %a, %c %d = sub i32 %a, %c
ret i32 %d ret i32 %d
} }

llvm/test/Analysis/BasicAA/constant-over-index.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
; PR4267 ; PR4267
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: MayAlias: double* %p.0.i.0, double* %p3 ; CHECK: MayAlias: double* %p.0.i.0, double* %p3
; %p3 is equal to %p.0.i.0 on the second iteration of the loop, ; %p3 is equal to %p.0.i.0 on the second iteration of the loop,
; so MayAlias is needed. In practice, basicaa returns PartialAlias ; so MayAlias is needed. In practice, basicaa returns PartialAlias
Show All 22 Lines

llvm/test/Analysis/BasicAA/cs-cs-arm.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; REQUIRES: arm ; REQUIRES: arm
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
target triple = "arm-apple-ios" target triple = "arm-apple-ios"
declare <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8*, i32) nounwind readonly declare <8 x i16> @llvm.arm.neon.vld1.v8i16.p0i8(i8*, i32) nounwind readonly
declare void @llvm.arm.neon.vst1.p0i8.v8i16(i8*, <8 x i16>, i32) nounwind declare void @llvm.arm.neon.vst1.p0i8.v8i16(i8*, <8 x i16>, i32) nounwind
Show All 25 Lines

llvm/test/Analysis/BasicAA/cs-cs.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -S 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -S 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
target triple = "arm-apple-ios" target triple = "arm-apple-ios"
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #0 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #0
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0
declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) #0 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) #0
declare void @a_readonly_func(i8*) #1 declare void @a_readonly_func(i8*) #1
▲ Show 20 Lines • Show All 403 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/dag.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
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" 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"
; BasicAA's guard against use-def cycles shouldn't prevent it from ; BasicAA's guard against use-def cycles shouldn't prevent it from
; analyzing use-def dags. ; analyzing use-def dags.
; CHECK: MustAlias: i8* %base, i8* %phi ; CHECK: MustAlias: i8* %base, i8* %phi
; CHECK: MustAlias: i8* %phi, i8* %wwa ; CHECK: MustAlias: i8* %phi, i8* %wwa
Show All 32 Lines

llvm/test/Analysis/BasicAA/dereferenceable.ll

; RUN: opt -basicaa -print-all-alias-modref-info -aa-eval -analyze < %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -print-all-alias-modref-info -aa-eval -analyze < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@G = global i32 0, align 4 @G = global i32 0, align 4
define i64 @global_and_deref_arg_1(i64* dereferenceable(8) %arg) { define i64 @global_and_deref_arg_1(i64* dereferenceable(8) %arg) {
; CHECK: Function: global_and_deref_arg_1: 2 pointers, 0 call sites ; CHECK: Function: global_and_deref_arg_1: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* @G, i64* %arg ; CHECK-NEXT: NoAlias: i32* @G, i64* %arg
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/empty.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
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" 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: Function: foo: ; CHECK: Function: foo:
; CHECK-NEXT: NoAlias: {}* %p, {}* %q ; CHECK-NEXT: NoAlias: {}* %p, {}* %q
define void @foo({}* %p, {}* %q) { define void @foo({}* %p, {}* %q) {
store {} {}, {}* %p store {} {}, {}* %p
store {} {}, {}* %q store {} {}, {}* %q
ret void ret void
} }

llvm/test/Analysis/BasicAA/fallback-mayalias.ll

; RUN: opt -basicaa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
; Check that BasicAA falls back to MayAlias (instead of PartialAlias) when none ; Check that BasicAA falls back to MayAlias (instead of PartialAlias) when none
; of its little tricks are applicable. ; of its little tricks are applicable.
; CHECK: MayAlias: float* %arrayidxA, float* %arrayidxB ; CHECK: MayAlias: float* %arrayidxA, float* %arrayidxB
define void @fallback_mayalias(float* noalias nocapture %C, i64 %i, i64 %j) local_unnamed_addr { define void @fallback_mayalias(float* noalias nocapture %C, i64 %i, i64 %j) local_unnamed_addr {
entry: entry:
Show All 14 Lines

llvm/test/Analysis/BasicAA/featuretest.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; This testcase tests for various features the basicaa test should be able to ; This testcase tests for various features the basicaa test should be able to
; determine, as noted in the comments. ; determine, as noted in the comments.
; RUN: opt < %s -basicaa -gvn -instcombine -dce -S | FileCheck %s --check-prefixes=CHECK,NO_ASSUME ; RUN: opt < %s -basic-aa -gvn -instcombine -dce -S | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
; RUN: opt < %s -basicaa -gvn -instcombine -dce --enable-knowledge-retention -S | FileCheck %s --check-prefixes=CHECK,USE_ASSUME ; RUN: opt < %s -basic-aa -gvn -instcombine -dce --enable-knowledge-retention -S | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
@Global = external global { i32 } @Global = external global { i32 }
declare void @external(i32*) declare void @external(i32*)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
; Array test: Test that operations on one local array do not invalidate ; Array test: Test that operations on one local array do not invalidate
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/full-store-partial-alias.ll

; RUN: opt -S -tbaa -gvn < %s | FileCheck -check-prefix=BASICAA %s ; RUN: opt -S -tbaa -gvn < %s | FileCheck -check-prefix=BASICAA %s
; RUN: opt -S -tbaa -disable-basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -tbaa -disable-basic-aa -gvn < %s | FileCheck %s
; rdar://8875631, rdar://8875069 ; rdar://8875631, rdar://8875069
; BasicAA should notice that the store stores to the entire %u object, ; BasicAA should notice that the store stores to the entire %u object,
; so the %tmp5 load is PartialAlias with the store and suppress TBAA. ; so the %tmp5 load is PartialAlias with the store and suppress TBAA.
; Without BasicAA, TBAA should say that %tmp5 is NoAlias with the store. ; Without BasicAA, TBAA should say that %tmp5 is NoAlias with the store.
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
Show All 27 Lines

llvm/test/Analysis/BasicAA/gcsetest.ll

; Test that GCSE uses basicaa to do alias analysis, which is capable of ; Test that GCSE uses basicaa to do alias analysis, which is capable of
; disambiguating some obvious cases. All loads should be removable in ; disambiguating some obvious cases. All loads should be removable in
; this testcase. ; this testcase.
; RUN: opt < %s -basicaa -gvn -instcombine -dce -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -dce -S | FileCheck %s
@A = global i32 7 @A = global i32 7
@B = global i32 8 @B = global i32 8
; CHECK: define i32 @test() ; CHECK: define i32 @test()
; CHECK-NEXT: store i32 123, i32* @B ; CHECK-NEXT: store i32 123, i32* @B
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/gep-alias.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
; Make sure that basicaa thinks R and r are must aliases. ; Make sure that basicaa thinks R and r are must aliases.
define i32 @test1(i8 * %P) { define i32 @test1(i8 * %P) {
entry: entry:
%Q = bitcast i8* %P to {i32, i32}* %Q = bitcast i8* %P to {i32, i32}*
%R = getelementptr {i32, i32}, {i32, i32}* %Q, i32 0, i32 1 %R = getelementptr {i32, i32}, {i32, i32}* %Q, i32 0, i32 1
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/gep-and-alias-64.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
target datalayout = "e-m:o-p:64:64-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:64:64-f64:32:64-f80:128-n8:16:32-S128"
target triple = "x86_64-apple-macosx10.6.0" target triple = "x86_64-apple-macosx10.6.0"
; The load and store address in the loop body could alias so the load ; The load and store address in the loop body could alias so the load
; can't be hoisted above the store and out of the loop. ; can't be hoisted above the store and out of the loop.
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1)
Show All 34 Lines

llvm/test/Analysis/BasicAA/gep-and-alias.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
; RUN: opt -S -basicaa -gvn -basicaa-force-at-least-64b=0 < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn -basicaa-force-at-least-64b=0 < %s | FileCheck %s
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.6.0" target triple = "i386-apple-macosx10.6.0"
; The load and store address in the loop body could alias so the load ; The load and store address in the loop body could alias so the load
; can't be hoisted above the store and out of the loop. ; can't be hoisted above the store and out of the loop.
declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1) declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1)
Show All 34 Lines

llvm/test/Analysis/BasicAA/getmodrefinfo-cs-cs.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Just Ref: call void @ro() <-> call void @f0() ; CHECK: Just Ref: call void @ro() <-> call void @f0()
declare void @f0() declare void @f0()
declare void @ro() readonly declare void @ro() readonly
define void @test0() { define void @test0() {
Show All 17 Lines

llvm/test/Analysis/BasicAA/global-size.ll

; A store or load cannot alias a global if the accessed amount is larger then ; A store or load cannot alias a global if the accessed amount is larger then
; the global. ; the global.
; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
@B = global i16 8 @B = global i16 8
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
define i16 @test1(i32* %P) { define i16 @test1(i32* %P) {
%X = load i16, i16* @B %X = load i16, i16* @B
store i32 7, i32* %P store i32 7, i32* %P
Show All 40 Lines

llvm/test/Analysis/BasicAA/guards.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
declare void @unknown_but_readonly() readonly declare void @unknown_but_readonly() readonly
define void @test1(i8* %P, i8* %Q) { define void @test1(i8* %P, i8* %Q) {
tail call void(i1,...) @llvm.experimental.guard(i1 true) [ "deopt"() ] tail call void(i1,...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
Show All 21 Lines

llvm/test/Analysis/BasicAA/intrinsics-arm.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
; REQUIRES: arm ; REQUIRES: arm
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
; BasicAA should prove that these calls don't interfere, since we've ; BasicAA should prove that these calls don't interfere, since we've
; specifically special cased exactly these two intrinsics in ; specifically special cased exactly these two intrinsics in
; MemoryLocation::getForArgument. ; MemoryLocation::getForArgument.
Show All 22 Lines

llvm/test/Analysis/BasicAA/intrinsics.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
; BasicAA should prove that these calls don't interfere, since they are ; BasicAA should prove that these calls don't interfere, since they are
; IntrArgReadMem and have noalias pointers. ; IntrArgReadMem and have noalias pointers.
; CHECK: define <8 x i16> @test0(<8 x i16>* noalias %p, <8 x i16>* noalias %q, <8 x i16> %y, <8 x i1> %m, <8 x i16> %pt) { ; CHECK: define <8 x i16> @test0(<8 x i16>* noalias %p, <8 x i16>* noalias %q, <8 x i16> %y, <8 x i1> %m, <8 x i16> %pt) {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 18 Lines

llvm/test/Analysis/BasicAA/invariant_group.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -basicaa -gvn -S | FileCheck -check-prefix=CHECK-GVN %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck -check-prefix=CHECK-GVN %s
; The input *.ll had been adapted from bug 37458: ; The input *.ll had been adapted from bug 37458:
; ;
; struct A { virtual void f(); int n; }; ; struct A { virtual void f(); int n; };
; ;
; int h() { ; int h() {
; A a; ; A a;
; a.n = 42; ; a.n = 42;
Show All 38 Lines

llvm/test/Analysis/BasicAA/invariant_load.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; The input *.ll is obtained by manually annotating "invariant.load" to the ; The input *.ll is obtained by manually annotating "invariant.load" to the
; two loads. With "invariant.load" metadata, the second load is redundant. ; two loads. With "invariant.load" metadata, the second load is redundant.
; ;
; int foo(int *p, char *q) { ; int foo(int *p, char *q) {
; *q = (char)*p; ; *q = (char)*p;
; return *p + 1; ; return *p + 1;
; } ; }
Show All 17 Lines

llvm/test/Analysis/BasicAA/memset_pattern.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
; PR10872 ; PR10872
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" 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"
target triple = "x86_64-apple-macosx10.7" target triple = "x86_64-apple-macosx10.7"
@z = internal global i32 0, align 4 @z = internal global i32 0, align 4
@y = internal global i32 0, align 4 @y = internal global i32 0, align 4
@x = internal constant i32 0, align 4 @x = internal constant i32 0, align 4
Show All 12 Lines

llvm/test/Analysis/BasicAA/modref.ll

; RUN: opt < %s -basicaa -gvn -dse -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @external(i32*) declare void @external(i32*)
define i32 @test0(i8* %P) { define i32 @test0(i8* %P) {
%A = alloca i32 %A = alloca i32
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/must-and-partial.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
; When merging MustAlias and PartialAlias, merge to PartialAlias ; When merging MustAlias and PartialAlias, merge to PartialAlias
; instead of MayAlias. ; 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" 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 ; CHECK: PartialAlias: i16* %bigbase0, i8* %phi
Show All 30 Lines

llvm/test/Analysis/BasicAA/negoffset.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
target triple = "i386-unknown-linux-gnu" target triple = "i386-unknown-linux-gnu"
declare i32* @random.i32(i32* %ptr) declare i32* @random.i32(i32* %ptr)
; CHECK-LABEL: Function: arr: ; CHECK-LABEL: Function: arr:
; CHECK-DAG: MayAlias: i32* %alloca, i32* %p0 ; CHECK-DAG: MayAlias: i32* %alloca, i32* %p0
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/no-escape-call.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; PR2436 ; PR2436
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8" target triple = "i386-apple-darwin8"
define i1 @foo(i32 %i) nounwind { define i1 @foo(i32 %i) nounwind {
; CHECK: ret i1 true ; CHECK: ret i1 true
entry: entry:
%arr = alloca [10 x i8*] ; <[10 x i8*]*> [#uses=1] %arr = alloca [10 x i8*] ; <[10 x i8*]*> [#uses=1]
Show All 15 Lines

llvm/test/Analysis/BasicAA/noalias-bugs.ll

; RUN: opt -S -basicaa -dse < %s | FileCheck %s ; RUN: opt -S -basic-aa -dse < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; We incorrectly returned noalias in the example below for "ptr.64" and ; We incorrectly returned noalias in the example below for "ptr.64" and
; "either_ptr.64". ; "either_ptr.64".
; PR18460 ; PR18460
Show All 24 Lines

llvm/test/Analysis/BasicAA/noalias-geps.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
; Check that geps with equal base offsets of noalias base pointers stay noalias. ; Check that geps with equal base offsets of noalias base pointers stay noalias.
define i32 @test(i32* %p, i16 %i) { define i32 @test(i32* %p, i16 %i) {
; CHECK-LABEL: Function: test: ; CHECK-LABEL: Function: test:
%pi = getelementptr i32, i32* %p, i32 0 %pi = getelementptr i32, i32* %p, i32 0
%pi.next = getelementptr i32, i32* %p, i32 1 %pi.next = getelementptr i32, i32* %p, i32 1
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/noalias-param.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
declare i32* @captures(i32* %cap) nounwind readonly declare i32* @captures(i32* %cap) nounwind readonly
define void @no(i32* noalias %a, i32* %b) nounwind { define void @no(i32* noalias %a, i32* %b) nounwind {
entry: entry:
store i32 1, i32* %a store i32 1, i32* %a
%cap = call i32* @captures(i32* %a) nounwind readonly %cap = call i32* @captures(i32* %a) nounwind readonly
%l = load i32, i32* %b %l = load i32, i32* %b
Show All 14 Lines

llvm/test/Analysis/BasicAA/noalias-wraparound-bug.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.6.0" target triple = "i386-apple-macosx10.6.0"
; We incorrectly returned noalias in the example below for "tmp5" and ; We incorrectly returned noalias in the example below for "tmp5" and
; "tmp12" returning i32 32, since basicaa converted the offsets to 64b ; "tmp12" returning i32 32, since basicaa converted the offsets to 64b
; and missed the wrap-around ; and missed the wrap-around
Show All 15 Lines

llvm/test/Analysis/BasicAA/nocapture.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
declare i32* @test(i32* nocapture) declare i32* @test(i32* nocapture)
define i32 @test2() { define i32 @test2() {
; CHECK: ret i32 0 ; CHECK: ret i32 0
%P = alloca i32 %P = alloca i32
%Q = call i32* @test(i32* %P) %Q = call i32* @test(i32* %P)
%a = load i32, i32* %P %a = load i32, i32* %P
Show All 27 Lines

llvm/test/Analysis/BasicAA/phi-aa.ll

; RUN: opt < %s -phi-values -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -phi-values -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<phi-values>,aa-eval' -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<phi-values>,aa-eval' -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
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-S128" 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-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; rdar://7282591 ; rdar://7282591
@X = common global i32 0 @X = common global i32 0
@Y = common global i32 0 @Y = common global i32 0
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/phi-and-select.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; BasicAA should detect NoAliases in PHIs and Selects. ; BasicAA should detect NoAliases in PHIs and Selects.
; CHECK: Function: foo ; CHECK: Function: foo
; CHECK: NoAlias: double* %a, double* %b ; CHECK: NoAlias: double* %a, double* %b
; CHECK: Function: bar ; CHECK: Function: bar
; CHECK: NoAlias: double* %a, double* %b ; CHECK: NoAlias: double* %a, double* %b
; CHECK: Function: qux ; CHECK: Function: qux
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/phi-loop.ll

; RUN: opt < %s -basicaa -basicaa-recphi=1 -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -basicaa-recphi=1 -gvn -S | FileCheck %s
; ;
; Check that section->word_ofs doesn't get reloaded in every iteration of the ; Check that section->word_ofs doesn't get reloaded in every iteration of the
; for loop. ; for loop.
; ;
; Code: ; Code:
; ;
; typedef struct { ; typedef struct {
; unsigned num_words; ; unsigned num_words;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/phi-spec-order.ll

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-f128:128:128-v128:128:128-n32:64" 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-f128:128:128-v128:128:128-n32:64"
target triple = "powerpc64-bgq-linux" target triple = "powerpc64-bgq-linux"
; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
@X = external global [16000 x double], align 32 @X = external global [16000 x double], align 32
@Y = external global [16000 x double], align 32 @Y = external global [16000 x double], align 32
define signext i32 @s000() nounwind { define signext i32 @s000() nounwind {
entry: entry:
br label %for.cond2.preheader br label %for.cond2.preheader
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/phi-speculation.ll

target datalayout = 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-S128" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; ptr_phi and ptr2_phi do not alias. ; ptr_phi and ptr2_phi do not alias.
; CHECK: test_noalias_1 ; CHECK: test_noalias_1
; CHECK: NoAlias: i32* %ptr2_phi, i32* %ptr_phi ; CHECK: NoAlias: i32* %ptr2_phi, i32* %ptr_phi
define i32 @test_noalias_1(i32* %ptr2, i32 %count, i32* %coeff) { define i32 @test_noalias_1(i32* %ptr2, i32 %count, i32* %coeff) {
entry: entry:
%ptr = getelementptr inbounds i32, i32* %ptr2, i64 1 %ptr = getelementptr inbounds i32, i32* %ptr2, i64 1
br label %while.body br label %while.body
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/pr31761.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
%struct.blam = type { i32, i32 } %struct.blam = type { i32, i32 }
Show All 10 Lines

llvm/test/Analysis/BasicAA/ptrmask.ll

; RUN: opt -basicaa -aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s
%struct = type <{ [20 x i64] }> %struct = type <{ [20 x i64] }>
; CHECK-LABEL: Function: test_noalias: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test_noalias: 4 pointers, 1 call sites
; CHECK-NEXT: NoAlias: %struct* %ptr1, i64* %ptr2 ; CHECK-NEXT: NoAlias: %struct* %ptr1, i64* %ptr2
; CHECK-NEXT: NoAlias: %struct* %addr.ptr, i64* %ptr2 ; CHECK-NEXT: NoAlias: %struct* %addr.ptr, i64* %ptr2
; CHECK-NEXT: NoAlias: i64* %gep, i64* %ptr2 ; CHECK-NEXT: NoAlias: i64* %gep, i64* %ptr2
define void @test_noalias(%struct* noalias %ptr1, i64* %ptr2, i64 %offset) { define void @test_noalias(%struct* noalias %ptr1, i64* %ptr2, i64 %offset) {
Show All 20 Lines

llvm/test/Analysis/BasicAA/pure-const-dce.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
@g = global i32 0 @g = global i32 0
; CHECK: @test ; CHECK: @test
; CHECK: entry ; CHECK: entry
; CHECK: %tmp0 = call i32 @TestConst(i32 5) [[READNONE:#[0-9]+]] ; CHECK: %tmp0 = call i32 @TestConst(i32 5) [[READNONE:#[0-9]+]]
; CHECK-NEXT: %tmp1 = call i32 @TestPure(i32 6) [[READONLY:#[0-9]+]] ; CHECK-NEXT: %tmp1 = call i32 @TestPure(i32 6) [[READONLY:#[0-9]+]]
; CHECK-NEXT: %tmp2 = call i32 @TestNone(i32 7) ; CHECK-NEXT: %tmp2 = call i32 @TestNone(i32 7)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/q.bad.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7--linux-gnueabi" target triple = "thumbv7--linux-gnueabi"
; CHECK-LABEL: test_zext_sext_amounts255 ; CHECK-LABEL: test_zext_sext_amounts255
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_zext_sext_amounts255(i8* %mem) { define void @test_zext_sext_amounts255(i8* %mem) {
%sext.1 = sext i8 255 to i16 %sext.1 = sext i8 255 to i16
%sext.zext.1 = zext i16 %sext.1 to i64 %sext.zext.1 = zext i16 %sext.1 to i64
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/returned.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct = type { i32, i32, i32 } %struct = type { i32, i32, i32 }
; CHECK-LABEL: test_simple ; CHECK-LABEL: test_simple
; CHECK-DAG: MustAlias: %struct* %st, %struct* %sta ; CHECK-DAG: MustAlias: %struct* %st, %struct* %sta
Show All 36 Lines

llvm/test/Analysis/BasicAA/sequential-gep.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Function: t1 ; CHECK: Function: t1
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @t1([8 x i32]* %p, i32 %addend, i32* %q) { define void @t1([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/store-promote.ll

; Test that LICM uses basicaa to do alias analysis, which is capable of ; Test that LICM uses basicaa to do alias analysis, which is capable of
; disambiguating some obvious cases. If LICM is able to disambiguate the ; disambiguating some obvious cases. If LICM is able to disambiguate the
; two pointers, then the load should be hoisted, and the store sunk. ; two pointers, then the load should be hoisted, and the store sunk.
; RUN: opt < %s -basicaa -licm -enable-mssa-loop-dependency=false -S | FileCheck %s -check-prefixes=CHECK,AST ; RUN: opt < %s -basic-aa -licm -enable-mssa-loop-dependency=false -S | FileCheck %s -check-prefixes=CHECK,AST
; RUN: opt < %s -basicaa -licm -enable-mssa-loop-dependency=true -S | FileCheck %s -check-prefixes=CHECK,MSSA ; RUN: opt < %s -basic-aa -licm -enable-mssa-loop-dependency=true -S | FileCheck %s -check-prefixes=CHECK,MSSA
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
@A = global i32 7 ; <i32*> [#uses=3] @A = global i32 7 ; <i32*> [#uses=3]
@B = global i32 8 ; <i32*> [#uses=2] @B = global i32 8 ; <i32*> [#uses=2]
@C = global [2 x i32] [ i32 4, i32 8 ] ; <[2 x i32]*> [#uses=2] @C = global [2 x i32] [ i32 4, i32 8 ] ; <[2 x i32]*> [#uses=2]
define i32 @test1(i1 %c) { define i32 @test1(i1 %c) {
%Atmp = load i32, i32* @A ; <i32> [#uses=2] %Atmp = load i32, i32* @A ; <i32> [#uses=2]
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/struct-geps.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -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" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct = type { i32, i32, i32 } %struct = type { i32, i32, i32 }
; CHECK-LABEL: test_simple ; CHECK-LABEL: test_simple
; CHECK-DAG: MayAlias: %struct* %st, i32* %x ; CHECK-DAG: MayAlias: %struct* %st, i32* %x
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/tail-byval.ll

; RUN: opt -basicaa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
declare void @takebyval(i32* byval %p) declare void @takebyval(i32* byval %p)
define i32 @tailbyval() { define i32 @tailbyval() {
entry: entry:
%p = alloca i32 %p = alloca i32
store i32 42, i32* %p store i32 42, i32* %p
tail call void @takebyval(i32* byval %p) tail call void @takebyval(i32* byval %p)
%rv = load i32, i32* %p %rv = load i32, i32* %p
ret i32 %rv ret i32 %rv
} }
; FIXME: This should be Just Ref. ; FIXME: This should be Just Ref.
; CHECK-LABEL: Function: tailbyval: 1 pointers, 1 call sites ; CHECK-LABEL: Function: tailbyval: 1 pointers, 1 call sites
; CHECK-NEXT: Both ModRef: Ptr: i32* %p <-> tail call void @takebyval(i32* byval %p) ; CHECK-NEXT: Both ModRef: Ptr: i32* %p <-> tail call void @takebyval(i32* byval %p)

llvm/test/Analysis/BasicAA/tailcall-modref.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
define i32 @test() { define i32 @test() {
; CHECK: ret i32 0 ; CHECK: ret i32 0
%A = alloca i32 ; <i32*> [#uses=3] %A = alloca i32 ; <i32*> [#uses=3]
call void @foo( i32* %A ) call void @foo( i32* %A )
%X = load i32, i32* %A ; <i32> [#uses=1] %X = load i32, i32* %A ; <i32> [#uses=1]
tail call void @bar( ) tail call void @bar( )
%Y = load i32, i32* %A ; <i32> [#uses=1] %Y = load i32, i32* %A ; <i32> [#uses=1]
%Z = sub i32 %X, %Y ; <i32> [#uses=1] %Z = sub i32 %X, %Y ; <i32> [#uses=1]
ret i32 %Z ret i32 %Z
} }
declare void @foo(i32*) declare void @foo(i32*)
declare void @bar() declare void @bar()

llvm/test/Analysis/BasicAA/underlying-value.ll

; RUN: opt -basicaa -licm -S < %s ; RUN: opt -basic-aa -licm -S < %s
; PR9931 ; PR9931
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" 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"
define void @func_20() nounwind { define void @func_20() nounwind {
entry: entry:
br label %for.cond br label %for.cond
Show All 16 Lines

llvm/test/Analysis/BasicAA/unreachable-block.ll

; RUN: opt -basicaa -aa-eval -disable-output < %s > /dev/null 2>&1 ; RUN: opt -basic-aa -aa-eval -disable-output < %s > /dev/null 2>&1
; BasicAA shouldn't infinitely recurse on the use-def cycles in ; BasicAA shouldn't infinitely recurse on the use-def cycles in
; unreachable code. ; unreachable code.
define void @func_2() nounwind { define void @func_2() nounwind {
entry: entry:
unreachable unreachable
bb: bb:
%t = select i1 undef, i32* %t, i32* undef %t = select i1 undef, i32* %t, i32* undef
%p = select i1 undef, i32* %p, i32* %p %p = select i1 undef, i32* %p, i32* %p
%q = select i1 undef, i32* undef, i32* %p %q = select i1 undef, i32* undef, i32* %p
%a = getelementptr i8, i8* %a, i32 0 %a = getelementptr i8, i8* %a, i32 0
unreachable unreachable
} }

llvm/test/Analysis/BasicAA/vscale.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; getelementptr ; getelementptr
; CHECK-LABEL: gep_alloca_const_offset_1 ; CHECK-LABEL: gep_alloca_const_offset_1
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_alloca_const_offset_1() { define void @gep_alloca_const_offset_1() {
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/zext.ll

; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
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-S128" 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-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: test_with_zext ; CHECK-LABEL: test_with_zext
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_with_zext() { define void @test_with_zext() {
%1 = tail call i8* @malloc(i64 120) %1 = tail call i8* @malloc(i64 120)
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines