← 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/X86/tailcall2.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/X86/tailcall2.ll
 
1
; RUN: llc < %s -march=x86    -asm-verbose=false | FileCheck %s -check-prefix=32
 
2
; RUN: llc < %s -march=x86-64 -asm-verbose=false | FileCheck %s -check-prefix=64
 
3
 
 
4
define void @t1(i32 %x) nounwind ssp {
 
5
entry:
 
6
; 32: t1:
 
7
; 32: jmp {{_?}}foo
 
8
 
 
9
; 64: t1:
 
10
; 64: jmp {{_?}}foo
 
11
  tail call void @foo() nounwind
 
12
  ret void
 
13
}
 
14
 
 
15
declare void @foo()
 
16
 
 
17
define void @t2() nounwind ssp {
 
18
entry:
 
19
; 32: t2:
 
20
; 32: jmp {{_?}}foo2
 
21
 
 
22
; 64: t2:
 
23
; 64: jmp {{_?}}foo2
 
24
  %0 = tail call i32 @foo2() nounwind
 
25
  ret void
 
26
}
 
27
 
 
28
declare i32 @foo2()
 
29
 
 
30
define void @t3() nounwind ssp {
 
31
entry:
 
32
; 32: t3:
 
33
; 32: jmp {{_?}}foo3
 
34
 
 
35
; 64: t3:
 
36
; 64: jmp {{_?}}foo3
 
37
  %0 = tail call i32 @foo3() nounwind
 
38
  ret void
 
39
}
 
40
 
 
41
declare i32 @foo3()
 
42
 
 
43
define void @t4(void (i32)* nocapture %x) nounwind ssp {
 
44
entry:
 
45
; 32: t4:
 
46
; 32: call *
 
47
; FIXME: gcc can generate a tailcall for this. But it's tricky.
 
48
 
 
49
; 64: t4:
 
50
; 64-NOT: call
 
51
; 64: jmpq *
 
52
  tail call void %x(i32 0) nounwind
 
53
  ret void
 
54
}
 
55
 
 
56
define void @t5(void ()* nocapture %x) nounwind ssp {
 
57
entry:
 
58
; 32: t5:
 
59
; 32-NOT: call
 
60
; 32: jmpl *
 
61
 
 
62
; 64: t5:
 
63
; 64-NOT: call
 
64
; 64: jmpq *
 
65
  tail call void %x() nounwind
 
66
  ret void
 
67
}
 
68
 
 
69
define i32 @t6(i32 %x) nounwind ssp {
 
70
entry:
 
71
; 32: t6:
 
72
; 32: call {{_?}}t6
 
73
; 32: jmp {{_?}}bar
 
74
 
 
75
; 64: t6:
 
76
; 64: jmp {{_?}}t6
 
77
; 64: jmp {{_?}}bar
 
78
  %0 = icmp slt i32 %x, 10
 
79
  br i1 %0, label %bb, label %bb1
 
80
 
 
81
bb:
 
82
  %1 = add nsw i32 %x, -1
 
83
  %2 = tail call i32 @t6(i32 %1) nounwind ssp
 
84
  ret i32 %2
 
85
 
 
86
bb1:
 
87
  %3 = tail call i32 @bar(i32 %x) nounwind
 
88
  ret i32 %3
 
89
}
 
90
 
 
91
declare i32 @bar(i32)
 
92
 
 
93
define i32 @t7(i32 %a, i32 %b, i32 %c) nounwind ssp {
 
94
entry:
 
95
; 32: t7:
 
96
; 32: jmp {{_?}}bar2
 
97
 
 
98
; 64: t7:
 
99
; 64: jmp {{_?}}bar2
 
100
  %0 = tail call i32 @bar2(i32 %a, i32 %b, i32 %c) nounwind
 
101
  ret i32 %0
 
102
}
 
103
 
 
104
declare i32 @bar2(i32, i32, i32)
 
105
 
 
106
define signext i16 @t8() nounwind ssp {
 
107
entry:
 
108
; 32: t8:
 
109
; 32: call {{_?}}bar3
 
110
 
 
111
; 64: t8:
 
112
; 64: callq {{_?}}bar3
 
113
  %0 = tail call signext i16 @bar3() nounwind      ; <i16> [#uses=1]
 
114
  ret i16 %0
 
115
}
 
116
 
 
117
declare signext i16 @bar3()
 
118
 
 
119
define signext i16 @t9(i32 (i32)* nocapture %x) nounwind ssp {
 
120
entry:
 
121
; 32: t9:
 
122
; 32: call *
 
123
 
 
124
; 64: t9:
 
125
; 64: callq *
 
126
  %0 = bitcast i32 (i32)* %x to i16 (i32)*
 
127
  %1 = tail call signext i16 %0(i32 0) nounwind
 
128
  ret i16 %1
 
129
}
 
130
 
 
131
define void @t10() nounwind ssp {
 
132
entry:
 
133
; 32: t10:
 
134
; 32: call
 
135
 
 
136
; 64: t10:
 
137
; 64: callq
 
138
  %0 = tail call i32 @foo4() noreturn nounwind
 
139
  unreachable
 
140
}
 
141
 
 
142
declare i32 @foo4()
 
143
 
 
144
define i32 @t11(i32 %x, i32 %y, i32 %z.0, i32 %z.1, i32 %z.2) nounwind ssp {
 
145
; In 32-bit mode, it's emitting a bunch of dead loads that are not being
 
146
; eliminated currently.
 
147
 
 
148
; 32: t11:
 
149
; 32-NOT: subl ${{[0-9]+}}, %esp
 
150
; 32: jne
 
151
; 32-NOT: movl
 
152
; 32-NOT: addl ${{[0-9]+}}, %esp
 
153
; 32: jmp {{_?}}foo5
 
154
 
 
155
; 64: t11:
 
156
; 64-NOT: subq ${{[0-9]+}}, %esp
 
157
; 64-NOT: addq ${{[0-9]+}}, %esp
 
158
; 64: jmp {{_?}}foo5
 
159
entry:
 
160
  %0 = icmp eq i32 %x, 0
 
161
  br i1 %0, label %bb6, label %bb
 
162
 
 
163
bb:
 
164
  %1 = tail call i32 @foo5(i32 %x, i32 %y, i32 %z.0, i32 %z.1, i32 %z.2) nounwind
 
165
  ret i32 %1
 
166
 
 
167
bb6:
 
168
  ret i32 0
 
169
}
 
170
 
 
171
declare i32 @foo5(i32, i32, i32, i32, i32)
 
172
 
 
173
%struct.t = type { i32, i32, i32, i32, i32 }
 
174
 
 
175
define i32 @t12(i32 %x, i32 %y, %struct.t* byval align 4 %z) nounwind ssp {
 
176
; 32: t12:
 
177
; 32-NOT: subl ${{[0-9]+}}, %esp
 
178
; 32-NOT: addl ${{[0-9]+}}, %esp
 
179
; 32: jmp {{_?}}foo6
 
180
 
 
181
; 64: t12:
 
182
; 64-NOT: subq ${{[0-9]+}}, %esp
 
183
; 64-NOT: addq ${{[0-9]+}}, %esp
 
184
; 64: jmp {{_?}}foo6
 
185
entry:
 
186
  %0 = icmp eq i32 %x, 0
 
187
  br i1 %0, label %bb2, label %bb
 
188
 
 
189
bb:
 
190
  %1 = tail call i32 @foo6(i32 %x, i32 %y, %struct.t* byval align 4 %z) nounwind
 
191
  ret i32 %1
 
192
 
 
193
bb2:
 
194
  ret i32 0
 
195
}
 
196
 
 
197
declare i32 @foo6(i32, i32, %struct.t* byval align 4)
 
198
 
 
199
; rdar://r7717598
 
200
%struct.ns = type { i32, i32 }
 
201
%struct.cp = type { float, float }
 
202
 
 
203
define %struct.ns* @t13(%struct.cp* %yy) nounwind ssp {
 
204
; 32: t13:
 
205
; 32-NOT: jmp
 
206
; 32: call
 
207
; 32: ret
 
208
 
 
209
; 64: t13:
 
210
; 64-NOT: jmp
 
211
; 64: call
 
212
; 64: ret
 
213
entry:
 
214
  %0 = tail call fastcc %struct.ns* @foo7(%struct.cp* byval align 4 %yy, i8 signext 0) nounwind
 
215
  ret %struct.ns* %0
 
216
}
 
217
 
 
218
declare fastcc %struct.ns* @foo7(%struct.cp* byval align 4, i8 signext) nounwind ssp