gcc/config/i386/sse.md

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