OSDN Git Service

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