contrib/gcc-4.4/gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009
   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, minus TImode, which gets
  23 ;; special-cased for TARGET_64BIT.
  24 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  25
  26 ;; All 16-byte vector modes handled by SSE
  27 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI 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 [V16QI V8HI V4SI V2DI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  43
  44 ;; Mix-n-match
  45 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  46 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  47 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  48 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  49 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  50 (define_mode_iterator SSEMODE1248 [V16QI V8HI V4SI V2DI])
  51 (define_mode_iterator SSEMODEF4 [SF DF V4SF V2DF])
  52 (define_mode_iterator SSEMODEF2P [V4SF V2DF])
  53
  54 (define_mode_iterator AVX256MODEF2P [V8SF V4DF])
  55 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
  56 (define_mode_iterator AVX256MODE4P [V4DI V4DF])
  57 (define_mode_iterator AVX256MODE8P [V8SI V8SF])
  58 (define_mode_iterator AVXMODEF2P [V4SF V2DF V8SF V4DF])
  59 (define_mode_iterator AVXMODEF4P [V4SF V4DF])
  60 (define_mode_iterator AVXMODEDCVTDQ2PS [V4SF V8SF])
  61 (define_mode_iterator AVXMODEDCVTPS2DQ [V4SI V8SI])
  62
  63 ;; Int-float size matches
  64 (define_mode_iterator SSEMODE4S [V4SF V4SI])
  65 (define_mode_iterator SSEMODE2D [V2DF V2DI])
  66
  67 ;; Modes handled by integer vcond pattern
  68 (define_mode_iterator SSEMODE124C8 [V16QI V8HI V4SI
  69                                     (V2DI "TARGET_SSE4_2 || TARGET_SSE5")])
  70
  71 ;; Mapping from float mode to required SSE level
  72 (define_mode_attr sse [(SF "sse") (DF "sse2") (V4SF "sse") (V2DF "sse2")])
  73
  74 ;; Mapping from integer vector mode to mnemonic suffix
  75 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
  76
  77 ;; Mapping of the sse5 suffix
  78 (define_mode_attr ssemodesuffixf4 [(SF "ss") (DF "sd")
  79                                    (V4SF "ps") (V2DF "pd")])
  80 (define_mode_attr ssemodesuffixf2s [(SF "ss") (DF "sd")
  81                                     (V4SF "ss") (V2DF "sd")])
  82 (define_mode_attr ssemodesuffixf2c [(V4SF "s") (V2DF "d")])
  83
  84 ;; Mapping of the max integer size for sse5 rotate immediate constraint
  85 (define_mode_attr sserotatemax [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
  86
  87 ;; Mapping of vector modes back to the scalar modes
  88 (define_mode_attr ssescalarmode [(V4SF "SF") (V2DF "DF")
  89                                  (V16QI "QI") (V8HI "HI")
  90                                  (V4SI "SI") (V2DI "DI")])
  91
  92 ;; Mapping of vector modes to a vector mode of double size
  93 (define_mode_attr ssedoublesizemode [(V2DF "V4DF") (V2DI "V4DI")
  94                                      (V4SF "V8SF") (V4SI "V8SI")])
  95
  96 ;; Number of scalar elements in each vector type
  97 (define_mode_attr ssescalarnum [(V4SF "4") (V2DF "2")
  98                                 (V16QI "16") (V8HI "8")
  99                                 (V4SI "4") (V2DI "2")])
 100
 101 ;; Mapping for AVX
 102 (define_mode_attr avxvecmode
 103   [(V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V4SF "V4SF")
 104    (V2DF "V2DF") (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI")
 105    (V8SF "V8SF") (V4DF "V4DF")])
 106 (define_mode_attr avxvecpsmode
 107   [(V16QI "V4SF") (V8HI "V4SF") (V4SI "V4SF") (V2DI "V4SF")
 108    (V32QI "V8SF") (V16HI "V8SF") (V8SI "V8SF") (V4DI "V8SF")])
 109 (define_mode_attr avxhalfvecmode
 110   [(V4SF "V2SF") (V32QI "V16QI")  (V16HI "V8HI") (V8SI "V4SI")
 111    (V4DI "V2DI") (V8SF "V4SF") (V4DF "V2DF")])
 112 (define_mode_attr avxscalarmode
 113   [(V16QI "QI") (V8HI "HI") (V4SI "SI") (V4SF "SF") (V2DF "DF")
 114    (V8SF "SF") (V4DF "DF")])
 115 (define_mode_attr avxcvtvecmode
 116   [(V4SF "V4SI") (V8SF "V8SI") (V4SI "V4SF") (V8SI "V8SF")])
 117 (define_mode_attr avxpermvecmode
 118   [(V2DF "V2DI") (V4SF "V4SI") (V4DF "V4DI") (V8SF "V8SI")])
 119 (define_mode_attr avxmodesuffixf2c
 120   [(V4SF "s") (V2DF "d") (V8SF "s") (V4DF "d")])
 121 (define_mode_attr avxmodesuffixp
 122  [(V2DF "pd") (V4SI "si") (V4SF "ps") (V8SF "ps") (V8SI "si")
 123   (V4DF "pd")])
 124 (define_mode_attr avxmodesuffixs
 125  [(V16QI "b") (V8HI "w") (V4SI "d")])
 126 (define_mode_attr avxmodesuffix
 127   [(V16QI "") (V32QI "256") (V4SI "") (V4SF "") (V2DF "")
 128    (V8SI "256") (V8SF "256") (V4DF "256")])
 129
 130 ;; Mapping of immediate bits for blend instructions
 131 (define_mode_attr blendbits
 132   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 133
 134 ;; Mapping of immediate bits for vpermil instructions
 135 (define_mode_attr vpermilbits
 136   [(V8SF "255") (V4SF "255") (V4DF "15") (V2DF "3")])
 137
 138 ;; Mapping of immediate bits for pinsr instructions
 139 (define_mode_attr pinsrbits [(V16QI "32768") (V8HI "128") (V4SI "8")])
 140
 141 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 142
 143 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 144 ;;
 145 ;; Move patterns
 146 ;;
 147 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 148
 149 (define_expand "mov<mode>"
 150   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 151         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 152   "TARGET_AVX"
 153 {
 154   ix86_expand_vector_move (<MODE>mode, operands);
 155   DONE;
 156 })
 157
 158 (define_insn "*avx_mov<mode>_internal"
 159   [(set (match_operand:AVXMODE 0 "nonimmediate_operand" "=x,x ,m")
 160         (match_operand:AVXMODE 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 161   "TARGET_AVX
 162    && (register_operand (operands[0], <MODE>mode)
 163        || register_operand (operands[1], <MODE>mode))"
 164 {
 165   switch (which_alternative)
 166     {
 167     case 0:
 168       return standard_sse_constant_opcode (insn, operands[1]);
 169     case 1:
 170     case 2:
 171       switch (get_attr_mode (insn))
 172         {
 173         case MODE_V8SF:
 174         case MODE_V4SF:
 175           return "vmovaps\t{%1, %0|%0, %1}";
 176         case MODE_V4DF:
 177         case MODE_V2DF:
 178           return "vmovapd\t{%1, %0|%0, %1}";
 179         default:
 180           return "vmovdqa\t{%1, %0|%0, %1}";
 181         }
 182     default:
 183       gcc_unreachable ();
 184     }
 185 }
 186   [(set_attr "type" "sselog1,ssemov,ssemov")
 187    (set_attr "prefix" "vex")
 188    (set_attr "mode" "<avxvecmode>")])
 189
 190 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 191 ;; This is essential for maintaining stable calling conventions.
 192
 193 (define_expand "mov<mode>"
 194   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "")
 195         (match_operand:SSEMODE 1 "nonimmediate_operand" ""))]
 196   "TARGET_SSE"
 197 {
 198   ix86_expand_vector_move (<MODE>mode, operands);
 199   DONE;
 200 })
 201
 202 (define_insn "*mov<mode>_internal"
 203   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "=x,x ,m")
 204         (match_operand:SSEMODE 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 205   "TARGET_SSE
 206    && (register_operand (operands[0], <MODE>mode)
 207        || register_operand (operands[1], <MODE>mode))"
 208 {
 209   switch (which_alternative)
 210     {
 211     case 0:
 212       return standard_sse_constant_opcode (insn, operands[1]);
 213     case 1:
 214     case 2:
 215       switch (get_attr_mode (insn))
 216         {
 217         case MODE_V4SF:
 218           return "movaps\t{%1, %0|%0, %1}";
 219         case MODE_V2DF:
 220           return "movapd\t{%1, %0|%0, %1}";
 221         default:
 222           return "movdqa\t{%1, %0|%0, %1}";
 223         }
 224     default:
 225       gcc_unreachable ();
 226     }
 227 }
 228   [(set_attr "type" "sselog1,ssemov,ssemov")
 229    (set (attr "mode")
 230         (cond [(ior (ior (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
 231                          (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 232                     (and (eq_attr "alternative" "2")
 233                          (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 234                              (const_int 0))))
 235                  (const_string "V4SF")
 236                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
 237                  (const_string "V4SF")
 238                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
 239                  (const_string "V2DF")
 240               ]
 241           (const_string "TI")))])
 242
 243 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 244 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 245 ;; from memory, we'd prefer to load the memory directly into the %xmm
 246 ;; register.  To facilitate this happy circumstance, this pattern won't
 247 ;; split until after register allocation.  If the 64-bit value didn't
 248 ;; come from memory, this is the best we can do.  This is much better
 249 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 250 ;; from there.
 251
 252 (define_insn_and_split "movdi_to_sse"
 253   [(parallel
 254     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 255           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 256      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 257   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 258   "#"
 259   "&& reload_completed"
 260   [(const_int 0)]
 261 {
 262  if (register_operand (operands[1], DImode))
 263    {
 264       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 265          Assemble the 64-bit DImode value in an xmm register.  */
 266       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 267                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 268       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 269                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 270       emit_insn (gen_sse2_punpckldq (operands[0], operands[0], operands[2]));
 271     }
 272  else if (memory_operand (operands[1], DImode))
 273       emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]), operands[1], const0_rtx));
 274  else
 275       gcc_unreachable ();
 276 })
 277
 278 (define_split
 279   [(set (match_operand:V4SF 0 "register_operand" "")
 280         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 281   "TARGET_SSE && reload_completed"
 282   [(set (match_dup 0)
 283         (vec_merge:V4SF
 284           (vec_duplicate:V4SF (match_dup 1))
 285           (match_dup 2)
 286           (const_int 1)))]
 287 {
 288   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 289   operands[2] = CONST0_RTX (V4SFmode);
 290 })
 291
 292 (define_split
 293   [(set (match_operand:V2DF 0 "register_operand" "")
 294         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 295   "TARGET_SSE2 && reload_completed"
 296   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 297 {
 298   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 299   operands[2] = CONST0_RTX (DFmode);
 300 })
 301
 302 (define_expand "push<mode>1"
 303   [(match_operand:AVX256MODE 0 "register_operand" "")]
 304   "TARGET_AVX"
 305 {
 306   ix86_expand_push (<MODE>mode, operands[0]);
 307   DONE;
 308 })
 309
 310 (define_expand "push<mode>1"
 311   [(match_operand:SSEMODE 0 "register_operand" "")]
 312   "TARGET_SSE"
 313 {
 314   ix86_expand_push (<MODE>mode, operands[0]);
 315   DONE;
 316 })
 317
 318 (define_expand "movmisalign<mode>"
 319   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 320         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 321   "TARGET_AVX"
 322 {
 323   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 324   DONE;
 325 })
 326
 327 (define_expand "movmisalign<mode>"
 328   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "")
 329         (match_operand:SSEMODE 1 "nonimmediate_operand" ""))]
 330   "TARGET_SSE"
 331 {
 332   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 333   DONE;
 334 })
 335
 336 (define_insn "avx_movup<avxmodesuffixf2c><avxmodesuffix>"
 337   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "=x,m")
 338         (unspec:AVXMODEF2P
 339           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm,x")]
 340           UNSPEC_MOVU))]
 341   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 342    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 343   "vmovup<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 344   [(set_attr "type" "ssemov")
 345    (set_attr "prefix" "vex")
 346    (set_attr "mode" "<MODE>")])
 347
 348 (define_insn "sse2_movq128"
 349   [(set (match_operand:V2DI 0 "register_operand" "=x")
 350         (vec_concat:V2DI
 351           (vec_select:DI
 352             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 353             (parallel [(const_int 0)]))
 354           (const_int 0)))]
 355   "TARGET_SSE2"
 356   "%vmovq\t{%1, %0|%0, %1}"
 357   [(set_attr "type" "ssemov")
 358    (set_attr "prefix" "maybe_vex")
 359    (set_attr "mode" "TI")])
 360
 361 (define_insn "<sse>_movup<ssemodesuffixf2c>"
 362   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m")
 363         (unspec:SSEMODEF2P
 364           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm,x")]
 365           UNSPEC_MOVU))]
 366   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 367    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 368   "movup<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 369   [(set_attr "type" "ssemov")
 370    (set_attr "mode" "<MODE>")])
 371
 372 (define_insn "avx_movdqu<avxmodesuffix>"
 373   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "=x,m")
 374         (unspec:AVXMODEQI
 375           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "xm,x")]
 376           UNSPEC_MOVU))]
 377   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 378   "vmovdqu\t{%1, %0|%0, %1}"
 379   [(set_attr "type" "ssemov")
 380    (set_attr "prefix" "vex")
 381    (set_attr "mode" "<avxvecmode>")])
 382
 383 (define_insn "sse2_movdqu"
 384   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 385         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 386                       UNSPEC_MOVU))]
 387   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 388   "movdqu\t{%1, %0|%0, %1}"
 389   [(set_attr "type" "ssemov")
 390    (set_attr "prefix_data16" "1")
 391    (set_attr "mode" "TI")])
 392
 393 (define_insn "avx_movnt<mode>"
 394   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
 395         (unspec:AVXMODEF2P
 396           [(match_operand:AVXMODEF2P 1 "register_operand" "x")]
 397           UNSPEC_MOVNT))]
 398   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 399   "vmovntp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 400   [(set_attr "type" "ssemov")
 401    (set_attr "prefix" "vex")
 402    (set_attr "mode" "<MODE>")])
 403
 404 (define_insn "<sse>_movnt<mode>"
 405   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "=m")
 406         (unspec:SSEMODEF2P
 407           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
 408           UNSPEC_MOVNT))]
 409   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 410   "movntp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 411   [(set_attr "type" "ssemov")
 412    (set_attr "mode" "<MODE>")])
 413
 414 (define_insn "avx_movnt<mode>"
 415   [(set (match_operand:AVXMODEDI 0 "memory_operand" "=m")
 416         (unspec:AVXMODEDI
 417           [(match_operand:AVXMODEDI 1 "register_operand" "x")]
 418           UNSPEC_MOVNT))]
 419   "TARGET_AVX"
 420   "vmovntdq\t{%1, %0|%0, %1}"
 421   [(set_attr "type" "ssecvt")
 422    (set_attr "prefix" "vex")
 423    (set_attr "mode" "<avxvecmode>")])
 424
 425 (define_insn "sse2_movntv2di"
 426   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 427         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 428                      UNSPEC_MOVNT))]
 429   "TARGET_SSE2"
 430   "movntdq\t{%1, %0|%0, %1}"
 431   [(set_attr "type" "ssecvt")
 432    (set_attr "prefix_data16" "1")
 433    (set_attr "mode" "TI")])
 434
 435 (define_insn "sse2_movntsi"
 436   [(set (match_operand:SI 0 "memory_operand" "=m")
 437         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 438                    UNSPEC_MOVNT))]
 439   "TARGET_SSE2"
 440   "movnti\t{%1, %0|%0, %1}"
 441   [(set_attr "type" "ssecvt")
 442    (set_attr "mode" "V2DF")])
 443
 444 (define_insn "avx_lddqu<avxmodesuffix>"
 445   [(set (match_operand:AVXMODEQI 0 "register_operand" "=x")
 446         (unspec:AVXMODEQI
 447           [(match_operand:AVXMODEQI 1 "memory_operand" "m")]
 448           UNSPEC_LDDQU))]
 449   "TARGET_AVX"
 450   "vlddqu\t{%1, %0|%0, %1}"
 451   [(set_attr "type" "ssecvt")
 452    (set_attr "prefix" "vex")
 453    (set_attr "mode" "<avxvecmode>")])
 454
 455 (define_insn "sse3_lddqu"
 456   [(set (match_operand:V16QI 0 "register_operand" "=x")
 457         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 458                       UNSPEC_LDDQU))]
 459   "TARGET_SSE3"
 460   "lddqu\t{%1, %0|%0, %1}"
 461   [(set_attr "type" "ssecvt")
 462    (set_attr "prefix_rep" "1")
 463    (set_attr "mode" "TI")])
 464
 465 ; Expand patterns for non-temporal stores.  At the moment, only those
 466 ; that directly map to insns are defined; it would be possible to
 467 ; define patterns for other modes that would expand to several insns.
 468
 469 (define_expand "storent<mode>"
 470   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "")
 471         (unspec:SSEMODEF2P
 472           [(match_operand:SSEMODEF2P 1 "register_operand" "")]
 473           UNSPEC_MOVNT))]
 474   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 475   "")
 476
 477 (define_expand "storent<mode>"
 478   [(set (match_operand:MODEF 0 "memory_operand" "")
 479         (unspec:MODEF
 480           [(match_operand:MODEF 1 "register_operand" "")]
 481           UNSPEC_MOVNT))]
 482   "TARGET_SSE4A"
 483   "")
 484
 485 (define_expand "storentv2di"
 486   [(set (match_operand:V2DI 0 "memory_operand" "")
 487         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "")]
 488                      UNSPEC_MOVNT))]
 489   "TARGET_SSE2"
 490   "")
 491
 492 (define_expand "storentsi"
 493   [(set (match_operand:SI 0 "memory_operand" "")
 494         (unspec:SI [(match_operand:SI 1 "register_operand" "")]
 495                    UNSPEC_MOVNT))]
 496   "TARGET_SSE2"
 497   "")
 498
 499 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 500 ;;
 501 ;; Parallel floating point arithmetic
 502 ;;
 503 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 504
 505 (define_expand "<code><mode>2"
 506   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 507         (absneg:SSEMODEF2P
 508           (match_operand:SSEMODEF2P 1 "register_operand" "")))]
 509   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 510   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 511
 512 (define_expand "<plusminus_insn><mode>3"
 513   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 514         (plusminus:AVX256MODEF2P
 515           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 516           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 517   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 518   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 519
 520 (define_insn "*avx_<plusminus_insn><mode>3"
 521   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 522         (plusminus:AVXMODEF2P
 523           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "<comm>x")
 524           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 525   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 526    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 527   "v<plusminus_mnemonic>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 528   [(set_attr "type" "sseadd")
 529    (set_attr "prefix" "vex")
 530    (set_attr "mode" "<avxvecmode>")])
 531
 532 (define_expand "<plusminus_insn><mode>3"
 533   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 534         (plusminus:SSEMODEF2P
 535           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 536           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 537   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 538   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 539
 540 (define_insn "*<plusminus_insn><mode>3"
 541   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 542         (plusminus:SSEMODEF2P
 543           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "<comm>0")
 544           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 545   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 546    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 547   "<plusminus_mnemonic>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 548   [(set_attr "type" "sseadd")
 549    (set_attr "mode" "<MODE>")])
 550
 551 (define_insn "*avx_vm<plusminus_insn><mode>3"
 552   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 553         (vec_merge:SSEMODEF2P
 554           (plusminus:SSEMODEF2P
 555             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 556             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 557           (match_dup 1)
 558           (const_int 1)))]
 559   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 560   "v<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 561   [(set_attr "type" "sseadd")
 562    (set_attr "prefix" "vex")
 563    (set_attr "mode" "<ssescalarmode>")])
 564
 565 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 566   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 567         (vec_merge:SSEMODEF2P
 568           (plusminus:SSEMODEF2P
 569             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 570             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 571           (match_dup 1)
 572           (const_int 1)))]
 573   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 574   "<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 575   [(set_attr "type" "sseadd")
 576    (set_attr "mode" "<ssescalarmode>")])
 577
 578 (define_expand "mul<mode>3"
 579   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 580         (mult:AVX256MODEF2P
 581           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 582           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 583   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 584   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 585
 586 (define_insn "*avx_mul<mode>3"
 587   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 588         (mult:AVXMODEF2P
 589           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 590           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 591   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 592    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 593   "vmulp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 594   [(set_attr "type" "ssemul")
 595    (set_attr "prefix" "vex")
 596    (set_attr "mode" "<avxvecmode>")])
 597
 598 (define_expand "mul<mode>3"
 599   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 600         (mult:SSEMODEF2P
 601           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 602           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 603   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 604   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 605
 606 (define_insn "*mul<mode>3"
 607   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 608         (mult:SSEMODEF2P
 609           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 610           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 611   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 612    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 613   "mulp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 614   [(set_attr "type" "ssemul")
 615    (set_attr "mode" "<MODE>")])
 616
 617 (define_insn "*avx_vmmul<mode>3"
 618   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 619         (vec_merge:SSEMODEF2P
 620           (mult:SSEMODEF2P
 621             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 622             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 623           (match_dup 1)
 624           (const_int 1)))]
 625   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 626   "vmuls<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 627   [(set_attr "type" "ssemul")
 628    (set_attr "prefix" "vex")
 629    (set_attr "mode" "<ssescalarmode>")])
 630
 631 (define_insn "<sse>_vmmul<mode>3"
 632   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 633         (vec_merge:SSEMODEF2P
 634           (mult:SSEMODEF2P
 635             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 636             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 637           (match_dup 1)
 638           (const_int 1)))]
 639   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 640   "muls<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 641   [(set_attr "type" "ssemul")
 642    (set_attr "mode" "<ssescalarmode>")])
 643
 644 (define_expand "divv8sf3"
 645   [(set (match_operand:V8SF 0 "register_operand" "")
 646         (div:V8SF (match_operand:V8SF 1 "register_operand" "")
 647                   (match_operand:V8SF 2 "nonimmediate_operand" "")))]
 648   "TARGET_AVX"
 649 {
 650   ix86_fixup_binary_operands_no_copy (DIV, V8SFmode, operands);
 651
 652   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size
 653       && flag_finite_math_only && !flag_trapping_math
 654       && flag_unsafe_math_optimizations)
 655     {
 656       ix86_emit_swdivsf (operands[0], operands[1],
 657                          operands[2], V8SFmode);
 658       DONE;
 659     }
 660 })
 661
 662 (define_expand "divv4df3"
 663   [(set (match_operand:V4DF 0 "register_operand" "")
 664         (div:V4DF (match_operand:V4DF 1 "register_operand" "")
 665                   (match_operand:V4DF 2 "nonimmediate_operand" "")))]
 666   "TARGET_AVX"
 667   "ix86_fixup_binary_operands_no_copy (DIV, V4DFmode, operands);")
 668
 669 (define_insn "avx_div<mode>3"
 670   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 671         (div:AVXMODEF2P
 672           (match_operand:AVXMODEF2P 1 "register_operand" "x")
 673           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 674   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 675   "vdivp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 676   [(set_attr "type" "ssediv")
 677    (set_attr "prefix" "vex")
 678    (set_attr "mode" "<MODE>")])
 679
 680 (define_expand "divv4sf3"
 681   [(set (match_operand:V4SF 0 "register_operand" "")
 682         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 683                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 684   "TARGET_SSE"
 685 {
 686   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 687       && flag_finite_math_only && !flag_trapping_math
 688       && flag_unsafe_math_optimizations)
 689     {
 690       ix86_emit_swdivsf (operands[0], operands[1],
 691                          operands[2], V4SFmode);
 692       DONE;
 693     }
 694 })
 695
 696 (define_expand "divv2df3"
 697   [(set (match_operand:V2DF 0 "register_operand" "")
 698         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
 699                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
 700   "TARGET_SSE2"
 701   "")
 702
 703 (define_insn "*avx_div<mode>3"
 704   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 705         (div:SSEMODEF2P
 706           (match_operand:SSEMODEF2P 1 "register_operand" "x")
 707           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 708   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 709   "vdivp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 710   [(set_attr "type" "ssediv")
 711    (set_attr "prefix" "vex")
 712    (set_attr "mode" "<MODE>")])
 713
 714 (define_insn "<sse>_div<mode>3"
 715   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 716         (div:SSEMODEF2P
 717           (match_operand:SSEMODEF2P 1 "register_operand" "0")
 718           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 719   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 720   "divp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 721   [(set_attr "type" "ssediv")
 722    (set_attr "mode" "<MODE>")])
 723
 724 (define_insn "*avx_vmdiv<mode>3"
 725   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 726         (vec_merge:SSEMODEF2P
 727           (div:SSEMODEF2P
 728             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 729             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 730           (match_dup 1)
 731           (const_int 1)))]
 732   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 733   "vdivs<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 734   [(set_attr "type" "ssediv")
 735    (set_attr "prefix" "vex")
 736    (set_attr "mode" "<ssescalarmode>")])
 737
 738 (define_insn "<sse>_vmdiv<mode>3"
 739   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 740         (vec_merge:SSEMODEF2P
 741           (div:SSEMODEF2P
 742             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 743             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 744           (match_dup 1)
 745           (const_int 1)))]
 746   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 747   "divs<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 748   [(set_attr "type" "ssediv")
 749    (set_attr "mode" "<ssescalarmode>")])
 750
 751 (define_insn "avx_rcpv8sf2"
 752   [(set (match_operand:V8SF 0 "register_operand" "=x")
 753         (unspec:V8SF
 754           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 755   "TARGET_AVX"
 756   "vrcpps\t{%1, %0|%0, %1}"
 757   [(set_attr "type" "sse")
 758    (set_attr "prefix" "vex")
 759    (set_attr "mode" "V8SF")])
 760
 761 (define_insn "sse_rcpv4sf2"
 762   [(set (match_operand:V4SF 0 "register_operand" "=x")
 763         (unspec:V4SF
 764           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 765   "TARGET_SSE"
 766   "%vrcpps\t{%1, %0|%0, %1}"
 767   [(set_attr "type" "sse")
 768    (set_attr "prefix" "maybe_vex")
 769    (set_attr "mode" "V4SF")])
 770
 771 (define_insn "*avx_vmrcpv4sf2"
 772   [(set (match_operand:V4SF 0 "register_operand" "=x")
 773         (vec_merge:V4SF
 774           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 775                        UNSPEC_RCP)
 776           (match_operand:V4SF 2 "register_operand" "x")
 777           (const_int 1)))]
 778   "TARGET_AVX"
 779   "vrcpss\t{%1, %2, %0|%0, %2, %1}"
 780   [(set_attr "type" "sse")
 781    (set_attr "prefix" "vex")
 782    (set_attr "mode" "SF")])
 783
 784 (define_insn "sse_vmrcpv4sf2"
 785   [(set (match_operand:V4SF 0 "register_operand" "=x")
 786         (vec_merge:V4SF
 787           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 788                        UNSPEC_RCP)
 789           (match_operand:V4SF 2 "register_operand" "0")
 790           (const_int 1)))]
 791   "TARGET_SSE"
 792   "rcpss\t{%1, %0|%0, %1}"
 793   [(set_attr "type" "sse")
 794    (set_attr "mode" "SF")])
 795
 796 (define_expand "sqrtv8sf2"
 797   [(set (match_operand:V8SF 0 "register_operand" "")
 798         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "")))]
 799   "TARGET_AVX"
 800 {
 801   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size
 802       && flag_finite_math_only && !flag_trapping_math
 803       && flag_unsafe_math_optimizations)
 804     {
 805       ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 0);
 806       DONE;
 807     }
 808 })
 809
 810 (define_insn "avx_sqrtv8sf2"
 811   [(set (match_operand:V8SF 0 "register_operand" "=x")
 812         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
 813   "TARGET_AVX"
 814   "vsqrtps\t{%1, %0|%0, %1}"
 815   [(set_attr "type" "sse")
 816    (set_attr "prefix" "vex")
 817    (set_attr "mode" "V8SF")])
 818
 819 (define_expand "sqrtv4sf2"
 820   [(set (match_operand:V4SF 0 "register_operand" "")
 821         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 822   "TARGET_SSE"
 823 {
 824   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 825       && flag_finite_math_only && !flag_trapping_math
 826       && flag_unsafe_math_optimizations)
 827     {
 828       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 829       DONE;
 830     }
 831 })
 832
 833 (define_insn "sse_sqrtv4sf2"
 834   [(set (match_operand:V4SF 0 "register_operand" "=x")
 835         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 836   "TARGET_SSE"
 837   "%vsqrtps\t{%1, %0|%0, %1}"
 838   [(set_attr "type" "sse")
 839    (set_attr "prefix" "maybe_vex")
 840    (set_attr "mode" "V4SF")])
 841
 842 (define_insn "sqrtv4df2"
 843   [(set (match_operand:V4DF 0 "register_operand" "=x")
 844         (sqrt:V4DF (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
 845   "TARGET_AVX"
 846   "vsqrtpd\t{%1, %0|%0, %1}"
 847   [(set_attr "type" "sse")
 848    (set_attr "prefix" "vex")
 849    (set_attr "mode" "V4DF")])
 850
 851 (define_insn "sqrtv2df2"
 852   [(set (match_operand:V2DF 0 "register_operand" "=x")
 853         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
 854   "TARGET_SSE2"
 855   "%vsqrtpd\t{%1, %0|%0, %1}"
 856   [(set_attr "type" "sse")
 857    (set_attr "prefix" "maybe_vex")
 858    (set_attr "mode" "V2DF")])
 859
 860 (define_insn "*avx_vmsqrt<mode>2"
 861   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 862         (vec_merge:SSEMODEF2P
 863           (sqrt:SSEMODEF2P
 864             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 865           (match_operand:SSEMODEF2P 2 "register_operand" "x")
 866           (const_int 1)))]
 867   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 868   "vsqrts<ssemodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
 869   [(set_attr "type" "sse")
 870    (set_attr "prefix" "vex")
 871    (set_attr "mode" "<ssescalarmode>")])
 872
 873 (define_insn "<sse>_vmsqrt<mode>2"
 874   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 875         (vec_merge:SSEMODEF2P
 876           (sqrt:SSEMODEF2P
 877             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 878           (match_operand:SSEMODEF2P 2 "register_operand" "0")
 879           (const_int 1)))]
 880   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 881   "sqrts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 882   [(set_attr "type" "sse")
 883    (set_attr "mode" "<ssescalarmode>")])
 884
 885 (define_expand "rsqrtv8sf2"
 886   [(set (match_operand:V8SF 0 "register_operand" "")
 887         (unspec:V8SF
 888           [(match_operand:V8SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 889   "TARGET_AVX && TARGET_SSE_MATH"
 890 {
 891   ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 1);
 892   DONE;
 893 })
 894
 895 (define_insn "avx_rsqrtv8sf2"
 896   [(set (match_operand:V8SF 0 "register_operand" "=x")
 897         (unspec:V8SF
 898           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 899   "TARGET_AVX"
 900   "vrsqrtps\t{%1, %0|%0, %1}"
 901   [(set_attr "type" "sse")
 902    (set_attr "prefix" "vex")
 903    (set_attr "mode" "V8SF")])
 904
 905 (define_expand "rsqrtv4sf2"
 906   [(set (match_operand:V4SF 0 "register_operand" "")
 907         (unspec:V4SF
 908           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 909   "TARGET_SSE_MATH"
 910 {
 911   ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 912   DONE;
 913 })
 914
 915 (define_insn "sse_rsqrtv4sf2"
 916   [(set (match_operand:V4SF 0 "register_operand" "=x")
 917         (unspec:V4SF
 918           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 919   "TARGET_SSE"
 920   "%vrsqrtps\t{%1, %0|%0, %1}"
 921   [(set_attr "type" "sse")
 922    (set_attr "prefix" "maybe_vex")
 923    (set_attr "mode" "V4SF")])
 924
 925 (define_insn "*avx_vmrsqrtv4sf2"
 926   [(set (match_operand:V4SF 0 "register_operand" "=x")
 927         (vec_merge:V4SF
 928           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 929                        UNSPEC_RSQRT)
 930           (match_operand:V4SF 2 "register_operand" "x")
 931           (const_int 1)))]
 932   "TARGET_AVX"
 933   "vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
 934   [(set_attr "type" "sse")
 935    (set_attr "prefix" "vex")
 936    (set_attr "mode" "SF")])
 937
 938 (define_insn "sse_vmrsqrtv4sf2"
 939   [(set (match_operand:V4SF 0 "register_operand" "=x")
 940         (vec_merge:V4SF
 941           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 942                        UNSPEC_RSQRT)
 943           (match_operand:V4SF 2 "register_operand" "0")
 944           (const_int 1)))]
 945   "TARGET_SSE"
 946   "rsqrtss\t{%1, %0|%0, %1}"
 947   [(set_attr "type" "sse")
 948    (set_attr "mode" "SF")])
 949
 950 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
 951 ;; isn't really correct, as those rtl operators aren't defined when
 952 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
 953
 954 (define_expand "<code><mode>3"
 955   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 956         (smaxmin:AVX256MODEF2P
 957           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 958           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 959   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 960 {
 961   if (!flag_finite_math_only)
 962     operands[1] = force_reg (<MODE>mode, operands[1]);
 963   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
 964 })
 965
 966 (define_expand "<code><mode>3"
 967   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 968         (smaxmin:SSEMODEF2P
 969           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 970           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 971   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 972 {
 973   if (!flag_finite_math_only)
 974     operands[1] = force_reg (<MODE>mode, operands[1]);
 975   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
 976 })
 977
 978 (define_insn "*avx_<code><mode>3_finite"
 979   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 980         (smaxmin:AVXMODEF2P
 981           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 982           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 983   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
 984    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 985   "v<maxminfprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 986   [(set_attr "type" "sseadd")
 987    (set_attr "prefix" "vex")
 988    (set_attr "mode" "<MODE>")])
 989
 990 (define_insn "*<code><mode>3_finite"
 991   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 992         (smaxmin:SSEMODEF2P
 993           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 994           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 995   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
 996    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 997   "<maxminfprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 998   [(set_attr "type" "sseadd")
 999    (set_attr "mode" "<MODE>")])
1000
1001 (define_insn "*avx_<code><mode>3"
1002   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1003         (smaxmin:AVXMODEF2P
1004           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1005           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1006   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1007   "v<maxminfprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1008   [(set_attr "type" "sseadd")
1009    (set_attr "prefix" "vex")
1010    (set_attr "mode" "<avxvecmode>")])
1011
1012 (define_insn "*<code><mode>3"
1013   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1014         (smaxmin:SSEMODEF2P
1015           (match_operand:SSEMODEF2P 1 "register_operand" "0")
1016           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1017   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1018   "<maxminfprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1019   [(set_attr "type" "sseadd")
1020    (set_attr "mode" "<MODE>")])
1021
1022 (define_insn "*avx_vm<code><mode>3"
1023   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1024         (vec_merge:SSEMODEF2P
1025           (smaxmin:SSEMODEF2P
1026             (match_operand:SSEMODEF2P 1 "register_operand" "x")
1027             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1028          (match_dup 1)
1029          (const_int 1)))]
1030   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
1031   "v<maxminfprefix>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1032   [(set_attr "type" "sse")
1033    (set_attr "prefix" "vex")
1034    (set_attr "mode" "<ssescalarmode>")])
1035
1036 (define_insn "<sse>_vm<code><mode>3"
1037   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1038         (vec_merge:SSEMODEF2P
1039           (smaxmin:SSEMODEF2P
1040             (match_operand:SSEMODEF2P 1 "register_operand" "0")
1041             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1042          (match_dup 1)
1043          (const_int 1)))]
1044   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1045   "<maxminfprefix>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1046   [(set_attr "type" "sse")
1047    (set_attr "mode" "<ssescalarmode>")])
1048
1049 ;; These versions of the min/max patterns implement exactly the operations
1050 ;;   min = (op1 < op2 ? op1 : op2)
1051 ;;   max = (!(op1 < op2) ? op1 : op2)
1052 ;; Their operands are not commutative, and thus they may be used in the
1053 ;; presence of -0.0 and NaN.
1054
1055 (define_insn "*avx_ieee_smin<mode>3"
1056   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1057         (unspec:AVXMODEF2P
1058           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1059            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1060          UNSPEC_IEEE_MIN))]
1061   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1062   "vminp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1063   [(set_attr "type" "sseadd")
1064    (set_attr "prefix" "vex")
1065    (set_attr "mode" "<avxvecmode>")])
1066
1067 (define_insn "*avx_ieee_smax<mode>3"
1068   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1069         (unspec:AVXMODEF2P
1070           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1071            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1072          UNSPEC_IEEE_MAX))]
1073   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1074   "vmaxp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1075   [(set_attr "type" "sseadd")
1076    (set_attr "prefix" "vex")
1077    (set_attr "mode" "<avxvecmode>")])
1078
1079 (define_insn "*ieee_smin<mode>3"
1080   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1081         (unspec:SSEMODEF2P
1082           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1083            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1084          UNSPEC_IEEE_MIN))]
1085   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1086   "minp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1087   [(set_attr "type" "sseadd")
1088    (set_attr "mode" "<MODE>")])
1089
1090 (define_insn "*ieee_smax<mode>3"
1091   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1092         (unspec:SSEMODEF2P
1093           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1094            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1095          UNSPEC_IEEE_MAX))]
1096   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1097   "maxp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1098   [(set_attr "type" "sseadd")
1099    (set_attr "mode" "<MODE>")])
1100
1101 (define_insn "avx_addsubv8sf3"
1102   [(set (match_operand:V8SF 0 "register_operand" "=x")
1103         (vec_merge:V8SF
1104           (plus:V8SF
1105             (match_operand:V8SF 1 "register_operand" "x")
1106             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1107           (minus:V8SF (match_dup 1) (match_dup 2))
1108           (const_int 170)))]
1109   "TARGET_AVX"
1110   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1111   [(set_attr "type" "sseadd")
1112    (set_attr "prefix" "vex")
1113    (set_attr "mode" "V8SF")])
1114
1115 (define_insn "avx_addsubv4df3"
1116   [(set (match_operand:V4DF 0 "register_operand" "=x")
1117         (vec_merge:V4DF
1118           (plus:V4DF
1119             (match_operand:V4DF 1 "register_operand" "x")
1120             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1121           (minus:V4DF (match_dup 1) (match_dup 2))
1122           (const_int 10)))]
1123   "TARGET_AVX"
1124   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1125   [(set_attr "type" "sseadd")
1126    (set_attr "prefix" "vex")
1127    (set_attr "mode" "V4DF")])
1128
1129 (define_insn "*avx_addsubv4sf3"
1130   [(set (match_operand:V4SF 0 "register_operand" "=x")
1131         (vec_merge:V4SF
1132           (plus:V4SF
1133             (match_operand:V4SF 1 "register_operand" "x")
1134             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1135           (minus:V4SF (match_dup 1) (match_dup 2))
1136           (const_int 10)))]
1137   "TARGET_AVX"
1138   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1139   [(set_attr "type" "sseadd")
1140    (set_attr "prefix" "vex")
1141    (set_attr "mode" "V4SF")])
1142
1143 (define_insn "sse3_addsubv4sf3"
1144   [(set (match_operand:V4SF 0 "register_operand" "=x")
1145         (vec_merge:V4SF
1146           (plus:V4SF
1147             (match_operand:V4SF 1 "register_operand" "0")
1148             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1149           (minus:V4SF (match_dup 1) (match_dup 2))
1150           (const_int 10)))]
1151   "TARGET_SSE3"
1152   "addsubps\t{%2, %0|%0, %2}"
1153   [(set_attr "type" "sseadd")
1154    (set_attr "prefix_rep" "1")
1155    (set_attr "mode" "V4SF")])
1156
1157 (define_insn "*avx_addsubv2df3"
1158   [(set (match_operand:V2DF 0 "register_operand" "=x")
1159         (vec_merge:V2DF
1160           (plus:V2DF
1161             (match_operand:V2DF 1 "register_operand" "x")
1162             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1163           (minus:V2DF (match_dup 1) (match_dup 2))
1164           (const_int 2)))]
1165   "TARGET_AVX"
1166   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1167   [(set_attr "type" "sseadd")
1168    (set_attr "prefix" "vex")
1169    (set_attr "mode" "V2DF")])
1170
1171 (define_insn "sse3_addsubv2df3"
1172   [(set (match_operand:V2DF 0 "register_operand" "=x")
1173         (vec_merge:V2DF
1174           (plus:V2DF
1175             (match_operand:V2DF 1 "register_operand" "0")
1176             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1177           (minus:V2DF (match_dup 1) (match_dup 2))
1178           (const_int 2)))]
1179   "TARGET_SSE3"
1180   "addsubpd\t{%2, %0|%0, %2}"
1181   [(set_attr "type" "sseadd")
1182    (set_attr "mode" "V2DF")])
1183
1184 (define_insn "avx_h<plusminus_insn>v4df3"
1185   [(set (match_operand:V4DF 0 "register_operand" "=x")
1186         (vec_concat:V4DF
1187           (vec_concat:V2DF
1188             (plusminus:DF
1189               (vec_select:DF
1190                 (match_operand:V4DF 1 "register_operand" "x")
1191                 (parallel [(const_int 0)]))
1192               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1193             (plusminus:DF
1194               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1195               (vec_select:DF (match_dup 1) (parallel [(const_int 3)]))))
1196           (vec_concat:V2DF
1197             (plusminus:DF
1198               (vec_select:DF
1199                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1200                 (parallel [(const_int 0)]))
1201               (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))
1202             (plusminus:DF
1203               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1204               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1205   "TARGET_AVX"
1206   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1207   [(set_attr "type" "sseadd")
1208    (set_attr "prefix" "vex")
1209    (set_attr "mode" "V4DF")])
1210
1211 (define_insn "avx_h<plusminus_insn>v8sf3"
1212   [(set (match_operand:V8SF 0 "register_operand" "=x")
1213         (vec_concat:V8SF
1214           (vec_concat:V4SF
1215             (vec_concat:V2SF
1216               (plusminus:SF
1217                 (vec_select:SF
1218                   (match_operand:V8SF 1 "register_operand" "x")
1219                   (parallel [(const_int 0)]))
1220                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1221               (plusminus:SF
1222                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1223                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1224             (vec_concat:V2SF
1225               (plusminus:SF
1226                 (vec_select:SF
1227                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1228                   (parallel [(const_int 0)]))
1229                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1230               (plusminus:SF
1231                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1232                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1233           (vec_concat:V4SF
1234             (vec_concat:V2SF
1235               (plusminus:SF
1236                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1237                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1238               (plusminus:SF
1239                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1240                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1241             (vec_concat:V2SF
1242               (plusminus:SF
1243                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1244                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1245               (plusminus:SF
1246                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1247                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1248   "TARGET_AVX"
1249   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1250   [(set_attr "type" "sseadd")
1251    (set_attr "prefix" "vex")
1252    (set_attr "mode" "V8SF")])
1253
1254 (define_insn "*avx_h<plusminus_insn>v4sf3"
1255   [(set (match_operand:V4SF 0 "register_operand" "=x")
1256         (vec_concat:V4SF
1257           (vec_concat:V2SF
1258             (plusminus:SF
1259               (vec_select:SF
1260                 (match_operand:V4SF 1 "register_operand" "x")
1261                 (parallel [(const_int 0)]))
1262               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1263             (plusminus:SF
1264               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1265               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1266           (vec_concat:V2SF
1267             (plusminus:SF
1268               (vec_select:SF
1269                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1270                 (parallel [(const_int 0)]))
1271               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1272             (plusminus:SF
1273               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1274               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1275   "TARGET_AVX"
1276   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1277   [(set_attr "type" "sseadd")
1278    (set_attr "prefix" "vex")
1279    (set_attr "mode" "V4SF")])
1280
1281 (define_insn "sse3_h<plusminus_insn>v4sf3"
1282   [(set (match_operand:V4SF 0 "register_operand" "=x")
1283         (vec_concat:V4SF
1284           (vec_concat:V2SF
1285             (plusminus:SF
1286               (vec_select:SF
1287                 (match_operand:V4SF 1 "register_operand" "0")
1288                 (parallel [(const_int 0)]))
1289               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1290             (plusminus:SF
1291               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1292               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1293           (vec_concat:V2SF
1294             (plusminus:SF
1295               (vec_select:SF
1296                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1297                 (parallel [(const_int 0)]))
1298               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1299             (plusminus:SF
1300               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1301               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1302   "TARGET_SSE3"
1303   "h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}"
1304   [(set_attr "type" "sseadd")
1305    (set_attr "prefix_rep" "1")
1306    (set_attr "mode" "V4SF")])
1307
1308 (define_insn "*avx_h<plusminus_insn>v2df3"
1309   [(set (match_operand:V2DF 0 "register_operand" "=x")
1310         (vec_concat:V2DF
1311           (plusminus:DF
1312             (vec_select:DF
1313               (match_operand:V2DF 1 "register_operand" "x")
1314               (parallel [(const_int 0)]))
1315             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1316           (plusminus:DF
1317             (vec_select:DF
1318               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1319               (parallel [(const_int 0)]))
1320             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1321   "TARGET_AVX"
1322   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1323   [(set_attr "type" "sseadd")
1324    (set_attr "prefix" "vex")
1325    (set_attr "mode" "V2DF")])
1326
1327 (define_insn "sse3_h<plusminus_insn>v2df3"
1328   [(set (match_operand:V2DF 0 "register_operand" "=x")
1329         (vec_concat:V2DF
1330           (plusminus:DF
1331             (vec_select:DF
1332               (match_operand:V2DF 1 "register_operand" "0")
1333               (parallel [(const_int 0)]))
1334             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1335           (plusminus:DF
1336             (vec_select:DF
1337               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1338               (parallel [(const_int 0)]))
1339             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1340   "TARGET_SSE3"
1341   "h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}"
1342   [(set_attr "type" "sseadd")
1343    (set_attr "mode" "V2DF")])
1344
1345 (define_expand "reduc_splus_v4sf"
1346   [(match_operand:V4SF 0 "register_operand" "")
1347    (match_operand:V4SF 1 "register_operand" "")]
1348   "TARGET_SSE"
1349 {
1350   if (TARGET_SSE3)
1351     {
1352       rtx tmp = gen_reg_rtx (V4SFmode);
1353       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1354       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1355     }
1356   else
1357     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
1358   DONE;
1359 })
1360
1361 (define_expand "reduc_splus_v2df"
1362   [(match_operand:V2DF 0 "register_operand" "")
1363    (match_operand:V2DF 1 "register_operand" "")]
1364   "TARGET_SSE3"
1365 {
1366   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1367   DONE;
1368 })
1369
1370 (define_expand "reduc_smax_v4sf"
1371   [(match_operand:V4SF 0 "register_operand" "")
1372    (match_operand:V4SF 1 "register_operand" "")]
1373   "TARGET_SSE"
1374 {
1375   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
1376   DONE;
1377 })
1378
1379 (define_expand "reduc_smin_v4sf"
1380   [(match_operand:V4SF 0 "register_operand" "")
1381    (match_operand:V4SF 1 "register_operand" "")]
1382   "TARGET_SSE"
1383 {
1384   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
1385   DONE;
1386 })
1387
1388 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1389 ;;
1390 ;; Parallel floating point comparisons
1391 ;;
1392 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1393
1394 (define_insn "avx_cmpp<avxmodesuffixf2c><mode>3"
1395   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1396         (unspec:AVXMODEF2P
1397           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1398            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
1399            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1400           UNSPEC_PCMP))]
1401   "TARGET_AVX"
1402   "vcmpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1403   [(set_attr "type" "ssecmp")
1404    (set_attr "prefix" "vex")
1405    (set_attr "mode" "<MODE>")])
1406
1407 (define_insn "avx_cmps<ssemodesuffixf2c><mode>3"
1408   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1409         (vec_merge:SSEMODEF2P
1410           (unspec:SSEMODEF2P
1411             [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1412              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
1413              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1414             UNSPEC_PCMP)
1415          (match_dup 1)
1416          (const_int 1)))]
1417   "TARGET_AVX"
1418   "vcmps<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1419   [(set_attr "type" "ssecmp")
1420    (set_attr "prefix" "vex")
1421    (set_attr "mode" "<ssescalarmode>")])
1422
1423 ;; We don't promote 128bit vector compare intrinsics. But vectorizer
1424 ;; may generate 256bit vector compare instructions.
1425 (define_insn "*avx_maskcmp<mode>3"
1426   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1427         (match_operator:AVXMODEF2P 3 "avx_comparison_float_operator"
1428                 [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1429                  (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]))]
1430   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1431   "vcmp%D3p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1432   [(set_attr "type" "ssecmp")
1433    (set_attr "prefix" "vex")
1434    (set_attr "mode" "<avxvecmode>")])
1435
1436 (define_insn "<sse>_maskcmp<mode>3"
1437   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x")
1438         (match_operator:SSEMODEF4 3 "sse_comparison_operator"
1439                 [(match_operand:SSEMODEF4 1 "register_operand" "0")
1440                  (match_operand:SSEMODEF4 2 "nonimmediate_operand" "xm")]))]
1441   "(SSE_FLOAT_MODE_P (<MODE>mode) || SSE_VEC_FLOAT_MODE_P (<MODE>mode))
1442    && !TARGET_SSE5"
1443   "cmp%D3<ssemodesuffixf4>\t{%2, %0|%0, %2}"
1444   [(set_attr "type" "ssecmp")
1445    (set_attr "mode" "<MODE>")])
1446
1447 (define_insn "<sse>_vmmaskcmp<mode>3"
1448   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1449         (vec_merge:SSEMODEF2P
1450          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1451                 [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1452                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1453          (match_dup 1)
1454          (const_int 1)))]
1455   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && !TARGET_SSE5"
1456   "cmp%D3s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1457   [(set_attr "type" "ssecmp")
1458    (set_attr "mode" "<ssescalarmode>")])
1459
1460 (define_insn "<sse>_comi"
1461   [(set (reg:CCFP FLAGS_REG)
1462         (compare:CCFP
1463           (vec_select:MODEF
1464             (match_operand:<ssevecmode> 0 "register_operand" "x")
1465             (parallel [(const_int 0)]))
1466           (vec_select:MODEF
1467             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1468             (parallel [(const_int 0)]))))]
1469   "SSE_FLOAT_MODE_P (<MODE>mode)"
1470   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1471   [(set_attr "type" "ssecomi")
1472    (set_attr "prefix" "maybe_vex")
1473    (set_attr "mode" "<MODE>")])
1474
1475 (define_insn "<sse>_ucomi"
1476   [(set (reg:CCFPU FLAGS_REG)
1477         (compare:CCFPU
1478           (vec_select:MODEF
1479             (match_operand:<ssevecmode> 0 "register_operand" "x")
1480             (parallel [(const_int 0)]))
1481           (vec_select:MODEF
1482             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1483             (parallel [(const_int 0)]))))]
1484   "SSE_FLOAT_MODE_P (<MODE>mode)"
1485   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1486   [(set_attr "type" "ssecomi")
1487    (set_attr "prefix" "maybe_vex")
1488    (set_attr "mode" "<MODE>")])
1489
1490 (define_expand "vcond<mode>"
1491   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1492         (if_then_else:SSEMODEF2P
1493           (match_operator 3 ""
1494             [(match_operand:SSEMODEF2P 4 "nonimmediate_operand" "")
1495              (match_operand:SSEMODEF2P 5 "nonimmediate_operand" "")])
1496           (match_operand:SSEMODEF2P 1 "general_operand" "")
1497           (match_operand:SSEMODEF2P 2 "general_operand" "")))]
1498   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1499 {
1500   bool ok = ix86_expand_fp_vcond (operands);
1501   gcc_assert (ok);
1502   DONE;
1503 })
1504
1505 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1506 ;;
1507 ;; Parallel floating point logical operations
1508 ;;
1509 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1510
1511 (define_insn "avx_andnot<mode>3"
1512   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1513         (and:AVXMODEF2P
1514           (not:AVXMODEF2P
1515             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1516           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1517   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1518   "vandnp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1519   [(set_attr "type" "sselog")
1520    (set_attr "prefix" "vex")
1521    (set_attr "mode" "<avxvecmode>")])
1522
1523 (define_insn "<sse>_andnot<mode>3"
1524   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1525         (and:SSEMODEF2P
1526           (not:SSEMODEF2P
1527             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1528           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1529   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1530   "andnp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1531   [(set_attr "type" "sselog")
1532    (set_attr "mode" "<MODE>")])
1533
1534 (define_expand "<code><mode>3"
1535   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1536         (plogic:AVX256MODEF2P
1537           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1538           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1539   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1540   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1541
1542 (define_insn "*avx_<code><mode>3"
1543   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1544         (plogic:AVXMODEF2P
1545           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1546           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1547   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1548    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1549   "v<plogicprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1550   [(set_attr "type" "sselog")
1551    (set_attr "prefix" "vex")
1552    (set_attr "mode" "<avxvecmode>")])
1553
1554 (define_expand "<code><mode>3"
1555   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1556         (plogic:SSEMODEF2P
1557           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1558           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1559   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1560   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1561
1562 (define_insn "*<code><mode>3"
1563   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1564         (plogic:SSEMODEF2P
1565           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1566           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1567   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1568    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1569   "<plogicprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1570   [(set_attr "type" "sselog")
1571    (set_attr "mode" "<MODE>")])
1572
1573 ;; Also define scalar versions.  These are used for abs, neg, and
1574 ;; conditional move.  Using subregs into vector modes causes register
1575 ;; allocation lossage.  These patterns do not allow memory operands
1576 ;; because the native instructions read the full 128-bits.
1577
1578 (define_insn "*avx_andnot<mode>3"
1579   [(set (match_operand:MODEF 0 "register_operand" "=x")
1580         (and:MODEF
1581           (not:MODEF
1582             (match_operand:MODEF 1 "register_operand" "x"))
1583             (match_operand:MODEF 2 "register_operand" "x")))]
1584   "AVX_FLOAT_MODE_P (<MODE>mode)"
1585   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1586   [(set_attr "type" "sselog")
1587    (set_attr "prefix" "vex")
1588    (set_attr "mode" "<ssevecmode>")])
1589
1590 (define_insn "*andnot<mode>3"
1591   [(set (match_operand:MODEF 0 "register_operand" "=x")
1592         (and:MODEF
1593           (not:MODEF
1594             (match_operand:MODEF 1 "register_operand" "0"))
1595             (match_operand:MODEF 2 "register_operand" "x")))]
1596   "SSE_FLOAT_MODE_P (<MODE>mode)"
1597   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1598   [(set_attr "type" "sselog")
1599    (set_attr "mode" "<ssevecmode>")])
1600
1601 (define_insn "*avx_<code><mode>3"
1602   [(set (match_operand:MODEF 0 "register_operand" "=x")
1603         (plogic:MODEF
1604           (match_operand:MODEF 1 "register_operand" "x")
1605           (match_operand:MODEF 2 "register_operand" "x")))]
1606   "AVX_FLOAT_MODE_P (<MODE>mode)"
1607   "v<plogicprefix>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1608   [(set_attr "type" "sselog")
1609    (set_attr "prefix" "vex")
1610    (set_attr "mode" "<ssevecmode>")])
1611
1612 (define_insn "*<code><mode>3"
1613   [(set (match_operand:MODEF 0 "register_operand" "=x")
1614         (plogic:MODEF
1615           (match_operand:MODEF 1 "register_operand" "0")
1616           (match_operand:MODEF 2 "register_operand" "x")))]
1617   "SSE_FLOAT_MODE_P (<MODE>mode)"
1618   "<plogicprefix>p<ssemodefsuffix>\t{%2, %0|%0, %2}"
1619   [(set_attr "type" "sselog")
1620    (set_attr "mode" "<ssevecmode>")])
1621
1622 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1623 ;;
1624 ;; SSE5 floating point multiply/accumulate instructions This includes the
1625 ;; scalar version of the instructions as well as the vector
1626 ;;
1627 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1628
1629 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1630 ;; combine to generate a multiply/add with two memory references.  We then
1631 ;; split this insn, into loading up the destination register with one of the
1632 ;; memory operations.  If we don't manage to split the insn, reload will
1633 ;; generate the appropriate moves.  The reason this is needed, is that combine
1634 ;; has already folded one of the memory references into both the multiply and
1635 ;; add insns, and it can't generate a new pseudo.  I.e.:
1636 ;;      (set (reg1) (mem (addr1)))
1637 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1638 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1639
1640 (define_insn "sse5_fmadd<mode>4"
1641   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1642         (plus:SSEMODEF4
1643          (mult:SSEMODEF4
1644           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1645           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))
1646          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")))]
1647   "TARGET_SSE5 && TARGET_FUSED_MADD
1648    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1649   "fmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1650   [(set_attr "type" "ssemuladd")
1651    (set_attr "mode" "<MODE>")])
1652
1653 ;; Split fmadd with two memory operands into a load and the fmadd.
1654 (define_split
1655   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1656         (plus:SSEMODEF4
1657          (mult:SSEMODEF4
1658           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1659           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1660          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1661   "TARGET_SSE5
1662    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1663    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1664    && !reg_mentioned_p (operands[0], operands[1])
1665    && !reg_mentioned_p (operands[0], operands[2])
1666    && !reg_mentioned_p (operands[0], operands[3])"
1667   [(const_int 0)]
1668 {
1669   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1670   emit_insn (gen_sse5_fmadd<mode>4 (operands[0], operands[1],
1671                                     operands[2], operands[3]));
1672   DONE;
1673 })
1674
1675 ;; For the scalar operations, use operand1 for the upper words that aren't
1676 ;; modified, so restrict the forms that are generated.
1677 ;; Scalar version of fmadd
1678 (define_insn "sse5_vmfmadd<mode>4"
1679   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1680         (vec_merge:SSEMODEF2P
1681          (plus:SSEMODEF2P
1682           (mult:SSEMODEF2P
1683            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1684            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1685           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1686          (match_dup 1)
1687          (const_int 1)))]
1688   "TARGET_SSE5 && TARGET_FUSED_MADD
1689    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1690   "fmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1691   [(set_attr "type" "ssemuladd")
1692    (set_attr "mode" "<MODE>")])
1693
1694 ;; Floating multiply and subtract
1695 ;; Allow two memory operands the same as fmadd
1696 (define_insn "sse5_fmsub<mode>4"
1697   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1698         (minus:SSEMODEF4
1699          (mult:SSEMODEF4
1700           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1701           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))
1702          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")))]
1703   "TARGET_SSE5 && TARGET_FUSED_MADD
1704    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1705   "fmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1706   [(set_attr "type" "ssemuladd")
1707    (set_attr "mode" "<MODE>")])
1708
1709 ;; Split fmsub with two memory operands into a load and the fmsub.
1710 (define_split
1711   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1712         (minus:SSEMODEF4
1713          (mult:SSEMODEF4
1714           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1715           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1716          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1717   "TARGET_SSE5
1718    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1719    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1720    && !reg_mentioned_p (operands[0], operands[1])
1721    && !reg_mentioned_p (operands[0], operands[2])
1722    && !reg_mentioned_p (operands[0], operands[3])"
1723   [(const_int 0)]
1724 {
1725   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1726   emit_insn (gen_sse5_fmsub<mode>4 (operands[0], operands[1],
1727                                     operands[2], operands[3]));
1728   DONE;
1729 })
1730
1731 ;; For the scalar operations, use operand1 for the upper words that aren't
1732 ;; modified, so restrict the forms that are generated.
1733 ;; Scalar version of fmsub
1734 (define_insn "sse5_vmfmsub<mode>4"
1735   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1736         (vec_merge:SSEMODEF2P
1737          (minus:SSEMODEF2P
1738           (mult:SSEMODEF2P
1739            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1740            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1741           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1742          (match_dup 1)
1743          (const_int 1)))]
1744   "TARGET_SSE5 && TARGET_FUSED_MADD
1745    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
1746   "fmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1747   [(set_attr "type" "ssemuladd")
1748    (set_attr "mode" "<MODE>")])
1749
1750 ;; Floating point negative multiply and add
1751 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b)
1752 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
1753 ;; Allow two memory operands to help in optimizing.
1754 (define_insn "sse5_fnmadd<mode>4"
1755   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1756         (minus:SSEMODEF4
1757          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")
1758          (mult:SSEMODEF4
1759           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1760           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))))]
1761   "TARGET_SSE5 && TARGET_FUSED_MADD
1762    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1763   "fnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1764   [(set_attr "type" "ssemuladd")
1765    (set_attr "mode" "<MODE>")])
1766
1767 ;; Split fnmadd with two memory operands into a load and the fnmadd.
1768 (define_split
1769   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1770         (minus:SSEMODEF4
1771          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")
1772          (mult:SSEMODEF4
1773           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1774           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))))]
1775   "TARGET_SSE5
1776    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1777    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1778    && !reg_mentioned_p (operands[0], operands[1])
1779    && !reg_mentioned_p (operands[0], operands[2])
1780    && !reg_mentioned_p (operands[0], operands[3])"
1781   [(const_int 0)]
1782 {
1783   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1784   emit_insn (gen_sse5_fnmadd<mode>4 (operands[0], operands[1],
1785                                      operands[2], operands[3]));
1786   DONE;
1787 })
1788
1789 ;; For the scalar operations, use operand1 for the upper words that aren't
1790 ;; modified, so restrict the forms that are generated.
1791 ;; Scalar version of fnmadd
1792 (define_insn "sse5_vmfnmadd<mode>4"
1793   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1794         (vec_merge:SSEMODEF2P
1795          (minus:SSEMODEF2P
1796           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1797           (mult:SSEMODEF2P
1798            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1799            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm")))
1800          (match_dup 1)
1801          (const_int 1)))]
1802   "TARGET_SSE5 && TARGET_FUSED_MADD
1803    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1804   "fnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1805   [(set_attr "type" "ssemuladd")
1806    (set_attr "mode" "<MODE>")])
1807
1808 ;; Floating point negative multiply and subtract
1809 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c
1810 ;; Allow 2 memory operands to help with optimization
1811 (define_insn "sse5_fnmsub<mode>4"
1812   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1813         (minus:SSEMODEF4
1814          (mult:SSEMODEF4
1815           (neg:SSEMODEF4
1816            (match_operand:SSEMODEF4 1 "nonimmediate_operand" "0,0"))
1817           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm"))
1818          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1819   "TARGET_SSE5 && TARGET_FUSED_MADD
1820    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)"
1821   "fnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1822   [(set_attr "type" "ssemuladd")
1823    (set_attr "mode" "<MODE>")])
1824
1825 ;; Split fnmsub with two memory operands into a load and the fmsub.
1826 (define_split
1827   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1828         (minus:SSEMODEF4
1829          (mult:SSEMODEF4
1830           (neg:SSEMODEF4
1831            (match_operand:SSEMODEF4 1 "nonimmediate_operand" ""))
1832           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1833          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1834   "TARGET_SSE5
1835    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)
1836    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)
1837    && !reg_mentioned_p (operands[0], operands[1])
1838    && !reg_mentioned_p (operands[0], operands[2])
1839    && !reg_mentioned_p (operands[0], operands[3])"
1840   [(const_int 0)]
1841 {
1842   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1843   emit_insn (gen_sse5_fnmsub<mode>4 (operands[0], operands[1],
1844                                      operands[2], operands[3]));
1845   DONE;
1846 })
1847
1848 ;; For the scalar operations, use operand1 for the upper words that aren't
1849 ;; modified, so restrict the forms that are generated.
1850 ;; Scalar version of fnmsub
1851 (define_insn "sse5_vmfnmsub<mode>4"
1852   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1853         (vec_merge:SSEMODEF2P
1854          (minus:SSEMODEF2P
1855           (mult:SSEMODEF2P
1856            (neg:SSEMODEF2P
1857             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0"))
1858            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1859           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1860          (match_dup 1)
1861          (const_int 1)))]
1862   "TARGET_SSE5 && TARGET_FUSED_MADD
1863    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)"
1864   "fnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1865   [(set_attr "type" "ssemuladd")
1866    (set_attr "mode" "<MODE>")])
1867
1868 ;; The same instructions using an UNSPEC to allow the intrinsic to be used
1869 ;; even if the user used -mno-fused-madd
1870 ;; Parallel instructions.  During instruction generation, just default
1871 ;; to registers, and let combine later build the appropriate instruction.
1872 (define_expand "sse5i_fmadd<mode>4"
1873   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1874         (unspec:SSEMODEF2P
1875          [(plus:SSEMODEF2P
1876            (mult:SSEMODEF2P
1877             (match_operand:SSEMODEF2P 1 "register_operand" "")
1878             (match_operand:SSEMODEF2P 2 "register_operand" ""))
1879            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
1880          UNSPEC_SSE5_INTRINSIC))]
1881   "TARGET_SSE5"
1882 {
1883   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1884   if (TARGET_FUSED_MADD)
1885     {
1886       emit_insn (gen_sse5_fmadd<mode>4 (operands[0], operands[1],
1887                                         operands[2], operands[3]));
1888       DONE;
1889     }
1890 })
1891
1892 (define_insn "*sse5i_fmadd<mode>4"
1893   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
1894         (unspec:SSEMODEF2P
1895          [(plus:SSEMODEF2P
1896            (mult:SSEMODEF2P
1897             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
1898             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
1899            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
1900          UNSPEC_SSE5_INTRINSIC))]
1901   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1902   "fmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1903   [(set_attr "type" "ssemuladd")
1904    (set_attr "mode" "<MODE>")])
1905
1906 (define_expand "sse5i_fmsub<mode>4"
1907   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1908         (unspec:SSEMODEF2P
1909          [(minus:SSEMODEF2P
1910            (mult:SSEMODEF2P
1911             (match_operand:SSEMODEF2P 1 "register_operand" "")
1912             (match_operand:SSEMODEF2P 2 "register_operand" ""))
1913            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
1914          UNSPEC_SSE5_INTRINSIC))]
1915   "TARGET_SSE5"
1916 {
1917   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1918   if (TARGET_FUSED_MADD)
1919     {
1920       emit_insn (gen_sse5_fmsub<mode>4 (operands[0], operands[1],
1921                                         operands[2], operands[3]));
1922       DONE;
1923     }
1924 })
1925
1926 (define_insn "*sse5i_fmsub<mode>4"
1927   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
1928         (unspec:SSEMODEF2P
1929          [(minus:SSEMODEF2P
1930            (mult:SSEMODEF2P
1931             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
1932             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
1933            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
1934          UNSPEC_SSE5_INTRINSIC))]
1935   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1936   "fmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1937   [(set_attr "type" "ssemuladd")
1938    (set_attr "mode" "<MODE>")])
1939
1940 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b)
1941 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
1942 (define_expand "sse5i_fnmadd<mode>4"
1943   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1944         (unspec:SSEMODEF2P
1945          [(minus:SSEMODEF2P
1946            (match_operand:SSEMODEF2P 3 "register_operand" "")
1947            (mult:SSEMODEF2P
1948             (match_operand:SSEMODEF2P 1 "register_operand" "")
1949             (match_operand:SSEMODEF2P 2 "register_operand" "")))]
1950          UNSPEC_SSE5_INTRINSIC))]
1951   "TARGET_SSE5"
1952 {
1953   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1954   if (TARGET_FUSED_MADD)
1955     {
1956       emit_insn (gen_sse5_fnmadd<mode>4 (operands[0], operands[1],
1957                                          operands[2], operands[3]));
1958       DONE;
1959     }
1960 })
1961
1962 (define_insn "*sse5i_fnmadd<mode>4"
1963   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
1964         (unspec:SSEMODEF2P
1965          [(minus:SSEMODEF2P
1966            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0")
1967            (mult:SSEMODEF2P
1968             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
1969             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x")))]
1970          UNSPEC_SSE5_INTRINSIC))]
1971   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1972   "fnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1973   [(set_attr "type" "ssemuladd")
1974    (set_attr "mode" "<MODE>")])
1975
1976 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c
1977 (define_expand "sse5i_fnmsub<mode>4"
1978   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1979         (unspec:SSEMODEF2P
1980          [(minus:SSEMODEF2P
1981            (mult:SSEMODEF2P
1982             (neg:SSEMODEF2P
1983              (match_operand:SSEMODEF2P 1 "register_operand" ""))
1984             (match_operand:SSEMODEF2P 2 "register_operand" ""))
1985            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
1986          UNSPEC_SSE5_INTRINSIC))]
1987   "TARGET_SSE5"
1988 {
1989   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1990   if (TARGET_FUSED_MADD)
1991     {
1992       emit_insn (gen_sse5_fnmsub<mode>4 (operands[0], operands[1],
1993                                          operands[2], operands[3]));
1994       DONE;
1995     }
1996 })
1997
1998 (define_insn "*sse5i_fnmsub<mode>4"
1999   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
2000         (unspec:SSEMODEF2P
2001          [(minus:SSEMODEF2P
2002            (mult:SSEMODEF2P
2003             (neg:SSEMODEF2P
2004              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0,x,xm"))
2005             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
2006            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
2007          UNSPEC_SSE5_INTRINSIC))]
2008   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2009   "fnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2010   [(set_attr "type" "ssemuladd")
2011    (set_attr "mode" "<MODE>")])
2012
2013 ;; Scalar instructions
2014 (define_expand "sse5i_vmfmadd<mode>4"
2015   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2016         (unspec:SSEMODEF2P
2017          [(vec_merge:SSEMODEF2P
2018            (plus:SSEMODEF2P
2019             (mult:SSEMODEF2P
2020              (match_operand:SSEMODEF2P 1 "register_operand" "")
2021              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2022             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2023            (match_dup 1)
2024            (const_int 0))]
2025          UNSPEC_SSE5_INTRINSIC))]
2026   "TARGET_SSE5"
2027 {
2028   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2029   if (TARGET_FUSED_MADD)
2030     {
2031       emit_insn (gen_sse5_vmfmadd<mode>4 (operands[0], operands[1],
2032                                           operands[2], operands[3]));
2033       DONE;
2034     }
2035 })
2036
2037 ;; For the scalar operations, use operand1 for the upper words that aren't
2038 ;; modified, so restrict the forms that are accepted.
2039 (define_insn "*sse5i_vmfmadd<mode>4"
2040   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2041         (unspec:SSEMODEF2P
2042          [(vec_merge:SSEMODEF2P
2043            (plus:SSEMODEF2P
2044             (mult:SSEMODEF2P
2045              (match_operand:SSEMODEF2P 1 "register_operand" "0,0")
2046              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2047             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2048            (match_dup 0)
2049            (const_int 0))]
2050          UNSPEC_SSE5_INTRINSIC))]
2051   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2052   "fmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2053   [(set_attr "type" "ssemuladd")
2054    (set_attr "mode" "<ssescalarmode>")])
2055
2056 (define_expand "sse5i_vmfmsub<mode>4"
2057   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2058         (unspec:SSEMODEF2P
2059          [(vec_merge:SSEMODEF2P
2060            (minus:SSEMODEF2P
2061             (mult:SSEMODEF2P
2062              (match_operand:SSEMODEF2P 1 "register_operand" "")
2063              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2064             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2065            (match_dup 0)
2066            (const_int 1))]
2067          UNSPEC_SSE5_INTRINSIC))]
2068   "TARGET_SSE5"
2069 {
2070   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2071   if (TARGET_FUSED_MADD)
2072     {
2073       emit_insn (gen_sse5_vmfmsub<mode>4 (operands[0], operands[1],
2074                                           operands[2], operands[3]));
2075       DONE;
2076     }
2077 })
2078
2079 (define_insn "*sse5i_vmfmsub<mode>4"
2080   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2081         (unspec:SSEMODEF2P
2082          [(vec_merge:SSEMODEF2P
2083            (minus:SSEMODEF2P
2084             (mult:SSEMODEF2P
2085              (match_operand:SSEMODEF2P 1 "register_operand" "0,0")
2086              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2087             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2088            (match_dup 1)
2089            (const_int 1))]
2090          UNSPEC_SSE5_INTRINSIC))]
2091   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2092   "fmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2093   [(set_attr "type" "ssemuladd")
2094    (set_attr "mode" "<ssescalarmode>")])
2095
2096 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
2097 (define_expand "sse5i_vmfnmadd<mode>4"
2098   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2099         (unspec:SSEMODEF2P
2100          [(vec_merge:SSEMODEF2P
2101            (minus:SSEMODEF2P
2102             (match_operand:SSEMODEF2P 3 "register_operand" "")
2103             (mult:SSEMODEF2P
2104              (match_operand:SSEMODEF2P 1 "register_operand" "")
2105              (match_operand:SSEMODEF2P 2 "register_operand" "")))
2106            (match_dup 1)
2107            (const_int 1))]
2108          UNSPEC_SSE5_INTRINSIC))]
2109   "TARGET_SSE5"
2110 {
2111   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2112   if (TARGET_FUSED_MADD)
2113     {
2114       emit_insn (gen_sse5_vmfnmadd<mode>4 (operands[0], operands[1],
2115                                            operands[2], operands[3]));
2116       DONE;
2117     }
2118 })
2119
2120 (define_insn "*sse5i_vmfnmadd<mode>4"
2121   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2122         (unspec:SSEMODEF2P
2123          [(vec_merge:SSEMODEF2P
2124            (minus:SSEMODEF2P
2125             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2126             (mult:SSEMODEF2P
2127              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0")
2128              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm")))
2129            (match_dup 1)
2130            (const_int 1))]
2131          UNSPEC_SSE5_INTRINSIC))]
2132   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
2133   "fnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2134   [(set_attr "type" "ssemuladd")
2135    (set_attr "mode" "<ssescalarmode>")])
2136
2137 (define_expand "sse5i_vmfnmsub<mode>4"
2138   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2139         (unspec:SSEMODEF2P
2140          [(vec_merge:SSEMODEF2P
2141            (minus:SSEMODEF2P
2142             (mult:SSEMODEF2P
2143              (neg:SSEMODEF2P
2144               (match_operand:SSEMODEF2P 1 "register_operand" ""))
2145              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2146             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2147            (match_dup 1)
2148            (const_int 1))]
2149          UNSPEC_SSE5_INTRINSIC))]
2150   "TARGET_SSE5"
2151 {
2152   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2153   if (TARGET_FUSED_MADD)
2154     {
2155       emit_insn (gen_sse5_vmfnmsub<mode>4 (operands[0], operands[1],
2156                                            operands[2], operands[3]));
2157       DONE;
2158     }
2159 })
2160
2161 (define_insn "*sse5i_vmfnmsub<mode>4"
2162   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2163         (unspec:SSEMODEF2P
2164          [(vec_merge:SSEMODEF2P
2165            (minus:SSEMODEF2P
2166             (mult:SSEMODEF2P
2167              (neg:SSEMODEF2P
2168               (match_operand:SSEMODEF2P 1 "register_operand" "0,0"))
2169              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2170             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2171            (match_dup 1)
2172            (const_int 1))]
2173          UNSPEC_SSE5_INTRINSIC))]
2174   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2175   "fnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2176   [(set_attr "type" "ssemuladd")
2177    (set_attr "mode" "<ssescalarmode>")])
2178
2179 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2180 ;;
2181 ;; Parallel single-precision floating point conversion operations
2182 ;;
2183 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2184
2185 (define_insn "sse_cvtpi2ps"
2186   [(set (match_operand:V4SF 0 "register_operand" "=x")
2187         (vec_merge:V4SF
2188           (vec_duplicate:V4SF
2189             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2190           (match_operand:V4SF 1 "register_operand" "0")
2191           (const_int 3)))]
2192   "TARGET_SSE"
2193   "cvtpi2ps\t{%2, %0|%0, %2}"
2194   [(set_attr "type" "ssecvt")
2195    (set_attr "mode" "V4SF")])
2196
2197 (define_insn "sse_cvtps2pi"
2198   [(set (match_operand:V2SI 0 "register_operand" "=y")
2199         (vec_select:V2SI
2200           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2201                        UNSPEC_FIX_NOTRUNC)
2202           (parallel [(const_int 0) (const_int 1)])))]
2203   "TARGET_SSE"
2204   "cvtps2pi\t{%1, %0|%0, %1}"
2205   [(set_attr "type" "ssecvt")
2206    (set_attr "unit" "mmx")
2207    (set_attr "mode" "DI")])
2208
2209 (define_insn "sse_cvttps2pi"
2210   [(set (match_operand:V2SI 0 "register_operand" "=y")
2211         (vec_select:V2SI
2212           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2213           (parallel [(const_int 0) (const_int 1)])))]
2214   "TARGET_SSE"
2215   "cvttps2pi\t{%1, %0|%0, %1}"
2216   [(set_attr "type" "ssecvt")
2217    (set_attr "unit" "mmx")
2218    (set_attr "mode" "SF")])
2219
2220 (define_insn "*avx_cvtsi2ss"
2221   [(set (match_operand:V4SF 0 "register_operand" "=x")
2222         (vec_merge:V4SF
2223           (vec_duplicate:V4SF
2224             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2225           (match_operand:V4SF 1 "register_operand" "x")
2226           (const_int 1)))]
2227   "TARGET_AVX"
2228   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2229   [(set_attr "type" "sseicvt")
2230    (set_attr "prefix" "vex")
2231    (set_attr "mode" "SF")])
2232
2233 (define_insn "sse_cvtsi2ss"
2234   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2235         (vec_merge:V4SF
2236           (vec_duplicate:V4SF
2237             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2238           (match_operand:V4SF 1 "register_operand" "0,0")
2239           (const_int 1)))]
2240   "TARGET_SSE"
2241   "cvtsi2ss\t{%2, %0|%0, %2}"
2242   [(set_attr "type" "sseicvt")
2243    (set_attr "athlon_decode" "vector,double")
2244    (set_attr "amdfam10_decode" "vector,double")
2245    (set_attr "mode" "SF")])
2246
2247 (define_insn "*avx_cvtsi2ssq"
2248   [(set (match_operand:V4SF 0 "register_operand" "=x")
2249         (vec_merge:V4SF
2250           (vec_duplicate:V4SF
2251             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2252           (match_operand:V4SF 1 "register_operand" "x")
2253           (const_int 1)))]
2254   "TARGET_AVX && TARGET_64BIT"
2255   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2256   [(set_attr "type" "sseicvt")
2257    (set_attr "prefix" "vex")
2258    (set_attr "mode" "SF")])
2259
2260 (define_insn "sse_cvtsi2ssq"
2261   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2262         (vec_merge:V4SF
2263           (vec_duplicate:V4SF
2264             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2265           (match_operand:V4SF 1 "register_operand" "0,0")
2266           (const_int 1)))]
2267   "TARGET_SSE && TARGET_64BIT"
2268   "cvtsi2ssq\t{%2, %0|%0, %2}"
2269   [(set_attr "type" "sseicvt")
2270    (set_attr "athlon_decode" "vector,double")
2271    (set_attr "amdfam10_decode" "vector,double")
2272    (set_attr "mode" "SF")])
2273
2274 (define_insn "sse_cvtss2si"
2275   [(set (match_operand:SI 0 "register_operand" "=r,r")
2276         (unspec:SI
2277           [(vec_select:SF
2278              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2279              (parallel [(const_int 0)]))]
2280           UNSPEC_FIX_NOTRUNC))]
2281   "TARGET_SSE"
2282   "%vcvtss2si\t{%1, %0|%0, %1}"
2283   [(set_attr "type" "sseicvt")
2284    (set_attr "athlon_decode" "double,vector")
2285    (set_attr "prefix_rep" "1")
2286    (set_attr "prefix" "maybe_vex")
2287    (set_attr "mode" "SI")])
2288
2289 (define_insn "sse_cvtss2si_2"
2290   [(set (match_operand:SI 0 "register_operand" "=r,r")
2291         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2292                    UNSPEC_FIX_NOTRUNC))]
2293   "TARGET_SSE"
2294   "%vcvtss2si\t{%1, %0|%0, %1}"
2295   [(set_attr "type" "sseicvt")
2296    (set_attr "athlon_decode" "double,vector")
2297    (set_attr "amdfam10_decode" "double,double")
2298    (set_attr "prefix_rep" "1")
2299    (set_attr "prefix" "maybe_vex")
2300    (set_attr "mode" "SI")])
2301
2302 (define_insn "sse_cvtss2siq"
2303   [(set (match_operand:DI 0 "register_operand" "=r,r")
2304         (unspec:DI
2305           [(vec_select:SF
2306              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2307              (parallel [(const_int 0)]))]
2308           UNSPEC_FIX_NOTRUNC))]
2309   "TARGET_SSE && TARGET_64BIT"
2310   "%vcvtss2siq\t{%1, %0|%0, %1}"
2311   [(set_attr "type" "sseicvt")
2312    (set_attr "athlon_decode" "double,vector")
2313    (set_attr "prefix_rep" "1")
2314    (set_attr "prefix" "maybe_vex")
2315    (set_attr "mode" "DI")])
2316
2317 (define_insn "sse_cvtss2siq_2"
2318   [(set (match_operand:DI 0 "register_operand" "=r,r")
2319         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2320                    UNSPEC_FIX_NOTRUNC))]
2321   "TARGET_SSE && TARGET_64BIT"
2322   "%vcvtss2siq\t{%1, %0|%0, %1}"
2323   [(set_attr "type" "sseicvt")
2324    (set_attr "athlon_decode" "double,vector")
2325    (set_attr "amdfam10_decode" "double,double")
2326    (set_attr "prefix_rep" "1")
2327    (set_attr "prefix" "maybe_vex")
2328    (set_attr "mode" "DI")])
2329
2330 (define_insn "sse_cvttss2si"
2331   [(set (match_operand:SI 0 "register_operand" "=r,r")
2332         (fix:SI
2333           (vec_select:SF
2334             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2335             (parallel [(const_int 0)]))))]
2336   "TARGET_SSE"
2337   "%vcvttss2si\t{%1, %0|%0, %1}"
2338   [(set_attr "type" "sseicvt")
2339    (set_attr "athlon_decode" "double,vector")
2340    (set_attr "amdfam10_decode" "double,double")
2341    (set_attr "prefix_rep" "1")
2342    (set_attr "prefix" "maybe_vex")
2343    (set_attr "mode" "SI")])
2344
2345 (define_insn "sse_cvttss2siq"
2346   [(set (match_operand:DI 0 "register_operand" "=r,r")
2347         (fix:DI
2348           (vec_select:SF
2349             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2350             (parallel [(const_int 0)]))))]
2351   "TARGET_SSE && TARGET_64BIT"
2352   "%vcvttss2siq\t{%1, %0|%0, %1}"
2353   [(set_attr "type" "sseicvt")
2354    (set_attr "athlon_decode" "double,vector")
2355    (set_attr "amdfam10_decode" "double,double")
2356    (set_attr "prefix_rep" "1")
2357    (set_attr "prefix" "maybe_vex")
2358    (set_attr "mode" "DI")])
2359
2360 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2361   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2362         (float:AVXMODEDCVTDQ2PS
2363           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2364   "TARGET_AVX"
2365   "vcvtdq2ps\t{%1, %0|%0, %1}"
2366   [(set_attr "type" "ssecvt")
2367    (set_attr "prefix" "vex")
2368    (set_attr "mode" "<avxvecmode>")])
2369
2370 (define_insn "sse2_cvtdq2ps"
2371   [(set (match_operand:V4SF 0 "register_operand" "=x")
2372         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2373   "TARGET_SSE2"
2374   "cvtdq2ps\t{%1, %0|%0, %1}"
2375   [(set_attr "type" "ssecvt")
2376    (set_attr "mode" "V4SF")])
2377
2378 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2379   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2380         (unspec:AVXMODEDCVTPS2DQ
2381           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2382           UNSPEC_FIX_NOTRUNC))]
2383   "TARGET_AVX"
2384   "vcvtps2dq\t{%1, %0|%0, %1}"
2385   [(set_attr "type" "ssecvt")
2386    (set_attr "prefix" "vex")
2387    (set_attr "mode" "<avxvecmode>")])
2388
2389 (define_insn "sse2_cvtps2dq"
2390   [(set (match_operand:V4SI 0 "register_operand" "=x")
2391         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2392                      UNSPEC_FIX_NOTRUNC))]
2393   "TARGET_SSE2"
2394   "cvtps2dq\t{%1, %0|%0, %1}"
2395   [(set_attr "type" "ssecvt")
2396    (set_attr "prefix_data16" "1")
2397    (set_attr "mode" "TI")])
2398
2399 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2400   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2401         (fix:AVXMODEDCVTPS2DQ
2402           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2403   "TARGET_AVX"
2404   "vcvttps2dq\t{%1, %0|%0, %1}"
2405   [(set_attr "type" "ssecvt")
2406    (set_attr "prefix" "vex")
2407    (set_attr "mode" "<avxvecmode>")])
2408
2409 (define_insn "sse2_cvttps2dq"
2410   [(set (match_operand:V4SI 0 "register_operand" "=x")
2411         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2412   "TARGET_SSE2"
2413   "cvttps2dq\t{%1, %0|%0, %1}"
2414   [(set_attr "type" "ssecvt")
2415    (set_attr "prefix_rep" "1")
2416    (set_attr "mode" "TI")])
2417
2418 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2419 ;;
2420 ;; Parallel double-precision floating point conversion operations
2421 ;;
2422 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2423
2424 (define_insn "sse2_cvtpi2pd"
2425   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2426         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2427   "TARGET_SSE2"
2428   "cvtpi2pd\t{%1, %0|%0, %1}"
2429   [(set_attr "type" "ssecvt")
2430    (set_attr "unit" "mmx,*")
2431    (set_attr "mode" "V2DF")])
2432
2433 (define_insn "sse2_cvtpd2pi"
2434   [(set (match_operand:V2SI 0 "register_operand" "=y")
2435         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2436                      UNSPEC_FIX_NOTRUNC))]
2437   "TARGET_SSE2"
2438   "cvtpd2pi\t{%1, %0|%0, %1}"
2439   [(set_attr "type" "ssecvt")
2440    (set_attr "unit" "mmx")
2441    (set_attr "prefix_data16" "1")
2442    (set_attr "mode" "DI")])
2443
2444 (define_insn "sse2_cvttpd2pi"
2445   [(set (match_operand:V2SI 0 "register_operand" "=y")
2446         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2447   "TARGET_SSE2"
2448   "cvttpd2pi\t{%1, %0|%0, %1}"
2449   [(set_attr "type" "ssecvt")
2450    (set_attr "unit" "mmx")
2451    (set_attr "prefix_data16" "1")
2452    (set_attr "mode" "TI")])
2453
2454 (define_insn "*avx_cvtsi2sd"
2455   [(set (match_operand:V2DF 0 "register_operand" "=x")
2456         (vec_merge:V2DF
2457           (vec_duplicate:V2DF
2458             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2459           (match_operand:V2DF 1 "register_operand" "x")
2460           (const_int 1)))]
2461   "TARGET_AVX"
2462   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2463   [(set_attr "type" "sseicvt")
2464    (set_attr "prefix" "vex")
2465    (set_attr "mode" "DF")])
2466
2467 (define_insn "sse2_cvtsi2sd"
2468   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2469         (vec_merge:V2DF
2470           (vec_duplicate:V2DF
2471             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2472           (match_operand:V2DF 1 "register_operand" "0,0")
2473           (const_int 1)))]
2474   "TARGET_SSE2"
2475   "cvtsi2sd\t{%2, %0|%0, %2}"
2476   [(set_attr "type" "sseicvt")
2477    (set_attr "mode" "DF")
2478    (set_attr "athlon_decode" "double,direct")
2479    (set_attr "amdfam10_decode" "vector,double")])
2480
2481 (define_insn "*avx_cvtsi2sdq"
2482   [(set (match_operand:V2DF 0 "register_operand" "=x")
2483         (vec_merge:V2DF
2484           (vec_duplicate:V2DF
2485             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2486           (match_operand:V2DF 1 "register_operand" "x")
2487           (const_int 1)))]
2488   "TARGET_AVX && TARGET_64BIT"
2489   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2490   [(set_attr "type" "sseicvt")
2491    (set_attr "prefix" "vex")
2492    (set_attr "mode" "DF")])
2493
2494 (define_insn "sse2_cvtsi2sdq"
2495   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2496         (vec_merge:V2DF
2497           (vec_duplicate:V2DF
2498             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2499           (match_operand:V2DF 1 "register_operand" "0,0")
2500           (const_int 1)))]
2501   "TARGET_SSE2 && TARGET_64BIT"
2502   "cvtsi2sdq\t{%2, %0|%0, %2}"
2503   [(set_attr "type" "sseicvt")
2504    (set_attr "mode" "DF")
2505    (set_attr "athlon_decode" "double,direct")
2506    (set_attr "amdfam10_decode" "vector,double")])
2507
2508 (define_insn "sse2_cvtsd2si"
2509   [(set (match_operand:SI 0 "register_operand" "=r,r")
2510         (unspec:SI
2511           [(vec_select:DF
2512              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2513              (parallel [(const_int 0)]))]
2514           UNSPEC_FIX_NOTRUNC))]
2515   "TARGET_SSE2"
2516   "%vcvtsd2si\t{%1, %0|%0, %1}"
2517   [(set_attr "type" "sseicvt")
2518    (set_attr "athlon_decode" "double,vector")
2519    (set_attr "prefix_rep" "1")
2520    (set_attr "prefix" "maybe_vex")
2521    (set_attr "mode" "SI")])
2522
2523 (define_insn "sse2_cvtsd2si_2"
2524   [(set (match_operand:SI 0 "register_operand" "=r,r")
2525         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2526                    UNSPEC_FIX_NOTRUNC))]
2527   "TARGET_SSE2"
2528   "%vcvtsd2si\t{%1, %0|%0, %1}"
2529   [(set_attr "type" "sseicvt")
2530    (set_attr "athlon_decode" "double,vector")
2531    (set_attr "amdfam10_decode" "double,double")
2532    (set_attr "prefix_rep" "1")
2533    (set_attr "prefix" "maybe_vex")
2534    (set_attr "mode" "SI")])
2535
2536 (define_insn "sse2_cvtsd2siq"
2537   [(set (match_operand:DI 0 "register_operand" "=r,r")
2538         (unspec:DI
2539           [(vec_select:DF
2540              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2541              (parallel [(const_int 0)]))]
2542           UNSPEC_FIX_NOTRUNC))]
2543   "TARGET_SSE2 && TARGET_64BIT"
2544   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2545   [(set_attr "type" "sseicvt")
2546    (set_attr "athlon_decode" "double,vector")
2547    (set_attr "prefix_rep" "1")
2548    (set_attr "prefix" "maybe_vex")
2549    (set_attr "mode" "DI")])
2550
2551 (define_insn "sse2_cvtsd2siq_2"
2552   [(set (match_operand:DI 0 "register_operand" "=r,r")
2553         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2554                    UNSPEC_FIX_NOTRUNC))]
2555   "TARGET_SSE2 && TARGET_64BIT"
2556   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2557   [(set_attr "type" "sseicvt")
2558    (set_attr "athlon_decode" "double,vector")
2559    (set_attr "amdfam10_decode" "double,double")
2560    (set_attr "prefix_rep" "1")
2561    (set_attr "prefix" "maybe_vex")
2562    (set_attr "mode" "DI")])
2563
2564 (define_insn "sse2_cvttsd2si"
2565   [(set (match_operand:SI 0 "register_operand" "=r,r")
2566         (fix:SI
2567           (vec_select:DF
2568             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2569             (parallel [(const_int 0)]))))]
2570   "TARGET_SSE2"
2571   "%vcvttsd2si\t{%1, %0|%0, %1}"
2572   [(set_attr "type" "sseicvt")
2573    (set_attr "prefix_rep" "1")
2574    (set_attr "prefix" "maybe_vex")
2575    (set_attr "mode" "SI")
2576    (set_attr "athlon_decode" "double,vector")
2577    (set_attr "amdfam10_decode" "double,double")])
2578
2579 (define_insn "sse2_cvttsd2siq"
2580   [(set (match_operand:DI 0 "register_operand" "=r,r")
2581         (fix:DI
2582           (vec_select:DF
2583             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2584             (parallel [(const_int 0)]))))]
2585   "TARGET_SSE2 && TARGET_64BIT"
2586   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2587   [(set_attr "type" "sseicvt")
2588    (set_attr "prefix_rep" "1")
2589    (set_attr "prefix" "maybe_vex")
2590    (set_attr "mode" "DI")
2591    (set_attr "athlon_decode" "double,vector")
2592    (set_attr "amdfam10_decode" "double,double")])
2593
2594 (define_insn "avx_cvtdq2pd256"
2595   [(set (match_operand:V4DF 0 "register_operand" "=x")
2596         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2597   "TARGET_AVX"
2598   "vcvtdq2pd\t{%1, %0|%0, %1}"
2599   [(set_attr "type" "ssecvt")
2600    (set_attr "prefix" "vex")
2601    (set_attr "mode" "V4DF")])
2602
2603 (define_insn "sse2_cvtdq2pd"
2604   [(set (match_operand:V2DF 0 "register_operand" "=x")
2605         (float:V2DF
2606           (vec_select:V2SI
2607             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2608             (parallel [(const_int 0) (const_int 1)]))))]
2609   "TARGET_SSE2"
2610   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2611   [(set_attr "type" "ssecvt")
2612    (set_attr "prefix" "maybe_vex")
2613    (set_attr "mode" "V2DF")])
2614
2615 (define_insn "avx_cvtpd2dq256"
2616   [(set (match_operand:V4SI 0 "register_operand" "=x")
2617         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2618                      UNSPEC_FIX_NOTRUNC))]
2619   "TARGET_AVX"
2620   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2621   [(set_attr "type" "ssecvt")
2622    (set_attr "prefix" "vex")
2623    (set_attr "mode" "OI")])
2624
2625 (define_expand "sse2_cvtpd2dq"
2626   [(set (match_operand:V4SI 0 "register_operand" "")
2627         (vec_concat:V4SI
2628           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2629                        UNSPEC_FIX_NOTRUNC)
2630           (match_dup 2)))]
2631   "TARGET_SSE2"
2632   "operands[2] = CONST0_RTX (V2SImode);")
2633
2634 (define_insn "*sse2_cvtpd2dq"
2635   [(set (match_operand:V4SI 0 "register_operand" "=x")
2636         (vec_concat:V4SI
2637           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2638                        UNSPEC_FIX_NOTRUNC)
2639           (match_operand:V2SI 2 "const0_operand" "")))]
2640   "TARGET_SSE2"
2641   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2642                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2643   [(set_attr "type" "ssecvt")
2644    (set_attr "prefix_rep" "1")
2645    (set_attr "prefix" "maybe_vex")
2646    (set_attr "mode" "TI")
2647    (set_attr "amdfam10_decode" "double")])
2648
2649 (define_insn "avx_cvttpd2dq256"
2650   [(set (match_operand:V4SI 0 "register_operand" "=x")
2651         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2652   "TARGET_AVX"
2653   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2654   [(set_attr "type" "ssecvt")
2655    (set_attr "prefix" "vex")
2656    (set_attr "mode" "OI")])
2657
2658 (define_expand "sse2_cvttpd2dq"
2659   [(set (match_operand:V4SI 0 "register_operand" "")
2660         (vec_concat:V4SI
2661           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2662           (match_dup 2)))]
2663   "TARGET_SSE2"
2664   "operands[2] = CONST0_RTX (V2SImode);")
2665
2666 (define_insn "*sse2_cvttpd2dq"
2667   [(set (match_operand:V4SI 0 "register_operand" "=x")
2668         (vec_concat:V4SI
2669           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2670           (match_operand:V2SI 2 "const0_operand" "")))]
2671   "TARGET_SSE2"
2672   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2673                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2674   [(set_attr "type" "ssecvt")
2675    (set_attr "prefix_rep" "1")
2676    (set_attr "prefix" "maybe_vex")
2677    (set_attr "mode" "TI")
2678    (set_attr "amdfam10_decode" "double")])
2679
2680 (define_insn "*avx_cvtsd2ss"
2681   [(set (match_operand:V4SF 0 "register_operand" "=x")
2682         (vec_merge:V4SF
2683           (vec_duplicate:V4SF
2684             (float_truncate:V2SF
2685               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2686           (match_operand:V4SF 1 "register_operand" "x")
2687           (const_int 1)))]
2688   "TARGET_AVX"
2689   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2690   [(set_attr "type" "ssecvt")
2691    (set_attr "prefix" "vex")
2692    (set_attr "mode" "SF")])
2693
2694 (define_insn "sse2_cvtsd2ss"
2695   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2696         (vec_merge:V4SF
2697           (vec_duplicate:V4SF
2698             (float_truncate:V2SF
2699               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2700           (match_operand:V4SF 1 "register_operand" "0,0")
2701           (const_int 1)))]
2702   "TARGET_SSE2"
2703   "cvtsd2ss\t{%2, %0|%0, %2}"
2704   [(set_attr "type" "ssecvt")
2705    (set_attr "athlon_decode" "vector,double")
2706    (set_attr "amdfam10_decode" "vector,double")
2707    (set_attr "mode" "SF")])
2708
2709 (define_insn "*avx_cvtss2sd"
2710   [(set (match_operand:V2DF 0 "register_operand" "=x")
2711         (vec_merge:V2DF
2712           (float_extend:V2DF
2713             (vec_select:V2SF
2714               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
2715               (parallel [(const_int 0) (const_int 1)])))
2716           (match_operand:V2DF 1 "register_operand" "x")
2717           (const_int 1)))]
2718   "TARGET_AVX"
2719   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2720   [(set_attr "type" "ssecvt")
2721    (set_attr "prefix" "vex")
2722    (set_attr "mode" "DF")])
2723
2724 (define_insn "sse2_cvtss2sd"
2725   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2726         (vec_merge:V2DF
2727           (float_extend:V2DF
2728             (vec_select:V2SF
2729               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2730               (parallel [(const_int 0) (const_int 1)])))
2731           (match_operand:V2DF 1 "register_operand" "0,0")
2732           (const_int 1)))]
2733   "TARGET_SSE2"
2734   "cvtss2sd\t{%2, %0|%0, %2}"
2735   [(set_attr "type" "ssecvt")
2736    (set_attr "amdfam10_decode" "vector,double")
2737    (set_attr "mode" "DF")])
2738
2739 (define_insn "avx_cvtpd2ps256"
2740   [(set (match_operand:V4SF 0 "register_operand" "=x")
2741         (float_truncate:V4SF
2742           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2743   "TARGET_AVX"
2744   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
2745   [(set_attr "type" "ssecvt")
2746    (set_attr "prefix" "vex")
2747    (set_attr "mode" "V4SF")])
2748
2749 (define_expand "sse2_cvtpd2ps"
2750   [(set (match_operand:V4SF 0 "register_operand" "")
2751         (vec_concat:V4SF
2752           (float_truncate:V2SF
2753             (match_operand:V2DF 1 "nonimmediate_operand" ""))
2754           (match_dup 2)))]
2755   "TARGET_SSE2"
2756   "operands[2] = CONST0_RTX (V2SFmode);")
2757
2758 (define_insn "*sse2_cvtpd2ps"
2759   [(set (match_operand:V4SF 0 "register_operand" "=x")
2760         (vec_concat:V4SF
2761           (float_truncate:V2SF
2762             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2763           (match_operand:V2SF 2 "const0_operand" "")))]
2764   "TARGET_SSE2"
2765   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
2766                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
2767   [(set_attr "type" "ssecvt")
2768    (set_attr "prefix_data16" "1")
2769    (set_attr "prefix" "maybe_vex")
2770    (set_attr "mode" "V4SF")
2771    (set_attr "amdfam10_decode" "double")])
2772
2773 (define_insn "avx_cvtps2pd256"
2774   [(set (match_operand:V4DF 0 "register_operand" "=x")
2775         (float_extend:V4DF
2776           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2777   "TARGET_AVX"
2778   "vcvtps2pd\t{%1, %0|%0, %1}"
2779   [(set_attr "type" "ssecvt")
2780    (set_attr "prefix" "vex")
2781    (set_attr "mode" "V4DF")])
2782
2783 (define_insn "sse2_cvtps2pd"
2784   [(set (match_operand:V2DF 0 "register_operand" "=x")
2785         (float_extend:V2DF
2786           (vec_select:V2SF
2787             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
2788             (parallel [(const_int 0) (const_int 1)]))))]
2789   "TARGET_SSE2"
2790   "%vcvtps2pd\t{%1, %0|%0, %1}"
2791   [(set_attr "type" "ssecvt")
2792    (set_attr "prefix" "maybe_vex")
2793    (set_attr "mode" "V2DF")
2794    (set_attr "amdfam10_decode" "direct")])
2795
2796 (define_expand "vec_unpacks_hi_v4sf"
2797   [(set (match_dup 2)
2798    (vec_select:V4SF
2799      (vec_concat:V8SF
2800        (match_dup 2)
2801        (match_operand:V4SF 1 "nonimmediate_operand" ""))
2802      (parallel [(const_int 6)
2803                 (const_int 7)
2804                 (const_int 2)
2805                 (const_int 3)])))
2806   (set (match_operand:V2DF 0 "register_operand" "")
2807    (float_extend:V2DF
2808      (vec_select:V2SF
2809        (match_dup 2)
2810        (parallel [(const_int 0) (const_int 1)]))))]
2811  "TARGET_SSE2"
2812 {
2813  operands[2] = gen_reg_rtx (V4SFmode);
2814 })
2815
2816 (define_expand "vec_unpacks_lo_v4sf"
2817   [(set (match_operand:V2DF 0 "register_operand" "")
2818         (float_extend:V2DF
2819           (vec_select:V2SF
2820             (match_operand:V4SF 1 "nonimmediate_operand" "")
2821             (parallel [(const_int 0) (const_int 1)]))))]
2822   "TARGET_SSE2")
2823
2824 (define_expand "vec_unpacks_float_hi_v8hi"
2825   [(match_operand:V4SF 0 "register_operand" "")
2826    (match_operand:V8HI 1 "register_operand" "")]
2827   "TARGET_SSE2"
2828 {
2829   rtx tmp = gen_reg_rtx (V4SImode);
2830
2831   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
2832   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2833   DONE;
2834 })
2835
2836 (define_expand "vec_unpacks_float_lo_v8hi"
2837   [(match_operand:V4SF 0 "register_operand" "")
2838    (match_operand:V8HI 1 "register_operand" "")]
2839   "TARGET_SSE2"
2840 {
2841   rtx tmp = gen_reg_rtx (V4SImode);
2842
2843   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
2844   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2845   DONE;
2846 })
2847
2848 (define_expand "vec_unpacku_float_hi_v8hi"
2849   [(match_operand:V4SF 0 "register_operand" "")
2850    (match_operand:V8HI 1 "register_operand" "")]
2851   "TARGET_SSE2"
2852 {
2853   rtx tmp = gen_reg_rtx (V4SImode);
2854
2855   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
2856   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2857   DONE;
2858 })
2859
2860 (define_expand "vec_unpacku_float_lo_v8hi"
2861   [(match_operand:V4SF 0 "register_operand" "")
2862    (match_operand:V8HI 1 "register_operand" "")]
2863   "TARGET_SSE2"
2864 {
2865   rtx tmp = gen_reg_rtx (V4SImode);
2866
2867   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
2868   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2869   DONE;
2870 })
2871
2872 (define_expand "vec_unpacks_float_hi_v4si"
2873   [(set (match_dup 2)
2874         (vec_select:V4SI
2875           (match_operand:V4SI 1 "nonimmediate_operand" "")
2876           (parallel [(const_int 2)
2877                      (const_int 3)
2878                      (const_int 2)
2879                      (const_int 3)])))
2880    (set (match_operand:V2DF 0 "register_operand" "")
2881         (float:V2DF
2882           (vec_select:V2SI
2883           (match_dup 2)
2884             (parallel [(const_int 0) (const_int 1)]))))]
2885  "TARGET_SSE2"
2886 {
2887  operands[2] = gen_reg_rtx (V4SImode);
2888 })
2889
2890 (define_expand "vec_unpacks_float_lo_v4si"
2891   [(set (match_operand:V2DF 0 "register_operand" "")
2892         (float:V2DF
2893           (vec_select:V2SI
2894             (match_operand:V4SI 1 "nonimmediate_operand" "")
2895             (parallel [(const_int 0) (const_int 1)]))))]
2896   "TARGET_SSE2")
2897
2898 (define_expand "vec_pack_trunc_v2df"
2899   [(match_operand:V4SF 0 "register_operand" "")
2900    (match_operand:V2DF 1 "nonimmediate_operand" "")
2901    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2902   "TARGET_SSE2"
2903 {
2904   rtx r1, r2;
2905
2906   r1 = gen_reg_rtx (V4SFmode);
2907   r2 = gen_reg_rtx (V4SFmode);
2908
2909   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
2910   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
2911   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
2912   DONE;
2913 })
2914
2915 (define_expand "vec_pack_sfix_trunc_v2df"
2916   [(match_operand:V4SI 0 "register_operand" "")
2917    (match_operand:V2DF 1 "nonimmediate_operand" "")
2918    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2919   "TARGET_SSE2"
2920 {
2921   rtx r1, r2;
2922
2923   r1 = gen_reg_rtx (V4SImode);
2924   r2 = gen_reg_rtx (V4SImode);
2925
2926   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
2927   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
2928   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
2929                                   gen_lowpart (V2DImode, r1),
2930                                   gen_lowpart (V2DImode, r2)));
2931   DONE;
2932 })
2933
2934 (define_expand "vec_pack_sfix_v2df"
2935   [(match_operand:V4SI 0 "register_operand" "")
2936    (match_operand:V2DF 1 "nonimmediate_operand" "")
2937    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2938   "TARGET_SSE2"
2939 {
2940   rtx r1, r2;
2941
2942   r1 = gen_reg_rtx (V4SImode);
2943   r2 = gen_reg_rtx (V4SImode);
2944
2945   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
2946   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
2947   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
2948                                   gen_lowpart (V2DImode, r1),
2949                                   gen_lowpart (V2DImode, r2)));
2950   DONE;
2951 })
2952
2953 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2954 ;;
2955 ;; Parallel single-precision floating point element swizzling
2956 ;;
2957 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2958
2959 (define_expand "sse_movhlps_exp"
2960   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
2961         (vec_select:V4SF
2962           (vec_concat:V8SF
2963             (match_operand:V4SF 1 "nonimmediate_operand" "")
2964             (match_operand:V4SF 2 "nonimmediate_operand" ""))
2965           (parallel [(const_int 6)
2966                      (const_int 7)
2967                      (const_int 2)
2968                      (const_int 3)])))]
2969   "TARGET_SSE"
2970   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
2971
2972 (define_insn "*avx_movhlps"
2973   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
2974         (vec_select:V4SF
2975           (vec_concat:V8SF
2976             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
2977             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
2978           (parallel [(const_int 6)
2979                      (const_int 7)
2980                      (const_int 2)
2981                      (const_int 3)])))]
2982   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
2983   "@
2984    vmovhlps\t{%2, %1, %0|%0, %1, %2}
2985    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
2986    vmovhps\t{%2, %0|%0, %2}"
2987   [(set_attr "type" "ssemov")
2988    (set_attr "prefix" "vex")
2989    (set_attr "mode" "V4SF,V2SF,V2SF")])
2990
2991 (define_insn "sse_movhlps"
2992   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
2993         (vec_select:V4SF
2994           (vec_concat:V8SF
2995             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
2996             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
2997           (parallel [(const_int 6)
2998                      (const_int 7)
2999                      (const_int 2)
3000                      (const_int 3)])))]
3001   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3002   "@
3003    movhlps\t{%2, %0|%0, %2}
3004    movlps\t{%H2, %0|%0, %H2}
3005    movhps\t{%2, %0|%0, %2}"
3006   [(set_attr "type" "ssemov")
3007    (set_attr "mode" "V4SF,V2SF,V2SF")])
3008
3009 (define_expand "sse_movlhps_exp"
3010   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3011         (vec_select:V4SF
3012           (vec_concat:V8SF
3013             (match_operand:V4SF 1 "nonimmediate_operand" "")
3014             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3015           (parallel [(const_int 0)
3016                      (const_int 1)
3017                      (const_int 4)
3018                      (const_int 5)])))]
3019   "TARGET_SSE"
3020   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3021
3022 (define_insn "*avx_movlhps"
3023   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3024         (vec_select:V4SF
3025           (vec_concat:V8SF
3026             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3027             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3028           (parallel [(const_int 0)
3029                      (const_int 1)
3030                      (const_int 4)
3031                      (const_int 5)])))]
3032   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3033   "@
3034    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3035    vmovhps\t{%2, %1, %0|%0, %1, %2}
3036    vmovlps\t{%2, %H0|%H0, %2}"
3037   [(set_attr "type" "ssemov")
3038    (set_attr "prefix" "vex")
3039    (set_attr "mode" "V4SF,V2SF,V2SF")])
3040
3041 (define_insn "sse_movlhps"
3042   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3043         (vec_select:V4SF
3044           (vec_concat:V8SF
3045             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3046             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3047           (parallel [(const_int 0)
3048                      (const_int 1)
3049                      (const_int 4)
3050                      (const_int 5)])))]
3051   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3052   "@
3053    movlhps\t{%2, %0|%0, %2}
3054    movhps\t{%2, %0|%0, %2}
3055    movlps\t{%2, %H0|%H0, %2}"
3056   [(set_attr "type" "ssemov")
3057    (set_attr "mode" "V4SF,V2SF,V2SF")])
3058
3059 (define_insn "avx_unpckhps256"
3060   [(set (match_operand:V8SF 0 "register_operand" "=x")
3061         (vec_select:V8SF
3062           (vec_concat:V16SF
3063             (match_operand:V8SF 1 "register_operand" "x")
3064             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3065           (parallel [(const_int 2) (const_int 10)
3066                      (const_int 3) (const_int 11)
3067                      (const_int 6) (const_int 14)
3068                      (const_int 7) (const_int 15)])))]
3069   "TARGET_AVX"
3070   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3071   [(set_attr "type" "sselog")
3072    (set_attr "prefix" "vex")
3073    (set_attr "mode" "V8SF")])
3074
3075 (define_insn "*avx_unpckhps"
3076   [(set (match_operand:V4SF 0 "register_operand" "=x")
3077         (vec_select:V4SF
3078           (vec_concat:V8SF
3079             (match_operand:V4SF 1 "register_operand" "x")
3080             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3081           (parallel [(const_int 2) (const_int 6)
3082                      (const_int 3) (const_int 7)])))]
3083   "TARGET_AVX"
3084   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3085   [(set_attr "type" "sselog")
3086    (set_attr "prefix" "vex")
3087    (set_attr "mode" "V4SF")])
3088
3089 (define_insn "sse_unpckhps"
3090   [(set (match_operand:V4SF 0 "register_operand" "=x")
3091         (vec_select:V4SF
3092           (vec_concat:V8SF
3093             (match_operand:V4SF 1 "register_operand" "0")
3094             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3095           (parallel [(const_int 2) (const_int 6)
3096                      (const_int 3) (const_int 7)])))]
3097   "TARGET_SSE"
3098   "unpckhps\t{%2, %0|%0, %2}"
3099   [(set_attr "type" "sselog")
3100    (set_attr "mode" "V4SF")])
3101
3102 (define_insn "avx_unpcklps256"
3103   [(set (match_operand:V8SF 0 "register_operand" "=x")
3104         (vec_select:V8SF
3105           (vec_concat:V16SF
3106             (match_operand:V8SF 1 "register_operand" "x")
3107             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3108           (parallel [(const_int 0) (const_int 8)
3109                      (const_int 1) (const_int 9)
3110                      (const_int 4) (const_int 12)
3111                      (const_int 5) (const_int 13)])))]
3112   "TARGET_AVX"
3113   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3114   [(set_attr "type" "sselog")
3115    (set_attr "prefix" "vex")
3116    (set_attr "mode" "V8SF")])
3117
3118 (define_insn "*avx_unpcklps"
3119   [(set (match_operand:V4SF 0 "register_operand" "=x")
3120         (vec_select:V4SF
3121           (vec_concat:V8SF
3122             (match_operand:V4SF 1 "register_operand" "x")
3123             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3124           (parallel [(const_int 0) (const_int 4)
3125                      (const_int 1) (const_int 5)])))]
3126   "TARGET_AVX"
3127   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3128   [(set_attr "type" "sselog")
3129    (set_attr "prefix" "vex")
3130    (set_attr "mode" "V4SF")])
3131
3132 (define_insn "sse_unpcklps"
3133   [(set (match_operand:V4SF 0 "register_operand" "=x")
3134         (vec_select:V4SF
3135           (vec_concat:V8SF
3136             (match_operand:V4SF 1 "register_operand" "0")
3137             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3138           (parallel [(const_int 0) (const_int 4)
3139                      (const_int 1) (const_int 5)])))]
3140   "TARGET_SSE"
3141   "unpcklps\t{%2, %0|%0, %2}"
3142   [(set_attr "type" "sselog")
3143    (set_attr "mode" "V4SF")])
3144
3145 ;; These are modeled with the same vec_concat as the others so that we
3146 ;; capture users of shufps that can use the new instructions
3147 (define_insn "avx_movshdup256"
3148   [(set (match_operand:V8SF 0 "register_operand" "=x")
3149         (vec_select:V8SF
3150           (vec_concat:V16SF
3151             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3152             (match_dup 1))
3153           (parallel [(const_int 1) (const_int 1)
3154                      (const_int 3) (const_int 3)
3155                      (const_int 5) (const_int 5)
3156                      (const_int 7) (const_int 7)])))]
3157   "TARGET_AVX"
3158   "vmovshdup\t{%1, %0|%0, %1}"
3159   [(set_attr "type" "sse")
3160    (set_attr "prefix" "vex")
3161    (set_attr "mode" "V8SF")])
3162
3163 (define_insn "sse3_movshdup"
3164   [(set (match_operand:V4SF 0 "register_operand" "=x")
3165         (vec_select:V4SF
3166           (vec_concat:V8SF
3167             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3168             (match_dup 1))
3169           (parallel [(const_int 1)
3170                      (const_int 1)
3171                      (const_int 7)
3172                      (const_int 7)])))]
3173   "TARGET_SSE3"
3174   "%vmovshdup\t{%1, %0|%0, %1}"
3175   [(set_attr "type" "sse")
3176    (set_attr "prefix_rep" "1")
3177    (set_attr "prefix" "maybe_vex")
3178    (set_attr "mode" "V4SF")])
3179
3180 (define_insn "avx_movsldup256"
3181   [(set (match_operand:V8SF 0 "register_operand" "=x")
3182         (vec_select:V8SF
3183           (vec_concat:V16SF
3184             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3185             (match_dup 1))
3186           (parallel [(const_int 0) (const_int 0)
3187                      (const_int 2) (const_int 2)
3188                      (const_int 4) (const_int 4)
3189                      (const_int 6) (const_int 6)])))]
3190   "TARGET_AVX"
3191   "vmovsldup\t{%1, %0|%0, %1}"
3192   [(set_attr "type" "sse")
3193    (set_attr "prefix" "vex")
3194    (set_attr "mode" "V8SF")])
3195
3196 (define_insn "sse3_movsldup"
3197   [(set (match_operand:V4SF 0 "register_operand" "=x")
3198         (vec_select:V4SF
3199           (vec_concat:V8SF
3200             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3201             (match_dup 1))
3202           (parallel [(const_int 0)
3203                      (const_int 0)
3204                      (const_int 6)
3205                      (const_int 6)])))]
3206   "TARGET_SSE3"
3207   "%vmovsldup\t{%1, %0|%0, %1}"
3208   [(set_attr "type" "sse")
3209    (set_attr "prefix_rep" "1")
3210    (set_attr "prefix" "maybe_vex")
3211    (set_attr "mode" "V4SF")])
3212
3213 (define_expand "avx_shufps256"
3214   [(match_operand:V8SF 0 "register_operand" "")
3215    (match_operand:V8SF 1 "register_operand" "")
3216    (match_operand:V8SF 2 "nonimmediate_operand" "")
3217    (match_operand:SI 3 "const_int_operand" "")]
3218   "TARGET_AVX"
3219 {
3220   int mask = INTVAL (operands[3]);
3221   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3222                                   GEN_INT ((mask >> 0) & 3),
3223                                   GEN_INT ((mask >> 2) & 3),
3224                                   GEN_INT (((mask >> 4) & 3) + 8),
3225                                   GEN_INT (((mask >> 6) & 3) + 8),
3226                                   GEN_INT (((mask >> 0) & 3) + 4),
3227                                   GEN_INT (((mask >> 2) & 3) + 4),
3228                                   GEN_INT (((mask >> 4) & 3) + 12),
3229                                   GEN_INT (((mask >> 6) & 3) + 12)));
3230   DONE;
3231 })
3232
3233 ;; One bit in mask selects 2 elements.
3234 (define_insn "avx_shufps256_1"
3235   [(set (match_operand:V8SF 0 "register_operand" "=x")
3236         (vec_select:V8SF
3237           (vec_concat:V16SF
3238             (match_operand:V8SF 1 "register_operand" "x")
3239             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3240           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3241                      (match_operand 4  "const_0_to_3_operand"   "")
3242                      (match_operand 5  "const_8_to_11_operand"  "")
3243                      (match_operand 6  "const_8_to_11_operand"  "")
3244                      (match_operand 7  "const_4_to_7_operand"   "")
3245                      (match_operand 8  "const_4_to_7_operand"   "")
3246                      (match_operand 9  "const_12_to_15_operand" "")
3247                      (match_operand 10 "const_12_to_15_operand" "")])))]
3248   "TARGET_AVX
3249    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3250        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3251        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3252        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3253 {
3254   int mask;
3255   mask = INTVAL (operands[3]);
3256   mask |= INTVAL (operands[4]) << 2;
3257   mask |= (INTVAL (operands[5]) - 8) << 4;
3258   mask |= (INTVAL (operands[6]) - 8) << 6;
3259   operands[3] = GEN_INT (mask);
3260
3261   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3262 }
3263   [(set_attr "type" "sselog")
3264    (set_attr "prefix" "vex")
3265    (set_attr "mode" "V8SF")])
3266
3267 (define_expand "sse_shufps"
3268   [(match_operand:V4SF 0 "register_operand" "")
3269    (match_operand:V4SF 1 "register_operand" "")
3270    (match_operand:V4SF 2 "nonimmediate_operand" "")
3271    (match_operand:SI 3 "const_int_operand" "")]
3272   "TARGET_SSE"
3273 {
3274   int mask = INTVAL (operands[3]);
3275   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3276                                GEN_INT ((mask >> 0) & 3),
3277                                GEN_INT ((mask >> 2) & 3),
3278                                GEN_INT (((mask >> 4) & 3) + 4),
3279                                GEN_INT (((mask >> 6) & 3) + 4)));
3280   DONE;
3281 })
3282
3283 (define_insn "*avx_shufps_<mode>"
3284   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3285         (vec_select:SSEMODE4S
3286           (vec_concat:<ssedoublesizemode>
3287             (match_operand:SSEMODE4S 1 "register_operand" "x")
3288             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3289           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3290                      (match_operand 4 "const_0_to_3_operand" "")
3291                      (match_operand 5 "const_4_to_7_operand" "")
3292                      (match_operand 6 "const_4_to_7_operand" "")])))]
3293   "TARGET_AVX"
3294 {
3295   int mask = 0;
3296   mask |= INTVAL (operands[3]) << 0;
3297   mask |= INTVAL (operands[4]) << 2;
3298   mask |= (INTVAL (operands[5]) - 4) << 4;
3299   mask |= (INTVAL (operands[6]) - 4) << 6;
3300   operands[3] = GEN_INT (mask);
3301
3302   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3303 }
3304   [(set_attr "type" "sselog")
3305    (set_attr "prefix" "vex")
3306    (set_attr "mode" "V4SF")])
3307
3308 (define_insn "sse_shufps_<mode>"
3309   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3310         (vec_select:SSEMODE4S
3311           (vec_concat:<ssedoublesizemode>
3312             (match_operand:SSEMODE4S 1 "register_operand" "0")
3313             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3314           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3315                      (match_operand 4 "const_0_to_3_operand" "")
3316                      (match_operand 5 "const_4_to_7_operand" "")
3317                      (match_operand 6 "const_4_to_7_operand" "")])))]
3318   "TARGET_SSE"
3319 {
3320   int mask = 0;
3321   mask |= INTVAL (operands[3]) << 0;
3322   mask |= INTVAL (operands[4]) << 2;
3323   mask |= (INTVAL (operands[5]) - 4) << 4;
3324   mask |= (INTVAL (operands[6]) - 4) << 6;
3325   operands[3] = GEN_INT (mask);
3326
3327   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3328 }
3329   [(set_attr "type" "sselog")
3330    (set_attr "mode" "V4SF")])
3331
3332 (define_insn "sse_storehps"
3333   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3334         (vec_select:V2SF
3335           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3336           (parallel [(const_int 2) (const_int 3)])))]
3337   "TARGET_SSE"
3338   "@
3339    %vmovhps\t{%1, %0|%0, %1}
3340    %vmovhlps\t{%1, %d0|%d0, %1}
3341    %vmovlps\t{%H1, %d0|%d0, %H1}"
3342   [(set_attr "type" "ssemov")
3343    (set_attr "prefix" "maybe_vex")
3344    (set_attr "mode" "V2SF,V4SF,V2SF")])
3345
3346 (define_expand "sse_loadhps_exp"
3347   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3348         (vec_concat:V4SF
3349           (vec_select:V2SF
3350             (match_operand:V4SF 1 "nonimmediate_operand" "")
3351             (parallel [(const_int 0) (const_int 1)]))
3352           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3353   "TARGET_SSE"
3354   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3355
3356 (define_insn "*avx_loadhps"
3357   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3358         (vec_concat:V4SF
3359           (vec_select:V2SF
3360             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3361             (parallel [(const_int 0) (const_int 1)]))
3362           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3363   "TARGET_AVX"
3364   "@
3365    vmovhps\t{%2, %1, %0|%0, %1, %2}
3366    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3367    vmovlps\t{%2, %H0|%H0, %2}"
3368   [(set_attr "type" "ssemov")
3369    (set_attr "prefix" "vex")
3370    (set_attr "mode" "V2SF,V4SF,V2SF")])
3371
3372 (define_insn "sse_loadhps"
3373   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3374         (vec_concat:V4SF
3375           (vec_select:V2SF
3376             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3377             (parallel [(const_int 0) (const_int 1)]))
3378           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3379   "TARGET_SSE"
3380   "@
3381    movhps\t{%2, %0|%0, %2}
3382    movlhps\t{%2, %0|%0, %2}
3383    movlps\t{%2, %H0|%H0, %2}"
3384   [(set_attr "type" "ssemov")
3385    (set_attr "mode" "V2SF,V4SF,V2SF")])
3386
3387 (define_insn "*avx_storelps"
3388   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3389         (vec_select:V2SF
3390           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3391           (parallel [(const_int 0) (const_int 1)])))]
3392   "TARGET_AVX"
3393   "@
3394    vmovlps\t{%1, %0|%0, %1}
3395    vmovaps\t{%1, %0|%0, %1}
3396    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3397   [(set_attr "type" "ssemov")
3398    (set_attr "prefix" "vex")
3399    (set_attr "mode" "V2SF,V2DF,V2SF")])
3400
3401 (define_insn "sse_storelps"
3402   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3403         (vec_select:V2SF
3404           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3405           (parallel [(const_int 0) (const_int 1)])))]
3406   "TARGET_SSE"
3407   "@
3408    movlps\t{%1, %0|%0, %1}
3409    movaps\t{%1, %0|%0, %1}
3410    movlps\t{%1, %0|%0, %1}"
3411   [(set_attr "type" "ssemov")
3412    (set_attr "mode" "V2SF,V4SF,V2SF")])
3413
3414 (define_expand "sse_loadlps_exp"
3415   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3416         (vec_concat:V4SF
3417           (match_operand:V2SF 2 "nonimmediate_operand" "")
3418           (vec_select:V2SF
3419             (match_operand:V4SF 1 "nonimmediate_operand" "")
3420             (parallel [(const_int 2) (const_int 3)]))))]
3421   "TARGET_SSE"
3422   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3423
3424 (define_insn "*avx_loadlps"
3425   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3426         (vec_concat:V4SF
3427           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3428           (vec_select:V2SF
3429             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3430             (parallel [(const_int 2) (const_int 3)]))))]
3431   "TARGET_AVX"
3432   "@
3433    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3434    vmovlps\t{%2, %1, %0|%0, %1, %2}
3435    vmovlps\t{%2, %0|%0, %2}"
3436   [(set_attr "type" "sselog,ssemov,ssemov")
3437    (set_attr "prefix" "vex")
3438    (set_attr "mode" "V4SF,V2SF,V2SF")])
3439
3440 (define_insn "sse_loadlps"
3441   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3442         (vec_concat:V4SF
3443           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3444           (vec_select:V2SF
3445             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3446             (parallel [(const_int 2) (const_int 3)]))))]
3447   "TARGET_SSE"
3448   "@
3449    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3450    movlps\t{%2, %0|%0, %2}
3451    movlps\t{%2, %0|%0, %2}"
3452   [(set_attr "type" "sselog,ssemov,ssemov")
3453    (set_attr "mode" "V4SF,V2SF,V2SF")])
3454
3455 (define_insn "*avx_movss"
3456   [(set (match_operand:V4SF 0 "register_operand" "=x")
3457         (vec_merge:V4SF
3458           (match_operand:V4SF 2 "register_operand" "x")
3459           (match_operand:V4SF 1 "register_operand" "x")
3460           (const_int 1)))]
3461   "TARGET_AVX"
3462   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3463   [(set_attr "type" "ssemov")
3464    (set_attr "prefix" "vex")
3465    (set_attr "mode" "SF")])
3466
3467 (define_insn "sse_movss"
3468   [(set (match_operand:V4SF 0 "register_operand" "=x")
3469         (vec_merge:V4SF
3470           (match_operand:V4SF 2 "register_operand" "x")
3471           (match_operand:V4SF 1 "register_operand" "0")
3472           (const_int 1)))]
3473   "TARGET_SSE"
3474   "movss\t{%2, %0|%0, %2}"
3475   [(set_attr "type" "ssemov")
3476    (set_attr "mode" "SF")])
3477
3478 (define_insn "*vec_dupv4sf_avx"
3479   [(set (match_operand:V4SF 0 "register_operand" "=x")
3480         (vec_duplicate:V4SF
3481           (match_operand:SF 1 "register_operand" "x")))]
3482   "TARGET_AVX"
3483   "vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}"
3484   [(set_attr "type" "sselog1")
3485    (set_attr "prefix" "vex")
3486    (set_attr "mode" "V4SF")])
3487
3488 (define_insn "*vec_dupv4sf"
3489   [(set (match_operand:V4SF 0 "register_operand" "=x")
3490         (vec_duplicate:V4SF
3491           (match_operand:SF 1 "register_operand" "0")))]
3492   "TARGET_SSE"
3493   "shufps\t{$0, %0, %0|%0, %0, 0}"
3494   [(set_attr "type" "sselog1")
3495    (set_attr "mode" "V4SF")])
3496
3497 (define_insn "*vec_concatv2sf_avx"
3498   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3499         (vec_concat:V2SF
3500           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3501           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3502   "TARGET_AVX"
3503   "@
3504    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3505    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3506    vmovss\t{%1, %0|%0, %1}
3507    punpckldq\t{%2, %0|%0, %2}
3508    movd\t{%1, %0|%0, %1}"
3509   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3510    (set (attr "prefix")
3511      (if_then_else (eq_attr "alternative" "3,4")
3512        (const_string "orig")
3513        (const_string "vex")))
3514    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3515
3516 ;; Although insertps takes register source, we prefer
3517 ;; unpcklps with register source since it is shorter.
3518 (define_insn "*vec_concatv2sf_sse4_1"
3519   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3520         (vec_concat:V2SF
3521           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3522           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3523   "TARGET_SSE4_1"
3524   "@
3525    unpcklps\t{%2, %0|%0, %2}
3526    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3527    movss\t{%1, %0|%0, %1}
3528    punpckldq\t{%2, %0|%0, %2}
3529    movd\t{%1, %0|%0, %1}"
3530   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3531    (set_attr "prefix_extra" "*,1,*,*,*")
3532    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3533
3534 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3535 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3536 ;; alternatives pretty much forces the MMX alternative to be chosen.
3537 (define_insn "*vec_concatv2sf_sse"
3538   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3539         (vec_concat:V2SF
3540           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3541           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3542   "TARGET_SSE"
3543   "@
3544    unpcklps\t{%2, %0|%0, %2}
3545    movss\t{%1, %0|%0, %1}
3546    punpckldq\t{%2, %0|%0, %2}
3547    movd\t{%1, %0|%0, %1}"
3548   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3549    (set_attr "mode" "V4SF,SF,DI,DI")])
3550
3551 (define_insn "*vec_concatv4sf_avx"
3552   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3553         (vec_concat:V4SF
3554           (match_operand:V2SF 1 "register_operand" " x,x")
3555           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3556   "TARGET_AVX"
3557   "@
3558    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3559    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3560   [(set_attr "type" "ssemov")
3561    (set_attr "prefix" "vex")
3562    (set_attr "mode" "V4SF,V2SF")])
3563
3564 (define_insn "*vec_concatv4sf_sse"
3565   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3566         (vec_concat:V4SF
3567           (match_operand:V2SF 1 "register_operand" " 0,0")
3568           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3569   "TARGET_SSE"
3570   "@
3571    movlhps\t{%2, %0|%0, %2}
3572    movhps\t{%2, %0|%0, %2}"
3573   [(set_attr "type" "ssemov")
3574    (set_attr "mode" "V4SF,V2SF")])
3575
3576 (define_expand "vec_init<mode>"
3577   [(match_operand:SSEMODE 0 "register_operand" "")
3578    (match_operand 1 "" "")]
3579   "TARGET_SSE"
3580 {
3581   ix86_expand_vector_init (false, operands[0], operands[1]);
3582   DONE;
3583 })
3584
3585 (define_insn "*vec_setv4sf_0_avx"
3586   [(set (match_operand:V4SF 0 "nonimmediate_operand"  "=x,x,x,m")
3587         (vec_merge:V4SF
3588           (vec_duplicate:V4SF
3589             (match_operand:SF 2 "general_operand"     " x,m,*r,x*rfF"))
3590           (match_operand:V4SF 1 "vector_move_operand" " x,C,C ,0")
3591           (const_int 1)))]
3592   "TARGET_AVX"
3593   "@
3594    vmovss\t{%2, %1, %0|%0, %1, %2}
3595    vmovss\t{%2, %0|%0, %2}
3596    vmovd\t{%2, %0|%0, %2}
3597    #"
3598   [(set_attr "type" "ssemov")
3599    (set_attr "prefix" "vex")
3600    (set_attr "mode" "SF")])
3601
3602 (define_insn "vec_setv4sf_0"
3603   [(set (match_operand:V4SF 0 "nonimmediate_operand"  "=x,x,Y2,m")
3604         (vec_merge:V4SF
3605           (vec_duplicate:V4SF
3606             (match_operand:SF 2 "general_operand"     " x,m,*r,x*rfF"))
3607           (match_operand:V4SF 1 "vector_move_operand" " 0,C,C ,0")
3608           (const_int 1)))]
3609   "TARGET_SSE"
3610   "@
3611    movss\t{%2, %0|%0, %2}
3612    movss\t{%2, %0|%0, %2}
3613    movd\t{%2, %0|%0, %2}
3614    #"
3615   [(set_attr "type" "ssemov")
3616    (set_attr "mode" "SF")])
3617
3618 ;; A subset is vec_setv4sf.
3619 (define_insn "*vec_setv4sf_avx"
3620   [(set (match_operand:V4SF 0 "register_operand" "=x")
3621         (vec_merge:V4SF
3622           (vec_duplicate:V4SF
3623             (match_operand:SF 2 "nonimmediate_operand" "xm"))
3624           (match_operand:V4SF 1 "register_operand" "x")
3625           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
3626   "TARGET_AVX"
3627 {
3628   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
3629   return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3630 }
3631   [(set_attr "type" "sselog")
3632    (set_attr "prefix" "vex")
3633    (set_attr "mode" "V4SF")])
3634
3635 (define_insn "*vec_setv4sf_sse4_1"
3636   [(set (match_operand:V4SF 0 "register_operand" "=x")
3637         (vec_merge:V4SF
3638           (vec_duplicate:V4SF
3639             (match_operand:SF 2 "nonimmediate_operand" "xm"))
3640           (match_operand:V4SF 1 "register_operand" "0")
3641           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
3642   "TARGET_SSE4_1"
3643 {
3644   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
3645   return "insertps\t{%3, %2, %0|%0, %2, %3}";
3646 }
3647   [(set_attr "type" "sselog")
3648    (set_attr "prefix_extra" "1")
3649    (set_attr "mode" "V4SF")])
3650
3651 (define_insn "*avx_insertps"
3652   [(set (match_operand:V4SF 0 "register_operand" "=x")
3653         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
3654                       (match_operand:V4SF 1 "register_operand" "x")
3655                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
3656                      UNSPEC_INSERTPS))]
3657   "TARGET_AVX"
3658   "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3659   [(set_attr "type" "sselog")
3660    (set_attr "prefix" "vex")
3661    (set_attr "mode" "V4SF")])
3662
3663 (define_insn "sse4_1_insertps"
3664   [(set (match_operand:V4SF 0 "register_operand" "=x")
3665         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
3666                       (match_operand:V4SF 1 "register_operand" "0")
3667                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
3668                      UNSPEC_INSERTPS))]
3669   "TARGET_SSE4_1"
3670   "insertps\t{%3, %2, %0|%0, %2, %3}";
3671   [(set_attr "type" "sselog")
3672    (set_attr "prefix_extra" "1")
3673    (set_attr "mode" "V4SF")])
3674
3675 (define_split
3676   [(set (match_operand:V4SF 0 "memory_operand" "")
3677         (vec_merge:V4SF
3678           (vec_duplicate:V4SF
3679             (match_operand:SF 1 "nonmemory_operand" ""))
3680           (match_dup 0)
3681           (const_int 1)))]
3682   "TARGET_SSE && reload_completed"
3683   [(const_int 0)]
3684 {
3685   emit_move_insn (adjust_address (operands[0], SFmode, 0), operands[1]);
3686   DONE;
3687 })
3688
3689 (define_expand "vec_set<mode>"
3690   [(match_operand:SSEMODE 0 "register_operand" "")
3691    (match_operand:<ssescalarmode> 1 "register_operand" "")
3692    (match_operand 2 "const_int_operand" "")]
3693   "TARGET_SSE"
3694 {
3695   ix86_expand_vector_set (false, operands[0], operands[1],
3696                           INTVAL (operands[2]));
3697   DONE;
3698 })
3699
3700 (define_insn_and_split "*vec_extractv4sf_0"
3701   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
3702         (vec_select:SF
3703           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
3704           (parallel [(const_int 0)])))]
3705   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3706   "#"
3707   "&& reload_completed"
3708   [(const_int 0)]
3709 {
3710   rtx op1 = operands[1];
3711   if (REG_P (op1))
3712     op1 = gen_rtx_REG (SFmode, REGNO (op1));
3713   else
3714     op1 = gen_lowpart (SFmode, op1);
3715   emit_move_insn (operands[0], op1);
3716   DONE;
3717 })
3718
3719 (define_expand "avx_vextractf128<mode>"
3720   [(match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "")
3721    (match_operand:AVX256MODE 1 "register_operand" "")
3722    (match_operand:SI 2 "const_0_to_1_operand" "")]
3723   "TARGET_AVX"
3724 {
3725   switch (INTVAL (operands[2]))
3726     {
3727     case 0:
3728       emit_insn (gen_vec_extract_lo_<mode> (operands[0], operands[1]));
3729       break;
3730     case 1:
3731       emit_insn (gen_vec_extract_hi_<mode> (operands[0], operands[1]));
3732       break;
3733     default:
3734       gcc_unreachable ();
3735     }
3736   DONE;
3737 })
3738
3739 (define_insn "vec_extract_lo_<mode>"
3740   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3741         (vec_select:<avxhalfvecmode>
3742           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
3743           (parallel [(const_int 0) (const_int 1)])))]
3744   "TARGET_AVX"
3745   "vextractf128\t{$0x0, %1, %0|%0, %1, 0x0}"
3746   [(set_attr "type" "sselog")
3747    (set_attr "memory" "none,store")
3748    (set_attr "prefix" "vex")
3749    (set_attr "mode" "V8SF")])
3750
3751 (define_insn "vec_extract_hi_<mode>"
3752   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3753         (vec_select:<avxhalfvecmode>
3754           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
3755           (parallel [(const_int 2) (const_int 3)])))]
3756   "TARGET_AVX"
3757   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3758   [(set_attr "type" "sselog")
3759    (set_attr "memory" "none,store")
3760    (set_attr "prefix" "vex")
3761    (set_attr "mode" "V8SF")])
3762
3763 (define_insn "vec_extract_lo_<mode>"
3764   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3765         (vec_select:<avxhalfvecmode>
3766           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
3767           (parallel [(const_int 0) (const_int 1)
3768                      (const_int 2) (const_int 3)])))]
3769   "TARGET_AVX"
3770   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3771   [(set_attr "type" "sselog")
3772    (set_attr "memory" "none,store")
3773    (set_attr "prefix" "vex")
3774    (set_attr "mode" "V8SF")])
3775
3776 (define_insn "vec_extract_hi_<mode>"
3777   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3778         (vec_select:<avxhalfvecmode>
3779           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
3780           (parallel [(const_int 4) (const_int 5)
3781                      (const_int 6) (const_int 7)])))]
3782   "TARGET_AVX"
3783   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3784   [(set_attr "type" "sselog")
3785    (set_attr "memory" "none,store")
3786    (set_attr "prefix" "vex")
3787    (set_attr "mode" "V8SF")])
3788
3789 (define_insn "vec_extract_lo_v16hi"
3790   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
3791         (vec_select:V8HI
3792           (match_operand:V16HI 1 "register_operand" "x,x")
3793           (parallel [(const_int 0) (const_int 1)
3794                      (const_int 2) (const_int 3)
3795                      (const_int 4) (const_int 5)
3796                      (const_int 6) (const_int 7)])))]
3797   "TARGET_AVX"
3798   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3799   [(set_attr "type" "sselog")
3800    (set_attr "memory" "none,store")
3801    (set_attr "prefix" "vex")
3802    (set_attr "mode" "V8SF")])
3803
3804 (define_insn "vec_extract_hi_v16hi"
3805   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
3806         (vec_select:V8HI
3807           (match_operand:V16HI 1 "register_operand" "x,x")
3808           (parallel [(const_int 8) (const_int 9)
3809                      (const_int 10) (const_int 11)
3810                      (const_int 12) (const_int 13)
3811                      (const_int 14) (const_int 15)])))]
3812   "TARGET_AVX"
3813   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3814   [(set_attr "type" "sselog")
3815    (set_attr "memory" "none,store")
3816    (set_attr "prefix" "vex")
3817    (set_attr "mode" "V8SF")])
3818
3819 (define_insn "vec_extract_lo_v32qi"
3820   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
3821         (vec_select:V16QI
3822           (match_operand:V32QI 1 "register_operand" "x,x")
3823           (parallel [(const_int 0) (const_int 1)
3824                      (const_int 2) (const_int 3)
3825                      (const_int 4) (const_int 5)
3826                      (const_int 6) (const_int 7)
3827                      (const_int 8) (const_int 9)
3828                      (const_int 10) (const_int 11)
3829                      (const_int 12) (const_int 13)
3830                      (const_int 14) (const_int 15)])))]
3831   "TARGET_AVX"
3832   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3833   [(set_attr "type" "sselog")
3834    (set_attr "memory" "none,store")
3835    (set_attr "prefix" "vex")
3836    (set_attr "mode" "V8SF")])
3837
3838 (define_insn "vec_extract_hi_v32qi"
3839   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
3840         (vec_select:V16QI
3841           (match_operand:V32QI 1 "register_operand" "x,x")
3842           (parallel [(const_int 16) (const_int 17)
3843                      (const_int 18) (const_int 19)
3844                      (const_int 20) (const_int 21)
3845                      (const_int 22) (const_int 23)
3846                      (const_int 24) (const_int 25)
3847                      (const_int 26) (const_int 27)
3848                      (const_int 28) (const_int 29)
3849                      (const_int 30) (const_int 31)])))]
3850   "TARGET_AVX"
3851   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3852   [(set_attr "type" "sselog")
3853    (set_attr "memory" "none,store")
3854    (set_attr "prefix" "vex")
3855    (set_attr "mode" "V8SF")])
3856
3857 (define_insn "*sse4_1_extractps"
3858   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
3859         (vec_select:SF
3860           (match_operand:V4SF 1 "register_operand" "x")
3861           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
3862   "TARGET_SSE4_1"
3863   "%vextractps\t{%2, %1, %0|%0, %1, %2}"
3864   [(set_attr "type" "sselog")
3865    (set_attr "prefix_extra" "1")
3866    (set_attr "prefix" "maybe_vex")
3867    (set_attr "mode" "V4SF")])
3868
3869 (define_insn_and_split "*vec_extract_v4sf_mem"
3870   [(set (match_operand:SF 0 "register_operand" "=x*rf")
3871        (vec_select:SF
3872          (match_operand:V4SF 1 "memory_operand" "o")
3873          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
3874   ""
3875   "#"
3876   "reload_completed"
3877   [(const_int 0)]
3878 {
3879   int i = INTVAL (operands[2]);
3880
3881   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
3882   DONE;
3883 })
3884
3885 (define_expand "vec_extract<mode>"
3886   [(match_operand:<ssescalarmode> 0 "register_operand" "")
3887    (match_operand:SSEMODE 1 "register_operand" "")
3888    (match_operand 2 "const_int_operand" "")]
3889   "TARGET_SSE"
3890 {
3891   ix86_expand_vector_extract (false, operands[0], operands[1],
3892                               INTVAL (operands[2]));
3893   DONE;
3894 })
3895
3896 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3897 ;;
3898 ;; Parallel double-precision floating point element swizzling
3899 ;;
3900 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3901
3902 (define_insn "avx_unpckhpd256"
3903   [(set (match_operand:V4DF 0 "register_operand" "=x")
3904         (vec_select:V4DF
3905           (vec_concat:V8DF
3906             (match_operand:V4DF 1 "register_operand" "x")
3907             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
3908           (parallel [(const_int 1) (const_int 5)
3909                      (const_int 3) (const_int 7)])))]
3910   "TARGET_AVX"
3911   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
3912   [(set_attr "type" "sselog")
3913    (set_attr "prefix" "vex")
3914    (set_attr "mode" "V4DF")])
3915
3916 (define_expand "sse2_unpckhpd_exp"
3917   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
3918         (vec_select:V2DF
3919           (vec_concat:V4DF
3920             (match_operand:V2DF 1 "nonimmediate_operand" "")
3921             (match_operand:V2DF 2 "nonimmediate_operand" ""))
3922           (parallel [(const_int 1)
3923                      (const_int 3)])))]
3924   "TARGET_SSE2"
3925   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
3926
3927 (define_insn "*avx_unpckhpd"
3928   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
3929         (vec_select:V2DF
3930           (vec_concat:V4DF
3931             (match_operand:V2DF 1 "nonimmediate_operand" " x,o,x")
3932             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,0"))
3933           (parallel [(const_int 1)
3934                      (const_int 3)])))]
3935   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3936   "@
3937    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
3938    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
3939    vmovhpd\t{%1, %0|%0, %1}"
3940   [(set_attr "type" "sselog,ssemov,ssemov")
3941    (set_attr "prefix" "vex")
3942    (set_attr "mode" "V2DF,V1DF,V1DF")])
3943
3944 (define_insn "sse2_unpckhpd"
3945   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
3946         (vec_select:V2DF
3947           (vec_concat:V4DF
3948             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
3949             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
3950           (parallel [(const_int 1)
3951                      (const_int 3)])))]
3952   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3953   "@
3954    unpckhpd\t{%2, %0|%0, %2}
3955    movlpd\t{%H1, %0|%0, %H1}
3956    movhpd\t{%1, %0|%0, %1}"
3957   [(set_attr "type" "sselog,ssemov,ssemov")
3958    (set_attr "mode" "V2DF,V1DF,V1DF")])
3959
3960 (define_insn "avx_movddup256"
3961   [(set (match_operand:V4DF 0 "register_operand" "=x")
3962         (vec_select:V4DF
3963           (vec_concat:V8DF
3964             (match_operand:V4DF 1 "nonimmediate_operand" "xm")
3965             (match_dup 1))
3966           (parallel [(const_int 0) (const_int 2)
3967                      (const_int 4) (const_int 6)])))]
3968   "TARGET_AVX"
3969   "vmovddup\t{%1, %0|%0, %1}"
3970   [(set_attr "type" "sselog1")
3971    (set_attr "prefix" "vex")
3972    (set_attr "mode" "V4DF")])
3973
3974 (define_insn "*avx_movddup"
3975   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,o")
3976         (vec_select:V2DF
3977           (vec_concat:V4DF
3978             (match_operand:V2DF 1 "nonimmediate_operand" "xm,x")
3979             (match_dup 1))
3980           (parallel [(const_int 0)
3981                      (const_int 2)])))]
3982   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3983   "@
3984    vmovddup\t{%1, %0|%0, %1}
3985    #"
3986   [(set_attr "type" "sselog1,ssemov")
3987    (set_attr "prefix" "vex")
3988    (set_attr "mode" "V2DF")])
3989
3990 (define_insn "*sse3_movddup"
3991   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,o")
3992         (vec_select:V2DF
3993           (vec_concat:V4DF
3994             (match_operand:V2DF 1 "nonimmediate_operand" "xm,x")
3995             (match_dup 1))
3996           (parallel [(const_int 0)
3997                      (const_int 2)])))]
3998   "TARGET_SSE3 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3999   "@
4000    movddup\t{%1, %0|%0, %1}
4001    #"
4002   [(set_attr "type" "sselog1,ssemov")
4003    (set_attr "mode" "V2DF")])
4004
4005 (define_split
4006   [(set (match_operand:V2DF 0 "memory_operand" "")
4007         (vec_select:V2DF
4008           (vec_concat:V4DF
4009             (match_operand:V2DF 1 "register_operand" "")
4010             (match_dup 1))
4011           (parallel [(const_int 0)
4012                      (const_int 2)])))]
4013   "TARGET_SSE3 && reload_completed"
4014   [(const_int 0)]
4015 {
4016   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4017   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4018   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4019   DONE;
4020 })
4021
4022 (define_insn "avx_unpcklpd256"
4023   [(set (match_operand:V4DF 0 "register_operand" "=x")
4024         (vec_select:V4DF
4025           (vec_concat:V8DF
4026             (match_operand:V4DF 1 "register_operand" "x")
4027             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4028           (parallel [(const_int 0) (const_int 4)
4029                      (const_int 2) (const_int 6)])))]
4030   "TARGET_AVX"
4031   "vunpcklpd\t{%2, %1, %0|%0, %1, %2}"
4032   [(set_attr "type" "sselog")
4033    (set_attr "prefix" "vex")
4034    (set_attr "mode" "V4DF")])
4035
4036 (define_expand "sse2_unpcklpd_exp"
4037   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4038         (vec_select:V2DF
4039           (vec_concat:V4DF
4040             (match_operand:V2DF 1 "nonimmediate_operand" "")
4041             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4042           (parallel [(const_int 0)
4043                      (const_int 2)])))]
4044   "TARGET_SSE2"
4045   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4046
4047 (define_insn "*avx_unpcklpd"
4048   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4049         (vec_select:V2DF
4050           (vec_concat:V4DF
4051             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0")
4052             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4053           (parallel [(const_int 0)
4054                      (const_int 2)])))]
4055   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4056   "@
4057    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4058    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4059    vmovlpd\t{%2, %H0|%H0, %2}"
4060   [(set_attr "type" "sselog,ssemov,ssemov")
4061    (set_attr "prefix" "vex")
4062    (set_attr "mode" "V2DF,V1DF,V1DF")])
4063
4064 (define_insn "sse2_unpcklpd"
4065   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4066         (vec_select:V2DF
4067           (vec_concat:V4DF
4068             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
4069             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4070           (parallel [(const_int 0)
4071                      (const_int 2)])))]
4072   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4073   "@
4074    unpcklpd\t{%2, %0|%0, %2}
4075    movhpd\t{%2, %0|%0, %2}
4076    movlpd\t{%2, %H0|%H0, %2}"
4077   [(set_attr "type" "sselog,ssemov,ssemov")
4078    (set_attr "mode" "V2DF,V1DF,V1DF")])
4079
4080 (define_expand "avx_shufpd256"
4081   [(match_operand:V4DF 0 "register_operand" "")
4082    (match_operand:V4DF 1 "register_operand" "")
4083    (match_operand:V4DF 2 "nonimmediate_operand" "")
4084    (match_operand:SI 3 "const_int_operand" "")]
4085   "TARGET_AVX"
4086 {
4087   int mask = INTVAL (operands[3]);
4088   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4089                                    GEN_INT (mask & 1),
4090                                    GEN_INT (mask & 2 ? 5 : 4),
4091                                    GEN_INT (mask & 4 ? 3 : 2),
4092                                    GEN_INT (mask & 8 ? 7 : 6)));
4093   DONE;
4094 })
4095
4096 (define_insn "avx_shufpd256_1"
4097   [(set (match_operand:V4DF 0 "register_operand" "=x")
4098         (vec_select:V4DF
4099           (vec_concat:V8DF
4100             (match_operand:V4DF 1 "register_operand" "x")
4101             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4102           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4103                      (match_operand 4 "const_4_to_5_operand" "")
4104                      (match_operand 5 "const_2_to_3_operand" "")
4105                      (match_operand 6 "const_6_to_7_operand" "")])))]
4106   "TARGET_AVX"
4107 {
4108   int mask;
4109   mask = INTVAL (operands[3]);
4110   mask |= (INTVAL (operands[4]) - 4) << 1;
4111   mask |= (INTVAL (operands[5]) - 2) << 2;
4112   mask |= (INTVAL (operands[6]) - 6) << 3;
4113   operands[3] = GEN_INT (mask);
4114
4115   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4116 }
4117   [(set_attr "type" "sselog")
4118    (set_attr "prefix" "vex")
4119    (set_attr "mode" "V4DF")])
4120
4121 (define_expand "sse2_shufpd"
4122   [(match_operand:V2DF 0 "register_operand" "")
4123    (match_operand:V2DF 1 "register_operand" "")
4124    (match_operand:V2DF 2 "nonimmediate_operand" "")
4125    (match_operand:SI 3 "const_int_operand" "")]
4126   "TARGET_SSE2"
4127 {
4128   int mask = INTVAL (operands[3]);
4129   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4130                                 GEN_INT (mask & 1),
4131                                 GEN_INT (mask & 2 ? 3 : 2)));
4132   DONE;
4133 })
4134
4135 (define_expand "vec_extract_even<mode>"
4136   [(set (match_operand:SSEMODE4S 0 "register_operand" "")
4137         (vec_select:SSEMODE4S
4138           (vec_concat:<ssedoublesizemode>
4139             (match_operand:SSEMODE4S 1 "register_operand" "")
4140             (match_operand:SSEMODE4S 2 "nonimmediate_operand" ""))
4141           (parallel [(const_int 0)
4142                      (const_int 2)
4143                      (const_int 4)
4144                      (const_int 6)])))]
4145   "TARGET_SSE")
4146
4147 (define_expand "vec_extract_odd<mode>"
4148   [(set (match_operand:SSEMODE4S 0 "register_operand" "")
4149         (vec_select:SSEMODE4S
4150           (vec_concat:<ssedoublesizemode>
4151             (match_operand:SSEMODE4S 1 "register_operand" "")
4152             (match_operand:SSEMODE4S 2 "nonimmediate_operand" ""))
4153           (parallel [(const_int 1)
4154                      (const_int 3)
4155                      (const_int 5)
4156                      (const_int 7)])))]
4157   "TARGET_SSE")
4158
4159 (define_expand "vec_extract_even<mode>"
4160   [(set (match_operand:SSEMODE2D 0 "register_operand" "")
4161         (vec_select:SSEMODE2D
4162           (vec_concat:<ssedoublesizemode>
4163             (match_operand:SSEMODE2D 1 "register_operand" "")
4164             (match_operand:SSEMODE2D 2 "nonimmediate_operand" ""))
4165           (parallel [(const_int 0)
4166                      (const_int 2)])))]
4167   "TARGET_SSE2")
4168
4169 (define_expand "vec_extract_odd<mode>"
4170   [(set (match_operand:SSEMODE2D 0 "register_operand" "")
4171         (vec_select:SSEMODE2D
4172           (vec_concat:<ssedoublesizemode>
4173             (match_operand:SSEMODE2D 1 "register_operand" "")
4174             (match_operand:SSEMODE2D 2 "nonimmediate_operand" ""))
4175           (parallel [(const_int 1)
4176                      (const_int 3)])))]
4177   "TARGET_SSE2")
4178
4179 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4180 (define_insn "*avx_punpckhqdq"
4181   [(set (match_operand:V2DI 0 "register_operand" "=x")
4182         (vec_select:V2DI
4183           (vec_concat:V4DI
4184             (match_operand:V2DI 1 "register_operand" "x")
4185             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4186           (parallel [(const_int 1)
4187                      (const_int 3)])))]
4188   "TARGET_AVX"
4189   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4190   [(set_attr "type" "sselog")
4191    (set_attr "prefix" "vex")
4192    (set_attr "mode" "TI")])
4193
4194 (define_insn "sse2_punpckhqdq"
4195   [(set (match_operand:V2DI 0 "register_operand" "=x")
4196         (vec_select:V2DI
4197           (vec_concat:V4DI
4198             (match_operand:V2DI 1 "register_operand" "0")
4199             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4200           (parallel [(const_int 1)
4201                      (const_int 3)])))]
4202   "TARGET_SSE2"
4203   "punpckhqdq\t{%2, %0|%0, %2}"
4204   [(set_attr "type" "sselog")
4205    (set_attr "prefix_data16" "1")
4206    (set_attr "mode" "TI")])
4207
4208 (define_insn "*avx_punpcklqdq"
4209   [(set (match_operand:V2DI 0 "register_operand" "=x")
4210         (vec_select:V2DI
4211           (vec_concat:V4DI
4212             (match_operand:V2DI 1 "register_operand" "x")
4213             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4214           (parallel [(const_int 0)
4215                      (const_int 2)])))]
4216   "TARGET_AVX"
4217   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4218   [(set_attr "type" "sselog")
4219    (set_attr "prefix" "vex")
4220    (set_attr "mode" "TI")])
4221
4222 (define_insn "sse2_punpcklqdq"
4223   [(set (match_operand:V2DI 0 "register_operand" "=x")
4224         (vec_select:V2DI
4225           (vec_concat:V4DI
4226             (match_operand:V2DI 1 "register_operand" "0")
4227             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4228           (parallel [(const_int 0)
4229                      (const_int 2)])))]
4230   "TARGET_SSE2"
4231   "punpcklqdq\t{%2, %0|%0, %2}"
4232   [(set_attr "type" "sselog")
4233    (set_attr "prefix_data16" "1")
4234    (set_attr "mode" "TI")])
4235
4236 (define_insn "*avx_shufpd_<mode>"
4237   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4238         (vec_select:SSEMODE2D
4239           (vec_concat:<ssedoublesizemode>
4240             (match_operand:SSEMODE2D 1 "register_operand" "x")
4241             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4242           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4243                      (match_operand 4 "const_2_to_3_operand" "")])))]
4244   "TARGET_AVX"
4245 {
4246   int mask;
4247   mask = INTVAL (operands[3]);
4248   mask |= (INTVAL (operands[4]) - 2) << 1;
4249   operands[3] = GEN_INT (mask);
4250
4251   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4252 }
4253   [(set_attr "type" "sselog")
4254    (set_attr "prefix" "vex")
4255    (set_attr "mode" "V2DF")])
4256
4257 (define_insn "sse2_shufpd_<mode>"
4258   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4259         (vec_select:SSEMODE2D
4260           (vec_concat:<ssedoublesizemode>
4261             (match_operand:SSEMODE2D 1 "register_operand" "0")
4262             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4263           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4264                      (match_operand 4 "const_2_to_3_operand" "")])))]
4265   "TARGET_SSE2"
4266 {
4267   int mask;
4268   mask = INTVAL (operands[3]);
4269   mask |= (INTVAL (operands[4]) - 2) << 1;
4270   operands[3] = GEN_INT (mask);
4271
4272   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4273 }
4274   [(set_attr "type" "sselog")
4275    (set_attr "mode" "V2DF")])
4276
4277 ;; Avoid combining registers from different units in a single alternative,
4278 ;; see comment above inline_secondary_memory_needed function in i386.c
4279 (define_insn "*avx_storehpd"
4280   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4281         (vec_select:DF
4282           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,o,o,o")
4283           (parallel [(const_int 1)])))]
4284   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4285   "@
4286    vmovhpd\t{%1, %0|%0, %1}
4287    vunpckhpd\t{%1, %1, %0|%0, %1, %1}
4288    #
4289    #
4290    #"
4291   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4292    (set_attr "prefix" "vex")
4293    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4294
4295 (define_insn "sse2_storehpd"
4296   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4297         (vec_select:DF
4298           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o,o,o")
4299           (parallel [(const_int 1)])))]
4300   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4301   "@
4302    movhpd\t{%1, %0|%0, %1}
4303    unpckhpd\t%0, %0
4304    #
4305    #
4306    #"
4307   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4308    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4309
4310 (define_split
4311   [(set (match_operand:DF 0 "register_operand" "")
4312         (vec_select:DF
4313           (match_operand:V2DF 1 "memory_operand" "")
4314           (parallel [(const_int 1)])))]
4315   "TARGET_SSE2 && reload_completed"
4316   [(set (match_dup 0) (match_dup 1))]
4317 {
4318   operands[1] = adjust_address (operands[1], DFmode, 8);
4319 })
4320
4321 ;; Avoid combining registers from different units in a single alternative,
4322 ;; see comment above inline_secondary_memory_needed function in i386.c
4323 (define_insn "sse2_storelpd"
4324   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4325         (vec_select:DF
4326           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4327           (parallel [(const_int 0)])))]
4328   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4329   "@
4330    %vmovlpd\t{%1, %0|%0, %1}
4331    #
4332    #
4333    #
4334    #"
4335   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4336    (set_attr "prefix" "maybe_vex")
4337    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4338
4339 (define_split
4340   [(set (match_operand:DF 0 "register_operand" "")
4341         (vec_select:DF
4342           (match_operand:V2DF 1 "nonimmediate_operand" "")
4343           (parallel [(const_int 0)])))]
4344   "TARGET_SSE2 && reload_completed"
4345   [(const_int 0)]
4346 {
4347   rtx op1 = operands[1];
4348   if (REG_P (op1))
4349     op1 = gen_rtx_REG (DFmode, REGNO (op1));
4350   else
4351     op1 = gen_lowpart (DFmode, op1);
4352   emit_move_insn (operands[0], op1);
4353   DONE;
4354 })
4355
4356 (define_expand "sse2_loadhpd_exp"
4357   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4358         (vec_concat:V2DF
4359           (vec_select:DF
4360             (match_operand:V2DF 1 "nonimmediate_operand" "")
4361             (parallel [(const_int 0)]))
4362           (match_operand:DF 2 "nonimmediate_operand" "")))]
4363   "TARGET_SSE2"
4364   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4365
4366 ;; Avoid combining registers from different units in a single alternative,
4367 ;; see comment above inline_secondary_memory_needed function in i386.c
4368 (define_insn "*avx_loadhpd"
4369   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o,o,o")
4370         (vec_concat:V2DF
4371           (vec_select:DF
4372             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,0,0")
4373             (parallel [(const_int 0)]))
4374           (match_operand:DF 2 "nonimmediate_operand"     " m,x,x,*f,r")))]
4375   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4376   "@
4377    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4378    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4379    #
4380    #
4381    #"
4382   [(set_attr "type" "ssemov,sselog,ssemov,fmov,imov")
4383    (set_attr "prefix" "vex")
4384    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4385
4386 (define_insn "sse2_loadhpd"
4387   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
4388         (vec_concat:V2DF
4389           (vec_select:DF
4390             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0,0,0")
4391             (parallel [(const_int 0)]))
4392           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x,*f,r")))]
4393   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4394   "@
4395    movhpd\t{%2, %0|%0, %2}
4396    unpcklpd\t{%2, %0|%0, %2}
4397    shufpd\t{$1, %1, %0|%0, %1, 1}
4398    #
4399    #
4400    #"
4401   [(set_attr "type" "ssemov,sselog,sselog,ssemov,fmov,imov")
4402    (set_attr "mode" "V1DF,V2DF,V2DF,DF,DF,DF")])
4403
4404 (define_split
4405   [(set (match_operand:V2DF 0 "memory_operand" "")
4406         (vec_concat:V2DF
4407           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
4408           (match_operand:DF 1 "register_operand" "")))]
4409   "TARGET_SSE2 && reload_completed"
4410   [(set (match_dup 0) (match_dup 1))]
4411 {
4412   operands[0] = adjust_address (operands[0], DFmode, 8);
4413 })
4414
4415 (define_expand "sse2_loadlpd_exp"
4416   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4417         (vec_concat:V2DF
4418           (match_operand:DF 2 "nonimmediate_operand" "")
4419           (vec_select:DF
4420             (match_operand:V2DF 1 "nonimmediate_operand" "")
4421             (parallel [(const_int 1)]))))]
4422   "TARGET_SSE2"
4423   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4424
4425 ;; Avoid combining registers from different units in a single alternative,
4426 ;; see comment above inline_secondary_memory_needed function in i386.c
4427 (define_insn "*avx_loadlpd"
4428   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,m,m,m")
4429         (vec_concat:V2DF
4430           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,x,x,*f,r")
4431           (vec_select:DF
4432             (match_operand:V2DF 1 "vector_move_operand" " C,x,x,o,0,0,0")
4433             (parallel [(const_int 1)]))))]
4434   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4435   "@
4436    vmovsd\t{%2, %0|%0, %2}
4437    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4438    vmovsd\t{%2, %1, %0|%0, %1, %2}
4439    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
4440    #
4441    #
4442    #"
4443   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov,fmov,imov")
4444    (set_attr "prefix" "vex")
4445    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
4446
4447 (define_insn "sse2_loadlpd"
4448   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
4449         (vec_concat:V2DF
4450           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x,*f,r")
4451           (vec_select:DF
4452             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0,0,0")
4453             (parallel [(const_int 1)]))))]
4454   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4455   "@
4456    movsd\t{%2, %0|%0, %2}
4457    movlpd\t{%2, %0|%0, %2}
4458    movsd\t{%2, %0|%0, %2}
4459    shufpd\t{$2, %2, %0|%0, %2, 2}
4460    movhpd\t{%H1, %0|%0, %H1}
4461    #
4462    #
4463    #"
4464   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,fmov,imov")
4465    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF,DF,DF")])
4466
4467 (define_split
4468   [(set (match_operand:V2DF 0 "memory_operand" "")
4469         (vec_concat:V2DF
4470           (match_operand:DF 1 "register_operand" "")
4471           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
4472   "TARGET_SSE2 && reload_completed"
4473   [(set (match_dup 0) (match_dup 1))]
4474 {
4475   operands[0] = adjust_address (operands[0], DFmode, 8);
4476 })
4477
4478 ;; Not sure these two are ever used, but it doesn't hurt to have
4479 ;; them. -aoliva
4480 (define_insn "*vec_extractv2df_1_sse"
4481   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4482         (vec_select:DF
4483           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4484           (parallel [(const_int 1)])))]
4485   "!TARGET_SSE2 && TARGET_SSE
4486    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4487   "@
4488    movhps\t{%1, %0|%0, %1}
4489    movhlps\t{%1, %0|%0, %1}
4490    movlps\t{%H1, %0|%0, %H1}"
4491   [(set_attr "type" "ssemov")
4492    (set_attr "mode" "V2SF,V4SF,V2SF")])
4493
4494 (define_insn "*vec_extractv2df_0_sse"
4495   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4496         (vec_select:DF
4497           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
4498           (parallel [(const_int 0)])))]
4499   "!TARGET_SSE2 && TARGET_SSE
4500    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4501   "@
4502    movlps\t{%1, %0|%0, %1}
4503    movaps\t{%1, %0|%0, %1}
4504    movlps\t{%1, %0|%0, %1}"
4505   [(set_attr "type" "ssemov")
4506    (set_attr "mode" "V2SF,V4SF,V2SF")])
4507
4508 (define_insn "*avx_movsd"
4509   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,o")
4510         (vec_merge:V2DF
4511           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,x,0")
4512           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,o,x")
4513           (const_int 1)))]
4514   "TARGET_AVX"
4515   "@
4516    vmovsd\t{%2, %1, %0|%0, %1, %2}
4517    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4518    vmovlpd\t{%2, %0|%0, %2}
4519    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
4520    vmovhps\t{%1, %H0|%H0, %1}"
4521   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov")
4522    (set_attr "prefix" "vex")
4523    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF")])
4524
4525 (define_insn "sse2_movsd"
4526   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
4527         (vec_merge:V2DF
4528           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
4529           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
4530           (const_int 1)))]
4531   "TARGET_SSE2"
4532   "@
4533    movsd\t{%2, %0|%0, %2}
4534    movlpd\t{%2, %0|%0, %2}
4535    movlpd\t{%2, %0|%0, %2}
4536    shufpd\t{$2, %2, %0|%0, %2, 2}
4537    movhps\t{%H1, %0|%0, %H1}
4538    movhps\t{%1, %H0|%H0, %1}"
4539   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
4540    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
4541
4542 (define_insn "*vec_dupv2df_sse3"
4543   [(set (match_operand:V2DF 0 "register_operand" "=x")
4544         (vec_duplicate:V2DF
4545           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
4546   "TARGET_SSE3"
4547   "%vmovddup\t{%1, %0|%0, %1}"
4548   [(set_attr "type" "sselog1")
4549    (set_attr "prefix" "maybe_vex")
4550    (set_attr "mode" "DF")])
4551
4552 (define_insn "vec_dupv2df"
4553   [(set (match_operand:V2DF 0 "register_operand" "=x")
4554         (vec_duplicate:V2DF
4555           (match_operand:DF 1 "register_operand" "0")))]
4556   "TARGET_SSE2"
4557   "unpcklpd\t%0, %0"
4558   [(set_attr "type" "sselog1")
4559    (set_attr "mode" "V2DF")])
4560
4561 (define_insn "*vec_concatv2df_sse3"
4562   [(set (match_operand:V2DF 0 "register_operand" "=x")
4563         (vec_concat:V2DF
4564           (match_operand:DF 1 "nonimmediate_operand" "xm")
4565           (match_dup 1)))]
4566   "TARGET_SSE3"
4567   "%vmovddup\t{%1, %0|%0, %1}"
4568   [(set_attr "type" "sselog1")
4569    (set_attr "prefix" "maybe_vex")
4570    (set_attr "mode" "DF")])
4571
4572 (define_insn "*vec_concatv2df_avx"
4573   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x")
4574         (vec_concat:V2DF
4575           (match_operand:DF 1 "nonimmediate_operand" " x,x,m")
4576           (match_operand:DF 2 "vector_move_operand"  " x,m,C")))]
4577   "TARGET_AVX"
4578   "@
4579    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4580    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4581    vmovsd\t{%1, %0|%0, %1}"
4582   [(set_attr "type" "ssemov")
4583    (set_attr "prefix" "vex")
4584    (set_attr "mode" "DF,V1DF,DF")])
4585
4586 (define_insn "*vec_concatv2df"
4587   [(set (match_operand:V2DF 0 "register_operand"     "=Y2,Y2,Y2,x,x")
4588         (vec_concat:V2DF
4589           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
4590           (match_operand:DF 2 "vector_move_operand"  " Y2,m ,C ,x,m")))]
4591   "TARGET_SSE"
4592   "@
4593    unpcklpd\t{%2, %0|%0, %2}
4594    movhpd\t{%2, %0|%0, %2}
4595    movsd\t{%1, %0|%0, %1}
4596    movlhps\t{%2, %0|%0, %2}
4597    movhps\t{%2, %0|%0, %2}"
4598   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
4599    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
4600
4601 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4602 ;;
4603 ;; Parallel integral arithmetic
4604 ;;
4605 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4606
4607 (define_expand "neg<mode>2"
4608   [(set (match_operand:SSEMODEI 0 "register_operand" "")
4609         (minus:SSEMODEI
4610           (match_dup 2)
4611           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
4612   "TARGET_SSE2"
4613   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
4614
4615 (define_expand "<plusminus_insn><mode>3"
4616   [(set (match_operand:SSEMODEI 0 "register_operand" "")
4617         (plusminus:SSEMODEI
4618           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
4619           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
4620   "TARGET_SSE2"
4621   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
4622
4623 (define_insn "*avx_<plusminus_insn><mode>3"
4624   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
4625         (plusminus:SSEMODEI
4626           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>x")
4627           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
4628   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4629   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
4630   [(set_attr "type" "sseiadd")
4631    (set_attr "prefix" "vex")
4632    (set_attr "mode" "TI")])
4633
4634 (define_insn "*<plusminus_insn><mode>3"
4635   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
4636         (plusminus:SSEMODEI
4637           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>0")
4638           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
4639   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4640   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
4641   [(set_attr "type" "sseiadd")
4642    (set_attr "prefix_data16" "1")
4643    (set_attr "mode" "TI")])
4644
4645 (define_expand "sse2_<plusminus_insn><mode>3"
4646   [(set (match_operand:SSEMODE12 0 "register_operand" "")
4647         (sat_plusminus:SSEMODE12
4648           (match_operand:SSEMODE12 1 "nonimmediate_operand" "")
4649           (match_operand:SSEMODE12 2 "nonimmediate_operand" "")))]
4650   "TARGET_SSE2"
4651   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
4652
4653 (define_insn "*avx_<plusminus_insn><mode>3"
4654   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
4655         (sat_plusminus:SSEMODE12
4656           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>x")
4657           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
4658   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4659   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
4660   [(set_attr "type" "sseiadd")
4661    (set_attr "prefix" "vex")
4662    (set_attr "mode" "TI")])
4663
4664 (define_insn "*sse2_<plusminus_insn><mode>3"
4665   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
4666         (sat_plusminus:SSEMODE12
4667           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>0")
4668           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
4669   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4670   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
4671   [(set_attr "type" "sseiadd")
4672    (set_attr "prefix_data16" "1")
4673    (set_attr "mode" "TI")])
4674
4675 (define_insn_and_split "mulv16qi3"
4676   [(set (match_operand:V16QI 0 "register_operand" "")
4677         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
4678                     (match_operand:V16QI 2 "register_operand" "")))]
4679   "TARGET_SSE2
4680    && !(reload_completed || reload_in_progress)"
4681   "#"
4682   "&& 1"
4683   [(const_int 0)]
4684 {
4685   rtx t[12], op0, op[3];
4686   int i;
4687
4688   if (TARGET_SSE5)
4689     {
4690       /* On SSE5, we can take advantage of the pperm instruction to pack and
4691          unpack the bytes.  Unpack data such that we've got a source byte in
4692          each low byte of each word.  We don't care what goes into the high
4693          byte, so put 0 there.  */
4694       for (i = 0; i < 6; ++i)
4695         t[i] = gen_reg_rtx (V8HImode);
4696
4697       for (i = 0; i < 2; i++)
4698         {
4699           op[0] = t[i];
4700           op[1] = operands[i+1];
4701           ix86_expand_sse5_unpack (op, true, true);             /* high bytes */
4702
4703           op[0] = t[i+2];
4704           ix86_expand_sse5_unpack (op, true, false);            /* low bytes */
4705         }
4706
4707       /* Multiply words.  */
4708       emit_insn (gen_mulv8hi3 (t[4], t[0], t[1]));              /* high bytes */
4709       emit_insn (gen_mulv8hi3 (t[5], t[2], t[3]));              /* low  bytes */
4710
4711       /* Pack the low byte of each word back into a single xmm */
4712       op[0] = operands[0];
4713       op[1] = t[5];
4714       op[2] = t[4];
4715       ix86_expand_sse5_pack (op);
4716       DONE;
4717     }
4718
4719   for (i = 0; i < 12; ++i)
4720     t[i] = gen_reg_rtx (V16QImode);
4721
4722   /* Unpack data such that we've got a source byte in each low byte of
4723      each word.  We don't care what goes into the high byte of each word.
4724      Rather than trying to get zero in there, most convenient is to let
4725      it be a copy of the low byte.  */
4726   emit_insn (gen_sse2_punpckhbw (t[0], operands[1], operands[1]));
4727   emit_insn (gen_sse2_punpckhbw (t[1], operands[2], operands[2]));
4728   emit_insn (gen_sse2_punpcklbw (t[2], operands[1], operands[1]));
4729   emit_insn (gen_sse2_punpcklbw (t[3], operands[2], operands[2]));
4730
4731   /* Multiply words.  The end-of-line annotations here give a picture of what
4732      the output of that instruction looks like.  Dot means don't care; the
4733      letters are the bytes of the result with A being the most significant.  */
4734   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
4735                            gen_lowpart (V8HImode, t[0]),
4736                            gen_lowpart (V8HImode, t[1])));
4737   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
4738                            gen_lowpart (V8HImode, t[2]),
4739                            gen_lowpart (V8HImode, t[3])));
4740
4741   /* Extract the relevant bytes and merge them back together.  */
4742   emit_insn (gen_sse2_punpckhbw (t[6], t[5], t[4]));    /* ..AI..BJ..CK..DL */
4743   emit_insn (gen_sse2_punpcklbw (t[7], t[5], t[4]));    /* ..EM..FN..GO..HP */
4744   emit_insn (gen_sse2_punpckhbw (t[8], t[7], t[6]));    /* ....AEIM....BFJN */
4745   emit_insn (gen_sse2_punpcklbw (t[9], t[7], t[6]));    /* ....CGKO....DHLP */
4746   emit_insn (gen_sse2_punpckhbw (t[10], t[9], t[8]));   /* ........ACEGIKMO */
4747   emit_insn (gen_sse2_punpcklbw (t[11], t[9], t[8]));   /* ........BDFHJLNP */
4748
4749   op0 = operands[0];
4750   emit_insn (gen_sse2_punpcklbw (op0, t[11], t[10]));   /* ABCDEFGHIJKLMNOP */
4751   DONE;
4752 })
4753
4754 (define_expand "mulv8hi3"
4755   [(set (match_operand:V8HI 0 "register_operand" "")
4756         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
4757                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
4758   "TARGET_SSE2"
4759   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4760
4761 (define_insn "*avx_mulv8hi3"
4762   [(set (match_operand:V8HI 0 "register_operand" "=x")
4763         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
4764                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
4765   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4766   "vpmullw\t{%2, %1, %0|%0, %1, %2}"
4767   [(set_attr "type" "sseimul")
4768    (set_attr "prefix" "vex")
4769    (set_attr "mode" "TI")])
4770
4771 (define_insn "*mulv8hi3"
4772   [(set (match_operand:V8HI 0 "register_operand" "=x")
4773         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
4774                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
4775   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4776   "pmullw\t{%2, %0|%0, %2}"
4777   [(set_attr "type" "sseimul")
4778    (set_attr "prefix_data16" "1")
4779    (set_attr "mode" "TI")])
4780
4781 (define_expand "smulv8hi3_highpart"
4782   [(set (match_operand:V8HI 0 "register_operand" "")
4783         (truncate:V8HI
4784           (lshiftrt:V8SI
4785             (mult:V8SI
4786               (sign_extend:V8SI
4787                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
4788               (sign_extend:V8SI
4789                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
4790             (const_int 16))))]
4791   "TARGET_SSE2"
4792   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4793
4794 (define_insn "*avxv8hi3_highpart"
4795   [(set (match_operand:V8HI 0 "register_operand" "=x")
4796         (truncate:V8HI
4797           (lshiftrt:V8SI
4798             (mult:V8SI
4799               (sign_extend:V8SI
4800                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
4801               (sign_extend:V8SI
4802                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4803             (const_int 16))))]
4804   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4805   "vpmulhw\t{%2, %1, %0|%0, %1, %2}"
4806   [(set_attr "type" "sseimul")
4807    (set_attr "prefix" "vex")
4808    (set_attr "mode" "TI")])
4809
4810 (define_insn "*smulv8hi3_highpart"
4811   [(set (match_operand:V8HI 0 "register_operand" "=x")
4812         (truncate:V8HI
4813           (lshiftrt:V8SI
4814             (mult:V8SI
4815               (sign_extend:V8SI
4816                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
4817               (sign_extend:V8SI
4818                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4819             (const_int 16))))]
4820   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4821   "pmulhw\t{%2, %0|%0, %2}"
4822   [(set_attr "type" "sseimul")
4823    (set_attr "prefix_data16" "1")
4824    (set_attr "mode" "TI")])
4825
4826 (define_expand "umulv8hi3_highpart"
4827   [(set (match_operand:V8HI 0 "register_operand" "")
4828         (truncate:V8HI
4829           (lshiftrt:V8SI
4830             (mult:V8SI
4831               (zero_extend:V8SI
4832                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
4833               (zero_extend:V8SI
4834                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
4835             (const_int 16))))]
4836   "TARGET_SSE2"
4837   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4838
4839 (define_insn "*avx_umulv8hi3_highpart"
4840   [(set (match_operand:V8HI 0 "register_operand" "=x")
4841         (truncate:V8HI
4842           (lshiftrt:V8SI
4843             (mult:V8SI
4844               (zero_extend:V8SI
4845                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
4846               (zero_extend:V8SI
4847                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4848             (const_int 16))))]
4849   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4850   "vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
4851   [(set_attr "type" "sseimul")
4852    (set_attr "prefix" "vex")
4853    (set_attr "mode" "TI")])
4854
4855 (define_insn "*umulv8hi3_highpart"
4856   [(set (match_operand:V8HI 0 "register_operand" "=x")
4857         (truncate:V8HI
4858           (lshiftrt:V8SI
4859             (mult:V8SI
4860               (zero_extend:V8SI
4861                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
4862               (zero_extend:V8SI
4863                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4864             (const_int 16))))]
4865   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4866   "pmulhuw\t{%2, %0|%0, %2}"
4867   [(set_attr "type" "sseimul")
4868    (set_attr "prefix_data16" "1")
4869    (set_attr "mode" "TI")])
4870
4871 (define_expand "sse2_umulv2siv2di3"
4872   [(set (match_operand:V2DI 0 "register_operand" "")
4873         (mult:V2DI
4874           (zero_extend:V2DI
4875             (vec_select:V2SI
4876               (match_operand:V4SI 1 "nonimmediate_operand" "")
4877               (parallel [(const_int 0) (const_int 2)])))
4878           (zero_extend:V2DI
4879             (vec_select:V2SI
4880               (match_operand:V4SI 2 "nonimmediate_operand" "")
4881               (parallel [(const_int 0) (const_int 2)])))))]
4882   "TARGET_SSE2"
4883   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
4884
4885 (define_insn "*avx_umulv2siv2di3"
4886   [(set (match_operand:V2DI 0 "register_operand" "=x")
4887         (mult:V2DI
4888           (zero_extend:V2DI
4889             (vec_select:V2SI
4890               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
4891               (parallel [(const_int 0) (const_int 2)])))
4892           (zero_extend:V2DI
4893             (vec_select:V2SI
4894               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
4895               (parallel [(const_int 0) (const_int 2)])))))]
4896   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
4897   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
4898   [(set_attr "type" "sseimul")
4899    (set_attr "prefix" "vex")
4900    (set_attr "mode" "TI")])
4901
4902 (define_insn "*sse2_umulv2siv2di3"
4903   [(set (match_operand:V2DI 0 "register_operand" "=x")
4904         (mult:V2DI
4905           (zero_extend:V2DI
4906             (vec_select:V2SI
4907               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
4908               (parallel [(const_int 0) (const_int 2)])))
4909           (zero_extend:V2DI
4910             (vec_select:V2SI
4911               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
4912               (parallel [(const_int 0) (const_int 2)])))))]
4913   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
4914   "pmuludq\t{%2, %0|%0, %2}"
4915   [(set_attr "type" "sseimul")
4916    (set_attr "prefix_data16" "1")
4917    (set_attr "mode" "TI")])
4918
4919 (define_expand "sse4_1_mulv2siv2di3"
4920   [(set (match_operand:V2DI 0 "register_operand" "")
4921         (mult:V2DI
4922           (sign_extend:V2DI
4923             (vec_select:V2SI
4924               (match_operand:V4SI 1 "nonimmediate_operand" "")
4925               (parallel [(const_int 0) (const_int 2)])))
4926           (sign_extend:V2DI
4927             (vec_select:V2SI
4928               (match_operand:V4SI 2 "nonimmediate_operand" "")
4929               (parallel [(const_int 0) (const_int 2)])))))]
4930   "TARGET_SSE4_1"
4931   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
4932
4933 (define_insn "*avx_mulv2siv2di3"
4934   [(set (match_operand:V2DI 0 "register_operand" "=x")
4935         (mult:V2DI
4936           (sign_extend:V2DI
4937             (vec_select:V2SI
4938               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
4939               (parallel [(const_int 0) (const_int 2)])))
4940           (sign_extend:V2DI
4941             (vec_select:V2SI
4942               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
4943               (parallel [(const_int 0) (const_int 2)])))))]
4944   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
4945   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
4946   [(set_attr "type" "sseimul")
4947    (set_attr "prefix" "vex")
4948    (set_attr "mode" "TI")])
4949
4950 (define_insn "*sse4_1_mulv2siv2di3"
4951   [(set (match_operand:V2DI 0 "register_operand" "=x")
4952         (mult:V2DI
4953           (sign_extend:V2DI
4954             (vec_select:V2SI
4955               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
4956               (parallel [(const_int 0) (const_int 2)])))
4957           (sign_extend:V2DI
4958             (vec_select:V2SI
4959               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
4960               (parallel [(const_int 0) (const_int 2)])))))]
4961   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
4962   "pmuldq\t{%2, %0|%0, %2}"
4963   [(set_attr "type" "sseimul")
4964    (set_attr "prefix_extra" "1")
4965    (set_attr "mode" "TI")])
4966
4967 (define_expand "sse2_pmaddwd"
4968   [(set (match_operand:V4SI 0 "register_operand" "")
4969         (plus:V4SI
4970           (mult:V4SI
4971             (sign_extend:V4SI
4972               (vec_select:V4HI
4973                 (match_operand:V8HI 1 "nonimmediate_operand" "")
4974                 (parallel [(const_int 0)
4975                            (const_int 2)
4976                            (const_int 4)
4977                            (const_int 6)])))
4978             (sign_extend:V4SI
4979               (vec_select:V4HI
4980                 (match_operand:V8HI 2 "nonimmediate_operand" "")
4981                 (parallel [(const_int 0)
4982                            (const_int 2)
4983                            (const_int 4)
4984                            (const_int 6)]))))
4985           (mult:V4SI
4986             (sign_extend:V4SI
4987               (vec_select:V4HI (match_dup 1)
4988                 (parallel [(const_int 1)
4989                            (const_int 3)
4990                            (const_int 5)
4991                            (const_int 7)])))
4992             (sign_extend:V4SI
4993               (vec_select:V4HI (match_dup 2)
4994                 (parallel [(const_int 1)
4995                            (const_int 3)
4996                            (const_int 5)
4997                            (const_int 7)]))))))]
4998   "TARGET_SSE2"
4999   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5000
5001 (define_insn "*avx_pmaddwd"
5002   [(set (match_operand:V4SI 0 "register_operand" "=x")
5003         (plus:V4SI
5004           (mult:V4SI
5005             (sign_extend:V4SI
5006               (vec_select:V4HI
5007                 (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5008                 (parallel [(const_int 0)
5009                            (const_int 2)
5010                            (const_int 4)
5011                            (const_int 6)])))
5012             (sign_extend:V4SI
5013               (vec_select:V4HI
5014                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5015                 (parallel [(const_int 0)
5016                            (const_int 2)
5017                            (const_int 4)
5018                            (const_int 6)]))))
5019           (mult:V4SI
5020             (sign_extend:V4SI
5021               (vec_select:V4HI (match_dup 1)
5022                 (parallel [(const_int 1)
5023                            (const_int 3)
5024                            (const_int 5)
5025                            (const_int 7)])))
5026             (sign_extend:V4SI
5027               (vec_select:V4HI (match_dup 2)
5028                 (parallel [(const_int 1)
5029                            (const_int 3)
5030                            (const_int 5)
5031                            (const_int 7)]))))))]
5032   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5033   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5034   [(set_attr "type" "sseiadd")
5035    (set_attr "prefix" "vex")
5036    (set_attr "mode" "TI")])
5037
5038 (define_insn "*sse2_pmaddwd"
5039   [(set (match_operand:V4SI 0 "register_operand" "=x")
5040         (plus:V4SI
5041           (mult:V4SI
5042             (sign_extend:V4SI
5043               (vec_select:V4HI
5044                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5045                 (parallel [(const_int 0)
5046                            (const_int 2)
5047                            (const_int 4)
5048                            (const_int 6)])))
5049             (sign_extend:V4SI
5050               (vec_select:V4HI
5051                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5052                 (parallel [(const_int 0)
5053                            (const_int 2)
5054                            (const_int 4)
5055                            (const_int 6)]))))
5056           (mult:V4SI
5057             (sign_extend:V4SI
5058               (vec_select:V4HI (match_dup 1)
5059                 (parallel [(const_int 1)
5060                            (const_int 3)
5061                            (const_int 5)
5062                            (const_int 7)])))
5063             (sign_extend:V4SI
5064               (vec_select:V4HI (match_dup 2)
5065                 (parallel [(const_int 1)
5066                            (const_int 3)
5067                            (const_int 5)
5068                            (const_int 7)]))))))]
5069   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5070   "pmaddwd\t{%2, %0|%0, %2}"
5071   [(set_attr "type" "sseiadd")
5072    (set_attr "prefix_data16" "1")
5073    (set_attr "mode" "TI")])
5074
5075 (define_expand "mulv4si3"
5076   [(set (match_operand:V4SI 0 "register_operand" "")
5077         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5078                    (match_operand:V4SI 2 "register_operand" "")))]
5079   "TARGET_SSE2"
5080 {
5081   if (TARGET_SSE4_1 || TARGET_SSE5)
5082     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
5083 })
5084
5085 (define_insn "*avx_mulv4si3"
5086   [(set (match_operand:V4SI 0 "register_operand" "=x")
5087         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5088                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5089   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5090   "vpmulld\t{%2, %1, %0|%0, %1, %2}"
5091   [(set_attr "type" "sseimul")
5092    (set_attr "prefix" "vex")
5093    (set_attr "mode" "TI")])
5094
5095 (define_insn "*sse4_1_mulv4si3"
5096   [(set (match_operand:V4SI 0 "register_operand" "=x")
5097         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5098                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5099   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5100   "pmulld\t{%2, %0|%0, %2}"
5101   [(set_attr "type" "sseimul")
5102    (set_attr "prefix_extra" "1")
5103    (set_attr "mode" "TI")])
5104
5105 ;; We don't have a straight 32-bit parallel multiply on SSE5, so fake it with a
5106 ;; multiply/add.  In general, we expect the define_split to occur before
5107 ;; register allocation, so we have to handle the corner case where the target
5108 ;; is the same as one of the inputs.
5109 (define_insn_and_split "*sse5_mulv4si3"
5110   [(set (match_operand:V4SI 0 "register_operand" "=&x")
5111         (mult:V4SI (match_operand:V4SI 1 "register_operand" "%x")
5112                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5113   "TARGET_SSE5"
5114   "#"
5115   "&& (reload_completed
5116        || (!reg_mentioned_p (operands[0], operands[1])
5117            && !reg_mentioned_p (operands[0], operands[2])))"
5118   [(set (match_dup 0)
5119         (match_dup 3))
5120    (set (match_dup 0)
5121         (plus:V4SI (mult:V4SI (match_dup 1)
5122                               (match_dup 2))
5123                    (match_dup 0)))]
5124 {
5125   operands[3] = CONST0_RTX (V4SImode);
5126 }
5127   [(set_attr "type" "ssemuladd")
5128    (set_attr "mode" "TI")])
5129
5130 (define_insn_and_split "*sse2_mulv4si3"
5131   [(set (match_operand:V4SI 0 "register_operand" "")
5132         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5133                    (match_operand:V4SI 2 "register_operand" "")))]
5134   "TARGET_SSE2 && !TARGET_SSE4_1 && !TARGET_SSE5
5135    && !(reload_completed || reload_in_progress)"
5136   "#"
5137   "&& 1"
5138   [(const_int 0)]
5139 {
5140   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5141   rtx op0, op1, op2;
5142
5143   op0 = operands[0];
5144   op1 = operands[1];
5145   op2 = operands[2];
5146   t1 = gen_reg_rtx (V4SImode);
5147   t2 = gen_reg_rtx (V4SImode);
5148   t3 = gen_reg_rtx (V4SImode);
5149   t4 = gen_reg_rtx (V4SImode);
5150   t5 = gen_reg_rtx (V4SImode);
5151   t6 = gen_reg_rtx (V4SImode);
5152   thirtytwo = GEN_INT (32);
5153
5154   /* Multiply elements 2 and 0.  */
5155   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
5156                                      op1, op2));
5157
5158   /* Shift both input vectors down one element, so that elements 3
5159      and 1 are now in the slots for elements 2 and 0.  For K8, at
5160      least, this is faster than using a shuffle.  */
5161   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
5162                                gen_lowpart (TImode, op1),
5163                                thirtytwo));
5164   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
5165                                gen_lowpart (TImode, op2),
5166                                thirtytwo));
5167   /* Multiply elements 3 and 1.  */
5168   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
5169                                      t2, t3));
5170
5171   /* Move the results in element 2 down to element 1; we don't care
5172      what goes in elements 2 and 3.  */
5173   emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
5174                                 const0_rtx, const0_rtx));
5175   emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
5176                                 const0_rtx, const0_rtx));
5177
5178   /* Merge the parts back together.  */
5179   emit_insn (gen_sse2_punpckldq (op0, t5, t6));
5180   DONE;
5181 })
5182
5183 (define_insn_and_split "mulv2di3"
5184   [(set (match_operand:V2DI 0 "register_operand" "")
5185         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
5186                    (match_operand:V2DI 2 "register_operand" "")))]
5187   "TARGET_SSE2
5188    && !(reload_completed || reload_in_progress)"
5189   "#"
5190   "&& 1"
5191   [(const_int 0)]
5192 {
5193   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5194   rtx op0, op1, op2;
5195
5196   if (TARGET_SSE5)
5197     {
5198       /* op1: A,B,C,D, op2: E,F,G,H */
5199       op0 = operands[0];
5200       op1 = gen_lowpart (V4SImode, operands[1]);
5201       op2 = gen_lowpart (V4SImode, operands[2]);
5202       t1 = gen_reg_rtx (V4SImode);
5203       t2 = gen_reg_rtx (V4SImode);
5204       t3 = gen_reg_rtx (V4SImode);
5205       t4 = gen_reg_rtx (V2DImode);
5206       t5 = gen_reg_rtx (V2DImode);
5207
5208       /* t1: B,A,D,C */
5209       emit_insn (gen_sse2_pshufd_1 (t1, op1,
5210                                     GEN_INT (1),
5211                                     GEN_INT (0),
5212                                     GEN_INT (3),
5213                                     GEN_INT (2)));
5214
5215       /* t2: 0 */
5216       emit_move_insn (t2, CONST0_RTX (V4SImode));
5217
5218       /* t3: (B*E),(A*F),(D*G),(C*H) */
5219       emit_insn (gen_sse5_pmacsdd (t3, t1, op2, t2));
5220
5221       /* t4: (B*E)+(A*F), (D*G)+(C*H) */
5222       emit_insn (gen_sse5_phadddq (t4, t3));
5223
5224       /* t5: ((B*E)+(A*F))<<32, ((D*G)+(C*H))<<32 */
5225       emit_insn (gen_ashlv2di3 (t5, t4, GEN_INT (32)));
5226
5227       /* op0: (((B*E)+(A*F))<<32)+(B*F), (((D*G)+(C*H))<<32)+(D*H) */
5228       emit_insn (gen_sse5_pmacsdql (op0, op1, op2, t5));
5229       DONE;
5230     }
5231
5232   op0 = operands[0];
5233   op1 = operands[1];
5234   op2 = operands[2];
5235   t1 = gen_reg_rtx (V2DImode);
5236   t2 = gen_reg_rtx (V2DImode);
5237   t3 = gen_reg_rtx (V2DImode);
5238   t4 = gen_reg_rtx (V2DImode);
5239   t5 = gen_reg_rtx (V2DImode);
5240   t6 = gen_reg_rtx (V2DImode);
5241   thirtytwo = GEN_INT (32);
5242
5243   /* Multiply low parts.  */
5244   emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
5245                                      gen_lowpart (V4SImode, op2)));
5246
5247   /* Shift input vectors left 32 bits so we can multiply high parts.  */
5248   emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
5249   emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
5250
5251   /* Multiply high parts by low parts.  */
5252   emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
5253                                      gen_lowpart (V4SImode, t3)));
5254   emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
5255                                      gen_lowpart (V4SImode, t2)));
5256
5257   /* Shift them back.  */
5258   emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
5259   emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
5260
5261   /* Add the three parts together.  */
5262   emit_insn (gen_addv2di3 (t6, t1, t4));
5263   emit_insn (gen_addv2di3 (op0, t6, t5));
5264   DONE;
5265 })
5266
5267 (define_expand "vec_widen_smult_hi_v8hi"
5268   [(match_operand:V4SI 0 "register_operand" "")
5269    (match_operand:V8HI 1 "register_operand" "")
5270    (match_operand:V8HI 2 "register_operand" "")]
5271   "TARGET_SSE2"
5272 {
5273   rtx op1, op2, t1, t2, dest;
5274
5275   op1 = operands[1];
5276   op2 = operands[2];
5277   t1 = gen_reg_rtx (V8HImode);
5278   t2 = gen_reg_rtx (V8HImode);
5279   dest = gen_lowpart (V8HImode, operands[0]);
5280
5281   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5282   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5283   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5284   DONE;
5285 })
5286
5287 (define_expand "vec_widen_smult_lo_v8hi"
5288   [(match_operand:V4SI 0 "register_operand" "")
5289    (match_operand:V8HI 1 "register_operand" "")
5290    (match_operand:V8HI 2 "register_operand" "")]
5291   "TARGET_SSE2"
5292 {
5293   rtx op1, op2, t1, t2, dest;
5294
5295   op1 = operands[1];
5296   op2 = operands[2];
5297   t1 = gen_reg_rtx (V8HImode);
5298   t2 = gen_reg_rtx (V8HImode);
5299   dest = gen_lowpart (V8HImode, operands[0]);
5300
5301   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5302   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5303   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5304   DONE;
5305 })
5306
5307 (define_expand "vec_widen_umult_hi_v8hi"
5308   [(match_operand:V4SI 0 "register_operand" "")
5309    (match_operand:V8HI 1 "register_operand" "")
5310    (match_operand:V8HI 2 "register_operand" "")]
5311   "TARGET_SSE2"
5312 {
5313   rtx op1, op2, t1, t2, dest;
5314
5315   op1 = operands[1];
5316   op2 = operands[2];
5317   t1 = gen_reg_rtx (V8HImode);
5318   t2 = gen_reg_rtx (V8HImode);
5319   dest = gen_lowpart (V8HImode, operands[0]);
5320
5321   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5322   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5323   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5324   DONE;
5325 })
5326
5327 (define_expand "vec_widen_umult_lo_v8hi"
5328   [(match_operand:V4SI 0 "register_operand" "")
5329    (match_operand:V8HI 1 "register_operand" "")
5330    (match_operand:V8HI 2 "register_operand" "")]
5331   "TARGET_SSE2"
5332 {
5333   rtx op1, op2, t1, t2, dest;
5334
5335   op1 = operands[1];
5336   op2 = operands[2];
5337   t1 = gen_reg_rtx (V8HImode);
5338   t2 = gen_reg_rtx (V8HImode);
5339   dest = gen_lowpart (V8HImode, operands[0]);
5340
5341   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5342   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5343   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5344   DONE;
5345 })
5346
5347 (define_expand "vec_widen_smult_hi_v4si"
5348   [(match_operand:V2DI 0 "register_operand" "")
5349    (match_operand:V4SI 1 "register_operand" "")
5350    (match_operand:V4SI 2 "register_operand" "")]
5351   "TARGET_SSE5"
5352 {
5353   rtx t1, t2;
5354
5355   t1 = gen_reg_rtx (V4SImode);
5356   t2 = gen_reg_rtx (V4SImode);
5357
5358   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5359                                 GEN_INT (0),
5360                                 GEN_INT (2),
5361                                 GEN_INT (1),
5362                                 GEN_INT (3)));
5363   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5364                                 GEN_INT (0),
5365                                 GEN_INT (2),
5366                                 GEN_INT (1),
5367                                 GEN_INT (3)));
5368   emit_insn (gen_sse5_mulv2div2di3_high (operands[0], t1, t2));
5369   DONE;
5370 })
5371
5372 (define_expand "vec_widen_smult_lo_v4si"
5373   [(match_operand:V2DI 0 "register_operand" "")
5374    (match_operand:V4SI 1 "register_operand" "")
5375    (match_operand:V4SI 2 "register_operand" "")]
5376   "TARGET_SSE5"
5377 {
5378   rtx t1, t2;
5379
5380   t1 = gen_reg_rtx (V4SImode);
5381   t2 = gen_reg_rtx (V4SImode);
5382
5383   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5384                                 GEN_INT (0),
5385                                 GEN_INT (2),
5386                                 GEN_INT (1),
5387                                 GEN_INT (3)));
5388   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5389                                 GEN_INT (0),
5390                                 GEN_INT (2),
5391                                 GEN_INT (1),
5392                                 GEN_INT (3)));
5393   emit_insn (gen_sse5_mulv2div2di3_low (operands[0], t1, t2));
5394   DONE;
5395   DONE;
5396 })
5397
5398 (define_expand "vec_widen_umult_hi_v4si"
5399   [(match_operand:V2DI 0 "register_operand" "")
5400    (match_operand:V4SI 1 "register_operand" "")
5401    (match_operand:V4SI 2 "register_operand" "")]
5402   "TARGET_SSE2"
5403 {
5404   rtx op1, op2, t1, t2;
5405
5406   op1 = operands[1];
5407   op2 = operands[2];
5408   t1 = gen_reg_rtx (V4SImode);
5409   t2 = gen_reg_rtx (V4SImode);
5410
5411   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
5412   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
5413   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5414   DONE;
5415 })
5416
5417 (define_expand "vec_widen_umult_lo_v4si"
5418   [(match_operand:V2DI 0 "register_operand" "")
5419    (match_operand:V4SI 1 "register_operand" "")
5420    (match_operand:V4SI 2 "register_operand" "")]
5421   "TARGET_SSE2"
5422 {
5423   rtx op1, op2, t1, t2;
5424
5425   op1 = operands[1];
5426   op2 = operands[2];
5427   t1 = gen_reg_rtx (V4SImode);
5428   t2 = gen_reg_rtx (V4SImode);
5429
5430   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
5431   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
5432   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5433   DONE;
5434 })
5435
5436 (define_expand "sdot_prodv8hi"
5437   [(match_operand:V4SI 0 "register_operand" "")
5438    (match_operand:V8HI 1 "register_operand" "")
5439    (match_operand:V8HI 2 "register_operand" "")
5440    (match_operand:V4SI 3 "register_operand" "")]
5441   "TARGET_SSE2"
5442 {
5443   rtx t = gen_reg_rtx (V4SImode);
5444   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
5445   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
5446   DONE;
5447 })
5448
5449 (define_expand "udot_prodv4si"
5450   [(match_operand:V2DI 0 "register_operand" "")
5451    (match_operand:V4SI 1 "register_operand" "")
5452    (match_operand:V4SI 2 "register_operand" "")
5453    (match_operand:V2DI 3 "register_operand" "")]
5454   "TARGET_SSE2"
5455 {
5456   rtx t1, t2, t3, t4;
5457
5458   t1 = gen_reg_rtx (V2DImode);
5459   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
5460   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
5461
5462   t2 = gen_reg_rtx (V4SImode);
5463   t3 = gen_reg_rtx (V4SImode);
5464   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
5465                                gen_lowpart (TImode, operands[1]),
5466                                GEN_INT (32)));
5467   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
5468                                gen_lowpart (TImode, operands[2]),
5469                                GEN_INT (32)));
5470
5471   t4 = gen_reg_rtx (V2DImode);
5472   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
5473
5474   emit_insn (gen_addv2di3 (operands[0], t1, t4));
5475   DONE;
5476 })
5477
5478 (define_insn "*avx_ashr<mode>3"
5479   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5480         (ashiftrt:SSEMODE24
5481           (match_operand:SSEMODE24 1 "register_operand" "x")
5482           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5483   "TARGET_AVX"
5484   "vpsra<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5485   [(set_attr "type" "sseishft")
5486    (set_attr "prefix" "vex")
5487    (set_attr "mode" "TI")])
5488
5489 (define_insn "ashr<mode>3"
5490   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5491         (ashiftrt:SSEMODE24
5492           (match_operand:SSEMODE24 1 "register_operand" "0")
5493           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5494   "TARGET_SSE2"
5495   "psra<ssevecsize>\t{%2, %0|%0, %2}"
5496   [(set_attr "type" "sseishft")
5497    (set_attr "prefix_data16" "1")
5498    (set_attr "mode" "TI")])
5499
5500 (define_insn "*avx_lshr<mode>3"
5501   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5502         (lshiftrt:SSEMODE248
5503           (match_operand:SSEMODE248 1 "register_operand" "x")
5504           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5505   "TARGET_AVX"
5506   "vpsrl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5507   [(set_attr "type" "sseishft")
5508    (set_attr "prefix" "vex")
5509    (set_attr "mode" "TI")])
5510
5511 (define_insn "lshr<mode>3"
5512   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5513         (lshiftrt:SSEMODE248
5514           (match_operand:SSEMODE248 1 "register_operand" "0")
5515           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5516   "TARGET_SSE2"
5517   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
5518   [(set_attr "type" "sseishft")
5519    (set_attr "prefix_data16" "1")
5520    (set_attr "mode" "TI")])
5521
5522 (define_insn "*avx_ashl<mode>3"
5523   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5524         (ashift:SSEMODE248
5525           (match_operand:SSEMODE248 1 "register_operand" "x")
5526           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5527   "TARGET_AVX"
5528   "vpsll<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5529   [(set_attr "type" "sseishft")
5530    (set_attr "prefix" "vex")
5531    (set_attr "mode" "TI")])
5532
5533 (define_insn "ashl<mode>3"
5534   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5535         (ashift:SSEMODE248
5536           (match_operand:SSEMODE248 1 "register_operand" "0")
5537           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5538   "TARGET_SSE2"
5539   "psll<ssevecsize>\t{%2, %0|%0, %2}"
5540   [(set_attr "type" "sseishft")
5541    (set_attr "prefix_data16" "1")
5542    (set_attr "mode" "TI")])
5543
5544 (define_expand "vec_shl_<mode>"
5545   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5546         (ashift:TI (match_operand:SSEMODEI 1 "register_operand" "")
5547                    (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
5548   "TARGET_SSE2"
5549 {
5550   operands[0] = gen_lowpart (TImode, operands[0]);
5551   operands[1] = gen_lowpart (TImode, operands[1]);
5552 })
5553
5554 (define_expand "vec_shr_<mode>"
5555   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5556         (lshiftrt:TI (match_operand:SSEMODEI 1 "register_operand" "")
5557                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
5558   "TARGET_SSE2"
5559 {
5560   operands[0] = gen_lowpart (TImode, operands[0]);
5561   operands[1] = gen_lowpart (TImode, operands[1]);
5562 })
5563
5564 (define_insn "*avx_<code><mode>3"
5565   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5566         (maxmin:SSEMODE124
5567           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
5568           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5569   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5570   "vp<maxminiprefix><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5571   [(set_attr "type" "sseiadd")
5572    (set_attr "prefix" "vex")
5573    (set_attr "mode" "TI")])
5574
5575 (define_expand "<code>v16qi3"
5576   [(set (match_operand:V16QI 0 "register_operand" "")
5577         (umaxmin:V16QI
5578           (match_operand:V16QI 1 "nonimmediate_operand" "")
5579           (match_operand:V16QI 2 "nonimmediate_operand" "")))]
5580   "TARGET_SSE2"
5581   "ix86_fixup_binary_operands_no_copy (<CODE>, V16QImode, operands);")
5582
5583 (define_insn "*<code>v16qi3"
5584   [(set (match_operand:V16QI 0 "register_operand" "=x")
5585         (umaxmin:V16QI
5586           (match_operand:V16QI 1 "nonimmediate_operand" "%0")
5587           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
5588   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
5589   "p<maxminiprefix>b\t{%2, %0|%0, %2}"
5590   [(set_attr "type" "sseiadd")
5591    (set_attr "prefix_data16" "1")
5592    (set_attr "mode" "TI")])
5593
5594 (define_expand "<code>v8hi3"
5595   [(set (match_operand:V8HI 0 "register_operand" "")
5596         (smaxmin:V8HI
5597           (match_operand:V8HI 1 "nonimmediate_operand" "")
5598           (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5599   "TARGET_SSE2"
5600   "ix86_fixup_binary_operands_no_copy (<CODE>, V8HImode, operands);")
5601
5602 (define_insn "*<code>v8hi3"
5603   [(set (match_operand:V8HI 0 "register_operand" "=x")
5604         (smaxmin:V8HI
5605           (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5606           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5607   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
5608   "p<maxminiprefix>w\t{%2, %0|%0, %2}"
5609   [(set_attr "type" "sseiadd")
5610    (set_attr "prefix_data16" "1")
5611    (set_attr "mode" "TI")])
5612
5613 (define_expand "umaxv8hi3"
5614   [(set (match_operand:V8HI 0 "register_operand" "")
5615         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
5616                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5617   "TARGET_SSE2"
5618 {
5619   if (TARGET_SSE4_1)
5620     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
5621   else
5622     {
5623       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
5624       if (rtx_equal_p (op3, op2))
5625         op3 = gen_reg_rtx (V8HImode);
5626       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
5627       emit_insn (gen_addv8hi3 (op0, op3, op2));
5628       DONE;
5629     }
5630 })
5631
5632 (define_expand "smax<mode>3"
5633   [(set (match_operand:SSEMODE14 0 "register_operand" "")
5634         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
5635                         (match_operand:SSEMODE14 2 "register_operand" "")))]
5636   "TARGET_SSE2"
5637 {
5638   if (TARGET_SSE4_1)
5639     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
5640   else
5641   {
5642     rtx xops[6];
5643     bool ok;
5644
5645     xops[0] = operands[0];
5646     xops[1] = operands[1];
5647     xops[2] = operands[2];
5648     xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
5649     xops[4] = operands[1];
5650     xops[5] = operands[2];
5651     ok = ix86_expand_int_vcond (xops);
5652     gcc_assert (ok);
5653     DONE;
5654   }
5655 })
5656
5657 (define_insn "*sse4_1_<code><mode>3"
5658   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
5659         (smaxmin:SSEMODE14
5660           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
5661           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
5662   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5663   "p<maxminiprefix><ssevecsize>\t{%2, %0|%0, %2}"
5664   [(set_attr "type" "sseiadd")
5665    (set_attr "prefix_extra" "1")
5666    (set_attr "mode" "TI")])
5667
5668 (define_expand "umaxv4si3"
5669   [(set (match_operand:V4SI 0 "register_operand" "")
5670         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
5671                    (match_operand:V4SI 2 "register_operand" "")))]
5672   "TARGET_SSE2"
5673 {
5674   if (TARGET_SSE4_1)
5675     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
5676   else
5677   {
5678     rtx xops[6];
5679     bool ok;
5680
5681     xops[0] = operands[0];
5682     xops[1] = operands[1];
5683     xops[2] = operands[2];
5684     xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
5685     xops[4] = operands[1];
5686     xops[5] = operands[2];
5687     ok = ix86_expand_int_vcond (xops);
5688     gcc_assert (ok);
5689     DONE;
5690   }
5691 })
5692
5693 (define_insn "*sse4_1_<code><mode>3"
5694   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5695         (umaxmin:SSEMODE24
5696           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
5697           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
5698   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5699   "p<maxminiprefix><ssevecsize>\t{%2, %0|%0, %2}"
5700   [(set_attr "type" "sseiadd")
5701    (set_attr "prefix_extra" "1")
5702    (set_attr "mode" "TI")])
5703
5704 (define_expand "smin<mode>3"
5705   [(set (match_operand:SSEMODE14 0 "register_operand" "")
5706         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
5707                         (match_operand:SSEMODE14 2 "register_operand" "")))]
5708   "TARGET_SSE2"
5709 {
5710   if (TARGET_SSE4_1)
5711     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
5712   else
5713     {
5714       rtx xops[6];
5715       bool ok;
5716
5717       xops[0] = operands[0];
5718       xops[1] = operands[2];
5719       xops[2] = operands[1];
5720       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
5721       xops[4] = operands[1];
5722       xops[5] = operands[2];
5723       ok = ix86_expand_int_vcond (xops);
5724       gcc_assert (ok);
5725       DONE;
5726     }
5727 })
5728
5729 (define_expand "umin<mode>3"
5730   [(set (match_operand:SSEMODE24 0 "register_operand" "")
5731         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
5732                         (match_operand:SSEMODE24 2 "register_operand" "")))]
5733   "TARGET_SSE2"
5734 {
5735   if (TARGET_SSE4_1)
5736     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
5737   else
5738     {
5739       rtx xops[6];
5740       bool ok;
5741
5742       xops[0] = operands[0];
5743       xops[1] = operands[2];
5744       xops[2] = operands[1];
5745       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
5746       xops[4] = operands[1];
5747       xops[5] = operands[2];
5748       ok = ix86_expand_int_vcond (xops);
5749       gcc_assert (ok);
5750       DONE;
5751     }
5752 })
5753
5754 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5755 ;;
5756 ;; Parallel integral comparisons
5757 ;;
5758 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5759
5760 (define_expand "sse2_eq<mode>3"
5761   [(set (match_operand:SSEMODE124 0 "register_operand" "")
5762         (eq:SSEMODE124
5763           (match_operand:SSEMODE124 1 "nonimmediate_operand" "")
5764           (match_operand:SSEMODE124 2 "nonimmediate_operand" "")))]
5765   "TARGET_SSE2 && !TARGET_SSE5"
5766   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
5767
5768 (define_insn "*avx_eq<mode>3"
5769   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
5770         (eq:SSEMODE1248
5771           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "%x")
5772           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
5773   "TARGET_AVX && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
5774   "vpcmpeq<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5775   [(set_attr "type" "ssecmp")
5776    (set_attr "prefix" "vex")
5777    (set_attr "mode" "TI")])
5778
5779 (define_insn "*sse2_eq<mode>3"
5780   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5781         (eq:SSEMODE124
5782           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
5783           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5784   "TARGET_SSE2 && !TARGET_SSE5
5785    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
5786   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
5787   [(set_attr "type" "ssecmp")
5788    (set_attr "prefix_data16" "1")
5789    (set_attr "mode" "TI")])
5790
5791 (define_expand "sse4_1_eqv2di3"
5792   [(set (match_operand:V2DI 0 "register_operand" "")
5793         (eq:V2DI
5794           (match_operand:V2DI 1 "nonimmediate_operand" "")
5795           (match_operand:V2DI 2 "nonimmediate_operand" "")))]
5796   "TARGET_SSE4_1"
5797   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
5798
5799 (define_insn "*sse4_1_eqv2di3"
5800   [(set (match_operand:V2DI 0 "register_operand" "=x")
5801         (eq:V2DI
5802           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
5803           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
5804   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
5805   "pcmpeqq\t{%2, %0|%0, %2}"
5806   [(set_attr "type" "ssecmp")
5807    (set_attr "prefix_extra" "1")
5808    (set_attr "mode" "TI")])
5809
5810 (define_insn "*avx_gt<mode>3"
5811   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
5812         (gt:SSEMODE1248
5813           (match_operand:SSEMODE1248 1 "register_operand" "x")
5814           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
5815   "TARGET_AVX"
5816   "vpcmpgt<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5817   [(set_attr "type" "ssecmp")
5818    (set_attr "prefix" "vex")
5819    (set_attr "mode" "TI")])
5820
5821 (define_insn "sse2_gt<mode>3"
5822   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5823         (gt:SSEMODE124
5824           (match_operand:SSEMODE124 1 "register_operand" "0")
5825           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5826   "TARGET_SSE2 && !TARGET_SSE5"
5827   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
5828   [(set_attr "type" "ssecmp")
5829    (set_attr "prefix_data16" "1")
5830    (set_attr "mode" "TI")])
5831
5832 (define_insn "sse4_2_gtv2di3"
5833   [(set (match_operand:V2DI 0 "register_operand" "=x")
5834         (gt:V2DI
5835           (match_operand:V2DI 1 "register_operand" "0")
5836           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
5837   "TARGET_SSE4_2"
5838   "pcmpgtq\t{%2, %0|%0, %2}"
5839   [(set_attr "type" "ssecmp")
5840    (set_attr "mode" "TI")])
5841
5842 (define_expand "vcond<mode>"
5843   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
5844         (if_then_else:SSEMODE124C8
5845           (match_operator 3 ""
5846             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
5847              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
5848           (match_operand:SSEMODE124C8 1 "general_operand" "")
5849           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
5850   "TARGET_SSE2"
5851 {
5852   bool ok = ix86_expand_int_vcond (operands);
5853   gcc_assert (ok);
5854   DONE;
5855 })
5856
5857 (define_expand "vcondu<mode>"
5858   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
5859         (if_then_else:SSEMODE124C8
5860           (match_operator 3 ""
5861             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
5862              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
5863           (match_operand:SSEMODE124C8 1 "general_operand" "")
5864           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
5865   "TARGET_SSE2"
5866 {
5867   bool ok = ix86_expand_int_vcond (operands);
5868   gcc_assert (ok);
5869   DONE;
5870 })
5871
5872 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5873 ;;
5874 ;; Parallel bitwise logical operations
5875 ;;
5876 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5877
5878 (define_expand "one_cmpl<mode>2"
5879   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5880         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
5881                       (match_dup 2)))]
5882   "TARGET_SSE2"
5883 {
5884   int i, n = GET_MODE_NUNITS (<MODE>mode);
5885   rtvec v = rtvec_alloc (n);
5886
5887   for (i = 0; i < n; ++i)
5888     RTVEC_ELT (v, i) = constm1_rtx;
5889
5890   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
5891 })
5892
5893 (define_insn "*avx_andnot<mode>3"
5894   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
5895         (and:AVX256MODEI
5896           (not:AVX256MODEI (match_operand:AVX256MODEI 1 "register_operand" "x"))
5897           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
5898   "TARGET_AVX"
5899   "vandnps\t{%2, %1, %0|%0, %1, %2}"
5900   [(set_attr "type" "sselog")
5901    (set_attr "prefix" "vex")
5902    (set_attr "mode" "<avxvecpsmode>")])
5903
5904 (define_insn "*sse_andnot<mode>3"
5905   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5906         (and:SSEMODEI
5907           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
5908           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5909   "(TARGET_SSE && !TARGET_SSE2)"
5910   "andnps\t{%2, %0|%0, %2}"
5911   [(set_attr "type" "sselog")
5912    (set_attr "mode" "V4SF")])
5913
5914 (define_insn "*avx_andnot<mode>3"
5915   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5916         (and:SSEMODEI
5917           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "x"))
5918           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5919   "TARGET_AVX"
5920   "vpandn\t{%2, %1, %0|%0, %1, %2}"
5921   [(set_attr "type" "sselog")
5922    (set_attr "prefix" "vex")
5923    (set_attr "mode" "TI")])
5924
5925 (define_insn "sse2_andnot<mode>3"
5926   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5927         (and:SSEMODEI
5928           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
5929           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5930   "TARGET_SSE2"
5931   "pandn\t{%2, %0|%0, %2}"
5932   [(set_attr "type" "sselog")
5933    (set_attr "prefix_data16" "1")
5934    (set_attr "mode" "TI")])
5935
5936 (define_insn "*andnottf3"
5937   [(set (match_operand:TF 0 "register_operand" "=x")
5938         (and:TF
5939           (not:TF (match_operand:TF 1 "register_operand" "0"))
5940           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
5941   "TARGET_SSE2"
5942   "pandn\t{%2, %0|%0, %2}"
5943   [(set_attr "type" "sselog")
5944    (set_attr "prefix_data16" "1")
5945    (set_attr "mode" "TI")])
5946
5947 (define_expand "<code><mode>3"
5948   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5949         (plogic:SSEMODEI
5950           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
5951           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
5952   "TARGET_SSE"
5953   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5954
5955 (define_insn "*avx_<code><mode>3"
5956   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
5957         (plogic:AVX256MODEI
5958           (match_operand:AVX256MODEI 1 "nonimmediate_operand" "%x")
5959           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
5960   "TARGET_AVX
5961    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5962   "v<plogicprefix>ps\t{%2, %1, %0|%0, %1, %2}"
5963   [(set_attr "type" "sselog")
5964    (set_attr "prefix" "vex")
5965    (set_attr "mode" "<avxvecpsmode>")])
5966
5967 (define_insn "*sse_<code><mode>3"
5968   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5969         (plogic:SSEMODEI
5970           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
5971           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5972   "(TARGET_SSE && !TARGET_SSE2)
5973    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5974   "<plogicprefix>ps\t{%2, %0|%0, %2}"
5975   [(set_attr "type" "sselog")
5976    (set_attr "mode" "V4SF")])
5977
5978 (define_insn "*avx_<code><mode>3"
5979   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5980         (plogic:SSEMODEI
5981           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%x")
5982           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5983   "TARGET_AVX
5984    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5985   "vp<plogicprefix>\t{%2, %1, %0|%0, %1, %2}"
5986   [(set_attr "type" "sselog")
5987    (set_attr "prefix" "vex")
5988    (set_attr "mode" "TI")])
5989
5990 (define_insn "*sse2_<code><mode>3"
5991   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5992         (plogic:SSEMODEI
5993           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
5994           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5995   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5996   "p<plogicprefix>\t{%2, %0|%0, %2}"
5997   [(set_attr "type" "sselog")
5998    (set_attr "prefix_data16" "1")
5999    (set_attr "mode" "TI")])
6000
6001 (define_expand "<code>tf3"
6002   [(set (match_operand:TF 0 "register_operand" "")
6003         (plogic:TF
6004           (match_operand:TF 1 "nonimmediate_operand" "")
6005           (match_operand:TF 2 "nonimmediate_operand" "")))]
6006   "TARGET_SSE2"
6007   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
6008
6009 (define_insn "*<code>tf3"
6010   [(set (match_operand:TF 0 "register_operand" "=x")
6011         (plogic:TF
6012           (match_operand:TF 1 "nonimmediate_operand" "%0")
6013           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6014   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
6015   "p<plogicprefix>\t{%2, %0|%0, %2}"
6016   [(set_attr "type" "sselog")
6017    (set_attr "prefix_data16" "1")
6018    (set_attr "mode" "TI")])
6019
6020 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6021 ;;
6022 ;; Parallel integral element swizzling
6023 ;;
6024 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6025
6026 ;; Reduce:
6027 ;;      op1 = abcdefghijklmnop
6028 ;;      op2 = qrstuvwxyz012345
6029 ;;       h1 = aqbrcsdteufvgwhx
6030 ;;       l1 = iyjzk0l1m2n3o4p5
6031 ;;       h2 = aiqybjrzcks0dlt1
6032 ;;       l2 = emu2fnv3gow4hpx5
6033 ;;       h3 = aeimquy2bfjnrvz3
6034 ;;       l3 = cgkosw04dhlptx15
6035 ;;   result = bdfhjlnprtvxz135
6036 (define_expand "vec_pack_trunc_v8hi"
6037   [(match_operand:V16QI 0 "register_operand" "")
6038    (match_operand:V8HI 1 "register_operand" "")
6039    (match_operand:V8HI 2 "register_operand" "")]
6040   "TARGET_SSE2"
6041 {
6042   rtx op1, op2, h1, l1, h2, l2, h3, l3;
6043
6044   if (TARGET_SSE5)
6045     {
6046       ix86_expand_sse5_pack (operands);
6047       DONE;
6048     }
6049
6050   op1 = gen_lowpart (V16QImode, operands[1]);
6051   op2 = gen_lowpart (V16QImode, operands[2]);
6052   h1 = gen_reg_rtx (V16QImode);
6053   l1 = gen_reg_rtx (V16QImode);
6054   h2 = gen_reg_rtx (V16QImode);
6055   l2 = gen_reg_rtx (V16QImode);
6056   h3 = gen_reg_rtx (V16QImode);
6057   l3 = gen_reg_rtx (V16QImode);
6058
6059   emit_insn (gen_vec_interleave_highv16qi (h1, op1, op2));
6060   emit_insn (gen_vec_interleave_lowv16qi (l1, op1, op2));
6061   emit_insn (gen_vec_interleave_highv16qi (h2, l1, h1));
6062   emit_insn (gen_vec_interleave_lowv16qi (l2, l1, h1));
6063   emit_insn (gen_vec_interleave_highv16qi (h3, l2, h2));
6064   emit_insn (gen_vec_interleave_lowv16qi (l3, l2, h2));
6065   emit_insn (gen_vec_interleave_lowv16qi (operands[0], l3, h3));
6066   DONE;
6067 })
6068
6069 ;; Reduce:
6070 ;;      op1 = abcdefgh
6071 ;;      op2 = ijklmnop
6072 ;;       h1 = aibjckdl
6073 ;;       l1 = emfngohp
6074 ;;       h2 = aeimbfjn
6075 ;;       l2 = cgkodhlp
6076 ;;   result = bdfhjlnp
6077 (define_expand "vec_pack_trunc_v4si"
6078   [(match_operand:V8HI 0 "register_operand" "")
6079    (match_operand:V4SI 1 "register_operand" "")
6080    (match_operand:V4SI 2 "register_operand" "")]
6081   "TARGET_SSE2"
6082 {
6083   rtx op1, op2, h1, l1, h2, l2;
6084
6085   if (TARGET_SSE5)
6086     {
6087       ix86_expand_sse5_pack (operands);
6088       DONE;
6089     }
6090
6091   op1 = gen_lowpart (V8HImode, operands[1]);
6092   op2 = gen_lowpart (V8HImode, operands[2]);
6093   h1 = gen_reg_rtx (V8HImode);
6094   l1 = gen_reg_rtx (V8HImode);
6095   h2 = gen_reg_rtx (V8HImode);
6096   l2 = gen_reg_rtx (V8HImode);
6097
6098   emit_insn (gen_vec_interleave_highv8hi (h1, op1, op2));
6099   emit_insn (gen_vec_interleave_lowv8hi (l1, op1, op2));
6100   emit_insn (gen_vec_interleave_highv8hi (h2, l1, h1));
6101   emit_insn (gen_vec_interleave_lowv8hi (l2, l1, h1));
6102   emit_insn (gen_vec_interleave_lowv8hi (operands[0], l2, h2));
6103   DONE;
6104 })
6105
6106 ;; Reduce:
6107 ;;     op1 = abcd
6108 ;;     op2 = efgh
6109 ;;      h1 = aebf
6110 ;;      l1 = cgdh
6111 ;;  result = bdfh
6112 (define_expand "vec_pack_trunc_v2di"
6113   [(match_operand:V4SI 0 "register_operand" "")
6114    (match_operand:V2DI 1 "register_operand" "")
6115    (match_operand:V2DI 2 "register_operand" "")]
6116   "TARGET_SSE2"
6117 {
6118   rtx op1, op2, h1, l1;
6119
6120   if (TARGET_SSE5)
6121     {
6122       ix86_expand_sse5_pack (operands);
6123       DONE;
6124     }
6125
6126   op1 = gen_lowpart (V4SImode, operands[1]);
6127   op2 = gen_lowpart (V4SImode, operands[2]);
6128   h1 = gen_reg_rtx (V4SImode);
6129   l1 = gen_reg_rtx (V4SImode);
6130
6131   emit_insn (gen_vec_interleave_highv4si (h1, op1, op2));
6132   emit_insn (gen_vec_interleave_lowv4si (l1, op1, op2));
6133   emit_insn (gen_vec_interleave_lowv4si (operands[0], l1, h1));
6134   DONE;
6135 })
6136
6137 (define_expand "vec_interleave_highv16qi"
6138   [(set (match_operand:V16QI 0 "register_operand" "")
6139         (vec_select:V16QI
6140           (vec_concat:V32QI
6141             (match_operand:V16QI 1 "register_operand" "")
6142             (match_operand:V16QI 2 "nonimmediate_operand" ""))
6143           (parallel [(const_int 8)  (const_int 24)
6144                      (const_int 9)  (const_int 25)
6145                      (const_int 10) (const_int 26)
6146                      (const_int 11) (const_int 27)
6147                      (const_int 12) (const_int 28)
6148                      (const_int 13) (const_int 29)
6149                      (const_int 14) (const_int 30)
6150                      (const_int 15) (const_int 31)])))]
6151   "TARGET_SSE2"
6152 {
6153   emit_insn (gen_sse2_punpckhbw (operands[0], operands[1], operands[2]));
6154   DONE;
6155 })
6156
6157 (define_expand "vec_interleave_lowv16qi"
6158   [(set (match_operand:V16QI 0 "register_operand" "")
6159         (vec_select:V16QI
6160           (vec_concat:V32QI
6161             (match_operand:V16QI 1 "register_operand" "")
6162             (match_operand:V16QI 2 "nonimmediate_operand" ""))
6163           (parallel [(const_int 0) (const_int 16)
6164                      (const_int 1) (const_int 17)
6165                      (const_int 2) (const_int 18)
6166                      (const_int 3) (const_int 19)
6167                      (const_int 4) (const_int 20)
6168                      (const_int 5) (const_int 21)
6169                      (const_int 6) (const_int 22)
6170                      (const_int 7) (const_int 23)])))]
6171   "TARGET_SSE2"
6172 {
6173   emit_insn (gen_sse2_punpcklbw (operands[0], operands[1], operands[2]));
6174   DONE;
6175 })
6176
6177 (define_expand "vec_interleave_highv8hi"
6178   [(set (match_operand:V8HI 0 "register_operand" "=")
6179         (vec_select:V8HI
6180           (vec_concat:V16HI
6181             (match_operand:V8HI 1 "register_operand" "")
6182             (match_operand:V8HI 2 "nonimmediate_operand" ""))
6183           (parallel [(const_int 4) (const_int 12)
6184                      (const_int 5) (const_int 13)
6185                      (const_int 6) (const_int 14)
6186                      (const_int 7) (const_int 15)])))]
6187   "TARGET_SSE2"
6188 {
6189   emit_insn (gen_sse2_punpckhwd (operands[0], operands[1], operands[2]));
6190   DONE;
6191 })
6192
6193 (define_expand "vec_interleave_lowv8hi"
6194   [(set (match_operand:V8HI 0 "register_operand" "")
6195         (vec_select:V8HI
6196           (vec_concat:V16HI
6197             (match_operand:V8HI 1 "register_operand" "")
6198             (match_operand:V8HI 2 "nonimmediate_operand" ""))
6199           (parallel [(const_int 0) (const_int 8)
6200                      (const_int 1) (const_int 9)
6201                      (const_int 2) (const_int 10)
6202                      (const_int 3) (const_int 11)])))]
6203   "TARGET_SSE2"
6204 {
6205   emit_insn (gen_sse2_punpcklwd (operands[0], operands[1], operands[2]));
6206   DONE;
6207 })
6208
6209 (define_expand "vec_interleave_highv4si"
6210   [(set (match_operand:V4SI 0 "register_operand" "")
6211         (vec_select:V4SI
6212           (vec_concat:V8SI
6213             (match_operand:V4SI 1 "register_operand" "")
6214             (match_operand:V4SI 2 "nonimmediate_operand" ""))
6215           (parallel [(const_int 2) (const_int 6)
6216                      (const_int 3) (const_int 7)])))]
6217   "TARGET_SSE2"
6218 {
6219   emit_insn (gen_sse2_punpckhdq (operands[0], operands[1], operands[2]));
6220   DONE;
6221 })
6222
6223 (define_expand "vec_interleave_lowv4si"
6224   [(set (match_operand:V4SI 0 "register_operand" "")
6225         (vec_select:V4SI
6226           (vec_concat:V8SI
6227             (match_operand:V4SI 1 "register_operand" "")
6228             (match_operand:V4SI 2 "nonimmediate_operand" ""))
6229           (parallel [(const_int 0) (const_int 4)
6230                      (const_int 1) (const_int 5)])))]
6231   "TARGET_SSE2"
6232 {
6233   emit_insn (gen_sse2_punpckldq (operands[0], operands[1], operands[2]));
6234   DONE;
6235 })
6236
6237 (define_expand "vec_interleave_highv2di"
6238   [(set (match_operand:V2DI 0 "register_operand" "")
6239         (vec_select:V2DI
6240           (vec_concat:V4DI
6241             (match_operand:V2DI 1 "register_operand" "")
6242             (match_operand:V2DI 2 "nonimmediate_operand" ""))
6243           (parallel [(const_int 1)
6244                      (const_int 3)])))]
6245   "TARGET_SSE2"
6246 {
6247   emit_insn (gen_sse2_punpckhqdq (operands[0], operands[1], operands[2]));
6248   DONE;
6249 })
6250
6251 (define_expand "vec_interleave_lowv2di"
6252   [(set (match_operand:V2DI 0 "register_operand" "")
6253         (vec_select:V2DI
6254           (vec_concat:V4DI
6255             (match_operand:V2DI 1 "register_operand" "")
6256             (match_operand:V2DI 2 "nonimmediate_operand" ""))
6257           (parallel [(const_int 0)
6258                      (const_int 2)])))]
6259   "TARGET_SSE2"
6260 {
6261   emit_insn (gen_sse2_punpcklqdq (operands[0], operands[1], operands[2]));
6262   DONE;
6263 })
6264
6265 (define_expand "vec_interleave_highv4sf"
6266   [(set (match_operand:V4SF 0 "register_operand" "")
6267         (vec_select:V4SF
6268           (vec_concat:V8SF
6269             (match_operand:V4SF 1 "register_operand" "")
6270             (match_operand:V4SF 2 "nonimmediate_operand" ""))
6271           (parallel [(const_int 2) (const_int 6)
6272                      (const_int 3) (const_int 7)])))]
6273   "TARGET_SSE")
6274
6275 (define_expand "vec_interleave_lowv4sf"
6276   [(set (match_operand:V4SF 0 "register_operand" "")
6277         (vec_select:V4SF
6278           (vec_concat:V8SF
6279             (match_operand:V4SF 1 "register_operand" "")
6280             (match_operand:V4SF 2 "nonimmediate_operand" ""))
6281           (parallel [(const_int 0) (const_int 4)
6282                      (const_int 1) (const_int 5)])))]
6283   "TARGET_SSE")
6284
6285 (define_expand "vec_interleave_highv2df"
6286   [(set (match_operand:V2DF 0 "register_operand" "")
6287         (vec_select:V2DF
6288           (vec_concat:V4DF
6289             (match_operand:V2DF 1 "register_operand" "")
6290             (match_operand:V2DF 2 "nonimmediate_operand" ""))
6291           (parallel [(const_int 1)
6292                      (const_int 3)])))]
6293   "TARGET_SSE2")
6294
6295 (define_expand "vec_interleave_lowv2df"
6296   [(set (match_operand:V2DF 0 "register_operand" "")
6297         (vec_select:V2DF
6298           (vec_concat:V4DF
6299             (match_operand:V2DF 1 "register_operand" "")
6300             (match_operand:V2DF 2 "nonimmediate_operand" ""))
6301           (parallel [(const_int 0)
6302                      (const_int 2)])))]
6303   "TARGET_SSE2")
6304
6305 (define_insn "*avx_packsswb"
6306   [(set (match_operand:V16QI 0 "register_operand" "=x")
6307         (vec_concat:V16QI
6308           (ss_truncate:V8QI
6309             (match_operand:V8HI 1 "register_operand" "x"))
6310           (ss_truncate:V8QI
6311             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6312   "TARGET_AVX"
6313   "vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6314   [(set_attr "type" "sselog")
6315    (set_attr "prefix" "vex")
6316    (set_attr "mode" "TI")])
6317
6318 (define_insn "sse2_packsswb"
6319   [(set (match_operand:V16QI 0 "register_operand" "=x")
6320         (vec_concat:V16QI
6321           (ss_truncate:V8QI
6322             (match_operand:V8HI 1 "register_operand" "0"))
6323           (ss_truncate:V8QI
6324             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6325   "TARGET_SSE2"
6326   "packsswb\t{%2, %0|%0, %2}"
6327   [(set_attr "type" "sselog")
6328    (set_attr "prefix_data16" "1")
6329    (set_attr "mode" "TI")])
6330
6331 (define_insn "*avx_packssdw"
6332   [(set (match_operand:V8HI 0 "register_operand" "=x")
6333         (vec_concat:V8HI
6334           (ss_truncate:V4HI
6335             (match_operand:V4SI 1 "register_operand" "x"))
6336           (ss_truncate:V4HI
6337             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6338   "TARGET_AVX"
6339   "vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6340   [(set_attr "type" "sselog")
6341    (set_attr "prefix" "vex")
6342    (set_attr "mode" "TI")])
6343
6344 (define_insn "sse2_packssdw"
6345   [(set (match_operand:V8HI 0 "register_operand" "=x")
6346         (vec_concat:V8HI
6347           (ss_truncate:V4HI
6348             (match_operand:V4SI 1 "register_operand" "0"))
6349           (ss_truncate:V4HI
6350             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6351   "TARGET_SSE2"
6352   "packssdw\t{%2, %0|%0, %2}"
6353   [(set_attr "type" "sselog")
6354    (set_attr "prefix_data16" "1")
6355    (set_attr "mode" "TI")])
6356
6357 (define_insn "*avx_packuswb"
6358   [(set (match_operand:V16QI 0 "register_operand" "=x")
6359         (vec_concat:V16QI
6360           (us_truncate:V8QI
6361             (match_operand:V8HI 1 "register_operand" "x"))
6362           (us_truncate:V8QI
6363             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6364   "TARGET_AVX"
6365   "vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6366   [(set_attr "type" "sselog")
6367    (set_attr "prefix" "vex")
6368    (set_attr "mode" "TI")])
6369
6370 (define_insn "sse2_packuswb"
6371   [(set (match_operand:V16QI 0 "register_operand" "=x")
6372         (vec_concat:V16QI
6373           (us_truncate:V8QI
6374             (match_operand:V8HI 1 "register_operand" "0"))
6375           (us_truncate:V8QI
6376             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6377   "TARGET_SSE2"
6378   "packuswb\t{%2, %0|%0, %2}"
6379   [(set_attr "type" "sselog")
6380    (set_attr "prefix_data16" "1")
6381    (set_attr "mode" "TI")])
6382
6383 (define_insn "*avx_punpckhbw"
6384   [(set (match_operand:V16QI 0 "register_operand" "=x")
6385         (vec_select:V16QI
6386           (vec_concat:V32QI
6387             (match_operand:V16QI 1 "register_operand" "x")
6388             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6389           (parallel [(const_int 8)  (const_int 24)
6390                      (const_int 9)  (const_int 25)
6391                      (const_int 10) (const_int 26)
6392                      (const_int 11) (const_int 27)
6393                      (const_int 12) (const_int 28)
6394                      (const_int 13) (const_int 29)
6395                      (const_int 14) (const_int 30)
6396                      (const_int 15) (const_int 31)])))]
6397   "TARGET_AVX"
6398   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6399   [(set_attr "type" "sselog")
6400    (set_attr "prefix" "vex")
6401    (set_attr "mode" "TI")])
6402
6403 (define_insn "sse2_punpckhbw"
6404   [(set (match_operand:V16QI 0 "register_operand" "=x")
6405         (vec_select:V16QI
6406           (vec_concat:V32QI
6407             (match_operand:V16QI 1 "register_operand" "0")
6408             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6409           (parallel [(const_int 8)  (const_int 24)
6410                      (const_int 9)  (const_int 25)
6411                      (const_int 10) (const_int 26)
6412                      (const_int 11) (const_int 27)
6413                      (const_int 12) (const_int 28)
6414                      (const_int 13) (const_int 29)
6415                      (const_int 14) (const_int 30)
6416                      (const_int 15) (const_int 31)])))]
6417   "TARGET_SSE2"
6418   "punpckhbw\t{%2, %0|%0, %2}"
6419   [(set_attr "type" "sselog")
6420    (set_attr "prefix_data16" "1")
6421    (set_attr "mode" "TI")])
6422
6423 (define_insn "*avx_punpcklbw"
6424   [(set (match_operand:V16QI 0 "register_operand" "=x")
6425         (vec_select:V16QI
6426           (vec_concat:V32QI
6427             (match_operand:V16QI 1 "register_operand" "x")
6428             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6429           (parallel [(const_int 0) (const_int 16)
6430                      (const_int 1) (const_int 17)
6431                      (const_int 2) (const_int 18)
6432                      (const_int 3) (const_int 19)
6433                      (const_int 4) (const_int 20)
6434                      (const_int 5) (const_int 21)
6435                      (const_int 6) (const_int 22)
6436                      (const_int 7) (const_int 23)])))]
6437   "TARGET_AVX"
6438   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6439   [(set_attr "type" "sselog")
6440    (set_attr "prefix" "vex")
6441    (set_attr "mode" "TI")])
6442
6443 (define_insn "sse2_punpcklbw"
6444   [(set (match_operand:V16QI 0 "register_operand" "=x")
6445         (vec_select:V16QI
6446           (vec_concat:V32QI
6447             (match_operand:V16QI 1 "register_operand" "0")
6448             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6449           (parallel [(const_int 0) (const_int 16)
6450                      (const_int 1) (const_int 17)
6451                      (const_int 2) (const_int 18)
6452                      (const_int 3) (const_int 19)
6453                      (const_int 4) (const_int 20)
6454                      (const_int 5) (const_int 21)
6455                      (const_int 6) (const_int 22)
6456                      (const_int 7) (const_int 23)])))]
6457   "TARGET_SSE2"
6458   "punpcklbw\t{%2, %0|%0, %2}"
6459   [(set_attr "type" "sselog")
6460    (set_attr "prefix_data16" "1")
6461    (set_attr "mode" "TI")])
6462
6463 (define_insn "*avx_punpckhwd"
6464   [(set (match_operand:V8HI 0 "register_operand" "=x")
6465         (vec_select:V8HI
6466           (vec_concat:V16HI
6467             (match_operand:V8HI 1 "register_operand" "x")
6468             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6469           (parallel [(const_int 4) (const_int 12)
6470                      (const_int 5) (const_int 13)
6471                      (const_int 6) (const_int 14)
6472                      (const_int 7) (const_int 15)])))]
6473   "TARGET_AVX"
6474   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6475   [(set_attr "type" "sselog")
6476    (set_attr "prefix" "vex")
6477    (set_attr "mode" "TI")])
6478
6479 (define_insn "sse2_punpckhwd"
6480   [(set (match_operand:V8HI 0 "register_operand" "=x")
6481         (vec_select:V8HI
6482           (vec_concat:V16HI
6483             (match_operand:V8HI 1 "register_operand" "0")
6484             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6485           (parallel [(const_int 4) (const_int 12)
6486                      (const_int 5) (const_int 13)
6487                      (const_int 6) (const_int 14)
6488                      (const_int 7) (const_int 15)])))]
6489   "TARGET_SSE2"
6490   "punpckhwd\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 "*avx_punpcklwd"
6496   [(set (match_operand:V8HI 0 "register_operand" "=x")
6497         (vec_select:V8HI
6498           (vec_concat:V16HI
6499             (match_operand:V8HI 1 "register_operand" "x")
6500             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6501           (parallel [(const_int 0) (const_int 8)
6502                      (const_int 1) (const_int 9)
6503                      (const_int 2) (const_int 10)
6504                      (const_int 3) (const_int 11)])))]
6505   "TARGET_AVX"
6506   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6507   [(set_attr "type" "sselog")
6508    (set_attr "prefix" "vex")
6509    (set_attr "mode" "TI")])
6510
6511 (define_insn "sse2_punpcklwd"
6512   [(set (match_operand:V8HI 0 "register_operand" "=x")
6513         (vec_select:V8HI
6514           (vec_concat:V16HI
6515             (match_operand:V8HI 1 "register_operand" "0")
6516             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6517           (parallel [(const_int 0) (const_int 8)
6518                      (const_int 1) (const_int 9)
6519                      (const_int 2) (const_int 10)
6520                      (const_int 3) (const_int 11)])))]
6521   "TARGET_SSE2"
6522   "punpcklwd\t{%2, %0|%0, %2}"
6523   [(set_attr "type" "sselog")
6524    (set_attr "prefix_data16" "1")
6525    (set_attr "mode" "TI")])
6526
6527 (define_insn "*avx_punpckhdq"
6528   [(set (match_operand:V4SI 0 "register_operand" "=x")
6529         (vec_select:V4SI
6530           (vec_concat:V8SI
6531             (match_operand:V4SI 1 "register_operand" "x")
6532             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6533           (parallel [(const_int 2) (const_int 6)
6534                      (const_int 3) (const_int 7)])))]
6535   "TARGET_AVX"
6536   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6537   [(set_attr "type" "sselog")
6538    (set_attr "prefix" "vex")
6539    (set_attr "mode" "TI")])
6540
6541 (define_insn "sse2_punpckhdq"
6542   [(set (match_operand:V4SI 0 "register_operand" "=x")
6543         (vec_select:V4SI
6544           (vec_concat:V8SI
6545             (match_operand:V4SI 1 "register_operand" "0")
6546             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6547           (parallel [(const_int 2) (const_int 6)
6548                      (const_int 3) (const_int 7)])))]
6549   "TARGET_SSE2"
6550   "punpckhdq\t{%2, %0|%0, %2}"
6551   [(set_attr "type" "sselog")
6552    (set_attr "prefix_data16" "1")
6553    (set_attr "mode" "TI")])
6554
6555 (define_insn "*avx_punpckldq"
6556   [(set (match_operand:V4SI 0 "register_operand" "=x")
6557         (vec_select:V4SI
6558           (vec_concat:V8SI
6559             (match_operand:V4SI 1 "register_operand" "x")
6560             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6561           (parallel [(const_int 0) (const_int 4)
6562                      (const_int 1) (const_int 5)])))]
6563   "TARGET_AVX"
6564   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6565   [(set_attr "type" "sselog")
6566    (set_attr "prefix" "vex")
6567    (set_attr "mode" "TI")])
6568
6569 (define_insn "sse2_punpckldq"
6570   [(set (match_operand:V4SI 0 "register_operand" "=x")
6571         (vec_select:V4SI
6572           (vec_concat:V8SI
6573             (match_operand:V4SI 1 "register_operand" "0")
6574             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6575           (parallel [(const_int 0) (const_int 4)
6576                      (const_int 1) (const_int 5)])))]
6577   "TARGET_SSE2"
6578   "punpckldq\t{%2, %0|%0, %2}"
6579   [(set_attr "type" "sselog")
6580    (set_attr "prefix_data16" "1")
6581    (set_attr "mode" "TI")])
6582
6583 (define_insn "*avx_pinsr<avxmodesuffixs>"
6584   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6585         (vec_merge:SSEMODE124
6586           (vec_duplicate:SSEMODE124
6587             (match_operand:<avxscalarmode> 2 "nonimmediate_operand" "rm"))
6588           (match_operand:SSEMODE124 1 "register_operand" "x")
6589           (match_operand:SI 3 "const_pow2_1_to_<pinsrbits>_operand" "n")))]
6590   "TARGET_AVX"
6591 {
6592   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6593   return "vpinsr<avxmodesuffixs>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6594 }
6595   [(set_attr "type" "sselog")
6596    (set_attr "prefix" "vex")
6597    (set_attr "mode" "TI")])
6598
6599 (define_insn "*sse4_1_pinsrb"
6600   [(set (match_operand:V16QI 0 "register_operand" "=x")
6601         (vec_merge:V16QI
6602           (vec_duplicate:V16QI
6603             (match_operand:QI 2 "nonimmediate_operand" "rm"))
6604           (match_operand:V16QI 1 "register_operand" "0")
6605           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
6606   "TARGET_SSE4_1"
6607 {
6608   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6609   return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
6610 }
6611   [(set_attr "type" "sselog")
6612    (set_attr "prefix_extra" "1")
6613    (set_attr "mode" "TI")])
6614
6615 (define_insn "*sse2_pinsrw"
6616   [(set (match_operand:V8HI 0 "register_operand" "=x")
6617         (vec_merge:V8HI
6618           (vec_duplicate:V8HI
6619             (match_operand:HI 2 "nonimmediate_operand" "rm"))
6620           (match_operand:V8HI 1 "register_operand" "0")
6621           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
6622   "TARGET_SSE2"
6623 {
6624   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6625   return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
6626 }
6627   [(set_attr "type" "sselog")
6628    (set_attr "prefix_data16" "1")
6629    (set_attr "mode" "TI")])
6630
6631 ;; It must come before sse2_loadld since it is preferred.
6632 (define_insn "*sse4_1_pinsrd"
6633   [(set (match_operand:V4SI 0 "register_operand" "=x")
6634         (vec_merge:V4SI
6635           (vec_duplicate:V4SI
6636             (match_operand:SI 2 "nonimmediate_operand" "rm"))
6637           (match_operand:V4SI 1 "register_operand" "0")
6638           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
6639   "TARGET_SSE4_1"
6640 {
6641   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6642   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
6643 }
6644   [(set_attr "type" "sselog")
6645    (set_attr "prefix_extra" "1")
6646    (set_attr "mode" "TI")])
6647
6648 (define_insn "*avx_pinsrq"
6649   [(set (match_operand:V2DI 0 "register_operand" "=x")
6650         (vec_merge:V2DI
6651           (vec_duplicate:V2DI
6652             (match_operand:DI 2 "nonimmediate_operand" "rm"))
6653           (match_operand:V2DI 1 "register_operand" "x")
6654           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
6655   "TARGET_AVX && TARGET_64BIT"
6656 {
6657   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6658   return "vpinsrq\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6659 }
6660   [(set_attr "type" "sselog")
6661    (set_attr "prefix" "vex")
6662    (set_attr "mode" "TI")])
6663
6664 (define_insn "*sse4_1_pinsrq"
6665   [(set (match_operand:V2DI 0 "register_operand" "=x")
6666         (vec_merge:V2DI
6667           (vec_duplicate:V2DI
6668             (match_operand:DI 2 "nonimmediate_operand" "rm"))
6669           (match_operand:V2DI 1 "register_operand" "0")
6670           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
6671   "TARGET_SSE4_1 && TARGET_64BIT"
6672 {
6673   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6674   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
6675 }
6676   [(set_attr "type" "sselog")
6677    (set_attr "prefix_extra" "1")
6678    (set_attr "mode" "TI")])
6679
6680 (define_insn "*sse4_1_pextrb"
6681   [(set (match_operand:SI 0 "register_operand" "=r")
6682         (zero_extend:SI
6683           (vec_select:QI
6684             (match_operand:V16QI 1 "register_operand" "x")
6685             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
6686   "TARGET_SSE4_1"
6687   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
6688   [(set_attr "type" "sselog")
6689    (set_attr "prefix_extra" "1")
6690    (set_attr "prefix" "maybe_vex")
6691    (set_attr "mode" "TI")])
6692
6693 (define_insn "*sse4_1_pextrb_memory"
6694   [(set (match_operand:QI 0 "memory_operand" "=m")
6695         (vec_select:QI
6696           (match_operand:V16QI 1 "register_operand" "x")
6697           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
6698   "TARGET_SSE4_1"
6699   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
6700   [(set_attr "type" "sselog")
6701    (set_attr "prefix_extra" "1")
6702    (set_attr "prefix" "maybe_vex")
6703    (set_attr "mode" "TI")])
6704
6705 (define_insn "*sse2_pextrw"
6706   [(set (match_operand:SI 0 "register_operand" "=r")
6707         (zero_extend:SI
6708           (vec_select:HI
6709             (match_operand:V8HI 1 "register_operand" "x")
6710             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
6711   "TARGET_SSE2"
6712   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
6713   [(set_attr "type" "sselog")
6714    (set_attr "prefix_data16" "1")
6715    (set_attr "prefix" "maybe_vex")
6716    (set_attr "mode" "TI")])
6717
6718 (define_insn "*sse4_1_pextrw_memory"
6719   [(set (match_operand:HI 0 "memory_operand" "=m")
6720         (vec_select:HI
6721           (match_operand:V8HI 1 "register_operand" "x")
6722           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
6723   "TARGET_SSE4_1"
6724   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
6725   [(set_attr "type" "sselog")
6726    (set_attr "prefix_extra" "1")
6727    (set_attr "prefix" "maybe_vex")
6728    (set_attr "mode" "TI")])
6729
6730 (define_insn "*sse4_1_pextrd"
6731   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
6732         (vec_select:SI
6733           (match_operand:V4SI 1 "register_operand" "x")
6734           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
6735   "TARGET_SSE4_1"
6736   "%vpextrd\t{%2, %1, %0|%0, %1, %2}"
6737   [(set_attr "type" "sselog")
6738    (set_attr "prefix_extra" "1")
6739    (set_attr "prefix" "maybe_vex")
6740    (set_attr "mode" "TI")])
6741
6742 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
6743 (define_insn "*sse4_1_pextrq"
6744   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
6745         (vec_select:DI
6746           (match_operand:V2DI 1 "register_operand" "x")
6747           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
6748   "TARGET_SSE4_1 && TARGET_64BIT"
6749   "%vpextrq\t{%2, %1, %0|%0, %1, %2}"
6750   [(set_attr "type" "sselog")
6751    (set_attr "prefix_extra" "1")
6752    (set_attr "prefix" "maybe_vex")
6753    (set_attr "mode" "TI")])
6754
6755 (define_expand "sse2_pshufd"
6756   [(match_operand:V4SI 0 "register_operand" "")
6757    (match_operand:V4SI 1 "nonimmediate_operand" "")
6758    (match_operand:SI 2 "const_int_operand" "")]
6759   "TARGET_SSE2"
6760 {
6761   int mask = INTVAL (operands[2]);
6762   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
6763                                 GEN_INT ((mask >> 0) & 3),
6764                                 GEN_INT ((mask >> 2) & 3),
6765                                 GEN_INT ((mask >> 4) & 3),
6766                                 GEN_INT ((mask >> 6) & 3)));
6767   DONE;
6768 })
6769
6770 (define_insn "sse2_pshufd_1"
6771   [(set (match_operand:V4SI 0 "register_operand" "=x")
6772         (vec_select:V4SI
6773           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
6774           (parallel [(match_operand 2 "const_0_to_3_operand" "")
6775                      (match_operand 3 "const_0_to_3_operand" "")
6776                      (match_operand 4 "const_0_to_3_operand" "")
6777                      (match_operand 5 "const_0_to_3_operand" "")])))]
6778   "TARGET_SSE2"
6779 {
6780   int mask = 0;
6781   mask |= INTVAL (operands[2]) << 0;
6782   mask |= INTVAL (operands[3]) << 2;
6783   mask |= INTVAL (operands[4]) << 4;
6784   mask |= INTVAL (operands[5]) << 6;
6785   operands[2] = GEN_INT (mask);
6786
6787   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
6788 }
6789   [(set_attr "type" "sselog1")
6790    (set_attr "prefix_data16" "1")
6791    (set_attr "prefix" "vex")
6792    (set_attr "mode" "TI")])
6793
6794 (define_expand "sse2_pshuflw"
6795   [(match_operand:V8HI 0 "register_operand" "")
6796    (match_operand:V8HI 1 "nonimmediate_operand" "")
6797    (match_operand:SI 2 "const_int_operand" "")]
6798   "TARGET_SSE2"
6799 {
6800   int mask = INTVAL (operands[2]);
6801   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
6802                                  GEN_INT ((mask >> 0) & 3),
6803                                  GEN_INT ((mask >> 2) & 3),
6804                                  GEN_INT ((mask >> 4) & 3),
6805                                  GEN_INT ((mask >> 6) & 3)));
6806   DONE;
6807 })
6808
6809 (define_insn "sse2_pshuflw_1"
6810   [(set (match_operand:V8HI 0 "register_operand" "=x")
6811         (vec_select:V8HI
6812           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
6813           (parallel [(match_operand 2 "const_0_to_3_operand" "")
6814                      (match_operand 3 "const_0_to_3_operand" "")
6815                      (match_operand 4 "const_0_to_3_operand" "")
6816                      (match_operand 5 "const_0_to_3_operand" "")
6817                      (const_int 4)
6818                      (const_int 5)
6819                      (const_int 6)
6820                      (const_int 7)])))]
6821   "TARGET_SSE2"
6822 {
6823   int mask = 0;
6824   mask |= INTVAL (operands[2]) << 0;
6825   mask |= INTVAL (operands[3]) << 2;
6826   mask |= INTVAL (operands[4]) << 4;
6827   mask |= INTVAL (operands[5]) << 6;
6828   operands[2] = GEN_INT (mask);
6829
6830   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
6831 }
6832   [(set_attr "type" "sselog")
6833    (set_attr "prefix_rep" "1")
6834    (set_attr "prefix" "maybe_vex")
6835    (set_attr "mode" "TI")])
6836
6837 (define_expand "sse2_pshufhw"
6838   [(match_operand:V8HI 0 "register_operand" "")
6839    (match_operand:V8HI 1 "nonimmediate_operand" "")
6840    (match_operand:SI 2 "const_int_operand" "")]
6841   "TARGET_SSE2"
6842 {
6843   int mask = INTVAL (operands[2]);
6844   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
6845                                  GEN_INT (((mask >> 0) & 3) + 4),
6846                                  GEN_INT (((mask >> 2) & 3) + 4),
6847                                  GEN_INT (((mask >> 4) & 3) + 4),
6848                                  GEN_INT (((mask >> 6) & 3) + 4)));
6849   DONE;
6850 })
6851
6852 (define_insn "sse2_pshufhw_1"
6853   [(set (match_operand:V8HI 0 "register_operand" "=x")
6854         (vec_select:V8HI
6855           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
6856           (parallel [(const_int 0)
6857                      (const_int 1)
6858                      (const_int 2)
6859                      (const_int 3)
6860                      (match_operand 2 "const_4_to_7_operand" "")
6861                      (match_operand 3 "const_4_to_7_operand" "")
6862                      (match_operand 4 "const_4_to_7_operand" "")
6863                      (match_operand 5 "const_4_to_7_operand" "")])))]
6864   "TARGET_SSE2"
6865 {
6866   int mask = 0;
6867   mask |= (INTVAL (operands[2]) - 4) << 0;
6868   mask |= (INTVAL (operands[3]) - 4) << 2;
6869   mask |= (INTVAL (operands[4]) - 4) << 4;
6870   mask |= (INTVAL (operands[5]) - 4) << 6;
6871   operands[2] = GEN_INT (mask);
6872
6873   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
6874 }
6875   [(set_attr "type" "sselog")
6876    (set_attr "prefix_rep" "1")
6877    (set_attr "prefix" "maybe_vex")
6878    (set_attr "mode" "TI")])
6879
6880 (define_expand "sse2_loadd"
6881   [(set (match_operand:V4SI 0 "register_operand" "")
6882         (vec_merge:V4SI
6883           (vec_duplicate:V4SI
6884             (match_operand:SI 1 "nonimmediate_operand" ""))
6885           (match_dup 2)
6886           (const_int 1)))]
6887   "TARGET_SSE"
6888   "operands[2] = CONST0_RTX (V4SImode);")
6889
6890 (define_insn "*avx_loadld"
6891   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x")
6892         (vec_merge:V4SI
6893           (vec_duplicate:V4SI
6894             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,x"))
6895           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,x")
6896           (const_int 1)))]
6897   "TARGET_AVX"
6898   "@
6899    vmovd\t{%2, %0|%0, %2}
6900    vmovd\t{%2, %0|%0, %2}
6901    vmovss\t{%2, %1, %0|%0, %1, %2}"
6902   [(set_attr "type" "ssemov")
6903    (set_attr "prefix" "vex")
6904    (set_attr "mode" "TI,TI,V4SF")])
6905
6906 (define_insn "sse2_loadld"
6907   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,Yi,x,x")
6908         (vec_merge:V4SI
6909           (vec_duplicate:V4SI
6910             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
6911           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
6912           (const_int 1)))]
6913   "TARGET_SSE"
6914   "@
6915    movd\t{%2, %0|%0, %2}
6916    movd\t{%2, %0|%0, %2}
6917    movss\t{%2, %0|%0, %2}
6918    movss\t{%2, %0|%0, %2}"
6919   [(set_attr "type" "ssemov")
6920    (set_attr "mode" "TI,TI,V4SF,SF")])
6921
6922 (define_insn_and_split "sse2_stored"
6923   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
6924         (vec_select:SI
6925           (match_operand:V4SI 1 "register_operand" "x,Yi")
6926           (parallel [(const_int 0)])))]
6927   "TARGET_SSE"
6928   "#"
6929   "&& reload_completed
6930    && (TARGET_INTER_UNIT_MOVES
6931        || MEM_P (operands [0])
6932        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
6933   [(set (match_dup 0) (match_dup 1))]
6934 {
6935   operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));
6936 })
6937
6938 (define_insn_and_split "*vec_ext_v4si_mem"
6939   [(set (match_operand:SI 0 "register_operand" "=r")
6940         (vec_select:SI
6941           (match_operand:V4SI 1 "memory_operand" "o")
6942           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
6943   ""
6944   "#"
6945   "reload_completed"
6946   [(const_int 0)]
6947 {
6948   int i = INTVAL (operands[2]);
6949
6950   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
6951   DONE;
6952 })
6953
6954 (define_expand "sse_storeq"
6955   [(set (match_operand:DI 0 "nonimmediate_operand" "")
6956         (vec_select:DI
6957           (match_operand:V2DI 1 "register_operand" "")
6958           (parallel [(const_int 0)])))]
6959   "TARGET_SSE"
6960   "")
6961
6962 (define_insn "*sse2_storeq_rex64"
6963   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,*r,r")
6964         (vec_select:DI
6965           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
6966           (parallel [(const_int 0)])))]
6967   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6968   "@
6969    #
6970    #
6971    %vmov{q}\t{%1, %0|%0, %1}"
6972   [(set_attr "type" "*,*,imov")
6973    (set_attr "prefix" "*,*,maybe_vex")
6974    (set_attr "mode" "*,*,DI")])
6975
6976 (define_insn "*sse2_storeq"
6977   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
6978         (vec_select:DI
6979           (match_operand:V2DI 1 "register_operand" "x")
6980           (parallel [(const_int 0)])))]
6981   "TARGET_SSE"
6982   "#")
6983
6984 (define_split
6985   [(set (match_operand:DI 0 "nonimmediate_operand" "")
6986         (vec_select:DI
6987           (match_operand:V2DI 1 "register_operand" "")
6988           (parallel [(const_int 0)])))]
6989   "TARGET_SSE
6990    && reload_completed
6991    && (TARGET_INTER_UNIT_MOVES
6992        || MEM_P (operands [0])
6993        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
6994   [(set (match_dup 0) (match_dup 1))]
6995 {
6996   operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));
6997 })
6998
6999 (define_insn "*vec_extractv2di_1_rex64_avx"
7000   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7001         (vec_select:DI
7002           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o,o")
7003           (parallel [(const_int 1)])))]
7004   "TARGET_64BIT
7005    && TARGET_AVX
7006    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7007   "@
7008    vmovhps\t{%1, %0|%0, %1}
7009    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7010    vmovq\t{%H1, %0|%0, %H1}
7011    vmov{q}\t{%H1, %0|%0, %H1}"
7012   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7013    (set_attr "memory" "*,none,*,*")
7014    (set_attr "prefix" "vex")
7015    (set_attr "mode" "V2SF,TI,TI,DI")])
7016
7017 (define_insn "*vec_extractv2di_1_rex64"
7018   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7019         (vec_select:DI
7020           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
7021           (parallel [(const_int 1)])))]
7022   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7023   "@
7024    movhps\t{%1, %0|%0, %1}
7025    psrldq\t{$8, %0|%0, 8}
7026    movq\t{%H1, %0|%0, %H1}
7027    mov{q}\t{%H1, %0|%0, %H1}"
7028   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7029    (set_attr "memory" "*,none,*,*")
7030    (set_attr "mode" "V2SF,TI,TI,DI")])
7031
7032 (define_insn "*vec_extractv2di_1_avx"
7033   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7034         (vec_select:DI
7035           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7036           (parallel [(const_int 1)])))]
7037   "!TARGET_64BIT
7038    && TARGET_AVX
7039    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7040   "@
7041    vmovhps\t{%1, %0|%0, %1}
7042    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7043    vmovq\t{%H1, %0|%0, %H1}"
7044   [(set_attr "type" "ssemov,sseishft,ssemov")
7045    (set_attr "memory" "*,none,*")
7046    (set_attr "prefix" "vex")
7047    (set_attr "mode" "V2SF,TI,TI")])
7048
7049 (define_insn "*vec_extractv2di_1_sse2"
7050   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7051         (vec_select:DI
7052           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
7053           (parallel [(const_int 1)])))]
7054   "!TARGET_64BIT
7055    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7056   "@
7057    movhps\t{%1, %0|%0, %1}
7058    psrldq\t{$8, %0|%0, 8}
7059    movq\t{%H1, %0|%0, %H1}"
7060   [(set_attr "type" "ssemov,sseishft,ssemov")
7061    (set_attr "memory" "*,none,*")
7062    (set_attr "mode" "V2SF,TI,TI")])
7063
7064 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
7065 (define_insn "*vec_extractv2di_1_sse"
7066   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7067         (vec_select:DI
7068           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7069           (parallel [(const_int 1)])))]
7070   "!TARGET_SSE2 && TARGET_SSE
7071    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7072   "@
7073    movhps\t{%1, %0|%0, %1}
7074    movhlps\t{%1, %0|%0, %1}
7075    movlps\t{%H1, %0|%0, %H1}"
7076   [(set_attr "type" "ssemov")
7077    (set_attr "mode" "V2SF,V4SF,V2SF")])
7078
7079 (define_insn "*vec_dupv4si"
7080   [(set (match_operand:V4SI 0 "register_operand" "=Y2,x")
7081         (vec_duplicate:V4SI
7082           (match_operand:SI 1 "register_operand" " Y2,0")))]
7083   "TARGET_SSE"
7084   "@
7085    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7086    shufps\t{$0, %0, %0|%0, %0, 0}"
7087   [(set_attr "type" "sselog1")
7088    (set_attr "prefix" "maybe_vex,orig")
7089    (set_attr "mode" "TI,V4SF")])
7090
7091 (define_insn "*vec_dupv2di_avx"
7092   [(set (match_operand:V2DI 0 "register_operand" "=x")
7093         (vec_duplicate:V2DI
7094           (match_operand:DI 1 "register_operand" "x")))]
7095   "TARGET_AVX"
7096   "vpunpcklqdq\t{%1, %1, %0|%0, %1, %1}"
7097   [(set_attr "type" "sselog1")
7098    (set_attr "prefix" "vex")
7099    (set_attr "mode" "TI")])
7100
7101 (define_insn "*vec_dupv2di"
7102   [(set (match_operand:V2DI 0 "register_operand" "=Y2,x")
7103         (vec_duplicate:V2DI
7104           (match_operand:DI 1 "register_operand" " 0 ,0")))]
7105   "TARGET_SSE"
7106   "@
7107    punpcklqdq\t%0, %0
7108    movlhps\t%0, %0"
7109   [(set_attr "type" "sselog1,ssemov")
7110    (set_attr "mode" "TI,V4SF")])
7111
7112 (define_insn "*vec_concatv2si_avx"
7113   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7114         (vec_concat:V2SI
7115           (match_operand:SI 1 "nonimmediate_operand" "x ,x,rm, 0 ,rm")
7116           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7117   "TARGET_AVX"
7118   "@
7119    vpinsrd\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7120    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7121    vmovd\t{%1, %0|%0, %1}
7122    punpckldq\t{%2, %0|%0, %2}
7123    movd\t{%1, %0|%0, %1}"
7124   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7125    (set (attr "prefix")
7126      (if_then_else (eq_attr "alternative" "3,4")
7127        (const_string "orig")
7128        (const_string "vex")))
7129    (set_attr "mode" "TI,TI,TI,DI,DI")])
7130
7131 (define_insn "*vec_concatv2si_sse4_1"
7132   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7133         (vec_concat:V2SI
7134           (match_operand:SI 1 "nonimmediate_operand" "0 ,0,rm, 0 ,rm")
7135           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7136   "TARGET_SSE4_1"
7137   "@
7138    pinsrd\t{$0x1, %2, %0|%0, %2, 0x1}
7139    punpckldq\t{%2, %0|%0, %2}
7140    movd\t{%1, %0|%0, %1}
7141    punpckldq\t{%2, %0|%0, %2}
7142    movd\t{%1, %0|%0, %1}"
7143   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7144    (set_attr "prefix_extra" "1,*,*,*,*")
7145    (set_attr "mode" "TI,TI,TI,DI,DI")])
7146
7147 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7148 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7149 ;; alternatives pretty much forces the MMX alternative to be chosen.
7150 (define_insn "*vec_concatv2si_sse2"
7151   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,*y")
7152         (vec_concat:V2SI
7153           (match_operand:SI 1 "nonimmediate_operand" " 0,rm, 0,rm")
7154           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,*y, C")))]
7155   "TARGET_SSE2"
7156   "@
7157    punpckldq\t{%2, %0|%0, %2}
7158    movd\t{%1, %0|%0, %1}
7159    punpckldq\t{%2, %0|%0, %2}
7160    movd\t{%1, %0|%0, %1}"
7161   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7162    (set_attr "mode" "TI,TI,DI,DI")])
7163
7164 (define_insn "*vec_concatv2si_sse"
7165   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
7166         (vec_concat:V2SI
7167           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
7168           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
7169   "TARGET_SSE"
7170   "@
7171    unpcklps\t{%2, %0|%0, %2}
7172    movss\t{%1, %0|%0, %1}
7173    punpckldq\t{%2, %0|%0, %2}
7174    movd\t{%1, %0|%0, %1}"
7175   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7176    (set_attr "mode" "V4SF,V4SF,DI,DI")])
7177
7178 (define_insn "*vec_concatv4si_1_avx"
7179   [(set (match_operand:V4SI 0 "register_operand"       "=x,x")
7180         (vec_concat:V4SI
7181           (match_operand:V2SI 1 "register_operand"     " x,x")
7182           (match_operand:V2SI 2 "nonimmediate_operand" " x,m")))]
7183   "TARGET_AVX"
7184   "@
7185    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7186    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7187   [(set_attr "type" "sselog,ssemov")
7188    (set_attr "prefix" "vex")
7189    (set_attr "mode" "TI,V2SF")])
7190
7191 (define_insn "*vec_concatv4si_1"
7192   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,x,x")
7193         (vec_concat:V4SI
7194           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
7195           (match_operand:V2SI 2 "nonimmediate_operand" " Y2,x,m")))]
7196   "TARGET_SSE"
7197   "@
7198    punpcklqdq\t{%2, %0|%0, %2}
7199    movlhps\t{%2, %0|%0, %2}
7200    movhps\t{%2, %0|%0, %2}"
7201   [(set_attr "type" "sselog,ssemov,ssemov")
7202    (set_attr "mode" "TI,V4SF,V2SF")])
7203
7204 (define_insn "*vec_concatv2di_avx"
7205   [(set (match_operand:V2DI 0 "register_operand"     "=x,?x,x,x")
7206         (vec_concat:V2DI
7207           (match_operand:DI 1 "nonimmediate_operand" " m,*y,x,x")
7208           (match_operand:DI 2 "vector_move_operand"  " C, C,x,m")))]
7209   "!TARGET_64BIT && TARGET_AVX"
7210   "@
7211    vmovq\t{%1, %0|%0, %1}
7212    movq2dq\t{%1, %0|%0, %1}
7213    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7214    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7215   [(set_attr "type" "ssemov,ssemov,sselog,ssemov")
7216    (set (attr "prefix")
7217      (if_then_else (eq_attr "alternative" "1")
7218        (const_string "orig")
7219        (const_string "vex")))
7220    (set_attr "mode" "TI,TI,TI,V2SF")])
7221
7222 (define_insn "vec_concatv2di"
7223   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,?Y2,Y2,x,x")
7224         (vec_concat:V2DI
7225           (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0")
7226           (match_operand:DI 2 "vector_move_operand"  " C  ,  C,Y2,x,m")))]
7227   "!TARGET_64BIT && TARGET_SSE"
7228   "@
7229    movq\t{%1, %0|%0, %1}
7230    movq2dq\t{%1, %0|%0, %1}
7231    punpcklqdq\t{%2, %0|%0, %2}
7232    movlhps\t{%2, %0|%0, %2}
7233    movhps\t{%2, %0|%0, %2}"
7234   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov")
7235    (set_attr "mode" "TI,TI,TI,V4SF,V2SF")])
7236
7237 (define_insn "*vec_concatv2di_rex64_avx"
7238   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,Yi,!x,x,x")
7239         (vec_concat:V2DI
7240           (match_operand:DI 1 "nonimmediate_operand" " x,m,r ,*y,x,x")
7241           (match_operand:DI 2 "vector_move_operand"  "rm,C,C ,C ,x,m")))]
7242   "TARGET_64BIT && TARGET_AVX"
7243   "@
7244    vpinsrq\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7245    vmovq\t{%1, %0|%0, %1}
7246    vmovq\t{%1, %0|%0, %1}
7247    movq2dq\t{%1, %0|%0, %1}
7248    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7249    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7250   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov")
7251    (set (attr "prefix")
7252      (if_then_else (eq_attr "alternative" "3")
7253        (const_string "orig")
7254        (const_string "vex")))
7255    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
7256
7257 (define_insn "*vec_concatv2di_rex64_sse4_1"
7258   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
7259         (vec_concat:V2DI
7260           (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0")
7261           (match_operand:DI 2 "vector_move_operand"  " rm,C ,C ,C ,x,x,m")))]
7262   "TARGET_64BIT && TARGET_SSE4_1"
7263   "@
7264    pinsrq\t{$0x1, %2, %0|%0, %2, 0x1}
7265    movq\t{%1, %0|%0, %1}
7266    movq\t{%1, %0|%0, %1}
7267    movq2dq\t{%1, %0|%0, %1}
7268    punpcklqdq\t{%2, %0|%0, %2}
7269    movlhps\t{%2, %0|%0, %2}
7270    movhps\t{%2, %0|%0, %2}"
7271   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7272    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7273    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
7274
7275 (define_insn "*vec_concatv2di_rex64_sse"
7276   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
7277         (vec_concat:V2DI
7278           (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0")
7279           (match_operand:DI 2 "vector_move_operand"  " C  ,C ,C  ,Y2,x,m")))]
7280   "TARGET_64BIT && TARGET_SSE"
7281   "@
7282    movq\t{%1, %0|%0, %1}
7283    movq\t{%1, %0|%0, %1}
7284    movq2dq\t{%1, %0|%0, %1}
7285    punpcklqdq\t{%2, %0|%0, %2}
7286    movlhps\t{%2, %0|%0, %2}
7287    movhps\t{%2, %0|%0, %2}"
7288   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7289    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")])
7290
7291 (define_expand "vec_unpacku_hi_v16qi"
7292   [(match_operand:V8HI 0 "register_operand" "")
7293    (match_operand:V16QI 1 "register_operand" "")]
7294   "TARGET_SSE2"
7295 {
7296   if (TARGET_SSE4_1)
7297     ix86_expand_sse4_unpack (operands, true, true);
7298   else if (TARGET_SSE5)
7299     ix86_expand_sse5_unpack (operands, true, true);
7300   else
7301     ix86_expand_sse_unpack (operands, true, true);
7302   DONE;
7303 })
7304
7305 (define_expand "vec_unpacks_hi_v16qi"
7306   [(match_operand:V8HI 0 "register_operand" "")
7307    (match_operand:V16QI 1 "register_operand" "")]
7308   "TARGET_SSE2"
7309 {
7310   if (TARGET_SSE4_1)
7311     ix86_expand_sse4_unpack (operands, false, true);
7312   else if (TARGET_SSE5)
7313     ix86_expand_sse5_unpack (operands, false, true);
7314   else
7315     ix86_expand_sse_unpack (operands, false, true);
7316   DONE;
7317 })
7318
7319 (define_expand "vec_unpacku_lo_v16qi"
7320   [(match_operand:V8HI 0 "register_operand" "")
7321    (match_operand:V16QI 1 "register_operand" "")]
7322   "TARGET_SSE2"
7323 {
7324   if (TARGET_SSE4_1)
7325     ix86_expand_sse4_unpack (operands, true, false);
7326   else if (TARGET_SSE5)
7327     ix86_expand_sse5_unpack (operands, true, false);
7328   else
7329     ix86_expand_sse_unpack (operands, true, false);
7330   DONE;
7331 })
7332
7333 (define_expand "vec_unpacks_lo_v16qi"
7334   [(match_operand:V8HI 0 "register_operand" "")
7335    (match_operand:V16QI 1 "register_operand" "")]
7336   "TARGET_SSE2"
7337 {
7338   if (TARGET_SSE4_1)
7339     ix86_expand_sse4_unpack (operands, false, false);
7340   else if (TARGET_SSE5)
7341     ix86_expand_sse5_unpack (operands, false, false);
7342   else
7343     ix86_expand_sse_unpack (operands, false, false);
7344   DONE;
7345 })
7346
7347 (define_expand "vec_unpacku_hi_v8hi"
7348   [(match_operand:V4SI 0 "register_operand" "")
7349    (match_operand:V8HI 1 "register_operand" "")]
7350   "TARGET_SSE2"
7351 {
7352   if (TARGET_SSE4_1)
7353     ix86_expand_sse4_unpack (operands, true, true);
7354   else if (TARGET_SSE5)
7355     ix86_expand_sse5_unpack (operands, true, true);
7356   else
7357     ix86_expand_sse_unpack (operands, true, true);
7358   DONE;
7359 })
7360
7361 (define_expand "vec_unpacks_hi_v8hi"
7362   [(match_operand:V4SI 0 "register_operand" "")
7363    (match_operand:V8HI 1 "register_operand" "")]
7364   "TARGET_SSE2"
7365 {
7366   if (TARGET_SSE4_1)
7367     ix86_expand_sse4_unpack (operands, false, true);
7368   else if (TARGET_SSE5)
7369     ix86_expand_sse5_unpack (operands, false, true);
7370   else
7371     ix86_expand_sse_unpack (operands, false, true);
7372   DONE;
7373 })
7374
7375 (define_expand "vec_unpacku_lo_v8hi"
7376   [(match_operand:V4SI 0 "register_operand" "")
7377    (match_operand:V8HI 1 "register_operand" "")]
7378   "TARGET_SSE2"
7379 {
7380   if (TARGET_SSE4_1)
7381     ix86_expand_sse4_unpack (operands, true, false);
7382   else if (TARGET_SSE5)
7383     ix86_expand_sse5_unpack (operands, true, false);
7384   else
7385     ix86_expand_sse_unpack (operands, true, false);
7386   DONE;
7387 })
7388
7389 (define_expand "vec_unpacks_lo_v8hi"
7390   [(match_operand:V4SI 0 "register_operand" "")
7391    (match_operand:V8HI 1 "register_operand" "")]
7392   "TARGET_SSE2"
7393 {
7394   if (TARGET_SSE4_1)
7395     ix86_expand_sse4_unpack (operands, false, false);
7396   else if (TARGET_SSE5)
7397     ix86_expand_sse5_unpack (operands, false, false);
7398   else
7399     ix86_expand_sse_unpack (operands, false, false);
7400   DONE;
7401 })
7402
7403 (define_expand "vec_unpacku_hi_v4si"
7404   [(match_operand:V2DI 0 "register_operand" "")
7405    (match_operand:V4SI 1 "register_operand" "")]
7406   "TARGET_SSE2"
7407 {
7408   if (TARGET_SSE4_1)
7409     ix86_expand_sse4_unpack (operands, true, true);
7410   else if (TARGET_SSE5)
7411     ix86_expand_sse5_unpack (operands, true, true);
7412   else
7413     ix86_expand_sse_unpack (operands, true, true);
7414   DONE;
7415 })
7416
7417 (define_expand "vec_unpacks_hi_v4si"
7418   [(match_operand:V2DI 0 "register_operand" "")
7419    (match_operand:V4SI 1 "register_operand" "")]
7420   "TARGET_SSE2"
7421 {
7422   if (TARGET_SSE4_1)
7423     ix86_expand_sse4_unpack (operands, false, true);
7424   else if (TARGET_SSE5)
7425     ix86_expand_sse5_unpack (operands, false, true);
7426   else
7427     ix86_expand_sse_unpack (operands, false, true);
7428   DONE;
7429 })
7430
7431 (define_expand "vec_unpacku_lo_v4si"
7432   [(match_operand:V2DI 0 "register_operand" "")
7433    (match_operand:V4SI 1 "register_operand" "")]
7434   "TARGET_SSE2"
7435 {
7436   if (TARGET_SSE4_1)
7437     ix86_expand_sse4_unpack (operands, true, false);
7438   else if (TARGET_SSE5)
7439     ix86_expand_sse5_unpack (operands, true, false);
7440   else
7441     ix86_expand_sse_unpack (operands, true, false);
7442   DONE;
7443 })
7444
7445 (define_expand "vec_unpacks_lo_v4si"
7446   [(match_operand:V2DI 0 "register_operand" "")
7447    (match_operand:V4SI 1 "register_operand" "")]
7448   "TARGET_SSE2"
7449 {
7450   if (TARGET_SSE4_1)
7451     ix86_expand_sse4_unpack (operands, false, false);
7452   else if (TARGET_SSE5)
7453     ix86_expand_sse5_unpack (operands, false, false);
7454   else
7455     ix86_expand_sse_unpack (operands, false, false);
7456   DONE;
7457 })
7458
7459 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7460 ;;
7461 ;; Miscellaneous
7462 ;;
7463 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7464
7465 (define_expand "sse2_uavgv16qi3"
7466   [(set (match_operand:V16QI 0 "register_operand" "")
7467         (truncate:V16QI
7468           (lshiftrt:V16HI
7469             (plus:V16HI
7470               (plus:V16HI
7471                 (zero_extend:V16HI
7472                   (match_operand:V16QI 1 "nonimmediate_operand" ""))
7473                 (zero_extend:V16HI
7474                   (match_operand:V16QI 2 "nonimmediate_operand" "")))
7475               (const_vector:V16QI [(const_int 1) (const_int 1)
7476                                    (const_int 1) (const_int 1)
7477                                    (const_int 1) (const_int 1)
7478                                    (const_int 1) (const_int 1)
7479                                    (const_int 1) (const_int 1)
7480                                    (const_int 1) (const_int 1)
7481                                    (const_int 1) (const_int 1)
7482                                    (const_int 1) (const_int 1)]))
7483             (const_int 1))))]
7484   "TARGET_SSE2"
7485   "ix86_fixup_binary_operands_no_copy (PLUS, V16QImode, operands);")
7486
7487 (define_insn "*avx_uavgv16qi3"
7488   [(set (match_operand:V16QI 0 "register_operand" "=x")
7489         (truncate:V16QI
7490           (lshiftrt:V16HI
7491             (plus:V16HI
7492               (plus:V16HI
7493                 (zero_extend:V16HI
7494                   (match_operand:V16QI 1 "nonimmediate_operand" "%x"))
7495                 (zero_extend:V16HI
7496                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7497               (const_vector:V16QI [(const_int 1) (const_int 1)
7498                                    (const_int 1) (const_int 1)
7499                                    (const_int 1) (const_int 1)
7500                                    (const_int 1) (const_int 1)
7501                                    (const_int 1) (const_int 1)
7502                                    (const_int 1) (const_int 1)
7503                                    (const_int 1) (const_int 1)
7504                                    (const_int 1) (const_int 1)]))
7505             (const_int 1))))]
7506   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7507   "vpavgb\t{%2, %1, %0|%0, %1, %2}"
7508   [(set_attr "type" "sseiadd")
7509    (set_attr "prefix" "vex")
7510    (set_attr "mode" "TI")])
7511
7512 (define_insn "*sse2_uavgv16qi3"
7513   [(set (match_operand:V16QI 0 "register_operand" "=x")
7514         (truncate:V16QI
7515           (lshiftrt:V16HI
7516             (plus:V16HI
7517               (plus:V16HI
7518                 (zero_extend:V16HI
7519                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
7520                 (zero_extend:V16HI
7521                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7522               (const_vector:V16QI [(const_int 1) (const_int 1)
7523                                    (const_int 1) (const_int 1)
7524                                    (const_int 1) (const_int 1)
7525                                    (const_int 1) (const_int 1)
7526                                    (const_int 1) (const_int 1)
7527                                    (const_int 1) (const_int 1)
7528                                    (const_int 1) (const_int 1)
7529                                    (const_int 1) (const_int 1)]))
7530             (const_int 1))))]
7531   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7532   "pavgb\t{%2, %0|%0, %2}"
7533   [(set_attr "type" "sseiadd")
7534    (set_attr "prefix_data16" "1")
7535    (set_attr "mode" "TI")])
7536
7537 (define_expand "sse2_uavgv8hi3"
7538   [(set (match_operand:V8HI 0 "register_operand" "")
7539         (truncate:V8HI
7540           (lshiftrt:V8SI
7541             (plus:V8SI
7542               (plus:V8SI
7543                 (zero_extend:V8SI
7544                   (match_operand:V8HI 1 "nonimmediate_operand" ""))
7545                 (zero_extend:V8SI
7546                   (match_operand:V8HI 2 "nonimmediate_operand" "")))
7547               (const_vector:V8HI [(const_int 1) (const_int 1)
7548                                   (const_int 1) (const_int 1)
7549                                   (const_int 1) (const_int 1)
7550                                   (const_int 1) (const_int 1)]))
7551             (const_int 1))))]
7552   "TARGET_SSE2"
7553   "ix86_fixup_binary_operands_no_copy (PLUS, V8HImode, operands);")
7554
7555 (define_insn "*avx_uavgv8hi3"
7556   [(set (match_operand:V8HI 0 "register_operand" "=x")
7557         (truncate:V8HI
7558           (lshiftrt:V8SI
7559             (plus:V8SI
7560               (plus:V8SI
7561                 (zero_extend:V8SI
7562                   (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
7563                 (zero_extend:V8SI
7564                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7565               (const_vector:V8HI [(const_int 1) (const_int 1)
7566                                   (const_int 1) (const_int 1)
7567                                   (const_int 1) (const_int 1)
7568                                   (const_int 1) (const_int 1)]))
7569             (const_int 1))))]
7570   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7571   "vpavgw\t{%2, %1, %0|%0, %1, %2}"
7572   [(set_attr "type" "sseiadd")
7573    (set_attr "prefix" "vex")
7574    (set_attr "mode" "TI")])
7575
7576 (define_insn "*sse2_uavgv8hi3"
7577   [(set (match_operand:V8HI 0 "register_operand" "=x")
7578         (truncate:V8HI
7579           (lshiftrt:V8SI
7580             (plus:V8SI
7581               (plus:V8SI
7582                 (zero_extend:V8SI
7583                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
7584                 (zero_extend:V8SI
7585                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7586               (const_vector:V8HI [(const_int 1) (const_int 1)
7587                                   (const_int 1) (const_int 1)
7588                                   (const_int 1) (const_int 1)
7589                                   (const_int 1) (const_int 1)]))
7590             (const_int 1))))]
7591   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7592   "pavgw\t{%2, %0|%0, %2}"
7593   [(set_attr "type" "sseiadd")
7594    (set_attr "prefix_data16" "1")
7595    (set_attr "mode" "TI")])
7596
7597 ;; The correct representation for this is absolutely enormous, and
7598 ;; surely not generally useful.
7599 (define_insn "*avx_psadbw"
7600   [(set (match_operand:V2DI 0 "register_operand" "=x")
7601         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "x")
7602                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7603                      UNSPEC_PSADBW))]
7604   "TARGET_AVX"
7605   "vpsadbw\t{%2, %1, %0|%0, %1, %2}"
7606   [(set_attr "type" "sseiadd")
7607    (set_attr "prefix" "vex")
7608    (set_attr "mode" "TI")])
7609
7610 (define_insn "sse2_psadbw"
7611   [(set (match_operand:V2DI 0 "register_operand" "=x")
7612         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
7613                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7614                      UNSPEC_PSADBW))]
7615   "TARGET_SSE2"
7616   "psadbw\t{%2, %0|%0, %2}"
7617   [(set_attr "type" "sseiadd")
7618    (set_attr "prefix_data16" "1")
7619    (set_attr "mode" "TI")])
7620
7621 (define_insn "avx_movmskp<avxmodesuffixf2c>256"
7622   [(set (match_operand:SI 0 "register_operand" "=r")
7623         (unspec:SI
7624           [(match_operand:AVX256MODEF2P 1 "register_operand" "x")]
7625           UNSPEC_MOVMSK))]
7626   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
7627   "vmovmskp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
7628   [(set_attr "type" "ssecvt")
7629    (set_attr "prefix" "vex")
7630    (set_attr "mode" "<MODE>")])
7631
7632 (define_insn "<sse>_movmskp<ssemodesuffixf2c>"
7633   [(set (match_operand:SI 0 "register_operand" "=r")
7634         (unspec:SI
7635           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
7636           UNSPEC_MOVMSK))]
7637   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
7638   "%vmovmskp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
7639   [(set_attr "type" "ssecvt")
7640    (set_attr "prefix" "maybe_vex")
7641    (set_attr "mode" "<MODE>")])
7642
7643 (define_insn "sse2_pmovmskb"
7644   [(set (match_operand:SI 0 "register_operand" "=r")
7645         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
7646                    UNSPEC_MOVMSK))]
7647   "TARGET_SSE2"
7648   "%vpmovmskb\t{%1, %0|%0, %1}"
7649   [(set_attr "type" "ssecvt")
7650    (set_attr "prefix_data16" "1")
7651    (set_attr "prefix" "maybe_vex")
7652    (set_attr "mode" "SI")])
7653
7654 (define_expand "sse2_maskmovdqu"
7655   [(set (match_operand:V16QI 0 "memory_operand" "")
7656         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
7657                        (match_operand:V16QI 2 "register_operand" "")
7658                        (match_dup 0)]
7659                       UNSPEC_MASKMOV))]
7660   "TARGET_SSE2"
7661   "")
7662
7663 (define_insn "*sse2_maskmovdqu"
7664   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
7665         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
7666                        (match_operand:V16QI 2 "register_operand" "x")
7667                        (mem:V16QI (match_dup 0))]
7668                       UNSPEC_MASKMOV))]
7669   "TARGET_SSE2 && !TARGET_64BIT"
7670   ;; @@@ check ordering of operands in intel/nonintel syntax
7671   "%vmaskmovdqu\t{%2, %1|%1, %2}"
7672   [(set_attr "type" "ssecvt")
7673    (set_attr "prefix_data16" "1")
7674    (set_attr "prefix" "maybe_vex")
7675    (set_attr "mode" "TI")])
7676
7677 (define_insn "*sse2_maskmovdqu_rex64"
7678   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
7679         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
7680                        (match_operand:V16QI 2 "register_operand" "x")
7681                        (mem:V16QI (match_dup 0))]
7682                       UNSPEC_MASKMOV))]
7683   "TARGET_SSE2 && TARGET_64BIT"
7684   ;; @@@ check ordering of operands in intel/nonintel syntax
7685   "%vmaskmovdqu\t{%2, %1|%1, %2}"
7686   [(set_attr "type" "ssecvt")
7687    (set_attr "prefix_data16" "1")
7688    (set_attr "prefix" "maybe_vex")
7689    (set_attr "mode" "TI")])
7690
7691 (define_insn "sse_ldmxcsr"
7692   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
7693                     UNSPECV_LDMXCSR)]
7694   "TARGET_SSE"
7695   "%vldmxcsr\t%0"
7696   [(set_attr "type" "sse")
7697    (set_attr "prefix" "maybe_vex")
7698    (set_attr "memory" "load")])
7699
7700 (define_insn "sse_stmxcsr"
7701   [(set (match_operand:SI 0 "memory_operand" "=m")
7702         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
7703   "TARGET_SSE"
7704   "%vstmxcsr\t%0"
7705   [(set_attr "type" "sse")
7706    (set_attr "prefix" "maybe_vex")
7707    (set_attr "memory" "store")])
7708
7709 (define_expand "sse_sfence"
7710   [(set (match_dup 0)
7711         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
7712   "TARGET_SSE || TARGET_3DNOW_A"
7713 {
7714   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7715   MEM_VOLATILE_P (operands[0]) = 1;
7716 })
7717
7718 (define_insn "*sse_sfence"
7719   [(set (match_operand:BLK 0 "" "")
7720         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
7721   "TARGET_SSE || TARGET_3DNOW_A"
7722   "sfence"
7723   [(set_attr "type" "sse")
7724    (set_attr "memory" "unknown")])
7725
7726 (define_insn "sse2_clflush"
7727   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
7728                     UNSPECV_CLFLUSH)]
7729   "TARGET_SSE2"
7730   "clflush\t%a0"
7731   [(set_attr "type" "sse")
7732    (set_attr "memory" "unknown")])
7733
7734 (define_expand "sse2_mfence"
7735   [(set (match_dup 0)
7736         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
7737   "TARGET_SSE2"
7738 {
7739   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7740   MEM_VOLATILE_P (operands[0]) = 1;
7741 })
7742
7743 (define_insn "*sse2_mfence"
7744   [(set (match_operand:BLK 0 "" "")
7745         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
7746   "TARGET_64BIT || TARGET_SSE2"
7747   "mfence"
7748   [(set_attr "type" "sse")
7749    (set_attr "memory" "unknown")])
7750
7751 (define_expand "sse2_lfence"
7752   [(set (match_dup 0)
7753         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
7754   "TARGET_SSE2"
7755 {
7756   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7757   MEM_VOLATILE_P (operands[0]) = 1;
7758 })
7759
7760 (define_insn "*sse2_lfence"
7761   [(set (match_operand:BLK 0 "" "")
7762         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
7763   "TARGET_SSE2"
7764   "lfence"
7765   [(set_attr "type" "sse")
7766    (set_attr "memory" "unknown")])
7767
7768 (define_insn "sse3_mwait"
7769   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
7770                      (match_operand:SI 1 "register_operand" "c")]
7771                     UNSPECV_MWAIT)]
7772   "TARGET_SSE3"
7773 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
7774 ;; Since 32bit register operands are implicitly zero extended to 64bit,
7775 ;; we only need to set up 32bit registers.
7776   "mwait"
7777   [(set_attr "length" "3")])
7778
7779 (define_insn "sse3_monitor"
7780   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
7781                      (match_operand:SI 1 "register_operand" "c")
7782                      (match_operand:SI 2 "register_operand" "d")]
7783                     UNSPECV_MONITOR)]
7784   "TARGET_SSE3 && !TARGET_64BIT"
7785   "monitor\t%0, %1, %2"
7786   [(set_attr "length" "3")])
7787
7788 (define_insn "sse3_monitor64"
7789   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
7790                      (match_operand:SI 1 "register_operand" "c")
7791                      (match_operand:SI 2 "register_operand" "d")]
7792                     UNSPECV_MONITOR)]
7793   "TARGET_SSE3 && TARGET_64BIT"
7794 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
7795 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
7796 ;; zero extended to 64bit, we only need to set up 32bit registers.
7797   "monitor"
7798   [(set_attr "length" "3")])
7799
7800 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7801 ;;
7802 ;; SSSE3 instructions
7803 ;;
7804 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7805
7806 (define_insn "*avx_phaddwv8hi3"
7807   [(set (match_operand:V8HI 0 "register_operand" "=x")
7808         (vec_concat:V8HI
7809           (vec_concat:V4HI
7810             (vec_concat:V2HI
7811               (plus:HI
7812                 (vec_select:HI
7813                   (match_operand:V8HI 1 "register_operand" "x")
7814                   (parallel [(const_int 0)]))
7815                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7816               (plus:HI
7817                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7818                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7819             (vec_concat:V2HI
7820               (plus:HI
7821                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
7822                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
7823               (plus:HI
7824                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
7825                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
7826           (vec_concat:V4HI
7827             (vec_concat:V2HI
7828               (plus:HI
7829                 (vec_select:HI
7830                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
7831                   (parallel [(const_int 0)]))
7832                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7833               (plus:HI
7834                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7835                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
7836             (vec_concat:V2HI
7837               (plus:HI
7838                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
7839                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
7840               (plus:HI
7841                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
7842                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
7843   "TARGET_AVX"
7844   "vphaddw\t{%2, %1, %0|%0, %1, %2}"
7845   [(set_attr "type" "sseiadd")
7846    (set_attr "prefix" "vex")
7847    (set_attr "mode" "TI")])
7848
7849 (define_insn "ssse3_phaddwv8hi3"
7850   [(set (match_operand:V8HI 0 "register_operand" "=x")
7851         (vec_concat:V8HI
7852           (vec_concat:V4HI
7853             (vec_concat:V2HI
7854               (plus:HI
7855                 (vec_select:HI
7856                   (match_operand:V8HI 1 "register_operand" "0")
7857                   (parallel [(const_int 0)]))
7858                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7859               (plus:HI
7860                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7861                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7862             (vec_concat:V2HI
7863               (plus:HI
7864                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
7865                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
7866               (plus:HI
7867                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
7868                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
7869           (vec_concat:V4HI
7870             (vec_concat:V2HI
7871               (plus:HI
7872                 (vec_select:HI
7873                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
7874                   (parallel [(const_int 0)]))
7875                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7876               (plus:HI
7877                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7878                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
7879             (vec_concat:V2HI
7880               (plus:HI
7881                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
7882                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
7883               (plus:HI
7884                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
7885                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
7886   "TARGET_SSSE3"
7887   "phaddw\t{%2, %0|%0, %2}"
7888   [(set_attr "type" "sseiadd")
7889    (set_attr "prefix_data16" "1")
7890    (set_attr "prefix_extra" "1")
7891    (set_attr "mode" "TI")])
7892
7893 (define_insn "ssse3_phaddwv4hi3"
7894   [(set (match_operand:V4HI 0 "register_operand" "=y")
7895         (vec_concat:V4HI
7896           (vec_concat:V2HI
7897             (plus:HI
7898               (vec_select:HI
7899                 (match_operand:V4HI 1 "register_operand" "0")
7900                 (parallel [(const_int 0)]))
7901               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7902             (plus:HI
7903               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7904               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7905           (vec_concat:V2HI
7906             (plus:HI
7907               (vec_select:HI
7908                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
7909                 (parallel [(const_int 0)]))
7910               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7911             (plus:HI
7912               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7913               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
7914   "TARGET_SSSE3"
7915   "phaddw\t{%2, %0|%0, %2}"
7916   [(set_attr "type" "sseiadd")
7917    (set_attr "prefix_extra" "1")
7918    (set_attr "mode" "DI")])
7919
7920 (define_insn "*avx_phadddv4si3"
7921   [(set (match_operand:V4SI 0 "register_operand" "=x")
7922         (vec_concat:V4SI
7923           (vec_concat:V2SI
7924             (plus:SI
7925               (vec_select:SI
7926                 (match_operand:V4SI 1 "register_operand" "x")
7927                 (parallel [(const_int 0)]))
7928               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
7929             (plus:SI
7930               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
7931               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
7932           (vec_concat:V2SI
7933             (plus:SI
7934               (vec_select:SI
7935                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
7936                 (parallel [(const_int 0)]))
7937               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
7938             (plus:SI
7939               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
7940               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
7941   "TARGET_AVX"
7942   "vphaddd\t{%2, %1, %0|%0, %1, %2}"
7943   [(set_attr "type" "sseiadd")
7944    (set_attr "prefix" "vex")
7945    (set_attr "mode" "TI")])
7946
7947 (define_insn "ssse3_phadddv4si3"
7948   [(set (match_operand:V4SI 0 "register_operand" "=x")
7949         (vec_concat:V4SI
7950           (vec_concat:V2SI
7951             (plus:SI
7952               (vec_select:SI
7953                 (match_operand:V4SI 1 "register_operand" "0")
7954                 (parallel [(const_int 0)]))
7955               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
7956             (plus:SI
7957               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
7958               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
7959           (vec_concat:V2SI
7960             (plus:SI
7961               (vec_select:SI
7962                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
7963                 (parallel [(const_int 0)]))
7964               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
7965             (plus:SI
7966               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
7967               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
7968   "TARGET_SSSE3"
7969   "phaddd\t{%2, %0|%0, %2}"
7970   [(set_attr "type" "sseiadd")
7971    (set_attr "prefix_data16" "1")
7972    (set_attr "prefix_extra" "1")
7973    (set_attr "mode" "TI")])
7974
7975 (define_insn "ssse3_phadddv2si3"
7976   [(set (match_operand:V2SI 0 "register_operand" "=y")
7977         (vec_concat:V2SI
7978           (plus:SI
7979             (vec_select:SI
7980               (match_operand:V2SI 1 "register_operand" "0")
7981               (parallel [(const_int 0)]))
7982             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
7983           (plus:SI
7984             (vec_select:SI
7985               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
7986               (parallel [(const_int 0)]))
7987             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
7988   "TARGET_SSSE3"
7989   "phaddd\t{%2, %0|%0, %2}"
7990   [(set_attr "type" "sseiadd")
7991    (set_attr "prefix_extra" "1")
7992    (set_attr "mode" "DI")])
7993
7994 (define_insn "*avx_phaddswv8hi3"
7995   [(set (match_operand:V8HI 0 "register_operand" "=x")
7996         (vec_concat:V8HI
7997           (vec_concat:V4HI
7998             (vec_concat:V2HI
7999               (ss_plus:HI
8000                 (vec_select:HI
8001                   (match_operand:V8HI 1 "register_operand" "x")
8002                   (parallel [(const_int 0)]))
8003                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8004               (ss_plus:HI
8005                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8006                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8007             (vec_concat:V2HI
8008               (ss_plus:HI
8009                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8010                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8011               (ss_plus:HI
8012                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8013                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8014           (vec_concat:V4HI
8015             (vec_concat:V2HI
8016               (ss_plus:HI
8017                 (vec_select:HI
8018                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8019                   (parallel [(const_int 0)]))
8020                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8021               (ss_plus:HI
8022                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8023                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8024             (vec_concat:V2HI
8025               (ss_plus:HI
8026                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8027                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8028               (ss_plus:HI
8029                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8030                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8031   "TARGET_AVX"
8032   "vphaddsw\t{%2, %1, %0|%0, %1, %2}"
8033   [(set_attr "type" "sseiadd")
8034    (set_attr "prefix" "vex")
8035    (set_attr "mode" "TI")])
8036
8037 (define_insn "ssse3_phaddswv8hi3"
8038   [(set (match_operand:V8HI 0 "register_operand" "=x")
8039         (vec_concat:V8HI
8040           (vec_concat:V4HI
8041             (vec_concat:V2HI
8042               (ss_plus:HI
8043                 (vec_select:HI
8044                   (match_operand:V8HI 1 "register_operand" "0")
8045                   (parallel [(const_int 0)]))
8046                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8047               (ss_plus:HI
8048                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8049                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8050             (vec_concat:V2HI
8051               (ss_plus:HI
8052                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8053                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8054               (ss_plus:HI
8055                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8056                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8057           (vec_concat:V4HI
8058             (vec_concat:V2HI
8059               (ss_plus:HI
8060                 (vec_select:HI
8061                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8062                   (parallel [(const_int 0)]))
8063                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8064               (ss_plus:HI
8065                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8066                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8067             (vec_concat:V2HI
8068               (ss_plus:HI
8069                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8070                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8071               (ss_plus:HI
8072                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8073                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8074   "TARGET_SSSE3"
8075   "phaddsw\t{%2, %0|%0, %2}"
8076   [(set_attr "type" "sseiadd")
8077    (set_attr "prefix_data16" "1")
8078    (set_attr "prefix_extra" "1")
8079    (set_attr "mode" "TI")])
8080
8081 (define_insn "ssse3_phaddswv4hi3"
8082   [(set (match_operand:V4HI 0 "register_operand" "=y")
8083         (vec_concat:V4HI
8084           (vec_concat:V2HI
8085             (ss_plus:HI
8086               (vec_select:HI
8087                 (match_operand:V4HI 1 "register_operand" "0")
8088                 (parallel [(const_int 0)]))
8089               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8090             (ss_plus:HI
8091               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8092               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8093           (vec_concat:V2HI
8094             (ss_plus:HI
8095               (vec_select:HI
8096                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8097                 (parallel [(const_int 0)]))
8098               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8099             (ss_plus:HI
8100               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8101               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8102   "TARGET_SSSE3"
8103   "phaddsw\t{%2, %0|%0, %2}"
8104   [(set_attr "type" "sseiadd")
8105    (set_attr "prefix_extra" "1")
8106    (set_attr "mode" "DI")])
8107
8108 (define_insn "*avx_phsubwv8hi3"
8109   [(set (match_operand:V8HI 0 "register_operand" "=x")
8110         (vec_concat:V8HI
8111           (vec_concat:V4HI
8112             (vec_concat:V2HI
8113               (minus:HI
8114                 (vec_select:HI
8115                   (match_operand:V8HI 1 "register_operand" "x")
8116                   (parallel [(const_int 0)]))
8117                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8118               (minus:HI
8119                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8120                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8121             (vec_concat:V2HI
8122               (minus:HI
8123                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8124                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8125               (minus:HI
8126                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8127                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8128           (vec_concat:V4HI
8129             (vec_concat:V2HI
8130               (minus:HI
8131                 (vec_select:HI
8132                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8133                   (parallel [(const_int 0)]))
8134                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8135               (minus:HI
8136                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8137                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8138             (vec_concat:V2HI
8139               (minus:HI
8140                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8141                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8142               (minus:HI
8143                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8144                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8145   "TARGET_AVX"
8146   "vphsubw\t{%2, %1, %0|%0, %1, %2}"
8147   [(set_attr "type" "sseiadd")
8148    (set_attr "prefix" "vex")
8149    (set_attr "mode" "TI")])
8150
8151 (define_insn "ssse3_phsubwv8hi3"
8152   [(set (match_operand:V8HI 0 "register_operand" "=x")
8153         (vec_concat:V8HI
8154           (vec_concat:V4HI
8155             (vec_concat:V2HI
8156               (minus:HI
8157                 (vec_select:HI
8158                   (match_operand:V8HI 1 "register_operand" "0")
8159                   (parallel [(const_int 0)]))
8160                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8161               (minus:HI
8162                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8163                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8164             (vec_concat:V2HI
8165               (minus:HI
8166                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8167                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8168               (minus:HI
8169                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8170                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8171           (vec_concat:V4HI
8172             (vec_concat:V2HI
8173               (minus:HI
8174                 (vec_select:HI
8175                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8176                   (parallel [(const_int 0)]))
8177                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8178               (minus:HI
8179                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8180                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8181             (vec_concat:V2HI
8182               (minus:HI
8183                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8184                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8185               (minus:HI
8186                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8187                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8188   "TARGET_SSSE3"
8189   "phsubw\t{%2, %0|%0, %2}"
8190   [(set_attr "type" "sseiadd")
8191    (set_attr "prefix_data16" "1")
8192    (set_attr "prefix_extra" "1")
8193    (set_attr "mode" "TI")])
8194
8195 (define_insn "ssse3_phsubwv4hi3"
8196   [(set (match_operand:V4HI 0 "register_operand" "=y")
8197         (vec_concat:V4HI
8198           (vec_concat:V2HI
8199             (minus:HI
8200               (vec_select:HI
8201                 (match_operand:V4HI 1 "register_operand" "0")
8202                 (parallel [(const_int 0)]))
8203               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8204             (minus:HI
8205               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8206               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8207           (vec_concat:V2HI
8208             (minus:HI
8209               (vec_select:HI
8210                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8211                 (parallel [(const_int 0)]))
8212               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8213             (minus:HI
8214               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8215               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8216   "TARGET_SSSE3"
8217   "phsubw\t{%2, %0|%0, %2}"
8218   [(set_attr "type" "sseiadd")
8219    (set_attr "prefix_extra" "1")
8220    (set_attr "mode" "DI")])
8221
8222 (define_insn "*avx_phsubdv4si3"
8223   [(set (match_operand:V4SI 0 "register_operand" "=x")
8224         (vec_concat:V4SI
8225           (vec_concat:V2SI
8226             (minus:SI
8227               (vec_select:SI
8228                 (match_operand:V4SI 1 "register_operand" "x")
8229                 (parallel [(const_int 0)]))
8230               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8231             (minus:SI
8232               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8233               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8234           (vec_concat:V2SI
8235             (minus:SI
8236               (vec_select:SI
8237                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8238                 (parallel [(const_int 0)]))
8239               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8240             (minus:SI
8241               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8242               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8243   "TARGET_AVX"
8244   "vphsubd\t{%2, %1, %0|%0, %1, %2}"
8245   [(set_attr "type" "sseiadd")
8246    (set_attr "prefix" "vex")
8247    (set_attr "mode" "TI")])
8248
8249 (define_insn "ssse3_phsubdv4si3"
8250   [(set (match_operand:V4SI 0 "register_operand" "=x")
8251         (vec_concat:V4SI
8252           (vec_concat:V2SI
8253             (minus:SI
8254               (vec_select:SI
8255                 (match_operand:V4SI 1 "register_operand" "0")
8256                 (parallel [(const_int 0)]))
8257               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8258             (minus:SI
8259               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8260               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8261           (vec_concat:V2SI
8262             (minus:SI
8263               (vec_select:SI
8264                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8265                 (parallel [(const_int 0)]))
8266               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8267             (minus:SI
8268               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8269               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8270   "TARGET_SSSE3"
8271   "phsubd\t{%2, %0|%0, %2}"
8272   [(set_attr "type" "sseiadd")
8273    (set_attr "prefix_data16" "1")
8274    (set_attr "prefix_extra" "1")
8275    (set_attr "mode" "TI")])
8276
8277 (define_insn "ssse3_phsubdv2si3"
8278   [(set (match_operand:V2SI 0 "register_operand" "=y")
8279         (vec_concat:V2SI
8280           (minus:SI
8281             (vec_select:SI
8282               (match_operand:V2SI 1 "register_operand" "0")
8283               (parallel [(const_int 0)]))
8284             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8285           (minus:SI
8286             (vec_select:SI
8287               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8288               (parallel [(const_int 0)]))
8289             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8290   "TARGET_SSSE3"
8291   "phsubd\t{%2, %0|%0, %2}"
8292   [(set_attr "type" "sseiadd")
8293    (set_attr "prefix_extra" "1")
8294    (set_attr "mode" "DI")])
8295
8296 (define_insn "*avx_phsubswv8hi3"
8297   [(set (match_operand:V8HI 0 "register_operand" "=x")
8298         (vec_concat:V8HI
8299           (vec_concat:V4HI
8300             (vec_concat:V2HI
8301               (ss_minus:HI
8302                 (vec_select:HI
8303                   (match_operand:V8HI 1 "register_operand" "x")
8304                   (parallel [(const_int 0)]))
8305                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8306               (ss_minus:HI
8307                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8308                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8309             (vec_concat:V2HI
8310               (ss_minus:HI
8311                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8312                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8313               (ss_minus:HI
8314                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8315                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8316           (vec_concat:V4HI
8317             (vec_concat:V2HI
8318               (ss_minus:HI
8319                 (vec_select:HI
8320                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8321                   (parallel [(const_int 0)]))
8322                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8323               (ss_minus:HI
8324                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8325                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8326             (vec_concat:V2HI
8327               (ss_minus:HI
8328                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8329                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8330               (ss_minus:HI
8331                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8332                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8333   "TARGET_AVX"
8334   "vphsubsw\t{%2, %1, %0|%0, %1, %2}"
8335   [(set_attr "type" "sseiadd")
8336    (set_attr "prefix" "vex")
8337    (set_attr "mode" "TI")])
8338
8339 (define_insn "ssse3_phsubswv8hi3"
8340   [(set (match_operand:V8HI 0 "register_operand" "=x")
8341         (vec_concat:V8HI
8342           (vec_concat:V4HI
8343             (vec_concat:V2HI
8344               (ss_minus:HI
8345                 (vec_select:HI
8346                   (match_operand:V8HI 1 "register_operand" "0")
8347                   (parallel [(const_int 0)]))
8348                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8349               (ss_minus:HI
8350                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8351                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8352             (vec_concat:V2HI
8353               (ss_minus:HI
8354                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8355                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8356               (ss_minus:HI
8357                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8358                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8359           (vec_concat:V4HI
8360             (vec_concat:V2HI
8361               (ss_minus:HI
8362                 (vec_select:HI
8363                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8364                   (parallel [(const_int 0)]))
8365                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8366               (ss_minus:HI
8367                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8368                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8369             (vec_concat:V2HI
8370               (ss_minus:HI
8371                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8372                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8373               (ss_minus:HI
8374                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8375                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8376   "TARGET_SSSE3"
8377   "phsubsw\t{%2, %0|%0, %2}"
8378   [(set_attr "type" "sseiadd")
8379    (set_attr "prefix_data16" "1")
8380    (set_attr "prefix_extra" "1")
8381    (set_attr "mode" "TI")])
8382
8383 (define_insn "ssse3_phsubswv4hi3"
8384   [(set (match_operand:V4HI 0 "register_operand" "=y")
8385         (vec_concat:V4HI
8386           (vec_concat:V2HI
8387             (ss_minus:HI
8388               (vec_select:HI
8389                 (match_operand:V4HI 1 "register_operand" "0")
8390                 (parallel [(const_int 0)]))
8391               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8392             (ss_minus:HI
8393               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8394               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8395           (vec_concat:V2HI
8396             (ss_minus:HI
8397               (vec_select:HI
8398                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8399                 (parallel [(const_int 0)]))
8400               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8401             (ss_minus:HI
8402               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8403               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8404   "TARGET_SSSE3"
8405   "phsubsw\t{%2, %0|%0, %2}"
8406   [(set_attr "type" "sseiadd")
8407    (set_attr "prefix_extra" "1")
8408    (set_attr "mode" "DI")])
8409
8410 (define_insn "*avx_pmaddubsw128"
8411   [(set (match_operand:V8HI 0 "register_operand" "=x")
8412         (ss_plus:V8HI
8413           (mult:V8HI
8414             (zero_extend:V8HI
8415               (vec_select:V4QI
8416                 (match_operand:V16QI 1 "register_operand" "x")
8417                 (parallel [(const_int 0)
8418                            (const_int 2)
8419                            (const_int 4)
8420                            (const_int 6)
8421                            (const_int 8)
8422                            (const_int 10)
8423                            (const_int 12)
8424                            (const_int 14)])))
8425             (sign_extend:V8HI
8426               (vec_select:V8QI
8427                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8428                 (parallel [(const_int 0)
8429                            (const_int 2)
8430                            (const_int 4)
8431                            (const_int 6)
8432                            (const_int 8)
8433                            (const_int 10)
8434                            (const_int 12)
8435                            (const_int 14)]))))
8436           (mult:V8HI
8437             (zero_extend:V8HI
8438               (vec_select:V16QI (match_dup 1)
8439                 (parallel [(const_int 1)
8440                            (const_int 3)
8441                            (const_int 5)
8442                            (const_int 7)
8443                            (const_int 9)
8444                            (const_int 11)
8445                            (const_int 13)
8446                            (const_int 15)])))
8447             (sign_extend:V8HI
8448               (vec_select:V16QI (match_dup 2)
8449                 (parallel [(const_int 1)
8450                            (const_int 3)
8451                            (const_int 5)
8452                            (const_int 7)
8453                            (const_int 9)
8454                            (const_int 11)
8455                            (const_int 13)
8456                            (const_int 15)]))))))]
8457   "TARGET_AVX"
8458   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8459   [(set_attr "type" "sseiadd")
8460    (set_attr "prefix" "vex")
8461    (set_attr "mode" "TI")])
8462
8463 (define_insn "ssse3_pmaddubsw128"
8464   [(set (match_operand:V8HI 0 "register_operand" "=x")
8465         (ss_plus:V8HI
8466           (mult:V8HI
8467             (zero_extend:V8HI
8468               (vec_select:V4QI
8469                 (match_operand:V16QI 1 "register_operand" "0")
8470                 (parallel [(const_int 0)
8471                            (const_int 2)
8472                            (const_int 4)
8473                            (const_int 6)
8474                            (const_int 8)
8475                            (const_int 10)
8476                            (const_int 12)
8477                            (const_int 14)])))
8478             (sign_extend:V8HI
8479               (vec_select:V8QI
8480                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8481                 (parallel [(const_int 0)
8482                            (const_int 2)
8483                            (const_int 4)
8484                            (const_int 6)
8485                            (const_int 8)
8486                            (const_int 10)
8487                            (const_int 12)
8488                            (const_int 14)]))))
8489           (mult:V8HI
8490             (zero_extend:V8HI
8491               (vec_select:V16QI (match_dup 1)
8492                 (parallel [(const_int 1)
8493                            (const_int 3)
8494                            (const_int 5)
8495                            (const_int 7)
8496                            (const_int 9)
8497                            (const_int 11)
8498                            (const_int 13)
8499                            (const_int 15)])))
8500             (sign_extend:V8HI
8501               (vec_select:V16QI (match_dup 2)
8502                 (parallel [(const_int 1)
8503                            (const_int 3)
8504                            (const_int 5)
8505                            (const_int 7)
8506                            (const_int 9)
8507                            (const_int 11)
8508                            (const_int 13)
8509                            (const_int 15)]))))))]
8510   "TARGET_SSSE3"
8511   "pmaddubsw\t{%2, %0|%0, %2}"
8512   [(set_attr "type" "sseiadd")
8513    (set_attr "prefix_data16" "1")
8514    (set_attr "prefix_extra" "1")
8515    (set_attr "mode" "TI")])
8516
8517 (define_insn "ssse3_pmaddubsw"
8518   [(set (match_operand:V4HI 0 "register_operand" "=y")
8519         (ss_plus:V4HI
8520           (mult:V4HI
8521             (zero_extend:V4HI
8522               (vec_select:V4QI
8523                 (match_operand:V8QI 1 "register_operand" "0")
8524                 (parallel [(const_int 0)
8525                            (const_int 2)
8526                            (const_int 4)
8527                            (const_int 6)])))
8528             (sign_extend:V4HI
8529               (vec_select:V4QI
8530                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8531                 (parallel [(const_int 0)
8532                            (const_int 2)
8533                            (const_int 4)
8534                            (const_int 6)]))))
8535           (mult:V4HI
8536             (zero_extend:V4HI
8537               (vec_select:V8QI (match_dup 1)
8538                 (parallel [(const_int 1)
8539                            (const_int 3)
8540                            (const_int 5)
8541                            (const_int 7)])))
8542             (sign_extend:V4HI
8543               (vec_select:V8QI (match_dup 2)
8544                 (parallel [(const_int 1)
8545                            (const_int 3)
8546                            (const_int 5)
8547                            (const_int 7)]))))))]
8548   "TARGET_SSSE3"
8549   "pmaddubsw\t{%2, %0|%0, %2}"
8550   [(set_attr "type" "sseiadd")
8551    (set_attr "prefix_extra" "1")
8552    (set_attr "mode" "DI")])
8553
8554 (define_expand "ssse3_pmulhrswv8hi3"
8555   [(set (match_operand:V8HI 0 "register_operand" "")
8556         (truncate:V8HI
8557           (lshiftrt:V8SI
8558             (plus:V8SI
8559               (lshiftrt:V8SI
8560                 (mult:V8SI
8561                   (sign_extend:V8SI
8562                     (match_operand:V8HI 1 "nonimmediate_operand" ""))
8563                   (sign_extend:V8SI
8564                     (match_operand:V8HI 2 "nonimmediate_operand" "")))
8565                 (const_int 14))
8566               (const_vector:V8HI [(const_int 1) (const_int 1)
8567                                   (const_int 1) (const_int 1)
8568                                   (const_int 1) (const_int 1)
8569                                   (const_int 1) (const_int 1)]))
8570             (const_int 1))))]
8571   "TARGET_SSSE3"
8572   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
8573
8574 (define_insn "*avx_pmulhrswv8hi3"
8575   [(set (match_operand:V8HI 0 "register_operand" "=x")
8576         (truncate:V8HI
8577           (lshiftrt:V8SI
8578             (plus:V8SI
8579               (lshiftrt:V8SI
8580                 (mult:V8SI
8581                   (sign_extend:V8SI
8582                     (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
8583                   (sign_extend:V8SI
8584                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8585                 (const_int 14))
8586               (const_vector:V8HI [(const_int 1) (const_int 1)
8587                                   (const_int 1) (const_int 1)
8588                                   (const_int 1) (const_int 1)
8589                                   (const_int 1) (const_int 1)]))
8590             (const_int 1))))]
8591   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8592   "vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
8593   [(set_attr "type" "sseimul")
8594    (set_attr "prefix" "vex")
8595    (set_attr "mode" "TI")])
8596
8597 (define_insn "*ssse3_pmulhrswv8hi3"
8598   [(set (match_operand:V8HI 0 "register_operand" "=x")
8599         (truncate:V8HI
8600           (lshiftrt:V8SI
8601             (plus:V8SI
8602               (lshiftrt:V8SI
8603                 (mult:V8SI
8604                   (sign_extend:V8SI
8605                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
8606                   (sign_extend:V8SI
8607                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8608                 (const_int 14))
8609               (const_vector:V8HI [(const_int 1) (const_int 1)
8610                                   (const_int 1) (const_int 1)
8611                                   (const_int 1) (const_int 1)
8612                                   (const_int 1) (const_int 1)]))
8613             (const_int 1))))]
8614   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8615   "pmulhrsw\t{%2, %0|%0, %2}"
8616   [(set_attr "type" "sseimul")
8617    (set_attr "prefix_data16" "1")
8618    (set_attr "prefix_extra" "1")
8619    (set_attr "mode" "TI")])
8620
8621 (define_expand "ssse3_pmulhrswv4hi3"
8622   [(set (match_operand:V4HI 0 "register_operand" "")
8623         (truncate:V4HI
8624           (lshiftrt:V4SI
8625             (plus:V4SI
8626               (lshiftrt:V4SI
8627                 (mult:V4SI
8628                   (sign_extend:V4SI
8629                     (match_operand:V4HI 1 "nonimmediate_operand" ""))
8630                   (sign_extend:V4SI
8631                     (match_operand:V4HI 2 "nonimmediate_operand" "")))
8632                 (const_int 14))
8633               (const_vector:V4HI [(const_int 1) (const_int 1)
8634                                   (const_int 1) (const_int 1)]))
8635             (const_int 1))))]
8636   "TARGET_SSSE3"
8637   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
8638
8639 (define_insn "*ssse3_pmulhrswv4hi3"
8640   [(set (match_operand:V4HI 0 "register_operand" "=y")
8641         (truncate:V4HI
8642           (lshiftrt:V4SI
8643             (plus:V4SI
8644               (lshiftrt:V4SI
8645                 (mult:V4SI
8646                   (sign_extend:V4SI
8647                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
8648                   (sign_extend:V4SI
8649                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
8650                 (const_int 14))
8651               (const_vector:V4HI [(const_int 1) (const_int 1)
8652                                   (const_int 1) (const_int 1)]))
8653             (const_int 1))))]
8654   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
8655   "pmulhrsw\t{%2, %0|%0, %2}"
8656   [(set_attr "type" "sseimul")
8657    (set_attr "prefix_extra" "1")
8658    (set_attr "mode" "DI")])
8659
8660 (define_insn "*avx_pshufbv16qi3"
8661   [(set (match_operand:V16QI 0 "register_operand" "=x")
8662         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8663                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8664                       UNSPEC_PSHUFB))]
8665   "TARGET_AVX"
8666   "vpshufb\t{%2, %1, %0|%0, %1, %2}";
8667   [(set_attr "type" "sselog1")
8668    (set_attr "prefix" "vex")
8669    (set_attr "mode" "TI")])
8670
8671 (define_insn "ssse3_pshufbv16qi3"
8672   [(set (match_operand:V16QI 0 "register_operand" "=x")
8673         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
8674                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8675                       UNSPEC_PSHUFB))]
8676   "TARGET_SSSE3"
8677   "pshufb\t{%2, %0|%0, %2}";
8678   [(set_attr "type" "sselog1")
8679    (set_attr "prefix_data16" "1")
8680    (set_attr "prefix_extra" "1")
8681    (set_attr "mode" "TI")])
8682
8683 (define_insn "ssse3_pshufbv8qi3"
8684   [(set (match_operand:V8QI 0 "register_operand" "=y")
8685         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
8686                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
8687                      UNSPEC_PSHUFB))]
8688   "TARGET_SSSE3"
8689   "pshufb\t{%2, %0|%0, %2}";
8690   [(set_attr "type" "sselog1")
8691    (set_attr "prefix_extra" "1")
8692    (set_attr "mode" "DI")])
8693
8694 (define_insn "*avx_psign<mode>3"
8695   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
8696         (unspec:SSEMODE124
8697           [(match_operand:SSEMODE124 1 "register_operand" "x")
8698            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
8699           UNSPEC_PSIGN))]
8700   "TARGET_AVX"
8701   "vpsign<ssevecsize>\t{%2, %1, %0|%0, %1, %2}";
8702   [(set_attr "type" "sselog1")
8703    (set_attr "prefix" "vex")
8704    (set_attr "mode" "TI")])
8705
8706 (define_insn "ssse3_psign<mode>3"
8707   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
8708         (unspec:SSEMODE124
8709           [(match_operand:SSEMODE124 1 "register_operand" "0")
8710            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
8711           UNSPEC_PSIGN))]
8712   "TARGET_SSSE3"
8713   "psign<ssevecsize>\t{%2, %0|%0, %2}";
8714   [(set_attr "type" "sselog1")
8715    (set_attr "prefix_data16" "1")
8716    (set_attr "prefix_extra" "1")
8717    (set_attr "mode" "TI")])
8718
8719 (define_insn "ssse3_psign<mode>3"
8720   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
8721         (unspec:MMXMODEI
8722           [(match_operand:MMXMODEI 1 "register_operand" "0")
8723            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
8724           UNSPEC_PSIGN))]
8725   "TARGET_SSSE3"
8726   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
8727   [(set_attr "type" "sselog1")
8728    (set_attr "prefix_extra" "1")
8729    (set_attr "mode" "DI")])
8730
8731 (define_insn "*avx_palignrti"
8732   [(set (match_operand:TI 0 "register_operand" "=x")
8733         (unspec:TI [(match_operand:TI 1 "register_operand" "x")
8734                     (match_operand:TI 2 "nonimmediate_operand" "xm")
8735                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
8736                    UNSPEC_PALIGNR))]
8737   "TARGET_AVX"
8738 {
8739   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8740   return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
8741 }
8742   [(set_attr "type" "sseishft")
8743    (set_attr "prefix" "vex")
8744    (set_attr "mode" "TI")])
8745
8746 (define_insn "ssse3_palignrti"
8747   [(set (match_operand:TI 0 "register_operand" "=x")
8748         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
8749                     (match_operand:TI 2 "nonimmediate_operand" "xm")
8750                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
8751                    UNSPEC_PALIGNR))]
8752   "TARGET_SSSE3"
8753 {
8754   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8755   return "palignr\t{%3, %2, %0|%0, %2, %3}";
8756 }
8757   [(set_attr "type" "sseishft")
8758    (set_attr "prefix_data16" "1")
8759    (set_attr "prefix_extra" "1")
8760    (set_attr "mode" "TI")])
8761
8762 (define_insn "ssse3_palignrdi"
8763   [(set (match_operand:DI 0 "register_operand" "=y")
8764         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
8765                     (match_operand:DI 2 "nonimmediate_operand" "ym")
8766                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
8767                    UNSPEC_PALIGNR))]
8768   "TARGET_SSSE3"
8769 {
8770   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8771   return "palignr\t{%3, %2, %0|%0, %2, %3}";
8772 }
8773   [(set_attr "type" "sseishft")
8774    (set_attr "prefix_extra" "1")
8775    (set_attr "mode" "DI")])
8776
8777 (define_insn "abs<mode>2"
8778   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
8779         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
8780   "TARGET_SSSE3"
8781   "%vpabs<ssevecsize>\t{%1, %0|%0, %1}"
8782   [(set_attr "type" "sselog1")
8783    (set_attr "prefix_data16" "1")
8784    (set_attr "prefix_extra" "1")
8785    (set_attr "prefix" "maybe_vex")
8786    (set_attr "mode" "TI")])
8787
8788 (define_insn "abs<mode>2"
8789   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
8790         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
8791   "TARGET_SSSE3"
8792   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
8793   [(set_attr "type" "sselog1")
8794    (set_attr "prefix_extra" "1")
8795    (set_attr "mode" "DI")])
8796
8797 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8798 ;;
8799 ;; AMD SSE4A instructions
8800 ;;
8801 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8802
8803 (define_insn "sse4a_movnt<mode>"
8804   [(set (match_operand:MODEF 0 "memory_operand" "=m")
8805         (unspec:MODEF
8806           [(match_operand:MODEF 1 "register_operand" "x")]
8807           UNSPEC_MOVNT))]
8808   "TARGET_SSE4A"
8809   "movnts<ssemodefsuffix>\t{%1, %0|%0, %1}"
8810   [(set_attr "type" "ssemov")
8811    (set_attr "mode" "<MODE>")])
8812
8813 (define_insn "sse4a_vmmovnt<mode>"
8814   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
8815         (unspec:<ssescalarmode>
8816           [(vec_select:<ssescalarmode>
8817              (match_operand:SSEMODEF2P 1 "register_operand" "x")
8818              (parallel [(const_int 0)]))]
8819           UNSPEC_MOVNT))]
8820   "TARGET_SSE4A"
8821   "movnts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
8822   [(set_attr "type" "ssemov")
8823    (set_attr "mode" "<ssescalarmode>")])
8824
8825 (define_insn "sse4a_extrqi"
8826   [(set (match_operand:V2DI 0 "register_operand" "=x")
8827         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8828                       (match_operand 2 "const_int_operand" "")
8829                       (match_operand 3 "const_int_operand" "")]
8830                      UNSPEC_EXTRQI))]
8831   "TARGET_SSE4A"
8832   "extrq\t{%3, %2, %0|%0, %2, %3}"
8833   [(set_attr "type" "sse")
8834    (set_attr "prefix_data16" "1")
8835    (set_attr "mode" "TI")])
8836
8837 (define_insn "sse4a_extrq"
8838   [(set (match_operand:V2DI 0 "register_operand" "=x")
8839         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8840                       (match_operand:V16QI 2 "register_operand" "x")]
8841                      UNSPEC_EXTRQ))]
8842   "TARGET_SSE4A"
8843   "extrq\t{%2, %0|%0, %2}"
8844   [(set_attr "type" "sse")
8845    (set_attr "prefix_data16" "1")
8846    (set_attr "mode" "TI")])
8847
8848 (define_insn "sse4a_insertqi"
8849   [(set (match_operand:V2DI 0 "register_operand" "=x")
8850         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8851                       (match_operand:V2DI 2 "register_operand" "x")
8852                       (match_operand 3 "const_int_operand" "")
8853                       (match_operand 4 "const_int_operand" "")]
8854                      UNSPEC_INSERTQI))]
8855   "TARGET_SSE4A"
8856   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
8857   [(set_attr "type" "sseins")
8858    (set_attr "prefix_rep" "1")
8859    (set_attr "mode" "TI")])
8860
8861 (define_insn "sse4a_insertq"
8862   [(set (match_operand:V2DI 0 "register_operand" "=x")
8863         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8864                       (match_operand:V2DI 2 "register_operand" "x")]
8865                      UNSPEC_INSERTQ))]
8866   "TARGET_SSE4A"
8867   "insertq\t{%2, %0|%0, %2}"
8868   [(set_attr "type" "sseins")
8869    (set_attr "prefix_rep" "1")
8870    (set_attr "mode" "TI")])
8871
8872 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8873 ;;
8874 ;; Intel SSE4.1 instructions
8875 ;;
8876 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8877
8878 (define_insn "avx_blendp<avxmodesuffixf2c><avxmodesuffix>"
8879   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
8880         (vec_merge:AVXMODEF2P
8881           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
8882           (match_operand:AVXMODEF2P 1 "register_operand" "x")
8883           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
8884   "TARGET_AVX"
8885   "vblendp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8886   [(set_attr "type" "ssemov")
8887    (set_attr "prefix" "vex")
8888    (set_attr "mode" "<avxvecmode>")])
8889
8890 (define_insn "avx_blendvp<avxmodesuffixf2c><avxmodesuffix>"
8891   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
8892         (unspec:AVXMODEF2P
8893           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
8894            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
8895            (match_operand:AVXMODEF2P 3 "register_operand" "x")]
8896           UNSPEC_BLENDV))]
8897   "TARGET_AVX"
8898   "vblendvp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8899   [(set_attr "type" "ssemov")
8900    (set_attr "prefix" "vex")
8901    (set_attr "mode" "<avxvecmode>")])
8902
8903 (define_insn "sse4_1_blendp<ssemodesuffixf2c>"
8904   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
8905         (vec_merge:SSEMODEF2P
8906           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
8907           (match_operand:SSEMODEF2P 1 "register_operand" "0")
8908           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
8909   "TARGET_SSE4_1"
8910   "blendp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
8911   [(set_attr "type" "ssemov")
8912    (set_attr "prefix_extra" "1")
8913    (set_attr "mode" "<MODE>")])
8914
8915 (define_insn "sse4_1_blendvp<ssemodesuffixf2c>"
8916   [(set (match_operand:SSEMODEF2P 0 "reg_not_xmm0_operand" "=x")
8917         (unspec:SSEMODEF2P
8918           [(match_operand:SSEMODEF2P 1 "reg_not_xmm0_operand" "0")
8919            (match_operand:SSEMODEF2P 2 "nonimm_not_xmm0_operand" "xm")
8920            (match_operand:SSEMODEF2P 3 "register_operand" "Yz")]
8921           UNSPEC_BLENDV))]
8922   "TARGET_SSE4_1"
8923   "blendvp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
8924   [(set_attr "type" "ssemov")
8925    (set_attr "prefix_extra" "1")
8926    (set_attr "mode" "<MODE>")])
8927
8928 (define_insn "avx_dpp<avxmodesuffixf2c><avxmodesuffix>"
8929   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
8930         (unspec:AVXMODEF2P
8931           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
8932            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
8933            (match_operand:SI 3 "const_0_to_255_operand" "n")]
8934           UNSPEC_DP))]
8935   "TARGET_AVX"
8936   "vdpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8937   [(set_attr "type" "ssemul")
8938    (set_attr "prefix" "vex")
8939    (set_attr "mode" "<avxvecmode>")])
8940
8941 (define_insn "sse4_1_dpp<ssemodesuffixf2c>"
8942   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
8943         (unspec:SSEMODEF2P
8944           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
8945            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
8946            (match_operand:SI 3 "const_0_to_255_operand" "n")]
8947           UNSPEC_DP))]
8948   "TARGET_SSE4_1"
8949   "dpp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
8950   [(set_attr "type" "ssemul")
8951    (set_attr "prefix_extra" "1")
8952    (set_attr "mode" "<MODE>")])
8953
8954 (define_insn "sse4_1_movntdqa"
8955   [(set (match_operand:V2DI 0 "register_operand" "=x")
8956         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
8957                      UNSPEC_MOVNTDQA))]
8958   "TARGET_SSE4_1"
8959   "%vmovntdqa\t{%1, %0|%0, %1}"
8960   [(set_attr "type" "ssecvt")
8961    (set_attr "prefix_extra" "1")
8962    (set_attr "prefix" "maybe_vex")
8963    (set_attr "mode" "TI")])
8964
8965 (define_insn "*avx_mpsadbw"
8966   [(set (match_operand:V16QI 0 "register_operand" "=x")
8967         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8968                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8969                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
8970                       UNSPEC_MPSADBW))]
8971   "TARGET_AVX"
8972   "vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8973   [(set_attr "type" "sselog1")
8974    (set_attr "prefix" "vex")
8975    (set_attr "mode" "TI")])
8976
8977 (define_insn "sse4_1_mpsadbw"
8978   [(set (match_operand:V16QI 0 "register_operand" "=x")
8979         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
8980                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8981                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
8982                       UNSPEC_MPSADBW))]
8983   "TARGET_SSE4_1"
8984   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
8985   [(set_attr "type" "sselog1")
8986    (set_attr "prefix_extra" "1")
8987    (set_attr "mode" "TI")])
8988
8989 (define_insn "*avx_packusdw"
8990   [(set (match_operand:V8HI 0 "register_operand" "=x")
8991         (vec_concat:V8HI
8992           (us_truncate:V4HI
8993             (match_operand:V4SI 1 "register_operand" "x"))
8994           (us_truncate:V4HI
8995             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
8996   "TARGET_AVX"
8997   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
8998   [(set_attr "type" "sselog")
8999    (set_attr "prefix" "vex")
9000    (set_attr "mode" "TI")])
9001
9002 (define_insn "sse4_1_packusdw"
9003   [(set (match_operand:V8HI 0 "register_operand" "=x")
9004         (vec_concat:V8HI
9005           (us_truncate:V4HI
9006             (match_operand:V4SI 1 "register_operand" "0"))
9007           (us_truncate:V4HI
9008             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9009   "TARGET_SSE4_1"
9010   "packusdw\t{%2, %0|%0, %2}"
9011   [(set_attr "type" "sselog")
9012    (set_attr "prefix_extra" "1")
9013    (set_attr "mode" "TI")])
9014
9015 (define_insn "*avx_pblendvb"
9016   [(set (match_operand:V16QI 0 "register_operand" "=x")
9017         (unspec:V16QI [(match_operand:V16QI 1 "register_operand"  "x")
9018                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9019                        (match_operand:V16QI 3 "register_operand" "x")]
9020                       UNSPEC_BLENDV))]
9021   "TARGET_AVX"
9022   "vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9023   [(set_attr "type" "ssemov")
9024    (set_attr "prefix" "vex")
9025    (set_attr "mode" "TI")])
9026
9027 (define_insn "sse4_1_pblendvb"
9028   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
9029         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
9030                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
9031                        (match_operand:V16QI 3 "register_operand" "Yz")]
9032                       UNSPEC_BLENDV))]
9033   "TARGET_SSE4_1"
9034   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
9035   [(set_attr "type" "ssemov")
9036    (set_attr "prefix_extra" "1")
9037    (set_attr "mode" "TI")])
9038
9039 (define_insn "*avx_pblendw"
9040   [(set (match_operand:V8HI 0 "register_operand" "=x")
9041         (vec_merge:V8HI
9042           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9043           (match_operand:V8HI 1 "register_operand" "x")
9044           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9045   "TARGET_AVX"
9046   "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9047   [(set_attr "type" "ssemov")
9048    (set_attr "prefix" "vex")
9049    (set_attr "mode" "TI")])
9050
9051 (define_insn "sse4_1_pblendw"
9052   [(set (match_operand:V8HI 0 "register_operand" "=x")
9053         (vec_merge:V8HI
9054           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9055           (match_operand:V8HI 1 "register_operand" "0")
9056           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9057   "TARGET_SSE4_1"
9058   "pblendw\t{%3, %2, %0|%0, %2, %3}"
9059   [(set_attr "type" "ssemov")
9060    (set_attr "prefix_extra" "1")
9061    (set_attr "mode" "TI")])
9062
9063 (define_insn "sse4_1_phminposuw"
9064   [(set (match_operand:V8HI 0 "register_operand" "=x")
9065         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
9066                      UNSPEC_PHMINPOSUW))]
9067   "TARGET_SSE4_1"
9068   "%vphminposuw\t{%1, %0|%0, %1}"
9069   [(set_attr "type" "sselog1")
9070    (set_attr "prefix_extra" "1")
9071    (set_attr "prefix" "maybe_vex")
9072    (set_attr "mode" "TI")])
9073
9074 (define_insn "sse4_1_extendv8qiv8hi2"
9075   [(set (match_operand:V8HI 0 "register_operand" "=x")
9076         (sign_extend:V8HI
9077           (vec_select:V8QI
9078             (match_operand:V16QI 1 "register_operand" "x")
9079             (parallel [(const_int 0)
9080                        (const_int 1)
9081                        (const_int 2)
9082                        (const_int 3)
9083                        (const_int 4)
9084                        (const_int 5)
9085                        (const_int 6)
9086                        (const_int 7)]))))]
9087   "TARGET_SSE4_1"
9088   "%vpmovsxbw\t{%1, %0|%0, %1}"
9089   [(set_attr "type" "ssemov")
9090    (set_attr "prefix_extra" "1")
9091    (set_attr "prefix" "maybe_vex")
9092    (set_attr "mode" "TI")])
9093
9094 (define_insn "*sse4_1_extendv8qiv8hi2"
9095   [(set (match_operand:V8HI 0 "register_operand" "=x")
9096         (sign_extend:V8HI
9097           (vec_select:V8QI
9098             (vec_duplicate:V16QI
9099               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9100             (parallel [(const_int 0)
9101                        (const_int 1)
9102                        (const_int 2)
9103                        (const_int 3)
9104                        (const_int 4)
9105                        (const_int 5)
9106                        (const_int 6)
9107                        (const_int 7)]))))]
9108   "TARGET_SSE4_1"
9109   "%vpmovsxbw\t{%1, %0|%0, %1}"
9110   [(set_attr "type" "ssemov")
9111    (set_attr "prefix_extra" "1")
9112    (set_attr "prefix" "maybe_vex")
9113    (set_attr "mode" "TI")])
9114
9115 (define_insn "sse4_1_extendv4qiv4si2"
9116   [(set (match_operand:V4SI 0 "register_operand" "=x")
9117         (sign_extend:V4SI
9118           (vec_select:V4QI
9119             (match_operand:V16QI 1 "register_operand" "x")
9120             (parallel [(const_int 0)
9121                        (const_int 1)
9122                        (const_int 2)
9123                        (const_int 3)]))))]
9124   "TARGET_SSE4_1"
9125   "%vpmovsxbd\t{%1, %0|%0, %1}"
9126   [(set_attr "type" "ssemov")
9127    (set_attr "prefix_extra" "1")
9128    (set_attr "prefix" "maybe_vex")
9129    (set_attr "mode" "TI")])
9130
9131 (define_insn "*sse4_1_extendv4qiv4si2"
9132   [(set (match_operand:V4SI 0 "register_operand" "=x")
9133         (sign_extend:V4SI
9134           (vec_select:V4QI
9135             (vec_duplicate:V16QI
9136               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9137             (parallel [(const_int 0)
9138                        (const_int 1)
9139                        (const_int 2)
9140                        (const_int 3)]))))]
9141   "TARGET_SSE4_1"
9142   "%vpmovsxbd\t{%1, %0|%0, %1}"
9143   [(set_attr "type" "ssemov")
9144    (set_attr "prefix_extra" "1")
9145    (set_attr "prefix" "maybe_vex")
9146    (set_attr "mode" "TI")])
9147
9148 (define_insn "sse4_1_extendv2qiv2di2"
9149   [(set (match_operand:V2DI 0 "register_operand" "=x")
9150         (sign_extend:V2DI
9151           (vec_select:V2QI
9152             (match_operand:V16QI 1 "register_operand" "x")
9153             (parallel [(const_int 0)
9154                        (const_int 1)]))))]
9155   "TARGET_SSE4_1"
9156   "%vpmovsxbq\t{%1, %0|%0, %1}"
9157   [(set_attr "type" "ssemov")
9158    (set_attr "prefix_extra" "1")
9159    (set_attr "prefix" "maybe_vex")
9160    (set_attr "mode" "TI")])
9161
9162 (define_insn "*sse4_1_extendv2qiv2di2"
9163   [(set (match_operand:V2DI 0 "register_operand" "=x")
9164         (sign_extend:V2DI
9165           (vec_select:V2QI
9166             (vec_duplicate:V16QI
9167               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9168             (parallel [(const_int 0)
9169                        (const_int 1)]))))]
9170   "TARGET_SSE4_1"
9171   "%vpmovsxbq\t{%1, %0|%0, %1}"
9172   [(set_attr "type" "ssemov")
9173    (set_attr "prefix_extra" "1")
9174    (set_attr "prefix" "maybe_vex")
9175    (set_attr "mode" "TI")])
9176
9177 (define_insn "sse4_1_extendv4hiv4si2"
9178   [(set (match_operand:V4SI 0 "register_operand" "=x")
9179         (sign_extend:V4SI
9180           (vec_select:V4HI
9181             (match_operand:V8HI 1 "register_operand" "x")
9182             (parallel [(const_int 0)
9183                        (const_int 1)
9184                        (const_int 2)
9185                        (const_int 3)]))))]
9186   "TARGET_SSE4_1"
9187   "%vpmovsxwd\t{%1, %0|%0, %1}"
9188   [(set_attr "type" "ssemov")
9189    (set_attr "prefix_extra" "1")
9190    (set_attr "prefix" "maybe_vex")
9191    (set_attr "mode" "TI")])
9192
9193 (define_insn "*sse4_1_extendv4hiv4si2"
9194   [(set (match_operand:V4SI 0 "register_operand" "=x")
9195         (sign_extend:V4SI
9196           (vec_select:V4HI
9197             (vec_duplicate:V8HI
9198               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9199             (parallel [(const_int 0)
9200                        (const_int 1)
9201                        (const_int 2)
9202                        (const_int 3)]))))]
9203   "TARGET_SSE4_1"
9204   "%vpmovsxwd\t{%1, %0|%0, %1}"
9205   [(set_attr "type" "ssemov")
9206    (set_attr "prefix_extra" "1")
9207    (set_attr "prefix" "maybe_vex")
9208    (set_attr "mode" "TI")])
9209
9210 (define_insn "sse4_1_extendv2hiv2di2"
9211   [(set (match_operand:V2DI 0 "register_operand" "=x")
9212         (sign_extend:V2DI
9213           (vec_select:V2HI
9214             (match_operand:V8HI 1 "register_operand" "x")
9215             (parallel [(const_int 0)
9216                        (const_int 1)]))))]
9217   "TARGET_SSE4_1"
9218   "%vpmovsxwq\t{%1, %0|%0, %1}"
9219   [(set_attr "type" "ssemov")
9220    (set_attr "prefix_extra" "1")
9221    (set_attr "prefix" "maybe_vex")
9222    (set_attr "mode" "TI")])
9223
9224 (define_insn "*sse4_1_extendv2hiv2di2"
9225   [(set (match_operand:V2DI 0 "register_operand" "=x")
9226         (sign_extend:V2DI
9227           (vec_select:V2HI
9228             (vec_duplicate:V8HI
9229               (match_operand:V8HI 1 "nonimmediate_operand" "xm"))
9230             (parallel [(const_int 0)
9231                        (const_int 1)]))))]
9232   "TARGET_SSE4_1"
9233   "%vpmovsxwq\t{%1, %0|%0, %1}"
9234   [(set_attr "type" "ssemov")
9235    (set_attr "prefix_extra" "1")
9236    (set_attr "prefix" "maybe_vex")
9237    (set_attr "mode" "TI")])
9238
9239 (define_insn "sse4_1_extendv2siv2di2"
9240   [(set (match_operand:V2DI 0 "register_operand" "=x")
9241         (sign_extend:V2DI
9242           (vec_select:V2SI
9243             (match_operand:V4SI 1 "register_operand" "x")
9244             (parallel [(const_int 0)
9245                        (const_int 1)]))))]
9246   "TARGET_SSE4_1"
9247   "%vpmovsxdq\t{%1, %0|%0, %1}"
9248   [(set_attr "type" "ssemov")
9249    (set_attr "prefix_extra" "1")
9250    (set_attr "prefix" "maybe_vex")
9251    (set_attr "mode" "TI")])
9252
9253 (define_insn "*sse4_1_extendv2siv2di2"
9254   [(set (match_operand:V2DI 0 "register_operand" "=x")
9255         (sign_extend:V2DI
9256           (vec_select:V2SI
9257             (vec_duplicate:V4SI
9258               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9259             (parallel [(const_int 0)
9260                        (const_int 1)]))))]
9261   "TARGET_SSE4_1"
9262   "%vpmovsxdq\t{%1, %0|%0, %1}"
9263   [(set_attr "type" "ssemov")
9264    (set_attr "prefix_extra" "1")
9265    (set_attr "prefix" "maybe_vex")
9266    (set_attr "mode" "TI")])
9267
9268 (define_insn "sse4_1_zero_extendv8qiv8hi2"
9269   [(set (match_operand:V8HI 0 "register_operand" "=x")
9270         (zero_extend:V8HI
9271           (vec_select:V8QI
9272             (match_operand:V16QI 1 "register_operand" "x")
9273             (parallel [(const_int 0)
9274                        (const_int 1)
9275                        (const_int 2)
9276                        (const_int 3)
9277                        (const_int 4)
9278                        (const_int 5)
9279                        (const_int 6)
9280                        (const_int 7)]))))]
9281   "TARGET_SSE4_1"
9282   "%vpmovzxbw\t{%1, %0|%0, %1}"
9283   [(set_attr "type" "ssemov")
9284    (set_attr "prefix_extra" "1")
9285    (set_attr "prefix" "maybe_vex")
9286    (set_attr "mode" "TI")])
9287
9288 (define_insn "*sse4_1_zero_extendv8qiv8hi2"
9289   [(set (match_operand:V8HI 0 "register_operand" "=x")
9290         (zero_extend:V8HI
9291           (vec_select:V8QI
9292             (vec_duplicate:V16QI
9293               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9294             (parallel [(const_int 0)
9295                        (const_int 1)
9296                        (const_int 2)
9297                        (const_int 3)
9298                        (const_int 4)
9299                        (const_int 5)
9300                        (const_int 6)
9301                        (const_int 7)]))))]
9302   "TARGET_SSE4_1"
9303   "%vpmovzxbw\t{%1, %0|%0, %1}"
9304   [(set_attr "type" "ssemov")
9305    (set_attr "prefix_extra" "1")
9306    (set_attr "prefix" "maybe_vex")
9307    (set_attr "mode" "TI")])
9308
9309 (define_insn "sse4_1_zero_extendv4qiv4si2"
9310   [(set (match_operand:V4SI 0 "register_operand" "=x")
9311         (zero_extend:V4SI
9312           (vec_select:V4QI
9313             (match_operand:V16QI 1 "register_operand" "x")
9314             (parallel [(const_int 0)
9315                        (const_int 1)
9316                        (const_int 2)
9317                        (const_int 3)]))))]
9318   "TARGET_SSE4_1"
9319   "%vpmovzxbd\t{%1, %0|%0, %1}"
9320   [(set_attr "type" "ssemov")
9321    (set_attr "prefix_extra" "1")
9322    (set_attr "prefix" "maybe_vex")
9323    (set_attr "mode" "TI")])
9324
9325 (define_insn "*sse4_1_zero_extendv4qiv4si2"
9326   [(set (match_operand:V4SI 0 "register_operand" "=x")
9327         (zero_extend:V4SI
9328           (vec_select:V4QI
9329             (vec_duplicate:V16QI
9330               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9331             (parallel [(const_int 0)
9332                        (const_int 1)
9333                        (const_int 2)
9334                        (const_int 3)]))))]
9335   "TARGET_SSE4_1"
9336   "%vpmovzxbd\t{%1, %0|%0, %1}"
9337   [(set_attr "type" "ssemov")
9338    (set_attr "prefix_extra" "1")
9339    (set_attr "prefix" "maybe_vex")
9340    (set_attr "mode" "TI")])
9341
9342 (define_insn "sse4_1_zero_extendv2qiv2di2"
9343   [(set (match_operand:V2DI 0 "register_operand" "=x")
9344         (zero_extend:V2DI
9345           (vec_select:V2QI
9346             (match_operand:V16QI 1 "register_operand" "x")
9347             (parallel [(const_int 0)
9348                        (const_int 1)]))))]
9349   "TARGET_SSE4_1"
9350   "%vpmovzxbq\t{%1, %0|%0, %1}"
9351   [(set_attr "type" "ssemov")
9352    (set_attr "prefix_extra" "1")
9353    (set_attr "prefix" "maybe_vex")
9354    (set_attr "mode" "TI")])
9355
9356 (define_insn "*sse4_1_zero_extendv2qiv2di2"
9357   [(set (match_operand:V2DI 0 "register_operand" "=x")
9358         (zero_extend:V2DI
9359           (vec_select:V2QI
9360             (vec_duplicate:V16QI
9361               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9362             (parallel [(const_int 0)
9363                        (const_int 1)]))))]
9364   "TARGET_SSE4_1"
9365   "%vpmovzxbq\t{%1, %0|%0, %1}"
9366   [(set_attr "type" "ssemov")
9367    (set_attr "prefix_extra" "1")
9368    (set_attr "prefix" "maybe_vex")
9369    (set_attr "mode" "TI")])
9370
9371 (define_insn "sse4_1_zero_extendv4hiv4si2"
9372   [(set (match_operand:V4SI 0 "register_operand" "=x")
9373         (zero_extend:V4SI
9374           (vec_select:V4HI
9375             (match_operand:V8HI 1 "register_operand" "x")
9376             (parallel [(const_int 0)
9377                        (const_int 1)
9378                        (const_int 2)
9379                        (const_int 3)]))))]
9380   "TARGET_SSE4_1"
9381   "%vpmovzxwd\t{%1, %0|%0, %1}"
9382   [(set_attr "type" "ssemov")
9383    (set_attr "prefix_extra" "1")
9384    (set_attr "prefix" "maybe_vex")
9385    (set_attr "mode" "TI")])
9386
9387 (define_insn "*sse4_1_zero_extendv4hiv4si2"
9388   [(set (match_operand:V4SI 0 "register_operand" "=x")
9389         (zero_extend:V4SI
9390           (vec_select:V4HI
9391             (vec_duplicate:V8HI
9392               (match_operand:V4HI 1 "nonimmediate_operand" "xm"))
9393             (parallel [(const_int 0)
9394                        (const_int 1)
9395                        (const_int 2)
9396                        (const_int 3)]))))]
9397   "TARGET_SSE4_1"
9398   "%vpmovzxwd\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 "sse4_1_zero_extendv2hiv2di2"
9405   [(set (match_operand:V2DI 0 "register_operand" "=x")
9406         (zero_extend:V2DI
9407           (vec_select:V2HI
9408             (match_operand:V8HI 1 "register_operand" "x")
9409             (parallel [(const_int 0)
9410                        (const_int 1)]))))]
9411   "TARGET_SSE4_1"
9412   "%vpmovzxwq\t{%1, %0|%0, %1}"
9413   [(set_attr "type" "ssemov")
9414    (set_attr "prefix_extra" "1")
9415    (set_attr "prefix" "maybe_vex")
9416    (set_attr "mode" "TI")])
9417
9418 (define_insn "*sse4_1_zero_extendv2hiv2di2"
9419   [(set (match_operand:V2DI 0 "register_operand" "=x")
9420         (zero_extend:V2DI
9421           (vec_select:V2HI
9422             (vec_duplicate:V8HI
9423               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9424             (parallel [(const_int 0)
9425                        (const_int 1)]))))]
9426   "TARGET_SSE4_1"
9427   "%vpmovzxwq\t{%1, %0|%0, %1}"
9428   [(set_attr "type" "ssemov")
9429    (set_attr "prefix_extra" "1")
9430    (set_attr "prefix" "maybe_vex")
9431    (set_attr "mode" "TI")])
9432
9433 (define_insn "sse4_1_zero_extendv2siv2di2"
9434   [(set (match_operand:V2DI 0 "register_operand" "=x")
9435         (zero_extend:V2DI
9436           (vec_select:V2SI
9437             (match_operand:V4SI 1 "register_operand" "x")
9438             (parallel [(const_int 0)
9439                        (const_int 1)]))))]
9440   "TARGET_SSE4_1"
9441   "%vpmovzxdq\t{%1, %0|%0, %1}"
9442   [(set_attr "type" "ssemov")
9443    (set_attr "prefix_extra" "1")
9444    (set_attr "prefix" "maybe_vex")
9445    (set_attr "mode" "TI")])
9446
9447 (define_insn "*sse4_1_zero_extendv2siv2di2"
9448   [(set (match_operand:V2DI 0 "register_operand" "=x")
9449         (zero_extend:V2DI
9450           (vec_select:V2SI
9451             (vec_duplicate:V4SI
9452               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9453             (parallel [(const_int 0)
9454                        (const_int 1)]))))]
9455   "TARGET_SSE4_1"
9456   "%vpmovzxdq\t{%1, %0|%0, %1}"
9457   [(set_attr "type" "ssemov")
9458    (set_attr "prefix_extra" "1")
9459    (set_attr "prefix" "maybe_vex")
9460    (set_attr "mode" "TI")])
9461
9462 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
9463 ;; setting FLAGS_REG. But it is not a really compare instruction.
9464 (define_insn "avx_vtestp<avxmodesuffixf2c><avxmodesuffix>"
9465   [(set (reg:CC FLAGS_REG)
9466         (unspec:CC [(match_operand:AVXMODEF2P 0 "register_operand" "x")
9467                     (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")]
9468                    UNSPEC_VTESTP))]
9469   "TARGET_AVX"
9470   "vtestp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
9471   [(set_attr "type" "ssecomi")
9472    (set_attr "prefix" "vex")
9473    (set_attr "mode" "<MODE>")])
9474
9475 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
9476 ;; But it is not a really compare instruction.
9477 (define_insn "avx_ptest256"
9478   [(set (reg:CC FLAGS_REG)
9479         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
9480                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
9481                    UNSPEC_PTEST))]
9482   "TARGET_AVX"
9483   "vptest\t{%1, %0|%0, %1}"
9484   [(set_attr "type" "ssecomi")
9485    (set_attr "prefix" "vex")
9486    (set_attr "mode" "OI")])
9487
9488 (define_insn "sse4_1_ptest"
9489   [(set (reg:CC FLAGS_REG)
9490         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
9491                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
9492                    UNSPEC_PTEST))]
9493   "TARGET_SSE4_1"
9494   "%vptest\t{%1, %0|%0, %1}"
9495   [(set_attr "type" "ssecomi")
9496    (set_attr "prefix_extra" "1")
9497    (set_attr "prefix" "maybe_vex")
9498    (set_attr "mode" "TI")])
9499
9500 (define_insn "avx_roundp<avxmodesuffixf2c>256"
9501   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
9502         (unspec:AVX256MODEF2P
9503           [(match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "xm")
9504            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9505           UNSPEC_ROUND))]
9506   "TARGET_AVX"
9507   "vroundp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9508   [(set_attr "type" "ssecvt")
9509    (set_attr "prefix" "vex")
9510    (set_attr "mode" "<MODE>")])
9511
9512 (define_insn "sse4_1_roundp<ssemodesuffixf2c>"
9513   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9514         (unspec:SSEMODEF2P
9515           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")
9516            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9517           UNSPEC_ROUND))]
9518   "TARGET_ROUND"
9519   "%vroundp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9520   [(set_attr "type" "ssecvt")
9521    (set_attr "prefix_extra" "1")
9522    (set_attr "prefix" "maybe_vex")
9523    (set_attr "mode" "<MODE>")])
9524
9525 (define_insn "*avx_rounds<ssemodesuffixf2c>"
9526   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9527         (vec_merge:SSEMODEF2P
9528           (unspec:SSEMODEF2P
9529             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9530              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9531             UNSPEC_ROUND)
9532           (match_operand:SSEMODEF2P 1 "register_operand" "x")
9533           (const_int 1)))]
9534   "TARGET_AVX"
9535   "vrounds<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9536   [(set_attr "type" "ssecvt")
9537    (set_attr "prefix" "vex")
9538    (set_attr "mode" "<MODE>")])
9539
9540 (define_insn "sse4_1_rounds<ssemodesuffixf2c>"
9541   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9542         (vec_merge:SSEMODEF2P
9543           (unspec:SSEMODEF2P
9544             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9545              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9546             UNSPEC_ROUND)
9547           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9548           (const_int 1)))]
9549   "TARGET_ROUND"
9550   "rounds<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9551   [(set_attr "type" "ssecvt")
9552    (set_attr "prefix_extra" "1")
9553    (set_attr "mode" "<MODE>")])
9554
9555 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9556 ;;
9557 ;; Intel SSE4.2 string/text processing instructions
9558 ;;
9559 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9560
9561 (define_insn_and_split "sse4_2_pcmpestr"
9562   [(set (match_operand:SI 0 "register_operand" "=c,c")
9563         (unspec:SI
9564           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
9565            (match_operand:SI 3 "register_operand" "a,a")
9566            (match_operand:V16QI 4 "nonimm_not_xmm0_operand" "x,m")
9567            (match_operand:SI 5 "register_operand" "d,d")
9568            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
9569           UNSPEC_PCMPESTR))
9570    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9571         (unspec:V16QI
9572           [(match_dup 2)
9573            (match_dup 3)
9574            (match_dup 4)
9575            (match_dup 5)
9576            (match_dup 6)]
9577           UNSPEC_PCMPESTR))
9578    (set (reg:CC FLAGS_REG)
9579         (unspec:CC
9580           [(match_dup 2)
9581            (match_dup 3)
9582            (match_dup 4)
9583            (match_dup 5)
9584            (match_dup 6)]
9585           UNSPEC_PCMPESTR))]
9586   "TARGET_SSE4_2
9587    && !(reload_completed || reload_in_progress)"
9588   "#"
9589   "&& 1"
9590   [(const_int 0)]
9591 {
9592   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9593   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9594   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9595
9596   if (ecx)
9597     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
9598                                      operands[3], operands[4],
9599                                      operands[5], operands[6]));
9600   if (xmm0)
9601     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
9602                                      operands[3], operands[4],
9603                                      operands[5], operands[6]));
9604   if (flags && !(ecx || xmm0))
9605     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
9606                                            operands[2], operands[3],
9607                                            operands[4], operands[5],
9608                                            operands[6]));
9609   DONE;
9610 }
9611   [(set_attr "type" "sselog")
9612    (set_attr "prefix_data16" "1")
9613    (set_attr "prefix_extra" "1")
9614    (set_attr "memory" "none,load")
9615    (set_attr "mode" "TI")])
9616
9617 (define_insn "sse4_2_pcmpestri"
9618   [(set (match_operand:SI 0 "register_operand" "=c,c")
9619         (unspec:SI
9620           [(match_operand:V16QI 1 "register_operand" "x,x")
9621            (match_operand:SI 2 "register_operand" "a,a")
9622            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9623            (match_operand:SI 4 "register_operand" "d,d")
9624            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9625           UNSPEC_PCMPESTR))
9626    (set (reg:CC FLAGS_REG)
9627         (unspec:CC
9628           [(match_dup 1)
9629            (match_dup 2)
9630            (match_dup 3)
9631            (match_dup 4)
9632            (match_dup 5)]
9633           UNSPEC_PCMPESTR))]
9634   "TARGET_SSE4_2"
9635   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
9636   [(set_attr "type" "sselog")
9637    (set_attr "prefix_data16" "1")
9638    (set_attr "prefix_extra" "1")
9639    (set_attr "prefix" "maybe_vex")
9640    (set_attr "memory" "none,load")
9641    (set_attr "mode" "TI")])
9642
9643 (define_insn "sse4_2_pcmpestrm"
9644   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9645         (unspec:V16QI
9646           [(match_operand:V16QI 1 "register_operand" "x,x")
9647            (match_operand:SI 2 "register_operand" "a,a")
9648            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9649            (match_operand:SI 4 "register_operand" "d,d")
9650            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9651           UNSPEC_PCMPESTR))
9652    (set (reg:CC FLAGS_REG)
9653         (unspec:CC
9654           [(match_dup 1)
9655            (match_dup 2)
9656            (match_dup 3)
9657            (match_dup 4)
9658            (match_dup 5)]
9659           UNSPEC_PCMPESTR))]
9660   "TARGET_SSE4_2"
9661   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
9662   [(set_attr "type" "sselog")
9663    (set_attr "prefix_data16" "1")
9664    (set_attr "prefix_extra" "1")
9665    (set_attr "prefix" "maybe_vex")
9666    (set_attr "memory" "none,load")
9667    (set_attr "mode" "TI")])
9668
9669 (define_insn "sse4_2_pcmpestr_cconly"
9670   [(set (reg:CC FLAGS_REG)
9671         (unspec:CC
9672           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9673            (match_operand:SI 3 "register_operand" "a,a,a,a")
9674            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
9675            (match_operand:SI 5 "register_operand" "d,d,d,d")
9676            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
9677           UNSPEC_PCMPESTR))
9678    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9679    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9680   "TARGET_SSE4_2"
9681   "@
9682    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9683    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9684    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
9685    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
9686   [(set_attr "type" "sselog")
9687    (set_attr "prefix_data16" "1")
9688    (set_attr "prefix_extra" "1")
9689    (set_attr "memory" "none,load,none,load")
9690    (set_attr "prefix" "maybe_vex")
9691    (set_attr "mode" "TI")])
9692
9693 (define_insn_and_split "sse4_2_pcmpistr"
9694   [(set (match_operand:SI 0 "register_operand" "=c,c")
9695         (unspec:SI
9696           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
9697            (match_operand:V16QI 3 "nonimm_not_xmm0_operand" "x,m")
9698            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
9699           UNSPEC_PCMPISTR))
9700    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9701         (unspec:V16QI
9702           [(match_dup 2)
9703            (match_dup 3)
9704            (match_dup 4)]
9705           UNSPEC_PCMPISTR))
9706    (set (reg:CC FLAGS_REG)
9707         (unspec:CC
9708           [(match_dup 2)
9709            (match_dup 3)
9710            (match_dup 4)]
9711           UNSPEC_PCMPISTR))]
9712   "TARGET_SSE4_2
9713    && !(reload_completed || reload_in_progress)"
9714   "#"
9715   "&& 1"
9716   [(const_int 0)]
9717 {
9718   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9719   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9720   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9721
9722   if (ecx)
9723     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
9724                                      operands[3], operands[4]));
9725   if (xmm0)
9726     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
9727                                      operands[3], operands[4]));
9728   if (flags && !(ecx || xmm0))
9729     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
9730                                            operands[2], operands[3],
9731                                            operands[4]));
9732   DONE;
9733 }
9734   [(set_attr "type" "sselog")
9735    (set_attr "prefix_data16" "1")
9736    (set_attr "prefix_extra" "1")
9737    (set_attr "memory" "none,load")
9738    (set_attr "mode" "TI")])
9739
9740 (define_insn "sse4_2_pcmpistri"
9741   [(set (match_operand:SI 0 "register_operand" "=c,c")
9742         (unspec:SI
9743           [(match_operand:V16QI 1 "register_operand" "x,x")
9744            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9745            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9746           UNSPEC_PCMPISTR))
9747    (set (reg:CC FLAGS_REG)
9748         (unspec:CC
9749           [(match_dup 1)
9750            (match_dup 2)
9751            (match_dup 3)]
9752           UNSPEC_PCMPISTR))]
9753   "TARGET_SSE4_2"
9754   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
9755   [(set_attr "type" "sselog")
9756    (set_attr "prefix_data16" "1")
9757    (set_attr "prefix_extra" "1")
9758    (set_attr "prefix" "maybe_vex")
9759    (set_attr "memory" "none,load")
9760    (set_attr "mode" "TI")])
9761
9762 (define_insn "sse4_2_pcmpistrm"
9763   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9764         (unspec:V16QI
9765           [(match_operand:V16QI 1 "register_operand" "x,x")
9766            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9767            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9768           UNSPEC_PCMPISTR))
9769    (set (reg:CC FLAGS_REG)
9770         (unspec:CC
9771           [(match_dup 1)
9772            (match_dup 2)
9773            (match_dup 3)]
9774           UNSPEC_PCMPISTR))]
9775   "TARGET_SSE4_2"
9776   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
9777   [(set_attr "type" "sselog")
9778    (set_attr "prefix_data16" "1")
9779    (set_attr "prefix_extra" "1")
9780    (set_attr "prefix" "maybe_vex")
9781    (set_attr "memory" "none,load")
9782    (set_attr "mode" "TI")])
9783
9784 (define_insn "sse4_2_pcmpistr_cconly"
9785   [(set (reg:CC FLAGS_REG)
9786         (unspec:CC
9787           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9788            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
9789            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
9790           UNSPEC_PCMPISTR))
9791    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9792    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9793   "TARGET_SSE4_2"
9794   "@
9795    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9796    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9797    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
9798    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
9799   [(set_attr "type" "sselog")
9800    (set_attr "prefix_data16" "1")
9801    (set_attr "prefix_extra" "1")
9802    (set_attr "memory" "none,load,none,load")
9803    (set_attr "prefix" "maybe_vex")
9804    (set_attr "mode" "TI")])
9805
9806 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9807 ;;
9808 ;; SSE5 instructions
9809 ;;
9810 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9811
9812 ;; SSE5 parallel integer multiply/add instructions.
9813 ;; Note the instruction does not allow the value being added to be a memory
9814 ;; operation.  However by pretending via the nonimmediate_operand predicate
9815 ;; that it does and splitting it later allows the following to be recognized:
9816 ;;      a[i] = b[i] * c[i] + d[i];
9817 (define_insn "sse5_pmacsww"
9818   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x")
9819         (plus:V8HI
9820          (mult:V8HI
9821           (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,xm")
9822           (match_operand:V8HI 2 "nonimmediate_operand" "x,xm,x"))
9823          (match_operand:V8HI 3 "register_operand" "0,0,0")))]
9824   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)"
9825   "@
9826    pmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}
9827    pmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}
9828    pmacsww\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9829   [(set_attr "type" "ssemuladd")
9830    (set_attr "mode" "TI")])
9831
9832 ;; Split pmacsww with two memory operands into a load and the pmacsww.
9833 (define_split
9834   [(set (match_operand:V8HI 0 "register_operand" "")
9835         (plus:V8HI
9836          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
9837                     (match_operand:V8HI 2 "nonimmediate_operand" ""))
9838          (match_operand:V8HI 3 "nonimmediate_operand" "")))]
9839   "TARGET_SSE5
9840    && !ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)
9841    && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)
9842    && !reg_mentioned_p (operands[0], operands[1])
9843    && !reg_mentioned_p (operands[0], operands[2])
9844    && !reg_mentioned_p (operands[0], operands[3])"
9845   [(const_int 0)]
9846 {
9847   ix86_expand_sse5_multiple_memory (operands, 4, V8HImode);
9848   emit_insn (gen_sse5_pmacsww (operands[0], operands[1], operands[2],
9849                                operands[3]));
9850   DONE;
9851 })
9852
9853 (define_insn "sse5_pmacssww"
9854   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x")
9855         (ss_plus:V8HI
9856          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
9857                     (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x"))
9858          (match_operand:V8HI 3 "register_operand" "0,0,0")))]
9859   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
9860   "@
9861    pmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}
9862    pmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}
9863    pmacssww\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9864   [(set_attr "type" "ssemuladd")
9865    (set_attr "mode" "TI")])
9866
9867 ;; Note the instruction does not allow the value being added to be a memory
9868 ;; operation.  However by pretending via the nonimmediate_operand predicate
9869 ;; that it does and splitting it later allows the following to be recognized:
9870 ;;      a[i] = b[i] * c[i] + d[i];
9871 (define_insn "sse5_pmacsdd"
9872   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
9873         (plus:V4SI
9874          (mult:V4SI
9875           (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9876           (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x"))
9877          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
9878   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)"
9879   "@
9880    pmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
9881    pmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
9882    pmacsdd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9883   [(set_attr "type" "ssemuladd")
9884    (set_attr "mode" "TI")])
9885
9886 ;; Split pmacsdd with two memory operands into a load and the pmacsdd.
9887 (define_split
9888   [(set (match_operand:V4SI 0 "register_operand" "")
9889         (plus:V4SI
9890          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "")
9891                     (match_operand:V4SI 2 "nonimmediate_operand" ""))
9892          (match_operand:V4SI 3 "nonimmediate_operand" "")))]
9893   "TARGET_SSE5
9894    && !ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)
9895    && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)
9896    && !reg_mentioned_p (operands[0], operands[1])
9897    && !reg_mentioned_p (operands[0], operands[2])
9898    && !reg_mentioned_p (operands[0], operands[3])"
9899   [(const_int 0)]
9900 {
9901   ix86_expand_sse5_multiple_memory (operands, 4, V4SImode);
9902   emit_insn (gen_sse5_pmacsdd (operands[0], operands[1], operands[2],
9903                                operands[3]));
9904   DONE;
9905 })
9906
9907 (define_insn "sse5_pmacssdd"
9908   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
9909         (ss_plus:V4SI
9910          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9911                     (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x"))
9912          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
9913   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
9914   "@
9915    pmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
9916    pmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
9917    pmacssdd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9918   [(set_attr "type" "ssemuladd")
9919    (set_attr "mode" "TI")])
9920
9921 (define_insn "sse5_pmacssdql"
9922   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
9923         (ss_plus:V2DI
9924          (mult:V2DI
9925           (sign_extend:V2DI
9926            (vec_select:V2SI
9927             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9928             (parallel [(const_int 1)
9929                        (const_int 3)])))
9930            (vec_select:V2SI
9931             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
9932             (parallel [(const_int 1)
9933                        (const_int 3)])))
9934          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
9935   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
9936   "@
9937    pmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
9938    pmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
9939    pmacssdql\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9940   [(set_attr "type" "ssemuladd")
9941    (set_attr "mode" "TI")])
9942
9943 (define_insn "sse5_pmacssdqh"
9944   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
9945         (ss_plus:V2DI
9946          (mult:V2DI
9947           (sign_extend:V2DI
9948            (vec_select:V2SI
9949             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9950             (parallel [(const_int 0)
9951                        (const_int 2)])))
9952           (sign_extend:V2DI
9953            (vec_select:V2SI
9954             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
9955             (parallel [(const_int 0)
9956                        (const_int 2)]))))
9957          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
9958   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
9959   "@
9960    pmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
9961    pmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
9962    pmacssdqh\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9963   [(set_attr "type" "ssemuladd")
9964    (set_attr "mode" "TI")])
9965
9966 (define_insn "sse5_pmacsdql"
9967   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
9968         (plus:V2DI
9969          (mult:V2DI
9970           (sign_extend:V2DI
9971            (vec_select:V2SI
9972             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9973             (parallel [(const_int 1)
9974                        (const_int 3)])))
9975           (sign_extend:V2DI
9976            (vec_select:V2SI
9977             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
9978             (parallel [(const_int 1)
9979                        (const_int 3)]))))
9980          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
9981   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
9982   "@
9983    pmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
9984    pmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
9985    pmacsdql\t{%3, %1, %2, %0|%0, %2, %1, %3}"
9986   [(set_attr "type" "ssemuladd")
9987    (set_attr "mode" "TI")])
9988
9989 (define_insn_and_split "*sse5_pmacsdql_mem"
9990   [(set (match_operand:V2DI 0 "register_operand" "=&x,&x,&x")
9991         (plus:V2DI
9992          (mult:V2DI
9993           (sign_extend:V2DI
9994            (vec_select:V2SI
9995             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
9996             (parallel [(const_int 1)
9997                        (const_int 3)])))
9998           (sign_extend:V2DI
9999            (vec_select:V2SI
10000             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10001             (parallel [(const_int 1)
10002                        (const_int 3)]))))
10003          (match_operand:V2DI 3 "memory_operand" "m,m,m")))]
10004   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, -1, true)"
10005   "#"
10006   "&& (reload_completed
10007        || (!reg_mentioned_p (operands[0], operands[1])
10008            && !reg_mentioned_p (operands[0], operands[2])))"
10009   [(set (match_dup 0)
10010         (match_dup 3))
10011    (set (match_dup 0)
10012         (plus:V2DI
10013          (mult:V2DI
10014           (sign_extend:V2DI
10015            (vec_select:V2SI
10016             (match_dup 1)
10017             (parallel [(const_int 1)
10018                        (const_int 3)])))
10019           (sign_extend:V2DI
10020            (vec_select:V2SI
10021             (match_dup 2)
10022             (parallel [(const_int 1)
10023                        (const_int 3)]))))
10024          (match_dup 0)))])
10025
10026 ;; We don't have a straight 32-bit parallel multiply and extend on SSE5, so
10027 ;; fake it with a multiply/add.  In general, we expect the define_split to
10028 ;; occur before register allocation, so we have to handle the corner case where
10029 ;; the target is the same as operands 1/2
10030 (define_insn_and_split "sse5_mulv2div2di3_low"
10031   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10032         (mult:V2DI
10033           (sign_extend:V2DI
10034             (vec_select:V2SI
10035               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10036               (parallel [(const_int 1)
10037                          (const_int 3)])))
10038           (sign_extend:V2DI
10039             (vec_select:V2SI
10040               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10041               (parallel [(const_int 1)
10042                          (const_int 3)])))))]
10043   "TARGET_SSE5"
10044   "#"
10045   "&& (reload_completed
10046        || (!reg_mentioned_p (operands[0], operands[1])
10047            && !reg_mentioned_p (operands[0], operands[2])))"
10048   [(set (match_dup 0)
10049         (match_dup 3))
10050    (set (match_dup 0)
10051         (plus:V2DI
10052          (mult:V2DI
10053           (sign_extend:V2DI
10054            (vec_select:V2SI
10055             (match_dup 1)
10056             (parallel [(const_int 1)
10057                        (const_int 3)])))
10058           (sign_extend:V2DI
10059            (vec_select:V2SI
10060             (match_dup 2)
10061             (parallel [(const_int 1)
10062                        (const_int 3)]))))
10063          (match_dup 0)))]
10064 {
10065   operands[3] = CONST0_RTX (V2DImode);
10066 }
10067   [(set_attr "type" "ssemuladd")
10068    (set_attr "mode" "TI")])
10069
10070 (define_insn "sse5_pmacsdqh"
10071   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
10072         (plus:V2DI
10073          (mult:V2DI
10074           (sign_extend:V2DI
10075            (vec_select:V2SI
10076             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10077             (parallel [(const_int 0)
10078                        (const_int 2)])))
10079           (sign_extend:V2DI
10080            (vec_select:V2SI
10081             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10082             (parallel [(const_int 0)
10083                        (const_int 2)]))))
10084          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
10085   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10086   "@
10087    pmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10088    pmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10089    pmacsdqh\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10090   [(set_attr "type" "ssemuladd")
10091    (set_attr "mode" "TI")])
10092
10093 (define_insn_and_split "*sse5_pmacsdqh_mem"
10094   [(set (match_operand:V2DI 0 "register_operand" "=&x,&x,&x")
10095         (plus:V2DI
10096          (mult:V2DI
10097           (sign_extend:V2DI
10098            (vec_select:V2SI
10099             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10100             (parallel [(const_int 0)
10101                        (const_int 2)])))
10102           (sign_extend:V2DI
10103            (vec_select:V2SI
10104             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10105             (parallel [(const_int 0)
10106                        (const_int 2)]))))
10107          (match_operand:V2DI 3 "memory_operand" "m,m,m")))]
10108   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, -1, true)"
10109   "#"
10110   "&& (reload_completed
10111        || (!reg_mentioned_p (operands[0], operands[1])
10112            && !reg_mentioned_p (operands[0], operands[2])))"
10113   [(set (match_dup 0)
10114         (match_dup 3))
10115    (set (match_dup 0)
10116         (plus:V2DI
10117          (mult:V2DI
10118           (sign_extend:V2DI
10119            (vec_select:V2SI
10120             (match_dup 1)
10121             (parallel [(const_int 0)
10122                        (const_int 2)])))
10123           (sign_extend:V2DI
10124            (vec_select:V2SI
10125             (match_dup 2)
10126             (parallel [(const_int 0)
10127                        (const_int 2)]))))
10128          (match_dup 0)))])
10129
10130 ;; We don't have a straight 32-bit parallel multiply and extend on SSE5, so
10131 ;; fake it with a multiply/add.  In general, we expect the define_split to
10132 ;; occur before register allocation, so we have to handle the corner case where
10133 ;; the target is the same as either operands[1] or operands[2]
10134 (define_insn_and_split "sse5_mulv2div2di3_high"
10135   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10136         (mult:V2DI
10137           (sign_extend:V2DI
10138             (vec_select:V2SI
10139               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10140               (parallel [(const_int 0)
10141                          (const_int 2)])))
10142           (sign_extend:V2DI
10143             (vec_select:V2SI
10144               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10145               (parallel [(const_int 0)
10146                          (const_int 2)])))))]
10147   "TARGET_SSE5"
10148   "#"
10149   "&& (reload_completed
10150        || (!reg_mentioned_p (operands[0], operands[1])
10151            && !reg_mentioned_p (operands[0], operands[2])))"
10152   [(set (match_dup 0)
10153         (match_dup 3))
10154    (set (match_dup 0)
10155         (plus:V2DI
10156          (mult:V2DI
10157           (sign_extend:V2DI
10158            (vec_select:V2SI
10159             (match_dup 1)
10160             (parallel [(const_int 0)
10161                        (const_int 2)])))
10162           (sign_extend:V2DI
10163            (vec_select:V2SI
10164             (match_dup 2)
10165             (parallel [(const_int 0)
10166                        (const_int 2)]))))
10167          (match_dup 0)))]
10168 {
10169   operands[3] = CONST0_RTX (V2DImode);
10170 }
10171   [(set_attr "type" "ssemuladd")
10172    (set_attr "mode" "TI")])
10173
10174 ;; SSE5 parallel integer multiply/add instructions for the intrinisics
10175 (define_insn "sse5_pmacsswd"
10176   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10177         (ss_plus:V4SI
10178          (mult:V4SI
10179           (sign_extend:V4SI
10180            (vec_select:V4HI
10181             (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10182             (parallel [(const_int 1)
10183                        (const_int 3)
10184                        (const_int 5)
10185                        (const_int 7)])))
10186           (sign_extend:V4SI
10187            (vec_select:V4HI
10188             (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10189             (parallel [(const_int 1)
10190                        (const_int 3)
10191                        (const_int 5)
10192                        (const_int 7)]))))
10193          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10194   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10195   "@
10196    pmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10197    pmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10198    pmacsswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10199   [(set_attr "type" "ssemuladd")
10200    (set_attr "mode" "TI")])
10201
10202 (define_insn "sse5_pmacswd"
10203   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10204         (plus:V4SI
10205          (mult:V4SI
10206           (sign_extend:V4SI
10207            (vec_select:V4HI
10208             (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10209             (parallel [(const_int 1)
10210                        (const_int 3)
10211                        (const_int 5)
10212                        (const_int 7)])))
10213           (sign_extend:V4SI
10214            (vec_select:V4HI
10215             (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10216             (parallel [(const_int 1)
10217                        (const_int 3)
10218                        (const_int 5)
10219                        (const_int 7)]))))
10220          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10221   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10222   "@
10223    pmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10224    pmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10225    pmacswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10226   [(set_attr "type" "ssemuladd")
10227    (set_attr "mode" "TI")])
10228
10229 (define_insn "sse5_pmadcsswd"
10230   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10231         (ss_plus:V4SI
10232          (plus:V4SI
10233           (mult:V4SI
10234            (sign_extend:V4SI
10235             (vec_select:V4HI
10236              (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10237              (parallel [(const_int 0)
10238                         (const_int 2)
10239                         (const_int 4)
10240                         (const_int 6)])))
10241            (sign_extend:V4SI
10242             (vec_select:V4HI
10243              (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10244              (parallel [(const_int 0)
10245                         (const_int 2)
10246                         (const_int 4)
10247                         (const_int 6)]))))
10248           (mult:V4SI
10249            (sign_extend:V4SI
10250             (vec_select:V4HI
10251              (match_dup 1)
10252              (parallel [(const_int 1)
10253                         (const_int 3)
10254                         (const_int 5)
10255                         (const_int 7)])))
10256            (sign_extend:V4SI
10257             (vec_select:V4HI
10258              (match_dup 2)
10259              (parallel [(const_int 1)
10260                         (const_int 3)
10261                         (const_int 5)
10262                         (const_int 7)])))))
10263          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10264   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10265   "@
10266    pmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10267    pmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10268    pmadcsswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10269   [(set_attr "type" "ssemuladd")
10270    (set_attr "mode" "TI")])
10271
10272 (define_insn "sse5_pmadcswd"
10273   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10274         (plus:V4SI
10275          (plus:V4SI
10276           (mult:V4SI
10277            (sign_extend:V4SI
10278             (vec_select:V4HI
10279              (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10280              (parallel [(const_int 0)
10281                         (const_int 2)
10282                         (const_int 4)
10283                         (const_int 6)])))
10284            (sign_extend:V4SI
10285             (vec_select:V4HI
10286              (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10287              (parallel [(const_int 0)
10288                         (const_int 2)
10289                         (const_int 4)
10290                         (const_int 6)]))))
10291           (mult:V4SI
10292            (sign_extend:V4SI
10293             (vec_select:V4HI
10294              (match_dup 1)
10295              (parallel [(const_int 1)
10296                         (const_int 3)
10297                         (const_int 5)
10298                         (const_int 7)])))
10299            (sign_extend:V4SI
10300             (vec_select:V4HI
10301              (match_dup 2)
10302              (parallel [(const_int 1)
10303                         (const_int 3)
10304                         (const_int 5)
10305                         (const_int 7)])))))
10306          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10307   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10308   "@
10309    pmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10310    pmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10311    pmadcswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10312   [(set_attr "type" "ssemuladd")
10313    (set_attr "mode" "TI")])
10314
10315 ;; SSE5 parallel XMM conditional moves
10316 (define_insn "sse5_pcmov_<mode>"
10317   [(set (match_operand:SSEMODE 0 "register_operand" "=x,x,x,x")
10318         (if_then_else:SSEMODE
10319           (match_operand:SSEMODE 3 "nonimmediate_operand" "0,0,xm,x")
10320           (match_operand:SSEMODE 1 "vector_move_operand" "x,xm,0,0")
10321           (match_operand:SSEMODE 2 "vector_move_operand" "xm,x,x,xm")))]
10322   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10323   "@
10324    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10325    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10326    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10327    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10328   [(set_attr "type" "sse4arg")])
10329
10330 ;; SSE5 horizontal add/subtract instructions
10331 (define_insn "sse5_phaddbw"
10332   [(set (match_operand:V8HI 0 "register_operand" "=x")
10333         (plus:V8HI
10334          (sign_extend:V8HI
10335           (vec_select:V8QI
10336            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10337            (parallel [(const_int 0)
10338                       (const_int 2)
10339                       (const_int 4)
10340                       (const_int 6)
10341                       (const_int 8)
10342                       (const_int 10)
10343                       (const_int 12)
10344                       (const_int 14)])))
10345          (sign_extend:V8HI
10346           (vec_select:V8QI
10347            (match_dup 1)
10348            (parallel [(const_int 1)
10349                       (const_int 3)
10350                       (const_int 5)
10351                       (const_int 7)
10352                       (const_int 9)
10353                       (const_int 11)
10354                       (const_int 13)
10355                       (const_int 15)])))))]
10356   "TARGET_SSE5"
10357   "phaddbw\t{%1, %0|%0, %1}"
10358   [(set_attr "type" "sseiadd1")])
10359
10360 (define_insn "sse5_phaddbd"
10361   [(set (match_operand:V4SI 0 "register_operand" "=x")
10362         (plus:V4SI
10363          (plus:V4SI
10364           (sign_extend:V4SI
10365            (vec_select:V4QI
10366             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10367             (parallel [(const_int 0)
10368                        (const_int 4)
10369                        (const_int 8)
10370                        (const_int 12)])))
10371           (sign_extend:V4SI
10372            (vec_select:V4QI
10373             (match_dup 1)
10374             (parallel [(const_int 1)
10375                        (const_int 5)
10376                        (const_int 9)
10377                        (const_int 13)]))))
10378          (plus:V4SI
10379           (sign_extend:V4SI
10380            (vec_select:V4QI
10381             (match_dup 1)
10382             (parallel [(const_int 2)
10383                        (const_int 6)
10384                        (const_int 10)
10385                        (const_int 14)])))
10386           (sign_extend:V4SI
10387            (vec_select:V4QI
10388             (match_dup 1)
10389             (parallel [(const_int 3)
10390                        (const_int 7)
10391                        (const_int 11)
10392                        (const_int 15)]))))))]
10393   "TARGET_SSE5"
10394   "phaddbd\t{%1, %0|%0, %1}"
10395   [(set_attr "type" "sseiadd1")])
10396
10397 (define_insn "sse5_phaddbq"
10398   [(set (match_operand:V2DI 0 "register_operand" "=x")
10399         (plus:V2DI
10400          (plus:V2DI
10401           (plus:V2DI
10402            (sign_extend:V2DI
10403             (vec_select:V2QI
10404              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10405              (parallel [(const_int 0)
10406                         (const_int 4)])))
10407            (sign_extend:V2DI
10408             (vec_select:V2QI
10409              (match_dup 1)
10410              (parallel [(const_int 1)
10411                         (const_int 5)]))))
10412           (plus:V2DI
10413            (sign_extend:V2DI
10414             (vec_select:V2QI
10415              (match_dup 1)
10416              (parallel [(const_int 2)
10417                         (const_int 6)])))
10418            (sign_extend:V2DI
10419             (vec_select:V2QI
10420              (match_dup 1)
10421              (parallel [(const_int 3)
10422                         (const_int 7)])))))
10423          (plus:V2DI
10424           (plus:V2DI
10425            (sign_extend:V2DI
10426             (vec_select:V2QI
10427              (match_dup 1)
10428              (parallel [(const_int 8)
10429                         (const_int 12)])))
10430            (sign_extend:V2DI
10431             (vec_select:V2QI
10432              (match_dup 1)
10433              (parallel [(const_int 9)
10434                         (const_int 13)]))))
10435           (plus:V2DI
10436            (sign_extend:V2DI
10437             (vec_select:V2QI
10438              (match_dup 1)
10439              (parallel [(const_int 10)
10440                         (const_int 14)])))
10441            (sign_extend:V2DI
10442             (vec_select:V2QI
10443              (match_dup 1)
10444              (parallel [(const_int 11)
10445                         (const_int 15)])))))))]
10446   "TARGET_SSE5"
10447   "phaddbq\t{%1, %0|%0, %1}"
10448   [(set_attr "type" "sseiadd1")])
10449
10450 (define_insn "sse5_phaddwd"
10451   [(set (match_operand:V4SI 0 "register_operand" "=x")
10452         (plus:V4SI
10453          (sign_extend:V4SI
10454           (vec_select:V4HI
10455            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10456            (parallel [(const_int 0)
10457                       (const_int 2)
10458                       (const_int 4)
10459                       (const_int 6)])))
10460          (sign_extend:V4SI
10461           (vec_select:V4HI
10462            (match_dup 1)
10463            (parallel [(const_int 1)
10464                       (const_int 3)
10465                       (const_int 5)
10466                       (const_int 7)])))))]
10467   "TARGET_SSE5"
10468   "phaddwd\t{%1, %0|%0, %1}"
10469   [(set_attr "type" "sseiadd1")])
10470
10471 (define_insn "sse5_phaddwq"
10472   [(set (match_operand:V2DI 0 "register_operand" "=x")
10473         (plus:V2DI
10474          (plus:V2DI
10475           (sign_extend:V2DI
10476            (vec_select:V2HI
10477             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10478             (parallel [(const_int 0)
10479                        (const_int 4)])))
10480           (sign_extend:V2DI
10481            (vec_select:V2HI
10482             (match_dup 1)
10483             (parallel [(const_int 1)
10484                        (const_int 5)]))))
10485          (plus:V2DI
10486           (sign_extend:V2DI
10487            (vec_select:V2HI
10488             (match_dup 1)
10489             (parallel [(const_int 2)
10490                        (const_int 6)])))
10491           (sign_extend:V2DI
10492            (vec_select:V2HI
10493             (match_dup 1)
10494             (parallel [(const_int 3)
10495                        (const_int 7)]))))))]
10496   "TARGET_SSE5"
10497   "phaddwq\t{%1, %0|%0, %1}"
10498   [(set_attr "type" "sseiadd1")])
10499
10500 (define_insn "sse5_phadddq"
10501   [(set (match_operand:V2DI 0 "register_operand" "=x")
10502         (plus:V2DI
10503          (sign_extend:V2DI
10504           (vec_select:V2SI
10505            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10506            (parallel [(const_int 0)
10507                       (const_int 2)])))
10508          (sign_extend:V2DI
10509           (vec_select:V2SI
10510            (match_dup 1)
10511            (parallel [(const_int 1)
10512                       (const_int 3)])))))]
10513   "TARGET_SSE5"
10514   "phadddq\t{%1, %0|%0, %1}"
10515   [(set_attr "type" "sseiadd1")])
10516
10517 (define_insn "sse5_phaddubw"
10518   [(set (match_operand:V8HI 0 "register_operand" "=x")
10519         (plus:V8HI
10520          (zero_extend:V8HI
10521           (vec_select:V8QI
10522            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10523            (parallel [(const_int 0)
10524                       (const_int 2)
10525                       (const_int 4)
10526                       (const_int 6)
10527                       (const_int 8)
10528                       (const_int 10)
10529                       (const_int 12)
10530                       (const_int 14)])))
10531          (zero_extend:V8HI
10532           (vec_select:V8QI
10533            (match_dup 1)
10534            (parallel [(const_int 1)
10535                       (const_int 3)
10536                       (const_int 5)
10537                       (const_int 7)
10538                       (const_int 9)
10539                       (const_int 11)
10540                       (const_int 13)
10541                       (const_int 15)])))))]
10542   "TARGET_SSE5"
10543   "phaddubw\t{%1, %0|%0, %1}"
10544   [(set_attr "type" "sseiadd1")])
10545
10546 (define_insn "sse5_phaddubd"
10547   [(set (match_operand:V4SI 0 "register_operand" "=x")
10548         (plus:V4SI
10549          (plus:V4SI
10550           (zero_extend:V4SI
10551            (vec_select:V4QI
10552             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10553             (parallel [(const_int 0)
10554                        (const_int 4)
10555                        (const_int 8)
10556                        (const_int 12)])))
10557           (zero_extend:V4SI
10558            (vec_select:V4QI
10559             (match_dup 1)
10560             (parallel [(const_int 1)
10561                        (const_int 5)
10562                        (const_int 9)
10563                        (const_int 13)]))))
10564          (plus:V4SI
10565           (zero_extend:V4SI
10566            (vec_select:V4QI
10567             (match_dup 1)
10568             (parallel [(const_int 2)
10569                        (const_int 6)
10570                        (const_int 10)
10571                        (const_int 14)])))
10572           (zero_extend:V4SI
10573            (vec_select:V4QI
10574             (match_dup 1)
10575             (parallel [(const_int 3)
10576                        (const_int 7)
10577                        (const_int 11)
10578                        (const_int 15)]))))))]
10579   "TARGET_SSE5"
10580   "phaddubd\t{%1, %0|%0, %1}"
10581   [(set_attr "type" "sseiadd1")])
10582
10583 (define_insn "sse5_phaddubq"
10584   [(set (match_operand:V2DI 0 "register_operand" "=x")
10585         (plus:V2DI
10586          (plus:V2DI
10587           (plus:V2DI
10588            (zero_extend:V2DI
10589             (vec_select:V2QI
10590              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10591              (parallel [(const_int 0)
10592                         (const_int 4)])))
10593            (sign_extend:V2DI
10594             (vec_select:V2QI
10595              (match_dup 1)
10596              (parallel [(const_int 1)
10597                         (const_int 5)]))))
10598           (plus:V2DI
10599            (zero_extend:V2DI
10600             (vec_select:V2QI
10601              (match_dup 1)
10602              (parallel [(const_int 2)
10603                         (const_int 6)])))
10604            (zero_extend:V2DI
10605             (vec_select:V2QI
10606              (match_dup 1)
10607              (parallel [(const_int 3)
10608                         (const_int 7)])))))
10609          (plus:V2DI
10610           (plus:V2DI
10611            (zero_extend:V2DI
10612             (vec_select:V2QI
10613              (match_dup 1)
10614              (parallel [(const_int 8)
10615                         (const_int 12)])))
10616            (sign_extend:V2DI
10617             (vec_select:V2QI
10618              (match_dup 1)
10619              (parallel [(const_int 9)
10620                         (const_int 13)]))))
10621           (plus:V2DI
10622            (zero_extend:V2DI
10623             (vec_select:V2QI
10624              (match_dup 1)
10625              (parallel [(const_int 10)
10626                         (const_int 14)])))
10627            (zero_extend:V2DI
10628             (vec_select:V2QI
10629              (match_dup 1)
10630              (parallel [(const_int 11)
10631                         (const_int 15)])))))))]
10632   "TARGET_SSE5"
10633   "phaddubq\t{%1, %0|%0, %1}"
10634   [(set_attr "type" "sseiadd1")])
10635
10636 (define_insn "sse5_phadduwd"
10637   [(set (match_operand:V4SI 0 "register_operand" "=x")
10638         (plus:V4SI
10639          (zero_extend:V4SI
10640           (vec_select:V4HI
10641            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10642            (parallel [(const_int 0)
10643                       (const_int 2)
10644                       (const_int 4)
10645                       (const_int 6)])))
10646          (zero_extend:V4SI
10647           (vec_select:V4HI
10648            (match_dup 1)
10649            (parallel [(const_int 1)
10650                       (const_int 3)
10651                       (const_int 5)
10652                       (const_int 7)])))))]
10653   "TARGET_SSE5"
10654   "phadduwd\t{%1, %0|%0, %1}"
10655   [(set_attr "type" "sseiadd1")])
10656
10657 (define_insn "sse5_phadduwq"
10658   [(set (match_operand:V2DI 0 "register_operand" "=x")
10659         (plus:V2DI
10660          (plus:V2DI
10661           (zero_extend:V2DI
10662            (vec_select:V2HI
10663             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10664             (parallel [(const_int 0)
10665                        (const_int 4)])))
10666           (zero_extend:V2DI
10667            (vec_select:V2HI
10668             (match_dup 1)
10669             (parallel [(const_int 1)
10670                        (const_int 5)]))))
10671          (plus:V2DI
10672           (zero_extend:V2DI
10673            (vec_select:V2HI
10674             (match_dup 1)
10675             (parallel [(const_int 2)
10676                        (const_int 6)])))
10677           (zero_extend:V2DI
10678            (vec_select:V2HI
10679             (match_dup 1)
10680             (parallel [(const_int 3)
10681                        (const_int 7)]))))))]
10682   "TARGET_SSE5"
10683   "phadduwq\t{%1, %0|%0, %1}"
10684   [(set_attr "type" "sseiadd1")])
10685
10686 (define_insn "sse5_phaddudq"
10687   [(set (match_operand:V2DI 0 "register_operand" "=x")
10688         (plus:V2DI
10689          (zero_extend:V2DI
10690           (vec_select:V2SI
10691            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10692            (parallel [(const_int 0)
10693                       (const_int 2)])))
10694          (zero_extend:V2DI
10695           (vec_select:V2SI
10696            (match_dup 1)
10697            (parallel [(const_int 1)
10698                       (const_int 3)])))))]
10699   "TARGET_SSE5"
10700   "phaddudq\t{%1, %0|%0, %1}"
10701   [(set_attr "type" "sseiadd1")])
10702
10703 (define_insn "sse5_phsubbw"
10704   [(set (match_operand:V8HI 0 "register_operand" "=x")
10705         (minus:V8HI
10706          (sign_extend:V8HI
10707           (vec_select:V8QI
10708            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10709            (parallel [(const_int 0)
10710                       (const_int 2)
10711                       (const_int 4)
10712                       (const_int 6)
10713                       (const_int 8)
10714                       (const_int 10)
10715                       (const_int 12)
10716                       (const_int 14)])))
10717          (sign_extend:V8HI
10718           (vec_select:V8QI
10719            (match_dup 1)
10720            (parallel [(const_int 1)
10721                       (const_int 3)
10722                       (const_int 5)
10723                       (const_int 7)
10724                       (const_int 9)
10725                       (const_int 11)
10726                       (const_int 13)
10727                       (const_int 15)])))))]
10728   "TARGET_SSE5"
10729   "phsubbw\t{%1, %0|%0, %1}"
10730   [(set_attr "type" "sseiadd1")])
10731
10732 (define_insn "sse5_phsubwd"
10733   [(set (match_operand:V4SI 0 "register_operand" "=x")
10734         (minus:V4SI
10735          (sign_extend:V4SI
10736           (vec_select:V4HI
10737            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10738            (parallel [(const_int 0)
10739                       (const_int 2)
10740                       (const_int 4)
10741                       (const_int 6)])))
10742          (sign_extend:V4SI
10743           (vec_select:V4HI
10744            (match_dup 1)
10745            (parallel [(const_int 1)
10746                       (const_int 3)
10747                       (const_int 5)
10748                       (const_int 7)])))))]
10749   "TARGET_SSE5"
10750   "phsubwd\t{%1, %0|%0, %1}"
10751   [(set_attr "type" "sseiadd1")])
10752
10753 (define_insn "sse5_phsubdq"
10754   [(set (match_operand:V2DI 0 "register_operand" "=x")
10755         (minus:V2DI
10756          (sign_extend:V2DI
10757           (vec_select:V2SI
10758            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10759            (parallel [(const_int 0)
10760                       (const_int 2)])))
10761          (sign_extend:V2DI
10762           (vec_select:V2SI
10763            (match_dup 1)
10764            (parallel [(const_int 1)
10765                       (const_int 3)])))))]
10766   "TARGET_SSE5"
10767   "phsubdq\t{%1, %0|%0, %1}"
10768   [(set_attr "type" "sseiadd1")])
10769
10770 ;; SSE5 permute instructions
10771 (define_insn "sse5_pperm"
10772   [(set (match_operand:V16QI 0 "register_operand" "=x,x,x,x")
10773         (unspec:V16QI
10774           [(match_operand:V16QI 1 "nonimmediate_operand" "0,0,x,xm")
10775            (match_operand:V16QI 2 "nonimmediate_operand" "x,xm,xm,x")
10776            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0")]
10777           UNSPEC_SSE5_PERMUTE))]
10778   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10779   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10780   [(set_attr "type" "sse4arg")
10781    (set_attr "mode" "TI")])
10782
10783 ;; The following are for the various unpack insns which doesn't need the first
10784 ;; source operand, so we can just use the output operand for the first operand.
10785 ;; This allows either of the other two operands to be a memory operand.  We
10786 ;; can't just use the first operand as an argument to the normal pperm because
10787 ;; then an output only argument, suddenly becomes an input operand.
10788 (define_insn "sse5_pperm_zero_v16qi_v8hi"
10789   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
10790         (zero_extend:V8HI
10791          (vec_select:V8QI
10792           (match_operand:V16QI 1 "nonimmediate_operand" "xm,x")
10793           (match_operand 2 "" ""))))    ;; parallel with const_int's
10794    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10795   "TARGET_SSE5
10796    && (register_operand (operands[1], V16QImode)
10797        || register_operand (operands[2], V16QImode))"
10798   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10799   [(set_attr "type" "sseadd")
10800    (set_attr "mode" "TI")])
10801
10802 (define_insn "sse5_pperm_sign_v16qi_v8hi"
10803   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
10804         (sign_extend:V8HI
10805          (vec_select:V8QI
10806           (match_operand:V16QI 1 "nonimmediate_operand" "xm,x")
10807           (match_operand 2 "" ""))))    ;; parallel with const_int's
10808    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10809   "TARGET_SSE5
10810    && (register_operand (operands[1], V16QImode)
10811        || register_operand (operands[2], V16QImode))"
10812   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10813   [(set_attr "type" "sseadd")
10814    (set_attr "mode" "TI")])
10815
10816 (define_insn "sse5_pperm_zero_v8hi_v4si"
10817   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
10818         (zero_extend:V4SI
10819          (vec_select:V4HI
10820           (match_operand:V8HI 1 "nonimmediate_operand" "xm,x")
10821           (match_operand 2 "" ""))))    ;; parallel with const_int's
10822    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10823   "TARGET_SSE5
10824    && (register_operand (operands[1], V8HImode)
10825        || register_operand (operands[2], V16QImode))"
10826   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10827   [(set_attr "type" "sseadd")
10828    (set_attr "mode" "TI")])
10829
10830 (define_insn "sse5_pperm_sign_v8hi_v4si"
10831   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
10832         (sign_extend:V4SI
10833          (vec_select:V4HI
10834           (match_operand:V8HI 1 "nonimmediate_operand" "xm,x")
10835           (match_operand 2 "" ""))))    ;; parallel with const_int's
10836    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10837   "TARGET_SSE5
10838    && (register_operand (operands[1], V8HImode)
10839        || register_operand (operands[2], V16QImode))"
10840   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10841   [(set_attr "type" "sseadd")
10842    (set_attr "mode" "TI")])
10843
10844 (define_insn "sse5_pperm_zero_v4si_v2di"
10845   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10846         (zero_extend:V2DI
10847          (vec_select:V2SI
10848           (match_operand:V4SI 1 "nonimmediate_operand" "xm,x")
10849           (match_operand 2 "" ""))))    ;; parallel with const_int's
10850    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10851   "TARGET_SSE5
10852    && (register_operand (operands[1], V4SImode)
10853        || register_operand (operands[2], V16QImode))"
10854   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10855   [(set_attr "type" "sseadd")
10856    (set_attr "mode" "TI")])
10857
10858 (define_insn "sse5_pperm_sign_v4si_v2di"
10859   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10860         (sign_extend:V2DI
10861          (vec_select:V2SI
10862           (match_operand:V4SI 1 "nonimmediate_operand" "xm,x")
10863           (match_operand 2 "" ""))))    ;; parallel with const_int's
10864    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
10865   "TARGET_SSE5
10866    && (register_operand (operands[1], V4SImode)
10867        || register_operand (operands[2], V16QImode))"
10868   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
10869   [(set_attr "type" "sseadd")
10870    (set_attr "mode" "TI")])
10871
10872 ;; SSE5 pack instructions that combine two vectors into a smaller vector
10873 (define_insn "sse5_pperm_pack_v2di_v4si"
10874   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x,x")
10875         (vec_concat:V4SI
10876          (truncate:V2SI
10877           (match_operand:V2DI 1 "nonimmediate_operand" "0,0,x,xm"))
10878          (truncate:V2SI
10879           (match_operand:V2DI 2 "nonimmediate_operand" "x,xm,xm,x"))))
10880    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
10881   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10882   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10883   [(set_attr "type" "sse4arg")
10884    (set_attr "mode" "TI")])
10885
10886 (define_insn "sse5_pperm_pack_v4si_v8hi"
10887   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x,x")
10888         (vec_concat:V8HI
10889          (truncate:V4HI
10890           (match_operand:V4SI 1 "nonimmediate_operand" "0,0,x,xm"))
10891          (truncate:V4HI
10892           (match_operand:V4SI 2 "nonimmediate_operand" "x,xm,xm,x"))))
10893    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
10894   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10895   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10896   [(set_attr "type" "sse4arg")
10897    (set_attr "mode" "TI")])
10898
10899 (define_insn "sse5_pperm_pack_v8hi_v16qi"
10900   [(set (match_operand:V16QI 0 "register_operand" "=x,x,x,x")
10901         (vec_concat:V16QI
10902          (truncate:V8QI
10903           (match_operand:V8HI 1 "nonimmediate_operand" "0,0,x,xm"))
10904          (truncate:V8QI
10905           (match_operand:V8HI 2 "nonimmediate_operand" "x,xm,xm,x"))))
10906    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
10907   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10908   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10909   [(set_attr "type" "sse4arg")
10910    (set_attr "mode" "TI")])
10911
10912 ;; Floating point permutation (permps, permpd)
10913 (define_insn "sse5_perm<mode>"
10914   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
10915         (unspec:SSEMODEF2P
10916          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0,x,xm")
10917           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x")
10918           (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0")]
10919          UNSPEC_SSE5_PERMUTE))]
10920   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10921   "perm<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10922   [(set_attr "type" "sse4arg")
10923    (set_attr "mode" "<MODE>")])
10924
10925 ;; SSE5 packed rotate instructions
10926 (define_expand "rotl<mode>3"
10927   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
10928         (rotate:SSEMODE1248
10929          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
10930          (match_operand:SI 2 "general_operand")))]
10931   "TARGET_SSE5"
10932 {
10933   /* If we were given a scalar, convert it to parallel */
10934   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
10935     {
10936       rtvec vs = rtvec_alloc (<ssescalarnum>);
10937       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
10938       rtx reg = gen_reg_rtx (<MODE>mode);
10939       rtx op2 = operands[2];
10940       int i;
10941
10942       if (GET_MODE (op2) != <ssescalarmode>mode)
10943         {
10944           op2 = gen_reg_rtx (<ssescalarmode>mode);
10945           convert_move (op2, operands[2], false);
10946         }
10947
10948       for (i = 0; i < <ssescalarnum>; i++)
10949         RTVEC_ELT (vs, i) = op2;
10950
10951       emit_insn (gen_vec_init<mode> (reg, par));
10952       emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], reg));
10953       DONE;
10954     }
10955 })
10956
10957 (define_expand "rotr<mode>3"
10958   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
10959         (rotatert:SSEMODE1248
10960          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
10961          (match_operand:SI 2 "general_operand")))]
10962   "TARGET_SSE5"
10963 {
10964   /* If we were given a scalar, convert it to parallel */
10965   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
10966     {
10967       rtvec vs = rtvec_alloc (<ssescalarnum>);
10968       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
10969       rtx neg = gen_reg_rtx (<MODE>mode);
10970       rtx reg = gen_reg_rtx (<MODE>mode);
10971       rtx op2 = operands[2];
10972       int i;
10973
10974       if (GET_MODE (op2) != <ssescalarmode>mode)
10975         {
10976           op2 = gen_reg_rtx (<ssescalarmode>mode);
10977           convert_move (op2, operands[2], false);
10978         }
10979
10980       for (i = 0; i < <ssescalarnum>; i++)
10981         RTVEC_ELT (vs, i) = op2;
10982
10983       emit_insn (gen_vec_init<mode> (reg, par));
10984       emit_insn (gen_neg<mode>2 (neg, reg));
10985       emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], neg));
10986       DONE;
10987     }
10988 })
10989
10990 (define_insn "sse5_rotl<mode>3"
10991   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
10992         (rotate:SSEMODE1248
10993          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
10994          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
10995   "TARGET_SSE5"
10996   "prot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
10997   [(set_attr "type" "sseishft")
10998    (set_attr "mode" "TI")])
10999
11000 (define_insn "sse5_rotr<mode>3"
11001   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11002         (rotatert:SSEMODE1248
11003          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11004          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11005   "TARGET_SSE5"
11006 {
11007   operands[3] = GEN_INT ((<ssescalarnum> * 8) - INTVAL (operands[2]));
11008   return \"prot<ssevecsize>\t{%3, %1, %0|%0, %1, %3}\";
11009 }
11010   [(set_attr "type" "sseishft")
11011    (set_attr "mode" "TI")])
11012
11013 (define_expand "vrotr<mode>3"
11014   [(match_operand:SSEMODE1248 0 "register_operand" "")
11015    (match_operand:SSEMODE1248 1 "register_operand" "")
11016    (match_operand:SSEMODE1248 2 "register_operand" "")]
11017   "TARGET_SSE5"
11018 {
11019   rtx reg = gen_reg_rtx (<MODE>mode);
11020   emit_insn (gen_neg<mode>2 (reg, operands[2]));
11021   emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], reg));
11022   DONE;
11023 })
11024
11025 (define_expand "vrotl<mode>3"
11026   [(match_operand:SSEMODE1248 0 "register_operand" "")
11027    (match_operand:SSEMODE1248 1 "register_operand" "")
11028    (match_operand:SSEMODE1248 2 "register_operand" "")]
11029   "TARGET_SSE5"
11030 {
11031   emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], operands[2]));
11032   DONE;
11033 })
11034
11035 (define_insn "sse5_vrotl<mode>3"
11036   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11037         (if_then_else:SSEMODE1248
11038          (ge:SSEMODE1248
11039           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11040           (const_int 0))
11041          (rotate:SSEMODE1248
11042           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11043           (match_dup 2))
11044          (rotatert:SSEMODE1248
11045           (match_dup 1)
11046           (neg:SSEMODE1248 (match_dup 2)))))]
11047   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11048   "prot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11049   [(set_attr "type" "sseishft")
11050    (set_attr "mode" "TI")])
11051
11052 ;; SSE5 packed shift instructions.
11053 ;; FIXME: add V2DI back in
11054 (define_expand "vlshr<mode>3"
11055   [(match_operand:SSEMODE124 0 "register_operand" "")
11056    (match_operand:SSEMODE124 1 "register_operand" "")
11057    (match_operand:SSEMODE124 2 "register_operand" "")]
11058   "TARGET_SSE5"
11059 {
11060   rtx neg = gen_reg_rtx (<MODE>mode);
11061   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11062   emit_insn (gen_sse5_lshl<mode>3 (operands[0], operands[1], neg));
11063   DONE;
11064 })
11065
11066 (define_expand "vashr<mode>3"
11067   [(match_operand:SSEMODE124 0 "register_operand" "")
11068    (match_operand:SSEMODE124 1 "register_operand" "")
11069    (match_operand:SSEMODE124 2 "register_operand" "")]
11070   "TARGET_SSE5"
11071 {
11072   rtx neg = gen_reg_rtx (<MODE>mode);
11073   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11074   emit_insn (gen_sse5_ashl<mode>3 (operands[0], operands[1], neg));
11075   DONE;
11076 })
11077
11078 (define_expand "vashl<mode>3"
11079   [(match_operand:SSEMODE124 0 "register_operand" "")
11080    (match_operand:SSEMODE124 1 "register_operand" "")
11081    (match_operand:SSEMODE124 2 "register_operand" "")]
11082   "TARGET_SSE5"
11083 {
11084   emit_insn (gen_sse5_ashl<mode>3 (operands[0], operands[1], operands[2]));
11085   DONE;
11086 })
11087
11088 (define_insn "sse5_ashl<mode>3"
11089   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11090         (if_then_else:SSEMODE1248
11091          (ge:SSEMODE1248
11092           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11093           (const_int 0))
11094          (ashift:SSEMODE1248
11095           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11096           (match_dup 2))
11097          (ashiftrt:SSEMODE1248
11098           (match_dup 1)
11099           (neg:SSEMODE1248 (match_dup 2)))))]
11100   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11101   "psha<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11102   [(set_attr "type" "sseishft")
11103    (set_attr "mode" "TI")])
11104
11105 (define_insn "sse5_lshl<mode>3"
11106   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11107         (if_then_else:SSEMODE1248
11108          (ge:SSEMODE1248
11109           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11110           (const_int 0))
11111          (ashift:SSEMODE1248
11112           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11113           (match_dup 2))
11114          (lshiftrt:SSEMODE1248
11115           (match_dup 1)
11116           (neg:SSEMODE1248 (match_dup 2)))))]
11117   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11118   "pshl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11119   [(set_attr "type" "sseishft")
11120    (set_attr "mode" "TI")])
11121
11122 ;; SSE2 doesn't have some shift varients, so define versions for SSE5
11123 (define_expand "ashlv16qi3"
11124   [(match_operand:V16QI 0 "register_operand" "")
11125    (match_operand:V16QI 1 "register_operand" "")
11126    (match_operand:SI 2 "nonmemory_operand" "")]
11127   "TARGET_SSE5"
11128 {
11129   rtvec vs = rtvec_alloc (16);
11130   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11131   rtx reg = gen_reg_rtx (V16QImode);
11132   int i;
11133   for (i = 0; i < 16; i++)
11134     RTVEC_ELT (vs, i) = operands[2];
11135
11136   emit_insn (gen_vec_initv16qi (reg, par));
11137   emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], reg));
11138   DONE;
11139 })
11140
11141 (define_expand "lshlv16qi3"
11142   [(match_operand:V16QI 0 "register_operand" "")
11143    (match_operand:V16QI 1 "register_operand" "")
11144    (match_operand:SI 2 "nonmemory_operand" "")]
11145   "TARGET_SSE5"
11146 {
11147   rtvec vs = rtvec_alloc (16);
11148   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11149   rtx reg = gen_reg_rtx (V16QImode);
11150   int i;
11151   for (i = 0; i < 16; i++)
11152     RTVEC_ELT (vs, i) = operands[2];
11153
11154   emit_insn (gen_vec_initv16qi (reg, par));
11155   emit_insn (gen_sse5_lshlv16qi3 (operands[0], operands[1], reg));
11156   DONE;
11157 })
11158
11159 (define_expand "ashrv16qi3"
11160   [(match_operand:V16QI 0 "register_operand" "")
11161    (match_operand:V16QI 1 "register_operand" "")
11162    (match_operand:SI 2 "nonmemory_operand" "")]
11163   "TARGET_SSE5"
11164 {
11165   rtvec vs = rtvec_alloc (16);
11166   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11167   rtx reg = gen_reg_rtx (V16QImode);
11168   int i;
11169   rtx ele = ((GET_CODE (operands[2]) == CONST_INT)
11170              ? GEN_INT (- INTVAL (operands[2]))
11171              : operands[2]);
11172
11173   for (i = 0; i < 16; i++)
11174     RTVEC_ELT (vs, i) = ele;
11175
11176   emit_insn (gen_vec_initv16qi (reg, par));
11177
11178   if (GET_CODE (operands[2]) != CONST_INT)
11179     {
11180       rtx neg = gen_reg_rtx (V16QImode);
11181       emit_insn (gen_negv16qi2 (neg, reg));
11182       emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], neg));
11183     }
11184   else
11185     emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], reg));
11186
11187   DONE;
11188 })
11189
11190 (define_expand "ashrv2di3"
11191   [(match_operand:V2DI 0 "register_operand" "")
11192    (match_operand:V2DI 1 "register_operand" "")
11193    (match_operand:DI 2 "nonmemory_operand" "")]
11194   "TARGET_SSE5"
11195 {
11196   rtvec vs = rtvec_alloc (2);
11197   rtx par = gen_rtx_PARALLEL (V2DImode, vs);
11198   rtx reg = gen_reg_rtx (V2DImode);
11199   rtx ele;
11200
11201   if (GET_CODE (operands[2]) == CONST_INT)
11202     ele = GEN_INT (- INTVAL (operands[2]));
11203   else if (GET_MODE (operands[2]) != DImode)
11204     {
11205       rtx move = gen_reg_rtx (DImode);
11206       ele = gen_reg_rtx (DImode);
11207       convert_move (move, operands[2], false);
11208       emit_insn (gen_negdi2 (ele, move));
11209     }
11210   else
11211     {
11212       ele = gen_reg_rtx (DImode);
11213       emit_insn (gen_negdi2 (ele, operands[2]));
11214     }
11215
11216   RTVEC_ELT (vs, 0) = ele;
11217   RTVEC_ELT (vs, 1) = ele;
11218   emit_insn (gen_vec_initv2di (reg, par));
11219   emit_insn (gen_sse5_ashlv2di3 (operands[0], operands[1], reg));
11220   DONE;
11221 })
11222
11223 ;; SSE5 FRCZ support
11224 ;; parallel insns
11225 (define_insn "sse5_frcz<mode>2"
11226   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11227         (unspec:SSEMODEF2P
11228          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")]
11229          UNSPEC_FRCZ))]
11230   "TARGET_SSE5"
11231   "frcz<ssemodesuffixf4>\t{%1, %0|%0, %1}"
11232   [(set_attr "type" "ssecvt1")
11233    (set_attr "prefix_extra" "1")
11234    (set_attr "mode" "<MODE>")])
11235
11236 ;; scalar insns
11237 (define_insn "sse5_vmfrcz<mode>2"
11238   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11239         (vec_merge:SSEMODEF2P
11240           (unspec:SSEMODEF2P
11241            [(match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
11242            UNSPEC_FRCZ)
11243           (match_operand:SSEMODEF2P 1 "register_operand" "0")
11244           (const_int 1)))]
11245   "TARGET_SSE5"
11246   "frcz<ssemodesuffixf2s>\t{%2, %0|%0, %2}"
11247   [(set_attr "type" "ssecvt1")
11248    (set_attr "prefix_extra" "1")
11249    (set_attr "mode" "<MODE>")])
11250
11251 (define_insn "sse5_cvtph2ps"
11252   [(set (match_operand:V4SF 0 "register_operand" "=x")
11253         (unspec:V4SF [(match_operand:V4HI 1 "nonimmediate_operand" "xm")]
11254                      UNSPEC_CVTPH2PS))]
11255   "TARGET_SSE5"
11256   "cvtph2ps\t{%1, %0|%0, %1}"
11257   [(set_attr "type" "ssecvt")
11258    (set_attr "mode" "V4SF")])
11259
11260 (define_insn "sse5_cvtps2ph"
11261   [(set (match_operand:V4HI 0 "nonimmediate_operand" "=xm")
11262         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")]
11263                      UNSPEC_CVTPS2PH))]
11264   "TARGET_SSE5"
11265   "cvtps2ph\t{%1, %0|%0, %1}"
11266   [(set_attr "type" "ssecvt")
11267    (set_attr "mode" "V4SF")])
11268
11269 ;; Scalar versions of the com instructions that use vector types that are
11270 ;; called from the intrinsics.  Unlike the the other s{s,d} instructions, the
11271 ;; com instructions fill in 0's in the upper bits instead of leaving them
11272 ;; unmodified, so we use const_vector of 0 instead of match_dup.
11273 (define_expand "sse5_vmmaskcmp<mode>3"
11274   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
11275         (vec_merge:SSEMODEF2P
11276          (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11277           [(match_operand:SSEMODEF2P 2 "register_operand" "")
11278            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "")])
11279          (match_dup 4)
11280          (const_int 1)))]
11281   "TARGET_SSE5"
11282 {
11283   operands[4] = CONST0_RTX (<MODE>mode);
11284 })
11285
11286 (define_insn "*sse5_vmmaskcmp<mode>3"
11287   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11288         (vec_merge:SSEMODEF2P
11289          (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11290           [(match_operand:SSEMODEF2P 2 "register_operand" "x")
11291            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm")])
11292           (match_operand:SSEMODEF2P 4 "")
11293           (const_int 1)))]
11294   "TARGET_SSE5"
11295   "com%Y1<ssemodesuffixf2s>\t{%3, %2, %0|%0, %2, %3}"
11296   [(set_attr "type" "sse4arg")
11297    (set_attr "mode" "<ssescalarmode>")])
11298
11299 ;; We don't have a comparison operator that always returns true/false, so
11300 ;; handle comfalse and comtrue specially.
11301 (define_insn "sse5_com_tf<mode>3"
11302   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11303         (unspec:SSEMODEF2P
11304          [(match_operand:SSEMODEF2P 1 "register_operand" "x")
11305           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
11306           (match_operand:SI 3 "const_int_operand" "n")]
11307          UNSPEC_SSE5_TRUEFALSE))]
11308   "TARGET_SSE5"
11309 {
11310   const char *ret = NULL;
11311
11312   switch (INTVAL (operands[3]))
11313     {
11314     case COM_FALSE_S:
11315       ret = \"comfalses<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11316       break;
11317
11318     case COM_FALSE_P:
11319       ret = \"comfalsep<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11320       break;
11321
11322     case COM_TRUE_S:
11323       ret = \"comfalses<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11324       break;
11325
11326     case COM_TRUE_P:
11327       ret = \"comfalsep<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11328       break;
11329
11330     default:
11331       gcc_unreachable ();
11332     }
11333
11334   return ret;
11335 }
11336   [(set_attr "type" "ssecmp")
11337    (set_attr "mode" "<MODE>")])
11338
11339 (define_insn "sse5_maskcmp<mode>3"
11340   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11341         (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11342          [(match_operand:SSEMODEF2P 2 "register_operand" "x")
11343           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm")]))]
11344   "TARGET_SSE5"
11345   "com%Y1<ssemodesuffixf4>\t{%3, %2, %0|%0, %2, %3}"
11346   [(set_attr "type" "ssecmp")
11347    (set_attr "mode" "<MODE>")])
11348
11349 (define_insn "sse5_maskcmp<mode>3"
11350   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11351         (match_operator:SSEMODE1248 1 "ix86_comparison_int_operator"
11352          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11353           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11354   "TARGET_SSE5"
11355   "pcom%Y1<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11356   [(set_attr "type" "sse4arg")
11357    (set_attr "mode" "TI")])
11358
11359 (define_insn "sse5_maskcmp_uns<mode>3"
11360   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11361         (match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11362          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11363           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11364   "TARGET_SSE5"
11365   "pcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11366   [(set_attr "type" "ssecmp")
11367    (set_attr "mode" "TI")])
11368
11369 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
11370 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
11371 ;; the exact instruction generated for the intrinsic.
11372 (define_insn "sse5_maskcmp_uns2<mode>3"
11373   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11374         (unspec:SSEMODE1248
11375          [(match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11376           [(match_operand:SSEMODE1248 2 "register_operand" "x")
11377            (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")])]
11378          UNSPEC_SSE5_UNSIGNED_CMP))]
11379   "TARGET_SSE5"
11380   "pcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11381   [(set_attr "type" "ssecmp")
11382    (set_attr "mode" "TI")])
11383
11384 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
11385 ;; being added here to be complete.
11386 (define_insn "sse5_pcom_tf<mode>3"
11387   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11388         (unspec:SSEMODE1248
11389           [(match_operand:SSEMODE1248 1 "register_operand" "x")
11390            (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")
11391            (match_operand:SI 3 "const_int_operand" "n")]
11392           UNSPEC_SSE5_TRUEFALSE))]
11393   "TARGET_SSE5"
11394 {
11395   return ((INTVAL (operands[3]) != 0)
11396           ? "pcomtrue<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11397           : "pcomfalse<ssevecsize>\t{%2, %1, %0|%0, %1, %2}");
11398 }
11399   [(set_attr "type" "ssecmp")
11400    (set_attr "mode" "TI")])
11401
11402 (define_insn "*avx_aesenc"
11403   [(set (match_operand:V2DI 0 "register_operand" "=x")
11404         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11405                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11406                       UNSPEC_AESENC))]
11407   "TARGET_AES && TARGET_AVX"
11408   "vaesenc\t{%2, %1, %0|%0, %1, %2}"
11409   [(set_attr "type" "sselog1")
11410    (set_attr "prefix" "vex")
11411    (set_attr "mode" "TI")])
11412
11413 (define_insn "aesenc"
11414   [(set (match_operand:V2DI 0 "register_operand" "=x")
11415         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11416                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11417                       UNSPEC_AESENC))]
11418   "TARGET_AES"
11419   "aesenc\t{%2, %0|%0, %2}"
11420   [(set_attr "type" "sselog1")
11421    (set_attr "prefix_extra" "1")
11422    (set_attr "mode" "TI")])
11423
11424 (define_insn "*avx_aesenclast"
11425   [(set (match_operand:V2DI 0 "register_operand" "=x")
11426         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11427                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11428                       UNSPEC_AESENCLAST))]
11429   "TARGET_AES && TARGET_AVX"
11430   "vaesenclast\t{%2, %1, %0|%0, %1, %2}"
11431   [(set_attr "type" "sselog1")
11432    (set_attr "prefix" "vex")
11433    (set_attr "mode" "TI")])
11434
11435 (define_insn "aesenclast"
11436   [(set (match_operand:V2DI 0 "register_operand" "=x")
11437         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11438                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11439                       UNSPEC_AESENCLAST))]
11440   "TARGET_AES"
11441   "aesenclast\t{%2, %0|%0, %2}"
11442   [(set_attr "type" "sselog1")
11443    (set_attr "prefix_extra" "1")
11444    (set_attr "mode" "TI")])
11445
11446 (define_insn "*avx_aesdec"
11447   [(set (match_operand:V2DI 0 "register_operand" "=x")
11448         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11449                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11450                       UNSPEC_AESDEC))]
11451   "TARGET_AES && TARGET_AVX"
11452   "vaesdec\t{%2, %1, %0|%0, %1, %2}"
11453   [(set_attr "type" "sselog1")
11454    (set_attr "prefix" "vex")
11455    (set_attr "mode" "TI")])
11456
11457 (define_insn "aesdec"
11458   [(set (match_operand:V2DI 0 "register_operand" "=x")
11459         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11460                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11461                       UNSPEC_AESDEC))]
11462   "TARGET_AES"
11463   "aesdec\t{%2, %0|%0, %2}"
11464   [(set_attr "type" "sselog1")
11465    (set_attr "prefix_extra" "1")
11466    (set_attr "mode" "TI")])
11467
11468 (define_insn "*avx_aesdeclast"
11469   [(set (match_operand:V2DI 0 "register_operand" "=x")
11470         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11471                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11472                       UNSPEC_AESDECLAST))]
11473   "TARGET_AES && TARGET_AVX"
11474   "vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
11475   [(set_attr "type" "sselog1")
11476    (set_attr "prefix" "vex")
11477    (set_attr "mode" "TI")])
11478
11479 (define_insn "aesdeclast"
11480   [(set (match_operand:V2DI 0 "register_operand" "=x")
11481         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11482                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11483                       UNSPEC_AESDECLAST))]
11484   "TARGET_AES"
11485   "aesdeclast\t{%2, %0|%0, %2}"
11486   [(set_attr "type" "sselog1")
11487    (set_attr "prefix_extra" "1")
11488    (set_attr "mode" "TI")])
11489
11490 (define_insn "aesimc"
11491   [(set (match_operand:V2DI 0 "register_operand" "=x")
11492         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11493                       UNSPEC_AESIMC))]
11494   "TARGET_AES"
11495   "%vaesimc\t{%1, %0|%0, %1}"
11496   [(set_attr "type" "sselog1")
11497    (set_attr "prefix_extra" "1")
11498    (set_attr "prefix" "maybe_vex")
11499    (set_attr "mode" "TI")])
11500
11501 (define_insn "aeskeygenassist"
11502   [(set (match_operand:V2DI 0 "register_operand" "=x")
11503         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
11504                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
11505                      UNSPEC_AESKEYGENASSIST))]
11506   "TARGET_AES"
11507   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
11508   [(set_attr "type" "sselog1")
11509    (set_attr "prefix_extra" "1")
11510    (set_attr "prefix" "maybe_vex")
11511    (set_attr "mode" "TI")])
11512
11513 (define_insn "*vpclmulqdq"
11514   [(set (match_operand:V2DI 0 "register_operand" "=x")
11515         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11516                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11517                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11518                      UNSPEC_PCLMUL))]
11519   "TARGET_PCLMUL && TARGET_AVX"
11520   "vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11521   [(set_attr "type" "sselog1")
11522    (set_attr "prefix" "vex")
11523    (set_attr "mode" "TI")])
11524
11525 (define_insn "pclmulqdq"
11526   [(set (match_operand:V2DI 0 "register_operand" "=x")
11527         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11528                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11529                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11530                      UNSPEC_PCLMUL))]
11531   "TARGET_PCLMUL"
11532   "pclmulqdq\t{%3, %2, %0|%0, %2, %3}"
11533   [(set_attr "type" "sselog1")
11534    (set_attr "prefix_extra" "1")
11535    (set_attr "mode" "TI")])
11536
11537 (define_expand "avx_vzeroall"
11538   [(match_par_dup 0 [(const_int 0)])]
11539   "TARGET_AVX"
11540 {
11541   int nregs = TARGET_64BIT ? 16 : 8;
11542   int regno;
11543
11544   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11545
11546   XVECEXP (operands[0], 0, 0)
11547     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11548                                UNSPECV_VZEROALL);
11549
11550   for (regno = 0; regno < nregs; regno++)
11551     XVECEXP (operands[0], 0, regno + 1)
11552       = gen_rtx_SET (VOIDmode,
11553                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
11554                      CONST0_RTX (V8SImode));
11555 })
11556
11557 (define_insn "*avx_vzeroall"
11558   [(match_parallel 0 "vzeroall_operation"
11559     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)
11560      (set (match_operand 1 "register_operand" "=x")
11561           (match_operand 2 "const0_operand" "X"))])]
11562   "TARGET_AVX"
11563   "vzeroall"
11564   [(set_attr "type" "sse")
11565    (set_attr "memory" "none")
11566    (set_attr "prefix" "vex")
11567    (set_attr "mode" "OI")])
11568
11569 ;; vzeroupper clobbers the upper 128bits of AVX registers.
11570 (define_insn "avx_vzeroupper"
11571   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)
11572    (clobber (reg:V8SI XMM0_REG))
11573    (clobber (reg:V8SI XMM1_REG))
11574    (clobber (reg:V8SI XMM2_REG))
11575    (clobber (reg:V8SI XMM3_REG))
11576    (clobber (reg:V8SI XMM4_REG))
11577    (clobber (reg:V8SI XMM5_REG))
11578    (clobber (reg:V8SI XMM6_REG))
11579    (clobber (reg:V8SI XMM7_REG))]
11580   "TARGET_AVX && !TARGET_64BIT"
11581   "vzeroupper"
11582   [(set_attr "type" "sse")
11583    (set_attr "memory" "none")
11584    (set_attr "prefix" "vex")
11585    (set_attr "mode" "OI")])
11586
11587 (define_insn "avx_vzeroupper_rex64"
11588   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)
11589    (clobber (reg:V8SI XMM0_REG))
11590    (clobber (reg:V8SI XMM1_REG))
11591    (clobber (reg:V8SI XMM2_REG))
11592    (clobber (reg:V8SI XMM3_REG))
11593    (clobber (reg:V8SI XMM4_REG))
11594    (clobber (reg:V8SI XMM5_REG))
11595    (clobber (reg:V8SI XMM6_REG))
11596    (clobber (reg:V8SI XMM7_REG))
11597    (clobber (reg:V8SI XMM8_REG))
11598    (clobber (reg:V8SI XMM9_REG))
11599    (clobber (reg:V8SI XMM10_REG))
11600    (clobber (reg:V8SI XMM11_REG))
11601    (clobber (reg:V8SI XMM12_REG))
11602    (clobber (reg:V8SI XMM13_REG))
11603    (clobber (reg:V8SI XMM14_REG))
11604    (clobber (reg:V8SI XMM15_REG))]
11605   "TARGET_AVX && TARGET_64BIT"
11606   "vzeroupper"
11607   [(set_attr "type" "sse")
11608    (set_attr "memory" "none")
11609    (set_attr "prefix" "vex")
11610    (set_attr "mode" "OI")])
11611
11612 (define_insn "avx_vpermil<mode>"
11613   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11614         (unspec:AVXMODEF2P
11615           [(match_operand:AVXMODEF2P 1 "register_operand" "xm")
11616            (match_operand:SI 2 "const_0_to_<vpermilbits>_operand" "n")]
11617           UNSPEC_VPERMIL))]
11618   "TARGET_AVX"
11619   "vpermilp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
11620   [(set_attr "type" "sselog")
11621    (set_attr "prefix" "vex")
11622    (set_attr "mode" "<MODE>")])
11623
11624 (define_insn "avx_vpermilvar<mode>3"
11625   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11626         (unspec:AVXMODEF2P
11627           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11628            (match_operand:<avxpermvecmode> 2 "nonimmediate_operand" "xm")]
11629           UNSPEC_VPERMIL))]
11630   "TARGET_AVX"
11631   "vpermilp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
11632   [(set_attr "type" "sselog")
11633    (set_attr "prefix" "vex")
11634    (set_attr "mode" "<MODE>")])
11635
11636 (define_insn "avx_vperm2f128<mode>3"
11637   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
11638         (unspec:AVX256MODE2P
11639           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
11640            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
11641            (match_operand:SI 3 "const_0_to_255_operand" "n")]
11642           UNSPEC_VPERMIL2F128))]
11643   "TARGET_AVX"
11644   "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11645   [(set_attr "type" "sselog")
11646    (set_attr "prefix" "vex")
11647    (set_attr "mode" "V8SF")])
11648
11649 (define_insn "avx_vbroadcasts<avxmodesuffixf2c><avxmodesuffix>"
11650   [(set (match_operand:AVXMODEF4P 0 "register_operand" "=x")
11651         (vec_concat:AVXMODEF4P
11652           (vec_concat:<avxhalfvecmode>
11653             (match_operand:<avxscalarmode> 1 "memory_operand" "m")
11654             (match_dup 1))
11655           (vec_concat:<avxhalfvecmode>
11656             (match_dup 1)
11657             (match_dup 1))))]
11658   "TARGET_AVX"
11659   "vbroadcasts<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
11660   [(set_attr "type" "ssemov")
11661    (set_attr "prefix" "vex")
11662    (set_attr "mode" "<avxscalarmode>")])
11663
11664 (define_insn "avx_vbroadcastss256"
11665   [(set (match_operand:V8SF 0 "register_operand" "=x")
11666         (vec_concat:V8SF
11667           (vec_concat:V4SF
11668             (vec_concat:V2SF
11669               (match_operand:SF 1 "memory_operand" "m")
11670               (match_dup 1))
11671             (vec_concat:V2SF
11672               (match_dup 1)
11673               (match_dup 1)))
11674           (vec_concat:V4SF
11675             (vec_concat:V2SF
11676               (match_dup 1)
11677               (match_dup 1))
11678             (vec_concat:V2SF
11679               (match_dup 1)
11680               (match_dup 1)))))]
11681   "TARGET_AVX"
11682   "vbroadcastss\t{%1, %0|%0, %1}"
11683   [(set_attr "type" "ssemov")
11684    (set_attr "prefix" "vex")
11685    (set_attr "mode" "SF")])
11686
11687 (define_insn "avx_vbroadcastf128_p<avxmodesuffixf2c>256"
11688   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
11689         (vec_concat:AVX256MODEF2P
11690           (match_operand:<avxhalfvecmode> 1 "memory_operand" "m")
11691           (match_dup 1)))]
11692   "TARGET_AVX"
11693   "vbroadcastf128\t{%1, %0|%0, %1}"
11694   [(set_attr "type" "ssemov")
11695    (set_attr "prefix" "vex")
11696    (set_attr "mode" "V4SF")])
11697
11698 (define_expand "avx_vinsertf128<mode>"
11699   [(match_operand:AVX256MODE 0 "register_operand" "")
11700    (match_operand:AVX256MODE 1 "register_operand" "")
11701    (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "")
11702    (match_operand:SI 3 "const_0_to_1_operand" "")]
11703   "TARGET_AVX"
11704 {
11705   switch (INTVAL (operands[3]))
11706     {
11707     case 0:
11708       emit_insn (gen_vec_set_lo_<mode> (operands[0], operands[1],
11709                                         operands[2]));
11710       break;
11711     case 1:
11712       emit_insn (gen_vec_set_hi_<mode> (operands[0], operands[1],
11713                                         operands[2]));
11714       break;
11715     default:
11716       gcc_unreachable ();
11717     }
11718   DONE;
11719 })
11720
11721 (define_insn "vec_set_lo_<mode>"
11722   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
11723         (vec_concat:AVX256MODE4P
11724           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
11725           (vec_select:<avxhalfvecmode>
11726             (match_operand:AVX256MODE4P 1 "register_operand" "x")
11727             (parallel [(const_int 2) (const_int 3)]))))]
11728   "TARGET_AVX"
11729   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11730   [(set_attr "type" "sselog")
11731    (set_attr "prefix" "vex")
11732    (set_attr "mode" "V8SF")])
11733
11734 (define_insn "vec_set_hi_<mode>"
11735   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
11736         (vec_concat:AVX256MODE4P
11737           (vec_select:<avxhalfvecmode>
11738             (match_operand:AVX256MODE4P 1 "register_operand" "x")
11739             (parallel [(const_int 0) (const_int 1)]))
11740           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
11741   "TARGET_AVX"
11742   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11743   [(set_attr "type" "sselog")
11744    (set_attr "prefix" "vex")
11745    (set_attr "mode" "V8SF")])
11746
11747 (define_insn "vec_set_lo_<mode>"
11748   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
11749         (vec_concat:AVX256MODE8P
11750           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
11751           (vec_select:<avxhalfvecmode>
11752             (match_operand:AVX256MODE8P 1 "register_operand" "x")
11753             (parallel [(const_int 4) (const_int 5)
11754                        (const_int 6) (const_int 7)]))))]
11755   "TARGET_AVX"
11756   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11757   [(set_attr "type" "sselog")
11758    (set_attr "prefix" "vex")
11759    (set_attr "mode" "V8SF")])
11760
11761 (define_insn "vec_set_hi_<mode>"
11762   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
11763         (vec_concat:AVX256MODE8P
11764           (vec_select:<avxhalfvecmode>
11765             (match_operand:AVX256MODE8P 1 "register_operand" "x")
11766             (parallel [(const_int 0) (const_int 1)
11767                        (const_int 2) (const_int 3)]))
11768           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
11769   "TARGET_AVX"
11770   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11771   [(set_attr "type" "sselog")
11772    (set_attr "prefix" "vex")
11773    (set_attr "mode" "V8SF")])
11774
11775 (define_insn "vec_set_lo_v16hi"
11776   [(set (match_operand:V16HI 0 "register_operand" "=x")
11777         (vec_concat:V16HI
11778           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
11779           (vec_select:V8HI
11780             (match_operand:V16HI 1 "register_operand" "x")
11781             (parallel [(const_int 8) (const_int 9)
11782                        (const_int 10) (const_int 11)
11783                        (const_int 12) (const_int 13)
11784                        (const_int 14) (const_int 15)]))))]
11785   "TARGET_AVX"
11786   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11787   [(set_attr "type" "sselog")
11788    (set_attr "prefix" "vex")
11789    (set_attr "mode" "V8SF")])
11790
11791 (define_insn "vec_set_hi_v16hi"
11792   [(set (match_operand:V16HI 0 "register_operand" "=x")
11793         (vec_concat:V16HI
11794           (vec_select:V8HI
11795             (match_operand:V16HI 1 "register_operand" "x")
11796             (parallel [(const_int 0) (const_int 1)
11797                        (const_int 2) (const_int 3)
11798                        (const_int 4) (const_int 5)
11799                        (const_int 6) (const_int 7)]))
11800           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
11801   "TARGET_AVX"
11802   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11803   [(set_attr "type" "sselog")
11804    (set_attr "prefix" "vex")
11805    (set_attr "mode" "V8SF")])
11806
11807 (define_insn "vec_set_lo_v32qi"
11808   [(set (match_operand:V32QI 0 "register_operand" "=x")
11809         (vec_concat:V32QI
11810           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
11811           (vec_select:V16QI
11812             (match_operand:V32QI 1 "register_operand" "x")
11813             (parallel [(const_int 16) (const_int 17)
11814                        (const_int 18) (const_int 19)
11815                        (const_int 20) (const_int 21)
11816                        (const_int 22) (const_int 23)
11817                        (const_int 24) (const_int 25)
11818                        (const_int 26) (const_int 27)
11819                        (const_int 28) (const_int 29)
11820                        (const_int 30) (const_int 31)]))))]
11821   "TARGET_AVX"
11822   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11823   [(set_attr "type" "sselog")
11824    (set_attr "prefix" "vex")
11825    (set_attr "mode" "V8SF")])
11826
11827 (define_insn "vec_set_hi_v32qi"
11828   [(set (match_operand:V32QI 0 "register_operand" "=x")
11829         (vec_concat:V32QI
11830           (vec_select:V16QI
11831             (match_operand:V32QI 1 "register_operand" "x")
11832             (parallel [(const_int 0) (const_int 1)
11833                        (const_int 2) (const_int 3)
11834                        (const_int 4) (const_int 5)
11835                        (const_int 6) (const_int 7)
11836                        (const_int 8) (const_int 9)
11837                        (const_int 10) (const_int 11)
11838                        (const_int 12) (const_int 13)
11839                        (const_int 14) (const_int 15)]))
11840           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
11841   "TARGET_AVX"
11842   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11843   [(set_attr "type" "sselog")
11844    (set_attr "prefix" "vex")
11845    (set_attr "mode" "V8SF")])
11846
11847 (define_insn "avx_maskloadp<avxmodesuffixf2c><avxmodesuffix>"
11848   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11849         (unspec:AVXMODEF2P
11850           [(match_operand:AVXMODEF2P 1 "memory_operand" "m")
11851            (match_operand:AVXMODEF2P 2 "register_operand" "x")
11852            (match_dup 0)]
11853           UNSPEC_MASKLOAD))]
11854   "TARGET_AVX"
11855   "vmaskmovp<avxmodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
11856   [(set_attr "type" "sselog1")
11857    (set_attr "prefix" "vex")
11858    (set_attr "mode" "<MODE>")])
11859
11860 (define_insn "avx_maskstorep<avxmodesuffixf2c><avxmodesuffix>"
11861   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
11862         (unspec:AVXMODEF2P
11863           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11864            (match_operand:AVXMODEF2P 2 "register_operand" "x")
11865            (match_dup 0)]
11866           UNSPEC_MASKSTORE))]
11867   "TARGET_AVX"
11868   "vmaskmovp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
11869   [(set_attr "type" "sselog1")
11870    (set_attr "prefix" "vex")
11871    (set_attr "mode" "<MODE>")])
11872
11873 (define_insn "avx_<avxmodesuffixp><avxmodesuffix>_<avxmodesuffixp>"
11874   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x,x")
11875         (unspec:AVX256MODE2P
11876           [(match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "0,xm")]
11877           UNSPEC_CAST))]
11878   "TARGET_AVX"
11879 {
11880   switch (which_alternative)
11881     {
11882     case 0:
11883       return "";
11884     case 1:
11885       switch (get_attr_mode (insn))
11886         {
11887         case MODE_V8SF:
11888           return "vmovaps\t{%1, %x0|%x0, %1}";
11889         case MODE_V4DF:
11890           return "vmovapd\t{%1, %x0|%x0, %1}";
11891         case MODE_OI:
11892           return "vmovdqa\t{%1, %x0|%x0, %1}";
11893         default:
11894           break;
11895         }
11896     default:
11897       break;
11898     }
11899   gcc_unreachable ();
11900 }
11901   [(set_attr "type" "ssemov")
11902    (set_attr "prefix" "vex")
11903    (set_attr "mode" "<avxvecmode>")
11904    (set (attr "length")
11905     (if_then_else (eq_attr "alternative" "0")
11906        (const_string "0")
11907        (const_string "*")))])
11908
11909 (define_insn "avx_<avxmodesuffixp>_<avxmodesuffixp><avxmodesuffix>"
11910   [(set (match_operand:<avxhalfvecmode> 0 "register_operand" "=x,x")
11911         (unspec:<avxhalfvecmode>
11912           [(match_operand:AVX256MODE2P 1 "nonimmediate_operand" "0,xm")]
11913           UNSPEC_CAST))]
11914   "TARGET_AVX"
11915 {
11916   switch (which_alternative)
11917     {
11918     case 0:
11919       return "";
11920     case 1:
11921       switch (get_attr_mode (insn))
11922         {
11923         case MODE_V8SF:
11924           return "vmovaps\t{%x1, %0|%0, %x1}";
11925         case MODE_V4DF:
11926           return "vmovapd\t{%x1, %0|%0, %x1}";
11927         case MODE_OI:
11928           return "vmovdqa\t{%x1, %0|%0, %x1}";
11929         default:
11930           break;
11931         }
11932     default:
11933       break;
11934     }
11935   gcc_unreachable ();
11936 }
11937   [(set_attr "type" "ssemov")
11938    (set_attr "prefix" "vex")
11939    (set_attr "mode" "<avxvecmode>")
11940    (set (attr "length")
11941     (if_then_else (eq_attr "alternative" "0")
11942        (const_string "0")
11943        (const_string "*")))])
11944
11945 (define_expand "vec_init<mode>"
11946   [(match_operand:AVX256MODE 0 "register_operand" "")
11947    (match_operand 1 "" "")]
11948   "TARGET_AVX"
11949 {
11950   ix86_expand_vector_init (false, operands[0], operands[1]);
11951   DONE;
11952 })
11953
11954 (define_insn "*vec_concat<mode>_avx"
11955   [(set (match_operand:AVX256MODE 0 "register_operand"   "=x,x")
11956         (vec_concat:AVX256MODE
11957           (match_operand:<avxhalfvecmode> 1 "register_operand" "x,x")
11958           (match_operand:<avxhalfvecmode> 2 "vector_move_operand" "xm,C")))]
11959   "TARGET_AVX"
11960 {
11961   switch (which_alternative)
11962     {
11963     case 0:
11964       return "vinsertf128\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
11965     case 1:
11966       switch (get_attr_mode (insn))
11967         {
11968         case MODE_V8SF:
11969           return "vmovaps\t{%1, %x0|%x0, %1}";
11970         case MODE_V4DF:
11971           return "vmovapd\t{%1, %x0|%x0, %1}";
11972         default:
11973           return "vmovdqa\t{%1, %x0|%x0, %1}";
11974         }
11975     default:
11976       gcc_unreachable ();
11977     }
11978 }
11979   [(set_attr "type" "sselog,ssemov")
11980    (set_attr "prefix" "vex")
11981    (set_attr "mode" "<avxvecmode>")])