OSDN Git Service

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