← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/test/CodeGen/PowerPC/vector.ll

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/test/CodeGen/PowerPC/vector.ll
 
1
; Test that vectors are scalarized/lowered correctly.
 
2
; RUN: llc < %s -march=ppc32 -mcpu=g5 > %t
 
3
; RUN: llc < %s -march=ppc32 -mcpu=g3 > %t
 
4
 
 
5
%d8 = type <8 x double>
 
6
%f1 = type <1 x float>
 
7
%f2 = type <2 x float>
 
8
%f4 = type <4 x float>
 
9
%f8 = type <8 x float>
 
10
%i4 = type <4 x i32>
 
11
 
 
12
;;; TEST HANDLING OF VARIOUS VECTOR SIZES
 
13
 
 
14
define void @test_f1(%f1* %P, %f1* %Q, %f1* %S) {
 
15
        %p = load %f1* %P               ; <%f1> [#uses=1]
 
16
        %q = load %f1* %Q               ; <%f1> [#uses=1]
 
17
        %R = fadd %f1 %p, %q             ; <%f1> [#uses=1]
 
18
        store %f1 %R, %f1* %S
 
19
        ret void
 
20
}
 
21
 
 
22
define void @test_f2(%f2* %P, %f2* %Q, %f2* %S) {
 
23
        %p = load %f2* %P               ; <%f2> [#uses=1]
 
24
        %q = load %f2* %Q               ; <%f2> [#uses=1]
 
25
        %R = fadd %f2 %p, %q             ; <%f2> [#uses=1]
 
26
        store %f2 %R, %f2* %S
 
27
        ret void
 
28
}
 
29
 
 
30
define void @test_f4(%f4* %P, %f4* %Q, %f4* %S) {
 
31
        %p = load %f4* %P               ; <%f4> [#uses=1]
 
32
        %q = load %f4* %Q               ; <%f4> [#uses=1]
 
33
        %R = fadd %f4 %p, %q             ; <%f4> [#uses=1]
 
34
        store %f4 %R, %f4* %S
 
35
        ret void
 
36
}
 
37
 
 
38
define void @test_f8(%f8* %P, %f8* %Q, %f8* %S) {
 
39
        %p = load %f8* %P               ; <%f8> [#uses=1]
 
40
        %q = load %f8* %Q               ; <%f8> [#uses=1]
 
41
        %R = fadd %f8 %p, %q             ; <%f8> [#uses=1]
 
42
        store %f8 %R, %f8* %S
 
43
        ret void
 
44
}
 
45
 
 
46
define void @test_fmul(%f8* %P, %f8* %Q, %f8* %S) {
 
47
        %p = load %f8* %P               ; <%f8> [#uses=1]
 
48
        %q = load %f8* %Q               ; <%f8> [#uses=1]
 
49
        %R = fmul %f8 %p, %q             ; <%f8> [#uses=1]
 
50
        store %f8 %R, %f8* %S
 
51
        ret void
 
52
}
 
53
 
 
54
define void @test_div(%f8* %P, %f8* %Q, %f8* %S) {
 
55
        %p = load %f8* %P               ; <%f8> [#uses=1]
 
56
        %q = load %f8* %Q               ; <%f8> [#uses=1]
 
57
        %R = fdiv %f8 %p, %q            ; <%f8> [#uses=1]
 
58
        store %f8 %R, %f8* %S
 
59
        ret void
 
60
}
 
61
 
 
62
;;; TEST VECTOR CONSTRUCTS
 
63
 
 
64
define void @test_cst(%f4* %P, %f4* %S) {
 
65
        %p = load %f4* %P               ; <%f4> [#uses=1]
 
66
        %R = fadd %f4 %p, < float 0x3FB99999A0000000, float 1.000000e+00, float
 
67
 2.000000e+00, float 4.500000e+00 >             ; <%f4> [#uses=1]
 
68
        store %f4 %R, %f4* %S
 
69
        ret void
 
70
}
 
71
 
 
72
define void @test_zero(%f4* %P, %f4* %S) {
 
73
        %p = load %f4* %P               ; <%f4> [#uses=1]
 
74
        %R = fadd %f4 %p, zeroinitializer                ; <%f4> [#uses=1]
 
75
        store %f4 %R, %f4* %S
 
76
        ret void
 
77
}
 
78
 
 
79
define void @test_undef(%f4* %P, %f4* %S) {
 
80
        %p = load %f4* %P               ; <%f4> [#uses=1]
 
81
        %R = fadd %f4 %p, undef          ; <%f4> [#uses=1]
 
82
        store %f4 %R, %f4* %S
 
83
        ret void
 
84
}
 
85
 
 
86
define void @test_constant_insert(%f4* %S) {
 
87
        %R = insertelement %f4 zeroinitializer, float 1.000000e+01, i32 0     
 
88
                ; <%f4> [#uses=1]
 
89
        store %f4 %R, %f4* %S
 
90
        ret void
 
91
}
 
92
 
 
93
define void @test_variable_buildvector(float %F, %f4* %S) {
 
94
        %R = insertelement %f4 zeroinitializer, float %F, i32 0        
 
95
        store %f4 %R, %f4* %S
 
96
        ret void
 
97
}
 
98
 
 
99
define void @test_scalar_to_vector(float %F, %f4* %S) {
 
100
        %R = insertelement %f4 undef, float %F, i32 0           
 
101
        store %f4 %R, %f4* %S
 
102
        ret void
 
103
}
 
104
 
 
105
define float @test_extract_elt(%f8* %P) {
 
106
        %p = load %f8* %P               ; <%f8> [#uses=1]
 
107
        %R = extractelement %f8 %p, i32 3               ; <float> [#uses=1]
 
108
        ret float %R
 
109
}
 
110
 
 
111
define double @test_extract_elt2(%d8* %P) {
 
112
        %p = load %d8* %P               ; <%d8> [#uses=1]
 
113
        %R = extractelement %d8 %p, i32 3               ; <double> [#uses=1]
 
114
        ret double %R
 
115
}
 
116
 
 
117
define void @test_cast_1(%f4* %b, %i4* %a) {
 
118
        %tmp = load %f4* %b             ; <%f4> [#uses=1]
 
119
        %tmp2 = fadd %f4 %tmp, < float 1.000000e+00, float 2.000000e+00, float
 
120
3.000000e+00, float 4.000000e+00 >              ; <%f4> [#uses=1]
 
121
        %tmp3 = bitcast %f4 %tmp2 to %i4                ; <%i4> [#uses=1]
 
122
        %tmp4 = add %i4 %tmp3, < i32 1, i32 2, i32 3, i32 4 >           
 
123
        store %i4 %tmp4, %i4* %a
 
124
        ret void
 
125
}
 
126
 
 
127
define void @test_cast_2(%f8* %a, <8 x i32>* %b) {
 
128
        %T = load %f8* %a               ; <%f8> [#uses=1]
 
129
        %T2 = bitcast %f8 %T to <8 x i32>               
 
130
        store <8 x i32> %T2, <8 x i32>* %b
 
131
        ret void
 
132
}
 
133
 
 
134
 
 
135
;;; TEST IMPORTANT IDIOMS
 
136
 
 
137
define void @splat(%f4* %P, %f4* %Q, float %X) {
 
138
        %tmp = insertelement %f4 undef, float %X, i32 0        
 
139
        %tmp2 = insertelement %f4 %tmp, float %X, i32 1       
 
140
        %tmp4 = insertelement %f4 %tmp2, float %X, i32 2    
 
141
        %tmp6 = insertelement %f4 %tmp4, float %X, i32 3   
 
142
        %q = load %f4* %Q               ; <%f4> [#uses=1]
 
143
        %R = fadd %f4 %q, %tmp6          ; <%f4> [#uses=1]
 
144
        store %f4 %R, %f4* %P
 
145
        ret void
 
146
}
 
147
 
 
148
define void @splat_i4(%i4* %P, %i4* %Q, i32 %X) {
 
149
        %tmp = insertelement %i4 undef, i32 %X, i32 0          
 
150
        %tmp2 = insertelement %i4 %tmp, i32 %X, i32 1         
 
151
        %tmp4 = insertelement %i4 %tmp2, i32 %X, i32 2       
 
152
        %tmp6 = insertelement %i4 %tmp4, i32 %X, i32 3     
 
153
        %q = load %i4* %Q               ; <%i4> [#uses=1]
 
154
        %R = add %i4 %q, %tmp6          ; <%i4> [#uses=1]
 
155
        store %i4 %R, %i4* %P
 
156
        ret void
 
157
}
 
158