%struct.head_type = type { [2 x %struct.LIST], %struct.FIRST_UNION, %struct.SECOND_UNION, %struct.THIRD_UNION, %struct.FOURTH_UNION, %struct.rec*, { %struct.rec* }, %struct.rec*, %struct.rec*, %struct.rec*, %struct.rec*, %struct.rec*, %struct.rec*, %struct.rec*, %struct.rec*, i32 }
%struct.rec = type { %struct.head_type }
-implementation ; Functions:
define i32 @test(%struct.closure_type* %tmp18169) {
%tmp18174 = getelementptr %struct.closure_type* %tmp18169, i32 0, i32 4, i32 0, i32 0 ; <i32*> [#uses=2]
%struct.vorbis_dsp_state = type { i32, %struct.vorbis_info*, float**, float**, i32, i32, i32, i32, i32, i32, i32, i32, i32, i64, i64, i64, i64, i64, i64, i8* }
%struct.vorbis_info = type { i32, i32, i32, i32, i32, i32, i32, i8* }
-implementation ; Functions:
define void @ov_read() {
entry:
@A = weak global [1000 x i32] zeroinitializer, align 32
-implementation ; Functions:
define void @test(i32 %N) {
entry:
; RUN: llvm-as %s -o /dev/null -f
-; This should parse correctly without an 'implementation', but our current YACC
; based parser doesn't have the required 2 token lookahead...
%T = type i32 *
; %typedef.bc_struct = type opaque
-implementation ; Functions:
define i1 @someFunc(i32* %tmp.71.reload, %typedef.bc_struct* %n1) {
ret i1 true
@s.10319 = external global %struct.aa_ss* ; <%struct.aa_ss**> [#uses=2]
@str15 = external constant [24 x i8] ; <[24 x i8]*> [#uses=1]
-implementation ; Functions:
define i8 @test(%struct.__fooY* %calendar, double* %atp, i8* %componentDesc, ...) zext {
entry:
%struct.varray_head_tag = type opaque
%union.tree_ann_d = type opaque
-implementation ; Functions:
define void @declspecs_add_type(i32 %spec.1) {
entry:
@__FUNCTION__.21382 = external global [19 x i8] ; <[19 x i8]*> [#uses=0]
@__FUNCTION__.21117 = external global [21 x i8] ; <[21 x i8]*> [#uses=0]
-implementation ; Functions:
declare void @push_gimplify_context()
%struct.rtx_def = type { i16, i8, i8, %struct.u }
%struct.u = type { [1 x i64] }
-implementation ; Functions:
-
define fastcc void @find_reloads_address(%struct.rtx_def** %loc) {
entry:
%ad_addr = alloca %struct.rtx_def* ; <%struct.rtx_def**> [#uses=2]
@numi = external global i32 ; <i32*> [#uses=1]
@counter = external global [2 x i32] ; <[2 x i32]*> [#uses=1]
-implementation ; Functions:
define void @main_bb_2E_i_bb205_2E_i_2E_i_bb115_2E_i_2E_i() {
newFuncRoot:
; RUN: grep 's4subq' %t.s | wc -l | grep 2 &&
; RUN: grep 's8subq' %t.s | wc -l | grep 2
-implementation ; Functions:
define i32 @al(i32 sext %x.s, i32 sext %y.s) sext {
entry:
; Make sure this testcase codegens to the ctpop instruction
; RUN: llvm-as < %s | llc -march=alpha | grep -i 'subl $16,1,$0'
-implementation ; Functions:
define i32 @foo(i32 sext %x) sext {
entry:
; Make sure this testcase codegens to the bic instruction
; RUN: llvm-as < %s | llc -march=alpha | grep 'zapnot'
-implementation ; Functions:
define i16 @foo(i64 %y) zext {
entry:
target triple = "i686-apple-darwin8"
%struct.Connector = type { i16, i16, i8, i8, %struct.Connector*, i8* }
-implementation ; Functions:
define i1 @prune_match_entry_2E_ce(%struct.Connector* %a, i16 %b.0.0.val) {
newFuncRoot:
target datalayout = "e-p:64:64"
target triple = "x86_64-apple-darwin8"
-implementation ; Functions:
declare void @llvm.memset.i64(i8*, i8, i64, i32)
@outfile = external global %struct.FILE* ; <%struct.FILE**> [#uses=1]
@str1 = external global [11 x i8] ; <[11 x i8]*> [#uses=1]
-implementation ; Functions:
declare i32 @fprintf(%struct.FILE*, i8*, ...)
; RUN: llvm-as < %s | llc
; PR1197
-implementation ; Functions:
define void @exp_attr__expand_n_attribute_reference() {
entry:
%struct.A = type { i32, i32 }
-implementation ; Functions:
define void @test1() {
entry:
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin8.8.0"
-implementation ; Functions:
define void @blargh() {
entry:
target triple = "powerpc-apple-darwin8"
@str = internal constant [18 x i8] c"hello world!, %d\0A\00" ; <[18 x i8]*> [#uses=1]
-implementation ; Functions:
define i32 @main() {
entry:
target datalayout = "e-p:64:64"
@i6000 = global [128 x i64] zeroinitializer, align 16
-implementation
define void @foo(i32* %a0, i32* %a1, i32* %a2, i32* %a3, i32* %a4, i32* %a5) {
b:
; RUN: llvm-as < %s | llc -march=x86
; ModuleID = 'a.bc'
-implementation ; Functions:
define i32 @foo(i32 %A, i32 %B) {
entry:
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin9"
-implementation ; Functions:
define void @acoshf() {
%tmp19 = tail call <2 x double> asm sideeffect "pcmpeqd $0, $0 \0A\09 cmpltsd $0, $0", "=x,0,~{dirflag},~{fpsr},~{flags}"( <2 x double> zeroinitializer ) ; <<2 x double>> [#uses=0]
@Y = weak global i32 0 ; <i32*> [#uses=1]
@X = weak global i32 0 ; <i32*> [#uses=2]
-implementation ; Functions:
define void @fn1() {
entry:
@a = hidden global i32 0
@b = external global i32
-implementation ; Functions:
define weak hidden void @_ZN6Person13privateMethodEv(%struct.Person* %this) {
ret void
target datalayout = "e-p:64:64"
target triple = "x86_64-apple-darwin8"
-implementation ; Functions:
define i32 @test(i16 sext %X) {
entry:
target datalayout = "e-p:64:64"
target triple = "x86_64-apple-darwin8"
-implementation ; Functions:
define void @bar(i16 zext %A) {
tail call void @foo( i16 %A sext )
%fvec1 = constant %fvec_type <float 1.0, float 1.0, float 1.0, float 1.0>
%fvec2 = constant %fvec_type <float 0.0, float 0.0, float 0.0, float 0.0>
-implementation ; Functions:
define bool %ivectest1() {
%v1 = load %ivec_type* getelementptr(%ivec_type* %ivec1, i32 0)
@E1 = global <{i8, i32, i32}> <{i8 1, i32 2, i32 3}>
@E2 = global {i8, i32, i32} {i8 4, i32 5, i32 6}
-implementation ; Functions:
define i32 @main()
{
declare void @"foo"(i31 %i, i63 %j, i10 %k)
-implementation
; foo test basic arith operations
define void @"foo"(i31 %i, i63 %j, i10 %k)
declare void @"foo"(i31 %i, i33 %j)
-implementation
; foo test basic bitwise operations
define void @"foo"(i31 %i, i33 %j)
declare void @"foo"(i31 %i, i1280 %j, i1 %k, float %f)
-implementation
; foo test basic arith operations
define void @"foo"(i31 %i, i1280 %j, i1 %k, float %f)
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i55 @"simpleIcmp"(i55 %i0, i55 %j0)
begin
declare void @"foo"()
-implementation
; foo test basic arith operations
define void @"foo"() {
@ZeroInit = global { [100 x i19 ], [40 x float ] } { [100 x i19] zeroinitializer,
[40 x float] zeroinitializer }
-implementation
define i19 @"foo"(i19 %blah)
begin
@foo1 = external global <4 x float>;
@foo2 = external global <2 x i10>;
-implementation ; Functions:
define void @main()
{
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation ; Functions:
; Test "stripped" format where nothing is symbolic... this is how the bytecode
; format looks anyways (except for negative vs positive offsets)...
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
;; This is an irreducible flow graph
;;---------------------------------------------------
-implementation
@somestr = constant [11x i8] c"hello world"
@sptr2 = global [11x i8]* @somestr
-implementation
type i55(i55(i55)*)
%thisfuncty = type i55 (i55) *
-implementation
declare void @F(%thisfuncty, %thisfuncty, %thisfuncty)
@ZeroInit = global { [100 x i27 ], [40 x float ] } { [100 x i27] zeroinitializer,
[40 x float] zeroinitializer }
-implementation
define i27 @"foo"(i27 %blah)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i63 @"test"(i63 %X)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
declare i32 @"atoi"(i8 *)
%Y1 = type { { \3 * }, \2 * }
%Z1 = type { { \3 * }, [12x\3] *, { { { \5 * } } } }
-implementation
@foo1 = external global <4 x float>;
@foo2 = external global <2 x i10>;
-implementation ; Functions:
define void @main()
{
@E1 = global <{i8, i35, i35}> <{i8 1, i35 2, i35 3}>
@E2 = global {i8, i35, i35} {i8 4, i35 5, i35 6}
-implementation ; Functions:
define i35 @main()
{
declare i16 @"test"(i16 sext %arg) sext
declare i8 @"test2" (i16 zext %a2) zext
-implementation
define i33 @main(i33 %argc, i8 **%argv) {
%val = trunc i33 %argc to i16
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
declare i31 @"bar"(i31 %in)
declare i8 *@"malloc"(i32)
;;**********************
-implementation
;;**********************
define void @"InsertIntoListTail"(%list** %L, i36 %Data)
%FunTy = type i31(i31)
-implementation
define void @"invoke"(%FunTy *%x)
begin
%x = type i19
-implementation
define i19 @"foo"(i19 %in)
begin
%inners = type {float, {i8 } }
%struct = type { i33 , {float, {i8 } } , i64 }
-implementation
define i33 @testfunction(i33 %i0, i33 %j0)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i31 @"simpleArith"(i31 %i0, i31 %j0)
begin
@array = constant [2 x i55] [ i55 12, i55 52 ]
constant { i55, i55 } { i55 4, i55 3 }
-implementation
define [2 x i55]* @testfunction(i55 %i0, i55 %j0)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i31 @"simpleIcmp"(i31 %i0, i31 %j0)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i31 @"simpleAdd"(i31 %i0, i31 %j0)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
define i31 @"simpleAdd"(i31 %i0, i31 %j0)
begin
%struct = type { i31 , {float, {i9 } } , i64 }
%complexty = type {i31, {[4 x i9 *], float}, double}
-implementation
define i31 @"main"()
begin
%i35 = type i35
-implementation
define i35 @"squared"(%i35 %i0)
begin
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
-implementation
declare i31 @"printf"(i8*, ...) ;; Prototype for: i32 __builtin_printf(const char*, ...)
@X = global i31 undef
-implementation
declare i32 @"atoi"(i8 *)
; RUN: diff %t1.ll %t2.ll
-implementation
declare void @bar()
; Demonstrate all of the variable argument handling intrinsic functions plus
; the va_arg instruction.
-implementation
declare void @llvm.va_start(i8** %ap)
declare void @llvm.va_copy(i8** %aq, i8** %ap)
declare void @llvm.va_end(i8** %ap)
; Demonstrate all of the variable argument handling intrinsic functions plus
; the va_arg instruction.
-implementation ; Functions:
declare void @llvm.va_start(i8**)
declare void @llvm.va_copy(i8**, i8*)
declare void @llvm.va_end(i8**)
; RUN: llvm-as %s -o - | opt -adce
-implementation
-
define i32 @"main"(i32 %argc)
begin
br label %2
@foo = internal constant [5 x i8] c"\00abc\00" ; <[5 x i8]*> [#uses=1]
@str = internal constant [4 x i8] c"%d\0A\00" ; <[4 x i8]*> [#uses=1]
-implementation ; Functions:
define i32 @test(i32 %J) {
entry:
target triple = "i686-pc-linux-gnu"
%struct.termbox = type { %struct.termbox*, i32, i32, i32, i32, i32 }
-implementation ; Functions:
define void @ggenorien() {
entry:
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"
target triple = "i686-pc-linux-gnu"
-implementation ; Functions:
define i1 @test(i32* %tmp141, i32* %tmp145,
i32 %b8, i32 %iftmp.430.0, i32* %tmp134.out, i32* %tmp137.out)
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
; RUN: grep -v OK | not grep add
-implementation
define i1 @test1(i1 %x) {
%tmp.2 = xor i1 %x, 1
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
; RUN: grep -v OK | not grep add
-implementation
define i111 @test1(i111 %x) {
%tmp.2 = shl i111 1, 110
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep 'and '
-implementation
-
define i39 @test0(i39 %A) {
%B = and i39 %A, 0 ; zero result
ret i39 %B
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep 'and '
-implementation
define i999 @test0(i999 %A) {
%B = and i999 %A, 0 ; zero result
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-implementation ; Functions:
define i32 @main() {
entry:
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep div
-implementation
define i33 @test1(i33 %X) {
%Y = udiv i33 %X, 4096
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep div
-implementation
define i333 @test1(i333 %X) {
%Y = udiv i333 %X, 70368744177664
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep mul
-implementation
define i17 @test1(i17 %X) {
%Y = mul i17 %X, 1024
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep mul
-implementation
define i177 @test1(i177 %X) {
%C = shl i177 1, 155
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep or
-implementation
define i7 @test0(i7 %X) {
%Y = or i7 %X, 0
; RUN: llvm-as < %s | opt -instcombine | llvm-dis > /tmp/or2.rel &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep or
-implementation
define i777 @test0(i777 %X) {
%Y = or i777 %X, 0
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep rem
-implementation
define i33 @test1(i33 %A) {
%B = urem i33 %A, 4096
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep rem
-implementation
define i333 @test1(i333 %A) {
%B = urem i333 %A, 70368744177664
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep select &&
; RUN: llvm-as < %s | opt -instcombine -disable-output
-implementation
define i41 @test1(i1 %C) {
%V = select i1 %C, i41 1, i41 0 ; V = C
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep 'xor '
-implementation
define i47 @test1(i47 %A, i47 %B) {
;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep 'xor '
-implementation
define i447 @test1(i447 %A, i447 %B) {
;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
%T = type <4 x float>
-implementation
define %T @test1(%T %v1) {
%v2 = shufflevector %T %v1, %T undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%struct.aal_state_t = type { %struct.CGPoint, %struct.CGPoint, %struct.CGPoint, i32, float, float, float, float, %struct.CGPoint, %struct.CGPoint, float, float, float, float, i32, i32, i32, i32, float, float, i8*, i32, i32, %struct.aal_edge_pool_t*, %struct.aal_edge_pool_t*, i8*, %struct.aal_callback_t*, i32, %struct.aal_span_t*, %struct.aal_span_t*, %struct.aal_span_t*, %struct.aal_span_pool_t*, i8, float, i8, i32 }
%struct.anon = type { %struct.aal_spanarray_t }
-implementation ; Functions:
declare void @llvm.memcpy.i32(i8*, i8*, i32, i32)
target triple = "powerpc-apple-darwin8.8.0"
%struct.foo = type { i8, i8 }
-implementation ; Functions:
define i32 @test1(%struct.foo* %P) {
entry:
%struct.bar = type { %struct.foo, i64, double }
%struct.foo = type { i32, i32 }
-implementation ; Functions:
define i32 @test1(%struct.foo* %P) {
entry:
projects / oota-llvm.git / commitdiff