OSDN Git Service

* config/i386/sse.md (xop_phaddbq): Fix vec_select selectors.
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / sse.md
1 ;; GCC machine description for SSE instructions
2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 ;; Free Software Foundation, Inc.
4 ;;
5 ;; This file is part of GCC.
6 ;;
7 ;; GCC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 3, or (at your option)
10 ;; any later version.
11 ;;
12 ;; GCC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 ;; GNU General Public License for more details.
16 ;;
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING3.  If not see
19 ;; <http://www.gnu.org/licenses/>.
20
21 (define_c_enum "unspec" [
22   ;; SSE
23   UNSPEC_MOVNT
24   UNSPEC_MOVU
25
26   ;; SSE3
27   UNSPEC_LDDQU
28
29   ;; SSSE3
30   UNSPEC_PSHUFB
31   UNSPEC_PSIGN
32   UNSPEC_PALIGNR
33
34   ;; For SSE4A support
35   UNSPEC_EXTRQI
36   UNSPEC_EXTRQ
37   UNSPEC_INSERTQI
38   UNSPEC_INSERTQ
39
40   ;; For SSE4.1 support
41   UNSPEC_BLENDV
42   UNSPEC_INSERTPS
43   UNSPEC_DP
44   UNSPEC_MOVNTDQA
45   UNSPEC_MPSADBW
46   UNSPEC_PHMINPOSUW
47   UNSPEC_PTEST
48
49   ;; For SSE4.2 support
50   UNSPEC_PCMPESTR
51   UNSPEC_PCMPISTR
52
53   ;; For FMA4 support
54   UNSPEC_FMADDSUB
55   UNSPEC_XOP_UNSIGNED_CMP
56   UNSPEC_XOP_TRUEFALSE
57   UNSPEC_XOP_PERMUTE
58   UNSPEC_FRCZ
59
60   ;; For AES support
61   UNSPEC_AESENC
62   UNSPEC_AESENCLAST
63   UNSPEC_AESDEC
64   UNSPEC_AESDECLAST
65   UNSPEC_AESIMC
66   UNSPEC_AESKEYGENASSIST
67
68   ;; For PCLMUL support
69   UNSPEC_PCLMUL
70
71   ;; For AVX support
72   UNSPEC_PCMP
73   UNSPEC_VPERMIL
74   UNSPEC_VPERMIL2
75   UNSPEC_VPERMIL2F128
76   UNSPEC_CAST
77   UNSPEC_VTESTP
78   UNSPEC_VCVTPH2PS
79   UNSPEC_VCVTPS2PH
80
81   ;; For AVX2 support
82   UNSPEC_VPERMSI
83   UNSPEC_VPERMDF
84   UNSPEC_VPERMSF
85   UNSPEC_VPERMTI
86   UNSPEC_GATHER
87   UNSPEC_VSIBADDR
88 ])
89
90 (define_c_enum "unspecv" [
91   UNSPECV_LDMXCSR
92   UNSPECV_STMXCSR
93   UNSPECV_CLFLUSH
94   UNSPECV_MONITOR
95   UNSPECV_MWAIT
96   UNSPECV_VZEROALL
97   UNSPECV_VZEROUPPER
98 ])
99
100 ;; All vector modes including V?TImode, used in move patterns.
101 (define_mode_iterator V16
102   [(V32QI "TARGET_AVX") V16QI
103    (V16HI "TARGET_AVX") V8HI
104    (V8SI "TARGET_AVX") V4SI
105    (V4DI "TARGET_AVX") V2DI
106    (V2TI "TARGET_AVX") V1TI
107    (V8SF "TARGET_AVX") V4SF
108    (V4DF "TARGET_AVX") V2DF])
109
110 ;; All vector modes
111 (define_mode_iterator V
112   [(V32QI "TARGET_AVX") V16QI
113    (V16HI "TARGET_AVX") V8HI
114    (V8SI "TARGET_AVX") V4SI
115    (V4DI "TARGET_AVX") V2DI
116    (V8SF "TARGET_AVX") V4SF
117    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
118
119 ;; All 128bit vector modes
120 (define_mode_iterator V_128
121   [V16QI V8HI V4SI V2DI V4SF (V2DF "TARGET_SSE2")])
122
123 ;; All 256bit vector modes
124 (define_mode_iterator V_256
125   [V32QI V16HI V8SI V4DI V8SF V4DF])
126
127 ;; All vector float modes
128 (define_mode_iterator VF
129   [(V8SF "TARGET_AVX") V4SF
130    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
131
132 ;; All SFmode vector float modes
133 (define_mode_iterator VF1
134   [(V8SF "TARGET_AVX") V4SF])
135
136 ;; All DFmode vector float modes
137 (define_mode_iterator VF2
138   [(V4DF "TARGET_AVX") V2DF])
139
140 ;; All 128bit vector float modes
141 (define_mode_iterator VF_128
142   [V4SF (V2DF "TARGET_SSE2")])
143
144 ;; All 256bit vector float modes
145 (define_mode_iterator VF_256
146   [V8SF V4DF])
147
148 ;; All vector integer modes
149 (define_mode_iterator VI
150   [(V32QI "TARGET_AVX") V16QI
151    (V16HI "TARGET_AVX") V8HI
152    (V8SI "TARGET_AVX") V4SI
153    (V4DI "TARGET_AVX") V2DI])
154
155 (define_mode_iterator VI_AVX2
156   [(V32QI "TARGET_AVX2") V16QI
157    (V16HI "TARGET_AVX2") V8HI
158    (V8SI "TARGET_AVX2") V4SI
159    (V4DI "TARGET_AVX2") V2DI])
160
161 ;; All QImode vector integer modes
162 (define_mode_iterator VI1
163   [(V32QI "TARGET_AVX") V16QI])
164
165 ;; All DImode vector integer modes
166 (define_mode_iterator VI8
167   [(V4DI "TARGET_AVX") V2DI])
168
169 (define_mode_iterator VI1_AVX2
170   [(V32QI "TARGET_AVX2") V16QI])
171
172 (define_mode_iterator VI2_AVX2
173   [(V16HI "TARGET_AVX2") V8HI])
174
175 (define_mode_iterator VI4_AVX2
176   [(V8SI "TARGET_AVX2") V4SI])
177
178 (define_mode_iterator VI8_AVX2
179   [(V4DI "TARGET_AVX2") V2DI])
180
181 ;; ??? We should probably use TImode instead.
182 (define_mode_iterator VIMAX_AVX2
183   [(V2TI "TARGET_AVX2") V1TI])
184
185 ;; ??? This should probably be dropped in favor of VIMAX_AVX2.
186 (define_mode_iterator SSESCALARMODE
187   [(V2TI "TARGET_AVX2") TI])
188
189 (define_mode_iterator VI12_AVX2
190   [(V32QI "TARGET_AVX2") V16QI
191    (V16HI "TARGET_AVX2") V8HI])
192
193 (define_mode_iterator VI24_AVX2
194   [(V16HI "TARGET_AVX2") V8HI
195    (V8SI "TARGET_AVX2") V4SI])
196
197 (define_mode_iterator VI124_AVX2
198   [(V32QI "TARGET_AVX2") V16QI
199    (V16HI "TARGET_AVX2") V8HI
200    (V8SI "TARGET_AVX2") V4SI])
201
202 (define_mode_iterator VI248_AVX2
203   [(V16HI "TARGET_AVX2") V8HI
204    (V8SI "TARGET_AVX2") V4SI
205    (V4DI "TARGET_AVX2") V2DI])
206
207 (define_mode_iterator VI48_AVX2
208   [(V8SI "TARGET_AVX2") V4SI
209    (V4DI "TARGET_AVX2") V2DI])
210
211 (define_mode_iterator V48_AVX2
212   [V4SF V2DF
213    V8SF V4DF
214    (V4SI "TARGET_AVX2") (V2DI "TARGET_AVX2")
215    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")])
216
217 (define_mode_attr sse2_avx2
218   [(V16QI "sse2") (V32QI "avx2")
219    (V8HI "sse2") (V16HI "avx2")
220    (V4SI "sse2") (V8SI "avx2")
221    (V2DI "sse2") (V4DI "avx2")
222    (V1TI "sse2") (V2TI "avx2")])
223
224 (define_mode_attr ssse3_avx2
225    [(V16QI "ssse3") (V32QI "avx2")
226     (V8HI "ssse3") (V16HI "avx2")
227     (V4SI "ssse3") (V8SI "avx2")
228     (V2DI "ssse3") (V4DI "avx2")
229     (TI "ssse3") (V2TI "avx2")])
230
231 (define_mode_attr sse4_1_avx2
232    [(V16QI "sse4_1") (V32QI "avx2")
233     (V8HI "sse4_1") (V16HI "avx2")
234     (V4SI "sse4_1") (V8SI "avx2")
235     (V2DI "sse4_1") (V4DI "avx2")])
236
237 (define_mode_attr avx_avx2
238   [(V4SF "avx") (V2DF "avx")
239    (V8SF "avx") (V4DF "avx")
240    (V4SI "avx2") (V2DI "avx2")
241    (V8SI "avx2") (V4DI "avx2")])
242
243 (define_mode_attr vec_avx2
244   [(V16QI "vec") (V32QI "avx2")
245    (V8HI "vec") (V16HI "avx2")
246    (V4SI "vec") (V8SI "avx2")
247    (V2DI "vec") (V4DI "avx2")])
248
249 (define_mode_attr ssedoublemode
250   [(V16HI "V16SI") (V8HI "V8SI")])
251
252 (define_mode_attr ssebytemode
253   [(V4DI "V32QI") (V2DI "V16QI")])
254
255 ;; All 128bit vector integer modes
256 (define_mode_iterator VI_128 [V16QI V8HI V4SI V2DI])
257
258 ;; All 256bit vector integer modes
259 (define_mode_iterator VI_256 [V32QI V16HI V8SI V4DI])
260
261 ;; Random 128bit vector integer mode combinations
262 (define_mode_iterator VI12_128 [V16QI V8HI])
263 (define_mode_iterator VI14_128 [V16QI V4SI])
264 (define_mode_iterator VI124_128 [V16QI V8HI V4SI])
265 (define_mode_iterator VI128_128 [V16QI V8HI V2DI])
266 (define_mode_iterator VI24_128 [V8HI V4SI])
267 (define_mode_iterator VI248_128 [V8HI V4SI V2DI])
268 (define_mode_iterator VI48_128 [V4SI V2DI])
269
270 ;; Random 256bit vector integer mode combinations
271 (define_mode_iterator VI124_256 [V32QI V16HI V8SI])
272 (define_mode_iterator VI48_256 [V8SI V4DI])
273
274 ;; Int-float size matches
275 (define_mode_iterator VI4F_128 [V4SI V4SF])
276 (define_mode_iterator VI8F_128 [V2DI V2DF])
277 (define_mode_iterator VI4F_256 [V8SI V8SF])
278 (define_mode_iterator VI8F_256 [V4DI V4DF])
279
280 ;; Mapping from float mode to required SSE level
281 (define_mode_attr sse
282   [(SF "sse") (DF "sse2")
283    (V4SF "sse") (V2DF "sse2")
284    (V8SF "avx") (V4DF "avx")])
285
286 (define_mode_attr sse2
287   [(V16QI "sse2") (V32QI "avx")
288    (V2DI "sse2") (V4DI "avx")])
289
290 (define_mode_attr sse3
291   [(V16QI "sse3") (V32QI "avx")])
292
293 (define_mode_attr sse4_1
294   [(V4SF "sse4_1") (V2DF "sse4_1")
295    (V8SF "avx") (V4DF "avx")])
296
297 (define_mode_attr avxsizesuffix
298   [(V32QI "256") (V16HI "256") (V8SI "256") (V4DI "256")
299    (V16QI "") (V8HI "") (V4SI "") (V2DI "")
300    (V8SF "256") (V4DF "256")
301    (V4SF "") (V2DF "")])
302
303 ;; SSE instruction mode
304 (define_mode_attr sseinsnmode
305   [(V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI") (V2TI "OI")
306    (V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
307    (V8SF "V8SF") (V4DF "V4DF")
308    (V4SF "V4SF") (V2DF "V2DF")
309    (TI "TI")])
310
311 ;; Mapping of vector float modes to an integer mode of the same size
312 (define_mode_attr sseintvecmode
313   [(V8SF "V8SI") (V4DF "V4DI")
314    (V4SF "V4SI") (V2DF "V2DI")
315    (V8SI "V8SI") (V4DI "V4DI")
316    (V4SI "V4SI") (V2DI "V2DI")
317    (V16HI "V16HI") (V8HI "V8HI")
318    (V32QI "V32QI") (V16QI "V16QI")])
319
320 (define_mode_attr sseintvecmodelower
321   [(V8SF "v8si") (V4DF "v4di")
322    (V4SF "v4si") (V2DF "v2di")
323    (V8SI "v8si") (V4DI "v4di")
324    (V4SI "v4si") (V2DI "v2di")
325    (V16HI "v16hi") (V8HI "v8hi")
326    (V32QI "v32qi") (V16QI "v16qi")])
327
328 ;; Mapping of vector modes to a vector mode of double size
329 (define_mode_attr ssedoublevecmode
330   [(V32QI "V64QI") (V16HI "V32HI") (V8SI "V16SI") (V4DI "V8DI")
331    (V16QI "V32QI") (V8HI "V16HI") (V4SI "V8SI") (V2DI "V4DI")
332    (V8SF "V16SF") (V4DF "V8DF")
333    (V4SF "V8SF") (V2DF "V4DF")])
334
335 ;; Mapping of vector modes to a vector mode of half size
336 (define_mode_attr ssehalfvecmode
337   [(V32QI "V16QI") (V16HI "V8HI") (V8SI "V4SI") (V4DI "V2DI")
338    (V16QI  "V8QI") (V8HI  "V4HI") (V4SI "V2SI")
339    (V8SF "V4SF") (V4DF "V2DF")
340    (V4SF "V2SF")])
341
342 ;; Mapping of vector modes back to the scalar modes
343 (define_mode_attr ssescalarmode
344   [(V32QI "QI") (V16HI "HI") (V8SI "SI") (V4DI "DI")
345    (V16QI "QI") (V8HI "HI") (V4SI "SI") (V2DI "DI")
346    (V8SF "SF") (V4DF "DF")
347    (V4SF "SF") (V2DF "DF")])
348
349 ;; Number of scalar elements in each vector type
350 (define_mode_attr ssescalarnum
351   [(V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")
352    (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
353    (V8SF "8") (V4DF "4")
354    (V4SF "4") (V2DF "2")])
355
356 ;; SSE prefix for integer vector modes
357 (define_mode_attr sseintprefix
358   [(V2DI "p") (V2DF "")
359    (V4DI "p") (V4DF "")
360    (V4SI "p") (V4SF "")
361    (V8SI "p") (V8SF "")])
362
363 ;; SSE scalar suffix for vector modes
364 (define_mode_attr ssescalarmodesuffix
365   [(SF "ss") (DF "sd")
366    (V8SF "ss") (V4DF "sd")
367    (V4SF "ss") (V2DF "sd")
368    (V8SI "ss") (V4DI "sd")
369    (V4SI "d")])
370
371 ;; Pack/unpack vector modes
372 (define_mode_attr sseunpackmode
373   [(V16QI "V8HI") (V8HI "V4SI") (V4SI "V2DI")
374    (V32QI "V16HI") (V16HI "V8SI") (V8SI "V4DI")])
375
376 (define_mode_attr ssepackmode
377   [(V8HI "V16QI") (V4SI "V8HI") (V2DI "V4SI")
378    (V16HI "V32QI") (V8SI "V16HI") (V4DI "V8SI")])
379
380 ;; Mapping of the max integer size for xop rotate immediate constraint
381 (define_mode_attr sserotatemax
382   [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
383
384 ;; Mapping of mode to cast intrinsic name
385 (define_mode_attr castmode [(V8SI "si") (V8SF "ps") (V4DF "pd")])
386
387 ;; Instruction suffix for sign and zero extensions.
388 (define_code_attr extsuffix [(sign_extend "sx") (zero_extend "zx")])
389
390 ;; i128 for integer vectors and TARGET_AVX2, f128 otherwise.
391 (define_mode_attr i128
392   [(V8SF "f128") (V4DF "f128") (V32QI "%~128") (V16HI "%~128")
393    (V8SI "%~128") (V4DI "%~128")])
394
395 ;; Mix-n-match
396 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
397
398 (define_mode_iterator FMAMODE [SF DF V4SF V2DF V8SF V4DF])
399
400 ;; Mapping of immediate bits for blend instructions
401 (define_mode_attr blendbits
402   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
403
404 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
405
406 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
407 ;;
408 ;; Move patterns
409 ;;
410 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
411
412 ;; All of these patterns are enabled for SSE1 as well as SSE2.
413 ;; This is essential for maintaining stable calling conventions.
414
415 (define_expand "mov<mode>"
416   [(set (match_operand:V16 0 "nonimmediate_operand" "")
417         (match_operand:V16 1 "nonimmediate_operand" ""))]
418   "TARGET_SSE"
419 {
420   ix86_expand_vector_move (<MODE>mode, operands);
421   DONE;
422 })
423
424 (define_insn "*mov<mode>_internal"
425   [(set (match_operand:V16 0 "nonimmediate_operand" "=x,x ,m")
426         (match_operand:V16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
427   "TARGET_SSE
428    && (register_operand (operands[0], <MODE>mode)
429        || register_operand (operands[1], <MODE>mode))"
430 {
431   switch (which_alternative)
432     {
433     case 0:
434       return standard_sse_constant_opcode (insn, operands[1]);
435     case 1:
436     case 2:
437       switch (get_attr_mode (insn))
438         {
439         case MODE_V8SF:
440         case MODE_V4SF:
441           if (TARGET_AVX
442               && (misaligned_operand (operands[0], <MODE>mode)
443                   || misaligned_operand (operands[1], <MODE>mode)))
444             return "vmovups\t{%1, %0|%0, %1}";
445           else
446             return "%vmovaps\t{%1, %0|%0, %1}";
447
448         case MODE_V4DF:
449         case MODE_V2DF:
450           if (TARGET_AVX
451               && (misaligned_operand (operands[0], <MODE>mode)
452                   || misaligned_operand (operands[1], <MODE>mode)))
453             return "vmovupd\t{%1, %0|%0, %1}";
454           else if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
455             return "%vmovaps\t{%1, %0|%0, %1}";
456           else
457             return "%vmovapd\t{%1, %0|%0, %1}";
458
459         case MODE_OI:
460         case MODE_TI:
461           if (TARGET_AVX
462               && (misaligned_operand (operands[0], <MODE>mode)
463                   || misaligned_operand (operands[1], <MODE>mode)))
464             return "vmovdqu\t{%1, %0|%0, %1}";
465           else if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
466             return "%vmovaps\t{%1, %0|%0, %1}";
467           else
468             return "%vmovdqa\t{%1, %0|%0, %1}";
469
470         default:
471           gcc_unreachable ();
472         }
473     default:
474       gcc_unreachable ();
475     }
476 }
477   [(set_attr "type" "sselog1,ssemov,ssemov")
478    (set_attr "prefix" "maybe_vex")
479    (set (attr "mode")
480         (cond [(match_test "TARGET_AVX")
481                  (const_string "<sseinsnmode>")
482                (ior (ior (match_test "optimize_function_for_size_p (cfun)")
483                          (not (match_test "TARGET_SSE2")))
484                     (and (eq_attr "alternative" "2")
485                          (match_test "TARGET_SSE_TYPELESS_STORES")))
486                  (const_string "V4SF")
487                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
488                  (const_string "V4SF")
489                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
490                  (const_string "V2DF")
491               ]
492           (const_string "TI")))])
493
494 (define_insn "sse2_movq128"
495   [(set (match_operand:V2DI 0 "register_operand" "=x")
496         (vec_concat:V2DI
497           (vec_select:DI
498             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
499             (parallel [(const_int 0)]))
500           (const_int 0)))]
501   "TARGET_SSE2"
502   "%vmovq\t{%1, %0|%0, %1}"
503   [(set_attr "type" "ssemov")
504    (set_attr "prefix" "maybe_vex")
505    (set_attr "mode" "TI")])
506
507 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
508 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
509 ;; from memory, we'd prefer to load the memory directly into the %xmm
510 ;; register.  To facilitate this happy circumstance, this pattern won't
511 ;; split until after register allocation.  If the 64-bit value didn't
512 ;; come from memory, this is the best we can do.  This is much better
513 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
514 ;; from there.
515
516 (define_insn_and_split "movdi_to_sse"
517   [(parallel
518     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
519           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
520      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
521   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
522   "#"
523   "&& reload_completed"
524   [(const_int 0)]
525 {
526  if (register_operand (operands[1], DImode))
527    {
528       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
529          Assemble the 64-bit DImode value in an xmm register.  */
530       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
531                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
532       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
533                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
534       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
535                                              operands[2]));
536     }
537  else if (memory_operand (operands[1], DImode))
538    emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]),
539                                   operands[1], const0_rtx));
540  else
541    gcc_unreachable ();
542 })
543
544 (define_split
545   [(set (match_operand:V4SF 0 "register_operand" "")
546         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
547   "TARGET_SSE && reload_completed"
548   [(set (match_dup 0)
549         (vec_merge:V4SF
550           (vec_duplicate:V4SF (match_dup 1))
551           (match_dup 2)
552           (const_int 1)))]
553 {
554   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
555   operands[2] = CONST0_RTX (V4SFmode);
556 })
557
558 (define_split
559   [(set (match_operand:V2DF 0 "register_operand" "")
560         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
561   "TARGET_SSE2 && reload_completed"
562   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
563 {
564   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
565   operands[2] = CONST0_RTX (DFmode);
566 })
567
568 (define_expand "push<mode>1"
569   [(match_operand:V16 0 "register_operand" "")]
570   "TARGET_SSE"
571 {
572   ix86_expand_push (<MODE>mode, operands[0]);
573   DONE;
574 })
575
576 (define_expand "movmisalign<mode>"
577   [(set (match_operand:V16 0 "nonimmediate_operand" "")
578         (match_operand:V16 1 "nonimmediate_operand" ""))]
579   "TARGET_SSE"
580 {
581   ix86_expand_vector_move_misalign (<MODE>mode, operands);
582   DONE;
583 })
584
585 (define_insn "<sse>_movu<ssemodesuffix><avxsizesuffix>"
586   [(set (match_operand:VF 0 "nonimmediate_operand" "=x,m")
587         (unspec:VF
588           [(match_operand:VF 1 "nonimmediate_operand" "xm,x")]
589           UNSPEC_MOVU))]
590   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
591   "%vmovu<ssemodesuffix>\t{%1, %0|%0, %1}"
592   [(set_attr "type" "ssemov")
593    (set_attr "movu" "1")
594    (set_attr "prefix" "maybe_vex")
595    (set_attr "mode" "<MODE>")])
596
597 (define_insn "<sse2>_movdqu<avxsizesuffix>"
598   [(set (match_operand:VI1 0 "nonimmediate_operand" "=x,m")
599         (unspec:VI1 [(match_operand:VI1 1 "nonimmediate_operand" "xm,x")]
600                     UNSPEC_MOVU))]
601   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
602   "%vmovdqu\t{%1, %0|%0, %1}"
603   [(set_attr "type" "ssemov")
604    (set_attr "movu" "1")
605    (set (attr "prefix_data16")
606      (if_then_else
607        (match_test "TARGET_AVX")
608      (const_string "*")
609      (const_string "1")))
610    (set_attr "prefix" "maybe_vex")
611    (set_attr "mode" "<sseinsnmode>")])
612
613 (define_insn "<sse3>_lddqu<avxsizesuffix>"
614   [(set (match_operand:VI1 0 "register_operand" "=x")
615         (unspec:VI1 [(match_operand:VI1 1 "memory_operand" "m")]
616                     UNSPEC_LDDQU))]
617   "TARGET_SSE3"
618   "%vlddqu\t{%1, %0|%0, %1}"
619   [(set_attr "type" "ssemov")
620    (set_attr "movu" "1")
621    (set (attr "prefix_data16")
622      (if_then_else
623        (match_test "TARGET_AVX")
624      (const_string "*")
625      (const_string "0")))
626    (set (attr "prefix_rep")
627      (if_then_else
628        (match_test "TARGET_AVX")
629      (const_string "*")
630      (const_string "1")))
631    (set_attr "prefix" "maybe_vex")
632    (set_attr "mode" "<sseinsnmode>")])
633
634 (define_insn "sse2_movnti<mode>"
635   [(set (match_operand:SWI48 0 "memory_operand" "=m")
636         (unspec:SWI48 [(match_operand:SWI48 1 "register_operand" "r")]
637                       UNSPEC_MOVNT))]
638   "TARGET_SSE2"
639   "movnti\t{%1, %0|%0, %1}"
640   [(set_attr "type" "ssemov")
641    (set_attr "prefix_data16" "0")
642    (set_attr "mode" "<MODE>")])
643
644 (define_insn "<sse>_movnt<mode>"
645   [(set (match_operand:VF 0 "memory_operand" "=m")
646         (unspec:VF [(match_operand:VF 1 "register_operand" "x")]
647                    UNSPEC_MOVNT))]
648   "TARGET_SSE"
649   "%vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
650   [(set_attr "type" "ssemov")
651    (set_attr "prefix" "maybe_vex")
652    (set_attr "mode" "<MODE>")])
653
654 (define_insn "<sse2>_movnt<mode>"
655   [(set (match_operand:VI8 0 "memory_operand" "=m")
656         (unspec:VI8 [(match_operand:VI8 1 "register_operand" "x")]
657                     UNSPEC_MOVNT))]
658   "TARGET_SSE2"
659   "%vmovntdq\t{%1, %0|%0, %1}"
660   [(set_attr "type" "ssecvt")
661    (set (attr "prefix_data16")
662      (if_then_else
663        (match_test "TARGET_AVX")
664      (const_string "*")
665      (const_string "1")))
666    (set_attr "prefix" "maybe_vex")
667    (set_attr "mode" "<sseinsnmode>")])
668
669 ; Expand patterns for non-temporal stores.  At the moment, only those
670 ; that directly map to insns are defined; it would be possible to
671 ; define patterns for other modes that would expand to several insns.
672
673 ;; Modes handled by storent patterns.
674 (define_mode_iterator STORENT_MODE
675   [(DI "TARGET_SSE2 && TARGET_64BIT") (SI "TARGET_SSE2")
676    (SF "TARGET_SSE4A") (DF "TARGET_SSE4A")
677    (V4DI "TARGET_AVX") (V2DI "TARGET_SSE2")
678    (V8SF "TARGET_AVX") V4SF
679    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
680
681 (define_expand "storent<mode>"
682   [(set (match_operand:STORENT_MODE 0 "memory_operand" "")
683         (unspec:STORENT_MODE
684           [(match_operand:STORENT_MODE 1 "register_operand" "")]
685           UNSPEC_MOVNT))]
686   "TARGET_SSE")
687
688 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
689 ;;
690 ;; Parallel floating point arithmetic
691 ;;
692 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
693
694 (define_expand "<code><mode>2"
695   [(set (match_operand:VF 0 "register_operand" "")
696         (absneg:VF
697           (match_operand:VF 1 "register_operand" "")))]
698   "TARGET_SSE"
699   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
700
701 (define_insn_and_split "*absneg<mode>2"
702   [(set (match_operand:VF 0 "register_operand" "=x,x,x,x")
703         (match_operator:VF 3 "absneg_operator"
704           [(match_operand:VF 1 "nonimmediate_operand" "0, xm,x, m")]))
705    (use (match_operand:VF 2 "nonimmediate_operand"    "xm,0, xm,x"))]
706   "TARGET_SSE"
707   "#"
708   "&& reload_completed"
709   [(const_int 0)]
710 {
711   enum rtx_code absneg_op;
712   rtx op1, op2;
713   rtx t;
714
715   if (TARGET_AVX)
716     {
717       if (MEM_P (operands[1]))
718         op1 = operands[2], op2 = operands[1];
719       else
720         op1 = operands[1], op2 = operands[2];
721     }
722   else
723     {
724       op1 = operands[0];
725       if (rtx_equal_p (operands[0], operands[1]))
726         op2 = operands[2];
727       else
728         op2 = operands[1];
729     }
730
731   absneg_op = GET_CODE (operands[3]) == NEG ? XOR : AND;
732   t = gen_rtx_fmt_ee (absneg_op, <MODE>mode, op1, op2);
733   t = gen_rtx_SET (VOIDmode, operands[0], t);
734   emit_insn (t);
735   DONE;
736 }
737   [(set_attr "isa" "noavx,noavx,avx,avx")])
738
739 (define_expand "<plusminus_insn><mode>3"
740   [(set (match_operand:VF 0 "register_operand" "")
741         (plusminus:VF
742           (match_operand:VF 1 "nonimmediate_operand" "")
743           (match_operand:VF 2 "nonimmediate_operand" "")))]
744   "TARGET_SSE"
745   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
746
747 (define_insn "*<plusminus_insn><mode>3"
748   [(set (match_operand:VF 0 "register_operand" "=x,x")
749         (plusminus:VF
750           (match_operand:VF 1 "nonimmediate_operand" "<comm>0,x")
751           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
752   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
753   "@
754    <plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
755    v<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
756   [(set_attr "isa" "noavx,avx")
757    (set_attr "type" "sseadd")
758    (set_attr "prefix" "orig,vex")
759    (set_attr "mode" "<MODE>")])
760
761 (define_insn "<sse>_vm<plusminus_insn><mode>3"
762   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
763         (vec_merge:VF_128
764           (plusminus:VF_128
765             (match_operand:VF_128 1 "register_operand" "0,x")
766             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
767           (match_dup 1)
768           (const_int 1)))]
769   "TARGET_SSE"
770   "@
771    <plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %2}
772    v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
773   [(set_attr "isa" "noavx,avx")
774    (set_attr "type" "sseadd")
775    (set_attr "prefix" "orig,vex")
776    (set_attr "mode" "<ssescalarmode>")])
777
778 (define_expand "mul<mode>3"
779   [(set (match_operand:VF 0 "register_operand" "")
780         (mult:VF
781           (match_operand:VF 1 "nonimmediate_operand" "")
782           (match_operand:VF 2 "nonimmediate_operand" "")))]
783   "TARGET_SSE"
784   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
785
786 (define_insn "*mul<mode>3"
787   [(set (match_operand:VF 0 "register_operand" "=x,x")
788         (mult:VF
789           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
790           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
791   "TARGET_SSE && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
792   "@
793    mul<ssemodesuffix>\t{%2, %0|%0, %2}
794    vmul<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
795   [(set_attr "isa" "noavx,avx")
796    (set_attr "type" "ssemul")
797    (set_attr "prefix" "orig,vex")
798    (set_attr "mode" "<MODE>")])
799
800 (define_insn "<sse>_vmmul<mode>3"
801   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
802         (vec_merge:VF_128
803           (mult:VF_128
804             (match_operand:VF_128 1 "register_operand" "0,x")
805             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
806           (match_dup 1)
807           (const_int 1)))]
808   "TARGET_SSE"
809   "@
810    mul<ssescalarmodesuffix>\t{%2, %0|%0, %2}
811    vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
812   [(set_attr "isa" "noavx,avx")
813    (set_attr "type" "ssemul")
814    (set_attr "prefix" "orig,vex")
815    (set_attr "mode" "<ssescalarmode>")])
816
817 (define_expand "div<mode>3"
818   [(set (match_operand:VF2 0 "register_operand" "")
819         (div:VF2 (match_operand:VF2 1 "register_operand" "")
820                  (match_operand:VF2 2 "nonimmediate_operand" "")))]
821   "TARGET_SSE2"
822   "ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);")
823
824 (define_expand "div<mode>3"
825   [(set (match_operand:VF1 0 "register_operand" "")
826         (div:VF1 (match_operand:VF1 1 "register_operand" "")
827                  (match_operand:VF1 2 "nonimmediate_operand" "")))]
828   "TARGET_SSE"
829 {
830   ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);
831
832   if (TARGET_SSE_MATH
833       && TARGET_RECIP_VEC_DIV
834       && !optimize_insn_for_size_p ()
835       && flag_finite_math_only && !flag_trapping_math
836       && flag_unsafe_math_optimizations)
837     {
838       ix86_emit_swdivsf (operands[0], operands[1], operands[2], <MODE>mode);
839       DONE;
840     }
841 })
842
843 (define_insn "<sse>_div<mode>3"
844   [(set (match_operand:VF 0 "register_operand" "=x,x")
845         (div:VF
846           (match_operand:VF 1 "register_operand" "0,x")
847           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
848   "TARGET_SSE"
849   "@
850    div<ssemodesuffix>\t{%2, %0|%0, %2}
851    vdiv<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
852   [(set_attr "isa" "noavx,avx")
853    (set_attr "type" "ssediv")
854    (set_attr "prefix" "orig,vex")
855    (set_attr "mode" "<MODE>")])
856
857 (define_insn "<sse>_vmdiv<mode>3"
858   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
859         (vec_merge:VF_128
860           (div:VF_128
861             (match_operand:VF_128 1 "register_operand" "0,x")
862             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
863           (match_dup 1)
864           (const_int 1)))]
865   "TARGET_SSE"
866   "@
867    div<ssescalarmodesuffix>\t{%2, %0|%0, %2}
868    vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
869   [(set_attr "isa" "noavx,avx")
870    (set_attr "type" "ssediv")
871    (set_attr "prefix" "orig,vex")
872    (set_attr "mode" "<ssescalarmode>")])
873
874 (define_insn "<sse>_rcp<mode>2"
875   [(set (match_operand:VF1 0 "register_operand" "=x")
876         (unspec:VF1
877           [(match_operand:VF1 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
878   "TARGET_SSE"
879   "%vrcpps\t{%1, %0|%0, %1}"
880   [(set_attr "type" "sse")
881    (set_attr "atom_sse_attr" "rcp")
882    (set_attr "prefix" "maybe_vex")
883    (set_attr "mode" "<MODE>")])
884
885 (define_insn "sse_vmrcpv4sf2"
886   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
887         (vec_merge:V4SF
888           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
889                        UNSPEC_RCP)
890           (match_operand:V4SF 2 "register_operand" "0,x")
891           (const_int 1)))]
892   "TARGET_SSE"
893   "@
894    rcpss\t{%1, %0|%0, %1}
895    vrcpss\t{%1, %2, %0|%0, %2, %1}"
896   [(set_attr "isa" "noavx,avx")
897    (set_attr "type" "sse")
898    (set_attr "atom_sse_attr" "rcp")
899    (set_attr "prefix" "orig,vex")
900    (set_attr "mode" "SF")])
901
902 (define_expand "sqrt<mode>2"
903   [(set (match_operand:VF2 0 "register_operand" "")
904         (sqrt:VF2 (match_operand:VF2 1 "nonimmediate_operand" "")))]
905   "TARGET_SSE2")
906
907 (define_expand "sqrt<mode>2"
908   [(set (match_operand:VF1 0 "register_operand" "")
909         (sqrt:VF1 (match_operand:VF1 1 "nonimmediate_operand" "")))]
910   "TARGET_SSE"
911 {
912   if (TARGET_SSE_MATH
913       && TARGET_RECIP_VEC_SQRT
914       && !optimize_insn_for_size_p ()
915       && flag_finite_math_only && !flag_trapping_math
916       && flag_unsafe_math_optimizations)
917     {
918       ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, false);
919       DONE;
920     }
921 })
922
923 (define_insn "<sse>_sqrt<mode>2"
924   [(set (match_operand:VF 0 "register_operand" "=x")
925         (sqrt:VF (match_operand:VF 1 "nonimmediate_operand" "xm")))]
926   "TARGET_SSE"
927   "%vsqrt<ssemodesuffix>\t{%1, %0|%0, %1}"
928   [(set_attr "type" "sse")
929    (set_attr "atom_sse_attr" "sqrt")
930    (set_attr "prefix" "maybe_vex")
931    (set_attr "mode" "<MODE>")])
932
933 (define_insn "<sse>_vmsqrt<mode>2"
934   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
935         (vec_merge:VF_128
936           (sqrt:VF_128
937             (match_operand:VF_128 1 "nonimmediate_operand" "xm,xm"))
938           (match_operand:VF_128 2 "register_operand" "0,x")
939           (const_int 1)))]
940   "TARGET_SSE"
941   "@
942    sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %1}
943    vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}"
944   [(set_attr "isa" "noavx,avx")
945    (set_attr "type" "sse")
946    (set_attr "atom_sse_attr" "sqrt")
947    (set_attr "prefix" "orig,vex")
948    (set_attr "mode" "<ssescalarmode>")])
949
950 (define_expand "rsqrt<mode>2"
951   [(set (match_operand:VF1 0 "register_operand" "")
952         (unspec:VF1
953           [(match_operand:VF1 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
954   "TARGET_SSE_MATH"
955 {
956   ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, true);
957   DONE;
958 })
959
960 (define_insn "<sse>_rsqrt<mode>2"
961   [(set (match_operand:VF1 0 "register_operand" "=x")
962         (unspec:VF1
963           [(match_operand:VF1 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
964   "TARGET_SSE"
965   "%vrsqrtps\t{%1, %0|%0, %1}"
966   [(set_attr "type" "sse")
967    (set_attr "prefix" "maybe_vex")
968    (set_attr "mode" "<MODE>")])
969
970 (define_insn "sse_vmrsqrtv4sf2"
971   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
972         (vec_merge:V4SF
973           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
974                        UNSPEC_RSQRT)
975           (match_operand:V4SF 2 "register_operand" "0,x")
976           (const_int 1)))]
977   "TARGET_SSE"
978   "@
979    rsqrtss\t{%1, %0|%0, %1}
980    vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
981   [(set_attr "isa" "noavx,avx")
982    (set_attr "type" "sse")
983    (set_attr "prefix" "orig,vex")
984    (set_attr "mode" "SF")])
985
986 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
987 ;; isn't really correct, as those rtl operators aren't defined when
988 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
989
990 (define_expand "<code><mode>3"
991   [(set (match_operand:VF 0 "register_operand" "")
992         (smaxmin:VF
993           (match_operand:VF 1 "nonimmediate_operand" "")
994           (match_operand:VF 2 "nonimmediate_operand" "")))]
995   "TARGET_SSE"
996 {
997   if (!flag_finite_math_only)
998     operands[1] = force_reg (<MODE>mode, operands[1]);
999   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1000 })
1001
1002 (define_insn "*<code><mode>3_finite"
1003   [(set (match_operand:VF 0 "register_operand" "=x,x")
1004         (smaxmin:VF
1005           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
1006           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1007   "TARGET_SSE && flag_finite_math_only
1008    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1009   "@
1010    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1011    v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1012   [(set_attr "isa" "noavx,avx")
1013    (set_attr "type" "sseadd")
1014    (set_attr "prefix" "orig,vex")
1015    (set_attr "mode" "<MODE>")])
1016
1017 (define_insn "*<code><mode>3"
1018   [(set (match_operand:VF 0 "register_operand" "=x,x")
1019         (smaxmin:VF
1020           (match_operand:VF 1 "register_operand" "0,x")
1021           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1022   "TARGET_SSE && !flag_finite_math_only"
1023   "@
1024    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1025    v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1026   [(set_attr "isa" "noavx,avx")
1027    (set_attr "type" "sseadd")
1028    (set_attr "prefix" "orig,vex")
1029    (set_attr "mode" "<MODE>")])
1030
1031 (define_insn "<sse>_vm<code><mode>3"
1032   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1033         (vec_merge:VF_128
1034           (smaxmin:VF_128
1035             (match_operand:VF_128 1 "register_operand" "0,x")
1036             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
1037          (match_dup 1)
1038          (const_int 1)))]
1039   "TARGET_SSE"
1040   "@
1041    <maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %2}
1042    v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1043   [(set_attr "isa" "noavx,avx")
1044    (set_attr "type" "sse")
1045    (set_attr "prefix" "orig,vex")
1046    (set_attr "mode" "<ssescalarmode>")])
1047
1048 ;; These versions of the min/max patterns implement exactly the operations
1049 ;;   min = (op1 < op2 ? op1 : op2)
1050 ;;   max = (!(op1 < op2) ? op1 : op2)
1051 ;; Their operands are not commutative, and thus they may be used in the
1052 ;; presence of -0.0 and NaN.
1053
1054 (define_insn "*ieee_smin<mode>3"
1055   [(set (match_operand:VF 0 "register_operand" "=x,x")
1056         (unspec:VF
1057           [(match_operand:VF 1 "register_operand" "0,x")
1058            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]
1059          UNSPEC_IEEE_MIN))]
1060   "TARGET_SSE"
1061   "@
1062    min<ssemodesuffix>\t{%2, %0|%0, %2}
1063    vmin<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1064   [(set_attr "isa" "noavx,avx")
1065    (set_attr "type" "sseadd")
1066    (set_attr "prefix" "orig,vex")
1067    (set_attr "mode" "<MODE>")])
1068
1069 (define_insn "*ieee_smax<mode>3"
1070   [(set (match_operand:VF 0 "register_operand" "=x,x")
1071         (unspec:VF
1072           [(match_operand:VF 1 "register_operand" "0,x")
1073            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]
1074          UNSPEC_IEEE_MAX))]
1075   "TARGET_SSE"
1076   "@
1077    max<ssemodesuffix>\t{%2, %0|%0, %2}
1078    vmax<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1079   [(set_attr "isa" "noavx,avx")
1080    (set_attr "type" "sseadd")
1081    (set_attr "prefix" "orig,vex")
1082    (set_attr "mode" "<MODE>")])
1083
1084 (define_insn "avx_addsubv4df3"
1085   [(set (match_operand:V4DF 0 "register_operand" "=x")
1086         (vec_merge:V4DF
1087           (plus:V4DF
1088             (match_operand:V4DF 1 "register_operand" "x")
1089             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1090           (minus:V4DF (match_dup 1) (match_dup 2))
1091           (const_int 10)))]
1092   "TARGET_AVX"
1093   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1094   [(set_attr "type" "sseadd")
1095    (set_attr "prefix" "vex")
1096    (set_attr "mode" "V4DF")])
1097
1098 (define_insn "sse3_addsubv2df3"
1099   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1100         (vec_merge:V2DF
1101           (plus:V2DF
1102             (match_operand:V2DF 1 "register_operand" "0,x")
1103             (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm"))
1104           (minus:V2DF (match_dup 1) (match_dup 2))
1105           (const_int 2)))]
1106   "TARGET_SSE3"
1107   "@
1108    addsubpd\t{%2, %0|%0, %2}
1109    vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1110   [(set_attr "isa" "noavx,avx")
1111    (set_attr "type" "sseadd")
1112    (set_attr "atom_unit" "complex")
1113    (set_attr "prefix" "orig,vex")
1114    (set_attr "mode" "V2DF")])
1115
1116 (define_insn "avx_addsubv8sf3"
1117   [(set (match_operand:V8SF 0 "register_operand" "=x")
1118         (vec_merge:V8SF
1119           (plus:V8SF
1120             (match_operand:V8SF 1 "register_operand" "x")
1121             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1122           (minus:V8SF (match_dup 1) (match_dup 2))
1123           (const_int 170)))]
1124   "TARGET_AVX"
1125   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1126   [(set_attr "type" "sseadd")
1127    (set_attr "prefix" "vex")
1128    (set_attr "mode" "V8SF")])
1129
1130 (define_insn "sse3_addsubv4sf3"
1131   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1132         (vec_merge:V4SF
1133           (plus:V4SF
1134             (match_operand:V4SF 1 "register_operand" "0,x")
1135             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
1136           (minus:V4SF (match_dup 1) (match_dup 2))
1137           (const_int 10)))]
1138   "TARGET_SSE3"
1139   "@
1140    addsubps\t{%2, %0|%0, %2}
1141    vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1142   [(set_attr "isa" "noavx,avx")
1143    (set_attr "type" "sseadd")
1144    (set_attr "prefix" "orig,vex")
1145    (set_attr "prefix_rep" "1,*")
1146    (set_attr "mode" "V4SF")])
1147
1148 (define_insn "avx_h<plusminus_insn>v4df3"
1149   [(set (match_operand:V4DF 0 "register_operand" "=x")
1150         (vec_concat:V4DF
1151           (vec_concat:V2DF
1152             (plusminus:DF
1153               (vec_select:DF
1154                 (match_operand:V4DF 1 "register_operand" "x")
1155                 (parallel [(const_int 0)]))
1156               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1157             (plusminus:DF
1158               (vec_select:DF
1159                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1160                 (parallel [(const_int 0)]))
1161               (vec_select:DF (match_dup 2) (parallel [(const_int 1)]))))
1162           (vec_concat:V2DF
1163             (plusminus:DF
1164               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1165               (vec_select:DF (match_dup 1) (parallel [(const_int 3)])))
1166             (plusminus:DF
1167               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1168               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1169   "TARGET_AVX"
1170   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1171   [(set_attr "type" "sseadd")
1172    (set_attr "prefix" "vex")
1173    (set_attr "mode" "V4DF")])
1174
1175 (define_insn "sse3_h<plusminus_insn>v2df3"
1176   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1177         (vec_concat:V2DF
1178           (plusminus:DF
1179             (vec_select:DF
1180               (match_operand:V2DF 1 "register_operand" "0,x")
1181               (parallel [(const_int 0)]))
1182             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1183           (plusminus:DF
1184             (vec_select:DF
1185               (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm")
1186               (parallel [(const_int 0)]))
1187             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1188   "TARGET_SSE3"
1189   "@
1190    h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}
1191    vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1192   [(set_attr "isa" "noavx,avx")
1193    (set_attr "type" "sseadd")
1194    (set_attr "prefix" "orig,vex")
1195    (set_attr "mode" "V2DF")])
1196
1197 (define_insn "avx_h<plusminus_insn>v8sf3"
1198   [(set (match_operand:V8SF 0 "register_operand" "=x")
1199         (vec_concat:V8SF
1200           (vec_concat:V4SF
1201             (vec_concat:V2SF
1202               (plusminus:SF
1203                 (vec_select:SF
1204                   (match_operand:V8SF 1 "register_operand" "x")
1205                   (parallel [(const_int 0)]))
1206                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1207               (plusminus:SF
1208                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1209                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1210             (vec_concat:V2SF
1211               (plusminus:SF
1212                 (vec_select:SF
1213                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1214                   (parallel [(const_int 0)]))
1215                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1216               (plusminus:SF
1217                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1218                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1219           (vec_concat:V4SF
1220             (vec_concat:V2SF
1221               (plusminus:SF
1222                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1223                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1224               (plusminus:SF
1225                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1226                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1227             (vec_concat:V2SF
1228               (plusminus:SF
1229                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1230                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1231               (plusminus:SF
1232                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1233                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1234   "TARGET_AVX"
1235   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1236   [(set_attr "type" "sseadd")
1237    (set_attr "prefix" "vex")
1238    (set_attr "mode" "V8SF")])
1239
1240 (define_insn "sse3_h<plusminus_insn>v4sf3"
1241   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1242         (vec_concat:V4SF
1243           (vec_concat:V2SF
1244             (plusminus:SF
1245               (vec_select:SF
1246                 (match_operand:V4SF 1 "register_operand" "0,x")
1247                 (parallel [(const_int 0)]))
1248               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1249             (plusminus:SF
1250               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1251               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1252           (vec_concat:V2SF
1253             (plusminus:SF
1254               (vec_select:SF
1255                 (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
1256                 (parallel [(const_int 0)]))
1257               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1258             (plusminus:SF
1259               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1260               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1261   "TARGET_SSE3"
1262   "@
1263    h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}
1264    vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1265   [(set_attr "isa" "noavx,avx")
1266    (set_attr "type" "sseadd")
1267    (set_attr "atom_unit" "complex")
1268    (set_attr "prefix" "orig,vex")
1269    (set_attr "prefix_rep" "1,*")
1270    (set_attr "mode" "V4SF")])
1271
1272 (define_expand "reduc_splus_v4df"
1273   [(match_operand:V4DF 0 "register_operand" "")
1274    (match_operand:V4DF 1 "register_operand" "")]
1275   "TARGET_AVX"
1276 {
1277   rtx tmp = gen_reg_rtx (V4DFmode);
1278   rtx tmp2 = gen_reg_rtx (V4DFmode);
1279   emit_insn (gen_avx_haddv4df3 (tmp, operands[1], operands[1]));
1280   emit_insn (gen_avx_vperm2f128v4df3 (tmp2, tmp, tmp, GEN_INT (1)));
1281   emit_insn (gen_addv4df3 (operands[0], tmp, tmp2));
1282   DONE;
1283 })
1284
1285 (define_expand "reduc_splus_v2df"
1286   [(match_operand:V2DF 0 "register_operand" "")
1287    (match_operand:V2DF 1 "register_operand" "")]
1288   "TARGET_SSE3"
1289 {
1290   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1291   DONE;
1292 })
1293
1294 (define_expand "reduc_splus_v8sf"
1295   [(match_operand:V8SF 0 "register_operand" "")
1296    (match_operand:V8SF 1 "register_operand" "")]
1297   "TARGET_AVX"
1298 {
1299   rtx tmp = gen_reg_rtx (V8SFmode);
1300   rtx tmp2 = gen_reg_rtx (V8SFmode);
1301   emit_insn (gen_avx_haddv8sf3 (tmp, operands[1], operands[1]));
1302   emit_insn (gen_avx_haddv8sf3 (tmp2, tmp, tmp));
1303   emit_insn (gen_avx_vperm2f128v8sf3 (tmp, tmp2, tmp2, GEN_INT (1)));
1304   emit_insn (gen_addv8sf3 (operands[0], tmp, tmp2));
1305   DONE;
1306 })
1307
1308 (define_expand "reduc_splus_v4sf"
1309   [(match_operand:V4SF 0 "register_operand" "")
1310    (match_operand:V4SF 1 "register_operand" "")]
1311   "TARGET_SSE"
1312 {
1313   if (TARGET_SSE3)
1314     {
1315       rtx tmp = gen_reg_rtx (V4SFmode);
1316       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1317       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1318     }
1319   else
1320     ix86_expand_reduc (gen_addv4sf3, operands[0], operands[1]);
1321   DONE;
1322 })
1323
1324 ;; Modes handled by reduc_sm{in,ax}* patterns.
1325 (define_mode_iterator REDUC_SMINMAX_MODE
1326   [(V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
1327    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
1328    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
1329    (V4SF "TARGET_SSE")])
1330
1331 (define_expand "reduc_<code>_<mode>"
1332   [(smaxmin:REDUC_SMINMAX_MODE
1333      (match_operand:REDUC_SMINMAX_MODE 0 "register_operand" "")
1334      (match_operand:REDUC_SMINMAX_MODE 1 "register_operand" ""))]
1335   ""
1336 {
1337   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
1338   DONE;
1339 })
1340
1341 (define_expand "reduc_<code>_<mode>"
1342   [(umaxmin:VI_256
1343      (match_operand:VI_256 0 "register_operand" "")
1344      (match_operand:VI_256 1 "register_operand" ""))]
1345   "TARGET_AVX2"
1346 {
1347   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
1348   DONE;
1349 })
1350
1351 (define_expand "reduc_umin_v8hi"
1352   [(umin:V8HI
1353      (match_operand:V8HI 0 "register_operand" "")
1354      (match_operand:V8HI 1 "register_operand" ""))]
1355   "TARGET_SSE4_1"
1356 {
1357   ix86_expand_reduc (gen_uminv8hi3, operands[0], operands[1]);
1358   DONE;
1359 })
1360
1361 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1362 ;;
1363 ;; Parallel floating point comparisons
1364 ;;
1365 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1366
1367 (define_insn "avx_cmp<mode>3"
1368   [(set (match_operand:VF 0 "register_operand" "=x")
1369         (unspec:VF
1370           [(match_operand:VF 1 "register_operand" "x")
1371            (match_operand:VF 2 "nonimmediate_operand" "xm")
1372            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1373           UNSPEC_PCMP))]
1374   "TARGET_AVX"
1375   "vcmp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1376   [(set_attr "type" "ssecmp")
1377    (set_attr "length_immediate" "1")
1378    (set_attr "prefix" "vex")
1379    (set_attr "mode" "<MODE>")])
1380
1381 (define_insn "avx_vmcmp<mode>3"
1382   [(set (match_operand:VF_128 0 "register_operand" "=x")
1383         (vec_merge:VF_128
1384           (unspec:VF_128
1385             [(match_operand:VF_128 1 "register_operand" "x")
1386              (match_operand:VF_128 2 "nonimmediate_operand" "xm")
1387              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1388             UNSPEC_PCMP)
1389          (match_dup 1)
1390          (const_int 1)))]
1391   "TARGET_AVX"
1392   "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1393   [(set_attr "type" "ssecmp")
1394    (set_attr "length_immediate" "1")
1395    (set_attr "prefix" "vex")
1396    (set_attr "mode" "<ssescalarmode>")])
1397
1398 (define_insn "*<sse>_maskcmp<mode>3_comm"
1399   [(set (match_operand:VF 0 "register_operand" "=x,x")
1400         (match_operator:VF 3 "sse_comparison_operator"
1401           [(match_operand:VF 1 "register_operand" "%0,x")
1402            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]))]
1403   "TARGET_SSE
1404    && GET_RTX_CLASS (GET_CODE (operands[3])) == RTX_COMM_COMPARE"
1405   "@
1406    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
1407    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1408   [(set_attr "isa" "noavx,avx")
1409    (set_attr "type" "ssecmp")
1410    (set_attr "length_immediate" "1")
1411    (set_attr "prefix" "orig,vex")
1412    (set_attr "mode" "<MODE>")])
1413
1414 (define_insn "<sse>_maskcmp<mode>3"
1415   [(set (match_operand:VF 0 "register_operand" "=x,x")
1416         (match_operator:VF 3 "sse_comparison_operator"
1417           [(match_operand:VF 1 "register_operand" "0,x")
1418            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]))]
1419   "TARGET_SSE"
1420   "@
1421    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
1422    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1423   [(set_attr "isa" "noavx,avx")
1424    (set_attr "type" "ssecmp")
1425    (set_attr "length_immediate" "1")
1426    (set_attr "prefix" "orig,vex")
1427    (set_attr "mode" "<MODE>")])
1428
1429 (define_insn "<sse>_vmmaskcmp<mode>3"
1430   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1431         (vec_merge:VF_128
1432          (match_operator:VF_128 3 "sse_comparison_operator"
1433            [(match_operand:VF_128 1 "register_operand" "0,x")
1434             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm")])
1435          (match_dup 1)
1436          (const_int 1)))]
1437   "TARGET_SSE"
1438   "@
1439    cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %2}
1440    vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1441   [(set_attr "isa" "noavx,avx")
1442    (set_attr "type" "ssecmp")
1443    (set_attr "length_immediate" "1,*")
1444    (set_attr "prefix" "orig,vex")
1445    (set_attr "mode" "<ssescalarmode>")])
1446
1447 (define_insn "<sse>_comi"
1448   [(set (reg:CCFP FLAGS_REG)
1449         (compare:CCFP
1450           (vec_select:MODEF
1451             (match_operand:<ssevecmode> 0 "register_operand" "x")
1452             (parallel [(const_int 0)]))
1453           (vec_select:MODEF
1454             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1455             (parallel [(const_int 0)]))))]
1456   "SSE_FLOAT_MODE_P (<MODE>mode)"
1457   "%vcomi<ssemodesuffix>\t{%1, %0|%0, %1}"
1458   [(set_attr "type" "ssecomi")
1459    (set_attr "prefix" "maybe_vex")
1460    (set_attr "prefix_rep" "0")
1461    (set (attr "prefix_data16")
1462         (if_then_else (eq_attr "mode" "DF")
1463                       (const_string "1")
1464                       (const_string "0")))
1465    (set_attr "mode" "<MODE>")])
1466
1467 (define_insn "<sse>_ucomi"
1468   [(set (reg:CCFPU FLAGS_REG)
1469         (compare:CCFPU
1470           (vec_select:MODEF
1471             (match_operand:<ssevecmode> 0 "register_operand" "x")
1472             (parallel [(const_int 0)]))
1473           (vec_select:MODEF
1474             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1475             (parallel [(const_int 0)]))))]
1476   "SSE_FLOAT_MODE_P (<MODE>mode)"
1477   "%vucomi<ssemodesuffix>\t{%1, %0|%0, %1}"
1478   [(set_attr "type" "ssecomi")
1479    (set_attr "prefix" "maybe_vex")
1480    (set_attr "prefix_rep" "0")
1481    (set (attr "prefix_data16")
1482         (if_then_else (eq_attr "mode" "DF")
1483                       (const_string "1")
1484                       (const_string "0")))
1485    (set_attr "mode" "<MODE>")])
1486
1487 (define_expand "vcond<V_256:mode><VF_256:mode>"
1488   [(set (match_operand:V_256 0 "register_operand" "")
1489         (if_then_else:V_256
1490           (match_operator 3 ""
1491             [(match_operand:VF_256 4 "nonimmediate_operand" "")
1492              (match_operand:VF_256 5 "nonimmediate_operand" "")])
1493           (match_operand:V_256 1 "general_operand" "")
1494           (match_operand:V_256 2 "general_operand" "")))]
1495   "TARGET_AVX
1496    && (GET_MODE_NUNITS (<V_256:MODE>mode)
1497        == GET_MODE_NUNITS (<VF_256:MODE>mode))"
1498 {
1499   bool ok = ix86_expand_fp_vcond (operands);
1500   gcc_assert (ok);
1501   DONE;
1502 })
1503
1504 (define_expand "vcond<V_128:mode><VF_128:mode>"
1505   [(set (match_operand:V_128 0 "register_operand" "")
1506         (if_then_else:V_128
1507           (match_operator 3 ""
1508             [(match_operand:VF_128 4 "nonimmediate_operand" "")
1509              (match_operand:VF_128 5 "nonimmediate_operand" "")])
1510           (match_operand:V_128 1 "general_operand" "")
1511           (match_operand:V_128 2 "general_operand" "")))]
1512   "TARGET_SSE
1513    && (GET_MODE_NUNITS (<V_128:MODE>mode)
1514        == GET_MODE_NUNITS (<VF_128:MODE>mode))"
1515 {
1516   bool ok = ix86_expand_fp_vcond (operands);
1517   gcc_assert (ok);
1518   DONE;
1519 })
1520
1521 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1522 ;;
1523 ;; Parallel floating point logical operations
1524 ;;
1525 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1526
1527 (define_insn "<sse>_andnot<mode>3"
1528   [(set (match_operand:VF 0 "register_operand" "=x,x")
1529         (and:VF
1530           (not:VF
1531             (match_operand:VF 1 "register_operand" "0,x"))
1532           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1533   "TARGET_SSE"
1534 {
1535   static char buf[32];
1536   const char *insn;
1537   const char *suffix
1538     = TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL ? "ps" : "<ssemodesuffix>";
1539
1540   switch (which_alternative)
1541     {
1542     case 0:
1543       insn = "andn%s\t{%%2, %%0|%%0, %%2}";
1544       break;
1545     case 1:
1546       insn = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1547       break;
1548     default:
1549       gcc_unreachable ();
1550     }
1551
1552   snprintf (buf, sizeof (buf), insn, suffix);
1553   return buf;
1554 }
1555   [(set_attr "isa" "noavx,avx")
1556    (set_attr "type" "sselog")
1557    (set_attr "prefix" "orig,vex")
1558    (set_attr "mode" "<MODE>")])
1559
1560 (define_expand "<code><mode>3"
1561   [(set (match_operand:VF 0 "register_operand" "")
1562         (any_logic:VF
1563           (match_operand:VF 1 "nonimmediate_operand" "")
1564           (match_operand:VF 2 "nonimmediate_operand" "")))]
1565   "TARGET_SSE"
1566   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1567
1568 (define_insn "*<code><mode>3"
1569   [(set (match_operand:VF 0 "register_operand" "=x,x")
1570         (any_logic:VF
1571           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
1572           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1573   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1574 {
1575   static char buf[32];
1576   const char *insn;
1577   const char *suffix
1578     = TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL ? "ps" : "<ssemodesuffix>";
1579
1580   switch (which_alternative)
1581     {
1582     case 0:
1583       insn = "<logic>%s\t{%%2, %%0|%%0, %%2}";
1584       break;
1585     case 1:
1586       insn = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1587       break;
1588     default:
1589       gcc_unreachable ();
1590     }
1591
1592   snprintf (buf, sizeof (buf), insn, suffix);
1593   return buf;
1594 }
1595   [(set_attr "isa" "noavx,avx")
1596    (set_attr "type" "sselog")
1597    (set_attr "prefix" "orig,vex")
1598    (set_attr "mode" "<MODE>")])
1599
1600 (define_expand "copysign<mode>3"
1601   [(set (match_dup 4)
1602         (and:VF
1603           (not:VF (match_dup 3))
1604           (match_operand:VF 1 "nonimmediate_operand" "")))
1605    (set (match_dup 5)
1606         (and:VF (match_dup 3)
1607                 (match_operand:VF 2 "nonimmediate_operand" "")))
1608    (set (match_operand:VF 0 "register_operand" "")
1609         (ior:VF (match_dup 4) (match_dup 5)))]
1610   "TARGET_SSE"
1611 {
1612   operands[3] = ix86_build_signbit_mask (<MODE>mode, 1, 0);
1613
1614   operands[4] = gen_reg_rtx (<MODE>mode);
1615   operands[5] = gen_reg_rtx (<MODE>mode);
1616 })
1617
1618 ;; Also define scalar versions.  These are used for abs, neg, and
1619 ;; conditional move.  Using subregs into vector modes causes register
1620 ;; allocation lossage.  These patterns do not allow memory operands
1621 ;; because the native instructions read the full 128-bits.
1622
1623 (define_insn "*andnot<mode>3"
1624   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
1625         (and:MODEF
1626           (not:MODEF
1627             (match_operand:MODEF 1 "register_operand" "0,x"))
1628             (match_operand:MODEF 2 "register_operand" "x,x")))]
1629   "SSE_FLOAT_MODE_P (<MODE>mode)"
1630 {
1631   static char buf[32];
1632   const char *insn;
1633   const char *suffix
1634     = TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL ? "ps" : "<ssevecmodesuffix>";
1635
1636   switch (which_alternative)
1637     {
1638     case 0:
1639       insn = "andn%s\t{%%2, %%0|%%0, %%2}";
1640       break;
1641     case 1:
1642       insn = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1643       break;
1644     default:
1645       gcc_unreachable ();
1646     }
1647
1648   snprintf (buf, sizeof (buf), insn, suffix);
1649   return buf;
1650 }
1651   [(set_attr "isa" "noavx,avx")
1652    (set_attr "type" "sselog")
1653    (set_attr "prefix" "orig,vex")
1654    (set_attr "mode" "<ssevecmode>")])
1655
1656 (define_insn "*<code><mode>3"
1657   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
1658         (any_logic:MODEF
1659           (match_operand:MODEF 1 "register_operand" "%0,x")
1660           (match_operand:MODEF 2 "register_operand" "x,x")))]
1661   "SSE_FLOAT_MODE_P (<MODE>mode)"
1662 {
1663   static char buf[32];
1664   const char *insn;
1665   const char *suffix
1666     = TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL ? "ps" : "<ssevecmodesuffix>";
1667
1668   switch (which_alternative)
1669     {
1670     case 0:
1671       insn = "<logic>%s\t{%%2, %%0|%%0, %%2}";
1672       break;
1673     case 1:
1674       insn = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1675       break;
1676     default:
1677       gcc_unreachable ();
1678     }
1679
1680   snprintf (buf, sizeof (buf), insn, suffix);
1681   return buf;
1682 }
1683   [(set_attr "isa" "noavx,avx")
1684    (set_attr "type" "sselog")
1685    (set_attr "prefix" "orig,vex")
1686    (set_attr "mode" "<ssevecmode>")])
1687
1688 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1689 ;;
1690 ;; FMA4 floating point multiply/accumulate instructions.  This
1691 ;; includes the scalar version of the instructions as well as the
1692 ;; vector.
1693 ;;
1694 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1695
1696 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1697 ;; combine to generate a multiply/add with two memory references.  We then
1698 ;; split this insn, into loading up the destination register with one of the
1699 ;; memory operations.  If we don't manage to split the insn, reload will
1700 ;; generate the appropriate moves.  The reason this is needed, is that combine
1701 ;; has already folded one of the memory references into both the multiply and
1702 ;; add insns, and it can't generate a new pseudo.  I.e.:
1703 ;;      (set (reg1) (mem (addr1)))
1704 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1705 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1706 ;;
1707 ;; ??? This is historic, pre-dating the gimple fma transformation.
1708 ;; We could now properly represent that only one memory operand is
1709 ;; allowed and not be penalized during optimization.
1710
1711 ;; Intrinsic FMA operations.
1712
1713 ;; The standard names for fma is only available with SSE math enabled.
1714 (define_expand "fma<mode>4"
1715   [(set (match_operand:FMAMODE 0 "register_operand")
1716         (fma:FMAMODE
1717           (match_operand:FMAMODE 1 "nonimmediate_operand")
1718           (match_operand:FMAMODE 2 "nonimmediate_operand")
1719           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
1720   "(TARGET_FMA || TARGET_FMA4) && TARGET_SSE_MATH")
1721
1722 (define_expand "fms<mode>4"
1723   [(set (match_operand:FMAMODE 0 "register_operand")
1724         (fma:FMAMODE
1725           (match_operand:FMAMODE 1 "nonimmediate_operand")
1726           (match_operand:FMAMODE 2 "nonimmediate_operand")
1727           (neg:FMAMODE (match_operand:FMAMODE 3 "nonimmediate_operand"))))]
1728   "(TARGET_FMA || TARGET_FMA4) && TARGET_SSE_MATH")
1729
1730 (define_expand "fnma<mode>4"
1731   [(set (match_operand:FMAMODE 0 "register_operand")
1732         (fma:FMAMODE
1733           (neg:FMAMODE (match_operand:FMAMODE 1 "nonimmediate_operand"))
1734           (match_operand:FMAMODE 2 "nonimmediate_operand")
1735           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
1736   "(TARGET_FMA || TARGET_FMA4) && TARGET_SSE_MATH")
1737
1738 (define_expand "fnms<mode>4"
1739   [(set (match_operand:FMAMODE 0 "register_operand")
1740         (fma:FMAMODE
1741           (neg:FMAMODE (match_operand:FMAMODE 1 "nonimmediate_operand"))
1742           (match_operand:FMAMODE 2 "nonimmediate_operand")
1743           (neg:FMAMODE (match_operand:FMAMODE 3 "nonimmediate_operand"))))]
1744   "(TARGET_FMA || TARGET_FMA4) && TARGET_SSE_MATH")
1745
1746 ;; The builtin for fma4intrin.h is not constrained by SSE math enabled.
1747 (define_expand "fma4i_fmadd_<mode>"
1748   [(set (match_operand:FMAMODE 0 "register_operand")
1749         (fma:FMAMODE
1750           (match_operand:FMAMODE 1 "nonimmediate_operand")
1751           (match_operand:FMAMODE 2 "nonimmediate_operand")
1752           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
1753   "TARGET_FMA || TARGET_FMA4")
1754
1755 (define_insn "*fma4i_fmadd_<mode>"
1756   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1757         (fma:FMAMODE
1758           (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x")
1759           (match_operand:FMAMODE 2 "nonimmediate_operand" " x,m")
1760           (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x")))]
1761   "TARGET_FMA4"
1762   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1763   [(set_attr "type" "ssemuladd")
1764    (set_attr "mode" "<MODE>")])
1765
1766 (define_insn "*fma4i_fmsub_<mode>"
1767   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1768         (fma:FMAMODE
1769           (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x")
1770           (match_operand:FMAMODE 2 "nonimmediate_operand" " x,m")
1771           (neg:FMAMODE
1772             (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x"))))]
1773   "TARGET_FMA4"
1774   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1775   [(set_attr "type" "ssemuladd")
1776    (set_attr "mode" "<MODE>")])
1777
1778 (define_insn "*fma4i_fnmadd_<mode>"
1779   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1780         (fma:FMAMODE
1781           (neg:FMAMODE
1782             (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x"))
1783           (match_operand:FMAMODE   2 "nonimmediate_operand" " x,m")
1784           (match_operand:FMAMODE   3 "nonimmediate_operand" "xm,x")))]
1785   "TARGET_FMA4"
1786   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1787   [(set_attr "type" "ssemuladd")
1788    (set_attr "mode" "<MODE>")])
1789
1790 (define_insn "*fma4i_fnmsub_<mode>"
1791   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1792         (fma:FMAMODE
1793           (neg:FMAMODE
1794             (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x"))
1795           (match_operand:FMAMODE   2 "nonimmediate_operand" " x,m")
1796           (neg:FMAMODE
1797             (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x"))))]
1798   "TARGET_FMA4"
1799   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1800   [(set_attr "type" "ssemuladd")
1801    (set_attr "mode" "<MODE>")])
1802
1803 ;; Scalar versions of the above.  Unlike ADDSS et al, these write the
1804 ;; entire destination register, with the high-order elements zeroed.
1805
1806 (define_expand "fma4i_vmfmadd_<mode>"
1807   [(set (match_operand:VF_128 0 "register_operand")
1808         (vec_merge:VF_128
1809           (fma:VF_128
1810             (match_operand:VF_128 1 "nonimmediate_operand")
1811             (match_operand:VF_128 2 "nonimmediate_operand")
1812             (match_operand:VF_128 3 "nonimmediate_operand"))
1813           (match_dup 4)
1814           (const_int 1)))]
1815   "TARGET_FMA4"
1816 {
1817   operands[4] = CONST0_RTX (<MODE>mode);
1818 })
1819
1820 (define_expand "fmai_vmfmadd_<mode>"
1821   [(set (match_operand:VF_128 0 "register_operand")
1822         (vec_merge:VF_128
1823           (fma:VF_128
1824             (match_operand:VF_128 1 "nonimmediate_operand")
1825             (match_operand:VF_128 2 "nonimmediate_operand")
1826             (match_operand:VF_128 3 "nonimmediate_operand"))
1827           (match_dup 0)
1828           (const_int 1)))]
1829   "TARGET_FMA")
1830
1831 (define_insn "*fmai_fmadd_<mode>"
1832   [(set (match_operand:VF_128 0 "register_operand" "=x,x,x")
1833         (vec_merge:VF_128
1834           (fma:VF_128
1835             (match_operand:VF_128 1 "nonimmediate_operand" "%0, 0,x")
1836             (match_operand:VF_128 2 "nonimmediate_operand" "xm, x,xm")
1837             (match_operand:VF_128 3 "nonimmediate_operand" " x,xm,0"))
1838           (match_dup 0)
1839           (const_int 1)))]
1840   "TARGET_FMA"
1841   "@
1842    vfmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2}
1843    vfmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
1844    vfmadd231<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1845   [(set_attr "type" "ssemuladd")
1846    (set_attr "mode" "<MODE>")])
1847
1848 (define_insn "*fmai_fmsub_<mode>"
1849   [(set (match_operand:VF_128 0 "register_operand" "=x,x,x")
1850         (vec_merge:VF_128
1851           (fma:VF_128
1852             (match_operand:VF_128   1 "nonimmediate_operand" "%0, 0,x")
1853             (match_operand:VF_128   2 "nonimmediate_operand" "xm, x,xm")
1854             (neg:VF_128
1855               (match_operand:VF_128 3 "nonimmediate_operand" " x,xm,0")))
1856           (match_dup 0)
1857           (const_int 1)))]
1858   "TARGET_FMA"
1859   "@
1860    vfmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2}
1861    vfmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
1862    vfmsub231<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1863   [(set_attr "type" "ssemuladd")
1864    (set_attr "mode" "<MODE>")])
1865
1866 (define_insn "*fmai_fnmadd_<mode>"
1867   [(set (match_operand:VF_128 0 "register_operand" "=x,x,x")
1868         (vec_merge:VF_128
1869           (fma:VF_128
1870             (neg:VF_128
1871               (match_operand:VF_128 1 "nonimmediate_operand" "%0, 0,x"))
1872             (match_operand:VF_128   2 "nonimmediate_operand" "xm, x,xm")
1873             (match_operand:VF_128   3 "nonimmediate_operand" " x,xm,0"))
1874           (match_dup 0)
1875           (const_int 1)))]
1876   "TARGET_FMA"
1877   "@
1878    vfnmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2}
1879    vfnmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
1880    vfnmadd231<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1881   [(set_attr "type" "ssemuladd")
1882    (set_attr "mode" "<MODE>")])
1883
1884 (define_insn "*fmai_fnmsub_<mode>"
1885   [(set (match_operand:VF_128 0 "register_operand" "=x,x,x")
1886         (vec_merge:VF_128
1887           (fma:VF_128
1888             (neg:VF_128
1889               (match_operand:VF_128 1 "nonimmediate_operand" "%0, 0,x"))
1890             (match_operand:VF_128   2 "nonimmediate_operand" "xm, x,xm")
1891             (neg:VF_128
1892               (match_operand:VF_128 3 "nonimmediate_operand" " x,xm,0")))
1893           (match_dup 0)
1894           (const_int 1)))]
1895   "TARGET_FMA"
1896   "@
1897    vfnmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2}
1898    vfnmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
1899    vfnmsub231<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1900   [(set_attr "type" "ssemuladd")
1901    (set_attr "mode" "<MODE>")])
1902
1903 (define_insn "*fma4i_vmfmadd_<mode>"
1904   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1905         (vec_merge:VF_128
1906           (fma:VF_128
1907             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
1908             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
1909             (match_operand:VF_128 3 "nonimmediate_operand" "xm,x"))
1910           (match_operand:VF_128 4 "const0_operand" "")
1911           (const_int 1)))]
1912   "TARGET_FMA4"
1913   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1914   [(set_attr "type" "ssemuladd")
1915    (set_attr "mode" "<MODE>")])
1916
1917 (define_insn "*fma4i_vmfmsub_<mode>"
1918   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1919         (vec_merge:VF_128
1920           (fma:VF_128
1921             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
1922             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
1923             (neg:VF_128
1924               (match_operand:VF_128 3 "nonimmediate_operand" "xm,x")))
1925           (match_operand:VF_128 4 "const0_operand" "")
1926           (const_int 1)))]
1927   "TARGET_FMA4"
1928   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1929   [(set_attr "type" "ssemuladd")
1930    (set_attr "mode" "<MODE>")])
1931
1932 (define_insn "*fma4i_vmfnmadd_<mode>"
1933   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1934         (vec_merge:VF_128
1935           (fma:VF_128
1936             (neg:VF_128
1937               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
1938             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
1939             (match_operand:VF_128   3 "nonimmediate_operand" "xm,x"))
1940           (match_operand:VF_128 4 "const0_operand" "")
1941           (const_int 1)))]
1942   "TARGET_FMA4"
1943   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1944   [(set_attr "type" "ssemuladd")
1945    (set_attr "mode" "<MODE>")])
1946
1947 (define_insn "*fma4i_vmfnmsub_<mode>"
1948   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1949         (vec_merge:VF_128
1950           (fma:VF_128
1951             (neg:VF_128
1952               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
1953             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
1954             (neg:VF_128
1955               (match_operand:VF_128   3 "nonimmediate_operand" "xm,x")))
1956           (match_operand:VF_128 4 "const0_operand" "")
1957           (const_int 1)))]
1958   "TARGET_FMA4"
1959   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1960   [(set_attr "type" "ssemuladd")
1961    (set_attr "mode" "<MODE>")])
1962
1963 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1964 ;;
1965 ;; FMA4 Parallel floating point multiply addsub and subadd operations.
1966 ;;
1967 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1968
1969 ;; It would be possible to represent these without the UNSPEC as
1970 ;;
1971 ;; (vec_merge
1972 ;;   (fma op1 op2 op3)
1973 ;;   (fma op1 op2 (neg op3))
1974 ;;   (merge-const))
1975 ;;
1976 ;; But this doesn't seem useful in practice.
1977
1978 (define_expand "fmaddsub_<mode>"
1979   [(set (match_operand:VF 0 "register_operand")
1980         (unspec:VF
1981           [(match_operand:VF 1 "nonimmediate_operand")
1982            (match_operand:VF 2 "nonimmediate_operand")
1983            (match_operand:VF 3 "nonimmediate_operand")]
1984           UNSPEC_FMADDSUB))]
1985   "TARGET_FMA || TARGET_FMA4")
1986
1987 (define_insn "*fma4_fmaddsub_<mode>"
1988   [(set (match_operand:VF 0 "register_operand" "=x,x")
1989         (unspec:VF
1990           [(match_operand:VF 1 "nonimmediate_operand" "%x,x")
1991            (match_operand:VF 2 "nonimmediate_operand" " x,m")
1992            (match_operand:VF 3 "nonimmediate_operand" "xm,x")]
1993           UNSPEC_FMADDSUB))]
1994   "TARGET_FMA4"
1995   "vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1996   [(set_attr "type" "ssemuladd")
1997    (set_attr "mode" "<MODE>")])
1998
1999 (define_insn "*fma4_fmsubadd_<mode>"
2000   [(set (match_operand:VF 0 "register_operand" "=x,x")
2001         (unspec:VF
2002           [(match_operand:VF 1 "nonimmediate_operand" "%x,x")
2003            (match_operand:VF 2 "nonimmediate_operand" " x,m")
2004            (neg:VF
2005              (match_operand:VF 3 "nonimmediate_operand" "xm,x"))]
2006           UNSPEC_FMADDSUB))]
2007   "TARGET_FMA4"
2008   "vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2009   [(set_attr "type" "ssemuladd")
2010    (set_attr "mode" "<MODE>")])
2011
2012 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2013 ;;
2014 ;; FMA3 floating point multiply/accumulate instructions.
2015 ;;
2016 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2017
2018 (define_insn "*fma_fmadd_<mode>"
2019   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2020         (fma:FMAMODE
2021           (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x")
2022           (match_operand:FMAMODE 2 "nonimmediate_operand" "xm, x,xm")
2023           (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0")))]
2024   "TARGET_FMA"
2025   "@
2026    vfmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2027    vfmadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2028    vfmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2029   [(set_attr "type" "ssemuladd")
2030    (set_attr "mode" "<MODE>")])
2031
2032 (define_insn "*fma_fmsub_<mode>"
2033   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2034         (fma:FMAMODE
2035           (match_operand:FMAMODE   1 "nonimmediate_operand" "%0, 0,x")
2036           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2037           (neg:FMAMODE
2038             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0"))))]
2039   "TARGET_FMA"
2040   "@
2041    vfmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2042    vfmsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2043    vfmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2044   [(set_attr "type" "ssemuladd")
2045    (set_attr "mode" "<MODE>")])
2046
2047 (define_insn "*fma_fnmadd_<mode>"
2048   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2049         (fma:FMAMODE
2050           (neg:FMAMODE
2051             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x"))
2052           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2053           (match_operand:FMAMODE   3 "nonimmediate_operand" " x,xm,0")))]
2054   "TARGET_FMA"
2055   "@
2056    vfnmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2057    vfnmadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2058    vfnmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2059   [(set_attr "type" "ssemuladd")
2060    (set_attr "mode" "<MODE>")])
2061
2062 (define_insn "*fma_fnmsub_<mode>"
2063   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2064         (fma:FMAMODE
2065           (neg:FMAMODE
2066             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x"))
2067           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2068           (neg:FMAMODE
2069             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0"))))]
2070   "TARGET_FMA"
2071   "@
2072    vfnmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2073    vfnmsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2074    vfnmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2075   [(set_attr "type" "ssemuladd")
2076    (set_attr "mode" "<MODE>")])
2077
2078 (define_insn "*fma_fmaddsub_<mode>"
2079   [(set (match_operand:VF 0 "register_operand" "=x,x,x")
2080         (unspec:VF
2081           [(match_operand:VF 1 "nonimmediate_operand" "%0, 0,x")
2082            (match_operand:VF 2 "nonimmediate_operand" "xm, x,xm")
2083            (match_operand:VF 3 "nonimmediate_operand" " x,xm,0")]
2084           UNSPEC_FMADDSUB))]
2085   "TARGET_FMA"
2086   "@
2087    vfmaddsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2088    vfmaddsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2089    vfmaddsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2090   [(set_attr "type" "ssemuladd")
2091    (set_attr "mode" "<MODE>")])
2092
2093 (define_insn "*fma_fmsubadd_<mode>"
2094   [(set (match_operand:VF 0 "register_operand" "=x,x,x")
2095         (unspec:VF
2096           [(match_operand:VF   1 "nonimmediate_operand" "%0, 0,x")
2097            (match_operand:VF   2 "nonimmediate_operand" "xm, x,xm")
2098            (neg:VF
2099              (match_operand:VF 3 "nonimmediate_operand" " x,xm,0"))]
2100           UNSPEC_FMADDSUB))]
2101   "TARGET_FMA"
2102   "@
2103    vfmsubadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2104    vfmsubadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2105    vfmsubadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2106   [(set_attr "type" "ssemuladd")
2107    (set_attr "mode" "<MODE>")])
2108
2109 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2110 ;;
2111 ;; Parallel single-precision floating point conversion operations
2112 ;;
2113 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2114
2115 (define_insn "sse_cvtpi2ps"
2116   [(set (match_operand:V4SF 0 "register_operand" "=x")
2117         (vec_merge:V4SF
2118           (vec_duplicate:V4SF
2119             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2120           (match_operand:V4SF 1 "register_operand" "0")
2121           (const_int 3)))]
2122   "TARGET_SSE"
2123   "cvtpi2ps\t{%2, %0|%0, %2}"
2124   [(set_attr "type" "ssecvt")
2125    (set_attr "mode" "V4SF")])
2126
2127 (define_insn "sse_cvtps2pi"
2128   [(set (match_operand:V2SI 0 "register_operand" "=y")
2129         (vec_select:V2SI
2130           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2131                        UNSPEC_FIX_NOTRUNC)
2132           (parallel [(const_int 0) (const_int 1)])))]
2133   "TARGET_SSE"
2134   "cvtps2pi\t{%1, %0|%0, %1}"
2135   [(set_attr "type" "ssecvt")
2136    (set_attr "unit" "mmx")
2137    (set_attr "mode" "DI")])
2138
2139 (define_insn "sse_cvttps2pi"
2140   [(set (match_operand:V2SI 0 "register_operand" "=y")
2141         (vec_select:V2SI
2142           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2143           (parallel [(const_int 0) (const_int 1)])))]
2144   "TARGET_SSE"
2145   "cvttps2pi\t{%1, %0|%0, %1}"
2146   [(set_attr "type" "ssecvt")
2147    (set_attr "unit" "mmx")
2148    (set_attr "prefix_rep" "0")
2149    (set_attr "mode" "SF")])
2150
2151 (define_insn "sse_cvtsi2ss"
2152   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2153         (vec_merge:V4SF
2154           (vec_duplicate:V4SF
2155             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
2156           (match_operand:V4SF 1 "register_operand" "0,0,x")
2157           (const_int 1)))]
2158   "TARGET_SSE"
2159   "@
2160    cvtsi2ss\t{%2, %0|%0, %2}
2161    cvtsi2ss\t{%2, %0|%0, %2}
2162    vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2163   [(set_attr "isa" "noavx,noavx,avx")
2164    (set_attr "type" "sseicvt")
2165    (set_attr "athlon_decode" "vector,double,*")
2166    (set_attr "amdfam10_decode" "vector,double,*")
2167    (set_attr "bdver1_decode" "double,direct,*")
2168    (set_attr "prefix" "orig,orig,vex")
2169    (set_attr "mode" "SF")])
2170
2171 (define_insn "sse_cvtsi2ssq"
2172   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2173         (vec_merge:V4SF
2174           (vec_duplicate:V4SF
2175             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,m,rm")))
2176           (match_operand:V4SF 1 "register_operand" "0,0,x")
2177           (const_int 1)))]
2178   "TARGET_SSE && TARGET_64BIT"
2179   "@
2180    cvtsi2ssq\t{%2, %0|%0, %2}
2181    cvtsi2ssq\t{%2, %0|%0, %2}
2182    vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2183   [(set_attr "isa" "noavx,noavx,avx")
2184    (set_attr "type" "sseicvt")
2185    (set_attr "athlon_decode" "vector,double,*")
2186    (set_attr "amdfam10_decode" "vector,double,*")
2187    (set_attr "bdver1_decode" "double,direct,*")
2188    (set_attr "length_vex" "*,*,4")
2189    (set_attr "prefix_rex" "1,1,*")
2190    (set_attr "prefix" "orig,orig,vex")
2191    (set_attr "mode" "SF")])
2192
2193 (define_insn "sse_cvtss2si"
2194   [(set (match_operand:SI 0 "register_operand" "=r,r")
2195         (unspec:SI
2196           [(vec_select:SF
2197              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2198              (parallel [(const_int 0)]))]
2199           UNSPEC_FIX_NOTRUNC))]
2200   "TARGET_SSE"
2201   "%vcvtss2si\t{%1, %0|%0, %1}"
2202   [(set_attr "type" "sseicvt")
2203    (set_attr "athlon_decode" "double,vector")
2204    (set_attr "bdver1_decode" "double,double")
2205    (set_attr "prefix_rep" "1")
2206    (set_attr "prefix" "maybe_vex")
2207    (set_attr "mode" "SI")])
2208
2209 (define_insn "sse_cvtss2si_2"
2210   [(set (match_operand:SI 0 "register_operand" "=r,r")
2211         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2212                    UNSPEC_FIX_NOTRUNC))]
2213   "TARGET_SSE"
2214   "%vcvtss2si\t{%1, %0|%0, %1}"
2215   [(set_attr "type" "sseicvt")
2216    (set_attr "athlon_decode" "double,vector")
2217    (set_attr "amdfam10_decode" "double,double")
2218    (set_attr "bdver1_decode" "double,double")
2219    (set_attr "prefix_rep" "1")
2220    (set_attr "prefix" "maybe_vex")
2221    (set_attr "mode" "SI")])
2222
2223 (define_insn "sse_cvtss2siq"
2224   [(set (match_operand:DI 0 "register_operand" "=r,r")
2225         (unspec:DI
2226           [(vec_select:SF
2227              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2228              (parallel [(const_int 0)]))]
2229           UNSPEC_FIX_NOTRUNC))]
2230   "TARGET_SSE && TARGET_64BIT"
2231   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2232   [(set_attr "type" "sseicvt")
2233    (set_attr "athlon_decode" "double,vector")
2234    (set_attr "bdver1_decode" "double,double")
2235    (set_attr "prefix_rep" "1")
2236    (set_attr "prefix" "maybe_vex")
2237    (set_attr "mode" "DI")])
2238
2239 (define_insn "sse_cvtss2siq_2"
2240   [(set (match_operand:DI 0 "register_operand" "=r,r")
2241         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2242                    UNSPEC_FIX_NOTRUNC))]
2243   "TARGET_SSE && TARGET_64BIT"
2244   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2245   [(set_attr "type" "sseicvt")
2246    (set_attr "athlon_decode" "double,vector")
2247    (set_attr "amdfam10_decode" "double,double")
2248    (set_attr "bdver1_decode" "double,double")
2249    (set_attr "prefix_rep" "1")
2250    (set_attr "prefix" "maybe_vex")
2251    (set_attr "mode" "DI")])
2252
2253 (define_insn "sse_cvttss2si"
2254   [(set (match_operand:SI 0 "register_operand" "=r,r")
2255         (fix:SI
2256           (vec_select:SF
2257             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2258             (parallel [(const_int 0)]))))]
2259   "TARGET_SSE"
2260   "%vcvttss2si\t{%1, %0|%0, %1}"
2261   [(set_attr "type" "sseicvt")
2262    (set_attr "athlon_decode" "double,vector")
2263    (set_attr "amdfam10_decode" "double,double")
2264    (set_attr "bdver1_decode" "double,double")
2265    (set_attr "prefix_rep" "1")
2266    (set_attr "prefix" "maybe_vex")
2267    (set_attr "mode" "SI")])
2268
2269 (define_insn "sse_cvttss2siq"
2270   [(set (match_operand:DI 0 "register_operand" "=r,r")
2271         (fix:DI
2272           (vec_select:SF
2273             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2274             (parallel [(const_int 0)]))))]
2275   "TARGET_SSE && TARGET_64BIT"
2276   "%vcvttss2si{q}\t{%1, %0|%0, %1}"
2277   [(set_attr "type" "sseicvt")
2278    (set_attr "athlon_decode" "double,vector")
2279    (set_attr "amdfam10_decode" "double,double")
2280    (set_attr "bdver1_decode" "double,double")
2281    (set_attr "prefix_rep" "1")
2282    (set_attr "prefix" "maybe_vex")
2283    (set_attr "mode" "DI")])
2284
2285 (define_insn "float<sseintvecmodelower><mode>2"
2286   [(set (match_operand:VF1 0 "register_operand" "=x")
2287         (float:VF1
2288           (match_operand:<sseintvecmode> 1 "nonimmediate_operand" "xm")))]
2289   "TARGET_SSE2"
2290   "%vcvtdq2ps\t{%1, %0|%0, %1}"
2291   [(set_attr "type" "ssecvt")
2292    (set_attr "prefix" "maybe_vex")
2293    (set_attr "mode" "<sseinsnmode>")])
2294
2295 (define_expand "floatuns<sseintvecmodelower><mode>2"
2296   [(match_operand:VF1 0 "register_operand" "")
2297    (match_operand:<sseintvecmode> 1 "register_operand" "")]
2298   "TARGET_SSE2 && (<MODE>mode == V4SFmode || TARGET_AVX2)"
2299 {
2300   ix86_expand_vector_convert_uns_vsivsf (operands[0], operands[1]);
2301   DONE;
2302 })
2303
2304 (define_insn "avx_cvtps2dq256"
2305   [(set (match_operand:V8SI 0 "register_operand" "=x")
2306         (unspec:V8SI [(match_operand:V8SF 1 "nonimmediate_operand" "xm")]
2307                      UNSPEC_FIX_NOTRUNC))]
2308   "TARGET_AVX"
2309   "vcvtps2dq\t{%1, %0|%0, %1}"
2310   [(set_attr "type" "ssecvt")
2311    (set_attr "prefix" "vex")
2312    (set_attr "mode" "OI")])
2313
2314 (define_insn "sse2_cvtps2dq"
2315   [(set (match_operand:V4SI 0 "register_operand" "=x")
2316         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2317                      UNSPEC_FIX_NOTRUNC))]
2318   "TARGET_SSE2"
2319   "%vcvtps2dq\t{%1, %0|%0, %1}"
2320   [(set_attr "type" "ssecvt")
2321    (set (attr "prefix_data16")
2322      (if_then_else
2323        (match_test "TARGET_AVX")
2324      (const_string "*")
2325      (const_string "1")))
2326    (set_attr "prefix" "maybe_vex")
2327    (set_attr "mode" "TI")])
2328
2329 (define_insn "fix_truncv8sfv8si2"
2330   [(set (match_operand:V8SI 0 "register_operand" "=x")
2331         (fix:V8SI (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
2332   "TARGET_AVX"
2333   "vcvttps2dq\t{%1, %0|%0, %1}"
2334   [(set_attr "type" "ssecvt")
2335    (set_attr "prefix" "vex")
2336    (set_attr "mode" "OI")])
2337
2338 (define_insn "fix_truncv4sfv4si2"
2339   [(set (match_operand:V4SI 0 "register_operand" "=x")
2340         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2341   "TARGET_SSE2"
2342   "%vcvttps2dq\t{%1, %0|%0, %1}"
2343   [(set_attr "type" "ssecvt")
2344    (set (attr "prefix_rep")
2345      (if_then_else
2346        (match_test "TARGET_AVX")
2347      (const_string "*")
2348      (const_string "1")))
2349    (set (attr "prefix_data16")
2350      (if_then_else
2351        (match_test "TARGET_AVX")
2352      (const_string "*")
2353      (const_string "0")))
2354    (set_attr "prefix_data16" "0")
2355    (set_attr "prefix" "maybe_vex")
2356    (set_attr "mode" "TI")])
2357
2358 (define_expand "fixuns_trunc<mode><sseintvecmodelower>2"
2359   [(match_operand:<sseintvecmode> 0 "register_operand" "")
2360    (match_operand:VF1 1 "register_operand" "")]
2361   "TARGET_SSE2"
2362 {
2363   rtx tmp[3];
2364   tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
2365   tmp[1] = gen_reg_rtx (<sseintvecmode>mode);
2366   emit_insn (gen_fix_trunc<mode><sseintvecmodelower>2 (tmp[1], tmp[0]));
2367   emit_insn (gen_xor<sseintvecmodelower>3 (operands[0], tmp[1], tmp[2]));
2368   DONE;
2369 })
2370
2371 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2372 ;;
2373 ;; Parallel double-precision floating point conversion operations
2374 ;;
2375 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2376
2377 (define_insn "sse2_cvtpi2pd"
2378   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2379         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2380   "TARGET_SSE2"
2381   "cvtpi2pd\t{%1, %0|%0, %1}"
2382   [(set_attr "type" "ssecvt")
2383    (set_attr "unit" "mmx,*")
2384    (set_attr "prefix_data16" "1,*")
2385    (set_attr "mode" "V2DF")])
2386
2387 (define_insn "sse2_cvtpd2pi"
2388   [(set (match_operand:V2SI 0 "register_operand" "=y")
2389         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2390                      UNSPEC_FIX_NOTRUNC))]
2391   "TARGET_SSE2"
2392   "cvtpd2pi\t{%1, %0|%0, %1}"
2393   [(set_attr "type" "ssecvt")
2394    (set_attr "unit" "mmx")
2395    (set_attr "bdver1_decode" "double")
2396    (set_attr "prefix_data16" "1")
2397    (set_attr "mode" "DI")])
2398
2399 (define_insn "sse2_cvttpd2pi"
2400   [(set (match_operand:V2SI 0 "register_operand" "=y")
2401         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2402   "TARGET_SSE2"
2403   "cvttpd2pi\t{%1, %0|%0, %1}"
2404   [(set_attr "type" "ssecvt")
2405    (set_attr "unit" "mmx")
2406    (set_attr "bdver1_decode" "double")
2407    (set_attr "prefix_data16" "1")
2408    (set_attr "mode" "TI")])
2409
2410 (define_insn "sse2_cvtsi2sd"
2411   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
2412         (vec_merge:V2DF
2413           (vec_duplicate:V2DF
2414             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
2415           (match_operand:V2DF 1 "register_operand" "0,0,x")
2416           (const_int 1)))]
2417   "TARGET_SSE2"
2418   "@
2419    cvtsi2sd\t{%2, %0|%0, %2}
2420    cvtsi2sd\t{%2, %0|%0, %2}
2421    vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2422   [(set_attr "isa" "noavx,noavx,avx")
2423    (set_attr "type" "sseicvt")
2424    (set_attr "athlon_decode" "double,direct,*")
2425    (set_attr "amdfam10_decode" "vector,double,*")
2426    (set_attr "bdver1_decode" "double,direct,*")
2427    (set_attr "prefix" "orig,orig,vex")
2428    (set_attr "mode" "DF")])
2429
2430 (define_insn "sse2_cvtsi2sdq"
2431   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
2432         (vec_merge:V2DF
2433           (vec_duplicate:V2DF
2434             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m,rm")))
2435           (match_operand:V2DF 1 "register_operand" "0,0,x")
2436           (const_int 1)))]
2437   "TARGET_SSE2 && TARGET_64BIT"
2438   "@
2439    cvtsi2sdq\t{%2, %0|%0, %2}
2440    cvtsi2sdq\t{%2, %0|%0, %2}
2441    vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2442   [(set_attr "isa" "noavx,noavx,avx")
2443    (set_attr "type" "sseicvt")
2444    (set_attr "athlon_decode" "double,direct,*")
2445    (set_attr "amdfam10_decode" "vector,double,*")
2446    (set_attr "bdver1_decode" "double,direct,*")
2447    (set_attr "length_vex" "*,*,4")
2448    (set_attr "prefix_rex" "1,1,*")
2449    (set_attr "prefix" "orig,orig,vex")
2450    (set_attr "mode" "DF")])
2451
2452 (define_insn "sse2_cvtsd2si"
2453   [(set (match_operand:SI 0 "register_operand" "=r,r")
2454         (unspec:SI
2455           [(vec_select:DF
2456              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2457              (parallel [(const_int 0)]))]
2458           UNSPEC_FIX_NOTRUNC))]
2459   "TARGET_SSE2"
2460   "%vcvtsd2si\t{%1, %0|%0, %1}"
2461   [(set_attr "type" "sseicvt")
2462    (set_attr "athlon_decode" "double,vector")
2463    (set_attr "bdver1_decode" "double,double")
2464    (set_attr "prefix_rep" "1")
2465    (set_attr "prefix" "maybe_vex")
2466    (set_attr "mode" "SI")])
2467
2468 (define_insn "sse2_cvtsd2si_2"
2469   [(set (match_operand:SI 0 "register_operand" "=r,r")
2470         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2471                    UNSPEC_FIX_NOTRUNC))]
2472   "TARGET_SSE2"
2473   "%vcvtsd2si\t{%1, %0|%0, %1}"
2474   [(set_attr "type" "sseicvt")
2475    (set_attr "athlon_decode" "double,vector")
2476    (set_attr "amdfam10_decode" "double,double")
2477    (set_attr "bdver1_decode" "double,double")
2478    (set_attr "prefix_rep" "1")
2479    (set_attr "prefix" "maybe_vex")
2480    (set_attr "mode" "SI")])
2481
2482 (define_insn "sse2_cvtsd2siq"
2483   [(set (match_operand:DI 0 "register_operand" "=r,r")
2484         (unspec:DI
2485           [(vec_select:DF
2486              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2487              (parallel [(const_int 0)]))]
2488           UNSPEC_FIX_NOTRUNC))]
2489   "TARGET_SSE2 && TARGET_64BIT"
2490   "%vcvtsd2si{q}\t{%1, %0|%0, %1}"
2491   [(set_attr "type" "sseicvt")
2492    (set_attr "athlon_decode" "double,vector")
2493    (set_attr "bdver1_decode" "double,double")
2494    (set_attr "prefix_rep" "1")
2495    (set_attr "prefix" "maybe_vex")
2496    (set_attr "mode" "DI")])
2497
2498 (define_insn "sse2_cvtsd2siq_2"
2499   [(set (match_operand:DI 0 "register_operand" "=r,r")
2500         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2501                    UNSPEC_FIX_NOTRUNC))]
2502   "TARGET_SSE2 && TARGET_64BIT"
2503   "%vcvtsd2si{q}\t{%1, %0|%0, %1}"
2504   [(set_attr "type" "sseicvt")
2505    (set_attr "athlon_decode" "double,vector")
2506    (set_attr "amdfam10_decode" "double,double")
2507    (set_attr "bdver1_decode" "double,double")
2508    (set_attr "prefix_rep" "1")
2509    (set_attr "prefix" "maybe_vex")
2510    (set_attr "mode" "DI")])
2511
2512 (define_insn "sse2_cvttsd2si"
2513   [(set (match_operand:SI 0 "register_operand" "=r,r")
2514         (fix:SI
2515           (vec_select:DF
2516             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2517             (parallel [(const_int 0)]))))]
2518   "TARGET_SSE2"
2519   "%vcvttsd2si\t{%1, %0|%0, %1}"
2520   [(set_attr "type" "sseicvt")
2521    (set_attr "athlon_decode" "double,vector")
2522    (set_attr "amdfam10_decode" "double,double")
2523    (set_attr "bdver1_decode" "double,double")
2524    (set_attr "prefix_rep" "1")
2525    (set_attr "prefix" "maybe_vex")
2526    (set_attr "mode" "SI")])
2527
2528 (define_insn "sse2_cvttsd2siq"
2529   [(set (match_operand:DI 0 "register_operand" "=r,r")
2530         (fix:DI
2531           (vec_select:DF
2532             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2533             (parallel [(const_int 0)]))))]
2534   "TARGET_SSE2 && TARGET_64BIT"
2535   "%vcvttsd2si{q}\t{%1, %0|%0, %1}"
2536   [(set_attr "type" "sseicvt")
2537    (set_attr "athlon_decode" "double,vector")
2538    (set_attr "amdfam10_decode" "double,double")
2539    (set_attr "bdver1_decode" "double,double")
2540    (set_attr "prefix_rep" "1")
2541    (set_attr "prefix" "maybe_vex")
2542    (set_attr "mode" "DI")])
2543
2544 (define_insn "floatv4siv4df2"
2545   [(set (match_operand:V4DF 0 "register_operand" "=x")
2546         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2547   "TARGET_AVX"
2548   "vcvtdq2pd\t{%1, %0|%0, %1}"
2549   [(set_attr "type" "ssecvt")
2550    (set_attr "prefix" "vex")
2551    (set_attr "mode" "V4DF")])
2552
2553 (define_insn "avx_cvtdq2pd256_2"
2554   [(set (match_operand:V4DF 0 "register_operand" "=x")
2555         (float:V4DF
2556           (vec_select:V4SI
2557             (match_operand:V8SI 1 "nonimmediate_operand" "xm")
2558             (parallel [(const_int 0) (const_int 1)
2559                        (const_int 2) (const_int 3)]))))]
2560   "TARGET_AVX"
2561   "vcvtdq2pd\t{%x1, %0|%0, %x1}"
2562   [(set_attr "type" "ssecvt")
2563    (set_attr "prefix" "vex")
2564    (set_attr "mode" "V4DF")])
2565
2566 (define_insn "sse2_cvtdq2pd"
2567   [(set (match_operand:V2DF 0 "register_operand" "=x")
2568         (float:V2DF
2569           (vec_select:V2SI
2570             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2571             (parallel [(const_int 0) (const_int 1)]))))]
2572   "TARGET_SSE2"
2573   "%vcvtdq2pd\t{%1, %0|%0, %q1}"
2574   [(set_attr "type" "ssecvt")
2575    (set_attr "prefix" "maybe_vex")
2576    (set_attr "mode" "V2DF")])
2577
2578 (define_insn "avx_cvtpd2dq256"
2579   [(set (match_operand:V4SI 0 "register_operand" "=x")
2580         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2581                      UNSPEC_FIX_NOTRUNC))]
2582   "TARGET_AVX"
2583   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2584   [(set_attr "type" "ssecvt")
2585    (set_attr "prefix" "vex")
2586    (set_attr "mode" "OI")])
2587
2588 (define_expand "avx_cvtpd2dq256_2"
2589   [(set (match_operand:V8SI 0 "register_operand" "")
2590         (vec_concat:V8SI
2591           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "")]
2592                        UNSPEC_FIX_NOTRUNC)
2593           (match_dup 2)))]
2594   "TARGET_AVX"
2595   "operands[2] = CONST0_RTX (V4SImode);")
2596
2597 (define_insn "*avx_cvtpd2dq256_2"
2598   [(set (match_operand:V8SI 0 "register_operand" "=x")
2599         (vec_concat:V8SI
2600           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2601                        UNSPEC_FIX_NOTRUNC)
2602           (match_operand:V4SI 2 "const0_operand" "")))]
2603   "TARGET_AVX"
2604   "vcvtpd2dq{y}\t{%1, %x0|%x0, %1}"
2605   [(set_attr "type" "ssecvt")
2606    (set_attr "prefix" "vex")
2607    (set_attr "mode" "OI")])
2608
2609 (define_expand "sse2_cvtpd2dq"
2610   [(set (match_operand:V4SI 0 "register_operand" "")
2611         (vec_concat:V4SI
2612           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2613                        UNSPEC_FIX_NOTRUNC)
2614           (match_dup 2)))]
2615   "TARGET_SSE2"
2616   "operands[2] = CONST0_RTX (V2SImode);")
2617
2618 (define_insn "*sse2_cvtpd2dq"
2619   [(set (match_operand:V4SI 0 "register_operand" "=x")
2620         (vec_concat:V4SI
2621           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2622                        UNSPEC_FIX_NOTRUNC)
2623           (match_operand:V2SI 2 "const0_operand" "")))]
2624   "TARGET_SSE2"
2625 {
2626   if (TARGET_AVX)
2627     return "vcvtpd2dq{x}\t{%1, %0|%0, %1}";
2628   else
2629     return "cvtpd2dq\t{%1, %0|%0, %1}";
2630 }
2631   [(set_attr "type" "ssecvt")
2632    (set_attr "prefix_rep" "1")
2633    (set_attr "prefix_data16" "0")
2634    (set_attr "prefix" "maybe_vex")
2635    (set_attr "mode" "TI")
2636    (set_attr "amdfam10_decode" "double")
2637    (set_attr "athlon_decode" "vector")
2638    (set_attr "bdver1_decode" "double")])
2639
2640 (define_insn "fix_truncv4dfv4si2"
2641   [(set (match_operand:V4SI 0 "register_operand" "=x")
2642         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2643   "TARGET_AVX"
2644   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2645   [(set_attr "type" "ssecvt")
2646    (set_attr "prefix" "vex")
2647    (set_attr "mode" "OI")])
2648
2649 (define_expand "avx_cvttpd2dq256_2"
2650   [(set (match_operand:V8SI 0 "register_operand" "")
2651         (vec_concat:V8SI
2652           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" ""))
2653           (match_dup 2)))]
2654   "TARGET_AVX"
2655   "operands[2] = CONST0_RTX (V4SImode);")
2656
2657 (define_insn "*avx_cvttpd2dq256_2"
2658   [(set (match_operand:V8SI 0 "register_operand" "=x")
2659         (vec_concat:V8SI
2660           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm"))
2661           (match_operand:V4SI 2 "const0_operand" "")))]
2662   "TARGET_AVX"
2663   "vcvttpd2dq{y}\t{%1, %x0|%x0, %1}"
2664   [(set_attr "type" "ssecvt")
2665    (set_attr "prefix" "vex")
2666    (set_attr "mode" "OI")])
2667
2668 (define_expand "sse2_cvttpd2dq"
2669   [(set (match_operand:V4SI 0 "register_operand" "")
2670         (vec_concat:V4SI
2671           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2672           (match_dup 2)))]
2673   "TARGET_SSE2"
2674   "operands[2] = CONST0_RTX (V2SImode);")
2675
2676 (define_insn "*sse2_cvttpd2dq"
2677   [(set (match_operand:V4SI 0 "register_operand" "=x")
2678         (vec_concat:V4SI
2679           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2680           (match_operand:V2SI 2 "const0_operand" "")))]
2681   "TARGET_SSE2"
2682 {
2683   if (TARGET_AVX)
2684     return "vcvttpd2dq{x}\t{%1, %0|%0, %1}";
2685   else
2686     return "cvttpd2dq\t{%1, %0|%0, %1}";
2687 }
2688   [(set_attr "type" "ssecvt")
2689    (set_attr "amdfam10_decode" "double")
2690    (set_attr "athlon_decode" "vector")
2691    (set_attr "bdver1_decode" "double")
2692    (set_attr "prefix" "maybe_vex")
2693    (set_attr "mode" "TI")])
2694
2695 (define_insn "sse2_cvtsd2ss"
2696   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2697         (vec_merge:V4SF
2698           (vec_duplicate:V4SF
2699             (float_truncate:V2SF
2700               (match_operand:V2DF 2 "nonimmediate_operand" "x,m,xm")))
2701           (match_operand:V4SF 1 "register_operand" "0,0,x")
2702           (const_int 1)))]
2703   "TARGET_SSE2"
2704   "@
2705    cvtsd2ss\t{%2, %0|%0, %2}
2706    cvtsd2ss\t{%2, %0|%0, %2}
2707    vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2708   [(set_attr "isa" "noavx,noavx,avx")
2709    (set_attr "type" "ssecvt")
2710    (set_attr "athlon_decode" "vector,double,*")
2711    (set_attr "amdfam10_decode" "vector,double,*")
2712    (set_attr "bdver1_decode" "direct,direct,*")
2713    (set_attr "prefix" "orig,orig,vex")
2714    (set_attr "mode" "SF")])
2715
2716 (define_insn "sse2_cvtss2sd"
2717   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
2718         (vec_merge:V2DF
2719           (float_extend:V2DF
2720             (vec_select:V2SF
2721               (match_operand:V4SF 2 "nonimmediate_operand" "x,m,xm")
2722               (parallel [(const_int 0) (const_int 1)])))
2723           (match_operand:V2DF 1 "register_operand" "0,0,x")
2724           (const_int 1)))]
2725   "TARGET_SSE2"
2726   "@
2727    cvtss2sd\t{%2, %0|%0, %2}
2728    cvtss2sd\t{%2, %0|%0, %2}
2729    vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2730   [(set_attr "isa" "noavx,noavx,avx")
2731    (set_attr "type" "ssecvt")
2732    (set_attr "amdfam10_decode" "vector,double,*")
2733    (set_attr "athlon_decode" "direct,direct,*")
2734    (set_attr "bdver1_decode" "direct,direct,*")
2735    (set_attr "prefix" "orig,orig,vex")
2736    (set_attr "mode" "DF")])
2737
2738 (define_insn "avx_cvtpd2ps256"
2739   [(set (match_operand:V4SF 0 "register_operand" "=x")
2740         (float_truncate:V4SF
2741           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2742   "TARGET_AVX"
2743   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
2744   [(set_attr "type" "ssecvt")
2745    (set_attr "prefix" "vex")
2746    (set_attr "mode" "V4SF")])
2747
2748 (define_expand "sse2_cvtpd2ps"
2749   [(set (match_operand:V4SF 0 "register_operand" "")
2750         (vec_concat:V4SF
2751           (float_truncate:V2SF
2752             (match_operand:V2DF 1 "nonimmediate_operand" ""))
2753           (match_dup 2)))]
2754   "TARGET_SSE2"
2755   "operands[2] = CONST0_RTX (V2SFmode);")
2756
2757 (define_insn "*sse2_cvtpd2ps"
2758   [(set (match_operand:V4SF 0 "register_operand" "=x")
2759         (vec_concat:V4SF
2760           (float_truncate:V2SF
2761             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2762           (match_operand:V2SF 2 "const0_operand" "")))]
2763   "TARGET_SSE2"
2764 {
2765   if (TARGET_AVX)
2766     return "vcvtpd2ps{x}\t{%1, %0|%0, %1}";
2767   else
2768     return "cvtpd2ps\t{%1, %0|%0, %1}";
2769 }
2770   [(set_attr "type" "ssecvt")
2771    (set_attr "amdfam10_decode" "double")
2772    (set_attr "athlon_decode" "vector")
2773    (set_attr "bdver1_decode" "double")
2774    (set_attr "prefix_data16" "1")
2775    (set_attr "prefix" "maybe_vex")
2776    (set_attr "mode" "V4SF")])
2777
2778 (define_insn "avx_cvtps2pd256"
2779   [(set (match_operand:V4DF 0 "register_operand" "=x")
2780         (float_extend:V4DF
2781           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2782   "TARGET_AVX"
2783   "vcvtps2pd\t{%1, %0|%0, %1}"
2784   [(set_attr "type" "ssecvt")
2785    (set_attr "prefix" "vex")
2786    (set_attr "mode" "V4DF")])
2787
2788 (define_insn "*avx_cvtps2pd256_2"
2789   [(set (match_operand:V4DF 0 "register_operand" "=x")
2790         (float_extend:V4DF
2791           (vec_select:V4SF
2792             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
2793             (parallel [(const_int 0) (const_int 1)
2794                        (const_int 2) (const_int 3)]))))]
2795   "TARGET_AVX"
2796   "vcvtps2pd\t{%x1, %0|%0, %x1}"
2797   [(set_attr "type" "ssecvt")
2798    (set_attr "prefix" "vex")
2799    (set_attr "mode" "V4DF")])
2800
2801 (define_insn "sse2_cvtps2pd"
2802   [(set (match_operand:V2DF 0 "register_operand" "=x")
2803         (float_extend:V2DF
2804           (vec_select:V2SF
2805             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
2806             (parallel [(const_int 0) (const_int 1)]))))]
2807   "TARGET_SSE2"
2808   "%vcvtps2pd\t{%1, %0|%0, %q1}"
2809   [(set_attr "type" "ssecvt")
2810    (set_attr "amdfam10_decode" "direct")
2811    (set_attr "athlon_decode" "double")
2812    (set_attr "bdver1_decode" "double")
2813    (set_attr "prefix_data16" "0")
2814    (set_attr "prefix" "maybe_vex")
2815    (set_attr "mode" "V2DF")])
2816
2817 (define_expand "vec_unpacks_hi_v4sf"
2818   [(set (match_dup 2)
2819    (vec_select:V4SF
2820      (vec_concat:V8SF
2821        (match_dup 2)
2822        (match_operand:V4SF 1 "nonimmediate_operand" ""))
2823      (parallel [(const_int 6) (const_int 7)
2824                 (const_int 2) (const_int 3)])))
2825   (set (match_operand:V2DF 0 "register_operand" "")
2826    (float_extend:V2DF
2827      (vec_select:V2SF
2828        (match_dup 2)
2829        (parallel [(const_int 0) (const_int 1)]))))]
2830   "TARGET_SSE2"
2831   "operands[2] = gen_reg_rtx (V4SFmode);")
2832
2833 (define_expand "vec_unpacks_hi_v8sf"
2834   [(set (match_dup 2)
2835         (vec_select:V4SF
2836           (match_operand:V8SF 1 "nonimmediate_operand" "")
2837           (parallel [(const_int 4) (const_int 5)
2838                      (const_int 6) (const_int 7)])))
2839    (set (match_operand:V4DF 0 "register_operand" "")
2840         (float_extend:V4DF
2841           (match_dup 2)))]
2842   "TARGET_AVX"
2843   "operands[2] = gen_reg_rtx (V4SFmode);")
2844
2845 (define_expand "vec_unpacks_lo_v4sf"
2846   [(set (match_operand:V2DF 0 "register_operand" "")
2847         (float_extend:V2DF
2848           (vec_select:V2SF
2849             (match_operand:V4SF 1 "nonimmediate_operand" "")
2850             (parallel [(const_int 0) (const_int 1)]))))]
2851   "TARGET_SSE2")
2852
2853 (define_expand "vec_unpacks_lo_v8sf"
2854   [(set (match_operand:V4DF 0 "register_operand" "")
2855         (float_extend:V4DF
2856           (vec_select:V4SF
2857             (match_operand:V8SF 1 "nonimmediate_operand" "")
2858             (parallel [(const_int 0) (const_int 1)
2859                        (const_int 2) (const_int 3)]))))]
2860   "TARGET_AVX")
2861
2862 (define_mode_attr sseunpackfltmode
2863   [(V8HI "V4SF") (V4SI "V2DF") (V16HI "V8SF") (V8SI "V4DF")])
2864
2865 (define_expand "vec_unpacks_float_hi_<mode>"
2866   [(match_operand:<sseunpackfltmode> 0 "register_operand" "")
2867    (match_operand:VI2_AVX2 1 "register_operand" "")]
2868   "TARGET_SSE2"
2869 {
2870   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
2871
2872   emit_insn (gen_vec_unpacks_hi_<mode> (tmp, operands[1]));
2873   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2874                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
2875   DONE;
2876 })
2877
2878 (define_expand "vec_unpacks_float_lo_<mode>"
2879   [(match_operand:<sseunpackfltmode> 0 "register_operand" "")
2880    (match_operand:VI2_AVX2 1 "register_operand" "")]
2881   "TARGET_SSE2"
2882 {
2883   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
2884
2885   emit_insn (gen_vec_unpacks_lo_<mode> (tmp, operands[1]));
2886   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2887                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
2888   DONE;
2889 })
2890
2891 (define_expand "vec_unpacku_float_hi_<mode>"
2892   [(match_operand:<sseunpackfltmode> 0 "register_operand" "")
2893    (match_operand:VI2_AVX2 1 "register_operand" "")]
2894   "TARGET_SSE2"
2895 {
2896   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
2897
2898   emit_insn (gen_vec_unpacku_hi_<mode> (tmp, operands[1]));
2899   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2900                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
2901   DONE;
2902 })
2903
2904 (define_expand "vec_unpacku_float_lo_<mode>"
2905   [(match_operand:<sseunpackfltmode> 0 "register_operand" "")
2906    (match_operand:VI2_AVX2 1 "register_operand" "")]
2907   "TARGET_SSE2"
2908 {
2909   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
2910
2911   emit_insn (gen_vec_unpacku_lo_<mode> (tmp, operands[1]));
2912   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2913                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
2914   DONE;
2915 })
2916
2917 (define_expand "vec_unpacks_float_hi_v4si"
2918   [(set (match_dup 2)
2919         (vec_select:V4SI
2920           (match_operand:V4SI 1 "nonimmediate_operand" "")
2921           (parallel [(const_int 2) (const_int 3)
2922                      (const_int 2) (const_int 3)])))
2923    (set (match_operand:V2DF 0 "register_operand" "")
2924         (float:V2DF
2925           (vec_select:V2SI
2926           (match_dup 2)
2927             (parallel [(const_int 0) (const_int 1)]))))]
2928   "TARGET_SSE2"
2929   "operands[2] = gen_reg_rtx (V4SImode);")
2930
2931 (define_expand "vec_unpacks_float_lo_v4si"
2932   [(set (match_operand:V2DF 0 "register_operand" "")
2933         (float:V2DF
2934           (vec_select:V2SI
2935             (match_operand:V4SI 1 "nonimmediate_operand" "")
2936             (parallel [(const_int 0) (const_int 1)]))))]
2937   "TARGET_SSE2")
2938
2939 (define_expand "vec_unpacks_float_hi_v8si"
2940   [(set (match_dup 2)
2941         (vec_select:V4SI
2942           (match_operand:V8SI 1 "nonimmediate_operand" "")
2943           (parallel [(const_int 4) (const_int 5)
2944                      (const_int 6) (const_int 7)])))
2945    (set (match_operand:V4DF 0 "register_operand" "")
2946         (float:V4DF
2947           (match_dup 2)))]
2948   "TARGET_AVX"
2949   "operands[2] = gen_reg_rtx (V4SImode);")
2950
2951 (define_expand "vec_unpacks_float_lo_v8si"
2952   [(set (match_operand:V4DF 0 "register_operand" "")
2953         (float:V4DF
2954           (vec_select:V4SI
2955             (match_operand:V8SI 1 "nonimmediate_operand" "")
2956             (parallel [(const_int 0) (const_int 1)
2957                        (const_int 2) (const_int 3)]))))]
2958   "TARGET_AVX")
2959
2960 (define_expand "vec_unpacku_float_hi_v4si"
2961   [(set (match_dup 5)
2962         (vec_select:V4SI
2963           (match_operand:V4SI 1 "nonimmediate_operand" "")
2964           (parallel [(const_int 2) (const_int 3)
2965                      (const_int 2) (const_int 3)])))
2966    (set (match_dup 6)
2967         (float:V2DF
2968           (vec_select:V2SI
2969           (match_dup 5)
2970             (parallel [(const_int 0) (const_int 1)]))))
2971    (set (match_dup 7)
2972         (lt:V2DF (match_dup 6) (match_dup 3)))
2973    (set (match_dup 8)
2974         (and:V2DF (match_dup 7) (match_dup 4)))
2975    (set (match_operand:V2DF 0 "register_operand" "")
2976         (plus:V2DF (match_dup 6) (match_dup 8)))]
2977   "TARGET_SSE2"
2978 {
2979   REAL_VALUE_TYPE TWO32r;
2980   rtx x;
2981   int i;
2982
2983   real_ldexp (&TWO32r, &dconst1, 32);
2984   x = const_double_from_real_value (TWO32r, DFmode);
2985
2986   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
2987   operands[4] = force_reg (V2DFmode,
2988                            ix86_build_const_vector (V2DFmode, 1, x));
2989
2990   operands[5] = gen_reg_rtx (V4SImode);
2991
2992   for (i = 6; i < 9; i++)
2993     operands[i] = gen_reg_rtx (V2DFmode);
2994 })
2995
2996 (define_expand "vec_unpacku_float_lo_v4si"
2997   [(set (match_dup 5)
2998         (float:V2DF
2999           (vec_select:V2SI
3000             (match_operand:V4SI 1 "nonimmediate_operand" "")
3001             (parallel [(const_int 0) (const_int 1)]))))
3002    (set (match_dup 6)
3003         (lt:V2DF (match_dup 5) (match_dup 3)))
3004    (set (match_dup 7)
3005         (and:V2DF (match_dup 6) (match_dup 4)))
3006    (set (match_operand:V2DF 0 "register_operand" "")
3007         (plus:V2DF (match_dup 5) (match_dup 7)))]
3008   "TARGET_SSE2"
3009 {
3010   REAL_VALUE_TYPE TWO32r;
3011   rtx x;
3012   int i;
3013
3014   real_ldexp (&TWO32r, &dconst1, 32);
3015   x = const_double_from_real_value (TWO32r, DFmode);
3016
3017   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3018   operands[4] = force_reg (V2DFmode,
3019                            ix86_build_const_vector (V2DFmode, 1, x));
3020
3021   for (i = 5; i < 8; i++)
3022     operands[i] = gen_reg_rtx (V2DFmode);
3023 })
3024
3025 (define_expand "vec_unpacku_float_hi_v8si"
3026   [(match_operand:V4DF 0 "register_operand" "")
3027    (match_operand:V8SI 1 "register_operand" "")]
3028   "TARGET_AVX"
3029 {
3030   REAL_VALUE_TYPE TWO32r;
3031   rtx x, tmp[6];
3032   int i;
3033
3034   real_ldexp (&TWO32r, &dconst1, 32);
3035   x = const_double_from_real_value (TWO32r, DFmode);
3036
3037   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
3038   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
3039   tmp[5] = gen_reg_rtx (V4SImode);
3040
3041   for (i = 2; i < 5; i++)
3042     tmp[i] = gen_reg_rtx (V4DFmode);
3043   emit_insn (gen_vec_extract_hi_v8si (tmp[5], operands[1]));
3044   emit_insn (gen_floatv4siv4df2 (tmp[2], tmp[5]));
3045   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
3046                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
3047   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
3048   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
3049   DONE;
3050 })
3051
3052 (define_expand "vec_unpacku_float_lo_v8si"
3053   [(match_operand:V4DF 0 "register_operand" "")
3054    (match_operand:V8SI 1 "nonimmediate_operand" "")]
3055   "TARGET_AVX"
3056 {
3057   REAL_VALUE_TYPE TWO32r;
3058   rtx x, tmp[5];
3059   int i;
3060
3061   real_ldexp (&TWO32r, &dconst1, 32);
3062   x = const_double_from_real_value (TWO32r, DFmode);
3063
3064   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
3065   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
3066
3067   for (i = 2; i < 5; i++)
3068     tmp[i] = gen_reg_rtx (V4DFmode);
3069   emit_insn (gen_avx_cvtdq2pd256_2 (tmp[2], operands[1]));
3070   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
3071                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
3072   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
3073   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
3074   DONE;
3075 })
3076
3077 (define_expand "vec_pack_trunc_v4df"
3078   [(set (match_dup 3)
3079         (float_truncate:V4SF
3080           (match_operand:V4DF 1 "nonimmediate_operand" "")))
3081    (set (match_dup 4)
3082         (float_truncate:V4SF
3083           (match_operand:V4DF 2 "nonimmediate_operand" "")))
3084    (set (match_operand:V8SF 0 "register_operand" "")
3085         (vec_concat:V8SF
3086           (match_dup 3)
3087           (match_dup 4)))]
3088   "TARGET_AVX"
3089 {
3090   operands[3] = gen_reg_rtx (V4SFmode);
3091   operands[4] = gen_reg_rtx (V4SFmode);
3092 })
3093
3094 (define_expand "vec_pack_trunc_v2df"
3095   [(match_operand:V4SF 0 "register_operand" "")
3096    (match_operand:V2DF 1 "nonimmediate_operand" "")
3097    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3098   "TARGET_SSE2"
3099 {
3100   rtx tmp0, tmp1;
3101
3102   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3103     {
3104       tmp0 = gen_reg_rtx (V4DFmode);
3105       tmp1 = force_reg (V2DFmode, operands[1]);
3106
3107       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3108       emit_insn (gen_avx_cvtpd2ps256 (operands[0], tmp0));
3109     }
3110   else
3111     {
3112       tmp0 = gen_reg_rtx (V4SFmode);
3113       tmp1 = gen_reg_rtx (V4SFmode);
3114
3115       emit_insn (gen_sse2_cvtpd2ps (tmp0, operands[1]));
3116       emit_insn (gen_sse2_cvtpd2ps (tmp1, operands[2]));
3117       emit_insn (gen_sse_movlhps (operands[0], tmp0, tmp1));
3118     }
3119   DONE;
3120 })
3121
3122 (define_expand "vec_pack_sfix_trunc_v4df"
3123   [(match_operand:V8SI 0 "register_operand" "")
3124    (match_operand:V4DF 1 "nonimmediate_operand" "")
3125    (match_operand:V4DF 2 "nonimmediate_operand" "")]
3126   "TARGET_AVX"
3127 {
3128   rtx r1, r2;
3129
3130   r1 = gen_reg_rtx (V4SImode);
3131   r2 = gen_reg_rtx (V4SImode);
3132
3133   emit_insn (gen_fix_truncv4dfv4si2 (r1, operands[1]));
3134   emit_insn (gen_fix_truncv4dfv4si2 (r2, operands[2]));
3135   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
3136   DONE;
3137 })
3138
3139 (define_expand "vec_pack_sfix_trunc_v2df"
3140   [(match_operand:V4SI 0 "register_operand" "")
3141    (match_operand:V2DF 1 "nonimmediate_operand" "")
3142    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3143   "TARGET_SSE2"
3144 {
3145   rtx tmp0, tmp1;
3146
3147   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3148     {
3149       tmp0 = gen_reg_rtx (V4DFmode);
3150       tmp1 = force_reg (V2DFmode, operands[1]);
3151
3152       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3153       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp0));
3154     }
3155   else
3156     {
3157       tmp0 = gen_reg_rtx (V4SImode);
3158       tmp1 = gen_reg_rtx (V4SImode);
3159
3160       emit_insn (gen_sse2_cvttpd2dq (tmp0, operands[1]));
3161       emit_insn (gen_sse2_cvttpd2dq (tmp1, operands[2]));
3162       emit_insn
3163        (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3164                                     gen_lowpart (V2DImode, tmp0),
3165                                     gen_lowpart (V2DImode, tmp1)));
3166     }
3167   DONE;
3168 })
3169
3170 (define_mode_attr ssepackfltmode
3171   [(V4DF "V8SI") (V2DF "V4SI")])
3172
3173 (define_expand "vec_pack_ufix_trunc_<mode>"
3174   [(match_operand:<ssepackfltmode> 0 "register_operand" "")
3175    (match_operand:VF2 1 "register_operand" "")
3176    (match_operand:VF2 2 "register_operand" "")]
3177   "TARGET_SSE2"
3178 {
3179   rtx tmp[7];
3180   tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
3181   tmp[1] = ix86_expand_adjust_ufix_to_sfix_si (operands[2], &tmp[3]);
3182   tmp[4] = gen_reg_rtx (<ssepackfltmode>mode);
3183   emit_insn (gen_vec_pack_sfix_trunc_<mode> (tmp[4], tmp[0], tmp[1]));
3184   if (<ssepackfltmode>mode == V4SImode || TARGET_AVX2)
3185     {
3186       tmp[5] = gen_reg_rtx (<ssepackfltmode>mode);
3187       ix86_expand_vec_extract_even_odd (tmp[5], tmp[2], tmp[3], 0);
3188     }
3189   else
3190     {
3191       tmp[5] = gen_reg_rtx (V8SFmode);
3192       ix86_expand_vec_extract_even_odd (tmp[5], gen_lowpart (V8SFmode, tmp[2]),
3193                                         gen_lowpart (V8SFmode, tmp[3]), 0);
3194       tmp[5] = gen_lowpart (V8SImode, tmp[5]);
3195     }
3196   tmp[6] = expand_simple_binop (<ssepackfltmode>mode, XOR, tmp[4], tmp[5],
3197                                 operands[0], 0, OPTAB_DIRECT);
3198   if (tmp[6] != operands[0])
3199     emit_move_insn (operands[0], tmp[6]);
3200   DONE;
3201 })
3202
3203 (define_expand "vec_pack_sfix_v4df"
3204   [(match_operand:V8SI 0 "register_operand" "")
3205    (match_operand:V4DF 1 "nonimmediate_operand" "")
3206    (match_operand:V4DF 2 "nonimmediate_operand" "")]
3207   "TARGET_AVX"
3208 {
3209   rtx r1, r2;
3210
3211   r1 = gen_reg_rtx (V4SImode);
3212   r2 = gen_reg_rtx (V4SImode);
3213
3214   emit_insn (gen_avx_cvtpd2dq256 (r1, operands[1]));
3215   emit_insn (gen_avx_cvtpd2dq256 (r2, operands[2]));
3216   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
3217   DONE;
3218 })
3219
3220 (define_expand "vec_pack_sfix_v2df"
3221   [(match_operand:V4SI 0 "register_operand" "")
3222    (match_operand:V2DF 1 "nonimmediate_operand" "")
3223    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3224   "TARGET_SSE2"
3225 {
3226   rtx tmp0, tmp1;
3227
3228   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3229     {
3230       tmp0 = gen_reg_rtx (V4DFmode);
3231       tmp1 = force_reg (V2DFmode, operands[1]);
3232
3233       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3234       emit_insn (gen_avx_cvtpd2dq256 (operands[0], tmp0));
3235     }
3236   else
3237     {
3238       tmp0 = gen_reg_rtx (V4SImode);
3239       tmp1 = gen_reg_rtx (V4SImode);
3240
3241       emit_insn (gen_sse2_cvtpd2dq (tmp0, operands[1]));
3242       emit_insn (gen_sse2_cvtpd2dq (tmp1, operands[2]));
3243       emit_insn
3244        (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3245                                     gen_lowpart (V2DImode, tmp0),
3246                                     gen_lowpart (V2DImode, tmp1)));
3247     }
3248   DONE;
3249 })
3250
3251 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3252 ;;
3253 ;; Parallel single-precision floating point element swizzling
3254 ;;
3255 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3256
3257 (define_expand "sse_movhlps_exp"
3258   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3259         (vec_select:V4SF
3260           (vec_concat:V8SF
3261             (match_operand:V4SF 1 "nonimmediate_operand" "")
3262             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3263           (parallel [(const_int 6)
3264                      (const_int 7)
3265                      (const_int 2)
3266                      (const_int 3)])))]
3267   "TARGET_SSE"
3268 {
3269   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
3270
3271   emit_insn (gen_sse_movhlps (dst, operands[1], operands[2]));
3272
3273   /* Fix up the destination if needed.  */
3274   if (dst != operands[0])
3275     emit_move_insn (operands[0], dst);
3276
3277   DONE;
3278 })
3279
3280 (define_insn "sse_movhlps"
3281   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
3282         (vec_select:V4SF
3283           (vec_concat:V8SF
3284             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
3285             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,o,o,x"))
3286           (parallel [(const_int 6)
3287                      (const_int 7)
3288                      (const_int 2)
3289                      (const_int 3)])))]
3290   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3291   "@
3292    movhlps\t{%2, %0|%0, %2}
3293    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3294    movlps\t{%H2, %0|%0, %H2}
3295    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3296    %vmovhps\t{%2, %0|%0, %2}"
3297   [(set_attr "isa" "noavx,avx,noavx,avx,*")
3298    (set_attr "type" "ssemov")
3299    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
3300    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
3301
3302 (define_expand "sse_movlhps_exp"
3303   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3304         (vec_select:V4SF
3305           (vec_concat:V8SF
3306             (match_operand:V4SF 1 "nonimmediate_operand" "")
3307             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3308           (parallel [(const_int 0)
3309                      (const_int 1)
3310                      (const_int 4)
3311                      (const_int 5)])))]
3312   "TARGET_SSE"
3313 {
3314   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
3315
3316   emit_insn (gen_sse_movlhps (dst, operands[1], operands[2]));
3317
3318   /* Fix up the destination if needed.  */
3319   if (dst != operands[0])
3320     emit_move_insn (operands[0], dst);
3321
3322   DONE;
3323 })
3324
3325 (define_insn "sse_movlhps"
3326   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
3327         (vec_select:V4SF
3328           (vec_concat:V8SF
3329             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
3330             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,x,x"))
3331           (parallel [(const_int 0)
3332                      (const_int 1)
3333                      (const_int 4)
3334                      (const_int 5)])))]
3335   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3336   "@
3337    movlhps\t{%2, %0|%0, %2}
3338    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3339    movhps\t{%2, %0|%0, %2}
3340    vmovhps\t{%2, %1, %0|%0, %1, %2}
3341    %vmovlps\t{%2, %H0|%H0, %2}"
3342   [(set_attr "isa" "noavx,avx,noavx,avx,*")
3343    (set_attr "type" "ssemov")
3344    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
3345    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
3346
3347 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3348 (define_insn "avx_unpckhps256"
3349   [(set (match_operand:V8SF 0 "register_operand" "=x")
3350         (vec_select:V8SF
3351           (vec_concat:V16SF
3352             (match_operand:V8SF 1 "register_operand" "x")
3353             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3354           (parallel [(const_int 2) (const_int 10)
3355                      (const_int 3) (const_int 11)
3356                      (const_int 6) (const_int 14)
3357                      (const_int 7) (const_int 15)])))]
3358   "TARGET_AVX"
3359   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3360   [(set_attr "type" "sselog")
3361    (set_attr "prefix" "vex")
3362    (set_attr "mode" "V8SF")])
3363
3364 (define_expand "vec_interleave_highv8sf"
3365   [(set (match_dup 3)
3366         (vec_select:V8SF
3367           (vec_concat:V16SF
3368             (match_operand:V8SF 1 "register_operand" "x")
3369             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3370           (parallel [(const_int 0) (const_int 8)
3371                      (const_int 1) (const_int 9)
3372                      (const_int 4) (const_int 12)
3373                      (const_int 5) (const_int 13)])))
3374    (set (match_dup 4)
3375         (vec_select:V8SF
3376           (vec_concat:V16SF
3377             (match_dup 1)
3378             (match_dup 2))
3379           (parallel [(const_int 2) (const_int 10)
3380                      (const_int 3) (const_int 11)
3381                      (const_int 6) (const_int 14)
3382                      (const_int 7) (const_int 15)])))
3383    (set (match_operand:V8SF 0 "register_operand" "")
3384         (vec_select:V8SF
3385           (vec_concat:V16SF
3386             (match_dup 3)
3387             (match_dup 4))
3388           (parallel [(const_int 4) (const_int 5)
3389                      (const_int 6) (const_int 7)
3390                      (const_int 12) (const_int 13)
3391                      (const_int 14) (const_int 15)])))]
3392  "TARGET_AVX"
3393 {
3394   operands[3] = gen_reg_rtx (V8SFmode);
3395   operands[4] = gen_reg_rtx (V8SFmode);
3396 })
3397
3398 (define_insn "vec_interleave_highv4sf"
3399   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3400         (vec_select:V4SF
3401           (vec_concat:V8SF
3402             (match_operand:V4SF 1 "register_operand" "0,x")
3403             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
3404           (parallel [(const_int 2) (const_int 6)
3405                      (const_int 3) (const_int 7)])))]
3406   "TARGET_SSE"
3407   "@
3408    unpckhps\t{%2, %0|%0, %2}
3409    vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3410   [(set_attr "isa" "noavx,avx")
3411    (set_attr "type" "sselog")
3412    (set_attr "prefix" "orig,vex")
3413    (set_attr "mode" "V4SF")])
3414
3415 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3416 (define_insn "avx_unpcklps256"
3417   [(set (match_operand:V8SF 0 "register_operand" "=x")
3418         (vec_select:V8SF
3419           (vec_concat:V16SF
3420             (match_operand:V8SF 1 "register_operand" "x")
3421             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3422           (parallel [(const_int 0) (const_int 8)
3423                      (const_int 1) (const_int 9)
3424                      (const_int 4) (const_int 12)
3425                      (const_int 5) (const_int 13)])))]
3426   "TARGET_AVX"
3427   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3428   [(set_attr "type" "sselog")
3429    (set_attr "prefix" "vex")
3430    (set_attr "mode" "V8SF")])
3431
3432 (define_expand "vec_interleave_lowv8sf"
3433   [(set (match_dup 3)
3434         (vec_select:V8SF
3435           (vec_concat:V16SF
3436             (match_operand:V8SF 1 "register_operand" "x")
3437             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3438           (parallel [(const_int 0) (const_int 8)
3439                      (const_int 1) (const_int 9)
3440                      (const_int 4) (const_int 12)
3441                      (const_int 5) (const_int 13)])))
3442    (set (match_dup 4)
3443         (vec_select:V8SF
3444           (vec_concat:V16SF
3445             (match_dup 1)
3446             (match_dup 2))
3447           (parallel [(const_int 2) (const_int 10)
3448                      (const_int 3) (const_int 11)
3449                      (const_int 6) (const_int 14)
3450                      (const_int 7) (const_int 15)])))
3451    (set (match_operand:V8SF 0 "register_operand" "")
3452         (vec_select:V8SF
3453           (vec_concat:V16SF
3454             (match_dup 3)
3455             (match_dup 4))
3456           (parallel [(const_int 0) (const_int 1)
3457                      (const_int 2) (const_int 3)
3458                      (const_int 8) (const_int 9)
3459                      (const_int 10) (const_int 11)])))]
3460  "TARGET_AVX"
3461 {
3462   operands[3] = gen_reg_rtx (V8SFmode);
3463   operands[4] = gen_reg_rtx (V8SFmode);
3464 })
3465
3466 (define_insn "vec_interleave_lowv4sf"
3467   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3468         (vec_select:V4SF
3469           (vec_concat:V8SF
3470             (match_operand:V4SF 1 "register_operand" "0,x")
3471             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
3472           (parallel [(const_int 0) (const_int 4)
3473                      (const_int 1) (const_int 5)])))]
3474