← 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/sse-minmax.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/sse-minmax.ll
 
1
; RUN: llc < %s -march=x86-64 -asm-verbose=false | FileCheck %s
 
2
; RUN: llc < %s -march=x86-64 -asm-verbose=false -enable-unsafe-fp-math | FileCheck -check-prefix=UNSAFE %s
 
3
; RUN: llc < %s -march=x86-64 -asm-verbose=false -enable-finite-only-fp-math | FileCheck -check-prefix=FINITE %s
 
4
 
 
5
; Some of these patterns can be matched as SSE min or max. Some of
 
6
; then can be matched provided that the operands are swapped.
 
7
; Some of them can't be matched at all and require a comparison
 
8
; and a conditional branch.
 
9
 
 
10
; The naming convention is {,x_,y_}{o,u}{gt,lt,ge,le}{,_inverse}
 
11
; x_ : use 0.0 instead of %y
 
12
; y_ : use -0.0 instead of %y
 
13
; _inverse : swap the arms of the select.
 
14
 
 
15
; CHECK:      ogt:
 
16
; CHECK-NEXT: maxsd %xmm1, %xmm0
 
17
; CHECK-NEXT: ret
 
18
; UNSAFE:      ogt:
 
19
; UNSAFE-NEXT: maxsd %xmm1, %xmm0
 
20
; UNSAFE-NEXT: ret
 
21
; FINITE:      ogt:
 
22
; FINITE-NEXT: maxsd %xmm1, %xmm0
 
23
; FINITE-NEXT: ret
 
24
define double @ogt(double %x, double %y) nounwind {
 
25
  %c = fcmp ogt double %x, %y
 
26
  %d = select i1 %c, double %x, double %y
 
27
  ret double %d
 
28
}
 
29
 
 
30
; CHECK:      olt:
 
31
; CHECK-NEXT: minsd %xmm1, %xmm0
 
32
; CHECK-NEXT: ret
 
33
; UNSAFE:      olt:
 
34
; UNSAFE-NEXT: minsd %xmm1, %xmm0
 
35
; UNSAFE-NEXT: ret
 
36
; FINITE:      olt:
 
37
; FINITE-NEXT: minsd %xmm1, %xmm0
 
38
; FINITE-NEXT: ret
 
39
define double @olt(double %x, double %y) nounwind {
 
40
  %c = fcmp olt double %x, %y
 
41
  %d = select i1 %c, double %x, double %y
 
42
  ret double %d
 
43
}
 
44
 
 
45
; CHECK:      ogt_inverse:
 
46
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
47
; CHECK-NEXT: movapd %xmm1, %xmm0
 
48
; CHECK-NEXT: ret
 
49
; UNSAFE:      ogt_inverse:
 
50
; UNSAFE-NEXT: minsd  %xmm0, %xmm1
 
51
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
52
; UNSAFE-NEXT: ret
 
53
; FINITE:      ogt_inverse:
 
54
; FINITE-NEXT: minsd  %xmm0, %xmm1
 
55
; FINITE-NEXT: movapd %xmm1, %xmm0
 
56
; FINITE-NEXT: ret
 
57
define double @ogt_inverse(double %x, double %y) nounwind {
 
58
  %c = fcmp ogt double %x, %y
 
59
  %d = select i1 %c, double %y, double %x
 
60
  ret double %d
 
61
}
 
62
 
 
63
; CHECK:      olt_inverse:
 
64
; CHECK-NEXT: maxsd  %xmm0, %xmm1
 
65
; CHECK-NEXT: movapd %xmm1, %xmm0
 
66
; CHECK-NEXT: ret
 
67
; UNSAFE:      olt_inverse:
 
68
; UNSAFE-NEXT: maxsd  %xmm0, %xmm1
 
69
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
70
; UNSAFE-NEXT: ret
 
71
; FINITE:      olt_inverse:
 
72
; FINITE-NEXT: maxsd  %xmm0, %xmm1
 
73
; FINITE-NEXT: movapd %xmm1, %xmm0
 
74
; FINITE-NEXT: ret
 
75
define double @olt_inverse(double %x, double %y) nounwind {
 
76
  %c = fcmp olt double %x, %y
 
77
  %d = select i1 %c, double %y, double %x
 
78
  ret double %d
 
79
}
 
80
 
 
81
; CHECK:      oge:
 
82
; CHECK-NEXT: ucomisd %xmm1, %xmm0
 
83
; UNSAFE:      oge:
 
84
; UNSAFE-NEXT: maxsd    %xmm1, %xmm0
 
85
; UNSAFE-NEXT: ret
 
86
; FINITE:      oge:
 
87
; FINITE-NEXT: maxsd    %xmm1, %xmm0
 
88
; FINITE-NEXT: ret
 
89
define double @oge(double %x, double %y) nounwind {
 
90
  %c = fcmp oge double %x, %y
 
91
  %d = select i1 %c, double %x, double %y
 
92
  ret double %d
 
93
}
 
94
 
 
95
; CHECK:      ole:
 
96
; CHECK-NEXT: ucomisd %xmm0, %xmm1
 
97
; UNSAFE:      ole:
 
98
; UNSAFE-NEXT: minsd %xmm1, %xmm0
 
99
; FINITE:      ole:
 
100
; FINITE-NEXT: minsd %xmm1, %xmm0
 
101
define double @ole(double %x, double %y) nounwind {
 
102
  %c = fcmp ole double %x, %y
 
103
  %d = select i1 %c, double %x, double %y
 
104
  ret double %d
 
105
}
 
106
 
 
107
; CHECK:      oge_inverse:
 
108
; CHECK-NEXT: ucomisd %xmm1, %xmm0
 
109
; UNSAFE:      oge_inverse:
 
110
; UNSAFE-NEXT: minsd %xmm0, %xmm1
 
111
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
112
; UNSAFE-NEXT: ret
 
113
; FINITE:      oge_inverse:
 
114
; FINITE-NEXT: minsd %xmm0, %xmm1
 
115
; FINITE-NEXT: movapd %xmm1, %xmm0
 
116
; FINITE-NEXT: ret
 
117
define double @oge_inverse(double %x, double %y) nounwind {
 
118
  %c = fcmp oge double %x, %y
 
119
  %d = select i1 %c, double %y, double %x
 
120
  ret double %d
 
121
}
 
122
 
 
123
; CHECK:      ole_inverse:
 
124
; CHECK-NEXT: ucomisd %xmm0, %xmm1
 
125
; UNSAFE:      ole_inverse:
 
126
; UNSAFE-NEXT: maxsd %xmm0, %xmm1
 
127
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
128
; UNSAFE-NEXT: ret
 
129
; FINITE:      ole_inverse:
 
130
; FINITE-NEXT: maxsd %xmm0, %xmm1
 
131
; FINITE-NEXT: movapd %xmm1, %xmm0
 
132
; FINITE-NEXT: ret
 
133
define double @ole_inverse(double %x, double %y) nounwind {
 
134
  %c = fcmp ole double %x, %y
 
135
  %d = select i1 %c, double %y, double %x
 
136
  ret double %d
 
137
}
 
138
 
 
139
; CHECK:      x_ogt:
 
140
; CHECK-NEXT: pxor  %xmm1, %xmm1
 
141
; CHECK-NEXT: maxsd %xmm1, %xmm0
 
142
; CHECK-NEXT: ret
 
143
; UNSAFE:      x_ogt:
 
144
; UNSAFE-NEXT: pxor  %xmm1, %xmm1
 
145
; UNSAFE-NEXT: maxsd %xmm1, %xmm0
 
146
; UNSAFE-NEXT: ret
 
147
; FINITE:      x_ogt:
 
148
; FINITE-NEXT: pxor  %xmm1, %xmm1
 
149
; FINITE-NEXT: maxsd %xmm1, %xmm0
 
150
; FINITE-NEXT: ret
 
151
define double @x_ogt(double %x) nounwind {
 
152
  %c = fcmp ogt double %x, 0.000000e+00
 
153
  %d = select i1 %c, double %x, double 0.000000e+00
 
154
  ret double %d
 
155
}
 
156
 
 
157
; CHECK:      x_olt:
 
158
; CHECK-NEXT: pxor  %xmm1, %xmm1
 
159
; CHECK-NEXT: minsd %xmm1, %xmm0
 
160
; CHECK-NEXT: ret
 
161
; UNSAFE:      x_olt:
 
162
; UNSAFE-NEXT: pxor  %xmm1, %xmm1
 
163
; UNSAFE-NEXT: minsd %xmm1, %xmm0
 
164
; UNSAFE-NEXT: ret
 
165
; FINITE:      x_olt:
 
166
; FINITE-NEXT: pxor  %xmm1, %xmm1
 
167
; FINITE-NEXT: minsd %xmm1, %xmm0
 
168
; FINITE-NEXT: ret
 
169
define double @x_olt(double %x) nounwind {
 
170
  %c = fcmp olt double %x, 0.000000e+00
 
171
  %d = select i1 %c, double %x, double 0.000000e+00
 
172
  ret double %d
 
173
}
 
174
 
 
175
; CHECK:      x_ogt_inverse:
 
176
; CHECK-NEXT: pxor   %xmm1, %xmm1
 
177
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
178
; CHECK-NEXT: movapd %xmm1, %xmm0
 
179
; CHECK-NEXT: ret
 
180
; UNSAFE:      x_ogt_inverse:
 
181
; UNSAFE-NEXT: pxor   %xmm1, %xmm1
 
182
; UNSAFE-NEXT: minsd  %xmm0, %xmm1
 
183
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
184
; UNSAFE-NEXT: ret
 
185
; FINITE:      x_ogt_inverse:
 
186
; FINITE-NEXT: pxor   %xmm1, %xmm1
 
187
; FINITE-NEXT: minsd  %xmm0, %xmm1
 
188
; FINITE-NEXT: movapd %xmm1, %xmm0
 
189
; FINITE-NEXT: ret
 
190
define double @x_ogt_inverse(double %x) nounwind {
 
191
  %c = fcmp ogt double %x, 0.000000e+00
 
192
  %d = select i1 %c, double 0.000000e+00, double %x
 
193
  ret double %d
 
194
}
 
195
 
 
196
; CHECK:      x_olt_inverse:
 
197
; CHECK-NEXT: pxor   %xmm1, %xmm1
 
198
; CHECK-NEXT: maxsd  %xmm0, %xmm1
 
199
; CHECK-NEXT: movapd %xmm1, %xmm0
 
200
; CHECK-NEXT: ret
 
201
; UNSAFE:      x_olt_inverse:
 
202
; UNSAFE-NEXT: pxor   %xmm1, %xmm1
 
203
; UNSAFE-NEXT: maxsd  %xmm0, %xmm1
 
204
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
205
; UNSAFE-NEXT: ret
 
206
; FINITE:      x_olt_inverse:
 
207
; FINITE-NEXT: pxor   %xmm1, %xmm1
 
208
; FINITE-NEXT: maxsd  %xmm0, %xmm1
 
209
; FINITE-NEXT: movapd %xmm1, %xmm0
 
210
; FINITE-NEXT: ret
 
211
define double @x_olt_inverse(double %x) nounwind {
 
212
  %c = fcmp olt double %x, 0.000000e+00
 
213
  %d = select i1 %c, double 0.000000e+00, double %x
 
214
  ret double %d
 
215
}
 
216
 
 
217
; CHECK:      x_oge:
 
218
; CHECK:      ucomisd %xmm1, %xmm0
 
219
; UNSAFE:      x_oge:
 
220
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
221
; UNSAFE-NEXT: maxsd   %xmm1, %xmm0
 
222
; UNSAFE-NEXT: ret
 
223
; FINITE:      x_oge:
 
224
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
225
; FINITE-NEXT: maxsd   %xmm1, %xmm0
 
226
; FINITE-NEXT: ret
 
227
define double @x_oge(double %x) nounwind {
 
228
  %c = fcmp oge double %x, 0.000000e+00
 
229
  %d = select i1 %c, double %x, double 0.000000e+00
 
230
  ret double %d
 
231
}
 
232
 
 
233
; CHECK:      x_ole:
 
234
; CHECK:      ucomisd %xmm0, %xmm1
 
235
; UNSAFE:      x_ole:
 
236
; UNSAFE-NEXT: pxor %xmm1, %xmm1
 
237
; UNSAFE-NEXT: minsd %xmm1, %xmm0
 
238
; UNSAFE-NEXT: ret
 
239
; FINITE:      x_ole:
 
240
; FINITE-NEXT: pxor %xmm1, %xmm1
 
241
; FINITE-NEXT: minsd %xmm1, %xmm0
 
242
; FINITE-NEXT: ret
 
243
define double @x_ole(double %x) nounwind {
 
244
  %c = fcmp ole double %x, 0.000000e+00
 
245
  %d = select i1 %c, double %x, double 0.000000e+00
 
246
  ret double %d
 
247
}
 
248
 
 
249
; CHECK:      x_oge_inverse:
 
250
; CHECK:      ucomisd %xmm1, %xmm0
 
251
; UNSAFE:      x_oge_inverse:
 
252
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
253
; UNSAFE-NEXT: minsd   %xmm0, %xmm1
 
254
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
255
; UNSAFE-NEXT: ret
 
256
; FINITE:      x_oge_inverse:
 
257
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
258
; FINITE-NEXT: minsd   %xmm0, %xmm1
 
259
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
260
; FINITE-NEXT: ret
 
261
define double @x_oge_inverse(double %x) nounwind {
 
262
  %c = fcmp oge double %x, 0.000000e+00
 
263
  %d = select i1 %c, double 0.000000e+00, double %x
 
264
  ret double %d
 
265
}
 
266
 
 
267
; CHECK:      x_ole_inverse:
 
268
; CHECK:      ucomisd %xmm0, %xmm1
 
269
; UNSAFE:      x_ole_inverse:
 
270
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
271
; UNSAFE-NEXT: maxsd   %xmm0, %xmm1
 
272
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
273
; UNSAFE-NEXT: ret
 
274
; FINITE:      x_ole_inverse:
 
275
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
276
; FINITE-NEXT: maxsd   %xmm0, %xmm1
 
277
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
278
; FINITE-NEXT: ret
 
279
define double @x_ole_inverse(double %x) nounwind {
 
280
  %c = fcmp ole double %x, 0.000000e+00
 
281
  %d = select i1 %c, double 0.000000e+00, double %x
 
282
  ret double %d
 
283
}
 
284
 
 
285
; CHECK:      ugt:
 
286
; CHECK:      ucomisd %xmm0, %xmm1
 
287
; UNSAFE:      ugt:
 
288
; UNSAFE-NEXT: maxsd   %xmm1, %xmm0
 
289
; UNSAFE-NEXT: ret
 
290
; FINITE:      ugt:
 
291
; FINITE-NEXT: maxsd   %xmm1, %xmm0
 
292
; FINITE-NEXT: ret
 
293
define double @ugt(double %x, double %y) nounwind {
 
294
  %c = fcmp ugt double %x, %y
 
295
  %d = select i1 %c, double %x, double %y
 
296
  ret double %d
 
297
}
 
298
 
 
299
; CHECK:      ult:
 
300
; CHECK:      ucomisd %xmm1, %xmm0
 
301
; UNSAFE:      ult:
 
302
; UNSAFE-NEXT: minsd   %xmm1, %xmm0
 
303
; UNSAFE-NEXT: ret
 
304
; FINITE:      ult:
 
305
; FINITE-NEXT: minsd   %xmm1, %xmm0
 
306
; FINITE-NEXT: ret
 
307
define double @ult(double %x, double %y) nounwind {
 
308
  %c = fcmp ult double %x, %y
 
309
  %d = select i1 %c, double %x, double %y
 
310
  ret double %d
 
311
}
 
312
 
 
313
; CHECK:      ugt_inverse:
 
314
; CHECK:      ucomisd %xmm0, %xmm1
 
315
; UNSAFE:      ugt_inverse:
 
316
; UNSAFE-NEXT: minsd   %xmm0, %xmm1
 
317
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
318
; UNSAFE-NEXT: ret
 
319
; FINITE:      ugt_inverse:
 
320
; FINITE-NEXT: minsd   %xmm0, %xmm1
 
321
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
322
; FINITE-NEXT: ret
 
323
define double @ugt_inverse(double %x, double %y) nounwind {
 
324
  %c = fcmp ugt double %x, %y
 
325
  %d = select i1 %c, double %y, double %x
 
326
  ret double %d
 
327
}
 
328
 
 
329
; CHECK:      ult_inverse:
 
330
; CHECK:      ucomisd %xmm1, %xmm0
 
331
; UNSAFE:      ult_inverse:
 
332
; UNSAFE-NEXT: maxsd   %xmm0, %xmm1
 
333
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
334
; UNSAFE-NEXT: ret
 
335
; FINITE:      ult_inverse:
 
336
; FINITE-NEXT: maxsd   %xmm0, %xmm1
 
337
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
338
; FINITE-NEXT: ret
 
339
define double @ult_inverse(double %x, double %y) nounwind {
 
340
  %c = fcmp ult double %x, %y
 
341
  %d = select i1 %c, double %y, double %x
 
342
  ret double %d
 
343
}
 
344
 
 
345
; CHECK:      uge:
 
346
; CHECK-NEXT: maxsd   %xmm0, %xmm1
 
347
; CHECK-NEXT: movapd  %xmm1, %xmm0
 
348
; CHECK-NEXT: ret
 
349
; UNSAFE:      uge:
 
350
; UNSAFE-NEXT: maxsd   %xmm1, %xmm0
 
351
; UNSAFE-NEXT: ret
 
352
; FINITE:      uge:
 
353
; FINITE-NEXT: maxsd   %xmm1, %xmm0
 
354
; FINITE-NEXT: ret
 
355
define double @uge(double %x, double %y) nounwind {
 
356
  %c = fcmp uge double %x, %y
 
357
  %d = select i1 %c, double %x, double %y
 
358
  ret double %d
 
359
}
 
360
 
 
361
; CHECK:      ule:
 
362
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
363
; CHECK-NEXT: movapd %xmm1, %xmm0
 
364
; CHECK-NEXT: ret
 
365
; UNSAFE:      ule:
 
366
; UNSAFE-NEXT: minsd   %xmm1, %xmm0
 
367
; UNSAFE-NEXT: ret
 
368
; FINITE:      ule:
 
369
; FINITE-NEXT: minsd   %xmm1, %xmm0
 
370
; FINITE-NEXT: ret
 
371
define double @ule(double %x, double %y) nounwind {
 
372
  %c = fcmp ule double %x, %y
 
373
  %d = select i1 %c, double %x, double %y
 
374
  ret double %d
 
375
}
 
376
 
 
377
; CHECK:      uge_inverse:
 
378
; CHECK-NEXT: minsd %xmm1, %xmm0
 
379
; CHECK-NEXT: ret
 
380
; UNSAFE:      uge_inverse:
 
381
; UNSAFE-NEXT: minsd %xmm0, %xmm1
 
382
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
383
; UNSAFE-NEXT: ret
 
384
; FINITE:      uge_inverse:
 
385
; FINITE-NEXT: minsd %xmm0, %xmm1
 
386
; FINITE-NEXT: movapd %xmm1, %xmm0
 
387
; FINITE-NEXT: ret
 
388
define double @uge_inverse(double %x, double %y) nounwind {
 
389
  %c = fcmp uge double %x, %y
 
390
  %d = select i1 %c, double %y, double %x
 
391
  ret double %d
 
392
}
 
393
 
 
394
; CHECK:      ule_inverse:
 
395
; CHECK-NEXT: maxsd %xmm1, %xmm0
 
396
; CHECK-NEXT: ret
 
397
; UNSAFE:      ule_inverse:
 
398
; UNSAFE-NEXT: maxsd %xmm0, %xmm1
 
399
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
400
; UNSAFE-NEXT: ret
 
401
; FINITE:      ule_inverse:
 
402
; FINITE-NEXT: maxsd %xmm0, %xmm1
 
403
; FINITE-NEXT: movapd %xmm1, %xmm0
 
404
; FINITE-NEXT: ret
 
405
define double @ule_inverse(double %x, double %y) nounwind {
 
406
  %c = fcmp ule double %x, %y
 
407
  %d = select i1 %c, double %y, double %x
 
408
  ret double %d
 
409
}
 
410
 
 
411
; CHECK:      x_ugt:
 
412
; CHECK:      ucomisd %xmm0, %xmm1
 
413
; UNSAFE:      x_ugt:
 
414
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
415
; UNSAFE-NEXT: maxsd   %xmm1, %xmm0
 
416
; UNSAFE-NEXT: ret
 
417
; FINITE:      x_ugt:
 
418
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
419
; FINITE-NEXT: maxsd   %xmm1, %xmm0
 
420
; FINITE-NEXT: ret
 
421
define double @x_ugt(double %x) nounwind {
 
422
  %c = fcmp ugt double %x, 0.000000e+00
 
423
  %d = select i1 %c, double %x, double 0.000000e+00
 
424
  ret double %d
 
425
}
 
426
 
 
427
; CHECK:      x_ult:
 
428
; CHECK:      ucomisd %xmm1, %xmm0
 
429
; UNSAFE:      x_ult:
 
430
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
431
; UNSAFE-NEXT: minsd   %xmm1, %xmm0
 
432
; UNSAFE-NEXT: ret
 
433
; FINITE:      x_ult:
 
434
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
435
; FINITE-NEXT: minsd   %xmm1, %xmm0
 
436
; FINITE-NEXT: ret
 
437
define double @x_ult(double %x) nounwind {
 
438
  %c = fcmp ult double %x, 0.000000e+00
 
439
  %d = select i1 %c, double %x, double 0.000000e+00
 
440
  ret double %d
 
441
}
 
442
 
 
443
; CHECK:      x_ugt_inverse:
 
444
; CHECK:      ucomisd %xmm0, %xmm1
 
445
; UNSAFE:      x_ugt_inverse:
 
446
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
447
; UNSAFE-NEXT: minsd   %xmm0, %xmm1
 
448
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
449
; UNSAFE-NEXT: ret
 
450
; FINITE:      x_ugt_inverse:
 
451
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
452
; FINITE-NEXT: minsd   %xmm0, %xmm1
 
453
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
454
; FINITE-NEXT: ret
 
455
define double @x_ugt_inverse(double %x) nounwind {
 
456
  %c = fcmp ugt double %x, 0.000000e+00
 
457
  %d = select i1 %c, double 0.000000e+00, double %x
 
458
  ret double %d
 
459
}
 
460
 
 
461
; CHECK:      x_ult_inverse:
 
462
; CHECK:      ucomisd %xmm1, %xmm0
 
463
; UNSAFE:      x_ult_inverse:
 
464
; UNSAFE-NEXT: pxor    %xmm1, %xmm1
 
465
; UNSAFE-NEXT: maxsd   %xmm0, %xmm1
 
466
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
467
; UNSAFE-NEXT: ret
 
468
; FINITE:      x_ult_inverse:
 
469
; FINITE-NEXT: pxor    %xmm1, %xmm1
 
470
; FINITE-NEXT: maxsd   %xmm0, %xmm1
 
471
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
472
; FINITE-NEXT: ret
 
473
define double @x_ult_inverse(double %x) nounwind {
 
474
  %c = fcmp ult double %x, 0.000000e+00
 
475
  %d = select i1 %c, double 0.000000e+00, double %x
 
476
  ret double %d
 
477
}
 
478
 
 
479
; CHECK:      x_uge:
 
480
; CHECK-NEXT: pxor   %xmm1, %xmm1
 
481
; CHECK-NEXT: maxsd  %xmm0, %xmm1
 
482
; CHECK-NEXT: movapd %xmm1, %xmm0
 
483
; CHECK-NEXT: ret
 
484
; UNSAFE:      x_uge:
 
485
; UNSAFE-NEXT: pxor   %xmm1, %xmm1
 
486
; UNSAFE-NEXT: maxsd  %xmm1, %xmm0
 
487
; UNSAFE-NEXT: ret
 
488
; FINITE:      x_uge:
 
489
; FINITE-NEXT: pxor   %xmm1, %xmm1
 
490
; FINITE-NEXT: maxsd  %xmm1, %xmm0
 
491
; FINITE-NEXT: ret
 
492
define double @x_uge(double %x) nounwind {
 
493
  %c = fcmp uge double %x, 0.000000e+00
 
494
  %d = select i1 %c, double %x, double 0.000000e+00
 
495
  ret double %d
 
496
}
 
497
 
 
498
; CHECK:      x_ule:
 
499
; CHECK-NEXT: pxor   %xmm1, %xmm1
 
500
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
501
; CHECK-NEXT: movapd %xmm1, %xmm0
 
502
; CHECK-NEXT: ret
 
503
; UNSAFE:      x_ule:
 
504
; UNSAFE-NEXT: pxor   %xmm1, %xmm1
 
505
; UNSAFE-NEXT: minsd  %xmm1, %xmm0
 
506
; UNSAFE-NEXT: ret
 
507
; FINITE:      x_ule:
 
508
; FINITE-NEXT: pxor   %xmm1, %xmm1
 
509
; FINITE-NEXT: minsd  %xmm1, %xmm0
 
510
; FINITE-NEXT: ret
 
511
define double @x_ule(double %x) nounwind {
 
512
  %c = fcmp ule double %x, 0.000000e+00
 
513
  %d = select i1 %c, double %x, double 0.000000e+00
 
514
  ret double %d
 
515
}
 
516
 
 
517
; CHECK:      x_uge_inverse:
 
518
; CHECK-NEXT: pxor  %xmm1, %xmm1
 
519
; CHECK-NEXT: minsd %xmm1, %xmm0
 
520
; CHECK-NEXT: ret
 
521
; UNSAFE:      x_uge_inverse:
 
522
; UNSAFE-NEXT: pxor  %xmm1, %xmm1
 
523
; UNSAFE-NEXT: minsd %xmm0, %xmm1
 
524
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
525
; UNSAFE-NEXT: ret
 
526
; FINITE:      x_uge_inverse:
 
527
; FINITE-NEXT: pxor  %xmm1, %xmm1
 
528
; FINITE-NEXT: minsd %xmm0, %xmm1
 
529
; FINITE-NEXT: movapd %xmm1, %xmm0
 
530
; FINITE-NEXT: ret
 
531
define double @x_uge_inverse(double %x) nounwind {
 
532
  %c = fcmp uge double %x, 0.000000e+00
 
533
  %d = select i1 %c, double 0.000000e+00, double %x
 
534
  ret double %d
 
535
}
 
536
 
 
537
; CHECK:      x_ule_inverse:
 
538
; CHECK-NEXT: pxor  %xmm1, %xmm1
 
539
; CHECK-NEXT: maxsd %xmm1, %xmm0
 
540
; CHECK-NEXT: ret
 
541
; UNSAFE:      x_ule_inverse:
 
542
; UNSAFE-NEXT: pxor  %xmm1, %xmm1
 
543
; UNSAFE-NEXT: maxsd %xmm0, %xmm1
 
544
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
545
; UNSAFE-NEXT: ret
 
546
; FINITE:      x_ule_inverse:
 
547
; FINITE-NEXT: pxor  %xmm1, %xmm1
 
548
; FINITE-NEXT: maxsd %xmm0, %xmm1
 
549
; FINITE-NEXT: movapd %xmm1, %xmm0
 
550
; FINITE-NEXT: ret
 
551
define double @x_ule_inverse(double %x) nounwind {
 
552
  %c = fcmp ule double %x, 0.000000e+00
 
553
  %d = select i1 %c, double 0.000000e+00, double %x
 
554
  ret double %d
 
555
}
 
556
 
 
557
; CHECK:      y_ogt:
 
558
; CHECK-NEXT: maxsd {{[^,]*}}, %xmm0
 
559
; CHECK-NEXT: ret
 
560
; UNSAFE:      y_ogt:
 
561
; UNSAFE-NEXT: maxsd {{[^,]*}}, %xmm0
 
562
; UNSAFE-NEXT: ret
 
563
; FINITE:      y_ogt:
 
564
; FINITE-NEXT: maxsd {{[^,]*}}, %xmm0
 
565
; FINITE-NEXT: ret
 
566
define double @y_ogt(double %x) nounwind {
 
567
  %c = fcmp ogt double %x, -0.000000e+00
 
568
  %d = select i1 %c, double %x, double -0.000000e+00
 
569
  ret double %d
 
570
}
 
571
 
 
572
; CHECK:      y_olt:
 
573
; CHECK-NEXT: minsd {{[^,]*}}, %xmm0
 
574
; CHECK-NEXT: ret
 
575
; UNSAFE:      y_olt:
 
576
; UNSAFE-NEXT: minsd {{[^,]*}}, %xmm0
 
577
; UNSAFE-NEXT: ret
 
578
; FINITE:      y_olt:
 
579
; FINITE-NEXT: minsd {{[^,]*}}, %xmm0
 
580
; FINITE-NEXT: ret
 
581
define double @y_olt(double %x) nounwind {
 
582
  %c = fcmp olt double %x, -0.000000e+00
 
583
  %d = select i1 %c, double %x, double -0.000000e+00
 
584
  ret double %d
 
585
}
 
586
 
 
587
; CHECK:      y_ogt_inverse:
 
588
; CHECK-NEXT: movsd  {{[^,]*}}, %xmm1
 
589
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
590
; CHECK-NEXT: movapd %xmm1, %xmm0
 
591
; CHECK-NEXT: ret
 
592
; UNSAFE:      y_ogt_inverse:
 
593
; UNSAFE-NEXT: movsd  {{[^,]*}}, %xmm1
 
594
; UNSAFE-NEXT: minsd  %xmm0, %xmm1
 
595
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
596
; UNSAFE-NEXT: ret
 
597
; FINITE:      y_ogt_inverse:
 
598
; FINITE-NEXT: movsd  {{[^,]*}}, %xmm1
 
599
; FINITE-NEXT: minsd  %xmm0, %xmm1
 
600
; FINITE-NEXT: movapd %xmm1, %xmm0
 
601
; FINITE-NEXT: ret
 
602
define double @y_ogt_inverse(double %x) nounwind {
 
603
  %c = fcmp ogt double %x, -0.000000e+00
 
604
  %d = select i1 %c, double -0.000000e+00, double %x
 
605
  ret double %d
 
606
}
 
607
 
 
608
; CHECK:      y_olt_inverse:
 
609
; CHECK-NEXT: movsd  {{[^,]*}}, %xmm1
 
610
; CHECK-NEXT: maxsd  %xmm0, %xmm1
 
611
; CHECK-NEXT: movapd %xmm1, %xmm0
 
612
; CHECK-NEXT: ret
 
613
; UNSAFE:      y_olt_inverse:
 
614
; UNSAFE-NEXT: movsd  {{[^,]*}}, %xmm1
 
615
; UNSAFE-NEXT: maxsd  %xmm0, %xmm1
 
616
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
617
; UNSAFE-NEXT: ret
 
618
; FINITE:      y_olt_inverse:
 
619
; FINITE-NEXT: movsd  {{[^,]*}}, %xmm1
 
620
; FINITE-NEXT: maxsd  %xmm0, %xmm1
 
621
; FINITE-NEXT: movapd %xmm1, %xmm0
 
622
; FINITE-NEXT: ret
 
623
define double @y_olt_inverse(double %x) nounwind {
 
624
  %c = fcmp olt double %x, -0.000000e+00
 
625
  %d = select i1 %c, double -0.000000e+00, double %x
 
626
  ret double %d
 
627
}
 
628
 
 
629
; CHECK:      y_oge:
 
630
; CHECK:      ucomisd %xmm1, %xmm0
 
631
; UNSAFE:      y_oge:
 
632
; UNSAFE-NEXT: maxsd   {{[^,]*}}, %xmm0
 
633
; UNSAFE-NEXT: ret
 
634
; FINITE:      y_oge:
 
635
; FINITE-NEXT: maxsd   {{[^,]*}}, %xmm0
 
636
; FINITE-NEXT: ret
 
637
define double @y_oge(double %x) nounwind {
 
638
  %c = fcmp oge double %x, -0.000000e+00
 
639
  %d = select i1 %c, double %x, double -0.000000e+00
 
640
  ret double %d
 
641
}
 
642
 
 
643
; CHECK:      y_ole:
 
644
; CHECK:      ucomisd %xmm0, %xmm1
 
645
; UNSAFE:      y_ole:
 
646
; UNSAFE-NEXT: minsd {{[^,]*}}, %xmm0
 
647
; UNSAFE-NEXT: ret
 
648
; FINITE:      y_ole:
 
649
; FINITE-NEXT: minsd {{[^,]*}}, %xmm0
 
650
; FINITE-NEXT: ret
 
651
define double @y_ole(double %x) nounwind {
 
652
  %c = fcmp ole double %x, -0.000000e+00
 
653
  %d = select i1 %c, double %x, double -0.000000e+00
 
654
  ret double %d
 
655
}
 
656
 
 
657
; CHECK:      y_oge_inverse:
 
658
; CHECK:      ucomisd %xmm1, %xmm0
 
659
; UNSAFE:      y_oge_inverse:
 
660
; UNSAFE-NEXT: movsd   {{[^,]*}}, %xmm1
 
661
; UNSAFE-NEXT: minsd   %xmm0, %xmm1
 
662
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
663
; UNSAFE-NEXT: ret
 
664
; FINITE:      y_oge_inverse:
 
665
; FINITE-NEXT: movsd   {{[^,]*}}, %xmm1
 
666
; FINITE-NEXT: minsd   %xmm0, %xmm1
 
667
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
668
; FINITE-NEXT: ret
 
669
define double @y_oge_inverse(double %x) nounwind {
 
670
  %c = fcmp oge double %x, -0.000000e+00
 
671
  %d = select i1 %c, double -0.000000e+00, double %x
 
672
  ret double %d
 
673
}
 
674
 
 
675
; CHECK:      y_ole_inverse:
 
676
; CHECK:      ucomisd %xmm0, %xmm1
 
677
; UNSAFE:      y_ole_inverse:
 
678
; UNSAFE-NEXT: movsd   {{[^,]*}}, %xmm1
 
679
; UNSAFE-NEXT: maxsd   %xmm0, %xmm1
 
680
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
681
; UNSAFE-NEXT: ret
 
682
; FINITE:      y_ole_inverse:
 
683
; FINITE-NEXT: movsd   {{[^,]*}}, %xmm1
 
684
; FINITE-NEXT: maxsd   %xmm0, %xmm1
 
685
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
686
; FINITE-NEXT: ret
 
687
define double @y_ole_inverse(double %x) nounwind {
 
688
  %c = fcmp ole double %x, -0.000000e+00
 
689
  %d = select i1 %c, double -0.000000e+00, double %x
 
690
  ret double %d
 
691
}
 
692
 
 
693
; CHECK:      y_ugt:
 
694
; CHECK:      ucomisd %xmm0, %xmm1
 
695
; UNSAFE:      y_ugt:
 
696
; UNSAFE-NEXT: maxsd   {{[^,]*}}, %xmm0
 
697
; UNSAFE-NEXT: ret
 
698
; FINITE:      y_ugt:
 
699
; FINITE-NEXT: maxsd   {{[^,]*}}, %xmm0
 
700
; FINITE-NEXT: ret
 
701
define double @y_ugt(double %x) nounwind {
 
702
  %c = fcmp ugt double %x, -0.000000e+00
 
703
  %d = select i1 %c, double %x, double -0.000000e+00
 
704
  ret double %d
 
705
}
 
706
 
 
707
; CHECK:      y_ult:
 
708
; CHECK:      ucomisd %xmm1, %xmm0
 
709
; UNSAFE:      y_ult:
 
710
; UNSAFE-NEXT: minsd   {{[^,]*}}, %xmm0
 
711
; UNSAFE-NEXT: ret
 
712
; FINITE:      y_ult:
 
713
; FINITE-NEXT: minsd   {{[^,]*}}, %xmm0
 
714
; FINITE-NEXT: ret
 
715
define double @y_ult(double %x) nounwind {
 
716
  %c = fcmp ult double %x, -0.000000e+00
 
717
  %d = select i1 %c, double %x, double -0.000000e+00
 
718
  ret double %d
 
719
}
 
720
 
 
721
; CHECK:      y_ugt_inverse:
 
722
; CHECK:      ucomisd %xmm0, %xmm1
 
723
; UNSAFE:      y_ugt_inverse:
 
724
; UNSAFE-NEXT: movsd   {{[^,]*}}, %xmm1
 
725
; UNSAFE-NEXT: minsd   %xmm0, %xmm1
 
726
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
727
; UNSAFE-NEXT: ret
 
728
; FINITE:      y_ugt_inverse:
 
729
; FINITE-NEXT: movsd   {{[^,]*}}, %xmm1
 
730
; FINITE-NEXT: minsd   %xmm0, %xmm1
 
731
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
732
; FINITE-NEXT: ret
 
733
define double @y_ugt_inverse(double %x) nounwind {
 
734
  %c = fcmp ugt double %x, -0.000000e+00
 
735
  %d = select i1 %c, double -0.000000e+00, double %x
 
736
  ret double %d
 
737
}
 
738
 
 
739
; CHECK:      y_ult_inverse:
 
740
; CHECK:      ucomisd %xmm1, %xmm0
 
741
; UNSAFE:      y_ult_inverse:
 
742
; UNSAFE-NEXT: movsd   {{[^,]*}}, %xmm1
 
743
; UNSAFE-NEXT: maxsd   %xmm0, %xmm1
 
744
; UNSAFE-NEXT: movapd  %xmm1, %xmm0
 
745
; UNSAFE-NEXT: ret
 
746
; FINITE:      y_ult_inverse:
 
747
; FINITE-NEXT: movsd   {{[^,]*}}, %xmm1
 
748
; FINITE-NEXT: maxsd   %xmm0, %xmm1
 
749
; FINITE-NEXT: movapd  %xmm1, %xmm0
 
750
; FINITE-NEXT: ret
 
751
define double @y_ult_inverse(double %x) nounwind {
 
752
  %c = fcmp ult double %x, -0.000000e+00
 
753
  %d = select i1 %c, double -0.000000e+00, double %x
 
754
  ret double %d
 
755
}
 
756
 
 
757
; CHECK:      y_uge:
 
758
; CHECK-NEXT: movsd  {{[^,]*}}, %xmm1
 
759
; CHECK-NEXT: maxsd  %xmm0, %xmm1
 
760
; CHECK-NEXT: movapd %xmm1, %xmm0
 
761
; CHECK-NEXT: ret
 
762
; UNSAFE:      y_uge:
 
763
; UNSAFE-NEXT: maxsd  {{[^,]*}}, %xmm0
 
764
; UNSAFE-NEXT: ret
 
765
; FINITE:      y_uge:
 
766
; FINITE-NEXT: maxsd  {{[^,]*}}, %xmm0
 
767
; FINITE-NEXT: ret
 
768
define double @y_uge(double %x) nounwind {
 
769
  %c = fcmp uge double %x, -0.000000e+00
 
770
  %d = select i1 %c, double %x, double -0.000000e+00
 
771
  ret double %d
 
772
}
 
773
 
 
774
; CHECK:      y_ule:
 
775
; CHECK-NEXT: movsd  {{[^,]*}}, %xmm1
 
776
; CHECK-NEXT: minsd  %xmm0, %xmm1
 
777
; CHECK-NEXT: movapd %xmm1, %xmm0
 
778
; CHECK-NEXT: ret
 
779
; UNSAFE:      y_ule:
 
780
; UNSAFE-NEXT: minsd  {{[^,]*}}, %xmm0
 
781
; UNSAFE-NEXT: ret
 
782
; FINITE:      y_ule:
 
783
; FINITE-NEXT: minsd  {{[^,]*}}, %xmm0
 
784
; FINITE-NEXT: ret
 
785
define double @y_ule(double %x) nounwind {
 
786
  %c = fcmp ule double %x, -0.000000e+00
 
787
  %d = select i1 %c, double %x, double -0.000000e+00
 
788
  ret double %d
 
789
}
 
790
 
 
791
; CHECK:      y_uge_inverse:
 
792
; CHECK-NEXT: minsd {{[^,]*}}, %xmm0
 
793
; CHECK-NEXT: ret
 
794
; UNSAFE:      y_uge_inverse:
 
795
; UNSAFE-NEXT: movsd {{[^,]*}}, %xmm1
 
796
; UNSAFE-NEXT: minsd %xmm0, %xmm1
 
797
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
798
; UNSAFE-NEXT: ret
 
799
; FINITE:      y_uge_inverse:
 
800
; FINITE-NEXT: movsd {{[^,]*}}, %xmm1
 
801
; FINITE-NEXT: minsd %xmm0, %xmm1
 
802
; FINITE-NEXT: movapd %xmm1, %xmm0
 
803
; FINITE-NEXT: ret
 
804
define double @y_uge_inverse(double %x) nounwind {
 
805
  %c = fcmp uge double %x, -0.000000e+00
 
806
  %d = select i1 %c, double -0.000000e+00, double %x
 
807
  ret double %d
 
808
}
 
809
 
 
810
; CHECK:      y_ule_inverse:
 
811
; CHECK-NEXT: maxsd {{[^,]*}}, %xmm0
 
812
; CHECK-NEXT: ret
 
813
; UNSAFE:      y_ule_inverse:
 
814
; UNSAFE-NEXT: movsd {{[^,]*}}, %xmm1
 
815
; UNSAFE-NEXT: maxsd %xmm0, %xmm1
 
816
; UNSAFE-NEXT: movapd %xmm1, %xmm0
 
817
; UNSAFE-NEXT: ret
 
818
; FINITE:      y_ule_inverse:
 
819
; FINITE-NEXT: movsd {{[^,]*}}, %xmm1
 
820
; FINITE-NEXT: maxsd %xmm0, %xmm1
 
821
; FINITE-NEXT: movapd %xmm1, %xmm0
 
822
; FINITE-NEXT: ret
 
823
define double @y_ule_inverse(double %x) nounwind {
 
824
  %c = fcmp ule double %x, -0.000000e+00
 
825
  %d = select i1 %c, double -0.000000e+00, double %x
 
826
  ret double %d
 
827
}
 
828
; Test a few more misc. cases.
 
829
 
 
830
; CHECK: clampTo3k_a:
 
831
; CHECK: minsd
 
832
; UNSAFE: clampTo3k_a:
 
833
; UNSAFE: minsd
 
834
; FINITE: clampTo3k_a:
 
835
; FINITE: minsd
 
836
define double @clampTo3k_a(double %x) nounwind readnone {
 
837
entry:
 
838
  %0 = fcmp ogt double %x, 3.000000e+03           ; <i1> [#uses=1]
 
839
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
840
  ret double %x_addr.0
 
841
}
 
842
 
 
843
; CHECK: clampTo3k_b:
 
844
; CHECK: minsd
 
845
; UNSAFE: clampTo3k_b:
 
846
; UNSAFE: minsd
 
847
; FINITE: clampTo3k_b:
 
848
; FINITE: minsd
 
849
define double @clampTo3k_b(double %x) nounwind readnone {
 
850
entry:
 
851
  %0 = fcmp uge double %x, 3.000000e+03           ; <i1> [#uses=1]
 
852
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
853
  ret double %x_addr.0
 
854
}
 
855
 
 
856
; CHECK: clampTo3k_c:
 
857
; CHECK: maxsd
 
858
; UNSAFE: clampTo3k_c:
 
859
; UNSAFE: maxsd
 
860
; FINITE: clampTo3k_c:
 
861
; FINITE: maxsd
 
862
define double @clampTo3k_c(double %x) nounwind readnone {
 
863
entry:
 
864
  %0 = fcmp olt double %x, 3.000000e+03           ; <i1> [#uses=1]
 
865
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
866
  ret double %x_addr.0
 
867
}
 
868
 
 
869
; CHECK: clampTo3k_d:
 
870
; CHECK: maxsd
 
871
; UNSAFE: clampTo3k_d:
 
872
; UNSAFE: maxsd
 
873
; FINITE: clampTo3k_d:
 
874
; FINITE: maxsd
 
875
define double @clampTo3k_d(double %x) nounwind readnone {
 
876
entry:
 
877
  %0 = fcmp ule double %x, 3.000000e+03           ; <i1> [#uses=1]
 
878
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
879
  ret double %x_addr.0
 
880
}
 
881
 
 
882
; CHECK: clampTo3k_e:
 
883
; CHECK: maxsd
 
884
; UNSAFE: clampTo3k_e:
 
885
; UNSAFE: maxsd
 
886
; FINITE: clampTo3k_e:
 
887
; FINITE: maxsd
 
888
define double @clampTo3k_e(double %x) nounwind readnone {
 
889
entry:
 
890
  %0 = fcmp olt double %x, 3.000000e+03           ; <i1> [#uses=1]
 
891
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
892
  ret double %x_addr.0
 
893
}
 
894
 
 
895
; CHECK: clampTo3k_f:
 
896
; CHECK: maxsd
 
897
; UNSAFE: clampTo3k_f:
 
898
; UNSAFE: maxsd
 
899
; FINITE: clampTo3k_f:
 
900
; FINITE: maxsd
 
901
define double @clampTo3k_f(double %x) nounwind readnone {
 
902
entry:
 
903
  %0 = fcmp ule double %x, 3.000000e+03           ; <i1> [#uses=1]
 
904
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
905
  ret double %x_addr.0
 
906
}
 
907
 
 
908
; CHECK: clampTo3k_g:
 
909
; CHECK: minsd
 
910
; UNSAFE: clampTo3k_g:
 
911
; UNSAFE: minsd
 
912
; FINITE: clampTo3k_g:
 
913
; FINITE: minsd
 
914
define double @clampTo3k_g(double %x) nounwind readnone {
 
915
entry:
 
916
  %0 = fcmp ogt double %x, 3.000000e+03           ; <i1> [#uses=1]
 
917
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
918
  ret double %x_addr.0
 
919
}
 
920
 
 
921
; CHECK: clampTo3k_h:
 
922
; CHECK: minsd
 
923
; UNSAFE: clampTo3k_h:
 
924
; UNSAFE: minsd
 
925
; FINITE: clampTo3k_h:
 
926
; FINITE: minsd
 
927
define double @clampTo3k_h(double %x) nounwind readnone {
 
928
entry:
 
929
  %0 = fcmp uge double %x, 3.000000e+03           ; <i1> [#uses=1]
 
930
  %x_addr.0 = select i1 %0, double 3.000000e+03, double %x ; <double> [#uses=1]
 
931
  ret double %x_addr.0
 
932
}