OSDN Git Service

0baefd8470509bd3bdd42d29f202b044313667f4
[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 "<sse>_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" "0")
1491                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1492          (match_dup 1)
1493          (const_int 1)))]
1494   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1495   "cmp%D3s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1496   [(set_attr "type" "ssecmp")
1497    (set_attr "length_immediate" "1")
1498    (set_attr "mode" "<ssescalarmode>")])
1499
1500 (define_insn "<sse>_comi"
1501   [(set (reg:CCFP FLAGS_REG)
1502         (compare:CCFP
1503           (vec_select:MODEF
1504             (match_operand:<ssevecmode> 0 "register_operand" "x")
1505             (parallel [(const_int 0)]))
1506           (vec_select:MODEF
1507             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1508             (parallel [(const_int 0)]))))]
1509   "SSE_FLOAT_MODE_P (<MODE>mode)"
1510   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1511   [(set_attr "type" "ssecomi")
1512    (set_attr "prefix" "maybe_vex")
1513    (set_attr "prefix_rep" "0")
1514    (set (attr "prefix_data16")
1515         (if_then_else (eq_attr "mode" "DF")
1516                       (const_string "1")
1517                       (const_string "0")))
1518    (set_attr "mode" "<MODE>")])
1519
1520 (define_insn "<sse>_ucomi"
1521   [(set (reg:CCFPU FLAGS_REG)
1522         (compare:CCFPU
1523           (vec_select:MODEF
1524             (match_operand:<ssevecmode> 0 "register_operand" "x")
1525             (parallel [(const_int 0)]))
1526           (vec_select:MODEF
1527             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1528             (parallel [(const_int 0)]))))]
1529   "SSE_FLOAT_MODE_P (<MODE>mode)"
1530   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1531   [(set_attr "type" "ssecomi")
1532    (set_attr "prefix" "maybe_vex")
1533    (set_attr "prefix_rep" "0")
1534    (set (attr "prefix_data16")
1535         (if_then_else (eq_attr "mode" "DF")
1536                       (const_string "1")
1537                       (const_string "0")))
1538    (set_attr "mode" "<MODE>")])
1539
1540 (define_expand "vcond<mode>"
1541   [(set (match_operand:AVXMODEF2P 0 "register_operand" "")
1542         (if_then_else:AVXMODEF2P
1543           (match_operator 3 ""
1544             [(match_operand:AVXMODEF2P 4 "nonimmediate_operand" "")
1545              (match_operand:AVXMODEF2P 5 "nonimmediate_operand" "")])
1546           (match_operand:AVXMODEF2P 1 "general_operand" "")
1547           (match_operand:AVXMODEF2P 2 "general_operand" "")))]
1548   "(SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1549     || AVX_VEC_FLOAT_MODE_P (<MODE>mode))"
1550 {
1551   bool ok = ix86_expand_fp_vcond (operands);
1552   gcc_assert (ok);
1553   DONE;
1554 })
1555
1556 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1557 ;;
1558 ;; Parallel floating point logical operations
1559 ;;
1560 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1561
1562 (define_insn "avx_andnot<mode>3"
1563   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1564         (and:AVXMODEF2P
1565           (not:AVXMODEF2P
1566             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1567           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1568   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1569   "vandnp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1570   [(set_attr "type" "sselog")
1571    (set_attr "prefix" "vex")
1572    (set_attr "mode" "<avxvecmode>")])
1573
1574 (define_insn "<sse>_andnot<mode>3"
1575   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1576         (and:SSEMODEF2P
1577           (not:SSEMODEF2P
1578             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1579           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1580   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1581   "andnp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1582   [(set_attr "type" "sselog")
1583    (set_attr "mode" "<MODE>")])
1584
1585 (define_expand "<code><mode>3"
1586   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1587         (any_logic:AVX256MODEF2P
1588           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1589           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1590   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1591   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1592
1593 (define_insn "*avx_<code><mode>3"
1594   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1595         (any_logic:AVXMODEF2P
1596           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1597           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1598   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1599    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1600   "v<logic>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1601   [(set_attr "type" "sselog")
1602    (set_attr "prefix" "vex")
1603    (set_attr "mode" "<avxvecmode>")])
1604
1605 (define_expand "<code><mode>3"
1606   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1607         (any_logic:SSEMODEF2P
1608           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1609           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1610   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1611   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1612
1613 (define_insn "*<code><mode>3"
1614   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1615         (any_logic:SSEMODEF2P
1616           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1617           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1618   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1619    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1620   "<logic>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1621   [(set_attr "type" "sselog")
1622    (set_attr "mode" "<MODE>")])
1623
1624 (define_expand "copysign<mode>3"
1625   [(set (match_dup 4)
1626         (and:SSEMODEF2P 
1627           (not:SSEMODEF2P (match_dup 3))
1628           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")))
1629    (set (match_dup 5)
1630         (and:SSEMODEF2P (match_dup 3)
1631                         (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))
1632    (set (match_operand:SSEMODEF2P 0 "register_operand" "")
1633         (ior:SSEMODEF2P (match_dup 4) (match_dup 5)))]
1634   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1635 {
1636   operands[3] = ix86_build_signbit_mask (<ssescalarmode>mode, 1, 0);
1637
1638   operands[4] = gen_reg_rtx (<MODE>mode);
1639   operands[5] = gen_reg_rtx (<MODE>mode);
1640 })
1641
1642 ;; Also define scalar versions.  These are used for abs, neg, and
1643 ;; conditional move.  Using subregs into vector modes causes register
1644 ;; allocation lossage.  These patterns do not allow memory operands
1645 ;; because the native instructions read the full 128-bits.
1646
1647 (define_insn "*avx_andnot<mode>3"
1648   [(set (match_operand:MODEF 0 "register_operand" "=x")
1649         (and:MODEF
1650           (not:MODEF
1651             (match_operand:MODEF 1 "register_operand" "x"))
1652             (match_operand:MODEF 2 "register_operand" "x")))]
1653   "AVX_FLOAT_MODE_P (<MODE>mode)"
1654   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1655   [(set_attr "type" "sselog")
1656    (set_attr "prefix" "vex")
1657    (set_attr "mode" "<ssevecmode>")])
1658
1659 (define_insn "*andnot<mode>3"
1660   [(set (match_operand:MODEF 0 "register_operand" "=x")
1661         (and:MODEF
1662           (not:MODEF
1663             (match_operand:MODEF 1 "register_operand" "0"))
1664             (match_operand:MODEF 2 "register_operand" "x")))]
1665   "SSE_FLOAT_MODE_P (<MODE>mode)"
1666   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1667   [(set_attr "type" "sselog")
1668    (set_attr "mode" "<ssevecmode>")])
1669
1670 (define_insn "*avx_<code><mode>3"
1671   [(set (match_operand:MODEF 0 "register_operand" "=x")
1672         (any_logic:MODEF
1673           (match_operand:MODEF 1 "register_operand" "x")
1674           (match_operand:MODEF 2 "register_operand" "x")))]
1675   "AVX_FLOAT_MODE_P (<MODE>mode)"
1676   "v<logic>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1677   [(set_attr "type" "sselog")
1678    (set_attr "prefix" "vex")
1679    (set_attr "mode" "<ssevecmode>")])
1680
1681 (define_insn "*<code><mode>3"
1682   [(set (match_operand:MODEF 0 "register_operand" "=x")
1683         (any_logic:MODEF
1684           (match_operand:MODEF 1 "register_operand" "0")
1685           (match_operand:MODEF 2 "register_operand" "x")))]
1686   "SSE_FLOAT_MODE_P (<MODE>mode)"
1687   "<logic>p<ssemodefsuffix>\t{%2, %0|%0, %2}"
1688   [(set_attr "type" "sselog")
1689    (set_attr "mode" "<ssevecmode>")])
1690
1691 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1692 ;;
1693 ;; FMA4 floating point multiply/accumulate instructions.  This
1694 ;; includes the scalar version of the instructions as well as the
1695 ;; vector.
1696 ;;
1697 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1698
1699 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1700 ;; combine to generate a multiply/add with two memory references.  We then
1701 ;; split this insn, into loading up the destination register with one of the
1702 ;; memory operations.  If we don't manage to split the insn, reload will
1703 ;; generate the appropriate moves.  The reason this is needed, is that combine
1704 ;; has already folded one of the memory references into both the multiply and
1705 ;; add insns, and it can't generate a new pseudo.  I.e.:
1706 ;;      (set (reg1) (mem (addr1)))
1707 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1708 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1709
1710 (define_insn "fma4_fmadd<mode>4256"
1711   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1712         (plus:FMA4MODEF4
1713          (mult:FMA4MODEF4
1714           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1715           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1716          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1717   "TARGET_FMA4 && TARGET_FUSED_MADD"
1718   "vfmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1719   [(set_attr "type" "ssemuladd")
1720    (set_attr "mode" "<MODE>")])
1721
1722 ;; Floating multiply and subtract.
1723 (define_insn "fma4_fmsub<mode>4256"
1724   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1725         (minus:FMA4MODEF4
1726          (mult:FMA4MODEF4
1727           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1728           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1729          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1730   "TARGET_FMA4 && TARGET_FUSED_MADD"
1731   "vfmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1732   [(set_attr "type" "ssemuladd")
1733    (set_attr "mode" "<MODE>")])
1734
1735 ;; Floating point negative multiply and add.
1736 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1737 (define_insn "fma4_fnmadd<mode>4256"
1738   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1739         (minus:FMA4MODEF4
1740          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1741          (mult:FMA4MODEF4
1742           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1743           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))))]
1744   "TARGET_FMA4 && TARGET_FUSED_MADD"
1745   "vfnmadd<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 subtract.
1750 (define_insn "fma4_fnmsub<mode>4256"
1751   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1752         (minus:FMA4MODEF4
1753          (mult:FMA4MODEF4
1754           (neg:FMA4MODEF4
1755            (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1756           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1757          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1758   "TARGET_FMA4 && TARGET_FUSED_MADD"
1759   "vfnmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1760   [(set_attr "type" "ssemuladd")
1761    (set_attr "mode" "<MODE>")])
1762
1763 (define_insn "fma4_fmadd<mode>4"
1764   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1765         (plus:SSEMODEF4
1766          (mult:SSEMODEF4
1767           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1768           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1769          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1770   "TARGET_FMA4 && TARGET_FUSED_MADD"
1771   "vfmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1772   [(set_attr "type" "ssemuladd")
1773    (set_attr "mode" "<MODE>")])
1774
1775 ;; For the scalar operations, use operand1 for the upper words that aren't
1776 ;; modified, so restrict the forms that are generated.
1777 ;; Scalar version of fmadd.
1778 (define_insn "fma4_vmfmadd<mode>4"
1779   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1780         (vec_merge:SSEMODEF2P
1781          (plus:SSEMODEF2P
1782           (mult:SSEMODEF2P
1783            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1784            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1785           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1786          (match_dup 0)
1787          (const_int 1)))]
1788   "TARGET_FMA4 && TARGET_FUSED_MADD"
1789   "vfmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1790   [(set_attr "type" "ssemuladd")
1791    (set_attr "mode" "<MODE>")])
1792
1793 ;; Floating multiply and subtract.
1794 ;; Allow two memory operands the same as fmadd.
1795 (define_insn "fma4_fmsub<mode>4"
1796   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1797         (minus:SSEMODEF4
1798          (mult:SSEMODEF4
1799           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1800           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1801          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1802   "TARGET_FMA4 && TARGET_FUSED_MADD"
1803   "vfmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1804   [(set_attr "type" "ssemuladd")
1805    (set_attr "mode" "<MODE>")])
1806
1807 ;; For the scalar operations, use operand1 for the upper words that aren't
1808 ;; modified, so restrict the forms that are generated.
1809 ;; Scalar version of fmsub.
1810 (define_insn "fma4_vmfmsub<mode>4"
1811   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1812         (vec_merge:SSEMODEF2P
1813          (minus:SSEMODEF2P
1814           (mult:SSEMODEF2P
1815            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1816            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1817           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1818          (match_dup 0)
1819          (const_int 1)))]
1820   "TARGET_FMA4 && TARGET_FUSED_MADD"
1821   "vfmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1822   [(set_attr "type" "ssemuladd")
1823    (set_attr "mode" "<MODE>")])
1824
1825 ;; Floating point negative multiply and add.
1826 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1827 (define_insn "fma4_fnmadd<mode>4"
1828   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1829         (minus:SSEMODEF4
1830          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")
1831          (mult:SSEMODEF4
1832           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1833           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))))]
1834   "TARGET_FMA4 && TARGET_FUSED_MADD"
1835   "vfnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1836   [(set_attr "type" "ssemuladd")
1837    (set_attr "mode" "<MODE>")])
1838
1839 ;; For the scalar operations, use operand1 for the upper words that aren't
1840 ;; modified, so restrict the forms that are generated.
1841 ;; Scalar version of fnmadd.
1842 (define_insn "fma4_vmfnmadd<mode>4"
1843   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1844         (vec_merge:SSEMODEF2P
1845          (minus:SSEMODEF2P
1846           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1847           (mult:SSEMODEF2P
1848            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1849            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
1850          (match_dup 0)
1851          (const_int 1)))]
1852   "TARGET_FMA4 && TARGET_FUSED_MADD"
1853   "vfnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1854   [(set_attr "type" "ssemuladd")
1855    (set_attr "mode" "<MODE>")])
1856
1857 ;; Floating point negative multiply and subtract.
1858 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c.
1859 (define_insn "fma4_fnmsub<mode>4"
1860   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1861         (minus:SSEMODEF4
1862          (mult:SSEMODEF4
1863           (neg:SSEMODEF4
1864            (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x"))
1865           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1866          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1867   "TARGET_FMA4 && TARGET_FUSED_MADD"
1868   "vfnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1869   [(set_attr "type" "ssemuladd")
1870    (set_attr "mode" "<MODE>")])
1871
1872 ;; For the scalar operations, use operand1 for the upper words that aren't
1873 ;; modified, so restrict the forms that are generated.
1874 ;; Scalar version of fnmsub.
1875 (define_insn "fma4_vmfnmsub<mode>4"
1876   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1877         (vec_merge:SSEMODEF2P
1878          (minus:SSEMODEF2P
1879           (mult:SSEMODEF2P
1880            (neg:SSEMODEF2P
1881             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1882            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1883           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1884          (match_dup 0)
1885          (const_int 1)))]
1886   "TARGET_FMA4 && TARGET_FUSED_MADD"
1887   "vfnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1888   [(set_attr "type" "ssemuladd")
1889    (set_attr "mode" "<MODE>")])
1890
1891 (define_insn "fma4i_fmadd<mode>4256"
1892   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1893         (unspec:FMA4MODEF4
1894          [(plus:FMA4MODEF4
1895            (mult:FMA4MODEF4
1896             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1897             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1898            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1899          UNSPEC_FMA4_INTRINSIC))]
1900   "TARGET_FMA4 && TARGET_FUSED_MADD"
1901   "vfmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1902   [(set_attr "type" "ssemuladd")
1903    (set_attr "mode" "<MODE>")])
1904
1905 (define_insn "fma4i_fmsub<mode>4256"
1906   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1907         (unspec:FMA4MODEF4
1908          [(minus: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   "vfmsub<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_fnmadd<mode>4256"
1920   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1921         (unspec:FMA4MODEF4
1922          [(minus:FMA4MODEF4
1923            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1924            (mult:FMA4MODEF4
1925             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1926             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m")))]
1927          UNSPEC_FMA4_INTRINSIC))]
1928   "TARGET_FMA4 && TARGET_FUSED_MADD"
1929   "vfnmadd<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_fnmsub<mode>4256"
1934   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1935         (unspec:FMA4MODEF4
1936          [(minus:FMA4MODEF4
1937            (mult:FMA4MODEF4
1938             (neg:FMA4MODEF4
1939              (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1940             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1941            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1942          UNSPEC_FMA4_INTRINSIC))]
1943   "TARGET_FMA4 && TARGET_FUSED_MADD"
1944   "vfnmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1945   [(set_attr "type" "ssemuladd")
1946    (set_attr "mode" "<MODE>")])
1947
1948 (define_insn "fma4i_fmadd<mode>4"
1949   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1950         (unspec:SSEMODEF2P
1951          [(plus:SSEMODEF2P
1952            (mult:SSEMODEF2P
1953             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1954             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1955            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1956          UNSPEC_FMA4_INTRINSIC))]
1957   "TARGET_FMA4 && TARGET_FUSED_MADD"
1958   "vfmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1959   [(set_attr "type" "ssemuladd")
1960    (set_attr "mode" "<MODE>")])
1961
1962 (define_insn "fma4i_fmsub<mode>4"
1963   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1964         (unspec:SSEMODEF2P
1965          [(minus: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   "vfmsub<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_fnmadd<mode>4"
1977   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1978         (unspec:SSEMODEF2P
1979          [(minus:SSEMODEF2P
1980            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1981            (mult:SSEMODEF2P
1982             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1983             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))]
1984          UNSPEC_FMA4_INTRINSIC))]
1985   "TARGET_FMA4 && TARGET_FUSED_MADD"
1986   "vfnmadd<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_fnmsub<mode>4"
1991   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1992         (unspec:SSEMODEF2P
1993          [(minus:SSEMODEF2P
1994            (mult:SSEMODEF2P
1995             (neg:SSEMODEF2P
1996              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1997             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1998            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1999          UNSPEC_FMA4_INTRINSIC))]
2000   "TARGET_FMA4 && TARGET_FUSED_MADD"
2001   "vfnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2002   [(set_attr "type" "ssemuladd")
2003    (set_attr "mode" "<MODE>")])
2004
2005 ;; For the scalar operations, use operand1 for the upper words that aren't
2006 ;; modified, so restrict the forms that are accepted.
2007 (define_insn "fma4i_vmfmadd<mode>4"
2008   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2009         (unspec:SSEMODEF2P
2010          [(vec_merge:SSEMODEF2P
2011            (plus:SSEMODEF2P
2012             (mult:SSEMODEF2P
2013              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2014              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2015             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2016            (match_dup 0)
2017            (const_int 1))]
2018          UNSPEC_FMA4_INTRINSIC))]
2019   "TARGET_FMA4 && TARGET_FUSED_MADD"
2020   "vfmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2021   [(set_attr "type" "ssemuladd")
2022    (set_attr "mode" "<ssescalarmode>")])
2023
2024 (define_insn "fma4i_vmfmsub<mode>4"
2025   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2026         (unspec:SSEMODEF2P
2027          [(vec_merge:SSEMODEF2P
2028            (minus:SSEMODEF2P
2029             (mult:SSEMODEF2P
2030              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2031              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2032             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2033            (match_dup 0)
2034            (const_int 1))]
2035          UNSPEC_FMA4_INTRINSIC))]
2036   "TARGET_FMA4 && TARGET_FUSED_MADD"
2037   "vfmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2038   [(set_attr "type" "ssemuladd")
2039    (set_attr "mode" "<ssescalarmode>")])
2040
2041 (define_insn "fma4i_vmfnmadd<mode>4"
2042   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2043         (unspec:SSEMODEF2P
2044          [(vec_merge:SSEMODEF2P
2045            (minus:SSEMODEF2P
2046             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2047             (mult:SSEMODEF2P
2048              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2049              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
2050            (match_dup 0)
2051            (const_int 1))]
2052          UNSPEC_FMA4_INTRINSIC))]
2053   "TARGET_FMA4 && TARGET_FUSED_MADD"
2054   "vfnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2055   [(set_attr "type" "ssemuladd")
2056    (set_attr "mode" "<ssescalarmode>")])
2057
2058 (define_insn "fma4i_vmfnmsub<mode>4"
2059   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2060         (unspec:SSEMODEF2P
2061          [(vec_merge:SSEMODEF2P
2062            (minus:SSEMODEF2P
2063             (mult:SSEMODEF2P
2064              (neg:SSEMODEF2P
2065               (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
2066              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2067             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2068            (match_dup 0)
2069            (const_int 1))]
2070          UNSPEC_FMA4_INTRINSIC))]
2071   "TARGET_FMA4 && TARGET_FUSED_MADD"
2072   "vfnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2073   [(set_attr "type" "ssemuladd")
2074    (set_attr "mode" "<ssescalarmode>")])
2075
2076 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2077 ;;
2078 ;; FMA4 Parallel floating point multiply addsub and subadd operations.
2079 ;;
2080 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2081
2082 (define_insn "fma4_fmaddsubv8sf4"
2083   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2084         (vec_merge:V8SF
2085           (plus:V8SF
2086             (mult:V8SF
2087               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2088               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2089             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2090           (minus:V8SF
2091             (mult:V8SF
2092               (match_dup 1)
2093               (match_dup 2))
2094             (match_dup 3))
2095           (const_int 170)))]
2096   "TARGET_FMA4 && TARGET_FUSED_MADD"
2097   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2098   [(set_attr "type" "ssemuladd")
2099    (set_attr "mode" "V8SF")])
2100
2101 (define_insn "fma4_fmaddsubv4df4"
2102   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2103         (vec_merge:V4DF
2104           (plus:V4DF
2105             (mult:V4DF
2106               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2107               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2108             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2109           (minus:V4DF
2110             (mult:V4DF
2111               (match_dup 1)
2112               (match_dup 2))
2113             (match_dup 3))
2114           (const_int 10)))]
2115   "TARGET_FMA4 && TARGET_FUSED_MADD"
2116   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2117   [(set_attr "type" "ssemuladd")
2118    (set_attr "mode" "V4DF")])
2119
2120 (define_insn "fma4_fmaddsubv4sf4"
2121   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2122         (vec_merge:V4SF
2123           (plus:V4SF
2124             (mult:V4SF
2125               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2126               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2127             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2128           (minus:V4SF
2129             (mult:V4SF
2130               (match_dup 1)
2131               (match_dup 2))
2132             (match_dup 3))
2133           (const_int 10)))]
2134   "TARGET_FMA4 && TARGET_FUSED_MADD"
2135   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2136   [(set_attr "type" "ssemuladd")
2137    (set_attr "mode" "V4SF")])
2138
2139 (define_insn "fma4_fmaddsubv2df4"
2140   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2141         (vec_merge:V2DF
2142           (plus:V2DF
2143             (mult:V2DF
2144               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2145               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2146             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2147           (minus:V2DF
2148             (mult:V2DF
2149               (match_dup 1)
2150               (match_dup 2))
2151             (match_dup 3))
2152           (const_int 2)))]
2153   "TARGET_FMA4 && TARGET_FUSED_MADD"
2154   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2155   [(set_attr "type" "ssemuladd")
2156    (set_attr "mode" "V2DF")])
2157
2158 (define_insn "fma4_fmsubaddv8sf4"
2159   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2160         (vec_merge:V8SF
2161           (plus:V8SF
2162             (mult:V8SF
2163               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2164               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2165             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2166           (minus:V8SF
2167             (mult:V8SF
2168               (match_dup 1)
2169               (match_dup 2))
2170             (match_dup 3))
2171           (const_int 85)))]
2172   "TARGET_FMA4 && TARGET_FUSED_MADD"
2173   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2174   [(set_attr "type" "ssemuladd")
2175    (set_attr "mode" "V8SF")])
2176
2177 (define_insn "fma4_fmsubaddv4df4"
2178   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2179         (vec_merge:V4DF
2180           (plus:V4DF
2181             (mult:V4DF
2182               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2183               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2184             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2185           (minus:V4DF
2186             (mult:V4DF
2187               (match_dup 1)
2188               (match_dup 2))
2189             (match_dup 3))
2190           (const_int 5)))]
2191   "TARGET_FMA4 && TARGET_FUSED_MADD"
2192   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2193   [(set_attr "type" "ssemuladd")
2194    (set_attr "mode" "V4DF")])
2195
2196 (define_insn "fma4_fmsubaddv4sf4"
2197   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2198         (vec_merge:V4SF
2199           (plus:V4SF
2200             (mult:V4SF
2201               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2202               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2203             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2204           (minus:V4SF
2205             (mult:V4SF
2206               (match_dup 1)
2207               (match_dup 2))
2208             (match_dup 3))
2209           (const_int 5)))]
2210   "TARGET_FMA4 && TARGET_FUSED_MADD"
2211   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2212   [(set_attr "type" "ssemuladd")
2213    (set_attr "mode" "V4SF")])
2214
2215 (define_insn "fma4_fmsubaddv2df4"
2216   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2217         (vec_merge:V2DF
2218           (plus:V2DF
2219             (mult:V2DF
2220               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2221               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2222             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2223           (minus:V2DF
2224             (mult:V2DF
2225               (match_dup 1)
2226               (match_dup 2))
2227             (match_dup 3))
2228           (const_int 1)))]
2229   "TARGET_FMA4 && TARGET_FUSED_MADD"
2230   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2231   [(set_attr "type" "ssemuladd")
2232    (set_attr "mode" "V2DF")])
2233
2234 (define_insn "fma4i_fmaddsubv8sf4"
2235   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2236         (unspec:V8SF
2237          [(vec_merge:V8SF
2238            (plus:V8SF
2239              (mult:V8SF
2240                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2241                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2242              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2243            (minus:V8SF
2244              (mult:V8SF
2245                (match_dup 1)
2246                (match_dup 2))
2247              (match_dup 3))
2248            (const_int 170))]
2249          UNSPEC_FMA4_INTRINSIC))]
2250   "TARGET_FMA4 && TARGET_FUSED_MADD"
2251   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2252   [(set_attr "type" "ssemuladd")
2253    (set_attr "mode" "V8SF")])
2254
2255 (define_insn "fma4i_fmaddsubv4df4"
2256   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2257         (unspec:V4DF
2258          [(vec_merge:V4DF
2259            (plus:V4DF
2260              (mult:V4DF
2261                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2262                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2263              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2264            (minus:V4DF
2265              (mult:V4DF
2266                (match_dup 1)
2267                (match_dup 2))
2268              (match_dup 3))
2269            (const_int 10))]
2270          UNSPEC_FMA4_INTRINSIC))]
2271   "TARGET_FMA4 && TARGET_FUSED_MADD"
2272   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2273   [(set_attr "type" "ssemuladd")
2274    (set_attr "mode" "V4DF")])
2275
2276 (define_insn "fma4i_fmaddsubv4sf4"
2277   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2278         (unspec:V4SF
2279          [(vec_merge:V4SF
2280            (plus:V4SF
2281              (mult:V4SF
2282                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2283                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2284              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2285            (minus:V4SF
2286              (mult:V4SF
2287                (match_dup 1)
2288                (match_dup 2))
2289              (match_dup 3))
2290            (const_int 10))]
2291          UNSPEC_FMA4_INTRINSIC))]
2292   "TARGET_FMA4 && TARGET_FUSED_MADD"
2293   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2294   [(set_attr "type" "ssemuladd")
2295    (set_attr "mode" "V4SF")])
2296
2297 (define_insn "fma4i_fmaddsubv2df4"
2298   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2299         (unspec:V2DF
2300          [(vec_merge:V2DF
2301            (plus:V2DF
2302              (mult:V2DF
2303                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2304                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2305              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2306            (minus:V2DF
2307              (mult:V2DF
2308                (match_dup 1)
2309                (match_dup 2))
2310              (match_dup 3))
2311            (const_int 2))]
2312          UNSPEC_FMA4_INTRINSIC))]
2313   "TARGET_FMA4 && TARGET_FUSED_MADD"
2314   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2315   [(set_attr "type" "ssemuladd")
2316    (set_attr "mode" "V2DF")])
2317
2318 (define_insn "fma4i_fmsubaddv8sf4"
2319   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2320         (unspec:V8SF
2321          [(vec_merge:V8SF
2322            (plus:V8SF
2323              (mult:V8SF
2324                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2325                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2326              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2327            (minus:V8SF
2328              (mult:V8SF
2329                (match_dup 1)
2330                (match_dup 2))
2331              (match_dup 3))
2332            (const_int 85))]
2333          UNSPEC_FMA4_INTRINSIC))]
2334   "TARGET_FMA4 && TARGET_FUSED_MADD"
2335   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2336   [(set_attr "type" "ssemuladd")
2337    (set_attr "mode" "V8SF")])
2338
2339 (define_insn "fma4i_fmsubaddv4df4"
2340   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2341         (unspec:V4DF
2342          [(vec_merge:V4DF
2343            (plus:V4DF
2344              (mult:V4DF
2345                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2346                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2347              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2348            (minus:V4DF
2349              (mult:V4DF
2350                (match_dup 1)
2351                (match_dup 2))
2352              (match_dup 3))
2353            (const_int 5))]
2354          UNSPEC_FMA4_INTRINSIC))]
2355   "TARGET_FMA4 && TARGET_FUSED_MADD"
2356   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2357   [(set_attr "type" "ssemuladd")
2358    (set_attr "mode" "V4DF")])
2359
2360 (define_insn "fma4i_fmsubaddv4sf4"
2361   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2362         (unspec:V4SF
2363          [(vec_merge:V4SF
2364            (plus:V4SF
2365              (mult:V4SF
2366                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2367                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2368              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2369            (minus:V4SF
2370              (mult:V4SF
2371                (match_dup 1)
2372                (match_dup 2))
2373              (match_dup 3))
2374            (const_int 5))]
2375          UNSPEC_FMA4_INTRINSIC))]
2376   "TARGET_FMA4 && TARGET_FUSED_MADD"
2377   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2378   [(set_attr "type" "ssemuladd")
2379    (set_attr "mode" "V4SF")])
2380
2381 (define_insn "fma4i_fmsubaddv2df4"
2382   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2383         (unspec:V2DF
2384          [(vec_merge:V2DF
2385            (plus:V2DF
2386              (mult:V2DF
2387                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2388                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2389              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2390            (minus:V2DF
2391              (mult:V2DF
2392                (match_dup 1)
2393                (match_dup 2))
2394              (match_dup 3))
2395            (const_int 1))]
2396          UNSPEC_FMA4_INTRINSIC))]
2397   "TARGET_FMA4 && TARGET_FUSED_MADD"
2398   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2399   [(set_attr "type" "ssemuladd")
2400    (set_attr "mode" "V2DF")])
2401
2402 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2403 ;;
2404 ;; Parallel single-precision floating point conversion operations
2405 ;;
2406 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2407
2408 (define_insn "sse_cvtpi2ps"
2409   [(set (match_operand:V4SF 0 "register_operand" "=x")
2410         (vec_merge:V4SF
2411           (vec_duplicate:V4SF
2412             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2413           (match_operand:V4SF 1 "register_operand" "0")
2414           (const_int 3)))]
2415   "TARGET_SSE"
2416   "cvtpi2ps\t{%2, %0|%0, %2}"
2417   [(set_attr "type" "ssecvt")
2418    (set_attr "mode" "V4SF")])
2419
2420 (define_insn "sse_cvtps2pi"
2421   [(set (match_operand:V2SI 0 "register_operand" "=y")
2422         (vec_select:V2SI
2423           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2424                        UNSPEC_FIX_NOTRUNC)
2425           (parallel [(const_int 0) (const_int 1)])))]
2426   "TARGET_SSE"
2427   "cvtps2pi\t{%1, %0|%0, %1}"
2428   [(set_attr "type" "ssecvt")
2429    (set_attr "unit" "mmx")
2430    (set_attr "mode" "DI")])
2431
2432 (define_insn "sse_cvttps2pi"
2433   [(set (match_operand:V2SI 0 "register_operand" "=y")
2434         (vec_select:V2SI
2435           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2436           (parallel [(const_int 0) (const_int 1)])))]
2437   "TARGET_SSE"
2438   "cvttps2pi\t{%1, %0|%0, %1}"
2439   [(set_attr "type" "ssecvt")
2440    (set_attr "unit" "mmx")
2441    (set_attr "prefix_rep" "0")
2442    (set_attr "mode" "SF")])
2443
2444 (define_insn "*avx_cvtsi2ss"
2445   [(set (match_operand:V4SF 0 "register_operand" "=x")
2446         (vec_merge:V4SF
2447           (vec_duplicate:V4SF
2448             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2449           (match_operand:V4SF 1 "register_operand" "x")
2450           (const_int 1)))]
2451   "TARGET_AVX"
2452   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2453   [(set_attr "type" "sseicvt")
2454    (set_attr "prefix" "vex")
2455    (set_attr "mode" "SF")])
2456
2457 (define_insn "sse_cvtsi2ss"
2458   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2459         (vec_merge:V4SF
2460           (vec_duplicate:V4SF
2461             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2462           (match_operand:V4SF 1 "register_operand" "0,0")
2463           (const_int 1)))]
2464   "TARGET_SSE"
2465   "cvtsi2ss\t{%2, %0|%0, %2}"
2466   [(set_attr "type" "sseicvt")
2467    (set_attr "athlon_decode" "vector,double")
2468    (set_attr "amdfam10_decode" "vector,double")
2469    (set_attr "mode" "SF")])
2470
2471 (define_insn "*avx_cvtsi2ssq"
2472   [(set (match_operand:V4SF 0 "register_operand" "=x")
2473         (vec_merge:V4SF
2474           (vec_duplicate:V4SF
2475             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2476           (match_operand:V4SF 1 "register_operand" "x")
2477           (const_int 1)))]
2478   "TARGET_AVX && TARGET_64BIT"
2479   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2480   [(set_attr "type" "sseicvt")
2481    (set_attr "length_vex" "4")
2482    (set_attr "prefix" "vex")
2483    (set_attr "mode" "SF")])
2484
2485 (define_insn "sse_cvtsi2ssq"
2486   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2487         (vec_merge:V4SF
2488           (vec_duplicate:V4SF
2489             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2490           (match_operand:V4SF 1 "register_operand" "0,0")
2491           (const_int 1)))]
2492   "TARGET_SSE && TARGET_64BIT"
2493   "cvtsi2ssq\t{%2, %0|%0, %2}"
2494   [(set_attr "type" "sseicvt")
2495    (set_attr "prefix_rex" "1")
2496    (set_attr "athlon_decode" "vector,double")
2497    (set_attr "amdfam10_decode" "vector,double")
2498    (set_attr "mode" "SF")])
2499
2500 (define_insn "sse_cvtss2si"
2501   [(set (match_operand:SI 0 "register_operand" "=r,r")
2502         (unspec:SI
2503           [(vec_select:SF
2504              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2505              (parallel [(const_int 0)]))]
2506           UNSPEC_FIX_NOTRUNC))]
2507   "TARGET_SSE"
2508   "%vcvtss2si\t{%1, %0|%0, %1}"
2509   [(set_attr "type" "sseicvt")
2510    (set_attr "athlon_decode" "double,vector")
2511    (set_attr "prefix_rep" "1")
2512    (set_attr "prefix" "maybe_vex")
2513    (set_attr "mode" "SI")])
2514
2515 (define_insn "sse_cvtss2si_2"
2516   [(set (match_operand:SI 0 "register_operand" "=r,r")
2517         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2518                    UNSPEC_FIX_NOTRUNC))]
2519   "TARGET_SSE"
2520   "%vcvtss2si\t{%1, %0|%0, %1}"
2521   [(set_attr "type" "sseicvt")
2522    (set_attr "athlon_decode" "double,vector")
2523    (set_attr "amdfam10_decode" "double,double")
2524    (set_attr "prefix_rep" "1")
2525    (set_attr "prefix" "maybe_vex")
2526    (set_attr "mode" "SI")])
2527
2528 (define_insn "sse_cvtss2siq"
2529   [(set (match_operand:DI 0 "register_operand" "=r,r")
2530         (unspec:DI
2531           [(vec_select:SF
2532              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2533              (parallel [(const_int 0)]))]
2534           UNSPEC_FIX_NOTRUNC))]
2535   "TARGET_SSE && TARGET_64BIT"
2536   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2537   [(set_attr "type" "sseicvt")
2538    (set_attr "athlon_decode" "double,vector")
2539    (set_attr "prefix_rep" "1")
2540    (set_attr "prefix" "maybe_vex")
2541    (set_attr "mode" "DI")])
2542
2543 (define_insn "sse_cvtss2siq_2"
2544   [(set (match_operand:DI 0 "register_operand" "=r,r")
2545         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2546                    UNSPEC_FIX_NOTRUNC))]
2547   "TARGET_SSE && TARGET_64BIT"
2548   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2549   [(set_attr "type" "sseicvt")
2550    (set_attr "athlon_decode" "double,vector")
2551    (set_attr "amdfam10_decode" "double,double")
2552    (set_attr "prefix_rep" "1")
2553    (set_attr "prefix" "maybe_vex")
2554    (set_attr "mode" "DI")])
2555
2556 (define_insn "sse_cvttss2si"
2557   [(set (match_operand:SI 0 "register_operand" "=r,r")
2558         (fix:SI
2559           (vec_select:SF
2560             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2561             (parallel [(const_int 0)]))))]
2562   "TARGET_SSE"
2563   "%vcvttss2si\t{%1, %0|%0, %1}"
2564   [(set_attr "type" "sseicvt")
2565    (set_attr "athlon_decode" "double,vector")
2566    (set_attr "amdfam10_decode" "double,double")
2567    (set_attr "prefix_rep" "1")
2568    (set_attr "prefix" "maybe_vex")
2569    (set_attr "mode" "SI")])
2570
2571 (define_insn "sse_cvttss2siq"
2572   [(set (match_operand:DI 0 "register_operand" "=r,r")
2573         (fix:DI
2574           (vec_select:SF
2575             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2576             (parallel [(const_int 0)]))))]
2577   "TARGET_SSE && TARGET_64BIT"
2578   "%vcvttss2si{q}\t{%1, %0|%0, %1}"
2579   [(set_attr "type" "sseicvt")
2580    (set_attr "athlon_decode" "double,vector")
2581    (set_attr "amdfam10_decode" "double,double")
2582    (set_attr "prefix_rep" "1")
2583    (set_attr "prefix" "maybe_vex")
2584    (set_attr "mode" "DI")])
2585
2586 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2587   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2588         (float:AVXMODEDCVTDQ2PS
2589           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2590   "TARGET_AVX"
2591   "vcvtdq2ps\t{%1, %0|%0, %1}"
2592   [(set_attr "type" "ssecvt")
2593    (set_attr "prefix" "vex")
2594    (set_attr "mode" "<avxvecmode>")])
2595
2596 (define_insn "sse2_cvtdq2ps"
2597   [(set (match_operand:V4SF 0 "register_operand" "=x")
2598         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2599   "TARGET_SSE2"
2600   "cvtdq2ps\t{%1, %0|%0, %1}"
2601   [(set_attr "type" "ssecvt")
2602    (set_attr "mode" "V4SF")])
2603
2604 (define_expand "sse2_cvtudq2ps"
2605   [(set (match_dup 5)
2606         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "")))
2607    (set (match_dup 6)
2608         (lt:V4SF (match_dup 5) (match_dup 3)))
2609    (set (match_dup 7)
2610         (and:V4SF (match_dup 6) (match_dup 4)))
2611    (set (match_operand:V4SF 0 "register_operand" "")
2612         (plus:V4SF (match_dup 5) (match_dup 7)))]
2613   "TARGET_SSE2"
2614 {
2615   REAL_VALUE_TYPE TWO32r;
2616   rtx x;
2617   int i;
2618
2619   real_ldexp (&TWO32r, &dconst1, 32);
2620   x = const_double_from_real_value (TWO32r, SFmode);
2621
2622   operands[3] = force_reg (V4SFmode, CONST0_RTX (V4SFmode));
2623   operands[4] = force_reg (V4SFmode, ix86_build_const_vector (SFmode, 1, x));
2624
2625   for (i = 5; i < 8; i++)
2626     operands[i] = gen_reg_rtx (V4SFmode);
2627 })
2628
2629 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2630   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2631         (unspec:AVXMODEDCVTPS2DQ
2632           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2633           UNSPEC_FIX_NOTRUNC))]
2634   "TARGET_AVX"
2635   "vcvtps2dq\t{%1, %0|%0, %1}"
2636   [(set_attr "type" "ssecvt")
2637    (set_attr "prefix" "vex")
2638    (set_attr "mode" "<avxvecmode>")])
2639
2640 (define_insn "sse2_cvtps2dq"
2641   [(set (match_operand:V4SI 0 "register_operand" "=x")
2642         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2643                      UNSPEC_FIX_NOTRUNC))]
2644   "TARGET_SSE2"
2645   "cvtps2dq\t{%1, %0|%0, %1}"
2646   [(set_attr "type" "ssecvt")
2647    (set_attr "prefix_data16" "1")
2648    (set_attr "mode" "TI")])
2649
2650 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2651   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2652         (fix:AVXMODEDCVTPS2DQ
2653           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2654   "TARGET_AVX"
2655   "vcvttps2dq\t{%1, %0|%0, %1}"
2656   [(set_attr "type" "ssecvt")
2657    (set_attr "prefix" "vex")
2658    (set_attr "mode" "<avxvecmode>")])
2659
2660 (define_insn "sse2_cvttps2dq"
2661   [(set (match_operand:V4SI 0 "register_operand" "=x")
2662         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2663   "TARGET_SSE2"
2664   "cvttps2dq\t{%1, %0|%0, %1}"
2665   [(set_attr "type" "ssecvt")
2666    (set_attr "prefix_rep" "1")
2667    (set_attr "prefix_data16" "0")
2668    (set_attr "mode" "TI")])
2669
2670 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2671 ;;
2672 ;; Parallel double-precision floating point conversion operations
2673 ;;
2674 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2675
2676 (define_insn "sse2_cvtpi2pd"
2677   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2678         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2679   "TARGET_SSE2"
2680   "cvtpi2pd\t{%1, %0|%0, %1}"
2681   [(set_attr "type" "ssecvt")
2682    (set_attr "unit" "mmx,*")
2683    (set_attr "prefix_data16" "1,*")
2684    (set_attr "mode" "V2DF")])
2685
2686 (define_insn "sse2_cvtpd2pi"
2687   [(set (match_operand:V2SI 0 "register_operand" "=y")
2688         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2689                      UNSPEC_FIX_NOTRUNC))]
2690   "TARGET_SSE2"
2691   "cvtpd2pi\t{%1, %0|%0, %1}"
2692   [(set_attr "type" "ssecvt")
2693    (set_attr "unit" "mmx")
2694    (set_attr "prefix_data16" "1")
2695    (set_attr "mode" "DI")])
2696
2697 (define_insn "sse2_cvttpd2pi"
2698   [(set (match_operand:V2SI 0 "register_operand" "=y")
2699         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2700   "TARGET_SSE2"
2701   "cvttpd2pi\t{%1, %0|%0, %1}"
2702   [(set_attr "type" "ssecvt")
2703    (set_attr "unit" "mmx")
2704    (set_attr "prefix_data16" "1")
2705    (set_attr "mode" "TI")])
2706
2707 (define_insn "*avx_cvtsi2sd"
2708   [(set (match_operand:V2DF 0 "register_operand" "=x")
2709         (vec_merge:V2DF
2710           (vec_duplicate:V2DF
2711             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2712           (match_operand:V2DF 1 "register_operand" "x")
2713           (const_int 1)))]
2714   "TARGET_AVX"
2715   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2716   [(set_attr "type" "sseicvt")
2717    (set_attr "prefix" "vex")
2718    (set_attr "mode" "DF")])
2719
2720 (define_insn "sse2_cvtsi2sd"
2721   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2722         (vec_merge:V2DF
2723           (vec_duplicate:V2DF
2724             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2725           (match_operand:V2DF 1 "register_operand" "0,0")
2726           (const_int 1)))]
2727   "TARGET_SSE2"
2728   "cvtsi2sd\t{%2, %0|%0, %2}"
2729   [(set_attr "type" "sseicvt")
2730    (set_attr "mode" "DF")
2731    (set_attr "athlon_decode" "double,direct")
2732    (set_attr "amdfam10_decode" "vector,double")])
2733
2734 (define_insn "*avx_cvtsi2sdq"
2735   [(set (match_operand:V2DF 0 "register_operand" "=x")
2736         (vec_merge:V2DF
2737           (vec_duplicate:V2DF
2738             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2739           (match_operand:V2DF 1 "register_operand" "x")
2740           (const_int 1)))]
2741   "TARGET_AVX && TARGET_64BIT"
2742   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2743   [(set_attr "type" "sseicvt")
2744    (set_attr "length_vex" "4")
2745    (set_attr "prefix" "vex")
2746    (set_attr "mode" "DF")])
2747
2748 (define_insn "sse2_cvtsi2sdq"
2749   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2750         (vec_merge:V2DF
2751           (vec_duplicate:V2DF
2752             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2753           (match_operand:V2DF 1 "register_operand" "0,0")
2754           (const_int 1)))]
2755   "TARGET_SSE2 && TARGET_64BIT"
2756   "cvtsi2sdq\t{%2, %0|%0, %2}"
2757   [(set_attr "type" "sseicvt")
2758    (set_attr "prefix_rex" "1")
2759    (set_attr "mode" "DF")
2760    (set_attr "athlon_decode" "double,direct")
2761    (set_attr "amdfam10_decode" "vector,double")])
2762
2763 (define_insn "sse2_cvtsd2si"
2764   [(set (match_operand:SI 0 "register_operand" "=r,r")
2765         (unspec:SI
2766           [(vec_select:DF
2767              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2768              (parallel [(const_int 0)]))]
2769           UNSPEC_FIX_NOTRUNC))]
2770   "TARGET_SSE2"
2771   "%vcvtsd2si\t{%1, %0|%0, %1}"
2772   [(set_attr "type" "sseicvt")
2773    (set_attr "athlon_decode" "double,vector")
2774    (set_attr "prefix_rep" "1")
2775    (set_attr "prefix" "maybe_vex")
2776    (set_attr "mode" "SI")])
2777
2778 (define_insn "sse2_cvtsd2si_2"
2779   [(set (match_operand:SI 0 "register_operand" "=r,r")
2780         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2781                    UNSPEC_FIX_NOTRUNC))]
2782   "TARGET_SSE2"
2783   "%vcvtsd2si\t{%1, %0|%0, %1}"
2784   [(set_attr "type" "sseicvt")
2785    (set_attr "athlon_decode" "double,vector")
2786    (set_attr "amdfam10_decode" "double,double")
2787    (set_attr "prefix_rep" "1")
2788    (set_attr "prefix" "maybe_vex")
2789    (set_attr "mode" "SI")])
2790
2791 (define_insn "sse2_cvtsd2siq"
2792   [(set (match_operand:DI 0 "register_operand" "=r,r")
2793         (unspec:DI
2794           [(vec_select:DF
2795              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2796              (parallel [(const_int 0)]))]
2797           UNSPEC_FIX_NOTRUNC))]
2798   "TARGET_SSE2 && TARGET_64BIT"
2799   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2800   [(set_attr "type" "sseicvt")
2801    (set_attr "athlon_decode" "double,vector")
2802    (set_attr "prefix_rep" "1")
2803    (set_attr "prefix" "maybe_vex")
2804    (set_attr "mode" "DI")])
2805
2806 (define_insn "sse2_cvtsd2siq_2"
2807   [(set (match_operand:DI 0 "register_operand" "=r,r")
2808         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2809                    UNSPEC_FIX_NOTRUNC))]
2810   "TARGET_SSE2 && TARGET_64BIT"
2811   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2812   [(set_attr "type" "sseicvt")
2813    (set_attr "athlon_decode" "double,vector")
2814    (set_attr "amdfam10_decode" "double,double")
2815    (set_attr "prefix_rep" "1")
2816    (set_attr "prefix" "maybe_vex")
2817    (set_attr "mode" "DI")])
2818
2819 (define_insn "sse2_cvttsd2si"
2820   [(set (match_operand:SI 0 "register_operand" "=r,r")
2821         (fix:SI
2822           (vec_select:DF
2823             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2824             (parallel [(const_int 0)]))))]
2825   "TARGET_SSE2"
2826   "%vcvttsd2si\t{%1, %0|%0, %1}"
2827   [(set_attr "type" "sseicvt")
2828    (set_attr "prefix_rep" "1")
2829    (set_attr "prefix" "maybe_vex")
2830    (set_attr "mode" "SI")
2831    (set_attr "athlon_decode" "double,vector")
2832    (set_attr "amdfam10_decode" "double,double")])
2833
2834 (define_insn "sse2_cvttsd2siq"
2835   [(set (match_operand:DI 0 "register_operand" "=r,r")
2836         (fix:DI
2837           (vec_select:DF
2838             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2839             (parallel [(const_int 0)]))))]
2840   "TARGET_SSE2 && TARGET_64BIT"
2841   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2842   [(set_attr "type" "sseicvt")
2843    (set_attr "prefix_rep" "1")
2844    (set_attr "prefix" "maybe_vex")
2845    (set_attr "mode" "DI")
2846    (set_attr "athlon_decode" "double,vector")
2847    (set_attr "amdfam10_decode" "double,double")])
2848
2849 (define_insn "avx_cvtdq2pd256"
2850   [(set (match_operand:V4DF 0 "register_operand" "=x")
2851         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2852   "TARGET_AVX"
2853   "vcvtdq2pd\t{%1, %0|%0, %1}"
2854   [(set_attr "type" "ssecvt")
2855    (set_attr "prefix" "vex")
2856    (set_attr "mode" "V4DF")])
2857
2858 (define_insn "sse2_cvtdq2pd"
2859   [(set (match_operand:V2DF 0 "register_operand" "=x")
2860         (float:V2DF
2861           (vec_select:V2SI
2862             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2863             (parallel [(const_int 0) (const_int 1)]))))]
2864   "TARGET_SSE2"
2865   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2866   [(set_attr "type" "ssecvt")
2867    (set_attr "prefix" "maybe_vex")
2868    (set_attr "mode" "V2DF")])
2869
2870 (define_insn "avx_cvtpd2dq256"
2871   [(set (match_operand:V4SI 0 "register_operand" "=x")
2872         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2873                      UNSPEC_FIX_NOTRUNC))]
2874   "TARGET_AVX"
2875   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2876   [(set_attr "type" "ssecvt")
2877    (set_attr "prefix" "vex")
2878    (set_attr "mode" "OI")])
2879
2880 (define_expand "sse2_cvtpd2dq"
2881   [(set (match_operand:V4SI 0 "register_operand" "")
2882         (vec_concat:V4SI
2883           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2884                        UNSPEC_FIX_NOTRUNC)
2885           (match_dup 2)))]
2886   "TARGET_SSE2"
2887   "operands[2] = CONST0_RTX (V2SImode);")
2888
2889 (define_insn "*sse2_cvtpd2dq"
2890   [(set (match_operand:V4SI 0 "register_operand" "=x")
2891         (vec_concat:V4SI
2892           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2893                        UNSPEC_FIX_NOTRUNC)
2894           (match_operand:V2SI 2 "const0_operand" "")))]
2895   "TARGET_SSE2"
2896   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2897                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2898   [(set_attr "type" "ssecvt")
2899    (set_attr "prefix_rep" "1")
2900    (set_attr "prefix_data16" "0")
2901    (set_attr "prefix" "maybe_vex")
2902    (set_attr "mode" "TI")
2903    (set_attr "amdfam10_decode" "double")])
2904
2905 (define_insn "avx_cvttpd2dq256"
2906   [(set (match_operand:V4SI 0 "register_operand" "=x")
2907         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2908   "TARGET_AVX"
2909   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2910   [(set_attr "type" "ssecvt")
2911    (set_attr "prefix" "vex")
2912    (set_attr "mode" "OI")])
2913
2914 (define_expand "sse2_cvttpd2dq"
2915   [(set (match_operand:V4SI 0 "register_operand" "")
2916         (vec_concat:V4SI
2917           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2918           (match_dup 2)))]
2919   "TARGET_SSE2"
2920   "operands[2] = CONST0_RTX (V2SImode);")
2921
2922 (define_insn "*sse2_cvttpd2dq"
2923   [(set (match_operand:V4SI 0 "register_operand" "=x")
2924         (vec_concat:V4SI
2925           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2926           (match_operand:V2SI 2 "const0_operand" "")))]
2927   "TARGET_SSE2"
2928   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2929                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2930   [(set_attr "type" "ssecvt")
2931    (set_attr "prefix" "maybe_vex")
2932    (set_attr "mode" "TI")
2933    (set_attr "amdfam10_decode" "double")])
2934
2935 (define_insn "*avx_cvtsd2ss"
2936   [(set (match_operand:V4SF 0 "register_operand" "=x")
2937         (vec_merge:V4SF
2938           (vec_duplicate:V4SF
2939             (float_truncate:V2SF
2940               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2941           (match_operand:V4SF 1 "register_operand" "x")
2942           (const_int 1)))]
2943   "TARGET_AVX"
2944   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2945   [(set_attr "type" "ssecvt")
2946    (set_attr "prefix" "vex")
2947    (set_attr "mode" "SF")])
2948
2949 (define_insn "sse2_cvtsd2ss"
2950   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2951         (vec_merge:V4SF
2952           (vec_duplicate:V4SF
2953             (float_truncate:V2SF
2954               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2955           (match_operand:V4SF 1 "register_operand" "0,0")
2956           (const_int 1)))]
2957   "TARGET_SSE2"
2958   "cvtsd2ss\t{%2, %0|%0, %2}"
2959   [(set_attr "type" "ssecvt")
2960    (set_attr "athlon_decode" "vector,double")
2961    (set_attr "amdfam10_decode" "vector,double")
2962    (set_attr "mode" "SF")])
2963
2964 (define_insn "*avx_cvtss2sd"
2965   [(set (match_operand:V2DF 0 "register_operand" "=x")
2966         (vec_merge:V2DF
2967           (float_extend:V2DF
2968             (vec_select:V2SF
2969               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
2970               (parallel [(const_int 0) (const_int 1)])))
2971           (match_operand:V2DF 1 "register_operand" "x")
2972           (const_int 1)))]
2973   "TARGET_AVX"
2974   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2975   [(set_attr "type" "ssecvt")
2976    (set_attr "prefix" "vex")
2977    (set_attr "mode" "DF")])
2978
2979 (define_insn "sse2_cvtss2sd"
2980   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2981         (vec_merge:V2DF
2982           (float_extend:V2DF
2983             (vec_select:V2SF
2984               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2985               (parallel [(const_int 0) (const_int 1)])))
2986           (match_operand:V2DF 1 "register_operand" "0,0")
2987           (const_int 1)))]
2988   "TARGET_SSE2"
2989   "cvtss2sd\t{%2, %0|%0, %2}"
2990   [(set_attr "type" "ssecvt")
2991    (set_attr "amdfam10_decode" "vector,double")
2992    (set_attr "mode" "DF")])
2993
2994 (define_insn "avx_cvtpd2ps256"
2995   [(set (match_operand:V4SF 0 "register_operand" "=x")
2996         (float_truncate:V4SF
2997           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2998   "TARGET_AVX"
2999   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
3000   [(set_attr "type" "ssecvt")
3001    (set_attr "prefix" "vex")
3002    (set_attr "mode" "V4SF")])
3003
3004 (define_expand "sse2_cvtpd2ps"
3005   [(set (match_operand:V4SF 0 "register_operand" "")
3006         (vec_concat:V4SF
3007           (float_truncate:V2SF
3008             (match_operand:V2DF 1 "nonimmediate_operand" ""))
3009           (match_dup 2)))]
3010   "TARGET_SSE2"
3011   "operands[2] = CONST0_RTX (V2SFmode);")
3012
3013 (define_insn "*sse2_cvtpd2ps"
3014   [(set (match_operand:V4SF 0 "register_operand" "=x")
3015         (vec_concat:V4SF
3016           (float_truncate:V2SF
3017             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
3018           (match_operand:V2SF 2 "const0_operand" "")))]
3019   "TARGET_SSE2"
3020   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
3021                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
3022   [(set_attr "type" "ssecvt")
3023    (set_attr "prefix_data16" "1")
3024    (set_attr "prefix" "maybe_vex")
3025    (set_attr "mode" "V4SF")
3026    (set_attr "amdfam10_decode" "double")])
3027
3028 (define_insn "avx_cvtps2pd256"
3029   [(set (match_operand:V4DF 0 "register_operand" "=x")
3030         (float_extend:V4DF
3031           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3032   "TARGET_AVX"
3033   "vcvtps2pd\t{%1, %0|%0, %1}"
3034   [(set_attr "type" "ssecvt")
3035    (set_attr "prefix" "vex")
3036    (set_attr "mode" "V4DF")])
3037
3038 (define_insn "sse2_cvtps2pd"
3039   [(set (match_operand:V2DF 0 "register_operand" "=x")
3040         (float_extend:V2DF
3041           (vec_select:V2SF
3042             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3043             (parallel [(const_int 0) (const_int 1)]))))]
3044   "TARGET_SSE2"
3045   "%vcvtps2pd\t{%1, %0|%0, %1}"
3046   [(set_attr "type" "ssecvt")
3047    (set_attr "prefix" "maybe_vex")
3048    (set_attr "mode" "V2DF")
3049    (set_attr "prefix_data16" "0")
3050    (set_attr "amdfam10_decode" "direct")])
3051
3052 (define_expand "vec_unpacks_hi_v4sf"
3053   [(set (match_dup 2)
3054    (vec_select:V4SF
3055      (vec_concat:V8SF
3056        (match_dup 2)
3057        (match_operand:V4SF 1 "nonimmediate_operand" ""))
3058      (parallel [(const_int 6)
3059                 (const_int 7)
3060                 (const_int 2)
3061                 (const_int 3)])))
3062   (set (match_operand:V2DF 0 "register_operand" "")
3063    (float_extend:V2DF
3064      (vec_select:V2SF
3065        (match_dup 2)
3066        (parallel [(const_int 0) (const_int 1)]))))]
3067  "TARGET_SSE2"
3068 {
3069  operands[2] = gen_reg_rtx (V4SFmode);
3070 })
3071
3072 (define_expand "vec_unpacks_lo_v4sf"
3073   [(set (match_operand:V2DF 0 "register_operand" "")
3074         (float_extend:V2DF
3075           (vec_select:V2SF
3076             (match_operand:V4SF 1 "nonimmediate_operand" "")
3077             (parallel [(const_int 0) (const_int 1)]))))]
3078   "TARGET_SSE2")
3079
3080 (define_expand "vec_unpacks_float_hi_v8hi"
3081   [(match_operand:V4SF 0 "register_operand" "")
3082    (match_operand:V8HI 1 "register_operand" "")]
3083   "TARGET_SSE2"
3084 {
3085   rtx tmp = gen_reg_rtx (V4SImode);
3086
3087   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
3088   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3089   DONE;
3090 })
3091
3092 (define_expand "vec_unpacks_float_lo_v8hi"
3093   [(match_operand:V4SF 0 "register_operand" "")
3094    (match_operand:V8HI 1 "register_operand" "")]
3095   "TARGET_SSE2"
3096 {
3097   rtx tmp = gen_reg_rtx (V4SImode);
3098
3099   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
3100   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3101   DONE;
3102 })
3103
3104 (define_expand "vec_unpacku_float_hi_v8hi"
3105   [(match_operand:V4SF 0 "register_operand" "")
3106    (match_operand:V8HI 1 "register_operand" "")]
3107   "TARGET_SSE2"
3108 {
3109   rtx tmp = gen_reg_rtx (V4SImode);
3110
3111   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
3112   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3113   DONE;
3114 })
3115
3116 (define_expand "vec_unpacku_float_lo_v8hi"
3117   [(match_operand:V4SF 0 "register_operand" "")
3118    (match_operand:V8HI 1 "register_operand" "")]
3119   "TARGET_SSE2"
3120 {
3121   rtx tmp = gen_reg_rtx (V4SImode);
3122
3123   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
3124   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3125   DONE;
3126 })
3127
3128 (define_expand "vec_unpacks_float_hi_v4si"
3129   [(set (match_dup 2)
3130         (vec_select:V4SI
3131           (match_operand:V4SI 1 "nonimmediate_operand" "")
3132           (parallel [(const_int 2)
3133                      (const_int 3)
3134                      (const_int 2)
3135                      (const_int 3)])))
3136    (set (match_operand:V2DF 0 "register_operand" "")
3137         (float:V2DF
3138           (vec_select:V2SI
3139           (match_dup 2)
3140             (parallel [(const_int 0) (const_int 1)]))))]
3141  "TARGET_SSE2"
3142  "operands[2] = gen_reg_rtx (V4SImode);")
3143
3144 (define_expand "vec_unpacks_float_lo_v4si"
3145   [(set (match_operand:V2DF 0 "register_operand" "")
3146         (float:V2DF
3147           (vec_select:V2SI
3148             (match_operand:V4SI 1 "nonimmediate_operand" "")
3149             (parallel [(const_int 0) (const_int 1)]))))]
3150   "TARGET_SSE2")
3151
3152 (define_expand "vec_unpacku_float_hi_v4si"
3153   [(set (match_dup 5)
3154         (vec_select:V4SI
3155           (match_operand:V4SI 1 "nonimmediate_operand" "")
3156           (parallel [(const_int 2)
3157                      (const_int 3)
3158                      (const_int 2)
3159                      (const_int 3)])))
3160    (set (match_dup 6)
3161         (float:V2DF
3162           (vec_select:V2SI
3163           (match_dup 5)
3164             (parallel [(const_int 0) (const_int 1)]))))
3165    (set (match_dup 7)
3166         (lt:V2DF (match_dup 6) (match_dup 3)))
3167    (set (match_dup 8)
3168         (and:V2DF (match_dup 7) (match_dup 4)))
3169    (set (match_operand:V2DF 0 "register_operand" "")
3170         (plus:V2DF (match_dup 6) (match_dup 8)))]
3171  "TARGET_SSE2"
3172 {
3173   REAL_VALUE_TYPE TWO32r;
3174   rtx x;
3175   int i;
3176
3177   real_ldexp (&TWO32r, &dconst1, 32);
3178   x = const_double_from_real_value (TWO32r, DFmode);
3179
3180   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3181   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3182
3183   operands[5] = gen_reg_rtx (V4SImode);
3184  
3185   for (i = 6; i < 9; i++)
3186     operands[i] = gen_reg_rtx (V2DFmode);
3187 })
3188
3189 (define_expand "vec_unpacku_float_lo_v4si"
3190   [(set (match_dup 5)
3191         (float:V2DF
3192           (vec_select:V2SI
3193             (match_operand:V4SI 1 "nonimmediate_operand" "")
3194             (parallel [(const_int 0) (const_int 1)]))))
3195    (set (match_dup 6)
3196         (lt:V2DF (match_dup 5) (match_dup 3)))
3197    (set (match_dup 7)
3198         (and:V2DF (match_dup 6) (match_dup 4)))
3199    (set (match_operand:V2DF 0 "register_operand" "")
3200         (plus:V2DF (match_dup 5) (match_dup 7)))]
3201   "TARGET_SSE2"
3202 {
3203   REAL_VALUE_TYPE TWO32r;
3204   rtx x;
3205   int i;
3206
3207   real_ldexp (&TWO32r, &dconst1, 32);
3208   x = const_double_from_real_value (TWO32r, DFmode);
3209
3210   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3211   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3212
3213   for (i = 5; i < 8; i++)
3214     operands[i] = gen_reg_rtx (V2DFmode);
3215 })
3216
3217 (define_expand "vec_pack_trunc_v2df"
3218   [(match_operand:V4SF 0 "register_operand" "")
3219    (match_operand:V2DF 1 "nonimmediate_operand" "")
3220    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3221   "TARGET_SSE2"
3222 {
3223   rtx r1, r2;
3224
3225   r1 = gen_reg_rtx (V4SFmode);
3226   r2 = gen_reg_rtx (V4SFmode);
3227
3228   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
3229   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
3230   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
3231   DONE;
3232 })
3233
3234 (define_expand "vec_pack_sfix_trunc_v2df"
3235   [(match_operand:V4SI 0 "register_operand" "")
3236    (match_operand:V2DF 1 "nonimmediate_operand" "")
3237    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3238   "TARGET_SSE2"
3239 {
3240   rtx r1, r2;
3241
3242   r1 = gen_reg_rtx (V4SImode);
3243   r2 = gen_reg_rtx (V4SImode);
3244
3245   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
3246   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
3247   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3248                                          gen_lowpart (V2DImode, r1),
3249                                          gen_lowpart (V2DImode, r2)));
3250   DONE;
3251 })
3252
3253 (define_expand "vec_pack_sfix_v2df"
3254   [(match_operand:V4SI 0 "register_operand" "")
3255    (match_operand:V2DF 1 "nonimmediate_operand" "")
3256    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3257   "TARGET_SSE2"
3258 {
3259   rtx r1, r2;
3260
3261   r1 = gen_reg_rtx (V4SImode);
3262   r2 = gen_reg_rtx (V4SImode);
3263
3264   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
3265   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
3266   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3267                                          gen_lowpart (V2DImode, r1),
3268                                          gen_lowpart (V2DImode, r2)));
3269   DONE;
3270 })
3271
3272 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3273 ;;
3274 ;; Parallel single-precision floating point element swizzling
3275 ;;
3276 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3277
3278 (define_expand "sse_movhlps_exp"
3279   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3280         (vec_select:V4SF
3281           (vec_concat:V8SF
3282             (match_operand:V4SF 1 "nonimmediate_operand" "")
3283             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3284           (parallel [(const_int 6)
3285                      (const_int 7)
3286                      (const_int 2)
3287                      (const_int 3)])))]
3288   "TARGET_SSE"
3289   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3290
3291 (define_insn "*avx_movhlps"
3292   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3293         (vec_select:V4SF
3294           (vec_concat:V8SF
3295             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3296             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3297           (parallel [(const_int 6)
3298                      (const_int 7)
3299                      (const_int 2)
3300                      (const_int 3)])))]
3301   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3302   "@
3303    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3304    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3305    vmovhps\t{%2, %0|%0, %2}"
3306   [(set_attr "type" "ssemov")
3307    (set_attr "prefix" "vex")
3308    (set_attr "mode" "V4SF,V2SF,V2SF")])
3309
3310 (define_insn "sse_movhlps"
3311   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3312         (vec_select:V4SF
3313           (vec_concat:V8SF
3314             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3315             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3316           (parallel [(const_int 6)
3317                      (const_int 7)
3318                      (const_int 2)
3319                      (const_int 3)])))]
3320   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3321   "@
3322    movhlps\t{%2, %0|%0, %2}
3323    movlps\t{%H2, %0|%0, %H2}
3324    movhps\t{%2, %0|%0, %2}"
3325   [(set_attr "type" "ssemov")
3326    (set_attr "mode" "V4SF,V2SF,V2SF")])
3327
3328 (define_expand "sse_movlhps_exp"
3329   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3330         (vec_select:V4SF
3331           (vec_concat:V8SF
3332             (match_operand:V4SF 1 "nonimmediate_operand" "")
3333             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3334           (parallel [(const_int 0)
3335                      (const_int 1)
3336                      (const_int 4)
3337                      (const_int 5)])))]
3338   "TARGET_SSE"
3339   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3340
3341 (define_insn "*avx_movlhps"
3342   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3343         (vec_select:V4SF
3344           (vec_concat:V8SF
3345             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3346             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3347           (parallel [(const_int 0)
3348                      (const_int 1)
3349                      (const_int 4)
3350                      (const_int 5)])))]
3351   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3352   "@
3353    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3354    vmovhps\t{%2, %1, %0|%0, %1, %2}
3355    vmovlps\t{%2, %H0|%H0, %2}"
3356   [(set_attr "type" "ssemov")
3357    (set_attr "prefix" "vex")
3358    (set_attr "mode" "V4SF,V2SF,V2SF")])
3359
3360 (define_insn "sse_movlhps"
3361   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3362         (vec_select:V4SF
3363           (vec_concat:V8SF
3364             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3365             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3366           (parallel [(const_int 0)
3367                      (const_int 1)
3368                      (const_int 4)
3369                      (const_int 5)])))]
3370   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3371   "@
3372    movlhps\t{%2, %0|%0, %2}
3373    movhps\t{%2, %0|%0, %2}
3374    movlps\t{%2, %H0|%H0, %2}"
3375   [(set_attr "type" "ssemov")
3376    (set_attr "mode" "V4SF,V2SF,V2SF")])
3377
3378 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3379 (define_insn "avx_unpckhps256"
3380   [(set (match_operand:V8SF 0 "register_operand" "=x")
3381         (vec_select:V8SF
3382           (vec_concat:V16SF
3383             (match_operand:V8SF 1 "register_operand" "x")
3384             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3385           (parallel [(const_int 2) (const_int 10)
3386                      (const_int 3) (const_int 11)
3387                      (const_int 6) (const_int 14)
3388                      (const_int 7) (const_int 15)])))]
3389   "TARGET_AVX"
3390   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3391   [(set_attr "type" "sselog")
3392    (set_attr "prefix" "vex")
3393    (set_attr "mode" "V8SF")])
3394
3395 (define_insn "*avx_interleave_highv4sf"
3396   [(set (match_operand:V4SF 0 "register_operand" "=x")
3397         (vec_select:V4SF
3398           (vec_concat:V8SF
3399             (match_operand:V4SF 1 "register_operand" "x")
3400             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3401           (parallel [(const_int 2) (const_int 6)
3402                      (const_int 3) (const_int 7)])))]
3403   "TARGET_AVX"
3404   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3405   [(set_attr "type" "sselog")
3406    (set_attr "prefix" "vex")
3407    (set_attr "mode" "V4SF")])
3408
3409 (define_insn "vec_interleave_highv4sf"
3410   [(set (match_operand:V4SF 0 "register_operand" "=x")
3411         (vec_select:V4SF
3412           (vec_concat:V8SF
3413             (match_operand:V4SF 1 "register_operand" "0")
3414             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3415           (parallel [(const_int 2) (const_int 6)
3416                      (const_int 3) (const_int 7)])))]
3417   "TARGET_SSE"
3418   "unpckhps\t{%2, %0|%0, %2}"
3419   [(set_attr "type" "sselog")
3420    (set_attr "mode" "V4SF")])
3421
3422 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3423 (define_insn "avx_unpcklps256"
3424   [(set (match_operand:V8SF 0 "register_operand" "=x")
3425         (vec_select:V8SF
3426           (vec_concat:V16SF
3427             (match_operand:V8SF 1 "register_operand" "x")
3428             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3429           (parallel [(const_int 0) (const_int 8)
3430                      (const_int 1) (const_int 9)
3431                      (const_int 4) (const_int 12)
3432                      (const_int 5) (const_int 13)])))]
3433   "TARGET_AVX"
3434   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3435   [(set_attr "type" "sselog")
3436    (set_attr "prefix" "vex")
3437    (set_attr "mode" "V8SF")])
3438
3439 (define_insn "*avx_interleave_lowv4sf"
3440   [(set (match_operand:V4SF 0 "register_operand" "=x")
3441         (vec_select:V4SF
3442           (vec_concat:V8SF
3443             (match_operand:V4SF 1 "register_operand" "x")
3444             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3445           (parallel [(const_int 0) (const_int 4)
3446                      (const_int 1) (const_int 5)])))]
3447   "TARGET_AVX"
3448   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3449   [(set_attr "type" "sselog")
3450    (set_attr "prefix" "vex")
3451    (set_attr "mode" "V4SF")])
3452
3453 (define_insn "vec_interleave_lowv4sf"
3454   [(set (match_operand:V4SF 0 "register_operand" "=x")
3455         (vec_select:V4SF
3456           (vec_concat:V8SF
3457             (match_operand:V4SF 1 "register_operand" "0")
3458             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3459           (parallel [(const_int 0) (const_int 4)
3460                      (const_int 1) (const_int 5)])))]
3461   "TARGET_SSE"
3462   "unpcklps\t{%2, %0|%0, %2}"
3463   [(set_attr "type" "sselog")
3464    (set_attr "mode" "V4SF")])
3465
3466 ;; These are modeled with the same vec_concat as the others so that we
3467 ;; capture users of shufps that can use the new instructions
3468 (define_insn "avx_movshdup256"
3469   [(set (match_operand:V8SF 0 "register_operand" "=x")
3470         (vec_select:V8SF
3471           (vec_concat:V16SF
3472             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3473             (match_dup 1))
3474           (parallel [(const_int 1) (const_int 1)
3475                      (const_int 3) (const_int 3)
3476                      (const_int 5) (const_int 5)
3477                      (const_int 7) (const_int 7)])))]
3478   "TARGET_AVX"
3479   "vmovshdup\t{%1, %0|%0, %1}"
3480   [(set_attr "type" "sse")
3481    (set_attr "prefix" "vex")
3482    (set_attr "mode" "V8SF")])
3483
3484 (define_insn "sse3_movshdup"
3485   [(set (match_operand:V4SF 0 "register_operand" "=x")
3486         (vec_select:V4SF
3487           (vec_concat:V8SF
3488             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3489             (match_dup 1))
3490           (parallel [(const_int 1)
3491                      (const_int 1)
3492                      (const_int 7)
3493                      (const_int 7)])))]
3494   "TARGET_SSE3"
3495   "%vmovshdup\t{%1, %0|%0, %1}"
3496   [(set_attr "type" "sse")
3497    (set_attr "prefix_rep" "1")
3498    (set_attr "prefix" "maybe_vex")
3499    (set_attr "mode" "V4SF")])
3500
3501 (define_insn "avx_movsldup256"
3502   [(set (match_operand:V8SF 0 "register_operand" "=x")
3503         (vec_select:V8SF
3504           (vec_concat:V16SF
3505             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3506             (match_dup 1))
3507           (parallel [(const_int 0) (const_int 0)
3508                      (const_int 2) (const_int 2)
3509                      (const_int 4) (const_int 4)
3510                      (const_int 6) (const_int 6)])))]
3511   "TARGET_AVX"
3512   "vmovsldup\t{%1, %0|%0, %1}"
3513   [(set_attr "type" "sse")
3514    (set_attr "prefix" "vex")
3515    (set_attr "mode" "V8SF")])
3516
3517 (define_insn "sse3_movsldup"
3518   [(set (match_operand:V4SF 0 "register_operand" "=x")
3519         (vec_select:V4SF
3520           (vec_concat:V8SF
3521             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3522             (match_dup 1))
3523           (parallel [(const_int 0)
3524                      (const_int 0)
3525                      (const_int 6)
3526                      (const_int 6)])))]
3527   "TARGET_SSE3"
3528   "%vmovsldup\t{%1, %0|%0, %1}"
3529   [(set_attr "type" "sse")
3530    (set_attr "prefix_rep" "1")
3531    (set_attr "prefix" "maybe_vex")
3532    (set_attr "mode" "V4SF")])
3533
3534 (define_expand "avx_shufps256"
3535   [(match_operand:V8SF 0 "register_operand" "")
3536    (match_operand:V8SF 1 "register_operand" "")
3537    (match_operand:V8SF 2 "nonimmediate_operand" "")
3538    (match_operand:SI 3 "const_int_operand" "")]
3539   "TARGET_AVX"
3540 {
3541   int mask = INTVAL (operands[3]);
3542   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3543                                   GEN_INT ((mask >> 0) & 3),
3544                                   GEN_INT ((mask >> 2) & 3),
3545                                   GEN_INT (((mask >> 4) & 3) + 8),
3546                                   GEN_INT (((mask >> 6) & 3) + 8),
3547                                   GEN_INT (((mask >> 0) & 3) + 4),
3548                                   GEN_INT (((mask >> 2) & 3) + 4),
3549                                   GEN_INT (((mask >> 4) & 3) + 12),
3550                                   GEN_INT (((mask >> 6) & 3) + 12)));
3551   DONE;
3552 })
3553
3554 ;; One bit in mask selects 2 elements.
3555 (define_insn "avx_shufps256_1"
3556   [(set (match_operand:V8SF 0 "register_operand" "=x")
3557         (vec_select:V8SF
3558           (vec_concat:V16SF
3559             (match_operand:V8SF 1 "register_operand" "x")
3560             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3561           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3562                      (match_operand 4  "const_0_to_3_operand"   "")
3563                      (match_operand 5  "const_8_to_11_operand"  "")
3564                      (match_operand 6  "const_8_to_11_operand"  "")
3565                      (match_operand 7  "const_4_to_7_operand"   "")
3566                      (match_operand 8  "const_4_to_7_operand"   "")
3567                      (match_operand 9  "const_12_to_15_operand" "")
3568                      (match_operand 10 "const_12_to_15_operand" "")])))]
3569   "TARGET_AVX
3570    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3571        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3572        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3573        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3574 {
3575   int mask;
3576   mask = INTVAL (operands[3]);
3577   mask |= INTVAL (operands[4]) << 2;
3578   mask |= (INTVAL (operands[5]) - 8) << 4;
3579   mask |= (INTVAL (operands[6]) - 8) << 6;
3580   operands[3] = GEN_INT (mask);
3581
3582   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3583 }
3584   [(set_attr "type" "sselog")
3585    (set_attr "length_immediate" "1")
3586    (set_attr "prefix" "vex")
3587    (set_attr "mode" "V8SF")])
3588
3589 (define_expand "sse_shufps"
3590   [(match_operand:V4SF 0 "register_operand" "")
3591    (match_operand:V4SF 1 "register_operand" "")
3592    (match_operand:V4SF 2 "nonimmediate_operand" "")
3593    (match_operand:SI 3 "const_int_operand" "")]
3594   "TARGET_SSE"
3595 {
3596   int mask = INTVAL (operands[3]);
3597   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3598                                GEN_INT ((mask >> 0) & 3),
3599                                GEN_INT ((mask >> 2) & 3),
3600                                GEN_INT (((mask >> 4) & 3) + 4),
3601                                GEN_INT (((mask >> 6) & 3) + 4)));
3602   DONE;
3603 })
3604
3605 (define_insn "*avx_shufps_<mode>"
3606   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3607         (vec_select:SSEMODE4S
3608           (vec_concat:<ssedoublesizemode>
3609             (match_operand:SSEMODE4S 1 "register_operand" "x")
3610             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3611           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3612                      (match_operand 4 "const_0_to_3_operand" "")
3613                      (match_operand 5 "const_4_to_7_operand" "")
3614                      (match_operand 6 "const_4_to_7_operand" "")])))]
3615   "TARGET_AVX"
3616 {
3617   int mask = 0;
3618   mask |= INTVAL (operands[3]) << 0;
3619   mask |= INTVAL (operands[4]) << 2;
3620   mask |= (INTVAL (operands[5]) - 4) << 4;
3621   mask |= (INTVAL (operands[6]) - 4) << 6;
3622   operands[3] = GEN_INT (mask);
3623
3624   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3625 }
3626   [(set_attr "type" "sselog")
3627    (set_attr "length_immediate" "1")
3628    (set_attr "prefix" "vex")
3629    (set_attr "mode" "V4SF")])
3630
3631 (define_insn "sse_shufps_<mode>"
3632   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3633         (vec_select:SSEMODE4S
3634           (vec_concat:<ssedoublesizemode>
3635             (match_operand:SSEMODE4S 1 "register_operand" "0")
3636             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3637           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3638                      (match_operand 4 "const_0_to_3_operand" "")
3639                      (match_operand 5 "const_4_to_7_operand" "")
3640                      (match_operand 6 "const_4_to_7_operand" "")])))]
3641   "TARGET_SSE"
3642 {
3643   int mask = 0;
3644   mask |= INTVAL (operands[3]) << 0;
3645   mask |= INTVAL (operands[4]) << 2;
3646   mask |= (INTVAL (operands[5]) - 4) << 4;
3647   mask |= (INTVAL (operands[6]) - 4) << 6;
3648   operands[3] = GEN_INT (mask);
3649
3650   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3651 }
3652   [(set_attr "type" "sselog")
3653    (set_attr "length_immediate" "1")
3654    (set_attr "mode" "V4SF")])
3655
3656 (define_insn "sse_storehps"
3657   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3658         (vec_select:V2SF
3659           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3660           (parallel [(const_int 2) (const_int 3)])))]
3661   "TARGET_SSE"
3662   "@
3663    %vmovhps\t{%1, %0|%0, %1}
3664    %vmovhlps\t{%1, %d0|%d0, %1}
3665    %vmovlps\t{%H1, %d0|%d0, %H1}"
3666   [(set_attr "type" "ssemov")
3667    (set_attr "prefix" "maybe_vex")
3668    (set_attr "mode" "V2SF,V4SF,V2SF")])
3669
3670 (define_expand "sse_loadhps_exp"
3671   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3672         (vec_concat:V4SF
3673           (vec_select:V2SF
3674             (match_operand:V4SF 1 "nonimmediate_operand" "")
3675             (parallel [(const_int 0) (const_int 1)]))
3676           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3677   "TARGET_SSE"
3678   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3679
3680 (define_insn "*avx_loadhps"
3681   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3682         (vec_concat:V4SF
3683           (vec_select:V2SF
3684             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3685             (parallel [(const_int 0) (const_int 1)]))
3686           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3687   "TARGET_AVX"
3688   "@
3689    vmovhps\t{%2, %1, %0|%0, %1, %2}
3690    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3691    vmovlps\t{%2, %H0|%H0, %2}"
3692   [(set_attr "type" "ssemov")
3693    (set_attr "prefix" "vex")
3694    (set_attr "mode" "V2SF,V4SF,V2SF")])
3695
3696 (define_insn "sse_loadhps"
3697   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3698         (vec_concat:V4SF
3699           (vec_select:V2SF
3700             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3701             (parallel [(const_int 0) (const_int 1)]))
3702           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3703   "TARGET_SSE"
3704   "@
3705    movhps\t{%2, %0|%0, %2}
3706    movlhps\t{%2, %0|%0, %2}
3707    movlps\t{%2, %H0|%H0, %2}"
3708   [(set_attr "type" "ssemov")
3709    (set_attr "mode" "V2SF,V4SF,V2SF")])
3710
3711 (define_insn "*avx_storelps"
3712   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3713         (vec_select:V2SF
3714           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3715           (parallel [(const_int 0) (const_int 1)])))]
3716   "TARGET_AVX"
3717   "@
3718    vmovlps\t{%1, %0|%0, %1}
3719    vmovaps\t{%1, %0|%0, %1}
3720    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3721   [(set_attr "type" "ssemov")
3722    (set_attr "prefix" "vex")
3723    (set_attr "mode" "V2SF,V2DF,V2SF")])
3724
3725 (define_insn "sse_storelps"
3726   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3727         (vec_select:V2SF
3728           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3729           (parallel [(const_int 0) (const_int 1)])))]
3730   "TARGET_SSE"
3731   "@
3732    movlps\t{%1, %0|%0, %1}
3733    movaps\t{%1, %0|%0, %1}
3734    movlps\t{%1, %0|%0, %1}"
3735   [(set_attr "type" "ssemov")
3736    (set_attr "mode" "V2SF,V4SF,V2SF")])
3737
3738 (define_expand "sse_loadlps_exp"
3739   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3740         (vec_concat:V4SF
3741           (match_operand:V2SF 2 "nonimmediate_operand" "")
3742           (vec_select:V2SF
3743             (match_operand:V4SF 1 "nonimmediate_operand" "")
3744             (parallel [(const_int 2) (const_int 3)]))))]
3745   "TARGET_SSE"
3746   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3747
3748 (define_insn "*avx_loadlps"
3749   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3750         (vec_concat:V4SF
3751           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3752           (vec_select:V2SF
3753             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3754             (parallel [(const_int 2) (const_int 3)]))))]
3755   "TARGET_AVX"
3756   "@
3757    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3758    vmovlps\t{%2, %1, %0|%0, %1, %2}
3759    vmovlps\t{%2, %0|%0, %2}"
3760   [(set_attr "type" "sselog,ssemov,ssemov")
3761    (set_attr "length_immediate" "1,*,*")
3762    (set_attr "prefix" "vex")
3763    (set_attr "mode" "V4SF,V2SF,V2SF")])
3764
3765 (define_insn "sse_loadlps"
3766   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3767         (vec_concat:V4SF
3768           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3769           (vec_select:V2SF
3770             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3771             (parallel [(const_int 2) (const_int 3)]))))]
3772   "TARGET_SSE"
3773   "@
3774    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3775    movlps\t{%2, %0|%0, %2}
3776    movlps\t{%2, %0|%0, %2}"
3777   [(set_attr "type" "sselog,ssemov,ssemov")
3778    (set_attr "length_immediate" "1,*,*")
3779    (set_attr "mode" "V4SF,V2SF,V2SF")])
3780
3781 (define_insn "*avx_movss"
3782   [(set (match_operand:V4SF 0 "register_operand" "=x")
3783         (vec_merge:V4SF
3784           (match_operand:V4SF 2 "register_operand" "x")
3785           (match_operand:V4SF 1 "register_operand" "x")
3786           (const_int 1)))]
3787   "TARGET_AVX"
3788   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3789   [(set_attr "type" "ssemov")
3790    (set_attr "prefix" "vex")
3791    (set_attr "mode" "SF")])
3792
3793 (define_insn "sse_movss"
3794   [(set (match_operand:V4SF 0 "register_operand" "=x")
3795         (vec_merge:V4SF
3796           (match_operand:V4SF 2 "register_operand" "x")
3797           (match_operand:V4SF 1 "register_operand" "0")
3798           (const_int 1)))]
3799   "TARGET_SSE"
3800   "movss\t{%2, %0|%0, %2}"
3801   [(set_attr "type" "ssemov")
3802    (set_attr "mode" "SF")])
3803
3804 (define_expand "vec_dupv4sf"
3805   [(set (match_operand:V4SF 0 "register_operand" "")
3806         (vec_duplicate:V4SF
3807           (match_operand:SF 1 "nonimmediate_operand" "")))]
3808   "TARGET_SSE"
3809 {
3810   if (!TARGET_AVX)
3811     operands[1] = force_reg (V4SFmode, operands[1]);
3812 })
3813
3814 (define_insn "*vec_dupv4sf_avx"
3815   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3816         (vec_duplicate:V4SF
3817           (match_operand:SF 1 "nonimmediate_operand" "x,m")))]
3818   "TARGET_AVX"
3819   "@
3820    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
3821    vbroadcastss\t{%1, %0|%0, %1}"
3822   [(set_attr "type" "sselog1,ssemov")
3823    (set_attr "length_immediate" "1,0")
3824    (set_attr "prefix_extra" "0,1")
3825    (set_attr "prefix" "vex")
3826    (set_attr "mode" "V4SF")])
3827
3828 (define_insn "*vec_dupv4sf"
3829   [(set (match_operand:V4SF 0 "register_operand" "=x")
3830         (vec_duplicate:V4SF
3831           (match_operand:SF 1 "register_operand" "0")))]
3832   "TARGET_SSE"
3833   "shufps\t{$0, %0, %0|%0, %0, 0}"
3834   [(set_attr "type" "sselog1")
3835    (set_attr "length_immediate" "1")
3836    (set_attr "mode" "V4SF")])
3837
3838 (define_insn "*vec_concatv2sf_avx"
3839   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3840         (vec_concat:V2SF
3841           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3842           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3843   "TARGET_AVX"
3844   "@
3845    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3846    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3847    vmovss\t{%1, %0|%0, %1}
3848    punpckldq\t{%2, %0|%0, %2}
3849    movd\t{%1, %0|%0, %1}"
3850   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3851    (set_attr "length_immediate" "*,1,*,*,*")
3852    (set_attr "prefix_extra" "*,1,*,*,*")
3853    (set (attr "prefix")
3854      (if_then_else (eq_attr "alternative" "3,4")
3855        (const_string "orig")
3856        (const_string "vex")))
3857    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3858
3859 ;; Although insertps takes register source, we prefer
3860 ;; unpcklps with register source since it is shorter.
3861 (define_insn "*vec_concatv2sf_sse4_1"
3862   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3863         (vec_concat:V2SF
3864           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3865           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3866   "TARGET_SSE4_1"
3867   "@
3868    unpcklps\t{%2, %0|%0, %2}
3869    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3870    movss\t{%1, %0|%0, %1}
3871    punpckldq\t{%2, %0|%0, %2}
3872    movd\t{%1, %0|%0, %1}"
3873   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3874    (set_attr "prefix_data16" "*,1,*,*,*")
3875    (set_attr "prefix_extra" "*,1,*,*,*")
3876    (set_attr "length_immediate" "*,1,*,*,*")
3877    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3878
3879 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3880 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3881 ;; alternatives pretty much forces the MMX alternative to be chosen.
3882 (define_insn "*vec_concatv2sf_sse"
3883   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3884         (vec_concat:V2SF
3885           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3886           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3887   "TARGET_SSE"
3888   "@
3889    unpcklps\t{%2, %0|%0, %2}
3890    movss\t{%1, %0|%0, %1}
3891    punpckldq\t{%2, %0|%0, %2}
3892    movd\t{%1, %0|%0, %1}"
3893   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3894    (set_attr "mode" "V4SF,SF,DI,DI")])
3895
3896 (define_insn "*vec_concatv4sf_avx"
3897   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3898         (vec_concat:V4SF
3899           (match_operand:V2SF 1 "register_operand" " x,x")
3900           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3901   "TARGET_AVX"
3902   "@
3903    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3904    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3905   [(set_attr "type" "ssemov")
3906    (set_attr "prefix" "vex")
3907    (set_attr "mode" "V4SF,V2SF")])
3908
3909 (define_insn "*vec_concatv4sf_sse"
3910   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3911         (vec_concat:V4SF
3912           (match_operand:V2SF 1 "register_operand" " 0,0")
3913           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3914   "TARGET_SSE"
3915   "@
3916    movlhps\t{%2, %0|%0, %2}
3917    movhps\t{%2, %0|%0, %2}"
3918   [(set_attr "type" "ssemov")
3919    (set_attr "mode" "V4SF,V2SF")])
3920
3921 (define_expand "vec_init<mode>"
3922   [(match_operand:SSEMODE 0 "register_operand" "")
3923    (match_operand 1 "" "")]
3924   "TARGET_SSE"
3925 {
3926   ix86_expand_vector_init (false, operands[0], operands[1]);
3927   DONE;
3928 })
3929
3930 (define_insn "*vec_set<mode>_0_avx"
3931   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3932         (vec_merge:SSEMODE4S
3933           (vec_duplicate:SSEMODE4S
3934             (match_operand:<ssescalarmode> 2
3935               "general_operand"                            " x,m,*r,x,*rm,x*rfF"))
3936           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0")
3937           (const_int 1)))]
3938   "TARGET_AVX"
3939   "@
3940    vinsertps\t{$0xe, %2, %2, %0|%0, %2, %2, 0xe}
3941    vmov<ssescalarmodesuffix2s>\t{%2, %0|%0, %2}
3942