-; RUN: as < %s | opt -no-aa -ds-aa -load-vn -gcse | dis | not grep load
+; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
%T = type { int*, int* }
int %main() {
; 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: as < %s | opt -ds-opt -globaldce | dis | grep %G
+; RUN: llvm-as < %s | opt -ds-opt -globaldce | llvm-dis | grep %G
%G = internal global int 0 ; <int*> [#uses=2]
; Make sure that the ds-opt pass is constantizing globals
;
-; RUN: as < %s | opt -ds-opt | dis | grep %G | grep constant
+; RUN: llvm-as < %s | opt -ds-opt | llvm-dis | grep %G | grep constant
%G = internal global int 0 ; <int*> [#uses=2]
; Test that GCSE uses ds-aa to do alias analysis, which is capable of
; disambiguating some cases.
-; RUN: as < %s | opt -no-aa -ds-aa -load-vn -gcse -instcombine -dce | dis | not grep ELIM
+; RUN: llvm-as < %s | 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
-; RUN: as < %s | opt -no-aa -ds-aa -load-vn -gcse -instcombine | dis | not grep seteq
+; RUN: llvm-as < %s | 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.
-; RUN: as < %s | opt -no-aa -ds-aa -load-vn -gcse | dis | not grep load
+; RUN: llvm-as < %s | opt -no-aa -ds-aa -load-vn -gcse | llvm-dis | not grep load
%X = internal global int 20
; of the bug that was causing the Olden Health benchmark to output incorrect
; results!
;
-; RUN: as < %s | opt -constprop | dis > s1 && \
-; RUN: as < %s | dis | as | opt -constprop | dis > s2 && \
+; RUN: llvm-as < %s | opt -constprop | llvm-dis > s1 && \
+; RUN: llvm-as < %s | llvm-dis | llvm-as | opt -constprop | llvm-dis > s2 && \
; RUN: diff s1 s2
implementation
; The output formater prints out 1.0e100 as Inf!
;
-; RUN: as < %s | dis | as | dis
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
implementation
; Check by running globaldce, which will remove the constant if there are
; no references to it!
;
-; RUN: as < %s | opt -globaldce | dis | not grep constant
+; RUN: llvm-as < %s | opt -globaldce | llvm-dis | not grep constant
;
%v1 = internal constant int 5
; This file takes about 48 __MINUTES__ to assemble using as. This is WAY too
; long. The type resolution code needs to be sped up a lot.
-; RUN: ulimit -t 20; as < %s
+; RUN: ulimit -t 20; llvm-as < %s
%ALL_INTERSECTIONS_METHOD = type int (%OBJECT*, %RAY*, %ISTACK*)*
%BBOX = type { %BBOX_VECT, %BBOX_VECT }
; Test to make sure that the 'internal' tag is not lost!
;
-; RUN: as < %s | dis | grep internal
+; RUN: llvm-as < %s | llvm-dis | grep internal
declare void %foo()
implementation
; Test that opaque types are preserved correctly
-; RUN: as < %s | dis | as | dis
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
;
%Ty = type opaque
; Make sure we don't get an assertion failure, even though this is a parse
; error
-; RUN: as < %s 2>&1 | grep 'No arguments'
+; RUN: llvm-as < %s 2>&1 | grep 'No arguments'
%ty = type void (int)
; Test double quotes in strings work correctly!
-; RUN: as < %s | dis | as | dis
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
;
%str = internal global [6 x sbyte] c"\22foo\22\00"
; Test that returning a pointer to a function causes the disassembler to print
; the right thing.
;
-; RUN: as < %s | dis | as
+; RUN: llvm-as < %s | llvm-dis | llvm-as
%ty = type void (int)
-; RUN: as < %s | dis | as
+; RUN: llvm-as < %s | llvm-dis | llvm-as
; Make sure that \\ works in a string initializer
%Slashtest = internal global [8 x sbyte] c"\5Cbegin{\00"
; reader should NEVER produce a program "successfully" with placeholders still
; around!
-; RUN: as < %s | dis | as
+; RUN: llvm-as < %s | llvm-dis | llvm-as
%.LC0 = internal global [4 x sbyte] c"foo\00" ; <[4 x sbyte]*> [#uses=1]
; Testcase that seems to break the bytecode reader. This comes from the
; "crafty" spec benchmark.
;
-; RUN: as < %s | opt -instcombine | dis | as
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | llvm-as
%CHESS_POSITION = type { uint, int }
-; RUN: as < %s | dis
+; RUN: llvm-as < %s | llvm-dis
%Domain = type { %Domain**, %Domain* }
-; RUN: as < %s | dis
+; RUN: llvm-as < %s | llvm-dis
void %test() {
%tmp.123 = cast long cast ([5 x { ubyte, sbyte }]* getelementptr ([30 x [5 x { ubyte, sbyte }]]* null, long 0, long 0) to long) to int
-; RUN: as < %s | dis | grep -- -2147483648
+; RUN: llvm-as < %s | llvm-dis | grep -- -2147483648
int %foo() {
ret int -2147483648
; This bug was caused by two CPR's existing for the same global variable,
; colliding in the Module level CPR map.
-; RUN: as < %s -o /dev/null -f
+; RUN: llvm-as < %s -o /dev/null -f
void %test() {
call void (...)* cast (void (short*, int)* %AddString to void (...)*)(short* null, int 0)
; Found by inspection of the code
-; RUN: as < %s 2>&1 | grep "Shift constant expression"
+; RUN: llvm-as < %s 2>&1 | grep "Shift constant expression"
global int shr (float 1.0, ubyte 2)
; Found by inspection of the code
-; RUN: as < %s 2>&1 | grep "Illegal"
+; RUN: llvm-as < %s 2>&1 | grep "Illegal"
global {} { int 7, float 1.0, int 7, int 8 }
-; RUN: as < %s | dis
+; RUN: llvm-as < %s | llvm-dis
void %test() {
invoke void %test() to label %Next except label %Next
Next:
-; RUN: as < %s | opt -instcombine -simplifycfg | dis | not grep br
+; RUN: llvm-as < %s | opt -instcombine -simplifycfg | llvm-dis | not grep br
%.str_1 = internal constant [6 x sbyte] c"_Bool\00" ; <[6 x sbyte]*> [#uses=1]
-; RUN: as < %s | dis | not grep getelementptr
+; RUN: llvm-as < %s | llvm-dis | not grep getelementptr
%A = external global { float } ; <{ float }*> [#uses=1]
global int* cast (float* getelementptr ({ float }* %A, long 0, ubyte 0) to int*)
; This test checks to make sure that constant exprs fold in some simple situations
-; RUN: as < %s | dis | not grep cast
+; RUN: llvm-as < %s | llvm-dis | not grep cast
%A = global int* cast (sbyte* null to int*) ; Cast null -> fold
%B = global int** cast (int** %A to int**) ; Cast to same type -> fold
-; RUN: as < %s | dis -c > f1.cbe.c
+; RUN: llvm-as < %s | llvm-dis -c > f1.cbe.c
; RUN: gcc -B/usr/bin/ f1.cbe.c -o f1.cbe
; RUN: ./f1.cbe
-; RUN: as < %s | dis -c | grep common | grep X
+; RUN: llvm-as < %s | llvm-dis -c | grep common | grep X
%X = linkonce global int 5
-; RUN: as < %s | dis -c > f1.cbe.c
+; RUN: llvm-as < %s | llvm-dis -c > f1.cbe.c
; RUN: gcc -B/usr/bin/ f1.cbe.c -o f1.cbe
; RUN: ./f1.cbe
-; RUN: as < %s | dis -c | grep common | grep X
+; RUN: llvm-as < %s | llvm-dis -c | grep common | grep X
%X = linkonce global int 5
-; RUN: as < %s | lli -force-interpreter=false -disable-local-ra=false
+; RUN: llvm-as < %s | lli -force-interpreter=false -disable-local-ra=false
;-print-machineinstrs
int %main() {
-; RUN: as < %s | lli -force-interpreter=false -disable-local-ra
+; RUN: llvm-as < %s | lli -force-interpreter=false -disable-local-ra
int %main(int %B) {
;%B = add int 0, 1
; it makes a ton of annoying overlapping live ranges. This code should not
; cause spills!
;
-; RUN: as < %s | lli -stats 2>&1 | not grep spilled
+; RUN: llvm-as < %s | lli -stats 2>&1 | not grep spilled
target endian = little
target pointersize = 32
-; RUN: as < %s | llc -march=x86
+; RUN: llvm-as < %s | llc -march=x86
implementation
-; RUN: as < %s | lli -force-interpreter=false
+; RUN: llvm-as < %s | lli -force-interpreter=false
int %main() {
br label %Loop
; This testcase shoudl return with an exit code of 1.
;
-; RUN: as < %s | not lli -force-interpreter=false
+; RUN: llvm-as < %s | not lli -force-interpreter=false
target endian = little
target pointersize = 32
-; RUN: as < %s | lli -force-interpreter=false - test
+; RUN: llvm-as < %s | lli -force-interpreter=false - test
target endian = little
target pointersize = 32
-; RUN: as < %s | llc -march=x86
+; RUN: llvm-as < %s | llc -march=x86
target endian = big ; We need the byteswaps for this test!
target pointersize = 64
projects / oota-llvm.git / commitdiff