OSDN Git Service

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