-; RUN: llvm-as < %s | opt -anders-aa -load-vn -gcse -deadargelim | llvm-dis | not grep ARG
+; RUN: llvm-upgrade < %s | llvm-as | opt -anders-aa -load-vn -gcse -deadargelim | llvm-dis | not grep ARG
%G = internal constant int* null
-; RUN: llvm-as < %s | opt -anders-aa -aa-eval
+; RUN: llvm-upgrade < %s | llvm-as | opt -anders-aa -aa-eval
implementation
-; RUN: llvm-as < %s | opt -anders-aa -load-vn -gcse -deadargelim | llvm-dis | grep store | not grep null
+; RUN: llvm-upgrade < %s | llvm-as | opt -anders-aa -load-vn -gcse -deadargelim | llvm-dis | grep store | not grep null
; Because the 'internal' function is passed to an external function, we don't
; know what the incoming values will alias. As such, we cannot do the
-; RUN: llvm-as < %s | opt -anders-aa -load-vn -gcse -instcombine | llvm-dis | grep 'ret bool true'
+; RUN: llvm-upgrade < %s | llvm-as | opt -anders-aa -load-vn -gcse -instcombine | llvm-dis | grep 'ret bool true'
%G = internal global int* null
declare int *%ext()
-; RUN: llvm-as < %s | opt -anders-aa -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -anders-aa -disable-output
void %foo() { ret void }
; 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.
-; RUN: llvm-as < %s | opt -load-vn -gcse -instcombine | llvm-dis | grep DONOTREMOVE
+; RUN: llvm-upgrade < %s | llvm-as | opt -load-vn -gcse -instcombine | llvm-dis | grep DONOTREMOVE
int %test() {
%A = alloca int
-; RUN: llvm-as < %s | opt -basicaa -aa-eval -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -aa-eval -disable-output
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
void %test({[2 x int],[2 x int]}* %A, long %X, long %Y) {
%P1 = getelementptr {[2 x int],[2 x int]}* %A, long 0, uint 0, long %X
-; RUN: llvm-as < %s | opt -load-vn -gcse -instcombine | llvm-dis | grep sub
+; RUN: llvm-upgrade < %s | llvm-as | opt -load-vn -gcse -instcombine | llvm-dis | grep sub
; BasicAA was incorrectly concluding that P1 and P2 didn't conflict!
-; RUN: llvm-as < %s | opt -basicaa -aa-eval -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -aa-eval -disable-output
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
void %test([17 x ushort]* %mask_bits) {
%P1 = getelementptr [17 x ushort]* %mask_bits, long 0, long 0
-; RUN: llvm-as < %s | opt -licm -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -licm -disable-output
%struct..apr_array_header_t = type { int*, int, int, int, sbyte* }
%struct..apr_table_t = type { %struct..apr_array_header_t, uint, [32 x int], [32 x int] }
-; RUN: llvm-as < %s | opt -basicaa -aa-eval -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -aa-eval -disable-output
int %MTConcat([3 x int]* %a.1) {
%tmp.961 = getelementptr [3 x int]* %a.1, long 0, long 4
-; RUN: llvm-as < %s | opt -basicaa -aa-eval -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -aa-eval -disable-output
%struct..RefPoint = type { int, { uint, ushort, ushort } }
%struct..RefRect = type { %struct..RefPoint, %struct..RefPoint }
; In this test, a local alloca cannot alias an incoming argument.
-; RUN: llvm-as < %s | opt -load-vn -gcse -instcombine | llvm-dis | not grep sub
+; RUN: llvm-upgrade < %s | llvm-as | opt -load-vn -gcse -instcombine | llvm-dis | not grep sub
int %test(int* %P) {
%X = alloca int
; This testcase consists of alias relations which should be completely
; resolvable by basicaa.
-; RUN: llvm-as < %s | opt -aa-eval -print-may-aliases 2>&1 -disable-output | not grep May:
+; RUN: llvm-upgrade < %s | llvm-as | opt -aa-eval -print-may-aliases 2>&1 -disable-output | not grep May:
%T = type { uint, [10 x ubyte] }
; This testcase consists of alias relations which should be completely
; resolvable by basicaa, but require analysis of getelementptr constant exprs.
-; RUN: llvm-as < %s | opt -aa-eval -print-may-aliases 2>&1 -disable-output | not grep May:
+; RUN: llvm-upgrade < %s | llvm-as | opt -aa-eval -print-may-aliases 2>&1 -disable-output | not grep May:
%T = type { uint, [10 x ubyte] }
-; RUN: llvm-as < %s | opt -licm
+; RUN: llvm-upgrade < %s | llvm-as | opt -licm
"java/lang/Object" = type { %struct.llvm_java_object_base }
"java/lang/StringBuffer" = type { "java/lang/Object", int, { "java/lang/Object", uint, [0 x ushort] }*, bool }
-; RUN: llvm-as < %s | opt -dse
+; RUN: llvm-upgrade < %s | llvm-as | opt -dse
"java/lang/Object" = type { %struct.llvm_java_object_base }
"java/lang/StringBuffer" = type { "java/lang/Object", int, { "java/lang/Object", uint, [0 x ushort] }*, bool }
-; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | grep 'load int\* %A'
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | grep 'load int\* %A'
declare double* %useit(int*)
-; RUN: llvm-as < %s | opt -aa-eval -disable-output 2>&1 | grep '2 no alias respon'
+; RUN: llvm-upgrade < %s | llvm-as | opt -aa-eval -disable-output 2>&1 | grep '2 no alias respon'
;; TEST that A[1][0] may alias A[0][i].
-; RUN: llvm-as < %s | opt -licm -disable-output
+; RUN: llvm-upgrade < %s | llvm-as | opt -licm -disable-output
target endian = big
target pointersize = 32
target triple = "powerpc-apple-darwin8.7.0"
; This testcase tests for various features the basicaa test should be able to
; determine, as noted in the comments.
-; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep REMOVE
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep REMOVE
%Global = external global { int }
; disambiguating some obvious cases. All loads should be removable in
; this testcase.
-; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep load
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine -dce | llvm-dis | not grep load
%A = global int 7
%B = global int 8
; A store or load cannot alias a global if the accessed amount is larger then
; the global.
-; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | not grep load
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | not grep load
%B = global short 8
; two pointers, then the load should be hoisted, and the store sunk. Thus
; the loop becomes empty and can be deleted by ADCE.
-; RUN: llvm-as < %s | opt -basicaa -licm --adce | llvm-dis | not grep Loop
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -licm --adce | llvm-dis | not grep Loop
%A = global int 7
%B = global int 8
; A very rudimentary test on AliasAnalysis::getModRefInfo.
-; RUN: llvm-as < %s | opt -print-all-alias-modref-info -aa-eval -disable-output &&
-; RUN: llvm-as < %s | opt -print-all-alias-modref-info -aa-eval -disable-output 2>&1 | not grep NoModRef
+; RUN: llvm-upgrade < %s | llvm-as | opt -print-all-alias-modref-info -aa-eval -disable-output &&
+; RUN: llvm-upgrade < %s | llvm-as | opt -print-all-alias-modref-info -aa-eval -disable-output 2>&1 | not grep NoModRef
int %callee() {
%X = alloca { int, int }
-; RUN: llvm-as < %s | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | grep 'ret int 0'
+; RUN: llvm-upgrade < %s | llvm-as | opt -basicaa -load-vn -gcse -instcombine | llvm-dis | grep 'ret int 0'
declare void %foo(int*)
declare void %bar()
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=Ptr:HR
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=Ptr:HR
-; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
+; RUN: llvm-upgrade < %s | llvm-as | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
%T = type { int*, int* }
int %main() {
; This is the same testcase as 2003-06-29-NodeCollapsing2.ll, but it uses the
; graph checker.
;
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
;
%T = type { int}
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=X:GM
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=X:GM
%G = internal global int 5
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
%X = internal global { int, short, short } { int 1, short 2, short 3 }
; This should cause the global node to collapse!!
; XFAIL: *
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc --dsgc-check-flags=test:GAU
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc --dsgc-check-flags=test:GAU
%Tree = type { int, %Tree*, %Tree* }
%T5 = external global %Tree
; This is the same testcase as 2003-06-29-NodeCollapsing2.ll, but it uses the
; graph checker.
;
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
;
%S = type { double, int }
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=Xn:SMR &&
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=X:SMR
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=Xn:SMR &&
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=X:SMR
declare void %llvm.memcpy.i32(sbyte*, sbyte*, uint, uint)
declare void %llvm.memmove.i32(sbyte*, sbyte*, uint, uint)
-; RUN: llvm-as < %s | opt -ds-aa -load-vn -gcse -instcombine | llvm-dis | not grep sub
+; RUN: llvm-upgrade < %s | llvm-as | opt -ds-aa -load-vn -gcse -instcombine | llvm-dis | not grep sub
void %bar(int* %p) {
ret void
-; RUN: llvm-as < %s | opt -ds-aa -load-vn -gcse -instcombine | llvm-dis | grep sub
+; RUN: llvm-upgrade < %s | llvm-as | opt -ds-aa -load-vn -gcse -instcombine | llvm-dis | grep sub
void %bar(int* %p) {
store int 15, int* %p
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=bu &&\
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=td
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=bu &&\
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=td
%S = type { double, int }
-; RUN: llvm-as < %s | opt -ds-aa -load-vn -gcse | llvm-dis | grep 'load int\* %L'
+; RUN: llvm-upgrade < %s | llvm-as | opt -ds-aa -load-vn -gcse | llvm-dis | grep 'load int\* %L'
%G = internal global int* null
-; RUN: llvm-as < %s | opt -analyze -datastructure
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure
target endian = little
target pointersize = 32
-; RUN: llvm-as < %s | opt -analyze -datastructure
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure
; ModuleID = 'bug3.bc'
target endian = little
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=x:IA
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=x:IA
; ModuleID = 'bug3.bc'
target endian = little
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=Y:SHM && \
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=P1:SHM,P2:SHM
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=Y:SHM && \
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=P1:SHM,P2:SHM
%G = internal constant [2 x int*(int*)*] [
int*(int*)* %callee1, int*(int*)* %callee2
; -- latter should remain unresolved in main() and copied to GG
; -- globals in GG pointed to by latter should be marked I, but not other nodes
;
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-check-flags=KnownPtr:S,UnknownPtr:SI -dsgc-dspass=bu
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-check-flags=KnownPtr:S,UnknownPtr:SI -dsgc-dspass=bu
%Z = internal global int 0
%X = internal global int 0
-; RUN: llvm-as < %s | opt -analyze -budatastructure -dont-print-ds
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -budatastructure -dont-print-ds
%MidFnTy = type void (\2*)
; Test to check for support for "physical subtyping"
;
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-abort-if-any-collapsed
;
%S = type { int }
%T = type { int, float, double }
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc --dsgc-abort-if-merged=Y,BVal
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc --dsgc-abort-if-merged=Y,BVal
implementation
; This tests to make sure that G ends up in the globals graph of the BU pass.
; If it is not, then %G will get converted to a 'constant' from a 'global'
;
-; RUN: llvm-as < %s | opt -ds-opt -globaldce | llvm-dis | grep %G
+; RUN: llvm-upgrade < %s | llvm-as | opt -ds-opt -globaldce | llvm-dis | grep %G
%G = internal global int 0 ; <int*> [#uses=2]
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=A:SM
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=A:SM
; Constant globals should not mark stuff incomplete. This should allow the
; bu pass to resolve the indirect call immediately in "test", allowing %A to
; be marked complete and the store to happen.
; Make sure that the ds-opt pass is constantizing globals
;
-; RUN: llvm-as < %s | opt -ds-opt | llvm-dis | grep %G | grep constant
+; RUN: llvm-upgrade < %s | llvm-as | opt -ds-opt | llvm-dis | grep %G | grep constant
%G = internal global int 0 ; <int*> [#uses=2]
; Test that ds-aa can be used for queries that require field sensitive AA.
-; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
+; RUN: llvm-upgrade < %s | llvm-as | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
%Pair = type { int, int }
; Test that GCSE uses ds-aa to do alias analysis, which is capable of
; disambiguating some cases.
-; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse -instcombine -dce | llvm-dis | not grep ELIM
+; RUN: llvm-upgrade < %s | llvm-as | opt -no-aa -ds-aa -load-vn -gcse -instcombine -dce | llvm-dis | not grep ELIM
%intpair = type {int*, int*}
implementation
; This test was failing because the globals X and Y are marked incomplete
; in the TD graph for %test
; XFAIL: *
-; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse -instcombine | llvm-dis | not grep seteq
+; RUN: llvm-upgrade < %s | llvm-as | opt -no-aa -ds-aa -load-vn -gcse -instcombine | llvm-dis | not grep seteq
%X = internal global int 20
%Y = internal global int* null
; Test that ds-aa is returning must-alias information when it can.
; XFAIL: *
-; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
+; RUN: llvm-upgrade < %s | llvm-as | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
%X = internal global int 20
; has no defined way to check for this, so DSA can know that strcpy doesn't
; require merging the input arguments.
-; RUN: llvm-as < %s | opt -analyze -datastructure-gc --dsgc-abort-if-merged=A,B --dsgc-check-flags=A:ASM,B:ASR --dsgc-dspass=bu
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -datastructure-gc --dsgc-abort-if-merged=A,B --dsgc-check-flags=A:ASM,B:ASR --dsgc-dspass=bu
implementation
-; RUN: llvm-as < %s | opt -analyze -domset -disable-verify
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -domset -disable-verify
;
int %re_match_2() {
ENTRY:
-; RUN: llvm-as < %s | opt -analyze -postdomfrontier -disable-verify
+; RUN: llvm-upgrade < %s | llvm-as | opt -analyze -postdomfrontier -disable-verify
;
; ModuleID = '2006-09-26-PostDominanceFrontier.bc'
target endian = little
-; RUN: llvm-as < %s | opt -domtree -break-crit-edges -analyze -domtree | grep '3.*%brtrue$'
+; RUN: llvm-upgrade < %s | llvm-as | opt -domtree -break-crit-edges -analyze -domtree | grep '3.*%brtrue$'
; PR932
implementation ; Functions:
projects / oota-llvm.git / commitdiff