gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   7 ;; GCC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 3, or (at your option)
  10 ;; any later version.
  11 ;;
  12 ;; GCC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16 ;;
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21
  22 ;; 16 byte integral modes handled by SSE
  23 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  24
  25 ;; All 16-byte vector modes handled by SSE
  26 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI V4SF V2DF])
  27 (define_mode_iterator SSEMODE16 [V16QI V8HI V4SI V2DI V1TI V4SF V2DF])
  28
  29 ;; 32 byte integral vector modes handled by AVX
  30 (define_mode_iterator AVX256MODEI [V32QI V16HI V8SI V4DI])
  31
  32 ;; All 32-byte vector modes handled by AVX
  33 (define_mode_iterator AVX256MODE [V32QI V16HI V8SI V4DI V8SF V4DF])
  34
  35 ;; All QI vector modes handled by AVX
  36 (define_mode_iterator AVXMODEQI [V32QI V16QI])
  37
  38 ;; All DI vector modes handled by AVX
  39 (define_mode_iterator AVXMODEDI [V4DI V2DI])
  40
  41 ;; All vector modes handled by AVX
  42 (define_mode_iterator AVXMODE
  43   [V16QI V8HI V4SI V2DI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  44 (define_mode_iterator AVXMODE16
  45   [V16QI V8HI V4SI V2DI V1TI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  46
  47 ;; Mix-n-match
  48 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  49 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  50 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  51 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  52 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  53 (define_mode_iterator SSEMODE1248 [V16QI V8HI V4SI V2DI])
  54 (define_mode_iterator SSEMODEF4 [SF DF V4SF V2DF])
  55 (define_mode_iterator FMA4MODEF4 [V8SF V4DF])
  56 (define_mode_iterator SSEMODEF2P [V4SF V2DF])
  57
  58 (define_mode_iterator AVX256MODEF2P [V8SF V4DF])
  59 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
  60 (define_mode_iterator AVX256MODE24P [V8SI V8SF V4DI V4DF])
  61 (define_mode_iterator AVX256MODE4P [V4DI V4DF])
  62 (define_mode_iterator AVX256MODE8P [V8SI V8SF])
  63 (define_mode_iterator AVXMODEF2P [V4SF V2DF V8SF V4DF])
  64 (define_mode_iterator AVXMODEF4P [V4SF V4DF])
  65 (define_mode_iterator AVXMODEFDP [V2DF V4DF])
  66 (define_mode_iterator AVXMODEFSP [V4SF V8SF])
  67 (define_mode_iterator AVXMODEDCVTDQ2PS [V4SF V8SF])
  68 (define_mode_iterator AVXMODEDCVTPS2DQ [V4SI V8SI])
  69
  70 ;; Int-float size matches
  71 (define_mode_iterator SSEMODE4S [V4SF V4SI])
  72 (define_mode_iterator SSEMODE2D [V2DF V2DI])
  73
  74 ;; Modes handled by integer vcond pattern
  75 (define_mode_iterator SSEMODE124C8 [V16QI V8HI V4SI
  76                                     (V2DI "TARGET_SSE4_2")])
  77
  78 ;; Modes handled by vec_extract_even/odd pattern.
  79 (define_mode_iterator SSEMODE_EO
  80   [(V4SF "TARGET_SSE")
  81    (V2DF "TARGET_SSE2")
  82    (V2DI "TARGET_SSE2") (V4SI "TARGET_SSE2")
  83    (V8HI "TARGET_SSE2") (V16QI "TARGET_SSE2")
  84    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
  85
  86 ;; Mapping from float mode to required SSE level
  87 (define_mode_attr sse [(SF "sse") (DF "sse2") (V4SF "sse") (V2DF "sse2")])
  88
  89 ;; Mapping from integer vector mode to mnemonic suffix
  90 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
  91
  92 ;; Mapping of the fma4 suffix
  93 (define_mode_attr fma4modesuffixf4 [(V8SF "ps") (V4DF "pd")])
  94 (define_mode_attr ssemodesuffixf2s [(SF "ss") (DF "sd")
  95                                     (V4SF "ss") (V2DF "sd")])
  96
  97 ;; Mapping of the avx suffix
  98 (define_mode_attr ssemodesuffixf4 [(SF "ss") (DF "sd")
  99                                    (V4SF "ps") (V2DF "pd")])
 100
 101 (define_mode_attr ssemodesuffixf2c [(V4SF "s") (V2DF "d")])
 102
 103 (define_mode_attr ssescalarmodesuffix2s [(V4SF "ss") (V4SI "d")])
 104
 105 ;; Mapping of the max integer size for xop rotate immediate constraint
 106 (define_mode_attr sserotatemax [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
 107
 108 ;; Mapping of vector modes back to the scalar modes
 109 (define_mode_attr ssescalarmode [(V4SF "SF") (V2DF "DF")
 110                                  (V16QI "QI") (V8HI "HI")
 111                                  (V4SI "SI") (V2DI "DI")])
 112
 113 ;; Mapping of vector modes to a vector mode of double size
 114 (define_mode_attr ssedoublesizemode
 115   [(V2DF "V4DF") (V2DI "V4DI") (V4SF "V8SF") (V4SI "V8SI")
 116    (V8HI "V16HI") (V16QI "V32QI")
 117    (V4DF "V8DF") (V8SF "V16SF")
 118    (V4DI "V8DI") (V8SI "V16SI") (V16HI "V32HI") (V32QI "V64QI")])
 119
 120 ;; Number of scalar elements in each vector type
 121 (define_mode_attr ssescalarnum
 122   [(V4SF "4") (V2DF "2") (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
 123    (V8SF "8") (V4DF "4") (V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")])
 124
 125 ;; Mapping for AVX
 126 (define_mode_attr avxvecmode
 127   [(V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
 128    (V4SF "V4SF") (V8SF "V8SF") (V2DF "V2DF") (V4DF "V4DF")
 129    (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI")])
 130 (define_mode_attr avxvecpsmode
 131   [(V16QI "V4SF") (V8HI "V4SF") (V4SI "V4SF") (V2DI "V4SF")
 132    (V32QI "V8SF") (V16HI "V8SF") (V8SI "V8SF") (V4DI "V8SF")])
 133 (define_mode_attr avxhalfvecmode
 134   [(V32QI "V16QI") (V16HI "V8HI") (V8SI "V4SI") (V4DI "V2DI")
 135    (V8SF "V4SF") (V4DF "V2DF")
 136    (V16QI  "V8QI") (V8HI  "V4HI") (V4SI "V2SI") (V4SF "V2SF")])
 137 (define_mode_attr avxscalarmode
 138   [(V16QI "QI") (V8HI  "HI") (V4SI "SI") (V2DI "DI") (V4SF "SF") (V2DF "DF")
 139    (V32QI "QI") (V16HI "HI") (V8SI "SI") (V4DI "DI") (V8SF "SF") (V4DF "DF")])
 140 (define_mode_attr avxcvtvecmode
 141   [(V4SF "V4SI") (V8SF "V8SI") (V4SI "V4SF") (V8SI "V8SF")])
 142 (define_mode_attr avxpermvecmode
 143   [(V2DF "V2DI") (V4SF "V4SI") (V4DF "V4DI") (V8SF "V8SI")])
 144 (define_mode_attr avxmodesuffixf2c
 145   [(V4SF "s") (V2DF "d") (V8SI "s") (V8SF "s") (V4DI "d") (V4DF "d")])
 146 (define_mode_attr avxmodesuffixp
 147  [(V2DF "pd") (V4SI "si") (V4SF "ps") (V8SF "ps") (V8SI "si")
 148   (V4DF "pd")])
 149 (define_mode_attr avxmodesuffix
 150   [(V16QI "") (V32QI "256") (V4SI "") (V4SF "") (V2DF "")
 151    (V8SI "256") (V8SF "256") (V4DF "256")])
 152
 153 ;; Mapping of immediate bits for blend instructions
 154 (define_mode_attr blendbits
 155   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 156
 157 ;; Mapping of immediate bits for pinsr instructions
 158 (define_mode_attr pinsrbits [(V16QI "32768") (V8HI "128") (V4SI "8")])
 159
 160 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 161
 162 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 163 ;;
 164 ;; Move patterns
 165 ;;
 166 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 167
 168 (define_expand "mov<mode>"
 169   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 170         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 171   "TARGET_AVX"
 172 {
 173   ix86_expand_vector_move (<MODE>mode, operands);
 174   DONE;
 175 })
 176
 177 (define_insn "*avx_mov<mode>_internal"
 178   [(set (match_operand:AVXMODE16 0 "nonimmediate_operand" "=x,x ,m")
 179         (match_operand:AVXMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 180   "TARGET_AVX
 181    && (register_operand (operands[0], <MODE>mode)
 182        || register_operand (operands[1], <MODE>mode))"
 183 {
 184   switch (which_alternative)
 185     {
 186     case 0:
 187       return standard_sse_constant_opcode (insn, operands[1]);
 188     case 1:
 189     case 2:
 190       switch (get_attr_mode (insn))
 191         {
 192         case MODE_V8SF:
 193         case MODE_V4SF:
 194           return "vmovaps\t{%1, %0|%0, %1}";
 195         case MODE_V4DF:
 196         case MODE_V2DF:
 197           return "vmovapd\t{%1, %0|%0, %1}";
 198         default:
 199           return "vmovdqa\t{%1, %0|%0, %1}";
 200         }
 201     default:
 202       gcc_unreachable ();
 203     }
 204 }
 205   [(set_attr "type" "sselog1,ssemov,ssemov")
 206    (set_attr "prefix" "vex")
 207    (set_attr "mode" "<avxvecmode>")])
 208
 209 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 210 ;; This is essential for maintaining stable calling conventions.
 211
 212 (define_expand "mov<mode>"
 213   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 214         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 215   "TARGET_SSE"
 216 {
 217   ix86_expand_vector_move (<MODE>mode, operands);
 218   DONE;
 219 })
 220
 221 (define_insn "*mov<mode>_internal"
 222   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "=x,x ,m")
 223         (match_operand:SSEMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 224   "TARGET_SSE
 225    && (register_operand (operands[0], <MODE>mode)
 226        || register_operand (operands[1], <MODE>mode))"
 227 {
 228   switch (which_alternative)
 229     {
 230     case 0:
 231       return standard_sse_constant_opcode (insn, operands[1]);
 232     case 1:
 233     case 2:
 234       switch (get_attr_mode (insn))
 235         {
 236         case MODE_V4SF:
 237           return "movaps\t{%1, %0|%0, %1}";
 238         case MODE_V2DF:
 239           return "movapd\t{%1, %0|%0, %1}";
 240         default:
 241           return "movdqa\t{%1, %0|%0, %1}";
 242         }
 243     default:
 244       gcc_unreachable ();
 245     }
 246 }
 247   [(set_attr "type" "sselog1,ssemov,ssemov")
 248    (set (attr "mode")
 249         (cond [(ior (ior (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
 250                          (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 251                     (and (eq_attr "alternative" "2")
 252                          (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 253                              (const_int 0))))
 254                  (const_string "V4SF")
 255                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
 256                  (const_string "V4SF")
 257                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
 258                  (const_string "V2DF")
 259               ]
 260           (const_string "TI")))])
 261
 262 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 263 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 264 ;; from memory, we'd prefer to load the memory directly into the %xmm
 265 ;; register.  To facilitate this happy circumstance, this pattern won't
 266 ;; split until after register allocation.  If the 64-bit value didn't
 267 ;; come from memory, this is the best we can do.  This is much better
 268 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 269 ;; from there.
 270
 271 (define_insn_and_split "movdi_to_sse"
 272   [(parallel
 273     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 274           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 275      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 276   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 277   "#"
 278   "&& reload_completed"
 279   [(const_int 0)]
 280 {
 281  if (register_operand (operands[1], DImode))
 282    {
 283       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 284          Assemble the 64-bit DImode value in an xmm register.  */
 285       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 286                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 287       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 288                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 289       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
 290                                              operands[2]));
 291     }
 292  else if (memory_operand (operands[1], DImode))
 293    emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]),
 294                                   operands[1], const0_rtx));
 295  else
 296    gcc_unreachable ();
 297 })
 298
 299 (define_split
 300   [(set (match_operand:V4SF 0 "register_operand" "")
 301         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 302   "TARGET_SSE && reload_completed"
 303   [(set (match_dup 0)
 304         (vec_merge:V4SF
 305           (vec_duplicate:V4SF (match_dup 1))
 306           (match_dup 2)
 307           (const_int 1)))]
 308 {
 309   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 310   operands[2] = CONST0_RTX (V4SFmode);
 311 })
 312
 313 (define_split
 314   [(set (match_operand:V2DF 0 "register_operand" "")
 315         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 316   "TARGET_SSE2 && reload_completed"
 317   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 318 {
 319   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 320   operands[2] = CONST0_RTX (DFmode);
 321 })
 322
 323 (define_expand "push<mode>1"
 324   [(match_operand:AVX256MODE 0 "register_operand" "")]
 325   "TARGET_AVX"
 326 {
 327   ix86_expand_push (<MODE>mode, operands[0]);
 328   DONE;
 329 })
 330
 331 (define_expand "push<mode>1"
 332   [(match_operand:SSEMODE16 0 "register_operand" "")]
 333   "TARGET_SSE"
 334 {
 335   ix86_expand_push (<MODE>mode, operands[0]);
 336   DONE;
 337 })
 338
 339 (define_expand "movmisalign<mode>"
 340   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 341         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 342   "TARGET_AVX"
 343 {
 344   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 345   DONE;
 346 })
 347
 348 (define_expand "movmisalign<mode>"
 349   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 350         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 351   "TARGET_SSE"
 352 {
 353   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 354   DONE;
 355 })
 356
 357 (define_insn "avx_movup<avxmodesuffixf2c><avxmodesuffix>"
 358   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "=x,m")
 359         (unspec:AVXMODEF2P
 360           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm,x")]
 361           UNSPEC_MOVU))]
 362   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 363    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 364   "vmovup<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 365   [(set_attr "type" "ssemov")
 366    (set_attr "movu" "1")
 367    (set_attr "prefix" "vex")
 368    (set_attr "mode" "<MODE>")])
 369
 370 (define_insn "sse2_movq128"
 371   [(set (match_operand:V2DI 0 "register_operand" "=x")
 372         (vec_concat:V2DI
 373           (vec_select:DI
 374             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 375             (parallel [(const_int 0)]))
 376           (const_int 0)))]
 377   "TARGET_SSE2"
 378   "%vmovq\t{%1, %0|%0, %1}"
 379   [(set_attr "type" "ssemov")
 380    (set_attr "prefix" "maybe_vex")
 381    (set_attr "mode" "TI")])
 382
 383 (define_insn "<sse>_movup<ssemodesuffixf2c>"
 384   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m")
 385         (unspec:SSEMODEF2P
 386           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm,x")]
 387           UNSPEC_MOVU))]
 388   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 389    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 390   "movup<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 391   [(set_attr "type" "ssemov")
 392    (set_attr "movu" "1")
 393    (set_attr "mode" "<MODE>")])
 394
 395 (define_insn "avx_movdqu<avxmodesuffix>"
 396   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "=x,m")
 397         (unspec:AVXMODEQI
 398           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "xm,x")]
 399           UNSPEC_MOVU))]
 400   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 401   "vmovdqu\t{%1, %0|%0, %1}"
 402   [(set_attr "type" "ssemov")
 403    (set_attr "movu" "1")
 404    (set_attr "prefix" "vex")
 405    (set_attr "mode" "<avxvecmode>")])
 406
 407 (define_insn "sse2_movdqu"
 408   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 409         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 410                       UNSPEC_MOVU))]
 411   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 412   "movdqu\t{%1, %0|%0, %1}"
 413   [(set_attr "type" "ssemov")
 414    (set_attr "movu" "1")
 415    (set_attr "prefix_data16" "1")
 416    (set_attr "mode" "TI")])
 417
 418 (define_insn "avx_movnt<mode>"
 419   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
 420         (unspec:AVXMODEF2P
 421           [(match_operand:AVXMODEF2P 1 "register_operand" "x")]
 422           UNSPEC_MOVNT))]
 423   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 424   "vmovntp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 425   [(set_attr "type" "ssemov")
 426    (set_attr "prefix" "vex")
 427    (set_attr "mode" "<MODE>")])
 428
 429 (define_insn "<sse>_movnt<mode>"
 430   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "=m")
 431         (unspec:SSEMODEF2P
 432           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
 433           UNSPEC_MOVNT))]
 434   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 435   "movntp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 436   [(set_attr "type" "ssemov")
 437    (set_attr "mode" "<MODE>")])
 438
 439 (define_insn "avx_movnt<mode>"
 440   [(set (match_operand:AVXMODEDI 0 "memory_operand" "=m")
 441         (unspec:AVXMODEDI
 442           [(match_operand:AVXMODEDI 1 "register_operand" "x")]
 443           UNSPEC_MOVNT))]
 444   "TARGET_AVX"
 445   "vmovntdq\t{%1, %0|%0, %1}"
 446   [(set_attr "type" "ssecvt")
 447    (set_attr "prefix" "vex")
 448    (set_attr "mode" "<avxvecmode>")])
 449
 450 (define_insn "sse2_movntv2di"
 451   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 452         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 453                      UNSPEC_MOVNT))]
 454   "TARGET_SSE2"
 455   "movntdq\t{%1, %0|%0, %1}"
 456   [(set_attr "type" "ssemov")
 457    (set_attr "prefix_data16" "1")
 458    (set_attr "mode" "TI")])
 459
 460 (define_insn "sse2_movntsi"
 461   [(set (match_operand:SI 0 "memory_operand" "=m")
 462         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 463                    UNSPEC_MOVNT))]
 464   "TARGET_SSE2"
 465   "movnti\t{%1, %0|%0, %1}"
 466   [(set_attr "type" "ssemov")
 467    (set_attr "prefix_data16" "0")
 468    (set_attr "mode" "V2DF")])
 469
 470 (define_insn "avx_lddqu<avxmodesuffix>"
 471   [(set (match_operand:AVXMODEQI 0 "register_operand" "=x")
 472         (unspec:AVXMODEQI
 473           [(match_operand:AVXMODEQI 1 "memory_operand" "m")]
 474           UNSPEC_LDDQU))]
 475   "TARGET_AVX"
 476   "vlddqu\t{%1, %0|%0, %1}"
 477   [(set_attr "type" "ssecvt")
 478    (set_attr "movu" "1")
 479    (set_attr "prefix" "vex")
 480    (set_attr "mode" "<avxvecmode>")])
 481
 482 (define_insn "sse3_lddqu"
 483   [(set (match_operand:V16QI 0 "register_operand" "=x")
 484         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 485                       UNSPEC_LDDQU))]
 486   "TARGET_SSE3"
 487   "lddqu\t{%1, %0|%0, %1}"
 488   [(set_attr "type" "ssemov")
 489    (set_attr "movu" "1")
 490    (set_attr "prefix_data16" "0")
 491    (set_attr "prefix_rep" "1")
 492    (set_attr "mode" "TI")])
 493
 494 ; Expand patterns for non-temporal stores.  At the moment, only those
 495 ; that directly map to insns are defined; it would be possible to
 496 ; define patterns for other modes that would expand to several insns.
 497
 498 (define_expand "storent<mode>"
 499   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "")
 500         (unspec:SSEMODEF2P
 501           [(match_operand:SSEMODEF2P 1 "register_operand" "")]
 502           UNSPEC_MOVNT))]
 503   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 504   "")
 505
 506 (define_expand "storent<mode>"
 507   [(set (match_operand:MODEF 0 "memory_operand" "")
 508         (unspec:MODEF
 509           [(match_operand:MODEF 1 "register_operand" "")]
 510           UNSPEC_MOVNT))]
 511   "TARGET_SSE4A"
 512   "")
 513
 514 (define_expand "storentv2di"
 515   [(set (match_operand:V2DI 0 "memory_operand" "")
 516         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "")]
 517                      UNSPEC_MOVNT))]
 518   "TARGET_SSE2"
 519   "")
 520
 521 (define_expand "storentsi"
 522   [(set (match_operand:SI 0 "memory_operand" "")
 523         (unspec:SI [(match_operand:SI 1 "register_operand" "")]
 524                    UNSPEC_MOVNT))]
 525   "TARGET_SSE2"
 526   "")
 527
 528 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 529 ;;
 530 ;; Parallel floating point arithmetic
 531 ;;
 532 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 533
 534 (define_expand "<code><mode>2"
 535   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 536         (absneg:SSEMODEF2P
 537           (match_operand:SSEMODEF2P 1 "register_operand" "")))]
 538   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 539   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 540
 541 (define_expand "<plusminus_insn><mode>3"
 542   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 543         (plusminus:AVX256MODEF2P
 544           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 545           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 546   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 547   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 548
 549 (define_insn "*avx_<plusminus_insn><mode>3"
 550   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 551         (plusminus:AVXMODEF2P
 552           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "<comm>x")
 553           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 554   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 555    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 556   "v<plusminus_mnemonic>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 557   [(set_attr "type" "sseadd")
 558    (set_attr "prefix" "vex")
 559    (set_attr "mode" "<avxvecmode>")])
 560
 561 (define_expand "<plusminus_insn><mode>3"
 562   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 563         (plusminus:SSEMODEF2P
 564           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 565           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 566   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 567   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 568
 569 (define_insn "*<plusminus_insn><mode>3"
 570   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 571         (plusminus:SSEMODEF2P
 572           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "<comm>0")
 573           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 574   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 575    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 576   "<plusminus_mnemonic>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 577   [(set_attr "type" "sseadd")
 578    (set_attr "mode" "<MODE>")])
 579
 580 (define_insn "*avx_vm<plusminus_insn><mode>3"
 581   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 582         (vec_merge:SSEMODEF2P
 583           (plusminus:SSEMODEF2P
 584             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 585             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 586           (match_dup 1)
 587           (const_int 1)))]
 588   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 589   "v<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 590   [(set_attr "type" "sseadd")
 591    (set_attr "prefix" "vex")
 592    (set_attr "mode" "<ssescalarmode>")])
 593
 594 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 595   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 596         (vec_merge:SSEMODEF2P
 597           (plusminus:SSEMODEF2P
 598             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 599             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 600           (match_dup 1)
 601           (const_int 1)))]
 602   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 603   "<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 604   [(set_attr "type" "sseadd")
 605    (set_attr "mode" "<ssescalarmode>")])
 606
 607 (define_expand "mul<mode>3"
 608   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 609         (mult:AVX256MODEF2P
 610           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 611           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 612   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 613   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 614
 615 (define_insn "*avx_mul<mode>3"
 616   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 617         (mult:AVXMODEF2P
 618           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 619           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 620   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 621    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 622   "vmulp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 623   [(set_attr "type" "ssemul")
 624    (set_attr "prefix" "vex")
 625    (set_attr "mode" "<avxvecmode>")])
 626
 627 (define_expand "mul<mode>3"
 628   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 629         (mult:SSEMODEF2P
 630           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 631           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 632   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 633   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 634
 635 (define_insn "*mul<mode>3"
 636   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 637         (mult:SSEMODEF2P
 638           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 639           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 640   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 641    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 642   "mulp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 643   [(set_attr "type" "ssemul")
 644    (set_attr "mode" "<MODE>")])
 645
 646 (define_insn "*avx_vmmul<mode>3"
 647   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 648         (vec_merge:SSEMODEF2P
 649           (mult:SSEMODEF2P
 650             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 651             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 652           (match_dup 1)
 653           (const_int 1)))]
 654   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 655   "vmuls<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 656   [(set_attr "type" "ssemul")
 657    (set_attr "prefix" "vex")
 658    (set_attr "mode" "<ssescalarmode>")])
 659
 660 (define_insn "<sse>_vmmul<mode>3"
 661   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 662         (vec_merge:SSEMODEF2P
 663           (mult:SSEMODEF2P
 664             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 665             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 666           (match_dup 1)
 667           (const_int 1)))]
 668   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 669   "muls<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 670   [(set_attr "type" "ssemul")
 671    (set_attr "mode" "<ssescalarmode>")])
 672
 673 (define_expand "divv8sf3"
 674   [(set (match_operand:V8SF 0 "register_operand" "")
 675         (div:V8SF (match_operand:V8SF 1 "register_operand" "")
 676                   (match_operand:V8SF 2 "nonimmediate_operand" "")))]
 677   "TARGET_AVX"
 678 {
 679   ix86_fixup_binary_operands_no_copy (DIV, V8SFmode, operands);
 680
 681   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 682       && flag_finite_math_only && !flag_trapping_math
 683       && flag_unsafe_math_optimizations)
 684     {
 685       ix86_emit_swdivsf (operands[0], operands[1],
 686                          operands[2], V8SFmode);
 687       DONE;
 688     }
 689 })
 690
 691 (define_expand "divv4df3"
 692   [(set (match_operand:V4DF 0 "register_operand" "")
 693         (div:V4DF (match_operand:V4DF 1 "register_operand" "")
 694                   (match_operand:V4DF 2 "nonimmediate_operand" "")))]
 695   "TARGET_AVX"
 696   "ix86_fixup_binary_operands_no_copy (DIV, V4DFmode, operands);")
 697
 698 (define_insn "avx_div<mode>3"
 699   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 700         (div:AVXMODEF2P
 701           (match_operand:AVXMODEF2P 1 "register_operand" "x")
 702           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 703   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 704   "vdivp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 705   [(set_attr "type" "ssediv")
 706    (set_attr "prefix" "vex")
 707    (set_attr "mode" "<MODE>")])
 708
 709 (define_expand "divv4sf3"
 710   [(set (match_operand:V4SF 0 "register_operand" "")
 711         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 712                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 713   "TARGET_SSE"
 714 {
 715   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 716       && flag_finite_math_only && !flag_trapping_math
 717       && flag_unsafe_math_optimizations)
 718     {
 719       ix86_emit_swdivsf (operands[0], operands[1],
 720                          operands[2], V4SFmode);
 721       DONE;
 722     }
 723 })
 724
 725 (define_expand "divv2df3"
 726   [(set (match_operand:V2DF 0 "register_operand" "")
 727         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
 728                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
 729   "TARGET_SSE2"
 730   "")
 731
 732 (define_insn "*avx_div<mode>3"
 733   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 734         (div:SSEMODEF2P
 735           (match_operand:SSEMODEF2P 1 "register_operand" "x")
 736           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 737   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 738   "vdivp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 739   [(set_attr "type" "ssediv")
 740    (set_attr "prefix" "vex")
 741    (set_attr "mode" "<MODE>")])
 742
 743 (define_insn "<sse>_div<mode>3"
 744   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 745         (div:SSEMODEF2P
 746           (match_operand:SSEMODEF2P 1 "register_operand" "0")
 747           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 748   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 749   "divp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 750   [(set_attr "type" "ssediv")
 751    (set_attr "mode" "<MODE>")])
 752
 753 (define_insn "*avx_vmdiv<mode>3"
 754   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 755         (vec_merge:SSEMODEF2P
 756           (div:SSEMODEF2P
 757             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 758             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 759           (match_dup 1)
 760           (const_int 1)))]
 761   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 762   "vdivs<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 763   [(set_attr "type" "ssediv")
 764    (set_attr "prefix" "vex")
 765    (set_attr "mode" "<ssescalarmode>")])
 766
 767 (define_insn "<sse>_vmdiv<mode>3"
 768   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 769         (vec_merge:SSEMODEF2P
 770           (div:SSEMODEF2P
 771             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 772             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 773           (match_dup 1)
 774           (const_int 1)))]
 775   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 776   "divs<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 777   [(set_attr "type" "ssediv")
 778    (set_attr "mode" "<ssescalarmode>")])
 779
 780 (define_insn "avx_rcpv8sf2"
 781   [(set (match_operand:V8SF 0 "register_operand" "=x")
 782         (unspec:V8SF
 783           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 784   "TARGET_AVX"
 785   "vrcpps\t{%1, %0|%0, %1}"
 786   [(set_attr "type" "sse")
 787    (set_attr "prefix" "vex")
 788    (set_attr "mode" "V8SF")])
 789
 790 (define_insn "sse_rcpv4sf2"
 791   [(set (match_operand:V4SF 0 "register_operand" "=x")
 792         (unspec:V4SF
 793           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 794   "TARGET_SSE"
 795   "%vrcpps\t{%1, %0|%0, %1}"
 796   [(set_attr "type" "sse")
 797    (set_attr "atom_sse_attr" "rcp")
 798    (set_attr "prefix" "maybe_vex")
 799    (set_attr "mode" "V4SF")])
 800
 801 (define_insn "*avx_vmrcpv4sf2"
 802   [(set (match_operand:V4SF 0 "register_operand" "=x")
 803         (vec_merge:V4SF
 804           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 805                        UNSPEC_RCP)
 806           (match_operand:V4SF 2 "register_operand" "x")
 807           (const_int 1)))]
 808   "TARGET_AVX"
 809   "vrcpss\t{%1, %2, %0|%0, %2, %1}"
 810   [(set_attr "type" "sse")
 811    (set_attr "prefix" "vex")
 812    (set_attr "mode" "SF")])
 813
 814 (define_insn "sse_vmrcpv4sf2"
 815   [(set (match_operand:V4SF 0 "register_operand" "=x")
 816         (vec_merge:V4SF
 817           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 818                        UNSPEC_RCP)
 819           (match_operand:V4SF 2 "register_operand" "0")
 820           (const_int 1)))]
 821   "TARGET_SSE"
 822   "rcpss\t{%1, %0|%0, %1}"
 823   [(set_attr "type" "sse")
 824    (set_attr "atom_sse_attr" "rcp")
 825    (set_attr "mode" "SF")])
 826
 827 (define_expand "sqrtv8sf2"
 828   [(set (match_operand:V8SF 0 "register_operand" "")
 829         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "")))]
 830   "TARGET_AVX"
 831 {
 832   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 833       && flag_finite_math_only && !flag_trapping_math
 834       && flag_unsafe_math_optimizations)
 835     {
 836       ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 0);
 837       DONE;
 838     }
 839 })
 840
 841 (define_insn "avx_sqrtv8sf2"
 842   [(set (match_operand:V8SF 0 "register_operand" "=x")
 843         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
 844   "TARGET_AVX"
 845   "vsqrtps\t{%1, %0|%0, %1}"
 846   [(set_attr "type" "sse")
 847    (set_attr "prefix" "vex")
 848    (set_attr "mode" "V8SF")])
 849
 850 (define_expand "sqrtv4sf2"
 851   [(set (match_operand:V4SF 0 "register_operand" "")
 852         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 853   "TARGET_SSE"
 854 {
 855   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 856       && flag_finite_math_only && !flag_trapping_math
 857       && flag_unsafe_math_optimizations)
 858     {
 859       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 860       DONE;
 861     }
 862 })
 863
 864 (define_insn "sse_sqrtv4sf2"
 865   [(set (match_operand:V4SF 0 "register_operand" "=x")
 866         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 867   "TARGET_SSE"
 868   "%vsqrtps\t{%1, %0|%0, %1}"
 869   [(set_attr "type" "sse")
 870    (set_attr "atom_sse_attr" "sqrt")
 871    (set_attr "prefix" "maybe_vex")
 872    (set_attr "mode" "V4SF")])
 873
 874 (define_insn "sqrtv4df2"
 875   [(set (match_operand:V4DF 0 "register_operand" "=x")
 876         (sqrt:V4DF (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
 877   "TARGET_AVX"
 878   "vsqrtpd\t{%1, %0|%0, %1}"
 879   [(set_attr "type" "sse")
 880    (set_attr "prefix" "vex")
 881    (set_attr "mode" "V4DF")])
 882
 883 (define_insn "sqrtv2df2"
 884   [(set (match_operand:V2DF 0 "register_operand" "=x")
 885         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
 886   "TARGET_SSE2"
 887   "%vsqrtpd\t{%1, %0|%0, %1}"
 888   [(set_attr "type" "sse")
 889    (set_attr "prefix" "maybe_vex")
 890    (set_attr "mode" "V2DF")])
 891
 892 (define_insn "*avx_vmsqrt<mode>2"
 893   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 894         (vec_merge:SSEMODEF2P
 895           (sqrt:SSEMODEF2P
 896             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 897           (match_operand:SSEMODEF2P 2 "register_operand" "x")
 898           (const_int 1)))]
 899   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 900   "vsqrts<ssemodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
 901   [(set_attr "type" "sse")
 902    (set_attr "prefix" "vex")
 903    (set_attr "mode" "<ssescalarmode>")])
 904
 905 (define_insn "<sse>_vmsqrt<mode>2"
 906   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 907         (vec_merge:SSEMODEF2P
 908           (sqrt:SSEMODEF2P
 909             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 910           (match_operand:SSEMODEF2P 2 "register_operand" "0")
 911           (const_int 1)))]
 912   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 913   "sqrts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 914   [(set_attr "type" "sse")
 915    (set_attr "atom_sse_attr" "sqrt")
 916    (set_attr "mode" "<ssescalarmode>")])
 917
 918 (define_expand "rsqrtv8sf2"
 919   [(set (match_operand:V8SF 0 "register_operand" "")
 920         (unspec:V8SF
 921           [(match_operand:V8SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 922   "TARGET_AVX && TARGET_SSE_MATH"
 923 {
 924   ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 1);
 925   DONE;
 926 })
 927
 928 (define_insn "avx_rsqrtv8sf2"
 929   [(set (match_operand:V8SF 0 "register_operand" "=x")
 930         (unspec:V8SF
 931           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 932   "TARGET_AVX"
 933   "vrsqrtps\t{%1, %0|%0, %1}"
 934   [(set_attr "type" "sse")
 935    (set_attr "prefix" "vex")
 936    (set_attr "mode" "V8SF")])
 937
 938 (define_expand "rsqrtv4sf2"
 939   [(set (match_operand:V4SF 0 "register_operand" "")
 940         (unspec:V4SF
 941           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 942   "TARGET_SSE_MATH"
 943 {
 944   ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 945   DONE;
 946 })
 947
 948 (define_insn "sse_rsqrtv4sf2"
 949   [(set (match_operand:V4SF 0 "register_operand" "=x")
 950         (unspec:V4SF
 951           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 952   "TARGET_SSE"
 953   "%vrsqrtps\t{%1, %0|%0, %1}"
 954   [(set_attr "type" "sse")
 955    (set_attr "prefix" "maybe_vex")
 956    (set_attr "mode" "V4SF")])
 957
 958 (define_insn "*avx_vmrsqrtv4sf2"
 959   [(set (match_operand:V4SF 0 "register_operand" "=x")
 960         (vec_merge:V4SF
 961           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 962                        UNSPEC_RSQRT)
 963           (match_operand:V4SF 2 "register_operand" "x")
 964           (const_int 1)))]
 965   "TARGET_AVX"
 966   "vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
 967   [(set_attr "type" "sse")
 968    (set_attr "prefix" "vex")
 969    (set_attr "mode" "SF")])
 970
 971 (define_insn "sse_vmrsqrtv4sf2"
 972   [(set (match_operand:V4SF 0 "register_operand" "=x")
 973         (vec_merge:V4SF
 974           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 975                        UNSPEC_RSQRT)
 976           (match_operand:V4SF 2 "register_operand" "0")
 977           (const_int 1)))]
 978   "TARGET_SSE"
 979   "rsqrtss\t{%1, %0|%0, %1}"
 980   [(set_attr "type" "sse")
 981    (set_attr "mode" "SF")])
 982
 983 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
 984 ;; isn't really correct, as those rtl operators aren't defined when
 985 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
 986
 987 (define_expand "<code><mode>3"
 988   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 989         (smaxmin:AVX256MODEF2P
 990           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 991           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 992   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 993 {
 994   if (!flag_finite_math_only)
 995     operands[1] = force_reg (<MODE>mode, operands[1]);
 996   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
 997 })
 998
 999 (define_expand "<code><mode>3"
1000   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1001         (smaxmin:SSEMODEF2P
1002           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1003           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1004   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1005 {
1006   if (!flag_finite_math_only)
1007     operands[1] = force_reg (<MODE>mode, operands[1]);
1008   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1009 })
1010
1011 (define_insn "*avx_<code><mode>3_finite"
1012   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1013         (smaxmin:AVXMODEF2P
1014           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1015           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1016   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1017    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1018   "v<maxmin_float>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1019   [(set_attr "type" "sseadd")
1020    (set_attr "prefix" "vex")
1021    (set_attr "mode" "<MODE>")])
1022
1023 (define_insn "*<code><mode>3_finite"
1024   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1025         (smaxmin:SSEMODEF2P
1026           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1027           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1028   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1029    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1030   "<maxmin_float>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1031   [(set_attr "type" "sseadd")
1032    (set_attr "mode" "<MODE>")])
1033
1034 (define_insn "*avx_<code><mode>3"
1035   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1036         (smaxmin:AVXMODEF2P
1037           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1038           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1039   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1040   "v<maxmin_float>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1041   [(set_attr "type" "sseadd")
1042    (set_attr "prefix" "vex")
1043    (set_attr "mode" "<avxvecmode>")])
1044
1045 (define_insn "*<code><mode>3"
1046   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1047         (smaxmin:SSEMODEF2P
1048           (match_operand:SSEMODEF2P 1 "register_operand" "0")
1049           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1050   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1051   "<maxmin_float>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1052   [(set_attr "type" "sseadd")
1053    (set_attr "mode" "<MODE>")])
1054
1055 (define_insn "*avx_vm<code><mode>3"
1056   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1057         (vec_merge:SSEMODEF2P
1058           (smaxmin:SSEMODEF2P
1059             (match_operand:SSEMODEF2P 1 "register_operand" "x")
1060             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1061          (match_dup 1)
1062          (const_int 1)))]
1063   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
1064   "v<maxmin_float>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1065   [(set_attr "type" "sse")
1066    (set_attr "prefix" "vex")
1067    (set_attr "mode" "<ssescalarmode>")])
1068
1069 (define_insn "<sse>_vm<code><mode>3"
1070   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1071         (vec_merge:SSEMODEF2P
1072           (smaxmin:SSEMODEF2P
1073             (match_operand:SSEMODEF2P 1 "register_operand" "0")
1074             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1075          (match_dup 1)
1076          (const_int 1)))]
1077   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1078   "<maxmin_float>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1079   [(set_attr "type" "sseadd")
1080    (set_attr "mode" "<ssescalarmode>")])
1081
1082 ;; These versions of the min/max patterns implement exactly the operations
1083 ;;   min = (op1 < op2 ? op1 : op2)
1084 ;;   max = (!(op1 < op2) ? op1 : op2)
1085 ;; Their operands are not commutative, and thus they may be used in the
1086 ;; presence of -0.0 and NaN.
1087
1088 (define_insn "*avx_ieee_smin<mode>3"
1089   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1090         (unspec:AVXMODEF2P
1091           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1092            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1093          UNSPEC_IEEE_MIN))]
1094   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1095   "vminp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1096   [(set_attr "type" "sseadd")
1097    (set_attr "prefix" "vex")
1098    (set_attr "mode" "<avxvecmode>")])
1099
1100 (define_insn "*avx_ieee_smax<mode>3"
1101   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1102         (unspec:AVXMODEF2P
1103           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1104            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1105          UNSPEC_IEEE_MAX))]
1106   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1107   "vmaxp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1108   [(set_attr "type" "sseadd")
1109    (set_attr "prefix" "vex")
1110    (set_attr "mode" "<avxvecmode>")])
1111
1112 (define_insn "*ieee_smin<mode>3"
1113   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1114         (unspec:SSEMODEF2P
1115           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1116            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1117          UNSPEC_IEEE_MIN))]
1118   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1119   "minp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1120   [(set_attr "type" "sseadd")
1121    (set_attr "mode" "<MODE>")])
1122
1123 (define_insn "*ieee_smax<mode>3"
1124   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1125         (unspec:SSEMODEF2P
1126           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1127            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1128          UNSPEC_IEEE_MAX))]
1129   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1130   "maxp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1131   [(set_attr "type" "sseadd")
1132    (set_attr "mode" "<MODE>")])
1133
1134 (define_insn "avx_addsubv8sf3"
1135   [(set (match_operand:V8SF 0 "register_operand" "=x")
1136         (vec_merge:V8SF
1137           (plus:V8SF
1138             (match_operand:V8SF 1 "register_operand" "x")
1139             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1140           (minus:V8SF (match_dup 1) (match_dup 2))
1141           (const_int 170)))]
1142   "TARGET_AVX"
1143   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1144   [(set_attr "type" "sseadd")
1145    (set_attr "prefix" "vex")
1146    (set_attr "mode" "V8SF")])
1147
1148 (define_insn "avx_addsubv4df3"
1149   [(set (match_operand:V4DF 0 "register_operand" "=x")
1150         (vec_merge:V4DF
1151           (plus:V4DF
1152             (match_operand:V4DF 1 "register_operand" "x")
1153             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1154           (minus:V4DF (match_dup 1) (match_dup 2))
1155           (const_int 10)))]
1156   "TARGET_AVX"
1157   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1158   [(set_attr "type" "sseadd")
1159    (set_attr "prefix" "vex")
1160    (set_attr "mode" "V4DF")])
1161
1162 (define_insn "*avx_addsubv4sf3"
1163   [(set (match_operand:V4SF 0 "register_operand" "=x")
1164         (vec_merge:V4SF
1165           (plus:V4SF
1166             (match_operand:V4SF 1 "register_operand" "x")
1167             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1168           (minus:V4SF (match_dup 1) (match_dup 2))
1169           (const_int 10)))]
1170   "TARGET_AVX"
1171   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1172   [(set_attr "type" "sseadd")
1173    (set_attr "prefix" "vex")
1174    (set_attr "mode" "V4SF")])
1175
1176 (define_insn "sse3_addsubv4sf3"
1177   [(set (match_operand:V4SF 0 "register_operand" "=x")
1178         (vec_merge:V4SF
1179           (plus:V4SF
1180             (match_operand:V4SF 1 "register_operand" "0")
1181             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1182           (minus:V4SF (match_dup 1) (match_dup 2))
1183           (const_int 10)))]
1184   "TARGET_SSE3"
1185   "addsubps\t{%2, %0|%0, %2}"
1186   [(set_attr "type" "sseadd")
1187    (set_attr "prefix_rep" "1")
1188    (set_attr "mode" "V4SF")])
1189
1190 (define_insn "*avx_addsubv2df3"
1191   [(set (match_operand:V2DF 0 "register_operand" "=x")
1192         (vec_merge:V2DF
1193           (plus:V2DF
1194             (match_operand:V2DF 1 "register_operand" "x")
1195             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1196           (minus:V2DF (match_dup 1) (match_dup 2))
1197           (const_int 2)))]
1198   "TARGET_AVX"
1199   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1200   [(set_attr "type" "sseadd")
1201    (set_attr "prefix" "vex")
1202    (set_attr "mode" "V2DF")])
1203
1204 (define_insn "sse3_addsubv2df3"
1205   [(set (match_operand:V2DF 0 "register_operand" "=x")
1206         (vec_merge:V2DF
1207           (plus:V2DF
1208             (match_operand:V2DF 1 "register_operand" "0")
1209             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1210           (minus:V2DF (match_dup 1) (match_dup 2))
1211           (const_int 2)))]
1212   "TARGET_SSE3"
1213   "addsubpd\t{%2, %0|%0, %2}"
1214   [(set_attr "type" "sseadd")
1215    (set_attr "atom_unit" "complex")
1216    (set_attr "mode" "V2DF")])
1217
1218 (define_insn "avx_h<plusminus_insn>v4df3"
1219   [(set (match_operand:V4DF 0 "register_operand" "=x")
1220         (vec_concat:V4DF
1221           (vec_concat:V2DF
1222             (plusminus:DF
1223               (vec_select:DF
1224                 (match_operand:V4DF 1 "register_operand" "x")
1225                 (parallel [(const_int 0)]))
1226               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1227             (plusminus:DF
1228               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1229               (vec_select:DF (match_dup 1) (parallel [(const_int 3)]))))
1230           (vec_concat:V2DF
1231             (plusminus:DF
1232               (vec_select:DF
1233                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1234                 (parallel [(const_int 0)]))
1235               (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))
1236             (plusminus:DF
1237               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1238               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1239   "TARGET_AVX"
1240   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1241   [(set_attr "type" "sseadd")
1242    (set_attr "prefix" "vex")
1243    (set_attr "mode" "V4DF")])
1244
1245 (define_insn "avx_h<plusminus_insn>v8sf3"
1246   [(set (match_operand:V8SF 0 "register_operand" "=x")
1247         (vec_concat:V8SF
1248           (vec_concat:V4SF
1249             (vec_concat:V2SF
1250               (plusminus:SF
1251                 (vec_select:SF
1252                   (match_operand:V8SF 1 "register_operand" "x")
1253                   (parallel [(const_int 0)]))
1254                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1255               (plusminus:SF
1256                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1257                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1258             (vec_concat:V2SF
1259               (plusminus:SF
1260                 (vec_select:SF
1261                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1262                   (parallel [(const_int 0)]))
1263                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1264               (plusminus:SF
1265                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1266                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1267           (vec_concat:V4SF
1268             (vec_concat:V2SF
1269               (plusminus:SF
1270                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1271                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1272               (plusminus:SF
1273                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1274                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1275             (vec_concat:V2SF
1276               (plusminus:SF
1277                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1278                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1279               (plusminus:SF
1280                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1281                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1282   "TARGET_AVX"
1283   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1284   [(set_attr "type" "sseadd")
1285    (set_attr "prefix" "vex")
1286    (set_attr "mode" "V8SF")])
1287
1288 (define_insn "*avx_h<plusminus_insn>v4sf3"
1289   [(set (match_operand:V4SF 0 "register_operand" "=x")
1290         (vec_concat:V4SF
1291           (vec_concat:V2SF
1292             (plusminus:SF
1293               (vec_select:SF
1294                 (match_operand:V4SF 1 "register_operand" "x")
1295                 (parallel [(const_int 0)]))
1296               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1297             (plusminus:SF
1298               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1299               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1300           (vec_concat:V2SF
1301             (plusminus:SF
1302               (vec_select:SF
1303                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1304                 (parallel [(const_int 0)]))
1305               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1306             (plusminus:SF
1307               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1308               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1309   "TARGET_AVX"
1310   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1311   [(set_attr "type" "sseadd")
1312    (set_attr "prefix" "vex")
1313    (set_attr "mode" "V4SF")])
1314
1315 (define_insn "sse3_h<plusminus_insn>v4sf3"
1316   [(set (match_operand:V4SF 0 "register_operand" "=x")
1317         (vec_concat:V4SF
1318           (vec_concat:V2SF
1319             (plusminus:SF
1320               (vec_select:SF
1321                 (match_operand:V4SF 1 "register_operand" "0")
1322                 (parallel [(const_int 0)]))
1323               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1324             (plusminus:SF
1325               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1326               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1327           (vec_concat:V2SF
1328             (plusminus:SF
1329               (vec_select:SF
1330                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1331                 (parallel [(const_int 0)]))
1332               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1333             (plusminus:SF
1334               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1335               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1336   "TARGET_SSE3"
1337   "h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}"
1338   [(set_attr "type" "sseadd")
1339    (set_attr "atom_unit" "complex")
1340    (set_attr "prefix_rep" "1")
1341    (set_attr "mode" "V4SF")])
1342
1343 (define_insn "*avx_h<plusminus_insn>v2df3"
1344   [(set (match_operand:V2DF 0 "register_operand" "=x")
1345         (vec_concat:V2DF
1346           (plusminus:DF
1347             (vec_select:DF
1348               (match_operand:V2DF 1 "register_operand" "x")
1349               (parallel [(const_int 0)]))
1350             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1351           (plusminus:DF
1352             (vec_select:DF
1353               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1354               (parallel [(const_int 0)]))
1355             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1356   "TARGET_AVX"
1357   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1358   [(set_attr "type" "sseadd")
1359    (set_attr "prefix" "vex")
1360    (set_attr "mode" "V2DF")])
1361
1362 (define_insn "sse3_h<plusminus_insn>v2df3"
1363   [(set (match_operand:V2DF 0 "register_operand" "=x")
1364         (vec_concat:V2DF
1365           (plusminus:DF
1366             (vec_select:DF
1367               (match_operand:V2DF 1 "register_operand" "0")
1368               (parallel [(const_int 0)]))
1369             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1370           (plusminus:DF
1371             (vec_select:DF
1372               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1373               (parallel [(const_int 0)]))
1374             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1375   "TARGET_SSE3"
1376   "h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}"
1377   [(set_attr "type" "sseadd")
1378    (set_attr "mode" "V2DF")])
1379
1380 (define_expand "reduc_splus_v4sf"
1381   [(match_operand:V4SF 0 "register_operand" "")
1382    (match_operand:V4SF 1 "register_operand" "")]
1383   "TARGET_SSE"
1384 {
1385   if (TARGET_SSE3)
1386     {
1387       rtx tmp = gen_reg_rtx (V4SFmode);
1388       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1389       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1390     }
1391   else
1392     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
1393   DONE;
1394 })
1395
1396 (define_expand "reduc_splus_v2df"
1397   [(match_operand:V2DF 0 "register_operand" "")
1398    (match_operand:V2DF 1 "register_operand" "")]
1399   "TARGET_SSE3"
1400 {
1401   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1402   DONE;
1403 })
1404
1405 (define_expand "reduc_smax_v4sf"
1406   [(match_operand:V4SF 0 "register_operand" "")
1407    (match_operand:V4SF 1 "register_operand" "")]
1408   "TARGET_SSE"
1409 {
1410   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
1411   DONE;
1412 })
1413
1414 (define_expand "reduc_smin_v4sf"
1415   [(match_operand:V4SF 0 "register_operand" "")
1416    (match_operand:V4SF 1 "register_operand" "")]
1417   "TARGET_SSE"
1418 {
1419   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
1420   DONE;
1421 })
1422
1423 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1424 ;;
1425 ;; Parallel floating point comparisons
1426 ;;
1427 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1428
1429 (define_insn "avx_cmpp<avxmodesuffixf2c><mode>3"
1430   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1431         (unspec:AVXMODEF2P
1432           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1433            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
1434            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1435           UNSPEC_PCMP))]
1436   "TARGET_AVX"
1437   "vcmpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1438   [(set_attr "type" "ssecmp")
1439    (set_attr "length_immediate" "1")
1440    (set_attr "prefix" "vex")
1441    (set_attr "mode" "<MODE>")])
1442
1443 (define_insn "avx_cmps<ssemodesuffixf2c><mode>3"
1444   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1445         (vec_merge:SSEMODEF2P
1446           (unspec:SSEMODEF2P
1447             [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1448              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
1449              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1450             UNSPEC_PCMP)
1451          (match_dup 1)
1452          (const_int 1)))]
1453   "TARGET_AVX"
1454   "vcmps<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1455   [(set_attr "type" "ssecmp")
1456    (set_attr "length_immediate" "1")
1457    (set_attr "prefix" "vex")
1458    (set_attr "mode" "<ssescalarmode>")])
1459
1460 ;; We don't promote 128bit vector compare intrinsics. But vectorizer
1461 ;; may generate 256bit vector compare instructions.
1462 (define_insn "*avx_maskcmp<mode>3"
1463   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1464         (match_operator:AVXMODEF2P 3 "avx_comparison_float_operator"
1465                 [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1466                  (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]))]
1467   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1468   "vcmp%D3p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1469   [(set_attr "type" "ssecmp")
1470    (set_attr "prefix" "vex")
1471    (set_attr "length_immediate" "1")
1472    (set_attr "mode" "<avxvecmode>")])
1473
1474 (define_insn "<sse>_maskcmp<mode>3"
1475   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x")
1476         (match_operator:SSEMODEF4 3 "sse_comparison_operator"
1477                 [(match_operand:SSEMODEF4 1 "register_operand" "0")
1478                  (match_operand:SSEMODEF4 2 "nonimmediate_operand" "xm")]))]
1479   "!TARGET_XOP
1480   && (SSE_FLOAT_MODE_P (<MODE>mode) || SSE_VEC_FLOAT_MODE_P (<MODE>mode))"
1481   "cmp%D3<ssemodesuffixf4>\t{%2, %0|%0, %2}"
1482   [(set_attr "type" "ssecmp")
1483    (set_attr "length_immediate" "1")
1484    (set_attr "mode" "<MODE>")])
1485
1486 (define_insn "<sse>_vmmaskcmp<mode>3"
1487   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1488         (vec_merge:SSEMODEF2P
1489          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1490                 [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1491                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1492          (match_dup 1)
1493          (const_int 1)))]
1494   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1495   "cmp%D3s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1496   [(set_attr "type" "ssecmp")
1497    (set_attr "length_immediate" "1")
1498    (set_attr "mode" "<ssescalarmode>")])
1499
1500 (define_insn "<sse>_comi"
1501   [(set (reg:CCFP FLAGS_REG)
1502         (compare:CCFP
1503           (vec_select:MODEF
1504             (match_operand:<ssevecmode> 0 "register_operand" "x")
1505             (parallel [(const_int 0)]))
1506           (vec_select:MODEF
1507             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1508             (parallel [(const_int 0)]))))]
1509   "SSE_FLOAT_MODE_P (<MODE>mode)"
1510   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1511   [(set_attr "type" "ssecomi")
1512    (set_attr "prefix" "maybe_vex")
1513    (set_attr "prefix_rep" "0")
1514    (set (attr "prefix_data16")
1515         (if_then_else (eq_attr "mode" "DF")
1516                       (const_string "1")
1517                       (const_string "0")))
1518    (set_attr "mode" "<MODE>")])
1519
1520 (define_insn "<sse>_ucomi"
1521   [(set (reg:CCFPU FLAGS_REG)
1522         (compare:CCFPU
1523           (vec_select:MODEF
1524             (match_operand:<ssevecmode> 0 "register_operand" "x")
1525             (parallel [(const_int 0)]))
1526           (vec_select:MODEF
1527             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1528             (parallel [(const_int 0)]))))]
1529   "SSE_FLOAT_MODE_P (<MODE>mode)"
1530   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1531   [(set_attr "type" "ssecomi")
1532    (set_attr "prefix" "maybe_vex")
1533    (set_attr "prefix_rep" "0")
1534    (set (attr "prefix_data16")
1535         (if_then_else (eq_attr "mode" "DF")
1536                       (const_string "1")
1537                       (const_string "0")))
1538    (set_attr "mode" "<MODE>")])
1539
1540 (define_expand "vcond<mode>"
1541   [(set (match_operand:AVXMODEF2P 0 "register_operand" "")
1542         (if_then_else:AVXMODEF2P
1543           (match_operator 3 ""
1544             [(match_operand:AVXMODEF2P 4 "nonimmediate_operand" "")
1545              (match_operand:AVXMODEF2P 5 "nonimmediate_operand" "")])
1546           (match_operand:AVXMODEF2P 1 "general_operand" "")
1547           (match_operand:AVXMODEF2P 2 "general_operand" "")))]
1548   "(SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1549     || AVX_VEC_FLOAT_MODE_P (<MODE>mode))"
1550 {
1551   bool ok = ix86_expand_fp_vcond (operands);
1552   gcc_assert (ok);
1553   DONE;
1554 })
1555
1556 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1557 ;;
1558 ;; Parallel floating point logical operations
1559 ;;
1560 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1561
1562 (define_insn "avx_andnot<mode>3"
1563   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1564         (and:AVXMODEF2P
1565           (not:AVXMODEF2P
1566             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1567           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1568   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1569   "vandnp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1570   [(set_attr "type" "sselog")
1571    (set_attr "prefix" "vex")
1572    (set_attr "mode" "<avxvecmode>")])
1573
1574 (define_insn "<sse>_andnot<mode>3"
1575   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1576         (and:SSEMODEF2P
1577           (not:SSEMODEF2P
1578             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1579           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1580   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1581   "andnp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1582   [(set_attr "type" "sselog")
1583    (set_attr "mode" "<MODE>")])
1584
1585 (define_expand "<code><mode>3"
1586   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1587         (any_logic:AVX256MODEF2P
1588           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1589           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1590   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1591   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1592
1593 (define_insn "*avx_<code><mode>3"
1594   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1595         (any_logic:AVXMODEF2P
1596           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1597           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1598   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1599    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1600   "v<logic>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1601   [(set_attr "type" "sselog")
1602    (set_attr "prefix" "vex")
1603    (set_attr "mode" "<avxvecmode>")])
1604
1605 (define_expand "<code><mode>3"
1606   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1607         (any_logic:SSEMODEF2P
1608           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1609           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1610   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1611   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1612
1613 (define_insn "*<code><mode>3"
1614   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1615         (any_logic:SSEMODEF2P
1616           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1617           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1618   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1619    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1620   "<logic>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1621   [(set_attr "type" "sselog")
1622    (set_attr "mode" "<MODE>")])
1623
1624 (define_expand "copysign<mode>3"
1625   [(set (match_dup 4)
1626         (and:SSEMODEF2P
1627           (not:SSEMODEF2P (match_dup 3))
1628           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")))
1629    (set (match_dup 5)
1630         (and:SSEMODEF2P (match_dup 3)
1631                         (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))
1632    (set (match_operand:SSEMODEF2P 0 "register_operand" "")
1633         (ior:SSEMODEF2P (match_dup 4) (match_dup 5)))]
1634   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1635 {
1636   operands[3] = ix86_build_signbit_mask (<ssescalarmode>mode, 1, 0);
1637
1638   operands[4] = gen_reg_rtx (<MODE>mode);
1639   operands[5] = gen_reg_rtx (<MODE>mode);
1640 })
1641
1642 ;; Also define scalar versions.  These are used for abs, neg, and
1643 ;; conditional move.  Using subregs into vector modes causes register
1644 ;; allocation lossage.  These patterns do not allow memory operands
1645 ;; because the native instructions read the full 128-bits.
1646
1647 (define_insn "*avx_andnot<mode>3"
1648   [(set (match_operand:MODEF 0 "register_operand" "=x")
1649         (and:MODEF
1650           (not:MODEF
1651             (match_operand:MODEF 1 "register_operand" "x"))
1652             (match_operand:MODEF 2 "register_operand" "x")))]
1653   "AVX_FLOAT_MODE_P (<MODE>mode)"
1654   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1655   [(set_attr "type" "sselog")
1656    (set_attr "prefix" "vex")
1657    (set_attr "mode" "<ssevecmode>")])
1658
1659 (define_insn "*andnot<mode>3"
1660   [(set (match_operand:MODEF 0 "register_operand" "=x")
1661         (and:MODEF
1662           (not:MODEF
1663             (match_operand:MODEF 1 "register_operand" "0"))
1664             (match_operand:MODEF 2 "register_operand" "x")))]
1665   "SSE_FLOAT_MODE_P (<MODE>mode)"
1666   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1667   [(set_attr "type" "sselog")
1668    (set_attr "mode" "<ssevecmode>")])
1669
1670 (define_insn "*avx_<code><mode>3"
1671   [(set (match_operand:MODEF 0 "register_operand" "=x")
1672         (any_logic:MODEF
1673           (match_operand:MODEF 1 "register_operand" "x")
1674           (match_operand:MODEF 2 "register_operand" "x")))]
1675   "AVX_FLOAT_MODE_P (<MODE>mode)"
1676   "v<logic>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1677   [(set_attr "type" "sselog")
1678    (set_attr "prefix" "vex")
1679    (set_attr "mode" "<ssevecmode>")])
1680
1681 (define_insn "*<code><mode>3"
1682   [(set (match_operand:MODEF 0 "register_operand" "=x")
1683         (any_logic:MODEF
1684           (match_operand:MODEF 1 "register_operand" "0")
1685           (match_operand:MODEF 2 "register_operand" "x")))]
1686   "SSE_FLOAT_MODE_P (<MODE>mode)"
1687   "<logic>p<ssemodefsuffix>\t{%2, %0|%0, %2}"
1688   [(set_attr "type" "sselog")
1689    (set_attr "mode" "<ssevecmode>")])
1690
1691 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1692 ;;
1693 ;; FMA4 floating point multiply/accumulate instructions.  This
1694 ;; includes the scalar version of the instructions as well as the
1695 ;; vector.
1696 ;;
1697 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1698
1699 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1700 ;; combine to generate a multiply/add with two memory references.  We then
1701 ;; split this insn, into loading up the destination register with one of the
1702 ;; memory operations.  If we don't manage to split the insn, reload will
1703 ;; generate the appropriate moves.  The reason this is needed, is that combine
1704 ;; has already folded one of the memory references into both the multiply and
1705 ;; add insns, and it can't generate a new pseudo.  I.e.:
1706 ;;      (set (reg1) (mem (addr1)))
1707 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1708 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1709
1710 (define_insn "fma4_fmadd<mode>4256"
1711   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1712         (plus:FMA4MODEF4
1713          (mult:FMA4MODEF4
1714           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1715           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1716          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1717   "TARGET_FMA4 && TARGET_FUSED_MADD"
1718   "vfmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1719   [(set_attr "type" "ssemuladd")
1720    (set_attr "mode" "<MODE>")])
1721
1722 ;; Floating multiply and subtract.
1723 (define_insn "fma4_fmsub<mode>4256"
1724   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1725         (minus:FMA4MODEF4
1726          (mult:FMA4MODEF4
1727           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1728           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1729          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1730   "TARGET_FMA4 && TARGET_FUSED_MADD"
1731   "vfmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1732   [(set_attr "type" "ssemuladd")
1733    (set_attr "mode" "<MODE>")])
1734
1735 ;; Floating point negative multiply and add.
1736 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1737 (define_insn "fma4_fnmadd<mode>4256"
1738   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1739         (minus:FMA4MODEF4
1740          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1741          (mult:FMA4MODEF4
1742           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1743           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))))]
1744   "TARGET_FMA4 && TARGET_FUSED_MADD"
1745   "vfnmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1746   [(set_attr "type" "ssemuladd")
1747    (set_attr "mode" "<MODE>")])
1748
1749 ;; Floating point negative multiply and subtract.
1750 (define_insn "fma4_fnmsub<mode>4256"
1751   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1752         (minus:FMA4MODEF4
1753          (mult:FMA4MODEF4
1754           (neg:FMA4MODEF4
1755            (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1756           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1757          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1758   "TARGET_FMA4 && TARGET_FUSED_MADD"
1759   "vfnmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1760   [(set_attr "type" "ssemuladd")
1761    (set_attr "mode" "<MODE>")])
1762
1763 (define_insn "fma4_fmadd<mode>4"
1764   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1765         (plus:SSEMODEF4
1766          (mult:SSEMODEF4
1767           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1768           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1769          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1770   "TARGET_FMA4 && TARGET_FUSED_MADD"
1771   "vfmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1772   [(set_attr "type" "ssemuladd")
1773    (set_attr "mode" "<MODE>")])
1774
1775 ;; For the scalar operations, use operand1 for the upper words that aren't
1776 ;; modified, so restrict the forms that are generated.
1777 ;; Scalar version of fmadd.
1778 (define_insn "fma4_vmfmadd<mode>4"
1779   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1780         (vec_merge:SSEMODEF2P
1781          (plus:SSEMODEF2P
1782           (mult:SSEMODEF2P
1783            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1784            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1785           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1786          (match_dup 0)
1787          (const_int 1)))]
1788   "TARGET_FMA4 && TARGET_FUSED_MADD"
1789   "vfmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1790   [(set_attr "type" "ssemuladd")
1791    (set_attr "mode" "<MODE>")])
1792
1793 ;; Floating multiply and subtract.
1794 ;; Allow two memory operands the same as fmadd.
1795 (define_insn "fma4_fmsub<mode>4"
1796   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1797         (minus:SSEMODEF4
1798          (mult:SSEMODEF4
1799           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1800           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1801          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1802   "TARGET_FMA4 && TARGET_FUSED_MADD"
1803   "vfmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1804   [(set_attr "type" "ssemuladd")
1805    (set_attr "mode" "<MODE>")])
1806
1807 ;; For the scalar operations, use operand1 for the upper words that aren't
1808 ;; modified, so restrict the forms that are generated.
1809 ;; Scalar version of fmsub.
1810 (define_insn "fma4_vmfmsub<mode>4"
1811   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1812         (vec_merge:SSEMODEF2P
1813          (minus:SSEMODEF2P
1814           (mult:SSEMODEF2P
1815            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1816            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1817           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1818          (match_dup 0)
1819          (const_int 1)))]
1820   "TARGET_FMA4 && TARGET_FUSED_MADD"
1821   "vfmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1822   [(set_attr "type" "ssemuladd")
1823    (set_attr "mode" "<MODE>")])
1824
1825 ;; Floating point negative multiply and add.
1826 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1827 (define_insn "fma4_fnmadd<mode>4"
1828   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1829         (minus:SSEMODEF4
1830          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")
1831          (mult:SSEMODEF4
1832           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1833           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))))]
1834   "TARGET_FMA4 && TARGET_FUSED_MADD"
1835   "vfnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1836   [(set_attr "type" "ssemuladd")
1837    (set_attr "mode" "<MODE>")])
1838
1839 ;; For the scalar operations, use operand1 for the upper words that aren't
1840 ;; modified, so restrict the forms that are generated.
1841 ;; Scalar version of fnmadd.
1842 (define_insn "fma4_vmfnmadd<mode>4"
1843   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1844         (vec_merge:SSEMODEF2P
1845          (minus:SSEMODEF2P
1846           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1847           (mult:SSEMODEF2P
1848            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1849            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
1850          (match_dup 0)
1851          (const_int 1)))]
1852   "TARGET_FMA4 && TARGET_FUSED_MADD"
1853   "vfnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1854   [(set_attr "type" "ssemuladd")
1855    (set_attr "mode" "<MODE>")])
1856
1857 ;; Floating point negative multiply and subtract.
1858 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c.
1859 (define_insn "fma4_fnmsub<mode>4"
1860   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1861         (minus:SSEMODEF4
1862          (mult:SSEMODEF4
1863           (neg:SSEMODEF4
1864            (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x"))
1865           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1866          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1867   "TARGET_FMA4 && TARGET_FUSED_MADD"
1868   "vfnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1869   [(set_attr "type" "ssemuladd")
1870    (set_attr "mode" "<MODE>")])
1871
1872 ;; For the scalar operations, use operand1 for the upper words that aren't
1873 ;; modified, so restrict the forms that are generated.
1874 ;; Scalar version of fnmsub.
1875 (define_insn "fma4_vmfnmsub<mode>4"
1876   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1877         (vec_merge:SSEMODEF2P
1878          (minus:SSEMODEF2P
1879           (mult:SSEMODEF2P
1880            (neg:SSEMODEF2P
1881             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1882            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1883           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1884          (match_dup 0)
1885          (const_int 1)))]
1886   "TARGET_FMA4 && TARGET_FUSED_MADD"
1887   "vfnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1888   [(set_attr "type" "ssemuladd")
1889    (set_attr "mode" "<MODE>")])
1890
1891 (define_insn "fma4i_fmadd<mode>4256"
1892   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1893         (unspec:FMA4MODEF4
1894          [(plus:FMA4MODEF4
1895            (mult:FMA4MODEF4
1896             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1897             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1898            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1899          UNSPEC_FMA4_INTRINSIC))]
1900   "TARGET_FMA4 && TARGET_FUSED_MADD"
1901   "vfmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1902   [(set_attr "type" "ssemuladd")
1903    (set_attr "mode" "<MODE>")])
1904
1905 (define_insn "fma4i_fmsub<mode>4256"
1906   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1907         (unspec:FMA4MODEF4
1908          [(minus:FMA4MODEF4
1909            (mult:FMA4MODEF4
1910             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1911             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1912            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1913          UNSPEC_FMA4_INTRINSIC))]
1914   "TARGET_FMA4 && TARGET_FUSED_MADD"
1915   "vfmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1916   [(set_attr "type" "ssemuladd")
1917    (set_attr "mode" "<MODE>")])
1918
1919 (define_insn "fma4i_fnmadd<mode>4256"
1920   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1921         (unspec:FMA4MODEF4
1922          [(minus:FMA4MODEF4
1923            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1924            (mult:FMA4MODEF4
1925             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1926             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m")))]
1927          UNSPEC_FMA4_INTRINSIC))]
1928   "TARGET_FMA4 && TARGET_FUSED_MADD"
1929   "vfnmadd<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1930   [(set_attr "type" "ssemuladd")
1931    (set_attr "mode" "<MODE>")])
1932
1933 (define_insn "fma4i_fnmsub<mode>4256"
1934   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1935         (unspec:FMA4MODEF4
1936          [(minus:FMA4MODEF4
1937            (mult:FMA4MODEF4
1938             (neg:FMA4MODEF4
1939              (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1940             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1941            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1942          UNSPEC_FMA4_INTRINSIC))]
1943   "TARGET_FMA4 && TARGET_FUSED_MADD"
1944   "vfnmsub<fma4modesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1945   [(set_attr "type" "ssemuladd")
1946    (set_attr "mode" "<MODE>")])
1947
1948 (define_insn "fma4i_fmadd<mode>4"
1949   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1950         (unspec:SSEMODEF2P
1951          [(plus:SSEMODEF2P
1952            (mult:SSEMODEF2P
1953             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1954             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1955            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1956          UNSPEC_FMA4_INTRINSIC))]
1957   "TARGET_FMA4 && TARGET_FUSED_MADD"
1958   "vfmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1959   [(set_attr "type" "ssemuladd")
1960    (set_attr "mode" "<MODE>")])
1961
1962 (define_insn "fma4i_fmsub<mode>4"
1963   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1964         (unspec:SSEMODEF2P
1965          [(minus:SSEMODEF2P
1966            (mult:SSEMODEF2P
1967             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1968             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1969            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1970          UNSPEC_FMA4_INTRINSIC))]
1971   "TARGET_FMA4 && TARGET_FUSED_MADD"
1972   "vfmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1973   [(set_attr "type" "ssemuladd")
1974    (set_attr "mode" "<MODE>")])
1975
1976 (define_insn "fma4i_fnmadd<mode>4"
1977   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1978         (unspec:SSEMODEF2P
1979          [(minus:SSEMODEF2P
1980            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1981            (mult:SSEMODEF2P
1982             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1983             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))]
1984          UNSPEC_FMA4_INTRINSIC))]
1985   "TARGET_FMA4 && TARGET_FUSED_MADD"
1986   "vfnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1987   [(set_attr "type" "ssemuladd")
1988    (set_attr "mode" "<MODE>")])
1989
1990 (define_insn "fma4i_fnmsub<mode>4"
1991   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1992         (unspec:SSEMODEF2P
1993          [(minus:SSEMODEF2P
1994            (mult:SSEMODEF2P
1995             (neg:SSEMODEF2P
1996              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1997             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1998            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1999          UNSPEC_FMA4_INTRINSIC))]
2000   "TARGET_FMA4 && TARGET_FUSED_MADD"
2001   "vfnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2002   [(set_attr "type" "ssemuladd")
2003    (set_attr "mode" "<MODE>")])
2004
2005 ;; For the scalar operations, use operand1 for the upper words that aren't
2006 ;; modified, so restrict the forms that are accepted.
2007 (define_insn "fma4i_vmfmadd<mode>4"
2008   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2009         (unspec:SSEMODEF2P
2010          [(vec_merge:SSEMODEF2P
2011            (plus:SSEMODEF2P
2012             (mult:SSEMODEF2P
2013              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2014              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2015             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2016            (match_dup 0)
2017            (const_int 1))]
2018          UNSPEC_FMA4_INTRINSIC))]
2019   "TARGET_FMA4 && TARGET_FUSED_MADD"
2020   "vfmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2021   [(set_attr "type" "ssemuladd")
2022    (set_attr "mode" "<ssescalarmode>")])
2023
2024 (define_insn "fma4i_vmfmsub<mode>4"
2025   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2026         (unspec:SSEMODEF2P
2027          [(vec_merge:SSEMODEF2P
2028            (minus:SSEMODEF2P
2029             (mult:SSEMODEF2P
2030              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2031              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2032             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2033            (match_dup 0)
2034            (const_int 1))]
2035          UNSPEC_FMA4_INTRINSIC))]
2036   "TARGET_FMA4 && TARGET_FUSED_MADD"
2037   "vfmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2038   [(set_attr "type" "ssemuladd")
2039    (set_attr "mode" "<ssescalarmode>")])
2040
2041 (define_insn "fma4i_vmfnmadd<mode>4"
2042   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2043         (unspec:SSEMODEF2P
2044          [(vec_merge:SSEMODEF2P
2045            (minus:SSEMODEF2P
2046             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2047             (mult:SSEMODEF2P
2048              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2049              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
2050            (match_dup 0)
2051            (const_int 1))]
2052          UNSPEC_FMA4_INTRINSIC))]
2053   "TARGET_FMA4 && TARGET_FUSED_MADD"
2054   "vfnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2055   [(set_attr "type" "ssemuladd")
2056    (set_attr "mode" "<ssescalarmode>")])
2057
2058 (define_insn "fma4i_vmfnmsub<mode>4"
2059   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2060         (unspec:SSEMODEF2P
2061          [(vec_merge:SSEMODEF2P
2062            (minus:SSEMODEF2P
2063             (mult:SSEMODEF2P
2064              (neg:SSEMODEF2P
2065               (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
2066              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2067             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2068            (match_dup 0)
2069            (const_int 1))]
2070          UNSPEC_FMA4_INTRINSIC))]
2071   "TARGET_FMA4 && TARGET_FUSED_MADD"
2072   "vfnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2073   [(set_attr "type" "ssemuladd")
2074    (set_attr "mode" "<ssescalarmode>")])
2075
2076 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2077 ;;
2078 ;; FMA4 Parallel floating point multiply addsub and subadd operations.
2079 ;;
2080 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2081
2082 (define_insn "fma4_fmaddsubv8sf4"
2083   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2084         (vec_merge:V8SF
2085           (plus:V8SF
2086             (mult:V8SF
2087               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2088               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2089             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2090           (minus:V8SF
2091             (mult:V8SF
2092               (match_dup 1)
2093               (match_dup 2))
2094             (match_dup 3))
2095           (const_int 170)))]
2096   "TARGET_FMA4 && TARGET_FUSED_MADD"
2097   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2098   [(set_attr "type" "ssemuladd")
2099    (set_attr "mode" "V8SF")])
2100
2101 (define_insn "fma4_fmaddsubv4df4"
2102   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2103         (vec_merge:V4DF
2104           (plus:V4DF
2105             (mult:V4DF
2106               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2107               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2108             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2109           (minus:V4DF
2110             (mult:V4DF
2111               (match_dup 1)
2112               (match_dup 2))
2113             (match_dup 3))
2114           (const_int 10)))]
2115   "TARGET_FMA4 && TARGET_FUSED_MADD"
2116   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2117   [(set_attr "type" "ssemuladd")
2118    (set_attr "mode" "V4DF")])
2119
2120 (define_insn "fma4_fmaddsubv4sf4"
2121   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2122         (vec_merge:V4SF
2123           (plus:V4SF
2124             (mult:V4SF
2125               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2126               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2127             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2128           (minus:V4SF
2129             (mult:V4SF
2130               (match_dup 1)
2131               (match_dup 2))
2132             (match_dup 3))
2133           (const_int 10)))]
2134   "TARGET_FMA4 && TARGET_FUSED_MADD"
2135   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2136   [(set_attr "type" "ssemuladd")
2137    (set_attr "mode" "V4SF")])
2138
2139 (define_insn "fma4_fmaddsubv2df4"
2140   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2141         (vec_merge:V2DF
2142           (plus:V2DF
2143             (mult:V2DF
2144               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2145               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2146             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2147           (minus:V2DF
2148             (mult:V2DF
2149               (match_dup 1)
2150               (match_dup 2))
2151             (match_dup 3))
2152           (const_int 2)))]
2153   "TARGET_FMA4 && TARGET_FUSED_MADD"
2154   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2155   [(set_attr "type" "ssemuladd")
2156    (set_attr "mode" "V2DF")])
2157
2158 (define_insn "fma4_fmsubaddv8sf4"
2159   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2160         (vec_merge:V8SF
2161           (plus:V8SF
2162             (mult:V8SF
2163               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2164               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2165             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2166           (minus:V8SF
2167             (mult:V8SF
2168               (match_dup 1)
2169               (match_dup 2))
2170             (match_dup 3))
2171           (const_int 85)))]
2172   "TARGET_FMA4 && TARGET_FUSED_MADD"
2173   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2174   [(set_attr "type" "ssemuladd")
2175    (set_attr "mode" "V8SF")])
2176
2177 (define_insn "fma4_fmsubaddv4df4"
2178   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2179         (vec_merge:V4DF
2180           (plus:V4DF
2181             (mult:V4DF
2182               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2183               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2184             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2185           (minus:V4DF
2186             (mult:V4DF
2187               (match_dup 1)
2188               (match_dup 2))
2189             (match_dup 3))
2190           (const_int 5)))]
2191   "TARGET_FMA4 && TARGET_FUSED_MADD"
2192   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2193   [(set_attr "type" "ssemuladd")
2194    (set_attr "mode" "V4DF")])
2195
2196 (define_insn "fma4_fmsubaddv4sf4"
2197   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2198         (vec_merge:V4SF
2199           (plus:V4SF
2200             (mult:V4SF
2201               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2202               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2203             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2204           (minus:V4SF
2205             (mult:V4SF
2206               (match_dup 1)
2207               (match_dup 2))
2208             (match_dup 3))
2209           (const_int 5)))]
2210   "TARGET_FMA4 && TARGET_FUSED_MADD"
2211   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2212   [(set_attr "type" "ssemuladd")
2213    (set_attr "mode" "V4SF")])
2214
2215 (define_insn "fma4_fmsubaddv2df4"
2216   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2217         (vec_merge:V2DF
2218           (plus:V2DF
2219             (mult:V2DF
2220               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2221               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2222             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2223           (minus:V2DF
2224             (mult:V2DF
2225               (match_dup 1)
2226               (match_dup 2))
2227             (match_dup 3))
2228           (const_int 1)))]
2229   "TARGET_FMA4 && TARGET_FUSED_MADD"
2230   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2231   [(set_attr "type" "ssemuladd")
2232    (set_attr "mode" "V2DF")])
2233
2234 (define_insn "fma4i_fmaddsubv8sf4"
2235   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2236         (unspec:V8SF
2237          [(vec_merge:V8SF
2238            (plus:V8SF
2239              (mult:V8SF
2240                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2241                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2242              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2243            (minus:V8SF
2244              (mult:V8SF
2245                (match_dup 1)
2246                (match_dup 2))
2247              (match_dup 3))
2248            (const_int 170))]
2249          UNSPEC_FMA4_INTRINSIC))]
2250   "TARGET_FMA4 && TARGET_FUSED_MADD"
2251   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2252   [(set_attr "type" "ssemuladd")
2253    (set_attr "mode" "V8SF")])
2254
2255 (define_insn "fma4i_fmaddsubv4df4"
2256   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2257         (unspec:V4DF
2258          [(vec_merge:V4DF
2259            (plus:V4DF
2260              (mult:V4DF
2261                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2262                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2263              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2264            (minus:V4DF
2265              (mult:V4DF
2266                (match_dup 1)
2267                (match_dup 2))
2268              (match_dup 3))
2269            (const_int 10))]
2270          UNSPEC_FMA4_INTRINSIC))]
2271   "TARGET_FMA4 && TARGET_FUSED_MADD"
2272   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2273   [(set_attr "type" "ssemuladd")
2274    (set_attr "mode" "V4DF")])
2275
2276 (define_insn "fma4i_fmaddsubv4sf4"
2277   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2278         (unspec:V4SF
2279          [(vec_merge:V4SF
2280            (plus:V4SF
2281              (mult:V4SF
2282                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2283                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2284              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2285            (minus:V4SF
2286              (mult:V4SF
2287                (match_dup 1)
2288                (match_dup 2))
2289              (match_dup 3))
2290            (const_int 10))]
2291          UNSPEC_FMA4_INTRINSIC))]
2292   "TARGET_FMA4 && TARGET_FUSED_MADD"
2293   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2294   [(set_attr "type" "ssemuladd")
2295    (set_attr "mode" "V4SF")])
2296
2297 (define_insn "fma4i_fmaddsubv2df4"
2298   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2299         (unspec:V2DF
2300          [(vec_merge:V2DF
2301            (plus:V2DF
2302              (mult:V2DF
2303                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2304                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2305              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2306            (minus:V2DF
2307              (mult:V2DF
2308                (match_dup 1)
2309                (match_dup 2))
2310              (match_dup 3))
2311            (const_int 2))]
2312          UNSPEC_FMA4_INTRINSIC))]
2313   "TARGET_FMA4 && TARGET_FUSED_MADD"
2314   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2315   [(set_attr "type" "ssemuladd")
2316    (set_attr "mode" "V2DF")])
2317
2318 (define_insn "fma4i_fmsubaddv8sf4"
2319   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2320         (unspec:V8SF
2321          [(vec_merge:V8SF
2322            (plus:V8SF
2323              (mult:V8SF
2324                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2325                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2326              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2327            (minus:V8SF
2328              (mult:V8SF
2329                (match_dup 1)
2330                (match_dup 2))
2331              (match_dup 3))
2332            (const_int 85))]
2333          UNSPEC_FMA4_INTRINSIC))]
2334   "TARGET_FMA4 && TARGET_FUSED_MADD"
2335   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2336   [(set_attr "type" "ssemuladd")
2337    (set_attr "mode" "V8SF")])
2338
2339 (define_insn "fma4i_fmsubaddv4df4"
2340   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2341         (unspec:V4DF
2342          [(vec_merge:V4DF
2343            (plus:V4DF
2344              (mult:V4DF
2345                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2346                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2347              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2348            (minus:V4DF
2349              (mult:V4DF
2350                (match_dup 1)
2351                (match_dup 2))
2352              (match_dup 3))
2353            (const_int 5))]
2354          UNSPEC_FMA4_INTRINSIC))]
2355   "TARGET_FMA4 && TARGET_FUSED_MADD"
2356   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2357   [(set_attr "type" "ssemuladd")
2358    (set_attr "mode" "V4DF")])
2359
2360 (define_insn "fma4i_fmsubaddv4sf4"
2361   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2362         (unspec:V4SF
2363          [(vec_merge:V4SF
2364            (plus:V4SF
2365              (mult:V4SF
2366                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2367                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2368              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2369            (minus:V4SF
2370              (mult:V4SF
2371                (match_dup 1)
2372                (match_dup 2))
2373              (match_dup 3))
2374            (const_int 5))]
2375          UNSPEC_FMA4_INTRINSIC))]
2376   "TARGET_FMA4 && TARGET_FUSED_MADD"
2377   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2378   [(set_attr "type" "ssemuladd")
2379    (set_attr "mode" "V4SF")])
2380
2381 (define_insn "fma4i_fmsubaddv2df4"
2382   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2383         (unspec:V2DF
2384          [(vec_merge:V2DF
2385            (plus:V2DF
2386              (mult:V2DF
2387                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2388                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2389              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2390            (minus:V2DF
2391              (mult:V2DF
2392                (match_dup 1)
2393                (match_dup 2))
2394              (match_dup 3))
2395            (const_int 1))]
2396          UNSPEC_FMA4_INTRINSIC))]
2397   "TARGET_FMA4 && TARGET_FUSED_MADD"
2398   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2399   [(set_attr "type" "ssemuladd")
2400    (set_attr "mode" "V2DF")])
2401
2402 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2403 ;;
2404 ;; Parallel single-precision floating point conversion operations
2405 ;;
2406 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2407
2408 (define_insn "sse_cvtpi2ps"
2409   [(set (match_operand:V4SF 0 "register_operand" "=x")
2410         (vec_merge:V4SF
2411           (vec_duplicate:V4SF
2412             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2413           (match_operand:V4SF 1 "register_operand" "0")
2414           (const_int 3)))]
2415   "TARGET_SSE"
2416   "cvtpi2ps\t{%2, %0|%0, %2}"
2417   [(set_attr "type" "ssecvt")
2418    (set_attr "mode" "V4SF")])
2419
2420 (define_insn "sse_cvtps2pi"
2421   [(set (match_operand:V2SI 0 "register_operand" "=y")
2422         (vec_select:V2SI
2423           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2424                        UNSPEC_FIX_NOTRUNC)
2425           (parallel [(const_int 0) (const_int 1)])))]
2426   "TARGET_SSE"
2427   "cvtps2pi\t{%1, %0|%0, %1}"
2428   [(set_attr "type" "ssecvt")
2429    (set_attr "unit" "mmx")
2430    (set_attr "mode" "DI")])
2431
2432 (define_insn "sse_cvttps2pi"
2433   [(set (match_operand:V2SI 0 "register_operand" "=y")
2434         (vec_select:V2SI
2435           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2436           (parallel [(const_int 0) (const_int 1)])))]
2437   "TARGET_SSE"
2438   "cvttps2pi\t{%1, %0|%0, %1}"
2439   [(set_attr "type" "ssecvt")
2440    (set_attr "unit" "mmx")
2441    (set_attr "prefix_rep" "0")
2442    (set_attr "mode" "SF")])
2443
2444 (define_insn "*avx_cvtsi2ss"
2445   [(set (match_operand:V4SF 0 "register_operand" "=x")
2446         (vec_merge:V4SF
2447           (vec_duplicate:V4SF
2448             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2449           (match_operand:V4SF 1 "register_operand" "x")
2450           (const_int 1)))]
2451   "TARGET_AVX"
2452   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2453   [(set_attr "type" "sseicvt")
2454    (set_attr "prefix" "vex")
2455    (set_attr "mode" "SF")])
2456
2457 (define_insn "sse_cvtsi2ss"
2458   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2459         (vec_merge:V4SF
2460           (vec_duplicate:V4SF
2461             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2462           (match_operand:V4SF 1 "register_operand" "0,0")
2463           (const_int 1)))]
2464   "TARGET_SSE"
2465   "cvtsi2ss\t{%2, %0|%0, %2}"
2466   [(set_attr "type" "sseicvt")
2467    (set_attr "athlon_decode" "vector,double")
2468    (set_attr "amdfam10_decode" "vector,double")
2469    (set_attr "mode" "SF")])
2470
2471 (define_insn "*avx_cvtsi2ssq"
2472   [(set (match_operand:V4SF 0 "register_operand" "=x")
2473         (vec_merge:V4SF
2474           (vec_duplicate:V4SF
2475             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2476           (match_operand:V4SF 1 "register_operand" "x")
2477           (const_int 1)))]
2478   "TARGET_AVX && TARGET_64BIT"
2479   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2480   [(set_attr "type" "sseicvt")
2481    (set_attr "length_vex" "4")
2482    (set_attr "prefix" "vex")
2483    (set_attr "mode" "SF")])
2484
2485 (define_insn "sse_cvtsi2ssq"
2486   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2487         (vec_merge:V4SF
2488           (vec_duplicate:V4SF
2489             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2490           (match_operand:V4SF 1 "register_operand" "0,0")
2491           (const_int 1)))]
2492   "TARGET_SSE && TARGET_64BIT"
2493   "cvtsi2ssq\t{%2, %0|%0, %2}"
2494   [(set_attr "type" "sseicvt")
2495    (set_attr "prefix_rex" "1")
2496    (set_attr "athlon_decode" "vector,double")
2497    (set_attr "amdfam10_decode" "vector,double")
2498    (set_attr "mode" "SF")])
2499
2500 (define_insn "sse_cvtss2si"
2501   [(set (match_operand:SI 0 "register_operand" "=r,r")
2502         (unspec:SI
2503           [(vec_select:SF
2504              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2505              (parallel [(const_int 0)]))]
2506           UNSPEC_FIX_NOTRUNC))]
2507   "TARGET_SSE"
2508   "%vcvtss2si\t{%1, %0|%0, %1}"
2509   [(set_attr "type" "sseicvt")
2510    (set_attr "athlon_decode" "double,vector")
2511    (set_attr "prefix_rep" "1")
2512    (set_attr "prefix" "maybe_vex")
2513    (set_attr "mode" "SI")])
2514
2515 (define_insn "sse_cvtss2si_2"
2516   [(set (match_operand:SI 0 "register_operand" "=r,r")
2517         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2518                    UNSPEC_FIX_NOTRUNC))]
2519   "TARGET_SSE"
2520   "%vcvtss2si\t{%1, %0|%0, %1}"
2521   [(set_attr "type" "sseicvt")
2522    (set_attr "athlon_decode" "double,vector")
2523    (set_attr "amdfam10_decode" "double,double")
2524    (set_attr "prefix_rep" "1")
2525    (set_attr "prefix" "maybe_vex")
2526    (set_attr "mode" "SI")])
2527
2528 (define_insn "sse_cvtss2siq"
2529   [(set (match_operand:DI 0 "register_operand" "=r,r")
2530         (unspec:DI
2531           [(vec_select:SF
2532              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2533              (parallel [(const_int 0)]))]
2534           UNSPEC_FIX_NOTRUNC))]
2535   "TARGET_SSE && TARGET_64BIT"
2536   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2537   [(set_attr "type" "sseicvt")
2538    (set_attr "athlon_decode" "double,vector")
2539    (set_attr "prefix_rep" "1")
2540    (set_attr "prefix" "maybe_vex")
2541    (set_attr "mode" "DI")])
2542
2543 (define_insn "sse_cvtss2siq_2"
2544   [(set (match_operand:DI 0 "register_operand" "=r,r")
2545         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2546                    UNSPEC_FIX_NOTRUNC))]
2547   "TARGET_SSE && TARGET_64BIT"
2548   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2549   [(set_attr "type" "sseicvt")
2550    (set_attr "athlon_decode" "double,vector")
2551    (set_attr "amdfam10_decode" "double,double")
2552    (set_attr "prefix_rep" "1")
2553    (set_attr "prefix" "maybe_vex")
2554    (set_attr "mode" "DI")])
2555
2556 (define_insn "sse_cvttss2si"
2557   [(set (match_operand:SI 0 "register_operand" "=r,r")
2558         (fix:SI
2559           (vec_select:SF
2560             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2561             (parallel [(const_int 0)]))))]
2562   "TARGET_SSE"
2563   "%vcvttss2si\t{%1, %0|%0, %1}"
2564   [(set_attr "type" "sseicvt")
2565    (set_attr "athlon_decode" "double,vector")
2566    (set_attr "amdfam10_decode" "double,double")
2567    (set_attr "prefix_rep" "1")
2568    (set_attr "prefix" "maybe_vex")
2569    (set_attr "mode" "SI")])
2570
2571 (define_insn "sse_cvttss2siq"
2572   [(set (match_operand:DI 0 "register_operand" "=r,r")
2573         (fix:DI
2574           (vec_select:SF
2575             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2576             (parallel [(const_int 0)]))))]
2577   "TARGET_SSE && TARGET_64BIT"
2578   "%vcvttss2si{q}\t{%1, %0|%0, %1}"
2579   [(set_attr "type" "sseicvt")
2580    (set_attr "athlon_decode" "double,vector")
2581    (set_attr "amdfam10_decode" "double,double")
2582    (set_attr "prefix_rep" "1")
2583    (set_attr "prefix" "maybe_vex")
2584    (set_attr "mode" "DI")])
2585
2586 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2587   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2588         (float:AVXMODEDCVTDQ2PS
2589           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2590   "TARGET_AVX"
2591   "vcvtdq2ps\t{%1, %0|%0, %1}"
2592   [(set_attr "type" "ssecvt")
2593    (set_attr "prefix" "vex")
2594    (set_attr "mode" "<avxvecmode>")])
2595
2596 (define_insn "sse2_cvtdq2ps"
2597   [(set (match_operand:V4SF 0 "register_operand" "=x")
2598         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2599   "TARGET_SSE2"
2600   "cvtdq2ps\t{%1, %0|%0, %1}"
2601   [(set_attr "type" "ssecvt")
2602    (set_attr "mode" "V4SF")])
2603
2604 (define_expand "sse2_cvtudq2ps"
2605   [(set (match_dup 5)
2606         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "")))
2607    (set (match_dup 6)
2608         (lt:V4SF (match_dup 5) (match_dup 3)))
2609    (set (match_dup 7)
2610         (and:V4SF (match_dup 6) (match_dup 4)))
2611    (set (match_operand:V4SF 0 "register_operand" "")
2612         (plus:V4SF (match_dup 5) (match_dup 7)))]
2613   "TARGET_SSE2"
2614 {
2615   REAL_VALUE_TYPE TWO32r;
2616   rtx x;
2617   int i;
2618
2619   real_ldexp (&TWO32r, &dconst1, 32);
2620   x = const_double_from_real_value (TWO32r, SFmode);
2621
2622   operands[3] = force_reg (V4SFmode, CONST0_RTX (V4SFmode));
2623   operands[4] = force_reg (V4SFmode, ix86_build_const_vector (SFmode, 1, x));
2624
2625   for (i = 5; i < 8; i++)
2626     operands[i] = gen_reg_rtx (V4SFmode);
2627 })
2628
2629 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2630   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2631         (unspec:AVXMODEDCVTPS2DQ
2632           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2633           UNSPEC_FIX_NOTRUNC))]
2634   "TARGET_AVX"
2635   "vcvtps2dq\t{%1, %0|%0, %1}"
2636   [(set_attr "type" "ssecvt")
2637    (set_attr "prefix" "vex")
2638    (set_attr "mode" "<avxvecmode>")])
2639
2640 (define_insn "sse2_cvtps2dq"
2641   [(set (match_operand:V4SI 0 "register_operand" "=x")
2642         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2643                      UNSPEC_FIX_NOTRUNC))]
2644   "TARGET_SSE2"
2645   "cvtps2dq\t{%1, %0|%0, %1}"
2646   [(set_attr "type" "ssecvt")
2647    (set_attr "prefix_data16" "1")
2648    (set_attr "mode" "TI")])
2649
2650 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2651   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2652         (fix:AVXMODEDCVTPS2DQ
2653           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2654   "TARGET_AVX"
2655   "vcvttps2dq\t{%1, %0|%0, %1}"
2656   [(set_attr "type" "ssecvt")
2657    (set_attr "prefix" "vex")
2658    (set_attr "mode" "<avxvecmode>")])
2659
2660 (define_insn "sse2_cvttps2dq"
2661   [(set (match_operand:V4SI 0 "register_operand" "=x")
2662         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2663   "TARGET_SSE2"
2664   "cvttps2dq\t{%1, %0|%0, %1}"
2665   [(set_attr "type" "ssecvt")
2666    (set_attr "prefix_rep" "1")
2667    (set_attr "prefix_data16" "0")
2668    (set_attr "mode" "TI")])
2669
2670 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2671 ;;
2672 ;; Parallel double-precision floating point conversion operations
2673 ;;
2674 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2675
2676 (define_insn "sse2_cvtpi2pd"
2677   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2678         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2679   "TARGET_SSE2"
2680   "cvtpi2pd\t{%1, %0|%0, %1}"
2681   [(set_attr "type" "ssecvt")
2682    (set_attr "unit" "mmx,*")
2683    (set_attr "prefix_data16" "1,*")
2684    (set_attr "mode" "V2DF")])
2685
2686 (define_insn "sse2_cvtpd2pi"
2687   [(set (match_operand:V2SI 0 "register_operand" "=y")
2688         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2689                      UNSPEC_FIX_NOTRUNC))]
2690   "TARGET_SSE2"
2691   "cvtpd2pi\t{%1, %0|%0, %1}"
2692   [(set_attr "type" "ssecvt")
2693    (set_attr "unit" "mmx")
2694    (set_attr "prefix_data16" "1")
2695    (set_attr "mode" "DI")])
2696
2697 (define_insn "sse2_cvttpd2pi"
2698   [(set (match_operand:V2SI 0 "register_operand" "=y")
2699         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2700   "TARGET_SSE2"
2701   "cvttpd2pi\t{%1, %0|%0, %1}"
2702   [(set_attr "type" "ssecvt")
2703    (set_attr "unit" "mmx")
2704    (set_attr "prefix_data16" "1")
2705    (set_attr "mode" "TI")])
2706
2707 (define_insn "*avx_cvtsi2sd"
2708   [(set (match_operand:V2DF 0 "register_operand" "=x")
2709         (vec_merge:V2DF
2710           (vec_duplicate:V2DF
2711             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2712           (match_operand:V2DF 1 "register_operand" "x")
2713           (const_int 1)))]
2714   "TARGET_AVX"
2715   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2716   [(set_attr "type" "sseicvt")
2717    (set_attr "prefix" "vex")
2718    (set_attr "mode" "DF")])
2719
2720 (define_insn "sse2_cvtsi2sd"
2721   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2722         (vec_merge:V2DF
2723           (vec_duplicate:V2DF
2724             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2725           (match_operand:V2DF 1 "register_operand" "0,0")
2726           (const_int 1)))]
2727   "TARGET_SSE2"
2728   "cvtsi2sd\t{%2, %0|%0, %2}"
2729   [(set_attr "type" "sseicvt")
2730    (set_attr "mode" "DF")
2731    (set_attr "athlon_decode" "double,direct")
2732    (set_attr "amdfam10_decode" "vector,double")])
2733
2734 (define_insn "*avx_cvtsi2sdq"
2735   [(set (match_operand:V2DF 0 "register_operand" "=x")
2736         (vec_merge:V2DF
2737           (vec_duplicate:V2DF
2738             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2739           (match_operand:V2DF 1 "register_operand" "x")
2740           (const_int 1)))]
2741   "TARGET_AVX && TARGET_64BIT"
2742   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2743   [(set_attr "type" "sseicvt")
2744    (set_attr "length_vex" "4")
2745    (set_attr "prefix" "vex")
2746    (set_attr "mode" "DF")])
2747
2748 (define_insn "sse2_cvtsi2sdq"
2749   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2750         (vec_merge:V2DF
2751           (vec_duplicate:V2DF
2752             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2753           (match_operand:V2DF 1 "register_operand" "0,0")
2754           (const_int 1)))]
2755   "TARGET_SSE2 && TARGET_64BIT"
2756   "cvtsi2sdq\t{%2, %0|%0, %2}"
2757   [(set_attr "type" "sseicvt")
2758    (set_attr "prefix_rex" "1")
2759    (set_attr "mode" "DF")
2760    (set_attr "athlon_decode" "double,direct")
2761    (set_attr "amdfam10_decode" "vector,double")])
2762
2763 (define_insn "sse2_cvtsd2si"
2764   [(set (match_operand:SI 0 "register_operand" "=r,r")
2765         (unspec:SI
2766           [(vec_select:DF
2767              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2768              (parallel [(const_int 0)]))]
2769           UNSPEC_FIX_NOTRUNC))]
2770   "TARGET_SSE2"
2771   "%vcvtsd2si\t{%1, %0|%0, %1}"
2772   [(set_attr "type" "sseicvt")
2773    (set_attr "athlon_decode" "double,vector")
2774    (set_attr "prefix_rep" "1")
2775    (set_attr "prefix" "maybe_vex")
2776    (set_attr "mode" "SI")])
2777
2778 (define_insn "sse2_cvtsd2si_2"
2779   [(set (match_operand:SI 0 "register_operand" "=r,r")
2780         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2781                    UNSPEC_FIX_NOTRUNC))]
2782   "TARGET_SSE2"
2783   "%vcvtsd2si\t{%1, %0|%0, %1}"
2784   [(set_attr "type" "sseicvt")
2785    (set_attr "athlon_decode" "double,vector")
2786    (set_attr "amdfam10_decode" "double,double")
2787    (set_attr "prefix_rep" "1")
2788    (set_attr "prefix" "maybe_vex")
2789    (set_attr "mode" "SI")])
2790
2791 (define_insn "sse2_cvtsd2siq"
2792   [(set (match_operand:DI 0 "register_operand" "=r,r")
2793         (unspec:DI
2794           [(vec_select:DF
2795              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2796              (parallel [(const_int 0)]))]
2797           UNSPEC_FIX_NOTRUNC))]
2798   "TARGET_SSE2 && TARGET_64BIT"
2799   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2800   [(set_attr "type" "sseicvt")
2801    (set_attr "athlon_decode" "double,vector")
2802    (set_attr "prefix_rep" "1")
2803    (set_attr "prefix" "maybe_vex")
2804    (set_attr "mode" "DI")])
2805
2806 (define_insn "sse2_cvtsd2siq_2"
2807   [(set (match_operand:DI 0 "register_operand" "=r,r")
2808         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2809                    UNSPEC_FIX_NOTRUNC))]
2810   "TARGET_SSE2 && TARGET_64BIT"
2811   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2812   [(set_attr "type" "sseicvt")
2813    (set_attr "athlon_decode" "double,vector")
2814    (set_attr "amdfam10_decode" "double,double")
2815    (set_attr "prefix_rep" "1")
2816    (set_attr "prefix" "maybe_vex")
2817    (set_attr "mode" "DI")])
2818
2819 (define_insn "sse2_cvttsd2si"
2820   [(set (match_operand:SI 0 "register_operand" "=r,r")
2821         (fix:SI
2822           (vec_select:DF
2823             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2824             (parallel [(const_int 0)]))))]
2825   "TARGET_SSE2"
2826   "%vcvttsd2si\t{%1, %0|%0, %1}"
2827   [(set_attr "type" "sseicvt")
2828    (set_attr "prefix_rep" "1")
2829    (set_attr "prefix" "maybe_vex")
2830    (set_attr "mode" "SI")
2831    (set_attr "athlon_decode" "double,vector")
2832    (set_attr "amdfam10_decode" "double,double")])
2833
2834 (define_insn "sse2_cvttsd2siq"
2835   [(set (match_operand:DI 0 "register_operand" "=r,r")
2836         (fix:DI
2837           (vec_select:DF
2838             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2839             (parallel [(const_int 0)]))))]
2840   "TARGET_SSE2 && TARGET_64BIT"
2841   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2842   [(set_attr "type" "sseicvt")
2843    (set_attr "prefix_rep" "1")
2844    (set_attr "prefix" "maybe_vex")
2845    (set_attr "mode" "DI")
2846    (set_attr "athlon_decode" "double,vector")
2847    (set_attr "amdfam10_decode" "double,double")])
2848
2849 (define_insn "avx_cvtdq2pd256"
2850   [(set (match_operand:V4DF 0 "register_operand" "=x")
2851         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2852   "TARGET_AVX"
2853   "vcvtdq2pd\t{%1, %0|%0, %1}"
2854   [(set_attr "type" "ssecvt")
2855    (set_attr "prefix" "vex")
2856    (set_attr "mode" "V4DF")])
2857
2858 (define_insn "sse2_cvtdq2pd"
2859   [(set (match_operand:V2DF 0 "register_operand" "=x")
2860         (float:V2DF
2861           (vec_select:V2SI
2862             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2863             (parallel [(const_int 0) (const_int 1)]))))]
2864   "TARGET_SSE2"
2865   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2866   [(set_attr "type" "ssecvt")
2867    (set_attr "prefix" "maybe_vex")
2868    (set_attr "mode" "V2DF")])
2869
2870 (define_insn "avx_cvtpd2dq256"
2871   [(set (match_operand:V4SI 0 "register_operand" "=x")
2872         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2873                      UNSPEC_FIX_NOTRUNC))]
2874   "TARGET_AVX"
2875   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2876   [(set_attr "type" "ssecvt")
2877    (set_attr "prefix" "vex")
2878    (set_attr "mode" "OI")])
2879
2880 (define_expand "sse2_cvtpd2dq"
2881   [(set (match_operand:V4SI 0 "register_operand" "")
2882         (vec_concat:V4SI
2883           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2884                        UNSPEC_FIX_NOTRUNC)
2885           (match_dup 2)))]
2886   "TARGET_SSE2"
2887   "operands[2] = CONST0_RTX (V2SImode);")
2888
2889 (define_insn "*sse2_cvtpd2dq"
2890   [(set (match_operand:V4SI 0 "register_operand" "=x")
2891         (vec_concat:V4SI
2892           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2893                        UNSPEC_FIX_NOTRUNC)
2894           (match_operand:V2SI 2 "const0_operand" "")))]
2895   "TARGET_SSE2"
2896   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2897                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2898   [(set_attr "type" "ssecvt")
2899    (set_attr "prefix_rep" "1")
2900    (set_attr "prefix_data16" "0")
2901    (set_attr "prefix" "maybe_vex")
2902    (set_attr "mode" "TI")
2903    (set_attr "amdfam10_decode" "double")])
2904
2905 (define_insn "avx_cvttpd2dq256"
2906   [(set (match_operand:V4SI 0 "register_operand" "=x")
2907         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2908   "TARGET_AVX"
2909   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2910   [(set_attr "type" "ssecvt")
2911    (set_attr "prefix" "vex")
2912    (set_attr "mode" "OI")])
2913
2914 (define_expand "sse2_cvttpd2dq"
2915   [(set (match_operand:V4SI 0 "register_operand" "")
2916         (vec_concat:V4SI
2917           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2918           (match_dup 2)))]
2919   "TARGET_SSE2"
2920   "operands[2] = CONST0_RTX (V2SImode);")
2921
2922 (define_insn "*sse2_cvttpd2dq"
2923   [(set (match_operand:V4SI 0 "register_operand" "=x")
2924         (vec_concat:V4SI
2925           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2926           (match_operand:V2SI 2 "const0_operand" "")))]
2927   "TARGET_SSE2"
2928   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2929                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2930   [(set_attr "type" "ssecvt")
2931    (set_attr "prefix" "maybe_vex")
2932    (set_attr "mode" "TI")
2933    (set_attr "amdfam10_decode" "double")])
2934
2935 (define_insn "*avx_cvtsd2ss"
2936   [(set (match_operand:V4SF 0 "register_operand" "=x")
2937         (vec_merge:V4SF
2938           (vec_duplicate:V4SF
2939             (float_truncate:V2SF
2940               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2941           (match_operand:V4SF 1 "register_operand" "x")
2942           (const_int 1)))]
2943   "TARGET_AVX"
2944   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2945   [(set_attr "type" "ssecvt")
2946    (set_attr "prefix" "vex")
2947    (set_attr "mode" "SF")])
2948
2949 (define_insn "sse2_cvtsd2ss"
2950   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2951         (vec_merge:V4SF
2952           (vec_duplicate:V4SF
2953             (float_truncate:V2SF
2954               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2955           (match_operand:V4SF 1 "register_operand" "0,0")
2956           (const_int 1)))]
2957   "TARGET_SSE2"
2958   "cvtsd2ss\t{%2, %0|%0, %2}"
2959   [(set_attr "type" "ssecvt")
2960    (set_attr "athlon_decode" "vector,double")
2961    (set_attr "amdfam10_decode" "vector,double")
2962    (set_attr "mode" "SF")])
2963
2964 (define_insn "*avx_cvtss2sd"
2965   [(set (match_operand:V2DF 0 "register_operand" "=x")
2966         (vec_merge:V2DF
2967           (float_extend:V2DF
2968             (vec_select:V2SF
2969               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
2970               (parallel [(const_int 0) (const_int 1)])))
2971           (match_operand:V2DF 1 "register_operand" "x")
2972           (const_int 1)))]
2973   "TARGET_AVX"
2974   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2975   [(set_attr "type" "ssecvt")
2976    (set_attr "prefix" "vex")
2977    (set_attr "mode" "DF")])
2978
2979 (define_insn "sse2_cvtss2sd"
2980   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2981         (vec_merge:V2DF
2982           (float_extend:V2DF
2983             (vec_select:V2SF
2984               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2985               (parallel [(const_int 0) (const_int 1)])))
2986           (match_operand:V2DF 1 "register_operand" "0,0")
2987           (const_int 1)))]
2988   "TARGET_SSE2"
2989   "cvtss2sd\t{%2, %0|%0, %2}"
2990   [(set_attr "type" "ssecvt")
2991    (set_attr "amdfam10_decode" "vector,double")
2992    (set_attr "mode" "DF")])
2993
2994 (define_insn "avx_cvtpd2ps256"
2995   [(set (match_operand:V4SF 0 "register_operand" "=x")
2996         (float_truncate:V4SF
2997           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2998   "TARGET_AVX"
2999   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
3000   [(set_attr "type" "ssecvt")
3001    (set_attr "prefix" "vex")
3002    (set_attr "mode" "V4SF")])
3003
3004 (define_expand "sse2_cvtpd2ps"
3005   [(set (match_operand:V4SF 0 "register_operand" "")
3006         (vec_concat:V4SF
3007           (float_truncate:V2SF
3008             (match_operand:V2DF 1 "nonimmediate_operand" ""))
3009           (match_dup 2)))]
3010   "TARGET_SSE2"
3011   "operands[2] = CONST0_RTX (V2SFmode);")
3012
3013 (define_insn "*sse2_cvtpd2ps"
3014   [(set (match_operand:V4SF 0 "register_operand" "=x")
3015         (vec_concat:V4SF
3016           (float_truncate:V2SF
3017             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
3018           (match_operand:V2SF 2 "const0_operand" "")))]
3019   "TARGET_SSE2"
3020   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
3021                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
3022   [(set_attr "type" "ssecvt")
3023    (set_attr "prefix_data16" "1")
3024    (set_attr "prefix" "maybe_vex")
3025    (set_attr "mode" "V4SF")
3026    (set_attr "amdfam10_decode" "double")])
3027
3028 (define_insn "avx_cvtps2pd256"
3029   [(set (match_operand:V4DF 0 "register_operand" "=x")
3030         (float_extend:V4DF
3031           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3032   "TARGET_AVX"
3033   "vcvtps2pd\t{%1, %0|%0, %1}"
3034   [(set_attr "type" "ssecvt")
3035    (set_attr "prefix" "vex")
3036    (set_attr "mode" "V4DF")])
3037
3038 (define_insn "sse2_cvtps2pd"
3039   [(set (match_operand:V2DF 0 "register_operand" "=x")
3040         (float_extend:V2DF
3041           (vec_select:V2SF
3042             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3043             (parallel [(const_int 0) (const_int 1)]))))]
3044   "TARGET_SSE2"
3045   "%vcvtps2pd\t{%1, %0|%0, %1}"
3046   [(set_attr "type" "ssecvt")
3047    (set_attr "prefix" "maybe_vex")
3048    (set_attr "mode" "V2DF")
3049    (set_attr "prefix_data16" "0")
3050    (set_attr "amdfam10_decode" "direct")])
3051
3052 (define_expand "vec_unpacks_hi_v4sf"
3053   [(set (match_dup 2)
3054    (vec_select:V4SF
3055      (vec_concat:V8SF
3056        (match_dup 2)
3057        (match_operand:V4SF 1 "nonimmediate_operand" ""))
3058      (parallel [(const_int 6)
3059                 (const_int 7)
3060                 (const_int 2)
3061                 (const_int 3)])))
3062   (set (match_operand:V2DF 0 "register_operand" "")
3063    (float_extend:V2DF
3064      (vec_select:V2SF
3065        (match_dup 2)
3066        (parallel [(const_int 0) (const_int 1)]))))]
3067  "TARGET_SSE2"
3068 {
3069  operands[2] = gen_reg_rtx (V4SFmode);
3070 })
3071
3072 (define_expand "vec_unpacks_lo_v4sf"
3073   [(set (match_operand:V2DF 0 "register_operand" "")
3074         (float_extend:V2DF
3075           (vec_select:V2SF
3076             (match_operand:V4SF 1 "nonimmediate_operand" "")
3077             (parallel [(const_int 0) (const_int 1)]))))]
3078   "TARGET_SSE2")
3079
3080 (define_expand "vec_unpacks_float_hi_v8hi"
3081   [(match_operand:V4SF 0 "register_operand" "")
3082    (match_operand:V8HI 1 "register_operand" "")]
3083   "TARGET_SSE2"
3084 {
3085   rtx tmp = gen_reg_rtx (V4SImode);
3086
3087   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
3088   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3089   DONE;
3090 })
3091
3092 (define_expand "vec_unpacks_float_lo_v8hi"
3093   [(match_operand:V4SF 0 "register_operand" "")
3094    (match_operand:V8HI 1 "register_operand" "")]
3095   "TARGET_SSE2"
3096 {
3097   rtx tmp = gen_reg_rtx (V4SImode);
3098
3099   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
3100   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3101   DONE;
3102 })
3103
3104 (define_expand "vec_unpacku_float_hi_v8hi"
3105   [(match_operand:V4SF 0 "register_operand" "")
3106    (match_operand:V8HI 1 "register_operand" "")]
3107   "TARGET_SSE2"
3108 {
3109   rtx tmp = gen_reg_rtx (V4SImode);
3110
3111   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
3112   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3113   DONE;
3114 })
3115
3116 (define_expand "vec_unpacku_float_lo_v8hi"
3117   [(match_operand:V4SF 0 "register_operand" "")
3118    (match_operand:V8HI 1 "register_operand" "")]
3119   "TARGET_SSE2"
3120 {
3121   rtx tmp = gen_reg_rtx (V4SImode);
3122
3123   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
3124   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3125   DONE;
3126 })
3127
3128 (define_expand "vec_unpacks_float_hi_v4si"
3129   [(set (match_dup 2)
3130         (vec_select:V4SI
3131           (match_operand:V4SI 1 "nonimmediate_operand" "")
3132           (parallel [(const_int 2)
3133                      (const_int 3)
3134                      (const_int 2)
3135                      (const_int 3)])))
3136    (set (match_operand:V2DF 0 "register_operand" "")
3137         (float:V2DF
3138           (vec_select:V2SI
3139           (match_dup 2)
3140             (parallel [(const_int 0) (const_int 1)]))))]
3141  "TARGET_SSE2"
3142  "operands[2] = gen_reg_rtx (V4SImode);")
3143
3144 (define_expand "vec_unpacks_float_lo_v4si"
3145   [(set (match_operand:V2DF 0 "register_operand" "")
3146         (float:V2DF
3147           (vec_select:V2SI
3148             (match_operand:V4SI 1 "nonimmediate_operand" "")
3149             (parallel [(const_int 0) (const_int 1)]))))]
3150   "TARGET_SSE2")
3151
3152 (define_expand "vec_unpacku_float_hi_v4si"
3153   [(set (match_dup 5)
3154         (vec_select:V4SI
3155           (match_operand:V4SI 1 "nonimmediate_operand" "")
3156           (parallel [(const_int 2)
3157                      (const_int 3)
3158                      (const_int 2)
3159                      (const_int 3)])))
3160    (set (match_dup 6)
3161         (float:V2DF
3162           (vec_select:V2SI
3163           (match_dup 5)
3164             (parallel [(const_int 0) (const_int 1)]))))
3165    (set (match_dup 7)
3166         (lt:V2DF (match_dup 6) (match_dup 3)))
3167    (set (match_dup 8)
3168         (and:V2DF (match_dup 7) (match_dup 4)))
3169    (set (match_operand:V2DF 0 "register_operand" "")
3170         (plus:V2DF (match_dup 6) (match_dup 8)))]
3171  "TARGET_SSE2"
3172 {
3173   REAL_VALUE_TYPE TWO32r;
3174   rtx x;
3175   int i;
3176
3177   real_ldexp (&TWO32r, &dconst1, 32);
3178   x = const_double_from_real_value (TWO32r, DFmode);
3179
3180   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3181   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3182
3183   operands[5] = gen_reg_rtx (V4SImode);
3184
3185   for (i = 6; i < 9; i++)
3186     operands[i] = gen_reg_rtx (V2DFmode);
3187 })
3188
3189 (define_expand "vec_unpacku_float_lo_v4si"
3190   [(set (match_dup 5)
3191         (float:V2DF
3192           (vec_select:V2SI
3193             (match_operand:V4SI 1 "nonimmediate_operand" "")
3194             (parallel [(const_int 0) (const_int 1)]))))
3195    (set (match_dup 6)
3196         (lt:V2DF (match_dup 5) (match_dup 3)))
3197    (set (match_dup 7)
3198         (and:V2DF (match_dup 6) (match_dup 4)))
3199    (set (match_operand:V2DF 0 "register_operand" "")
3200         (plus:V2DF (match_dup 5) (match_dup 7)))]
3201   "TARGET_SSE2"
3202 {
3203   REAL_VALUE_TYPE TWO32r;
3204   rtx x;
3205   int i;
3206
3207   real_ldexp (&TWO32r, &dconst1, 32);
3208   x = const_double_from_real_value (TWO32r, DFmode);
3209
3210   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3211   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3212
3213   for (i = 5; i < 8; i++)
3214     operands[i] = gen_reg_rtx (V2DFmode);
3215 })
3216
3217 (define_expand "vec_pack_trunc_v2df"
3218   [(match_operand:V4SF 0 "register_operand" "")
3219    (match_operand:V2DF 1 "nonimmediate_operand" "")
3220    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3221   "TARGET_SSE2"
3222 {
3223   rtx r1, r2;
3224
3225   r1 = gen_reg_rtx (V4SFmode);
3226   r2 = gen_reg_rtx (V4SFmode);
3227
3228   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
3229   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
3230   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
3231   DONE;
3232 })
3233
3234 (define_expand "vec_pack_sfix_trunc_v2df"
3235   [(match_operand:V4SI 0 "register_operand" "")
3236    (match_operand:V2DF 1 "nonimmediate_operand" "")
3237    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3238   "TARGET_SSE2"
3239 {
3240   rtx r1, r2;
3241
3242   r1 = gen_reg_rtx (V4SImode);
3243   r2 = gen_reg_rtx (V4SImode);
3244
3245   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
3246   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
3247   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3248                                          gen_lowpart (V2DImode, r1),
3249                                          gen_lowpart (V2DImode, r2)));
3250   DONE;
3251 })
3252
3253 (define_expand "vec_pack_sfix_v2df"
3254   [(match_operand:V4SI 0 "register_operand" "")
3255    (match_operand:V2DF 1 "nonimmediate_operand" "")
3256    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3257   "TARGET_SSE2"
3258 {
3259   rtx r1, r2;
3260
3261   r1 = gen_reg_rtx (V4SImode);
3262   r2 = gen_reg_rtx (V4SImode);
3263
3264   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
3265   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
3266   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3267                                          gen_lowpart (V2DImode, r1),
3268                                          gen_lowpart (V2DImode, r2)));
3269   DONE;
3270 })
3271
3272 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3273 ;;
3274 ;; Parallel single-precision floating point element swizzling
3275 ;;
3276 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3277
3278 (define_expand "sse_movhlps_exp"
3279   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3280         (vec_select:V4SF
3281           (vec_concat:V8SF
3282             (match_operand:V4SF 1 "nonimmediate_operand" "")
3283             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3284           (parallel [(const_int 6)
3285                      (const_int 7)
3286                      (const_int 2)
3287                      (const_int 3)])))]
3288   "TARGET_SSE"
3289   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3290
3291 (define_insn "*avx_movhlps"
3292   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3293         (vec_select:V4SF
3294           (vec_concat:V8SF
3295             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3296             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3297           (parallel [(const_int 6)
3298                      (const_int 7)
3299                      (const_int 2)
3300                      (const_int 3)])))]
3301   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3302   "@
3303    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3304    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3305    vmovhps\t{%2, %0|%0, %2}"
3306   [(set_attr "type" "ssemov")
3307    (set_attr "prefix" "vex")
3308    (set_attr "mode" "V4SF,V2SF,V2SF")])
3309
3310 (define_insn "sse_movhlps"
3311   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3312         (vec_select:V4SF
3313           (vec_concat:V8SF
3314             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3315             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3316           (parallel [(const_int 6)
3317                      (const_int 7)
3318                      (const_int 2)
3319                      (const_int 3)])))]
3320   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3321   "@
3322    movhlps\t{%2, %0|%0, %2}
3323    movlps\t{%H2, %0|%0, %H2}
3324    movhps\t{%2, %0|%0, %2}"
3325   [(set_attr "type" "ssemov")
3326    (set_attr "mode" "V4SF,V2SF,V2SF")])
3327
3328 (define_expand "sse_movlhps_exp"
3329   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3330         (vec_select:V4SF
3331           (vec_concat:V8SF
3332             (match_operand:V4SF 1 "nonimmediate_operand" "")
3333             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3334           (parallel [(const_int 0)
3335                      (const_int 1)
3336                      (const_int 4)
3337                      (const_int 5)])))]
3338   "TARGET_SSE"
3339   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3340
3341 (define_insn "*avx_movlhps"
3342   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3343         (vec_select:V4SF
3344           (vec_concat:V8SF
3345             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3346             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3347           (parallel [(const_int 0)
3348                      (const_int 1)
3349                      (const_int 4)
3350                      (const_int 5)])))]
3351   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3352   "@
3353    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3354    vmovhps\t{%2, %1, %0|%0, %1, %2}
3355    vmovlps\t{%2, %H0|%H0, %2}"
3356   [(set_attr "type" "ssemov")
3357    (set_attr "prefix" "vex")
3358    (set_attr "mode" "V4SF,V2SF,V2SF")])
3359
3360 (define_insn "sse_movlhps"
3361   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3362         (vec_select:V4SF
3363           (vec_concat:V8SF
3364             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3365             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3366           (parallel [(const_int 0)
3367                      (const_int 1)
3368                      (const_int 4)
3369                      (const_int 5)])))]
3370   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3371   "@
3372    movlhps\t{%2, %0|%0, %2}
3373    movhps\t{%2, %0|%0, %2}
3374    movlps\t{%2, %H0|%H0, %2}"
3375   [(set_attr "type" "ssemov")
3376    (set_attr "mode" "V4SF,V2SF,V2SF")])
3377
3378 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3379 (define_insn "avx_unpckhps256"
3380   [(set (match_operand:V8SF 0 "register_operand" "=x")
3381         (vec_select:V8SF
3382           (vec_concat:V16SF
3383             (match_operand:V8SF 1 "register_operand" "x")
3384             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3385           (parallel [(const_int 2) (const_int 10)
3386                      (const_int 3) (const_int 11)
3387                      (const_int 6) (const_int 14)
3388                      (const_int 7) (const_int 15)])))]
3389   "TARGET_AVX"
3390   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3391   [(set_attr "type" "sselog")
3392    (set_attr "prefix" "vex")
3393    (set_attr "mode" "V8SF")])
3394
3395 (define_insn "*avx_interleave_highv4sf"
3396   [(set (match_operand:V4SF 0 "register_operand" "=x")
3397         (vec_select:V4SF
3398           (vec_concat:V8SF
3399             (match_operand:V4SF 1 "register_operand" "x")
3400             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3401           (parallel [(const_int 2) (const_int 6)
3402                      (const_int 3) (const_int 7)])))]
3403   "TARGET_AVX"
3404   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3405   [(set_attr "type" "sselog")
3406    (set_attr "prefix" "vex")
3407    (set_attr "mode" "V4SF")])
3408
3409 (define_insn "vec_interleave_highv4sf"
3410   [(set (match_operand:V4SF 0 "register_operand" "=x")
3411         (vec_select:V4SF
3412           (vec_concat:V8SF
3413             (match_operand:V4SF 1 "register_operand" "0")
3414             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3415           (parallel [(const_int 2) (const_int 6)
3416                      (const_int 3) (const_int 7)])))]
3417   "TARGET_SSE"
3418   "unpckhps\t{%2, %0|%0, %2}"
3419   [(set_attr "type" "sselog")
3420    (set_attr "mode" "V4SF")])
3421
3422 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3423 (define_insn "avx_unpcklps256"
3424   [(set (match_operand:V8SF 0 "register_operand" "=x")
3425         (vec_select:V8SF
3426           (vec_concat:V16SF
3427             (match_operand:V8SF 1 "register_operand" "x")
3428             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3429           (parallel [(const_int 0) (const_int 8)
3430                      (const_int 1) (const_int 9)
3431                      (const_int 4) (const_int 12)
3432                      (const_int 5) (const_int 13)])))]
3433   "TARGET_AVX"
3434   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3435   [(set_attr "type" "sselog")
3436    (set_attr "prefix" "vex")
3437    (set_attr "mode" "V8SF")])
3438
3439 (define_insn "*avx_interleave_lowv4sf"
3440   [(set (match_operand:V4SF 0 "register_operand" "=x")
3441         (vec_select:V4SF
3442           (vec_concat:V8SF
3443             (match_operand:V4SF 1 "register_operand" "x")
3444             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3445           (parallel [(const_int 0) (const_int 4)
3446                      (const_int 1) (const_int 5)])))]
3447   "TARGET_AVX"
3448   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3449   [(set_attr "type" "sselog")
3450    (set_attr "prefix" "vex")
3451    (set_attr "mode" "V4SF")])
3452
3453 (define_insn "vec_interleave_lowv4sf"
3454   [(set (match_operand:V4SF 0 "register_operand" "=x")
3455         (vec_select:V4SF
3456           (vec_concat:V8SF
3457             (match_operand:V4SF 1 "register_operand" "0")
3458             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3459           (parallel [(const_int 0) (const_int 4)
3460                      (const_int 1) (const_int 5)])))]
3461   "TARGET_SSE"
3462   "unpcklps\t{%2, %0|%0, %2}"
3463   [(set_attr "type" "sselog")
3464    (set_attr "mode" "V4SF")])
3465
3466 ;; These are modeled with the same vec_concat as the others so that we
3467 ;; capture users of shufps that can use the new instructions
3468 (define_insn "avx_movshdup256"
3469   [(set (match_operand:V8SF 0 "register_operand" "=x")
3470         (vec_select:V8SF
3471           (vec_concat:V16SF
3472             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3473             (match_dup 1))
3474           (parallel [(const_int 1) (const_int 1)
3475                      (const_int 3) (const_int 3)
3476                      (const_int 5) (const_int 5)
3477                      (const_int 7) (const_int 7)])))]
3478   "TARGET_AVX"
3479   "vmovshdup\t{%1, %0|%0, %1}"
3480   [(set_attr "type" "sse")
3481    (set_attr "prefix" "vex")
3482    (set_attr "mode" "V8SF")])
3483
3484 (define_insn "sse3_movshdup"
3485   [(set (match_operand:V4SF 0 "register_operand" "=x")
3486         (vec_select:V4SF
3487           (vec_concat:V8SF
3488             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3489             (match_dup 1))
3490           (parallel [(const_int 1)
3491                      (const_int 1)
3492                      (const_int 7)
3493                      (const_int 7)])))]
3494   "TARGET_SSE3"
3495   "%vmovshdup\t{%1, %0|%0, %1}"
3496   [(set_attr "type" "sse")
3497    (set_attr "prefix_rep" "1")
3498    (set_attr "prefix" "maybe_vex")
3499    (set_attr "mode" "V4SF")])
3500
3501 (define_insn "avx_movsldup256"
3502   [(set (match_operand:V8SF 0 "register_operand" "=x")
3503         (vec_select:V8SF
3504           (vec_concat:V16SF
3505             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3506             (match_dup 1))
3507           (parallel [(const_int 0) (const_int 0)
3508                      (const_int 2) (const_int 2)
3509                      (const_int 4) (const_int 4)
3510                      (const_int 6) (const_int 6)])))]
3511   "TARGET_AVX"
3512   "vmovsldup\t{%1, %0|%0, %1}"
3513   [(set_attr "type" "sse")
3514    (set_attr "prefix" "vex")
3515    (set_attr "mode" "V8SF")])
3516
3517 (define_insn "sse3_movsldup"
3518   [(set (match_operand:V4SF 0 "register_operand" "=x")
3519         (vec_select:V4SF
3520           (vec_concat:V8SF
3521             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3522             (match_dup 1))
3523           (parallel [(const_int 0)
3524                      (const_int 0)
3525                      (const_int 6)
3526                      (const_int 6)])))]
3527   "TARGET_SSE3"
3528   "%vmovsldup\t{%1, %0|%0, %1}"
3529   [(set_attr "type" "sse")
3530    (set_attr "prefix_rep" "1")
3531    (set_attr "prefix" "maybe_vex")
3532    (set_attr "mode" "V4SF")])
3533
3534 (define_expand "avx_shufps256"
3535   [(match_operand:V8SF 0 "register_operand" "")
3536    (match_operand:V8SF 1 "register_operand" "")
3537    (match_operand:V8SF 2 "nonimmediate_operand" "")
3538    (match_operand:SI 3 "const_int_operand" "")]
3539   "TARGET_AVX"
3540 {
3541   int mask = INTVAL (operands[3]);
3542   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3543                                   GEN_INT ((mask >> 0) & 3),
3544                                   GEN_INT ((mask >> 2) & 3),
3545                                   GEN_INT (((mask >> 4) & 3) + 8),
3546                                   GEN_INT (((mask >> 6) & 3) + 8),
3547                                   GEN_INT (((mask >> 0) & 3) + 4),
3548                                   GEN_INT (((mask >> 2) & 3) + 4),
3549                                   GEN_INT (((mask >> 4) & 3) + 12),
3550                                   GEN_INT (((mask >> 6) & 3) + 12)));
3551   DONE;
3552 })
3553
3554 ;; One bit in mask selects 2 elements.
3555 (define_insn "avx_shufps256_1"
3556   [(set (match_operand:V8SF 0 "register_operand" "=x")
3557         (vec_select:V8SF
3558           (vec_concat:V16SF
3559             (match_operand:V8SF 1 "register_operand" "x")
3560             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3561           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3562                      (match_operand 4  "const_0_to_3_operand"   "")
3563                      (match_operand 5  "const_8_to_11_operand"  "")
3564                      (match_operand 6  "const_8_to_11_operand"  "")
3565                      (match_operand 7  "const_4_to_7_operand"   "")
3566                      (match_operand 8  "const_4_to_7_operand"   "")
3567                      (match_operand 9  "const_12_to_15_operand" "")
3568                      (match_operand 10 "const_12_to_15_operand" "")])))]
3569   "TARGET_AVX
3570    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3571        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3572        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3573        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3574 {
3575   int mask;
3576   mask = INTVAL (operands[3]);
3577   mask |= INTVAL (operands[4]) << 2;
3578   mask |= (INTVAL (operands[5]) - 8) << 4;
3579   mask |= (INTVAL (operands[6]) - 8) << 6;
3580   operands[3] = GEN_INT (mask);
3581
3582   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3583 }
3584   [(set_attr "type" "sselog")
3585    (set_attr "length_immediate" "1")
3586    (set_attr "prefix" "vex")
3587    (set_attr "mode" "V8SF")])
3588
3589 (define_expand "sse_shufps"
3590   [(match_operand:V4SF 0 "register_operand" "")
3591    (match_operand:V4SF 1 "register_operand" "")
3592    (match_operand:V4SF 2 "nonimmediate_operand" "")
3593    (match_operand:SI 3 "const_int_operand" "")]
3594   "TARGET_SSE"
3595 {
3596   int mask = INTVAL (operands[3]);
3597   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3598                                GEN_INT ((mask >> 0) & 3),
3599                                GEN_INT ((mask >> 2) & 3),
3600                                GEN_INT (((mask >> 4) & 3) + 4),
3601                                GEN_INT (((mask >> 6) & 3) + 4)));
3602   DONE;
3603 })
3604
3605 (define_insn "*avx_shufps_<mode>"
3606   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3607         (vec_select:SSEMODE4S
3608           (vec_concat:<ssedoublesizemode>
3609             (match_operand:SSEMODE4S 1 "register_operand" "x")
3610             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3611           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3612                      (match_operand 4 "const_0_to_3_operand" "")
3613                      (match_operand 5 "const_4_to_7_operand" "")
3614                      (match_operand 6 "const_4_to_7_operand" "")])))]
3615   "TARGET_AVX"
3616 {
3617   int mask = 0;
3618   mask |= INTVAL (operands[3]) << 0;
3619   mask |= INTVAL (operands[4]) << 2;
3620   mask |= (INTVAL (operands[5]) - 4) << 4;
3621   mask |= (INTVAL (operands[6]) - 4) << 6;
3622   operands[3] = GEN_INT (mask);
3623
3624   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3625 }
3626   [(set_attr "type" "sselog")
3627    (set_attr "length_immediate" "1")
3628    (set_attr "prefix" "vex")
3629    (set_attr "mode" "V4SF")])
3630
3631 (define_insn "sse_shufps_<mode>"
3632   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3633         (vec_select:SSEMODE4S
3634           (vec_concat:<ssedoublesizemode>
3635             (match_operand:SSEMODE4S 1 "register_operand" "0")
3636             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3637           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3638                      (match_operand 4 "const_0_to_3_operand" "")
3639                      (match_operand 5 "const_4_to_7_operand" "")
3640                      (match_operand 6 "const_4_to_7_operand" "")])))]
3641   "TARGET_SSE"
3642 {
3643   int mask = 0;
3644   mask |= INTVAL (operands[3]) << 0;
3645   mask |= INTVAL (operands[4]) << 2;
3646   mask |= (INTVAL (operands[5]) - 4) << 4;
3647   mask |= (INTVAL (operands[6]) - 4) << 6;
3648   operands[3] = GEN_INT (mask);
3649
3650   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3651 }
3652   [(set_attr "type" "sselog")
3653    (set_attr "length_immediate" "1")
3654    (set_attr "mode" "V4SF")])
3655
3656 (define_insn "sse_storehps"
3657   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3658         (vec_select:V2SF
3659           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3660           (parallel [(const_int 2) (const_int 3)])))]
3661   "TARGET_SSE"
3662   "@
3663    %vmovhps\t{%1, %0|%0, %1}
3664    %vmovhlps\t{%1, %d0|%d0, %1}
3665    %vmovlps\t{%H1, %d0|%d0, %H1}"
3666   [(set_attr "type" "ssemov")
3667    (set_attr "prefix" "maybe_vex")
3668    (set_attr "mode" "V2SF,V4SF,V2SF")])
3669
3670 (define_expand "sse_loadhps_exp"
3671   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3672         (vec_concat:V4SF
3673           (vec_select:V2SF
3674             (match_operand:V4SF 1 "nonimmediate_operand" "")
3675             (parallel [(const_int 0) (const_int 1)]))
3676           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3677   "TARGET_SSE"
3678   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3679
3680 (define_insn "*avx_loadhps"
3681   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3682         (vec_concat:V4SF
3683           (vec_select:V2SF
3684             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3685             (parallel [(const_int 0) (const_int 1)]))
3686           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3687   "TARGET_AVX"
3688   "@
3689    vmovhps\t{%2, %1, %0|%0, %1, %2}
3690    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3691    vmovlps\t{%2, %H0|%H0, %2}"
3692   [(set_attr "type" "ssemov")
3693    (set_attr "prefix" "vex")
3694    (set_attr "mode" "V2SF,V4SF,V2SF")])
3695
3696 (define_insn "sse_loadhps"
3697   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3698         (vec_concat:V4SF
3699           (vec_select:V2SF
3700             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3701             (parallel [(const_int 0) (const_int 1)]))
3702           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3703   "TARGET_SSE"
3704   "@
3705    movhps\t{%2, %0|%0, %2}
3706    movlhps\t{%2, %0|%0, %2}
3707    movlps\t{%2, %H0|%H0, %2}"
3708   [(set_attr "type" "ssemov")
3709    (set_attr "mode" "V2SF,V4SF,V2SF")])
3710
3711 (define_insn "*avx_storelps"
3712   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3713         (vec_select:V2SF
3714           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3715           (parallel [(const_int 0) (const_int 1)])))]
3716   "TARGET_AVX"
3717   "@
3718    vmovlps\t{%1, %0|%0, %1}
3719    vmovaps\t{%1, %0|%0, %1}
3720    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3721   [(set_attr "type" "ssemov")
3722    (set_attr "prefix" "vex")
3723    (set_attr "mode" "V2SF,V2DF,V2SF")])
3724
3725 (define_insn "sse_storelps"
3726   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3727         (vec_select:V2SF
3728           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3729           (parallel [(const_int 0) (const_int 1)])))]
3730   "TARGET_SSE"
3731   "@
3732    movlps\t{%1, %0|%0, %1}
3733    movaps\t{%1, %0|%0, %1}
3734    movlps\t{%1, %0|%0, %1}"
3735   [(set_attr "type" "ssemov")
3736    (set_attr "mode" "V2SF,V4SF,V2SF")])
3737
3738 (define_expand "sse_loadlps_exp"
3739   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3740         (vec_concat:V4SF
3741           (match_operand:V2SF 2 "nonimmediate_operand" "")
3742           (vec_select:V2SF
3743             (match_operand:V4SF 1 "nonimmediate_operand" "")
3744             (parallel [(const_int 2) (const_int 3)]))))]
3745   "TARGET_SSE"
3746   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3747
3748 (define_insn "*avx_loadlps"
3749   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3750         (vec_concat:V4SF
3751           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3752           (vec_select:V2SF
3753             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3754             (parallel [(const_int 2) (const_int 3)]))))]
3755   "TARGET_AVX"
3756   "@
3757    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3758    vmovlps\t{%2, %1, %0|%0, %1, %2}
3759    vmovlps\t{%2, %0|%0, %2}"
3760   [(set_attr "type" "sselog,ssemov,ssemov")
3761    (set_attr "length_immediate" "1,*,*")
3762    (set_attr "prefix" "vex")
3763    (set_attr "mode" "V4SF,V2SF,V2SF")])
3764
3765 (define_insn "sse_loadlps"
3766   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3767         (vec_concat:V4SF
3768           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3769           (vec_select:V2SF
3770             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3771             (parallel [(const_int 2) (const_int 3)]))))]
3772   "TARGET_SSE"
3773   "@
3774    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3775    movlps\t{%2, %0|%0, %2}
3776    movlps\t{%2, %0|%0, %2}"
3777   [(set_attr "type" "sselog,ssemov,ssemov")
3778    (set_attr "length_immediate" "1,*,*")
3779    (set_attr "mode" "V4SF,V2SF,V2SF")])
3780
3781 (define_insn "*avx_movss"
3782   [(set (match_operand:V4SF 0 "register_operand" "=x")
3783         (vec_merge:V4SF
3784           (match_operand:V4SF 2 "register_operand" "x")
3785           (match_operand:V4SF 1 "register_operand" "x")
3786           (const_int 1)))]
3787   "TARGET_AVX"
3788   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3789   [(set_attr "type" "ssemov")
3790    (set_attr "prefix" "vex")
3791    (set_attr "mode" "SF")])
3792
3793 (define_insn "sse_movss"
3794   [(set (match_operand:V4SF 0 "register_operand" "=x")
3795         (vec_merge:V4SF
3796           (match_operand:V4SF 2 "register_operand" "x")
3797           (match_operand:V4SF 1 "register_operand" "0")
3798           (const_int 1)))]
3799   "TARGET_SSE"
3800   "movss\t{%2, %0|%0, %2}"
3801   [(set_attr "type" "ssemov")
3802    (set_attr "mode" "SF")])
3803
3804 (define_expand "vec_dupv4sf"
3805   [(set (match_operand:V4SF 0 "register_operand" "")
3806         (vec_duplicate:V4SF
3807           (match_operand:SF 1 "nonimmediate_operand" "")))]
3808   "TARGET_SSE"
3809 {
3810   if (!TARGET_AVX)
3811     operands[1] = force_reg (V4SFmode, operands[1]);
3812 })
3813
3814 (define_insn "*vec_dupv4sf_avx"
3815   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3816         (vec_duplicate:V4SF
3817           (match_operand:SF 1 "nonimmediate_operand" "x,m")))]
3818   "TARGET_AVX"
3819   "@
3820    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
3821    vbroadcastss\t{%1, %0|%0, %1}"
3822   [(set_attr "type" "sselog1,ssemov")
3823    (set_attr "length_immediate" "1,0")
3824    (set_attr "prefix_extra" "0,1")
3825    (set_attr "prefix" "vex")
3826    (set_attr "mode" "V4SF")])
3827
3828 (define_insn "*vec_dupv4sf"
3829   [(set (match_operand:V4SF 0 "register_operand" "=x")
3830         (vec_duplicate:V4SF
3831           (match_operand:SF 1 "register_operand" "0")))]
3832   "TARGET_SSE"
3833   "shufps\t{$0, %0, %0|%0, %0, 0}"
3834   [(set_attr "type" "sselog1")
3835    (set_attr "length_immediate" "1")
3836    (set_attr "mode" "V4SF")])
3837
3838 (define_insn "*vec_concatv2sf_avx"
3839   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3840         (vec_concat:V2SF
3841           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3842           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3843   "TARGET_AVX"
3844   "@
3845    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3846    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3847    vmovss\t{%1, %0|%0, %1}
3848    punpckldq\t{%2, %0|%0, %2}
3849    movd\t{%1, %0|%0, %1}"
3850   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3851    (set_attr "length_immediate" "*,1,*,*,*")
3852    (set_attr "prefix_extra" "*,1,*,*,*")
3853    (set (attr "prefix")
3854      (if_then_else (eq_attr "alternative" "3,4")
3855        (const_string "orig")
3856        (const_string "vex")))
3857    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3858
3859 ;; Although insertps takes register source, we prefer
3860 ;; unpcklps with register source since it is shorter.
3861 (define_insn "*vec_concatv2sf_sse4_1"
3862   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3863         (vec_concat:V2SF
3864           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3865           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3866   "TARGET_SSE4_1"
3867   "@
3868    unpcklps\t{%2, %0|%0, %2}
3869    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3870    movss\t{%1, %0|%0, %1}
3871    punpckldq\t{%2, %0|%0, %2}
3872    movd\t{%1, %0|%0, %1}"
3873   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3874    (set_attr "prefix_data16" "*,1,*,*,*")
3875    (set_attr "prefix_extra" "*,1,*,*,*")
3876    (set_attr "length_immediate" "*,1,*,*,*")
3877    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3878
3879 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3880 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3881 ;; alternatives pretty much forces the MMX alternative to be chosen.
3882 (define_insn "*vec_concatv2sf_sse"
3883   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3884         (vec_concat:V2SF
3885           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3886           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3887   "TARGET_SSE"
3888   "@
3889    unpcklps\t{%2, %0|%0, %2}
3890    movss\t{%1, %0|%0, %1}
3891    punpckldq\t{%2, %0|%0, %2}
3892    movd\t{%1, %0|%0, %1}"
3893   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3894    (set_attr "mode" "V4SF,SF,DI,DI")])
3895
3896 (define_insn "*vec_concatv4sf_avx"
3897   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3898         (vec_concat:V4SF
3899           (match_operand:V2SF 1 "register_operand" " x,x")
3900           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3901   "TARGET_AVX"
3902   "@
3903    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3904    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3905   [(set_attr "type" "ssemov")
3906    (set_attr "prefix" "vex")
3907    (set_attr "mode" "V4SF,V2SF")])
3908
3909 (define_insn "*vec_concatv4sf_sse"
3910   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3911         (vec_concat:V4SF
3912           (match_operand:V2SF 1 "register_operand" " 0,0")
3913           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3914   "TARGET_SSE"
3915   "@
3916    movlhps\t{%2, %0|%0, %2}
3917    movhps\t{%2, %0|%0, %2}"
3918   [(set_attr "type" "ssemov")
3919    (set_attr "mode" "V4SF,V2SF")])
3920
3921 (define_expand "vec_init<mode>"
3922   [(match_operand:SSEMODE 0 "register_operand" "")
3923    (match_operand 1 "" "")]
3924   "TARGET_SSE"
3925 {
3926   ix86_expand_vector_init (false, operands[0], operands[1]);
3927   DONE;
3928 })
3929
3930 (define_insn "*vec_set<mode>_0_avx"
3931   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3932         (vec_merge:SSEMODE4S
3933           (vec_duplicate:SSEMODE4S
3934             (match_operand:<ssescalarmode> 2
3935               "general_operand"                            " x,m,*r,x,*rm,x*rfF"))
3936           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0")
3937           (const_int 1)))]
3938   "TARGET_AVX"
3939   "@
3940    vinsertps\t{$0xe, %2, %2, %0|%0, %2, %2, 0xe}
3941    vmov<ssescalarmodesuffix2s>\t{%2, %0|%0, %2}
3942    vmovd\t{%2, %0|%0, %2}
3943    vmovss\t{%2, %1, %0|%0, %1, %2}
3944    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
3945    #"
3946   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
3947    (set_attr "prefix_extra" "*,*,*,*,1,*")
3948    (set_attr "length_immediate" "*,*,*,*,1,*")
3949    (set_attr "prefix" "vex")
3950    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
3951
3952 (define_insn "*vec_set<mode>_0_sse4_1"
3953   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3954         (vec_merge:SSEMODE4S
3955           (vec_duplicate:SSEMODE4S
3956             (match_operand:<ssescalarmode> 2
3957               "general_operand"                            " x,m,*r,x,*rm,*rfF"))
3958           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,0,  0,0")
3959           (const_int 1)))]
3960   "TARGET_SSE4_1"
3961   "@
3962    insertps\t{$0xe, %2, %0|%0, %2, 0xe}
3963    mov<ssescalarmodesuffix2s>\t{%2, %0|%0, %2}
3964    movd\t{%2, %0|%0, %2}
3965    movss\t{%2, %0|%0, %2}
3966    pinsrd\t{$0, %2, %0|%0, %2, 0}
3967    #"
3968   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
3969    (set_attr "prefix_extra" "*,*,*,*,1,*")
3970    (set_attr "length_immediate" "*,*,*,*,1,*")
3971    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
3972
3973 (define_insn "*vec_set<mode>_0_sse2"
3974   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x, x,x,m")
3975         (vec_merge:SSEMODE4S
3976           (vec_duplicate:SSEMODE4S
3977             (match_operand:<ssescalarmode> 2
3978               "general_operand"                            " m,*r,x,x*rfF"))
3979           (match_operand:SSEMODE4S 1 "vector_move_operand" " C, C,0,0")
3980           (const_int 1)))]
3981   "TARGET_SSE2"
3982   "@
3983    mov<ssescalarmodesuffix2s>\t{%2, %0|%0, %2}
3984    movd\t{%2, %0|%0, %2}
3985    movss\t{%2, %0|%0, %2}
3986    #"
3987   [(set_attr "type" "ssemov")
3988    (set_attr "mode" "<ssescalarmode>,SI,SF,*")])
3989
3990 (define_insn "vec_set<mode>_0"
3991   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x,m")
3992         (vec_merge:SSEMODE4S
3993           (vec_duplicate:SSEMODE4S
3994             (match_operand:<ssescalarmode> 2
3995               "general_operand"                            " m,x,x*rfF"))
3996           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,0,0")
3997           (const_int 1)))]
3998   "TARGET_SSE"
3999   "@
4000    movss\t{%2, %0|%0, %2}
4001    movss\t{%2, %0|%0, %2}
4002    #"
4003   [(set_attr "type" "ssemov")
4004    (set_attr "mode" "SF")])
4005
4006 ;; A subset is vec_setv4sf.
4007 (define_insn "*vec_setv4sf_avx"
4008   [(set (match_operand:V4SF 0 "register_operand" "=x")
4009         (vec_merge:V4SF
4010           (vec_duplicate:V4SF
4011             (match_operand:SF 2 "nonimmediate_operand" "xm"))
4012           (match_operand:V4SF 1 "register_operand" "x")
4013           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4014   "TARGET_AVX"
4015 {
4016   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4017   return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4018 }
4019   [(set_attr "type" "sselog")
4020    (set_attr "prefix_extra" "1")
4021    (set_attr "length_immediate" "1")
4022    (set_attr "prefix" "vex")
4023    (set_attr "mode" "V4SF")])
4024
4025 (define_insn "*vec_setv4sf_sse4_1"
4026   [(set (match_operand:V4SF 0 "register_operand" "=x")
4027         (vec_merge:V4SF
4028           (vec_duplicate:V4SF
4029             (match_operand:SF 2 "nonimmediate_operand" "xm"))
4030           (match_operand:V4SF 1 "register_operand" "0")
4031           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4032   "TARGET_SSE4_1"
4033 {
4034   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4035   return "insertps\t{%3, %2, %0|%0, %2, %3}";
4036 }
4037   [(set_attr "type" "sselog")
4038    (set_attr "prefix_data16" "1")
4039    (set_attr "prefix_extra" "1")
4040    (set_attr "length_immediate" "1")
4041    (set_attr "mode" "V4SF")])
4042
4043 (define_insn "*avx_insertps"
4044   [(set (match_operand:V4SF 0 "register_operand" "=x")
4045         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
4046                       (match_operand:V4SF 1 "register_operand" "x")
4047                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4048                      UNSPEC_INSERTPS))]
4049   "TARGET_AVX"
4050   "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4051   [(set_attr "type" "sselog")
4052    (set_attr "prefix" "vex")
4053    (set_attr "prefix_extra" "1")
4054    (set_attr "length_immediate" "1")
4055    (set_attr "mode" "V4SF")])
4056
4057 (define_insn "sse4_1_insertps"
4058   [(set (match_operand:V4SF 0 "register_operand" "=x")
4059         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
4060                       (match_operand:V4SF 1 "register_operand" "0")
4061                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4062                      UNSPEC_INSERTPS))]
4063   "TARGET_SSE4_1"
4064   "insertps\t{%3, %2, %0|%0, %2, %3}";
4065   [(set_attr "type" "sselog")
4066    (set_attr "prefix_data16" "1")
4067    (set_attr "prefix_extra" "1")
4068    (set_attr "length_immediate" "1")
4069    (set_attr "mode" "V4SF")])
4070
4071 (define_split
4072   [(set (match_operand:V4SF 0 "memory_operand" "")
4073         (vec_merge:V4SF
4074           (vec_duplicate:V4SF
4075             (match_operand:SF 1 "nonmemory_operand" ""))
4076           (match_dup 0)
4077           (const_int 1)))]
4078   "TARGET_SSE && reload_completed"
4079   [(const_int 0)]
4080 {
4081   emit_move_insn (adjust_address (operands[0], SFmode, 0), operands[1]);
4082   DONE;
4083 })
4084
4085 (define_expand "vec_set<mode>"
4086   [(match_operand:SSEMODE 0 "register_operand" "")
4087    (match_operand:<ssescalarmode> 1 "register_operand" "")
4088    (match_operand 2 "const_int_operand" "")]
4089   "TARGET_SSE"
4090 {
4091   ix86_expand_vector_set (false, operands[0], operands[1],
4092                           INTVAL (operands[2]));
4093   DONE;
4094 })
4095
4096 (define_insn_and_split "*vec_extractv4sf_0"
4097   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
4098         (vec_select:SF
4099           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
4100           (parallel [(const_int 0)])))]
4101   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4102   "#"
4103   "&& reload_completed"
4104   [(const_int 0)]
4105 {
4106   rtx op1 = operands[1];
4107   if (REG_P (op1))
4108     op1 = gen_rtx_REG (SFmode, REGNO (op1));
4109   else
4110     op1 = gen_lowpart (SFmode, op1);
4111   emit_move_insn (operands[0], op1);
4112   DONE;
4113 })
4114
4115 (define_expand "avx_vextractf128<mode>"
4116   [(match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "")
4117    (match_operand:AVX256MODE 1 "register_operand" "")
4118    (match_operand:SI 2 "const_0_to_1_operand" "")]
4119   "TARGET_AVX"
4120 {
4121   switch (INTVAL (operands[2]))
4122     {
4123     case 0:
4124       emit_insn (gen_vec_extract_lo_<mode> (operands[0], operands[1]));
4125       break;
4126     case 1:
4127       emit_insn (gen_vec_extract_hi_<mode> (operands[0], operands[1]));
4128       break;
4129     default:
4130       gcc_unreachable ();
4131     }
4132   DONE;
4133 })
4134
4135 (define_insn "vec_extract_lo_<mode>"
4136   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4137         (vec_select:<avxhalfvecmode>
4138           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
4139           (parallel [(const_int 0) (const_int 1)])))]
4140   "TARGET_AVX"
4141   "vextractf128\t{$0x0, %1, %0|%0, %1, 0x0}"
4142   [(set_attr "type" "sselog")
4143    (set_attr "prefix_extra" "1")
4144    (set_attr "length_immediate" "1")
4145    (set_attr "memory" "none,store")
4146    (set_attr "prefix" "vex")
4147    (set_attr "mode" "V8SF")])
4148
4149 (define_insn "vec_extract_hi_<mode>"
4150   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4151         (vec_select:<avxhalfvecmode>
4152           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
4153           (parallel [(const_int 2) (const_int 3)])))]
4154   "TARGET_AVX"
4155   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4156   [(set_attr "type" "sselog")
4157    (set_attr "prefix_extra" "1")
4158    (set_attr "length_immediate" "1")
4159    (set_attr "memory" "none,store")
4160    (set_attr "prefix" "vex")
4161    (set_attr "mode" "V8SF")])
4162
4163 (define_insn "vec_extract_lo_<mode>"
4164   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4165         (vec_select:<avxhalfvecmode>
4166           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
4167           (parallel [(const_int 0) (const_int 1)
4168                      (const_int 2) (const_int 3)])))]
4169   "TARGET_AVX"
4170   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4171   [(set_attr "type" "sselog")
4172    (set_attr "prefix_extra" "1")
4173    (set_attr "length_immediate" "1")
4174    (set_attr "memory" "none,store")
4175    (set_attr "prefix" "vex")
4176    (set_attr "mode" "V8SF")])
4177
4178 (define_insn "vec_extract_hi_<mode>"
4179   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4180         (vec_select:<avxhalfvecmode>
4181           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
4182           (parallel [(const_int 4) (const_int 5)
4183                      (const_int 6) (const_int 7)])))]
4184   "TARGET_AVX"
4185   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4186   [(set_attr "type" "sselog")
4187    (set_attr "prefix_extra" "1")
4188    (set_attr "length_immediate" "1")
4189    (set_attr "memory" "none,store")
4190    (set_attr "prefix" "vex")
4191    (set_attr "mode" "V8SF")])
4192
4193 (define_insn "vec_extract_lo_v16hi"
4194   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4195         (vec_select:V8HI
4196           (match_operand:V16HI 1 "register_operand" "x,x")
4197           (parallel [(const_int 0) (const_int 1)
4198                      (const_int 2) (const_int 3)
4199                      (const_int 4) (const_int 5)
4200                      (const_int 6) (const_int 7)])))]
4201   "TARGET_AVX"
4202   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4203   [(set_attr "type" "sselog")
4204    (set_attr "prefix_extra" "1")
4205    (set_attr "length_immediate" "1")
4206    (set_attr "memory" "none,store")
4207    (set_attr "prefix" "vex")
4208    (set_attr "mode" "V8SF")])
4209
4210 (define_insn "vec_extract_hi_v16hi"
4211   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4212         (vec_select:V8HI
4213           (match_operand:V16HI 1 "register_operand" "x,x")
4214           (parallel [(const_int 8) (const_int 9)
4215                      (const_int 10) (const_int 11)
4216                      (const_int 12) (const_int 13)
4217                      (const_int 14) (const_int 15)])))]
4218   "TARGET_AVX"
4219   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4220   [(set_attr "type" "sselog")
4221    (set_attr "prefix_extra" "1")
4222    (set_attr "length_immediate" "1")
4223    (set_attr "memory" "none,store")
4224    (set_attr "prefix" "vex")
4225    (set_attr "mode" "V8SF")])
4226
4227 (define_insn "vec_extract_lo_v32qi"
4228   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4229         (vec_select:V16QI
4230           (match_operand:V32QI 1 "register_operand" "x,x")
4231           (parallel [(const_int 0) (const_int 1)
4232                      (const_int 2) (const_int 3)
4233                      (const_int 4) (const_int 5)
4234                      (const_int 6) (const_int 7)
4235                      (const_int 8) (const_int 9)
4236                      (const_int 10) (const_int 11)
4237                      (const_int 12) (const_int 13)
4238                      (const_int 14) (const_int 15)])))]
4239   "TARGET_AVX"
4240   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4241   [(set_attr "type" "sselog")
4242    (set_attr "prefix_extra" "1")
4243    (set_attr "length_immediate" "1")
4244    (set_attr "memory" "none,store")
4245    (set_attr "prefix" "vex")
4246    (set_attr "mode" "V8SF")])
4247
4248 (define_insn "vec_extract_hi_v32qi"
4249   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4250         (vec_select:V16QI
4251           (match_operand:V32QI 1 "register_operand" "x,x")
4252           (parallel [(const_int 16) (const_int 17)
4253                      (const_int 18) (const_int 19)
4254                      (const_int 20) (const_int 21)
4255                      (const_int 22) (const_int 23)
4256                      (const_int 24) (const_int 25)
4257                      (const_int 26) (const_int 27)
4258                      (const_int 28) (const_int 29)
4259                      (const_int 30) (const_int 31)])))]
4260   "TARGET_AVX"
4261   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4262   [(set_attr "type" "sselog")
4263    (set_attr "prefix_extra" "1")
4264    (set_attr "length_immediate" "1")
4265    (set_attr "memory" "none,store")
4266    (set_attr "prefix" "vex")
4267    (set_attr "mode" "V8SF")])
4268
4269 (define_insn "*sse4_1_extractps"
4270   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
4271         (vec_select:SF
4272           (match_operand:V4SF 1 "register_operand" "x")
4273           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
4274   "TARGET_SSE4_1"
4275   "%vextractps\t{%2, %1, %0|%0, %1, %2}"
4276   [(set_attr "type" "sselog")
4277    (set_attr "prefix_data16" "1")
4278    (set_attr "prefix_extra" "1")
4279    (set_attr "length_immediate" "1")
4280    (set_attr "prefix" "maybe_vex")
4281    (set_attr "mode" "V4SF")])
4282
4283 (define_insn_and_split "*vec_extract_v4sf_mem"
4284   [(set (match_operand:SF 0 "register_operand" "=x*rf")
4285        (vec_select:SF
4286          (match_operand:V4SF 1 "memory_operand" "o")
4287          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
4288   ""
4289   "#"
4290   "reload_completed"
4291   [(const_int 0)]
4292 {
4293   int i = INTVAL (operands[2]);
4294
4295   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
4296   DONE;
4297 })
4298
4299 (define_expand "vec_extract<mode>"
4300   [(match_operand:<ssescalarmode> 0 "register_operand" "")
4301    (match_operand:SSEMODE 1 "register_operand" "")
4302    (match_operand 2 "const_int_operand" "")]
4303   "TARGET_SSE"
4304 {
4305   ix86_expand_vector_extract (false, operands[0], operands[1],
4306                               INTVAL (operands[2]));
4307   DONE;
4308 })
4309
4310 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4311 ;;
4312 ;; Parallel double-precision floating point element swizzling
4313 ;;
4314 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4315
4316 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4317 (define_insn "avx_unpckhpd256"
4318   [(set (match_operand:V4DF 0 "register_operand" "=x")
4319         (vec_select:V4DF
4320           (vec_concat:V8DF
4321             (match_operand:V4DF 1 "register_operand" "x")
4322             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4323           (parallel [(const_int 1) (const_int 5)
4324                      (const_int 3) (const_int 7)])))]
4325   "TARGET_AVX"
4326   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
4327   [(set_attr "type" "sselog")
4328    (set_attr "prefix" "vex")
4329    (set_attr "mode" "V4DF")])
4330
4331 (define_expand "vec_interleave_highv2df"
4332   [(set (match_operand:V2DF 0 "register_operand" "")
4333         (vec_select:V2DF
4334           (vec_concat:V4DF
4335             (match_operand:V2DF 1 "nonimmediate_operand" "")
4336             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4337           (parallel [(const_int 1)
4338                      (const_int 3)])))]
4339   "TARGET_SSE2"
4340 {
4341   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
4342     operands[2] = force_reg (V2DFmode, operands[2]);
4343 })
4344
4345 (define_insn "*avx_interleave_highv2df"
4346   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4347         (vec_select:V2DF
4348           (vec_concat:V4DF
4349             (match_operand:V2DF 1 "nonimmediate_operand" " x,o,o,x")
4350             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,x,0"))
4351           (parallel [(const_int 1)
4352                      (const_int 3)])))]
4353   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4354   "@
4355    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
4356    vmovddup\t{%H1, %0|%0, %H1}
4357    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
4358    vmovhpd\t{%1, %0|%0, %1}"
4359   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4360    (set_attr "prefix" "vex")
4361    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4362
4363 (define_insn "*sse3_interleave_highv2df"
4364   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4365         (vec_select:V2DF
4366           (vec_concat:V4DF
4367             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,o,x")
4368             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,0,0"))
4369           (parallel [(const_int 1)
4370                      (const_int 3)])))]
4371   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4372   "@
4373    unpckhpd\t{%2, %0|%0, %2}
4374    movddup\t{%H1, %0|%0, %H1}
4375    movlpd\t{%H1, %0|%0, %H1}
4376    movhpd\t{%1, %0|%0, %1}"
4377   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4378    (set_attr "prefix_data16" "*,*,1,1")
4379    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4380
4381 (define_insn "*sse2_interleave_highv2df"
4382   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
4383         (vec_select:V2DF
4384           (vec_concat:V4DF
4385             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
4386             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
4387           (parallel [(const_int 1)
4388                      (const_int 3)])))]
4389   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4390   "@
4391    unpckhpd\t{%2, %0|%0, %2}
4392    movlpd\t{%H1, %0|%0, %H1}
4393    movhpd\t{%1, %0|%0, %1}"
4394   [(set_attr "type" "sselog,ssemov,ssemov")
4395    (set_attr "prefix_data16" "*,1,1")
4396    (set_attr "mode" "V2DF,V1DF,V1DF")])
4397
4398 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4399 (define_expand "avx_movddup256"
4400   [(set (match_operand:V4DF 0 "register_operand" "")
4401         (vec_select:V4DF
4402           (vec_concat:V8DF
4403             (match_operand:V4DF 1 "nonimmediate_operand" "")
4404             (match_dup 1))
4405           (parallel [(const_int 0) (const_int 4)
4406                      (const_int 2) (const_int 6)])))]
4407   "TARGET_AVX"
4408   "")
4409
4410 (define_expand "avx_unpcklpd256"
4411   [(set (match_operand:V4DF 0 "register_operand" "")
4412         (vec_select:V4DF
4413           (vec_concat:V8DF
4414             (match_operand:V4DF 1 "register_operand" "")
4415             (match_operand:V4DF 2 "nonimmediate_operand" ""))
4416           (parallel [(const_int 0) (const_int 4)
4417                      (const_int 2) (const_int 6)])))]
4418   "TARGET_AVX"
4419   "")
4420
4421 (define_insn "*avx_unpcklpd256"
4422   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
4423         (vec_select:V4DF
4424           (vec_concat:V8DF
4425             (match_operand:V4DF 1 "nonimmediate_operand" "xm,x")
4426             (match_operand:V4DF 2 "nonimmediate_operand" " 1,xm"))
4427           (parallel [(const_int 0) (const_int 4)
4428                      (const_int 2) (const_int 6)])))]
4429   "TARGET_AVX
4430    && (!MEM_P (operands[1]) || rtx_equal_p (operands[1], operands[2]))"
4431   "@
4432    vmovddup\t{%1, %0|%0, %1}
4433    vunpcklpd\t{%2, %1, %0|%0, %1, %2}"
4434   [(set_attr "type" "sselog")
4435    (set_attr "prefix" "vex")
4436    (set_attr "mode" "V4DF")])
4437
4438 (define_expand "vec_interleave_lowv2df"
4439   [(set (match_operand:V2DF 0 "register_operand" "")
4440         (vec_select:V2DF
4441           (vec_concat:V4DF
4442             (match_operand:V2DF 1 "nonimmediate_operand" "")
4443             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4444           (parallel [(const_int 0)
4445                      (const_int 2)])))]
4446   "TARGET_SSE2"
4447 {
4448   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
4449     operands[1] = force_reg (V2DFmode, operands[1]);
4450 })
4451
4452 (define_insn "*avx_interleave_lowv2df"
4453   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4454         (vec_select:V2DF
4455           (vec_concat:V4DF
4456             (match_operand:V2DF 1 "nonimmediate_operand" " x,m,x,0")
4457             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4458           (parallel [(const_int 0)
4459                      (const_int 2)])))]
4460   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4461   "@
4462    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4463    vmovddup\t{%1, %0|%0, %1}
4464    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4465    vmovlpd\t{%2, %H0|%H0, %2}"
4466   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4467    (set_attr "prefix" "vex")
4468    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4469
4470 (define_insn "*sse3_interleave_lowv2df"
4471   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4472         (vec_select:V2DF
4473           (vec_concat:V4DF
4474             (match_operand:V2DF 1 "nonimmediate_operand" " 0,m,0,0")
4475             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4476           (parallel [(const_int 0)
4477                      (const_int 2)])))]
4478   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4479   "@
4480    unpcklpd\t{%2, %0|%0, %2}
4481    movddup\t{%1, %0|%0, %1}
4482    movhpd\t{%2, %0|%0, %2}
4483    movlpd\t{%2, %H0|%H0, %2}"
4484   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4485    (set_attr "prefix_data16" "*,*,1,1")
4486    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4487
4488 (define_insn "*sse2_interleave_lowv2df"
4489   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4490         (vec_select:V2DF
4491           (vec_concat:V4DF
4492             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
4493             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4494           (parallel [(const_int 0)
4495                      (const_int 2)])))]
4496   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4497   "@
4498    unpcklpd\t{%2, %0|%0, %2}
4499    movhpd\t{%2, %0|%0, %2}
4500    movlpd\t{%2, %H0|%H0, %2}"
4501   [(set_attr "type" "sselog,ssemov,ssemov")
4502    (set_attr "prefix_data16" "*,1,1")
4503    (set_attr "mode" "V2DF,V1DF,V1DF")])
4504
4505 (define_split
4506   [(set (match_operand:V2DF 0 "memory_operand" "")
4507         (vec_select:V2DF
4508           (vec_concat:V4DF
4509             (match_operand:V2DF 1 "register_operand" "")
4510             (match_dup 1))
4511           (parallel [(const_int 0)
4512                      (const_int 2)])))]
4513   "TARGET_SSE3 && reload_completed"
4514   [(const_int 0)]
4515 {
4516   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4517   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4518   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4519   DONE;
4520 })
4521
4522 (define_split
4523   [(set (match_operand:V2DF 0 "register_operand" "")
4524         (vec_select:V2DF
4525           (vec_concat:V4DF
4526             (match_operand:V2DF 1 "memory_operand" "")
4527             (match_dup 1))
4528           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "")
4529                      (match_operand:SI 3 "const_int_operand" "")])))]
4530   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
4531   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
4532 {
4533   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
4534 })
4535
4536 (define_expand "avx_shufpd256"
4537   [(match_operand:V4DF 0 "register_operand" "")
4538    (match_operand:V4DF 1 "register_operand" "")
4539    (match_operand:V4DF 2 "nonimmediate_operand" "")
4540    (match_operand:SI 3 "const_int_operand" "")]
4541   "TARGET_AVX"
4542 {
4543   int mask = INTVAL (operands[3]);
4544   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4545                                    GEN_INT (mask & 1),
4546                                    GEN_INT (mask & 2 ? 5 : 4),
4547                                    GEN_INT (mask & 4 ? 3 : 2),
4548                                    GEN_INT (mask & 8 ? 7 : 6)));
4549   DONE;
4550 })
4551
4552 (define_insn "avx_shufpd256_1"
4553   [(set (match_operand:V4DF 0 "register_operand" "=x")
4554         (vec_select:V4DF
4555           (vec_concat:V8DF
4556             (match_operand:V4DF 1 "register_operand" "x")
4557             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4558           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4559                      (match_operand 4 "const_4_to_5_operand" "")
4560                      (match_operand 5 "const_2_to_3_operand" "")
4561                      (match_operand 6 "const_6_to_7_operand" "")])))]
4562   "TARGET_AVX"
4563 {
4564   int mask;
4565   mask = INTVAL (operands[3]);
4566   mask |= (INTVAL (operands[4]) - 4) << 1;
4567   mask |= (INTVAL (operands[5]) - 2) << 2;
4568   mask |= (INTVAL (operands[6]) - 6) << 3;
4569   operands[3] = GEN_INT (mask);
4570
4571   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4572 }
4573   [(set_attr "type" "sselog")
4574    (set_attr "length_immediate" "1")
4575    (set_attr "prefix" "vex")
4576    (set_attr "mode" "V4DF")])
4577
4578 (define_expand "sse2_shufpd"
4579   [(match_operand:V2DF 0 "register_operand" "")
4580    (match_operand:V2DF 1 "register_operand" "")
4581    (match_operand:V2DF 2 "nonimmediate_operand" "")
4582    (match_operand:SI 3 "const_int_operand" "")]
4583   "TARGET_SSE2"
4584 {
4585   int mask = INTVAL (operands[3]);
4586   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4587                                 GEN_INT (mask & 1),
4588                                 GEN_INT (mask & 2 ? 3 : 2)));
4589   DONE;
4590 })
4591
4592 (define_expand "vec_extract_even<mode>"
4593   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4594    (match_operand:SSEMODE_EO 1 "register_operand" "")
4595    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4596   ""
4597 {
4598   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 0);
4599   DONE;
4600 })
4601
4602 (define_expand "vec_extract_odd<mode>"
4603   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4604    (match_operand:SSEMODE_EO 1 "register_operand" "")
4605    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4606   ""
4607 {
4608   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 1);
4609   DONE;
4610 })
4611
4612 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4613 (define_insn "*avx_interleave_highv2di"
4614   [(set (match_operand:V2DI 0 "register_operand" "=x")
4615         (vec_select:V2DI
4616           (vec_concat:V4DI
4617             (match_operand:V2DI 1 "register_operand" "x")
4618             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4619           (parallel [(const_int 1)
4620                      (const_int 3)])))]
4621   "TARGET_AVX"
4622   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4623   [(set_attr "type" "sselog")
4624    (set_attr "prefix" "vex")
4625    (set_attr "mode" "TI")])
4626
4627 (define_insn "vec_interleave_highv2di"
4628   [(set (match_operand:V2DI 0 "register_operand" "=x")
4629         (vec_select:V2DI
4630           (vec_concat:V4DI
4631             (match_operand:V2DI 1 "register_operand" "0")
4632             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4633           (parallel [(const_int 1)
4634                      (const_int 3)])))]
4635   "TARGET_SSE2"
4636   "punpckhqdq\t{%2, %0|%0, %2}"
4637   [(set_attr "type" "sselog")
4638    (set_attr "prefix_data16" "1")
4639    (set_attr "mode" "TI")])
4640
4641 (define_insn "*avx_interleave_lowv2di"
4642   [(set (match_operand:V2DI 0 "register_operand" "=x")
4643         (vec_select:V2DI
4644           (vec_concat:V4DI
4645             (match_operand:V2DI 1 "register_operand" "x")
4646             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4647           (parallel [(const_int 0)
4648                      (const_int 2)])))]
4649   "TARGET_AVX"
4650   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4651   [(set_attr "type" "sselog")
4652    (set_attr "prefix" "vex")
4653    (set_attr "mode" "TI")])
4654
4655 (define_insn "vec_interleave_lowv2di"
4656   [(set (match_operand:V2DI 0 "register_operand" "=x")
4657         (vec_select:V2DI
4658           (vec_concat:V4DI
4659             (match_operand:V2DI 1 "register_operand" "0")
4660             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4661           (parallel [(const_int 0)
4662                      (const_int 2)])))]
4663   "TARGET_SSE2"
4664   "punpcklqdq\t{%2, %0|%0, %2}"
4665   [(set_attr "type" "sselog")
4666    (set_attr "prefix_data16" "1")
4667    (set_attr "mode" "TI")])
4668
4669 (define_insn "*avx_shufpd_<mode>"
4670   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4671         (vec_select:SSEMODE2D
4672           (vec_concat:<ssedoublesizemode>
4673             (match_operand:SSEMODE2D 1 "register_operand" "x")
4674             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4675           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4676                      (match_operand 4 "const_2_to_3_operand" "")])))]
4677   "TARGET_AVX"
4678 {
4679   int mask;
4680   mask = INTVAL (operands[3]);
4681   mask |= (INTVAL (operands[4]) - 2) << 1;
4682   operands[3] = GEN_INT (mask);
4683
4684   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4685 }
4686   [(set_attr "type" "sselog")
4687    (set_attr "length_immediate" "1")
4688    (set_attr "prefix" "vex")
4689    (set_attr "mode" "V2DF")])
4690
4691 (define_insn "sse2_shufpd_<mode>"
4692   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4693         (vec_select:SSEMODE2D
4694           (vec_concat:<ssedoublesizemode>
4695             (match_operand:SSEMODE2D 1 "register_operand" "0")
4696             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4697           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4698                      (match_operand 4 "const_2_to_3_operand" "")])))]
4699   "TARGET_SSE2"
4700 {
4701   int mask;
4702   mask = INTVAL (operands[3]);
4703   mask |= (INTVAL (operands[4]) - 2) << 1;
4704   operands[3] = GEN_INT (mask);
4705
4706   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4707 }
4708   [(set_attr "type" "sselog")
4709    (set_attr "length_immediate" "1")
4710    (set_attr "mode" "V2DF")])
4711
4712 ;; Avoid combining registers from different units in a single alternative,
4713 ;; see comment above inline_secondary_memory_needed function in i386.c
4714 (define_insn "*avx_storehpd"
4715   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4716         (vec_select:DF
4717           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,o,o,o")
4718           (parallel [(const_int 1)])))]
4719   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4720   "@
4721    vmovhpd\t{%1, %0|%0, %1}
4722    vunpckhpd\t{%1, %1, %0|%0, %1, %1}
4723    #
4724    #
4725    #"
4726   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4727    (set_attr "prefix" "vex")
4728    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4729
4730 (define_insn "sse2_storehpd"
4731   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4732         (vec_select:DF
4733           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o,o,o")
4734           (parallel [(const_int 1)])))]
4735   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4736   "@
4737    movhpd\t{%1, %0|%0, %1}
4738    unpckhpd\t%0, %0
4739    #
4740    #
4741    #"
4742   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4743    (set_attr "prefix_data16" "1,*,*,*,*")
4744    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4745
4746 (define_split
4747   [(set (match_operand:DF 0 "register_operand" "")
4748         (vec_select:DF
4749           (match_operand:V2DF 1 "memory_operand" "")
4750           (parallel [(const_int 1)])))]
4751   "TARGET_SSE2 && reload_completed"
4752   [(set (match_dup 0) (match_dup 1))]
4753 {
4754   operands[1] = adjust_address (operands[1], DFmode, 8);
4755 })
4756
4757 ;; Avoid combining registers from different units in a single alternative,
4758 ;; see comment above inline_secondary_memory_needed function in i386.c
4759 (define_insn "sse2_storelpd"
4760   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4761         (vec_select:DF
4762           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4763           (parallel [(const_int 0)])))]
4764   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4765   "@
4766    %vmovlpd\t{%1, %0|%0, %1}
4767    #
4768    #
4769    #
4770    #"
4771   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4772    (set_attr "prefix_data16" "1,*,*,*,*")
4773    (set_attr "prefix" "maybe_vex")
4774    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4775
4776 (define_split
4777   [(set (match_operand:DF 0 "register_operand" "")
4778         (vec_select:DF
4779           (match_operand:V2DF 1 "nonimmediate_operand" "")
4780           (parallel [(const_int 0)])))]
4781   "TARGET_SSE2 && reload_completed"
4782   [(const_int 0)]
4783 {
4784   rtx op1 = operands[1];
4785   if (REG_P (op1))
4786     op1 = gen_rtx_REG (DFmode, REGNO (op1));
4787   else
4788     op1 = gen_lowpart (DFmode, op1);
4789   emit_move_insn (operands[0], op1);
4790   DONE;
4791 })
4792
4793 (define_expand "sse2_loadhpd_exp"
4794   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4795         (vec_concat:V2DF
4796           (vec_select:DF
4797             (match_operand:V2DF 1 "nonimmediate_operand" "")
4798             (parallel [(const_int 0)]))
4799           (match_operand:DF 2 "nonimmediate_operand" "")))]
4800   "TARGET_SSE2"
4801   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4802
4803 ;; Avoid combining registers from different units in a single alternative,
4804 ;; see comment above inline_secondary_memory_needed function in i386.c
4805 (define_insn "*avx_loadhpd"
4806   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o,o,o")
4807         (vec_concat:V2DF
4808           (vec_select:DF
4809             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,0,0")
4810             (parallel [(const_int 0)]))
4811           (match_operand:DF 2 "nonimmediate_operand"     " m,x,x,*f,r")))]
4812   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4813   "@
4814    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4815    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4816    #
4817    #
4818    #"
4819   [(set_attr "type" "ssemov,sselog,ssemov,fmov,imov")
4820    (set_attr "prefix" "vex")
4821    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4822
4823 (define_insn "sse2_loadhpd"
4824   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
4825         (vec_concat:V2DF
4826           (vec_select:DF
4827             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0,0,0")
4828             (parallel [(const_int 0)]))
4829           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x,*f,r")))]
4830   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4831   "@
4832    movhpd\t{%2, %0|%0, %2}
4833    unpcklpd\t{%2, %0|%0, %2}
4834    shufpd\t{$1, %1, %0|%0, %1, 1}
4835    #
4836    #
4837    #"
4838   [(set_attr "type" "ssemov,sselog,sselog,ssemov,fmov,imov")
4839    (set_attr "prefix_data16" "1,*,*,*,*,*")
4840    (set_attr "length_immediate" "*,*,1,*,*,*")
4841    (set_attr "mode" "V1DF,V2DF,V2DF,DF,DF,DF")])
4842
4843 (define_split
4844   [(set (match_operand:V2DF 0 "memory_operand" "")
4845         (vec_concat:V2DF
4846           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
4847           (match_operand:DF 1 "register_operand" "")))]
4848   "TARGET_SSE2 && reload_completed"
4849   [(set (match_dup 0) (match_dup 1))]
4850 {
4851   operands[0] = adjust_address (operands[0], DFmode, 8);
4852 })
4853
4854 (define_expand "sse2_loadlpd_exp"
4855   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4856         (vec_concat:V2DF
4857           (match_operand:DF 2 "nonimmediate_operand" "")
4858           (vec_select:DF
4859             (match_operand:V2DF 1 "nonimmediate_operand" "")
4860             (parallel [(const_int 1)]))))]
4861   "TARGET_SSE2"
4862   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4863
4864 ;; Avoid combining registers from different units in a single alternative,
4865 ;; see comment above inline_secondary_memory_needed function in i386.c
4866 (define_insn "*avx_loadlpd"
4867   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,m,m,m")
4868         (vec_concat:V2DF
4869           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,x,x,*f,r")
4870           (vec_select:DF
4871             (match_operand:V2DF 1 "vector_move_operand" " C,x,x,o,0,0,0")
4872             (parallel [(const_int 1)]))))]
4873   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4874   "@
4875    vmovsd\t{%2, %0|%0, %2}
4876    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4877    vmovsd\t{%2, %1, %0|%0, %1, %2}
4878    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
4879    #
4880    #
4881    #"
4882   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov,fmov,imov")
4883    (set_attr "prefix" "vex")
4884    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
4885
4886 (define_insn "sse2_loadlpd"
4887   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
4888         (vec_concat:V2DF
4889           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x,*f,r")
4890           (vec_select:DF
4891             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0,0,0")
4892             (parallel [(const_int 1)]))))]
4893   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4894   "@
4895    movsd\t{%2, %0|%0, %2}
4896    movlpd\t{%2, %0|%0, %2}
4897    movsd\t{%2, %0|%0, %2}
4898    shufpd\t{$2, %2, %0|%0, %2, 2}
4899    movhpd\t{%H1, %0|%0, %H1}
4900    #
4901    #
4902    #"
4903   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,fmov,imov")
4904    (set_attr "prefix_data16" "*,1,*,*,1,*,*,*")
4905    (set_attr "length_immediate" "*,*,*,1,*,*,*,*")
4906    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF,DF,DF")])
4907
4908 (define_split
4909   [(set (match_operand:V2DF 0 "memory_operand" "")
4910         (vec_concat:V2DF
4911           (match_operand:DF 1 "register_operand" "")
4912           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
4913   "TARGET_SSE2 && reload_completed"
4914   [(set (match_dup 0) (match_dup 1))]
4915 {
4916   operands[0] = adjust_address (operands[0], DFmode, 8);
4917 })
4918
4919 ;; Not sure these two are ever used, but it doesn't hurt to have
4920 ;; them. -aoliva
4921 (define_insn "*vec_extractv2df_1_sse"
4922   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4923         (vec_select:DF
4924           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4925           (parallel [(const_int 1)])))]
4926   "!TARGET_SSE2 && TARGET_SSE
4927    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4928   "@
4929    movhps\t{%1, %0|%0, %1}
4930    movhlps\t{%1, %0|%0, %1}
4931    movlps\t{%H1, %0|%0, %H1}"
4932   [(set_attr "type" "ssemov")
4933    (set_attr "mode" "V2SF,V4SF,V2SF")])
4934
4935 (define_insn "*vec_extractv2df_0_sse"
4936   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4937         (vec_select:DF
4938           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
4939           (parallel [(const_int 0)])))]
4940   "!TARGET_SSE2 && TARGET_SSE
4941    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4942   "@
4943    movlps\t{%1, %0|%0, %1}
4944    movaps\t{%1, %0|%0, %1}
4945    movlps\t{%1, %0|%0, %1}"
4946   [(set_attr "type" "ssemov")
4947    (set_attr "mode" "V2SF,V4SF,V2SF")])
4948
4949 (define_insn "*avx_movsd"
4950   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,o")
4951         (vec_merge:V2DF
4952           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,x,0")
4953           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,o,x")
4954           (const_int 1)))]
4955   "TARGET_AVX"
4956   "@
4957    vmovsd\t{%2, %1, %0|%0, %1, %2}
4958    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4959    vmovlpd\t{%2, %0|%0, %2}
4960    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
4961    vmovhps\t{%1, %H0|%H0, %1}"
4962   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov")
4963    (set_attr "prefix" "vex")
4964    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF")])
4965
4966 (define_insn "sse2_movsd"
4967   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
4968         (vec_merge:V2DF
4969           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
4970           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
4971           (const_int 1)))]
4972   "TARGET_SSE2"
4973   "@
4974    movsd\t{%2, %0|%0, %2}
4975    movlpd\t{%2, %0|%0, %2}
4976    movlpd\t{%2, %0|%0, %2}
4977    shufpd\t{$2, %2, %0|%0, %2, 2}
4978    movhps\t{%H1, %0|%0, %H1}
4979    movhps\t{%1, %H0|%H0, %1}"
4980   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
4981    (set_attr "prefix_data16" "*,1,1,*,*,*")
4982    (set_attr "length_immediate" "*,*,*,1,*,*")
4983    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
4984
4985 (define_insn "*vec_dupv2df_sse3"
4986   [(set (match_operand:V2DF 0 "register_operand" "=x")
4987         (vec_duplicate:V2DF
4988           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
4989   "TARGET_SSE3"
4990   "%vmovddup\t{%1, %0|%0, %1}"
4991   [(set_attr "type" "sselog1")
4992    (set_attr "prefix" "maybe_vex")
4993    (set_attr "mode" "DF")])
4994
4995 (define_insn "vec_dupv2df"
4996   [(set (match_operand:V2DF 0 "register_operand" "=x")
4997         (vec_duplicate:V2DF
4998           (match_operand:DF 1 "register_operand" "0")))]
4999   "TARGET_SSE2"
5000   "unpcklpd\t%0, %0"
5001   [(set_attr "type" "sselog1")
5002    (set_attr "mode" "V2DF")])
5003
5004 (define_insn "*vec_concatv2df_sse3"
5005   [(set (match_operand:V2DF 0 "register_operand" "=x")
5006         (vec_concat:V2DF
5007           (match_operand:DF 1 "nonimmediate_operand" "xm")
5008           (match_dup 1)))]
5009   "TARGET_SSE3"
5010   "%vmovddup\t{%1, %0|%0, %1}"
5011   [(set_attr "type" "sselog1")
5012    (set_attr "prefix" "maybe_vex")
5013    (set_attr "mode" "DF")])
5014
5015 (define_insn "*vec_concatv2df_avx"
5016   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x")
5017         (vec_concat:V2DF
5018           (match_operand:DF 1 "nonimmediate_operand" " x,x,m")
5019           (match_operand:DF 2 "vector_move_operand"  " x,m,C")))]
5020   "TARGET_AVX"
5021   "@
5022    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
5023    vmovhpd\t{%2, %1, %0|%0, %1, %2}
5024    vmovsd\t{%1, %0|%0, %1}"
5025   [(set_attr "type" "ssemov")
5026    (set_attr "prefix" "vex")
5027    (set_attr "mode" "DF,V1DF,DF")])
5028
5029 (define_insn "*vec_concatv2df"
5030   [(set (match_operand:V2DF 0 "register_operand"     "=Y2,Y2,Y2,x,x")
5031         (vec_concat:V2DF
5032           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
5033           (match_operand:DF 2 "vector_move_operand"  " Y2,m ,C ,x,m")))]
5034   "TARGET_SSE"
5035   "@
5036    unpcklpd\t{%2, %0|%0, %2}
5037    movhpd\t{%2, %0|%0, %2}
5038    movsd\t{%1, %0|%0, %1}
5039    movlhps\t{%2, %0|%0, %2}
5040    movhps\t{%2, %0|%0, %2}"
5041   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
5042    (set_attr "prefix_data16" "*,1,*,*,*")
5043    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
5044
5045 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5046 ;;
5047 ;; Parallel integral arithmetic
5048 ;;
5049 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5050
5051 (define_expand "neg<mode>2"
5052   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5053         (minus:SSEMODEI
5054           (match_dup 2)
5055           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
5056   "TARGET_SSE2"
5057   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
5058
5059 (define_expand "<plusminus_insn><mode>3"
5060   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5061         (plusminus:SSEMODEI
5062           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
5063           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
5064   "TARGET_SSE2"
5065   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5066
5067 (define_insn "*avx_<plusminus_insn><mode>3"
5068   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5069         (plusminus:SSEMODEI
5070           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>x")
5071           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5072   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5073   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5074   [(set_attr "type" "sseiadd")
5075    (set_attr "prefix" "vex")
5076    (set_attr "mode" "TI")])
5077
5078 (define_insn "*<plusminus_insn><mode>3"
5079   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5080         (plusminus:SSEMODEI
5081           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>0")
5082           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5083   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5084   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5085   [(set_attr "type" "sseiadd")
5086    (set_attr "prefix_data16" "1")
5087    (set_attr "mode" "TI")])
5088
5089 (define_expand "sse2_<plusminus_insn><mode>3"
5090   [(set (match_operand:SSEMODE12 0 "register_operand" "")
5091         (sat_plusminus:SSEMODE12
5092           (match_operand:SSEMODE12 1 "nonimmediate_operand" "")
5093           (match_operand:SSEMODE12 2 "nonimmediate_operand" "")))]
5094   "TARGET_SSE2"
5095   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5096
5097 (define_insn "*avx_<plusminus_insn><mode>3"
5098   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5099         (sat_plusminus:SSEMODE12
5100           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>x")
5101           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5102   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5103   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5104   [(set_attr "type" "sseiadd")
5105    (set_attr "prefix" "vex")
5106    (set_attr "mode" "TI")])
5107
5108 (define_insn "*sse2_<plusminus_insn><mode>3"
5109   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5110         (sat_plusminus:SSEMODE12
5111           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>0")
5112           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5113   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5114   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5115   [(set_attr "type" "sseiadd")
5116    (set_attr "prefix_data16" "1")
5117    (set_attr "mode" "TI")])
5118
5119 (define_insn_and_split "mulv16qi3"
5120   [(set (match_operand:V16QI 0 "register_operand" "")
5121         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
5122                     (match_operand:V16QI 2 "register_operand" "")))]
5123   "TARGET_SSE2
5124    && can_create_pseudo_p ()"
5125   "#"
5126   "&& 1"
5127   [(const_int 0)]
5128 {
5129   rtx t[6];
5130   int i;
5131
5132   for (i = 0; i < 6; ++i)
5133     t[i] = gen_reg_rtx (V16QImode);
5134
5135   /* Unpack data such that we've got a source byte in each low byte of
5136      each word.  We don't care what goes into the high byte of each word.
5137      Rather than trying to get zero in there, most convenient is to let
5138      it be a copy of the low byte.  */
5139   emit_insn (gen_vec_interleave_highv16qi (t[0], operands[1], operands[1]));
5140   emit_insn (gen_vec_interleave_highv16qi (t[1], operands[2], operands[2]));
5141   emit_insn (gen_vec_interleave_lowv16qi (t[2], operands[1], operands[1]));
5142   emit_insn (gen_vec_interleave_lowv16qi (t[3], operands[2], operands[2]));
5143
5144   /* Multiply words.  The end-of-line annotations here give a picture of what
5145      the output of that instruction looks like.  Dot means don't care; the
5146      letters are the bytes of the result with A being the most significant.  */
5147   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
5148                            gen_lowpart (V8HImode, t[0]),
5149                            gen_lowpart (V8HImode, t[1])));
5150   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
5151                            gen_lowpart (V8HImode, t[2]),
5152                            gen_lowpart (V8HImode, t[3])));
5153
5154   /* Extract the even bytes and merge them back together.  */
5155   ix86_expand_vec_extract_even_odd (operands[0], t[5], t[4], 0);
5156   DONE;
5157 })
5158
5159 (define_expand "mulv8hi3"
5160   [(set (match_operand:V8HI 0 "register_operand" "")
5161         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
5162                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5163   "TARGET_SSE2"
5164   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5165
5166 (define_insn "*avx_mulv8hi3"
5167   [(set (match_operand:V8HI 0 "register_operand" "=x")
5168         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5169                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5170   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5171   "vpmullw\t{%2, %1, %0|%0, %1, %2}"
5172   [(set_attr "type" "sseimul")
5173    (set_attr "prefix" "vex")
5174    (set_attr "mode" "TI")])
5175
5176 (define_insn "*mulv8hi3"
5177   [(set (match_operand:V8HI 0 "register_operand" "=x")
5178         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5179                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5180   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5181   "pmullw\t{%2, %0|%0, %2}"
5182   [(set_attr "type" "sseimul")
5183    (set_attr "prefix_data16" "1")
5184    (set_attr "mode" "TI")])
5185
5186 (define_expand "smulv8hi3_highpart"
5187   [(set (match_operand:V8HI 0 "register_operand" "")
5188         (truncate:V8HI
5189           (lshiftrt:V8SI
5190             (mult:V8SI
5191               (sign_extend:V8SI
5192                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
5193               (sign_extend:V8SI
5194                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
5195             (const_int 16))))]
5196   "TARGET_SSE2"
5197   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5198
5199 (define_insn "*avxv8hi3_highpart"
5200   [(set (match_operand:V8HI 0 "register_operand" "=x")
5201         (truncate:V8HI
5202           (lshiftrt:V8SI
5203             (mult:V8SI
5204               (sign_extend:V8SI
5205                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
5206               (sign_extend:V8SI
5207                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5208             (const_int 16))))]
5209   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5210   "vpmulhw\t{%2, %1, %0|%0, %1, %2}"
5211   [(set_attr "type" "sseimul")
5212    (set_attr "prefix" "vex")
5213    (set_attr "mode" "TI")])
5214
5215 (define_insn "*smulv8hi3_highpart"
5216   [(set (match_operand:V8HI 0 "register_operand" "=x")
5217         (truncate:V8HI
5218           (lshiftrt:V8SI
5219             (mult:V8SI
5220               (sign_extend:V8SI
5221                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5222               (sign_extend:V8SI
5223                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5224             (const_int 16))))]
5225   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5226   "pmulhw\t{%2, %0|%0, %2}"
5227   [(set_attr "type" "sseimul")
5228    (set_attr "prefix_data16" "1")
5229    (set_attr "mode" "TI")])
5230
5231 (define_expand "umulv8hi3_highpart"
5232   [(set (match_operand:V8HI 0 "register_operand" "")
5233         (truncate:V8HI
5234           (lshiftrt:V8SI
5235             (mult:V8SI
5236               (zero_extend:V8SI
5237                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
5238               (zero_extend:V8SI
5239                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
5240             (const_int 16))))]
5241   "TARGET_SSE2"
5242   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5243
5244 (define_insn "*avx_umulv8hi3_highpart"
5245   [(set (match_operand:V8HI 0 "register_operand" "=x")
5246         (truncate:V8HI
5247           (lshiftrt:V8SI
5248             (mult:V8SI
5249               (zero_extend:V8SI
5250                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
5251               (zero_extend:V8SI
5252                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5253             (const_int 16))))]
5254   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5255   "vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
5256   [(set_attr "type" "sseimul")
5257    (set_attr "prefix" "vex")
5258    (set_attr "mode" "TI")])
5259
5260 (define_insn "*umulv8hi3_highpart"
5261   [(set (match_operand:V8HI 0 "register_operand" "=x")
5262         (truncate:V8HI
5263           (lshiftrt:V8SI
5264             (mult:V8SI
5265               (zero_extend:V8SI
5266                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5267               (zero_extend:V8SI
5268                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5269             (const_int 16))))]
5270   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5271   "pmulhuw\t{%2, %0|%0, %2}"
5272   [(set_attr "type" "sseimul")
5273    (set_attr "prefix_data16" "1")
5274    (set_attr "mode" "TI")])
5275
5276 (define_expand "sse2_umulv2siv2di3"
5277   [(set (match_operand:V2DI 0 "register_operand" "")
5278         (mult:V2DI
5279           (zero_extend:V2DI
5280             (vec_select:V2SI
5281               (match_operand:V4SI 1 "nonimmediate_operand" "")
5282               (parallel [(const_int 0) (const_int 2)])))
5283           (zero_extend:V2DI
5284             (vec_select:V2SI
5285               (match_operand:V4SI 2 "nonimmediate_operand" "")
5286               (parallel [(const_int 0) (const_int 2)])))))]
5287   "TARGET_SSE2"
5288   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5289
5290 (define_insn "*avx_umulv2siv2di3"
5291   [(set (match_operand:V2DI 0 "register_operand" "=x")
5292         (mult:V2DI
5293           (zero_extend:V2DI
5294             (vec_select:V2SI
5295               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5296               (parallel [(const_int 0) (const_int 2)])))
5297           (zero_extend:V2DI
5298             (vec_select:V2SI
5299               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5300               (parallel [(const_int 0) (const_int 2)])))))]
5301   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5302   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5303   [(set_attr "type" "sseimul")
5304    (set_attr "prefix" "vex")
5305    (set_attr "mode" "TI")])
5306
5307 (define_insn "*sse2_umulv2siv2di3"
5308   [(set (match_operand:V2DI 0 "register_operand" "=x")
5309         (mult:V2DI
5310           (zero_extend:V2DI
5311             (vec_select:V2SI
5312               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5313               (parallel [(const_int 0) (const_int 2)])))
5314           (zero_extend:V2DI
5315             (vec_select:V2SI
5316               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5317               (parallel [(const_int 0) (const_int 2)])))))]
5318   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5319   "pmuludq\t{%2, %0|%0, %2}"
5320   [(set_attr "type" "sseimul")
5321    (set_attr "prefix_data16" "1")
5322    (set_attr "mode" "TI")])
5323
5324 (define_expand "sse4_1_mulv2siv2di3"
5325   [(set (match_operand:V2DI 0 "register_operand" "")
5326         (mult:V2DI
5327           (sign_extend:V2DI
5328             (vec_select:V2SI
5329               (match_operand:V4SI 1 "nonimmediate_operand" "")
5330               (parallel [(const_int 0) (const_int 2)])))
5331           (sign_extend:V2DI
5332             (vec_select:V2SI
5333               (match_operand:V4SI 2 "nonimmediate_operand" "")
5334               (parallel [(const_int 0) (const_int 2)])))))]
5335   "TARGET_SSE4_1"
5336   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5337
5338 (define_insn "*avx_mulv2siv2di3"
5339   [(set (match_operand:V2DI 0 "register_operand" "=x")
5340         (mult:V2DI
5341           (sign_extend:V2DI
5342             (vec_select:V2SI
5343               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5344               (parallel [(const_int 0) (const_int 2)])))
5345           (sign_extend:V2DI
5346             (vec_select:V2SI
5347               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5348               (parallel [(const_int 0) (const_int 2)])))))]
5349   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5350   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5351   [(set_attr "type" "sseimul")
5352    (set_attr "prefix_extra" "1")
5353    (set_attr "prefix" "vex")
5354    (set_attr "mode" "TI")])
5355
5356 (define_insn "*sse4_1_mulv2siv2di3"
5357   [(set (match_operand:V2DI 0 "register_operand" "=x")
5358         (mult:V2DI
5359           (sign_extend:V2DI
5360             (vec_select:V2SI
5361               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5362               (parallel [(const_int 0) (const_int 2)])))
5363           (sign_extend:V2DI
5364             (vec_select:V2SI
5365               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5366               (parallel [(const_int 0) (const_int 2)])))))]
5367   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5368   "pmuldq\t{%2, %0|%0, %2}"
5369   [(set_attr "type" "sseimul")
5370    (set_attr "prefix_extra" "1")
5371    (set_attr "mode" "TI")])
5372
5373 (define_expand "sse2_pmaddwd"
5374   [(set (match_operand:V4SI 0 "register_operand" "")
5375         (plus:V4SI
5376           (mult:V4SI
5377             (sign_extend:V4SI
5378               (vec_select:V4HI
5379                 (match_operand:V8HI 1 "nonimmediate_operand" "")
5380                 (parallel [(const_int 0)
5381                            (const_int 2)
5382                            (const_int 4)
5383                            (const_int 6)])))
5384             (sign_extend:V4SI
5385               (vec_select:V4HI
5386                 (match_operand:V8HI 2 "nonimmediate_operand" "")
5387                 (parallel [(const_int 0)
5388                            (const_int 2)
5389                            (const_int 4)
5390                            (const_int 6)]))))
5391           (mult:V4SI
5392             (sign_extend:V4SI
5393               (vec_select:V4HI (match_dup 1)
5394                 (parallel [(const_int 1)
5395                            (const_int 3)
5396                            (const_int 5)
5397                            (const_int 7)])))
5398             (sign_extend:V4SI
5399               (vec_select:V4HI (match_dup 2)
5400                 (parallel [(const_int 1)
5401                            (const_int 3)
5402                            (const_int 5)
5403                            (const_int 7)]))))))]
5404   "TARGET_SSE2"
5405   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5406
5407 (define_insn "*avx_pmaddwd"
5408   [(set (match_operand:V4SI 0 "register_operand" "=x")
5409         (plus:V4SI
5410           (mult:V4SI
5411             (sign_extend:V4SI
5412               (vec_select:V4HI
5413                 (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5414                 (parallel [(const_int 0)
5415                            (const_int 2)
5416                            (const_int 4)
5417                            (const_int 6)])))
5418             (sign_extend:V4SI
5419               (vec_select:V4HI
5420                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5421                 (parallel [(const_int 0)
5422                            (const_int 2)
5423                            (const_int 4)
5424                            (const_int 6)]))))
5425           (mult:V4SI
5426             (sign_extend:V4SI
5427               (vec_select:V4HI (match_dup 1)
5428                 (parallel [(const_int 1)
5429                            (const_int 3)
5430                            (const_int 5)
5431                            (const_int 7)])))
5432             (sign_extend:V4SI
5433               (vec_select:V4HI (match_dup 2)
5434                 (parallel [(const_int 1)
5435                            (const_int 3)
5436                            (const_int 5)
5437                            (const_int 7)]))))))]
5438   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5439   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5440   [(set_attr "type" "sseiadd")
5441    (set_attr "prefix" "vex")
5442    (set_attr "mode" "TI")])
5443
5444 (define_insn "*sse2_pmaddwd"
5445   [(set (match_operand:V4SI 0 "register_operand" "=x")
5446         (plus:V4SI
5447           (mult:V4SI
5448             (sign_extend:V4SI
5449               (vec_select:V4HI
5450                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5451                 (parallel [(const_int 0)
5452                            (const_int 2)
5453                            (const_int 4)
5454                            (const_int 6)])))
5455             (sign_extend:V4SI
5456               (vec_select:V4HI
5457                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5458                 (parallel [(const_int 0)
5459                            (const_int 2)
5460                            (const_int 4)
5461                            (const_int 6)]))))
5462           (mult:V4SI
5463             (sign_extend:V4SI
5464               (vec_select:V4HI (match_dup 1)
5465                 (parallel [(const_int 1)
5466                            (const_int 3)
5467                            (const_int 5)
5468                            (const_int 7)])))
5469             (sign_extend:V4SI
5470               (vec_select:V4HI (match_dup 2)
5471                 (parallel [(const_int 1)
5472                            (const_int 3)
5473                            (const_int 5)
5474                            (const_int 7)]))))))]
5475   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5476   "pmaddwd\t{%2, %0|%0, %2}"
5477   [(set_attr "type" "sseiadd")
5478    (set_attr "atom_unit" "simul")
5479    (set_attr "prefix_data16" "1")
5480    (set_attr "mode" "TI")])
5481
5482 (define_expand "mulv4si3"
5483   [(set (match_operand:V4SI 0 "register_operand" "")
5484         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5485                    (match_operand:V4SI 2 "register_operand" "")))]
5486   "TARGET_SSE2"
5487 {
5488   if (TARGET_SSE4_1 || TARGET_AVX)
5489     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
5490 })
5491
5492 (define_insn "*avx_mulv4si3"
5493   [(set (match_operand:V4SI 0 "register_operand" "=x")
5494         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5495                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5496   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5497   "vpmulld\t{%2, %1, %0|%0, %1, %2}"
5498   [(set_attr "type" "sseimul")
5499    (set_attr "prefix_extra" "1")
5500    (set_attr "prefix" "vex")
5501    (set_attr "mode" "TI")])
5502
5503 (define_insn "*sse4_1_mulv4si3"
5504   [(set (match_operand:V4SI 0 "register_operand" "=x")
5505         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5506                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5507   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5508   "pmulld\t{%2, %0|%0, %2}"
5509   [(set_attr "type" "sseimul")
5510    (set_attr "prefix_extra" "1")
5511    (set_attr "mode" "TI")])
5512
5513 (define_insn_and_split "*sse2_mulv4si3"
5514   [(set (match_operand:V4SI 0 "register_operand" "")
5515         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5516                    (match_operand:V4SI 2 "register_operand" "")))]
5517   "TARGET_SSE2 && !TARGET_SSE4_1 && !TARGET_AVX
5518    && can_create_pseudo_p ()"
5519   "#"
5520   "&& 1"
5521   [(const_int 0)]
5522 {
5523   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5524   rtx op0, op1, op2;
5525
5526   op0 = operands[0];
5527   op1 = operands[1];
5528   op2 = operands[2];
5529   t1 = gen_reg_rtx (V4SImode);
5530   t2 = gen_reg_rtx (V4SImode);
5531   t3 = gen_reg_rtx (V4SImode);
5532   t4 = gen_reg_rtx (V4SImode);
5533   t5 = gen_reg_rtx (V4SImode);
5534   t6 = gen_reg_rtx (V4SImode);
5535   thirtytwo = GEN_INT (32);
5536
5537   /* Multiply elements 2 and 0.  */
5538   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
5539                                      op1, op2));
5540
5541   /* Shift both input vectors down one element, so that elements 3
5542      and 1 are now in the slots for elements 2 and 0.  For K8, at
5543      least, this is faster than using a shuffle.  */
5544   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5545                                  gen_lowpart (V1TImode, op1),
5546                                  thirtytwo));
5547   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5548                                  gen_lowpart (V1TImode, op2),
5549                                  thirtytwo));
5550   /* Multiply elements 3 and 1.  */
5551   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
5552                                      t2, t3));
5553
5554   /* Move the results in element 2 down to element 1; we don't care
5555      what goes in elements 2 and 3.  */
5556   emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
5557                                 const0_rtx, const0_rtx));
5558   emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
5559                                 const0_rtx, const0_rtx));
5560
5561   /* Merge the parts back together.  */
5562   emit_insn (gen_vec_interleave_lowv4si (op0, t5, t6));
5563   DONE;
5564 })
5565
5566 (define_insn_and_split "mulv2di3"
5567   [(set (match_operand:V2DI 0 "register_operand" "")
5568         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
5569                    (match_operand:V2DI 2 "register_operand" "")))]
5570   "TARGET_SSE2
5571    && can_create_pseudo_p ()"
5572   "#"
5573   "&& 1"
5574   [(const_int 0)]
5575 {
5576   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5577   rtx op0, op1, op2;
5578
5579   op0 = operands[0];
5580   op1 = operands[1];
5581   op2 = operands[2];
5582
5583   if (TARGET_XOP)
5584     {
5585       /* op1: A,B,C,D, op2: E,F,G,H */
5586       op1 = gen_lowpart (V4SImode, op1);
5587       op2 = gen_lowpart (V4SImode, op2);
5588
5589       t1 = gen_reg_rtx (V4SImode);
5590       t2 = gen_reg_rtx (V4SImode);
5591       t3 = gen_reg_rtx (V2DImode);
5592       t4 = gen_reg_rtx (V2DImode);
5593
5594       /* t1: B,A,D,C */
5595       emit_insn (gen_sse2_pshufd_1 (t1, op1,
5596                                     GEN_INT (1),
5597                                     GEN_INT (0),
5598                                     GEN_INT (3),
5599                                     GEN_INT (2)));
5600
5601       /* t2: (B*E),(A*F),(D*G),(C*H) */
5602       emit_insn (gen_mulv4si3 (t2, t1, op2));
5603
5604       /* t4: (B*E)+(A*F), (D*G)+(C*H) */
5605       emit_insn (gen_xop_phadddq (t3, t2));
5606
5607       /* t5: ((B*E)+(A*F))<<32, ((D*G)+(C*H))<<32 */
5608       emit_insn (gen_ashlv2di3 (t4, t3, GEN_INT (32)));
5609
5610       /* op0: (((B*E)+(A*F))<<32)+(B*F), (((D*G)+(C*H))<<32)+(D*H) */
5611       emit_insn (gen_xop_pmacsdql (op0, op1, op2, t4));
5612     }
5613   else
5614     {
5615       t1 = gen_reg_rtx (V2DImode);
5616       t2 = gen_reg_rtx (V2DImode);
5617       t3 = gen_reg_rtx (V2DImode);
5618       t4 = gen_reg_rtx (V2DImode);
5619       t5 = gen_reg_rtx (V2DImode);
5620       t6 = gen_reg_rtx (V2DImode);
5621       thirtytwo = GEN_INT (32);
5622
5623       /* Multiply low parts.  */
5624       emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
5625                                          gen_lowpart (V4SImode, op2)));
5626
5627       /* Shift input vectors left 32 bits so we can multiply high parts.  */
5628       emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
5629       emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
5630
5631       /* Multiply high parts by low parts.  */
5632       emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
5633                                          gen_lowpart (V4SImode, t3)));
5634       emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
5635                                          gen_lowpart (V4SImode, t2)));
5636
5637       /* Shift them back.  */
5638       emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
5639       emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
5640
5641       /* Add the three parts together.  */
5642       emit_insn (gen_addv2di3 (t6, t1, t4));
5643       emit_insn (gen_addv2di3 (op0, t6, t5));
5644     }
5645   DONE;
5646 })
5647
5648 (define_expand "vec_widen_smult_hi_v8hi"
5649   [(match_operand:V4SI 0 "register_operand" "")
5650    (match_operand:V8HI 1 "register_operand" "")
5651    (match_operand:V8HI 2 "register_operand" "")]
5652   "TARGET_SSE2"
5653 {
5654   rtx op1, op2, t1, t2, dest;
5655
5656   op1 = operands[1];
5657   op2 = operands[2];
5658   t1 = gen_reg_rtx (V8HImode);
5659   t2 = gen_reg_rtx (V8HImode);
5660   dest = gen_lowpart (V8HImode, operands[0]);
5661
5662   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5663   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5664   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5665   DONE;
5666 })
5667
5668 (define_expand "vec_widen_smult_lo_v8hi"
5669   [(match_operand:V4SI 0 "register_operand" "")
5670    (match_operand:V8HI 1 "register_operand" "")
5671    (match_operand:V8HI 2 "register_operand" "")]
5672   "TARGET_SSE2"
5673 {
5674   rtx op1, op2, t1, t2, dest;
5675
5676   op1 = operands[1];
5677   op2 = operands[2];
5678   t1 = gen_reg_rtx (V8HImode);
5679   t2 = gen_reg_rtx (V8HImode);
5680   dest = gen_lowpart (V8HImode, operands[0]);
5681
5682   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5683   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5684   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5685   DONE;
5686 })
5687
5688 (define_expand "vec_widen_umult_hi_v8hi"
5689   [(match_operand:V4SI 0 "register_operand" "")
5690    (match_operand:V8HI 1 "register_operand" "")
5691    (match_operand:V8HI 2 "register_operand" "")]
5692   "TARGET_SSE2"
5693 {
5694   rtx op1, op2, t1, t2, dest;
5695
5696   op1 = operands[1];
5697   op2 = operands[2];
5698   t1 = gen_reg_rtx (V8HImode);
5699   t2 = gen_reg_rtx (V8HImode);
5700   dest = gen_lowpart (V8HImode, operands[0]);
5701
5702   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5703   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5704   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5705   DONE;
5706 })
5707
5708 (define_expand "vec_widen_umult_lo_v8hi"
5709   [(match_operand:V4SI 0 "register_operand" "")
5710    (match_operand:V8HI 1 "register_operand" "")
5711    (match_operand:V8HI 2 "register_operand" "")]
5712   "TARGET_SSE2"
5713 {
5714   rtx op1, op2, t1, t2, dest;
5715
5716   op1 = operands[1];
5717   op2 = operands[2];
5718   t1 = gen_reg_rtx (V8HImode);
5719   t2 = gen_reg_rtx (V8HImode);
5720   dest = gen_lowpart (V8HImode, operands[0]);
5721
5722   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5723   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5724   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5725   DONE;
5726 })
5727
5728 (define_expand "vec_widen_smult_hi_v4si"
5729   [(match_operand:V2DI 0 "register_operand" "")
5730    (match_operand:V4SI 1 "register_operand" "")
5731    (match_operand:V4SI 2 "register_operand" "")]
5732   "TARGET_XOP"
5733 {
5734   rtx t1, t2;
5735
5736   t1 = gen_reg_rtx (V4SImode);
5737   t2 = gen_reg_rtx (V4SImode);
5738
5739   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5740                                 GEN_INT (0),
5741                                 GEN_INT (2),
5742                                 GEN_INT (1),
5743                                 GEN_INT (3)));
5744   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5745                                 GEN_INT (0),
5746                                 GEN_INT (2),
5747                                 GEN_INT (1),
5748                                 GEN_INT (3)));
5749   emit_insn (gen_xop_mulv2div2di3_high (operands[0], t1, t2));
5750   DONE;
5751 })
5752
5753 (define_expand "vec_widen_smult_lo_v4si"
5754   [(match_operand:V2DI 0 "register_operand" "")
5755    (match_operand:V4SI 1 "register_operand" "")
5756    (match_operand:V4SI 2 "register_operand" "")]
5757   "TARGET_XOP"
5758 {
5759   rtx t1, t2;
5760
5761   t1 = gen_reg_rtx (V4SImode);
5762   t2 = gen_reg_rtx (V4SImode);
5763
5764   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5765                                 GEN_INT (0),
5766                                 GEN_INT (2),
5767                                 GEN_INT (1),
5768                                 GEN_INT (3)));
5769   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5770                                 GEN_INT (0),
5771                                 GEN_INT (2),
5772                                 GEN_INT (1),
5773                                 GEN_INT (3)));
5774   emit_insn (gen_xop_mulv2div2di3_low (operands[0], t1, t2));
5775   DONE;
5776 })
5777
5778 (define_expand "vec_widen_umult_hi_v4si"
5779   [(match_operand:V2DI 0 "register_operand" "")
5780    (match_operand:V4SI 1 "register_operand" "")
5781    (match_operand:V4SI 2 "register_operand" "")]
5782   "TARGET_SSE2"
5783 {
5784   rtx op1, op2, t1, t2;
5785
5786   op1 = operands[1];
5787   op2 = operands[2];
5788   t1 = gen_reg_rtx (V4SImode);
5789   t2 = gen_reg_rtx (V4SImode);
5790
5791   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
5792   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
5793   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5794   DONE;
5795 })
5796
5797 (define_expand "vec_widen_umult_lo_v4si"
5798   [(match_operand:V2DI 0 "register_operand" "")
5799    (match_operand:V4SI 1 "register_operand" "")
5800    (match_operand:V4SI 2 "register_operand" "")]
5801   "TARGET_SSE2"
5802 {
5803   rtx op1, op2, t1, t2;
5804
5805   op1 = operands[1];
5806   op2 = operands[2];
5807   t1 = gen_reg_rtx (V4SImode);
5808   t2 = gen_reg_rtx (V4SImode);
5809
5810   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
5811   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
5812   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5813   DONE;
5814 })
5815
5816 (define_expand "sdot_prodv8hi"
5817   [(match_operand:V4SI 0 "register_operand" "")
5818    (match_operand:V8HI 1 "register_operand" "")
5819    (match_operand:V8HI 2 "register_operand" "")
5820    (match_operand:V4SI 3 "register_operand" "")]
5821   "TARGET_SSE2"
5822 {
5823   rtx t = gen_reg_rtx (V4SImode);
5824   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
5825   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
5826   DONE;
5827 })
5828
5829 (define_expand "udot_prodv4si"
5830   [(match_operand:V2DI 0 "register_operand" "")
5831    (match_operand:V4SI 1 "register_operand" "")
5832    (match_operand:V4SI 2 "register_operand" "")
5833    (match_operand:V2DI 3 "register_operand" "")]
5834   "TARGET_SSE2"
5835 {
5836   rtx t1, t2, t3, t4;
5837
5838   t1 = gen_reg_rtx (V2DImode);
5839   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
5840   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
5841
5842   t2 = gen_reg_rtx (V4SImode);
5843   t3 = gen_reg_rtx (V4SImode);
5844   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5845                                  gen_lowpart (V1TImode, operands[1]),
5846                                  GEN_INT (32)));
5847   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5848                                  gen_lowpart (V1TImode, operands[2]),
5849                                  GEN_INT (32)));
5850
5851   t4 = gen_reg_rtx (V2DImode);
5852   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
5853
5854   emit_insn (gen_addv2di3 (operands[0], t1, t4));
5855   DONE;
5856 })
5857
5858 (define_insn "*avx_ashr<mode>3"
5859   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5860         (ashiftrt:SSEMODE24
5861           (match_operand:SSEMODE24 1 "register_operand" "x")
5862           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5863   "TARGET_AVX"
5864   "vpsra<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5865   [(set_attr "type" "sseishft")
5866    (set_attr "prefix" "vex")
5867    (set (attr "length_immediate")
5868      (if_then_else (match_operand 2 "const_int_operand" "")
5869        (const_string "1")
5870        (const_string "0")))
5871    (set_attr "mode" "TI")])
5872
5873 (define_insn "ashr<mode>3"
5874   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5875         (ashiftrt:SSEMODE24
5876           (match_operand:SSEMODE24 1 "register_operand" "0")
5877           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5878   "TARGET_SSE2"
5879   "psra<ssevecsize>\t{%2, %0|%0, %2}"
5880   [(set_attr "type" "sseishft")
5881    (set_attr "prefix_data16" "1")
5882    (set (attr "length_immediate")
5883      (if_then_else (match_operand 2 "const_int_operand" "")
5884        (const_string "1")
5885        (const_string "0")))
5886    (set_attr "mode" "TI")])
5887
5888 (define_insn "*avx_lshrv1ti3"
5889   [(set (match_operand:V1TI 0 "register_operand" "=x")
5890         (lshiftrt:V1TI
5891          (match_operand:V1TI 1 "register_operand" "x")
5892          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5893   "TARGET_AVX"
5894 {
5895   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5896   return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5897 }
5898   [(set_attr "type" "sseishft")
5899    (set_attr "prefix" "vex")
5900    (set_attr "length_immediate" "1")
5901    (set_attr "mode" "TI")])
5902
5903 (define_insn "*avx_lshr<mode>3"
5904   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5905         (lshiftrt:SSEMODE248
5906           (match_operand:SSEMODE248 1 "register_operand" "x")
5907           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5908   "TARGET_AVX"
5909   "vpsrl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5910   [(set_attr "type" "sseishft")
5911    (set_attr "prefix" "vex")
5912    (set (attr "length_immediate")
5913      (if_then_else (match_operand 2 "const_int_operand" "")
5914        (const_string "1")
5915        (const_string "0")))
5916    (set_attr "mode" "TI")])
5917
5918 (define_insn "sse2_lshrv1ti3"
5919   [(set (match_operand:V1TI 0 "register_operand" "=x")
5920         (lshiftrt:V1TI
5921          (match_operand:V1TI 1 "register_operand" "0")
5922          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5923   "TARGET_SSE2"
5924 {
5925   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5926   return "psrldq\t{%2, %0|%0, %2}";
5927 }
5928   [(set_attr "type" "sseishft")
5929    (set_attr "prefix_data16" "1")
5930    (set_attr "length_immediate" "1")
5931    (set_attr "mode" "TI")])
5932
5933 (define_insn "lshr<mode>3"
5934   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5935         (lshiftrt:SSEMODE248
5936           (match_operand:SSEMODE248 1 "register_operand" "0")
5937           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5938   "TARGET_SSE2"
5939   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
5940   [(set_attr "type" "sseishft")
5941    (set_attr "prefix_data16" "1")
5942    (set (attr "length_immediate")
5943      (if_then_else (match_operand 2 "const_int_operand" "")
5944        (const_string "1")
5945        (const_string "0")))
5946    (set_attr "mode" "TI")])
5947
5948 (define_insn "*avx_ashlv1ti3"
5949   [(set (match_operand:V1TI 0 "register_operand" "=x")
5950         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "x")
5951                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5952   "TARGET_AVX"
5953 {
5954   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5955   return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
5956 }
5957   [(set_attr "type" "sseishft")
5958    (set_attr "prefix" "vex")
5959    (set_attr "length_immediate" "1")
5960    (set_attr "mode" "TI")])
5961
5962 (define_insn "*avx_ashl<mode>3"
5963   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5964         (ashift:SSEMODE248
5965           (match_operand:SSEMODE248 1 "register_operand" "x")
5966           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5967   "TARGET_AVX"
5968   "vpsll<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5969   [(set_attr "type" "sseishft")
5970    (set_attr "prefix" "vex")
5971    (set (attr "length_immediate")
5972      (if_then_else (match_operand 2 "const_int_operand" "")
5973        (const_string "1")
5974        (const_string "0")))
5975    (set_attr "mode" "TI")])
5976
5977 (define_insn "sse2_ashlv1ti3"
5978   [(set (match_operand:V1TI 0 "register_operand" "=x")
5979         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "0")
5980                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5981   "TARGET_SSE2"
5982 {
5983   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5984   return "pslldq\t{%2, %0|%0, %2}";
5985 }
5986   [(set_attr "type" "sseishft")
5987    (set_attr "prefix_data16" "1")
5988    (set_attr "length_immediate" "1")
5989    (set_attr "mode" "TI")])
5990
5991 (define_insn "ashl<mode>3"
5992   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5993         (ashift:SSEMODE248
5994           (match_operand:SSEMODE248 1 "register_operand" "0")
5995           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5996   "TARGET_SSE2"
5997   "psll<ssevecsize>\t{%2, %0|%0, %2}"
5998   [(set_attr "type" "sseishft")
5999    (set_attr "prefix_data16" "1")
6000    (set (attr "length_immediate")
6001      (if_then_else (match_operand 2 "const_int_operand" "")
6002        (const_string "1")
6003        (const_string "0")))
6004    (set_attr "mode" "TI")])
6005
6006 (define_expand "vec_shl_<mode>"
6007   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6008         (ashift:V1TI
6009          (match_operand:SSEMODEI 1 "register_operand" "")
6010          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6011   "TARGET_SSE2"
6012 {
6013   operands[0] = gen_lowpart (V1TImode, operands[0]);
6014   operands[1] = gen_lowpart (V1TImode, operands[1]);
6015 })
6016
6017 (define_expand "vec_shr_<mode>"
6018   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6019         (lshiftrt:V1TI
6020          (match_operand:SSEMODEI 1 "register_operand" "")
6021          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6022   "TARGET_SSE2"
6023 {
6024   operands[0] = gen_lowpart (V1TImode, operands[0]);
6025   operands[1] = gen_lowpart (V1TImode, operands[1]);
6026 })
6027
6028 (define_insn "*avx_<code><mode>3"
6029   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6030         (maxmin:SSEMODE124
6031           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
6032           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6033   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6034   "vp<maxmin_int><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6035   [(set_attr "type" "sseiadd")
6036    (set (attr "prefix_extra")
6037      (if_then_else
6038        (ne (symbol_ref "<MODE>mode != ((<CODE> == SMAX || <CODE> == SMIN) ? V8HImode : V16QImode)")
6039            (const_int 0))
6040        (const_string "1")
6041        (const_string "0")))
6042    (set_attr "prefix" "vex")
6043    (set_attr "mode" "TI")])
6044
6045 (define_expand "<code>v16qi3"
6046   [(set (match_operand:V16QI 0 "register_operand" "")
6047         (umaxmin:V16QI
6048           (match_operand:V16QI 1 "nonimmediate_operand" "")
6049           (match_operand:V16QI 2 "nonimmediate_operand" "")))]
6050   "TARGET_SSE2"
6051   "ix86_fixup_binary_operands_no_copy (<CODE>, V16QImode, operands);")
6052
6053 (define_insn "*<code>v16qi3"
6054   [(set (match_operand:V16QI 0 "register_operand" "=x")
6055         (umaxmin:V16QI
6056           (match_operand:V16QI 1 "nonimmediate_operand" "%0")
6057           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
6058   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
6059   "p<maxmin_int>b\t{%2, %0|%0, %2}"
6060   [(set_attr "type" "sseiadd")
6061    (set_attr "prefix_data16" "1")
6062    (set_attr "mode" "TI")])
6063
6064 (define_expand "<code>v8hi3"
6065   [(set (match_operand:V8HI 0 "register_operand" "")
6066         (smaxmin:V8HI
6067           (match_operand:V8HI 1 "nonimmediate_operand" "")
6068           (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6069   "TARGET_SSE2"
6070   "ix86_fixup_binary_operands_no_copy (<CODE>, V8HImode, operands);")
6071
6072 (define_insn "*<code>v8hi3"
6073   [(set (match_operand:V8HI 0 "register_operand" "=x")
6074         (smaxmin:V8HI
6075           (match_operand:V8HI 1 "nonimmediate_operand" "%0")
6076           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
6077   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
6078   "p<maxmin_int>w\t{%2, %0|%0, %2}"
6079   [(set_attr "type" "sseiadd")
6080    (set_attr "prefix_data16" "1")
6081    (set_attr "mode" "TI")])
6082
6083 (define_expand "umaxv8hi3"
6084   [(set (match_operand:V8HI 0 "register_operand" "")
6085         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
6086                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6087   "TARGET_SSE2"
6088 {
6089   if (TARGET_SSE4_1)
6090     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
6091   else
6092     {
6093       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
6094       if (rtx_equal_p (op3, op2))
6095         op3 = gen_reg_rtx (V8HImode);
6096       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
6097       emit_insn (gen_addv8hi3 (op0, op3, op2));
6098       DONE;
6099     }
6100 })
6101
6102 (define_expand "smax<mode>3"
6103   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6104         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6105                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6106   "TARGET_SSE2"
6107 {
6108   if (TARGET_SSE4_1)
6109     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
6110   else
6111   {
6112     rtx xops[6];
6113     bool ok;
6114
6115     xops[0] = operands[0];
6116     xops[1] = operands[1];
6117     xops[2] = operands[2];
6118     xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6119     xops[4] = operands[1];
6120     xops[5] = operands[2];
6121     ok = ix86_expand_int_vcond (xops);
6122     gcc_assert (ok);
6123     DONE;
6124   }
6125 })
6126
6127 (define_insn "*sse4_1_<code><mode>3"
6128   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
6129         (smaxmin:SSEMODE14
6130           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
6131           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
6132   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6133   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6134   [(set_attr "type" "sseiadd")
6135    (set_attr "prefix_extra" "1")
6136    (set_attr "mode" "TI")])
6137
6138 (define_expand "smaxv2di3"
6139   [(set (match_operand:V2DI 0 "register_operand" "")
6140         (smax:V2DI (match_operand:V2DI 1 "register_operand" "")
6141                    (match_operand:V2DI 2 "register_operand" "")))]
6142   "TARGET_SSE4_2"
6143 {
6144   rtx xops[6];
6145   bool ok;
6146
6147   xops[0] = operands[0];
6148   xops[1] = operands[1];
6149   xops[2] = operands[2];
6150   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6151   xops[4] = operands[1];
6152   xops[5] = operands[2];
6153   ok = ix86_expand_int_vcond (xops);
6154   gcc_assert (ok);
6155   DONE;
6156 })
6157
6158 (define_expand "umaxv4si3"
6159   [(set (match_operand:V4SI 0 "register_operand" "")
6160         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
6161                    (match_operand:V4SI 2 "register_operand" "")))]
6162   "TARGET_SSE2"
6163 {
6164   if (TARGET_SSE4_1)
6165     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
6166   else
6167   {
6168     rtx xops[6];
6169     bool ok;
6170
6171     xops[0] = operands[0];
6172     xops[1] = operands[1];
6173     xops[2] = operands[2];
6174     xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6175     xops[4] = operands[1];
6176     xops[5] = operands[2];
6177     ok = ix86_expand_int_vcond (xops);
6178     gcc_assert (ok);
6179     DONE;
6180   }
6181 })
6182
6183 (define_insn "*sse4_1_<code><mode>3"
6184   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
6185         (umaxmin:SSEMODE24
6186           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
6187           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
6188   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6189   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6190   [(set_attr "type" "sseiadd")
6191    (set_attr "prefix_extra" "1")
6192    (set_attr "mode" "TI")])
6193
6194 (define_expand "umaxv2di3"
6195   [(set (match_operand:V2DI 0 "register_operand" "")
6196         (umax:V2DI (match_operand:V2DI 1 "register_operand" "")
6197                    (match_operand:V2DI 2 "register_operand" "")))]
6198   "TARGET_SSE4_2"
6199 {
6200   rtx xops[6];
6201   bool ok;
6202
6203   xops[0] = operands[0];
6204   xops[1] = operands[1];
6205   xops[2] = operands[2];
6206   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6207   xops[4] = operands[1];
6208   xops[5] = operands[2];
6209   ok = ix86_expand_int_vcond (xops);
6210   gcc_assert (ok);
6211   DONE;
6212 })
6213
6214 (define_expand "smin<mode>3"
6215   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6216         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6217                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6218   "TARGET_SSE2"
6219 {
6220   if (TARGET_SSE4_1)
6221     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
6222   else
6223     {
6224       rtx xops[6];
6225       bool ok;
6226
6227       xops[0] = operands[0];
6228       xops[1] = operands[2];
6229       xops[2] = operands[1];
6230       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6231       xops[4] = operands[1];
6232       xops[5] = operands[2];
6233       ok = ix86_expand_int_vcond (xops);
6234       gcc_assert (ok);
6235       DONE;
6236     }
6237 })
6238
6239 (define_expand "sminv2di3"
6240   [(set (match_operand:V2DI 0 "register_operand" "")
6241         (smin:V2DI (match_operand:V2DI 1 "register_operand" "")
6242                    (match_operand:V2DI 2 "register_operand" "")))]
6243   "TARGET_SSE4_2"
6244 {
6245   rtx xops[6];
6246   bool ok;
6247
6248   xops[0] = operands[0];
6249   xops[1] = operands[2];
6250   xops[2] = operands[1];
6251   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6252   xops[4] = operands[1];
6253   xops[5] = operands[2];
6254   ok = ix86_expand_int_vcond (xops);
6255   gcc_assert (ok);
6256   DONE;
6257 })
6258
6259 (define_expand "umin<mode>3"
6260   [(set (match_operand:SSEMODE24 0 "register_operand" "")
6261         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
6262                         (match_operand:SSEMODE24 2 "register_operand" "")))]
6263   "TARGET_SSE2"
6264 {
6265   if (TARGET_SSE4_1)
6266     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
6267   else
6268     {
6269       rtx xops[6];
6270       bool ok;
6271
6272       xops[0] = operands[0];
6273       xops[1] = operands[2];
6274       xops[2] = operands[1];
6275       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6276       xops[4] = operands[1];
6277       xops[5] = operands[2];
6278       ok = ix86_expand_int_vcond (xops);
6279       gcc_assert (ok);
6280       DONE;
6281     }
6282 })
6283
6284 (define_expand "uminv2di3"
6285   [(set (match_operand:V2DI 0 "register_operand" "")
6286         (umin:V2DI (match_operand:V2DI 1 "register_operand" "")
6287                    (match_operand:V2DI 2 "register_operand" "")))]
6288   "TARGET_SSE4_2"
6289 {
6290   rtx xops[6];
6291   bool ok;
6292
6293   xops[0] = operands[0];
6294   xops[1] = operands[2];
6295   xops[2] = operands[1];
6296   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6297   xops[4] = operands[1];
6298   xops[5] = operands[2];
6299   ok = ix86_expand_int_vcond (xops);
6300   gcc_assert (ok);
6301   DONE;
6302 })
6303
6304 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6305 ;;
6306 ;; Parallel integral comparisons
6307 ;;
6308 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6309
6310 (define_expand "sse2_eq<mode>3"
6311   [(set (match_operand:SSEMODE124 0 "register_operand" "")
6312         (eq:SSEMODE124
6313           (match_operand:SSEMODE124 1 "nonimmediate_operand" "")
6314           (match_operand:SSEMODE124 2 "nonimmediate_operand" "")))]
6315   "TARGET_SSE2 && !TARGET_XOP "
6316   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
6317
6318 (define_insn "*avx_eq<mode>3"
6319   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6320         (eq:SSEMODE1248
6321           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "%x")
6322           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6323   "TARGET_AVX && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6324   "vpcmpeq<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6325   [(set_attr "type" "ssecmp")
6326    (set (attr "prefix_extra")
6327      (if_then_else (match_operand:V2DI 0 "" "")
6328        (const_string "1")
6329        (const_string "*")))
6330    (set_attr "prefix" "vex")
6331    (set_attr "mode" "TI")])
6332
6333 (define_insn "*sse2_eq<mode>3"
6334   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6335         (eq:SSEMODE124
6336           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
6337           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6338   "TARGET_SSE2 && !TARGET_XOP
6339    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6340   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
6341   [(set_attr "type" "ssecmp")
6342    (set_attr "prefix_data16" "1")
6343    (set_attr "mode" "TI")])
6344
6345 (define_expand "sse4_1_eqv2di3"
6346   [(set (match_operand:V2DI 0 "register_operand" "")
6347         (eq:V2DI
6348           (match_operand:V2DI 1 "nonimmediate_operand" "")
6349           (match_operand:V2DI 2 "nonimmediate_operand" "")))]
6350   "TARGET_SSE4_1"
6351   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
6352
6353 (define_insn "*sse4_1_eqv2di3"
6354   [(set (match_operand:V2DI 0 "register_operand" "=x")
6355         (eq:V2DI
6356           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
6357           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6358   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
6359   "pcmpeqq\t{%2, %0|%0, %2}"
6360   [(set_attr "type" "ssecmp")
6361    (set_attr "prefix_extra" "1")
6362    (set_attr "mode" "TI")])
6363
6364 (define_insn "*avx_gt<mode>3"
6365   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6366         (gt:SSEMODE1248
6367           (match_operand:SSEMODE1248 1 "register_operand" "x")
6368           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6369   "TARGET_AVX"
6370   "vpcmpgt<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6371   [(set_attr "type" "ssecmp")
6372    (set (attr "prefix_extra")
6373      (if_then_else (match_operand:V2DI 0 "" "")
6374        (const_string "1")
6375        (const_string "*")))
6376    (set_attr "prefix" "vex")
6377    (set_attr "mode" "TI")])
6378
6379 (define_insn "sse2_gt<mode>3"
6380   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6381         (gt:SSEMODE124
6382           (match_operand:SSEMODE124 1 "register_operand" "0")
6383           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6384   "TARGET_SSE2 && !TARGET_XOP"
6385   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
6386   [(set_attr "type" "ssecmp")
6387    (set_attr "prefix_data16" "1")
6388    (set_attr "mode" "TI")])
6389
6390 (define_insn "sse4_2_gtv2di3"
6391   [(set (match_operand:V2DI 0 "register_operand" "=x")
6392         (gt:V2DI
6393           (match_operand:V2DI 1 "register_operand" "0")
6394           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6395   "TARGET_SSE4_2"
6396   "pcmpgtq\t{%2, %0|%0, %2}"
6397   [(set_attr "type" "ssecmp")
6398    (set_attr "prefix_extra" "1")
6399    (set_attr "mode" "TI")])
6400
6401 (define_expand "vcond<mode>"
6402   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6403         (if_then_else:SSEMODE124C8
6404           (match_operator 3 ""
6405             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6406              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6407           (match_operand:SSEMODE124C8 1 "general_operand" "")
6408           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6409   "TARGET_SSE2"
6410 {
6411   bool ok = ix86_expand_int_vcond (operands);
6412   gcc_assert (ok);
6413   DONE;
6414 })
6415
6416 (define_expand "vcondu<mode>"
6417   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6418         (if_then_else:SSEMODE124C8
6419           (match_operator 3 ""
6420             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6421              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6422           (match_operand:SSEMODE124C8 1 "general_operand" "")
6423           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6424   "TARGET_SSE2"
6425 {
6426   bool ok = ix86_expand_int_vcond (operands);
6427   gcc_assert (ok);
6428   DONE;
6429 })
6430
6431 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6432 ;;
6433 ;; Parallel bitwise logical operations
6434 ;;
6435 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6436
6437 (define_expand "one_cmpl<mode>2"
6438   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6439         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6440                       (match_dup 2)))]
6441   "TARGET_SSE2"
6442 {
6443   int i, n = GET_MODE_NUNITS (<MODE>mode);
6444   rtvec v = rtvec_alloc (n);
6445
6446   for (i = 0; i < n; ++i)
6447     RTVEC_ELT (v, i) = constm1_rtx;
6448
6449   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
6450 })
6451
6452 (define_insn "*avx_andnot<mode>3"
6453   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6454         (and:AVX256MODEI
6455           (not:AVX256MODEI (match_operand:AVX256MODEI 1 "register_operand" "x"))
6456           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6457   "TARGET_AVX"
6458   "vandnps\t{%2, %1, %0|%0, %1, %2}"
6459   [(set_attr "type" "sselog")
6460    (set_attr "prefix" "vex")
6461    (set_attr "mode" "<avxvecpsmode>")])
6462
6463 (define_insn "*sse_andnot<mode>3"
6464   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6465         (and:SSEMODEI
6466           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6467           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6468   "(TARGET_SSE && !TARGET_SSE2)"
6469   "andnps\t{%2, %0|%0, %2}"
6470   [(set_attr "type" "sselog")
6471    (set_attr "mode" "V4SF")])
6472
6473 (define_insn "*avx_andnot<mode>3"
6474   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6475         (and:SSEMODEI
6476           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "x"))
6477           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6478   "TARGET_AVX"
6479   "vpandn\t{%2, %1, %0|%0, %1, %2}"
6480   [(set_attr "type" "sselog")
6481    (set_attr "prefix" "vex")
6482    (set_attr "mode" "TI")])
6483
6484 (define_insn "sse2_andnot<mode>3"
6485   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6486         (and:SSEMODEI
6487           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6488           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6489   "TARGET_SSE2"
6490   "pandn\t{%2, %0|%0, %2}"
6491   [(set_attr "type" "sselog")
6492    (set_attr "prefix_data16" "1")
6493    (set_attr "mode" "TI")])
6494
6495 (define_insn "*andnottf3"
6496   [(set (match_operand:TF 0 "register_operand" "=x")
6497         (and:TF
6498           (not:TF (match_operand:TF 1 "register_operand" "0"))
6499           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6500   "TARGET_SSE2"
6501   "pandn\t{%2, %0|%0, %2}"
6502   [(set_attr "type" "sselog")
6503    (set_attr "prefix_data16" "1")
6504    (set_attr "mode" "TI")])
6505
6506 (define_expand "<code><mode>3"
6507   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6508         (any_logic:SSEMODEI
6509           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6510           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
6511   "TARGET_SSE"
6512   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
6513
6514 (define_insn "*avx_<code><mode>3"
6515   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6516         (any_logic:AVX256MODEI
6517           (match_operand:AVX256MODEI 1 "nonimmediate_operand" "%x")
6518           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6519   "TARGET_AVX
6520    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6521   "v<logic>ps\t{%2, %1, %0|%0, %1, %2}"
6522   [(set_attr "type" "sselog")
6523    (set_attr "prefix" "vex")
6524    (set_attr "mode" "<avxvecpsmode>")])
6525
6526 (define_insn "*sse_<code><mode>3"
6527   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6528         (any_logic:SSEMODEI
6529           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6530           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6531   "(TARGET_SSE && !TARGET_SSE2)
6532    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6533   "<logic>ps\t{%2, %0|%0, %2}"
6534   [(set_attr "type" "sselog")
6535    (set_attr "mode" "V4SF")])
6536
6537 (define_insn "*avx_<code><mode>3"
6538   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6539         (any_logic:SSEMODEI
6540           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%x")
6541           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6542   "TARGET_AVX
6543    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6544   "vp<logic>\t{%2, %1, %0|%0, %1, %2}"
6545   [(set_attr "type" "sselog")
6546    (set_attr "prefix" "vex")
6547    (set_attr "mode" "TI")])
6548
6549 (define_insn "*sse2_<code><mode>3"
6550   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6551         (any_logic:SSEMODEI
6552           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6553           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6554   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6555   "p<logic>\t{%2, %0|%0, %2}"
6556   [(set_attr "type" "sselog")
6557    (set_attr "prefix_data16" "1")
6558    (set_attr "mode" "TI")])
6559
6560 (define_expand "<code>tf3"
6561   [(set (match_operand:TF 0 "register_operand" "")
6562         (any_logic:TF
6563           (match_operand:TF 1 "nonimmediate_operand" "")
6564           (match_operand:TF 2 "nonimmediate_operand" "")))]
6565   "TARGET_SSE2"
6566   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
6567
6568 (define_insn "*<code>tf3"
6569   [(set (match_operand:TF 0 "register_operand" "=x")
6570         (any_logic:TF
6571           (match_operand:TF 1 "nonimmediate_operand" "%0")
6572           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6573   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
6574   "p<logic>\t{%2, %0|%0, %2}"
6575   [(set_attr "type" "sselog")
6576    (set_attr "prefix_data16" "1")
6577    (set_attr "mode" "TI")])
6578
6579 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6580 ;;
6581 ;; Parallel integral element swizzling
6582 ;;
6583 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6584
6585 (define_expand "vec_pack_trunc_v8hi"
6586   [(match_operand:V16QI 0 "register_operand" "")
6587    (match_operand:V8HI 1 "register_operand" "")
6588    (match_operand:V8HI 2 "register_operand" "")]
6589   "TARGET_SSE2"
6590 {
6591   rtx op1 = gen_lowpart (V16QImode, operands[1]);
6592   rtx op2 = gen_lowpart (V16QImode, operands[2]);
6593   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6594   DONE;
6595 })
6596
6597 (define_expand "vec_pack_trunc_v4si"
6598   [(match_operand:V8HI 0 "register_operand" "")
6599    (match_operand:V4SI 1 "register_operand" "")
6600    (match_operand:V4SI 2 "register_operand" "")]
6601   "TARGET_SSE2"
6602 {
6603   rtx op1 = gen_lowpart (V8HImode, operands[1]);
6604   rtx op2 = gen_lowpart (V8HImode, operands[2]);
6605   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6606   DONE;
6607 })
6608
6609 (define_expand "vec_pack_trunc_v2di"
6610   [(match_operand:V4SI 0 "register_operand" "")
6611    (match_operand:V2DI 1 "register_operand" "")
6612    (match_operand:V2DI 2 "register_operand" "")]
6613   "TARGET_SSE2"
6614 {
6615   rtx op1 = gen_lowpart (V4SImode, operands[1]);
6616   rtx op2 = gen_lowpart (V4SImode, operands[2]);
6617   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6618   DONE;
6619 })
6620
6621 (define_insn "*avx_packsswb"
6622   [(set (match_operand:V16QI 0 "register_operand" "=x")
6623         (vec_concat:V16QI
6624           (ss_truncate:V8QI
6625             (match_operand:V8HI 1 "register_operand" "x"))
6626           (ss_truncate:V8QI
6627             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6628   "TARGET_AVX"
6629   "vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6630   [(set_attr "type" "sselog")
6631    (set_attr "prefix" "vex")
6632    (set_attr "mode" "TI")])
6633
6634 (define_insn "sse2_packsswb"
6635   [(set (match_operand:V16QI 0 "register_operand" "=x")
6636         (vec_concat:V16QI
6637           (ss_truncate:V8QI
6638             (match_operand:V8HI 1 "register_operand" "0"))
6639           (ss_truncate:V8QI
6640             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6641   "TARGET_SSE2"
6642   "packsswb\t{%2, %0|%0, %2}"
6643   [(set_attr "type" "sselog")
6644    (set_attr "prefix_data16" "1")
6645    (set_attr "mode" "TI")])
6646
6647 (define_insn "*avx_packssdw"
6648   [(set (match_operand:V8HI 0 "register_operand" "=x")
6649         (vec_concat:V8HI
6650           (ss_truncate:V4HI
6651             (match_operand:V4SI 1 "register_operand" "x"))
6652           (ss_truncate:V4HI
6653             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6654   "TARGET_AVX"
6655   "vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6656   [(set_attr "type" "sselog")
6657    (set_attr "prefix" "vex")
6658    (set_attr "mode" "TI")])
6659
6660 (define_insn "sse2_packssdw"
6661   [(set (match_operand:V8HI 0 "register_operand" "=x")
6662         (vec_concat:V8HI
6663           (ss_truncate:V4HI
6664             (match_operand:V4SI 1 "register_operand" "0"))
6665           (ss_truncate:V4HI
6666             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6667   "TARGET_SSE2"
6668   "packssdw\t{%2, %0|%0, %2}"
6669   [(set_attr "type" "sselog")
6670    (set_attr "prefix_data16" "1")
6671    (set_attr "mode" "TI")])
6672
6673 (define_insn "*avx_packuswb"
6674   [(set (match_operand:V16QI 0 "register_operand" "=x")
6675         (vec_concat:V16QI
6676           (us_truncate:V8QI
6677             (match_operand:V8HI 1 "register_operand" "x"))
6678           (us_truncate:V8QI
6679             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6680   "TARGET_AVX"
6681   "vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6682   [(set_attr "type" "sselog")
6683    (set_attr "prefix" "vex")
6684    (set_attr "mode" "TI")])
6685
6686 (define_insn "sse2_packuswb"
6687   [(set (match_operand:V16QI 0 "register_operand" "=x")
6688         (vec_concat:V16QI
6689           (us_truncate:V8QI
6690             (match_operand:V8HI 1 "register_operand" "0"))
6691           (us_truncate:V8QI
6692             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6693   "TARGET_SSE2"
6694   "packuswb\t{%2, %0|%0, %2}"
6695   [(set_attr "type" "sselog")
6696    (set_attr "prefix_data16" "1")
6697    (set_attr "mode" "TI")])
6698
6699 (define_insn "*avx_interleave_highv16qi"
6700   [(set (match_operand:V16QI 0 "register_operand" "=x")
6701         (vec_select:V16QI
6702           (vec_concat:V32QI
6703             (match_operand:V16QI 1 "register_operand" "x")
6704             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6705           (parallel [(const_int 8)  (const_int 24)
6706                      (const_int 9)  (const_int 25)
6707                      (const_int 10) (const_int 26)
6708                      (const_int 11) (const_int 27)
6709                      (const_int 12) (const_int 28)
6710                      (const_int 13) (const_int 29)
6711                      (const_int 14) (const_int 30)
6712                      (const_int 15) (const_int 31)])))]
6713   "TARGET_AVX"
6714   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6715   [(set_attr "type" "sselog")
6716    (set_attr "prefix" "vex")
6717    (set_attr "mode" "TI")])
6718
6719 (define_insn "vec_interleave_highv16qi"
6720   [(set (match_operand:V16QI 0 "register_operand" "=x")
6721         (vec_select:V16QI
6722           (vec_concat:V32QI
6723             (match_operand:V16QI 1 "register_operand" "0")
6724             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6725           (parallel [(const_int 8)  (const_int 24)
6726                      (const_int 9)  (const_int 25)
6727                      (const_int 10) (const_int 26)
6728                      (const_int 11) (const_int 27)
6729                      (const_int 12) (const_int 28)
6730                      (const_int 13) (const_int 29)
6731                      (const_int 14) (const_int 30)
6732                      (const_int 15) (const_int 31)])))]
6733   "TARGET_SSE2"
6734   "punpckhbw\t{%2, %0|%0, %2}"
6735   [(set_attr "type" "sselog")
6736    (set_attr "prefix_data16" "1")
6737    (set_attr "mode" "TI")])
6738
6739 (define_insn "*avx_interleave_lowv16qi"
6740   [(set (match_operand:V16QI 0 "register_operand" "=x")
6741         (vec_select:V16QI
6742           (vec_concat:V32QI
6743             (match_operand:V16QI 1 "register_operand" "x")
6744             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6745           (parallel [(const_int 0) (const_int 16)
6746                      (const_int 1) (const_int 17)
6747                      (const_int 2) (const_int 18)
6748                      (const_int 3) (const_int 19)
6749                      (const_int 4) (const_int 20)
6750                      (const_int 5) (const_int 21)
6751                      (const_int 6) (const_int 22)
6752                      (const_int 7) (const_int 23)])))]
6753   "TARGET_AVX"
6754   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6755   [(set_attr "type" "sselog")
6756    (set_attr "prefix" "vex")
6757    (set_attr "mode" "TI")])
6758
6759 (define_insn "vec_interleave_lowv16qi"
6760   [(set (match_operand:V16QI 0 "register_operand" "=x")
6761         (vec_select:V16QI
6762           (vec_concat:V32QI
6763             (match_operand:V16QI 1 "register_operand" "0")
6764             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6765           (parallel [(const_int 0) (const_int 16)
6766                      (const_int 1) (const_int 17)
6767                      (const_int 2) (const_int 18)
6768                      (const_int 3) (const_int 19)
6769                      (const_int 4) (const_int 20)
6770                      (const_int 5) (const_int 21)
6771                      (const_int 6) (const_int 22)
6772                      (const_int 7) (const_int 23)])))]
6773   "TARGET_SSE2"
6774   "punpcklbw\t{%2, %0|%0, %2}"
6775   [(set_attr "type" "sselog")
6776    (set_attr "prefix_data16" "1")
6777    (set_attr "mode" "TI")])
6778
6779 (define_insn "*avx_interleave_highv8hi"
6780   [(set (match_operand:V8HI 0 "register_operand" "=x")
6781         (vec_select:V8HI
6782           (vec_concat:V16HI
6783             (match_operand:V8HI 1 "register_operand" "x")
6784             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6785           (parallel [(const_int 4) (const_int 12)
6786                      (const_int 5) (const_int 13)
6787                      (const_int 6) (const_int 14)
6788                      (const_int 7) (const_int 15)])))]
6789   "TARGET_AVX"
6790   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6791   [(set_attr "type" "sselog")
6792    (set_attr "prefix" "vex")
6793    (set_attr "mode" "TI")])
6794
6795 (define_insn "vec_interleave_highv8hi"
6796   [(set (match_operand:V8HI 0 "register_operand" "=x")
6797         (vec_select:V8HI
6798           (vec_concat:V16HI
6799             (match_operand:V8HI 1 "register_operand" "0")
6800             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6801           (parallel [(const_int 4) (const_int 12)
6802                      (const_int 5) (const_int 13)
6803                      (const_int 6) (const_int 14)
6804                      (const_int 7) (const_int 15)])))]
6805   "TARGET_SSE2"
6806   "punpckhwd\t{%2, %0|%0, %2}"
6807   [(set_attr "type" "sselog")
6808    (set_attr "prefix_data16" "1")
6809    (set_attr "mode" "TI")])
6810
6811 (define_insn "*avx_interleave_lowv8hi"
6812   [(set (match_operand:V8HI 0 "register_operand" "=x")
6813         (vec_select:V8HI
6814           (vec_concat:V16HI
6815             (match_operand:V8HI 1 "register_operand" "x")
6816             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6817           (parallel [(const_int 0) (const_int 8)
6818                      (const_int 1) (const_int 9)
6819                      (const_int 2) (const_int 10)
6820                      (const_int 3) (const_int 11)])))]
6821   "TARGET_AVX"
6822   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6823   [(set_attr "type" "sselog")
6824    (set_attr "prefix" "vex")
6825    (set_attr "mode" "TI")])
6826
6827 (define_insn "vec_interleave_lowv8hi"
6828   [(set (match_operand:V8HI 0 "register_operand" "=x")
6829         (vec_select:V8HI
6830           (vec_concat:V16HI
6831             (match_operand:V8HI 1 "register_operand" "0")
6832             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6833           (parallel [(const_int 0) (const_int 8)
6834                      (const_int 1) (const_int 9)
6835                      (const_int 2) (const_int 10)
6836                      (const_int 3) (const_int 11)])))]
6837   "TARGET_SSE2"
6838   "punpcklwd\t{%2, %0|%0, %2}"
6839   [(set_attr "type" "sselog")
6840    (set_attr "prefix_data16" "1")
6841    (set_attr "mode" "TI")])
6842
6843 (define_insn "*avx_interleave_highv4si"
6844   [(set (match_operand:V4SI 0 "register_operand" "=x")
6845         (vec_select:V4SI
6846           (vec_concat:V8SI
6847             (match_operand:V4SI 1 "register_operand" "x")
6848             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6849           (parallel [(const_int 2) (const_int 6)
6850                      (const_int 3) (const_int 7)])))]
6851   "TARGET_AVX"
6852   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6853   [(set_attr "type" "sselog")
6854    (set_attr "prefix" "vex")
6855    (set_attr "mode" "TI")])
6856
6857 (define_insn "vec_interleave_highv4si"
6858   [(set (match_operand:V4SI 0 "register_operand" "=x")
6859         (vec_select:V4SI
6860           (vec_concat:V8SI
6861             (match_operand:V4SI 1 "register_operand" "0")
6862             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6863           (parallel [(const_int 2) (const_int 6)
6864                      (const_int 3) (const_int 7)])))]
6865   "TARGET_SSE2"
6866   "punpckhdq\t{%2, %0|%0, %2}"
6867   [(set_attr "type" "sselog")
6868    (set_attr "prefix_data16" "1")
6869    (set_attr "mode" "TI")])
6870
6871 (define_insn "*avx_interleave_lowv4si"
6872   [(set (match_operand:V4SI 0 "register_operand" "=x")
6873         (vec_select:V4SI
6874           (vec_concat:V8SI
6875             (match_operand:V4SI 1 "register_operand" "x")
6876             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6877           (parallel [(const_int 0) (const_int 4)
6878                      (const_int 1) (const_int 5)])))]
6879   "TARGET_AVX"
6880   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6881   [(set_attr "type" "sselog")
6882    (set_attr "prefix" "vex")
6883    (set_attr "mode" "TI")])
6884
6885 (define_insn "vec_interleave_lowv4si"
6886   [(set (match_operand:V4SI 0 "register_operand" "=x")
6887         (vec_select:V4SI
6888           (vec_concat:V8SI
6889             (match_operand:V4SI 1 "register_operand" "0")
6890             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6891           (parallel [(const_int 0) (const_int 4)
6892                      (const_int 1) (const_int 5)])))]
6893   "TARGET_SSE2"
6894   "punpckldq\t{%2, %0|%0, %2}"
6895   [(set_attr "type" "sselog")
6896    (set_attr "prefix_data16" "1")
6897    (set_attr "mode" "TI")])
6898
6899 (define_insn "*avx_pinsr<ssevecsize>"
6900   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6901         (vec_merge:SSEMODE124
6902           (vec_duplicate:SSEMODE124
6903             (match_operand:<avxscalarmode> 2 "nonimmediate_operand" "rm"))
6904           (match_operand:SSEMODE124 1 "register_operand" "x")
6905           (match_operand:SI 3 "const_pow2_1_to_<pinsrbits>_operand" "n")))]
6906   "TARGET_AVX"
6907 {
6908   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6909   if (MEM_P (operands[2]))
6910     return "vpinsr<ssevecsize>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6911   else
6912     return "vpinsr<ssevecsize>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6913 }
6914   [(set_attr "type" "sselog")
6915    (set (attr "prefix_extra")
6916      (if_then_else (match_operand:V8HI 0 "register_operand" "")
6917        (const_string "0")
6918        (const_string "1")))
6919    (set_attr "length_immediate" "1")
6920    (set_attr "prefix" "vex")
6921    (set_attr "mode" "TI")])
6922
6923 (define_insn "*sse4_1_pinsrb"
6924   [(set (match_operand:V16QI 0 "register_operand" "=x")
6925         (vec_merge:V16QI
6926           (vec_duplicate:V16QI
6927             (match_operand:QI 2 "nonimmediate_operand" "rm"))
6928           (match_operand:V16QI 1 "register_operand" "0")
6929           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
6930   "TARGET_SSE4_1"
6931 {
6932   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6933   if (MEM_P (operands[2]))
6934     return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
6935   else
6936     return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
6937 }
6938   [(set_attr "type" "sselog")
6939    (set_attr "prefix_extra" "1")
6940    (set_attr "length_immediate" "1")
6941    (set_attr "mode" "TI")])
6942
6943 (define_insn "*sse2_pinsrw"
6944   [(set (match_operand:V8HI 0 "register_operand" "=x")
6945         (vec_merge:V8HI
6946           (vec_duplicate:V8HI
6947             (match_operand:HI 2 "nonimmediate_operand" "rm"))
6948           (match_operand:V8HI 1 "register_operand" "0")
6949           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
6950   "TARGET_SSE2"
6951 {
6952   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6953   if (MEM_P (operands[2]))
6954     return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
6955   else
6956     return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
6957 }
6958   [(set_attr "type" "sselog")
6959    (set_attr "prefix_data16" "1")
6960    (set_attr "length_immediate" "1")
6961    (set_attr "mode" "TI")])
6962
6963 ;; It must come before sse2_loadld since it is preferred.
6964 (define_insn "*sse4_1_pinsrd"
6965   [(set (match_operand:V4SI 0 "register_operand" "=x")
6966         (vec_merge:V4SI
6967           (vec_duplicate:V4SI
6968             (match_operand:SI 2 "nonimmediate_operand" "rm"))
6969           (match_operand:V4SI 1 "register_operand" "0")
6970           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
6971   "TARGET_SSE4_1"
6972 {
6973   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6974   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
6975 }
6976   [(set_attr "type" "sselog")
6977    (set_attr "prefix_extra" "1")
6978    (set_attr "length_immediate" "1")
6979    (set_attr "mode" "TI")])
6980
6981 (define_insn "*avx_pinsrq"
6982   [(set (match_operand:V2DI 0 "register_operand" "=x")
6983         (vec_merge:V2DI
6984           (vec_duplicate:V2DI
6985             (match_operand:DI 2 "nonimmediate_operand" "rm"))
6986           (match_operand:V2DI 1 "register_operand" "x")
6987           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
6988   "TARGET_AVX && TARGET_64BIT"
6989 {
6990   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6991   return "vpinsrq\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6992 }
6993   [(set_attr "type" "sselog")
6994    (set_attr "prefix_extra" "1")
6995    (set_attr "length_immediate" "1")
6996    (set_attr "prefix" "vex")
6997    (set_attr "mode" "TI")])
6998
6999 (define_insn "*sse4_1_pinsrq"
7000   [(set (match_operand:V2DI 0 "register_operand" "=x")
7001         (vec_merge:V2DI
7002           (vec_duplicate:V2DI
7003             (match_operand:DI 2 "nonimmediate_operand" "rm"))
7004           (match_operand:V2DI 1 "register_operand" "0")
7005           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
7006   "TARGET_SSE4_1 && TARGET_64BIT"
7007 {
7008   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7009   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
7010 }
7011   [(set_attr "type" "sselog")
7012    (set_attr "prefix_rex" "1")
7013    (set_attr "prefix_extra" "1")
7014    (set_attr "length_immediate" "1")
7015    (set_attr "mode" "TI")])
7016
7017 (define_insn "*sse4_1_pextrb"
7018   [(set (match_operand:SI 0 "register_operand" "=r")
7019         (zero_extend:SI
7020           (vec_select:QI
7021             (match_operand:V16QI 1 "register_operand" "x")
7022             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
7023   "TARGET_SSE4_1"
7024   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
7025   [(set_attr "type" "sselog")
7026    (set_attr "prefix_extra" "1")
7027    (set_attr "length_immediate" "1")
7028    (set_attr "prefix" "maybe_vex")
7029    (set_attr "mode" "TI")])
7030
7031 (define_insn "*sse4_1_pextrb_memory"
7032   [(set (match_operand:QI 0 "memory_operand" "=m")
7033         (vec_select:QI
7034           (match_operand:V16QI 1 "register_operand" "x")
7035           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
7036   "TARGET_SSE4_1"
7037   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
7038   [(set_attr "type" "sselog")
7039    (set_attr "prefix_extra" "1")
7040    (set_attr "length_immediate" "1")
7041    (set_attr "prefix" "maybe_vex")
7042    (set_attr "mode" "TI")])
7043
7044 (define_insn "*sse2_pextrw"
7045   [(set (match_operand:SI 0 "register_operand" "=r")
7046         (zero_extend:SI
7047           (vec_select:HI
7048             (match_operand:V8HI 1 "register_operand" "x")
7049             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
7050   "TARGET_SSE2"
7051   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
7052   [(set_attr "type" "sselog")
7053    (set_attr "prefix_data16" "1")
7054    (set_attr "length_immediate" "1")
7055    (set_attr "prefix" "maybe_vex")
7056    (set_attr "mode" "TI")])
7057
7058 (define_insn "*sse4_1_pextrw_memory"
7059   [(set (match_operand:HI 0 "memory_operand" "=m")
7060         (vec_select:HI
7061           (match_operand:V8HI 1 "register_operand" "x")
7062           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
7063   "TARGET_SSE4_1"
7064   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
7065   [(set_attr "type" "sselog")
7066    (set_attr "prefix_extra" "1")
7067    (set_attr "length_immediate" "1")
7068    (set_attr "prefix" "maybe_vex")
7069    (set_attr "mode" "TI")])
7070
7071 (define_insn "*sse4_1_pextrd"
7072   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
7073         (vec_select:SI
7074           (match_operand:V4SI 1 "register_operand" "x")
7075           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
7076   "TARGET_SSE4_1"
7077   "%vpextrd\t{%2, %1, %0|%0, %1, %2}"
7078   [(set_attr "type" "sselog")
7079    (set_attr "prefix_extra" "1")
7080    (set_attr "length_immediate" "1")
7081    (set_attr "prefix" "maybe_vex")
7082    (set_attr "mode" "TI")])
7083
7084 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
7085 (define_insn "*sse4_1_pextrq"
7086   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
7087         (vec_select:DI
7088           (match_operand:V2DI 1 "register_operand" "x")
7089           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
7090   "TARGET_SSE4_1 && TARGET_64BIT"
7091   "%vpextrq\t{%2, %1, %0|%0, %1, %2}"
7092   [(set_attr "type" "sselog")
7093    (set_attr "prefix_rex" "1")
7094    (set_attr "prefix_extra" "1")
7095    (set_attr "length_immediate" "1")
7096    (set_attr "prefix" "maybe_vex")
7097    (set_attr "mode" "TI")])
7098
7099 (define_expand "sse2_pshufd"
7100   [(match_operand:V4SI 0 "register_operand" "")
7101    (match_operand:V4SI 1 "nonimmediate_operand" "")
7102    (match_operand:SI 2 "const_int_operand" "")]
7103   "TARGET_SSE2"
7104 {
7105   int mask = INTVAL (operands[2]);
7106   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
7107                                 GEN_INT ((mask >> 0) & 3),
7108                                 GEN_INT ((mask >> 2) & 3),
7109                                 GEN_INT ((mask >> 4) & 3),
7110                                 GEN_INT ((mask >> 6) & 3)));
7111   DONE;
7112 })
7113
7114 (define_insn "sse2_pshufd_1"
7115   [(set (match_operand:V4SI 0 "register_operand" "=x")
7116         (vec_select:V4SI
7117           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
7118           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7119                      (match_operand 3 "const_0_to_3_operand" "")
7120                      (match_operand 4 "const_0_to_3_operand" "")
7121                      (match_operand 5 "const_0_to_3_operand" "")])))]
7122   "TARGET_SSE2"
7123 {
7124   int mask = 0;
7125   mask |= INTVAL (operands[2]) << 0;
7126   mask |= INTVAL (operands[3]) << 2;
7127   mask |= INTVAL (operands[4]) << 4;
7128   mask |= INTVAL (operands[5]) << 6;
7129   operands[2] = GEN_INT (mask);
7130
7131   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
7132 }
7133   [(set_attr "type" "sselog1")
7134    (set_attr "prefix_data16" "1")
7135    (set_attr "prefix" "maybe_vex")
7136    (set_attr "length_immediate" "1")
7137    (set_attr "mode" "TI")])
7138
7139 (define_expand "sse2_pshuflw"
7140   [(match_operand:V8HI 0 "register_operand" "")
7141    (match_operand:V8HI 1 "nonimmediate_operand" "")
7142    (match_operand:SI 2 "const_int_operand" "")]
7143   "TARGET_SSE2"
7144 {
7145   int mask = INTVAL (operands[2]);
7146   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
7147                                  GEN_INT ((mask >> 0) & 3),
7148                                  GEN_INT ((mask >> 2) & 3),
7149                                  GEN_INT ((mask >> 4) & 3),
7150                                  GEN_INT ((mask >> 6) & 3)));
7151   DONE;
7152 })
7153
7154 (define_insn "sse2_pshuflw_1"
7155   [(set (match_operand:V8HI 0 "register_operand" "=x")
7156         (vec_select:V8HI
7157           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7158           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7159                      (match_operand 3 "const_0_to_3_operand" "")
7160                      (match_operand 4 "const_0_to_3_operand" "")
7161                      (match_operand 5 "const_0_to_3_operand" "")
7162                      (const_int 4)
7163                      (const_int 5)
7164                      (const_int 6)
7165                      (const_int 7)])))]
7166   "TARGET_SSE2"
7167 {
7168   int mask = 0;
7169   mask |= INTVAL (operands[2]) << 0;
7170   mask |= INTVAL (operands[3]) << 2;
7171   mask |= INTVAL (operands[4]) << 4;
7172   mask |= INTVAL (operands[5]) << 6;
7173   operands[2] = GEN_INT (mask);
7174
7175   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7176 }
7177   [(set_attr "type" "sselog")
7178    (set_attr "prefix_data16" "0")
7179    (set_attr "prefix_rep" "1")
7180    (set_attr "prefix" "maybe_vex")
7181    (set_attr "length_immediate" "1")
7182    (set_attr "mode" "TI")])
7183
7184 (define_expand "sse2_pshufhw"
7185   [(match_operand:V8HI 0 "register_operand" "")
7186    (match_operand:V8HI 1 "nonimmediate_operand" "")
7187    (match_operand:SI 2 "const_int_operand" "")]
7188   "TARGET_SSE2"
7189 {
7190   int mask = INTVAL (operands[2]);
7191   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
7192                                  GEN_INT (((mask >> 0) & 3) + 4),
7193                                  GEN_INT (((mask >> 2) & 3) + 4),
7194                                  GEN_INT (((mask >> 4) & 3) + 4),
7195                                  GEN_INT (((mask >> 6) & 3) + 4)));
7196   DONE;
7197 })
7198
7199 (define_insn "sse2_pshufhw_1"
7200   [(set (match_operand:V8HI 0 "register_operand" "=x")
7201         (vec_select:V8HI
7202           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7203           (parallel [(const_int 0)
7204                      (const_int 1)
7205                      (const_int 2)
7206                      (const_int 3)
7207                      (match_operand 2 "const_4_to_7_operand" "")
7208                      (match_operand 3 "const_4_to_7_operand" "")
7209                      (match_operand 4 "const_4_to_7_operand" "")
7210                      (match_operand 5 "const_4_to_7_operand" "")])))]
7211   "TARGET_SSE2"
7212 {
7213   int mask = 0;
7214   mask |= (INTVAL (operands[2]) - 4) << 0;
7215   mask |= (INTVAL (operands[3]) - 4) << 2;
7216   mask |= (INTVAL (operands[4]) - 4) << 4;
7217   mask |= (INTVAL (operands[5]) - 4) << 6;
7218   operands[2] = GEN_INT (mask);
7219
7220   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7221 }
7222   [(set_attr "type" "sselog")
7223    (set_attr "prefix_rep" "1")
7224    (set_attr "prefix_data16" "0")
7225    (set_attr "prefix" "maybe_vex")
7226    (set_attr "length_immediate" "1")
7227    (set_attr "mode" "TI")])
7228
7229 (define_expand "sse2_loadd"
7230   [(set (match_operand:V4SI 0 "register_operand" "")
7231         (vec_merge:V4SI
7232           (vec_duplicate:V4SI
7233             (match_operand:SI 1 "nonimmediate_operand" ""))
7234           (match_dup 2)
7235           (const_int 1)))]
7236   "TARGET_SSE"
7237   "operands[2] = CONST0_RTX (V4SImode);")
7238
7239 (define_insn "*avx_loadld"
7240   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x")
7241         (vec_merge:V4SI
7242           (vec_duplicate:V4SI
7243             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,x"))
7244           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,x")
7245           (const_int 1)))]
7246   "TARGET_AVX"
7247   "@
7248    vmovd\t{%2, %0|%0, %2}
7249    vmovd\t{%2, %0|%0, %2}
7250    vmovss\t{%2, %1, %0|%0, %1, %2}"
7251   [(set_attr "type" "ssemov")
7252    (set_attr "prefix" "vex")
7253    (set_attr "mode" "TI,TI,V4SF")])
7254
7255 (define_insn "sse2_loadld"
7256   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,Yi,x,x")
7257         (vec_merge:V4SI
7258           (vec_duplicate:V4SI
7259             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
7260           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
7261           (const_int 1)))]
7262   "TARGET_SSE"
7263   "@
7264    movd\t{%2, %0|%0, %2}
7265    movd\t{%2, %0|%0, %2}
7266    movss\t{%2, %0|%0, %2}
7267    movss\t{%2, %0|%0, %2}"
7268   [(set_attr "type" "ssemov")
7269    (set_attr "mode" "TI,TI,V4SF,SF")])
7270
7271 (define_insn_and_split "sse2_stored"
7272   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
7273         (vec_select:SI
7274           (match_operand:V4SI 1 "register_operand" "x,Yi")
7275           (parallel [(const_int 0)])))]
7276   "TARGET_SSE"
7277   "#"
7278   "&& reload_completed
7279    && (TARGET_INTER_UNIT_MOVES
7280        || MEM_P (operands [0])
7281        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7282   [(set (match_dup 0) (match_dup 1))]
7283 {
7284   operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));
7285 })
7286
7287 (define_insn_and_split "*vec_ext_v4si_mem"
7288   [(set (match_operand:SI 0 "register_operand" "=r")
7289         (vec_select:SI
7290           (match_operand:V4SI 1 "memory_operand" "o")
7291           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
7292   ""
7293   "#"
7294   "reload_completed"
7295   [(const_int 0)]
7296 {
7297   int i = INTVAL (operands[2]);
7298
7299   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
7300   DONE;
7301 })
7302
7303 (define_expand "sse_storeq"
7304   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7305         (vec_select:DI
7306           (match_operand:V2DI 1 "register_operand" "")
7307           (parallel [(const_int 0)])))]
7308   "TARGET_SSE"
7309   "")
7310
7311 (define_insn "*sse2_storeq_rex64"
7312   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,*r,r")
7313         (vec_select:DI
7314           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
7315           (parallel [(const_int 0)])))]
7316   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7317   "@
7318    #
7319    #
7320    %vmov{q}\t{%1, %0|%0, %1}"
7321   [(set_attr "type" "*,*,imov")
7322    (set_attr "prefix" "*,*,maybe_vex")
7323    (set_attr "mode" "*,*,DI")])
7324
7325 (define_insn "*sse2_storeq"
7326   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
7327         (vec_select:DI
7328           (match_operand:V2DI 1 "register_operand" "x")
7329           (parallel [(const_int 0)])))]
7330   "TARGET_SSE"
7331   "#")
7332
7333 (define_split
7334   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7335         (vec_select:DI
7336           (match_operand:V2DI 1 "register_operand" "")
7337           (parallel [(const_int 0)])))]
7338   "TARGET_SSE
7339    && reload_completed
7340    && (TARGET_INTER_UNIT_MOVES
7341        || MEM_P (operands [0])
7342        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7343   [(set (match_dup 0) (match_dup 1))]
7344 {
7345   operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));
7346 })
7347
7348 (define_insn "*vec_extractv2di_1_rex64_avx"
7349   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7350         (vec_select:DI
7351           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o,o")
7352           (parallel [(const_int 1)])))]
7353   "TARGET_64BIT
7354    && TARGET_AVX
7355    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7356   "@
7357    vmovhps\t{%1, %0|%0, %1}
7358    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7359    vmovq\t{%H1, %0|%0, %H1}
7360    vmov{q}\t{%H1, %0|%0, %H1}"
7361   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7362    (set_attr "length_immediate" "*,1,*,*")
7363    (set_attr "memory" "*,none,*,*")
7364    (set_attr "prefix" "vex")
7365    (set_attr "mode" "V2SF,TI,TI,DI")])
7366
7367 (define_insn "*vec_extractv2di_1_rex64"
7368   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7369         (vec_select:DI
7370           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
7371           (parallel [(const_int 1)])))]
7372   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7373   "@
7374    movhps\t{%1, %0|%0, %1}
7375    psrldq\t{$8, %0|%0, 8}
7376    movq\t{%H1, %0|%0, %H1}
7377    mov{q}\t{%H1, %0|%0, %H1}"
7378   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7379    (set_attr "length_immediate" "*,1,*,*")
7380    (set_attr "atom_unit" "*,sishuf,*,*")
7381    (set_attr "memory" "*,none,*,*")
7382    (set_attr "mode" "V2SF,TI,TI,DI")])
7383
7384 (define_insn "*vec_extractv2di_1_avx"
7385   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7386         (vec_select:DI
7387           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7388           (parallel [(const_int 1)])))]
7389   "!TARGET_64BIT
7390    && TARGET_AVX
7391    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7392   "@
7393    vmovhps\t{%1, %0|%0, %1}
7394    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7395    vmovq\t{%H1, %0|%0, %H1}"
7396   [(set_attr "type" "ssemov,sseishft,ssemov")
7397    (set_attr "length_immediate" "*,1,*")
7398    (set_attr "memory" "*,none,*")
7399    (set_attr "prefix" "vex")
7400    (set_attr "mode" "V2SF,TI,TI")])
7401
7402 (define_insn "*vec_extractv2di_1_sse2"
7403   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7404         (vec_select:DI
7405           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
7406           (parallel [(const_int 1)])))]
7407   "!TARGET_64BIT
7408    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7409   "@
7410    movhps\t{%1, %0|%0, %1}
7411    psrldq\t{$8, %0|%0, 8}
7412    movq\t{%H1, %0|%0, %H1}"
7413   [(set_attr "type" "ssemov,sseishft,ssemov")
7414    (set_attr "length_immediate" "*,1,*")
7415    (set_attr "atom_unit" "*,sishuf,*")
7416    (set_attr "memory" "*,none,*")
7417    (set_attr "mode" "V2SF,TI,TI")])
7418
7419 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
7420 (define_insn "*vec_extractv2di_1_sse"
7421   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7422         (vec_select:DI
7423           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7424           (parallel [(const_int 1)])))]
7425   "!TARGET_SSE2 && TARGET_SSE
7426    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7427   "@
7428    movhps\t{%1, %0|%0, %1}
7429    movhlps\t{%1, %0|%0, %1}
7430    movlps\t{%H1, %0|%0, %H1}"
7431   [(set_attr "type" "ssemov")
7432    (set_attr "mode" "V2SF,V4SF,V2SF")])
7433
7434 (define_insn "*vec_dupv4si_avx"
7435   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
7436         (vec_duplicate:V4SI
7437           (match_operand:SI 1 "register_operand" "x,m")))]
7438   "TARGET_AVX"
7439   "@
7440    vpshufd\t{$0, %1, %0|%0, %1, 0}
7441    vbroadcastss\t{%1, %0|%0, %1}"
7442   [(set_attr "type" "sselog1,ssemov")
7443    (set_attr "length_immediate" "1,0")
7444    (set_attr "prefix_extra" "0,1")
7445    (set_attr "prefix" "vex")
7446    (set_attr "mode" "TI,V4SF")])
7447
7448 (define_insn "*vec_dupv4si"
7449   [(set (match_operand:V4SI 0 "register_operand" "=Y2,x")
7450         (vec_duplicate:V4SI
7451           (match_operand:SI 1 "register_operand" " Y2,0")))]
7452   "TARGET_SSE"
7453   "@
7454    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7455    shufps\t{$0, %0, %0|%0, %0, 0}"
7456   [(set_attr "type" "sselog1")
7457    (set_attr "length_immediate" "1")
7458    (set_attr "mode" "TI,V4SF")])
7459
7460 (define_insn "*vec_dupv2di_avx"
7461   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7462         (vec_duplicate:V2DI
7463           (match_operand:DI 1 "nonimmediate_operand" " x,m")))]
7464   "TARGET_AVX"
7465   "@
7466    vpunpcklqdq\t{%1, %1, %0|%0, %1, %1}
7467    vmovddup\t{%1, %0|%0, %1}"
7468   [(set_attr "type" "sselog1")
7469    (set_attr "prefix" "vex")
7470    (set_attr "mode" "TI,DF")])
7471
7472 (define_insn "*vec_dupv2di_sse3"
7473   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7474         (vec_duplicate:V2DI
7475           (match_operand:DI 1 "nonimmediate_operand" " 0,m")))]
7476   "TARGET_SSE3"
7477   "@
7478    punpcklqdq\t%0, %0
7479    movddup\t{%1, %0|%0, %1}"
7480   [(set_attr "type" "sselog1")
7481    (set_attr "mode" "TI,DF")])
7482
7483 (define_insn "*vec_dupv2di"
7484   [(set (match_operand:V2DI 0 "register_operand" "=Y2,x")
7485         (vec_duplicate:V2DI
7486           (match_operand:DI 1 "register_operand" " 0 ,0")))]
7487   "TARGET_SSE"
7488   "@
7489    punpcklqdq\t%0, %0
7490    movlhps\t%0, %0"
7491   [(set_attr "type" "sselog1,ssemov")
7492    (set_attr "mode" "TI,V4SF")])
7493
7494 (define_insn "*vec_concatv2si_avx"
7495   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7496         (vec_concat:V2SI
7497           (match_operand:SI 1 "nonimmediate_operand" "x ,x,rm, 0 ,rm")
7498           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7499   "TARGET_AVX"
7500   "@
7501    vpinsrd\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7502    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7503    vmovd\t{%1, %0|%0, %1}
7504    punpckldq\t{%2, %0|%0, %2}
7505    movd\t{%1, %0|%0, %1}"
7506   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7507    (set_attr "prefix_extra" "1,*,*,*,*")
7508    (set_attr "length_immediate" "1,*,*,*,*")
7509    (set (attr "prefix")
7510      (if_then_else (eq_attr "alternative" "3,4")
7511        (const_string "orig")
7512        (const_string "vex")))
7513    (set_attr "mode" "TI,TI,TI,DI,DI")])
7514
7515 (define_insn "*vec_concatv2si_sse4_1"
7516   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7517         (vec_concat:V2SI
7518           (match_operand:SI 1 "nonimmediate_operand" "0 ,0,rm, 0 ,rm")
7519           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7520   "TARGET_SSE4_1"
7521   "@
7522    pinsrd\t{$0x1, %2, %0|%0, %2, 0x1}
7523    punpckldq\t{%2, %0|%0, %2}
7524    movd\t{%1, %0|%0, %1}
7525    punpckldq\t{%2, %0|%0, %2}
7526    movd\t{%1, %0|%0, %1}"
7527   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7528    (set_attr "prefix_extra" "1,*,*,*,*")
7529    (set_attr "length_immediate" "1,*,*,*,*")
7530    (set_attr "mode" "TI,TI,TI,DI,DI")])
7531
7532 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7533 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7534 ;; alternatives pretty much forces the MMX alternative to be chosen.
7535 (define_insn "*vec_concatv2si_sse2"
7536   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,*y")
7537         (vec_concat:V2SI
7538           (match_operand:SI 1 "nonimmediate_operand" " 0,rm, 0,rm")
7539           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,*y, C")))]
7540   "TARGET_SSE2"
7541   "@
7542    punpckldq\t{%2, %0|%0, %2}
7543    movd\t{%1, %0|%0, %1}
7544    punpckldq\t{%2, %0|%0, %2}
7545    movd\t{%1, %0|%0, %1}"
7546   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7547    (set_attr "mode" "TI,TI,DI,DI")])
7548
7549 (define_insn "*vec_concatv2si_sse"
7550   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
7551         (vec_concat:V2SI
7552           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
7553           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
7554   "TARGET_SSE"
7555   "@
7556    unpcklps\t{%2, %0|%0, %2}
7557    movss\t{%1, %0|%0, %1}
7558    punpckldq\t{%2, %0|%0, %2}
7559    movd\t{%1, %0|%0, %1}"
7560   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7561    (set_attr "mode" "V4SF,V4SF,DI,DI")])
7562
7563 (define_insn "*vec_concatv4si_1_avx"
7564   [(set (match_operand:V4SI 0 "register_operand"       "=x,x")
7565         (vec_concat:V4SI
7566           (match_operand:V2SI 1 "register_operand"     " x,x")
7567           (match_operand:V2SI 2 "nonimmediate_operand" " x,m")))]
7568   "TARGET_AVX"
7569   "@
7570    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7571    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7572   [(set_attr "type" "sselog,ssemov")
7573    (set_attr "prefix" "vex")
7574    (set_attr "mode" "TI,V2SF")])
7575
7576 (define_insn "*vec_concatv4si_1"
7577   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,x,x")
7578         (vec_concat:V4SI
7579           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
7580           (match_operand:V2SI 2 "nonimmediate_operand" " Y2,x,m")))]
7581   "TARGET_SSE"
7582   "@
7583    punpcklqdq\t{%2, %0|%0, %2}
7584    movlhps\t{%2, %0|%0, %2}
7585    movhps\t{%2, %0|%0, %2}"
7586   [(set_attr "type" "sselog,ssemov,ssemov")
7587    (set_attr "mode" "TI,V4SF,V2SF")])
7588
7589 (define_insn "*vec_concatv2di_avx"
7590   [(set (match_operand:V2DI 0 "register_operand"     "=x,?x,x,x")
7591         (vec_concat:V2DI
7592           (match_operand:DI 1 "nonimmediate_operand" " m,*y,x,x")
7593           (match_operand:DI 2 "vector_move_operand"  " C, C,x,m")))]
7594   "!TARGET_64BIT && TARGET_AVX"
7595   "@
7596    vmovq\t{%1, %0|%0, %1}
7597    movq2dq\t{%1, %0|%0, %1}
7598    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7599    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7600   [(set_attr "type" "ssemov,ssemov,sselog,ssemov")
7601    (set (attr "prefix")
7602      (if_then_else (eq_attr "alternative" "1")
7603        (const_string "orig")
7604        (const_string "vex")))
7605    (set_attr "mode" "TI,TI,TI,V2SF")])
7606
7607 (define_insn "vec_concatv2di"
7608   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,?Y2,Y2,x,x")
7609         (vec_concat:V2DI
7610           (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0")
7611           (match_operand:DI 2 "vector_move_operand"  " C  ,  C,Y2,x,m")))]
7612   "!TARGET_64BIT && TARGET_SSE"
7613   "@
7614    movq\t{%1, %0|%0, %1}
7615    movq2dq\t{%1, %0|%0, %1}
7616    punpcklqdq\t{%2, %0|%0, %2}
7617    movlhps\t{%2, %0|%0, %2}
7618    movhps\t{%2, %0|%0, %2}"
7619   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov")
7620    (set_attr "mode" "TI,TI,TI,V4SF,V2SF")])
7621
7622 (define_insn "*vec_concatv2di_rex64_avx"
7623   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,Yi,!x,x,x")
7624         (vec_concat:V2DI
7625           (match_operand:DI 1 "nonimmediate_operand" " x,m,r ,*y,x,x")
7626           (match_operand:DI 2 "vector_move_operand"  "rm,C,C ,C ,x,m")))]
7627   "TARGET_64BIT && TARGET_AVX"
7628   "@
7629    vpinsrq\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7630    vmovq\t{%1, %0|%0, %1}
7631    vmovq\t{%1, %0|%0, %1}
7632    movq2dq\t{%1, %0|%0, %1}
7633    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7634    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7635   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov")
7636    (set_attr "prefix_extra" "1,*,*,*,*,*")
7637    (set_attr "length_immediate" "1,*,*,*,*,*")
7638    (set (attr "prefix")
7639      (if_then_else (eq_attr "alternative" "3")
7640        (const_string "orig")
7641        (const_string "vex")))
7642    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
7643
7644 (define_insn "*vec_concatv2di_rex64_sse4_1"
7645   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
7646         (vec_concat:V2DI
7647           (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0")
7648           (match_operand:DI 2 "vector_move_operand"  " rm,C ,C ,C ,x,x,m")))]
7649   "TARGET_64BIT && TARGET_SSE4_1"
7650   "@
7651    pinsrq\t{$0x1, %2, %0|%0, %2, 0x1}
7652    movq\t{%1, %0|%0, %1}
7653    movq\t{%1, %0|%0, %1}
7654    movq2dq\t{%1, %0|%0, %1}
7655    punpcklqdq\t{%2, %0|%0, %2}
7656    movlhps\t{%2, %0|%0, %2}
7657    movhps\t{%2, %0|%0, %2}"
7658   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7659    (set_attr "prefix_rex" "1,*,1,*,*,*,*")
7660    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7661    (set_attr "length_immediate" "1,*,*,*,*,*,*")
7662    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
7663
7664 (define_insn "*vec_concatv2di_rex64_sse"
7665   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
7666         (vec_concat:V2DI
7667           (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0")
7668           (match_operand:DI 2 "vector_move_operand"  " C  ,C ,C  ,Y2,x,m")))]
7669   "TARGET_64BIT && TARGET_SSE"
7670   "@
7671    movq\t{%1, %0|%0, %1}
7672    movq\t{%1, %0|%0, %1}
7673    movq2dq\t{%1, %0|%0, %1}
7674    punpcklqdq\t{%2, %0|%0, %2}
7675    movlhps\t{%2, %0|%0, %2}
7676    movhps\t{%2, %0|%0, %2}"
7677   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7678    (set_attr "prefix_rex" "*,1,*,*,*,*")
7679    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")])
7680
7681 (define_expand "vec_unpacku_hi_v16qi"
7682   [(match_operand:V8HI 0 "register_operand" "")
7683    (match_operand:V16QI 1 "register_operand" "")]
7684   "TARGET_SSE2"
7685 {
7686   if (TARGET_SSE4_1)
7687     ix86_expand_sse4_unpack (operands, true, true);
7688   else
7689     ix86_expand_sse_unpack (operands, true, true);
7690   DONE;
7691 })
7692
7693 (define_expand "vec_unpacks_hi_v16qi"
7694   [(match_operand:V8HI 0 "register_operand" "")
7695    (match_operand:V16QI 1 "register_operand" "")]
7696   "TARGET_SSE2"
7697 {
7698   if (TARGET_SSE4_1)
7699     ix86_expand_sse4_unpack (operands, false, true);
7700   else
7701     ix86_expand_sse_unpack (operands, false, true);
7702   DONE;
7703 })
7704
7705 (define_expand "vec_unpacku_lo_v16qi"
7706   [(match_operand:V8HI 0 "register_operand" "")
7707    (match_operand:V16QI 1 "register_operand" "")]
7708   "TARGET_SSE2"
7709 {
7710   if (TARGET_SSE4_1)
7711     ix86_expand_sse4_unpack (operands, true, false);
7712   else
7713     ix86_expand_sse_unpack (operands, true, false);
7714   DONE;
7715 })
7716
7717 (define_expand "vec_unpacks_lo_v16qi"
7718   [(match_operand:V8HI 0 "register_operand" "")
7719    (match_operand:V16QI 1 "register_operand" "")]
7720   "TARGET_SSE2"
7721 {
7722   if (TARGET_SSE4_1)
7723     ix86_expand_sse4_unpack (operands, false, false);
7724   else
7725     ix86_expand_sse_unpack (operands, false, false);
7726   DONE;
7727 })
7728
7729 (define_expand "vec_unpacku_hi_v8hi"
7730   [(match_operand:V4SI 0 "register_operand" "")
7731    (match_operand:V8HI 1 "register_operand" "")]
7732   "TARGET_SSE2"
7733 {
7734   if (TARGET_SSE4_1)
7735     ix86_expand_sse4_unpack (operands, true, true);
7736   else
7737     ix86_expand_sse_unpack (operands, true, true);
7738   DONE;
7739 })
7740
7741 (define_expand "vec_unpacks_hi_v8hi"
7742   [(match_operand:V4SI 0 "register_operand" "")
7743    (match_operand:V8HI 1 "register_operand" "")]
7744   "TARGET_SSE2"
7745 {
7746   if (TARGET_SSE4_1)
7747     ix86_expand_sse4_unpack (operands, false, true);
7748   else
7749     ix86_expand_sse_unpack (operands, false, true);
7750   DONE;
7751 })
7752
7753 (define_expand "vec_unpacku_lo_v8hi"
7754   [(match_operand:V4SI 0 "register_operand" "")
7755    (match_operand:V8HI 1 "register_operand" "")]
7756   "TARGET_SSE2"
7757 {
7758   if (TARGET_SSE4_1)
7759     ix86_expand_sse4_unpack (operands, true, false);
7760   else
7761     ix86_expand_sse_unpack (operands, true, false);
7762   DONE;
7763 })
7764
7765 (define_expand "vec_unpacks_lo_v8hi"
7766   [(match_operand:V4SI 0 "register_operand" "")
7767    (match_operand:V8HI 1 "register_operand" "")]
7768   "TARGET_SSE2"
7769 {
7770   if (TARGET_SSE4_1)
7771     ix86_expand_sse4_unpack (operands, false, false);
7772   else
7773     ix86_expand_sse_unpack (operands, false, false);
7774   DONE;
7775 })
7776
7777 (define_expand "vec_unpacku_hi_v4si"
7778   [(match_operand:V2DI 0 "register_operand" "")
7779    (match_operand:V4SI 1 "register_operand" "")]
7780   "TARGET_SSE2"
7781 {
7782   if (TARGET_SSE4_1)
7783     ix86_expand_sse4_unpack (operands, true, true);
7784   else
7785     ix86_expand_sse_unpack (operands, true, true);
7786   DONE;
7787 })
7788
7789 (define_expand "vec_unpacks_hi_v4si"
7790   [(match_operand:V2DI 0 "register_operand" "")
7791    (match_operand:V4SI 1 "register_operand" "")]
7792   "TARGET_SSE2"
7793 {
7794   if (TARGET_SSE4_1)
7795     ix86_expand_sse4_unpack (operands, false, true);
7796   else
7797     ix86_expand_sse_unpack (operands, false, true);
7798   DONE;
7799 })
7800
7801 (define_expand "vec_unpacku_lo_v4si"
7802   [(match_operand:V2DI 0 "register_operand" "")
7803    (match_operand:V4SI 1 "register_operand" "")]
7804   "TARGET_SSE2"
7805 {
7806   if (TARGET_SSE4_1)
7807     ix86_expand_sse4_unpack (operands, true, false);
7808   else
7809     ix86_expand_sse_unpack (operands, true, false);
7810   DONE;
7811 })
7812
7813 (define_expand "vec_unpacks_lo_v4si"
7814   [(match_operand:V2DI 0 "register_operand" "")
7815    (match_operand:V4SI 1 "register_operand" "")]
7816   "TARGET_SSE2"
7817 {
7818   if (TARGET_SSE4_1)
7819     ix86_expand_sse4_unpack (operands, false, false);
7820   else
7821     ix86_expand_sse_unpack (operands, false, false);
7822   DONE;
7823 })
7824
7825 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7826 ;;
7827 ;; Miscellaneous
7828 ;;
7829 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7830
7831 (define_expand "sse2_uavgv16qi3"
7832   [(set (match_operand:V16QI 0 "register_operand" "")
7833         (truncate:V16QI
7834           (lshiftrt:V16HI
7835             (plus:V16HI
7836               (plus:V16HI
7837                 (zero_extend:V16HI
7838                   (match_operand:V16QI 1 "nonimmediate_operand" ""))
7839                 (zero_extend:V16HI
7840                   (match_operand:V16QI 2 "nonimmediate_operand" "")))
7841               (const_vector:V16QI [(const_int 1) (const_int 1)
7842                                    (const_int 1) (const_int 1)
7843                                    (const_int 1) (const_int 1)
7844                                    (const_int 1) (const_int 1)
7845                                    (const_int 1) (const_int 1)
7846                                    (const_int 1) (const_int 1)
7847                                    (const_int 1) (const_int 1)
7848                                    (const_int 1) (const_int 1)]))
7849             (const_int 1))))]
7850   "TARGET_SSE2"
7851   "ix86_fixup_binary_operands_no_copy (PLUS, V16QImode, operands);")
7852
7853 (define_insn "*avx_uavgv16qi3"
7854   [(set (match_operand:V16QI 0 "register_operand" "=x")
7855         (truncate:V16QI
7856           (lshiftrt:V16HI
7857             (plus:V16HI
7858               (plus:V16HI
7859                 (zero_extend:V16HI
7860                   (match_operand:V16QI 1 "nonimmediate_operand" "%x"))
7861                 (zero_extend:V16HI
7862                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7863               (const_vector:V16QI [(const_int 1) (const_int 1)
7864                                    (const_int 1) (const_int 1)
7865                                    (const_int 1) (const_int 1)
7866                                    (const_int 1) (const_int 1)
7867                                    (const_int 1) (const_int 1)
7868                                    (const_int 1) (const_int 1)
7869                                    (const_int 1) (const_int 1)
7870                                    (const_int 1) (const_int 1)]))
7871             (const_int 1))))]
7872   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7873   "vpavgb\t{%2, %1, %0|%0, %1, %2}"
7874   [(set_attr "type" "sseiadd")
7875    (set_attr "prefix" "vex")
7876    (set_attr "mode" "TI")])
7877
7878 (define_insn "*sse2_uavgv16qi3"
7879   [(set (match_operand:V16QI 0 "register_operand" "=x")
7880         (truncate:V16QI
7881           (lshiftrt:V16HI
7882             (plus:V16HI
7883               (plus:V16HI
7884                 (zero_extend:V16HI
7885                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
7886                 (zero_extend:V16HI
7887                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7888               (const_vector:V16QI [(const_int 1) (const_int 1)
7889                                    (const_int 1) (const_int 1)
7890                                    (const_int 1) (const_int 1)
7891                                    (const_int 1) (const_int 1)
7892                                    (const_int 1) (const_int 1)
7893                                    (const_int 1) (const_int 1)
7894                                    (const_int 1) (const_int 1)
7895                                    (const_int 1) (const_int 1)]))
7896             (const_int 1))))]
7897   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7898   "pavgb\t{%2, %0|%0, %2}"
7899   [(set_attr "type" "sseiadd")
7900    (set_attr "prefix_data16" "1")
7901    (set_attr "mode" "TI")])
7902
7903 (define_expand "sse2_uavgv8hi3"
7904   [(set (match_operand:V8HI 0 "register_operand" "")
7905         (truncate:V8HI
7906           (lshiftrt:V8SI
7907             (plus:V8SI
7908               (plus:V8SI
7909                 (zero_extend:V8SI
7910                   (match_operand:V8HI 1 "nonimmediate_operand" ""))
7911                 (zero_extend:V8SI
7912                   (match_operand:V8HI 2 "nonimmediate_operand" "")))
7913               (const_vector:V8HI [(const_int 1) (const_int 1)
7914                                   (const_int 1) (const_int 1)
7915                                   (const_int 1) (const_int 1)
7916                                   (const_int 1) (const_int 1)]))
7917             (const_int 1))))]
7918   "TARGET_SSE2"
7919   "ix86_fixup_binary_operands_no_copy (PLUS, V8HImode, operands);")
7920
7921 (define_insn "*avx_uavgv8hi3"
7922   [(set (match_operand:V8HI 0 "register_operand" "=x")
7923         (truncate:V8HI
7924           (lshiftrt:V8SI
7925             (plus:V8SI
7926               (plus:V8SI
7927                 (zero_extend:V8SI
7928                   (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
7929                 (zero_extend:V8SI
7930                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7931               (const_vector:V8HI [(const_int 1) (const_int 1)
7932                                   (const_int 1) (const_int 1)
7933                                   (const_int 1) (const_int 1)
7934                                   (const_int 1) (const_int 1)]))
7935             (const_int 1))))]
7936   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7937   "vpavgw\t{%2, %1, %0|%0, %1, %2}"
7938   [(set_attr "type" "sseiadd")
7939    (set_attr "prefix" "vex")
7940    (set_attr "mode" "TI")])
7941
7942 (define_insn "*sse2_uavgv8hi3"
7943   [(set (match_operand:V8HI 0 "register_operand" "=x")
7944         (truncate:V8HI
7945           (lshiftrt:V8SI
7946             (plus:V8SI
7947               (plus:V8SI
7948                 (zero_extend:V8SI
7949                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
7950                 (zero_extend:V8SI
7951                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7952               (const_vector:V8HI [(const_int 1) (const_int 1)
7953                                   (const_int 1) (const_int 1)
7954                                   (const_int 1) (const_int 1)
7955                                   (const_int 1) (const_int 1)]))
7956             (const_int 1))))]
7957   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7958   "pavgw\t{%2, %0|%0, %2}"
7959   [(set_attr "type" "sseiadd")
7960    (set_attr "prefix_data16" "1")
7961    (set_attr "mode" "TI")])
7962
7963 ;; The correct representation for this is absolutely enormous, and
7964 ;; surely not generally useful.
7965 (define_insn "*avx_psadbw"
7966   [(set (match_operand:V2DI 0 "register_operand" "=x")
7967         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "x")
7968                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7969                      UNSPEC_PSADBW))]
7970   "TARGET_AVX"
7971   "vpsadbw\t{%2, %1, %0|%0, %1, %2}"
7972   [(set_attr "type" "sseiadd")
7973    (set_attr "prefix" "vex")
7974    (set_attr "mode" "TI")])
7975
7976 (define_insn "sse2_psadbw"
7977   [(set (match_operand:V2DI 0 "register_operand" "=x")
7978         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
7979                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7980                      UNSPEC_PSADBW))]
7981   "TARGET_SSE2"
7982   "psadbw\t{%2, %0|%0, %2}"
7983   [(set_attr "type" "sseiadd")
7984    (set_attr "atom_unit" "simul")
7985    (set_attr "prefix_data16" "1")
7986    (set_attr "mode" "TI")])
7987
7988 (define_insn "avx_movmskp<avxmodesuffixf2c>256"
7989   [(set (match_operand:SI 0 "register_operand" "=r")
7990         (unspec:SI
7991           [(match_operand:AVX256MODEF2P 1 "register_operand" "x")]
7992           UNSPEC_MOVMSK))]
7993   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
7994   "vmovmskp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
7995   [(set_attr "type" "ssecvt")
7996    (set_attr "prefix" "vex")
7997    (set_attr "mode" "<MODE>")])
7998
7999 (define_insn "<sse>_movmskp<ssemodesuffixf2c>"
8000   [(set (match_operand:SI 0 "register_operand" "=r")
8001         (unspec:SI
8002           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
8003           UNSPEC_MOVMSK))]
8004   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
8005   "%vmovmskp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
8006   [(set_attr "type" "ssemov")
8007    (set_attr "prefix" "maybe_vex")
8008    (set_attr "mode" "<MODE>")])
8009
8010 (define_insn "sse2_pmovmskb"
8011   [(set (match_operand:SI 0 "register_operand" "=r")
8012         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
8013                    UNSPEC_MOVMSK))]
8014   "TARGET_SSE2"
8015   "%vpmovmskb\t{%1, %0|%0, %1}"
8016   [(set_attr "type" "ssemov")
8017    (set_attr "prefix_data16" "1")
8018    (set_attr "prefix" "maybe_vex")
8019    (set_attr "mode" "SI")])
8020
8021 (define_expand "sse2_maskmovdqu"
8022   [(set (match_operand:V16QI 0 "memory_operand" "")
8023         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
8024                        (match_operand:V16QI 2 "register_operand" "")
8025                        (match_dup 0)]
8026                       UNSPEC_MASKMOV))]
8027   "TARGET_SSE2"
8028   "")
8029
8030 (define_insn "*sse2_maskmovdqu"
8031   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
8032         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8033                        (match_operand:V16QI 2 "register_operand" "x")
8034                        (mem:V16QI (match_dup 0))]
8035                       UNSPEC_MASKMOV))]
8036   "TARGET_SSE2 && !TARGET_64BIT"
8037   ;; @@@ check ordering of operands in intel/nonintel syntax
8038   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8039   [(set_attr "type" "ssemov")
8040    (set_attr "prefix_data16" "1")
8041    ;; The implicit %rdi operand confuses default length_vex computation.
8042    (set_attr "length_vex" "3")
8043    (set_attr "prefix" "maybe_vex")
8044    (set_attr "mode" "TI")])
8045
8046 (define_insn "*sse2_maskmovdqu_rex64"
8047   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
8048         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8049                        (match_operand:V16QI 2 "register_operand" "x")
8050                        (mem:V16QI (match_dup 0))]
8051                       UNSPEC_MASKMOV))]
8052   "TARGET_SSE2 && TARGET_64BIT"
8053   ;; @@@ check ordering of operands in intel/nonintel syntax
8054   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8055   [(set_attr "type" "ssemov")
8056    (set_attr "prefix_data16" "1")
8057    ;; The implicit %rdi operand confuses default length_vex computation.
8058    (set (attr "length_vex")
8059      (symbol_ref ("REGNO (operands[2]) >= FIRST_REX_SSE_REG ? 3 + 1 : 2 + 1")))
8060    (set_attr "prefix" "maybe_vex")
8061    (set_attr "mode" "TI")])
8062
8063 (define_insn "sse_ldmxcsr"
8064   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
8065                     UNSPECV_LDMXCSR)]
8066   "TARGET_SSE"
8067   "%vldmxcsr\t%0"
8068   [(set_attr "type" "sse")
8069    (set_attr "atom_sse_attr" "mxcsr")
8070    (set_attr "prefix" "maybe_vex")
8071    (set_attr "memory" "load")])
8072
8073 (define_insn "sse_stmxcsr"
8074   [(set (match_operand:SI 0 "memory_operand" "=m")
8075         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
8076   "TARGET_SSE"
8077   "%vstmxcsr\t%0"
8078   [(set_attr "type" "sse")
8079    (set_attr "atom_sse_attr" "mxcsr")
8080    (set_attr "prefix" "maybe_vex")
8081    (set_attr "memory" "store")])
8082
8083 (define_expand "sse_sfence"
8084   [(set (match_dup 0)
8085         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8086   "TARGET_SSE || TARGET_3DNOW_A"
8087 {
8088   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8089   MEM_VOLATILE_P (operands[0]) = 1;
8090 })
8091
8092 (define_insn "*sse_sfence"
8093   [(set (match_operand:BLK 0 "" "")
8094         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8095   "TARGET_SSE || TARGET_3DNOW_A"
8096   "sfence"
8097   [(set_attr "type" "sse")
8098    (set_attr "length_address" "0")
8099    (set_attr "atom_sse_attr" "fence")
8100    (set_attr "memory" "unknown")])
8101
8102 (define_insn "sse2_clflush"
8103   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
8104                     UNSPECV_CLFLUSH)]
8105   "TARGET_SSE2"
8106   "clflush\t%a0"
8107   [(set_attr "type" "sse")
8108    (set_attr "atom_sse_attr" "fence")
8109    (set_attr "memory" "unknown")])
8110
8111 (define_expand "sse2_mfence"
8112   [(set (match_dup 0)
8113         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8114   "TARGET_SSE2"
8115 {
8116   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8117   MEM_VOLATILE_P (operands[0]) = 1;
8118 })
8119
8120 (define_insn "*sse2_mfence"
8121   [(set (match_operand:BLK 0 "" "")
8122         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8123   "TARGET_64BIT || TARGET_SSE2"
8124   "mfence"
8125   [(set_attr "type" "sse")
8126    (set_attr "length_address" "0")
8127    (set_attr "atom_sse_attr" "fence")
8128    (set_attr "memory" "unknown")])
8129
8130 (define_expand "sse2_lfence"
8131   [(set (match_dup 0)
8132         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8133   "TARGET_SSE2"
8134 {
8135   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8136   MEM_VOLATILE_P (operands[0]) = 1;
8137 })
8138
8139 (define_insn "*sse2_lfence"
8140   [(set (match_operand:BLK 0 "" "")
8141         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8142   "TARGET_SSE2"
8143   "lfence"
8144   [(set_attr "type" "sse")
8145    (set_attr "length_address" "0")
8146    (set_attr "atom_sse_attr" "lfence")
8147    (set_attr "memory" "unknown")])
8148
8149 (define_insn "sse3_mwait"
8150   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8151                      (match_operand:SI 1 "register_operand" "c")]
8152                     UNSPECV_MWAIT)]
8153   "TARGET_SSE3"
8154 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
8155 ;; Since 32bit register operands are implicitly zero extended to 64bit,
8156 ;; we only need to set up 32bit registers.
8157   "mwait"
8158   [(set_attr "length" "3")])
8159
8160 (define_insn "sse3_monitor"
8161   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8162                      (match_operand:SI 1 "register_operand" "c")
8163                      (match_operand:SI 2 "register_operand" "d")]
8164                     UNSPECV_MONITOR)]
8165   "TARGET_SSE3 && !TARGET_64BIT"
8166   "monitor\t%0, %1, %2"
8167   [(set_attr "length" "3")])
8168
8169 (define_insn "sse3_monitor64"
8170   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
8171                      (match_operand:SI 1 "register_operand" "c")
8172                      (match_operand:SI 2 "register_operand" "d")]
8173                     UNSPECV_MONITOR)]
8174   "TARGET_SSE3 && TARGET_64BIT"
8175 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
8176 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
8177 ;; zero extended to 64bit, we only need to set up 32bit registers.
8178   "monitor"
8179   [(set_attr "length" "3")])
8180
8181 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8182 ;;
8183 ;; SSSE3 instructions
8184 ;;
8185 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8186
8187 (define_insn "*avx_phaddwv8hi3"
8188   [(set (match_operand:V8HI 0 "register_operand" "=x")
8189         (vec_concat:V8HI
8190           (vec_concat:V4HI
8191             (vec_concat:V2HI
8192               (plus:HI
8193                 (vec_select:HI
8194                   (match_operand:V8HI 1 "register_operand" "x")
8195                   (parallel [(const_int 0)]))
8196                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8197               (plus:HI
8198                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8199                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8200             (vec_concat:V2HI
8201               (plus:HI
8202                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8203                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8204               (plus:HI
8205                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8206                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8207           (vec_concat:V4HI
8208             (vec_concat:V2HI
8209               (plus:HI
8210                 (vec_select:HI
8211                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8212                   (parallel [(const_int 0)]))
8213                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8214               (plus:HI
8215                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8216                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8217             (vec_concat:V2HI
8218               (plus:HI
8219                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8220                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8221               (plus:HI
8222                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8223                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8224   "TARGET_AVX"
8225   "vphaddw\t{%2, %1, %0|%0, %1, %2}"
8226   [(set_attr "type" "sseiadd")
8227    (set_attr "prefix_extra" "1")
8228    (set_attr "prefix" "vex")
8229    (set_attr "mode" "TI")])
8230
8231 (define_insn "ssse3_phaddwv8hi3"
8232   [(set (match_operand:V8HI 0 "register_operand" "=x")
8233         (vec_concat:V8HI
8234           (vec_concat:V4HI
8235             (vec_concat:V2HI
8236               (plus:HI
8237                 (vec_select:HI
8238                   (match_operand:V8HI 1 "register_operand" "0")
8239                   (parallel [(const_int 0)]))
8240                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8241               (plus:HI
8242                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8243                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8244             (vec_concat:V2HI
8245               (plus:HI
8246                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8247                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8248               (plus:HI
8249                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8250                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8251           (vec_concat:V4HI
8252             (vec_concat:V2HI
8253               (plus:HI
8254                 (vec_select:HI
8255                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8256                   (parallel [(const_int 0)]))
8257                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8258               (plus:HI
8259                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8260                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8261             (vec_concat:V2HI
8262               (plus:HI
8263                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8264                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8265               (plus:HI
8266                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8267                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8268   "TARGET_SSSE3"
8269   "phaddw\t{%2, %0|%0, %2}"
8270   [(set_attr "type" "sseiadd")
8271    (set_attr "atom_unit" "complex")
8272    (set_attr "prefix_data16" "1")
8273    (set_attr "prefix_extra" "1")
8274    (set_attr "mode" "TI")])
8275
8276 (define_insn "ssse3_phaddwv4hi3"
8277   [(set (match_operand:V4HI 0 "register_operand" "=y")
8278         (vec_concat:V4HI
8279           (vec_concat:V2HI
8280             (plus:HI
8281               (vec_select:HI
8282                 (match_operand:V4HI 1 "register_operand" "0")
8283                 (parallel [(const_int 0)]))
8284               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8285             (plus:HI
8286               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8287               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8288           (vec_concat:V2HI
8289             (plus:HI
8290               (vec_select:HI
8291                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8292                 (parallel [(const_int 0)]))
8293               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8294             (plus:HI
8295               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8296               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8297   "TARGET_SSSE3"
8298   "phaddw\t{%2, %0|%0, %2}"
8299   [(set_attr "type" "sseiadd")
8300    (set_attr "atom_unit" "complex")
8301    (set_attr "prefix_extra" "1")
8302    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8303    (set_attr "mode" "DI")])
8304
8305 (define_insn "*avx_phadddv4si3"
8306   [(set (match_operand:V4SI 0 "register_operand" "=x")
8307         (vec_concat:V4SI
8308           (vec_concat:V2SI
8309             (plus:SI
8310               (vec_select:SI
8311                 (match_operand:V4SI 1 "register_operand" "x")
8312                 (parallel [(const_int 0)]))
8313               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8314             (plus:SI
8315               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8316               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8317           (vec_concat:V2SI
8318             (plus:SI
8319               (vec_select:SI
8320                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8321                 (parallel [(const_int 0)]))
8322               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8323             (plus:SI
8324               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8325               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8326   "TARGET_AVX"
8327   "vphaddd\t{%2, %1, %0|%0, %1, %2}"
8328   [(set_attr "type" "sseiadd")
8329    (set_attr "prefix_extra" "1")
8330    (set_attr "prefix" "vex")
8331    (set_attr "mode" "TI")])
8332
8333 (define_insn "ssse3_phadddv4si3"
8334   [(set (match_operand:V4SI 0 "register_operand" "=x")
8335         (vec_concat:V4SI
8336           (vec_concat:V2SI
8337             (plus:SI
8338               (vec_select:SI
8339                 (match_operand:V4SI 1 "register_operand" "0")
8340                 (parallel [(const_int 0)]))
8341               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8342             (plus:SI
8343               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8344               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8345           (vec_concat:V2SI
8346             (plus:SI
8347               (vec_select:SI
8348                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8349                 (parallel [(const_int 0)]))
8350               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8351             (plus:SI
8352               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8353               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8354   "TARGET_SSSE3"
8355   "phaddd\t{%2, %0|%0, %2}"
8356   [(set_attr "type" "sseiadd")
8357    (set_attr "atom_unit" "complex")
8358    (set_attr "prefix_data16" "1")
8359    (set_attr "prefix_extra" "1")
8360    (set_attr "mode" "TI")])
8361
8362 (define_insn "ssse3_phadddv2si3"
8363   [(set (match_operand:V2SI 0 "register_operand" "=y")
8364         (vec_concat:V2SI
8365           (plus:SI
8366             (vec_select:SI
8367               (match_operand:V2SI 1 "register_operand" "0")
8368               (parallel [(const_int 0)]))
8369             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8370           (plus:SI
8371             (vec_select:SI
8372               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8373               (parallel [(const_int 0)]))
8374             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8375   "TARGET_SSSE3"
8376   "phaddd\t{%2, %0|%0, %2}"
8377   [(set_attr "type" "sseiadd")
8378    (set_attr "atom_unit" "complex")
8379    (set_attr "prefix_extra" "1")
8380    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8381    (set_attr "mode" "DI")])
8382
8383 (define_insn "*avx_phaddswv8hi3"
8384   [(set (match_operand:V8HI 0 "register_operand" "=x")
8385         (vec_concat:V8HI
8386           (vec_concat:V4HI
8387             (vec_concat:V2HI
8388               (ss_plus:HI
8389                 (vec_select:HI
8390                   (match_operand:V8HI 1 "register_operand" "x")
8391                   (parallel [(const_int 0)]))
8392                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8393               (ss_plus:HI
8394                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8395                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8396             (vec_concat:V2HI
8397               (ss_plus:HI
8398                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8399                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8400               (ss_plus:HI
8401                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8402                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8403           (vec_concat:V4HI
8404             (vec_concat:V2HI
8405               (ss_plus:HI
8406                 (vec_select:HI
8407                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8408                   (parallel [(const_int 0)]))
8409                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8410               (ss_plus:HI
8411                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8412                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8413             (vec_concat:V2HI
8414               (ss_plus:HI
8415                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8416                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8417               (ss_plus:HI
8418                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8419                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8420   "TARGET_AVX"
8421   "vphaddsw\t{%2, %1, %0|%0, %1, %2}"
8422   [(set_attr "type" "sseiadd")
8423    (set_attr "prefix_extra" "1")
8424    (set_attr "prefix" "vex")
8425    (set_attr "mode" "TI")])
8426
8427 (define_insn "ssse3_phaddswv8hi3"
8428   [(set (match_operand:V8HI 0 "register_operand" "=x")
8429         (vec_concat:V8HI
8430           (vec_concat:V4HI
8431             (vec_concat:V2HI
8432               (ss_plus:HI
8433                 (vec_select:HI
8434                   (match_operand:V8HI 1 "register_operand" "0")
8435                   (parallel [(const_int 0)]))
8436                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8437               (ss_plus:HI
8438                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8439                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8440             (vec_concat:V2HI
8441               (ss_plus:HI
8442                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8443                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8444               (ss_plus:HI
8445                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8446                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8447           (vec_concat:V4HI
8448             (vec_concat:V2HI
8449               (ss_plus:HI
8450                 (vec_select:HI
8451                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8452                   (parallel [(const_int 0)]))
8453                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8454               (ss_plus:HI
8455                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8456                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8457             (vec_concat:V2HI
8458               (ss_plus:HI
8459                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8460                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8461               (ss_plus:HI
8462                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8463                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8464   "TARGET_SSSE3"
8465   "phaddsw\t{%2, %0|%0, %2}"
8466   [(set_attr "type" "sseiadd")
8467    (set_attr "atom_unit" "complex")
8468    (set_attr "prefix_data16" "1")
8469    (set_attr "prefix_extra" "1")
8470    (set_attr "mode" "TI")])
8471
8472 (define_insn "ssse3_phaddswv4hi3"
8473   [(set (match_operand:V4HI 0 "register_operand" "=y")
8474         (vec_concat:V4HI
8475           (vec_concat:V2HI
8476             (ss_plus:HI
8477               (vec_select:HI
8478                 (match_operand:V4HI 1 "register_operand" "0")
8479                 (parallel [(const_int 0)]))
8480               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8481             (ss_plus:HI
8482               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8483               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8484           (vec_concat:V2HI
8485             (ss_plus:HI
8486               (vec_select:HI
8487                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8488                 (parallel [(const_int 0)]))
8489               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8490             (ss_plus:HI
8491               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8492               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8493   "TARGET_SSSE3"
8494   "phaddsw\t{%2, %0|%0, %2}"
8495   [(set_attr "type" "sseiadd")
8496    (set_attr "atom_unit" "complex")
8497    (set_attr "prefix_extra" "1")
8498    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8499    (set_attr "mode" "DI")])
8500
8501 (define_insn "*avx_phsubwv8hi3"
8502   [(set (match_operand:V8HI 0 "register_operand" "=x")
8503         (vec_concat:V8HI
8504           (vec_concat:V4HI
8505             (vec_concat:V2HI
8506               (minus:HI
8507                 (vec_select:HI
8508                   (match_operand:V8HI 1 "register_operand" "x")
8509                   (parallel [(const_int 0)]))
8510                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8511               (minus:HI
8512                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8513                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8514             (vec_concat:V2HI
8515               (minus:HI
8516                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8517                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8518               (minus:HI
8519                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8520                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8521           (vec_concat:V4HI
8522             (vec_concat:V2HI
8523               (minus:HI
8524                 (vec_select:HI
8525                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8526                   (parallel [(const_int 0)]))
8527                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8528               (minus:HI
8529                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8530                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8531             (vec_concat:V2HI
8532               (minus:HI
8533                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8534                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8535               (minus:HI
8536                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8537                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8538   "TARGET_AVX"
8539   "vphsubw\t{%2, %1, %0|%0, %1, %2}"
8540   [(set_attr "type" "sseiadd")
8541    (set_attr "prefix_extra" "1")
8542    (set_attr "prefix" "vex")
8543    (set_attr "mode" "TI")])
8544
8545 (define_insn "ssse3_phsubwv8hi3"
8546   [(set (match_operand:V8HI 0 "register_operand" "=x")
8547         (vec_concat:V8HI
8548           (vec_concat:V4HI
8549             (vec_concat:V2HI
8550               (minus:HI
8551                 (vec_select:HI
8552                   (match_operand:V8HI 1 "register_operand" "0")
8553                   (parallel [(const_int 0)]))
8554                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8555               (minus:HI
8556                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8557                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8558             (vec_concat:V2HI
8559               (minus:HI
8560                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8561                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8562               (minus:HI
8563                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8564                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8565           (vec_concat:V4HI
8566             (vec_concat:V2HI
8567               (minus:HI
8568                 (vec_select:HI
8569                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8570                   (parallel [(const_int 0)]))
8571                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8572               (minus:HI
8573                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8574                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8575             (vec_concat:V2HI
8576               (minus:HI
8577                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8578                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8579               (minus:HI
8580                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8581                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8582   "TARGET_SSSE3"
8583   "phsubw\t{%2, %0|%0, %2}"
8584   [(set_attr "type" "sseiadd")
8585    (set_attr "atom_unit" "complex")
8586    (set_attr "prefix_data16" "1")
8587    (set_attr "prefix_extra" "1")
8588    (set_attr "mode" "TI")])
8589
8590 (define_insn "ssse3_phsubwv4hi3"
8591   [(set (match_operand:V4HI 0 "register_operand" "=y")
8592         (vec_concat:V4HI
8593           (vec_concat:V2HI
8594             (minus:HI
8595               (vec_select:HI
8596                 (match_operand:V4HI 1 "register_operand" "0")
8597                 (parallel [(const_int 0)]))
8598               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8599             (minus:HI
8600               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8601               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8602           (vec_concat:V2HI
8603             (minus:HI
8604               (vec_select:HI
8605                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8606                 (parallel [(const_int 0)]))
8607               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8608             (minus:HI
8609               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8610               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8611   "TARGET_SSSE3"
8612   "phsubw\t{%2, %0|%0, %2}"
8613   [(set_attr "type" "sseiadd")
8614    (set_attr "atom_unit" "complex")
8615    (set_attr "prefix_extra" "1")
8616    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8617    (set_attr "mode" "DI")])
8618
8619 (define_insn "*avx_phsubdv4si3"
8620   [(set (match_operand:V4SI 0 "register_operand" "=x")
8621         (vec_concat:V4SI
8622           (vec_concat:V2SI
8623             (minus:SI
8624               (vec_select:SI
8625                 (match_operand:V4SI 1 "register_operand" "x")
8626                 (parallel [(const_int 0)]))
8627               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8628             (minus:SI
8629               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8630               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8631           (vec_concat:V2SI
8632             (minus:SI
8633               (vec_select:SI
8634                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8635                 (parallel [(const_int 0)]))
8636               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8637             (minus:SI
8638               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8639               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8640   "TARGET_AVX"
8641   "vphsubd\t{%2, %1, %0|%0, %1, %2}"
8642   [(set_attr "type" "sseiadd")
8643    (set_attr "prefix_extra" "1")
8644    (set_attr "prefix" "vex")
8645    (set_attr "mode" "TI")])
8646
8647 (define_insn "ssse3_phsubdv4si3"
8648   [(set (match_operand:V4SI 0 "register_operand" "=x")
8649         (vec_concat:V4SI
8650           (vec_concat:V2SI
8651             (minus:SI
8652               (vec_select:SI
8653                 (match_operand:V4SI 1 "register_operand" "0")
8654                 (parallel [(const_int 0)]))
8655               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8656             (minus:SI
8657               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8658               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8659           (vec_concat:V2SI
8660             (minus:SI
8661               (vec_select:SI
8662                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8663                 (parallel [(const_int 0)]))
8664               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8665             (minus:SI
8666               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8667               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8668   "TARGET_SSSE3"
8669   "phsubd\t{%2, %0|%0, %2}"
8670   [(set_attr "type" "sseiadd")
8671    (set_attr "atom_unit" "complex")
8672    (set_attr "prefix_data16" "1")
8673    (set_attr "prefix_extra" "1")
8674    (set_attr "mode" "TI")])
8675
8676 (define_insn "ssse3_phsubdv2si3"
8677   [(set (match_operand:V2SI 0 "register_operand" "=y")
8678         (vec_concat:V2SI
8679           (minus:SI
8680             (vec_select:SI
8681               (match_operand:V2SI 1 "register_operand" "0")
8682               (parallel [(const_int 0)]))
8683             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8684           (minus:SI
8685             (vec_select:SI
8686               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8687               (parallel [(const_int 0)]))
8688             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8689   "TARGET_SSSE3"
8690   "phsubd\t{%2, %0|%0, %2}"
8691   [(set_attr "type" "sseiadd")
8692    (set_attr "atom_unit" "complex")
8693    (set_attr "prefix_extra" "1")
8694    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8695    (set_attr "mode" "DI")])
8696
8697 (define_insn "*avx_phsubswv8hi3"
8698   [(set (match_operand:V8HI 0 "register_operand" "=x")
8699         (vec_concat:V8HI
8700           (vec_concat:V4HI
8701             (vec_concat:V2HI
8702               (ss_minus:HI
8703                 (vec_select:HI
8704                   (match_operand:V8HI 1 "register_operand" "x")
8705                   (parallel [(const_int 0)]))
8706                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8707               (ss_minus:HI
8708                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8709                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8710             (vec_concat:V2HI
8711               (ss_minus:HI
8712                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8713                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8714               (ss_minus:HI
8715                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8716                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8717           (vec_concat:V4HI
8718             (vec_concat:V2HI
8719               (ss_minus:HI
8720                 (vec_select:HI
8721                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8722                   (parallel [(const_int 0)]))
8723                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8724               (ss_minus:HI
8725                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8726                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8727             (vec_concat:V2HI
8728               (ss_minus:HI
8729                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8730                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8731               (ss_minus:HI
8732                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8733                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8734   "TARGET_AVX"
8735   "vphsubsw\t{%2, %1, %0|%0, %1, %2}"
8736   [(set_attr "type" "sseiadd")
8737    (set_attr "prefix_extra" "1")
8738    (set_attr "prefix" "vex")
8739    (set_attr "mode" "TI")])
8740
8741 (define_insn "ssse3_phsubswv8hi3"
8742   [(set (match_operand:V8HI 0 "register_operand" "=x")
8743         (vec_concat:V8HI
8744           (vec_concat:V4HI
8745             (vec_concat:V2HI
8746               (ss_minus:HI
8747                 (vec_select:HI
8748                   (match_operand:V8HI 1 "register_operand" "0")
8749                   (parallel [(const_int 0)]))
8750                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8751               (ss_minus:HI
8752                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8753                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8754             (vec_concat:V2HI
8755               (ss_minus:HI
8756                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8757                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8758               (ss_minus:HI
8759                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8760                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8761           (vec_concat:V4HI
8762             (vec_concat:V2HI
8763               (ss_minus:HI
8764                 (vec_select:HI
8765                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8766                   (parallel [(const_int 0)]))
8767                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8768               (ss_minus:HI
8769                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8770                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8771             (vec_concat:V2HI
8772               (ss_minus:HI
8773                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8774                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8775               (ss_minus:HI
8776                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8777                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8778   "TARGET_SSSE3"
8779   "phsubsw\t{%2, %0|%0, %2}"
8780   [(set_attr "type" "sseiadd")
8781    (set_attr "atom_unit" "complex")
8782    (set_attr "prefix_data16" "1")
8783    (set_attr "prefix_extra" "1")
8784    (set_attr "mode" "TI")])
8785
8786 (define_insn "ssse3_phsubswv4hi3"
8787   [(set (match_operand:V4HI 0 "register_operand" "=y")
8788         (vec_concat:V4HI
8789           (vec_concat:V2HI
8790             (ss_minus:HI
8791               (vec_select:HI
8792                 (match_operand:V4HI 1 "register_operand" "0")
8793                 (parallel [(const_int 0)]))
8794               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8795             (ss_minus:HI
8796               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8797               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8798           (vec_concat:V2HI
8799             (ss_minus:HI
8800               (vec_select:HI
8801                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8802                 (parallel [(const_int 0)]))
8803               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8804             (ss_minus:HI
8805               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8806               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8807   "TARGET_SSSE3"
8808   "phsubsw\t{%2, %0|%0, %2}"
8809   [(set_attr "type" "sseiadd")
8810    (set_attr "atom_unit" "complex")
8811    (set_attr "prefix_extra" "1")
8812    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8813    (set_attr "mode" "DI")])
8814
8815 (define_insn "*avx_pmaddubsw128"
8816   [(set (match_operand:V8HI 0 "register_operand" "=x")
8817         (ss_plus:V8HI
8818           (mult:V8HI
8819             (zero_extend:V8HI
8820               (vec_select:V4QI
8821                 (match_operand:V16QI 1 "register_operand" "x")
8822                 (parallel [(const_int 0)
8823                            (const_int 2)
8824                            (const_int 4)
8825                            (const_int 6)
8826                            (const_int 8)
8827                            (const_int 10)
8828                            (const_int 12)
8829                            (const_int 14)])))
8830             (sign_extend:V8HI
8831               (vec_select:V8QI
8832                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8833                 (parallel [(const_int 0)
8834                            (const_int 2)
8835                            (const_int 4)
8836                            (const_int 6)
8837                            (const_int 8)
8838                            (const_int 10)
8839                            (const_int 12)
8840                            (const_int 14)]))))
8841           (mult:V8HI
8842             (zero_extend:V8HI
8843               (vec_select:V16QI (match_dup 1)
8844                 (parallel [(const_int 1)
8845                            (const_int 3)
8846                            (const_int 5)
8847                            (const_int 7)
8848                            (const_int 9)
8849                            (const_int 11)
8850                            (const_int 13)
8851                            (const_int 15)])))
8852             (sign_extend:V8HI
8853               (vec_select:V16QI (match_dup 2)
8854                 (parallel [(const_int 1)
8855                            (const_int 3)
8856                            (const_int 5)
8857                            (const_int 7)
8858                            (const_int 9)
8859                            (const_int 11)
8860                            (const_int 13)
8861                            (const_int 15)]))))))]
8862   "TARGET_AVX"
8863   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8864   [(set_attr "type" "sseiadd")
8865    (set_attr "prefix_extra" "1")
8866    (set_attr "prefix" "vex")
8867    (set_attr "mode" "TI")])
8868
8869 (define_insn "ssse3_pmaddubsw128"
8870   [(set (match_operand:V8HI 0 "register_operand" "=x")
8871         (ss_plus:V8HI
8872           (mult:V8HI
8873             (zero_extend:V8HI
8874               (vec_select:V4QI
8875                 (match_operand:V16QI 1 "register_operand" "0")
8876                 (parallel [(const_int 0)
8877                            (const_int 2)
8878                            (const_int 4)
8879                            (const_int 6)
8880                            (const_int 8)
8881                            (const_int 10)
8882                            (const_int 12)
8883                            (const_int 14)])))
8884             (sign_extend:V8HI
8885               (vec_select:V8QI
8886                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8887                 (parallel [(const_int 0)
8888                            (const_int 2)
8889                            (const_int 4)
8890                            (const_int 6)
8891                            (const_int 8)
8892                            (const_int 10)
8893                            (const_int 12)
8894                            (const_int 14)]))))
8895           (mult:V8HI
8896             (zero_extend:V8HI
8897               (vec_select:V16QI (match_dup 1)
8898                 (parallel [(const_int 1)
8899                            (const_int 3)
8900                            (const_int 5)
8901                            (const_int 7)
8902                            (const_int 9)
8903                            (const_int 11)
8904                            (const_int 13)
8905                            (const_int 15)])))
8906             (sign_extend:V8HI
8907               (vec_select:V16QI (match_dup 2)
8908                 (parallel [(const_int 1)
8909                            (const_int 3)
8910                            (const_int 5)
8911                            (const_int 7)
8912                            (const_int 9)
8913                            (const_int 11)
8914                            (const_int 13)
8915                            (const_int 15)]))))))]
8916   "TARGET_SSSE3"
8917   "pmaddubsw\t{%2, %0|%0, %2}"
8918   [(set_attr "type" "sseiadd")
8919    (set_attr "atom_unit" "simul")
8920    (set_attr "prefix_data16" "1")
8921    (set_attr "prefix_extra" "1")
8922    (set_attr "mode" "TI")])
8923
8924 (define_insn "ssse3_pmaddubsw"
8925   [(set (match_operand:V4HI 0 "register_operand" "=y")
8926         (ss_plus:V4HI
8927           (mult:V4HI
8928             (zero_extend:V4HI
8929               (vec_select:V4QI
8930                 (match_operand:V8QI 1 "register_operand" "0")
8931                 (parallel [(const_int 0)
8932                            (const_int 2)
8933                            (const_int 4)
8934                            (const_int 6)])))
8935             (sign_extend:V4HI
8936               (vec_select:V4QI
8937                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8938                 (parallel [(const_int 0)
8939                            (const_int 2)
8940                            (const_int 4)
8941                            (const_int 6)]))))
8942           (mult:V4HI
8943             (zero_extend:V4HI
8944               (vec_select:V8QI (match_dup 1)
8945                 (parallel [(const_int 1)
8946                            (const_int 3)
8947                            (const_int 5)
8948                            (const_int 7)])))
8949             (sign_extend:V4HI
8950               (vec_select:V8QI (match_dup 2)
8951                 (parallel [(const_int 1)
8952                            (const_int 3)
8953                            (const_int 5)
8954                            (const_int 7)]))))))]
8955   "TARGET_SSSE3"
8956   "pmaddubsw\t{%2, %0|%0, %2}"
8957   [(set_attr "type" "sseiadd")
8958    (set_attr "atom_unit" "simul")
8959    (set_attr "prefix_extra" "1")
8960    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8961    (set_attr "mode" "DI")])
8962
8963 (define_expand "ssse3_pmulhrswv8hi3"
8964   [(set (match_operand:V8HI 0 "register_operand" "")
8965         (truncate:V8HI
8966           (lshiftrt:V8SI
8967             (plus:V8SI
8968               (lshiftrt:V8SI
8969                 (mult:V8SI
8970                   (sign_extend:V8SI
8971                     (match_operand:V8HI 1 "nonimmediate_operand" ""))
8972                   (sign_extend:V8SI
8973                     (match_operand:V8HI 2 "nonimmediate_operand" "")))
8974                 (const_int 14))
8975               (const_vector:V8HI [(const_int 1) (const_int 1)
8976                                   (const_int 1) (const_int 1)
8977                                   (const_int 1) (const_int 1)
8978                                   (const_int 1) (const_int 1)]))
8979             (const_int 1))))]
8980   "TARGET_SSSE3"
8981   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
8982
8983 (define_insn "*avx_pmulhrswv8hi3"
8984   [(set (match_operand:V8HI 0 "register_operand" "=x")
8985         (truncate:V8HI
8986           (lshiftrt:V8SI
8987             (plus:V8SI
8988               (lshiftrt:V8SI
8989                 (mult:V8SI
8990                   (sign_extend:V8SI
8991                     (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
8992                   (sign_extend:V8SI
8993                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8994                 (const_int 14))
8995               (const_vector:V8HI [(const_int 1) (const_int 1)
8996                                   (const_int 1) (const_int 1)
8997                                   (const_int 1) (const_int 1)
8998                                   (const_int 1) (const_int 1)]))
8999             (const_int 1))))]
9000   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9001   "vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
9002   [(set_attr "type" "sseimul")
9003    (set_attr "prefix_extra" "1")
9004    (set_attr "prefix" "vex")
9005    (set_attr "mode" "TI")])
9006
9007 (define_insn "*ssse3_pmulhrswv8hi3"
9008   [(set (match_operand:V8HI 0 "register_operand" "=x")
9009         (truncate:V8HI
9010           (lshiftrt:V8SI
9011             (plus:V8SI
9012               (lshiftrt:V8SI
9013                 (mult:V8SI
9014                   (sign_extend:V8SI
9015                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
9016                   (sign_extend:V8SI
9017                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
9018                 (const_int 14))
9019               (const_vector:V8HI [(const_int 1) (const_int 1)
9020                                   (const_int 1) (const_int 1)
9021                                   (const_int 1) (const_int 1)
9022                                   (const_int 1) (const_int 1)]))
9023             (const_int 1))))]
9024   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9025   "pmulhrsw\t{%2, %0|%0, %2}"
9026   [(set_attr "type" "sseimul")
9027    (set_attr "prefix_data16" "1")
9028    (set_attr "prefix_extra" "1")
9029    (set_attr "mode" "TI")])
9030
9031 (define_expand "ssse3_pmulhrswv4hi3"
9032   [(set (match_operand:V4HI 0 "register_operand" "")
9033         (truncate:V4HI
9034           (lshiftrt:V4SI
9035             (plus:V4SI
9036               (lshiftrt:V4SI
9037                 (mult:V4SI
9038                   (sign_extend:V4SI
9039                     (match_operand:V4HI 1 "nonimmediate_operand" ""))
9040                   (sign_extend:V4SI
9041                     (match_operand:V4HI 2 "nonimmediate_operand" "")))
9042                 (const_int 14))
9043               (const_vector:V4HI [(const_int 1) (const_int 1)
9044                                   (const_int 1) (const_int 1)]))
9045             (const_int 1))))]
9046   "TARGET_SSSE3"
9047   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
9048
9049 (define_insn "*ssse3_pmulhrswv4hi3"
9050   [(set (match_operand:V4HI 0 "register_operand" "=y")
9051         (truncate:V4HI
9052           (lshiftrt:V4SI
9053             (plus:V4SI
9054               (lshiftrt:V4SI
9055                 (mult:V4SI
9056                   (sign_extend:V4SI
9057                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
9058                   (sign_extend:V4SI
9059                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
9060                 (const_int 14))
9061               (const_vector:V4HI [(const_int 1) (const_int 1)
9062                                   (const_int 1) (const_int 1)]))
9063             (const_int 1))))]
9064   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
9065   "pmulhrsw\t{%2, %0|%0, %2}"
9066   [(set_attr "type" "sseimul")
9067    (set_attr "prefix_extra" "1")
9068    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9069    (set_attr "mode" "DI")])
9070
9071 (define_insn "*avx_pshufbv16qi3"
9072   [(set (match_operand:V16QI 0 "register_operand" "=x")
9073         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9074                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9075                       UNSPEC_PSHUFB))]
9076   "TARGET_AVX"
9077   "vpshufb\t{%2, %1, %0|%0, %1, %2}";
9078   [(set_attr "type" "sselog1")
9079    (set_attr "prefix_extra" "1")
9080    (set_attr "prefix" "vex")
9081    (set_attr "mode" "TI")])
9082
9083 (define_insn "ssse3_pshufbv16qi3"
9084   [(set (match_operand:V16QI 0 "register_operand" "=x")
9085         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9086                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9087                       UNSPEC_PSHUFB))]
9088   "TARGET_SSSE3"
9089   "pshufb\t{%2, %0|%0, %2}";
9090   [(set_attr "type" "sselog1")
9091    (set_attr "prefix_data16" "1")
9092    (set_attr "prefix_extra" "1")
9093    (set_attr "mode" "TI")])
9094
9095 (define_insn "ssse3_pshufbv8qi3"
9096   [(set (match_operand:V8QI 0 "register_operand" "=y")
9097         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
9098                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
9099                      UNSPEC_PSHUFB))]
9100   "TARGET_SSSE3"
9101   "pshufb\t{%2, %0|%0, %2}";
9102   [(set_attr "type" "sselog1")
9103    (set_attr "prefix_extra" "1")
9104    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9105    (set_attr "mode" "DI")])
9106
9107 (define_insn "*avx_psign<mode>3"
9108   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9109         (unspec:SSEMODE124
9110           [(match_operand:SSEMODE124 1 "register_operand" "x")
9111            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9112           UNSPEC_PSIGN))]
9113   "TARGET_AVX"
9114   "vpsign<ssevecsize>\t{%2, %1, %0|%0, %1, %2}";
9115   [(set_attr "type" "sselog1")
9116    (set_attr "prefix_extra" "1")
9117    (set_attr "prefix" "vex")
9118    (set_attr "mode" "TI")])
9119
9120 (define_insn "ssse3_psign<mode>3"
9121   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9122         (unspec:SSEMODE124
9123           [(match_operand:SSEMODE124 1 "register_operand" "0")
9124            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9125           UNSPEC_PSIGN))]
9126   "TARGET_SSSE3"
9127   "psign<ssevecsize>\t{%2, %0|%0, %2}";
9128   [(set_attr "type" "sselog1")
9129    (set_attr "prefix_data16" "1")
9130    (set_attr "prefix_extra" "1")
9131    (set_attr "mode" "TI")])
9132
9133 (define_insn "ssse3_psign<mode>3"
9134   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9135         (unspec:MMXMODEI
9136           [(match_operand:MMXMODEI 1 "register_operand" "0")
9137            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
9138           UNSPEC_PSIGN))]
9139   "TARGET_SSSE3"
9140   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
9141   [(set_attr "type" "sselog1")
9142    (set_attr "prefix_extra" "1")
9143    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9144    (set_attr "mode" "DI")])
9145
9146 (define_insn "*avx_palignrti"
9147   [(set (match_operand:TI 0 "register_operand" "=x")
9148         (unspec:TI [(match_operand:TI 1 "register_operand" "x")
9149                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9150                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9151                    UNSPEC_PALIGNR))]
9152   "TARGET_AVX"
9153 {
9154   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9155   return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
9156 }
9157   [(set_attr "type" "sseishft")
9158    (set_attr "prefix_extra" "1")
9159    (set_attr "length_immediate" "1")
9160    (set_attr "prefix" "vex")
9161    (set_attr "mode" "TI")])
9162
9163 (define_insn "ssse3_palignrti"
9164   [(set (match_operand:TI 0 "register_operand" "=x")
9165         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
9166                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9167                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9168                    UNSPEC_PALIGNR))]
9169   "TARGET_SSSE3"
9170 {
9171   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9172   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9173 }
9174   [(set_attr "type" "sseishft")
9175    (set_attr "atom_unit" "sishuf")
9176    (set_attr "prefix_data16" "1")
9177    (set_attr "prefix_extra" "1")
9178    (set_attr "length_immediate" "1")
9179    (set_attr "mode" "TI")])
9180
9181 (define_insn "ssse3_palignrdi"
9182   [(set (match_operand:DI 0 "register_operand" "=y")
9183         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
9184                     (match_operand:DI 2 "nonimmediate_operand" "ym")
9185                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9186                    UNSPEC_PALIGNR))]
9187   "TARGET_SSSE3"
9188 {
9189   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9190   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9191 }
9192   [(set_attr "type" "sseishft")
9193    (set_attr "atom_unit" "sishuf")
9194    (set_attr "prefix_extra" "1")
9195    (set_attr "length_immediate" "1")
9196    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9197    (set_attr "mode" "DI")])
9198
9199 (define_insn "abs<mode>2"
9200   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9201         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
9202   "TARGET_SSSE3"
9203   "%vpabs<ssevecsize>\t{%1, %0|%0, %1}"
9204   [(set_attr "type" "sselog1")
9205    (set_attr "prefix_data16" "1")
9206    (set_attr "prefix_extra" "1")
9207    (set_attr "prefix" "maybe_vex")
9208    (set_attr "mode" "TI")])
9209
9210 (define_insn "abs<mode>2"
9211   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9212         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
9213   "TARGET_SSSE3"
9214   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
9215   [(set_attr "type" "sselog1")
9216    (set_attr "prefix_rep" "0")
9217    (set_attr "prefix_extra" "1")
9218    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9219    (set_attr "mode" "DI")])
9220
9221 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9222 ;;
9223 ;; AMD SSE4A instructions
9224 ;;
9225 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9226
9227 (define_insn "sse4a_movnt<mode>"
9228   [(set (match_operand:MODEF 0 "memory_operand" "=m")
9229         (unspec:MODEF
9230           [(match_operand:MODEF 1 "register_operand" "x")]
9231           UNSPEC_MOVNT))]
9232   "TARGET_SSE4A"
9233   "movnts<ssemodefsuffix>\t{%1, %0|%0, %1}"
9234   [(set_attr "type" "ssemov")
9235    (set_attr "mode" "<MODE>")])
9236
9237 (define_insn "sse4a_vmmovnt<mode>"
9238   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
9239         (unspec:<ssescalarmode>
9240           [(vec_select:<ssescalarmode>
9241              (match_operand:SSEMODEF2P 1 "register_operand" "x")
9242              (parallel [(const_int 0)]))]
9243           UNSPEC_MOVNT))]
9244   "TARGET_SSE4A"
9245   "movnts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
9246   [(set_attr "type" "ssemov")
9247    (set_attr "mode" "<ssescalarmode>")])
9248
9249 (define_insn "sse4a_extrqi"
9250   [(set (match_operand:V2DI 0 "register_operand" "=x")
9251         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9252                       (match_operand 2 "const_int_operand" "")
9253                       (match_operand 3 "const_int_operand" "")]
9254                      UNSPEC_EXTRQI))]
9255   "TARGET_SSE4A"
9256   "extrq\t{%3, %2, %0|%0, %2, %3}"
9257   [(set_attr "type" "sse")
9258    (set_attr "prefix_data16" "1")
9259    (set_attr "length_immediate" "2")
9260    (set_attr "mode" "TI")])
9261
9262 (define_insn "sse4a_extrq"
9263   [(set (match_operand:V2DI 0 "register_operand" "=x")
9264         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9265                       (match_operand:V16QI 2 "register_operand" "x")]
9266                      UNSPEC_EXTRQ))]
9267   "TARGET_SSE4A"
9268   "extrq\t{%2, %0|%0, %2}"
9269   [(set_attr "type" "sse")
9270    (set_attr "prefix_data16" "1")
9271    (set_attr "mode" "TI")])
9272
9273 (define_insn "sse4a_insertqi"
9274   [(set (match_operand:V2DI 0 "register_operand" "=x")
9275         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9276                       (match_operand:V2DI 2 "register_operand" "x")
9277                       (match_operand 3 "const_int_operand" "")
9278                       (match_operand 4 "const_int_operand" "")]
9279                      UNSPEC_INSERTQI))]
9280   "TARGET_SSE4A"
9281   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
9282   [(set_attr "type" "sseins")
9283    (set_attr "prefix_data16" "0")
9284    (set_attr "prefix_rep" "1")
9285    (set_attr "length_immediate" "2")
9286    (set_attr "mode" "TI")])
9287
9288 (define_insn "sse4a_insertq"
9289   [(set (match_operand:V2DI 0 "register_operand" "=x")
9290         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9291                       (match_operand:V2DI 2 "register_operand" "x")]
9292                      UNSPEC_INSERTQ))]
9293   "TARGET_SSE4A"
9294   "insertq\t{%2, %0|%0, %2}"
9295   [(set_attr "type" "sseins")
9296    (set_attr "prefix_data16" "0")
9297    (set_attr "prefix_rep" "1")
9298    (set_attr "mode" "TI")])
9299
9300 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9301 ;;
9302 ;; Intel SSE4.1 instructions
9303 ;;
9304 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9305
9306 (define_insn "avx_blendp<avxmodesuffixf2c><avxmodesuffix>"
9307   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9308         (vec_merge:AVXMODEF2P
9309           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9310           (match_operand:AVXMODEF2P 1 "register_operand" "x")
9311           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9312   "TARGET_AVX"
9313   "vblendp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9314   [(set_attr "type" "ssemov")
9315    (set_attr "prefix_extra" "1")
9316    (set_attr "length_immediate" "1")
9317    (set_attr "prefix" "vex")
9318    (set_attr "mode" "<avxvecmode>")])
9319
9320 (define_insn "avx_blendvp<avxmodesuffixf2c><avxmodesuffix>"
9321   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9322         (unspec:AVXMODEF2P
9323           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
9324            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9325            (match_operand:AVXMODEF2P 3 "register_operand" "x")]
9326           UNSPEC_BLENDV))]
9327   "TARGET_AVX"
9328   "vblendvp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9329   [(set_attr "type" "ssemov")
9330    (set_attr "prefix_extra" "1")
9331    (set_attr "length_immediate" "1")
9332    (set_attr "prefix" "vex")
9333    (set_attr "mode" "<avxvecmode>")])
9334
9335 (define_insn "sse4_1_blendp<ssemodesuffixf2c>"
9336   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9337         (vec_merge:SSEMODEF2P
9338           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9339           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9340           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9341   "TARGET_SSE4_1"
9342   "blendp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9343   [(set_attr "type" "ssemov")
9344    (set_attr "prefix_data16" "1")
9345    (set_attr "prefix_extra" "1")
9346    (set_attr "length_immediate" "1")
9347    (set_attr "mode" "<MODE>")])
9348
9349 (define_insn "sse4_1_blendvp<ssemodesuffixf2c>"
9350   [(set (match_operand:SSEMODEF2P 0 "reg_not_xmm0_operand" "=x")
9351         (unspec:SSEMODEF2P
9352           [(match_operand:SSEMODEF2P 1 "reg_not_xmm0_operand" "0")
9353            (match_operand:SSEMODEF2P 2 "nonimm_not_xmm0_operand" "xm")
9354            (match_operand:SSEMODEF2P 3 "register_operand" "Yz")]
9355           UNSPEC_BLENDV))]
9356   "TARGET_SSE4_1"
9357   "blendvp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9358   [(set_attr "type" "ssemov")
9359    (set_attr "prefix_data16" "1")
9360    (set_attr "prefix_extra" "1")
9361    (set_attr "mode" "<MODE>")])
9362
9363 (define_insn "avx_dpp<avxmodesuffixf2c><avxmodesuffix>"
9364   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9365         (unspec:AVXMODEF2P
9366           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
9367            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9368            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9369           UNSPEC_DP))]
9370   "TARGET_AVX"
9371   "vdpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9372   [(set_attr "type" "ssemul")
9373    (set_attr "prefix" "vex")
9374    (set_attr "prefix_extra" "1")
9375    (set_attr "length_immediate" "1")
9376    (set_attr "mode" "<avxvecmode>")])
9377
9378 (define_insn "sse4_1_dpp<ssemodesuffixf2c>"
9379   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9380         (unspec:SSEMODEF2P
9381           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
9382            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9383            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9384           UNSPEC_DP))]
9385   "TARGET_SSE4_1"
9386   "dpp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9387   [(set_attr "type" "ssemul")
9388    (set_attr "prefix_data16" "1")
9389    (set_attr "prefix_extra" "1")
9390    (set_attr "length_immediate" "1")
9391    (set_attr "mode" "<MODE>")])
9392
9393 (define_insn "sse4_1_movntdqa"
9394   [(set (match_operand:V2DI 0 "register_operand" "=x")
9395         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
9396                      UNSPEC_MOVNTDQA))]
9397   "TARGET_SSE4_1"
9398   "%vmovntdqa\t{%1, %0|%0, %1}"
9399   [(set_attr "type" "ssemov")
9400    (set_attr "prefix_extra" "1")
9401    (set_attr "prefix" "maybe_vex")
9402    (set_attr "mode" "TI")])
9403
9404 (define_insn "*avx_mpsadbw"
9405   [(set (match_operand:V16QI 0 "register_operand" "=x")
9406         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9407                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9408                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9409                       UNSPEC_MPSADBW))]
9410   "TARGET_AVX"
9411   "vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9412   [(set_attr "type" "sselog1")
9413    (set_attr "prefix" "vex")
9414    (set_attr "prefix_extra" "1")
9415    (set_attr "length_immediate" "1")
9416    (set_attr "mode" "TI")])
9417
9418 (define_insn "sse4_1_mpsadbw"
9419   [(set (match_operand:V16QI 0 "register_operand" "=x")
9420         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9421                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9422                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9423                       UNSPEC_MPSADBW))]
9424   "TARGET_SSE4_1"
9425   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
9426   [(set_attr "type" "sselog1")
9427    (set_attr "prefix_extra" "1")
9428    (set_attr "length_immediate" "1")
9429    (set_attr "mode" "TI")])
9430
9431 (define_insn "*avx_packusdw"
9432   [(set (match_operand:V8HI 0 "register_operand" "=x")
9433         (vec_concat:V8HI
9434           (us_truncate:V4HI
9435             (match_operand:V4SI 1 "register_operand" "x"))
9436           (us_truncate:V4HI
9437             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9438   "TARGET_AVX"
9439   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
9440   [(set_attr "type" "sselog")
9441    (set_attr "prefix_extra" "1")
9442    (set_attr "prefix" "vex")
9443    (set_attr "mode" "TI")])
9444
9445 (define_insn "sse4_1_packusdw"
9446   [(set (match_operand:V8HI 0 "register_operand" "=x")
9447         (vec_concat:V8HI
9448           (us_truncate:V4HI
9449             (match_operand:V4SI 1 "register_operand" "0"))
9450           (us_truncate:V4HI
9451             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9452   "TARGET_SSE4_1"
9453   "packusdw\t{%2, %0|%0, %2}"
9454   [(set_attr "type" "sselog")
9455    (set_attr "prefix_extra" "1")
9456    (set_attr "mode" "TI")])
9457
9458 (define_insn "*avx_pblendvb"
9459   [(set (match_operand:V16QI 0 "register_operand" "=x")
9460         (unspec:V16QI [(match_operand:V16QI 1 "register_operand"  "x")
9461                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9462                        (match_operand:V16QI 3 "register_operand" "x")]
9463                       UNSPEC_BLENDV))]
9464   "TARGET_AVX"
9465   "vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9466   [(set_attr "type" "ssemov")
9467    (set_attr "prefix_extra" "1")
9468    (set_attr "length_immediate" "1")
9469    (set_attr "prefix" "vex")
9470    (set_attr "mode" "TI")])
9471
9472 (define_insn "sse4_1_pblendvb"
9473   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
9474         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
9475                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
9476                        (match_operand:V16QI 3 "register_operand" "Yz")]
9477                       UNSPEC_BLENDV))]
9478   "TARGET_SSE4_1"
9479   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
9480   [(set_attr "type" "ssemov")
9481    (set_attr "prefix_extra" "1")
9482    (set_attr "mode" "TI")])
9483
9484 (define_insn "*avx_pblendw"
9485   [(set (match_operand:V8HI 0 "register_operand" "=x")
9486         (vec_merge:V8HI
9487           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9488           (match_operand:V8HI 1 "register_operand" "x")
9489           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9490   "TARGET_AVX"
9491   "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9492   [(set_attr "type" "ssemov")
9493    (set_attr "prefix" "vex")
9494    (set_attr "prefix_extra" "1")
9495    (set_attr "length_immediate" "1")
9496    (set_attr "mode" "TI")])
9497
9498 (define_insn "sse4_1_pblendw"
9499   [(set (match_operand:V8HI 0 "register_operand" "=x")
9500         (vec_merge:V8HI
9501           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9502           (match_operand:V8HI 1 "register_operand" "0")
9503           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9504   "TARGET_SSE4_1"
9505   "pblendw\t{%3, %2, %0|%0, %2, %3}"
9506   [(set_attr "type" "ssemov")
9507    (set_attr "prefix_extra" "1")
9508    (set_attr "length_immediate" "1")
9509    (set_attr "mode" "TI")])
9510
9511 (define_insn "sse4_1_phminposuw"
9512   [(set (match_operand:V8HI 0 "register_operand" "=x")
9513         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
9514                      UNSPEC_PHMINPOSUW))]
9515   "TARGET_SSE4_1"
9516   "%vphminposuw\t{%1, %0|%0, %1}"
9517   [(set_attr "type" "sselog1")
9518    (set_attr "prefix_extra" "1")
9519    (set_attr "prefix" "maybe_vex")
9520    (set_attr "mode" "TI")])
9521
9522 (define_insn "sse4_1_extendv8qiv8hi2"
9523   [(set (match_operand:V8HI 0 "register_operand" "=x")
9524         (sign_extend:V8HI
9525           (vec_select:V8QI
9526             (match_operand:V16QI 1 "register_operand" "x")
9527             (parallel [(const_int 0)
9528                        (const_int 1)
9529                        (const_int 2)
9530                        (const_int 3)
9531                        (const_int 4)
9532                        (const_int 5)
9533                        (const_int 6)
9534                        (const_int 7)]))))]
9535   "TARGET_SSE4_1"
9536   "%vpmovsxbw\t{%1, %0|%0, %1}"
9537   [(set_attr "type" "ssemov")
9538    (set_attr "prefix_extra" "1")
9539    (set_attr "prefix" "maybe_vex")
9540    (set_attr "mode" "TI")])
9541
9542 (define_insn "*sse4_1_extendv8qiv8hi2"
9543   [(set (match_operand:V8HI 0 "register_operand" "=x")
9544         (sign_extend:V8HI
9545           (vec_select:V8QI
9546             (vec_duplicate:V16QI
9547               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9548             (parallel [(const_int 0)
9549                        (const_int 1)
9550                        (const_int 2)
9551                        (const_int 3)
9552                        (const_int 4)
9553                        (const_int 5)
9554                        (const_int 6)
9555                        (const_int 7)]))))]
9556   "TARGET_SSE4_1"
9557   "%vpmovsxbw\t{%1, %0|%0, %1}"
9558   [(set_attr "type" "ssemov")
9559    (set_attr "prefix_extra" "1")
9560    (set_attr "prefix" "maybe_vex")
9561    (set_attr "mode" "TI")])
9562
9563 (define_insn "sse4_1_extendv4qiv4si2"
9564   [(set (match_operand:V4SI 0 "register_operand" "=x")
9565         (sign_extend:V4SI
9566           (vec_select:V4QI
9567             (match_operand:V16QI 1 "register_operand" "x")
9568             (parallel [(const_int 0)
9569                        (const_int 1)
9570                        (const_int 2)
9571                        (const_int 3)]))))]
9572   "TARGET_SSE4_1"
9573   "%vpmovsxbd\t{%1, %0|%0, %1}"
9574   [(set_attr "type" "ssemov")
9575    (set_attr "prefix_extra" "1")
9576    (set_attr "prefix" "maybe_vex")
9577    (set_attr "mode" "TI")])
9578
9579 (define_insn "*sse4_1_extendv4qiv4si2"
9580   [(set (match_operand:V4SI 0 "register_operand" "=x")
9581         (sign_extend:V4SI
9582           (vec_select:V4QI
9583             (vec_duplicate:V16QI
9584               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9585             (parallel [(const_int 0)
9586                        (const_int 1)
9587                        (const_int 2)
9588                        (const_int 3)]))))]
9589   "TARGET_SSE4_1"
9590   "%vpmovsxbd\t{%1, %0|%0, %1}"
9591   [(set_attr "type" "ssemov")
9592    (set_attr "prefix_extra" "1")
9593    (set_attr "prefix" "maybe_vex")
9594    (set_attr "mode" "TI")])
9595
9596 (define_insn "sse4_1_extendv2qiv2di2"
9597   [(set (match_operand:V2DI 0 "register_operand" "=x")
9598         (sign_extend:V2DI
9599           (vec_select:V2QI
9600             (match_operand:V16QI 1 "register_operand" "x")
9601             (parallel [(const_int 0)
9602                        (const_int 1)]))))]
9603   "TARGET_SSE4_1"
9604   "%vpmovsxbq\t{%1, %0|%0, %1}"
9605   [(set_attr "type" "ssemov")
9606    (set_attr "prefix_extra" "1")
9607    (set_attr "prefix" "maybe_vex")
9608    (set_attr "mode" "TI")])
9609
9610 (define_insn "*sse4_1_extendv2qiv2di2"
9611   [(set (match_operand:V2DI 0 "register_operand" "=x")
9612         (sign_extend:V2DI
9613           (vec_select:V2QI
9614             (vec_duplicate:V16QI
9615               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9616             (parallel [(const_int 0)
9617                        (const_int 1)]))))]
9618   "TARGET_SSE4_1"
9619   "%vpmovsxbq\t{%1, %0|%0, %1}"
9620   [(set_attr "type" "ssemov")
9621    (set_attr "prefix_extra" "1")
9622    (set_attr "prefix" "maybe_vex")
9623    (set_attr "mode" "TI")])
9624
9625 (define_insn "sse4_1_extendv4hiv4si2"
9626   [(set (match_operand:V4SI 0 "register_operand" "=x")
9627         (sign_extend:V4SI
9628           (vec_select:V4HI
9629             (match_operand:V8HI 1 "register_operand" "x")
9630             (parallel [(const_int 0)
9631                        (const_int 1)
9632                        (const_int 2)
9633                        (const_int 3)]))))]
9634   "TARGET_SSE4_1"
9635   "%vpmovsxwd\t{%1, %0|%0, %1}"
9636   [(set_attr "type" "ssemov")
9637    (set_attr "prefix_extra" "1")
9638    (set_attr "prefix" "maybe_vex")
9639    (set_attr "mode" "TI")])
9640
9641 (define_insn "*sse4_1_extendv4hiv4si2"
9642   [(set (match_operand:V4SI 0 "register_operand" "=x")
9643         (sign_extend:V4SI
9644           (vec_select:V4HI
9645             (vec_duplicate:V8HI
9646               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9647             (parallel [(const_int 0)
9648                        (const_int 1)
9649                        (const_int 2)
9650                        (const_int 3)]))))]
9651   "TARGET_SSE4_1"
9652   "%vpmovsxwd\t{%1, %0|%0, %1}"
9653   [(set_attr "type" "ssemov")
9654    (set_attr "prefix_extra" "1")
9655    (set_attr "prefix" "maybe_vex")
9656    (set_attr "mode" "TI")])
9657
9658 (define_insn "sse4_1_extendv2hiv2di2"
9659   [(set (match_operand:V2DI 0 "register_operand" "=x")
9660         (sign_extend:V2DI
9661           (vec_select:V2HI
9662             (match_operand:V8HI 1 "register_operand" "x")
9663             (parallel [(const_int 0)
9664                        (const_int 1)]))))]
9665   "TARGET_SSE4_1"
9666   "%vpmovsxwq\t{%1, %0|%0, %1}"
9667   [(set_attr "type" "ssemov")
9668    (set_attr "prefix_extra" "1")
9669    (set_attr "prefix" "maybe_vex")
9670    (set_attr "mode" "TI")])
9671
9672 (define_insn "*sse4_1_extendv2hiv2di2"
9673   [(set (match_operand:V2DI 0 "register_operand" "=x")
9674         (sign_extend:V2DI
9675           (vec_select:V2HI
9676             (vec_duplicate:V8HI
9677               (match_operand:V8HI 1 "nonimmediate_operand" "xm"))
9678             (parallel [(const_int 0)
9679                        (const_int 1)]))))]
9680   "TARGET_SSE4_1"
9681   "%vpmovsxwq\t{%1, %0|%0, %1}"
9682   [(set_attr "type" "ssemov")
9683    (set_attr "prefix_extra" "1")
9684    (set_attr "prefix" "maybe_vex")
9685    (set_attr "mode" "TI")])
9686
9687 (define_insn "sse4_1_extendv2siv2di2"
9688   [(set (match_operand:V2DI 0 "register_operand" "=x")
9689         (sign_extend:V2DI
9690           (vec_select:V2SI
9691             (match_operand:V4SI 1 "register_operand" "x")
9692             (parallel [(const_int 0)
9693                        (const_int 1)]))))]
9694   "TARGET_SSE4_1"
9695   "%vpmovsxdq\t{%1, %0|%0, %1}"
9696   [(set_attr "type" "ssemov")
9697    (set_attr "prefix_extra" "1")
9698    (set_attr "prefix" "maybe_vex")
9699    (set_attr "mode" "TI")])
9700
9701 (define_insn "*sse4_1_extendv2siv2di2"
9702   [(set (match_operand:V2DI 0 "register_operand" "=x")
9703         (sign_extend:V2DI
9704           (vec_select:V2SI
9705             (vec_duplicate:V4SI
9706               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9707             (parallel [(const_int 0)
9708                        (const_int 1)]))))]
9709   "TARGET_SSE4_1"
9710   "%vpmovsxdq\t{%1, %0|%0, %1}"
9711   [(set_attr "type" "ssemov")
9712    (set_attr "prefix_extra" "1")
9713    (set_attr "prefix" "maybe_vex")
9714    (set_attr "mode" "TI")])
9715
9716 (define_insn "sse4_1_zero_extendv8qiv8hi2"
9717   [(set (match_operand:V8HI 0 "register_operand" "=x")
9718         (zero_extend:V8HI
9719           (vec_select:V8QI
9720             (match_operand:V16QI 1 "register_operand" "x")
9721             (parallel [(const_int 0)
9722                        (const_int 1)
9723                        (const_int 2)
9724                        (const_int 3)
9725                        (const_int 4)
9726                        (const_int 5)
9727                        (const_int 6)
9728                        (const_int 7)]))))]
9729   "TARGET_SSE4_1"
9730   "%vpmovzxbw\t{%1, %0|%0, %1}"
9731   [(set_attr "type" "ssemov")
9732    (set_attr "prefix_extra" "1")
9733    (set_attr "prefix" "maybe_vex")
9734    (set_attr "mode" "TI")])
9735
9736 (define_insn "*sse4_1_zero_extendv8qiv8hi2"
9737   [(set (match_operand:V8HI 0 "register_operand" "=x")
9738         (zero_extend:V8HI
9739           (vec_select:V8QI
9740             (vec_duplicate:V16QI
9741               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9742             (parallel [(const_int 0)
9743                        (const_int 1)
9744                        (const_int 2)
9745                        (const_int 3)
9746                        (const_int 4)
9747                        (const_int 5)
9748                        (const_int 6)
9749                        (const_int 7)]))))]
9750   "TARGET_SSE4_1"
9751   "%vpmovzxbw\t{%1, %0|%0, %1}"
9752   [(set_attr "type" "ssemov")
9753    (set_attr "prefix_extra" "1")
9754    (set_attr "prefix" "maybe_vex")
9755    (set_attr "mode" "TI")])
9756
9757 (define_insn "sse4_1_zero_extendv4qiv4si2"
9758   [(set (match_operand:V4SI 0 "register_operand" "=x")
9759         (zero_extend:V4SI
9760           (vec_select:V4QI
9761             (match_operand:V16QI 1 "register_operand" "x")
9762             (parallel [(const_int 0)
9763                        (const_int 1)
9764                        (const_int 2)
9765                        (const_int 3)]))))]
9766   "TARGET_SSE4_1"
9767   "%vpmovzxbd\t{%1, %0|%0, %1}"
9768   [(set_attr "type" "ssemov")
9769    (set_attr "prefix_extra" "1")
9770    (set_attr "prefix" "maybe_vex")
9771    (set_attr "mode" "TI")])
9772
9773 (define_insn "*sse4_1_zero_extendv4qiv4si2"
9774   [(set (match_operand:V4SI 0 "register_operand" "=x")
9775         (zero_extend:V4SI
9776           (vec_select:V4QI
9777             (vec_duplicate:V16QI
9778               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9779             (parallel [(const_int 0)
9780                        (const_int 1)
9781                        (const_int 2)
9782                        (const_int 3)]))))]
9783   "TARGET_SSE4_1"
9784   "%vpmovzxbd\t{%1, %0|%0, %1}"
9785   [(set_attr "type" "ssemov")
9786    (set_attr "prefix_extra" "1")
9787    (set_attr "prefix" "maybe_vex")
9788    (set_attr "mode" "TI")])
9789
9790 (define_insn "sse4_1_zero_extendv2qiv2di2"
9791   [(set (match_operand:V2DI 0 "register_operand" "=x")
9792         (zero_extend:V2DI
9793           (vec_select:V2QI
9794             (match_operand:V16QI 1 "register_operand" "x")
9795             (parallel [(const_int 0)
9796                        (const_int 1)]))))]
9797   "TARGET_SSE4_1"
9798   "%vpmovzxbq\t{%1, %0|%0, %1}"
9799   [(set_attr "type" "ssemov")
9800    (set_attr "prefix_extra" "1")
9801    (set_attr "prefix" "maybe_vex")
9802    (set_attr "mode" "TI")])
9803
9804 (define_insn "*sse4_1_zero_extendv2qiv2di2"
9805   [(set (match_operand:V2DI 0 "register_operand" "=x")
9806         (zero_extend:V2DI
9807           (vec_select:V2QI
9808             (vec_duplicate:V16QI
9809               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9810             (parallel [(const_int 0)
9811                        (const_int 1)]))))]
9812   "TARGET_SSE4_1"
9813   "%vpmovzxbq\t{%1, %0|%0, %1}"
9814   [(set_attr "type" "ssemov")
9815    (set_attr "prefix_extra" "1")
9816    (set_attr "prefix" "maybe_vex")
9817    (set_attr "mode" "TI")])
9818
9819 (define_insn "sse4_1_zero_extendv4hiv4si2"
9820   [(set (match_operand:V4SI 0 "register_operand" "=x")
9821         (zero_extend:V4SI
9822           (vec_select:V4HI
9823             (match_operand:V8HI 1 "register_operand" "x")
9824             (parallel [(const_int 0)
9825                        (const_int 1)
9826                        (const_int 2)
9827                        (const_int 3)]))))]
9828   "TARGET_SSE4_1"
9829   "%vpmovzxwd\t{%1, %0|%0, %1}"
9830   [(set_attr "type" "ssemov")
9831    (set_attr "prefix_extra" "1")
9832    (set_attr "prefix" "maybe_vex")
9833    (set_attr "mode" "TI")])
9834
9835 (define_insn "*sse4_1_zero_extendv4hiv4si2"
9836   [(set (match_operand:V4SI 0 "register_operand" "=x")
9837         (zero_extend:V4SI
9838           (vec_select:V4HI
9839             (vec_duplicate:V8HI
9840               (match_operand:V4HI 1 "nonimmediate_operand" "xm"))
9841             (parallel [(const_int 0)
9842                        (const_int 1)
9843                        (const_int 2)
9844                        (const_int 3)]))))]
9845   "TARGET_SSE4_1"
9846   "%vpmovzxwd\t{%1, %0|%0, %1}"
9847   [(set_attr "type" "ssemov")
9848    (set_attr "prefix_extra" "1")
9849    (set_attr "prefix" "maybe_vex")
9850    (set_attr "mode" "TI")])
9851
9852 (define_insn "sse4_1_zero_extendv2hiv2di2"
9853   [(set (match_operand:V2DI 0 "register_operand" "=x")
9854         (zero_extend:V2DI
9855           (vec_select:V2HI
9856             (match_operand:V8HI 1 "register_operand" "x")
9857             (parallel [(const_int 0)
9858                        (const_int 1)]))))]
9859   "TARGET_SSE4_1"
9860   "%vpmovzxwq\t{%1, %0|%0, %1}"
9861   [(set_attr "type" "ssemov")
9862    (set_attr "prefix_extra" "1")
9863    (set_attr "prefix" "maybe_vex")
9864    (set_attr "mode" "TI")])
9865
9866 (define_insn "*sse4_1_zero_extendv2hiv2di2"
9867   [(set (match_operand:V2DI 0 "register_operand" "=x")
9868         (zero_extend:V2DI
9869           (vec_select:V2HI
9870             (vec_duplicate:V8HI
9871               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9872             (parallel [(const_int 0)
9873                        (const_int 1)]))))]
9874   "TARGET_SSE4_1"
9875   "%vpmovzxwq\t{%1, %0|%0, %1}"
9876   [(set_attr "type" "ssemov")
9877    (set_attr "prefix_extra" "1")
9878    (set_attr "prefix" "maybe_vex")
9879    (set_attr "mode" "TI")])
9880
9881 (define_insn "sse4_1_zero_extendv2siv2di2"
9882   [(set (match_operand:V2DI 0 "register_operand" "=x")
9883         (zero_extend:V2DI
9884           (vec_select:V2SI
9885             (match_operand:V4SI 1 "register_operand" "x")
9886             (parallel [(const_int 0)
9887                        (const_int 1)]))))]
9888   "TARGET_SSE4_1"
9889   "%vpmovzxdq\t{%1, %0|%0, %1}"
9890   [(set_attr "type" "ssemov")
9891    (set_attr "prefix_extra" "1")
9892    (set_attr "prefix" "maybe_vex")
9893    (set_attr "mode" "TI")])
9894
9895 (define_insn "*sse4_1_zero_extendv2siv2di2"
9896   [(set (match_operand:V2DI 0 "register_operand" "=x")
9897         (zero_extend:V2DI
9898           (vec_select:V2SI
9899             (vec_duplicate:V4SI
9900               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9901             (parallel [(const_int 0)
9902                        (const_int 1)]))))]
9903   "TARGET_SSE4_1"
9904   "%vpmovzxdq\t{%1, %0|%0, %1}"
9905   [(set_attr "type" "ssemov")
9906    (set_attr "prefix_extra" "1")
9907    (set_attr "prefix" "maybe_vex")
9908    (set_attr "mode" "TI")])
9909
9910 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
9911 ;; setting FLAGS_REG. But it is not a really compare instruction.
9912 (define_insn "avx_vtestp<avxmodesuffixf2c><avxmodesuffix>"
9913   [(set (reg:CC FLAGS_REG)
9914         (unspec:CC [(match_operand:AVXMODEF2P 0 "register_operand" "x")
9915                     (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")]
9916                    UNSPEC_VTESTP))]
9917   "TARGET_AVX"
9918   "vtestp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
9919   [(set_attr "type" "ssecomi")
9920    (set_attr "prefix_extra" "1")
9921    (set_attr "prefix" "vex")
9922    (set_attr "mode" "<MODE>")])
9923
9924 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
9925 ;; But it is not a really compare instruction.
9926 (define_insn "avx_ptest256"
9927   [(set (reg:CC FLAGS_REG)
9928         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
9929                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
9930                    UNSPEC_PTEST))]
9931   "TARGET_AVX"
9932   "vptest\t{%1, %0|%0, %1}"
9933   [(set_attr "type" "ssecomi")
9934    (set_attr "prefix_extra" "1")
9935    (set_attr "prefix" "vex")
9936    (set_attr "mode" "OI")])
9937
9938 (define_insn "sse4_1_ptest"
9939   [(set (reg:CC FLAGS_REG)
9940         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
9941                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
9942                    UNSPEC_PTEST))]
9943   "TARGET_SSE4_1"
9944   "%vptest\t{%1, %0|%0, %1}"
9945   [(set_attr "type" "ssecomi")
9946    (set_attr "prefix_extra" "1")
9947    (set_attr "prefix" "maybe_vex")
9948    (set_attr "mode" "TI")])
9949
9950 (define_insn "avx_roundp<avxmodesuffixf2c>256"
9951   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
9952         (unspec:AVX256MODEF2P
9953           [(match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "xm")
9954            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9955           UNSPEC_ROUND))]
9956   "TARGET_AVX"
9957   "vroundp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9958   [(set_attr "type" "ssecvt")
9959    (set_attr "prefix_extra" "1")
9960    (set_attr "length_immediate" "1")
9961    (set_attr "prefix" "vex")
9962    (set_attr "mode" "<MODE>")])
9963
9964 (define_insn "sse4_1_roundp<ssemodesuffixf2c>"
9965   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9966         (unspec:SSEMODEF2P
9967           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")
9968            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9969           UNSPEC_ROUND))]
9970   "TARGET_ROUND"
9971   "%vroundp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9972   [(set_attr "type" "ssecvt")
9973    (set_attr "prefix_data16" "1")
9974    (set_attr "prefix_extra" "1")
9975    (set_attr "length_immediate" "1")
9976    (set_attr "prefix" "maybe_vex")
9977    (set_attr "mode" "<MODE>")])
9978
9979 (define_insn "*avx_rounds<ssemodesuffixf2c>"
9980   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9981         (vec_merge:SSEMODEF2P
9982           (unspec:SSEMODEF2P
9983             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9984              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9985             UNSPEC_ROUND)
9986           (match_operand:SSEMODEF2P 1 "register_operand" "x")
9987           (const_int 1)))]
9988   "TARGET_AVX"
9989   "vrounds<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9990   [(set_attr "type" "ssecvt")
9991    (set_attr "prefix_extra" "1")
9992    (set_attr "length_immediate" "1")
9993    (set_attr "prefix" "vex")
9994    (set_attr "mode" "<MODE>")])
9995
9996 (define_insn "sse4_1_rounds<ssemodesuffixf2c>"
9997   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9998         (vec_merge:SSEMODEF2P
9999           (unspec:SSEMODEF2P
10000             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
10001              (match_operand:SI 3 "const_0_to_15_operand" "n")]
10002             UNSPEC_ROUND)
10003           (match_operand:SSEMODEF2P 1 "register_operand" "0")
10004           (const_int 1)))]
10005   "TARGET_ROUND"
10006   "rounds<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
10007   [(set_attr "type" "ssecvt")
10008    (set_attr "prefix_data16" "1")
10009    (set_attr "prefix_extra" "1")
10010    (set_attr "length_immediate" "1")
10011    (set_attr "mode" "<MODE>")])
10012
10013 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10014 ;;
10015 ;; Intel SSE4.2 string/text processing instructions
10016 ;;
10017 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10018
10019 (define_insn_and_split "sse4_2_pcmpestr"
10020   [(set (match_operand:SI 0 "register_operand" "=c,c")
10021         (unspec:SI
10022           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
10023            (match_operand:SI 3 "register_operand" "a,a")
10024            (match_operand:V16QI 4 "nonimm_not_xmm0_operand" "x,m")
10025            (match_operand:SI 5 "register_operand" "d,d")
10026            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
10027           UNSPEC_PCMPESTR))
10028    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
10029         (unspec:V16QI
10030           [(match_dup 2)
10031            (match_dup 3)
10032            (match_dup 4)
10033            (match_dup 5)
10034            (match_dup 6)]
10035           UNSPEC_PCMPESTR))
10036    (set (reg:CC FLAGS_REG)
10037         (unspec:CC
10038           [(match_dup 2)
10039            (match_dup 3)
10040            (match_dup 4)
10041            (match_dup 5)
10042            (match_dup 6)]
10043           UNSPEC_PCMPESTR))]
10044   "TARGET_SSE4_2
10045    && can_create_pseudo_p ()"
10046   "#"
10047   "&& 1"
10048   [(const_int 0)]
10049 {
10050   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
10051   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
10052   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
10053
10054   if (ecx)
10055     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
10056                                      operands[3], operands[4],
10057                                      operands[5], operands[6]));
10058   if (xmm0)
10059     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
10060                                      operands[3], operands[4],
10061                                      operands[5], operands[6]));
10062   if (flags && !(ecx || xmm0))
10063     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
10064                                            operands[2], operands[3],
10065                                            operands[4], operands[5],
10066                                            operands[6]));
10067   DONE;
10068 }
10069   [(set_attr "type" "sselog")
10070    (set_attr "prefix_data16" "1")
10071    (set_attr "prefix_extra" "1")
10072    (set_attr "length_immediate" "1")
10073    (set_attr "memory" "none,load")
10074    (set_attr "mode" "TI")])
10075
10076 (define_insn "sse4_2_pcmpestri"
10077   [(set (match_operand:SI 0 "register_operand" "=c,c")
10078         (unspec:SI
10079           [(match_operand:V16QI 1 "register_operand" "x,x")
10080            (match_operand:SI 2 "register_operand" "a,a")
10081            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
10082            (match_operand:SI 4 "register_operand" "d,d")
10083            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
10084           UNSPEC_PCMPESTR))
10085    (set (reg:CC FLAGS_REG)
10086         (unspec:CC
10087           [(match_dup 1)
10088            (match_dup 2)
10089            (match_dup 3)
10090            (match_dup 4)
10091            (match_dup 5)]
10092           UNSPEC_PCMPESTR))]
10093   "TARGET_SSE4_2"
10094   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
10095   [(set_attr "type" "sselog")
10096    (set_attr "prefix_data16" "1")
10097    (set_attr "prefix_extra" "1")
10098    (set_attr "prefix" "maybe_vex")
10099    (set_attr "length_immediate" "1")
10100    (set_attr "memory" "none,load")
10101    (set_attr "mode" "TI")])
10102
10103 (define_insn "sse4_2_pcmpestrm"
10104   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
10105         (unspec:V16QI
10106           [(match_operand:V16QI 1 "register_operand" "x,x")
10107            (match_operand:SI 2 "register_operand" "a,a")
10108            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
10109            (match_operand:SI 4 "register_operand" "d,d")
10110            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
10111           UNSPEC_PCMPESTR))
10112    (set (reg:CC FLAGS_REG)
10113         (unspec:CC
10114           [(match_dup 1)
10115            (match_dup 2)
10116            (match_dup 3)
10117            (match_dup 4)
10118            (match_dup 5)]
10119           UNSPEC_PCMPESTR))]
10120   "TARGET_SSE4_2"
10121   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
10122   [(set_attr "type" "sselog")
10123    (set_attr "prefix_data16" "1")
10124    (set_attr "prefix_extra" "1")
10125    (set_attr "length_immediate" "1")
10126    (set_attr "prefix" "maybe_vex")
10127    (set_attr "memory" "none,load")
10128    (set_attr "mode" "TI")])
10129
10130 (define_insn "sse4_2_pcmpestr_cconly"
10131   [(set (reg:CC FLAGS_REG)
10132         (unspec:CC
10133           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
10134            (match_operand:SI 3 "register_operand" "a,a,a,a")
10135            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
10136            (match_operand:SI 5 "register_operand" "d,d,d,d")
10137            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
10138           UNSPEC_PCMPESTR))
10139    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
10140    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
10141   "TARGET_SSE4_2"
10142   "@
10143    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
10144    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
10145    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
10146    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
10147   [(set_attr "type" "sselog")
10148    (set_attr "prefix_data16" "1")
10149    (set_attr "prefix_extra" "1")
10150    (set_attr "length_immediate" "1")
10151    (set_attr "memory" "none,load,none,load")
10152    (set_attr "prefix" "maybe_vex")
10153    (set_attr "mode" "TI")])
10154
10155 (define_insn_and_split "sse4_2_pcmpistr"
10156   [(set (match_operand:SI 0 "register_operand" "=c,c")
10157         (unspec:SI
10158           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
10159            (match_operand:V16QI 3 "nonimm_not_xmm0_operand" "x,m")
10160            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
10161           UNSPEC_PCMPISTR))
10162    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
10163         (unspec:V16QI
10164           [(match_dup 2)
10165            (match_dup 3)
10166            (match_dup 4)]
10167           UNSPEC_PCMPISTR))
10168    (set (reg:CC FLAGS_REG)
10169         (unspec:CC
10170           [(match_dup 2)
10171            (match_dup 3)
10172            (match_dup 4)]
10173           UNSPEC_PCMPISTR))]
10174   "TARGET_SSE4_2
10175    && can_create_pseudo_p ()"
10176   "#"
10177   "&& 1"
10178   [(const_int 0)]
10179 {
10180   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
10181   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
10182   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
10183
10184   if (ecx)
10185     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
10186                                      operands[3], operands[4]));
10187   if (xmm0)
10188     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
10189                                      operands[3], operands[4]));
10190   if (flags && !(ecx || xmm0))
10191     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
10192                                            operands[2], operands[3],
10193                                            operands[4]));
10194   DONE;
10195 }
10196   [(set_attr "type" "sselog")
10197    (set_attr "prefix_data16" "1")
10198    (set_attr "prefix_extra" "1")
10199    (set_attr "length_immediate" "1")
10200    (set_attr "memory" "none,load")
10201    (set_attr "mode" "TI")])
10202
10203 (define_insn "sse4_2_pcmpistri"
10204   [(set (match_operand:SI 0 "register_operand" "=c,c")
10205         (unspec:SI
10206           [(match_operand:V16QI 1 "register_operand" "x,x")
10207            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10208            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10209           UNSPEC_PCMPISTR))
10210    (set (reg:CC FLAGS_REG)
10211         (unspec:CC
10212           [(match_dup 1)
10213            (match_dup 2)
10214            (match_dup 3)]
10215           UNSPEC_PCMPISTR))]
10216   "TARGET_SSE4_2"
10217   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
10218   [(set_attr "type" "sselog")
10219    (set_attr "prefix_data16" "1")
10220    (set_attr "prefix_extra" "1")
10221    (set_attr "length_immediate" "1")
10222    (set_attr "prefix" "maybe_vex")
10223    (set_attr "memory" "none,load")
10224    (set_attr "mode" "TI")])
10225
10226 (define_insn "sse4_2_pcmpistrm"
10227   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
10228         (unspec:V16QI
10229           [(match_operand:V16QI 1 "register_operand" "x,x")
10230            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10231            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10232           UNSPEC_PCMPISTR))
10233    (set (reg:CC FLAGS_REG)
10234         (unspec:CC
10235           [(match_dup 1)
10236            (match_dup 2)
10237            (match_dup 3)]
10238           UNSPEC_PCMPISTR))]
10239   "TARGET_SSE4_2"
10240   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
10241   [(set_attr "type" "sselog")
10242    (set_attr "prefix_data16" "1")
10243    (set_attr "prefix_extra" "1")
10244    (set_attr "length_immediate" "1")
10245    (set_attr "prefix" "maybe_vex")
10246    (set_attr "memory" "none,load")
10247    (set_attr "mode" "TI")])
10248
10249 (define_insn "sse4_2_pcmpistr_cconly"
10250   [(set (reg:CC FLAGS_REG)
10251         (unspec:CC
10252           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
10253            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
10254            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
10255           UNSPEC_PCMPISTR))
10256    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
10257    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
10258   "TARGET_SSE4_2"
10259   "@
10260    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10261    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10262    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
10263    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
10264   [(set_attr "type" "sselog")
10265    (set_attr "prefix_data16" "1")
10266    (set_attr "prefix_extra" "1")
10267    (set_attr "length_immediate" "1")
10268    (set_attr "memory" "none,load,none,load")
10269    (set_attr "prefix" "maybe_vex")
10270    (set_attr "mode" "TI")])
10271
10272 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10273 ;;
10274 ;; XOP instructions
10275 ;;
10276 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10277
10278 ;; XOP parallel integer multiply/add instructions.
10279 ;; Note the XOP multiply/add instructions
10280 ;;     a[i] = b[i] * c[i] + d[i];
10281 ;; do not allow the value being added to be a memory operation.
10282 (define_insn "xop_pmacsww"
10283   [(set (match_operand:V8HI 0 "register_operand" "=x")
10284         (plus:V8HI
10285          (mult:V8HI
10286           (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10287           (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10288          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10289   "TARGET_XOP"
10290   "vpmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10291   [(set_attr "type" "ssemuladd")
10292    (set_attr "mode" "TI")])
10293
10294 (define_insn "xop_pmacssww"
10295   [(set (match_operand:V8HI 0 "register_operand" "=x")
10296         (ss_plus:V8HI
10297          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10298                     (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10299          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10300   "TARGET_XOP"
10301   "vpmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10302   [(set_attr "type" "ssemuladd")
10303    (set_attr "mode" "TI")])
10304
10305 (define_insn "xop_pmacsdd"
10306   [(set (match_operand:V4SI 0 "register_operand" "=x")
10307         (plus:V4SI
10308          (mult:V4SI
10309           (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10310           (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10311          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10312   "TARGET_XOP"
10313   "vpmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10314   [(set_attr "type" "ssemuladd")
10315    (set_attr "mode" "TI")])
10316
10317 (define_insn "xop_pmacssdd"
10318   [(set (match_operand:V4SI 0 "register_operand" "=x")
10319         (ss_plus:V4SI
10320          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10321                     (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10322          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10323   "TARGET_XOP"
10324   "vpmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10325   [(set_attr "type" "ssemuladd")
10326    (set_attr "mode" "TI")])
10327
10328 (define_insn "xop_pmacssdql"
10329   [(set (match_operand:V2DI 0 "register_operand" "=x")
10330         (ss_plus:V2DI
10331          (mult:V2DI
10332           (sign_extend:V2DI
10333            (vec_select:V2SI
10334             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10335             (parallel [(const_int 1)
10336                        (const_int 3)])))
10337           (vec_select:V2SI
10338            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10339            (parallel [(const_int 1)
10340                       (const_int 3)])))
10341          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10342   "TARGET_XOP"
10343   "vpmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10344   [(set_attr "type" "ssemuladd")
10345    (set_attr "mode" "TI")])
10346
10347 (define_insn "xop_pmacssdqh"
10348   [(set (match_operand:V2DI 0 "register_operand" "=x")
10349         (ss_plus:V2DI
10350          (mult:V2DI
10351           (sign_extend:V2DI
10352            (vec_select:V2SI
10353             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10354             (parallel [(const_int 0)
10355                        (const_int 2)])))
10356           (sign_extend:V2DI
10357            (vec_select:V2SI
10358             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10359             (parallel [(const_int 0)
10360                        (const_int 2)]))))
10361          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10362   "TARGET_XOP"
10363   "vpmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10364   [(set_attr "type" "ssemuladd")
10365    (set_attr "mode" "TI")])
10366
10367 (define_insn "xop_pmacsdql"
10368   [(set (match_operand:V2DI 0 "register_operand" "=x")
10369         (plus:V2DI
10370          (mult:V2DI
10371           (sign_extend:V2DI
10372            (vec_select:V2SI
10373             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10374             (parallel [(const_int 1)
10375                        (const_int 3)])))
10376           (sign_extend:V2DI
10377            (vec_select:V2SI
10378             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10379             (parallel [(const_int 1)
10380                        (const_int 3)]))))
10381          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10382   "TARGET_XOP"
10383   "vpmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10384   [(set_attr "type" "ssemuladd")
10385    (set_attr "mode" "TI")])
10386
10387 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10388 ;; fake it with a multiply/add.  In general, we expect the define_split to
10389 ;; occur before register allocation, so we have to handle the corner case where
10390 ;; the target is the same as operands 1/2
10391 (define_insn_and_split "xop_mulv2div2di3_low"
10392   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10393         (mult:V2DI
10394           (sign_extend:V2DI
10395             (vec_select:V2SI
10396               (match_operand:V4SI 1 "register_operand" "%x")
10397               (parallel [(const_int 1)
10398                          (const_int 3)])))
10399           (sign_extend:V2DI
10400             (vec_select:V2SI
10401               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10402               (parallel [(const_int 1)
10403                          (const_int 3)])))))]
10404   "TARGET_XOP"
10405   "#"
10406   "&& reload_completed"
10407   [(set (match_dup 0)
10408         (match_dup 3))
10409    (set (match_dup 0)
10410         (plus:V2DI
10411          (mult:V2DI
10412           (sign_extend:V2DI
10413            (vec_select:V2SI
10414             (match_dup 1)
10415             (parallel [(const_int 1)
10416                        (const_int 3)])))
10417           (sign_extend:V2DI
10418            (vec_select:V2SI
10419             (match_dup 2)
10420             (parallel [(const_int 1)
10421                        (const_int 3)]))))
10422          (match_dup 0)))]
10423 {
10424   operands[3] = CONST0_RTX (V2DImode);
10425 }
10426   [(set_attr "type" "ssemul")
10427    (set_attr "mode" "TI")])
10428
10429 (define_insn "xop_pmacsdqh"
10430   [(set (match_operand:V2DI 0 "register_operand" "=x")
10431         (plus:V2DI
10432          (mult:V2DI
10433           (sign_extend:V2DI
10434            (vec_select:V2SI
10435             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10436             (parallel [(const_int 0)
10437                        (const_int 2)])))
10438           (sign_extend:V2DI
10439            (vec_select:V2SI
10440             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10441             (parallel [(const_int 0)
10442                        (const_int 2)]))))
10443          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10444   "TARGET_XOP"
10445   "vpmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10446   [(set_attr "type" "ssemuladd")
10447    (set_attr "mode" "TI")])
10448
10449 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10450 ;; fake it with a multiply/add.  In general, we expect the define_split to
10451 ;; occur before register allocation, so we have to handle the corner case where
10452 ;; the target is the same as either operands[1] or operands[2]
10453 (define_insn_and_split "xop_mulv2div2di3_high"
10454   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10455         (mult:V2DI
10456           (sign_extend:V2DI
10457             (vec_select:V2SI
10458               (match_operand:V4SI 1 "register_operand" "%x")
10459               (parallel [(const_int 0)
10460                          (const_int 2)])))
10461           (sign_extend:V2DI
10462             (vec_select:V2SI
10463               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10464               (parallel [(const_int 0)
10465                          (const_int 2)])))))]
10466   "TARGET_XOP"
10467   "#"
10468   "&& reload_completed"
10469   [(set (match_dup 0)
10470         (match_dup 3))
10471    (set (match_dup 0)
10472         (plus:V2DI
10473          (mult:V2DI
10474           (sign_extend:V2DI
10475            (vec_select:V2SI
10476             (match_dup 1)
10477             (parallel [(const_int 0)
10478                        (const_int 2)])))
10479           (sign_extend:V2DI
10480            (vec_select:V2SI
10481             (match_dup 2)
10482             (parallel [(const_int 0)
10483                        (const_int 2)]))))
10484          (match_dup 0)))]
10485 {
10486   operands[3] = CONST0_RTX (V2DImode);
10487 }
10488   [(set_attr "type" "ssemul")
10489    (set_attr "mode" "TI")])
10490
10491 ;; XOP parallel integer multiply/add instructions for the intrinisics
10492 (define_insn "xop_pmacsswd"
10493   [(set (match_operand:V4SI 0 "register_operand" "=x")
10494         (ss_plus:V4SI
10495          (mult:V4SI
10496           (sign_extend:V4SI
10497            (vec_select:V4HI
10498             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10499             (parallel [(const_int 1)
10500                        (const_int 3)
10501                        (const_int 5)
10502                        (const_int 7)])))
10503           (sign_extend:V4SI
10504            (vec_select:V4HI
10505             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10506             (parallel [(const_int 1)
10507                        (const_int 3)
10508                        (const_int 5)
10509                        (const_int 7)]))))
10510          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10511   "TARGET_XOP"
10512   "vpmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10513   [(set_attr "type" "ssemuladd")
10514    (set_attr "mode" "TI")])
10515
10516 (define_insn "xop_pmacswd"
10517   [(set (match_operand:V4SI 0 "register_operand" "=x")
10518         (plus:V4SI
10519          (mult:V4SI
10520           (sign_extend:V4SI
10521            (vec_select:V4HI
10522             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10523             (parallel [(const_int 1)
10524                        (const_int 3)
10525                        (const_int 5)
10526                        (const_int 7)])))
10527           (sign_extend:V4SI
10528            (vec_select:V4HI
10529             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10530             (parallel [(const_int 1)
10531                        (const_int 3)
10532                        (const_int 5)
10533                        (const_int 7)]))))
10534          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10535   "TARGET_XOP"
10536   "vpmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10537   [(set_attr "type" "ssemuladd")
10538    (set_attr "mode" "TI")])
10539
10540 (define_insn "xop_pmadcsswd"
10541   [(set (match_operand:V4SI 0 "register_operand" "=x")
10542         (ss_plus:V4SI
10543          (plus:V4SI
10544           (mult:V4SI
10545            (sign_extend:V4SI
10546             (vec_select:V4HI
10547              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10548              (parallel [(const_int 0)
10549                         (const_int 2)
10550                         (const_int 4)
10551                         (const_int 6)])))
10552            (sign_extend:V4SI
10553             (vec_select:V4HI
10554              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10555              (parallel [(const_int 0)
10556                         (const_int 2)
10557                         (const_int 4)
10558                         (const_int 6)]))))
10559           (mult:V4SI
10560            (sign_extend:V4SI
10561             (vec_select:V4HI
10562              (match_dup 1)
10563              (parallel [(const_int 1)
10564                         (const_int 3)
10565                         (const_int 5)
10566                         (const_int 7)])))
10567            (sign_extend:V4SI
10568             (vec_select:V4HI
10569              (match_dup 2)
10570              (parallel [(const_int 1)
10571                         (const_int 3)
10572                         (const_int 5)
10573                         (const_int 7)])))))
10574          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10575   "TARGET_XOP"
10576   "vpmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10577   [(set_attr "type" "ssemuladd")
10578    (set_attr "mode" "TI")])
10579
10580 (define_insn "xop_pmadcswd"
10581   [(set (match_operand:V4SI 0 "register_operand" "=x")
10582         (plus:V4SI
10583          (plus:V4SI
10584           (mult:V4SI
10585            (sign_extend:V4SI
10586             (vec_select:V4HI
10587              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10588              (parallel [(const_int 0)
10589                         (const_int 2)
10590                         (const_int 4)
10591                         (const_int 6)])))
10592            (sign_extend:V4SI
10593             (vec_select:V4HI
10594              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10595              (parallel [(const_int 0)
10596                         (const_int 2)
10597                         (const_int 4)
10598                         (const_int 6)]))))
10599           (mult:V4SI
10600            (sign_extend:V4SI
10601             (vec_select:V4HI
10602              (match_dup 1)
10603              (parallel [(const_int 1)
10604                         (const_int 3)
10605                         (const_int 5)
10606                         (const_int 7)])))
10607            (sign_extend:V4SI
10608             (vec_select:V4HI
10609              (match_dup 2)
10610              (parallel [(const_int 1)
10611                         (const_int 3)
10612                         (const_int 5)
10613                         (const_int 7)])))))
10614          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10615   "TARGET_XOP"
10616   "vpmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10617   [(set_attr "type" "ssemuladd")
10618    (set_attr "mode" "TI")])
10619
10620 ;; XOP parallel XMM conditional moves
10621 (define_insn "xop_pcmov_<mode>"
10622   [(set (match_operand:SSEMODE 0 "register_operand" "=x,x")
10623         (if_then_else:SSEMODE
10624           (match_operand:SSEMODE 3 "nonimmediate_operand" "x,m")
10625           (match_operand:SSEMODE 1 "vector_move_operand" "x,x")
10626           (match_operand:SSEMODE 2 "vector_move_operand" "xm,x")))]
10627   "TARGET_XOP"
10628   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10629   [(set_attr "type" "sse4arg")])
10630
10631 (define_insn "xop_pcmov_<mode>256"
10632   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x")
10633         (if_then_else:AVX256MODE
10634           (match_operand:AVX256MODE 3 "nonimmediate_operand" "x,m")
10635           (match_operand:AVX256MODE 1 "vector_move_operand" "x,x")
10636           (match_operand:AVX256MODE 2 "vector_move_operand" "xm,x")))]
10637   "TARGET_XOP"
10638   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10639   [(set_attr "type" "sse4arg")])
10640
10641 ;; XOP horizontal add/subtract instructions
10642 (define_insn "xop_phaddbw"
10643   [(set (match_operand:V8HI 0 "register_operand" "=x")
10644         (plus:V8HI
10645          (sign_extend:V8HI
10646           (vec_select:V8QI
10647            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10648            (parallel [(const_int 0)
10649                       (const_int 2)
10650                       (const_int 4)
10651                       (const_int 6)
10652                       (const_int 8)
10653                       (const_int 10)
10654                       (const_int 12)
10655                       (const_int 14)])))
10656          (sign_extend:V8HI
10657           (vec_select:V8QI
10658            (match_dup 1)
10659            (parallel [(const_int 1)
10660                       (const_int 3)
10661                       (const_int 5)
10662                       (const_int 7)
10663                       (const_int 9)
10664                       (const_int 11)
10665                       (const_int 13)
10666                       (const_int 15)])))))]
10667   "TARGET_XOP"
10668   "vphaddbw\t{%1, %0|%0, %1}"
10669   [(set_attr "type" "sseiadd1")])
10670
10671 (define_insn "xop_phaddbd"
10672   [(set (match_operand:V4SI 0 "register_operand" "=x")
10673         (plus:V4SI
10674          (plus:V4SI
10675           (sign_extend:V4SI
10676            (vec_select:V4QI
10677             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10678             (parallel [(const_int 0)
10679                        (const_int 4)
10680                        (const_int 8)
10681                        (const_int 12)])))
10682           (sign_extend:V4SI
10683            (vec_select:V4QI
10684             (match_dup 1)
10685             (parallel [(const_int 1)
10686                        (const_int 5)
10687                        (const_int 9)
10688                        (const_int 13)]))))
10689          (plus:V4SI
10690           (sign_extend:V4SI
10691            (vec_select:V4QI
10692             (match_dup 1)
10693             (parallel [(const_int 2)
10694                        (const_int 6)
10695                        (const_int 10)
10696                        (const_int 14)])))
10697           (sign_extend:V4SI
10698            (vec_select:V4QI
10699             (match_dup 1)
10700             (parallel [(const_int 3)
10701                        (const_int 7)
10702                        (const_int 11)
10703                        (const_int 15)]))))))]
10704   "TARGET_XOP"
10705   "vphaddbd\t{%1, %0|%0, %1}"
10706   [(set_attr "type" "sseiadd1")])
10707
10708 (define_insn "xop_phaddbq"
10709   [(set (match_operand:V2DI 0 "register_operand" "=x")
10710         (plus:V2DI
10711          (plus:V2DI
10712           (plus:V2DI
10713            (sign_extend:V2DI
10714             (vec_select:V2QI
10715              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10716              (parallel [(const_int 0)
10717                         (const_int 4)])))
10718            (sign_extend:V2DI
10719             (vec_select:V2QI
10720              (match_dup 1)
10721              (parallel [(const_int 1)
10722                         (const_int 5)]))))
10723           (plus:V2DI
10724            (sign_extend:V2DI
10725             (vec_select:V2QI
10726              (match_dup 1)
10727              (parallel [(const_int 2)
10728                         (const_int 6)])))
10729            (sign_extend:V2DI
10730             (vec_select:V2QI
10731              (match_dup 1)
10732              (parallel [(const_int 3)
10733                         (const_int 7)])))))
10734          (plus:V2DI
10735           (plus:V2DI
10736            (sign_extend:V2DI
10737             (vec_select:V2QI
10738              (match_dup 1)
10739              (parallel [(const_int 8)
10740                         (const_int 12)])))
10741            (sign_extend:V2DI
10742             (vec_select:V2QI
10743              (match_dup 1)
10744              (parallel [(const_int 9)
10745                         (const_int 13)]))))
10746           (plus:V2DI
10747            (sign_extend:V2DI
10748             (vec_select:V2QI
10749              (match_dup 1)
10750              (parallel [(const_int 10)
10751                         (const_int 14)])))
10752            (sign_extend:V2DI
10753             (vec_select:V2QI
10754              (match_dup 1)
10755              (parallel [(const_int 11)
10756                         (const_int 15)])))))))]
10757   "TARGET_XOP"
10758   "vphaddbq\t{%1, %0|%0, %1}"
10759   [(set_attr "type" "sseiadd1")])
10760
10761 (define_insn "xop_phaddwd"
10762   [(set (match_operand:V4SI 0 "register_operand" "=x")
10763         (plus:V4SI
10764          (sign_extend:V4SI
10765           (vec_select:V4HI
10766            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10767            (parallel [(const_int 0)
10768                       (const_int 2)
10769                       (const_int 4)
10770                       (const_int 6)])))
10771          (sign_extend:V4SI
10772           (vec_select:V4HI
10773            (match_dup 1)
10774            (parallel [(const_int 1)
10775                       (const_int 3)
10776                       (const_int 5)
10777                       (const_int 7)])))))]
10778   "TARGET_XOP"
10779   "vphaddwd\t{%1, %0|%0, %1}"
10780   [(set_attr "type" "sseiadd1")])
10781
10782 (define_insn "xop_phaddwq"
10783   [(set (match_operand:V2DI 0 "register_operand" "=x")
10784         (plus:V2DI
10785          (plus:V2DI
10786           (sign_extend:V2DI
10787            (vec_select:V2HI
10788             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10789             (parallel [(const_int 0)
10790                        (const_int 4)])))
10791           (sign_extend:V2DI
10792            (vec_select:V2HI
10793             (match_dup 1)
10794             (parallel [(const_int 1)
10795                        (const_int 5)]))))
10796          (plus:V2DI
10797           (sign_extend:V2DI
10798            (vec_select:V2HI
10799             (match_dup 1)
10800             (parallel [(const_int 2)
10801                        (const_int 6)])))
10802           (sign_extend:V2DI
10803            (vec_select:V2HI
10804             (match_dup 1)
10805             (parallel [(const_int 3)
10806                        (const_int 7)]))))))]
10807   "TARGET_XOP"
10808   "vphaddwq\t{%1, %0|%0, %1}"
10809   [(set_attr "type" "sseiadd1")])
10810
10811 (define_insn "xop_phadddq"
10812   [(set (match_operand:V2DI 0 "register_operand" "=x")
10813         (plus:V2DI
10814          (sign_extend:V2DI
10815           (vec_select:V2SI
10816            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10817            (parallel [(const_int 0)
10818                       (const_int 2)])))
10819          (sign_extend:V2DI
10820           (vec_select:V2SI
10821            (match_dup 1)
10822            (parallel [(const_int 1)
10823                       (const_int 3)])))))]
10824   "TARGET_XOP"
10825   "vphadddq\t{%1, %0|%0, %1}"
10826   [(set_attr "type" "sseiadd1")])
10827
10828 (define_insn "xop_phaddubw"
10829   [(set (match_operand:V8HI 0 "register_operand" "=x")
10830         (plus:V8HI
10831          (zero_extend:V8HI
10832           (vec_select:V8QI
10833            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10834            (parallel [(const_int 0)
10835                       (const_int 2)
10836                       (const_int 4)
10837                       (const_int 6)
10838                       (const_int 8)
10839                       (const_int 10)
10840                       (const_int 12)
10841                       (const_int 14)])))
10842          (zero_extend:V8HI
10843           (vec_select:V8QI
10844            (match_dup 1)
10845            (parallel [(const_int 1)
10846                       (const_int 3)
10847                       (const_int 5)
10848                       (const_int 7)
10849                       (const_int 9)
10850                       (const_int 11)
10851                       (const_int 13)
10852                       (const_int 15)])))))]
10853   "TARGET_XOP"
10854   "vphaddubw\t{%1, %0|%0, %1}"
10855   [(set_attr "type" "sseiadd1")])
10856
10857 (define_insn "xop_phaddubd"
10858   [(set (match_operand:V4SI 0 "register_operand" "=x")
10859         (plus:V4SI
10860          (plus:V4SI
10861           (zero_extend:V4SI
10862            (vec_select:V4QI
10863             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10864             (parallel [(const_int 0)
10865                        (const_int 4)
10866                        (const_int 8)
10867                        (const_int 12)])))
10868           (zero_extend:V4SI
10869            (vec_select:V4QI
10870             (match_dup 1)
10871             (parallel [(const_int 1)
10872                        (const_int 5)
10873                        (const_int 9)
10874                        (const_int 13)]))))
10875          (plus:V4SI
10876           (zero_extend:V4SI
10877            (vec_select:V4QI
10878             (match_dup 1)
10879             (parallel [(const_int 2)
10880                        (const_int 6)
10881                        (const_int 10)
10882                        (const_int 14)])))
10883           (zero_extend:V4SI
10884            (vec_select:V4QI
10885             (match_dup 1)
10886             (parallel [(const_int 3)
10887                        (const_int 7)
10888                        (const_int 11)
10889                        (const_int 15)]))))))]
10890   "TARGET_XOP"
10891   "vphaddubd\t{%1, %0|%0, %1}"
10892   [(set_attr "type" "sseiadd1")])
10893
10894 (define_insn "xop_phaddubq"
10895   [(set (match_operand:V2DI 0 "register_operand" "=x")
10896         (plus:V2DI
10897          (plus:V2DI
10898           (plus:V2DI
10899            (zero_extend:V2DI
10900             (vec_select:V2QI
10901              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10902              (parallel [(const_int 0)
10903                         (const_int 4)])))
10904            (sign_extend:V2DI
10905             (vec_select:V2QI
10906              (match_dup 1)
10907              (parallel [(const_int 1)
10908                         (const_int 5)]))))
10909           (plus:V2DI
10910            (zero_extend:V2DI
10911             (vec_select:V2QI
10912              (match_dup 1)
10913              (parallel [(const_int 2)
10914                         (const_int 6)])))
10915            (zero_extend:V2DI
10916             (vec_select:V2QI
10917              (match_dup 1)
10918              (parallel [(const_int 3)
10919                         (const_int 7)])))))
10920          (plus:V2DI
10921           (plus:V2DI
10922            (zero_extend:V2DI
10923             (vec_select:V2QI
10924              (match_dup 1)
10925              (parallel [(const_int 8)
10926                         (const_int 12)])))
10927            (sign_extend:V2DI
10928             (vec_select:V2QI
10929              (match_dup 1)
10930              (parallel [(const_int 9)
10931                         (const_int 13)]))))
10932           (plus:V2DI
10933            (zero_extend:V2DI
10934             (vec_select:V2QI
10935              (match_dup 1)
10936              (parallel [(const_int 10)
10937                         (const_int 14)])))
10938            (zero_extend:V2DI
10939             (vec_select:V2QI
10940              (match_dup 1)
10941              (parallel [(const_int 11)
10942                         (const_int 15)])))))))]
10943   "TARGET_XOP"
10944   "vphaddubq\t{%1, %0|%0, %1}"
10945   [(set_attr "type" "sseiadd1")])
10946
10947 (define_insn "xop_phadduwd"
10948   [(set (match_operand:V4SI 0 "register_operand" "=x")
10949         (plus:V4SI
10950          (zero_extend:V4SI
10951           (vec_select:V4HI
10952            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10953            (parallel [(const_int 0)
10954                       (const_int 2)
10955                       (const_int 4)
10956                       (const_int 6)])))
10957          (zero_extend:V4SI
10958           (vec_select:V4HI
10959            (match_dup 1)
10960            (parallel [(const_int 1)
10961                       (const_int 3)
10962                       (const_int 5)
10963                       (const_int 7)])))))]
10964   "TARGET_XOP"
10965   "vphadduwd\t{%1, %0|%0, %1}"
10966   [(set_attr "type" "sseiadd1")])
10967
10968 (define_insn "xop_phadduwq"
10969   [(set (match_operand:V2DI 0 "register_operand" "=x")
10970         (plus:V2DI
10971          (plus:V2DI
10972           (zero_extend:V2DI
10973            (vec_select:V2HI
10974             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10975             (parallel [(const_int 0)
10976                        (const_int 4)])))
10977           (zero_extend:V2DI
10978            (vec_select:V2HI
10979             (match_dup 1)
10980             (parallel [(const_int 1)
10981                        (const_int 5)]))))
10982          (plus:V2DI
10983           (zero_extend:V2DI
10984            (vec_select:V2HI
10985             (match_dup 1)
10986             (parallel [(const_int 2)
10987                        (const_int 6)])))
10988           (zero_extend:V2DI
10989            (vec_select:V2HI
10990             (match_dup 1)
10991             (parallel [(const_int 3)
10992                        (const_int 7)]))))))]
10993   "TARGET_XOP"
10994   "vphadduwq\t{%1, %0|%0, %1}"
10995   [(set_attr "type" "sseiadd1")])
10996
10997 (define_insn "xop_phaddudq"
10998   [(set (match_operand:V2DI 0 "register_operand" "=x")
10999         (plus:V2DI
11000          (zero_extend:V2DI
11001           (vec_select:V2SI
11002            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11003            (parallel [(const_int 0)
11004                       (const_int 2)])))
11005          (zero_extend:V2DI
11006           (vec_select:V2SI
11007            (match_dup 1)
11008            (parallel [(const_int 1)
11009                       (const_int 3)])))))]
11010   "TARGET_XOP"
11011   "vphaddudq\t{%1, %0|%0, %1}"
11012   [(set_attr "type" "sseiadd1")])
11013
11014 (define_insn "xop_phsubbw"
11015   [(set (match_operand:V8HI 0 "register_operand" "=x")
11016         (minus:V8HI
11017          (sign_extend:V8HI
11018           (vec_select:V8QI
11019            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11020            (parallel [(const_int 0)
11021                       (const_int 2)
11022                       (const_int 4)
11023                       (const_int 6)
11024                       (const_int 8)
11025                       (const_int 10)
11026                       (const_int 12)
11027                       (const_int 14)])))
11028          (sign_extend:V8HI
11029           (vec_select:V8QI
11030            (match_dup 1)
11031            (parallel [(const_int 1)
11032                       (const_int 3)
11033                       (const_int 5)
11034                       (const_int 7)
11035                       (const_int 9)
11036                       (const_int 11)
11037                       (const_int 13)
11038                       (const_int 15)])))))]
11039   "TARGET_XOP"
11040   "vphsubbw\t{%1, %0|%0, %1}"
11041   [(set_attr "type" "sseiadd1")])
11042
11043 (define_insn "xop_phsubwd"
11044   [(set (match_operand:V4SI 0 "register_operand" "=x")
11045         (minus:V4SI
11046          (sign_extend:V4SI
11047           (vec_select:V4HI
11048            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11049            (parallel [(const_int 0)
11050                       (const_int 2)
11051                       (const_int 4)
11052                       (const_int 6)])))
11053          (sign_extend:V4SI
11054           (vec_select:V4HI
11055            (match_dup 1)
11056            (parallel [(const_int 1)
11057                       (const_int 3)
11058                       (const_int 5)
11059                       (const_int 7)])))))]
11060   "TARGET_XOP"
11061   "vphsubwd\t{%1, %0|%0, %1}"
11062   [(set_attr "type" "sseiadd1")])
11063
11064 (define_insn "xop_phsubdq"
11065   [(set (match_operand:V2DI 0 "register_operand" "=x")
11066         (minus:V2DI
11067          (sign_extend:V2DI
11068           (vec_select:V2SI
11069            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11070            (parallel [(const_int 0)
11071                       (const_int 2)])))
11072          (sign_extend:V2DI
11073           (vec_select:V2SI
11074            (match_dup 1)
11075            (parallel [(const_int 1)
11076                       (const_int 3)])))))]
11077   "TARGET_XOP"
11078   "vphsubdq\t{%1, %0|%0, %1}"
11079   [(set_attr "type" "sseiadd1")])
11080
11081 ;; XOP permute instructions
11082 (define_insn "xop_pperm"
11083   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
11084         (unspec:V16QI
11085           [(match_operand:V16QI 1 "register_operand" "x,x")
11086            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
11087            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
11088           UNSPEC_XOP_PERMUTE))]
11089   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11090   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11091   [(set_attr "type" "sse4arg")
11092    (set_attr "mode" "TI")])
11093
11094 ;; XOP pack instructions that combine two vectors into a smaller vector
11095 (define_insn "xop_pperm_pack_v2di_v4si"
11096   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
11097         (vec_concat:V4SI
11098          (truncate:V2SI
11099           (match_operand:V2DI 1 "register_operand" "x,x"))
11100          (truncate:V2SI
11101           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
11102    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11103   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11104   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11105   [(set_attr "type" "sse4arg")
11106    (set_attr "mode" "TI")])
11107
11108 (define_insn "xop_pperm_pack_v4si_v8hi"
11109   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11110         (vec_concat:V8HI
11111          (truncate:V4HI
11112           (match_operand:V4SI 1 "register_operand" "x,x"))
11113          (truncate:V4HI
11114           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
11115    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11116   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11117   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11118   [(set_attr "type" "sse4arg")
11119    (set_attr "mode" "TI")])
11120
11121 (define_insn "xop_pperm_pack_v8hi_v16qi"
11122   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
11123         (vec_concat:V16QI
11124          (truncate:V8QI
11125           (match_operand:V8HI 1 "register_operand" "x,x"))
11126          (truncate:V8QI
11127           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
11128    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11129   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11130   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11131   [(set_attr "type" "sse4arg")
11132    (set_attr "mode" "TI")])
11133
11134 ;; XOP packed rotate instructions
11135 (define_expand "rotl<mode>3"
11136   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11137         (rotate:SSEMODE1248
11138          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11139          (match_operand:SI 2 "general_operand")))]
11140   "TARGET_XOP"
11141 {
11142   /* If we were given a scalar, convert it to parallel */
11143   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11144     {
11145       rtvec vs = rtvec_alloc (<ssescalarnum>);
11146       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11147       rtx reg = gen_reg_rtx (<MODE>mode);
11148       rtx op2 = operands[2];
11149       int i;
11150
11151       if (GET_MODE (op2) != <ssescalarmode>mode)
11152         {
11153           op2 = gen_reg_rtx (<ssescalarmode>mode);
11154           convert_move (op2, operands[2], false);
11155         }
11156
11157       for (i = 0; i < <ssescalarnum>; i++)
11158         RTVEC_ELT (vs, i) = op2;
11159
11160       emit_insn (gen_vec_init<mode> (reg, par));
11161       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
11162       DONE;
11163     }
11164 })
11165
11166 (define_expand "rotr<mode>3"
11167   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11168         (rotatert:SSEMODE1248
11169          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11170          (match_operand:SI 2 "general_operand")))]
11171   "TARGET_XOP"
11172 {
11173   /* If we were given a scalar, convert it to parallel */
11174   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11175     {
11176       rtvec vs = rtvec_alloc (<ssescalarnum>);
11177       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11178       rtx neg = gen_reg_rtx (<MODE>mode);
11179       rtx reg = gen_reg_rtx (<MODE>mode);
11180       rtx op2 = operands[2];
11181       int i;
11182
11183       if (GET_MODE (op2) != <ssescalarmode>mode)
11184         {
11185           op2 = gen_reg_rtx (<ssescalarmode>mode);
11186           convert_move (op2, operands[2], false);
11187         }
11188
11189       for (i = 0; i < <ssescalarnum>; i++)
11190         RTVEC_ELT (vs, i) = op2;
11191
11192       emit_insn (gen_vec_init<mode> (reg, par));
11193       emit_insn (gen_neg<mode>2 (neg, reg));
11194       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
11195       DONE;
11196     }
11197 })
11198
11199 (define_insn "xop_rotl<mode>3"
11200   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11201         (rotate:SSEMODE1248
11202          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11203          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11204   "TARGET_XOP"
11205   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11206   [(set_attr "type" "sseishft")
11207    (set_attr "length_immediate" "1")
11208    (set_attr "mode" "TI")])
11209
11210 (define_insn "xop_rotr<mode>3"
11211   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11212         (rotatert:SSEMODE1248
11213          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11214          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11215   "TARGET_XOP"
11216 {
11217   operands[3] = GEN_INT ((<ssescalarnum> * 8) - INTVAL (operands[2]));
11218   return \"vprot<ssevecsize>\t{%3, %1, %0|%0, %1, %3}\";
11219 }
11220   [(set_attr "type" "sseishft")
11221    (set_attr "length_immediate" "1")
11222    (set_attr "mode" "TI")])
11223
11224 (define_expand "vrotr<mode>3"
11225   [(match_operand:SSEMODE1248 0 "register_operand" "")
11226    (match_operand:SSEMODE1248 1 "register_operand" "")
11227    (match_operand:SSEMODE1248 2 "register_operand" "")]
11228   "TARGET_XOP"
11229 {
11230   rtx reg = gen_reg_rtx (<MODE>mode);
11231   emit_insn (gen_neg<mode>2 (reg, operands[2]));
11232   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
11233   DONE;
11234 })
11235
11236 (define_expand "vrotl<mode>3"
11237   [(match_operand:SSEMODE1248 0 "register_operand" "")
11238    (match_operand:SSEMODE1248 1 "register_operand" "")
11239    (match_operand:SSEMODE1248 2 "register_operand" "")]
11240   "TARGET_XOP"
11241 {
11242   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
11243   DONE;
11244 })
11245
11246 (define_insn "xop_vrotl<mode>3"
11247   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11248         (if_then_else:SSEMODE1248
11249          (ge:SSEMODE1248
11250           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11251           (const_int 0))
11252          (rotate:SSEMODE1248
11253           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11254           (match_dup 2))
11255          (rotatert:SSEMODE1248
11256           (match_dup 1)
11257           (neg:SSEMODE1248 (match_dup 2)))))]
11258   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11259   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11260   [(set_attr "type" "sseishft")
11261    (set_attr "prefix_data16" "0")
11262    (set_attr "prefix_extra" "2")
11263    (set_attr "mode" "TI")])
11264
11265 ;; XOP packed shift instructions.
11266 ;; FIXME: add V2DI back in
11267 (define_expand "vlshr<mode>3"
11268   [(match_operand:SSEMODE124 0 "register_operand" "")
11269    (match_operand:SSEMODE124 1 "register_operand" "")
11270    (match_operand:SSEMODE124 2 "register_operand" "")]
11271   "TARGET_XOP"
11272 {
11273   rtx neg = gen_reg_rtx (<MODE>mode);
11274   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11275   emit_insn (gen_xop_lshl<mode>3 (operands[0], operands[1], neg));
11276   DONE;
11277 })
11278
11279 (define_expand "vashr<mode>3"
11280   [(match_operand:SSEMODE124 0 "register_operand" "")
11281    (match_operand:SSEMODE124 1 "register_operand" "")
11282    (match_operand:SSEMODE124 2 "register_operand" "")]
11283   "TARGET_XOP"
11284 {
11285   rtx neg = gen_reg_rtx (<MODE>mode);
11286   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11287   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], neg));
11288   DONE;
11289 })
11290
11291 (define_expand "vashl<mode>3"
11292   [(match_operand:SSEMODE124 0 "register_operand" "")
11293    (match_operand:SSEMODE124 1 "register_operand" "")
11294    (match_operand:SSEMODE124 2 "register_operand" "")]
11295   "TARGET_XOP"
11296 {
11297   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], operands[2]));
11298   DONE;
11299 })
11300
11301 (define_insn "xop_ashl<mode>3"
11302   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11303         (if_then_else:SSEMODE1248
11304          (ge:SSEMODE1248
11305           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11306           (const_int 0))
11307          (ashift:SSEMODE1248
11308           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11309           (match_dup 2))
11310          (ashiftrt:SSEMODE1248
11311           (match_dup 1)
11312           (neg:SSEMODE1248 (match_dup 2)))))]
11313   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11314   "vpsha<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11315   [(set_attr "type" "sseishft")
11316    (set_attr "prefix_data16" "0")
11317    (set_attr "prefix_extra" "2")
11318    (set_attr "mode" "TI")])
11319
11320 (define_insn "xop_lshl<mode>3"
11321   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11322         (if_then_else:SSEMODE1248
11323          (ge:SSEMODE1248
11324           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11325           (const_int 0))
11326          (ashift:SSEMODE1248
11327           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11328           (match_dup 2))
11329          (lshiftrt:SSEMODE1248
11330           (match_dup 1)
11331           (neg:SSEMODE1248 (match_dup 2)))))]
11332   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11333   "vpshl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11334   [(set_attr "type" "sseishft")
11335    (set_attr "prefix_data16" "0")
11336    (set_attr "prefix_extra" "2")
11337    (set_attr "mode" "TI")])
11338
11339 ;; SSE2 doesn't have some shift varients, so define versions for XOP
11340 (define_expand "ashlv16qi3"
11341   [(match_operand:V16QI 0 "register_operand" "")
11342    (match_operand:V16QI 1 "register_operand" "")
11343    (match_operand:SI 2 "nonmemory_operand" "")]
11344   "TARGET_XOP"
11345 {
11346   rtvec vs = rtvec_alloc (16);
11347   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11348   rtx reg = gen_reg_rtx (V16QImode);
11349   int i;
11350   for (i = 0; i < 16; i++)
11351     RTVEC_ELT (vs, i) = operands[2];
11352
11353   emit_insn (gen_vec_initv16qi (reg, par));
11354   emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11355   DONE;
11356 })
11357
11358 (define_expand "lshlv16qi3"
11359   [(match_operand:V16QI 0 "register_operand" "")
11360    (match_operand:V16QI 1 "register_operand" "")
11361    (match_operand:SI 2 "nonmemory_operand" "")]
11362   "TARGET_XOP"
11363 {
11364   rtvec vs = rtvec_alloc (16);
11365   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11366   rtx reg = gen_reg_rtx (V16QImode);
11367   int i;
11368   for (i = 0; i < 16; i++)
11369     RTVEC_ELT (vs, i) = operands[2];
11370
11371   emit_insn (gen_vec_initv16qi (reg, par));
11372   emit_insn (gen_xop_lshlv16qi3 (operands[0], operands[1], reg));
11373   DONE;
11374 })
11375
11376 (define_expand "ashrv16qi3"
11377   [(match_operand:V16QI 0 "register_operand" "")
11378    (match_operand:V16QI 1 "register_operand" "")
11379    (match_operand:SI 2 "nonmemory_operand" "")]
11380   "TARGET_XOP"
11381 {
11382   rtvec vs = rtvec_alloc (16);
11383   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11384   rtx reg = gen_reg_rtx (V16QImode);
11385   int i;
11386   rtx ele = ((CONST_INT_P (operands[2]))
11387              ? GEN_INT (- INTVAL (operands[2]))
11388              : operands[2]);
11389
11390   for (i = 0; i < 16; i++)
11391     RTVEC_ELT (vs, i) = ele;
11392
11393   emit_insn (gen_vec_initv16qi (reg, par));
11394
11395   if (!CONST_INT_P (operands[2]))
11396     {
11397       rtx neg = gen_reg_rtx (V16QImode);
11398       emit_insn (gen_negv16qi2 (neg, reg));
11399       emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], neg));
11400     }
11401   else
11402     emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11403
11404   DONE;
11405 })
11406
11407 (define_expand "ashrv2di3"
11408   [(match_operand:V2DI 0 "register_operand" "")
11409    (match_operand:V2DI 1 "register_operand" "")
11410    (match_operand:DI 2 "nonmemory_operand" "")]
11411   "TARGET_XOP"
11412 {
11413   rtvec vs = rtvec_alloc (2);
11414   rtx par = gen_rtx_PARALLEL (V2DImode, vs);
11415   rtx reg = gen_reg_rtx (V2DImode);
11416   rtx ele;
11417
11418   if (CONST_INT_P (operands[2]))
11419     ele = GEN_INT (- INTVAL (operands[2]));
11420   else if (GET_MODE (operands[2]) != DImode)
11421     {
11422       rtx move = gen_reg_rtx (DImode);
11423       ele = gen_reg_rtx (DImode);
11424       convert_move (move, operands[2], false);
11425       emit_insn (gen_negdi2 (ele, move));
11426     }
11427   else
11428     {
11429       ele = gen_reg_rtx (DImode);
11430       emit_insn (gen_negdi2 (ele, operands[2]));
11431     }
11432
11433   RTVEC_ELT (vs, 0) = ele;
11434   RTVEC_ELT (vs, 1) = ele;
11435   emit_insn (gen_vec_initv2di (reg, par));
11436   emit_insn (gen_xop_ashlv2di3 (operands[0], operands[1], reg));
11437   DONE;
11438 })
11439
11440 ;; XOP FRCZ support
11441 ;; parallel insns
11442 (define_insn "xop_frcz<mode>2"
11443   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11444         (unspec:SSEMODEF2P
11445          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")]
11446          UNSPEC_FRCZ))]
11447   "TARGET_XOP"
11448   "vfrcz<ssemodesuffixf4>\t{%1, %0|%0, %1}"
11449   [(set_attr "type" "ssecvt1")
11450    (set_attr "mode" "<MODE>")])
11451
11452 ;; scalar insns
11453 (define_insn "xop_vmfrcz<mode>2"
11454   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11455         (vec_merge:SSEMODEF2P
11456           (unspec:SSEMODEF2P
11457            [(match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
11458            UNSPEC_FRCZ)
11459           (match_operand:SSEMODEF2P 1 "register_operand" "0")
11460           (const_int 1)))]
11461   "TARGET_XOP"
11462   "vfrcz<ssemodesuffixf2s>\t{%2, %0|%0, %2}"
11463   [(set_attr "type" "ssecvt1")
11464    (set_attr "mode" "<MODE>")])
11465
11466 (define_insn "xop_frcz<mode>2256"
11467   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x")
11468         (unspec:FMA4MODEF4
11469          [(match_operand:FMA4MODEF4 1 "nonimmediate_operand" "xm")]
11470          UNSPEC_FRCZ))]
11471   "TARGET_XOP"
11472   "vfrcz<fma4modesuffixf4>\t{%1, %0|%0, %1}"
11473   [(set_attr "type" "ssecvt1")
11474    (set_attr "mode" "<MODE>")])
11475
11476 (define_insn "xop_maskcmp<mode>3"
11477   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11478         (match_operator:SSEMODE1248 1 "ix86_comparison_int_operator"
11479          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11480           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11481   "TARGET_XOP"
11482   "vpcom%Y1<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11483   [(set_attr "type" "sse4arg")
11484    (set_attr "prefix_data16" "0")
11485    (set_attr "prefix_rep" "0")
11486    (set_attr "prefix_extra" "2")
11487    (set_attr "length_immediate" "1")
11488    (set_attr "mode" "TI")])
11489
11490 (define_insn "xop_maskcmp_uns<mode>3"
11491   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11492         (match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11493          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11494           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11495   "TARGET_XOP"
11496   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11497   [(set_attr "type" "ssecmp")
11498    (set_attr "prefix_data16" "0")
11499    (set_attr "prefix_rep" "0")
11500    (set_attr "prefix_extra" "2")
11501    (set_attr "length_immediate" "1")
11502    (set_attr "mode" "TI")])
11503
11504 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
11505 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
11506 ;; the exact instruction generated for the intrinsic.
11507 (define_insn "xop_maskcmp_uns2<mode>3"
11508   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11509         (unspec:SSEMODE1248
11510          [(match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11511           [(match_operand:SSEMODE1248 2 "register_operand" "x")
11512            (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")])]
11513          UNSPEC_XOP_UNSIGNED_CMP))]
11514   "TARGET_XOP"
11515   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11516   [(set_attr "type" "ssecmp")
11517    (set_attr "prefix_data16" "0")
11518    (set_attr "prefix_extra" "2")
11519    (set_attr "length_immediate" "1")
11520    (set_attr "mode" "TI")])
11521
11522 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
11523 ;; being added here to be complete.
11524 (define_insn "xop_pcom_tf<mode>3"
11525   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11526         (unspec:SSEMODE1248
11527           [(match_operand:SSEMODE1248 1 "register_operand" "x")
11528            (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")
11529            (match_operand:SI 3 "const_int_operand" "n")]
11530           UNSPEC_XOP_TRUEFALSE))]
11531   "TARGET_XOP"
11532 {
11533   return ((INTVAL (operands[3]) != 0)
11534           ? "vpcomtrue<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11535           : "vpcomfalse<ssevecsize>\t{%2, %1, %0|%0, %1, %2}");
11536 }
11537   [(set_attr "type" "ssecmp")
11538    (set_attr "prefix_data16" "0")
11539    (set_attr "prefix_extra" "2")
11540    (set_attr "length_immediate" "1")
11541    (set_attr "mode" "TI")])
11542
11543 (define_insn "xop_vpermil2<mode>3"
11544   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11545         (unspec:AVXMODEF2P
11546           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11547            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "%x")
11548            (match_operand:<avxpermvecmode> 3 "nonimmediate_operand" "xm")
11549            (match_operand:SI 4 "const_0_to_3_operand" "n")]
11550           UNSPEC_VPERMIL2))]
11551   "TARGET_XOP"
11552   "vpermil2p<avxmodesuffixf2c>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
11553   [(set_attr "type" "sse4arg")
11554    (set_attr "length_immediate" "1")
11555    (set_attr "mode" "<MODE>")])
11556
11557 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11558 (define_insn "*avx_aesenc"
11559   [(set (match_operand:V2DI 0 "register_operand" "=x")
11560         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11561                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11562                       UNSPEC_AESENC))]
11563   "TARGET_AES && TARGET_AVX"
11564   "vaesenc\t{%2, %1, %0|%0, %1, %2}"
11565   [(set_attr "type" "sselog1")
11566    (set_attr "prefix_extra" "1")
11567    (set_attr "prefix" "vex")
11568    (set_attr "mode" "TI")])
11569
11570 (define_insn "aesenc"
11571   [(set (match_operand:V2DI 0 "register_operand" "=x")
11572         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11573                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11574                       UNSPEC_AESENC))]
11575   "TARGET_AES"
11576   "aesenc\t{%2, %0|%0, %2}"
11577   [(set_attr "type" "sselog1")
11578    (set_attr "prefix_extra" "1")
11579    (set_attr "mode" "TI")])
11580
11581 (define_insn "*avx_aesenclast"
11582   [(set (match_operand:V2DI 0 "register_operand" "=x")
11583         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11584                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11585                       UNSPEC_AESENCLAST))]
11586   "TARGET_AES && TARGET_AVX"
11587   "vaesenclast\t{%2, %1, %0|%0, %1, %2}"
11588   [(set_attr "type" "sselog1")
11589    (set_attr "prefix_extra" "1")
11590    (set_attr "prefix" "vex")
11591    (set_attr "mode" "TI")])
11592
11593 (define_insn "aesenclast"
11594   [(set (match_operand:V2DI 0 "register_operand" "=x")
11595         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11596                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11597                       UNSPEC_AESENCLAST))]
11598   "TARGET_AES"
11599   "aesenclast\t{%2, %0|%0, %2}"
11600   [(set_attr "type" "sselog1")
11601    (set_attr "prefix_extra" "1")
11602    (set_attr "mode" "TI")])
11603
11604 (define_insn "*avx_aesdec"
11605   [(set (match_operand:V2DI 0 "register_operand" "=x")
11606         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11607                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11608                       UNSPEC_AESDEC))]
11609   "TARGET_AES && TARGET_AVX"
11610   "vaesdec\t{%2, %1, %0|%0, %1, %2}"
11611   [(set_attr "type" "sselog1")
11612    (set_attr "prefix_extra" "1")
11613    (set_attr "prefix" "vex")
11614    (set_attr "mode" "TI")])
11615
11616 (define_insn "aesdec"
11617   [(set (match_operand:V2DI 0 "register_operand" "=x")
11618         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11619                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11620                       UNSPEC_AESDEC))]
11621   "TARGET_AES"
11622   "aesdec\t{%2, %0|%0, %2}"
11623   [(set_attr "type" "sselog1")
11624    (set_attr "prefix_extra" "1")
11625    (set_attr "mode" "TI")])
11626
11627 (define_insn "*avx_aesdeclast"
11628   [(set (match_operand:V2DI 0 "register_operand" "=x")
11629         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11630                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11631                       UNSPEC_AESDECLAST))]
11632   "TARGET_AES && TARGET_AVX"
11633   "vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
11634   [(set_attr "type" "sselog1")
11635    (set_attr "prefix_extra" "1")
11636    (set_attr "prefix" "vex")
11637    (set_attr "mode" "TI")])
11638
11639 (define_insn "aesdeclast"
11640   [(set (match_operand:V2DI 0 "register_operand" "=x")
11641         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11642                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11643                       UNSPEC_AESDECLAST))]
11644   "TARGET_AES"
11645   "aesdeclast\t{%2, %0|%0, %2}"
11646   [(set_attr "type" "sselog1")
11647    (set_attr "prefix_extra" "1")
11648    (set_attr "mode" "TI")])
11649
11650 (define_insn "aesimc"
11651   [(set (match_operand:V2DI 0 "register_operand" "=x")
11652         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11653                       UNSPEC_AESIMC))]
11654   "TARGET_AES"
11655   "%vaesimc\t{%1, %0|%0, %1}"
11656   [(set_attr "type" "sselog1")
11657    (set_attr "prefix_extra" "1")
11658    (set_attr "prefix" "maybe_vex")
11659    (set_attr "mode" "TI")])
11660
11661 (define_insn "aeskeygenassist"
11662   [(set (match_operand:V2DI 0 "register_operand" "=x")
11663         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
11664                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
11665                      UNSPEC_AESKEYGENASSIST))]
11666   "TARGET_AES"
11667   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
11668   [(set_attr "type" "sselog1")
11669    (set_attr "prefix_extra" "1")
11670    (set_attr "length_immediate" "1")
11671    (set_attr "prefix" "maybe_vex")
11672    (set_attr "mode" "TI")])
11673
11674 (define_insn "*vpclmulqdq"
11675   [(set (match_operand:V2DI 0 "register_operand" "=x")
11676         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11677                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11678                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11679                      UNSPEC_PCLMUL))]
11680   "TARGET_PCLMUL && TARGET_AVX"
11681   "vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11682   [(set_attr "type" "sselog1")
11683    (set_attr "prefix_extra" "1")
11684    (set_attr "length_immediate" "1")
11685    (set_attr "prefix" "vex")
11686    (set_attr "mode" "TI")])
11687
11688 (define_insn "pclmulqdq"
11689   [(set (match_operand:V2DI 0 "register_operand" "=x")
11690         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11691                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11692                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11693                      UNSPEC_PCLMUL))]
11694   "TARGET_PCLMUL"
11695   "pclmulqdq\t{%3, %2, %0|%0, %2, %3}"
11696   [(set_attr "type" "sselog1")
11697    (set_attr "prefix_extra" "1")
11698    (set_attr "length_immediate" "1")
11699    (set_attr "mode" "TI")])
11700
11701 (define_expand "avx_vzeroall"
11702   [(match_par_dup 0 [(const_int 0)])]
11703   "TARGET_AVX"
11704 {
11705   int nregs = TARGET_64BIT ? 16 : 8;
11706   int regno;
11707
11708   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11709
11710   XVECEXP (operands[0], 0, 0)
11711     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11712                                UNSPECV_VZEROALL);
11713
11714   for (regno = 0; regno < nregs; regno++)
11715     XVECEXP (operands[0], 0, regno + 1)
11716       = gen_rtx_SET (VOIDmode,
11717                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
11718                      CONST0_RTX (V8SImode));
11719 })
11720
11721 (define_insn "*avx_vzeroall"
11722   [(match_parallel 0 "vzeroall_operation"
11723     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
11724   "TARGET_AVX"
11725   "vzeroall"
11726   [(set_attr "type" "sse")
11727    (set_attr "modrm" "0")
11728    (set_attr "memory" "none")
11729    (set_attr "prefix" "vex")
11730    (set_attr "mode" "OI")])
11731
11732 ;; vzeroupper clobbers the upper 128bits of AVX registers.
11733 (define_expand "avx_vzeroupper"
11734   [(match_par_dup 0 [(const_int 0)])]
11735   "TARGET_AVX"
11736 {
11737   int nregs = TARGET_64BIT ? 16 : 8;
11738   int regno;
11739
11740   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11741
11742   XVECEXP (operands[0], 0, 0)
11743     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11744                                UNSPECV_VZEROUPPER);
11745
11746   for (regno = 0; regno < nregs; regno++)
11747     XVECEXP (operands[0], 0, regno + 1)
11748       = gen_rtx_CLOBBER (VOIDmode,
11749                          gen_rtx_REG (V8SImode, SSE_REGNO (regno)));
11750 })
11751
11752 (define_insn "*avx_vzeroupper"
11753   [(match_parallel 0 "vzeroupper_operation"
11754     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)])]
11755   "TARGET_AVX"
11756   "vzeroupper"
11757   [(set_attr "type" "sse")
11758    (set_attr "modrm" "0")
11759    (set_attr "memory" "none")
11760    (set_attr "prefix" "vex")
11761    (set_attr "mode" "OI")])
11762
11763 (define_insn_and_split "vec_dup<mode>"
11764   [(set (match_operand:AVX256MODE24P 0 "register_operand" "=x,x")
11765         (vec_duplicate:AVX256MODE24P
11766           (match_operand:<avxscalarmode> 1 "nonimmediate_operand" "m,?x")))]
11767   "TARGET_AVX"
11768   "@
11769    vbroadcasts<avxmodesuffixf2c>\t{%1, %0|%0, %1}
11770    #"
11771   "&& reload_completed && REG_P (operands[1])"
11772   [(set (match_dup 2) (vec_duplicate:<avxhalfvecmode> (match_dup 1)))
11773    (set (match_dup 0) (vec_concat:AVX256MODE24P (match_dup 2) (match_dup 2)))]
11774 {
11775   operands[2] = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (operands[0]));
11776 }
11777   [(set_attr "type" "ssemov")
11778    (set_attr "prefix_extra" "1")
11779    (set_attr "prefix" "vex")
11780    (set_attr "mode" "V8SF")])
11781
11782 (define_insn "avx_vbroadcastf128_<mode>"
11783   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x,x")
11784         (vec_concat:AVX256MODE
11785           (match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
11786           (match_dup 1)))]
11787   "TARGET_AVX"
11788   "@
11789    vbroadcastf128\t{%1, %0|%0, %1}
11790    vinsertf128\t{$1, %1, %0, %0|%0, %0, %1, 1}
11791    vperm2f128\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
11792   [(set_attr "type" "ssemov,sselog1,sselog1")
11793    (set_attr "prefix_extra" "1")
11794    (set_attr "length_immediate" "0,1,1")
11795    (set_attr "prefix" "vex")
11796    (set_attr "mode" "V4SF,V8SF,V8SF")])
11797
11798 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
11799 ;; If it so happens that the input is in memory, use vbroadcast.
11800 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
11801 (define_insn "*avx_vperm_broadcast_v4sf"
11802   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
11803         (vec_select:V4SF
11804           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
11805           (match_parallel 2 "avx_vbroadcast_operand"
11806             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11807   "TARGET_AVX"
11808 {
11809   int elt = INTVAL (operands[3]);
11810   switch (which_alternative)
11811     {
11812     case 0:
11813     case 1:
11814       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
11815       return "vbroadcastss\t{%1, %0|%0, %1}";
11816     case 2:
11817       operands[2] = GEN_INT (elt * 0x55);
11818       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
11819     default:
11820       gcc_unreachable ();
11821     }
11822 }
11823   [(set_attr "type" "ssemov,ssemov,sselog1")
11824    (set_attr "prefix_extra" "1")
11825    (set_attr "length_immediate" "0,0,1")
11826    (set_attr "prefix" "vex")
11827    (set_attr "mode" "SF,SF,V4SF")])
11828
11829 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
11830   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x,x,x")
11831         (vec_select:AVX256MODEF2P
11832           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "m,o,?x")
11833           (match_parallel 2 "avx_vbroadcast_operand"
11834             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11835   "TARGET_AVX"
11836   "#"
11837   "&& reload_completed"
11838   [(set (match_dup 0) (vec_duplicate:AVX256MODEF2P (match_dup 1)))]
11839 {
11840   rtx op0 = operands[0], op1 = operands[1];
11841   int elt = INTVAL (operands[3]);
11842
11843   if (REG_P (op1))
11844     {
11845       int mask;
11846
11847       /* Shuffle element we care about into all elements of the 128-bit lane.
11848          The other lane gets shuffled too, but we don't care.  */
11849       if (<MODE>mode == V4DFmode)
11850         mask = (elt & 1 ? 15 : 0);
11851       else
11852         mask = (elt & 3) * 0x55;
11853       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
11854
11855       /* Shuffle the lane we care about into both lanes of the dest.  */
11856       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
11857       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
11858       DONE;
11859     }
11860
11861   operands[1] = adjust_address_nv (op1, <avxscalarmode>mode,
11862                                    elt * GET_MODE_SIZE (<avxscalarmode>mode));
11863 })
11864
11865 (define_expand "avx_vpermil<mode>"
11866   [(set (match_operand:AVXMODEFDP 0 "register_operand" "")
11867         (vec_select:AVXMODEFDP
11868           (match_operand:AVXMODEFDP 1 "nonimmediate_operand" "")
11869           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11870   "TARGET_AVX"
11871 {
11872   int mask = INTVAL (operands[2]);
11873   rtx perm[<ssescalarnum>];
11874
11875   perm[0] = GEN_INT (mask & 1);
11876   perm[1] = GEN_INT ((mask >> 1) & 1);
11877   if (<MODE>mode == V4DFmode)
11878     {
11879       perm[2] = GEN_INT (((mask >> 2) & 1) + 2);
11880       perm[3] = GEN_INT (((mask >> 3) & 1) + 2);
11881     }
11882
11883   operands[2]
11884     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11885 })
11886
11887 (define_expand "avx_vpermil<mode>"
11888   [(set (match_operand:AVXMODEFSP 0 "register_operand" "")
11889         (vec_select:AVXMODEFSP
11890           (match_operand:AVXMODEFSP 1 "nonimmediate_operand" "")
11891           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11892   "TARGET_AVX"
11893 {
11894   int mask = INTVAL (operands[2]);
11895   rtx perm[<ssescalarnum>];
11896
11897   perm[0] = GEN_INT (mask & 3);
11898   perm[1] = GEN_INT ((mask >> 2) & 3);
11899   perm[2] = GEN_INT ((mask >> 4) & 3);
11900   perm[3] = GEN_INT ((mask >> 6) & 3);
11901   if (<MODE>mode == V8SFmode)
11902     {
11903       perm[4] = GEN_INT ((mask & 3) + 4);
11904       perm[5] = GEN_INT (((mask >> 2) & 3) + 4);
11905       perm[6] = GEN_INT (((mask >> 4) & 3) + 4);
11906       perm[7] = GEN_INT (((mask >> 6) & 3) + 4);
11907     }
11908
11909   operands[2]
11910     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11911 })
11912
11913 (define_insn "*avx_vpermilp<mode>"
11914   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11915         (vec_select:AVXMODEF2P
11916           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")
11917           (match_parallel 2 "avx_vpermilp_<mode>_operand"
11918             [(match_operand 3 "const_int_operand" "")])))]
11919   "TARGET_AVX"
11920 {
11921   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
11922   operands[2] = GEN_INT (mask);
11923   return "vpermilp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}";
11924 }
11925   [(set_attr "type" "sselog")
11926    (set_attr "prefix_extra" "1")
11927    (set_attr "length_immediate" "1")
11928    (set_attr "prefix" "vex")
11929    (set_attr "mode" "<MODE>")])
11930
11931 (define_insn "avx_vpermilvar<mode>3"
11932   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11933         (unspec:AVXMODEF2P
11934           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11935            (match_operand:<avxpermvecmode> 2 "nonimmediate_operand" "xm")]
11936           UNSPEC_VPERMIL))]
11937   "TARGET_AVX"
11938   "vpermilp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
11939   [(set_attr "type" "sselog")
11940    (set_attr "prefix_extra" "1")
11941    (set_attr "prefix" "vex")
11942    (set_attr "mode" "<MODE>")])
11943
11944 (define_expand "avx_vperm2f128<mode>3"
11945   [(set (match_operand:AVX256MODE2P 0 "register_operand" "")
11946         (unspec:AVX256MODE2P
11947           [(match_operand:AVX256MODE2P 1 "register_operand" "")
11948            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "")
11949            (match_operand:SI 3 "const_0_to_255_operand" "")]
11950           UNSPEC_VPERMIL2F128))]
11951   "TARGET_AVX"
11952 {
11953   int mask = INTVAL (operands[3]);
11954   if ((mask & 0x88) == 0)
11955     {
11956       rtx perm[<ssescalarnum>], t1, t2;
11957       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
11958
11959       base = (mask & 3) * nelt2;
11960       for (i = 0; i < nelt2; ++i)
11961         perm[i] = GEN_INT (base + i);
11962
11963       base = ((mask >> 4) & 3) * nelt2;
11964       for (i = 0; i < nelt2; ++i)
11965         perm[i + nelt2] = GEN_INT (base + i);
11966
11967       t2 = gen_rtx_VEC_CONCAT (<ssedoublesizemode>mode,
11968                                operands[1], operands[2]);
11969       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
11970       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
11971       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
11972       emit_insn (t2);
11973       DONE;
11974     }
11975 })
11976
11977 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
11978 ;; means that in order to represent this properly in rtl we'd have to
11979 ;; nest *another* vec_concat with a zero operand and do the select from
11980 ;; a 4x wide vector.  That doesn't seem very nice.
11981 (define_insn "*avx_vperm2f128<mode>_full"
11982   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
11983         (unspec:AVX256MODE2P
11984           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
11985            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
11986            (match_operand:SI 3 "const_0_to_255_operand" "n")]
11987           UNSPEC_VPERMIL2F128))]
11988   "TARGET_AVX"
11989   "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11990   [(set_attr "type" "sselog")
11991    (set_attr "prefix_extra" "1")
11992    (set_attr "length_immediate" "1")
11993    (set_attr "prefix" "vex")
11994    (set_attr "mode" "V8SF")])
11995
11996 (define_insn "*avx_vperm2f128<mode>_nozero"
11997   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
11998         (vec_select:AVX256MODE2P
11999           (vec_concat:<ssedoublesizemode>
12000             (match_operand:AVX256MODE2P 1 "register_operand" "x")
12001             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
12002           (match_parallel 3 "avx_vperm2f128_<mode>_operand"
12003             [(match_operand 4 "const_int_operand" "")])))]
12004   "TARGET_AVX"
12005 {
12006   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
12007   operands[3] = GEN_INT (mask);
12008   return "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}";
12009 }
12010   [(set_attr "type" "sselog")
12011    (set_attr "prefix_extra" "1")
12012    (set_attr "length_immediate" "1")
12013    (set_attr "prefix" "vex")
12014    (set_attr "mode" "V8SF")])
12015
12016 (define_expand "avx_vinsertf128<mode>"
12017   [(match_operand:AVX256MODE 0 "register_operand" "")
12018    (match_operand:AVX256MODE 1 "register_operand" "")
12019    (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "")
12020    (match_operand:SI 3 "const_0_to_1_operand" "")]
12021   "TARGET_AVX"
12022 {
12023   switch (INTVAL (operands[3]))
12024     {
12025     case 0:
12026       emit_insn (gen_vec_set_lo_<mode> (operands[0], operands[1],
12027                                         operands[2]));
12028       break;
12029     case 1:
12030       emit_insn (gen_vec_set_hi_<mode> (operands[0], operands[1],
12031                                         operands[2]));
12032       break;
12033     default:
12034       gcc_unreachable ();
12035     }
12036   DONE;
12037 })
12038
12039 (define_insn "vec_set_lo_<mode>"
12040   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12041         (vec_concat:AVX256MODE4P
12042           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12043           (vec_select:<avxhalfvecmode>
12044             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12045             (parallel [(const_int 2) (const_int 3)]))))]
12046   "TARGET_AVX"
12047   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12048   [(set_attr "type" "sselog")
12049    (set_attr "prefix_extra" "1")
12050    (set_attr "length_immediate" "1")
12051    (set_attr "prefix" "vex")
12052    (set_attr "mode" "V8SF")])
12053
12054 (define_insn "vec_set_hi_<mode>"
12055   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12056         (vec_concat:AVX256MODE4P
12057           (vec_select:<avxhalfvecmode>
12058             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12059             (parallel [(const_int 0) (const_int 1)]))
12060           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12061   "TARGET_AVX"
12062   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12063   [(set_attr "type" "sselog")
12064    (set_attr "prefix_extra" "1")
12065    (set_attr "length_immediate" "1")
12066    (set_attr "prefix" "vex")
12067    (set_attr "mode" "V8SF")])
12068
12069 (define_insn "vec_set_lo_<mode>"
12070   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12071         (vec_concat:AVX256MODE8P
12072           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12073           (vec_select:<avxhalfvecmode>
12074             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12075             (parallel [(const_int 4) (const_int 5)
12076                        (const_int 6) (const_int 7)]))))]
12077   "TARGET_AVX"
12078   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12079   [(set_attr "type" "sselog")
12080    (set_attr "prefix_extra" "1")
12081    (set_attr "length_immediate" "1")
12082    (set_attr "prefix" "vex")
12083    (set_attr "mode" "V8SF")])
12084
12085 (define_insn "vec_set_hi_<mode>"
12086   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12087         (vec_concat:AVX256MODE8P
12088           (vec_select:<avxhalfvecmode>
12089             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12090             (parallel [(const_int 0) (const_int 1)
12091                        (const_int 2) (const_int 3)]))
12092           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12093   "TARGET_AVX"
12094   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12095   [(set_attr "type" "sselog")
12096    (set_attr "prefix_extra" "1")
12097    (set_attr "length_immediate" "1")
12098    (set_attr "prefix" "vex")
12099    (set_attr "mode" "V8SF")])
12100
12101 (define_insn "vec_set_lo_v16hi"
12102   [(set (match_operand:V16HI 0 "register_operand" "=x")
12103         (vec_concat:V16HI
12104           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
12105           (vec_select:V8HI
12106             (match_operand:V16HI 1 "register_operand" "x")
12107             (parallel [(const_int 8) (const_int 9)
12108                        (const_int 10) (const_int 11)
12109                        (const_int 12) (const_int 13)
12110                        (const_int 14) (const_int 15)]))))]
12111   "TARGET_AVX"
12112   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12113   [(set_attr "type" "sselog")
12114    (set_attr "prefix_extra" "1")
12115    (set_attr "length_immediate" "1")
12116    (set_attr "prefix" "vex")
12117    (set_attr "mode" "V8SF")])
12118
12119 (define_insn "vec_set_hi_v16hi"
12120   [(set (match_operand:V16HI 0 "register_operand" "=x")
12121         (vec_concat:V16HI
12122           (vec_select:V8HI
12123             (match_operand:V16HI 1 "register_operand" "x")
12124             (parallel [(const_int 0) (const_int 1)
12125                        (const_int 2) (const_int 3)
12126                        (const_int 4) (const_int 5)
12127                        (const_int 6) (const_int 7)]))
12128           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
12129   "TARGET_AVX"
12130   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12131   [(set_attr "type" "sselog")
12132    (set_attr "prefix_extra" "1")
12133    (set_attr "length_immediate" "1")
12134    (set_attr "prefix" "vex")
12135    (set_attr "mode" "V8SF")])
12136
12137 (define_insn "vec_set_lo_v32qi"
12138   [(set (match_operand:V32QI 0 "register_operand" "=x")
12139         (vec_concat:V32QI
12140           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
12141           (vec_select:V16QI
12142             (match_operand:V32QI 1 "register_operand" "x")
12143             (parallel [(const_int 16) (const_int 17)
12144                        (const_int 18) (const_int 19)
12145                        (const_int 20) (const_int 21)
12146                        (const_int 22) (const_int 23)
12147                        (const_int 24) (const_int 25)
12148                        (const_int 26) (const_int 27)
12149                        (const_int 28) (const_int 29)
12150                        (const_int 30) (const_int 31)]))))]
12151   "TARGET_AVX"
12152   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12153   [(set_attr "type" "sselog")
12154    (set_attr "prefix_extra" "1")
12155    (set_attr "length_immediate" "1")
12156    (set_attr "prefix" "vex")
12157    (set_attr "mode" "V8SF")])
12158
12159 (define_insn "vec_set_hi_v32qi"
12160   [(set (match_operand:V32QI 0 "register_operand" "=x")
12161         (vec_concat:V32QI
12162           (vec_select:V16QI
12163             (match_operand:V32QI 1 "register_operand" "x")
12164             (parallel [(const_int 0) (const_int 1)
12165                        (const_int 2) (const_int 3)
12166                        (const_int 4) (const_int 5)
12167                        (const_int 6) (const_int 7)
12168                        (const_int 8) (const_int 9)
12169                        (const_int 10) (const_int 11)
12170                        (const_int 12) (const_int 13)
12171                        (const_int 14) (const_int 15)]))
12172           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
12173   "TARGET_AVX"
12174   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12175   [(set_attr "type" "sselog")
12176    (set_attr "prefix_extra" "1")
12177    (set_attr "length_immediate" "1")
12178    (set_attr "prefix" "vex")
12179    (set_attr "mode" "V8SF")])
12180
12181 (define_insn "avx_maskloadp<avxmodesuffixf2c><avxmodesuffix>"
12182   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
12183         (unspec:AVXMODEF2P
12184           [(match_operand:AVXMODEF2P 1 "memory_operand" "m")
12185            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12186            (match_dup 0)]
12187           UNSPEC_MASKLOAD))]
12188   "TARGET_AVX"
12189   "vmaskmovp<avxmodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
12190   [(set_attr "type" "sselog1")
12191    (set_attr "prefix_extra" "1")
12192    (set_attr "prefix" "vex")
12193    (set_attr "mode" "<MODE>")])
12194
12195 (define_insn "avx_maskstorep<avxmodesuffixf2c><avxmodesuffix>"
12196   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
12197         (unspec:AVXMODEF2P
12198           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
12199            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12200            (match_dup 0)]
12201           UNSPEC_MASKSTORE))]
12202   "TARGET_AVX"
12203   "vmaskmovp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
12204   [(set_attr "type" "sselog1")
12205    (set_attr "prefix_extra" "1")
12206    (set_attr "prefix" "vex")
12207    (set_attr "mode" "<MODE>")])
12208
12209 (define_insn "avx_<avxmodesuffixp><avxmodesuffix>_<avxmodesuffixp>"
12210   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x,x")
12211         (unspec:AVX256MODE2P
12212           [(match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "0,xm")]
12213           UNSPEC_CAST))]
12214   "TARGET_AVX"
12215 {
12216   switch (which_alternative)
12217     {
12218     case 0:
12219       return "";
12220     case 1:
12221       switch (get_attr_mode (insn))
12222         {
12223         case MODE_V8SF:
12224           return "vmovaps\t{%1, %x0|%x0, %1}";
12225         case MODE_V4DF:
12226           return "vmovapd\t{%1, %x0|%x0, %1}";
12227         case MODE_OI:
12228           return "vmovdqa\t{%1, %x0|%x0, %1}";
12229         default:
12230           break;
12231         }
12232     default:
12233       break;
12234     }
12235   gcc_unreachable ();
12236 }
12237   [(set_attr "type" "ssemov")
12238    (set_attr "prefix" "vex")
12239    (set_attr "mode" "<avxvecmode>")
12240    (set (attr "length")
12241     (if_then_else (eq_attr "alternative" "0")
12242        (const_string "0")
12243        (const_string "*")))])
12244
12245 (define_insn "avx_<avxmodesuffixp>_<avxmodesuffixp><avxmodesuffix>"
12246   [(set (match_operand:<avxhalfvecmode> 0 "register_operand" "=x,x")
12247         (unspec:<avxhalfvecmode>
12248           [(match_operand:AVX256MODE2P 1 "nonimmediate_operand" "0,xm")]
12249           UNSPEC_CAST))]
12250   "TARGET_AVX"
12251 {
12252   switch (which_alternative)
12253     {
12254     case 0:
12255       return "";
12256     case 1:
12257       switch (get_attr_mode (insn))
12258         {
12259         case MODE_V8SF:
12260           return "vmovaps\t{%x1, %0|%0, %x1}";
12261         case MODE_V4DF:
12262           return "vmovapd\t{%x1, %0|%0, %x1}";
12263         case MODE_OI:
12264           return "vmovdqa\t{%x1, %0|%0, %x1}";
12265         default:
12266           break;
12267         }
12268     default:
12269       break;
12270     }
12271   gcc_unreachable ();
12272 }
12273   [(set_attr "type" "ssemov")
12274    (set_attr "prefix" "vex")
12275    (set_attr "mode" "<avxvecmode>")
12276    (set (attr "length")
12277     (if_then_else (eq_attr "alternative" "0")
12278        (const_string "0")
12279        (const_string "*")))])
12280
12281 (define_expand "vec_init<mode>"
12282   [(match_operand:AVX256MODE 0 "register_operand" "")
12283    (match_operand 1 "" "")]
12284   "TARGET_AVX"
12285 {
12286   ix86_expand_vector_init (false, operands[0], operands[1]);
12287   DONE;
12288 })
12289
12290 (define_insn "*vec_concat<mode>_avx"
12291   [(set (match_operand:AVX256MODE 0 "register_operand"   "=x,x")
12292         (vec_concat:AVX256MODE
12293           (match_operand:<avxhalfvecmode> 1 "register_operand" "x,x")
12294           (match_operand:<avxhalfvecmode> 2 "vector_move_operand" "xm,C")))]
12295   "TARGET_AVX"
12296 {
12297   switch (which_alternative)
12298     {
12299     case 0:
12300       return "vinsertf128\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
12301     case 1:
12302       switch (get_attr_mode (insn))
12303         {
12304         case MODE_V8SF:
12305           return "vmovaps\t{%1, %x0|%x0, %1}";
12306         case MODE_V4DF:
12307           return "vmovapd\t{%1, %x0|%x0, %1}";
12308         default:
12309           return "vmovdqa\t{%1, %x0|%x0, %1}";
12310         }
12311     default:
12312       gcc_unreachable ();
12313     }
12314 }
12315   [(set_attr "type" "sselog,ssemov")
12316    (set_attr "prefix_extra" "1,*")
12317    (set_attr "length_immediate" "1,*")
12318    (set_attr "prefix" "vex")
12319    (set_attr "mode" "<avxvecmode>")])