llvm.org GIT mirror llvm / 13f5c58
verify-uselistorder: Force -preserve-bc-use-list-order git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216022 91177308-0d34-0410-b5e6-96231b3b80d8 Duncan P. N. Exon Smith 6 years ago
151 changed file(s) with 160 addition(s) and 151 deletion(s). Raw diff Collapse all Expand all
5353 /// \brief Whether to preserve use-list ordering.
5454 bool shouldPreserveBitcodeUseListOrder();
5555 bool shouldPreserveAssemblyUseListOrder();
56 void setPreserveBitcodeUseListOrder(bool ShouldPreserve);
57 void setPreserveAssemblyUseListOrder(bool ShouldPreserve);
5658
5759 } // end namespace llvm
5860
3232 bool llvm::shouldPreserveAssemblyUseListOrder() {
3333 return PreserveAssemblyUseListOrder;
3434 }
35
36 void llvm::setPreserveBitcodeUseListOrder(bool ShouldPreserve) {
37 PreserveBitcodeUseListOrder = ShouldPreserve;
38 }
39
40 void llvm::setPreserveAssemblyUseListOrder(bool ShouldPreserve) {
41 PreserveAssemblyUseListOrder = ShouldPreserve;
42 }
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Method arguments were being checked for collisions at the global scope before
44 ; the method object was created by the parser. Because of this, false
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Another name collision problem. Here the problem was that if a forward
44 ; declaration for a method was found, that this would cause spurious conflicts
88 ; RUN: llvm-as < %s | llvm-dis | llvm-as | opt -constprop | \
99 ; RUN: llvm-dis > %t.2
1010 ; RUN: diff %t.1 %t.2
11 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
11 ; RUN: verify-uselistorder %s
1212
1313 define double @test() {
1414 %tmp = fmul double 7.200000e+101, 0x427F4000 ; [#uses=1]
0 ; The output formater prints out 1.0e100 as Inf!
11 ;
22 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | grep 0x7FF0000000000000
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44
55 define float @test() {
66 %tmp = fmul float 0x7FF0000000000000, 1.000000e+01 ; [#uses=1]
66 ; RUN: opt < %s -globaldce -S | \
77 ; RUN: not grep constant
88 ;
9 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
9 ; RUN: verify-uselistorder %s
1010
1111 @v1 = internal constant i32 5
1212
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; It looks like the assembler is not forward resolving the function declaraion
33 ; correctly.
44
0 ; Test that opaque types are preserved correctly
11 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
22 ;
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44
55 %Ty = type opaque
66
0 ; Test double quotes in strings work correctly!
11 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
22 ;
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44 @str = internal global [6 x i8] c"\22foo\22\00" ; <[6 x i8]*> [#uses=0]
55
11 ; the right thing.
22 ;
33 ; RUN: llvm-as < %s | llvm-dis | llvm-as
4 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
4 ; RUN: verify-uselistorder %s
55
66 declare void (i32)* @foo()
77
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Make sure that \\ works in a string initializer
44 @Slashtest = internal global [8 x i8] c"\5Cbegin{\00"
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @test(i32 %X) {
44 call void @test( i32 6 )
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @.LC0 = internal global [12 x i8] c"hello world\00" ; <[12 x i8]*> [#uses=1]
44
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @.LC0 = internal global [12 x i8] c"hello world\00" ; <[12 x i8]*> [#uses=1]
44
88 ; around!
99 ;
1010 ; RUN: llvm-as < %s | llvm-dis | llvm-as
11 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
11 ; RUN: verify-uselistorder %s
1212
1313 @.LC0 = internal global [4 x i8] c"foo\00" ; <[4 x i8]*> [#uses=1]
1414 @X = global i8* null ; [#uses=0]
11 ; "crafty" spec benchmark.
22 ;
33 ; RUN: opt < %s -instcombine | llvm-dis
4 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
4 ; RUN: verify-uselistorder %s
55
66 %CHESS_POSITION = type { i32, i32 }
77 @pawn_probes = external global i32 ; [#uses=0]
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Dominance relationships is not calculated correctly for unreachable blocks,
44 ; which causes the verifier to barf on this input.
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; This testcase comes from the following really simple c file:
33 ;; int foo[30000]
44 ;;; We should not be soo slow for such a simple case!
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 %Domain = type { %Domain**, %Domain* }
44 @D = global %Domain zeroinitializer ; <%Domain*> [#uses=0]
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @X = external global i32*
44 @X1 = external global %T*
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @spell_order = global [4 x i8] c"\FF\00\F7\00"
44
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; There should be absolutely no problem with this testcase.
33
44 define i32 @test(i32 %arg1, i32 %arg2) {
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @test() {
44 %tmp.123 = trunc i64 0 to i32 ; [#uses=0]
0 ; RUN: llvm-as < %s | llvm-dis | grep -- -2147483648
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define i32 @foo() {
44 ret i32 -2147483648
0 ; This bug was caused by two CPR's existing for the same global variable,
11 ; colliding in the Module level CPR map.
22 ; RUN: llvm-as %s -o /dev/null
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44
55 define void @test() {
66 call void (...)* bitcast (void (i16*, i32)* @AddString to void (...)*)( i16* null, i32 0 )
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Check minimal switch statement
44
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Test that shift instructions can be used in constant expressions.
33
44 global i32 3670016
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; The old C front-end never generated empty structures, now the new one
44 ; can. For some reason we never handled them in the parser. Weird.
0 ; RUN: opt < %s -instcombine -simplifycfg -S | not grep br
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @.str_1 = internal constant [6 x i8] c"_Bool\00" ; <[6 x i8]*> [#uses=2]
44
0 ; RUN: llvm-as < %s | llvm-dis | not grep getelementptr
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @A = external global { float } ; <{ float }*> [#uses=2]
44 global i32* bitcast ({ float }* @A to i32*) ; :0 [#uses=0]
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define i32 @test() {
44 ret i32 ashr (i32 ptrtoint (i32 ()* @test to i32), i32 2)
0 ; RUN: llvm-as < %s | llvm-dis | not grep " bitcast ("
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @.Base64_1 = external constant [4 x i8] ; <[4 x i8]*> [#uses=1]
44
0 ; RUN: llvm-as < %s | llvm-dis | \
11 ; RUN: not grep "getelementptr.*getelementptr"
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 %struct.TTriangleItem = type { i8*, i8*, [3 x %struct.TUVVertex] }
55 %struct.TUVVertex = type { i16, i16, i16, i16 }
0 ; RUN: llvm-as < %s | llvm-dis | grep 9223372036854775808
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 global i64 -9223372036854775808
44
0 ; RUN: llvm-as < %s | llvm-dis | grep -- -0.0
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 global double 0x8000000000000000
44 global float -0.0
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; %inc2 uses it's own value, but that's ok, as it's unreachable!
44
0 ; RUN: llvm-as < %s | llvm-dis | not grep ptrtoint
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; All of these should be eliminable
33
44
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define i32* @t1({ float, i32 }* %X) {
44 %W = getelementptr { float, i32 }* %X, i32 20, i32 1 ; [#uses=0]
0 ; RUN: llvm-as < %s > /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @t() {
44 entry:
0 ;; The bytecode writer was trying to treat undef values as ConstantArray's when
11 ;; they looked like strings.
22 ;; RUN: llvm-as %s -o /dev/null
3 ;; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ;; RUN: verify-uselistorder %s
44 @G = internal global [8 x i8] undef
55
0 ; RUN: llvm-as < %s | llvm-dis | grep 1.0
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define double @test() {
44 ret double 1.0 ;; This should not require hex notation
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @test() {
44 call {i32} @foo()
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as > /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 %t = type opaque
44 @x = global %t undef
0 ; RUN: llvm-as < %s > /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define <4 x i32> @foo() {
44 ret <4 x i32> zeroinitializer
0 ; RUN: llvm-as < %s | llvm-dis | grep bitcast
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define i1 @main(i32 %X) {
44 %res = bitcast i1 true to i1
0 ; Test Case for PR1080
11 ; RUN: llvm-as %s -o /dev/null
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 @str = internal constant [4 x i8] c"-ga\00" ; <[4 x i8]*> [#uses=2]
55
0 ; Test whether negative values > 64 bits retain their negativeness.
11 ; RUN: llvm-as < %s | llvm-dis | grep "add i65.*, -1"
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 define i65 @testConsts(i65 %N) {
55 %a = add i65 %N, -1
0 ; RUN: llvm-as < %s | llvm-dis | grep "align 1024"
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define i32 @test(i32* %arg) {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | grep "align 1024"
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @test(i32* %arg) {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | grep "icmp.*test_weak.*null"
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR1358
33 @G = global i1 icmp ne (i32 (...)* @test_weak, i32 (...)* null)
44
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 target datalayout = "e-p:64:64:64-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"
33 target triple = "x86_64-apple-darwin8"
44 %struct.bar = type { i32 }
0 ; PR1553
11 ; RUN: llvm-as < %s > /dev/null
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33 define void @bar() {
44 %t = call i8 @foo( i8 10 )
55 zext i8 %t to i32
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR1645
33
44 @__gthread_active_ptr.5335 = internal constant i8* bitcast (i32 (i32)* @__gthrw_pthread_cancel to i8*)
0 ; RUN: llvm-as < %s | llvm-dis | grep "@f.*gc.*shadowstack"
11 ; RUN: llvm-as < %s | llvm-dis | grep "@g.*gc.*java"
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 define void @f() gc "shadowstack" {
55 entry:
22 ; RUN: llvm-as < %s | llvm-dis | grep "addrspace(66)" | count 2
33 ; RUN: llvm-as < %s | llvm-dis | grep "addrspace(11)" | count 6
44 ; RUN: llvm-as < %s | llvm-dis | grep "addrspace(22)" | count 5
5 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
5 ; RUN: verify-uselistorder %s
66
77 %struct.mystruct = type { i32, i32 addrspace(33)*, i32, i32 addrspace(33)* }
88 @input = weak addrspace(42) global %struct.mystruct zeroinitializer ; <%struct.mystruct addrspace(42)*> [#uses=1]
0 ; RUN: llvm-as < %s | llvm-dis | grep byval
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 %struct = type { }
44
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR2538
33 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"
44 target triple = "i686-pc-linux-gnu"
0 ; Test function attributes
11 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 ; CHECK: define void @fn1() #0
55 define void @fn1() alwaysinline {
0 ; Test return attributes
11 ; RUN: llvm-as < %s | llvm-dis | grep "define inreg i32"
22 ; RUN: llvm-as < %s | llvm-dis | grep "call inreg i32"
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44
55 define inreg i32 @fn1() {
66 ret i32 0
0 ; RUN: llvm-as < %s | llvm-dis | grep "quote"
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @"a\22quote" = global i32 0
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR3372
33
44 @X = global i32* @0
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33
44 define void @foo() {
0 ; RUN: opt < %s -strip -S | llvm-as | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Stripping the name from A should not break references to it.
44 %A = type opaque
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR3876
33 @gdtr = external global [0 x i8]
44
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @foo = global i32 0
44 @bar = constant i32* getelementptr(i32* @foo)
0 ; RUN: opt -std-compile-opts < %s | llvm-dis | not grep badref
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 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"
44 target triple = "x86_64-apple-darwin10.2"
11 ; situations
22
33 ; RUN: llvm-as < %s | llvm-dis | not grep "("
4 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
4 ; RUN: verify-uselistorder %s
55
66 @A = global i64 0
77
0 ; This test checks to make sure that constant exprs fold in some simple situations
11
22 ; RUN: llvm-as < %s | llvm-dis | not grep cast
3 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder %s
44
55 @A = global i32* bitcast (i8* null to i32*) ; Cast null -> fold
66 @B = global i32** bitcast (i32** @A to i32**) ; Cast to same type -> fold
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR18319
33
44 define void @function() {
11 ; situations
22
33 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
4 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
4 ; RUN: verify-uselistorder %s
55
66 ; Even give it a datalayout, to tempt folding as much as possible.
77 target datalayout = "p:32:32"
0 ; RUN: llvm-as < %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 %struct.S_102 = type { float, float }
44
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Test that global aliases are allowed to be constant addrspacecast
44
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @foo
44 ; CHECK: store { i32, i32 } { i32 7, i32 9 }, { i32, i32 }* %x
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define { i32 } @foob() nounwind {
44 ret {i32}{ i32 0 }
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @A = global i1 0, align 536870912
44
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 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"
33 target triple = "i386-apple-darwin10.0"
44
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR3611
33
44 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"
0 ; RUN: opt < %s | opt -S | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Basic smoke test for atomic operations.
33
44 define void @f(i32* %x) {
0 ; Test to make sure intrinsics are automatically upgraded.
11 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 declare i8 @llvm.ctlz.i8(i8)
55 declare i16 @llvm.ctlz.i16(i16)
0 ; RUN: llvm-as < %s > %t
11 ; RUN: llvm-nm %t | FileCheck %s
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33 ; Test for isBitcodeFile, llvm-nm must read from a file for this test.
44 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"
55 target triple = "i686-apple-darwin9.2.2"
0 ; RUN: llvm-as < %s | llvm-dis -show-annotations | FileCheck -check-prefix=ANNOT %s
11 ; RUN: llvm-as < %s | llvm-dis | FileCheck -check-prefix=BARE %s
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 ; The bare version of this file should not have any #uses lines.
55 ; BARE: @B =
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @G = externally_initialized global i32 0
44
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
11 ; RUN: opt -S < %s | FileCheck %s
2 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder %s
33
44 @addr = external global i64
55 @select = external global i1
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 @addr = external global i64
44
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @Foo(i32 %a, i32 %b) {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Verify that over-indexed getelementptrs are folded.
44 @A = external global [2 x [3 x [5 x [7 x i32]]]]
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; Make sure the address space of forward decls is preserved
44
0 ; RUN: opt < %s -O3 -S | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Testing half constant propagation.
33
44 define half @abc() nounwind {
0 ; RUN: opt < %s -O3 -S | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Testing half to float conversion.
33
44 define float @abc() nounwind {
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Basic smoke test for half type.
33
44 ; CHECK: define half @halftest
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: define [18446744073709551615 x i8]* @foo() {
44 ; CHECK: ret [18446744073709551615 x i8]* null
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 define void @a() {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @foo
44 ; CHECK-NEXT: load
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @test
44 ; CHECK: ret void, !bar !1, !foo !0
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 !0 = metadata !{metadata !"zero"}
44 !1 = metadata !{metadata !"one"}
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR2480
33
44 define i32 @test(i32 %X) nounwind {
0 ; RUN: llvm-as %s -o /dev/null
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33
44 define i32 @test(i1 %C, i32 %V1, i32 %V2) {
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @a = thread_local global i32 0
44 ; CHECK: @b = thread_local(localdynamic) global i32 0
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 %struct.foobar = type { i32 }
44
0 ; RUN: llvm-as < %s | llvm-dis
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 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"
44
44 ;
55 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
66 ; RUN: opt -S < %s | FileCheck %s
7 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
7 ; RUN: verify-uselistorder %s
88
99 define void @_Z28loop_with_vectorize_metadatav() {
1010 entry:
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Rudimentary test of fcmp/icmp on vectors returning vector of bool
33
44 ; CHECK: @ffoo
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; PR2317
33 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"
44 target triple = "i686-apple-darwin9.2.2"
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Rudimentary test of select on vectors returning vector of bool
33
44 ; CHECK: @foo
0 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22
33 ; CHECK: @foo
44 ; CHECK: shl
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder %s
22 ; Basic smoke test for x86_mmx type.
33
44 ; CHECK: define x86_mmx @sh16
0 ; This test ensures that we get a bitcast constant expression in and out,
11 ; not a sitofp constant expression.
22 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
3 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder < %s
44 ; CHECK: bitcast (
55
66 @G = external global i32
0 ; RUN: llvm-as < %s | llvm-dis -disable-output
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; PR4373
33
44 @foo = weak global { i32 } zeroinitializer
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; aggregateOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread instructions with aggregate operands
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; Tests vclz and vcnt
33
44 define <4 x i16> @vclz16(<4 x i16>* %A) nounwind {
0 ; RUN: llvm-as %s -o - | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 define void @test_cmpxchg(i32* %addr, i32 %desired, i32 %new) {
44 cmpxchg i32* %addr, i32 %desired, i32 %new seq_cst seq_cst
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; attributes-3.3.ll.bc was generated by passing this file to llvm-as-3.3.
44 ; The test checks that LLVM does not silently misread attributes of
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; PR12696
33
44 define void @f1(i8 zeroext)
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; BinaryFloatOperation.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread binary float instructions from
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; BinaryIntOperation.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread binary integer instructions from
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; bitwiseOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread bitwise instructions from
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; PR9857
33
44 define void @f(i8** nocapture %ptr1) {
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; calling-conventions.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not silently misread calling conventions of
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; case-ranges.ll.bc was generated by passing this file to llvm-as from the 3.3
44 ; release of LLVM. This tests that the bitcode for switches from that release
0 ; RUN: llvm-dis < %s.bc | FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; cmpxchg-upgrade.ll.bc was produced by running a version of llvm-as from just
44 ; before the IR change on this file.
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; conversionOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread conversion instructions from
0 ; RUN: llvm-as < %s -o %t.bc 2>&1 >/dev/null | FileCheck -check-prefix=WARN %s
11 ; RUN: llvm-dis < %t.bc | FileCheck %s
2 ; RUN: verify-uselistorder < %t.bc -preserve-bc-use-list-order
2 ; RUN: verify-uselistorder < %t.bc
33
44 define i32 @main() {
55 entry:
0 ; RUN: opt < %s -constprop | llvm-dis -disable-output
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; PR3465
33
44 define double @test() {
0 ; RUN: llvm-as < %s | llvm-dis > %t0
11 ; RUN: opt -S < %s > %t1
22 ; RUN: diff %t0 %t1
3 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder < %s
44 ; PR6140
55
66 ; Make sure the flags are serialized/deserialized properly for both
0 ; Basic sanity test to check that instruction operands are encoded with
11 ; relative IDs.
22 ; RUN: llvm-as < %s | llvm-bcanalyzer -dump | FileCheck %s
3 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder < %s
44
55 ; CHECK: FUNCTION_BLOCK
66 ; CHECK: INST_BINOP {{.*}}op0=1 op1=1
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; global-variables.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not silently misread global variables attributes of
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 ; inalloca should roundtrip.
44
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; linkage-types-3.2.ll.bc was generated by passing this file to llvm-as-3.2
44 ; The test checks that LLVM does not silently misread linkage types of
0 ; RUN: llvm-dis < %s.bc | FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; local-linkage-default-visibility.3.4.ll.bc was generated by passing this file
44 ; to llvm-as-3.4. The test checks that LLVM upgrades visibility of symbols
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; memOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread memory related instructions of
0 ; RUN: llvm-as < %s | llvm-dis -disable-output
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 %0 = type { %object.ModuleInfo.__vtbl*, i8*, %"byte[]", %1, %"ClassInfo[]", i32, void ()*, void ()*, void ()*, i8*, void ()* } ; type %0
33 %1 = type { i64, %object.ModuleInfo* } ; type %1
44 %2 = type { i32, void ()* } ; type %2
0 ; RUN: llvm-as < %s | llvm-dis -disable-output
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 !llvm.foo = !{!0}
44 !0 = metadata !{i32 42}
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; miscInstructions.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread miscellaneous instructions of
0 ; RUN: llvm-dis < %s.bc | FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; old-aliases.bc consist of this file assembled with an old llvm-as (3.5 trunk)
44 ; from when aliases contained a ConstantExpr.
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 define i32 @foo(<2 x i64> %bar) nounwind {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 define i32 @foo(<4 x float> %bar) nounwind {
44 entry:
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 define <2 x i32> @main() {
44 ret <2 x i32> select (<2 x i1> , <2 x i32> zeroinitializer, <2 x i32> )
0 ; RUN: llvm-as < %s | llvm-dis -disable-output
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 ;
44 ; tests the bitcodereader can handle the case where the reader will initially
0 ; RUN: opt < %s -S | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22 ; CHECK-NOT: {@llvm\\.palign}
33
44 define <4 x i32> @align1(<4 x i32> %a, <4 x i32> %b) nounwind readnone ssp {
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 ; Check that musttail and tail roundtrip.
44
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; TerminatorOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread terminator instructions from
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; Global constructors should no longer be upgraded when reading bitcode.
44 ; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()* }] zeroinitializer
0 ; Test to make sure loop vectorizer metadata is automatically upgraded.
11 ;
22 ; RUN: llvm-dis < %s.bc | FileCheck %s
3 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
3 ; RUN: verify-uselistorder < %s.bc
44
55 define void @_Z28loop_with_vectorize_metadatav() {
66 entry:
0 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
1 ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s
22
33 ; Function Attrs: nounwind
44 define void @_Z4testPiPf(i32* nocapture %pI, float* nocapture %pF) #0 {
None ; RUN: verify-uselistorder < %s -preserve-bc-use-list-order
0 ; RUN: verify-uselistorder < %s
11
22 @a = global [4 x i1] [i1 0, i1 1, i1 0, i1 1]
33 @b = alias i1* getelementptr ([4 x i1]* @a, i64 0, i64 2)
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; vaArgIntrinsic.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread variable argument intrinsic instructions
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; vectorOperations.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not misread vector operations of
0 ; RUN: llvm-dis < %s.bc| FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; visibility-styles.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
44 ; The test checks that LLVM does not silently misread visibility styles of
0 ; RUN: llvm-dis < %s.bc | FileCheck %s
1 ; RUN: verify-uselistorder < %s.bc -preserve-bc-use-list-order
1 ; RUN: verify-uselistorder < %s.bc
22
33 ; cmpxchg-upgrade.ll.bc was produced by running a version of llvm-as from just
44 ; before the IR change on this file.
533533 errs() << "*** verify-use-list-order ***\n";
534534 if (!shouldPreserveBitcodeUseListOrder()) {
535535 // Can't verify if order isn't preserved.
536 errs() << "warning: cannot verify bitcode; "
537 "try -preserve-bc-use-list-order\n";
538 return 0;
536 errs() << "warning: forcing -preserve-bc-use-list-order\n";
537 setPreserveBitcodeUseListOrder(true);
539538 }
540539
541540 // Verify the use lists now and after reversing them.