OSDN Git Service

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