From f865dcd0092df9fdba44e8d1a996f1e1344760e5 Mon Sep 17 00:00:00 2001 From: Tanya Lattner Date: Thu, 14 Feb 2008 06:56:27 +0000 Subject: Remove llvm-upgrade. llvm-svn: 47110 --- llvm/test/Analysis/BasicAA/featuretest.ll | 101 +++++++++++++++--------------- 1 file changed, 49 insertions(+), 52 deletions(-) (limited to 'llvm/test/Analysis/BasicAA/featuretest.ll') diff --git a/llvm/test/Analysis/BasicAA/featuretest.ll b/llvm/test/Analysis/BasicAA/featuretest.ll index 52e0a526700..a9eeb5d3d2f 100644 --- a/llvm/test/Analysis/BasicAA/featuretest.ll +++ b/llvm/test/Analysis/BasicAA/featuretest.ll @@ -1,85 +1,82 @@ ; This testcase tests for various features the basicaa test should be able to ; determine, as noted in the comments. -; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep REMOVE - -%Global = external global { int } - -implementation +; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep REMOVE +@Global = external global { i32 } ; Array test: Test that operations on one local array do not invalidate ; operations on another array. Important for scientific codes. ; -int %different_array_test(long %A, long %B) { - %Array1 = alloca int, uint 100 - %Array2 = alloca int, uint 200 +define i32 @different_array_test(i64 %A, i64 %B) { + %Array1 = alloca i32, i32 100 + %Array2 = alloca i32, i32 200 - %pointer = getelementptr int* %Array1, long %A - %val = load int* %pointer + %pointer = getelementptr i32* %Array1, i64 %A + %val = load i32* %pointer - %pointer2 = getelementptr int* %Array2, long %B - store int 7, int* %pointer2 + %pointer2 = getelementptr i32* %Array2, i64 %B + store i32 7, i32* %pointer2 - %REMOVE = load int* %pointer ; redundant with above load - %retval = sub int %REMOVE, %val - ret int %retval + %REMOVE = load i32* %pointer ; redundant with above load + %retval = sub i32 %REMOVE, %val + ret i32 %retval } ; Constant index test: Constant indexes into the same array should not ; interfere with each other. Again, important for scientific codes. ; -int %constant_array_index_test() { - %Array = alloca int, uint 100 - %P1 = getelementptr int* %Array, long 7 - %P2 = getelementptr int* %Array, long 6 +define i32 @constant_array_index_test() { + %Array = alloca i32, i32 100 + %P1 = getelementptr i32* %Array, i64 7 + %P2 = getelementptr i32* %Array, i64 6 - %A = load int* %P1 - store int 1, int* %P2 ; Should not invalidate load - %BREMOVE = load int* %P1 - %Val = sub int %A, %BREMOVE - ret int %Val + %A = load i32* %P1 + store i32 1, i32* %P2 ; Should not invalidate load + %BREMOVE = load i32* %P1 + %Val = sub i32 %A, %BREMOVE + ret i32 %Val } ; Test that if two pointers are spaced out by a constant getelementptr, that ; they cannot alias. -int %gep_distance_test(int* %A) { - %REMOVEu = load int* %A - %B = getelementptr int* %A, long 2 ; Cannot alias A - store int 7, int* %B - %REMOVEv = load int* %A - %r = sub int %REMOVEu, %REMOVEv - ret int %r +define i32 @gep_distance_test(i32* %A) { + %REMOVEu = load i32* %A + %B = getelementptr i32* %A, i64 2 ; Cannot alias A + store i32 7, i32* %B + %REMOVEv = load i32* %A + %r = sub i32 %REMOVEu, %REMOVEv + ret i32 %r } ; Test that if two pointers are spaced out by a constant offset, that they ; cannot alias, even if there is a variable offset between them... -int %gep_distance_test2({int,int}* %A, long %distance) { - %A = getelementptr {int,int}* %A, long 0, uint 0 - %REMOVEu = load int* %A - %B = getelementptr {int,int}* %A, long %distance, uint 1 - store int 7, int* %B ; B cannot alias A, it's at least 4 bytes away - %REMOVEv = load int* %A - %r = sub int %REMOVEu, %REMOVEv - ret int %r +define i32 @gep_distance_test2({i32,i32}* %A, i64 %distance) { + %A1 = getelementptr {i32,i32}* %A, i64 0, i32 0 + %REMOVEu = load i32* %A1 + %B = getelementptr {i32,i32}* %A, i64 %distance, i32 1 + store i32 7, i32* %B ; B cannot alias A, it's at least 4 bytes away + %REMOVEv = load i32* %A1 + %r = sub i32 %REMOVEu, %REMOVEv + ret i32 %r } ; Test that we can do funny pointer things and that distance calc will still ; work. -int %gep_distance_test3(int * %A) { - %X = load int* %A - %B = cast int* %A to sbyte* - %C = getelementptr sbyte* %B, long 4 - %Y = load sbyte* %C - ret int 8 +define i32 @gep_distance_test3(i32 * %A) { + %X = load i32* %A + %B = bitcast i32* %A to i8* + %C = getelementptr i8* %B, i64 4 + %Y = load i8* %C + ret i32 8 } ; Test that we can disambiguate globals reached through constantexpr geps -int %constexpr_test() { - %X = alloca int - %Y = load int* %X - store int 5, int* getelementptr ({ int }* %Global, long 0, uint 0) - %REMOVE = load int* %X - %retval = sub int %Y, %REMOVE - ret int %retval +define i32 @constexpr_test() { + %X = alloca i32 + %Y = load i32* %X + store i32 5, i32* getelementptr ({ i32 }* @Global, i64 0, i32 0) + %REMOVE = load i32* %X + %retval = sub i32 %Y, %REMOVE + ret i32 %retval } -- cgit v1.2.3