gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   7 ;; GCC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 3, or (at your option)
  10 ;; any later version.
  11 ;;
  12 ;; GCC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16 ;;
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21
  22 ;; 16 byte integral modes handled by SSE
  23 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  24
  25 ;; All 16-byte vector modes handled by SSE
  26 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI V4SF V2DF])
  27 (define_mode_iterator SSEMODE16 [V16QI V8HI V4SI V2DI V1TI V4SF V2DF])
  28
  29 ;; 32 byte integral vector modes handled by AVX
  30 (define_mode_iterator AVX256MODEI [V32QI V16HI V8SI V4DI])
  31
  32 ;; All 32-byte vector modes handled by AVX
  33 (define_mode_iterator AVX256MODE [V32QI V16HI V8SI V4DI V8SF V4DF])
  34
  35 ;; All QI vector modes handled by AVX
  36 (define_mode_iterator AVXMODEQI [V32QI V16QI])
  37
  38 ;; All DI vector modes handled by AVX
  39 (define_mode_iterator AVXMODEDI [V4DI V2DI])
  40
  41 ;; All vector modes handled by AVX
  42 (define_mode_iterator AVXMODE
  43   [V16QI V8HI V4SI V2DI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  44 (define_mode_iterator AVXMODE16
  45   [V16QI V8HI V4SI V2DI V1TI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  46
  47 ;; Mix-n-match
  48 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  49 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  50 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  51 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  52 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  53 (define_mode_iterator SSEMODE1248 [V16QI V8HI V4SI V2DI])
  54 (define_mode_iterator SSEMODEF4 [SF DF V4SF V2DF])
  55 (define_mode_iterator FMA4MODEF4 [V8SF V4DF])
  56 (define_mode_iterator SSEMODEF2P [V4SF V2DF])
  57
  58 (define_mode_iterator AVX256MODEF2P [V8SF V4DF])
  59 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
  60 (define_mode_iterator AVX256MODE24P [V8SI V8SF V4DI V4DF])
  61 (define_mode_iterator AVX256MODE4P [V4DI V4DF])
  62 (define_mode_iterator AVX256MODE8P [V8SI V8SF])
  63 (define_mode_iterator AVXMODEF2P [V4SF V2DF V8SF V4DF])
  64 (define_mode_iterator AVXMODEF4P [V4SF V4DF])
  65 (define_mode_iterator AVXMODEFDP [V2DF V4DF])
  66 (define_mode_iterator AVXMODEFSP [V4SF V8SF])
  67 (define_mode_iterator AVXMODEDCVTDQ2PS [V4SF V8SF])
  68 (define_mode_iterator AVXMODEDCVTPS2DQ [V4SI V8SI])
  69
  70 ;; Int-float size matches
  71 (define_mode_iterator SSEMODE4S [V4SF V4SI])
  72 (define_mode_iterator SSEMODE2D [V2DF V2DI])
  73
  74 ;; Modes handled by integer vcond pattern
  75 (define_mode_iterator SSEMODE124C8 [V16QI V8HI V4SI
  76                                     (V2DI "TARGET_SSE4_2")])
  77
  78 ;; Modes handled by vec_extract_even/odd pattern.
  79 (define_mode_iterator SSEMODE_EO
  80   [(V4SF "TARGET_SSE")
  81    (V2DF "TARGET_SSE2")
  82    (V2DI "TARGET_SSE2") (V4SI "TARGET_SSE2")
  83    (V8HI "TARGET_SSE2") (V16QI "TARGET_SSE2")
  84    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
  85
  86 ;; Mapping from float mode to required SSE level
  87 (define_mode_attr sse [(SF "sse") (DF "sse2") (V4SF "sse") (V2DF "sse2")])
  88
  89 ;; Mapping from integer vector mode to mnemonic suffix
  90 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
  91
  92 ;; Mapping of the insn mnemonic suffix
  93 (define_mode_attr ssemodesuffix
  94   [(SF "ss") (DF "sd") (V4SF "ps") (V2DF "pd") (V8SF "ps") (V4DF "pd")
  95    (V8SI "ps") (V4DI "pd")])
  96 (define_mode_attr ssescalarmodesuffix
  97   [(SF "ss") (DF "sd") (V4SF "ss") (V2DF "sd") (V8SF "ss") (V4DF "sd")
  98    (V4SI "d")])
  99
 100 ;; Mapping of the max integer size for xop rotate immediate constraint
 101 (define_mode_attr sserotatemax [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
 102
 103 ;; Mapping of vector modes back to the scalar modes
 104 (define_mode_attr ssescalarmode [(V4SF "SF") (V2DF "DF")
 105                                  (V16QI "QI") (V8HI "HI")
 106                                  (V4SI "SI") (V2DI "DI")])
 107
 108 ;; Mapping of vector modes to a vector mode of double size
 109 (define_mode_attr ssedoublesizemode
 110   [(V2DF "V4DF") (V2DI "V4DI") (V4SF "V8SF") (V4SI "V8SI")
 111    (V8HI "V16HI") (V16QI "V32QI")
 112    (V4DF "V8DF") (V8SF "V16SF")
 113    (V4DI "V8DI") (V8SI "V16SI") (V16HI "V32HI") (V32QI "V64QI")])
 114
 115 ;; Number of scalar elements in each vector type
 116 (define_mode_attr ssescalarnum
 117   [(V4SF "4") (V2DF "2") (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
 118    (V8SF "8") (V4DF "4") (V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")])
 119
 120 ;; Mapping for AVX
 121 (define_mode_attr avxvecmode
 122   [(V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
 123    (V4SF "V4SF") (V8SF "V8SF") (V2DF "V2DF") (V4DF "V4DF")
 124    (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI")])
 125 (define_mode_attr avxvecpsmode
 126   [(V16QI "V4SF") (V8HI "V4SF") (V4SI "V4SF") (V2DI "V4SF")
 127    (V32QI "V8SF") (V16HI "V8SF") (V8SI "V8SF") (V4DI "V8SF")])
 128 (define_mode_attr avxhalfvecmode
 129   [(V32QI "V16QI") (V16HI "V8HI") (V8SI "V4SI") (V4DI "V2DI")
 130    (V8SF "V4SF") (V4DF "V2DF")
 131    (V16QI  "V8QI") (V8HI  "V4HI") (V4SI "V2SI") (V4SF "V2SF")])
 132 (define_mode_attr avxscalarmode
 133   [(V16QI "QI") (V8HI  "HI") (V4SI "SI") (V2DI "DI") (V4SF "SF") (V2DF "DF")
 134    (V32QI "QI") (V16HI "HI") (V8SI "SI") (V4DI "DI") (V8SF "SF") (V4DF "DF")])
 135 (define_mode_attr avxcvtvecmode
 136   [(V4SF "V4SI") (V8SF "V8SI") (V4SI "V4SF") (V8SI "V8SF")])
 137 (define_mode_attr avxpermvecmode
 138   [(V2DF "V2DI") (V4SF "V4SI") (V4DF "V4DI") (V8SF "V8SI")])
 139 (define_mode_attr avxmodesuffixp
 140  [(V2DF "pd") (V4SI "si") (V4SF "ps") (V8SF "ps") (V8SI "si")
 141   (V4DF "pd")])
 142 (define_mode_attr avxmodesuffix
 143   [(V16QI "") (V32QI "256") (V4SI "") (V4SF "") (V2DF "")
 144    (V8SI "256") (V8SF "256") (V4DF "256")])
 145
 146 ;; Mapping of immediate bits for blend instructions
 147 (define_mode_attr blendbits
 148   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 149
 150 ;; Mapping of immediate bits for pinsr instructions
 151 (define_mode_attr pinsrbits [(V16QI "32768") (V8HI "128") (V4SI "8")])
 152
 153 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 154
 155 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 156 ;;
 157 ;; Move patterns
 158 ;;
 159 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 160
 161 (define_expand "mov<mode>"
 162   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 163         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 164   "TARGET_AVX"
 165 {
 166   ix86_expand_vector_move (<MODE>mode, operands);
 167   DONE;
 168 })
 169
 170 (define_insn "*avx_mov<mode>_internal"
 171   [(set (match_operand:AVXMODE16 0 "nonimmediate_operand" "=x,x ,m")
 172         (match_operand:AVXMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 173   "TARGET_AVX
 174    && (register_operand (operands[0], <MODE>mode)
 175        || register_operand (operands[1], <MODE>mode))"
 176 {
 177   switch (which_alternative)
 178     {
 179     case 0:
 180       return standard_sse_constant_opcode (insn, operands[1]);
 181     case 1:
 182     case 2:
 183       switch (get_attr_mode (insn))
 184         {
 185         case MODE_V8SF:
 186         case MODE_V4SF:
 187           return "vmovaps\t{%1, %0|%0, %1}";
 188         case MODE_V4DF:
 189         case MODE_V2DF:
 190           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 191             return "vmovaps\t{%1, %0|%0, %1}";
 192           else
 193             return "vmovapd\t{%1, %0|%0, %1}";
 194         default:
 195           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 196             return "vmovaps\t{%1, %0|%0, %1}";
 197           else
 198             return "vmovdqa\t{%1, %0|%0, %1}";
 199         }
 200     default:
 201       gcc_unreachable ();
 202     }
 203 }
 204   [(set_attr "type" "sselog1,ssemov,ssemov")
 205    (set_attr "prefix" "vex")
 206    (set_attr "mode" "<avxvecmode>")])
 207
 208 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 209 ;; This is essential for maintaining stable calling conventions.
 210
 211 (define_expand "mov<mode>"
 212   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 213         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 214   "TARGET_SSE"
 215 {
 216   ix86_expand_vector_move (<MODE>mode, operands);
 217   DONE;
 218 })
 219
 220 (define_insn "*mov<mode>_internal"
 221   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "=x,x ,m")
 222         (match_operand:SSEMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 223   "TARGET_SSE
 224    && (register_operand (operands[0], <MODE>mode)
 225        || register_operand (operands[1], <MODE>mode))"
 226 {
 227   switch (which_alternative)
 228     {
 229     case 0:
 230       return standard_sse_constant_opcode (insn, operands[1]);
 231     case 1:
 232     case 2:
 233       switch (get_attr_mode (insn))
 234         {
 235         case MODE_V4SF:
 236           return "movaps\t{%1, %0|%0, %1}";
 237         case MODE_V2DF:
 238           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 239             return "movaps\t{%1, %0|%0, %1}";
 240           else
 241             return "movapd\t{%1, %0|%0, %1}";
 242         default:
 243           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 244             return "movaps\t{%1, %0|%0, %1}";
 245           else
 246             return "movdqa\t{%1, %0|%0, %1}";
 247         }
 248     default:
 249       gcc_unreachable ();
 250     }
 251 }
 252   [(set_attr "type" "sselog1,ssemov,ssemov")
 253    (set (attr "mode")
 254         (cond [(ior (ior (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
 255                          (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 256                     (and (eq_attr "alternative" "2")
 257                          (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 258                              (const_int 0))))
 259                  (const_string "V4SF")
 260                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
 261                  (const_string "V4SF")
 262                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
 263                  (const_string "V2DF")
 264               ]
 265           (const_string "TI")))])
 266
 267 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 268 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 269 ;; from memory, we'd prefer to load the memory directly into the %xmm
 270 ;; register.  To facilitate this happy circumstance, this pattern won't
 271 ;; split until after register allocation.  If the 64-bit value didn't
 272 ;; come from memory, this is the best we can do.  This is much better
 273 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 274 ;; from there.
 275
 276 (define_insn_and_split "movdi_to_sse"
 277   [(parallel
 278     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 279           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 280      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 281   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 282   "#"
 283   "&& reload_completed"
 284   [(const_int 0)]
 285 {
 286  if (register_operand (operands[1], DImode))
 287    {
 288       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 289          Assemble the 64-bit DImode value in an xmm register.  */
 290       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 291                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 292       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 293                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 294       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
 295                                              operands[2]));
 296     }
 297  else if (memory_operand (operands[1], DImode))
 298    emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]),
 299                                   operands[1], const0_rtx));
 300  else
 301    gcc_unreachable ();
 302 })
 303
 304 (define_split
 305   [(set (match_operand:V4SF 0 "register_operand" "")
 306         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 307   "TARGET_SSE && reload_completed"
 308   [(set (match_dup 0)
 309         (vec_merge:V4SF
 310           (vec_duplicate:V4SF (match_dup 1))
 311           (match_dup 2)
 312           (const_int 1)))]
 313 {
 314   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 315   operands[2] = CONST0_RTX (V4SFmode);
 316 })
 317
 318 (define_split
 319   [(set (match_operand:V2DF 0 "register_operand" "")
 320         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 321   "TARGET_SSE2 && reload_completed"
 322   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 323 {
 324   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 325   operands[2] = CONST0_RTX (DFmode);
 326 })
 327
 328 (define_expand "push<mode>1"
 329   [(match_operand:AVX256MODE 0 "register_operand" "")]
 330   "TARGET_AVX"
 331 {
 332   ix86_expand_push (<MODE>mode, operands[0]);
 333   DONE;
 334 })
 335
 336 (define_expand "push<mode>1"
 337   [(match_operand:SSEMODE16 0 "register_operand" "")]
 338   "TARGET_SSE"
 339 {
 340   ix86_expand_push (<MODE>mode, operands[0]);
 341   DONE;
 342 })
 343
 344 (define_expand "movmisalign<mode>"
 345   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 346         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 347   "TARGET_AVX"
 348 {
 349   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 350   DONE;
 351 })
 352
 353 (define_expand "movmisalign<mode>"
 354   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 355         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 356   "TARGET_SSE"
 357 {
 358   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 359   DONE;
 360 })
 361
 362 (define_insn "avx_movu<ssemodesuffix><avxmodesuffix>"
 363   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "=x,m")
 364         (unspec:AVXMODEF2P
 365           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm,x")]
 366           UNSPEC_MOVU))]
 367   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 368    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 369   "vmovu<ssemodesuffix>\t{%1, %0|%0, %1}"
 370   [(set_attr "type" "ssemov")
 371    (set_attr "movu" "1")
 372    (set_attr "prefix" "vex")
 373    (set_attr "mode" "<MODE>")])
 374
 375 (define_insn "sse2_movq128"
 376   [(set (match_operand:V2DI 0 "register_operand" "=x")
 377         (vec_concat:V2DI
 378           (vec_select:DI
 379             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 380             (parallel [(const_int 0)]))
 381           (const_int 0)))]
 382   "TARGET_SSE2"
 383   "%vmovq\t{%1, %0|%0, %1}"
 384   [(set_attr "type" "ssemov")
 385    (set_attr "prefix" "maybe_vex")
 386    (set_attr "mode" "TI")])
 387
 388 (define_insn "<sse>_movu<ssemodesuffix>"
 389   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m")
 390         (unspec:SSEMODEF2P
 391           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm,x")]
 392           UNSPEC_MOVU))]
 393   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 394    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 395   "movu<ssemodesuffix>\t{%1, %0|%0, %1}"
 396   [(set_attr "type" "ssemov")
 397    (set_attr "movu" "1")
 398    (set_attr "mode" "<MODE>")])
 399
 400 (define_insn "avx_movdqu<avxmodesuffix>"
 401   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "=x,m")
 402         (unspec:AVXMODEQI
 403           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "xm,x")]
 404           UNSPEC_MOVU))]
 405   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 406   "vmovdqu\t{%1, %0|%0, %1}"
 407   [(set_attr "type" "ssemov")
 408    (set_attr "movu" "1")
 409    (set_attr "prefix" "vex")
 410    (set_attr "mode" "<avxvecmode>")])
 411
 412 (define_insn "sse2_movdqu"
 413   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 414         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 415                       UNSPEC_MOVU))]
 416   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 417   "movdqu\t{%1, %0|%0, %1}"
 418   [(set_attr "type" "ssemov")
 419    (set_attr "movu" "1")
 420    (set_attr "prefix_data16" "1")
 421    (set_attr "mode" "TI")])
 422
 423 (define_insn "avx_movnt<mode>"
 424   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
 425         (unspec:AVXMODEF2P
 426           [(match_operand:AVXMODEF2P 1 "register_operand" "x")]
 427           UNSPEC_MOVNT))]
 428   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 429   "vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
 430   [(set_attr "type" "ssemov")
 431    (set_attr "prefix" "vex")
 432    (set_attr "mode" "<MODE>")])
 433
 434 (define_insn "<sse>_movnt<mode>"
 435   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "=m")
 436         (unspec:SSEMODEF2P
 437           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
 438           UNSPEC_MOVNT))]
 439   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 440   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
 441   [(set_attr "type" "ssemov")
 442    (set_attr "mode" "<MODE>")])
 443
 444 (define_insn "avx_movnt<mode>"
 445   [(set (match_operand:AVXMODEDI 0 "memory_operand" "=m")
 446         (unspec:AVXMODEDI
 447           [(match_operand:AVXMODEDI 1 "register_operand" "x")]
 448           UNSPEC_MOVNT))]
 449   "TARGET_AVX"
 450   "vmovntdq\t{%1, %0|%0, %1}"
 451   [(set_attr "type" "ssecvt")
 452    (set_attr "prefix" "vex")
 453    (set_attr "mode" "<avxvecmode>")])
 454
 455 (define_insn "sse2_movntv2di"
 456   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 457         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 458                      UNSPEC_MOVNT))]
 459   "TARGET_SSE2"
 460   "movntdq\t{%1, %0|%0, %1}"
 461   [(set_attr "type" "ssemov")
 462    (set_attr "prefix_data16" "1")
 463    (set_attr "mode" "TI")])
 464
 465 (define_insn "sse2_movntsi"
 466   [(set (match_operand:SI 0 "memory_operand" "=m")
 467         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 468                    UNSPEC_MOVNT))]
 469   "TARGET_SSE2"
 470   "movnti\t{%1, %0|%0, %1}"
 471   [(set_attr "type" "ssemov")
 472    (set_attr "prefix_data16" "0")
 473    (set_attr "mode" "V2DF")])
 474
 475 (define_insn "avx_lddqu<avxmodesuffix>"
 476   [(set (match_operand:AVXMODEQI 0 "register_operand" "=x")
 477         (unspec:AVXMODEQI
 478           [(match_operand:AVXMODEQI 1 "memory_operand" "m")]
 479           UNSPEC_LDDQU))]
 480   "TARGET_AVX"
 481   "vlddqu\t{%1, %0|%0, %1}"
 482   [(set_attr "type" "ssecvt")
 483    (set_attr "movu" "1")
 484    (set_attr "prefix" "vex")
 485    (set_attr "mode" "<avxvecmode>")])
 486
 487 (define_insn "sse3_lddqu"
 488   [(set (match_operand:V16QI 0 "register_operand" "=x")
 489         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 490                       UNSPEC_LDDQU))]
 491   "TARGET_SSE3"
 492   "lddqu\t{%1, %0|%0, %1}"
 493   [(set_attr "type" "ssemov")
 494    (set_attr "movu" "1")
 495    (set_attr "prefix_data16" "0")
 496    (set_attr "prefix_rep" "1")
 497    (set_attr "mode" "TI")])
 498
 499 ; Expand patterns for non-temporal stores.  At the moment, only those
 500 ; that directly map to insns are defined; it would be possible to
 501 ; define patterns for other modes that would expand to several insns.
 502
 503 (define_expand "storent<mode>"
 504   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "")
 505         (unspec:SSEMODEF2P
 506           [(match_operand:SSEMODEF2P 1 "register_operand" "")]
 507           UNSPEC_MOVNT))]
 508   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 509   "")
 510
 511 (define_expand "storent<mode>"
 512   [(set (match_operand:MODEF 0 "memory_operand" "")
 513         (unspec:MODEF
 514           [(match_operand:MODEF 1 "register_operand" "")]
 515           UNSPEC_MOVNT))]
 516   "TARGET_SSE4A"
 517   "")
 518
 519 (define_expand "storentv2di"
 520   [(set (match_operand:V2DI 0 "memory_operand" "")
 521         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "")]
 522                      UNSPEC_MOVNT))]
 523   "TARGET_SSE2"
 524   "")
 525
 526 (define_expand "storentsi"
 527   [(set (match_operand:SI 0 "memory_operand" "")
 528         (unspec:SI [(match_operand:SI 1 "register_operand" "")]
 529                    UNSPEC_MOVNT))]
 530   "TARGET_SSE2"
 531   "")
 532
 533 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 534 ;;
 535 ;; Parallel floating point arithmetic
 536 ;;
 537 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 538
 539 (define_expand "<code><mode>2"
 540   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 541         (absneg:SSEMODEF2P
 542           (match_operand:SSEMODEF2P 1 "register_operand" "")))]
 543   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 544   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 545
 546 (define_expand "<plusminus_insn><mode>3"
 547   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 548         (plusminus:AVX256MODEF2P
 549           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 550           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 551   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 552   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 553
 554 (define_insn "*avx_<plusminus_insn><mode>3"
 555   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 556         (plusminus:AVXMODEF2P
 557           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "<comm>x")
 558           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 559   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 560    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 561   "v<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 562   [(set_attr "type" "sseadd")
 563    (set_attr "prefix" "vex")
 564    (set_attr "mode" "<avxvecmode>")])
 565
 566 (define_expand "<plusminus_insn><mode>3"
 567   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 568         (plusminus:SSEMODEF2P
 569           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 570           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 571   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 572   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 573
 574 (define_insn "*<plusminus_insn><mode>3"
 575   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 576         (plusminus:SSEMODEF2P
 577           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "<comm>0")
 578           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 579   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 580    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 581   "<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}"
 582   [(set_attr "type" "sseadd")
 583    (set_attr "mode" "<MODE>")])
 584
 585 (define_insn "*avx_vm<plusminus_insn><mode>3"
 586   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 587         (vec_merge:SSEMODEF2P
 588           (plusminus:SSEMODEF2P
 589             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 590             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 591           (match_dup 1)
 592           (const_int 1)))]
 593   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 594   "v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 595   [(set_attr "type" "sseadd")
 596    (set_attr "prefix" "vex")
 597    (set_attr "mode" "<ssescalarmode>")])
 598
 599 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 600   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 601         (vec_merge:SSEMODEF2P
 602           (plusminus:SSEMODEF2P
 603             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 604             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 605           (match_dup 1)
 606           (const_int 1)))]
 607   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 608   "<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 609   [(set_attr "type" "sseadd")
 610    (set_attr "mode" "<ssescalarmode>")])
 611
 612 (define_expand "mul<mode>3"
 613   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 614         (mult:AVX256MODEF2P
 615           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 616           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 617   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 618   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 619
 620 (define_insn "*avx_mul<mode>3"
 621   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 622         (mult:AVXMODEF2P
 623           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 624           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 625   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 626    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 627   "vmul<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 628   [(set_attr "type" "ssemul")
 629    (set_attr "prefix" "vex")
 630    (set_attr "mode" "<avxvecmode>")])
 631
 632 (define_expand "mul<mode>3"
 633   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 634         (mult:SSEMODEF2P
 635           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 636           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 637   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 638   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 639
 640 (define_insn "*mul<mode>3"
 641   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 642         (mult:SSEMODEF2P
 643           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 644           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 645   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 646    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 647   "mul<ssemodesuffix>\t{%2, %0|%0, %2}"
 648   [(set_attr "type" "ssemul")
 649    (set_attr "mode" "<MODE>")])
 650
 651 (define_insn "*avx_vmmul<mode>3"
 652   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 653         (vec_merge:SSEMODEF2P
 654           (mult:SSEMODEF2P
 655             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 656             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 657           (match_dup 1)
 658           (const_int 1)))]
 659   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 660   "vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 661   [(set_attr "type" "ssemul")
 662    (set_attr "prefix" "vex")
 663    (set_attr "mode" "<ssescalarmode>")])
 664
 665 (define_insn "<sse>_vmmul<mode>3"
 666   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 667         (vec_merge:SSEMODEF2P
 668           (mult:SSEMODEF2P
 669             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 670             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 671           (match_dup 1)
 672           (const_int 1)))]
 673   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 674   "mul<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 675   [(set_attr "type" "ssemul")
 676    (set_attr "mode" "<ssescalarmode>")])
 677
 678 (define_expand "divv8sf3"
 679   [(set (match_operand:V8SF 0 "register_operand" "")
 680         (div:V8SF (match_operand:V8SF 1 "register_operand" "")
 681                   (match_operand:V8SF 2 "nonimmediate_operand" "")))]
 682   "TARGET_AVX"
 683 {
 684   ix86_fixup_binary_operands_no_copy (DIV, V8SFmode, operands);
 685
 686   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_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], V8SFmode);
 692       DONE;
 693     }
 694 })
 695
 696 (define_expand "divv4df3"
 697   [(set (match_operand:V4DF 0 "register_operand" "")
 698         (div:V4DF (match_operand:V4DF 1 "register_operand" "")
 699                   (match_operand:V4DF 2 "nonimmediate_operand" "")))]
 700   "TARGET_AVX"
 701   "ix86_fixup_binary_operands_no_copy (DIV, V4DFmode, operands);")
 702
 703 (define_insn "avx_div<mode>3"
 704   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 705         (div:AVXMODEF2P
 706           (match_operand:AVXMODEF2P 1 "register_operand" "x")
 707           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 708   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 709   "vdiv<ssemodesuffix>\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_expand "divv4sf3"
 715   [(set (match_operand:V4SF 0 "register_operand" "")
 716         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 717                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 718   "TARGET_SSE"
 719 {
 720   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 721       && flag_finite_math_only && !flag_trapping_math
 722       && flag_unsafe_math_optimizations)
 723     {
 724       ix86_emit_swdivsf (operands[0], operands[1],
 725                          operands[2], V4SFmode);
 726       DONE;
 727     }
 728 })
 729
 730 (define_expand "divv2df3"
 731   [(set (match_operand:V2DF 0 "register_operand" "")
 732         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
 733                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
 734   "TARGET_SSE2"
 735   "")
 736
 737 (define_insn "*avx_div<mode>3"
 738   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 739         (div:SSEMODEF2P
 740           (match_operand:SSEMODEF2P 1 "register_operand" "x")
 741           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 742   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 743   "vdiv<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 744   [(set_attr "type" "ssediv")
 745    (set_attr "prefix" "vex")
 746    (set_attr "mode" "<MODE>")])
 747
 748 (define_insn "<sse>_div<mode>3"
 749   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 750         (div:SSEMODEF2P
 751           (match_operand:SSEMODEF2P 1 "register_operand" "0")
 752           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 753   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 754   "div<ssemodesuffix>\t{%2, %0|%0, %2}"
 755   [(set_attr "type" "ssediv")
 756    (set_attr "mode" "<MODE>")])
 757
 758 (define_insn "*avx_vmdiv<mode>3"
 759   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 760         (vec_merge:SSEMODEF2P
 761           (div:SSEMODEF2P
 762             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 763             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 764           (match_dup 1)
 765           (const_int 1)))]
 766   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 767   "vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 768   [(set_attr "type" "ssediv")
 769    (set_attr "prefix" "vex")
 770    (set_attr "mode" "<ssescalarmode>")])
 771
 772 (define_insn "<sse>_vmdiv<mode>3"
 773   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 774         (vec_merge:SSEMODEF2P
 775           (div:SSEMODEF2P
 776             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 777             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 778           (match_dup 1)
 779           (const_int 1)))]
 780   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 781   "div<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 782   [(set_attr "type" "ssediv")
 783    (set_attr "mode" "<ssescalarmode>")])
 784
 785 (define_insn "avx_rcpv8sf2"
 786   [(set (match_operand:V8SF 0 "register_operand" "=x")
 787         (unspec:V8SF
 788           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 789   "TARGET_AVX"
 790   "vrcpps\t{%1, %0|%0, %1}"
 791   [(set_attr "type" "sse")
 792    (set_attr "prefix" "vex")
 793    (set_attr "mode" "V8SF")])
 794
 795 (define_insn "sse_rcpv4sf2"
 796   [(set (match_operand:V4SF 0 "register_operand" "=x")
 797         (unspec:V4SF
 798           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 799   "TARGET_SSE"
 800   "%vrcpps\t{%1, %0|%0, %1}"
 801   [(set_attr "type" "sse")
 802    (set_attr "atom_sse_attr" "rcp")
 803    (set_attr "prefix" "maybe_vex")
 804    (set_attr "mode" "V4SF")])
 805
 806 (define_insn "*avx_vmrcpv4sf2"
 807   [(set (match_operand:V4SF 0 "register_operand" "=x")
 808         (vec_merge:V4SF
 809           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 810                        UNSPEC_RCP)
 811           (match_operand:V4SF 2 "register_operand" "x")
 812           (const_int 1)))]
 813   "TARGET_AVX"
 814   "vrcpss\t{%1, %2, %0|%0, %2, %1}"
 815   [(set_attr "type" "sse")
 816    (set_attr "prefix" "vex")
 817    (set_attr "mode" "SF")])
 818
 819 (define_insn "sse_vmrcpv4sf2"
 820   [(set (match_operand:V4SF 0 "register_operand" "=x")
 821         (vec_merge:V4SF
 822           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 823                        UNSPEC_RCP)
 824           (match_operand:V4SF 2 "register_operand" "0")
 825           (const_int 1)))]
 826   "TARGET_SSE"
 827   "rcpss\t{%1, %0|%0, %1}"
 828   [(set_attr "type" "sse")
 829    (set_attr "atom_sse_attr" "rcp")
 830    (set_attr "mode" "SF")])
 831
 832 (define_expand "sqrtv8sf2"
 833   [(set (match_operand:V8SF 0 "register_operand" "")
 834         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "")))]
 835   "TARGET_AVX"
 836 {
 837   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 838       && flag_finite_math_only && !flag_trapping_math
 839       && flag_unsafe_math_optimizations)
 840     {
 841       ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 0);
 842       DONE;
 843     }
 844 })
 845
 846 (define_insn "avx_sqrtv8sf2"
 847   [(set (match_operand:V8SF 0 "register_operand" "=x")
 848         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
 849   "TARGET_AVX"
 850   "vsqrtps\t{%1, %0|%0, %1}"
 851   [(set_attr "type" "sse")
 852    (set_attr "prefix" "vex")
 853    (set_attr "mode" "V8SF")])
 854
 855 (define_expand "sqrtv4sf2"
 856   [(set (match_operand:V4SF 0 "register_operand" "")
 857         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 858   "TARGET_SSE"
 859 {
 860   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 861       && flag_finite_math_only && !flag_trapping_math
 862       && flag_unsafe_math_optimizations)
 863     {
 864       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 865       DONE;
 866     }
 867 })
 868
 869 (define_insn "sse_sqrtv4sf2"
 870   [(set (match_operand:V4SF 0 "register_operand" "=x")
 871         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 872   "TARGET_SSE"
 873   "%vsqrtps\t{%1, %0|%0, %1}"
 874   [(set_attr "type" "sse")
 875    (set_attr "atom_sse_attr" "sqrt")
 876    (set_attr "prefix" "maybe_vex")
 877    (set_attr "mode" "V4SF")])
 878
 879 (define_insn "sqrtv4df2"
 880   [(set (match_operand:V4DF 0 "register_operand" "=x")
 881         (sqrt:V4DF (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
 882   "TARGET_AVX"
 883   "vsqrtpd\t{%1, %0|%0, %1}"
 884   [(set_attr "type" "sse")
 885    (set_attr "prefix" "vex")
 886    (set_attr "mode" "V4DF")])
 887
 888 (define_insn "sqrtv2df2"
 889   [(set (match_operand:V2DF 0 "register_operand" "=x")
 890         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
 891   "TARGET_SSE2"
 892   "%vsqrtpd\t{%1, %0|%0, %1}"
 893   [(set_attr "type" "sse")
 894    (set_attr "prefix" "maybe_vex")
 895    (set_attr "mode" "V2DF")])
 896
 897 (define_insn "*avx_vmsqrt<mode>2"
 898   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 899         (vec_merge:SSEMODEF2P
 900           (sqrt:SSEMODEF2P
 901             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 902           (match_operand:SSEMODEF2P 2 "register_operand" "x")
 903           (const_int 1)))]
 904   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 905   "vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}"
 906   [(set_attr "type" "sse")
 907    (set_attr "prefix" "vex")
 908    (set_attr "mode" "<ssescalarmode>")])
 909
 910 (define_insn "<sse>_vmsqrt<mode>2"
 911   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 912         (vec_merge:SSEMODEF2P
 913           (sqrt:SSEMODEF2P
 914             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 915           (match_operand:SSEMODEF2P 2 "register_operand" "0")
 916           (const_int 1)))]
 917   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 918   "sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
 919   [(set_attr "type" "sse")
 920    (set_attr "atom_sse_attr" "sqrt")
 921    (set_attr "mode" "<ssescalarmode>")])
 922
 923 (define_expand "rsqrtv8sf2"
 924   [(set (match_operand:V8SF 0 "register_operand" "")
 925         (unspec:V8SF
 926           [(match_operand:V8SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 927   "TARGET_AVX && TARGET_SSE_MATH"
 928 {
 929   ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 1);
 930   DONE;
 931 })
 932
 933 (define_insn "avx_rsqrtv8sf2"
 934   [(set (match_operand:V8SF 0 "register_operand" "=x")
 935         (unspec:V8SF
 936           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 937   "TARGET_AVX"
 938   "vrsqrtps\t{%1, %0|%0, %1}"
 939   [(set_attr "type" "sse")
 940    (set_attr "prefix" "vex")
 941    (set_attr "mode" "V8SF")])
 942
 943 (define_expand "rsqrtv4sf2"
 944   [(set (match_operand:V4SF 0 "register_operand" "")
 945         (unspec:V4SF
 946           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 947   "TARGET_SSE_MATH"
 948 {
 949   ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 950   DONE;
 951 })
 952
 953 (define_insn "sse_rsqrtv4sf2"
 954   [(set (match_operand:V4SF 0 "register_operand" "=x")
 955         (unspec:V4SF
 956           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 957   "TARGET_SSE"
 958   "%vrsqrtps\t{%1, %0|%0, %1}"
 959   [(set_attr "type" "sse")
 960    (set_attr "prefix" "maybe_vex")
 961    (set_attr "mode" "V4SF")])
 962
 963 (define_insn "*avx_vmrsqrtv4sf2"
 964   [(set (match_operand:V4SF 0 "register_operand" "=x")
 965         (vec_merge:V4SF
 966           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 967                        UNSPEC_RSQRT)
 968           (match_operand:V4SF 2 "register_operand" "x")
 969           (const_int 1)))]
 970   "TARGET_AVX"
 971   "vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
 972   [(set_attr "type" "sse")
 973    (set_attr "prefix" "vex")
 974    (set_attr "mode" "SF")])
 975
 976 (define_insn "sse_vmrsqrtv4sf2"
 977   [(set (match_operand:V4SF 0 "register_operand" "=x")
 978         (vec_merge:V4SF
 979           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 980                        UNSPEC_RSQRT)
 981           (match_operand:V4SF 2 "register_operand" "0")
 982           (const_int 1)))]
 983   "TARGET_SSE"
 984   "rsqrtss\t{%1, %0|%0, %1}"
 985   [(set_attr "type" "sse")
 986    (set_attr "mode" "SF")])
 987
 988 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
 989 ;; isn't really correct, as those rtl operators aren't defined when
 990 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
 991
 992 (define_expand "<code><mode>3"
 993   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 994         (smaxmin:AVX256MODEF2P
 995           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 996           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 997   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 998 {
 999   if (!flag_finite_math_only)
1000     operands[1] = force_reg (<MODE>mode, operands[1]);
1001   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1002 })
1003
1004 (define_expand "<code><mode>3"
1005   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1006         (smaxmin:SSEMODEF2P
1007           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1008           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1009   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1010 {
1011   if (!flag_finite_math_only)
1012     operands[1] = force_reg (<MODE>mode, operands[1]);
1013   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1014 })
1015
1016 (define_insn "*avx_<code><mode>3_finite"
1017   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1018         (smaxmin:AVXMODEF2P
1019           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1020           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1021   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1022    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1023   "v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1024   [(set_attr "type" "sseadd")
1025    (set_attr "prefix" "vex")
1026    (set_attr "mode" "<MODE>")])
1027
1028 (define_insn "*<code><mode>3_finite"
1029   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1030         (smaxmin:SSEMODEF2P
1031           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1032           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1033   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1034    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1035   "<maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}"
1036   [(set_attr "type" "sseadd")
1037    (set_attr "mode" "<MODE>")])
1038
1039 (define_insn "*avx_<code><mode>3"
1040   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1041         (smaxmin:AVXMODEF2P
1042           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1043           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1044   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1045   "v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1046   [(set_attr "type" "sseadd")
1047    (set_attr "prefix" "vex")
1048    (set_attr "mode" "<avxvecmode>")])
1049
1050 (define_insn "*<code><mode>3"
1051   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1052         (smaxmin:SSEMODEF2P
1053           (match_operand:SSEMODEF2P 1 "register_operand" "0")
1054           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1055   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1056   "<maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}"
1057   [(set_attr "type" "sseadd")
1058    (set_attr "mode" "<MODE>")])
1059
1060 (define_insn "*avx_vm<code><mode>3"
1061   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1062         (vec_merge:SSEMODEF2P
1063           (smaxmin:SSEMODEF2P
1064             (match_operand:SSEMODEF2P 1 "register_operand" "x")
1065             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1066          (match_dup 1)
1067          (const_int 1)))]
1068   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
1069   "v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1070   [(set_attr "type" "sse")
1071    (set_attr "prefix" "vex")
1072    (set_attr "mode" "<ssescalarmode>")])
1073
1074 (define_insn "<sse>_vm<code><mode>3"
1075   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1076         (vec_merge:SSEMODEF2P
1077           (smaxmin:SSEMODEF2P
1078             (match_operand:SSEMODEF2P 1 "register_operand" "0")
1079             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1080          (match_dup 1)
1081          (const_int 1)))]
1082   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1083   "<maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %2}"
1084   [(set_attr "type" "sseadd")
1085    (set_attr "mode" "<ssescalarmode>")])
1086
1087 ;; These versions of the min/max patterns implement exactly the operations
1088 ;;   min = (op1 < op2 ? op1 : op2)
1089 ;;   max = (!(op1 < op2) ? op1 : op2)
1090 ;; Their operands are not commutative, and thus they may be used in the
1091 ;; presence of -0.0 and NaN.
1092
1093 (define_insn "*avx_ieee_smin<mode>3"
1094   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1095         (unspec:AVXMODEF2P
1096           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1097            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1098          UNSPEC_IEEE_MIN))]
1099   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1100   "vmin<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1101   [(set_attr "type" "sseadd")
1102    (set_attr "prefix" "vex")
1103    (set_attr "mode" "<avxvecmode>")])
1104
1105 (define_insn "*avx_ieee_smax<mode>3"
1106   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1107         (unspec:AVXMODEF2P
1108           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1109            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1110          UNSPEC_IEEE_MAX))]
1111   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1112   "vmax<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1113   [(set_attr "type" "sseadd")
1114    (set_attr "prefix" "vex")
1115    (set_attr "mode" "<avxvecmode>")])
1116
1117 (define_insn "*ieee_smin<mode>3"
1118   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1119         (unspec:SSEMODEF2P
1120           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1121            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1122          UNSPEC_IEEE_MIN))]
1123   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1124   "min<ssemodesuffix>\t{%2, %0|%0, %2}"
1125   [(set_attr "type" "sseadd")
1126    (set_attr "mode" "<MODE>")])
1127
1128 (define_insn "*ieee_smax<mode>3"
1129   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1130         (unspec:SSEMODEF2P
1131           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1132            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1133          UNSPEC_IEEE_MAX))]
1134   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1135   "max<ssemodesuffix>\t{%2, %0|%0, %2}"
1136   [(set_attr "type" "sseadd")
1137    (set_attr "mode" "<MODE>")])
1138
1139 (define_insn "avx_addsubv8sf3"
1140   [(set (match_operand:V8SF 0 "register_operand" "=x")
1141         (vec_merge:V8SF
1142           (plus:V8SF
1143             (match_operand:V8SF 1 "register_operand" "x")
1144             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1145           (minus:V8SF (match_dup 1) (match_dup 2))
1146           (const_int 170)))]
1147   "TARGET_AVX"
1148   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1149   [(set_attr "type" "sseadd")
1150    (set_attr "prefix" "vex")
1151    (set_attr "mode" "V8SF")])
1152
1153 (define_insn "avx_addsubv4df3"
1154   [(set (match_operand:V4DF 0 "register_operand" "=x")
1155         (vec_merge:V4DF
1156           (plus:V4DF
1157             (match_operand:V4DF 1 "register_operand" "x")
1158             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1159           (minus:V4DF (match_dup 1) (match_dup 2))
1160           (const_int 10)))]
1161   "TARGET_AVX"
1162   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1163   [(set_attr "type" "sseadd")
1164    (set_attr "prefix" "vex")
1165    (set_attr "mode" "V4DF")])
1166
1167 (define_insn "*avx_addsubv4sf3"
1168   [(set (match_operand:V4SF 0 "register_operand" "=x")
1169         (vec_merge:V4SF
1170           (plus:V4SF
1171             (match_operand:V4SF 1 "register_operand" "x")
1172             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1173           (minus:V4SF (match_dup 1) (match_dup 2))
1174           (const_int 10)))]
1175   "TARGET_AVX"
1176   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1177   [(set_attr "type" "sseadd")
1178    (set_attr "prefix" "vex")
1179    (set_attr "mode" "V4SF")])
1180
1181 (define_insn "sse3_addsubv4sf3"
1182   [(set (match_operand:V4SF 0 "register_operand" "=x")
1183         (vec_merge:V4SF
1184           (plus:V4SF
1185             (match_operand:V4SF 1 "register_operand" "0")
1186             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1187           (minus:V4SF (match_dup 1) (match_dup 2))
1188           (const_int 10)))]
1189   "TARGET_SSE3"
1190   "addsubps\t{%2, %0|%0, %2}"
1191   [(set_attr "type" "sseadd")
1192    (set_attr "prefix_rep" "1")
1193    (set_attr "mode" "V4SF")])
1194
1195 (define_insn "*avx_addsubv2df3"
1196   [(set (match_operand:V2DF 0 "register_operand" "=x")
1197         (vec_merge:V2DF
1198           (plus:V2DF
1199             (match_operand:V2DF 1 "register_operand" "x")
1200             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1201           (minus:V2DF (match_dup 1) (match_dup 2))
1202           (const_int 2)))]
1203   "TARGET_AVX"
1204   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1205   [(set_attr "type" "sseadd")
1206    (set_attr "prefix" "vex")
1207    (set_attr "mode" "V2DF")])
1208
1209 (define_insn "sse3_addsubv2df3"
1210   [(set (match_operand:V2DF 0 "register_operand" "=x")
1211         (vec_merge:V2DF
1212           (plus:V2DF
1213             (match_operand:V2DF 1 "register_operand" "0")
1214             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1215           (minus:V2DF (match_dup 1) (match_dup 2))
1216           (const_int 2)))]
1217   "TARGET_SSE3"
1218   "addsubpd\t{%2, %0|%0, %2}"
1219   [(set_attr "type" "sseadd")
1220    (set_attr "atom_unit" "complex")
1221    (set_attr "mode" "V2DF")])
1222
1223 (define_insn "avx_h<plusminus_insn>v4df3"
1224   [(set (match_operand:V4DF 0 "register_operand" "=x")
1225         (vec_concat:V4DF
1226           (vec_concat:V2DF
1227             (plusminus:DF
1228               (vec_select:DF
1229                 (match_operand:V4DF 1 "register_operand" "x")
1230                 (parallel [(const_int 0)]))
1231               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1232             (plusminus:DF
1233               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1234               (vec_select:DF (match_dup 1) (parallel [(const_int 3)]))))
1235           (vec_concat:V2DF
1236             (plusminus:DF
1237               (vec_select:DF
1238                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1239                 (parallel [(const_int 0)]))
1240               (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))
1241             (plusminus:DF
1242               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1243               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1244   "TARGET_AVX"
1245   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1246   [(set_attr "type" "sseadd")
1247    (set_attr "prefix" "vex")
1248    (set_attr "mode" "V4DF")])
1249
1250 (define_insn "avx_h<plusminus_insn>v8sf3"
1251   [(set (match_operand:V8SF 0 "register_operand" "=x")
1252         (vec_concat:V8SF
1253           (vec_concat:V4SF
1254             (vec_concat:V2SF
1255               (plusminus:SF
1256                 (vec_select:SF
1257                   (match_operand:V8SF 1 "register_operand" "x")
1258                   (parallel [(const_int 0)]))
1259                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1260               (plusminus:SF
1261                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1262                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1263             (vec_concat:V2SF
1264               (plusminus:SF
1265                 (vec_select:SF
1266                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1267                   (parallel [(const_int 0)]))
1268                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1269               (plusminus:SF
1270                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1271                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1272           (vec_concat:V4SF
1273             (vec_concat:V2SF
1274               (plusminus:SF
1275                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1276                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1277               (plusminus:SF
1278                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1279                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1280             (vec_concat:V2SF
1281               (plusminus:SF
1282                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1283                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1284               (plusminus:SF
1285                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1286                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1287   "TARGET_AVX"
1288   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1289   [(set_attr "type" "sseadd")
1290    (set_attr "prefix" "vex")
1291    (set_attr "mode" "V8SF")])
1292
1293 (define_insn "*avx_h<plusminus_insn>v4sf3"
1294   [(set (match_operand:V4SF 0 "register_operand" "=x")
1295         (vec_concat:V4SF
1296           (vec_concat:V2SF
1297             (plusminus:SF
1298               (vec_select:SF
1299                 (match_operand:V4SF 1 "register_operand" "x")
1300                 (parallel [(const_int 0)]))
1301               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1302             (plusminus:SF
1303               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1304               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1305           (vec_concat:V2SF
1306             (plusminus:SF
1307               (vec_select:SF
1308                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1309                 (parallel [(const_int 0)]))
1310               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1311             (plusminus:SF
1312               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1313               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1314   "TARGET_AVX"
1315   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1316   [(set_attr "type" "sseadd")
1317    (set_attr "prefix" "vex")
1318    (set_attr "mode" "V4SF")])
1319
1320 (define_insn "sse3_h<plusminus_insn>v4sf3"
1321   [(set (match_operand:V4SF 0 "register_operand" "=x")
1322         (vec_concat:V4SF
1323           (vec_concat:V2SF
1324             (plusminus:SF
1325               (vec_select:SF
1326                 (match_operand:V4SF 1 "register_operand" "0")
1327                 (parallel [(const_int 0)]))
1328               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1329             (plusminus:SF
1330               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1331               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1332           (vec_concat:V2SF
1333             (plusminus:SF
1334               (vec_select:SF
1335                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1336                 (parallel [(const_int 0)]))
1337               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1338             (plusminus:SF
1339               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1340               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1341   "TARGET_SSE3"
1342   "h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}"
1343   [(set_attr "type" "sseadd")
1344    (set_attr "atom_unit" "complex")
1345    (set_attr "prefix_rep" "1")
1346    (set_attr "mode" "V4SF")])
1347
1348 (define_insn "*avx_h<plusminus_insn>v2df3"
1349   [(set (match_operand:V2DF 0 "register_operand" "=x")
1350         (vec_concat:V2DF
1351           (plusminus:DF
1352             (vec_select:DF
1353               (match_operand:V2DF 1 "register_operand" "x")
1354               (parallel [(const_int 0)]))
1355             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1356           (plusminus:DF
1357             (vec_select:DF
1358               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1359               (parallel [(const_int 0)]))
1360             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1361   "TARGET_AVX"
1362   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1363   [(set_attr "type" "sseadd")
1364    (set_attr "prefix" "vex")
1365    (set_attr "mode" "V2DF")])
1366
1367 (define_insn "sse3_h<plusminus_insn>v2df3"
1368   [(set (match_operand:V2DF 0 "register_operand" "=x")
1369         (vec_concat:V2DF
1370           (plusminus:DF
1371             (vec_select:DF
1372               (match_operand:V2DF 1 "register_operand" "0")
1373               (parallel [(const_int 0)]))
1374             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1375           (plusminus:DF
1376             (vec_select:DF
1377               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1378               (parallel [(const_int 0)]))
1379             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1380   "TARGET_SSE3"
1381   "h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}"
1382   [(set_attr "type" "sseadd")
1383    (set_attr "mode" "V2DF")])
1384
1385 (define_expand "reduc_splus_v4sf"
1386   [(match_operand:V4SF 0 "register_operand" "")
1387    (match_operand:V4SF 1 "register_operand" "")]
1388   "TARGET_SSE"
1389 {
1390   if (TARGET_SSE3)
1391     {
1392       rtx tmp = gen_reg_rtx (V4SFmode);
1393       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1394       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1395     }
1396   else
1397     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
1398   DONE;
1399 })
1400
1401 (define_expand "reduc_splus_v2df"
1402   [(match_operand:V2DF 0 "register_operand" "")
1403    (match_operand:V2DF 1 "register_operand" "")]
1404   "TARGET_SSE3"
1405 {
1406   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1407   DONE;
1408 })
1409
1410 (define_expand "reduc_smax_v4sf"
1411   [(match_operand:V4SF 0 "register_operand" "")
1412    (match_operand:V4SF 1 "register_operand" "")]
1413   "TARGET_SSE"
1414 {
1415   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
1416   DONE;
1417 })
1418
1419 (define_expand "reduc_smin_v4sf"
1420   [(match_operand:V4SF 0 "register_operand" "")
1421    (match_operand:V4SF 1 "register_operand" "")]
1422   "TARGET_SSE"
1423 {
1424   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
1425   DONE;
1426 })
1427
1428 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1429 ;;
1430 ;; Parallel floating point comparisons
1431 ;;
1432 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1433
1434 (define_insn "avx_cmp<ssemodesuffix><mode>3"
1435   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1436         (unspec:AVXMODEF2P
1437           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1438            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
1439            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1440           UNSPEC_PCMP))]
1441   "TARGET_AVX"
1442   "vcmp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1443   [(set_attr "type" "ssecmp")
1444    (set_attr "length_immediate" "1")
1445    (set_attr "prefix" "vex")
1446    (set_attr "mode" "<MODE>")])
1447
1448 (define_insn "avx_cmp<ssescalarmodesuffix><mode>3"
1449   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1450         (vec_merge:SSEMODEF2P
1451           (unspec:SSEMODEF2P
1452             [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1453              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
1454              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1455             UNSPEC_PCMP)
1456          (match_dup 1)
1457          (const_int 1)))]
1458   "TARGET_AVX"
1459   "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1460   [(set_attr "type" "ssecmp")
1461    (set_attr "length_immediate" "1")
1462    (set_attr "prefix" "vex")
1463    (set_attr "mode" "<ssescalarmode>")])
1464
1465 ;; We don't promote 128bit vector compare intrinsics. But vectorizer
1466 ;; may generate 256bit vector compare instructions.
1467 (define_insn "*avx_maskcmp<mode>3"
1468   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1469         (match_operator:AVXMODEF2P 3 "avx_comparison_float_operator"
1470                 [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1471                  (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]))]
1472   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1473   "vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1474   [(set_attr "type" "ssecmp")
1475    (set_attr "prefix" "vex")
1476    (set_attr "length_immediate" "1")
1477    (set_attr "mode" "<avxvecmode>")])
1478
1479 (define_insn "<sse>_maskcmp<mode>3"
1480   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x")
1481         (match_operator:SSEMODEF4 3 "sse_comparison_operator"
1482                 [(match_operand:SSEMODEF4 1 "register_operand" "0")
1483                  (match_operand:SSEMODEF4 2 "nonimmediate_operand" "xm")]))]
1484   "!TARGET_XOP
1485   && (SSE_FLOAT_MODE_P (<MODE>mode) || SSE_VEC_FLOAT_MODE_P (<MODE>mode))"
1486   "cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}"
1487   [(set_attr "type" "ssecmp")
1488    (set_attr "length_immediate" "1")
1489    (set_attr "mode" "<MODE>")])
1490
1491 (define_insn "*avx_vmmaskcmp<mode>3"
1492   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1493         (vec_merge:SSEMODEF2P
1494          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1495                 [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1496                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1497          (match_dup 1)
1498          (const_int 1)))]
1499   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1500   "vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1501   [(set_attr "type" "ssecmp")
1502    (set_attr "prefix" "vex")
1503    (set_attr "mode" "<ssescalarmode>")])
1504
1505 (define_insn "<sse>_vmmaskcmp<mode>3"
1506   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1507         (vec_merge:SSEMODEF2P
1508          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1509                 [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1510                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1511          (match_dup 1)
1512          (const_int 1)))]
1513   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1514   "cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
1515   [(set_attr "type" "ssecmp")
1516    (set_attr "length_immediate" "1")
1517    (set_attr "mode" "<ssescalarmode>")])
1518
1519 (define_insn "<sse>_comi"
1520   [(set (reg:CCFP FLAGS_REG)
1521         (compare:CCFP
1522           (vec_select:MODEF
1523             (match_operand:<ssevecmode> 0 "register_operand" "x")
1524             (parallel [(const_int 0)]))
1525           (vec_select:MODEF
1526             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1527             (parallel [(const_int 0)]))))]
1528   "SSE_FLOAT_MODE_P (<MODE>mode)"
1529   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1530   [(set_attr "type" "ssecomi")
1531    (set_attr "prefix" "maybe_vex")
1532    (set_attr "prefix_rep" "0")
1533    (set (attr "prefix_data16")
1534         (if_then_else (eq_attr "mode" "DF")
1535                       (const_string "1")
1536                       (const_string "0")))
1537    (set_attr "mode" "<MODE>")])
1538
1539 (define_insn "<sse>_ucomi"
1540   [(set (reg:CCFPU FLAGS_REG)
1541         (compare:CCFPU
1542           (vec_select:MODEF
1543             (match_operand:<ssevecmode> 0 "register_operand" "x")
1544             (parallel [(const_int 0)]))
1545           (vec_select:MODEF
1546             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1547             (parallel [(const_int 0)]))))]
1548   "SSE_FLOAT_MODE_P (<MODE>mode)"
1549   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1550   [(set_attr "type" "ssecomi")
1551    (set_attr "prefix" "maybe_vex")
1552    (set_attr "prefix_rep" "0")
1553    (set (attr "prefix_data16")
1554         (if_then_else (eq_attr "mode" "DF")
1555                       (const_string "1")
1556                       (const_string "0")))
1557    (set_attr "mode" "<MODE>")])
1558
1559 (define_expand "vcond<mode>"
1560   [(set (match_operand:AVXMODEF2P 0 "register_operand" "")
1561         (if_then_else:AVXMODEF2P
1562           (match_operator 3 ""
1563             [(match_operand:AVXMODEF2P 4 "nonimmediate_operand" "")
1564              (match_operand:AVXMODEF2P 5 "nonimmediate_operand" "")])
1565           (match_operand:AVXMODEF2P 1 "general_operand" "")
1566           (match_operand:AVXMODEF2P 2 "general_operand" "")))]
1567   "(SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1568     || AVX_VEC_FLOAT_MODE_P (<MODE>mode))"
1569 {
1570   bool ok = ix86_expand_fp_vcond (operands);
1571   gcc_assert (ok);
1572   DONE;
1573 })
1574
1575 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1576 ;;
1577 ;; Parallel floating point logical operations
1578 ;;
1579 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1580
1581 (define_insn "avx_andnot<mode>3"
1582   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1583         (and:AVXMODEF2P
1584           (not:AVXMODEF2P
1585             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1586           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1587   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1588   "vandn<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1589   [(set_attr "type" "sselog")
1590    (set_attr "prefix" "vex")
1591    (set_attr "mode" "<avxvecmode>")])
1592
1593 (define_insn "<sse>_andnot<mode>3"
1594   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1595         (and:SSEMODEF2P
1596           (not:SSEMODEF2P
1597             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1598           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1599   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1600   "andn<ssemodesuffix>\t{%2, %0|%0, %2}"
1601   [(set_attr "type" "sselog")
1602    (set_attr "mode" "<MODE>")])
1603
1604 (define_expand "<code><mode>3"
1605   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1606         (any_logic:AVX256MODEF2P
1607           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1608           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1609   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1610   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1611
1612 (define_insn "*avx_<code><mode>3"
1613   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1614         (any_logic:AVXMODEF2P
1615           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1616           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1617   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1618    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1619 {
1620   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1621     return "v<logic>ps\t{%2, %1, %0|%0, %1, %2}";
1622   else
1623     return "v<logic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
1624 }
1625   [(set_attr "type" "sselog")
1626    (set_attr "prefix" "vex")
1627    (set_attr "mode" "<avxvecmode>")])
1628
1629 (define_expand "<code><mode>3"
1630   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1631         (any_logic:SSEMODEF2P
1632           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1633           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1634   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1635   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1636
1637 (define_insn "*<code><mode>3"
1638   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1639         (any_logic:SSEMODEF2P
1640           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1641           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1642   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1643    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1644 {
1645   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1646     return "<logic>ps\t{%2, %0|%0, %2}";
1647   else
1648     return "<logic><ssemodesuffix>\t{%2, %0|%0, %2}";
1649 }
1650   [(set_attr "type" "sselog")
1651    (set_attr "mode" "<MODE>")])
1652
1653 (define_expand "copysign<mode>3"
1654   [(set (match_dup 4)
1655         (and:SSEMODEF2P
1656           (not:SSEMODEF2P (match_dup 3))
1657           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")))
1658    (set (match_dup 5)
1659         (and:SSEMODEF2P (match_dup 3)
1660                         (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))
1661    (set (match_operand:SSEMODEF2P 0 "register_operand" "")
1662         (ior:SSEMODEF2P (match_dup 4) (match_dup 5)))]
1663   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1664 {
1665   operands[3] = ix86_build_signbit_mask (<ssescalarmode>mode, 1, 0);
1666
1667   operands[4] = gen_reg_rtx (<MODE>mode);
1668   operands[5] = gen_reg_rtx (<MODE>mode);
1669 })
1670
1671 ;; Also define scalar versions.  These are used for abs, neg, and
1672 ;; conditional move.  Using subregs into vector modes causes register
1673 ;; allocation lossage.  These patterns do not allow memory operands
1674 ;; because the native instructions read the full 128-bits.
1675
1676 (define_insn "*avx_andnot<mode>3"
1677   [(set (match_operand:MODEF 0 "register_operand" "=x")
1678         (and:MODEF
1679           (not:MODEF
1680             (match_operand:MODEF 1 "register_operand" "x"))
1681             (match_operand:MODEF 2 "register_operand" "x")))]
1682   "AVX_FLOAT_MODE_P (<MODE>mode)"
1683   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1684   [(set_attr "type" "sselog")
1685    (set_attr "prefix" "vex")
1686    (set_attr "mode" "<ssevecmode>")])
1687
1688 (define_insn "*andnot<mode>3"
1689   [(set (match_operand:MODEF 0 "register_operand" "=x")
1690         (and:MODEF
1691           (not:MODEF
1692             (match_operand:MODEF 1 "register_operand" "0"))
1693             (match_operand:MODEF 2 "register_operand" "x")))]
1694   "SSE_FLOAT_MODE_P (<MODE>mode)"
1695   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1696   [(set_attr "type" "sselog")
1697    (set_attr "mode" "<ssevecmode>")])
1698
1699 (define_insn "*avx_<code><mode>3"
1700   [(set (match_operand:MODEF 0 "register_operand" "=x")
1701         (any_logic:MODEF
1702           (match_operand:MODEF 1 "register_operand" "x")
1703           (match_operand:MODEF 2 "register_operand" "x")))]
1704   "AVX_FLOAT_MODE_P (<MODE>mode)"
1705 {
1706   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1707     return "v<logic>ps\t{%2, %1, %0|%0, %1, %2}";
1708   else
1709     return "v<logic>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}";
1710 }
1711   [(set_attr "type" "sselog")
1712    (set_attr "prefix" "vex")
1713    (set_attr "mode" "<ssevecmode>")])
1714
1715 (define_insn "*<code><mode>3"
1716   [(set (match_operand:MODEF 0 "register_operand" "=x")
1717         (any_logic:MODEF
1718           (match_operand:MODEF 1 "register_operand" "0")
1719           (match_operand:MODEF 2 "register_operand" "x")))]
1720   "SSE_FLOAT_MODE_P (<MODE>mode)"
1721 {
1722   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1723     return "<logic>ps\t{%2, %0|%0, %2}";
1724   else
1725     return "<logic>p<ssemodefsuffix>\t{%2, %0|%0, %2}";
1726 }
1727   [(set_attr "type" "sselog")
1728    (set_attr "mode" "<ssevecmode>")])
1729
1730 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1731 ;;
1732 ;; FMA4 floating point multiply/accumulate instructions.  This
1733 ;; includes the scalar version of the instructions as well as the
1734 ;; vector.
1735 ;;
1736 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1737
1738 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1739 ;; combine to generate a multiply/add with two memory references.  We then
1740 ;; split this insn, into loading up the destination register with one of the
1741 ;; memory operations.  If we don't manage to split the insn, reload will
1742 ;; generate the appropriate moves.  The reason this is needed, is that combine
1743 ;; has already folded one of the memory references into both the multiply and
1744 ;; add insns, and it can't generate a new pseudo.  I.e.:
1745 ;;      (set (reg1) (mem (addr1)))
1746 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1747 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1748
1749 (define_insn "fma4_fmadd<mode>4256"
1750   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1751         (plus:FMA4MODEF4
1752          (mult:FMA4MODEF4
1753           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1754           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1755          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1756   "TARGET_FMA4 && TARGET_FUSED_MADD"
1757   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1758   [(set_attr "type" "ssemuladd")
1759    (set_attr "mode" "<MODE>")])
1760
1761 ;; Floating multiply and subtract.
1762 (define_insn "fma4_fmsub<mode>4256"
1763   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1764         (minus:FMA4MODEF4
1765          (mult:FMA4MODEF4
1766           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1767           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1768          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1769   "TARGET_FMA4 && TARGET_FUSED_MADD"
1770   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1771   [(set_attr "type" "ssemuladd")
1772    (set_attr "mode" "<MODE>")])
1773
1774 ;; Floating point negative multiply and add.
1775 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1776 (define_insn "fma4_fnmadd<mode>4256"
1777   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1778         (minus:FMA4MODEF4
1779          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1780          (mult:FMA4MODEF4
1781           (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1782           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))))]
1783   "TARGET_FMA4 && TARGET_FUSED_MADD"
1784   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1785   [(set_attr "type" "ssemuladd")
1786    (set_attr "mode" "<MODE>")])
1787
1788 ;; Floating point negative multiply and subtract.
1789 (define_insn "fma4_fnmsub<mode>4256"
1790   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1791         (minus:FMA4MODEF4
1792          (mult:FMA4MODEF4
1793           (neg:FMA4MODEF4
1794            (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1795           (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1796          (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")))]
1797   "TARGET_FMA4 && TARGET_FUSED_MADD"
1798   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1799   [(set_attr "type" "ssemuladd")
1800    (set_attr "mode" "<MODE>")])
1801
1802 (define_insn "fma4_fmadd<mode>4"
1803   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1804         (plus:SSEMODEF4
1805          (mult:SSEMODEF4
1806           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1807           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1808          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1809   "TARGET_FMA4 && TARGET_FUSED_MADD"
1810   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1811   [(set_attr "type" "ssemuladd")
1812    (set_attr "mode" "<MODE>")])
1813
1814 ;; For the scalar operations, use operand1 for the upper words that aren't
1815 ;; modified, so restrict the forms that are generated.
1816 ;; Scalar version of fmadd.
1817 (define_insn "fma4_vmfmadd<mode>4"
1818   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1819         (vec_merge:SSEMODEF2P
1820          (plus:SSEMODEF2P
1821           (mult:SSEMODEF2P
1822            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1823            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1824           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1825          (match_dup 0)
1826          (const_int 1)))]
1827   "TARGET_FMA4 && TARGET_FUSED_MADD"
1828   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1829   [(set_attr "type" "ssemuladd")
1830    (set_attr "mode" "<MODE>")])
1831
1832 ;; Floating multiply and subtract.
1833 ;; Allow two memory operands the same as fmadd.
1834 (define_insn "fma4_fmsub<mode>4"
1835   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1836         (minus:SSEMODEF4
1837          (mult:SSEMODEF4
1838           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1839           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1840          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1841   "TARGET_FMA4 && TARGET_FUSED_MADD"
1842   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1843   [(set_attr "type" "ssemuladd")
1844    (set_attr "mode" "<MODE>")])
1845
1846 ;; For the scalar operations, use operand1 for the upper words that aren't
1847 ;; modified, so restrict the forms that are generated.
1848 ;; Scalar version of fmsub.
1849 (define_insn "fma4_vmfmsub<mode>4"
1850   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1851         (vec_merge:SSEMODEF2P
1852          (minus:SSEMODEF2P
1853           (mult:SSEMODEF2P
1854            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1855            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1856           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1857          (match_dup 0)
1858          (const_int 1)))]
1859   "TARGET_FMA4 && TARGET_FUSED_MADD"
1860   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1861   [(set_attr "type" "ssemuladd")
1862    (set_attr "mode" "<MODE>")])
1863
1864 ;; Floating point negative multiply and add.
1865 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b).
1866 (define_insn "fma4_fnmadd<mode>4"
1867   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1868         (minus:SSEMODEF4
1869          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")
1870          (mult:SSEMODEF4
1871           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x")
1872           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))))]
1873   "TARGET_FMA4 && TARGET_FUSED_MADD"
1874   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1875   [(set_attr "type" "ssemuladd")
1876    (set_attr "mode" "<MODE>")])
1877
1878 ;; For the scalar operations, use operand1 for the upper words that aren't
1879 ;; modified, so restrict the forms that are generated.
1880 ;; Scalar version of fnmadd.
1881 (define_insn "fma4_vmfnmadd<mode>4"
1882   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1883         (vec_merge:SSEMODEF2P
1884          (minus:SSEMODEF2P
1885           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1886           (mult:SSEMODEF2P
1887            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1888            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
1889          (match_dup 0)
1890          (const_int 1)))]
1891   "TARGET_FMA4 && TARGET_FUSED_MADD"
1892   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1893   [(set_attr "type" "ssemuladd")
1894    (set_attr "mode" "<MODE>")])
1895
1896 ;; Floating point negative multiply and subtract.
1897 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c.
1898 (define_insn "fma4_fnmsub<mode>4"
1899   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1900         (minus:SSEMODEF4
1901          (mult:SSEMODEF4
1902           (neg:SSEMODEF4
1903            (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%x,x"))
1904           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,m"))
1905          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1906   "TARGET_FMA4 && TARGET_FUSED_MADD"
1907   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1908   [(set_attr "type" "ssemuladd")
1909    (set_attr "mode" "<MODE>")])
1910
1911 ;; For the scalar operations, use operand1 for the upper words that aren't
1912 ;; modified, so restrict the forms that are generated.
1913 ;; Scalar version of fnmsub.
1914 (define_insn "fma4_vmfnmsub<mode>4"
1915   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1916         (vec_merge:SSEMODEF2P
1917          (minus:SSEMODEF2P
1918           (mult:SSEMODEF2P
1919            (neg:SSEMODEF2P
1920             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1921            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1922           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1923          (match_dup 0)
1924          (const_int 1)))]
1925   "TARGET_FMA4 && TARGET_FUSED_MADD"
1926   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1927   [(set_attr "type" "ssemuladd")
1928    (set_attr "mode" "<MODE>")])
1929
1930 (define_insn "fma4i_fmadd<mode>4256"
1931   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1932         (unspec:FMA4MODEF4
1933          [(plus:FMA4MODEF4
1934            (mult:FMA4MODEF4
1935             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1936             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1937            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1938          UNSPEC_FMA4_INTRINSIC))]
1939   "TARGET_FMA4"
1940   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1941   [(set_attr "type" "ssemuladd")
1942    (set_attr "mode" "<MODE>")])
1943
1944 (define_insn "fma4i_fmsub<mode>4256"
1945   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1946         (unspec:FMA4MODEF4
1947          [(minus:FMA4MODEF4
1948            (mult:FMA4MODEF4
1949             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1950             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1951            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1952          UNSPEC_FMA4_INTRINSIC))]
1953   "TARGET_FMA4"
1954   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1955   [(set_attr "type" "ssemuladd")
1956    (set_attr "mode" "<MODE>")])
1957
1958 (define_insn "fma4i_fnmadd<mode>4256"
1959   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1960         (unspec:FMA4MODEF4
1961          [(minus:FMA4MODEF4
1962            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x")
1963            (mult:FMA4MODEF4
1964             (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x")
1965             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m")))]
1966          UNSPEC_FMA4_INTRINSIC))]
1967   "TARGET_FMA4"
1968   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1969   [(set_attr "type" "ssemuladd")
1970    (set_attr "mode" "<MODE>")])
1971
1972 (define_insn "fma4i_fnmsub<mode>4256"
1973   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x,x")
1974         (unspec:FMA4MODEF4
1975          [(minus:FMA4MODEF4
1976            (mult:FMA4MODEF4
1977             (neg:FMA4MODEF4
1978              (match_operand:FMA4MODEF4 1 "nonimmediate_operand" "%x,x"))
1979             (match_operand:FMA4MODEF4 2 "nonimmediate_operand" "x,m"))
1980            (match_operand:FMA4MODEF4 3 "nonimmediate_operand" "xm,x"))]
1981          UNSPEC_FMA4_INTRINSIC))]
1982   "TARGET_FMA4"
1983   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1984   [(set_attr "type" "ssemuladd")
1985    (set_attr "mode" "<MODE>")])
1986
1987 (define_insn "fma4i_fmadd<mode>4"
1988   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1989         (unspec:SSEMODEF2P
1990          [(plus:SSEMODEF2P
1991            (mult:SSEMODEF2P
1992             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1993             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
1994            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
1995          UNSPEC_FMA4_INTRINSIC))]
1996   "TARGET_FMA4"
1997   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1998   [(set_attr "type" "ssemuladd")
1999    (set_attr "mode" "<MODE>")])
2000
2001 (define_insn "fma4i_fmsub<mode>4"
2002   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2003         (unspec:SSEMODEF2P
2004          [(minus:SSEMODEF2P
2005            (mult:SSEMODEF2P
2006             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2007             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2008            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
2009          UNSPEC_FMA4_INTRINSIC))]
2010   "TARGET_FMA4"
2011   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2012   [(set_attr "type" "ssemuladd")
2013    (set_attr "mode" "<MODE>")])
2014
2015 (define_insn "fma4i_fnmadd<mode>4"
2016   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2017         (unspec:SSEMODEF2P
2018          [(minus:SSEMODEF2P
2019            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2020            (mult:SSEMODEF2P
2021             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2022             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))]
2023          UNSPEC_FMA4_INTRINSIC))]
2024   "TARGET_FMA4"
2025   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2026   [(set_attr "type" "ssemuladd")
2027    (set_attr "mode" "<MODE>")])
2028
2029 (define_insn "fma4i_fnmsub<mode>4"
2030   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2031         (unspec:SSEMODEF2P
2032          [(minus:SSEMODEF2P
2033            (mult:SSEMODEF2P
2034             (neg:SSEMODEF2P
2035              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
2036             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2037            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))]
2038          UNSPEC_FMA4_INTRINSIC))]
2039   "TARGET_FMA4"
2040   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2041   [(set_attr "type" "ssemuladd")
2042    (set_attr "mode" "<MODE>")])
2043
2044 ;; For the scalar operations, use operand1 for the upper words that aren't
2045 ;; modified, so restrict the forms that are accepted.
2046 (define_insn "fma4i_vmfmadd<mode>4"
2047   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2048         (unspec:SSEMODEF2P
2049          [(vec_merge:SSEMODEF2P
2050            (plus:SSEMODEF2P
2051             (mult:SSEMODEF2P
2052              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2053              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2054             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2055            (match_dup 0)
2056            (const_int 1))]
2057          UNSPEC_FMA4_INTRINSIC))]
2058   "TARGET_FMA4"
2059   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2060   [(set_attr "type" "ssemuladd")
2061    (set_attr "mode" "<ssescalarmode>")])
2062
2063 (define_insn "fma4i_vmfmsub<mode>4"
2064   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2065         (unspec:SSEMODEF2P
2066          [(vec_merge:SSEMODEF2P
2067            (minus:SSEMODEF2P
2068             (mult:SSEMODEF2P
2069              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2070              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2071             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2072            (match_dup 0)
2073            (const_int 1))]
2074          UNSPEC_FMA4_INTRINSIC))]
2075   "TARGET_FMA4"
2076   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2077   [(set_attr "type" "ssemuladd")
2078    (set_attr "mode" "<ssescalarmode>")])
2079
2080 (define_insn "fma4i_vmfnmadd<mode>4"
2081   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2082         (unspec:SSEMODEF2P
2083          [(vec_merge:SSEMODEF2P
2084            (minus:SSEMODEF2P
2085             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2086             (mult:SSEMODEF2P
2087              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
2088              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m")))
2089            (match_dup 0)
2090            (const_int 1))]
2091          UNSPEC_FMA4_INTRINSIC))]
2092   "TARGET_FMA4"
2093   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2094   [(set_attr "type" "ssemuladd")
2095    (set_attr "mode" "<ssescalarmode>")])
2096
2097 (define_insn "fma4i_vmfnmsub<mode>4"
2098   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2099         (unspec:SSEMODEF2P
2100          [(vec_merge:SSEMODEF2P
2101            (minus:SSEMODEF2P
2102             (mult:SSEMODEF2P
2103              (neg:SSEMODEF2P
2104               (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
2105              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,m"))
2106             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2107            (match_dup 0)
2108            (const_int 1))]
2109          UNSPEC_FMA4_INTRINSIC))]
2110   "TARGET_FMA4"
2111   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2112   [(set_attr "type" "ssemuladd")
2113    (set_attr "mode" "<ssescalarmode>")])
2114
2115 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2116 ;;
2117 ;; FMA4 Parallel floating point multiply addsub and subadd operations.
2118 ;;
2119 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2120
2121 (define_insn "fma4_fmaddsubv8sf4"
2122   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2123         (vec_merge:V8SF
2124           (plus:V8SF
2125             (mult:V8SF
2126               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2127               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2128             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2129           (minus:V8SF
2130             (mult:V8SF
2131               (match_dup 1)
2132               (match_dup 2))
2133             (match_dup 3))
2134           (const_int 170)))]
2135   "TARGET_FMA4 && TARGET_FUSED_MADD"
2136   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2137   [(set_attr "type" "ssemuladd")
2138    (set_attr "mode" "V8SF")])
2139
2140 (define_insn "fma4_fmaddsubv4df4"
2141   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2142         (vec_merge:V4DF
2143           (plus:V4DF
2144             (mult:V4DF
2145               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2146               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2147             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2148           (minus:V4DF
2149             (mult:V4DF
2150               (match_dup 1)
2151               (match_dup 2))
2152             (match_dup 3))
2153           (const_int 10)))]
2154   "TARGET_FMA4 && TARGET_FUSED_MADD"
2155   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2156   [(set_attr "type" "ssemuladd")
2157    (set_attr "mode" "V4DF")])
2158
2159 (define_insn "fma4_fmaddsubv4sf4"
2160   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2161         (vec_merge:V4SF
2162           (plus:V4SF
2163             (mult:V4SF
2164               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2165               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2166             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2167           (minus:V4SF
2168             (mult:V4SF
2169               (match_dup 1)
2170               (match_dup 2))
2171             (match_dup 3))
2172           (const_int 10)))]
2173   "TARGET_FMA4 && TARGET_FUSED_MADD"
2174   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2175   [(set_attr "type" "ssemuladd")
2176    (set_attr "mode" "V4SF")])
2177
2178 (define_insn "fma4_fmaddsubv2df4"
2179   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2180         (vec_merge:V2DF
2181           (plus:V2DF
2182             (mult:V2DF
2183               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2184               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2185             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2186           (minus:V2DF
2187             (mult:V2DF
2188               (match_dup 1)
2189               (match_dup 2))
2190             (match_dup 3))
2191           (const_int 2)))]
2192   "TARGET_FMA4 && TARGET_FUSED_MADD"
2193   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2194   [(set_attr "type" "ssemuladd")
2195    (set_attr "mode" "V2DF")])
2196
2197 (define_insn "fma4_fmsubaddv8sf4"
2198   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2199         (vec_merge:V8SF
2200           (plus:V8SF
2201             (mult:V8SF
2202               (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2203               (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2204             (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2205           (minus:V8SF
2206             (mult:V8SF
2207               (match_dup 1)
2208               (match_dup 2))
2209             (match_dup 3))
2210           (const_int 85)))]
2211   "TARGET_FMA4 && TARGET_FUSED_MADD"
2212   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2213   [(set_attr "type" "ssemuladd")
2214    (set_attr "mode" "V8SF")])
2215
2216 (define_insn "fma4_fmsubaddv4df4"
2217   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2218         (vec_merge:V4DF
2219           (plus:V4DF
2220             (mult:V4DF
2221               (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2222               (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2223             (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2224           (minus:V4DF
2225             (mult:V4DF
2226               (match_dup 1)
2227               (match_dup 2))
2228             (match_dup 3))
2229           (const_int 5)))]
2230   "TARGET_FMA4 && TARGET_FUSED_MADD"
2231   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2232   [(set_attr "type" "ssemuladd")
2233    (set_attr "mode" "V4DF")])
2234
2235 (define_insn "fma4_fmsubaddv4sf4"
2236   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2237         (vec_merge:V4SF
2238           (plus:V4SF
2239             (mult:V4SF
2240               (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2241               (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2242             (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2243           (minus:V4SF
2244             (mult:V4SF
2245               (match_dup 1)
2246               (match_dup 2))
2247             (match_dup 3))
2248           (const_int 5)))]
2249   "TARGET_FMA4 && TARGET_FUSED_MADD"
2250   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2251   [(set_attr "type" "ssemuladd")
2252    (set_attr "mode" "V4SF")])
2253
2254 (define_insn "fma4_fmsubaddv2df4"
2255   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2256         (vec_merge:V2DF
2257           (plus:V2DF
2258             (mult:V2DF
2259               (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2260               (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2261             (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2262           (minus:V2DF
2263             (mult:V2DF
2264               (match_dup 1)
2265               (match_dup 2))
2266             (match_dup 3))
2267           (const_int 1)))]
2268   "TARGET_FMA4 && TARGET_FUSED_MADD"
2269   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2270   [(set_attr "type" "ssemuladd")
2271    (set_attr "mode" "V2DF")])
2272
2273 (define_insn "fma4i_fmaddsubv8sf4"
2274   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2275         (unspec:V8SF
2276          [(vec_merge:V8SF
2277            (plus:V8SF
2278              (mult:V8SF
2279                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2280                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2281              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2282            (minus:V8SF
2283              (mult:V8SF
2284                (match_dup 1)
2285                (match_dup 2))
2286              (match_dup 3))
2287            (const_int 170))]
2288          UNSPEC_FMA4_INTRINSIC))]
2289   "TARGET_FMA4"
2290   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2291   [(set_attr "type" "ssemuladd")
2292    (set_attr "mode" "V8SF")])
2293
2294 (define_insn "fma4i_fmaddsubv4df4"
2295   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2296         (unspec:V4DF
2297          [(vec_merge:V4DF
2298            (plus:V4DF
2299              (mult:V4DF
2300                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2301                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2302              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2303            (minus:V4DF
2304              (mult:V4DF
2305                (match_dup 1)
2306                (match_dup 2))
2307              (match_dup 3))
2308            (const_int 10))]
2309          UNSPEC_FMA4_INTRINSIC))]
2310   "TARGET_FMA4"
2311   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2312   [(set_attr "type" "ssemuladd")
2313    (set_attr "mode" "V4DF")])
2314
2315 (define_insn "fma4i_fmaddsubv4sf4"
2316   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2317         (unspec:V4SF
2318          [(vec_merge:V4SF
2319            (plus:V4SF
2320              (mult:V4SF
2321                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2322                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2323              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2324            (minus:V4SF
2325              (mult:V4SF
2326                (match_dup 1)
2327                (match_dup 2))
2328              (match_dup 3))
2329            (const_int 10))]
2330          UNSPEC_FMA4_INTRINSIC))]
2331   "TARGET_FMA4"
2332   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2333   [(set_attr "type" "ssemuladd")
2334    (set_attr "mode" "V4SF")])
2335
2336 (define_insn "fma4i_fmaddsubv2df4"
2337   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2338         (unspec:V2DF
2339          [(vec_merge:V2DF
2340            (plus:V2DF
2341              (mult:V2DF
2342                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2343                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2344              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2345            (minus:V2DF
2346              (mult:V2DF
2347                (match_dup 1)
2348                (match_dup 2))
2349              (match_dup 3))
2350            (const_int 2))]
2351          UNSPEC_FMA4_INTRINSIC))]
2352   "TARGET_FMA4"
2353   "vfmaddsubpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2354   [(set_attr "type" "ssemuladd")
2355    (set_attr "mode" "V2DF")])
2356
2357 (define_insn "fma4i_fmsubaddv8sf4"
2358   [(set (match_operand:V8SF 0 "register_operand" "=x,x")
2359         (unspec:V8SF
2360          [(vec_merge:V8SF
2361            (plus:V8SF
2362              (mult:V8SF
2363                (match_operand:V8SF 1 "nonimmediate_operand" "%x,x")
2364                (match_operand:V8SF 2 "nonimmediate_operand" "x,m"))
2365              (match_operand:V8SF 3 "nonimmediate_operand" "xm,x"))
2366            (minus:V8SF
2367              (mult:V8SF
2368                (match_dup 1)
2369                (match_dup 2))
2370              (match_dup 3))
2371            (const_int 85))]
2372          UNSPEC_FMA4_INTRINSIC))]
2373   "TARGET_FMA4"
2374   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2375   [(set_attr "type" "ssemuladd")
2376    (set_attr "mode" "V8SF")])
2377
2378 (define_insn "fma4i_fmsubaddv4df4"
2379   [(set (match_operand:V4DF 0 "register_operand" "=x,x")
2380         (unspec:V4DF
2381          [(vec_merge:V4DF
2382            (plus:V4DF
2383              (mult:V4DF
2384                (match_operand:V4DF 1 "nonimmediate_operand" "%x,x")
2385                (match_operand:V4DF 2 "nonimmediate_operand" "x,m"))
2386              (match_operand:V4DF 3 "nonimmediate_operand" "xm,x"))
2387            (minus:V4DF
2388              (mult:V4DF
2389                (match_dup 1)
2390                (match_dup 2))
2391              (match_dup 3))
2392            (const_int 5))]
2393          UNSPEC_FMA4_INTRINSIC))]
2394   "TARGET_FMA4"
2395   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2396   [(set_attr "type" "ssemuladd")
2397    (set_attr "mode" "V4DF")])
2398
2399 (define_insn "fma4i_fmsubaddv4sf4"
2400   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2401         (unspec:V4SF
2402          [(vec_merge:V4SF
2403            (plus:V4SF
2404              (mult:V4SF
2405                (match_operand:V4SF 1 "nonimmediate_operand" "%x,x")
2406                (match_operand:V4SF 2 "nonimmediate_operand" "x,m"))
2407              (match_operand:V4SF 3 "nonimmediate_operand" "xm,x"))
2408            (minus:V4SF
2409              (mult:V4SF
2410                (match_dup 1)
2411                (match_dup 2))
2412              (match_dup 3))
2413            (const_int 5))]
2414          UNSPEC_FMA4_INTRINSIC))]
2415   "TARGET_FMA4"
2416   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2417   [(set_attr "type" "ssemuladd")
2418    (set_attr "mode" "V4SF")])
2419
2420 (define_insn "fma4i_fmsubaddv2df4"
2421   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2422         (unspec:V2DF
2423          [(vec_merge:V2DF
2424            (plus:V2DF
2425              (mult:V2DF
2426                (match_operand:V2DF 1 "nonimmediate_operand" "%x,x")
2427                (match_operand:V2DF 2 "nonimmediate_operand" "x,m"))
2428              (match_operand:V2DF 3 "nonimmediate_operand" "xm,x"))
2429            (minus:V2DF
2430              (mult:V2DF
2431                (match_dup 1)
2432                (match_dup 2))
2433              (match_dup 3))
2434            (const_int 1))]
2435          UNSPEC_FMA4_INTRINSIC))]
2436   "TARGET_FMA4"
2437   "vfmsubaddpd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2438   [(set_attr "type" "ssemuladd")
2439    (set_attr "mode" "V2DF")])
2440
2441 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2442 ;;
2443 ;; Parallel single-precision floating point conversion operations
2444 ;;
2445 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2446
2447 (define_insn "sse_cvtpi2ps"
2448   [(set (match_operand:V4SF 0 "register_operand" "=x")
2449         (vec_merge:V4SF
2450           (vec_duplicate:V4SF
2451             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2452           (match_operand:V4SF 1 "register_operand" "0")
2453           (const_int 3)))]
2454   "TARGET_SSE"
2455   "cvtpi2ps\t{%2, %0|%0, %2}"
2456   [(set_attr "type" "ssecvt")
2457    (set_attr "mode" "V4SF")])
2458
2459 (define_insn "sse_cvtps2pi"
2460   [(set (match_operand:V2SI 0 "register_operand" "=y")
2461         (vec_select:V2SI
2462           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2463                        UNSPEC_FIX_NOTRUNC)
2464           (parallel [(const_int 0) (const_int 1)])))]
2465   "TARGET_SSE"
2466   "cvtps2pi\t{%1, %0|%0, %1}"
2467   [(set_attr "type" "ssecvt")
2468    (set_attr "unit" "mmx")
2469    (set_attr "mode" "DI")])
2470
2471 (define_insn "sse_cvttps2pi"
2472   [(set (match_operand:V2SI 0 "register_operand" "=y")
2473         (vec_select:V2SI
2474           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2475           (parallel [(const_int 0) (const_int 1)])))]
2476   "TARGET_SSE"
2477   "cvttps2pi\t{%1, %0|%0, %1}"
2478   [(set_attr "type" "ssecvt")
2479    (set_attr "unit" "mmx")
2480    (set_attr "prefix_rep" "0")
2481    (set_attr "mode" "SF")])
2482
2483 (define_insn "*avx_cvtsi2ss"
2484   [(set (match_operand:V4SF 0 "register_operand" "=x")
2485         (vec_merge:V4SF
2486           (vec_duplicate:V4SF
2487             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2488           (match_operand:V4SF 1 "register_operand" "x")
2489           (const_int 1)))]
2490   "TARGET_AVX"
2491   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2492   [(set_attr "type" "sseicvt")
2493    (set_attr "prefix" "vex")
2494    (set_attr "mode" "SF")])
2495
2496 (define_insn "sse_cvtsi2ss"
2497   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2498         (vec_merge:V4SF
2499           (vec_duplicate:V4SF
2500             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2501           (match_operand:V4SF 1 "register_operand" "0,0")
2502           (const_int 1)))]
2503   "TARGET_SSE"
2504   "cvtsi2ss\t{%2, %0|%0, %2}"
2505   [(set_attr "type" "sseicvt")
2506    (set_attr "athlon_decode" "vector,double")
2507    (set_attr "amdfam10_decode" "vector,double")
2508    (set_attr "mode" "SF")])
2509
2510 (define_insn "*avx_cvtsi2ssq"
2511   [(set (match_operand:V4SF 0 "register_operand" "=x")
2512         (vec_merge:V4SF
2513           (vec_duplicate:V4SF
2514             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2515           (match_operand:V4SF 1 "register_operand" "x")
2516           (const_int 1)))]
2517   "TARGET_AVX && TARGET_64BIT"
2518   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2519   [(set_attr "type" "sseicvt")
2520    (set_attr "length_vex" "4")
2521    (set_attr "prefix" "vex")
2522    (set_attr "mode" "SF")])
2523
2524 (define_insn "sse_cvtsi2ssq"
2525   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2526         (vec_merge:V4SF
2527           (vec_duplicate:V4SF
2528             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2529           (match_operand:V4SF 1 "register_operand" "0,0")
2530           (const_int 1)))]
2531   "TARGET_SSE && TARGET_64BIT"
2532   "cvtsi2ssq\t{%2, %0|%0, %2}"
2533   [(set_attr "type" "sseicvt")
2534    (set_attr "prefix_rex" "1")
2535    (set_attr "athlon_decode" "vector,double")
2536    (set_attr "amdfam10_decode" "vector,double")
2537    (set_attr "mode" "SF")])
2538
2539 (define_insn "sse_cvtss2si"
2540   [(set (match_operand:SI 0 "register_operand" "=r,r")
2541         (unspec:SI
2542           [(vec_select:SF
2543              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2544              (parallel [(const_int 0)]))]
2545           UNSPEC_FIX_NOTRUNC))]
2546   "TARGET_SSE"
2547   "%vcvtss2si\t{%1, %0|%0, %1}"
2548   [(set_attr "type" "sseicvt")
2549    (set_attr "athlon_decode" "double,vector")
2550    (set_attr "prefix_rep" "1")
2551    (set_attr "prefix" "maybe_vex")
2552    (set_attr "mode" "SI")])
2553
2554 (define_insn "sse_cvtss2si_2"
2555   [(set (match_operand:SI 0 "register_operand" "=r,r")
2556         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2557                    UNSPEC_FIX_NOTRUNC))]
2558   "TARGET_SSE"
2559   "%vcvtss2si\t{%1, %0|%0, %1}"
2560   [(set_attr "type" "sseicvt")
2561    (set_attr "athlon_decode" "double,vector")
2562    (set_attr "amdfam10_decode" "double,double")
2563    (set_attr "prefix_rep" "1")
2564    (set_attr "prefix" "maybe_vex")
2565    (set_attr "mode" "SI")])
2566
2567 (define_insn "sse_cvtss2siq"
2568   [(set (match_operand:DI 0 "register_operand" "=r,r")
2569         (unspec:DI
2570           [(vec_select:SF
2571              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2572              (parallel [(const_int 0)]))]
2573           UNSPEC_FIX_NOTRUNC))]
2574   "TARGET_SSE && TARGET_64BIT"
2575   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2576   [(set_attr "type" "sseicvt")
2577    (set_attr "athlon_decode" "double,vector")
2578    (set_attr "prefix_rep" "1")
2579    (set_attr "prefix" "maybe_vex")
2580    (set_attr "mode" "DI")])
2581
2582 (define_insn "sse_cvtss2siq_2"
2583   [(set (match_operand:DI 0 "register_operand" "=r,r")
2584         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2585                    UNSPEC_FIX_NOTRUNC))]
2586   "TARGET_SSE && TARGET_64BIT"
2587   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2588   [(set_attr "type" "sseicvt")
2589    (set_attr "athlon_decode" "double,vector")
2590    (set_attr "amdfam10_decode" "double,double")
2591    (set_attr "prefix_rep" "1")
2592    (set_attr "prefix" "maybe_vex")
2593    (set_attr "mode" "DI")])
2594
2595 (define_insn "sse_cvttss2si"
2596   [(set (match_operand:SI 0 "register_operand" "=r,r")
2597         (fix:SI
2598           (vec_select:SF
2599             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2600             (parallel [(const_int 0)]))))]
2601   "TARGET_SSE"
2602   "%vcvttss2si\t{%1, %0|%0, %1}"
2603   [(set_attr "type" "sseicvt")
2604    (set_attr "athlon_decode" "double,vector")
2605    (set_attr "amdfam10_decode" "double,double")
2606    (set_attr "prefix_rep" "1")
2607    (set_attr "prefix" "maybe_vex")
2608    (set_attr "mode" "SI")])
2609
2610 (define_insn "sse_cvttss2siq"
2611   [(set (match_operand:DI 0 "register_operand" "=r,r")
2612         (fix:DI
2613           (vec_select:SF
2614             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2615             (parallel [(const_int 0)]))))]
2616   "TARGET_SSE && TARGET_64BIT"
2617   "%vcvttss2si{q}\t{%1, %0|%0, %1}"
2618   [(set_attr "type" "sseicvt")
2619    (set_attr "athlon_decode" "double,vector")
2620    (set_attr "amdfam10_decode" "double,double")
2621    (set_attr "prefix_rep" "1")
2622    (set_attr "prefix" "maybe_vex")
2623    (set_attr "mode" "DI")])
2624
2625 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2626   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2627         (float:AVXMODEDCVTDQ2PS
2628           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2629   "TARGET_AVX"
2630   "vcvtdq2ps\t{%1, %0|%0, %1}"
2631   [(set_attr "type" "ssecvt")
2632    (set_attr "prefix" "vex")
2633    (set_attr "mode" "<avxvecmode>")])
2634
2635 (define_insn "sse2_cvtdq2ps"
2636   [(set (match_operand:V4SF 0 "register_operand" "=x")
2637         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2638   "TARGET_SSE2"
2639   "cvtdq2ps\t{%1, %0|%0, %1}"
2640   [(set_attr "type" "ssecvt")
2641    (set_attr "mode" "V4SF")])
2642
2643 (define_expand "sse2_cvtudq2ps"
2644   [(set (match_dup 5)
2645         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "")))
2646    (set (match_dup 6)
2647         (lt:V4SF (match_dup 5) (match_dup 3)))
2648    (set (match_dup 7)
2649         (and:V4SF (match_dup 6) (match_dup 4)))
2650    (set (match_operand:V4SF 0 "register_operand" "")
2651         (plus:V4SF (match_dup 5) (match_dup 7)))]
2652   "TARGET_SSE2"
2653 {
2654   REAL_VALUE_TYPE TWO32r;
2655   rtx x;
2656   int i;
2657
2658   real_ldexp (&TWO32r, &dconst1, 32);
2659   x = const_double_from_real_value (TWO32r, SFmode);
2660
2661   operands[3] = force_reg (V4SFmode, CONST0_RTX (V4SFmode));
2662   operands[4] = force_reg (V4SFmode, ix86_build_const_vector (SFmode, 1, x));
2663
2664   for (i = 5; i < 8; i++)
2665     operands[i] = gen_reg_rtx (V4SFmode);
2666 })
2667
2668 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2669   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2670         (unspec:AVXMODEDCVTPS2DQ
2671           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2672           UNSPEC_FIX_NOTRUNC))]
2673   "TARGET_AVX"
2674   "vcvtps2dq\t{%1, %0|%0, %1}"
2675   [(set_attr "type" "ssecvt")
2676    (set_attr "prefix" "vex")
2677    (set_attr "mode" "<avxvecmode>")])
2678
2679 (define_insn "sse2_cvtps2dq"
2680   [(set (match_operand:V4SI 0 "register_operand" "=x")
2681         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2682                      UNSPEC_FIX_NOTRUNC))]
2683   "TARGET_SSE2"
2684   "cvtps2dq\t{%1, %0|%0, %1}"
2685   [(set_attr "type" "ssecvt")
2686    (set_attr "prefix_data16" "1")
2687    (set_attr "mode" "TI")])
2688
2689 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2690   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2691         (fix:AVXMODEDCVTPS2DQ
2692           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2693   "TARGET_AVX"
2694   "vcvttps2dq\t{%1, %0|%0, %1}"
2695   [(set_attr "type" "ssecvt")
2696    (set_attr "prefix" "vex")
2697    (set_attr "mode" "<avxvecmode>")])
2698
2699 (define_insn "sse2_cvttps2dq"
2700   [(set (match_operand:V4SI 0 "register_operand" "=x")
2701         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2702   "TARGET_SSE2"
2703   "cvttps2dq\t{%1, %0|%0, %1}"
2704   [(set_attr "type" "ssecvt")
2705    (set_attr "prefix_rep" "1")
2706    (set_attr "prefix_data16" "0")
2707    (set_attr "mode" "TI")])
2708
2709 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2710 ;;
2711 ;; Parallel double-precision floating point conversion operations
2712 ;;
2713 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2714
2715 (define_insn "sse2_cvtpi2pd"
2716   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2717         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2718   "TARGET_SSE2"
2719   "cvtpi2pd\t{%1, %0|%0, %1}"
2720   [(set_attr "type" "ssecvt")
2721    (set_attr "unit" "mmx,*")
2722    (set_attr "prefix_data16" "1,*")
2723    (set_attr "mode" "V2DF")])
2724
2725 (define_insn "sse2_cvtpd2pi"
2726   [(set (match_operand:V2SI 0 "register_operand" "=y")
2727         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2728                      UNSPEC_FIX_NOTRUNC))]
2729   "TARGET_SSE2"
2730   "cvtpd2pi\t{%1, %0|%0, %1}"
2731   [(set_attr "type" "ssecvt")
2732    (set_attr "unit" "mmx")
2733    (set_attr "prefix_data16" "1")
2734    (set_attr "mode" "DI")])
2735
2736 (define_insn "sse2_cvttpd2pi"
2737   [(set (match_operand:V2SI 0 "register_operand" "=y")
2738         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2739   "TARGET_SSE2"
2740   "cvttpd2pi\t{%1, %0|%0, %1}"
2741   [(set_attr "type" "ssecvt")
2742    (set_attr "unit" "mmx")
2743    (set_attr "prefix_data16" "1")
2744    (set_attr "mode" "TI")])
2745
2746 (define_insn "*avx_cvtsi2sd"
2747   [(set (match_operand:V2DF 0 "register_operand" "=x")
2748         (vec_merge:V2DF
2749           (vec_duplicate:V2DF
2750             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2751           (match_operand:V2DF 1 "register_operand" "x")
2752           (const_int 1)))]
2753   "TARGET_AVX"
2754   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2755   [(set_attr "type" "sseicvt")
2756    (set_attr "prefix" "vex")
2757    (set_attr "mode" "DF")])
2758
2759 (define_insn "sse2_cvtsi2sd"
2760   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2761         (vec_merge:V2DF
2762           (vec_duplicate:V2DF
2763             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2764           (match_operand:V2DF 1 "register_operand" "0,0")
2765           (const_int 1)))]
2766   "TARGET_SSE2"
2767   "cvtsi2sd\t{%2, %0|%0, %2}"
2768   [(set_attr "type" "sseicvt")
2769    (set_attr "mode" "DF")
2770    (set_attr "athlon_decode" "double,direct")
2771    (set_attr "amdfam10_decode" "vector,double")])
2772
2773 (define_insn "*avx_cvtsi2sdq"
2774   [(set (match_operand:V2DF 0 "register_operand" "=x")
2775         (vec_merge:V2DF
2776           (vec_duplicate:V2DF
2777             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2778           (match_operand:V2DF 1 "register_operand" "x")
2779           (const_int 1)))]
2780   "TARGET_AVX && TARGET_64BIT"
2781   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2782   [(set_attr "type" "sseicvt")
2783    (set_attr "length_vex" "4")
2784    (set_attr "prefix" "vex")
2785    (set_attr "mode" "DF")])
2786
2787 (define_insn "sse2_cvtsi2sdq"
2788   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2789         (vec_merge:V2DF
2790           (vec_duplicate:V2DF
2791             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2792           (match_operand:V2DF 1 "register_operand" "0,0")
2793           (const_int 1)))]
2794   "TARGET_SSE2 && TARGET_64BIT"
2795   "cvtsi2sdq\t{%2, %0|%0, %2}"
2796   [(set_attr "type" "sseicvt")
2797    (set_attr "prefix_rex" "1")
2798    (set_attr "mode" "DF")
2799    (set_attr "athlon_decode" "double,direct")
2800    (set_attr "amdfam10_decode" "vector,double")])
2801
2802 (define_insn "sse2_cvtsd2si"
2803   [(set (match_operand:SI 0 "register_operand" "=r,r")
2804         (unspec:SI
2805           [(vec_select:DF
2806              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2807              (parallel [(const_int 0)]))]
2808           UNSPEC_FIX_NOTRUNC))]
2809   "TARGET_SSE2"
2810   "%vcvtsd2si\t{%1, %0|%0, %1}"
2811   [(set_attr "type" "sseicvt")
2812    (set_attr "athlon_decode" "double,vector")
2813    (set_attr "prefix_rep" "1")
2814    (set_attr "prefix" "maybe_vex")
2815    (set_attr "mode" "SI")])
2816
2817 (define_insn "sse2_cvtsd2si_2"
2818   [(set (match_operand:SI 0 "register_operand" "=r,r")
2819         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2820                    UNSPEC_FIX_NOTRUNC))]
2821   "TARGET_SSE2"
2822   "%vcvtsd2si\t{%1, %0|%0, %1}"
2823   [(set_attr "type" "sseicvt")
2824    (set_attr "athlon_decode" "double,vector")
2825    (set_attr "amdfam10_decode" "double,double")
2826    (set_attr "prefix_rep" "1")
2827    (set_attr "prefix" "maybe_vex")
2828    (set_attr "mode" "SI")])
2829
2830 (define_insn "sse2_cvtsd2siq"
2831   [(set (match_operand:DI 0 "register_operand" "=r,r")
2832         (unspec:DI
2833           [(vec_select:DF
2834              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2835              (parallel [(const_int 0)]))]
2836           UNSPEC_FIX_NOTRUNC))]
2837   "TARGET_SSE2 && TARGET_64BIT"
2838   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2839   [(set_attr "type" "sseicvt")
2840    (set_attr "athlon_decode" "double,vector")
2841    (set_attr "prefix_rep" "1")
2842    (set_attr "prefix" "maybe_vex")
2843    (set_attr "mode" "DI")])
2844
2845 (define_insn "sse2_cvtsd2siq_2"
2846   [(set (match_operand:DI 0 "register_operand" "=r,r")
2847         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2848                    UNSPEC_FIX_NOTRUNC))]
2849   "TARGET_SSE2 && TARGET_64BIT"
2850   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2851   [(set_attr "type" "sseicvt")
2852    (set_attr "athlon_decode" "double,vector")
2853    (set_attr "amdfam10_decode" "double,double")
2854    (set_attr "prefix_rep" "1")
2855    (set_attr "prefix" "maybe_vex")
2856    (set_attr "mode" "DI")])
2857
2858 (define_insn "sse2_cvttsd2si"
2859   [(set (match_operand:SI 0 "register_operand" "=r,r")
2860         (fix:SI
2861           (vec_select:DF
2862             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2863             (parallel [(const_int 0)]))))]
2864   "TARGET_SSE2"
2865   "%vcvttsd2si\t{%1, %0|%0, %1}"
2866   [(set_attr "type" "sseicvt")
2867    (set_attr "prefix_rep" "1")
2868    (set_attr "prefix" "maybe_vex")
2869    (set_attr "mode" "SI")
2870    (set_attr "athlon_decode" "double,vector")
2871    (set_attr "amdfam10_decode" "double,double")])
2872
2873 (define_insn "sse2_cvttsd2siq"
2874   [(set (match_operand:DI 0 "register_operand" "=r,r")
2875         (fix:DI
2876           (vec_select:DF
2877             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2878             (parallel [(const_int 0)]))))]
2879   "TARGET_SSE2 && TARGET_64BIT"
2880   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2881   [(set_attr "type" "sseicvt")
2882    (set_attr "prefix_rep" "1")
2883    (set_attr "prefix" "maybe_vex")
2884    (set_attr "mode" "DI")
2885    (set_attr "athlon_decode" "double,vector")
2886    (set_attr "amdfam10_decode" "double,double")])
2887
2888 (define_insn "avx_cvtdq2pd256"
2889   [(set (match_operand:V4DF 0 "register_operand" "=x")
2890         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2891   "TARGET_AVX"
2892   "vcvtdq2pd\t{%1, %0|%0, %1}"
2893   [(set_attr "type" "ssecvt")
2894    (set_attr "prefix" "vex")
2895    (set_attr "mode" "V4DF")])
2896
2897 (define_insn "sse2_cvtdq2pd"
2898   [(set (match_operand:V2DF 0 "register_operand" "=x")
2899         (float:V2DF
2900           (vec_select:V2SI
2901             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2902             (parallel [(const_int 0) (const_int 1)]))))]
2903   "TARGET_SSE2"
2904   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2905   [(set_attr "type" "ssecvt")
2906    (set_attr "prefix" "maybe_vex")
2907    (set_attr "mode" "V2DF")])
2908
2909 (define_insn "avx_cvtpd2dq256"
2910   [(set (match_operand:V4SI 0 "register_operand" "=x")
2911         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2912                      UNSPEC_FIX_NOTRUNC))]
2913   "TARGET_AVX"
2914   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2915   [(set_attr "type" "ssecvt")
2916    (set_attr "prefix" "vex")
2917    (set_attr "mode" "OI")])
2918
2919 (define_expand "sse2_cvtpd2dq"
2920   [(set (match_operand:V4SI 0 "register_operand" "")
2921         (vec_concat:V4SI
2922           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2923                        UNSPEC_FIX_NOTRUNC)
2924           (match_dup 2)))]
2925   "TARGET_SSE2"
2926   "operands[2] = CONST0_RTX (V2SImode);")
2927
2928 (define_insn "*sse2_cvtpd2dq"
2929   [(set (match_operand:V4SI 0 "register_operand" "=x")
2930         (vec_concat:V4SI
2931           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2932                        UNSPEC_FIX_NOTRUNC)
2933           (match_operand:V2SI 2 "const0_operand" "")))]
2934   "TARGET_SSE2"
2935   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2936                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2937   [(set_attr "type" "ssecvt")
2938    (set_attr "prefix_rep" "1")
2939    (set_attr "prefix_data16" "0")
2940    (set_attr "prefix" "maybe_vex")
2941    (set_attr "mode" "TI")
2942    (set_attr "amdfam10_decode" "double")])
2943
2944 (define_insn "avx_cvttpd2dq256"
2945   [(set (match_operand:V4SI 0 "register_operand" "=x")
2946         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2947   "TARGET_AVX"
2948   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2949   [(set_attr "type" "ssecvt")
2950    (set_attr "prefix" "vex")
2951    (set_attr "mode" "OI")])
2952
2953 (define_expand "sse2_cvttpd2dq"
2954   [(set (match_operand:V4SI 0 "register_operand" "")
2955         (vec_concat:V4SI
2956           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2957           (match_dup 2)))]
2958   "TARGET_SSE2"
2959   "operands[2] = CONST0_RTX (V2SImode);")
2960
2961 (define_insn "*sse2_cvttpd2dq"
2962   [(set (match_operand:V4SI 0 "register_operand" "=x")
2963         (vec_concat:V4SI
2964           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2965           (match_operand:V2SI 2 "const0_operand" "")))]
2966   "TARGET_SSE2"
2967   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2968                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2969   [(set_attr "type" "ssecvt")
2970    (set_attr "prefix" "maybe_vex")
2971    (set_attr "mode" "TI")
2972    (set_attr "amdfam10_decode" "double")])
2973
2974 (define_insn "*avx_cvtsd2ss"
2975   [(set (match_operand:V4SF 0 "register_operand" "=x")
2976         (vec_merge:V4SF
2977           (vec_duplicate:V4SF
2978             (float_truncate:V2SF
2979               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2980           (match_operand:V4SF 1 "register_operand" "x")
2981           (const_int 1)))]
2982   "TARGET_AVX"
2983   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2984   [(set_attr "type" "ssecvt")
2985    (set_attr "prefix" "vex")
2986    (set_attr "mode" "SF")])
2987
2988 (define_insn "sse2_cvtsd2ss"
2989   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2990         (vec_merge:V4SF
2991           (vec_duplicate:V4SF
2992             (float_truncate:V2SF
2993               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2994           (match_operand:V4SF 1 "register_operand" "0,0")
2995           (const_int 1)))]
2996   "TARGET_SSE2"
2997   "cvtsd2ss\t{%2, %0|%0, %2}"
2998   [(set_attr "type" "ssecvt")
2999    (set_attr "athlon_decode" "vector,double")
3000    (set_attr "amdfam10_decode" "vector,double")
3001    (set_attr "mode" "SF")])
3002
3003 (define_insn "*avx_cvtss2sd"
3004   [(set (match_operand:V2DF 0 "register_operand" "=x")
3005         (vec_merge:V2DF
3006           (float_extend:V2DF
3007             (vec_select:V2SF
3008               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
3009               (parallel [(const_int 0) (const_int 1)])))
3010           (match_operand:V2DF 1 "register_operand" "x")
3011           (const_int 1)))]
3012   "TARGET_AVX"
3013   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
3014   [(set_attr "type" "ssecvt")
3015    (set_attr "prefix" "vex")
3016    (set_attr "mode" "DF")])
3017
3018 (define_insn "sse2_cvtss2sd"
3019   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
3020         (vec_merge:V2DF
3021           (float_extend:V2DF
3022             (vec_select:V2SF
3023               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
3024               (parallel [(const_int 0) (const_int 1)])))
3025           (match_operand:V2DF 1 "register_operand" "0,0")
3026           (const_int 1)))]
3027   "TARGET_SSE2"
3028   "cvtss2sd\t{%2, %0|%0, %2}"
3029   [(set_attr "type" "ssecvt")
3030    (set_attr "amdfam10_decode" "vector,double")
3031    (set_attr "mode" "DF")])
3032
3033 (define_insn "avx_cvtpd2ps256"
3034   [(set (match_operand:V4SF 0 "register_operand" "=x")
3035         (float_truncate:V4SF
3036           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
3037   "TARGET_AVX"
3038   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
3039   [(set_attr "type" "ssecvt")
3040    (set_attr "prefix" "vex")
3041    (set_attr "mode" "V4SF")])
3042
3043 (define_expand "sse2_cvtpd2ps"
3044   [(set (match_operand:V4SF 0 "register_operand" "")
3045         (vec_concat:V4SF
3046           (float_truncate:V2SF
3047             (match_operand:V2DF 1 "nonimmediate_operand" ""))
3048           (match_dup 2)))]
3049   "TARGET_SSE2"
3050   "operands[2] = CONST0_RTX (V2SFmode);")
3051
3052 (define_insn "*sse2_cvtpd2ps"
3053   [(set (match_operand:V4SF 0 "register_operand" "=x")
3054         (vec_concat:V4SF
3055           (float_truncate:V2SF
3056             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
3057           (match_operand:V2SF 2 "const0_operand" "")))]
3058   "TARGET_SSE2"
3059   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
3060                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
3061   [(set_attr "type" "ssecvt")
3062    (set_attr "prefix_data16" "1")
3063    (set_attr "prefix" "maybe_vex")
3064    (set_attr "mode" "V4SF")
3065    (set_attr "amdfam10_decode" "double")])
3066
3067 (define_insn "avx_cvtps2pd256"
3068   [(set (match_operand:V4DF 0 "register_operand" "=x")
3069         (float_extend:V4DF
3070           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3071   "TARGET_AVX"
3072   "vcvtps2pd\t{%1, %0|%0, %1}"
3073   [(set_attr "type" "ssecvt")
3074    (set_attr "prefix" "vex")
3075    (set_attr "mode" "V4DF")])
3076
3077 (define_insn "sse2_cvtps2pd"
3078   [(set (match_operand:V2DF 0 "register_operand" "=x")
3079         (float_extend:V2DF
3080           (vec_select:V2SF
3081             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3082             (parallel [(const_int 0) (const_int 1)]))))]
3083   "TARGET_SSE2"
3084   "%vcvtps2pd\t{%1, %0|%0, %1}"
3085   [(set_attr "type" "ssecvt")
3086    (set_attr "prefix" "maybe_vex")
3087    (set_attr "mode" "V2DF")
3088    (set_attr "prefix_data16" "0")
3089    (set_attr "amdfam10_decode" "direct")])
3090
3091 (define_expand "vec_unpacks_hi_v4sf"
3092   [(set (match_dup 2)
3093    (vec_select:V4SF
3094      (vec_concat:V8SF
3095        (match_dup 2)
3096        (match_operand:V4SF 1 "nonimmediate_operand" ""))
3097      (parallel [(const_int 6)
3098                 (const_int 7)
3099                 (const_int 2)
3100                 (const_int 3)])))
3101   (set (match_operand:V2DF 0 "register_operand" "")
3102    (float_extend:V2DF
3103      (vec_select:V2SF
3104        (match_dup 2)
3105        (parallel [(const_int 0) (const_int 1)]))))]
3106  "TARGET_SSE2"
3107 {
3108  operands[2] = gen_reg_rtx (V4SFmode);
3109 })
3110
3111 (define_expand "vec_unpacks_lo_v4sf"
3112   [(set (match_operand:V2DF 0 "register_operand" "")
3113         (float_extend:V2DF
3114           (vec_select:V2SF
3115             (match_operand:V4SF 1 "nonimmediate_operand" "")
3116             (parallel [(const_int 0) (const_int 1)]))))]
3117   "TARGET_SSE2")
3118
3119 (define_expand "vec_unpacks_float_hi_v8hi"
3120   [(match_operand:V4SF 0 "register_operand" "")
3121    (match_operand:V8HI 1 "register_operand" "")]
3122   "TARGET_SSE2"
3123 {
3124   rtx tmp = gen_reg_rtx (V4SImode);
3125
3126   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
3127   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3128   DONE;
3129 })
3130
3131 (define_expand "vec_unpacks_float_lo_v8hi"
3132   [(match_operand:V4SF 0 "register_operand" "")
3133    (match_operand:V8HI 1 "register_operand" "")]
3134   "TARGET_SSE2"
3135 {
3136   rtx tmp = gen_reg_rtx (V4SImode);
3137
3138   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
3139   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3140   DONE;
3141 })
3142
3143 (define_expand "vec_unpacku_float_hi_v8hi"
3144   [(match_operand:V4SF 0 "register_operand" "")
3145    (match_operand:V8HI 1 "register_operand" "")]
3146   "TARGET_SSE2"
3147 {
3148   rtx tmp = gen_reg_rtx (V4SImode);
3149
3150   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
3151   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3152   DONE;
3153 })
3154
3155 (define_expand "vec_unpacku_float_lo_v8hi"
3156   [(match_operand:V4SF 0 "register_operand" "")
3157    (match_operand:V8HI 1 "register_operand" "")]
3158   "TARGET_SSE2"
3159 {
3160   rtx tmp = gen_reg_rtx (V4SImode);
3161
3162   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
3163   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
3164   DONE;
3165 })
3166
3167 (define_expand "vec_unpacks_float_hi_v4si"
3168   [(set (match_dup 2)
3169         (vec_select:V4SI
3170           (match_operand:V4SI 1 "nonimmediate_operand" "")
3171           (parallel [(const_int 2)
3172                      (const_int 3)
3173                      (const_int 2)
3174                      (const_int 3)])))
3175    (set (match_operand:V2DF 0 "register_operand" "")
3176         (float:V2DF
3177           (vec_select:V2SI
3178           (match_dup 2)
3179             (parallel [(const_int 0) (const_int 1)]))))]
3180  "TARGET_SSE2"
3181  "operands[2] = gen_reg_rtx (V4SImode);")
3182
3183 (define_expand "vec_unpacks_float_lo_v4si"
3184   [(set (match_operand:V2DF 0 "register_operand" "")
3185         (float:V2DF
3186           (vec_select:V2SI
3187             (match_operand:V4SI 1 "nonimmediate_operand" "")
3188             (parallel [(const_int 0) (const_int 1)]))))]
3189   "TARGET_SSE2")
3190
3191 (define_expand "vec_unpacku_float_hi_v4si"
3192   [(set (match_dup 5)
3193         (vec_select:V4SI
3194           (match_operand:V4SI 1 "nonimmediate_operand" "")
3195           (parallel [(const_int 2)
3196                      (const_int 3)
3197                      (const_int 2)
3198                      (const_int 3)])))
3199    (set (match_dup 6)
3200         (float:V2DF
3201           (vec_select:V2SI
3202           (match_dup 5)
3203             (parallel [(const_int 0) (const_int 1)]))))
3204    (set (match_dup 7)
3205         (lt:V2DF (match_dup 6) (match_dup 3)))
3206    (set (match_dup 8)
3207         (and:V2DF (match_dup 7) (match_dup 4)))
3208    (set (match_operand:V2DF 0 "register_operand" "")
3209         (plus:V2DF (match_dup 6) (match_dup 8)))]
3210  "TARGET_SSE2"
3211 {
3212   REAL_VALUE_TYPE TWO32r;
3213   rtx x;
3214   int i;
3215
3216   real_ldexp (&TWO32r, &dconst1, 32);
3217   x = const_double_from_real_value (TWO32r, DFmode);
3218
3219   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3220   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3221
3222   operands[5] = gen_reg_rtx (V4SImode);
3223
3224   for (i = 6; i < 9; i++)
3225     operands[i] = gen_reg_rtx (V2DFmode);
3226 })
3227
3228 (define_expand "vec_unpacku_float_lo_v4si"
3229   [(set (match_dup 5)
3230         (float:V2DF
3231           (vec_select:V2SI
3232             (match_operand:V4SI 1 "nonimmediate_operand" "")
3233             (parallel [(const_int 0) (const_int 1)]))))
3234    (set (match_dup 6)
3235         (lt:V2DF (match_dup 5) (match_dup 3)))
3236    (set (match_dup 7)
3237         (and:V2DF (match_dup 6) (match_dup 4)))
3238    (set (match_operand:V2DF 0 "register_operand" "")
3239         (plus:V2DF (match_dup 5) (match_dup 7)))]
3240   "TARGET_SSE2"
3241 {
3242   REAL_VALUE_TYPE TWO32r;
3243   rtx x;
3244   int i;
3245
3246   real_ldexp (&TWO32r, &dconst1, 32);
3247   x = const_double_from_real_value (TWO32r, DFmode);
3248
3249   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3250   operands[4] = force_reg (V2DFmode, ix86_build_const_vector (DFmode, 1, x));
3251
3252   for (i = 5; i < 8; i++)
3253     operands[i] = gen_reg_rtx (V2DFmode);
3254 })
3255
3256 (define_expand "vec_pack_trunc_v2df"
3257   [(match_operand:V4SF 0 "register_operand" "")
3258    (match_operand:V2DF 1 "nonimmediate_operand" "")
3259    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3260   "TARGET_SSE2"
3261 {
3262   rtx r1, r2;
3263
3264   r1 = gen_reg_rtx (V4SFmode);
3265   r2 = gen_reg_rtx (V4SFmode);
3266
3267   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
3268   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
3269   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
3270   DONE;
3271 })
3272
3273 (define_expand "vec_pack_sfix_trunc_v2df"
3274   [(match_operand:V4SI 0 "register_operand" "")
3275    (match_operand:V2DF 1 "nonimmediate_operand" "")
3276    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3277   "TARGET_SSE2"
3278 {
3279   rtx r1, r2;
3280
3281   r1 = gen_reg_rtx (V4SImode);
3282   r2 = gen_reg_rtx (V4SImode);
3283
3284   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
3285   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
3286   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3287                                          gen_lowpart (V2DImode, r1),
3288                                          gen_lowpart (V2DImode, r2)));
3289   DONE;
3290 })
3291
3292 (define_expand "vec_pack_sfix_v2df"
3293   [(match_operand:V4SI 0 "register_operand" "")
3294    (match_operand:V2DF 1 "nonimmediate_operand" "")
3295    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3296   "TARGET_SSE2"
3297 {
3298   rtx r1, r2;
3299
3300   r1 = gen_reg_rtx (V4SImode);
3301   r2 = gen_reg_rtx (V4SImode);
3302
3303   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
3304   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
3305   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3306                                          gen_lowpart (V2DImode, r1),
3307                                          gen_lowpart (V2DImode, r2)));
3308   DONE;
3309 })
3310
3311 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3312 ;;
3313 ;; Parallel single-precision floating point element swizzling
3314 ;;
3315 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3316
3317 (define_expand "sse_movhlps_exp"
3318   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3319         (vec_select:V4SF
3320           (vec_concat:V8SF
3321             (match_operand:V4SF 1 "nonimmediate_operand" "")
3322             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3323           (parallel [(const_int 6)
3324                      (const_int 7)
3325                      (const_int 2)
3326                      (const_int 3)])))]
3327   "TARGET_SSE"
3328   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3329
3330 (define_insn "*avx_movhlps"
3331   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3332         (vec_select:V4SF
3333           (vec_concat:V8SF
3334             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3335             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3336           (parallel [(const_int 6)
3337                      (const_int 7)
3338                      (const_int 2)
3339                      (const_int 3)])))]
3340   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3341   "@
3342    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3343    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3344    vmovhps\t{%2, %0|%0, %2}"
3345   [(set_attr "type" "ssemov")
3346    (set_attr "prefix" "vex")
3347    (set_attr "mode" "V4SF,V2SF,V2SF")])
3348
3349 (define_insn "sse_movhlps"
3350   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3351         (vec_select:V4SF
3352           (vec_concat:V8SF
3353             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3354             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3355           (parallel [(const_int 6)
3356                      (const_int 7)
3357                      (const_int 2)
3358                      (const_int 3)])))]
3359   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3360   "@
3361    movhlps\t{%2, %0|%0, %2}
3362    movlps\t{%H2, %0|%0, %H2}
3363    movhps\t{%2, %0|%0, %2}"
3364   [(set_attr "type" "ssemov")
3365    (set_attr "mode" "V4SF,V2SF,V2SF")])
3366
3367 (define_expand "sse_movlhps_exp"
3368   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3369         (vec_select:V4SF
3370           (vec_concat:V8SF
3371             (match_operand:V4SF 1 "nonimmediate_operand" "")
3372             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3373           (parallel [(const_int 0)
3374                      (const_int 1)
3375                      (const_int 4)
3376                      (const_int 5)])))]
3377   "TARGET_SSE"
3378   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3379
3380 (define_insn "*avx_movlhps"
3381   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3382         (vec_select:V4SF
3383           (vec_concat:V8SF
3384             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3385             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3386           (parallel [(const_int 0)
3387                      (const_int 1)
3388                      (const_int 4)
3389                      (const_int 5)])))]
3390   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3391   "@
3392    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3393    vmovhps\t{%2, %1, %0|%0, %1, %2}
3394    vmovlps\t{%2, %H0|%H0, %2}"
3395   [(set_attr "type" "ssemov")
3396    (set_attr "prefix" "vex")
3397    (set_attr "mode" "V4SF,V2SF,V2SF")])
3398
3399 (define_insn "sse_movlhps"
3400   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3401         (vec_select:V4SF
3402           (vec_concat:V8SF
3403             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3404             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3405           (parallel [(const_int 0)
3406                      (const_int 1)
3407                      (const_int 4)
3408                      (const_int 5)])))]
3409   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3410   "@
3411    movlhps\t{%2, %0|%0, %2}
3412    movhps\t{%2, %0|%0, %2}
3413    movlps\t{%2, %H0|%H0, %2}"
3414   [(set_attr "type" "ssemov")
3415    (set_attr "mode" "V4SF,V2SF,V2SF")])
3416
3417 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3418 (define_insn "avx_unpckhps256"
3419   [(set (match_operand:V8SF 0 "register_operand" "=x")
3420         (vec_select:V8SF
3421           (vec_concat:V16SF
3422             (match_operand:V8SF 1 "register_operand" "x")
3423             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3424           (parallel [(const_int 2) (const_int 10)
3425                      (const_int 3) (const_int 11)
3426                      (const_int 6) (const_int 14)
3427                      (const_int 7) (const_int 15)])))]
3428   "TARGET_AVX"
3429   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3430   [(set_attr "type" "sselog")
3431    (set_attr "prefix" "vex")
3432    (set_attr "mode" "V8SF")])
3433
3434 (define_insn "*avx_interleave_highv4sf"
3435   [(set (match_operand:V4SF 0 "register_operand" "=x")
3436         (vec_select:V4SF
3437           (vec_concat:V8SF
3438             (match_operand:V4SF 1 "register_operand" "x")
3439             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3440           (parallel [(const_int 2) (const_int 6)
3441                      (const_int 3) (const_int 7)])))]
3442   "TARGET_AVX"
3443   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3444   [(set_attr "type" "sselog")
3445    (set_attr "prefix" "vex")
3446    (set_attr "mode" "V4SF")])
3447
3448 (define_insn "vec_interleave_highv4sf"
3449   [(set (match_operand:V4SF 0 "register_operand" "=x")
3450         (vec_select:V4SF
3451           (vec_concat:V8SF
3452             (match_operand:V4SF 1 "register_operand" "0")
3453             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3454           (parallel [(const_int 2) (const_int 6)
3455                      (const_int 3) (const_int 7)])))]
3456   "TARGET_SSE"
3457   "unpckhps\t{%2, %0|%0, %2}"
3458   [(set_attr "type" "sselog")
3459    (set_attr "mode" "V4SF")])
3460
3461 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3462 (define_insn "avx_unpcklps256"
3463   [(set (match_operand:V8SF 0 "register_operand" "=x")
3464         (vec_select:V8SF
3465           (vec_concat:V16SF
3466             (match_operand:V8SF 1 "register_operand" "x")
3467             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3468           (parallel [(const_int 0) (const_int 8)
3469                      (const_int 1) (const_int 9)
3470                      (const_int 4) (const_int 12)
3471                      (const_int 5) (const_int 13)])))]
3472   "TARGET_AVX"
3473   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3474   [(set_attr "type" "sselog")
3475    (set_attr "prefix" "vex")
3476    (set_attr "mode" "V8SF")])
3477
3478 (define_insn "*avx_interleave_lowv4sf"
3479   [(set (match_operand:V4SF 0 "register_operand" "=x")
3480         (vec_select:V4SF
3481           (vec_concat:V8SF
3482             (match_operand:V4SF 1 "register_operand" "x")
3483             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3484           (parallel [(const_int 0) (const_int 4)
3485                      (const_int 1) (const_int 5)])))]
3486   "TARGET_AVX"
3487   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3488   [(set_attr "type" "sselog")
3489    (set_attr "prefix" "vex")
3490    (set_attr "mode" "V4SF")])
3491
3492 (define_insn "vec_interleave_lowv4sf"
3493   [(set (match_operand:V4SF 0 "register_operand" "=x")
3494         (vec_select:V4SF
3495           (vec_concat:V8SF
3496             (match_operand:V4SF 1 "register_operand" "0")
3497             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3498           (parallel [(const_int 0) (const_int 4)
3499                      (const_int 1) (const_int 5)])))]
3500   "TARGET_SSE"
3501   "unpcklps\t{%2, %0|%0, %2}"
3502   [(set_attr "type" "sselog")
3503    (set_attr "mode" "V4SF")])
3504
3505 ;; These are modeled with the same vec_concat as the others so that we
3506 ;; capture users of shufps that can use the new instructions
3507 (define_insn "avx_movshdup256"
3508   [(set (match_operand:V8SF 0 "register_operand" "=x")
3509         (vec_select:V8SF
3510           (vec_concat:V16SF
3511             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3512             (match_dup 1))
3513           (parallel [(const_int 1) (const_int 1)
3514                      (const_int 3) (const_int 3)
3515                      (const_int 5) (const_int 5)
3516                      (const_int 7) (const_int 7)])))]
3517   "TARGET_AVX"
3518   "vmovshdup\t{%1, %0|%0, %1}"
3519   [(set_attr "type" "sse")
3520    (set_attr "prefix" "vex")
3521    (set_attr "mode" "V8SF")])
3522
3523 (define_insn "sse3_movshdup"
3524   [(set (match_operand:V4SF 0 "register_operand" "=x")
3525         (vec_select:V4SF
3526           (vec_concat:V8SF
3527             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3528             (match_dup 1))
3529           (parallel [(const_int 1)
3530                      (const_int 1)
3531                      (const_int 7)
3532                      (const_int 7)])))]
3533   "TARGET_SSE3"
3534   "%vmovshdup\t{%1, %0|%0, %1}"
3535   [(set_attr "type" "sse")
3536    (set_attr "prefix_rep" "1")
3537    (set_attr "prefix" "maybe_vex")
3538    (set_attr "mode" "V4SF")])
3539
3540 (define_insn "avx_movsldup256"
3541   [(set (match_operand:V8SF 0 "register_operand" "=x")
3542         (vec_select:V8SF
3543           (vec_concat:V16SF
3544             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3545             (match_dup 1))
3546           (parallel [(const_int 0) (const_int 0)
3547                      (const_int 2) (const_int 2)
3548                      (const_int 4) (const_int 4)
3549                      (const_int 6) (const_int 6)])))]
3550   "TARGET_AVX"
3551   "vmovsldup\t{%1, %0|%0, %1}"
3552   [(set_attr "type" "sse")
3553    (set_attr "prefix" "vex")
3554    (set_attr "mode" "V8SF")])
3555
3556 (define_insn "sse3_movsldup"
3557   [(set (match_operand:V4SF 0 "register_operand" "=x")
3558         (vec_select:V4SF
3559           (vec_concat:V8SF
3560             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3561             (match_dup 1))
3562           (parallel [(const_int 0)
3563                      (const_int 0)
3564                      (const_int 6)
3565                      (const_int 6)])))]
3566   "TARGET_SSE3"
3567   "%vmovsldup\t{%1, %0|%0, %1}"
3568   [(set_attr "type" "sse")
3569    (set_attr "prefix_rep" "1")
3570    (set_attr "prefix" "maybe_vex")
3571    (set_attr "mode" "V4SF")])
3572
3573 (define_expand "avx_shufps256"
3574   [(match_operand:V8SF 0 "register_operand" "")
3575    (match_operand:V8SF 1 "register_operand" "")
3576    (match_operand:V8SF 2 "nonimmediate_operand" "")
3577    (match_operand:SI 3 "const_int_operand" "")]
3578   "TARGET_AVX"
3579 {
3580   int mask = INTVAL (operands[3]);
3581   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3582                                   GEN_INT ((mask >> 0) & 3),
3583                                   GEN_INT ((mask >> 2) & 3),
3584                                   GEN_INT (((mask >> 4) & 3) + 8),
3585                                   GEN_INT (((mask >> 6) & 3) + 8),
3586                                   GEN_INT (((mask >> 0) & 3) + 4),
3587                                   GEN_INT (((mask >> 2) & 3) + 4),
3588                                   GEN_INT (((mask >> 4) & 3) + 12),
3589                                   GEN_INT (((mask >> 6) & 3) + 12)));
3590   DONE;
3591 })
3592
3593 ;; One bit in mask selects 2 elements.
3594 (define_insn "avx_shufps256_1"
3595   [(set (match_operand:V8SF 0 "register_operand" "=x")
3596         (vec_select:V8SF
3597           (vec_concat:V16SF
3598             (match_operand:V8SF 1 "register_operand" "x")
3599             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3600           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3601                      (match_operand 4  "const_0_to_3_operand"   "")
3602                      (match_operand 5  "const_8_to_11_operand"  "")
3603                      (match_operand 6  "const_8_to_11_operand"  "")
3604                      (match_operand 7  "const_4_to_7_operand"   "")
3605                      (match_operand 8  "const_4_to_7_operand"   "")
3606                      (match_operand 9  "const_12_to_15_operand" "")
3607                      (match_operand 10 "const_12_to_15_operand" "")])))]
3608   "TARGET_AVX
3609    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3610        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3611        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3612        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3613 {
3614   int mask;
3615   mask = INTVAL (operands[3]);
3616   mask |= INTVAL (operands[4]) << 2;
3617   mask |= (INTVAL (operands[5]) - 8) << 4;
3618   mask |= (INTVAL (operands[6]) - 8) << 6;
3619   operands[3] = GEN_INT (mask);
3620
3621   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3622 }
3623   [(set_attr "type" "sselog")
3624    (set_attr "length_immediate" "1")
3625    (set_attr "prefix" "vex")
3626    (set_attr "mode" "V8SF")])
3627
3628 (define_expand "sse_shufps"
3629   [(match_operand:V4SF 0 "register_operand" "")
3630    (match_operand:V4SF 1 "register_operand" "")
3631    (match_operand:V4SF 2 "nonimmediate_operand" "")
3632    (match_operand:SI 3 "const_int_operand" "")]
3633   "TARGET_SSE"
3634 {
3635   int mask = INTVAL (operands[3]);
3636   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3637                                GEN_INT ((mask >> 0) & 3),
3638                                GEN_INT ((mask >> 2) & 3),
3639                                GEN_INT (((mask >> 4) & 3) + 4),
3640                                GEN_INT (((mask >> 6) & 3) + 4)));
3641   DONE;
3642 })
3643
3644 (define_insn "*avx_shufps_<mode>"
3645   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3646         (vec_select:SSEMODE4S
3647           (vec_concat:<ssedoublesizemode>
3648             (match_operand:SSEMODE4S 1 "register_operand" "x")
3649             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3650           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3651                      (match_operand 4 "const_0_to_3_operand" "")
3652                      (match_operand 5 "const_4_to_7_operand" "")
3653                      (match_operand 6 "const_4_to_7_operand" "")])))]
3654   "TARGET_AVX"
3655 {
3656   int mask = 0;
3657   mask |= INTVAL (operands[3]) << 0;
3658   mask |= INTVAL (operands[4]) << 2;
3659   mask |= (INTVAL (operands[5]) - 4) << 4;
3660   mask |= (INTVAL (operands[6]) - 4) << 6;
3661   operands[3] = GEN_INT (mask);
3662
3663   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3664 }
3665   [(set_attr "type" "sselog")
3666    (set_attr "length_immediate" "1")
3667    (set_attr "prefix" "vex")
3668    (set_attr "mode" "V4SF")])
3669
3670 (define_insn "sse_shufps_<mode>"
3671   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3672         (vec_select:SSEMODE4S
3673           (vec_concat:<ssedoublesizemode>
3674             (match_operand:SSEMODE4S 1 "register_operand" "0")
3675             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3676           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3677                      (match_operand 4 "const_0_to_3_operand" "")
3678                      (match_operand 5 "const_4_to_7_operand" "")
3679                      (match_operand 6 "const_4_to_7_operand" "")])))]
3680   "TARGET_SSE"
3681 {
3682   int mask = 0;
3683   mask |= INTVAL (operands[3]) << 0;
3684   mask |= INTVAL (operands[4]) << 2;
3685   mask |= (INTVAL (operands[5]) - 4) << 4;
3686   mask |= (INTVAL (operands[6]) - 4) << 6;
3687   operands[3] = GEN_INT (mask);
3688
3689   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3690 }
3691   [(set_attr "type" "sselog")
3692    (set_attr "length_immediate" "1")
3693    (set_attr "mode" "V4SF")])
3694
3695 (define_insn "sse_storehps"
3696   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3697         (vec_select:V2SF
3698           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3699           (parallel [(const_int 2) (const_int 3)])))]
3700   "TARGET_SSE"
3701   "@
3702    %vmovhps\t{%1, %0|%0, %1}
3703    %vmovhlps\t{%1, %d0|%d0, %1}
3704    %vmovlps\t{%H1, %d0|%d0, %H1}"
3705   [(set_attr "type" "ssemov")
3706    (set_attr "prefix" "maybe_vex")
3707    (set_attr "mode" "V2SF,V4SF,V2SF")])
3708
3709 (define_expand "sse_loadhps_exp"
3710   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3711         (vec_concat:V4SF
3712           (vec_select:V2SF
3713             (match_operand:V4SF 1 "nonimmediate_operand" "")
3714             (parallel [(const_int 0) (const_int 1)]))
3715           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3716   "TARGET_SSE"
3717   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3718
3719 (define_insn "*avx_loadhps"
3720   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3721         (vec_concat:V4SF
3722           (vec_select:V2SF
3723             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3724             (parallel [(const_int 0) (const_int 1)]))
3725           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3726   "TARGET_AVX"
3727   "@
3728    vmovhps\t{%2, %1, %0|%0, %1, %2}
3729    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3730    vmovlps\t{%2, %H0|%H0, %2}"
3731   [(set_attr "type" "ssemov")
3732    (set_attr "prefix" "vex")
3733    (set_attr "mode" "V2SF,V4SF,V2SF")])
3734
3735 (define_insn "sse_loadhps"
3736   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3737         (vec_concat:V4SF
3738           (vec_select:V2SF
3739             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3740             (parallel [(const_int 0) (const_int 1)]))
3741           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3742   "TARGET_SSE"
3743   "@
3744    movhps\t{%2, %0|%0, %2}
3745    movlhps\t{%2, %0|%0, %2}
3746    movlps\t{%2, %H0|%H0, %2}"
3747   [(set_attr "type" "ssemov")
3748    (set_attr "mode" "V2SF,V4SF,V2SF")])
3749
3750 (define_insn "*avx_storelps"
3751   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3752         (vec_select:V2SF
3753           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3754           (parallel [(const_int 0) (const_int 1)])))]
3755   "TARGET_AVX"
3756   "@
3757    vmovlps\t{%1, %0|%0, %1}
3758    vmovaps\t{%1, %0|%0, %1}
3759    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3760   [(set_attr "type" "ssemov")
3761    (set_attr "prefix" "vex")
3762    (set_attr "mode" "V2SF,V2DF,V2SF")])
3763
3764 (define_insn "sse_storelps"
3765   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3766         (vec_select:V2SF
3767           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3768           (parallel [(const_int 0) (const_int 1)])))]
3769   "TARGET_SSE"
3770   "@
3771    movlps\t{%1, %0|%0, %1}
3772    movaps\t{%1, %0|%0, %1}
3773    movlps\t{%1, %0|%0, %1}"
3774   [(set_attr "type" "ssemov")
3775    (set_attr "mode" "V2SF,V4SF,V2SF")])
3776
3777 (define_expand "sse_loadlps_exp"
3778   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3779         (vec_concat:V4SF
3780           (match_operand:V2SF 2 "nonimmediate_operand" "")
3781           (vec_select:V2SF
3782             (match_operand:V4SF 1 "nonimmediate_operand" "")
3783             (parallel [(const_int 2) (const_int 3)]))))]
3784   "TARGET_SSE"
3785   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3786
3787 (define_insn "*avx_loadlps"
3788   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3789         (vec_concat:V4SF
3790           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3791           (vec_select:V2SF
3792             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3793             (parallel [(const_int 2) (const_int 3)]))))]
3794   "TARGET_AVX"
3795   "@
3796    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3797    vmovlps\t{%2, %1, %0|%0, %1, %2}
3798    vmovlps\t{%2, %0|%0, %2}"
3799   [(set_attr "type" "sselog,ssemov,ssemov")
3800    (set_attr "length_immediate" "1,*,*")
3801    (set_attr "prefix" "vex")
3802    (set_attr "mode" "V4SF,V2SF,V2SF")])
3803
3804 (define_insn "sse_loadlps"
3805   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3806         (vec_concat:V4SF
3807           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3808           (vec_select:V2SF
3809             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3810             (parallel [(const_int 2) (const_int 3)]))))]
3811   "TARGET_SSE"
3812   "@
3813    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3814    movlps\t{%2, %0|%0, %2}
3815    movlps\t{%2, %0|%0, %2}"
3816   [(set_attr "type" "sselog,ssemov,ssemov")
3817    (set_attr "length_immediate" "1,*,*")
3818    (set_attr "mode" "V4SF,V2SF,V2SF")])
3819
3820 (define_insn "*avx_movss"
3821   [(set (match_operand:V4SF 0 "register_operand" "=x")
3822         (vec_merge:V4SF
3823           (match_operand:V4SF 2 "register_operand" "x")
3824           (match_operand:V4SF 1 "register_operand" "x")
3825           (const_int 1)))]
3826   "TARGET_AVX"
3827   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3828   [(set_attr "type" "ssemov")
3829    (set_attr "prefix" "vex")
3830    (set_attr "mode" "SF")])
3831
3832 (define_insn "sse_movss"
3833   [(set (match_operand:V4SF 0 "register_operand" "=x")
3834         (vec_merge:V4SF
3835           (match_operand:V4SF 2 "register_operand" "x")
3836           (match_operand:V4SF 1 "register_operand" "0")
3837           (const_int 1)))]
3838   "TARGET_SSE"
3839   "movss\t{%2, %0|%0, %2}"
3840   [(set_attr "type" "ssemov")
3841    (set_attr "mode" "SF")])
3842
3843 (define_expand "vec_dupv4sf"
3844   [(set (match_operand:V4SF 0 "register_operand" "")
3845         (vec_duplicate:V4SF
3846           (match_operand:SF 1 "nonimmediate_operand" "")))]
3847   "TARGET_SSE"
3848 {
3849   if (!TARGET_AVX)
3850     operands[1] = force_reg (V4SFmode, operands[1]);
3851 })
3852
3853 (define_insn "*vec_dupv4sf_avx"
3854   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3855         (vec_duplicate:V4SF
3856           (match_operand:SF 1 "nonimmediate_operand" "x,m")))]
3857   "TARGET_AVX"
3858   "@
3859    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
3860    vbroadcastss\t{%1, %0|%0, %1}"
3861   [(set_attr "type" "sselog1,ssemov")
3862    (set_attr "length_immediate" "1,0")
3863    (set_attr "prefix_extra" "0,1")
3864    (set_attr "prefix" "vex")
3865    (set_attr "mode" "V4SF")])
3866
3867 (define_insn "*vec_dupv4sf"
3868   [(set (match_operand:V4SF 0 "register_operand" "=x")
3869         (vec_duplicate:V4SF
3870           (match_operand:SF 1 "register_operand" "0")))]
3871   "TARGET_SSE"
3872   "shufps\t{$0, %0, %0|%0, %0, 0}"
3873   [(set_attr "type" "sselog1")
3874    (set_attr "length_immediate" "1")
3875    (set_attr "mode" "V4SF")])
3876
3877 (define_insn "*vec_concatv2sf_avx"
3878   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3879         (vec_concat:V2SF
3880           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3881           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3882   "TARGET_AVX"
3883   "@
3884    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3885    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3886    vmovss\t{%1, %0|%0, %1}
3887    punpckldq\t{%2, %0|%0, %2}
3888    movd\t{%1, %0|%0, %1}"
3889   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3890    (set_attr "length_immediate" "*,1,*,*,*")
3891    (set_attr "prefix_extra" "*,1,*,*,*")
3892    (set (attr "prefix")
3893      (if_then_else (eq_attr "alternative" "3,4")
3894        (const_string "orig")
3895        (const_string "vex")))
3896    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3897
3898 ;; Although insertps takes register source, we prefer
3899 ;; unpcklps with register source since it is shorter.
3900 (define_insn "*vec_concatv2sf_sse4_1"
3901   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3902         (vec_concat:V2SF
3903           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3904           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3905   "TARGET_SSE4_1"
3906   "@
3907    unpcklps\t{%2, %0|%0, %2}
3908    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3909    movss\t{%1, %0|%0, %1}
3910    punpckldq\t{%2, %0|%0, %2}
3911    movd\t{%1, %0|%0, %1}"
3912   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3913    (set_attr "prefix_data16" "*,1,*,*,*")
3914    (set_attr "prefix_extra" "*,1,*,*,*")
3915    (set_attr "length_immediate" "*,1,*,*,*")
3916    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3917
3918 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3919 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3920 ;; alternatives pretty much forces the MMX alternative to be chosen.
3921 (define_insn "*vec_concatv2sf_sse"
3922   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3923         (vec_concat:V2SF
3924           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3925           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3926   "TARGET_SSE"
3927   "@
3928    unpcklps\t{%2, %0|%0, %2}
3929    movss\t{%1, %0|%0, %1}
3930    punpckldq\t{%2, %0|%0, %2}
3931    movd\t{%1, %0|%0, %1}"
3932   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3933    (set_attr "mode" "V4SF,SF,DI,DI")])
3934
3935 (define_insn "*vec_concatv4sf_avx"
3936   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3937         (vec_concat:V4SF
3938           (match_operand:V2SF 1 "register_operand" " x,x")
3939           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3940   "TARGET_AVX"
3941   "@
3942    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3943    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3944   [(set_attr "type" "ssemov")
3945    (set_attr "prefix" "vex")
3946    (set_attr "mode" "V4SF,V2SF")])
3947
3948 (define_insn "*vec_concatv4sf_sse"
3949   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3950         (vec_concat:V4SF
3951           (match_operand:V2SF 1 "register_operand" " 0,0")
3952           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3953   "TARGET_SSE"
3954   "@
3955    movlhps\t{%2, %0|%0, %2}
3956    movhps\t{%2, %0|%0, %2}"
3957   [(set_attr "type" "ssemov")
3958    (set_attr "mode" "V4SF,V2SF")])
3959
3960 (define_expand "vec_init<mode>"
3961   [(match_operand:SSEMODE 0 "register_operand" "")
3962    (match_operand 1 "" "")]
3963   "TARGET_SSE"
3964 {
3965   ix86_expand_vector_init (false, operands[0], operands[1]);
3966   DONE;
3967 })
3968
3969 (define_insn "*vec_set<mode>_0_avx"
3970   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3971         (vec_merge:SSEMODE4S
3972           (vec_duplicate:SSEMODE4S
3973             (match_operand:<ssescalarmode> 2
3974               "general_operand"                            " x,m,*r,x,*rm,x*rfF"))
3975           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0")
3976           (const_int 1)))]
3977   "TARGET_AVX"
3978   "@
3979    vinsertps\t{$0xe, %2, %2, %0|%0, %2, %2, 0xe}
3980    vmov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
3981    vmovd\t{%2, %0|%0, %2}
3982    vmovss\t{%2, %1, %0|%0, %1, %2}
3983    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
3984    #"
3985   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
3986    (set_attr "prefix_extra" "*,*,*,*,1,*")
3987    (set_attr "length_immediate" "*,*,*,*,1,*")
3988    (set_attr "prefix" "vex")
3989    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
3990
3991 (define_insn "*vec_set<mode>_0_sse4_1"
3992   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3993         (vec_merge:SSEMODE4S
3994           (vec_duplicate:SSEMODE4S
3995             (match_operand:<ssescalarmode> 2
3996               "general_operand"                            " x,m,*r,x,*rm,*rfF"))
3997           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,0,  0,0")
3998           (const_int 1)))]
3999   "TARGET_SSE4_1"
4000   "@
4001    insertps\t{$0xe, %2, %0|%0, %2, 0xe}
4002    mov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
4003    movd\t{%2, %0|%0, %2}
4004    movss\t{%2, %0|%0, %2}
4005    pinsrd\t{$0, %2, %0|%0, %2, 0}
4006    #"
4007   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
4008    (set_attr "prefix_extra" "*,*,*,*,1,*")
4009    (set_attr "length_immediate" "*,*,*,*,1,*")
4010    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
4011
4012 (define_insn "*vec_set<mode>_0_sse2"
4013   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x, x,x,m")
4014         (vec_merge:SSEMODE4S
4015           (vec_duplicate:SSEMODE4S
4016             (match_operand:<ssescalarmode> 2
4017               "general_operand"                            " m,*r,x,x*rfF"))
4018           (match_operand:SSEMODE4S 1 "vector_move_operand" " C, C,0,0")
4019           (const_int 1)))]
4020   "TARGET_SSE2"
4021   "@
4022    mov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
4023    movd\t{%2, %0|%0, %2}
4024    movss\t{%2, %0|%0, %2}
4025    #"
4026   [(set_attr "type" "ssemov")
4027    (set_attr "mode" "<ssescalarmode>,SI,SF,*")])
4028
4029 (define_insn "vec_set<mode>_0"
4030   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x,m")
4031         (vec_merge:SSEMODE4S
4032           (vec_duplicate:SSEMODE4S
4033             (match_operand:<ssescalarmode> 2
4034               "general_operand"                            " m,x,x*rfF"))
4035           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,0,0")
4036           (const_int 1)))]
4037   "TARGET_SSE"
4038   "@
4039    movss\t{%2, %0|%0, %2}
4040    movss\t{%2, %0|%0, %2}
4041    #"
4042   [(set_attr "type" "ssemov")
4043    (set_attr "mode" "SF,SF,*")])
4044
4045 ;; A subset is vec_setv4sf.
4046 (define_insn "*vec_setv4sf_avx"
4047   [(set (match_operand:V4SF 0 "register_operand" "=x")
4048         (vec_merge:V4SF
4049           (vec_duplicate:V4SF
4050             (match_operand:SF 2 "nonimmediate_operand" "xm"))
4051           (match_operand:V4SF 1 "register_operand" "x")
4052           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4053   "TARGET_AVX"
4054 {
4055   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4056   return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4057 }
4058   [(set_attr "type" "sselog")
4059    (set_attr "prefix_extra" "1")
4060    (set_attr "length_immediate" "1")
4061    (set_attr "prefix" "vex")
4062    (set_attr "mode" "V4SF")])
4063
4064 (define_insn "*vec_setv4sf_sse4_1"
4065   [(set (match_operand:V4SF 0 "register_operand" "=x")
4066         (vec_merge:V4SF
4067           (vec_duplicate:V4SF
4068             (match_operand:SF 2 "nonimmediate_operand" "xm"))
4069           (match_operand:V4SF 1 "register_operand" "0")
4070           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4071   "TARGET_SSE4_1"
4072 {
4073   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4074   return "insertps\t{%3, %2, %0|%0, %2, %3}";
4075 }
4076   [(set_attr "type" "sselog")
4077    (set_attr "prefix_data16" "1")
4078    (set_attr "prefix_extra" "1")
4079    (set_attr "length_immediate" "1")
4080    (set_attr "mode" "V4SF")])
4081
4082 (define_insn "*avx_insertps"
4083   [(set (match_operand:V4SF 0 "register_operand" "=x")
4084         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
4085                       (match_operand:V4SF 1 "register_operand" "x")
4086                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4087                      UNSPEC_INSERTPS))]
4088   "TARGET_AVX"
4089   "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4090   [(set_attr "type" "sselog")
4091    (set_attr "prefix" "vex")
4092    (set_attr "prefix_extra" "1")
4093    (set_attr "length_immediate" "1")
4094    (set_attr "mode" "V4SF")])
4095
4096 (define_insn "sse4_1_insertps"
4097   [(set (match_operand:V4SF 0 "register_operand" "=x")
4098         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
4099                       (match_operand:V4SF 1 "register_operand" "0")
4100                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4101                      UNSPEC_INSERTPS))]
4102   "TARGET_SSE4_1"
4103   "insertps\t{%3, %2, %0|%0, %2, %3}";
4104   [(set_attr "type" "sselog")
4105    (set_attr "prefix_data16" "1")
4106    (set_attr "prefix_extra" "1")
4107    (set_attr "length_immediate" "1")
4108    (set_attr "mode" "V4SF")])
4109
4110 (define_split
4111   [(set (match_operand:SSEMODE4S 0 "memory_operand" "")
4112         (vec_merge:SSEMODE4S
4113           (vec_duplicate:SSEMODE4S
4114             (match_operand:<ssescalarmode> 1 "nonmemory_operand" ""))
4115           (match_dup 0)
4116           (const_int 1)))]
4117   "TARGET_SSE && reload_completed"
4118   [(const_int 0)]
4119 {
4120   emit_move_insn (adjust_address (operands[0], <ssescalarmode>mode, 0),
4121                   operands[1]);
4122   DONE;
4123 })
4124
4125 (define_expand "vec_set<mode>"
4126   [(match_operand:SSEMODE 0 "register_operand" "")
4127    (match_operand:<ssescalarmode> 1 "register_operand" "")
4128    (match_operand 2 "const_int_operand" "")]
4129   "TARGET_SSE"
4130 {
4131   ix86_expand_vector_set (false, operands[0], operands[1],
4132                           INTVAL (operands[2]));
4133   DONE;
4134 })
4135
4136 (define_insn_and_split "*vec_extractv4sf_0"
4137   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
4138         (vec_select:SF
4139           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
4140           (parallel [(const_int 0)])))]
4141   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4142   "#"
4143   "&& reload_completed"
4144   [(const_int 0)]
4145 {
4146   rtx op1 = operands[1];
4147   if (REG_P (op1))
4148     op1 = gen_rtx_REG (SFmode, REGNO (op1));
4149   else
4150     op1 = gen_lowpart (SFmode, op1);
4151   emit_move_insn (operands[0], op1);
4152   DONE;
4153 })
4154
4155 (define_expand "avx_vextractf128<mode>"
4156   [(match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "")
4157    (match_operand:AVX256MODE 1 "register_operand" "")
4158    (match_operand:SI 2 "const_0_to_1_operand" "")]
4159   "TARGET_AVX"
4160 {
4161   switch (INTVAL (operands[2]))
4162     {
4163     case 0:
4164       emit_insn (gen_vec_extract_lo_<mode> (operands[0], operands[1]));
4165       break;
4166     case 1:
4167       emit_insn (gen_vec_extract_hi_<mode> (operands[0], operands[1]));
4168       break;
4169     default:
4170       gcc_unreachable ();
4171     }
4172   DONE;
4173 })
4174
4175 (define_insn_and_split "vec_extract_lo_<mode>"
4176   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4177         (vec_select:<avxhalfvecmode>
4178           (match_operand:AVX256MODE4P 1 "nonimmediate_operand" "xm,x")
4179           (parallel [(const_int 0) (const_int 1)])))]
4180   "TARGET_AVX"
4181   "#"
4182   "&& reload_completed"
4183   [(const_int 0)]
4184 {
4185   rtx op1 = operands[1];
4186   if (REG_P (op1))
4187     op1 = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (op1));
4188   else
4189     op1 = gen_lowpart (<avxhalfvecmode>mode, op1);
4190   emit_move_insn (operands[0], op1);
4191   DONE;
4192 })
4193
4194 (define_insn "vec_extract_hi_<mode>"
4195   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4196         (vec_select:<avxhalfvecmode>
4197           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
4198           (parallel [(const_int 2) (const_int 3)])))]
4199   "TARGET_AVX"
4200   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4201   [(set_attr "type" "sselog")
4202    (set_attr "prefix_extra" "1")
4203    (set_attr "length_immediate" "1")
4204    (set_attr "memory" "none,store")
4205    (set_attr "prefix" "vex")
4206    (set_attr "mode" "V8SF")])
4207
4208 (define_insn_and_split "vec_extract_lo_<mode>"
4209   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4210         (vec_select:<avxhalfvecmode>
4211           (match_operand:AVX256MODE8P 1 "nonimmediate_operand" "xm,x")
4212           (parallel [(const_int 0) (const_int 1)
4213                      (const_int 2) (const_int 3)])))]
4214   "TARGET_AVX"
4215   "#"
4216   "&& reload_completed"
4217   [(const_int 0)]
4218 {
4219   rtx op1 = operands[1];
4220   if (REG_P (op1))
4221     op1 = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (op1));
4222   else
4223     op1 = gen_lowpart (<avxhalfvecmode>mode, op1);
4224   emit_move_insn (operands[0], op1);
4225   DONE;
4226 })
4227
4228 (define_insn "vec_extract_hi_<mode>"
4229   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4230         (vec_select:<avxhalfvecmode>
4231           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
4232           (parallel [(const_int 4) (const_int 5)
4233                      (const_int 6) (const_int 7)])))]
4234   "TARGET_AVX"
4235   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4236   [(set_attr "type" "sselog")
4237    (set_attr "prefix_extra" "1")
4238    (set_attr "length_immediate" "1")
4239    (set_attr "memory" "none,store")
4240    (set_attr "prefix" "vex")
4241    (set_attr "mode" "V8SF")])
4242
4243 (define_insn_and_split "vec_extract_lo_v16hi"
4244   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4245         (vec_select:V8HI
4246           (match_operand:V16HI 1 "nonimmediate_operand" "xm,x")
4247           (parallel [(const_int 0) (const_int 1)
4248                      (const_int 2) (const_int 3)
4249                      (const_int 4) (const_int 5)
4250                      (const_int 6) (const_int 7)])))]
4251   "TARGET_AVX"
4252   "#"
4253   "&& reload_completed"
4254   [(const_int 0)]
4255 {
4256   rtx op1 = operands[1];
4257   if (REG_P (op1))
4258     op1 = gen_rtx_REG (V8HImode, REGNO (op1));
4259   else
4260     op1 = gen_lowpart (V8HImode, op1);
4261   emit_move_insn (operands[0], op1);
4262   DONE;
4263 })
4264
4265 (define_insn "vec_extract_hi_v16hi"
4266   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4267         (vec_select:V8HI
4268           (match_operand:V16HI 1 "register_operand" "x,x")
4269           (parallel [(const_int 8) (const_int 9)
4270                      (const_int 10) (const_int 11)
4271                      (const_int 12) (const_int 13)
4272                      (const_int 14) (const_int 15)])))]
4273   "TARGET_AVX"
4274   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4275   [(set_attr "type" "sselog")
4276    (set_attr "prefix_extra" "1")
4277    (set_attr "length_immediate" "1")
4278    (set_attr "memory" "none,store")
4279    (set_attr "prefix" "vex")
4280    (set_attr "mode" "V8SF")])
4281
4282 (define_insn_and_split "vec_extract_lo_v32qi"
4283   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4284         (vec_select:V16QI
4285           (match_operand:V32QI 1 "nonimmediate_operand" "xm,x")
4286           (parallel [(const_int 0) (const_int 1)
4287                      (const_int 2) (const_int 3)
4288                      (const_int 4) (const_int 5)
4289                      (const_int 6) (const_int 7)
4290                      (const_int 8) (const_int 9)
4291                      (const_int 10) (const_int 11)
4292                      (const_int 12) (const_int 13)
4293                      (const_int 14) (const_int 15)])))]
4294   "TARGET_AVX"
4295   "#"
4296   "&& reload_completed"
4297   [(const_int 0)]
4298 {
4299   rtx op1 = operands[1];
4300   if (REG_P (op1))
4301     op1 = gen_rtx_REG (V16QImode, REGNO (op1));
4302   else
4303     op1 = gen_lowpart (V16QImode, op1);
4304   emit_move_insn (operands[0], op1);
4305   DONE;
4306 })
4307
4308 (define_insn "vec_extract_hi_v32qi"
4309   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4310         (vec_select:V16QI
4311           (match_operand:V32QI 1 "register_operand" "x,x")
4312           (parallel [(const_int 16) (const_int 17)
4313                      (const_int 18) (const_int 19)
4314                      (const_int 20) (const_int 21)
4315                      (const_int 22) (const_int 23)
4316                      (const_int 24) (const_int 25)
4317                      (const_int 26) (const_int 27)
4318                      (const_int 28) (const_int 29)
4319                      (const_int 30) (const_int 31)])))]
4320   "TARGET_AVX"
4321   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4322   [(set_attr "type" "sselog")
4323    (set_attr "prefix_extra" "1")
4324    (set_attr "length_immediate" "1")
4325    (set_attr "memory" "none,store")
4326    (set_attr "prefix" "vex")
4327    (set_attr "mode" "V8SF")])
4328
4329 (define_insn "*sse4_1_extractps"
4330   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
4331         (vec_select:SF
4332           (match_operand:V4SF 1 "register_operand" "x")
4333           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
4334   "TARGET_SSE4_1"
4335   "%vextractps\t{%2, %1, %0|%0, %1, %2}"
4336   [(set_attr "type" "sselog")
4337    (set_attr "prefix_data16" "1")
4338    (set_attr "prefix_extra" "1")
4339    (set_attr "length_immediate" "1")
4340    (set_attr "prefix" "maybe_vex")
4341    (set_attr "mode" "V4SF")])
4342
4343 (define_insn_and_split "*vec_extract_v4sf_mem"
4344   [(set (match_operand:SF 0 "register_operand" "=x*rf")
4345        (vec_select:SF
4346          (match_operand:V4SF 1 "memory_operand" "o")
4347          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
4348   ""
4349   "#"
4350   "reload_completed"
4351   [(const_int 0)]
4352 {
4353   int i = INTVAL (operands[2]);
4354
4355   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
4356   DONE;
4357 })
4358
4359 (define_expand "vec_extract<mode>"
4360   [(match_operand:<ssescalarmode> 0 "register_operand" "")
4361    (match_operand:SSEMODE 1 "register_operand" "")
4362    (match_operand 2 "const_int_operand" "")]
4363   "TARGET_SSE"
4364 {
4365   ix86_expand_vector_extract (false, operands[0], operands[1],
4366                               INTVAL (operands[2]));
4367   DONE;
4368 })
4369
4370 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4371 ;;
4372 ;; Parallel double-precision floating point element swizzling
4373 ;;
4374 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4375
4376 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4377 (define_insn "avx_unpckhpd256"
4378   [(set (match_operand:V4DF 0 "register_operand" "=x")
4379         (vec_select:V4DF
4380           (vec_concat:V8DF
4381             (match_operand:V4DF 1 "register_operand" "x")
4382             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4383           (parallel [(const_int 1) (const_int 5)
4384                      (const_int 3) (const_int 7)])))]
4385   "TARGET_AVX"
4386   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
4387   [(set_attr "type" "sselog")
4388    (set_attr "prefix" "vex")
4389    (set_attr "mode" "V4DF")])
4390
4391 (define_expand "vec_interleave_highv2df"
4392   [(set (match_operand:V2DF 0 "register_operand" "")
4393         (vec_select:V2DF
4394           (vec_concat:V4DF
4395             (match_operand:V2DF 1 "nonimmediate_operand" "")
4396             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4397           (parallel [(const_int 1)
4398                      (const_int 3)])))]
4399   "TARGET_SSE2"
4400 {
4401   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
4402     operands[2] = force_reg (V2DFmode, operands[2]);
4403 })
4404
4405 (define_insn "*avx_interleave_highv2df"
4406   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4407         (vec_select:V2DF
4408           (vec_concat:V4DF
4409             (match_operand:V2DF 1 "nonimmediate_operand" " x,o,o,x")
4410             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,x,0"))
4411           (parallel [(const_int 1)
4412                      (const_int 3)])))]
4413   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4414   "@
4415    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
4416    vmovddup\t{%H1, %0|%0, %H1}
4417    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
4418    vmovhpd\t{%1, %0|%0, %1}"
4419   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4420    (set_attr "prefix" "vex")
4421    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4422
4423 (define_insn "*sse3_interleave_highv2df"
4424   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4425         (vec_select:V2DF
4426           (vec_concat:V4DF
4427             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,o,x")
4428             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,0,0"))
4429           (parallel [(const_int 1)
4430                      (const_int 3)])))]
4431   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4432   "@
4433    unpckhpd\t{%2, %0|%0, %2}
4434    movddup\t{%H1, %0|%0, %H1}
4435    movlpd\t{%H1, %0|%0, %H1}
4436    movhpd\t{%1, %0|%0, %1}"
4437   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4438    (set_attr "prefix_data16" "*,*,1,1")
4439    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4440
4441 (define_insn "*sse2_interleave_highv2df"
4442   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
4443         (vec_select:V2DF
4444           (vec_concat:V4DF
4445             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
4446             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
4447           (parallel [(const_int 1)
4448                      (const_int 3)])))]
4449   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4450   "@
4451    unpckhpd\t{%2, %0|%0, %2}
4452    movlpd\t{%H1, %0|%0, %H1}
4453    movhpd\t{%1, %0|%0, %1}"
4454   [(set_attr "type" "sselog,ssemov,ssemov")
4455    (set_attr "prefix_data16" "*,1,1")
4456    (set_attr "mode" "V2DF,V1DF,V1DF")])
4457
4458 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4459 (define_expand "avx_movddup256"
4460   [(set (match_operand:V4DF 0 "register_operand" "")
4461         (vec_select:V4DF
4462           (vec_concat:V8DF
4463             (match_operand:V4DF 1 "nonimmediate_operand" "")
4464             (match_dup 1))
4465           (parallel [(const_int 0) (const_int 4)
4466                      (const_int 2) (const_int 6)])))]
4467   "TARGET_AVX"
4468   "")
4469
4470 (define_expand "avx_unpcklpd256"
4471   [(set (match_operand:V4DF 0 "register_operand" "")
4472         (vec_select:V4DF
4473           (vec_concat:V8DF
4474             (match_operand:V4DF 1 "register_operand" "")
4475             (match_operand:V4DF 2 "nonimmediate_operand" ""))
4476           (parallel [(const_int 0) (const_int 4)
4477                      (const_int 2) (const_int 6)])))]
4478   "TARGET_AVX"
4479   "")
4480
4481 (define_insn "*avx_unpcklpd256"
4482   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
4483         (vec_select:V4DF
4484           (vec_concat:V8DF
4485             (match_operand:V4DF 1 "nonimmediate_operand" "xm,x")
4486             (match_operand:V4DF 2 "nonimmediate_operand" " 1,xm"))
4487           (parallel [(const_int 0) (const_int 4)
4488                      (const_int 2) (const_int 6)])))]
4489   "TARGET_AVX
4490    && (!MEM_P (operands[1]) || rtx_equal_p (operands[1], operands[2]))"
4491   "@
4492    vmovddup\t{%1, %0|%0, %1}
4493    vunpcklpd\t{%2, %1, %0|%0, %1, %2}"
4494   [(set_attr "type" "sselog")
4495    (set_attr "prefix" "vex")
4496    (set_attr "mode" "V4DF")])
4497
4498 (define_expand "vec_interleave_lowv2df"
4499   [(set (match_operand:V2DF 0 "register_operand" "")
4500         (vec_select:V2DF
4501           (vec_concat:V4DF
4502             (match_operand:V2DF 1 "nonimmediate_operand" "")
4503             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4504           (parallel [(const_int 0)
4505                      (const_int 2)])))]
4506   "TARGET_SSE2"
4507 {
4508   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
4509     operands[1] = force_reg (V2DFmode, operands[1]);
4510 })
4511
4512 (define_insn "*avx_interleave_lowv2df"
4513   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4514         (vec_select:V2DF
4515           (vec_concat:V4DF
4516             (match_operand:V2DF 1 "nonimmediate_operand" " x,m,x,0")
4517             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4518           (parallel [(const_int 0)
4519                      (const_int 2)])))]
4520   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4521   "@
4522    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4523    vmovddup\t{%1, %0|%0, %1}
4524    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4525    vmovlpd\t{%2, %H0|%H0, %2}"
4526   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4527    (set_attr "prefix" "vex")
4528    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4529
4530 (define_insn "*sse3_interleave_lowv2df"
4531   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4532         (vec_select:V2DF
4533           (vec_concat:V4DF
4534             (match_operand:V2DF 1 "nonimmediate_operand" " 0,m,0,0")
4535             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4536           (parallel [(const_int 0)
4537                      (const_int 2)])))]
4538   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4539   "@
4540    unpcklpd\t{%2, %0|%0, %2}
4541    movddup\t{%1, %0|%0, %1}
4542    movhpd\t{%2, %0|%0, %2}
4543    movlpd\t{%2, %H0|%H0, %2}"
4544   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4545    (set_attr "prefix_data16" "*,*,1,1")
4546    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4547
4548 (define_insn "*sse2_interleave_lowv2df"
4549   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4550         (vec_select:V2DF
4551           (vec_concat:V4DF
4552             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
4553             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4554           (parallel [(const_int 0)
4555                      (const_int 2)])))]
4556   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4557   "@
4558    unpcklpd\t{%2, %0|%0, %2}
4559    movhpd\t{%2, %0|%0, %2}
4560    movlpd\t{%2, %H0|%H0, %2}"
4561   [(set_attr "type" "sselog,ssemov,ssemov")
4562    (set_attr "prefix_data16" "*,1,1")
4563    (set_attr "mode" "V2DF,V1DF,V1DF")])
4564
4565 (define_split
4566   [(set (match_operand:V2DF 0 "memory_operand" "")
4567         (vec_select:V2DF
4568           (vec_concat:V4DF
4569             (match_operand:V2DF 1 "register_operand" "")
4570             (match_dup 1))
4571           (parallel [(const_int 0)
4572                      (const_int 2)])))]
4573   "TARGET_SSE3 && reload_completed"
4574   [(const_int 0)]
4575 {
4576   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4577   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4578   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4579   DONE;
4580 })
4581
4582 (define_split
4583   [(set (match_operand:V2DF 0 "register_operand" "")
4584         (vec_select:V2DF
4585           (vec_concat:V4DF
4586             (match_operand:V2DF 1 "memory_operand" "")
4587             (match_dup 1))
4588           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "")
4589                      (match_operand:SI 3 "const_int_operand" "")])))]
4590   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
4591   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
4592 {
4593   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
4594 })
4595
4596 (define_expand "avx_shufpd256"
4597   [(match_operand:V4DF 0 "register_operand" "")
4598    (match_operand:V4DF 1 "register_operand" "")
4599    (match_operand:V4DF 2 "nonimmediate_operand" "")
4600    (match_operand:SI 3 "const_int_operand" "")]
4601   "TARGET_AVX"
4602 {
4603   int mask = INTVAL (operands[3]);
4604   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4605                                    GEN_INT (mask & 1),
4606                                    GEN_INT (mask & 2 ? 5 : 4),
4607                                    GEN_INT (mask & 4 ? 3 : 2),
4608                                    GEN_INT (mask & 8 ? 7 : 6)));
4609   DONE;
4610 })
4611
4612 (define_insn "avx_shufpd256_1"
4613   [(set (match_operand:V4DF 0 "register_operand" "=x")
4614         (vec_select:V4DF
4615           (vec_concat:V8DF
4616             (match_operand:V4DF 1 "register_operand" "x")
4617             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4618           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4619                      (match_operand 4 "const_4_to_5_operand" "")
4620                      (match_operand 5 "const_2_to_3_operand" "")
4621                      (match_operand 6 "const_6_to_7_operand" "")])))]
4622   "TARGET_AVX"
4623 {
4624   int mask;
4625   mask = INTVAL (operands[3]);
4626   mask |= (INTVAL (operands[4]) - 4) << 1;
4627   mask |= (INTVAL (operands[5]) - 2) << 2;
4628   mask |= (INTVAL (operands[6]) - 6) << 3;
4629   operands[3] = GEN_INT (mask);
4630
4631   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4632 }
4633   [(set_attr "type" "sselog")
4634    (set_attr "length_immediate" "1")
4635    (set_attr "prefix" "vex")
4636    (set_attr "mode" "V4DF")])
4637
4638 (define_expand "sse2_shufpd"
4639   [(match_operand:V2DF 0 "register_operand" "")
4640    (match_operand:V2DF 1 "register_operand" "")
4641    (match_operand:V2DF 2 "nonimmediate_operand" "")
4642    (match_operand:SI 3 "const_int_operand" "")]
4643   "TARGET_SSE2"
4644 {
4645   int mask = INTVAL (operands[3]);
4646   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4647                                 GEN_INT (mask & 1),
4648                                 GEN_INT (mask & 2 ? 3 : 2)));
4649   DONE;
4650 })
4651
4652 (define_expand "vec_extract_even<mode>"
4653   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4654    (match_operand:SSEMODE_EO 1 "register_operand" "")
4655    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4656   ""
4657 {
4658   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 0);
4659   DONE;
4660 })
4661
4662 (define_expand "vec_extract_odd<mode>"
4663   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4664    (match_operand:SSEMODE_EO 1 "register_operand" "")
4665    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4666   ""
4667 {
4668   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 1);
4669   DONE;
4670 })
4671
4672 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4673 (define_insn "*avx_interleave_highv2di"
4674   [(set (match_operand:V2DI 0 "register_operand" "=x")
4675         (vec_select:V2DI
4676           (vec_concat:V4DI
4677             (match_operand:V2DI 1 "register_operand" "x")
4678             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4679           (parallel [(const_int 1)
4680                      (const_int 3)])))]
4681   "TARGET_AVX"
4682   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4683   [(set_attr "type" "sselog")
4684    (set_attr "prefix" "vex")
4685    (set_attr "mode" "TI")])
4686
4687 (define_insn "vec_interleave_highv2di"
4688   [(set (match_operand:V2DI 0 "register_operand" "=x")
4689         (vec_select:V2DI
4690           (vec_concat:V4DI
4691             (match_operand:V2DI 1 "register_operand" "0")
4692             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4693           (parallel [(const_int 1)
4694                      (const_int 3)])))]
4695   "TARGET_SSE2"
4696   "punpckhqdq\t{%2, %0|%0, %2}"
4697   [(set_attr "type" "sselog")
4698    (set_attr "prefix_data16" "1")
4699    (set_attr "mode" "TI")])
4700
4701 (define_insn "*avx_interleave_lowv2di"
4702   [(set (match_operand:V2DI 0 "register_operand" "=x")
4703         (vec_select:V2DI
4704           (vec_concat:V4DI
4705             (match_operand:V2DI 1 "register_operand" "x")
4706             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4707           (parallel [(const_int 0)
4708                      (const_int 2)])))]
4709   "TARGET_AVX"
4710   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4711   [(set_attr "type" "sselog")
4712    (set_attr "prefix" "vex")
4713    (set_attr "mode" "TI")])
4714
4715 (define_insn "vec_interleave_lowv2di"
4716   [(set (match_operand:V2DI 0 "register_operand" "=x")
4717         (vec_select:V2DI
4718           (vec_concat:V4DI
4719             (match_operand:V2DI 1 "register_operand" "0")
4720             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4721           (parallel [(const_int 0)
4722                      (const_int 2)])))]
4723   "TARGET_SSE2"
4724   "punpcklqdq\t{%2, %0|%0, %2}"
4725   [(set_attr "type" "sselog")
4726    (set_attr "prefix_data16" "1")
4727    (set_attr "mode" "TI")])
4728
4729 (define_insn "*avx_shufpd_<mode>"
4730   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4731         (vec_select:SSEMODE2D
4732           (vec_concat:<ssedoublesizemode>
4733             (match_operand:SSEMODE2D 1 "register_operand" "x")
4734             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4735           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4736                      (match_operand 4 "const_2_to_3_operand" "")])))]
4737   "TARGET_AVX"
4738 {
4739   int mask;
4740   mask = INTVAL (operands[3]);
4741   mask |= (INTVAL (operands[4]) - 2) << 1;
4742   operands[3] = GEN_INT (mask);
4743
4744   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4745 }
4746   [(set_attr "type" "sselog")
4747    (set_attr "length_immediate" "1")
4748    (set_attr "prefix" "vex")
4749    (set_attr "mode" "V2DF")])
4750
4751 (define_insn "sse2_shufpd_<mode>"
4752   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4753         (vec_select:SSEMODE2D
4754           (vec_concat:<ssedoublesizemode>
4755             (match_operand:SSEMODE2D 1 "register_operand" "0")
4756             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4757           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4758                      (match_operand 4 "const_2_to_3_operand" "")])))]
4759   "TARGET_SSE2"
4760 {
4761   int mask;
4762   mask = INTVAL (operands[3]);
4763   mask |= (INTVAL (operands[4]) - 2) << 1;
4764   operands[3] = GEN_INT (mask);
4765
4766   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4767 }
4768   [(set_attr "type" "sselog")
4769    (set_attr "length_immediate" "1")
4770    (set_attr "mode" "V2DF")])
4771
4772 ;; Avoid combining registers from different units in a single alternative,
4773 ;; see comment above inline_secondary_memory_needed function in i386.c
4774 (define_insn "*avx_storehpd"
4775   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4776         (vec_select:DF
4777           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,o,o,o")
4778           (parallel [(const_int 1)])))]
4779   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4780   "@
4781    vmovhpd\t{%1, %0|%0, %1}
4782    vunpckhpd\t{%1, %1, %0|%0, %1, %1}
4783    #
4784    #
4785    #"
4786   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4787    (set_attr "prefix" "vex")
4788    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4789
4790 (define_insn "sse2_storehpd"
4791   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4792         (vec_select:DF
4793           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o,o,o")
4794           (parallel [(const_int 1)])))]
4795   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4796   "@
4797    movhpd\t{%1, %0|%0, %1}
4798    unpckhpd\t%0, %0
4799    #
4800    #
4801    #"
4802   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4803    (set_attr "prefix_data16" "1,*,*,*,*")
4804    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4805
4806 (define_split
4807   [(set (match_operand:DF 0 "register_operand" "")
4808         (vec_select:DF
4809           (match_operand:V2DF 1 "memory_operand" "")
4810           (parallel [(const_int 1)])))]
4811   "TARGET_SSE2 && reload_completed"
4812   [(set (match_dup 0) (match_dup 1))]
4813 {
4814   operands[1] = adjust_address (operands[1], DFmode, 8);
4815 })
4816
4817 ;; Avoid combining registers from different units in a single alternative,
4818 ;; see comment above inline_secondary_memory_needed function in i386.c
4819 (define_insn "sse2_storelpd"
4820   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4821         (vec_select:DF
4822           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4823           (parallel [(const_int 0)])))]
4824   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4825   "@
4826    %vmovlpd\t{%1, %0|%0, %1}
4827    #
4828    #
4829    #
4830    #"
4831   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4832    (set_attr "prefix_data16" "1,*,*,*,*")
4833    (set_attr "prefix" "maybe_vex")
4834    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4835
4836 (define_split
4837   [(set (match_operand:DF 0 "register_operand" "")
4838         (vec_select:DF
4839           (match_operand:V2DF 1 "nonimmediate_operand" "")
4840           (parallel [(const_int 0)])))]
4841   "TARGET_SSE2 && reload_completed"
4842   [(const_int 0)]
4843 {
4844   rtx op1 = operands[1];
4845   if (REG_P (op1))
4846     op1 = gen_rtx_REG (DFmode, REGNO (op1));
4847   else
4848     op1 = gen_lowpart (DFmode, op1);
4849   emit_move_insn (operands[0], op1);
4850   DONE;
4851 })
4852
4853 (define_expand "sse2_loadhpd_exp"
4854   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4855         (vec_concat:V2DF
4856           (vec_select:DF
4857             (match_operand:V2DF 1 "nonimmediate_operand" "")
4858             (parallel [(const_int 0)]))
4859           (match_operand:DF 2 "nonimmediate_operand" "")))]
4860   "TARGET_SSE2"
4861   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4862
4863 ;; Avoid combining registers from different units in a single alternative,
4864 ;; see comment above inline_secondary_memory_needed function in i386.c
4865 (define_insn "*avx_loadhpd"
4866   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o,o,o")
4867         (vec_concat:V2DF
4868           (vec_select:DF
4869             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,0,0")
4870             (parallel [(const_int 0)]))
4871           (match_operand:DF 2 "nonimmediate_operand"     " m,x,x,*f,r")))]
4872   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4873   "@
4874    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4875    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4876    #
4877    #
4878    #"
4879   [(set_attr "type" "ssemov,sselog,ssemov,fmov,imov")
4880    (set_attr "prefix" "vex")
4881    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4882
4883 (define_insn "sse2_loadhpd"
4884   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
4885         (vec_concat:V2DF
4886           (vec_select:DF
4887             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0,0,0")
4888             (parallel [(const_int 0)]))
4889           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x,*f,r")))]
4890   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4891   "@
4892    movhpd\t{%2, %0|%0, %2}
4893    unpcklpd\t{%2, %0|%0, %2}
4894    shufpd\t{$1, %1, %0|%0, %1, 1}
4895    #
4896    #
4897    #"
4898   [(set_attr "type" "ssemov,sselog,sselog,ssemov,fmov,imov")
4899    (set_attr "prefix_data16" "1,*,*,*,*,*")
4900    (set_attr "length_immediate" "*,*,1,*,*,*")
4901    (set_attr "mode" "V1DF,V2DF,V2DF,DF,DF,DF")])
4902
4903 (define_split
4904   [(set (match_operand:V2DF 0 "memory_operand" "")
4905         (vec_concat:V2DF
4906           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
4907           (match_operand:DF 1 "register_operand" "")))]
4908   "TARGET_SSE2 && reload_completed"
4909   [(set (match_dup 0) (match_dup 1))]
4910 {
4911   operands[0] = adjust_address (operands[0], DFmode, 8);
4912 })
4913
4914 (define_expand "sse2_loadlpd_exp"
4915   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4916         (vec_concat:V2DF
4917           (match_operand:DF 2 "nonimmediate_operand" "")
4918           (vec_select:DF
4919             (match_operand:V2DF 1 "nonimmediate_operand" "")
4920             (parallel [(const_int 1)]))))]
4921   "TARGET_SSE2"
4922   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4923
4924 ;; Avoid combining registers from different units in a single alternative,
4925 ;; see comment above inline_secondary_memory_needed function in i386.c
4926 (define_insn "*avx_loadlpd"
4927   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,m,m,m")
4928         (vec_concat:V2DF
4929           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,x,x,*f,r")
4930           (vec_select:DF
4931             (match_operand:V2DF 1 "vector_move_operand" " C,x,x,o,0,0,0")
4932             (parallel [(const_int 1)]))))]
4933   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4934   "@
4935    vmovsd\t{%2, %0|%0, %2}
4936    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4937    vmovsd\t{%2, %1, %0|%0, %1, %2}
4938    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
4939    #
4940    #
4941    #"
4942   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov,fmov,imov")
4943    (set_attr "prefix" "vex")
4944    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
4945
4946 (define_insn "sse2_loadlpd"
4947   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
4948         (vec_concat:V2DF
4949           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x,*f,r")
4950           (vec_select:DF
4951             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0,0,0")
4952             (parallel [(const_int 1)]))))]
4953   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4954   "@
4955    movsd\t{%2, %0|%0, %2}
4956    movlpd\t{%2, %0|%0, %2}
4957    movsd\t{%2, %0|%0, %2}
4958    shufpd\t{$2, %2, %0|%0, %2, 2}
4959    movhpd\t{%H1, %0|%0, %H1}
4960    #
4961    #
4962    #"
4963   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,fmov,imov")
4964    (set_attr "prefix_data16" "*,1,*,*,1,*,*,*")
4965    (set_attr "length_immediate" "*,*,*,1,*,*,*,*")
4966    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF,DF,DF")])
4967
4968 (define_split
4969   [(set (match_operand:V2DF 0 "memory_operand" "")
4970         (vec_concat:V2DF
4971           (match_operand:DF 1 "register_operand" "")
4972           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
4973   "TARGET_SSE2 && reload_completed"
4974   [(set (match_dup 0) (match_dup 1))]
4975 {
4976   operands[0] = adjust_address (operands[0], DFmode, 8);
4977 })
4978
4979 ;; Not sure these two are ever used, but it doesn't hurt to have
4980 ;; them. -aoliva
4981 (define_insn "*vec_extractv2df_1_sse"
4982   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4983         (vec_select:DF
4984           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4985           (parallel [(const_int 1)])))]
4986   "!TARGET_SSE2 && TARGET_SSE
4987    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4988   "@
4989    movhps\t{%1, %0|%0, %1}
4990    movhlps\t{%1, %0|%0, %1}
4991    movlps\t{%H1, %0|%0, %H1}"
4992   [(set_attr "type" "ssemov")
4993    (set_attr "mode" "V2SF,V4SF,V2SF")])
4994
4995 (define_insn "*vec_extractv2df_0_sse"
4996   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4997         (vec_select:DF
4998           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
4999           (parallel [(const_int 0)])))]
5000   "!TARGET_SSE2 && TARGET_SSE
5001    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5002   "@
5003    movlps\t{%1, %0|%0, %1}
5004    movaps\t{%1, %0|%0, %1}
5005    movlps\t{%1, %0|%0, %1}"
5006   [(set_attr "type" "ssemov")
5007    (set_attr "mode" "V2SF,V4SF,V2SF")])
5008
5009 (define_insn "*avx_movsd"
5010   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,o")
5011         (vec_merge:V2DF
5012           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,x,0")
5013           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,o,x")
5014           (const_int 1)))]
5015   "TARGET_AVX"
5016   "@
5017    vmovsd\t{%2, %1, %0|%0, %1, %2}
5018    vmovlpd\t{%2, %1, %0|%0, %1, %2}
5019    vmovlpd\t{%2, %0|%0, %2}
5020    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
5021    vmovhps\t{%1, %H0|%H0, %1}"
5022   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov")
5023    (set_attr "prefix" "vex")
5024    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF")])
5025
5026 (define_insn "sse2_movsd"
5027   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
5028         (vec_merge:V2DF
5029           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
5030           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
5031           (const_int 1)))]
5032   "TARGET_SSE2"
5033   "@
5034    movsd\t{%2, %0|%0, %2}
5035    movlpd\t{%2, %0|%0, %2}
5036    movlpd\t{%2, %0|%0, %2}
5037    shufpd\t{$2, %2, %0|%0, %2, 2}
5038    movhps\t{%H1, %0|%0, %H1}
5039    movhps\t{%1, %H0|%H0, %1}"
5040   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
5041    (set_attr "prefix_data16" "*,1,1,*,*,*")
5042    (set_attr "length_immediate" "*,*,*,1,*,*")
5043    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
5044
5045 (define_insn "*vec_dupv2df_sse3"
5046   [(set (match_operand:V2DF 0 "register_operand" "=x")
5047         (vec_duplicate:V2DF
5048           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
5049   "TARGET_SSE3"
5050   "%vmovddup\t{%1, %0|%0, %1}"
5051   [(set_attr "type" "sselog1")
5052    (set_attr "prefix" "maybe_vex")
5053    (set_attr "mode" "DF")])
5054
5055 (define_insn "vec_dupv2df"
5056   [(set (match_operand:V2DF 0 "register_operand" "=x")
5057         (vec_duplicate:V2DF
5058           (match_operand:DF 1 "register_operand" "0")))]
5059   "TARGET_SSE2"
5060   "unpcklpd\t%0, %0"
5061   [(set_attr "type" "sselog1")
5062    (set_attr "mode" "V2DF")])
5063
5064 (define_insn "*vec_concatv2df_sse3"
5065   [(set (match_operand:V2DF 0 "register_operand" "=x")
5066         (vec_concat:V2DF
5067           (match_operand:DF 1 "nonimmediate_operand" "xm")
5068           (match_dup 1)))]
5069   "TARGET_SSE3"
5070   "%vmovddup\t{%1, %0|%0, %1}"
5071   [(set_attr "type" "sselog1")
5072    (set_attr "prefix" "maybe_vex")
5073    (set_attr "mode" "DF")])
5074
5075 (define_insn "*vec_concatv2df_avx"
5076   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x")
5077         (vec_concat:V2DF
5078           (match_operand:DF 1 "nonimmediate_operand" " x,x,m")
5079           (match_operand:DF 2 "vector_move_operand"  " x,m,C")))]
5080   "TARGET_AVX"
5081   "@
5082    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
5083    vmovhpd\t{%2, %1, %0|%0, %1, %2}
5084    vmovsd\t{%1, %0|%0, %1}"
5085   [(set_attr "type" "ssemov")
5086    (set_attr "prefix" "vex")
5087    (set_attr "mode" "DF,V1DF,DF")])
5088
5089 (define_insn "*vec_concatv2df"
5090   [(set (match_operand:V2DF 0 "register_operand"     "=Y2,Y2,Y2,x,x")
5091         (vec_concat:V2DF
5092           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
5093           (match_operand:DF 2 "vector_move_operand"  " Y2,m ,C ,x,m")))]
5094   "TARGET_SSE"
5095   "@
5096    unpcklpd\t{%2, %0|%0, %2}
5097    movhpd\t{%2, %0|%0, %2}
5098    movsd\t{%1, %0|%0, %1}
5099    movlhps\t{%2, %0|%0, %2}
5100    movhps\t{%2, %0|%0, %2}"
5101   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
5102    (set_attr "prefix_data16" "*,1,*,*,*")
5103    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
5104
5105 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5106 ;;
5107 ;; Parallel integral arithmetic
5108 ;;
5109 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5110
5111 (define_expand "neg<mode>2"
5112   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5113         (minus:SSEMODEI
5114           (match_dup 2)
5115           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
5116   "TARGET_SSE2"
5117   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
5118
5119 (define_expand "<plusminus_insn><mode>3"
5120   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5121         (plusminus:SSEMODEI
5122           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
5123           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
5124   "TARGET_SSE2"
5125   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5126
5127 (define_insn "*avx_<plusminus_insn><mode>3"
5128   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5129         (plusminus:SSEMODEI
5130           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>x")
5131           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5132   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5133   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5134   [(set_attr "type" "sseiadd")
5135    (set_attr "prefix" "vex")
5136    (set_attr "mode" "TI")])
5137
5138 (define_insn "*<plusminus_insn><mode>3"
5139   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5140         (plusminus:SSEMODEI
5141           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>0")
5142           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5143   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5144   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5145   [(set_attr "type" "sseiadd")
5146    (set_attr "prefix_data16" "1")
5147    (set_attr "mode" "TI")])
5148
5149 (define_expand "sse2_<plusminus_insn><mode>3"
5150   [(set (match_operand:SSEMODE12 0 "register_operand" "")
5151         (sat_plusminus:SSEMODE12
5152           (match_operand:SSEMODE12 1 "nonimmediate_operand" "")
5153           (match_operand:SSEMODE12 2 "nonimmediate_operand" "")))]
5154   "TARGET_SSE2"
5155   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5156
5157 (define_insn "*avx_<plusminus_insn><mode>3"
5158   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5159         (sat_plusminus:SSEMODE12
5160           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>x")
5161           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5162   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5163   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5164   [(set_attr "type" "sseiadd")
5165    (set_attr "prefix" "vex")
5166    (set_attr "mode" "TI")])
5167
5168 (define_insn "*sse2_<plusminus_insn><mode>3"
5169   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5170         (sat_plusminus:SSEMODE12
5171           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>0")
5172           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5173   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5174   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5175   [(set_attr "type" "sseiadd")
5176    (set_attr "prefix_data16" "1")
5177    (set_attr "mode" "TI")])
5178
5179 (define_insn_and_split "mulv16qi3"
5180   [(set (match_operand:V16QI 0 "register_operand" "")
5181         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
5182                     (match_operand:V16QI 2 "register_operand" "")))]
5183   "TARGET_SSE2
5184    && can_create_pseudo_p ()"
5185   "#"
5186   "&& 1"
5187   [(const_int 0)]
5188 {
5189   rtx t[6];
5190   int i;
5191
5192   for (i = 0; i < 6; ++i)
5193     t[i] = gen_reg_rtx (V16QImode);
5194
5195   /* Unpack data such that we've got a source byte in each low byte of
5196      each word.  We don't care what goes into the high byte of each word.
5197      Rather than trying to get zero in there, most convenient is to let
5198      it be a copy of the low byte.  */
5199   emit_insn (gen_vec_interleave_highv16qi (t[0], operands[1], operands[1]));
5200   emit_insn (gen_vec_interleave_highv16qi (t[1], operands[2], operands[2]));
5201   emit_insn (gen_vec_interleave_lowv16qi (t[2], operands[1], operands[1]));
5202   emit_insn (gen_vec_interleave_lowv16qi (t[3], operands[2], operands[2]));
5203
5204   /* Multiply words.  The end-of-line annotations here give a picture of what
5205      the output of that instruction looks like.  Dot means don't care; the
5206      letters are the bytes of the result with A being the most significant.  */
5207   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
5208                            gen_lowpart (V8HImode, t[0]),
5209                            gen_lowpart (V8HImode, t[1])));
5210   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
5211                            gen_lowpart (V8HImode, t[2]),
5212                            gen_lowpart (V8HImode, t[3])));
5213
5214   /* Extract the even bytes and merge them back together.  */
5215   ix86_expand_vec_extract_even_odd (operands[0], t[5], t[4], 0);
5216   DONE;
5217 })
5218
5219 (define_expand "mulv8hi3"
5220   [(set (match_operand:V8HI 0 "register_operand" "")
5221         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
5222                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5223   "TARGET_SSE2"
5224   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5225
5226 (define_insn "*avx_mulv8hi3"
5227   [(set (match_operand:V8HI 0 "register_operand" "=x")
5228         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5229                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5230   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5231   "vpmullw\t{%2, %1, %0|%0, %1, %2}"
5232   [(set_attr "type" "sseimul")
5233    (set_attr "prefix" "vex")
5234    (set_attr "mode" "TI")])
5235
5236 (define_insn "*mulv8hi3"
5237   [(set (match_operand:V8HI 0 "register_operand" "=x")
5238         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5239                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5240   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5241   "pmullw\t{%2, %0|%0, %2}"
5242   [(set_attr "type" "sseimul")
5243    (set_attr "prefix_data16" "1")
5244    (set_attr "mode" "TI")])
5245
5246 (define_expand "smulv8hi3_highpart"
5247   [(set (match_operand:V8HI 0 "register_operand" "")
5248         (truncate:V8HI
5249           (lshiftrt:V8SI
5250             (mult:V8SI
5251               (sign_extend:V8SI
5252                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
5253               (sign_extend:V8SI
5254                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
5255             (const_int 16))))]
5256   "TARGET_SSE2"
5257   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5258
5259 (define_insn "*avxv8hi3_highpart"
5260   [(set (match_operand:V8HI 0 "register_operand" "=x")
5261         (truncate:V8HI
5262           (lshiftrt:V8SI
5263             (mult:V8SI
5264               (sign_extend:V8SI
5265                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
5266               (sign_extend:V8SI
5267                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5268             (const_int 16))))]
5269   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5270   "vpmulhw\t{%2, %1, %0|%0, %1, %2}"
5271   [(set_attr "type" "sseimul")
5272    (set_attr "prefix" "vex")
5273    (set_attr "mode" "TI")])
5274
5275 (define_insn "*smulv8hi3_highpart"
5276   [(set (match_operand:V8HI 0 "register_operand" "=x")
5277         (truncate:V8HI
5278           (lshiftrt:V8SI
5279             (mult:V8SI
5280               (sign_extend:V8SI
5281                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5282               (sign_extend:V8SI
5283                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5284             (const_int 16))))]
5285   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5286   "pmulhw\t{%2, %0|%0, %2}"
5287   [(set_attr "type" "sseimul")
5288    (set_attr "prefix_data16" "1")
5289    (set_attr "mode" "TI")])
5290
5291 (define_expand "umulv8hi3_highpart"
5292   [(set (match_operand:V8HI 0 "register_operand" "")
5293         (truncate:V8HI
5294           (lshiftrt:V8SI
5295             (mult:V8SI
5296               (zero_extend:V8SI
5297                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
5298               (zero_extend:V8SI
5299                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
5300             (const_int 16))))]
5301   "TARGET_SSE2"
5302   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5303
5304 (define_insn "*avx_umulv8hi3_highpart"
5305   [(set (match_operand:V8HI 0 "register_operand" "=x")
5306         (truncate:V8HI
5307           (lshiftrt:V8SI
5308             (mult:V8SI
5309               (zero_extend:V8SI
5310                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
5311               (zero_extend:V8SI
5312                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5313             (const_int 16))))]
5314   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5315   "vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
5316   [(set_attr "type" "sseimul")
5317    (set_attr "prefix" "vex")
5318    (set_attr "mode" "TI")])
5319
5320 (define_insn "*umulv8hi3_highpart"
5321   [(set (match_operand:V8HI 0 "register_operand" "=x")
5322         (truncate:V8HI
5323           (lshiftrt:V8SI
5324             (mult:V8SI
5325               (zero_extend:V8SI
5326                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5327               (zero_extend:V8SI
5328                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5329             (const_int 16))))]
5330   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5331   "pmulhuw\t{%2, %0|%0, %2}"
5332   [(set_attr "type" "sseimul")
5333    (set_attr "prefix_data16" "1")
5334    (set_attr "mode" "TI")])
5335
5336 (define_expand "sse2_umulv2siv2di3"
5337   [(set (match_operand:V2DI 0 "register_operand" "")
5338         (mult:V2DI
5339           (zero_extend:V2DI
5340             (vec_select:V2SI
5341               (match_operand:V4SI 1 "nonimmediate_operand" "")
5342               (parallel [(const_int 0) (const_int 2)])))
5343           (zero_extend:V2DI
5344             (vec_select:V2SI
5345               (match_operand:V4SI 2 "nonimmediate_operand" "")
5346               (parallel [(const_int 0) (const_int 2)])))))]
5347   "TARGET_SSE2"
5348   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5349
5350 (define_insn "*avx_umulv2siv2di3"
5351   [(set (match_operand:V2DI 0 "register_operand" "=x")
5352         (mult:V2DI
5353           (zero_extend:V2DI
5354             (vec_select:V2SI
5355               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5356               (parallel [(const_int 0) (const_int 2)])))
5357           (zero_extend:V2DI
5358             (vec_select:V2SI
5359               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5360               (parallel [(const_int 0) (const_int 2)])))))]
5361   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5362   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5363   [(set_attr "type" "sseimul")
5364    (set_attr "prefix" "vex")
5365    (set_attr "mode" "TI")])
5366
5367 (define_insn "*sse2_umulv2siv2di3"
5368   [(set (match_operand:V2DI 0 "register_operand" "=x")
5369         (mult:V2DI
5370           (zero_extend:V2DI
5371             (vec_select:V2SI
5372               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5373               (parallel [(const_int 0) (const_int 2)])))
5374           (zero_extend:V2DI
5375             (vec_select:V2SI
5376               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5377               (parallel [(const_int 0) (const_int 2)])))))]
5378   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5379   "pmuludq\t{%2, %0|%0, %2}"
5380   [(set_attr "type" "sseimul")
5381    (set_attr "prefix_data16" "1")
5382    (set_attr "mode" "TI")])
5383
5384 (define_expand "sse4_1_mulv2siv2di3"
5385   [(set (match_operand:V2DI 0 "register_operand" "")
5386         (mult:V2DI
5387           (sign_extend:V2DI
5388             (vec_select:V2SI
5389               (match_operand:V4SI 1 "nonimmediate_operand" "")
5390               (parallel [(const_int 0) (const_int 2)])))
5391           (sign_extend:V2DI
5392             (vec_select:V2SI
5393               (match_operand:V4SI 2 "nonimmediate_operand" "")
5394               (parallel [(const_int 0) (const_int 2)])))))]
5395   "TARGET_SSE4_1"
5396   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5397
5398 (define_insn "*avx_mulv2siv2di3"
5399   [(set (match_operand:V2DI 0 "register_operand" "=x")
5400         (mult:V2DI
5401           (sign_extend:V2DI
5402             (vec_select:V2SI
5403               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5404               (parallel [(const_int 0) (const_int 2)])))
5405           (sign_extend:V2DI
5406             (vec_select:V2SI
5407               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5408               (parallel [(const_int 0) (const_int 2)])))))]
5409   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5410   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5411   [(set_attr "type" "sseimul")
5412    (set_attr "prefix_extra" "1")
5413    (set_attr "prefix" "vex")
5414    (set_attr "mode" "TI")])
5415
5416 (define_insn "*sse4_1_mulv2siv2di3"
5417   [(set (match_operand:V2DI 0 "register_operand" "=x")
5418         (mult:V2DI
5419           (sign_extend:V2DI
5420             (vec_select:V2SI
5421               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5422               (parallel [(const_int 0) (const_int 2)])))
5423           (sign_extend:V2DI
5424             (vec_select:V2SI
5425               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5426               (parallel [(const_int 0) (const_int 2)])))))]
5427   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5428   "pmuldq\t{%2, %0|%0, %2}"
5429   [(set_attr "type" "sseimul")
5430    (set_attr "prefix_extra" "1")
5431    (set_attr "mode" "TI")])
5432
5433 (define_expand "sse2_pmaddwd"
5434   [(set (match_operand:V4SI 0 "register_operand" "")
5435         (plus:V4SI
5436           (mult:V4SI
5437             (sign_extend:V4SI
5438               (vec_select:V4HI
5439                 (match_operand:V8HI 1 "nonimmediate_operand" "")
5440                 (parallel [(const_int 0)
5441                            (const_int 2)
5442                            (const_int 4)
5443                            (const_int 6)])))
5444             (sign_extend:V4SI
5445               (vec_select:V4HI
5446                 (match_operand:V8HI 2 "nonimmediate_operand" "")
5447                 (parallel [(const_int 0)
5448                            (const_int 2)
5449                            (const_int 4)
5450                            (const_int 6)]))))
5451           (mult:V4SI
5452             (sign_extend:V4SI
5453               (vec_select:V4HI (match_dup 1)
5454                 (parallel [(const_int 1)
5455                            (const_int 3)
5456                            (const_int 5)
5457                            (const_int 7)])))
5458             (sign_extend:V4SI
5459               (vec_select:V4HI (match_dup 2)
5460                 (parallel [(const_int 1)
5461                            (const_int 3)
5462                            (const_int 5)
5463                            (const_int 7)]))))))]
5464   "TARGET_SSE2"
5465   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5466
5467 (define_insn "*avx_pmaddwd"
5468   [(set (match_operand:V4SI 0 "register_operand" "=x")
5469         (plus:V4SI
5470           (mult:V4SI
5471             (sign_extend:V4SI
5472               (vec_select:V4HI
5473                 (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5474                 (parallel [(const_int 0)
5475                            (const_int 2)
5476                            (const_int 4)
5477                            (const_int 6)])))
5478             (sign_extend:V4SI
5479               (vec_select:V4HI
5480                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5481                 (parallel [(const_int 0)
5482                            (const_int 2)
5483                            (const_int 4)
5484                            (const_int 6)]))))
5485           (mult:V4SI
5486             (sign_extend:V4SI
5487               (vec_select:V4HI (match_dup 1)
5488                 (parallel [(const_int 1)
5489                            (const_int 3)
5490                            (const_int 5)
5491                            (const_int 7)])))
5492             (sign_extend:V4SI
5493               (vec_select:V4HI (match_dup 2)
5494                 (parallel [(const_int 1)
5495                            (const_int 3)
5496                            (const_int 5)
5497                            (const_int 7)]))))))]
5498   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5499   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5500   [(set_attr "type" "sseiadd")
5501    (set_attr "prefix" "vex")
5502    (set_attr "mode" "TI")])
5503
5504 (define_insn "*sse2_pmaddwd"
5505   [(set (match_operand:V4SI 0 "register_operand" "=x")
5506         (plus:V4SI
5507           (mult:V4SI
5508             (sign_extend:V4SI
5509               (vec_select:V4HI
5510                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5511                 (parallel [(const_int 0)
5512                            (const_int 2)
5513                            (const_int 4)
5514                            (const_int 6)])))
5515             (sign_extend:V4SI
5516               (vec_select:V4HI
5517                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5518                 (parallel [(const_int 0)
5519                            (const_int 2)
5520                            (const_int 4)
5521                            (const_int 6)]))))
5522           (mult:V4SI
5523             (sign_extend:V4SI
5524               (vec_select:V4HI (match_dup 1)
5525                 (parallel [(const_int 1)
5526                            (const_int 3)
5527                            (const_int 5)
5528                            (const_int 7)])))
5529             (sign_extend:V4SI
5530               (vec_select:V4HI (match_dup 2)
5531                 (parallel [(const_int 1)
5532                            (const_int 3)
5533                            (const_int 5)
5534                            (const_int 7)]))))))]
5535   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5536   "pmaddwd\t{%2, %0|%0, %2}"
5537   [(set_attr "type" "sseiadd")
5538    (set_attr "atom_unit" "simul")
5539    (set_attr "prefix_data16" "1")
5540    (set_attr "mode" "TI")])
5541
5542 (define_expand "mulv4si3"
5543   [(set (match_operand:V4SI 0 "register_operand" "")
5544         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5545                    (match_operand:V4SI 2 "register_operand" "")))]
5546   "TARGET_SSE2"
5547 {
5548   if (TARGET_SSE4_1 || TARGET_AVX)
5549     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
5550 })
5551
5552 (define_insn "*avx_mulv4si3"
5553   [(set (match_operand:V4SI 0 "register_operand" "=x")
5554         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5555                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5556   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5557   "vpmulld\t{%2, %1, %0|%0, %1, %2}"
5558   [(set_attr "type" "sseimul")
5559    (set_attr "prefix_extra" "1")
5560    (set_attr "prefix" "vex")
5561    (set_attr "mode" "TI")])
5562
5563 (define_insn "*sse4_1_mulv4si3"
5564   [(set (match_operand:V4SI 0 "register_operand" "=x")
5565         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5566                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5567   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5568   "pmulld\t{%2, %0|%0, %2}"
5569   [(set_attr "type" "sseimul")
5570    (set_attr "prefix_extra" "1")
5571    (set_attr "mode" "TI")])
5572
5573 (define_insn_and_split "*sse2_mulv4si3"
5574   [(set (match_operand:V4SI 0 "register_operand" "")
5575         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5576                    (match_operand:V4SI 2 "register_operand" "")))]
5577   "TARGET_SSE2 && !TARGET_SSE4_1 && !TARGET_AVX
5578    && can_create_pseudo_p ()"
5579   "#"
5580   "&& 1"
5581   [(const_int 0)]
5582 {
5583   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5584   rtx op0, op1, op2;
5585
5586   op0 = operands[0];
5587   op1 = operands[1];
5588   op2 = operands[2];
5589   t1 = gen_reg_rtx (V4SImode);
5590   t2 = gen_reg_rtx (V4SImode);
5591   t3 = gen_reg_rtx (V4SImode);
5592   t4 = gen_reg_rtx (V4SImode);
5593   t5 = gen_reg_rtx (V4SImode);
5594   t6 = gen_reg_rtx (V4SImode);
5595   thirtytwo = GEN_INT (32);
5596
5597   /* Multiply elements 2 and 0.  */
5598   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
5599                                      op1, op2));
5600
5601   /* Shift both input vectors down one element, so that elements 3
5602      and 1 are now in the slots for elements 2 and 0.  For K8, at
5603      least, this is faster than using a shuffle.  */
5604   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5605                                  gen_lowpart (V1TImode, op1),
5606                                  thirtytwo));
5607   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5608                                  gen_lowpart (V1TImode, op2),
5609                                  thirtytwo));
5610   /* Multiply elements 3 and 1.  */
5611   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
5612                                      t2, t3));
5613
5614   /* Move the results in element 2 down to element 1; we don't care
5615      what goes in elements 2 and 3.  */
5616   emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
5617                                 const0_rtx, const0_rtx));
5618   emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
5619                                 const0_rtx, const0_rtx));
5620
5621   /* Merge the parts back together.  */
5622   emit_insn (gen_vec_interleave_lowv4si (op0, t5, t6));
5623   DONE;
5624 })
5625
5626 (define_insn_and_split "mulv2di3"
5627   [(set (match_operand:V2DI 0 "register_operand" "")
5628         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
5629                    (match_operand:V2DI 2 "register_operand" "")))]
5630   "TARGET_SSE2
5631    && can_create_pseudo_p ()"
5632   "#"
5633   "&& 1"
5634   [(const_int 0)]
5635 {
5636   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5637   rtx op0, op1, op2;
5638
5639   op0 = operands[0];
5640   op1 = operands[1];
5641   op2 = operands[2];
5642
5643   if (TARGET_XOP)
5644     {
5645       /* op1: A,B,C,D, op2: E,F,G,H */
5646       op1 = gen_lowpart (V4SImode, op1);
5647       op2 = gen_lowpart (V4SImode, op2);
5648
5649       t1 = gen_reg_rtx (V4SImode);
5650       t2 = gen_reg_rtx (V4SImode);
5651       t3 = gen_reg_rtx (V2DImode);
5652       t4 = gen_reg_rtx (V2DImode);
5653
5654       /* t1: B,A,D,C */
5655       emit_insn (gen_sse2_pshufd_1 (t1, op1,
5656                                     GEN_INT (1),
5657                                     GEN_INT (0),
5658                                     GEN_INT (3),
5659                                     GEN_INT (2)));
5660
5661       /* t2: (B*E),(A*F),(D*G),(C*H) */
5662       emit_insn (gen_mulv4si3 (t2, t1, op2));
5663
5664       /* t4: (B*E)+(A*F), (D*G)+(C*H) */
5665       emit_insn (gen_xop_phadddq (t3, t2));
5666
5667       /* t5: ((B*E)+(A*F))<<32, ((D*G)+(C*H))<<32 */
5668       emit_insn (gen_ashlv2di3 (t4, t3, GEN_INT (32)));
5669
5670       /* op0: (((B*E)+(A*F))<<32)+(B*F), (((D*G)+(C*H))<<32)+(D*H) */
5671       emit_insn (gen_xop_pmacsdql (op0, op1, op2, t4));
5672     }
5673   else
5674     {
5675       t1 = gen_reg_rtx (V2DImode);
5676       t2 = gen_reg_rtx (V2DImode);
5677       t3 = gen_reg_rtx (V2DImode);
5678       t4 = gen_reg_rtx (V2DImode);
5679       t5 = gen_reg_rtx (V2DImode);
5680       t6 = gen_reg_rtx (V2DImode);
5681       thirtytwo = GEN_INT (32);
5682
5683       /* Multiply low parts.  */
5684       emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
5685                                          gen_lowpart (V4SImode, op2)));
5686
5687       /* Shift input vectors left 32 bits so we can multiply high parts.  */
5688       emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
5689       emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
5690
5691       /* Multiply high parts by low parts.  */
5692       emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
5693                                          gen_lowpart (V4SImode, t3)));
5694       emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
5695                                          gen_lowpart (V4SImode, t2)));
5696
5697       /* Shift them back.  */
5698       emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
5699       emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
5700
5701       /* Add the three parts together.  */
5702       emit_insn (gen_addv2di3 (t6, t1, t4));
5703       emit_insn (gen_addv2di3 (op0, t6, t5));
5704     }
5705   DONE;
5706 })
5707
5708 (define_expand "vec_widen_smult_hi_v8hi"
5709   [(match_operand:V4SI 0 "register_operand" "")
5710    (match_operand:V8HI 1 "register_operand" "")
5711    (match_operand:V8HI 2 "register_operand" "")]
5712   "TARGET_SSE2"
5713 {
5714   rtx op1, op2, t1, t2, dest;
5715
5716   op1 = operands[1];
5717   op2 = operands[2];
5718   t1 = gen_reg_rtx (V8HImode);
5719   t2 = gen_reg_rtx (V8HImode);
5720   dest = gen_lowpart (V8HImode, operands[0]);
5721
5722   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5723   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5724   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5725   DONE;
5726 })
5727
5728 (define_expand "vec_widen_smult_lo_v8hi"
5729   [(match_operand:V4SI 0 "register_operand" "")
5730    (match_operand:V8HI 1 "register_operand" "")
5731    (match_operand:V8HI 2 "register_operand" "")]
5732   "TARGET_SSE2"
5733 {
5734   rtx op1, op2, t1, t2, dest;
5735
5736   op1 = operands[1];
5737   op2 = operands[2];
5738   t1 = gen_reg_rtx (V8HImode);
5739   t2 = gen_reg_rtx (V8HImode);
5740   dest = gen_lowpart (V8HImode, operands[0]);
5741
5742   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5743   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5744   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5745   DONE;
5746 })
5747
5748 (define_expand "vec_widen_umult_hi_v8hi"
5749   [(match_operand:V4SI 0 "register_operand" "")
5750    (match_operand:V8HI 1 "register_operand" "")
5751    (match_operand:V8HI 2 "register_operand" "")]
5752   "TARGET_SSE2"
5753 {
5754   rtx op1, op2, t1, t2, dest;
5755
5756   op1 = operands[1];
5757   op2 = operands[2];
5758   t1 = gen_reg_rtx (V8HImode);
5759   t2 = gen_reg_rtx (V8HImode);
5760   dest = gen_lowpart (V8HImode, operands[0]);
5761
5762   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5763   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5764   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5765   DONE;
5766 })
5767
5768 (define_expand "vec_widen_umult_lo_v8hi"
5769   [(match_operand:V4SI 0 "register_operand" "")
5770    (match_operand:V8HI 1 "register_operand" "")
5771    (match_operand:V8HI 2 "register_operand" "")]
5772   "TARGET_SSE2"
5773 {
5774   rtx op1, op2, t1, t2, dest;
5775
5776   op1 = operands[1];
5777   op2 = operands[2];
5778   t1 = gen_reg_rtx (V8HImode);
5779   t2 = gen_reg_rtx (V8HImode);
5780   dest = gen_lowpart (V8HImode, operands[0]);
5781
5782   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5783   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5784   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5785   DONE;
5786 })
5787
5788 (define_expand "vec_widen_smult_hi_v4si"
5789   [(match_operand:V2DI 0 "register_operand" "")
5790    (match_operand:V4SI 1 "register_operand" "")
5791    (match_operand:V4SI 2 "register_operand" "")]
5792   "TARGET_XOP"
5793 {
5794   rtx t1, t2;
5795
5796   t1 = gen_reg_rtx (V4SImode);
5797   t2 = gen_reg_rtx (V4SImode);
5798
5799   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5800                                 GEN_INT (0),
5801                                 GEN_INT (2),
5802                                 GEN_INT (1),
5803                                 GEN_INT (3)));
5804   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5805                                 GEN_INT (0),
5806                                 GEN_INT (2),
5807                                 GEN_INT (1),
5808                                 GEN_INT (3)));
5809   emit_insn (gen_xop_mulv2div2di3_high (operands[0], t1, t2));
5810   DONE;
5811 })
5812
5813 (define_expand "vec_widen_smult_lo_v4si"
5814   [(match_operand:V2DI 0 "register_operand" "")
5815    (match_operand:V4SI 1 "register_operand" "")
5816    (match_operand:V4SI 2 "register_operand" "")]
5817   "TARGET_XOP"
5818 {
5819   rtx t1, t2;
5820
5821   t1 = gen_reg_rtx (V4SImode);
5822   t2 = gen_reg_rtx (V4SImode);
5823
5824   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5825                                 GEN_INT (0),
5826                                 GEN_INT (2),
5827                                 GEN_INT (1),
5828                                 GEN_INT (3)));
5829   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5830                                 GEN_INT (0),
5831                                 GEN_INT (2),
5832                                 GEN_INT (1),
5833                                 GEN_INT (3)));
5834   emit_insn (gen_xop_mulv2div2di3_low (operands[0], t1, t2));
5835   DONE;
5836 })
5837
5838 (define_expand "vec_widen_umult_hi_v4si"
5839   [(match_operand:V2DI 0 "register_operand" "")
5840    (match_operand:V4SI 1 "register_operand" "")
5841    (match_operand:V4SI 2 "register_operand" "")]
5842   "TARGET_SSE2"
5843 {
5844   rtx op1, op2, t1, t2;
5845
5846   op1 = operands[1];
5847   op2 = operands[2];
5848   t1 = gen_reg_rtx (V4SImode);
5849   t2 = gen_reg_rtx (V4SImode);
5850
5851   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
5852   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
5853   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5854   DONE;
5855 })
5856
5857 (define_expand "vec_widen_umult_lo_v4si"
5858   [(match_operand:V2DI 0 "register_operand" "")
5859    (match_operand:V4SI 1 "register_operand" "")
5860    (match_operand:V4SI 2 "register_operand" "")]
5861   "TARGET_SSE2"
5862 {
5863   rtx op1, op2, t1, t2;
5864
5865   op1 = operands[1];
5866   op2 = operands[2];
5867   t1 = gen_reg_rtx (V4SImode);
5868   t2 = gen_reg_rtx (V4SImode);
5869
5870   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
5871   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
5872   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5873   DONE;
5874 })
5875
5876 (define_expand "sdot_prodv8hi"
5877   [(match_operand:V4SI 0 "register_operand" "")
5878    (match_operand:V8HI 1 "register_operand" "")
5879    (match_operand:V8HI 2 "register_operand" "")
5880    (match_operand:V4SI 3 "register_operand" "")]
5881   "TARGET_SSE2"
5882 {
5883   rtx t = gen_reg_rtx (V4SImode);
5884   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
5885   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
5886   DONE;
5887 })
5888
5889 (define_expand "udot_prodv4si"
5890   [(match_operand:V2DI 0 "register_operand" "")
5891    (match_operand:V4SI 1 "register_operand" "")
5892    (match_operand:V4SI 2 "register_operand" "")
5893    (match_operand:V2DI 3 "register_operand" "")]
5894   "TARGET_SSE2"
5895 {
5896   rtx t1, t2, t3, t4;
5897
5898   t1 = gen_reg_rtx (V2DImode);
5899   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
5900   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
5901
5902   t2 = gen_reg_rtx (V4SImode);
5903   t3 = gen_reg_rtx (V4SImode);
5904   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5905                                  gen_lowpart (V1TImode, operands[1]),
5906                                  GEN_INT (32)));
5907   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5908                                  gen_lowpart (V1TImode, operands[2]),
5909                                  GEN_INT (32)));
5910
5911   t4 = gen_reg_rtx (V2DImode);
5912   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
5913
5914   emit_insn (gen_addv2di3 (operands[0], t1, t4));
5915   DONE;
5916 })
5917
5918 (define_insn "*avx_ashr<mode>3"
5919   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5920         (ashiftrt:SSEMODE24
5921           (match_operand:SSEMODE24 1 "register_operand" "x")
5922           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5923   "TARGET_AVX"
5924   "vpsra<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5925   [(set_attr "type" "sseishft")
5926    (set_attr "prefix" "vex")
5927    (set (attr "length_immediate")
5928      (if_then_else (match_operand 2 "const_int_operand" "")
5929        (const_string "1")
5930        (const_string "0")))
5931    (set_attr "mode" "TI")])
5932
5933 (define_insn "ashr<mode>3"
5934   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5935         (ashiftrt:SSEMODE24
5936           (match_operand:SSEMODE24 1 "register_operand" "0")
5937           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5938   "TARGET_SSE2"
5939   "psra<ssevecsize>\t{%2, %0|%0, %2}"
5940   [(set_attr "type" "sseishft")
5941    (set_attr "prefix_data16" "1")
5942    (set (attr "length_immediate")
5943      (if_then_else (match_operand 2 "const_int_operand" "")
5944        (const_string "1")
5945        (const_string "0")))
5946    (set_attr "mode" "TI")])
5947
5948 (define_insn "*avx_lshrv1ti3"
5949   [(set (match_operand:V1TI 0 "register_operand" "=x")
5950         (lshiftrt:V1TI
5951          (match_operand:V1TI 1 "register_operand" "x")
5952          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5953   "TARGET_AVX"
5954 {
5955   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5956   return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5957 }
5958   [(set_attr "type" "sseishft")
5959    (set_attr "prefix" "vex")
5960    (set_attr "length_immediate" "1")
5961    (set_attr "mode" "TI")])
5962
5963 (define_insn "*avx_lshr<mode>3"
5964   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5965         (lshiftrt:SSEMODE248
5966           (match_operand:SSEMODE248 1 "register_operand" "x")
5967           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5968   "TARGET_AVX"
5969   "vpsrl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5970   [(set_attr "type" "sseishft")
5971    (set_attr "prefix" "vex")
5972    (set (attr "length_immediate")
5973      (if_then_else (match_operand 2 "const_int_operand" "")
5974        (const_string "1")
5975        (const_string "0")))
5976    (set_attr "mode" "TI")])
5977
5978 (define_insn "sse2_lshrv1ti3"
5979   [(set (match_operand:V1TI 0 "register_operand" "=x")
5980         (lshiftrt:V1TI
5981          (match_operand:V1TI 1 "register_operand" "0")
5982          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5983   "TARGET_SSE2"
5984 {
5985   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5986   return "psrldq\t{%2, %0|%0, %2}";
5987 }
5988   [(set_attr "type" "sseishft")
5989    (set_attr "prefix_data16" "1")
5990    (set_attr "length_immediate" "1")
5991    (set_attr "atom_unit" "sishuf")
5992    (set_attr "mode" "TI")])
5993
5994 (define_insn "lshr<mode>3"
5995   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5996         (lshiftrt:SSEMODE248
5997           (match_operand:SSEMODE248 1 "register_operand" "0")
5998           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5999   "TARGET_SSE2"
6000   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
6001   [(set_attr "type" "sseishft")
6002    (set_attr "prefix_data16" "1")
6003    (set (attr "length_immediate")
6004      (if_then_else (match_operand 2 "const_int_operand" "")
6005        (const_string "1")
6006        (const_string "0")))
6007    (set_attr "mode" "TI")])
6008
6009 (define_insn "*avx_ashlv1ti3"
6010   [(set (match_operand:V1TI 0 "register_operand" "=x")
6011         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "x")
6012                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
6013   "TARGET_AVX"
6014 {
6015   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
6016   return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
6017 }
6018   [(set_attr "type" "sseishft")
6019    (set_attr "prefix" "vex")
6020    (set_attr "length_immediate" "1")
6021    (set_attr "mode" "TI")])
6022
6023 (define_insn "*avx_ashl<mode>3"
6024   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
6025         (ashift:SSEMODE248
6026           (match_operand:SSEMODE248 1 "register_operand" "x")
6027           (match_operand:SI 2 "nonmemory_operand" "xN")))]
6028   "TARGET_AVX"
6029   "vpsll<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6030   [(set_attr "type" "sseishft")
6031    (set_attr "prefix" "vex")
6032    (set (attr "length_immediate")
6033      (if_then_else (match_operand 2 "const_int_operand" "")
6034        (const_string "1")
6035        (const_string "0")))
6036    (set_attr "mode" "TI")])
6037
6038 (define_insn "sse2_ashlv1ti3"
6039   [(set (match_operand:V1TI 0 "register_operand" "=x")
6040         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "0")
6041                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
6042   "TARGET_SSE2"
6043 {
6044   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
6045   return "pslldq\t{%2, %0|%0, %2}";
6046 }
6047   [(set_attr "type" "sseishft")
6048    (set_attr "prefix_data16" "1")
6049    (set_attr "length_immediate" "1")
6050    (set_attr "mode" "TI")])
6051
6052 (define_insn "ashl<mode>3"
6053   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
6054         (ashift:SSEMODE248
6055           (match_operand:SSEMODE248 1 "register_operand" "0")
6056           (match_operand:SI 2 "nonmemory_operand" "xN")))]
6057   "TARGET_SSE2"
6058   "psll<ssevecsize>\t{%2, %0|%0, %2}"
6059   [(set_attr "type" "sseishft")
6060    (set_attr "prefix_data16" "1")
6061    (set (attr "length_immediate")
6062      (if_then_else (match_operand 2 "const_int_operand" "")
6063        (const_string "1")
6064        (const_string "0")))
6065    (set_attr "mode" "TI")])
6066
6067 (define_expand "vec_shl_<mode>"
6068   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6069         (ashift:V1TI
6070          (match_operand:SSEMODEI 1 "register_operand" "")
6071          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6072   "TARGET_SSE2"
6073 {
6074   operands[0] = gen_lowpart (V1TImode, operands[0]);
6075   operands[1] = gen_lowpart (V1TImode, operands[1]);
6076 })
6077
6078 (define_expand "vec_shr_<mode>"
6079   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6080         (lshiftrt:V1TI
6081          (match_operand:SSEMODEI 1 "register_operand" "")
6082          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6083   "TARGET_SSE2"
6084 {
6085   operands[0] = gen_lowpart (V1TImode, operands[0]);
6086   operands[1] = gen_lowpart (V1TImode, operands[1]);
6087 })
6088
6089 (define_insn "*avx_<code><mode>3"
6090   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6091         (maxmin:SSEMODE124
6092           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
6093           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6094   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6095   "vp<maxmin_int><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6096   [(set_attr "type" "sseiadd")
6097    (set (attr "prefix_extra")
6098      (if_then_else
6099        (ne (symbol_ref "<MODE>mode != ((<CODE> == SMAX || <CODE> == SMIN) ? V8HImode : V16QImode)")
6100            (const_int 0))
6101        (const_string "1")
6102        (const_string "0")))
6103    (set_attr "prefix" "vex")
6104    (set_attr "mode" "TI")])
6105
6106 (define_expand "<code>v16qi3"
6107   [(set (match_operand:V16QI 0 "register_operand" "")
6108         (umaxmin:V16QI
6109           (match_operand:V16QI 1 "nonimmediate_operand" "")
6110           (match_operand:V16QI 2 "nonimmediate_operand" "")))]
6111   "TARGET_SSE2"
6112   "ix86_fixup_binary_operands_no_copy (<CODE>, V16QImode, operands);")
6113
6114 (define_insn "*<code>v16qi3"
6115   [(set (match_operand:V16QI 0 "register_operand" "=x")
6116         (umaxmin:V16QI
6117           (match_operand:V16QI 1 "nonimmediate_operand" "%0")
6118           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
6119   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
6120   "p<maxmin_int>b\t{%2, %0|%0, %2}"
6121   [(set_attr "type" "sseiadd")
6122    (set_attr "prefix_data16" "1")
6123    (set_attr "mode" "TI")])
6124
6125 (define_expand "<code>v8hi3"
6126   [(set (match_operand:V8HI 0 "register_operand" "")
6127         (smaxmin:V8HI
6128           (match_operand:V8HI 1 "nonimmediate_operand" "")
6129           (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6130   "TARGET_SSE2"
6131   "ix86_fixup_binary_operands_no_copy (<CODE>, V8HImode, operands);")
6132
6133 (define_insn "*<code>v8hi3"
6134   [(set (match_operand:V8HI 0 "register_operand" "=x")
6135         (smaxmin:V8HI
6136           (match_operand:V8HI 1 "nonimmediate_operand" "%0")
6137           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
6138   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
6139   "p<maxmin_int>w\t{%2, %0|%0, %2}"
6140   [(set_attr "type" "sseiadd")
6141    (set_attr "prefix_data16" "1")
6142    (set_attr "mode" "TI")])
6143
6144 (define_expand "umaxv8hi3"
6145   [(set (match_operand:V8HI 0 "register_operand" "")
6146         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
6147                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6148   "TARGET_SSE2"
6149 {
6150   if (TARGET_SSE4_1)
6151     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
6152   else
6153     {
6154       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
6155       if (rtx_equal_p (op3, op2))
6156         op3 = gen_reg_rtx (V8HImode);
6157       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
6158       emit_insn (gen_addv8hi3 (op0, op3, op2));
6159       DONE;
6160     }
6161 })
6162
6163 (define_expand "smax<mode>3"
6164   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6165         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6166                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6167   "TARGET_SSE2"
6168 {
6169   if (TARGET_SSE4_1)
6170     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
6171   else
6172   {
6173     rtx xops[6];
6174     bool ok;
6175
6176     xops[0] = operands[0];
6177     xops[1] = operands[1];
6178     xops[2] = operands[2];
6179     xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6180     xops[4] = operands[1];
6181     xops[5] = operands[2];
6182     ok = ix86_expand_int_vcond (xops);
6183     gcc_assert (ok);
6184     DONE;
6185   }
6186 })
6187
6188 (define_insn "*sse4_1_<code><mode>3"
6189   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
6190         (smaxmin:SSEMODE14
6191           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
6192           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
6193   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6194   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6195   [(set_attr "type" "sseiadd")
6196    (set_attr "prefix_extra" "1")
6197    (set_attr "mode" "TI")])
6198
6199 (define_expand "smaxv2di3"
6200   [(set (match_operand:V2DI 0 "register_operand" "")
6201         (smax:V2DI (match_operand:V2DI 1 "register_operand" "")
6202                    (match_operand:V2DI 2 "register_operand" "")))]
6203   "TARGET_SSE4_2"
6204 {
6205   rtx xops[6];
6206   bool ok;
6207
6208   xops[0] = operands[0];
6209   xops[1] = operands[1];
6210   xops[2] = operands[2];
6211   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6212   xops[4] = operands[1];
6213   xops[5] = operands[2];
6214   ok = ix86_expand_int_vcond (xops);
6215   gcc_assert (ok);
6216   DONE;
6217 })
6218
6219 (define_expand "umaxv4si3"
6220   [(set (match_operand:V4SI 0 "register_operand" "")
6221         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
6222                    (match_operand:V4SI 2 "register_operand" "")))]
6223   "TARGET_SSE2"
6224 {
6225   if (TARGET_SSE4_1)
6226     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
6227   else
6228   {
6229     rtx xops[6];
6230     bool ok;
6231
6232     xops[0] = operands[0];
6233     xops[1] = operands[1];
6234     xops[2] = operands[2];
6235     xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6236     xops[4] = operands[1];
6237     xops[5] = operands[2];
6238     ok = ix86_expand_int_vcond (xops);
6239     gcc_assert (ok);
6240     DONE;
6241   }
6242 })
6243
6244 (define_insn "*sse4_1_<code><mode>3"
6245   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
6246         (umaxmin:SSEMODE24
6247           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
6248           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
6249   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6250   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6251   [(set_attr "type" "sseiadd")
6252    (set_attr "prefix_extra" "1")
6253    (set_attr "mode" "TI")])
6254
6255 (define_expand "umaxv2di3"
6256   [(set (match_operand:V2DI 0 "register_operand" "")
6257         (umax:V2DI (match_operand:V2DI 1 "register_operand" "")
6258                    (match_operand:V2DI 2 "register_operand" "")))]
6259   "TARGET_SSE4_2"
6260 {
6261   rtx xops[6];
6262   bool ok;
6263
6264   xops[0] = operands[0];
6265   xops[1] = operands[1];
6266   xops[2] = operands[2];
6267   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6268   xops[4] = operands[1];
6269   xops[5] = operands[2];
6270   ok = ix86_expand_int_vcond (xops);
6271   gcc_assert (ok);
6272   DONE;
6273 })
6274
6275 (define_expand "smin<mode>3"
6276   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6277         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6278                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6279   "TARGET_SSE2"
6280 {
6281   if (TARGET_SSE4_1)
6282     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
6283   else
6284     {
6285       rtx xops[6];
6286       bool ok;
6287
6288       xops[0] = operands[0];
6289       xops[1] = operands[2];
6290       xops[2] = operands[1];
6291       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6292       xops[4] = operands[1];
6293       xops[5] = operands[2];
6294       ok = ix86_expand_int_vcond (xops);
6295       gcc_assert (ok);
6296       DONE;
6297     }
6298 })
6299
6300 (define_expand "sminv2di3"
6301   [(set (match_operand:V2DI 0 "register_operand" "")
6302         (smin:V2DI (match_operand:V2DI 1 "register_operand" "")
6303                    (match_operand:V2DI 2 "register_operand" "")))]
6304   "TARGET_SSE4_2"
6305 {
6306   rtx xops[6];
6307   bool ok;
6308
6309   xops[0] = operands[0];
6310   xops[1] = operands[2];
6311   xops[2] = operands[1];
6312   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6313   xops[4] = operands[1];
6314   xops[5] = operands[2];
6315   ok = ix86_expand_int_vcond (xops);
6316   gcc_assert (ok);
6317   DONE;
6318 })
6319
6320 (define_expand "umin<mode>3"
6321   [(set (match_operand:SSEMODE24 0 "register_operand" "")
6322         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
6323                         (match_operand:SSEMODE24 2 "register_operand" "")))]
6324   "TARGET_SSE2"
6325 {
6326   if (TARGET_SSE4_1)
6327     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
6328   else
6329     {
6330       rtx xops[6];
6331       bool ok;
6332
6333       xops[0] = operands[0];
6334       xops[1] = operands[2];
6335       xops[2] = operands[1];
6336       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6337       xops[4] = operands[1];
6338       xops[5] = operands[2];
6339       ok = ix86_expand_int_vcond (xops);
6340       gcc_assert (ok);
6341       DONE;
6342     }
6343 })
6344
6345 (define_expand "uminv2di3"
6346   [(set (match_operand:V2DI 0 "register_operand" "")
6347         (umin:V2DI (match_operand:V2DI 1 "register_operand" "")
6348                    (match_operand:V2DI 2 "register_operand" "")))]
6349   "TARGET_SSE4_2"
6350 {
6351   rtx xops[6];
6352   bool ok;
6353
6354   xops[0] = operands[0];
6355   xops[1] = operands[2];
6356   xops[2] = operands[1];
6357   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6358   xops[4] = operands[1];
6359   xops[5] = operands[2];
6360   ok = ix86_expand_int_vcond (xops);
6361   gcc_assert (ok);
6362   DONE;
6363 })
6364
6365 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6366 ;;
6367 ;; Parallel integral comparisons
6368 ;;
6369 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6370
6371 (define_expand "sse2_eq<mode>3"
6372   [(set (match_operand:SSEMODE124 0 "register_operand" "")
6373         (eq:SSEMODE124
6374           (match_operand:SSEMODE124 1 "nonimmediate_operand" "")
6375           (match_operand:SSEMODE124 2 "nonimmediate_operand" "")))]
6376   "TARGET_SSE2 && !TARGET_XOP "
6377   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
6378
6379 (define_insn "*avx_eq<mode>3"
6380   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6381         (eq:SSEMODE1248
6382           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "%x")
6383           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6384   "TARGET_AVX && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6385   "vpcmpeq<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6386   [(set_attr "type" "ssecmp")
6387    (set (attr "prefix_extra")
6388      (if_then_else (match_operand:V2DI 0 "" "")
6389        (const_string "1")
6390        (const_string "*")))
6391    (set_attr "prefix" "vex")
6392    (set_attr "mode" "TI")])
6393
6394 (define_insn "*sse2_eq<mode>3"
6395   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6396         (eq:SSEMODE124
6397           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
6398           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6399   "TARGET_SSE2 && !TARGET_XOP
6400    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6401   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
6402   [(set_attr "type" "ssecmp")
6403    (set_attr "prefix_data16" "1")
6404    (set_attr "mode" "TI")])
6405
6406 (define_expand "sse4_1_eqv2di3"
6407   [(set (match_operand:V2DI 0 "register_operand" "")
6408         (eq:V2DI
6409           (match_operand:V2DI 1 "nonimmediate_operand" "")
6410           (match_operand:V2DI 2 "nonimmediate_operand" "")))]
6411   "TARGET_SSE4_1"
6412   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
6413
6414 (define_insn "*sse4_1_eqv2di3"
6415   [(set (match_operand:V2DI 0 "register_operand" "=x")
6416         (eq:V2DI
6417           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
6418           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6419   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
6420   "pcmpeqq\t{%2, %0|%0, %2}"
6421   [(set_attr "type" "ssecmp")
6422    (set_attr "prefix_extra" "1")
6423    (set_attr "mode" "TI")])
6424
6425 (define_insn "*avx_gt<mode>3"
6426   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6427         (gt:SSEMODE1248
6428           (match_operand:SSEMODE1248 1 "register_operand" "x")
6429           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6430   "TARGET_AVX"
6431   "vpcmpgt<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6432   [(set_attr "type" "ssecmp")
6433    (set (attr "prefix_extra")
6434      (if_then_else (match_operand:V2DI 0 "" "")
6435        (const_string "1")
6436        (const_string "*")))
6437    (set_attr "prefix" "vex")
6438    (set_attr "mode" "TI")])
6439
6440 (define_insn "sse2_gt<mode>3"
6441   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6442         (gt:SSEMODE124
6443           (match_operand:SSEMODE124 1 "register_operand" "0")
6444           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6445   "TARGET_SSE2 && !TARGET_XOP"
6446   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
6447   [(set_attr "type" "ssecmp")
6448    (set_attr "prefix_data16" "1")
6449    (set_attr "mode" "TI")])
6450
6451 (define_insn "sse4_2_gtv2di3"
6452   [(set (match_operand:V2DI 0 "register_operand" "=x")
6453         (gt:V2DI
6454           (match_operand:V2DI 1 "register_operand" "0")
6455           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6456   "TARGET_SSE4_2"
6457   "pcmpgtq\t{%2, %0|%0, %2}"
6458   [(set_attr "type" "ssecmp")
6459    (set_attr "prefix_extra" "1")
6460    (set_attr "mode" "TI")])
6461
6462 (define_expand "vcond<mode>"
6463   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6464         (if_then_else:SSEMODE124C8
6465           (match_operator 3 ""
6466             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6467              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6468           (match_operand:SSEMODE124C8 1 "general_operand" "")
6469           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6470   "TARGET_SSE2"
6471 {
6472   bool ok = ix86_expand_int_vcond (operands);
6473   gcc_assert (ok);
6474   DONE;
6475 })
6476
6477 (define_expand "vcondu<mode>"
6478   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6479         (if_then_else:SSEMODE124C8
6480           (match_operator 3 ""
6481             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6482              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6483           (match_operand:SSEMODE124C8 1 "general_operand" "")
6484           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6485   "TARGET_SSE2"
6486 {
6487   bool ok = ix86_expand_int_vcond (operands);
6488   gcc_assert (ok);
6489   DONE;
6490 })
6491
6492 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6493 ;;
6494 ;; Parallel bitwise logical operations
6495 ;;
6496 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6497
6498 (define_expand "one_cmpl<mode>2"
6499   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6500         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6501                       (match_dup 2)))]
6502   "TARGET_SSE2"
6503 {
6504   int i, n = GET_MODE_NUNITS (<MODE>mode);
6505   rtvec v = rtvec_alloc (n);
6506
6507   for (i = 0; i < n; ++i)
6508     RTVEC_ELT (v, i) = constm1_rtx;
6509
6510   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
6511 })
6512
6513 (define_insn "*avx_andnot<mode>3"
6514   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6515         (and:AVX256MODEI
6516           (not:AVX256MODEI (match_operand:AVX256MODEI 1 "register_operand" "x"))
6517           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6518   "TARGET_AVX"
6519   "vandnps\t{%2, %1, %0|%0, %1, %2}"
6520   [(set_attr "type" "sselog")
6521    (set_attr "prefix" "vex")
6522    (set_attr "mode" "<avxvecpsmode>")])
6523
6524 (define_insn "*sse_andnot<mode>3"
6525   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6526         (and:SSEMODEI
6527           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6528           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6529   "(TARGET_SSE && !TARGET_SSE2)"
6530   "andnps\t{%2, %0|%0, %2}"
6531   [(set_attr "type" "sselog")
6532    (set_attr "mode" "V4SF")])
6533
6534 (define_insn "*avx_andnot<mode>3"
6535   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6536         (and:SSEMODEI
6537           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "x"))
6538           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6539   "TARGET_AVX"
6540   "vpandn\t{%2, %1, %0|%0, %1, %2}"
6541   [(set_attr "type" "sselog")
6542    (set_attr "prefix" "vex")
6543    (set_attr "mode" "TI")])
6544
6545 (define_insn "sse2_andnot<mode>3"
6546   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6547         (and:SSEMODEI
6548           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6549           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6550   "TARGET_SSE2"
6551   "pandn\t{%2, %0|%0, %2}"
6552   [(set_attr "type" "sselog")
6553    (set_attr "prefix_data16" "1")
6554    (set_attr "mode" "TI")])
6555
6556 (define_insn "*andnottf3"
6557   [(set (match_operand:TF 0 "register_operand" "=x")
6558         (and:TF
6559           (not:TF (match_operand:TF 1 "register_operand" "0"))
6560           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6561   "TARGET_SSE2"
6562   "pandn\t{%2, %0|%0, %2}"
6563   [(set_attr "type" "sselog")
6564    (set_attr "prefix_data16" "1")
6565    (set_attr "mode" "TI")])
6566
6567 (define_expand "<code><mode>3"
6568   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6569         (any_logic:SSEMODEI
6570           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6571           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
6572   "TARGET_SSE"
6573   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
6574
6575 (define_insn "*avx_<code><mode>3"
6576   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6577         (any_logic:AVX256MODEI
6578           (match_operand:AVX256MODEI 1 "nonimmediate_operand" "%x")
6579           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6580   "TARGET_AVX
6581    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6582   "v<logic>ps\t{%2, %1, %0|%0, %1, %2}"
6583   [(set_attr "type" "sselog")
6584    (set_attr "prefix" "vex")
6585    (set_attr "mode" "<avxvecpsmode>")])
6586
6587 (define_insn "*sse_<code><mode>3"
6588   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6589         (any_logic:SSEMODEI
6590           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6591           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6592   "(TARGET_SSE && !TARGET_SSE2)
6593    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6594   "<logic>ps\t{%2, %0|%0, %2}"
6595   [(set_attr "type" "sselog")
6596    (set_attr "mode" "V4SF")])
6597
6598 (define_insn "*avx_<code><mode>3"
6599   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6600         (any_logic:SSEMODEI
6601           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%x")
6602           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6603   "TARGET_AVX
6604    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6605   "vp<logic>\t{%2, %1, %0|%0, %1, %2}"
6606   [(set_attr "type" "sselog")
6607    (set_attr "prefix" "vex")
6608    (set_attr "mode" "TI")])
6609
6610 (define_insn "*sse2_<code><mode>3"
6611   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6612         (any_logic:SSEMODEI
6613           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6614           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6615   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6616   "p<logic>\t{%2, %0|%0, %2}"
6617   [(set_attr "type" "sselog")
6618    (set_attr "prefix_data16" "1")
6619    (set_attr "mode" "TI")])
6620
6621 (define_expand "<code>tf3"
6622   [(set (match_operand:TF 0 "register_operand" "")
6623         (any_logic:TF
6624           (match_operand:TF 1 "nonimmediate_operand" "")
6625           (match_operand:TF 2 "nonimmediate_operand" "")))]
6626   "TARGET_SSE2"
6627   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
6628
6629 (define_insn "*<code>tf3"
6630   [(set (match_operand:TF 0 "register_operand" "=x")
6631         (any_logic:TF
6632           (match_operand:TF 1 "nonimmediate_operand" "%0")
6633           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6634   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
6635   "p<logic>\t{%2, %0|%0, %2}"
6636   [(set_attr "type" "sselog")
6637    (set_attr "prefix_data16" "1")
6638    (set_attr "mode" "TI")])
6639
6640 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6641 ;;
6642 ;; Parallel integral element swizzling
6643 ;;
6644 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6645
6646 (define_expand "vec_pack_trunc_v8hi"
6647   [(match_operand:V16QI 0 "register_operand" "")
6648    (match_operand:V8HI 1 "register_operand" "")
6649    (match_operand:V8HI 2 "register_operand" "")]
6650   "TARGET_SSE2"
6651 {
6652   rtx op1 = gen_lowpart (V16QImode, operands[1]);
6653   rtx op2 = gen_lowpart (V16QImode, operands[2]);
6654   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6655   DONE;
6656 })
6657
6658 (define_expand "vec_pack_trunc_v4si"
6659   [(match_operand:V8HI 0 "register_operand" "")
6660    (match_operand:V4SI 1 "register_operand" "")
6661    (match_operand:V4SI 2 "register_operand" "")]
6662   "TARGET_SSE2"
6663 {
6664   rtx op1 = gen_lowpart (V8HImode, operands[1]);
6665   rtx op2 = gen_lowpart (V8HImode, operands[2]);
6666   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6667   DONE;
6668 })
6669
6670 (define_expand "vec_pack_trunc_v2di"
6671   [(match_operand:V4SI 0 "register_operand" "")
6672    (match_operand:V2DI 1 "register_operand" "")
6673    (match_operand:V2DI 2 "register_operand" "")]
6674   "TARGET_SSE2"
6675 {
6676   rtx op1 = gen_lowpart (V4SImode, operands[1]);
6677   rtx op2 = gen_lowpart (V4SImode, operands[2]);
6678   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6679   DONE;
6680 })
6681
6682 (define_insn "*avx_packsswb"
6683   [(set (match_operand:V16QI 0 "register_operand" "=x")
6684         (vec_concat:V16QI
6685           (ss_truncate:V8QI
6686             (match_operand:V8HI 1 "register_operand" "x"))
6687           (ss_truncate:V8QI
6688             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6689   "TARGET_AVX"
6690   "vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6691   [(set_attr "type" "sselog")
6692    (set_attr "prefix" "vex")
6693    (set_attr "mode" "TI")])
6694
6695 (define_insn "sse2_packsswb"
6696   [(set (match_operand:V16QI 0 "register_operand" "=x")
6697         (vec_concat:V16QI
6698           (ss_truncate:V8QI
6699             (match_operand:V8HI 1 "register_operand" "0"))
6700           (ss_truncate:V8QI
6701             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6702   "TARGET_SSE2"
6703   "packsswb\t{%2, %0|%0, %2}"
6704   [(set_attr "type" "sselog")
6705    (set_attr "prefix_data16" "1")
6706    (set_attr "mode" "TI")])
6707
6708 (define_insn "*avx_packssdw"
6709   [(set (match_operand:V8HI 0 "register_operand" "=x")
6710         (vec_concat:V8HI
6711           (ss_truncate:V4HI
6712             (match_operand:V4SI 1 "register_operand" "x"))
6713           (ss_truncate:V4HI
6714             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6715   "TARGET_AVX"
6716   "vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6717   [(set_attr "type" "sselog")
6718    (set_attr "prefix" "vex")
6719    (set_attr "mode" "TI")])
6720
6721 (define_insn "sse2_packssdw"
6722   [(set (match_operand:V8HI 0 "register_operand" "=x")
6723         (vec_concat:V8HI
6724           (ss_truncate:V4HI
6725             (match_operand:V4SI 1 "register_operand" "0"))
6726           (ss_truncate:V4HI
6727             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6728   "TARGET_SSE2"
6729   "packssdw\t{%2, %0|%0, %2}"
6730   [(set_attr "type" "sselog")
6731    (set_attr "prefix_data16" "1")
6732    (set_attr "mode" "TI")])
6733
6734 (define_insn "*avx_packuswb"
6735   [(set (match_operand:V16QI 0 "register_operand" "=x")
6736         (vec_concat:V16QI
6737           (us_truncate:V8QI
6738             (match_operand:V8HI 1 "register_operand" "x"))
6739           (us_truncate:V8QI
6740             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6741   "TARGET_AVX"
6742   "vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6743   [(set_attr "type" "sselog")
6744    (set_attr "prefix" "vex")
6745    (set_attr "mode" "TI")])
6746
6747 (define_insn "sse2_packuswb"
6748   [(set (match_operand:V16QI 0 "register_operand" "=x")
6749         (vec_concat:V16QI
6750           (us_truncate:V8QI
6751             (match_operand:V8HI 1 "register_operand" "0"))
6752           (us_truncate:V8QI
6753             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6754   "TARGET_SSE2"
6755   "packuswb\t{%2, %0|%0, %2}"
6756   [(set_attr "type" "sselog")
6757    (set_attr "prefix_data16" "1")
6758    (set_attr "mode" "TI")])
6759
6760 (define_insn "*avx_interleave_highv16qi"
6761   [(set (match_operand:V16QI 0 "register_operand" "=x")
6762         (vec_select:V16QI
6763           (vec_concat:V32QI
6764             (match_operand:V16QI 1 "register_operand" "x")
6765             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6766           (parallel [(const_int 8)  (const_int 24)
6767                      (const_int 9)  (const_int 25)
6768                      (const_int 10) (const_int 26)
6769                      (const_int 11) (const_int 27)
6770                      (const_int 12) (const_int 28)
6771                      (const_int 13) (const_int 29)
6772                      (const_int 14) (const_int 30)
6773                      (const_int 15) (const_int 31)])))]
6774   "TARGET_AVX"
6775   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6776   [(set_attr "type" "sselog")
6777    (set_attr "prefix" "vex")
6778    (set_attr "mode" "TI")])
6779
6780 (define_insn "vec_interleave_highv16qi"
6781   [(set (match_operand:V16QI 0 "register_operand" "=x")
6782         (vec_select:V16QI
6783           (vec_concat:V32QI
6784             (match_operand:V16QI 1 "register_operand" "0")
6785             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6786           (parallel [(const_int 8)  (const_int 24)
6787                      (const_int 9)  (const_int 25)
6788                      (const_int 10) (const_int 26)
6789                      (const_int 11) (const_int 27)
6790                      (const_int 12) (const_int 28)
6791                      (const_int 13) (const_int 29)
6792                      (const_int 14) (const_int 30)
6793                      (const_int 15) (const_int 31)])))]
6794   "TARGET_SSE2"
6795   "punpckhbw\t{%2, %0|%0, %2}"
6796   [(set_attr "type" "sselog")
6797    (set_attr "prefix_data16" "1")
6798    (set_attr "mode" "TI")])
6799
6800 (define_insn "*avx_interleave_lowv16qi"
6801   [(set (match_operand:V16QI 0 "register_operand" "=x")
6802         (vec_select:V16QI
6803           (vec_concat:V32QI
6804             (match_operand:V16QI 1 "register_operand" "x")
6805             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6806           (parallel [(const_int 0) (const_int 16)
6807                      (const_int 1) (const_int 17)
6808                      (const_int 2) (const_int 18)
6809                      (const_int 3) (const_int 19)
6810                      (const_int 4) (const_int 20)
6811                      (const_int 5) (const_int 21)
6812                      (const_int 6) (const_int 22)
6813                      (const_int 7) (const_int 23)])))]
6814   "TARGET_AVX"
6815   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6816   [(set_attr "type" "sselog")
6817    (set_attr "prefix" "vex")
6818    (set_attr "mode" "TI")])
6819
6820 (define_insn "vec_interleave_lowv16qi"
6821   [(set (match_operand:V16QI 0 "register_operand" "=x")
6822         (vec_select:V16QI
6823           (vec_concat:V32QI
6824             (match_operand:V16QI 1 "register_operand" "0")
6825             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6826           (parallel [(const_int 0) (const_int 16)
6827                      (const_int 1) (const_int 17)
6828                      (const_int 2) (const_int 18)
6829                      (const_int 3) (const_int 19)
6830                      (const_int 4) (const_int 20)
6831                      (const_int 5) (const_int 21)
6832                      (const_int 6) (const_int 22)
6833                      (const_int 7) (const_int 23)])))]
6834   "TARGET_SSE2"
6835   "punpcklbw\t{%2, %0|%0, %2}"
6836   [(set_attr "type" "sselog")
6837    (set_attr "prefix_data16" "1")
6838    (set_attr "mode" "TI")])
6839
6840 (define_insn "*avx_interleave_highv8hi"
6841   [(set (match_operand:V8HI 0 "register_operand" "=x")
6842         (vec_select:V8HI
6843           (vec_concat:V16HI
6844             (match_operand:V8HI 1 "register_operand" "x")
6845             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6846           (parallel [(const_int 4) (const_int 12)
6847                      (const_int 5) (const_int 13)
6848                      (const_int 6) (const_int 14)
6849                      (const_int 7) (const_int 15)])))]
6850   "TARGET_AVX"
6851   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6852   [(set_attr "type" "sselog")
6853    (set_attr "prefix" "vex")
6854    (set_attr "mode" "TI")])
6855
6856 (define_insn "vec_interleave_highv8hi"
6857   [(set (match_operand:V8HI 0 "register_operand" "=x")
6858         (vec_select:V8HI
6859           (vec_concat:V16HI
6860             (match_operand:V8HI 1 "register_operand" "0")
6861             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6862           (parallel [(const_int 4) (const_int 12)
6863                      (const_int 5) (const_int 13)
6864                      (const_int 6) (const_int 14)
6865                      (const_int 7) (const_int 15)])))]
6866   "TARGET_SSE2"
6867   "punpckhwd\t{%2, %0|%0, %2}"
6868   [(set_attr "type" "sselog")
6869    (set_attr "prefix_data16" "1")
6870    (set_attr "mode" "TI")])
6871
6872 (define_insn "*avx_interleave_lowv8hi"
6873   [(set (match_operand:V8HI 0 "register_operand" "=x")
6874         (vec_select:V8HI
6875           (vec_concat:V16HI
6876             (match_operand:V8HI 1 "register_operand" "x")
6877             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6878           (parallel [(const_int 0) (const_int 8)
6879                      (const_int 1) (const_int 9)
6880                      (const_int 2) (const_int 10)
6881                      (const_int 3) (const_int 11)])))]
6882   "TARGET_AVX"
6883   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6884   [(set_attr "type" "sselog")
6885    (set_attr "prefix" "vex")
6886    (set_attr "mode" "TI")])
6887
6888 (define_insn "vec_interleave_lowv8hi"
6889   [(set (match_operand:V8HI 0 "register_operand" "=x")
6890         (vec_select:V8HI
6891           (vec_concat:V16HI
6892             (match_operand:V8HI 1 "register_operand" "0")
6893             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6894           (parallel [(const_int 0) (const_int 8)
6895                      (const_int 1) (const_int 9)
6896                      (const_int 2) (const_int 10)
6897                      (const_int 3) (const_int 11)])))]
6898   "TARGET_SSE2"
6899   "punpcklwd\t{%2, %0|%0, %2}"
6900   [(set_attr "type" "sselog")
6901    (set_attr "prefix_data16" "1")
6902    (set_attr "mode" "TI")])
6903
6904 (define_insn "*avx_interleave_highv4si"
6905   [(set (match_operand:V4SI 0 "register_operand" "=x")
6906         (vec_select:V4SI
6907           (vec_concat:V8SI
6908             (match_operand:V4SI 1 "register_operand" "x")
6909             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6910           (parallel [(const_int 2) (const_int 6)
6911                      (const_int 3) (const_int 7)])))]
6912   "TARGET_AVX"
6913   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6914   [(set_attr "type" "sselog")
6915    (set_attr "prefix" "vex")
6916    (set_attr "mode" "TI")])
6917
6918 (define_insn "vec_interleave_highv4si"
6919   [(set (match_operand:V4SI 0 "register_operand" "=x")
6920         (vec_select:V4SI
6921           (vec_concat:V8SI
6922             (match_operand:V4SI 1 "register_operand" "0")
6923             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6924           (parallel [(const_int 2) (const_int 6)
6925                      (const_int 3) (const_int 7)])))]
6926   "TARGET_SSE2"
6927   "punpckhdq\t{%2, %0|%0, %2}"
6928   [(set_attr "type" "sselog")
6929    (set_attr "prefix_data16" "1")
6930    (set_attr "mode" "TI")])
6931
6932 (define_insn "*avx_interleave_lowv4si"
6933   [(set (match_operand:V4SI 0 "register_operand" "=x")
6934         (vec_select:V4SI
6935           (vec_concat:V8SI
6936             (match_operand:V4SI 1 "register_operand" "x")
6937             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6938           (parallel [(const_int 0) (const_int 4)
6939                      (const_int 1) (const_int 5)])))]
6940   "TARGET_AVX"
6941   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6942   [(set_attr "type" "sselog")
6943    (set_attr "prefix" "vex")
6944    (set_attr "mode" "TI")])
6945
6946 (define_insn "vec_interleave_lowv4si"
6947   [(set (match_operand:V4SI 0 "register_operand" "=x")
6948         (vec_select:V4SI
6949           (vec_concat:V8SI
6950             (match_operand:V4SI 1 "register_operand" "0")
6951             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6952           (parallel [(const_int 0) (const_int 4)
6953                      (const_int 1) (const_int 5)])))]
6954   "TARGET_SSE2"
6955   "punpckldq\t{%2, %0|%0, %2}"
6956   [(set_attr "type" "sselog")
6957    (set_attr "prefix_data16" "1")
6958    (set_attr "mode" "TI")])
6959
6960 (define_insn "*avx_pinsr<ssevecsize>"
6961   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6962         (vec_merge:SSEMODE124
6963           (vec_duplicate:SSEMODE124
6964             (match_operand:<avxscalarmode> 2 "nonimmediate_operand" "rm"))
6965           (match_operand:SSEMODE124 1 "register_operand" "x")
6966           (match_operand:SI 3 "const_pow2_1_to_<pinsrbits>_operand" "n")))]
6967   "TARGET_AVX"
6968 {
6969   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6970   if (MEM_P (operands[2]))
6971     return "vpinsr<ssevecsize>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6972   else
6973     return "vpinsr<ssevecsize>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6974 }
6975   [(set_attr "type" "sselog")
6976    (set (attr "prefix_extra")
6977      (if_then_else (match_operand:V8HI 0 "register_operand" "")
6978        (const_string "0")
6979        (const_string "1")))
6980    (set_attr "length_immediate" "1")
6981    (set_attr "prefix" "vex")
6982    (set_attr "mode" "TI")])
6983
6984 (define_insn "*sse4_1_pinsrb"
6985   [(set (match_operand:V16QI 0 "register_operand" "=x")
6986         (vec_merge:V16QI
6987           (vec_duplicate:V16QI
6988             (match_operand:QI 2 "nonimmediate_operand" "rm"))
6989           (match_operand:V16QI 1 "register_operand" "0")
6990           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
6991   "TARGET_SSE4_1"
6992 {
6993   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6994   if (MEM_P (operands[2]))
6995     return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
6996   else
6997     return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
6998 }
6999   [(set_attr "type" "sselog")
7000    (set_attr "prefix_extra" "1")
7001    (set_attr "length_immediate" "1")
7002    (set_attr "mode" "TI")])
7003
7004 (define_insn "*sse2_pinsrw"
7005   [(set (match_operand:V8HI 0 "register_operand" "=x")
7006         (vec_merge:V8HI
7007           (vec_duplicate:V8HI
7008             (match_operand:HI 2 "nonimmediate_operand" "rm"))
7009           (match_operand:V8HI 1 "register_operand" "0")
7010           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
7011   "TARGET_SSE2"
7012 {
7013   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7014   if (MEM_P (operands[2]))
7015     return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
7016   else
7017     return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
7018 }
7019   [(set_attr "type" "sselog")
7020    (set_attr "prefix_data16" "1")
7021    (set_attr "length_immediate" "1")
7022    (set_attr "mode" "TI")])
7023
7024 ;; It must come before sse2_loadld since it is preferred.
7025 (define_insn "*sse4_1_pinsrd"
7026   [(set (match_operand:V4SI 0 "register_operand" "=x")
7027         (vec_merge:V4SI
7028           (vec_duplicate:V4SI
7029             (match_operand:SI 2 "nonimmediate_operand" "rm"))
7030           (match_operand:V4SI 1 "register_operand" "0")
7031           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
7032   "TARGET_SSE4_1"
7033 {
7034   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7035   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
7036 }
7037   [(set_attr "type" "sselog")
7038    (set_attr "prefix_extra" "1")
7039    (set_attr "length_immediate" "1")
7040    (set_attr "mode" "TI")])
7041
7042 (define_insn "*avx_pinsrq"
7043   [(set (match_operand:V2DI 0 "register_operand" "=x")
7044         (vec_merge:V2DI
7045           (vec_duplicate:V2DI
7046             (match_operand:DI 2 "nonimmediate_operand" "rm"))
7047           (match_operand:V2DI 1 "register_operand" "x")
7048           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
7049   "TARGET_AVX && TARGET_64BIT"
7050 {
7051   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7052   return "vpinsrq\t{%3, %2, %1, %0|%0, %1, %2, %3}";
7053 }
7054   [(set_attr "type" "sselog")
7055    (set_attr "prefix_extra" "1")
7056    (set_attr "length_immediate" "1")
7057    (set_attr "prefix" "vex")
7058    (set_attr "mode" "TI")])
7059
7060 (define_insn "*sse4_1_pinsrq"
7061   [(set (match_operand:V2DI 0 "register_operand" "=x")
7062         (vec_merge:V2DI
7063           (vec_duplicate:V2DI
7064             (match_operand:DI 2 "nonimmediate_operand" "rm"))
7065           (match_operand:V2DI 1 "register_operand" "0")
7066           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
7067   "TARGET_SSE4_1 && TARGET_64BIT"
7068 {
7069   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7070   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
7071 }
7072   [(set_attr "type" "sselog")
7073    (set_attr "prefix_rex" "1")
7074    (set_attr "prefix_extra" "1")
7075    (set_attr "length_immediate" "1")
7076    (set_attr "mode" "TI")])
7077
7078 (define_insn "*sse4_1_pextrb"
7079   [(set (match_operand:SI 0 "register_operand" "=r")
7080         (zero_extend:SI
7081           (vec_select:QI
7082             (match_operand:V16QI 1 "register_operand" "x")
7083             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
7084   "TARGET_SSE4_1"
7085   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
7086   [(set_attr "type" "sselog")
7087    (set_attr "prefix_extra" "1")
7088    (set_attr "length_immediate" "1")
7089    (set_attr "prefix" "maybe_vex")
7090    (set_attr "mode" "TI")])
7091
7092 (define_insn "*sse4_1_pextrb_memory"
7093   [(set (match_operand:QI 0 "memory_operand" "=m")
7094         (vec_select:QI
7095           (match_operand:V16QI 1 "register_operand" "x")
7096           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
7097   "TARGET_SSE4_1"
7098   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
7099   [(set_attr "type" "sselog")
7100    (set_attr "prefix_extra" "1")
7101    (set_attr "length_immediate" "1")
7102    (set_attr "prefix" "maybe_vex")
7103    (set_attr "mode" "TI")])
7104
7105 (define_insn "*sse2_pextrw"
7106   [(set (match_operand:SI 0 "register_operand" "=r")
7107         (zero_extend:SI
7108           (vec_select:HI
7109             (match_operand:V8HI 1 "register_operand" "x")
7110             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
7111   "TARGET_SSE2"
7112   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
7113   [(set_attr "type" "sselog")
7114    (set_attr "prefix_data16" "1")
7115    (set_attr "length_immediate" "1")
7116    (set_attr "prefix" "maybe_vex")
7117    (set_attr "mode" "TI")])
7118
7119 (define_insn "*sse4_1_pextrw_memory"
7120   [(set (match_operand:HI 0 "memory_operand" "=m")
7121         (vec_select:HI
7122           (match_operand:V8HI 1 "register_operand" "x")
7123           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
7124   "TARGET_SSE4_1"
7125   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
7126   [(set_attr "type" "sselog")
7127    (set_attr "prefix_extra" "1")
7128    (set_attr "length_immediate" "1")
7129    (set_attr "prefix" "maybe_vex")
7130    (set_attr "mode" "TI")])
7131
7132 (define_insn "*sse4_1_pextrd"
7133   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
7134         (vec_select:SI
7135           (match_operand:V4SI 1 "register_operand" "x")
7136           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
7137   "TARGET_SSE4_1"
7138   "%vpextrd\t{%2, %1, %0|%0, %1, %2}"
7139   [(set_attr "type" "sselog")
7140    (set_attr "prefix_extra" "1")
7141    (set_attr "length_immediate" "1")
7142    (set_attr "prefix" "maybe_vex")
7143    (set_attr "mode" "TI")])
7144
7145 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
7146 (define_insn "*sse4_1_pextrq"
7147   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
7148         (vec_select:DI
7149           (match_operand:V2DI 1 "register_operand" "x")
7150           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
7151   "TARGET_SSE4_1 && TARGET_64BIT"
7152   "%vpextrq\t{%2, %1, %0|%0, %1, %2}"
7153   [(set_attr "type" "sselog")
7154    (set_attr "prefix_rex" "1")
7155    (set_attr "prefix_extra" "1")
7156    (set_attr "length_immediate" "1")
7157    (set_attr "prefix" "maybe_vex")
7158    (set_attr "mode" "TI")])
7159
7160 (define_expand "sse2_pshufd"
7161   [(match_operand:V4SI 0 "register_operand" "")
7162    (match_operand:V4SI 1 "nonimmediate_operand" "")
7163    (match_operand:SI 2 "const_int_operand" "")]
7164   "TARGET_SSE2"
7165 {
7166   int mask = INTVAL (operands[2]);
7167   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
7168                                 GEN_INT ((mask >> 0) & 3),
7169                                 GEN_INT ((mask >> 2) & 3),
7170                                 GEN_INT ((mask >> 4) & 3),
7171                                 GEN_INT ((mask >> 6) & 3)));
7172   DONE;
7173 })
7174
7175 (define_insn "sse2_pshufd_1"
7176   [(set (match_operand:V4SI 0 "register_operand" "=x")
7177         (vec_select:V4SI
7178           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
7179           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7180                      (match_operand 3 "const_0_to_3_operand" "")
7181                      (match_operand 4 "const_0_to_3_operand" "")
7182                      (match_operand 5 "const_0_to_3_operand" "")])))]
7183   "TARGET_SSE2"
7184 {
7185   int mask = 0;
7186   mask |= INTVAL (operands[2]) << 0;
7187   mask |= INTVAL (operands[3]) << 2;
7188   mask |= INTVAL (operands[4]) << 4;
7189   mask |= INTVAL (operands[5]) << 6;
7190   operands[2] = GEN_INT (mask);
7191
7192   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
7193 }
7194   [(set_attr "type" "sselog1")
7195    (set_attr "prefix_data16" "1")
7196    (set_attr "prefix" "maybe_vex")
7197    (set_attr "length_immediate" "1")
7198    (set_attr "mode" "TI")])
7199
7200 (define_expand "sse2_pshuflw"
7201   [(match_operand:V8HI 0 "register_operand" "")
7202    (match_operand:V8HI 1 "nonimmediate_operand" "")
7203    (match_operand:SI 2 "const_int_operand" "")]
7204   "TARGET_SSE2"
7205 {
7206   int mask = INTVAL (operands[2]);
7207   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
7208                                  GEN_INT ((mask >> 0) & 3),
7209                                  GEN_INT ((mask >> 2) & 3),
7210                                  GEN_INT ((mask >> 4) & 3),
7211                                  GEN_INT ((mask >> 6) & 3)));
7212   DONE;
7213 })
7214
7215 (define_insn "sse2_pshuflw_1"
7216   [(set (match_operand:V8HI 0 "register_operand" "=x")
7217         (vec_select:V8HI
7218           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7219           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7220                      (match_operand 3 "const_0_to_3_operand" "")
7221                      (match_operand 4 "const_0_to_3_operand" "")
7222                      (match_operand 5 "const_0_to_3_operand" "")
7223                      (const_int 4)
7224                      (const_int 5)
7225                      (const_int 6)
7226                      (const_int 7)])))]
7227   "TARGET_SSE2"
7228 {
7229   int mask = 0;
7230   mask |= INTVAL (operands[2]) << 0;
7231   mask |= INTVAL (operands[3]) << 2;
7232   mask |= INTVAL (operands[4]) << 4;
7233   mask |= INTVAL (operands[5]) << 6;
7234   operands[2] = GEN_INT (mask);
7235
7236   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7237 }
7238   [(set_attr "type" "sselog")
7239    (set_attr "prefix_data16" "0")
7240    (set_attr "prefix_rep" "1")
7241    (set_attr "prefix" "maybe_vex")
7242    (set_attr "length_immediate" "1")
7243    (set_attr "mode" "TI")])
7244
7245 (define_expand "sse2_pshufhw"
7246   [(match_operand:V8HI 0 "register_operand" "")
7247    (match_operand:V8HI 1 "nonimmediate_operand" "")
7248    (match_operand:SI 2 "const_int_operand" "")]
7249   "TARGET_SSE2"
7250 {
7251   int mask = INTVAL (operands[2]);
7252   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
7253                                  GEN_INT (((mask >> 0) & 3) + 4),
7254                                  GEN_INT (((mask >> 2) & 3) + 4),
7255                                  GEN_INT (((mask >> 4) & 3) + 4),
7256                                  GEN_INT (((mask >> 6) & 3) + 4)));
7257   DONE;
7258 })
7259
7260 (define_insn "sse2_pshufhw_1"
7261   [(set (match_operand:V8HI 0 "register_operand" "=x")
7262         (vec_select:V8HI
7263           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7264           (parallel [(const_int 0)
7265                      (const_int 1)
7266                      (const_int 2)
7267                      (const_int 3)
7268                      (match_operand 2 "const_4_to_7_operand" "")
7269                      (match_operand 3 "const_4_to_7_operand" "")
7270                      (match_operand 4 "const_4_to_7_operand" "")
7271                      (match_operand 5 "const_4_to_7_operand" "")])))]
7272   "TARGET_SSE2"
7273 {
7274   int mask = 0;
7275   mask |= (INTVAL (operands[2]) - 4) << 0;
7276   mask |= (INTVAL (operands[3]) - 4) << 2;
7277   mask |= (INTVAL (operands[4]) - 4) << 4;
7278   mask |= (INTVAL (operands[5]) - 4) << 6;
7279   operands[2] = GEN_INT (mask);
7280
7281   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7282 }
7283   [(set_attr "type" "sselog")
7284    (set_attr "prefix_rep" "1")
7285    (set_attr "prefix_data16" "0")
7286    (set_attr "prefix" "maybe_vex")
7287    (set_attr "length_immediate" "1")
7288    (set_attr "mode" "TI")])
7289
7290 (define_expand "sse2_loadd"
7291   [(set (match_operand:V4SI 0 "register_operand" "")
7292         (vec_merge:V4SI
7293           (vec_duplicate:V4SI
7294             (match_operand:SI 1 "nonimmediate_operand" ""))
7295           (match_dup 2)
7296           (const_int 1)))]
7297   "TARGET_SSE"
7298   "operands[2] = CONST0_RTX (V4SImode);")
7299
7300 (define_insn "*avx_loadld"
7301   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x")
7302         (vec_merge:V4SI
7303           (vec_duplicate:V4SI
7304             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,x"))
7305           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,x")
7306           (const_int 1)))]
7307   "TARGET_AVX"
7308   "@
7309    vmovd\t{%2, %0|%0, %2}
7310    vmovd\t{%2, %0|%0, %2}
7311    vmovss\t{%2, %1, %0|%0, %1, %2}"
7312   [(set_attr "type" "ssemov")
7313    (set_attr "prefix" "vex")
7314    (set_attr "mode" "TI,TI,V4SF")])
7315
7316 (define_insn "sse2_loadld"
7317   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,Yi,x,x")
7318         (vec_merge:V4SI
7319           (vec_duplicate:V4SI
7320             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
7321           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
7322           (const_int 1)))]
7323   "TARGET_SSE"
7324   "@
7325    movd\t{%2, %0|%0, %2}
7326    movd\t{%2, %0|%0, %2}
7327    movss\t{%2, %0|%0, %2}
7328    movss\t{%2, %0|%0, %2}"
7329   [(set_attr "type" "ssemov")
7330    (set_attr "mode" "TI,TI,V4SF,SF")])
7331
7332 (define_insn_and_split "sse2_stored"
7333   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
7334         (vec_select:SI
7335           (match_operand:V4SI 1 "register_operand" "x,Yi")
7336           (parallel [(const_int 0)])))]
7337   "TARGET_SSE"
7338   "#"
7339   "&& reload_completed
7340    && (TARGET_INTER_UNIT_MOVES
7341        || MEM_P (operands [0])
7342        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7343   [(set (match_dup 0) (match_dup 1))]
7344 {
7345   operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));
7346 })
7347
7348 (define_insn_and_split "*vec_ext_v4si_mem"
7349   [(set (match_operand:SI 0 "register_operand" "=r")
7350         (vec_select:SI
7351           (match_operand:V4SI 1 "memory_operand" "o")
7352           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
7353   ""
7354   "#"
7355   "reload_completed"
7356   [(const_int 0)]
7357 {
7358   int i = INTVAL (operands[2]);
7359
7360   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
7361   DONE;
7362 })
7363
7364 (define_expand "sse_storeq"
7365   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7366         (vec_select:DI
7367           (match_operand:V2DI 1 "register_operand" "")
7368           (parallel [(const_int 0)])))]
7369   "TARGET_SSE"
7370   "")
7371
7372 (define_insn "*sse2_storeq_rex64"
7373   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,*r,r")
7374         (vec_select:DI
7375           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
7376           (parallel [(const_int 0)])))]
7377   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7378   "@
7379    #
7380    #
7381    %vmov{q}\t{%1, %0|%0, %1}"
7382   [(set_attr "type" "*,*,imov")
7383    (set_attr "prefix" "*,*,maybe_vex")
7384    (set_attr "mode" "*,*,DI")])
7385
7386 (define_insn "*sse2_storeq"
7387   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
7388         (vec_select:DI
7389           (match_operand:V2DI 1 "register_operand" "x")
7390           (parallel [(const_int 0)])))]
7391   "TARGET_SSE"
7392   "#")
7393
7394 (define_split
7395   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7396         (vec_select:DI
7397           (match_operand:V2DI 1 "register_operand" "")
7398           (parallel [(const_int 0)])))]
7399   "TARGET_SSE
7400    && reload_completed
7401    && (TARGET_INTER_UNIT_MOVES
7402        || MEM_P (operands [0])
7403        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7404   [(set (match_dup 0) (match_dup 1))]
7405 {
7406   operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));
7407 })
7408
7409 (define_insn "*vec_extractv2di_1_rex64_avx"
7410   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7411         (vec_select:DI
7412           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o,o")
7413           (parallel [(const_int 1)])))]
7414   "TARGET_64BIT
7415    && TARGET_AVX
7416    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7417   "@
7418    vmovhps\t{%1, %0|%0, %1}
7419    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7420    vmovq\t{%H1, %0|%0, %H1}
7421    vmov{q}\t{%H1, %0|%0, %H1}"
7422   [(set_attr "type" "ssemov,sseishft1,ssemov,imov")
7423    (set_attr "length_immediate" "*,1,*,*")
7424    (set_attr "memory" "*,none,*,*")
7425    (set_attr "prefix" "vex")
7426    (set_attr "mode" "V2SF,TI,TI,DI")])
7427
7428 (define_insn "*vec_extractv2di_1_rex64"
7429   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7430         (vec_select:DI
7431           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
7432           (parallel [(const_int 1)])))]
7433   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7434   "@
7435    movhps\t{%1, %0|%0, %1}
7436    psrldq\t{$8, %0|%0, 8}
7437    movq\t{%H1, %0|%0, %H1}
7438    mov{q}\t{%H1, %0|%0, %H1}"
7439   [(set_attr "type" "ssemov,sseishft1,ssemov,imov")
7440    (set_attr "length_immediate" "*,1,*,*")
7441    (set_attr "memory" "*,none,*,*")
7442    (set_attr "mode" "V2SF,TI,TI,DI")])
7443
7444 (define_insn "*vec_extractv2di_1_avx"
7445   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7446         (vec_select:DI
7447           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7448           (parallel [(const_int 1)])))]
7449   "!TARGET_64BIT
7450    && TARGET_AVX
7451    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7452   "@
7453    vmovhps\t{%1, %0|%0, %1}
7454    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7455    vmovq\t{%H1, %0|%0, %H1}"
7456   [(set_attr "type" "ssemov,sseishft1,ssemov")
7457    (set_attr "length_immediate" "*,1,*")
7458    (set_attr "memory" "*,none,*")
7459    (set_attr "prefix" "vex")
7460    (set_attr "mode" "V2SF,TI,TI")])
7461
7462 (define_insn "*vec_extractv2di_1_sse2"
7463   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7464         (vec_select:DI
7465           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
7466           (parallel [(const_int 1)])))]
7467   "!TARGET_64BIT
7468    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7469   "@
7470    movhps\t{%1, %0|%0, %1}
7471    psrldq\t{$8, %0|%0, 8}
7472    movq\t{%H1, %0|%0, %H1}"
7473   [(set_attr "type" "ssemov,sseishft1,ssemov")
7474    (set_attr "length_immediate" "*,1,*")
7475    (set_attr "memory" "*,none,*")
7476    (set_attr "mode" "V2SF,TI,TI")])
7477
7478 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
7479 (define_insn "*vec_extractv2di_1_sse"
7480   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7481         (vec_select:DI
7482           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7483           (parallel [(const_int 1)])))]
7484   "!TARGET_SSE2 && TARGET_SSE
7485    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7486   "@
7487    movhps\t{%1, %0|%0, %1}
7488    movhlps\t{%1, %0|%0, %1}
7489    movlps\t{%H1, %0|%0, %H1}"
7490   [(set_attr "type" "ssemov")
7491    (set_attr "mode" "V2SF,V4SF,V2SF")])
7492
7493 (define_insn "*vec_dupv4si_avx"
7494   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
7495         (vec_duplicate:V4SI
7496           (match_operand:SI 1 "register_operand" "x,m")))]
7497   "TARGET_AVX"
7498   "@
7499    vpshufd\t{$0, %1, %0|%0, %1, 0}
7500    vbroadcastss\t{%1, %0|%0, %1}"
7501   [(set_attr "type" "sselog1,ssemov")
7502    (set_attr "length_immediate" "1,0")
7503    (set_attr "prefix_extra" "0,1")
7504    (set_attr "prefix" "vex")
7505    (set_attr "mode" "TI,V4SF")])
7506
7507 (define_insn "*vec_dupv4si"
7508   [(set (match_operand:V4SI 0 "register_operand" "=Y2,x")
7509         (vec_duplicate:V4SI
7510           (match_operand:SI 1 "register_operand" " Y2,0")))]
7511   "TARGET_SSE"
7512   "@
7513    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7514    shufps\t{$0, %0, %0|%0, %0, 0}"
7515   [(set_attr "type" "sselog1")
7516    (set_attr "length_immediate" "1")
7517    (set_attr "mode" "TI,V4SF")])
7518
7519 (define_insn "*vec_dupv2di_avx"
7520   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7521         (vec_duplicate:V2DI
7522           (match_operand:DI 1 "nonimmediate_operand" " x,m")))]
7523   "TARGET_AVX"
7524   "@
7525    vpunpcklqdq\t{%1, %1, %0|%0, %1, %1}
7526    vmovddup\t{%1, %0|%0, %1}"
7527   [(set_attr "type" "sselog1")
7528    (set_attr "prefix" "vex")
7529    (set_attr "mode" "TI,DF")])
7530
7531 (define_insn "*vec_dupv2di_sse3"
7532   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7533         (vec_duplicate:V2DI
7534           (match_operand:DI 1 "nonimmediate_operand" " 0,m")))]
7535   "TARGET_SSE3"
7536   "@
7537    punpcklqdq\t%0, %0
7538    movddup\t{%1, %0|%0, %1}"
7539   [(set_attr "type" "sselog1")
7540    (set_attr "mode" "TI,DF")])
7541
7542 (define_insn "*vec_dupv2di"
7543   [(set (match_operand:V2DI 0 "register_operand" "=Y2,x")
7544         (vec_duplicate:V2DI
7545           (match_operand:DI 1 "register_operand" " 0 ,0")))]
7546   "TARGET_SSE"
7547   "@
7548    punpcklqdq\t%0, %0
7549    movlhps\t%0, %0"
7550   [(set_attr "type" "sselog1,ssemov")
7551    (set_attr "mode" "TI,V4SF")])
7552
7553 (define_insn "*vec_concatv2si_avx"
7554   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7555         (vec_concat:V2SI
7556           (match_operand:SI 1 "nonimmediate_operand" "x ,x,rm, 0 ,rm")
7557           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7558   "TARGET_AVX"
7559   "@
7560    vpinsrd\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7561    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7562    vmovd\t{%1, %0|%0, %1}
7563    punpckldq\t{%2, %0|%0, %2}
7564    movd\t{%1, %0|%0, %1}"
7565   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7566    (set_attr "prefix_extra" "1,*,*,*,*")
7567    (set_attr "length_immediate" "1,*,*,*,*")
7568    (set (attr "prefix")
7569      (if_then_else (eq_attr "alternative" "3,4")
7570        (const_string "orig")
7571        (const_string "vex")))
7572    (set_attr "mode" "TI,TI,TI,DI,DI")])
7573
7574 (define_insn "*vec_concatv2si_sse4_1"
7575   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7576         (vec_concat:V2SI
7577           (match_operand:SI 1 "nonimmediate_operand" "0 ,0,rm, 0 ,rm")
7578           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7579   "TARGET_SSE4_1"
7580   "@
7581    pinsrd\t{$0x1, %2, %0|%0, %2, 0x1}
7582    punpckldq\t{%2, %0|%0, %2}
7583    movd\t{%1, %0|%0, %1}
7584    punpckldq\t{%2, %0|%0, %2}
7585    movd\t{%1, %0|%0, %1}"
7586   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7587    (set_attr "prefix_extra" "1,*,*,*,*")
7588    (set_attr "length_immediate" "1,*,*,*,*")
7589    (set_attr "mode" "TI,TI,TI,DI,DI")])
7590
7591 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7592 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7593 ;; alternatives pretty much forces the MMX alternative to be chosen.
7594 (define_insn "*vec_concatv2si_sse2"
7595   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,*y")
7596         (vec_concat:V2SI
7597           (match_operand:SI 1 "nonimmediate_operand" " 0,rm, 0,rm")
7598           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,*y, C")))]
7599   "TARGET_SSE2"
7600   "@
7601    punpckldq\t{%2, %0|%0, %2}
7602    movd\t{%1, %0|%0, %1}
7603    punpckldq\t{%2, %0|%0, %2}
7604    movd\t{%1, %0|%0, %1}"
7605   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7606    (set_attr "mode" "TI,TI,DI,DI")])
7607
7608 (define_insn "*vec_concatv2si_sse"
7609   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
7610         (vec_concat:V2SI
7611           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
7612           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
7613   "TARGET_SSE"
7614   "@
7615    unpcklps\t{%2, %0|%0, %2}
7616    movss\t{%1, %0|%0, %1}
7617    punpckldq\t{%2, %0|%0, %2}
7618    movd\t{%1, %0|%0, %1}"
7619   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7620    (set_attr "mode" "V4SF,V4SF,DI,DI")])
7621
7622 (define_insn "*vec_concatv4si_1_avx"
7623   [(set (match_operand:V4SI 0 "register_operand"       "=x,x")
7624         (vec_concat:V4SI
7625           (match_operand:V2SI 1 "register_operand"     " x,x")
7626           (match_operand:V2SI 2 "nonimmediate_operand" " x,m")))]
7627   "TARGET_AVX"
7628   "@
7629    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7630    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7631   [(set_attr "type" "sselog,ssemov")
7632    (set_attr "prefix" "vex")
7633    (set_attr "mode" "TI,V2SF")])
7634
7635 (define_insn "*vec_concatv4si_1"
7636   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,x,x")
7637         (vec_concat:V4SI
7638           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
7639           (match_operand:V2SI 2 "nonimmediate_operand" " Y2,x,m")))]
7640   "TARGET_SSE"
7641   "@
7642    punpcklqdq\t{%2, %0|%0, %2}
7643    movlhps\t{%2, %0|%0, %2}
7644    movhps\t{%2, %0|%0, %2}"
7645   [(set_attr "type" "sselog,ssemov,ssemov")
7646    (set_attr "mode" "TI,V4SF,V2SF")])
7647
7648 (define_insn "*vec_concatv2di_avx"
7649   [(set (match_operand:V2DI 0 "register_operand"     "=x,?x,x,x")
7650         (vec_concat:V2DI
7651           (match_operand:DI 1 "nonimmediate_operand" " m,*y,x,x")
7652           (match_operand:DI 2 "vector_move_operand"  " C, C,x,m")))]
7653   "!TARGET_64BIT && TARGET_AVX"
7654   "@
7655    vmovq\t{%1, %0|%0, %1}
7656    movq2dq\t{%1, %0|%0, %1}
7657    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7658    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7659   [(set_attr "type" "ssemov,ssemov,sselog,ssemov")
7660    (set (attr "prefix")
7661      (if_then_else (eq_attr "alternative" "1")
7662        (const_string "orig")
7663        (const_string "vex")))
7664    (set_attr "mode" "TI,TI,TI,V2SF")])
7665
7666 (define_insn "vec_concatv2di"
7667   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,?Y2,Y2,x,x")
7668         (vec_concat:V2DI
7669           (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0")
7670           (match_operand:DI 2 "vector_move_operand"  " C  ,  C,Y2,x,m")))]
7671   "!TARGET_64BIT && TARGET_SSE"
7672   "@
7673    movq\t{%1, %0|%0, %1}
7674    movq2dq\t{%1, %0|%0, %1}
7675    punpcklqdq\t{%2, %0|%0, %2}
7676    movlhps\t{%2, %0|%0, %2}
7677    movhps\t{%2, %0|%0, %2}"
7678   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov")
7679    (set_attr "mode" "TI,TI,TI,V4SF,V2SF")])
7680
7681 (define_insn "*vec_concatv2di_rex64_avx"
7682   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,Yi,!x,x,x")
7683         (vec_concat:V2DI
7684           (match_operand:DI 1 "nonimmediate_operand" " x,m,r ,*y,x,x")
7685           (match_operand:DI 2 "vector_move_operand"  "rm,C,C ,C ,x,m")))]
7686   "TARGET_64BIT && TARGET_AVX"
7687   "@
7688    vpinsrq\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7689    vmovq\t{%1, %0|%0, %1}
7690    vmovq\t{%1, %0|%0, %1}
7691    movq2dq\t{%1, %0|%0, %1}
7692    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7693    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7694   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov")
7695    (set_attr "prefix_extra" "1,*,*,*,*,*")
7696    (set_attr "length_immediate" "1,*,*,*,*,*")
7697    (set (attr "prefix")
7698      (if_then_else (eq_attr "alternative" "3")
7699        (const_string "orig")
7700        (const_string "vex")))
7701    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
7702
7703 (define_insn "*vec_concatv2di_rex64_sse4_1"
7704   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
7705         (vec_concat:V2DI
7706           (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0")
7707           (match_operand:DI 2 "vector_move_operand"  " rm,C ,C ,C ,x,x,m")))]
7708   "TARGET_64BIT && TARGET_SSE4_1"
7709   "@
7710    pinsrq\t{$0x1, %2, %0|%0, %2, 0x1}
7711    movq\t{%1, %0|%0, %1}
7712    movq\t{%1, %0|%0, %1}
7713    movq2dq\t{%1, %0|%0, %1}
7714    punpcklqdq\t{%2, %0|%0, %2}
7715    movlhps\t{%2, %0|%0, %2}
7716    movhps\t{%2, %0|%0, %2}"
7717   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7718    (set_attr "prefix_rex" "1,*,1,*,*,*,*")
7719    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7720    (set_attr "length_immediate" "1,*,*,*,*,*,*")
7721    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
7722
7723 (define_insn "*vec_concatv2di_rex64_sse"
7724   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
7725         (vec_concat:V2DI
7726           (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0")
7727           (match_operand:DI 2 "vector_move_operand"  " C  ,C ,C  ,Y2,x,m")))]
7728   "TARGET_64BIT && TARGET_SSE"
7729   "@
7730    movq\t{%1, %0|%0, %1}
7731    movq\t{%1, %0|%0, %1}
7732    movq2dq\t{%1, %0|%0, %1}
7733    punpcklqdq\t{%2, %0|%0, %2}
7734    movlhps\t{%2, %0|%0, %2}
7735    movhps\t{%2, %0|%0, %2}"
7736   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7737    (set_attr "prefix_rex" "*,1,*,*,*,*")
7738    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")])
7739
7740 (define_expand "vec_unpacku_hi_v16qi"
7741   [(match_operand:V8HI 0 "register_operand" "")
7742    (match_operand:V16QI 1 "register_operand" "")]
7743   "TARGET_SSE2"
7744 {
7745   if (TARGET_SSE4_1)
7746     ix86_expand_sse4_unpack (operands, true, true);
7747   else
7748     ix86_expand_sse_unpack (operands, true, true);
7749   DONE;
7750 })
7751
7752 (define_expand "vec_unpacks_hi_v16qi"
7753   [(match_operand:V8HI 0 "register_operand" "")
7754    (match_operand:V16QI 1 "register_operand" "")]
7755   "TARGET_SSE2"
7756 {
7757   if (TARGET_SSE4_1)
7758     ix86_expand_sse4_unpack (operands, false, true);
7759   else
7760     ix86_expand_sse_unpack (operands, false, true);
7761   DONE;
7762 })
7763
7764 (define_expand "vec_unpacku_lo_v16qi"
7765   [(match_operand:V8HI 0 "register_operand" "")
7766    (match_operand:V16QI 1 "register_operand" "")]
7767   "TARGET_SSE2"
7768 {
7769   if (TARGET_SSE4_1)
7770     ix86_expand_sse4_unpack (operands, true, false);
7771   else
7772     ix86_expand_sse_unpack (operands, true, false);
7773   DONE;
7774 })
7775
7776 (define_expand "vec_unpacks_lo_v16qi"
7777   [(match_operand:V8HI 0 "register_operand" "")
7778    (match_operand:V16QI 1 "register_operand" "")]
7779   "TARGET_SSE2"
7780 {
7781   if (TARGET_SSE4_1)
7782     ix86_expand_sse4_unpack (operands, false, false);
7783   else
7784     ix86_expand_sse_unpack (operands, false, false);
7785   DONE;
7786 })
7787
7788 (define_expand "vec_unpacku_hi_v8hi"
7789   [(match_operand:V4SI 0 "register_operand" "")
7790    (match_operand:V8HI 1 "register_operand" "")]
7791   "TARGET_SSE2"
7792 {
7793   if (TARGET_SSE4_1)
7794     ix86_expand_sse4_unpack (operands, true, true);
7795   else
7796     ix86_expand_sse_unpack (operands, true, true);
7797   DONE;
7798 })
7799
7800 (define_expand "vec_unpacks_hi_v8hi"
7801   [(match_operand:V4SI 0 "register_operand" "")
7802    (match_operand:V8HI 1 "register_operand" "")]
7803   "TARGET_SSE2"
7804 {
7805   if (TARGET_SSE4_1)
7806     ix86_expand_sse4_unpack (operands, false, true);
7807   else
7808     ix86_expand_sse_unpack (operands, false, true);
7809   DONE;
7810 })
7811
7812 (define_expand "vec_unpacku_lo_v8hi"
7813   [(match_operand:V4SI 0 "register_operand" "")
7814    (match_operand:V8HI 1 "register_operand" "")]
7815   "TARGET_SSE2"
7816 {
7817   if (TARGET_SSE4_1)
7818     ix86_expand_sse4_unpack (operands, true, false);
7819   else
7820     ix86_expand_sse_unpack (operands, true, false);
7821   DONE;
7822 })
7823
7824 (define_expand "vec_unpacks_lo_v8hi"
7825   [(match_operand:V4SI 0 "register_operand" "")
7826    (match_operand:V8HI 1 "register_operand" "")]
7827   "TARGET_SSE2"
7828 {
7829   if (TARGET_SSE4_1)
7830     ix86_expand_sse4_unpack (operands, false, false);
7831   else
7832     ix86_expand_sse_unpack (operands, false, false);
7833   DONE;
7834 })
7835
7836 (define_expand "vec_unpacku_hi_v4si"
7837   [(match_operand:V2DI 0 "register_operand" "")
7838    (match_operand:V4SI 1 "register_operand" "")]
7839   "TARGET_SSE2"
7840 {
7841   if (TARGET_SSE4_1)
7842     ix86_expand_sse4_unpack (operands, true, true);
7843   else
7844     ix86_expand_sse_unpack (operands, true, true);
7845   DONE;
7846 })
7847
7848 (define_expand "vec_unpacks_hi_v4si"
7849   [(match_operand:V2DI 0 "register_operand" "")
7850    (match_operand:V4SI 1 "register_operand" "")]
7851   "TARGET_SSE2"
7852 {
7853   if (TARGET_SSE4_1)
7854     ix86_expand_sse4_unpack (operands, false, true);
7855   else
7856     ix86_expand_sse_unpack (operands, false, true);
7857   DONE;
7858 })
7859
7860 (define_expand "vec_unpacku_lo_v4si"
7861   [(match_operand:V2DI 0 "register_operand" "")
7862    (match_operand:V4SI 1 "register_operand" "")]
7863   "TARGET_SSE2"
7864 {
7865   if (TARGET_SSE4_1)
7866     ix86_expand_sse4_unpack (operands, true, false);
7867   else
7868     ix86_expand_sse_unpack (operands, true, false);
7869   DONE;
7870 })
7871
7872 (define_expand "vec_unpacks_lo_v4si"
7873   [(match_operand:V2DI 0 "register_operand" "")
7874    (match_operand:V4SI 1 "register_operand" "")]
7875   "TARGET_SSE2"
7876 {
7877   if (TARGET_SSE4_1)
7878     ix86_expand_sse4_unpack (operands, false, false);
7879   else
7880     ix86_expand_sse_unpack (operands, false, false);
7881   DONE;
7882 })
7883
7884 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7885 ;;
7886 ;; Miscellaneous
7887 ;;
7888 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7889
7890 (define_expand "sse2_uavgv16qi3"
7891   [(set (match_operand:V16QI 0 "register_operand" "")
7892         (truncate:V16QI
7893           (lshiftrt:V16HI
7894             (plus:V16HI
7895               (plus:V16HI
7896                 (zero_extend:V16HI
7897                   (match_operand:V16QI 1 "nonimmediate_operand" ""))
7898                 (zero_extend:V16HI
7899                   (match_operand:V16QI 2 "nonimmediate_operand" "")))
7900               (const_vector:V16QI [(const_int 1) (const_int 1)
7901                                    (const_int 1) (const_int 1)
7902                                    (const_int 1) (const_int 1)
7903                                    (const_int 1) (const_int 1)
7904                                    (const_int 1) (const_int 1)
7905                                    (const_int 1) (const_int 1)
7906                                    (const_int 1) (const_int 1)
7907                                    (const_int 1) (const_int 1)]))
7908             (const_int 1))))]
7909   "TARGET_SSE2"
7910   "ix86_fixup_binary_operands_no_copy (PLUS, V16QImode, operands);")
7911
7912 (define_insn "*avx_uavgv16qi3"
7913   [(set (match_operand:V16QI 0 "register_operand" "=x")
7914         (truncate:V16QI
7915           (lshiftrt:V16HI
7916             (plus:V16HI
7917               (plus:V16HI
7918                 (zero_extend:V16HI
7919                   (match_operand:V16QI 1 "nonimmediate_operand" "%x"))
7920                 (zero_extend:V16HI
7921                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7922               (const_vector:V16QI [(const_int 1) (const_int 1)
7923                                    (const_int 1) (const_int 1)
7924                                    (const_int 1) (const_int 1)
7925                                    (const_int 1) (const_int 1)
7926                                    (const_int 1) (const_int 1)
7927                                    (const_int 1) (const_int 1)
7928                                    (const_int 1) (const_int 1)
7929                                    (const_int 1) (const_int 1)]))
7930             (const_int 1))))]
7931   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7932   "vpavgb\t{%2, %1, %0|%0, %1, %2}"
7933   [(set_attr "type" "sseiadd")
7934    (set_attr "prefix" "vex")
7935    (set_attr "mode" "TI")])
7936
7937 (define_insn "*sse2_uavgv16qi3"
7938   [(set (match_operand:V16QI 0 "register_operand" "=x")
7939         (truncate:V16QI
7940           (lshiftrt:V16HI
7941             (plus:V16HI
7942               (plus:V16HI
7943                 (zero_extend:V16HI
7944                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
7945                 (zero_extend:V16HI
7946                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7947               (const_vector:V16QI [(const_int 1) (const_int 1)
7948                                    (const_int 1) (const_int 1)
7949                                    (const_int 1) (const_int 1)
7950                                    (const_int 1) (const_int 1)
7951                                    (const_int 1) (const_int 1)
7952                                    (const_int 1) (const_int 1)
7953                                    (const_int 1) (const_int 1)
7954                                    (const_int 1) (const_int 1)]))
7955             (const_int 1))))]
7956   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7957   "pavgb\t{%2, %0|%0, %2}"
7958   [(set_attr "type" "sseiadd")
7959    (set_attr "prefix_data16" "1")
7960    (set_attr "mode" "TI")])
7961
7962 (define_expand "sse2_uavgv8hi3"
7963   [(set (match_operand:V8HI 0 "register_operand" "")
7964         (truncate:V8HI
7965           (lshiftrt:V8SI
7966             (plus:V8SI
7967               (plus:V8SI
7968                 (zero_extend:V8SI
7969                   (match_operand:V8HI 1 "nonimmediate_operand" ""))
7970                 (zero_extend:V8SI
7971                   (match_operand:V8HI 2 "nonimmediate_operand" "")))
7972               (const_vector:V8HI [(const_int 1) (const_int 1)
7973                                   (const_int 1) (const_int 1)
7974                                   (const_int 1) (const_int 1)
7975                                   (const_int 1) (const_int 1)]))
7976             (const_int 1))))]
7977   "TARGET_SSE2"
7978   "ix86_fixup_binary_operands_no_copy (PLUS, V8HImode, operands);")
7979
7980 (define_insn "*avx_uavgv8hi3"
7981   [(set (match_operand:V8HI 0 "register_operand" "=x")
7982         (truncate:V8HI
7983           (lshiftrt:V8SI
7984             (plus:V8SI
7985               (plus:V8SI
7986                 (zero_extend:V8SI
7987                   (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
7988                 (zero_extend:V8SI
7989                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7990               (const_vector:V8HI [(const_int 1) (const_int 1)
7991                                   (const_int 1) (const_int 1)
7992                                   (const_int 1) (const_int 1)
7993                                   (const_int 1) (const_int 1)]))
7994             (const_int 1))))]
7995   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7996   "vpavgw\t{%2, %1, %0|%0, %1, %2}"
7997   [(set_attr "type" "sseiadd")
7998    (set_attr "prefix" "vex")
7999    (set_attr "mode" "TI")])
8000
8001 (define_insn "*sse2_uavgv8hi3"
8002   [(set (match_operand:V8HI 0 "register_operand" "=x")
8003         (truncate:V8HI
8004           (lshiftrt:V8SI
8005             (plus:V8SI
8006               (plus:V8SI
8007                 (zero_extend:V8SI
8008                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
8009                 (zero_extend:V8SI
8010                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8011               (const_vector:V8HI [(const_int 1) (const_int 1)
8012                                   (const_int 1) (const_int 1)
8013                                   (const_int 1) (const_int 1)
8014                                   (const_int 1) (const_int 1)]))
8015             (const_int 1))))]
8016   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
8017   "pavgw\t{%2, %0|%0, %2}"
8018   [(set_attr "type" "sseiadd")
8019    (set_attr "prefix_data16" "1")
8020    (set_attr "mode" "TI")])
8021
8022 ;; The correct representation for this is absolutely enormous, and
8023 ;; surely not generally useful.
8024 (define_insn "*avx_psadbw"
8025   [(set (match_operand:V2DI 0 "register_operand" "=x")
8026         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "x")
8027                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8028                      UNSPEC_PSADBW))]
8029   "TARGET_AVX"
8030   "vpsadbw\t{%2, %1, %0|%0, %1, %2}"
8031   [(set_attr "type" "sseiadd")
8032    (set_attr "prefix" "vex")
8033    (set_attr "mode" "TI")])
8034
8035 (define_insn "sse2_psadbw"
8036   [(set (match_operand:V2DI 0 "register_operand" "=x")
8037         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
8038                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8039                      UNSPEC_PSADBW))]
8040   "TARGET_SSE2"
8041   "psadbw\t{%2, %0|%0, %2}"
8042   [(set_attr "type" "sseiadd")
8043    (set_attr "atom_unit" "simul")
8044    (set_attr "prefix_data16" "1")
8045    (set_attr "mode" "TI")])
8046
8047 (define_insn "avx_movmsk<ssemodesuffix>256"
8048   [(set (match_operand:SI 0 "register_operand" "=r")
8049         (unspec:SI
8050           [(match_operand:AVX256MODEF2P 1 "register_operand" "x")]
8051           UNSPEC_MOVMSK))]
8052   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
8053   "vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
8054   [(set_attr "type" "ssecvt")
8055    (set_attr "prefix" "vex")
8056    (set_attr "mode" "<MODE>")])
8057
8058 (define_insn "<sse>_movmsk<ssemodesuffix>"
8059   [(set (match_operand:SI 0 "register_operand" "=r")
8060         (unspec:SI
8061           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
8062           UNSPEC_MOVMSK))]
8063   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
8064   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
8065   [(set_attr "type" "ssemov")
8066    (set_attr "prefix" "maybe_vex")
8067    (set_attr "mode" "<MODE>")])
8068
8069 (define_insn "sse2_pmovmskb"
8070   [(set (match_operand:SI 0 "register_operand" "=r")
8071         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
8072                    UNSPEC_MOVMSK))]
8073   "TARGET_SSE2"
8074   "%vpmovmskb\t{%1, %0|%0, %1}"
8075   [(set_attr "type" "ssemov")
8076    (set_attr "prefix_data16" "1")
8077    (set_attr "prefix" "maybe_vex")
8078    (set_attr "mode" "SI")])
8079
8080 (define_expand "sse2_maskmovdqu"
8081   [(set (match_operand:V16QI 0 "memory_operand" "")
8082         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
8083                        (match_operand:V16QI 2 "register_operand" "")
8084                        (match_dup 0)]
8085                       UNSPEC_MASKMOV))]
8086   "TARGET_SSE2"
8087   "")
8088
8089 (define_insn "*sse2_maskmovdqu"
8090   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
8091         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8092                        (match_operand:V16QI 2 "register_operand" "x")
8093                        (mem:V16QI (match_dup 0))]
8094                       UNSPEC_MASKMOV))]
8095   "TARGET_SSE2 && !TARGET_64BIT"
8096   ;; @@@ check ordering of operands in intel/nonintel syntax
8097   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8098   [(set_attr "type" "ssemov")
8099    (set_attr "prefix_data16" "1")
8100    ;; The implicit %rdi operand confuses default length_vex computation.
8101    (set_attr "length_vex" "3")
8102    (set_attr "prefix" "maybe_vex")
8103    (set_attr "mode" "TI")])
8104
8105 (define_insn "*sse2_maskmovdqu_rex64"
8106   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
8107         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8108                        (match_operand:V16QI 2 "register_operand" "x")
8109                        (mem:V16QI (match_dup 0))]
8110                       UNSPEC_MASKMOV))]
8111   "TARGET_SSE2 && TARGET_64BIT"
8112   ;; @@@ check ordering of operands in intel/nonintel syntax
8113   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8114   [(set_attr "type" "ssemov")
8115    (set_attr "prefix_data16" "1")
8116    ;; The implicit %rdi operand confuses default length_vex computation.
8117    (set (attr "length_vex")
8118      (symbol_ref ("REGNO (operands[2]) >= FIRST_REX_SSE_REG ? 3 + 1 : 2 + 1")))
8119    (set_attr "prefix" "maybe_vex")
8120    (set_attr "mode" "TI")])
8121
8122 (define_insn "sse_ldmxcsr"
8123   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
8124                     UNSPECV_LDMXCSR)]
8125   "TARGET_SSE"
8126   "%vldmxcsr\t%0"
8127   [(set_attr "type" "sse")
8128    (set_attr "atom_sse_attr" "mxcsr")
8129    (set_attr "prefix" "maybe_vex")
8130    (set_attr "memory" "load")])
8131
8132 (define_insn "sse_stmxcsr"
8133   [(set (match_operand:SI 0 "memory_operand" "=m")
8134         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
8135   "TARGET_SSE"
8136   "%vstmxcsr\t%0"
8137   [(set_attr "type" "sse")
8138    (set_attr "atom_sse_attr" "mxcsr")
8139    (set_attr "prefix" "maybe_vex")
8140    (set_attr "memory" "store")])
8141
8142 (define_expand "sse_sfence"
8143   [(set (match_dup 0)
8144         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8145   "TARGET_SSE || TARGET_3DNOW_A"
8146 {
8147   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8148   MEM_VOLATILE_P (operands[0]) = 1;
8149 })
8150
8151 (define_insn "*sse_sfence"
8152   [(set (match_operand:BLK 0 "" "")
8153         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8154   "TARGET_SSE || TARGET_3DNOW_A"
8155   "sfence"
8156   [(set_attr "type" "sse")
8157    (set_attr "length_address" "0")
8158    (set_attr "atom_sse_attr" "fence")
8159    (set_attr "memory" "unknown")])
8160
8161 (define_insn "sse2_clflush"
8162   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
8163                     UNSPECV_CLFLUSH)]
8164   "TARGET_SSE2"
8165   "clflush\t%a0"
8166   [(set_attr "type" "sse")
8167    (set_attr "atom_sse_attr" "fence")
8168    (set_attr "memory" "unknown")])
8169
8170 (define_expand "sse2_mfence"
8171   [(set (match_dup 0)
8172         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8173   "TARGET_SSE2"
8174 {
8175   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8176   MEM_VOLATILE_P (operands[0]) = 1;
8177 })
8178
8179 (define_insn "*sse2_mfence"
8180   [(set (match_operand:BLK 0 "" "")
8181         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8182   "TARGET_64BIT || TARGET_SSE2"
8183   "mfence"
8184   [(set_attr "type" "sse")
8185    (set_attr "length_address" "0")
8186    (set_attr "atom_sse_attr" "fence")
8187    (set_attr "memory" "unknown")])
8188
8189 (define_expand "sse2_lfence"
8190   [(set (match_dup 0)
8191         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8192   "TARGET_SSE2"
8193 {
8194   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8195   MEM_VOLATILE_P (operands[0]) = 1;
8196 })
8197
8198 (define_insn "*sse2_lfence"
8199   [(set (match_operand:BLK 0 "" "")
8200         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8201   "TARGET_SSE2"
8202   "lfence"
8203   [(set_attr "type" "sse")
8204    (set_attr "length_address" "0")
8205    (set_attr "atom_sse_attr" "lfence")
8206    (set_attr "memory" "unknown")])
8207
8208 (define_insn "sse3_mwait"
8209   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8210                      (match_operand:SI 1 "register_operand" "c")]
8211                     UNSPECV_MWAIT)]
8212   "TARGET_SSE3"
8213 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
8214 ;; Since 32bit register operands are implicitly zero extended to 64bit,
8215 ;; we only need to set up 32bit registers.
8216   "mwait"
8217   [(set_attr "length" "3")])
8218
8219 (define_insn "sse3_monitor"
8220   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8221                      (match_operand:SI 1 "register_operand" "c")
8222                      (match_operand:SI 2 "register_operand" "d")]
8223                     UNSPECV_MONITOR)]
8224   "TARGET_SSE3 && !TARGET_64BIT"
8225   "monitor\t%0, %1, %2"
8226   [(set_attr "length" "3")])
8227
8228 (define_insn "sse3_monitor64"
8229   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
8230                      (match_operand:SI 1 "register_operand" "c")
8231                      (match_operand:SI 2 "register_operand" "d")]
8232                     UNSPECV_MONITOR)]
8233   "TARGET_SSE3 && TARGET_64BIT"
8234 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
8235 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
8236 ;; zero extended to 64bit, we only need to set up 32bit registers.
8237   "monitor"
8238   [(set_attr "length" "3")])
8239
8240 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8241 ;;
8242 ;; SSSE3 instructions
8243 ;;
8244 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8245
8246 (define_insn "*avx_phaddwv8hi3"
8247   [(set (match_operand:V8HI 0 "register_operand" "=x")
8248         (vec_concat:V8HI
8249           (vec_concat:V4HI
8250             (vec_concat:V2HI
8251               (plus:HI
8252                 (vec_select:HI
8253                   (match_operand:V8HI 1 "register_operand" "x")
8254                   (parallel [(const_int 0)]))
8255                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8256               (plus:HI
8257                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8258                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8259             (vec_concat:V2HI
8260               (plus:HI
8261                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8262                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8263               (plus:HI
8264                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8265                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8266           (vec_concat:V4HI
8267             (vec_concat:V2HI
8268               (plus:HI
8269                 (vec_select:HI
8270                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8271                   (parallel [(const_int 0)]))
8272                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8273               (plus:HI
8274                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8275                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8276             (vec_concat:V2HI
8277               (plus:HI
8278                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8279                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8280               (plus:HI
8281                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8282                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8283   "TARGET_AVX"
8284   "vphaddw\t{%2, %1, %0|%0, %1, %2}"
8285   [(set_attr "type" "sseiadd")
8286    (set_attr "prefix_extra" "1")
8287    (set_attr "prefix" "vex")
8288    (set_attr "mode" "TI")])
8289
8290 (define_insn "ssse3_phaddwv8hi3"
8291   [(set (match_operand:V8HI 0 "register_operand" "=x")
8292         (vec_concat:V8HI
8293           (vec_concat:V4HI
8294             (vec_concat:V2HI
8295               (plus:HI
8296                 (vec_select:HI
8297                   (match_operand:V8HI 1 "register_operand" "0")
8298                   (parallel [(const_int 0)]))
8299                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8300               (plus:HI
8301                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8302                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8303             (vec_concat:V2HI
8304               (plus:HI
8305                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8306                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8307               (plus:HI
8308                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8309                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8310           (vec_concat:V4HI
8311             (vec_concat:V2HI
8312               (plus:HI
8313                 (vec_select:HI
8314                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8315                   (parallel [(const_int 0)]))
8316                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8317               (plus:HI
8318                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8319                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8320             (vec_concat:V2HI
8321               (plus:HI
8322                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8323                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8324               (plus:HI
8325                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8326                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8327   "TARGET_SSSE3"
8328   "phaddw\t{%2, %0|%0, %2}"
8329   [(set_attr "type" "sseiadd")
8330    (set_attr "atom_unit" "complex")
8331    (set_attr "prefix_data16" "1")
8332    (set_attr "prefix_extra" "1")
8333    (set_attr "mode" "TI")])
8334
8335 (define_insn "ssse3_phaddwv4hi3"
8336   [(set (match_operand:V4HI 0 "register_operand" "=y")
8337         (vec_concat:V4HI
8338           (vec_concat:V2HI
8339             (plus:HI
8340               (vec_select:HI
8341                 (match_operand:V4HI 1 "register_operand" "0")
8342                 (parallel [(const_int 0)]))
8343               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8344             (plus:HI
8345               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8346               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8347           (vec_concat:V2HI
8348             (plus:HI
8349               (vec_select:HI
8350                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8351                 (parallel [(const_int 0)]))
8352               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8353             (plus:HI
8354               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8355               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8356   "TARGET_SSSE3"
8357   "phaddw\t{%2, %0|%0, %2}"
8358   [(set_attr "type" "sseiadd")
8359    (set_attr "atom_unit" "complex")
8360    (set_attr "prefix_extra" "1")
8361    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8362    (set_attr "mode" "DI")])
8363
8364 (define_insn "*avx_phadddv4si3"
8365   [(set (match_operand:V4SI 0 "register_operand" "=x")
8366         (vec_concat:V4SI
8367           (vec_concat:V2SI
8368             (plus:SI
8369               (vec_select:SI
8370                 (match_operand:V4SI 1 "register_operand" "x")
8371                 (parallel [(const_int 0)]))
8372               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8373             (plus:SI
8374               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8375               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8376           (vec_concat:V2SI
8377             (plus:SI
8378               (vec_select:SI
8379                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8380                 (parallel [(const_int 0)]))
8381               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8382             (plus:SI
8383               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8384               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8385   "TARGET_AVX"
8386   "vphaddd\t{%2, %1, %0|%0, %1, %2}"
8387   [(set_attr "type" "sseiadd")
8388    (set_attr "prefix_extra" "1")
8389    (set_attr "prefix" "vex")
8390    (set_attr "mode" "TI")])
8391
8392 (define_insn "ssse3_phadddv4si3"
8393   [(set (match_operand:V4SI 0 "register_operand" "=x")
8394         (vec_concat:V4SI
8395           (vec_concat:V2SI
8396             (plus:SI
8397               (vec_select:SI
8398                 (match_operand:V4SI 1 "register_operand" "0")
8399                 (parallel [(const_int 0)]))
8400               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8401             (plus:SI
8402               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8403               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8404           (vec_concat:V2SI
8405             (plus:SI
8406               (vec_select:SI
8407                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8408                 (parallel [(const_int 0)]))
8409               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8410             (plus:SI
8411               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8412               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8413   "TARGET_SSSE3"
8414   "phaddd\t{%2, %0|%0, %2}"
8415   [(set_attr "type" "sseiadd")
8416    (set_attr "atom_unit" "complex")
8417    (set_attr "prefix_data16" "1")
8418    (set_attr "prefix_extra" "1")
8419    (set_attr "mode" "TI")])
8420
8421 (define_insn "ssse3_phadddv2si3"
8422   [(set (match_operand:V2SI 0 "register_operand" "=y")
8423         (vec_concat:V2SI
8424           (plus:SI
8425             (vec_select:SI
8426               (match_operand:V2SI 1 "register_operand" "0")
8427               (parallel [(const_int 0)]))
8428             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8429           (plus:SI
8430             (vec_select:SI
8431               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8432               (parallel [(const_int 0)]))
8433             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8434   "TARGET_SSSE3"
8435   "phaddd\t{%2, %0|%0, %2}"
8436   [(set_attr "type" "sseiadd")
8437    (set_attr "atom_unit" "complex")
8438    (set_attr "prefix_extra" "1")
8439    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8440    (set_attr "mode" "DI")])
8441
8442 (define_insn "*avx_phaddswv8hi3"
8443   [(set (match_operand:V8HI 0 "register_operand" "=x")
8444         (vec_concat:V8HI
8445           (vec_concat:V4HI
8446             (vec_concat:V2HI
8447               (ss_plus:HI
8448                 (vec_select:HI
8449                   (match_operand:V8HI 1 "register_operand" "x")
8450                   (parallel [(const_int 0)]))
8451                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8452               (ss_plus:HI
8453                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8454                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8455             (vec_concat:V2HI
8456               (ss_plus:HI
8457                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8458                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8459               (ss_plus:HI
8460                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8461                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8462           (vec_concat:V4HI
8463             (vec_concat:V2HI
8464               (ss_plus:HI
8465                 (vec_select:HI
8466                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8467                   (parallel [(const_int 0)]))
8468                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8469               (ss_plus:HI
8470                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8471                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8472             (vec_concat:V2HI
8473               (ss_plus:HI
8474                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8475                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8476               (ss_plus:HI
8477                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8478                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8479   "TARGET_AVX"
8480   "vphaddsw\t{%2, %1, %0|%0, %1, %2}"
8481   [(set_attr "type" "sseiadd")
8482    (set_attr "prefix_extra" "1")
8483    (set_attr "prefix" "vex")
8484    (set_attr "mode" "TI")])
8485
8486 (define_insn "ssse3_phaddswv8hi3"
8487   [(set (match_operand:V8HI 0 "register_operand" "=x")
8488         (vec_concat:V8HI
8489           (vec_concat:V4HI
8490             (vec_concat:V2HI
8491               (ss_plus:HI
8492                 (vec_select:HI
8493                   (match_operand:V8HI 1 "register_operand" "0")
8494                   (parallel [(const_int 0)]))
8495                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8496               (ss_plus:HI
8497                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8498                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8499             (vec_concat:V2HI
8500               (ss_plus:HI
8501                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8502                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8503               (ss_plus:HI
8504                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8505                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8506           (vec_concat:V4HI
8507             (vec_concat:V2HI
8508               (ss_plus:HI
8509                 (vec_select:HI
8510                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8511                   (parallel [(const_int 0)]))
8512                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8513               (ss_plus:HI
8514                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8515                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8516             (vec_concat:V2HI
8517               (ss_plus:HI
8518                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8519                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8520               (ss_plus:HI
8521                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8522                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8523   "TARGET_SSSE3"
8524   "phaddsw\t{%2, %0|%0, %2}"
8525   [(set_attr "type" "sseiadd")
8526    (set_attr "atom_unit" "complex")
8527    (set_attr "prefix_data16" "1")
8528    (set_attr "prefix_extra" "1")
8529    (set_attr "mode" "TI")])
8530
8531 (define_insn "ssse3_phaddswv4hi3"
8532   [(set (match_operand:V4HI 0 "register_operand" "=y")
8533         (vec_concat:V4HI
8534           (vec_concat:V2HI
8535             (ss_plus:HI
8536               (vec_select:HI
8537                 (match_operand:V4HI 1 "register_operand" "0")
8538                 (parallel [(const_int 0)]))
8539               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8540             (ss_plus:HI
8541               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8542               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8543           (vec_concat:V2HI
8544             (ss_plus:HI
8545               (vec_select:HI
8546                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8547                 (parallel [(const_int 0)]))
8548               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8549             (ss_plus:HI
8550               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8551               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8552   "TARGET_SSSE3"
8553   "phaddsw\t{%2, %0|%0, %2}"
8554   [(set_attr "type" "sseiadd")
8555    (set_attr "atom_unit" "complex")
8556    (set_attr "prefix_extra" "1")
8557    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8558    (set_attr "mode" "DI")])
8559
8560 (define_insn "*avx_phsubwv8hi3"
8561   [(set (match_operand:V8HI 0 "register_operand" "=x")
8562         (vec_concat:V8HI
8563           (vec_concat:V4HI
8564             (vec_concat:V2HI
8565               (minus:HI
8566                 (vec_select:HI
8567                   (match_operand:V8HI 1 "register_operand" "x")
8568                   (parallel [(const_int 0)]))
8569                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8570               (minus:HI
8571                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8572                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8573             (vec_concat:V2HI
8574               (minus:HI
8575                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8576                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8577               (minus:HI
8578                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8579                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8580           (vec_concat:V4HI
8581             (vec_concat:V2HI
8582               (minus:HI
8583                 (vec_select:HI
8584                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8585                   (parallel [(const_int 0)]))
8586                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8587               (minus:HI
8588                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8589                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8590             (vec_concat:V2HI
8591               (minus:HI
8592                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8593                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8594               (minus:HI
8595                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8596                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8597   "TARGET_AVX"
8598   "vphsubw\t{%2, %1, %0|%0, %1, %2}"
8599   [(set_attr "type" "sseiadd")
8600    (set_attr "prefix_extra" "1")
8601    (set_attr "prefix" "vex")
8602    (set_attr "mode" "TI")])
8603
8604 (define_insn "ssse3_phsubwv8hi3"
8605   [(set (match_operand:V8HI 0 "register_operand" "=x")
8606         (vec_concat:V8HI
8607           (vec_concat:V4HI
8608             (vec_concat:V2HI
8609               (minus:HI
8610                 (vec_select:HI
8611                   (match_operand:V8HI 1 "register_operand" "0")
8612                   (parallel [(const_int 0)]))
8613                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8614               (minus:HI
8615                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8616                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8617             (vec_concat:V2HI
8618               (minus:HI
8619                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8620                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8621               (minus:HI
8622                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8623                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8624           (vec_concat:V4HI
8625             (vec_concat:V2HI
8626               (minus:HI
8627                 (vec_select:HI
8628                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8629                   (parallel [(const_int 0)]))
8630                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8631               (minus:HI
8632                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8633                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8634             (vec_concat:V2HI
8635               (minus:HI
8636                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8637                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8638               (minus:HI
8639                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8640                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8641   "TARGET_SSSE3"
8642   "phsubw\t{%2, %0|%0, %2}"
8643   [(set_attr "type" "sseiadd")
8644    (set_attr "atom_unit" "complex")
8645    (set_attr "prefix_data16" "1")
8646    (set_attr "prefix_extra" "1")
8647    (set_attr "mode" "TI")])
8648
8649 (define_insn "ssse3_phsubwv4hi3"
8650   [(set (match_operand:V4HI 0 "register_operand" "=y")
8651         (vec_concat:V4HI
8652           (vec_concat:V2HI
8653             (minus:HI
8654               (vec_select:HI
8655                 (match_operand:V4HI 1 "register_operand" "0")
8656                 (parallel [(const_int 0)]))
8657               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8658             (minus:HI
8659               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8660               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8661           (vec_concat:V2HI
8662             (minus:HI
8663               (vec_select:HI
8664                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8665                 (parallel [(const_int 0)]))
8666               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8667             (minus:HI
8668               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8669               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8670   "TARGET_SSSE3"
8671   "phsubw\t{%2, %0|%0, %2}"
8672   [(set_attr "type" "sseiadd")
8673    (set_attr "atom_unit" "complex")
8674    (set_attr "prefix_extra" "1")
8675    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8676    (set_attr "mode" "DI")])
8677
8678 (define_insn "*avx_phsubdv4si3"
8679   [(set (match_operand:V4SI 0 "register_operand" "=x")
8680         (vec_concat:V4SI
8681           (vec_concat:V2SI
8682             (minus:SI
8683               (vec_select:SI
8684                 (match_operand:V4SI 1 "register_operand" "x")
8685                 (parallel [(const_int 0)]))
8686               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8687             (minus:SI
8688               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8689               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8690           (vec_concat:V2SI
8691             (minus:SI
8692               (vec_select:SI
8693                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8694                 (parallel [(const_int 0)]))
8695               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8696             (minus:SI
8697               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8698               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8699   "TARGET_AVX"
8700   "vphsubd\t{%2, %1, %0|%0, %1, %2}"
8701   [(set_attr "type" "sseiadd")
8702    (set_attr "prefix_extra" "1")
8703    (set_attr "prefix" "vex")
8704    (set_attr "mode" "TI")])
8705
8706 (define_insn "ssse3_phsubdv4si3"
8707   [(set (match_operand:V4SI 0 "register_operand" "=x")
8708         (vec_concat:V4SI
8709           (vec_concat:V2SI
8710             (minus:SI
8711               (vec_select:SI
8712                 (match_operand:V4SI 1 "register_operand" "0")
8713                 (parallel [(const_int 0)]))
8714               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8715             (minus:SI
8716               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8717               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8718           (vec_concat:V2SI
8719             (minus:SI
8720               (vec_select:SI
8721                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8722                 (parallel [(const_int 0)]))
8723               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8724             (minus:SI
8725               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8726               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8727   "TARGET_SSSE3"
8728   "phsubd\t{%2, %0|%0, %2}"
8729   [(set_attr "type" "sseiadd")
8730    (set_attr "atom_unit" "complex")
8731    (set_attr "prefix_data16" "1")
8732    (set_attr "prefix_extra" "1")
8733    (set_attr "mode" "TI")])
8734
8735 (define_insn "ssse3_phsubdv2si3"
8736   [(set (match_operand:V2SI 0 "register_operand" "=y")
8737         (vec_concat:V2SI
8738           (minus:SI
8739             (vec_select:SI
8740               (match_operand:V2SI 1 "register_operand" "0")
8741               (parallel [(const_int 0)]))
8742             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8743           (minus:SI
8744             (vec_select:SI
8745               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8746               (parallel [(const_int 0)]))
8747             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8748   "TARGET_SSSE3"
8749   "phsubd\t{%2, %0|%0, %2}"
8750   [(set_attr "type" "sseiadd")
8751    (set_attr "atom_unit" "complex")
8752    (set_attr "prefix_extra" "1")
8753    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8754    (set_attr "mode" "DI")])
8755
8756 (define_insn "*avx_phsubswv8hi3"
8757   [(set (match_operand:V8HI 0 "register_operand" "=x")
8758         (vec_concat:V8HI
8759           (vec_concat:V4HI
8760             (vec_concat:V2HI
8761               (ss_minus:HI
8762                 (vec_select:HI
8763                   (match_operand:V8HI 1 "register_operand" "x")
8764                   (parallel [(const_int 0)]))
8765                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8766               (ss_minus:HI
8767                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8768                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8769             (vec_concat:V2HI
8770               (ss_minus:HI
8771                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8772                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8773               (ss_minus:HI
8774                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8775                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8776           (vec_concat:V4HI
8777             (vec_concat:V2HI
8778               (ss_minus:HI
8779                 (vec_select:HI
8780                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8781                   (parallel [(const_int 0)]))
8782                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8783               (ss_minus:HI
8784                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8785                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8786             (vec_concat:V2HI
8787               (ss_minus:HI
8788                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8789                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8790               (ss_minus:HI
8791                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8792                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8793   "TARGET_AVX"
8794   "vphsubsw\t{%2, %1, %0|%0, %1, %2}"
8795   [(set_attr "type" "sseiadd")
8796    (set_attr "prefix_extra" "1")
8797    (set_attr "prefix" "vex")
8798    (set_attr "mode" "TI")])
8799
8800 (define_insn "ssse3_phsubswv8hi3"
8801   [(set (match_operand:V8HI 0 "register_operand" "=x")
8802         (vec_concat:V8HI
8803           (vec_concat:V4HI
8804             (vec_concat:V2HI
8805               (ss_minus:HI
8806                 (vec_select:HI
8807                   (match_operand:V8HI 1 "register_operand" "0")
8808                   (parallel [(const_int 0)]))
8809                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8810               (ss_minus:HI
8811                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8812                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8813             (vec_concat:V2HI
8814               (ss_minus:HI
8815                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8816                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8817               (ss_minus:HI
8818                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8819                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8820           (vec_concat:V4HI
8821             (vec_concat:V2HI
8822               (ss_minus:HI
8823                 (vec_select:HI
8824                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8825                   (parallel [(const_int 0)]))
8826                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8827               (ss_minus:HI
8828                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8829                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8830             (vec_concat:V2HI
8831               (ss_minus:HI
8832                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8833                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8834               (ss_minus:HI
8835                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8836                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8837   "TARGET_SSSE3"
8838   "phsubsw\t{%2, %0|%0, %2}"
8839   [(set_attr "type" "sseiadd")
8840    (set_attr "atom_unit" "complex")
8841    (set_attr "prefix_data16" "1")
8842    (set_attr "prefix_extra" "1")
8843    (set_attr "mode" "TI")])
8844
8845 (define_insn "ssse3_phsubswv4hi3"
8846   [(set (match_operand:V4HI 0 "register_operand" "=y")
8847         (vec_concat:V4HI
8848           (vec_concat:V2HI
8849             (ss_minus:HI
8850               (vec_select:HI
8851                 (match_operand:V4HI 1 "register_operand" "0")
8852                 (parallel [(const_int 0)]))
8853               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8854             (ss_minus:HI
8855               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8856               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8857           (vec_concat:V2HI
8858             (ss_minus:HI
8859               (vec_select:HI
8860                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8861                 (parallel [(const_int 0)]))
8862               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8863             (ss_minus:HI
8864               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8865               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8866   "TARGET_SSSE3"
8867   "phsubsw\t{%2, %0|%0, %2}"
8868   [(set_attr "type" "sseiadd")
8869    (set_attr "atom_unit" "complex")
8870    (set_attr "prefix_extra" "1")
8871    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8872    (set_attr "mode" "DI")])
8873
8874 (define_insn "*avx_pmaddubsw128"
8875   [(set (match_operand:V8HI 0 "register_operand" "=x")
8876         (ss_plus:V8HI
8877           (mult:V8HI
8878             (zero_extend:V8HI
8879               (vec_select:V4QI
8880                 (match_operand:V16QI 1 "register_operand" "x")
8881                 (parallel [(const_int 0)
8882                            (const_int 2)
8883                            (const_int 4)
8884                            (const_int 6)
8885                            (const_int 8)
8886                            (const_int 10)
8887                            (const_int 12)
8888                            (const_int 14)])))
8889             (sign_extend:V8HI
8890               (vec_select:V8QI
8891                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8892                 (parallel [(const_int 0)
8893                            (const_int 2)
8894                            (const_int 4)
8895                            (const_int 6)
8896                            (const_int 8)
8897                            (const_int 10)
8898                            (const_int 12)
8899                            (const_int 14)]))))
8900           (mult:V8HI
8901             (zero_extend:V8HI
8902               (vec_select:V16QI (match_dup 1)
8903                 (parallel [(const_int 1)
8904                            (const_int 3)
8905                            (const_int 5)
8906                            (const_int 7)
8907                            (const_int 9)
8908                            (const_int 11)
8909                            (const_int 13)
8910                            (const_int 15)])))
8911             (sign_extend:V8HI
8912               (vec_select:V16QI (match_dup 2)
8913                 (parallel [(const_int 1)
8914                            (const_int 3)
8915                            (const_int 5)
8916                            (const_int 7)
8917                            (const_int 9)
8918                            (const_int 11)
8919                            (const_int 13)
8920                            (const_int 15)]))))))]
8921   "TARGET_AVX"
8922   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8923   [(set_attr "type" "sseiadd")
8924    (set_attr "prefix_extra" "1")
8925    (set_attr "prefix" "vex")
8926    (set_attr "mode" "TI")])
8927
8928 (define_insn "ssse3_pmaddubsw128"
8929   [(set (match_operand:V8HI 0 "register_operand" "=x")
8930         (ss_plus:V8HI
8931           (mult:V8HI
8932             (zero_extend:V8HI
8933               (vec_select:V4QI
8934                 (match_operand:V16QI 1 "register_operand" "0")
8935                 (parallel [(const_int 0)
8936                            (const_int 2)
8937                            (const_int 4)
8938                            (const_int 6)
8939                            (const_int 8)
8940                            (const_int 10)
8941                            (const_int 12)
8942                            (const_int 14)])))
8943             (sign_extend:V8HI
8944               (vec_select:V8QI
8945                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8946                 (parallel [(const_int 0)
8947                            (const_int 2)
8948                            (const_int 4)
8949                            (const_int 6)
8950                            (const_int 8)
8951                            (const_int 10)
8952                            (const_int 12)
8953                            (const_int 14)]))))
8954           (mult:V8HI
8955             (zero_extend:V8HI
8956               (vec_select:V16QI (match_dup 1)
8957                 (parallel [(const_int 1)
8958                            (const_int 3)
8959                            (const_int 5)
8960                            (const_int 7)
8961                            (const_int 9)
8962                            (const_int 11)
8963                            (const_int 13)
8964                            (const_int 15)])))
8965             (sign_extend:V8HI
8966               (vec_select:V16QI (match_dup 2)
8967                 (parallel [(const_int 1)
8968                            (const_int 3)
8969                            (const_int 5)
8970                            (const_int 7)
8971                            (const_int 9)
8972                            (const_int 11)
8973                            (const_int 13)
8974                            (const_int 15)]))))))]
8975   "TARGET_SSSE3"
8976   "pmaddubsw\t{%2, %0|%0, %2}"
8977   [(set_attr "type" "sseiadd")
8978    (set_attr "atom_unit" "simul")
8979    (set_attr "prefix_data16" "1")
8980    (set_attr "prefix_extra" "1")
8981    (set_attr "mode" "TI")])
8982
8983 (define_insn "ssse3_pmaddubsw"
8984   [(set (match_operand:V4HI 0 "register_operand" "=y")
8985         (ss_plus:V4HI
8986           (mult:V4HI
8987             (zero_extend:V4HI
8988               (vec_select:V4QI
8989                 (match_operand:V8QI 1 "register_operand" "0")
8990                 (parallel [(const_int 0)
8991                            (const_int 2)
8992                            (const_int 4)
8993                            (const_int 6)])))
8994             (sign_extend:V4HI
8995               (vec_select:V4QI
8996                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8997                 (parallel [(const_int 0)
8998                            (const_int 2)
8999                            (const_int 4)
9000                            (const_int 6)]))))
9001           (mult:V4HI
9002             (zero_extend:V4HI
9003               (vec_select:V8QI (match_dup 1)
9004                 (parallel [(const_int 1)
9005                            (const_int 3)
9006                            (const_int 5)
9007                            (const_int 7)])))
9008             (sign_extend:V4HI
9009               (vec_select:V8QI (match_dup 2)
9010                 (parallel [(const_int 1)
9011                            (const_int 3)
9012                            (const_int 5)
9013                            (const_int 7)]))))))]
9014   "TARGET_SSSE3"
9015   "pmaddubsw\t{%2, %0|%0, %2}"
9016   [(set_attr "type" "sseiadd")
9017    (set_attr "atom_unit" "simul")
9018    (set_attr "prefix_extra" "1")
9019    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9020    (set_attr "mode" "DI")])
9021
9022 (define_expand "ssse3_pmulhrswv8hi3"
9023   [(set (match_operand:V8HI 0 "register_operand" "")
9024         (truncate:V8HI
9025           (lshiftrt:V8SI
9026             (plus:V8SI
9027               (lshiftrt:V8SI
9028                 (mult:V8SI
9029                   (sign_extend:V8SI
9030                     (match_operand:V8HI 1 "nonimmediate_operand" ""))
9031                   (sign_extend:V8SI
9032                     (match_operand:V8HI 2 "nonimmediate_operand" "")))
9033                 (const_int 14))
9034               (const_vector:V8HI [(const_int 1) (const_int 1)
9035                                   (const_int 1) (const_int 1)
9036                                   (const_int 1) (const_int 1)
9037                                   (const_int 1) (const_int 1)]))
9038             (const_int 1))))]
9039   "TARGET_SSSE3"
9040   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
9041
9042 (define_insn "*avx_pmulhrswv8hi3"
9043   [(set (match_operand:V8HI 0 "register_operand" "=x")
9044         (truncate:V8HI
9045           (lshiftrt:V8SI
9046             (plus:V8SI
9047               (lshiftrt:V8SI
9048                 (mult:V8SI
9049                   (sign_extend:V8SI
9050                     (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
9051                   (sign_extend:V8SI
9052                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
9053                 (const_int 14))
9054               (const_vector:V8HI [(const_int 1) (const_int 1)
9055                                   (const_int 1) (const_int 1)
9056                                   (const_int 1) (const_int 1)
9057                                   (const_int 1) (const_int 1)]))
9058             (const_int 1))))]
9059   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9060   "vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
9061   [(set_attr "type" "sseimul")
9062    (set_attr "prefix_extra" "1")
9063    (set_attr "prefix" "vex")
9064    (set_attr "mode" "TI")])
9065
9066 (define_insn "*ssse3_pmulhrswv8hi3"
9067   [(set (match_operand:V8HI 0 "register_operand" "=x")
9068         (truncate:V8HI
9069           (lshiftrt:V8SI
9070             (plus:V8SI
9071               (lshiftrt:V8SI
9072                 (mult:V8SI
9073                   (sign_extend:V8SI
9074                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
9075                   (sign_extend:V8SI
9076                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
9077                 (const_int 14))
9078               (const_vector:V8HI [(const_int 1) (const_int 1)
9079                                   (const_int 1) (const_int 1)
9080                                   (const_int 1) (const_int 1)
9081                                   (const_int 1) (const_int 1)]))
9082             (const_int 1))))]
9083   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9084   "pmulhrsw\t{%2, %0|%0, %2}"
9085   [(set_attr "type" "sseimul")
9086    (set_attr "prefix_data16" "1")
9087    (set_attr "prefix_extra" "1")
9088    (set_attr "mode" "TI")])
9089
9090 (define_expand "ssse3_pmulhrswv4hi3"
9091   [(set (match_operand:V4HI 0 "register_operand" "")
9092         (truncate:V4HI
9093           (lshiftrt:V4SI
9094             (plus:V4SI
9095               (lshiftrt:V4SI
9096                 (mult:V4SI
9097                   (sign_extend:V4SI
9098                     (match_operand:V4HI 1 "nonimmediate_operand" ""))
9099                   (sign_extend:V4SI
9100                     (match_operand:V4HI 2 "nonimmediate_operand" "")))
9101                 (const_int 14))
9102               (const_vector:V4HI [(const_int 1) (const_int 1)
9103                                   (const_int 1) (const_int 1)]))
9104             (const_int 1))))]
9105   "TARGET_SSSE3"
9106   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
9107
9108 (define_insn "*ssse3_pmulhrswv4hi3"
9109   [(set (match_operand:V4HI 0 "register_operand" "=y")
9110         (truncate:V4HI
9111           (lshiftrt:V4SI
9112             (plus:V4SI
9113               (lshiftrt:V4SI
9114                 (mult:V4SI
9115                   (sign_extend:V4SI
9116                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
9117                   (sign_extend:V4SI
9118                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
9119                 (const_int 14))
9120               (const_vector:V4HI [(const_int 1) (const_int 1)
9121                                   (const_int 1) (const_int 1)]))
9122             (const_int 1))))]
9123   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
9124   "pmulhrsw\t{%2, %0|%0, %2}"
9125   [(set_attr "type" "sseimul")
9126    (set_attr "prefix_extra" "1")
9127    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9128    (set_attr "mode" "DI")])
9129
9130 (define_insn "*avx_pshufbv16qi3"
9131   [(set (match_operand:V16QI 0 "register_operand" "=x")
9132         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9133                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9134                       UNSPEC_PSHUFB))]
9135   "TARGET_AVX"
9136   "vpshufb\t{%2, %1, %0|%0, %1, %2}";
9137   [(set_attr "type" "sselog1")
9138    (set_attr "prefix_extra" "1")
9139    (set_attr "prefix" "vex")
9140    (set_attr "mode" "TI")])
9141
9142 (define_insn "ssse3_pshufbv16qi3"
9143   [(set (match_operand:V16QI 0 "register_operand" "=x")
9144         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9145                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9146                       UNSPEC_PSHUFB))]
9147   "TARGET_SSSE3"
9148   "pshufb\t{%2, %0|%0, %2}";
9149   [(set_attr "type" "sselog1")
9150    (set_attr "prefix_data16" "1")
9151    (set_attr "prefix_extra" "1")
9152    (set_attr "mode" "TI")])
9153
9154 (define_insn "ssse3_pshufbv8qi3"
9155   [(set (match_operand:V8QI 0 "register_operand" "=y")
9156         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
9157                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
9158                      UNSPEC_PSHUFB))]
9159   "TARGET_SSSE3"
9160   "pshufb\t{%2, %0|%0, %2}";
9161   [(set_attr "type" "sselog1")
9162    (set_attr "prefix_extra" "1")
9163    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9164    (set_attr "mode" "DI")])
9165
9166 (define_insn "*avx_psign<mode>3"
9167   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9168         (unspec:SSEMODE124
9169           [(match_operand:SSEMODE124 1 "register_operand" "x")
9170            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9171           UNSPEC_PSIGN))]
9172   "TARGET_AVX"
9173   "vpsign<ssevecsize>\t{%2, %1, %0|%0, %1, %2}";
9174   [(set_attr "type" "sselog1")
9175    (set_attr "prefix_extra" "1")
9176    (set_attr "prefix" "vex")
9177    (set_attr "mode" "TI")])
9178
9179 (define_insn "ssse3_psign<mode>3"
9180   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9181         (unspec:SSEMODE124
9182           [(match_operand:SSEMODE124 1 "register_operand" "0")
9183            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9184           UNSPEC_PSIGN))]
9185   "TARGET_SSSE3"
9186   "psign<ssevecsize>\t{%2, %0|%0, %2}";
9187   [(set_attr "type" "sselog1")
9188    (set_attr "prefix_data16" "1")
9189    (set_attr "prefix_extra" "1")
9190    (set_attr "mode" "TI")])
9191
9192 (define_insn "ssse3_psign<mode>3"
9193   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9194         (unspec:MMXMODEI
9195           [(match_operand:MMXMODEI 1 "register_operand" "0")
9196            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
9197           UNSPEC_PSIGN))]
9198   "TARGET_SSSE3"
9199   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
9200   [(set_attr "type" "sselog1")
9201    (set_attr "prefix_extra" "1")
9202    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9203    (set_attr "mode" "DI")])
9204
9205 (define_insn "*avx_palignrti"
9206   [(set (match_operand:TI 0 "register_operand" "=x")
9207         (unspec:TI [(match_operand:TI 1 "register_operand" "x")
9208                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9209                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9210                    UNSPEC_PALIGNR))]
9211   "TARGET_AVX"
9212 {
9213   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9214   return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
9215 }
9216   [(set_attr "type" "sseishft")
9217    (set_attr "prefix_extra" "1")
9218    (set_attr "length_immediate" "1")
9219    (set_attr "prefix" "vex")
9220    (set_attr "mode" "TI")])
9221
9222 (define_insn "ssse3_palignrti"
9223   [(set (match_operand:TI 0 "register_operand" "=x")
9224         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
9225                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9226                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9227                    UNSPEC_PALIGNR))]
9228   "TARGET_SSSE3"
9229 {
9230   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9231   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9232 }
9233   [(set_attr "type" "sseishft")
9234    (set_attr "atom_unit" "sishuf")
9235    (set_attr "prefix_data16" "1")
9236    (set_attr "prefix_extra" "1")
9237    (set_attr "length_immediate" "1")
9238    (set_attr "mode" "TI")])
9239
9240 (define_insn "ssse3_palignrdi"
9241   [(set (match_operand:DI 0 "register_operand" "=y")
9242         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
9243                     (match_operand:DI 2 "nonimmediate_operand" "ym")
9244                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9245                    UNSPEC_PALIGNR))]
9246   "TARGET_SSSE3"
9247 {
9248   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9249   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9250 }
9251   [(set_attr "type" "sseishft")
9252    (set_attr "atom_unit" "sishuf")
9253    (set_attr "prefix_extra" "1")
9254    (set_attr "length_immediate" "1")
9255    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9256    (set_attr "mode" "DI")])
9257
9258 (define_insn "abs<mode>2"
9259   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9260         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
9261   "TARGET_SSSE3"
9262   "%vpabs<ssevecsize>\t{%1, %0|%0, %1}"
9263   [(set_attr "type" "sselog1")
9264    (set_attr "prefix_data16" "1")
9265    (set_attr "prefix_extra" "1")
9266    (set_attr "prefix" "maybe_vex")
9267    (set_attr "mode" "TI")])
9268
9269 (define_insn "abs<mode>2"
9270   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9271         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
9272   "TARGET_SSSE3"
9273   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
9274   [(set_attr "type" "sselog1")
9275    (set_attr "prefix_rep" "0")
9276    (set_attr "prefix_extra" "1")
9277    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9278    (set_attr "mode" "DI")])
9279
9280 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9281 ;;
9282 ;; AMD SSE4A instructions
9283 ;;
9284 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9285
9286 (define_insn "sse4a_movnt<mode>"
9287   [(set (match_operand:MODEF 0 "memory_operand" "=m")
9288         (unspec:MODEF
9289           [(match_operand:MODEF 1 "register_operand" "x")]
9290           UNSPEC_MOVNT))]
9291   "TARGET_SSE4A"
9292   "movnts<ssemodefsuffix>\t{%1, %0|%0, %1}"
9293   [(set_attr "type" "ssemov")
9294    (set_attr "mode" "<MODE>")])
9295
9296 (define_insn "sse4a_vmmovnt<mode>"
9297   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
9298         (unspec:<ssescalarmode>
9299           [(vec_select:<ssescalarmode>
9300              (match_operand:SSEMODEF2P 1 "register_operand" "x")
9301              (parallel [(const_int 0)]))]
9302           UNSPEC_MOVNT))]
9303   "TARGET_SSE4A"
9304   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
9305   [(set_attr "type" "ssemov")
9306    (set_attr "mode" "<ssescalarmode>")])
9307
9308 (define_insn "sse4a_extrqi"
9309   [(set (match_operand:V2DI 0 "register_operand" "=x")
9310         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9311                       (match_operand 2 "const_int_operand" "")
9312                       (match_operand 3 "const_int_operand" "")]
9313                      UNSPEC_EXTRQI))]
9314   "TARGET_SSE4A"
9315   "extrq\t{%3, %2, %0|%0, %2, %3}"
9316   [(set_attr "type" "sse")
9317    (set_attr "prefix_data16" "1")
9318    (set_attr "length_immediate" "2")
9319    (set_attr "mode" "TI")])
9320
9321 (define_insn "sse4a_extrq"
9322   [(set (match_operand:V2DI 0 "register_operand" "=x")
9323         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9324                       (match_operand:V16QI 2 "register_operand" "x")]
9325                      UNSPEC_EXTRQ))]
9326   "TARGET_SSE4A"
9327   "extrq\t{%2, %0|%0, %2}"
9328   [(set_attr "type" "sse")
9329    (set_attr "prefix_data16" "1")
9330    (set_attr "mode" "TI")])
9331
9332 (define_insn "sse4a_insertqi"
9333   [(set (match_operand:V2DI 0 "register_operand" "=x")
9334         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9335                       (match_operand:V2DI 2 "register_operand" "x")
9336                       (match_operand 3 "const_int_operand" "")
9337                       (match_operand 4 "const_int_operand" "")]
9338                      UNSPEC_INSERTQI))]
9339   "TARGET_SSE4A"
9340   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
9341   [(set_attr "type" "sseins")
9342    (set_attr "prefix_data16" "0")
9343    (set_attr "prefix_rep" "1")
9344    (set_attr "length_immediate" "2")
9345    (set_attr "mode" "TI")])
9346
9347 (define_insn "sse4a_insertq"
9348   [(set (match_operand:V2DI 0 "register_operand" "=x")
9349         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9350                       (match_operand:V2DI 2 "register_operand" "x")]
9351                      UNSPEC_INSERTQ))]
9352   "TARGET_SSE4A"
9353   "insertq\t{%2, %0|%0, %2}"
9354   [(set_attr "type" "sseins")
9355    (set_attr "prefix_data16" "0")
9356    (set_attr "prefix_rep" "1")
9357    (set_attr "mode" "TI")])
9358
9359 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9360 ;;
9361 ;; Intel SSE4.1 instructions
9362 ;;
9363 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9364
9365 (define_insn "avx_blend<ssemodesuffix><avxmodesuffix>"
9366   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9367         (vec_merge:AVXMODEF2P
9368           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9369           (match_operand:AVXMODEF2P 1 "register_operand" "x")
9370           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9371   "TARGET_AVX"
9372   "vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9373   [(set_attr "type" "ssemov")
9374    (set_attr "prefix_extra" "1")
9375    (set_attr "length_immediate" "1")
9376    (set_attr "prefix" "vex")
9377    (set_attr "mode" "<avxvecmode>")])
9378
9379 (define_insn "avx_blendv<ssemodesuffix><avxmodesuffix>"
9380   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9381         (unspec:AVXMODEF2P
9382           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
9383            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9384            (match_operand:AVXMODEF2P 3 "register_operand" "x")]
9385           UNSPEC_BLENDV))]
9386   "TARGET_AVX"
9387   "vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9388   [(set_attr "type" "ssemov")
9389    (set_attr "prefix_extra" "1")
9390    (set_attr "length_immediate" "1")
9391    (set_attr "prefix" "vex")
9392    (set_attr "mode" "<avxvecmode>")])
9393
9394 (define_insn "sse4_1_blend<ssemodesuffix>"
9395   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9396         (vec_merge:SSEMODEF2P
9397           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9398           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9399           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9400   "TARGET_SSE4_1"
9401   "blend<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9402   [(set_attr "type" "ssemov")
9403    (set_attr "prefix_data16" "1")
9404    (set_attr "prefix_extra" "1")
9405    (set_attr "length_immediate" "1")
9406    (set_attr "mode" "<MODE>")])
9407
9408 (define_insn "sse4_1_blendv<ssemodesuffix>"
9409   [(set (match_operand:SSEMODEF2P 0 "reg_not_xmm0_operand" "=x")
9410         (unspec:SSEMODEF2P
9411           [(match_operand:SSEMODEF2P 1 "reg_not_xmm0_operand" "0")
9412            (match_operand:SSEMODEF2P 2 "nonimm_not_xmm0_operand" "xm")
9413            (match_operand:SSEMODEF2P 3 "register_operand" "Yz")]
9414           UNSPEC_BLENDV))]
9415   "TARGET_SSE4_1"
9416   "blendv<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9417   [(set_attr "type" "ssemov")
9418    (set_attr "prefix_data16" "1")
9419    (set_attr "prefix_extra" "1")
9420    (set_attr "mode" "<MODE>")])
9421
9422 (define_insn "avx_dp<ssemodesuffix><avxmodesuffix>"
9423   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9424         (unspec:AVXMODEF2P
9425           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
9426            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9427            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9428           UNSPEC_DP))]
9429   "TARGET_AVX"
9430   "vdp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9431   [(set_attr "type" "ssemul")
9432    (set_attr "prefix" "vex")
9433    (set_attr "prefix_extra" "1")
9434    (set_attr "length_immediate" "1")
9435    (set_attr "mode" "<avxvecmode>")])
9436
9437 (define_insn "sse4_1_dp<ssemodesuffix>"
9438   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9439         (unspec:SSEMODEF2P
9440           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
9441            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9442            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9443           UNSPEC_DP))]
9444   "TARGET_SSE4_1"
9445   "dp<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9446   [(set_attr "type" "ssemul")
9447    (set_attr "prefix_data16" "1")
9448    (set_attr "prefix_extra" "1")
9449    (set_attr "length_immediate" "1")
9450    (set_attr "mode" "<MODE>")])
9451
9452 (define_insn "sse4_1_movntdqa"
9453   [(set (match_operand:V2DI 0 "register_operand" "=x")
9454         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
9455                      UNSPEC_MOVNTDQA))]
9456   "TARGET_SSE4_1"
9457   "%vmovntdqa\t{%1, %0|%0, %1}"
9458   [(set_attr "type" "ssemov")
9459    (set_attr "prefix_extra" "1")
9460    (set_attr "prefix" "maybe_vex")
9461    (set_attr "mode" "TI")])
9462
9463 (define_insn "*avx_mpsadbw"
9464   [(set (match_operand:V16QI 0 "register_operand" "=x")
9465         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9466                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9467                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9468                       UNSPEC_MPSADBW))]
9469   "TARGET_AVX"
9470   "vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9471   [(set_attr "type" "sselog1")
9472    (set_attr "prefix" "vex")
9473    (set_attr "prefix_extra" "1")
9474    (set_attr "length_immediate" "1")
9475    (set_attr "mode" "TI")])
9476
9477 (define_insn "sse4_1_mpsadbw"
9478   [(set (match_operand:V16QI 0 "register_operand" "=x")
9479         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9480                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9481                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9482                       UNSPEC_MPSADBW))]
9483   "TARGET_SSE4_1"
9484   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
9485   [(set_attr "type" "sselog1")
9486    (set_attr "prefix_extra" "1")
9487    (set_attr "length_immediate" "1")
9488    (set_attr "mode" "TI")])
9489
9490 (define_insn "*avx_packusdw"
9491   [(set (match_operand:V8HI 0 "register_operand" "=x")
9492         (vec_concat:V8HI
9493           (us_truncate:V4HI
9494             (match_operand:V4SI 1 "register_operand" "x"))
9495           (us_truncate:V4HI
9496             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9497   "TARGET_AVX"
9498   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
9499   [(set_attr "type" "sselog")
9500    (set_attr "prefix_extra" "1")
9501    (set_attr "prefix" "vex")
9502    (set_attr "mode" "TI")])
9503
9504 (define_insn "sse4_1_packusdw"
9505   [(set (match_operand:V8HI 0 "register_operand" "=x")
9506         (vec_concat:V8HI
9507           (us_truncate:V4HI
9508             (match_operand:V4SI 1 "register_operand" "0"))
9509           (us_truncate:V4HI
9510             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9511   "TARGET_SSE4_1"
9512   "packusdw\t{%2, %0|%0, %2}"
9513   [(set_attr "type" "sselog")
9514    (set_attr "prefix_extra" "1")
9515    (set_attr "mode" "TI")])
9516
9517 (define_insn "*avx_pblendvb"
9518   [(set (match_operand:V16QI 0 "register_operand" "=x")
9519         (unspec:V16QI [(match_operand:V16QI 1 "register_operand"  "x")
9520                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9521                        (match_operand:V16QI 3 "register_operand" "x")]
9522                       UNSPEC_BLENDV))]
9523   "TARGET_AVX"
9524   "vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9525   [(set_attr "type" "ssemov")
9526    (set_attr "prefix_extra" "1")
9527    (set_attr "length_immediate" "1")
9528    (set_attr "prefix" "vex")
9529    (set_attr "mode" "TI")])
9530
9531 (define_insn "sse4_1_pblendvb"
9532   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
9533         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
9534                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
9535                        (match_operand:V16QI 3 "register_operand" "Yz")]
9536                       UNSPEC_BLENDV))]
9537   "TARGET_SSE4_1"
9538   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
9539   [(set_attr "type" "ssemov")
9540    (set_attr "prefix_extra" "1")
9541    (set_attr "mode" "TI")])
9542
9543 (define_insn "*avx_pblendw"
9544   [(set (match_operand:V8HI 0 "register_operand" "=x")
9545         (vec_merge:V8HI
9546           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9547           (match_operand:V8HI 1 "register_operand" "x")
9548           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9549   "TARGET_AVX"
9550   "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9551   [(set_attr "type" "ssemov")
9552    (set_attr "prefix" "vex")
9553    (set_attr "prefix_extra" "1")
9554    (set_attr "length_immediate" "1")
9555    (set_attr "mode" "TI")])
9556
9557 (define_insn "sse4_1_pblendw"
9558   [(set (match_operand:V8HI 0 "register_operand" "=x")
9559         (vec_merge:V8HI
9560           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9561           (match_operand:V8HI 1 "register_operand" "0")
9562           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9563   "TARGET_SSE4_1"
9564   "pblendw\t{%3, %2, %0|%0, %2, %3}"
9565   [(set_attr "type" "ssemov")
9566    (set_attr "prefix_extra" "1")
9567    (set_attr "length_immediate" "1")
9568    (set_attr "mode" "TI")])
9569
9570 (define_insn "sse4_1_phminposuw"
9571   [(set (match_operand:V8HI 0 "register_operand" "=x")
9572         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
9573                      UNSPEC_PHMINPOSUW))]
9574   "TARGET_SSE4_1"
9575   "%vphminposuw\t{%1, %0|%0, %1}"
9576   [(set_attr "type" "sselog1")
9577    (set_attr "prefix_extra" "1")
9578    (set_attr "prefix" "maybe_vex")
9579    (set_attr "mode" "TI")])
9580
9581 (define_insn "sse4_1_extendv8qiv8hi2"
9582   [(set (match_operand:V8HI 0 "register_operand" "=x")
9583         (sign_extend:V8HI
9584           (vec_select:V8QI
9585             (match_operand:V16QI 1 "register_operand" "x")
9586             (parallel [(const_int 0)
9587                        (const_int 1)
9588                        (const_int 2)
9589                        (const_int 3)
9590                        (const_int 4)
9591                        (const_int 5)
9592                        (const_int 6)
9593                        (const_int 7)]))))]
9594   "TARGET_SSE4_1"
9595   "%vpmovsxbw\t{%1, %0|%0, %1}"
9596   [(set_attr "type" "ssemov")
9597    (set_attr "prefix_extra" "1")
9598    (set_attr "prefix" "maybe_vex")
9599    (set_attr "mode" "TI")])
9600
9601 (define_insn "*sse4_1_extendv8qiv8hi2"
9602   [(set (match_operand:V8HI 0 "register_operand" "=x")
9603         (sign_extend:V8HI
9604           (vec_select:V8QI
9605             (vec_duplicate:V16QI
9606               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9607             (parallel [(const_int 0)
9608                        (const_int 1)
9609                        (const_int 2)
9610                        (const_int 3)
9611                        (const_int 4)
9612                        (const_int 5)
9613                        (const_int 6)
9614                        (const_int 7)]))))]
9615   "TARGET_SSE4_1"
9616   "%vpmovsxbw\t{%1, %0|%0, %1}"
9617   [(set_attr "type" "ssemov")
9618    (set_attr "prefix_extra" "1")
9619    (set_attr "prefix" "maybe_vex")
9620    (set_attr "mode" "TI")])
9621
9622 (define_insn "sse4_1_extendv4qiv4si2"
9623   [(set (match_operand:V4SI 0 "register_operand" "=x")
9624         (sign_extend:V4SI
9625           (vec_select:V4QI
9626             (match_operand:V16QI 1 "register_operand" "x")
9627             (parallel [(const_int 0)
9628                        (const_int 1)
9629                        (const_int 2)
9630                        (const_int 3)]))))]
9631   "TARGET_SSE4_1"
9632   "%vpmovsxbd\t{%1, %0|%0, %1}"
9633   [(set_attr "type" "ssemov")
9634    (set_attr "prefix_extra" "1")
9635    (set_attr "prefix" "maybe_vex")
9636    (set_attr "mode" "TI")])
9637
9638 (define_insn "*sse4_1_extendv4qiv4si2"
9639   [(set (match_operand:V4SI 0 "register_operand" "=x")
9640         (sign_extend:V4SI
9641           (vec_select:V4QI
9642             (vec_duplicate:V16QI
9643               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9644             (parallel [(const_int 0)
9645                        (const_int 1)
9646                        (const_int 2)
9647                        (const_int 3)]))))]
9648   "TARGET_SSE4_1"
9649   "%vpmovsxbd\t{%1, %0|%0, %1}"
9650   [(set_attr "type" "ssemov")
9651    (set_attr "prefix_extra" "1")
9652    (set_attr "prefix" "maybe_vex")
9653    (set_attr "mode" "TI")])
9654
9655 (define_insn "sse4_1_extendv2qiv2di2"
9656   [(set (match_operand:V2DI 0 "register_operand" "=x")
9657         (sign_extend:V2DI
9658           (vec_select:V2QI
9659             (match_operand:V16QI 1 "register_operand" "x")
9660             (parallel [(const_int 0)
9661                        (const_int 1)]))))]
9662   "TARGET_SSE4_1"
9663   "%vpmovsxbq\t{%1, %0|%0, %1}"
9664   [(set_attr "type" "ssemov")
9665    (set_attr "prefix_extra" "1")
9666    (set_attr "prefix" "maybe_vex")
9667    (set_attr "mode" "TI")])
9668
9669 (define_insn "*sse4_1_extendv2qiv2di2"
9670   [(set (match_operand:V2DI 0 "register_operand" "=x")
9671         (sign_extend:V2DI
9672           (vec_select:V2QI
9673             (vec_duplicate:V16QI
9674               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9675             (parallel [(const_int 0)
9676                        (const_int 1)]))))]
9677   "TARGET_SSE4_1"
9678   "%vpmovsxbq\t{%1, %0|%0, %1}"
9679   [(set_attr "type" "ssemov")
9680    (set_attr "prefix_extra" "1")
9681    (set_attr "prefix" "maybe_vex")
9682    (set_attr "mode" "TI")])
9683
9684 (define_insn "sse4_1_extendv4hiv4si2"
9685   [(set (match_operand:V4SI 0 "register_operand" "=x")
9686         (sign_extend:V4SI
9687           (vec_select:V4HI
9688             (match_operand:V8HI 1 "register_operand" "x")
9689             (parallel [(const_int 0)
9690                        (const_int 1)
9691                        (const_int 2)
9692                        (const_int 3)]))))]
9693   "TARGET_SSE4_1"
9694   "%vpmovsxwd\t{%1, %0|%0, %1}"
9695   [(set_attr "type" "ssemov")
9696    (set_attr "prefix_extra" "1")
9697    (set_attr "prefix" "maybe_vex")
9698    (set_attr "mode" "TI")])
9699
9700 (define_insn "*sse4_1_extendv4hiv4si2"
9701   [(set (match_operand:V4SI 0 "register_operand" "=x")
9702         (sign_extend:V4SI
9703           (vec_select:V4HI
9704             (vec_duplicate:V8HI
9705               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9706             (parallel [(const_int 0)
9707                        (const_int 1)
9708                        (const_int 2)
9709                        (const_int 3)]))))]
9710   "TARGET_SSE4_1"
9711   "%vpmovsxwd\t{%1, %0|%0, %1}"
9712   [(set_attr "type" "ssemov")
9713    (set_attr "prefix_extra" "1")
9714    (set_attr "prefix" "maybe_vex")
9715    (set_attr "mode" "TI")])
9716
9717 (define_insn "sse4_1_extendv2hiv2di2"
9718   [(set (match_operand:V2DI 0 "register_operand" "=x")
9719         (sign_extend:V2DI
9720           (vec_select:V2HI
9721             (match_operand:V8HI 1 "register_operand" "x")
9722             (parallel [(const_int 0)
9723                        (const_int 1)]))))]
9724   "TARGET_SSE4_1"
9725   "%vpmovsxwq\t{%1, %0|%0, %1}"
9726   [(set_attr "type" "ssemov")
9727    (set_attr "prefix_extra" "1")
9728    (set_attr "prefix" "maybe_vex")
9729    (set_attr "mode" "TI")])
9730
9731 (define_insn "*sse4_1_extendv2hiv2di2"
9732   [(set (match_operand:V2DI 0 "register_operand" "=x")
9733         (sign_extend:V2DI
9734           (vec_select:V2HI
9735             (vec_duplicate:V8HI
9736               (match_operand:V8HI 1 "nonimmediate_operand" "xm"))
9737             (parallel [(const_int 0)
9738                        (const_int 1)]))))]
9739   "TARGET_SSE4_1"
9740   "%vpmovsxwq\t{%1, %0|%0, %1}"
9741   [(set_attr "type" "ssemov")
9742    (set_attr "prefix_extra" "1")
9743    (set_attr "prefix" "maybe_vex")
9744    (set_attr "mode" "TI")])
9745
9746 (define_insn "sse4_1_extendv2siv2di2"
9747   [(set (match_operand:V2DI 0 "register_operand" "=x")
9748         (sign_extend:V2DI
9749           (vec_select:V2SI
9750             (match_operand:V4SI 1 "register_operand" "x")
9751             (parallel [(const_int 0)
9752                        (const_int 1)]))))]
9753   "TARGET_SSE4_1"
9754   "%vpmovsxdq\t{%1, %0|%0, %1}"
9755   [(set_attr "type" "ssemov")
9756    (set_attr "prefix_extra" "1")
9757    (set_attr "prefix" "maybe_vex")
9758    (set_attr "mode" "TI")])
9759
9760 (define_insn "*sse4_1_extendv2siv2di2"
9761   [(set (match_operand:V2DI 0 "register_operand" "=x")
9762         (sign_extend:V2DI
9763           (vec_select:V2SI
9764             (vec_duplicate:V4SI
9765               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9766             (parallel [(const_int 0)
9767                        (const_int 1)]))))]
9768   "TARGET_SSE4_1"
9769   "%vpmovsxdq\t{%1, %0|%0, %1}"
9770   [(set_attr "type" "ssemov")
9771    (set_attr "prefix_extra" "1")
9772    (set_attr "prefix" "maybe_vex")
9773    (set_attr "mode" "TI")])
9774
9775 (define_insn "sse4_1_zero_extendv8qiv8hi2"
9776   [(set (match_operand:V8HI 0 "register_operand" "=x")
9777         (zero_extend:V8HI
9778           (vec_select:V8QI
9779             (match_operand:V16QI 1 "register_operand" "x")
9780             (parallel [(const_int 0)
9781                        (const_int 1)
9782                        (const_int 2)
9783                        (const_int 3)
9784                        (const_int 4)
9785                        (const_int 5)
9786                        (const_int 6)
9787                        (const_int 7)]))))]
9788   "TARGET_SSE4_1"
9789   "%vpmovzxbw\t{%1, %0|%0, %1}"
9790   [(set_attr "type" "ssemov")
9791    (set_attr "prefix_extra" "1")
9792    (set_attr "prefix" "maybe_vex")
9793    (set_attr "mode" "TI")])
9794
9795 (define_insn "*sse4_1_zero_extendv8qiv8hi2"
9796   [(set (match_operand:V8HI 0 "register_operand" "=x")
9797         (zero_extend:V8HI
9798           (vec_select:V8QI
9799             (vec_duplicate:V16QI
9800               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9801             (parallel [(const_int 0)
9802                        (const_int 1)
9803                        (const_int 2)
9804                        (const_int 3)
9805                        (const_int 4)
9806                        (const_int 5)
9807                        (const_int 6)
9808                        (const_int 7)]))))]
9809   "TARGET_SSE4_1"
9810   "%vpmovzxbw\t{%1, %0|%0, %1}"
9811   [(set_attr "type" "ssemov")
9812    (set_attr "prefix_extra" "1")
9813    (set_attr "prefix" "maybe_vex")
9814    (set_attr "mode" "TI")])
9815
9816 (define_insn "sse4_1_zero_extendv4qiv4si2"
9817   [(set (match_operand:V4SI 0 "register_operand" "=x")
9818         (zero_extend:V4SI
9819           (vec_select:V4QI
9820             (match_operand:V16QI 1 "register_operand" "x")
9821             (parallel [(const_int 0)
9822                        (const_int 1)
9823                        (const_int 2)
9824                        (const_int 3)]))))]
9825   "TARGET_SSE4_1"
9826   "%vpmovzxbd\t{%1, %0|%0, %1}"
9827   [(set_attr "type" "ssemov")
9828    (set_attr "prefix_extra" "1")
9829    (set_attr "prefix" "maybe_vex")
9830    (set_attr "mode" "TI")])
9831
9832 (define_insn "*sse4_1_zero_extendv4qiv4si2"
9833   [(set (match_operand:V4SI 0 "register_operand" "=x")
9834         (zero_extend:V4SI
9835           (vec_select:V4QI
9836             (vec_duplicate:V16QI
9837               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9838             (parallel [(const_int 0)
9839                        (const_int 1)
9840                        (const_int 2)
9841                        (const_int 3)]))))]
9842   "TARGET_SSE4_1"
9843   "%vpmovzxbd\t{%1, %0|%0, %1}"
9844   [(set_attr "type" "ssemov")
9845    (set_attr "prefix_extra" "1")
9846    (set_attr "prefix" "maybe_vex")
9847    (set_attr "mode" "TI")])
9848
9849 (define_insn "sse4_1_zero_extendv2qiv2di2"
9850   [(set (match_operand:V2DI 0 "register_operand" "=x")
9851         (zero_extend:V2DI
9852           (vec_select:V2QI
9853             (match_operand:V16QI 1 "register_operand" "x")
9854             (parallel [(const_int 0)
9855                        (const_int 1)]))))]
9856   "TARGET_SSE4_1"
9857   "%vpmovzxbq\t{%1, %0|%0, %1}"
9858   [(set_attr "type" "ssemov")
9859    (set_attr "prefix_extra" "1")
9860    (set_attr "prefix" "maybe_vex")
9861    (set_attr "mode" "TI")])
9862
9863 (define_insn "*sse4_1_zero_extendv2qiv2di2"
9864   [(set (match_operand:V2DI 0 "register_operand" "=x")
9865         (zero_extend:V2DI
9866           (vec_select:V2QI
9867             (vec_duplicate:V16QI
9868               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9869             (parallel [(const_int 0)
9870                        (const_int 1)]))))]
9871   "TARGET_SSE4_1"
9872   "%vpmovzxbq\t{%1, %0|%0, %1}"
9873   [(set_attr "type" "ssemov")
9874    (set_attr "prefix_extra" "1")
9875    (set_attr "prefix" "maybe_vex")
9876    (set_attr "mode" "TI")])
9877
9878 (define_insn "sse4_1_zero_extendv4hiv4si2"
9879   [(set (match_operand:V4SI 0 "register_operand" "=x")
9880         (zero_extend:V4SI
9881           (vec_select:V4HI
9882             (match_operand:V8HI 1 "register_operand" "x")
9883             (parallel [(const_int 0)
9884                        (const_int 1)
9885                        (const_int 2)
9886                        (const_int 3)]))))]
9887   "TARGET_SSE4_1"
9888   "%vpmovzxwd\t{%1, %0|%0, %1}"
9889   [(set_attr "type" "ssemov")
9890    (set_attr "prefix_extra" "1")
9891    (set_attr "prefix" "maybe_vex")
9892    (set_attr "mode" "TI")])
9893
9894 (define_insn "*sse4_1_zero_extendv4hiv4si2"
9895   [(set (match_operand:V4SI 0 "register_operand" "=x")
9896         (zero_extend:V4SI
9897           (vec_select:V4HI
9898             (vec_duplicate:V8HI
9899               (match_operand:V4HI 1 "nonimmediate_operand" "xm"))
9900             (parallel [(const_int 0)
9901                        (const_int 1)
9902                        (const_int 2)
9903                        (const_int 3)]))))]
9904   "TARGET_SSE4_1"
9905   "%vpmovzxwd\t{%1, %0|%0, %1}"
9906   [(set_attr "type" "ssemov")
9907    (set_attr "prefix_extra" "1")
9908    (set_attr "prefix" "maybe_vex")
9909    (set_attr "mode" "TI")])
9910
9911 (define_insn "sse4_1_zero_extendv2hiv2di2"
9912   [(set (match_operand:V2DI 0 "register_operand" "=x")
9913         (zero_extend:V2DI
9914           (vec_select:V2HI
9915             (match_operand:V8HI 1 "register_operand" "x")
9916             (parallel [(const_int 0)
9917                        (const_int 1)]))))]
9918   "TARGET_SSE4_1"
9919   "%vpmovzxwq\t{%1, %0|%0, %1}"
9920   [(set_attr "type" "ssemov")
9921    (set_attr "prefix_extra" "1")
9922    (set_attr "prefix" "maybe_vex")
9923    (set_attr "mode" "TI")])
9924
9925 (define_insn "*sse4_1_zero_extendv2hiv2di2"
9926   [(set (match_operand:V2DI 0 "register_operand" "=x")
9927         (zero_extend:V2DI
9928           (vec_select:V2HI
9929             (vec_duplicate:V8HI
9930               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9931             (parallel [(const_int 0)
9932                        (const_int 1)]))))]
9933   "TARGET_SSE4_1"
9934   "%vpmovzxwq\t{%1, %0|%0, %1}"
9935   [(set_attr "type" "ssemov")
9936    (set_attr "prefix_extra" "1")
9937    (set_attr "prefix" "maybe_vex")
9938    (set_attr "mode" "TI")])
9939
9940 (define_insn "sse4_1_zero_extendv2siv2di2"
9941   [(set (match_operand:V2DI 0 "register_operand" "=x")
9942         (zero_extend:V2DI
9943           (vec_select:V2SI
9944             (match_operand:V4SI 1 "register_operand" "x")
9945             (parallel [(const_int 0)
9946                        (const_int 1)]))))]
9947   "TARGET_SSE4_1"
9948   "%vpmovzxdq\t{%1, %0|%0, %1}"
9949   [(set_attr "type" "ssemov")
9950    (set_attr "prefix_extra" "1")
9951    (set_attr "prefix" "maybe_vex")
9952    (set_attr "mode" "TI")])
9953
9954 (define_insn "*sse4_1_zero_extendv2siv2di2"
9955   [(set (match_operand:V2DI 0 "register_operand" "=x")
9956         (zero_extend:V2DI
9957           (vec_select:V2SI
9958             (vec_duplicate:V4SI
9959               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9960             (parallel [(const_int 0)
9961                        (const_int 1)]))))]
9962   "TARGET_SSE4_1"
9963   "%vpmovzxdq\t{%1, %0|%0, %1}"
9964   [(set_attr "type" "ssemov")
9965    (set_attr "prefix_extra" "1")
9966    (set_attr "prefix" "maybe_vex")
9967    (set_attr "mode" "TI")])
9968
9969 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
9970 ;; setting FLAGS_REG. But it is not a really compare instruction.
9971 (define_insn "avx_vtest<ssemodesuffix><avxmodesuffix>"
9972   [(set (reg:CC FLAGS_REG)
9973         (unspec:CC [(match_operand:AVXMODEF2P 0 "register_operand" "x")
9974                     (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")]
9975                    UNSPEC_VTESTP))]
9976   "TARGET_AVX"
9977   "vtest<ssemodesuffix>\t{%1, %0|%0, %1}"
9978   [(set_attr "type" "ssecomi")
9979    (set_attr "prefix_extra" "1")
9980    (set_attr "prefix" "vex")
9981    (set_attr "mode" "<MODE>")])
9982
9983 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
9984 ;; But it is not a really compare instruction.
9985 (define_insn "avx_ptest256"
9986   [(set (reg:CC FLAGS_REG)
9987         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
9988                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
9989                    UNSPEC_PTEST))]
9990   "TARGET_AVX"
9991   "vptest\t{%1, %0|%0, %1}"
9992   [(set_attr "type" "ssecomi")
9993    (set_attr "prefix_extra" "1")
9994    (set_attr "prefix" "vex")
9995    (set_attr "mode" "OI")])
9996
9997 (define_insn "sse4_1_ptest"
9998   [(set (reg:CC FLAGS_REG)
9999         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
10000                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
10001                    UNSPEC_PTEST))]
10002   "TARGET_SSE4_1"
10003   "%vptest\t{%1, %0|%0, %1}"
10004   [(set_attr "type" "ssecomi")
10005    (set_attr "prefix_extra" "1")
10006    (set_attr "prefix" "maybe_vex")
10007    (set_attr "mode" "TI")])
10008
10009 (define_insn "avx_round<ssemodesuffix>256"
10010   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
10011         (unspec:AVX256MODEF2P
10012           [(match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "xm")
10013            (match_operand:SI 2 "const_0_to_15_operand" "n")]
10014           UNSPEC_ROUND))]
10015   "TARGET_AVX"
10016   "vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10017   [(set_attr "type" "ssecvt")
10018    (set_attr "prefix_extra" "1")
10019    (set_attr "length_immediate" "1")
10020    (set_attr "prefix" "vex")
10021    (set_attr "mode" "<MODE>")])
10022
10023 (define_insn "sse4_1_round<ssemodesuffix>"
10024   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
10025         (unspec:SSEMODEF2P
10026           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")
10027            (match_operand:SI 2 "const_0_to_15_operand" "n")]
10028           UNSPEC_ROUND))]
10029   "TARGET_ROUND"
10030   "%vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10031   [(set_attr "type" "ssecvt")
10032    (set_attr "prefix_data16" "1")
10033    (set_attr "prefix_extra" "1")
10034    (set_attr "length_immediate" "1")
10035    (set_attr "prefix" "maybe_vex")
10036    (set_attr "mode" "<MODE>")])
10037
10038 (define_insn "*avx_round<ssescalarmodesuffix>"
10039   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
10040         (vec_merge:SSEMODEF2P
10041           (unspec:SSEMODEF2P
10042             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
10043              (match_operand:SI 3 "const_0_to_15_operand" "n")]
10044             UNSPEC_ROUND)
10045           (match_operand:SSEMODEF2P 1 "register_operand" "x")
10046           (const_int 1)))]
10047   "TARGET_AVX"
10048   "vround<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10049   [(set_attr "type" "ssecvt")
10050    (set_attr "prefix_extra" "1")
10051    (set_attr "length_immediate" "1")
10052    (set_attr "prefix" "vex")
10053    (set_attr "mode" "<MODE>")])
10054
10055 (define_insn "sse4_1_round<ssescalarmodesuffix>"
10056   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
10057         (vec_merge:SSEMODEF2P
10058           (unspec:SSEMODEF2P
10059             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
10060              (match_operand:SI 3 "const_0_to_15_operand" "n")]
10061             UNSPEC_ROUND)
10062           (match_operand:SSEMODEF2P 1 "register_operand" "0")
10063           (const_int 1)))]
10064   "TARGET_ROUND"
10065   "round<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}"
10066   [(set_attr "type" "ssecvt")
10067    (set_attr "prefix_data16" "1")
10068    (set_attr "prefix_extra" "1")
10069    (set_attr "length_immediate" "1")
10070    (set_attr "mode" "<MODE>")])
10071
10072 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10073 ;;
10074 ;; Intel SSE4.2 string/text processing instructions
10075 ;;
10076 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10077
10078 (define_insn_and_split "sse4_2_pcmpestr"
10079   [(set (match_operand:SI 0 "register_operand" "=c,c")
10080         (unspec:SI
10081           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
10082            (match_operand:SI 3 "register_operand" "a,a")
10083            (match_operand:V16QI 4 "nonimm_not_xmm0_operand" "x,m")
10084            (match_operand:SI 5 "register_operand" "d,d")
10085            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
10086           UNSPEC_PCMPESTR))
10087    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
10088         (unspec:V16QI
10089           [(match_dup 2)
10090            (match_dup 3)
10091            (match_dup 4)
10092            (match_dup 5)
10093            (match_dup 6)]
10094           UNSPEC_PCMPESTR))
10095    (set (reg:CC FLAGS_REG)
10096         (unspec:CC
10097           [(match_dup 2)
10098            (match_dup 3)
10099            (match_dup 4)
10100            (match_dup 5)
10101            (match_dup 6)]
10102           UNSPEC_PCMPESTR))]
10103   "TARGET_SSE4_2
10104    && can_create_pseudo_p ()"
10105   "#"
10106   "&& 1"
10107   [(const_int 0)]
10108 {
10109   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
10110   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
10111   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
10112
10113   if (ecx)
10114     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
10115                                      operands[3], operands[4],
10116                                      operands[5], operands[6]));
10117   if (xmm0)
10118     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
10119                                      operands[3], operands[4],
10120                                      operands[5], operands[6]));
10121   if (flags && !(ecx || xmm0))
10122     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
10123                                            operands[2], operands[3],
10124                                            operands[4], operands[5],
10125                                            operands[6]));
10126   DONE;
10127 }
10128   [(set_attr "type" "sselog")
10129    (set_attr "prefix_data16" "1")
10130    (set_attr "prefix_extra" "1")
10131    (set_attr "length_immediate" "1")
10132    (set_attr "memory" "none,load")
10133    (set_attr "mode" "TI")])
10134
10135 (define_insn "sse4_2_pcmpestri"
10136   [(set (match_operand:SI 0 "register_operand" "=c,c")
10137         (unspec:SI
10138           [(match_operand:V16QI 1 "register_operand" "x,x")
10139            (match_operand:SI 2 "register_operand" "a,a")
10140            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
10141            (match_operand:SI 4 "register_operand" "d,d")
10142            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
10143           UNSPEC_PCMPESTR))
10144    (set (reg:CC FLAGS_REG)
10145         (unspec:CC
10146           [(match_dup 1)
10147            (match_dup 2)
10148            (match_dup 3)
10149            (match_dup 4)
10150            (match_dup 5)]
10151           UNSPEC_PCMPESTR))]
10152   "TARGET_SSE4_2"
10153   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
10154   [(set_attr "type" "sselog")
10155    (set_attr "prefix_data16" "1")
10156    (set_attr "prefix_extra" "1")
10157    (set_attr "prefix" "maybe_vex")
10158    (set_attr "length_immediate" "1")
10159    (set_attr "memory" "none,load")
10160    (set_attr "mode" "TI")])
10161
10162 (define_insn "sse4_2_pcmpestrm"
10163   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
10164         (unspec:V16QI
10165           [(match_operand:V16QI 1 "register_operand" "x,x")
10166            (match_operand:SI 2 "register_operand" "a,a")
10167            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
10168            (match_operand:SI 4 "register_operand" "d,d")
10169            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
10170           UNSPEC_PCMPESTR))
10171    (set (reg:CC FLAGS_REG)
10172         (unspec:CC
10173           [(match_dup 1)
10174            (match_dup 2)
10175            (match_dup 3)
10176            (match_dup 4)
10177            (match_dup 5)]
10178           UNSPEC_PCMPESTR))]
10179   "TARGET_SSE4_2"
10180   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
10181   [(set_attr "type" "sselog")
10182    (set_attr "prefix_data16" "1")
10183    (set_attr "prefix_extra" "1")
10184    (set_attr "length_immediate" "1")
10185    (set_attr "prefix" "maybe_vex")
10186    (set_attr "memory" "none,load")
10187    (set_attr "mode" "TI")])
10188
10189 (define_insn "sse4_2_pcmpestr_cconly"
10190   [(set (reg:CC FLAGS_REG)
10191         (unspec:CC
10192           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
10193            (match_operand:SI 3 "register_operand" "a,a,a,a")
10194            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
10195            (match_operand:SI 5 "register_operand" "d,d,d,d")
10196            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
10197           UNSPEC_PCMPESTR))
10198    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
10199    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
10200   "TARGET_SSE4_2"
10201   "@
10202    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
10203    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
10204    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
10205    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
10206   [(set_attr "type" "sselog")
10207    (set_attr "prefix_data16" "1")
10208    (set_attr "prefix_extra" "1")
10209    (set_attr "length_immediate" "1")
10210    (set_attr "memory" "none,load,none,load")
10211    (set_attr "prefix" "maybe_vex")
10212    (set_attr "mode" "TI")])
10213
10214 (define_insn_and_split "sse4_2_pcmpistr"
10215   [(set (match_operand:SI 0 "register_operand" "=c,c")
10216         (unspec:SI
10217           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
10218            (match_operand:V16QI 3 "nonimm_not_xmm0_operand" "x,m")
10219            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
10220           UNSPEC_PCMPISTR))
10221    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
10222         (unspec:V16QI
10223           [(match_dup 2)
10224            (match_dup 3)
10225            (match_dup 4)]
10226           UNSPEC_PCMPISTR))
10227    (set (reg:CC FLAGS_REG)
10228         (unspec:CC
10229           [(match_dup 2)
10230            (match_dup 3)
10231            (match_dup 4)]
10232           UNSPEC_PCMPISTR))]
10233   "TARGET_SSE4_2
10234    && can_create_pseudo_p ()"
10235   "#"
10236   "&& 1"
10237   [(const_int 0)]
10238 {
10239   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
10240   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
10241   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
10242
10243   if (ecx)
10244     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
10245                                      operands[3], operands[4]));
10246   if (xmm0)
10247     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
10248                                      operands[3], operands[4]));
10249   if (flags && !(ecx || xmm0))
10250     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
10251                                            operands[2], operands[3],
10252                                            operands[4]));
10253   DONE;
10254 }
10255   [(set_attr "type" "sselog")
10256    (set_attr "prefix_data16" "1")
10257    (set_attr "prefix_extra" "1")
10258    (set_attr "length_immediate" "1")
10259    (set_attr "memory" "none,load")
10260    (set_attr "mode" "TI")])
10261
10262 (define_insn "sse4_2_pcmpistri"
10263   [(set (match_operand:SI 0 "register_operand" "=c,c")
10264         (unspec:SI
10265           [(match_operand:V16QI 1 "register_operand" "x,x")
10266            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10267            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10268           UNSPEC_PCMPISTR))
10269    (set (reg:CC FLAGS_REG)
10270         (unspec:CC
10271           [(match_dup 1)
10272            (match_dup 2)
10273            (match_dup 3)]
10274           UNSPEC_PCMPISTR))]
10275   "TARGET_SSE4_2"
10276   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
10277   [(set_attr "type" "sselog")
10278    (set_attr "prefix_data16" "1")
10279    (set_attr "prefix_extra" "1")
10280    (set_attr "length_immediate" "1")
10281    (set_attr "prefix" "maybe_vex")
10282    (set_attr "memory" "none,load")
10283    (set_attr "mode" "TI")])
10284
10285 (define_insn "sse4_2_pcmpistrm"
10286   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
10287         (unspec:V16QI
10288           [(match_operand:V16QI 1 "register_operand" "x,x")
10289            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10290            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10291           UNSPEC_PCMPISTR))
10292    (set (reg:CC FLAGS_REG)
10293         (unspec:CC
10294           [(match_dup 1)
10295            (match_dup 2)
10296            (match_dup 3)]
10297           UNSPEC_PCMPISTR))]
10298   "TARGET_SSE4_2"
10299   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
10300   [(set_attr "type" "sselog")
10301    (set_attr "prefix_data16" "1")
10302    (set_attr "prefix_extra" "1")
10303    (set_attr "length_immediate" "1")
10304    (set_attr "prefix" "maybe_vex")
10305    (set_attr "memory" "none,load")
10306    (set_attr "mode" "TI")])
10307
10308 (define_insn "sse4_2_pcmpistr_cconly"
10309   [(set (reg:CC FLAGS_REG)
10310         (unspec:CC
10311           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
10312            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
10313            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
10314           UNSPEC_PCMPISTR))
10315    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
10316    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
10317   "TARGET_SSE4_2"
10318   "@
10319    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10320    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10321    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
10322    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
10323   [(set_attr "type" "sselog")
10324    (set_attr "prefix_data16" "1")
10325    (set_attr "prefix_extra" "1")
10326    (set_attr "length_immediate" "1")
10327    (set_attr "memory" "none,load,none,load")
10328    (set_attr "prefix" "maybe_vex")
10329    (set_attr "mode" "TI")])
10330
10331 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10332 ;;
10333 ;; XOP instructions
10334 ;;
10335 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10336
10337 ;; XOP parallel integer multiply/add instructions.
10338 ;; Note the XOP multiply/add instructions
10339 ;;     a[i] = b[i] * c[i] + d[i];
10340 ;; do not allow the value being added to be a memory operation.
10341 (define_insn "xop_pmacsww"
10342   [(set (match_operand:V8HI 0 "register_operand" "=x")
10343         (plus:V8HI
10344          (mult:V8HI
10345           (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10346           (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10347          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10348   "TARGET_XOP"
10349   "vpmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10350   [(set_attr "type" "ssemuladd")
10351    (set_attr "mode" "TI")])
10352
10353 (define_insn "xop_pmacssww"
10354   [(set (match_operand:V8HI 0 "register_operand" "=x")
10355         (ss_plus:V8HI
10356          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10357                     (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10358          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10359   "TARGET_XOP"
10360   "vpmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10361   [(set_attr "type" "ssemuladd")
10362    (set_attr "mode" "TI")])
10363
10364 (define_insn "xop_pmacsdd"
10365   [(set (match_operand:V4SI 0 "register_operand" "=x")
10366         (plus:V4SI
10367          (mult:V4SI
10368           (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10369           (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10370          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10371   "TARGET_XOP"
10372   "vpmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10373   [(set_attr "type" "ssemuladd")
10374    (set_attr "mode" "TI")])
10375
10376 (define_insn "xop_pmacssdd"
10377   [(set (match_operand:V4SI 0 "register_operand" "=x")
10378         (ss_plus:V4SI
10379          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10380                     (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10381          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10382   "TARGET_XOP"
10383   "vpmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10384   [(set_attr "type" "ssemuladd")
10385    (set_attr "mode" "TI")])
10386
10387 (define_insn "xop_pmacssdql"
10388   [(set (match_operand:V2DI 0 "register_operand" "=x")
10389         (ss_plus:V2DI
10390          (mult:V2DI
10391           (sign_extend:V2DI
10392            (vec_select:V2SI
10393             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10394             (parallel [(const_int 1)
10395                        (const_int 3)])))
10396           (vec_select:V2SI
10397            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10398            (parallel [(const_int 1)
10399                       (const_int 3)])))
10400          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10401   "TARGET_XOP"
10402   "vpmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10403   [(set_attr "type" "ssemuladd")
10404    (set_attr "mode" "TI")])
10405
10406 (define_insn "xop_pmacssdqh"
10407   [(set (match_operand:V2DI 0 "register_operand" "=x")
10408         (ss_plus:V2DI
10409          (mult:V2DI
10410           (sign_extend:V2DI
10411            (vec_select:V2SI
10412             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10413             (parallel [(const_int 0)
10414                        (const_int 2)])))
10415           (sign_extend:V2DI
10416            (vec_select:V2SI
10417             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10418             (parallel [(const_int 0)
10419                        (const_int 2)]))))
10420          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10421   "TARGET_XOP"
10422   "vpmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10423   [(set_attr "type" "ssemuladd")
10424    (set_attr "mode" "TI")])
10425
10426 (define_insn "xop_pmacsdql"
10427   [(set (match_operand:V2DI 0 "register_operand" "=x")
10428         (plus:V2DI
10429          (mult:V2DI
10430           (sign_extend:V2DI
10431            (vec_select:V2SI
10432             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10433             (parallel [(const_int 1)
10434                        (const_int 3)])))
10435           (sign_extend:V2DI
10436            (vec_select:V2SI
10437             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10438             (parallel [(const_int 1)
10439                        (const_int 3)]))))
10440          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10441   "TARGET_XOP"
10442   "vpmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10443   [(set_attr "type" "ssemuladd")
10444    (set_attr "mode" "TI")])
10445
10446 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10447 ;; fake it with a multiply/add.  In general, we expect the define_split to
10448 ;; occur before register allocation, so we have to handle the corner case where
10449 ;; the target is the same as operands 1/2
10450 (define_insn_and_split "xop_mulv2div2di3_low"
10451   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10452         (mult:V2DI
10453           (sign_extend:V2DI
10454             (vec_select:V2SI
10455               (match_operand:V4SI 1 "register_operand" "%x")
10456               (parallel [(const_int 1)
10457                          (const_int 3)])))
10458           (sign_extend:V2DI
10459             (vec_select:V2SI
10460               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10461               (parallel [(const_int 1)
10462                          (const_int 3)])))))]
10463   "TARGET_XOP"
10464   "#"
10465   "&& reload_completed"
10466   [(set (match_dup 0)
10467         (match_dup 3))
10468    (set (match_dup 0)
10469         (plus:V2DI
10470          (mult:V2DI
10471           (sign_extend:V2DI
10472            (vec_select:V2SI
10473             (match_dup 1)
10474             (parallel [(const_int 1)
10475                        (const_int 3)])))
10476           (sign_extend:V2DI
10477            (vec_select:V2SI
10478             (match_dup 2)
10479             (parallel [(const_int 1)
10480                        (const_int 3)]))))
10481          (match_dup 0)))]
10482 {
10483   operands[3] = CONST0_RTX (V2DImode);
10484 }
10485   [(set_attr "type" "ssemul")
10486    (set_attr "mode" "TI")])
10487
10488 (define_insn "xop_pmacsdqh"
10489   [(set (match_operand:V2DI 0 "register_operand" "=x")
10490         (plus:V2DI
10491          (mult:V2DI
10492           (sign_extend:V2DI
10493            (vec_select:V2SI
10494             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10495             (parallel [(const_int 0)
10496                        (const_int 2)])))
10497           (sign_extend:V2DI
10498            (vec_select:V2SI
10499             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10500             (parallel [(const_int 0)
10501                        (const_int 2)]))))
10502          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10503   "TARGET_XOP"
10504   "vpmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10505   [(set_attr "type" "ssemuladd")
10506    (set_attr "mode" "TI")])
10507
10508 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10509 ;; fake it with a multiply/add.  In general, we expect the define_split to
10510 ;; occur before register allocation, so we have to handle the corner case where
10511 ;; the target is the same as either operands[1] or operands[2]
10512 (define_insn_and_split "xop_mulv2div2di3_high"
10513   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10514         (mult:V2DI
10515           (sign_extend:V2DI
10516             (vec_select:V2SI
10517               (match_operand:V4SI 1 "register_operand" "%x")
10518               (parallel [(const_int 0)
10519                          (const_int 2)])))
10520           (sign_extend:V2DI
10521             (vec_select:V2SI
10522               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10523               (parallel [(const_int 0)
10524                          (const_int 2)])))))]
10525   "TARGET_XOP"
10526   "#"
10527   "&& reload_completed"
10528   [(set (match_dup 0)
10529         (match_dup 3))
10530    (set (match_dup 0)
10531         (plus:V2DI
10532          (mult:V2DI
10533           (sign_extend:V2DI
10534            (vec_select:V2SI
10535             (match_dup 1)
10536             (parallel [(const_int 0)
10537                        (const_int 2)])))
10538           (sign_extend:V2DI
10539            (vec_select:V2SI
10540             (match_dup 2)
10541             (parallel [(const_int 0)
10542                        (const_int 2)]))))
10543          (match_dup 0)))]
10544 {
10545   operands[3] = CONST0_RTX (V2DImode);
10546 }
10547   [(set_attr "type" "ssemul")
10548    (set_attr "mode" "TI")])
10549
10550 ;; XOP parallel integer multiply/add instructions for the intrinisics
10551 (define_insn "xop_pmacsswd"
10552   [(set (match_operand:V4SI 0 "register_operand" "=x")
10553         (ss_plus:V4SI
10554          (mult:V4SI
10555           (sign_extend:V4SI
10556            (vec_select:V4HI
10557             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10558             (parallel [(const_int 1)
10559                        (const_int 3)
10560                        (const_int 5)
10561                        (const_int 7)])))
10562           (sign_extend:V4SI
10563            (vec_select:V4HI
10564             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10565             (parallel [(const_int 1)
10566                        (const_int 3)
10567                        (const_int 5)
10568                        (const_int 7)]))))
10569          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10570   "TARGET_XOP"
10571   "vpmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10572   [(set_attr "type" "ssemuladd")
10573    (set_attr "mode" "TI")])
10574
10575 (define_insn "xop_pmacswd"
10576   [(set (match_operand:V4SI 0 "register_operand" "=x")
10577         (plus:V4SI
10578          (mult:V4SI
10579           (sign_extend:V4SI
10580            (vec_select:V4HI
10581             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10582             (parallel [(const_int 1)
10583                        (const_int 3)
10584                        (const_int 5)
10585                        (const_int 7)])))
10586           (sign_extend:V4SI
10587            (vec_select:V4HI
10588             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10589             (parallel [(const_int 1)
10590                        (const_int 3)
10591                        (const_int 5)
10592                        (const_int 7)]))))
10593          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10594   "TARGET_XOP"
10595   "vpmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10596   [(set_attr "type" "ssemuladd")
10597    (set_attr "mode" "TI")])
10598
10599 (define_insn "xop_pmadcsswd"
10600   [(set (match_operand:V4SI 0 "register_operand" "=x")
10601         (ss_plus:V4SI
10602          (plus:V4SI
10603           (mult:V4SI
10604            (sign_extend:V4SI
10605             (vec_select:V4HI
10606              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10607              (parallel [(const_int 0)
10608                         (const_int 2)
10609                         (const_int 4)
10610                         (const_int 6)])))
10611            (sign_extend:V4SI
10612             (vec_select:V4HI
10613              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10614              (parallel [(const_int 0)
10615                         (const_int 2)
10616                         (const_int 4)
10617                         (const_int 6)]))))
10618           (mult:V4SI
10619            (sign_extend:V4SI
10620             (vec_select:V4HI
10621              (match_dup 1)
10622              (parallel [(const_int 1)
10623                         (const_int 3)
10624                         (const_int 5)
10625                         (const_int 7)])))
10626            (sign_extend:V4SI
10627             (vec_select:V4HI
10628              (match_dup 2)
10629              (parallel [(const_int 1)
10630                         (const_int 3)
10631                         (const_int 5)
10632                         (const_int 7)])))))
10633          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10634   "TARGET_XOP"
10635   "vpmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10636   [(set_attr "type" "ssemuladd")
10637    (set_attr "mode" "TI")])
10638
10639 (define_insn "xop_pmadcswd"
10640   [(set (match_operand:V4SI 0 "register_operand" "=x")
10641         (plus:V4SI
10642          (plus:V4SI
10643           (mult:V4SI
10644            (sign_extend:V4SI
10645             (vec_select:V4HI
10646              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10647              (parallel [(const_int 0)
10648                         (const_int 2)
10649                         (const_int 4)
10650                         (const_int 6)])))
10651            (sign_extend:V4SI
10652             (vec_select:V4HI
10653              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10654              (parallel [(const_int 0)
10655                         (const_int 2)
10656                         (const_int 4)
10657                         (const_int 6)]))))
10658           (mult:V4SI
10659            (sign_extend:V4SI
10660             (vec_select:V4HI
10661              (match_dup 1)
10662              (parallel [(const_int 1)
10663                         (const_int 3)
10664                         (const_int 5)
10665                         (const_int 7)])))
10666            (sign_extend:V4SI
10667             (vec_select:V4HI
10668              (match_dup 2)
10669              (parallel [(const_int 1)
10670                         (const_int 3)
10671                         (const_int 5)
10672                         (const_int 7)])))))
10673          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10674   "TARGET_XOP"
10675   "vpmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10676   [(set_attr "type" "ssemuladd")
10677    (set_attr "mode" "TI")])
10678
10679 ;; XOP parallel XMM conditional moves
10680 (define_insn "xop_pcmov_<mode>"
10681   [(set (match_operand:SSEMODE 0 "register_operand" "=x,x")
10682         (if_then_else:SSEMODE
10683           (match_operand:SSEMODE 3 "nonimmediate_operand" "x,m")
10684           (match_operand:SSEMODE 1 "vector_move_operand" "x,x")
10685           (match_operand:SSEMODE 2 "vector_move_operand" "xm,x")))]
10686   "TARGET_XOP"
10687   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10688   [(set_attr "type" "sse4arg")])
10689
10690 (define_insn "xop_pcmov_<mode>256"
10691   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x")
10692         (if_then_else:AVX256MODE
10693           (match_operand:AVX256MODE 3 "nonimmediate_operand" "x,m")
10694           (match_operand:AVX256MODE 1 "vector_move_operand" "x,x")
10695           (match_operand:AVX256MODE 2 "vector_move_operand" "xm,x")))]
10696   "TARGET_XOP"
10697   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10698   [(set_attr "type" "sse4arg")])
10699
10700 ;; XOP horizontal add/subtract instructions
10701 (define_insn "xop_phaddbw"
10702   [(set (match_operand:V8HI 0 "register_operand" "=x")
10703         (plus:V8HI
10704          (sign_extend:V8HI
10705           (vec_select:V8QI
10706            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10707            (parallel [(const_int 0)
10708                       (const_int 2)
10709                       (const_int 4)
10710                       (const_int 6)
10711                       (const_int 8)
10712                       (const_int 10)
10713                       (const_int 12)
10714                       (const_int 14)])))
10715          (sign_extend:V8HI
10716           (vec_select:V8QI
10717            (match_dup 1)
10718            (parallel [(const_int 1)
10719                       (const_int 3)
10720                       (const_int 5)
10721                       (const_int 7)
10722                       (const_int 9)
10723                       (const_int 11)
10724                       (const_int 13)
10725                       (const_int 15)])))))]
10726   "TARGET_XOP"
10727   "vphaddbw\t{%1, %0|%0, %1}"
10728   [(set_attr "type" "sseiadd1")])
10729
10730 (define_insn "xop_phaddbd"
10731   [(set (match_operand:V4SI 0 "register_operand" "=x")
10732         (plus:V4SI
10733          (plus:V4SI
10734           (sign_extend:V4SI
10735            (vec_select:V4QI
10736             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10737             (parallel [(const_int 0)
10738                        (const_int 4)
10739                        (const_int 8)
10740                        (const_int 12)])))
10741           (sign_extend:V4SI
10742            (vec_select:V4QI
10743             (match_dup 1)
10744             (parallel [(const_int 1)
10745                        (const_int 5)
10746                        (const_int 9)
10747                        (const_int 13)]))))
10748          (plus:V4SI
10749           (sign_extend:V4SI
10750            (vec_select:V4QI
10751             (match_dup 1)
10752             (parallel [(const_int 2)
10753                        (const_int 6)
10754                        (const_int 10)
10755                        (const_int 14)])))
10756           (sign_extend:V4SI
10757            (vec_select:V4QI
10758             (match_dup 1)
10759             (parallel [(const_int 3)
10760                        (const_int 7)
10761                        (const_int 11)
10762                        (const_int 15)]))))))]
10763   "TARGET_XOP"
10764   "vphaddbd\t{%1, %0|%0, %1}"
10765   [(set_attr "type" "sseiadd1")])
10766
10767 (define_insn "xop_phaddbq"
10768   [(set (match_operand:V2DI 0 "register_operand" "=x")
10769         (plus:V2DI
10770          (plus:V2DI
10771           (plus:V2DI
10772            (sign_extend:V2DI
10773             (vec_select:V2QI
10774              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10775              (parallel [(const_int 0)
10776                         (const_int 4)])))
10777            (sign_extend:V2DI
10778             (vec_select:V2QI
10779              (match_dup 1)
10780              (parallel [(const_int 1)
10781                         (const_int 5)]))))
10782           (plus:V2DI
10783            (sign_extend:V2DI
10784             (vec_select:V2QI
10785              (match_dup 1)
10786              (parallel [(const_int 2)
10787                         (const_int 6)])))
10788            (sign_extend:V2DI
10789             (vec_select:V2QI
10790              (match_dup 1)
10791              (parallel [(const_int 3)
10792                         (const_int 7)])))))
10793          (plus:V2DI
10794           (plus:V2DI
10795            (sign_extend:V2DI
10796             (vec_select:V2QI
10797              (match_dup 1)
10798              (parallel [(const_int 8)
10799                         (const_int 12)])))
10800            (sign_extend:V2DI
10801             (vec_select:V2QI
10802              (match_dup 1)
10803              (parallel [(const_int 9)
10804                         (const_int 13)]))))
10805           (plus:V2DI
10806            (sign_extend:V2DI
10807             (vec_select:V2QI
10808              (match_dup 1)
10809              (parallel [(const_int 10)
10810                         (const_int 14)])))
10811            (sign_extend:V2DI
10812             (vec_select:V2QI
10813              (match_dup 1)
10814              (parallel [(const_int 11)
10815                         (const_int 15)])))))))]
10816   "TARGET_XOP"
10817   "vphaddbq\t{%1, %0|%0, %1}"
10818   [(set_attr "type" "sseiadd1")])
10819
10820 (define_insn "xop_phaddwd"
10821   [(set (match_operand:V4SI 0 "register_operand" "=x")
10822         (plus:V4SI
10823          (sign_extend:V4SI
10824           (vec_select:V4HI
10825            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10826            (parallel [(const_int 0)
10827                       (const_int 2)
10828                       (const_int 4)
10829                       (const_int 6)])))
10830          (sign_extend:V4SI
10831           (vec_select:V4HI
10832            (match_dup 1)
10833            (parallel [(const_int 1)
10834                       (const_int 3)
10835                       (const_int 5)
10836                       (const_int 7)])))))]
10837   "TARGET_XOP"
10838   "vphaddwd\t{%1, %0|%0, %1}"
10839   [(set_attr "type" "sseiadd1")])
10840
10841 (define_insn "xop_phaddwq"
10842   [(set (match_operand:V2DI 0 "register_operand" "=x")
10843         (plus:V2DI
10844          (plus:V2DI
10845           (sign_extend:V2DI
10846            (vec_select:V2HI
10847             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10848             (parallel [(const_int 0)
10849                        (const_int 4)])))
10850           (sign_extend:V2DI
10851            (vec_select:V2HI
10852             (match_dup 1)
10853             (parallel [(const_int 1)
10854                        (const_int 5)]))))
10855          (plus:V2DI
10856           (sign_extend:V2DI
10857            (vec_select:V2HI
10858             (match_dup 1)
10859             (parallel [(const_int 2)
10860                        (const_int 6)])))
10861           (sign_extend:V2DI
10862            (vec_select:V2HI
10863             (match_dup 1)
10864             (parallel [(const_int 3)
10865                        (const_int 7)]))))))]
10866   "TARGET_XOP"
10867   "vphaddwq\t{%1, %0|%0, %1}"
10868   [(set_attr "type" "sseiadd1")])
10869
10870 (define_insn "xop_phadddq"
10871   [(set (match_operand:V2DI 0 "register_operand" "=x")
10872         (plus:V2DI
10873          (sign_extend:V2DI
10874           (vec_select:V2SI
10875            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10876            (parallel [(const_int 0)
10877                       (const_int 2)])))
10878          (sign_extend:V2DI
10879           (vec_select:V2SI
10880            (match_dup 1)
10881            (parallel [(const_int 1)
10882                       (const_int 3)])))))]
10883   "TARGET_XOP"
10884   "vphadddq\t{%1, %0|%0, %1}"
10885   [(set_attr "type" "sseiadd1")])
10886
10887 (define_insn "xop_phaddubw"
10888   [(set (match_operand:V8HI 0 "register_operand" "=x")
10889         (plus:V8HI
10890          (zero_extend:V8HI
10891           (vec_select:V8QI
10892            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10893            (parallel [(const_int 0)
10894                       (const_int 2)
10895                       (const_int 4)
10896                       (const_int 6)
10897                       (const_int 8)
10898                       (const_int 10)
10899                       (const_int 12)
10900                       (const_int 14)])))
10901          (zero_extend:V8HI
10902           (vec_select:V8QI
10903            (match_dup 1)
10904            (parallel [(const_int 1)
10905                       (const_int 3)
10906                       (const_int 5)
10907                       (const_int 7)
10908                       (const_int 9)
10909                       (const_int 11)
10910                       (const_int 13)
10911                       (const_int 15)])))))]
10912   "TARGET_XOP"
10913   "vphaddubw\t{%1, %0|%0, %1}"
10914   [(set_attr "type" "sseiadd1")])
10915
10916 (define_insn "xop_phaddubd"
10917   [(set (match_operand:V4SI 0 "register_operand" "=x")
10918         (plus:V4SI
10919          (plus:V4SI
10920           (zero_extend:V4SI
10921            (vec_select:V4QI
10922             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10923             (parallel [(const_int 0)
10924                        (const_int 4)
10925                        (const_int 8)
10926                        (const_int 12)])))
10927           (zero_extend:V4SI
10928            (vec_select:V4QI
10929             (match_dup 1)
10930             (parallel [(const_int 1)
10931                        (const_int 5)
10932                        (const_int 9)
10933                        (const_int 13)]))))
10934          (plus:V4SI
10935           (zero_extend:V4SI
10936            (vec_select:V4QI
10937             (match_dup 1)
10938             (parallel [(const_int 2)
10939                        (const_int 6)
10940                        (const_int 10)
10941                        (const_int 14)])))
10942           (zero_extend:V4SI
10943            (vec_select:V4QI
10944             (match_dup 1)
10945             (parallel [(const_int 3)
10946                        (const_int 7)
10947                        (const_int 11)
10948                        (const_int 15)]))))))]
10949   "TARGET_XOP"
10950   "vphaddubd\t{%1, %0|%0, %1}"
10951   [(set_attr "type" "sseiadd1")])
10952
10953 (define_insn "xop_phaddubq"
10954   [(set (match_operand:V2DI 0 "register_operand" "=x")
10955         (plus:V2DI
10956          (plus:V2DI
10957           (plus:V2DI
10958            (zero_extend:V2DI
10959             (vec_select:V2QI
10960              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10961              (parallel [(const_int 0)
10962                         (const_int 4)])))
10963            (sign_extend:V2DI
10964             (vec_select:V2QI
10965              (match_dup 1)
10966              (parallel [(const_int 1)
10967                         (const_int 5)]))))
10968           (plus:V2DI
10969            (zero_extend:V2DI
10970             (vec_select:V2QI
10971              (match_dup 1)
10972              (parallel [(const_int 2)
10973                         (const_int 6)])))
10974            (zero_extend:V2DI
10975             (vec_select:V2QI
10976              (match_dup 1)
10977              (parallel [(const_int 3)
10978                         (const_int 7)])))))
10979          (plus:V2DI
10980           (plus:V2DI
10981            (zero_extend:V2DI
10982             (vec_select:V2QI
10983              (match_dup 1)
10984              (parallel [(const_int 8)
10985                         (const_int 12)])))
10986            (sign_extend:V2DI
10987             (vec_select:V2QI
10988              (match_dup 1)
10989              (parallel [(const_int 9)
10990                         (const_int 13)]))))
10991           (plus:V2DI
10992            (zero_extend:V2DI
10993             (vec_select:V2QI
10994              (match_dup 1)
10995              (parallel [(const_int 10)
10996                         (const_int 14)])))
10997            (zero_extend:V2DI
10998             (vec_select:V2QI
10999              (match_dup 1)
11000              (parallel [(const_int 11)
11001                         (const_int 15)])))))))]
11002   "TARGET_XOP"
11003   "vphaddubq\t{%1, %0|%0, %1}"
11004   [(set_attr "type" "sseiadd1")])
11005
11006 (define_insn "xop_phadduwd"
11007   [(set (match_operand:V4SI 0 "register_operand" "=x")
11008         (plus:V4SI
11009          (zero_extend:V4SI
11010           (vec_select:V4HI
11011            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11012            (parallel [(const_int 0)
11013                       (const_int 2)
11014                       (const_int 4)
11015                       (const_int 6)])))
11016          (zero_extend:V4SI
11017           (vec_select:V4HI
11018            (match_dup 1)
11019            (parallel [(const_int 1)
11020                       (const_int 3)
11021                       (const_int 5)
11022                       (const_int 7)])))))]
11023   "TARGET_XOP"
11024   "vphadduwd\t{%1, %0|%0, %1}"
11025   [(set_attr "type" "sseiadd1")])
11026
11027 (define_insn "xop_phadduwq"
11028   [(set (match_operand:V2DI 0 "register_operand" "=x")
11029         (plus:V2DI
11030          (plus:V2DI
11031           (zero_extend:V2DI
11032            (vec_select:V2HI
11033             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11034             (parallel [(const_int 0)
11035                        (const_int 4)])))
11036           (zero_extend:V2DI
11037            (vec_select:V2HI
11038             (match_dup 1)
11039             (parallel [(const_int 1)
11040                        (const_int 5)]))))
11041          (plus:V2DI
11042           (zero_extend:V2DI
11043            (vec_select:V2HI
11044             (match_dup 1)
11045             (parallel [(const_int 2)
11046                        (const_int 6)])))
11047           (zero_extend:V2DI
11048            (vec_select:V2HI
11049             (match_dup 1)
11050             (parallel [(const_int 3)
11051                        (const_int 7)]))))))]
11052   "TARGET_XOP"
11053   "vphadduwq\t{%1, %0|%0, %1}"
11054   [(set_attr "type" "sseiadd1")])
11055
11056 (define_insn "xop_phaddudq"
11057   [(set (match_operand:V2DI 0 "register_operand" "=x")
11058         (plus:V2DI
11059          (zero_extend:V2DI
11060           (vec_select:V2SI
11061            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11062            (parallel [(const_int 0)
11063                       (const_int 2)])))
11064          (zero_extend:V2DI
11065           (vec_select:V2SI
11066            (match_dup 1)
11067            (parallel [(const_int 1)
11068                       (const_int 3)])))))]
11069   "TARGET_XOP"
11070   "vphaddudq\t{%1, %0|%0, %1}"
11071   [(set_attr "type" "sseiadd1")])
11072
11073 (define_insn "xop_phsubbw"
11074   [(set (match_operand:V8HI 0 "register_operand" "=x")
11075         (minus:V8HI
11076          (sign_extend:V8HI
11077           (vec_select:V8QI
11078            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11079            (parallel [(const_int 0)
11080                       (const_int 2)
11081                       (const_int 4)
11082                       (const_int 6)
11083                       (const_int 8)
11084                       (const_int 10)
11085                       (const_int 12)
11086                       (const_int 14)])))
11087          (sign_extend:V8HI
11088           (vec_select:V8QI
11089            (match_dup 1)
11090            (parallel [(const_int 1)
11091                       (const_int 3)
11092                       (const_int 5)
11093                       (const_int 7)
11094                       (const_int 9)
11095                       (const_int 11)
11096                       (const_int 13)
11097                       (const_int 15)])))))]
11098   "TARGET_XOP"
11099   "vphsubbw\t{%1, %0|%0, %1}"
11100   [(set_attr "type" "sseiadd1")])
11101
11102 (define_insn "xop_phsubwd"
11103   [(set (match_operand:V4SI 0 "register_operand" "=x")
11104         (minus:V4SI
11105          (sign_extend:V4SI
11106           (vec_select:V4HI
11107            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11108            (parallel [(const_int 0)
11109                       (const_int 2)
11110                       (const_int 4)
11111                       (const_int 6)])))
11112          (sign_extend:V4SI
11113           (vec_select:V4HI
11114            (match_dup 1)
11115            (parallel [(const_int 1)
11116                       (const_int 3)
11117                       (const_int 5)
11118                       (const_int 7)])))))]
11119   "TARGET_XOP"
11120   "vphsubwd\t{%1, %0|%0, %1}"
11121   [(set_attr "type" "sseiadd1")])
11122
11123 (define_insn "xop_phsubdq"
11124   [(set (match_operand:V2DI 0 "register_operand" "=x")
11125         (minus:V2DI
11126          (sign_extend:V2DI
11127           (vec_select:V2SI
11128            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11129            (parallel [(const_int 0)
11130                       (const_int 2)])))
11131          (sign_extend:V2DI
11132           (vec_select:V2SI
11133            (match_dup 1)
11134            (parallel [(const_int 1)
11135                       (const_int 3)])))))]
11136   "TARGET_XOP"
11137   "vphsubdq\t{%1, %0|%0, %1}"
11138   [(set_attr "type" "sseiadd1")])
11139
11140 ;; XOP permute instructions
11141 (define_insn "xop_pperm"
11142   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
11143         (unspec:V16QI
11144           [(match_operand:V16QI 1 "register_operand" "x,x")
11145            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
11146            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
11147           UNSPEC_XOP_PERMUTE))]
11148   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11149   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11150   [(set_attr "type" "sse4arg")
11151    (set_attr "mode" "TI")])
11152
11153 ;; XOP pack instructions that combine two vectors into a smaller vector
11154 (define_insn "xop_pperm_pack_v2di_v4si"
11155   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
11156         (vec_concat:V4SI
11157          (truncate:V2SI
11158           (match_operand:V2DI 1 "register_operand" "x,x"))
11159          (truncate:V2SI
11160           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
11161    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11162   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11163   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11164   [(set_attr "type" "sse4arg")
11165    (set_attr "mode" "TI")])
11166
11167 (define_insn "xop_pperm_pack_v4si_v8hi"
11168   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11169         (vec_concat:V8HI
11170          (truncate:V4HI
11171           (match_operand:V4SI 1 "register_operand" "x,x"))
11172          (truncate:V4HI
11173           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
11174    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11175   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11176   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11177   [(set_attr "type" "sse4arg")
11178    (set_attr "mode" "TI")])
11179
11180 (define_insn "xop_pperm_pack_v8hi_v16qi"
11181   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
11182         (vec_concat:V16QI
11183          (truncate:V8QI
11184           (match_operand:V8HI 1 "register_operand" "x,x"))
11185          (truncate:V8QI
11186           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
11187    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
11188   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
11189   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11190   [(set_attr "type" "sse4arg")
11191    (set_attr "mode" "TI")])
11192
11193 ;; XOP packed rotate instructions
11194 (define_expand "rotl<mode>3"
11195   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11196         (rotate:SSEMODE1248
11197          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11198          (match_operand:SI 2 "general_operand")))]
11199   "TARGET_XOP"
11200 {
11201   /* If we were given a scalar, convert it to parallel */
11202   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11203     {
11204       rtvec vs = rtvec_alloc (<ssescalarnum>);
11205       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11206       rtx reg = gen_reg_rtx (<MODE>mode);
11207       rtx op2 = operands[2];
11208       int i;
11209
11210       if (GET_MODE (op2) != <ssescalarmode>mode)
11211         {
11212           op2 = gen_reg_rtx (<ssescalarmode>mode);
11213           convert_move (op2, operands[2], false);
11214         }
11215
11216       for (i = 0; i < <ssescalarnum>; i++)
11217         RTVEC_ELT (vs, i) = op2;
11218
11219       emit_insn (gen_vec_init<mode> (reg, par));
11220       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
11221       DONE;
11222     }
11223 })
11224
11225 (define_expand "rotr<mode>3"
11226   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11227         (rotatert:SSEMODE1248
11228          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11229          (match_operand:SI 2 "general_operand")))]
11230   "TARGET_XOP"
11231 {
11232   /* If we were given a scalar, convert it to parallel */
11233   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11234     {
11235       rtvec vs = rtvec_alloc (<ssescalarnum>);
11236       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11237       rtx neg = gen_reg_rtx (<MODE>mode);
11238       rtx reg = gen_reg_rtx (<MODE>mode);
11239       rtx op2 = operands[2];
11240       int i;
11241
11242       if (GET_MODE (op2) != <ssescalarmode>mode)
11243         {
11244           op2 = gen_reg_rtx (<ssescalarmode>mode);
11245           convert_move (op2, operands[2], false);
11246         }
11247
11248       for (i = 0; i < <ssescalarnum>; i++)
11249         RTVEC_ELT (vs, i) = op2;
11250
11251       emit_insn (gen_vec_init<mode> (reg, par));
11252       emit_insn (gen_neg<mode>2 (neg, reg));
11253       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
11254       DONE;
11255     }
11256 })
11257
11258 (define_insn "xop_rotl<mode>3"
11259   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11260         (rotate:SSEMODE1248
11261          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11262          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11263   "TARGET_XOP"
11264   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11265   [(set_attr "type" "sseishft")
11266    (set_attr "length_immediate" "1")
11267    (set_attr "mode" "TI")])
11268
11269 (define_insn "xop_rotr<mode>3"
11270   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11271         (rotatert:SSEMODE1248
11272          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11273          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11274   "TARGET_XOP"
11275 {
11276   operands[3] = GEN_INT ((<ssescalarnum> * 8) - INTVAL (operands[2]));
11277   return \"vprot<ssevecsize>\t{%3, %1, %0|%0, %1, %3}\";
11278 }
11279   [(set_attr "type" "sseishft")
11280    (set_attr "length_immediate" "1")
11281    (set_attr "mode" "TI")])
11282
11283 (define_expand "vrotr<mode>3"
11284   [(match_operand:SSEMODE1248 0 "register_operand" "")
11285    (match_operand:SSEMODE1248 1 "register_operand" "")
11286    (match_operand:SSEMODE1248 2 "register_operand" "")]
11287   "TARGET_XOP"
11288 {
11289   rtx reg = gen_reg_rtx (<MODE>mode);
11290   emit_insn (gen_neg<mode>2 (reg, operands[2]));
11291   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
11292   DONE;
11293 })
11294
11295 (define_expand "vrotl<mode>3"
11296   [(match_operand:SSEMODE1248 0 "register_operand" "")
11297    (match_operand:SSEMODE1248 1 "register_operand" "")
11298    (match_operand:SSEMODE1248 2 "register_operand" "")]
11299   "TARGET_XOP"
11300 {
11301   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
11302   DONE;
11303 })
11304
11305 (define_insn "xop_vrotl<mode>3"
11306   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11307         (if_then_else:SSEMODE1248
11308          (ge:SSEMODE1248
11309           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11310           (const_int 0))
11311          (rotate:SSEMODE1248
11312           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11313           (match_dup 2))
11314          (rotatert:SSEMODE1248
11315           (match_dup 1)
11316           (neg:SSEMODE1248 (match_dup 2)))))]
11317   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11318   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11319   [(set_attr "type" "sseishft")
11320    (set_attr "prefix_data16" "0")
11321    (set_attr "prefix_extra" "2")
11322    (set_attr "mode" "TI")])
11323
11324 ;; XOP packed shift instructions.
11325 ;; FIXME: add V2DI back in
11326 (define_expand "vlshr<mode>3"
11327   [(match_operand:SSEMODE124 0 "register_operand" "")
11328    (match_operand:SSEMODE124 1 "register_operand" "")
11329    (match_operand:SSEMODE124 2 "register_operand" "")]
11330   "TARGET_XOP"
11331 {
11332   rtx neg = gen_reg_rtx (<MODE>mode);
11333   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11334   emit_insn (gen_xop_lshl<mode>3 (operands[0], operands[1], neg));
11335   DONE;
11336 })
11337
11338 (define_expand "vashr<mode>3"
11339   [(match_operand:SSEMODE124 0 "register_operand" "")
11340    (match_operand:SSEMODE124 1 "register_operand" "")
11341    (match_operand:SSEMODE124 2 "register_operand" "")]
11342   "TARGET_XOP"
11343 {
11344   rtx neg = gen_reg_rtx (<MODE>mode);
11345   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11346   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], neg));
11347   DONE;
11348 })
11349
11350 (define_expand "vashl<mode>3"
11351   [(match_operand:SSEMODE124 0 "register_operand" "")
11352    (match_operand:SSEMODE124 1 "register_operand" "")
11353    (match_operand:SSEMODE124 2 "register_operand" "")]
11354   "TARGET_XOP"
11355 {
11356   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], operands[2]));
11357   DONE;
11358 })
11359
11360 (define_insn "xop_ashl<mode>3"
11361   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11362         (if_then_else:SSEMODE1248
11363          (ge:SSEMODE1248
11364           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11365           (const_int 0))
11366          (ashift:SSEMODE1248
11367           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11368           (match_dup 2))
11369          (ashiftrt:SSEMODE1248
11370           (match_dup 1)
11371           (neg:SSEMODE1248 (match_dup 2)))))]
11372   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11373   "vpsha<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11374   [(set_attr "type" "sseishft")
11375    (set_attr "prefix_data16" "0")
11376    (set_attr "prefix_extra" "2")
11377    (set_attr "mode" "TI")])
11378
11379 (define_insn "xop_lshl<mode>3"
11380   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11381         (if_then_else:SSEMODE1248
11382          (ge:SSEMODE1248
11383           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11384           (const_int 0))
11385          (ashift:SSEMODE1248
11386           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11387           (match_dup 2))
11388          (lshiftrt:SSEMODE1248
11389           (match_dup 1)
11390           (neg:SSEMODE1248 (match_dup 2)))))]
11391   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11392   "vpshl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11393   [(set_attr "type" "sseishft")
11394    (set_attr "prefix_data16" "0")
11395    (set_attr "prefix_extra" "2")
11396    (set_attr "mode" "TI")])
11397
11398 ;; SSE2 doesn't have some shift varients, so define versions for XOP
11399 (define_expand "ashlv16qi3"
11400   [(match_operand:V16QI 0 "register_operand" "")
11401    (match_operand:V16QI 1 "register_operand" "")
11402    (match_operand:SI 2 "nonmemory_operand" "")]
11403   "TARGET_XOP"
11404 {
11405   rtvec vs = rtvec_alloc (16);
11406   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11407   rtx reg = gen_reg_rtx (V16QImode);
11408   int i;
11409   for (i = 0; i < 16; i++)
11410     RTVEC_ELT (vs, i) = operands[2];
11411
11412   emit_insn (gen_vec_initv16qi (reg, par));
11413   emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11414   DONE;
11415 })
11416
11417 (define_expand "lshlv16qi3"
11418   [(match_operand:V16QI 0 "register_operand" "")
11419    (match_operand:V16QI 1 "register_operand" "")
11420    (match_operand:SI 2 "nonmemory_operand" "")]
11421   "TARGET_XOP"
11422 {
11423   rtvec vs = rtvec_alloc (16);
11424   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11425   rtx reg = gen_reg_rtx (V16QImode);
11426   int i;
11427   for (i = 0; i < 16; i++)
11428     RTVEC_ELT (vs, i) = operands[2];
11429
11430   emit_insn (gen_vec_initv16qi (reg, par));
11431   emit_insn (gen_xop_lshlv16qi3 (operands[0], operands[1], reg));
11432   DONE;
11433 })
11434
11435 (define_expand "ashrv16qi3"
11436   [(match_operand:V16QI 0 "register_operand" "")
11437    (match_operand:V16QI 1 "register_operand" "")
11438    (match_operand:SI 2 "nonmemory_operand" "")]
11439   "TARGET_XOP"
11440 {
11441   rtvec vs = rtvec_alloc (16);
11442   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11443   rtx reg = gen_reg_rtx (V16QImode);
11444   int i;
11445   rtx ele = ((CONST_INT_P (operands[2]))
11446              ? GEN_INT (- INTVAL (operands[2]))
11447              : operands[2]);
11448
11449   for (i = 0; i < 16; i++)
11450     RTVEC_ELT (vs, i) = ele;
11451
11452   emit_insn (gen_vec_initv16qi (reg, par));
11453
11454   if (!CONST_INT_P (operands[2]))
11455     {
11456       rtx neg = gen_reg_rtx (V16QImode);
11457       emit_insn (gen_negv16qi2 (neg, reg));
11458       emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], neg));
11459     }
11460   else
11461     emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11462
11463   DONE;
11464 })
11465
11466 (define_expand "ashrv2di3"
11467   [(match_operand:V2DI 0 "register_operand" "")
11468    (match_operand:V2DI 1 "register_operand" "")
11469    (match_operand:DI 2 "nonmemory_operand" "")]
11470   "TARGET_XOP"
11471 {
11472   rtvec vs = rtvec_alloc (2);
11473   rtx par = gen_rtx_PARALLEL (V2DImode, vs);
11474   rtx reg = gen_reg_rtx (V2DImode);
11475   rtx ele;
11476
11477   if (CONST_INT_P (operands[2]))
11478     ele = GEN_INT (- INTVAL (operands[2]));
11479   else if (GET_MODE (operands[2]) != DImode)
11480     {
11481       rtx move = gen_reg_rtx (DImode);
11482       ele = gen_reg_rtx (DImode);
11483       convert_move (move, operands[2], false);
11484       emit_insn (gen_negdi2 (ele, move));
11485     }
11486   else
11487     {
11488       ele = gen_reg_rtx (DImode);
11489       emit_insn (gen_negdi2 (ele, operands[2]));
11490     }
11491
11492   RTVEC_ELT (vs, 0) = ele;
11493   RTVEC_ELT (vs, 1) = ele;
11494   emit_insn (gen_vec_initv2di (reg, par));
11495   emit_insn (gen_xop_ashlv2di3 (operands[0], operands[1], reg));
11496   DONE;
11497 })
11498
11499 ;; XOP FRCZ support
11500 ;; parallel insns
11501 (define_insn "xop_frcz<mode>2"
11502   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11503         (unspec:SSEMODEF2P
11504          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")]
11505          UNSPEC_FRCZ))]
11506   "TARGET_XOP"
11507   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
11508   [(set_attr "type" "ssecvt1")
11509    (set_attr "mode" "<MODE>")])
11510
11511 ;; scalar insns
11512 (define_insn "xop_vmfrcz<mode>2"
11513   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11514         (vec_merge:SSEMODEF2P
11515           (unspec:SSEMODEF2P
11516            [(match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
11517            UNSPEC_FRCZ)
11518           (match_operand:SSEMODEF2P 1 "register_operand" "0")
11519           (const_int 1)))]
11520   "TARGET_XOP"
11521   "vfrcz<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
11522   [(set_attr "type" "ssecvt1")
11523    (set_attr "mode" "<MODE>")])
11524
11525 (define_insn "xop_frcz<mode>2256"
11526   [(set (match_operand:FMA4MODEF4 0 "register_operand" "=x")
11527         (unspec:FMA4MODEF4
11528          [(match_operand:FMA4MODEF4 1 "nonimmediate_operand" "xm")]
11529          UNSPEC_FRCZ))]
11530   "TARGET_XOP"
11531   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
11532   [(set_attr "type" "ssecvt1")
11533    (set_attr "mode" "<MODE>")])
11534
11535 (define_insn "xop_maskcmp<mode>3"
11536   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11537         (match_operator:SSEMODE1248 1 "ix86_comparison_int_operator"
11538          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11539           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11540   "TARGET_XOP"
11541   "vpcom%Y1<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11542   [(set_attr "type" "sse4arg")
11543    (set_attr "prefix_data16" "0")
11544    (set_attr "prefix_rep" "0")
11545    (set_attr "prefix_extra" "2")
11546    (set_attr "length_immediate" "1")
11547    (set_attr "mode" "TI")])
11548
11549 (define_insn "xop_maskcmp_uns<mode>3"
11550   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11551         (match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11552          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11553           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11554   "TARGET_XOP"
11555   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11556   [(set_attr "type" "ssecmp")
11557    (set_attr "prefix_data16" "0")
11558    (set_attr "prefix_rep" "0")
11559    (set_attr "prefix_extra" "2")
11560    (set_attr "length_immediate" "1")
11561    (set_attr "mode" "TI")])
11562
11563 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
11564 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
11565 ;; the exact instruction generated for the intrinsic.
11566 (define_insn "xop_maskcmp_uns2<mode>3"
11567   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11568         (unspec:SSEMODE1248
11569          [(match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11570           [(match_operand:SSEMODE1248 2 "register_operand" "x")
11571            (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")])]
11572          UNSPEC_XOP_UNSIGNED_CMP))]
11573   "TARGET_XOP"
11574   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11575   [(set_attr "type" "ssecmp")
11576    (set_attr "prefix_data16" "0")
11577    (set_attr "prefix_extra" "2")
11578    (set_attr "length_immediate" "1")
11579    (set_attr "mode" "TI")])
11580
11581 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
11582 ;; being added here to be complete.
11583 (define_insn "xop_pcom_tf<mode>3"
11584   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11585         (unspec:SSEMODE1248
11586           [(match_operand:SSEMODE1248 1 "register_operand" "x")
11587            (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")
11588            (match_operand:SI 3 "const_int_operand" "n")]
11589           UNSPEC_XOP_TRUEFALSE))]
11590   "TARGET_XOP"
11591 {
11592   return ((INTVAL (operands[3]) != 0)
11593           ? "vpcomtrue<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11594           : "vpcomfalse<ssevecsize>\t{%2, %1, %0|%0, %1, %2}");
11595 }
11596   [(set_attr "type" "ssecmp")
11597    (set_attr "prefix_data16" "0")
11598    (set_attr "prefix_extra" "2")
11599    (set_attr "length_immediate" "1")
11600    (set_attr "mode" "TI")])
11601
11602 (define_insn "xop_vpermil2<mode>3"
11603   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11604         (unspec:AVXMODEF2P
11605           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11606            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "%x")
11607            (match_operand:<avxpermvecmode> 3 "nonimmediate_operand" "xm")
11608            (match_operand:SI 4 "const_0_to_3_operand" "n")]
11609           UNSPEC_VPERMIL2))]
11610   "TARGET_XOP"
11611   "vpermil2<ssemodesuffix>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
11612   [(set_attr "type" "sse4arg")
11613    (set_attr "length_immediate" "1")
11614    (set_attr "mode" "<MODE>")])
11615
11616 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11617 (define_insn "*avx_aesenc"
11618   [(set (match_operand:V2DI 0 "register_operand" "=x")
11619         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11620                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11621                       UNSPEC_AESENC))]
11622   "TARGET_AES && TARGET_AVX"
11623   "vaesenc\t{%2, %1, %0|%0, %1, %2}"
11624   [(set_attr "type" "sselog1")
11625    (set_attr "prefix_extra" "1")
11626    (set_attr "prefix" "vex")
11627    (set_attr "mode" "TI")])
11628
11629 (define_insn "aesenc"
11630   [(set (match_operand:V2DI 0 "register_operand" "=x")
11631         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11632                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11633                       UNSPEC_AESENC))]
11634   "TARGET_AES"
11635   "aesenc\t{%2, %0|%0, %2}"
11636   [(set_attr "type" "sselog1")
11637    (set_attr "prefix_extra" "1")
11638    (set_attr "mode" "TI")])
11639
11640 (define_insn "*avx_aesenclast"
11641   [(set (match_operand:V2DI 0 "register_operand" "=x")
11642         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11643                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11644                       UNSPEC_AESENCLAST))]
11645   "TARGET_AES && TARGET_AVX"
11646   "vaesenclast\t{%2, %1, %0|%0, %1, %2}"
11647   [(set_attr "type" "sselog1")
11648    (set_attr "prefix_extra" "1")
11649    (set_attr "prefix" "vex")
11650    (set_attr "mode" "TI")])
11651
11652 (define_insn "aesenclast"
11653   [(set (match_operand:V2DI 0 "register_operand" "=x")
11654         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11655                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11656                       UNSPEC_AESENCLAST))]
11657   "TARGET_AES"
11658   "aesenclast\t{%2, %0|%0, %2}"
11659   [(set_attr "type" "sselog1")
11660    (set_attr "prefix_extra" "1")
11661    (set_attr "mode" "TI")])
11662
11663 (define_insn "*avx_aesdec"
11664   [(set (match_operand:V2DI 0 "register_operand" "=x")
11665         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11666                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11667                       UNSPEC_AESDEC))]
11668   "TARGET_AES && TARGET_AVX"
11669   "vaesdec\t{%2, %1, %0|%0, %1, %2}"
11670   [(set_attr "type" "sselog1")
11671    (set_attr "prefix_extra" "1")
11672    (set_attr "prefix" "vex")
11673    (set_attr "mode" "TI")])
11674
11675 (define_insn "aesdec"
11676   [(set (match_operand:V2DI 0 "register_operand" "=x")
11677         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11678                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11679                       UNSPEC_AESDEC))]
11680   "TARGET_AES"
11681   "aesdec\t{%2, %0|%0, %2}"
11682   [(set_attr "type" "sselog1")
11683    (set_attr "prefix_extra" "1")
11684    (set_attr "mode" "TI")])
11685
11686 (define_insn "*avx_aesdeclast"
11687   [(set (match_operand:V2DI 0 "register_operand" "=x")
11688         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11689                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11690                       UNSPEC_AESDECLAST))]
11691   "TARGET_AES && TARGET_AVX"
11692   "vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
11693   [(set_attr "type" "sselog1")
11694    (set_attr "prefix_extra" "1")
11695    (set_attr "prefix" "vex")
11696    (set_attr "mode" "TI")])
11697
11698 (define_insn "aesdeclast"
11699   [(set (match_operand:V2DI 0 "register_operand" "=x")
11700         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11701                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11702                       UNSPEC_AESDECLAST))]
11703   "TARGET_AES"
11704   "aesdeclast\t{%2, %0|%0, %2}"
11705   [(set_attr "type" "sselog1")
11706    (set_attr "prefix_extra" "1")
11707    (set_attr "mode" "TI")])
11708
11709 (define_insn "aesimc"
11710   [(set (match_operand:V2DI 0 "register_operand" "=x")
11711         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11712                       UNSPEC_AESIMC))]
11713   "TARGET_AES"
11714   "%vaesimc\t{%1, %0|%0, %1}"
11715   [(set_attr "type" "sselog1")
11716    (set_attr "prefix_extra" "1")
11717    (set_attr "prefix" "maybe_vex")
11718    (set_attr "mode" "TI")])
11719
11720 (define_insn "aeskeygenassist"
11721   [(set (match_operand:V2DI 0 "register_operand" "=x")
11722         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
11723                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
11724                      UNSPEC_AESKEYGENASSIST))]
11725   "TARGET_AES"
11726   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
11727   [(set_attr "type" "sselog1")
11728    (set_attr "prefix_extra" "1")
11729    (set_attr "length_immediate" "1")
11730    (set_attr "prefix" "maybe_vex")
11731    (set_attr "mode" "TI")])
11732
11733 (define_insn "*vpclmulqdq"
11734   [(set (match_operand:V2DI 0 "register_operand" "=x")
11735         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11736                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11737                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11738                      UNSPEC_PCLMUL))]
11739   "TARGET_PCLMUL && TARGET_AVX"
11740   "vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11741   [(set_attr "type" "sselog1")
11742    (set_attr "prefix_extra" "1")
11743    (set_attr "length_immediate" "1")
11744    (set_attr "prefix" "vex")
11745    (set_attr "mode" "TI")])
11746
11747 (define_insn "pclmulqdq"
11748   [(set (match_operand:V2DI 0 "register_operand" "=x")
11749         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11750                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11751                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11752                      UNSPEC_PCLMUL))]
11753   "TARGET_PCLMUL"
11754   "pclmulqdq\t{%3, %2, %0|%0, %2, %3}"
11755   [(set_attr "type" "sselog1")
11756    (set_attr "prefix_extra" "1")
11757    (set_attr "length_immediate" "1")
11758    (set_attr "mode" "TI")])
11759
11760 (define_expand "avx_vzeroall"
11761   [(match_par_dup 0 [(const_int 0)])]
11762   "TARGET_AVX"
11763 {
11764   int nregs = TARGET_64BIT ? 16 : 8;
11765   int regno;
11766
11767   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11768
11769   XVECEXP (operands[0], 0, 0)
11770     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11771                                UNSPECV_VZEROALL);
11772
11773   for (regno = 0; regno < nregs; regno++)
11774     XVECEXP (operands[0], 0, regno + 1)
11775       = gen_rtx_SET (VOIDmode,
11776                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
11777                      CONST0_RTX (V8SImode));
11778 })
11779
11780 (define_insn "*avx_vzeroall"
11781   [(match_parallel 0 "vzeroall_operation"
11782     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
11783   "TARGET_AVX"
11784   "vzeroall"
11785   [(set_attr "type" "sse")
11786    (set_attr "modrm" "0")
11787    (set_attr "memory" "none")
11788    (set_attr "prefix" "vex")
11789    (set_attr "mode" "OI")])
11790
11791 ;; vzeroupper clobbers the upper 128bits of AVX registers.
11792 (define_expand "avx_vzeroupper"
11793   [(match_par_dup 0 [(const_int 0)])]
11794   "TARGET_AVX"
11795 {
11796   int nregs = TARGET_64BIT ? 16 : 8;
11797   int regno;
11798
11799   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11800
11801   XVECEXP (operands[0], 0, 0)
11802     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11803                                UNSPECV_VZEROUPPER);
11804
11805   for (regno = 0; regno < nregs; regno++)
11806     XVECEXP (operands[0], 0, regno + 1)
11807       = gen_rtx_CLOBBER (VOIDmode,
11808                          gen_rtx_REG (V8SImode, SSE_REGNO (regno)));
11809 })
11810
11811 (define_insn "*avx_vzeroupper"
11812   [(match_parallel 0 "vzeroupper_operation"
11813     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)])]
11814   "TARGET_AVX"
11815   "vzeroupper"
11816   [(set_attr "type" "sse")
11817    (set_attr "modrm" "0")
11818    (set_attr "memory" "none")
11819    (set_attr "prefix" "vex")
11820    (set_attr "mode" "OI")])
11821
11822 (define_insn_and_split "vec_dup<mode>"
11823   [(set (match_operand:AVX256MODE24P 0 "register_operand" "=x,x")
11824         (vec_duplicate:AVX256MODE24P
11825           (match_operand:<avxscalarmode> 1 "nonimmediate_operand" "m,?x")))]
11826   "TARGET_AVX"
11827   "@
11828    vbroadcast<ssescalarmodesuffix>\t{%1, %0|%0, %1}
11829    #"
11830   "&& reload_completed && REG_P (operands[1])"
11831   [(set (match_dup 2) (vec_duplicate:<avxhalfvecmode> (match_dup 1)))
11832    (set (match_dup 0) (vec_concat:AVX256MODE24P (match_dup 2) (match_dup 2)))]
11833 {
11834   operands[2] = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (operands[0]));
11835 }
11836   [(set_attr "type" "ssemov")
11837    (set_attr "prefix_extra" "1")
11838    (set_attr "prefix" "vex")
11839    (set_attr "mode" "V8SF")])
11840
11841 (define_insn "avx_vbroadcastf128_<mode>"
11842   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x,x")
11843         (vec_concat:AVX256MODE
11844           (match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
11845           (match_dup 1)))]
11846   "TARGET_AVX"
11847   "@
11848    vbroadcastf128\t{%1, %0|%0, %1}
11849    vinsertf128\t{$1, %1, %0, %0|%0, %0, %1, 1}
11850    vperm2f128\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
11851   [(set_attr "type" "ssemov,sselog1,sselog1")
11852    (set_attr "prefix_extra" "1")
11853    (set_attr "length_immediate" "0,1,1")
11854    (set_attr "prefix" "vex")
11855    (set_attr "mode" "V4SF,V8SF,V8SF")])
11856
11857 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
11858 ;; If it so happens that the input is in memory, use vbroadcast.
11859 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
11860 (define_insn "*avx_vperm_broadcast_v4sf"
11861   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
11862         (vec_select:V4SF
11863           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
11864           (match_parallel 2 "avx_vbroadcast_operand"
11865             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11866   "TARGET_AVX"
11867 {
11868   int elt = INTVAL (operands[3]);
11869   switch (which_alternative)
11870     {
11871     case 0:
11872     case 1:
11873       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
11874       return "vbroadcastss\t{%1, %0|%0, %1}";
11875     case 2:
11876       operands[2] = GEN_INT (elt * 0x55);
11877       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
11878     default:
11879       gcc_unreachable ();
11880     }
11881 }
11882   [(set_attr "type" "ssemov,ssemov,sselog1")
11883    (set_attr "prefix_extra" "1")
11884    (set_attr "length_immediate" "0,0,1")
11885    (set_attr "prefix" "vex")
11886    (set_attr "mode" "SF,SF,V4SF")])
11887
11888 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
11889   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x,x,x")
11890         (vec_select:AVX256MODEF2P
11891           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "m,o,?x")
11892           (match_parallel 2 "avx_vbroadcast_operand"
11893             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11894   "TARGET_AVX"
11895   "#"
11896   "&& reload_completed"
11897   [(set (match_dup 0) (vec_duplicate:AVX256MODEF2P (match_dup 1)))]
11898 {
11899   rtx op0 = operands[0], op1 = operands[1];
11900   int elt = INTVAL (operands[3]);
11901
11902   if (REG_P (op1))
11903     {
11904       int mask;
11905
11906       /* Shuffle element we care about into all elements of the 128-bit lane.
11907          The other lane gets shuffled too, but we don't care.  */
11908       if (<MODE>mode == V4DFmode)
11909         mask = (elt & 1 ? 15 : 0);
11910       else
11911         mask = (elt & 3) * 0x55;
11912       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
11913
11914       /* Shuffle the lane we care about into both lanes of the dest.  */
11915       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
11916       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
11917       DONE;
11918     }
11919
11920   operands[1] = adjust_address_nv (op1, <avxscalarmode>mode,
11921                                    elt * GET_MODE_SIZE (<avxscalarmode>mode));
11922 })
11923
11924 (define_expand "avx_vpermil<mode>"
11925   [(set (match_operand:AVXMODEFDP 0 "register_operand" "")
11926         (vec_select:AVXMODEFDP
11927           (match_operand:AVXMODEFDP 1 "nonimmediate_operand" "")
11928           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11929   "TARGET_AVX"
11930 {
11931   int mask = INTVAL (operands[2]);
11932   rtx perm[<ssescalarnum>];
11933
11934   perm[0] = GEN_INT (mask & 1);
11935   perm[1] = GEN_INT ((mask >> 1) & 1);
11936   if (<MODE>mode == V4DFmode)
11937     {
11938       perm[2] = GEN_INT (((mask >> 2) & 1) + 2);
11939       perm[3] = GEN_INT (((mask >> 3) & 1) + 2);
11940     }
11941
11942   operands[2]
11943     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11944 })
11945
11946 (define_expand "avx_vpermil<mode>"
11947   [(set (match_operand:AVXMODEFSP 0 "register_operand" "")
11948         (vec_select:AVXMODEFSP
11949           (match_operand:AVXMODEFSP 1 "nonimmediate_operand" "")
11950           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11951   "TARGET_AVX"
11952 {
11953   int mask = INTVAL (operands[2]);
11954   rtx perm[<ssescalarnum>];
11955
11956   perm[0] = GEN_INT (mask & 3);
11957   perm[1] = GEN_INT ((mask >> 2) & 3);
11958   perm[2] = GEN_INT ((mask >> 4) & 3);
11959   perm[3] = GEN_INT ((mask >> 6) & 3);
11960   if (<MODE>mode == V8SFmode)
11961     {
11962       perm[4] = GEN_INT ((mask & 3) + 4);
11963       perm[5] = GEN_INT (((mask >> 2) & 3) + 4);
11964       perm[6] = GEN_INT (((mask >> 4) & 3) + 4);
11965       perm[7] = GEN_INT (((mask >> 6) & 3) + 4);
11966     }
11967
11968   operands[2]
11969     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11970 })
11971
11972 (define_insn "*avx_vpermilp<mode>"
11973   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11974         (vec_select:AVXMODEF2P
11975           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")
11976           (match_parallel 2 "avx_vpermilp_<mode>_operand"
11977             [(match_operand 3 "const_int_operand" "")])))]
11978   "TARGET_AVX"
11979 {
11980   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
11981   operands[2] = GEN_INT (mask);
11982   return "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
11983 }
11984   [(set_attr "type" "sselog")
11985    (set_attr "prefix_extra" "1")
11986    (set_attr "length_immediate" "1")
11987    (set_attr "prefix" "vex")
11988    (set_attr "mode" "<MODE>")])
11989
11990 (define_insn "avx_vpermilvar<mode>3"
11991   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11992         (unspec:AVXMODEF2P
11993           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11994            (match_operand:<avxpermvecmode> 2 "nonimmediate_operand" "xm")]
11995           UNSPEC_VPERMIL))]
11996   "TARGET_AVX"
11997   "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11998   [(set_attr "type" "sselog")
11999    (set_attr "prefix_extra" "1")
12000    (set_attr "prefix" "vex")
12001    (set_attr "mode" "<MODE>")])
12002
12003 (define_expand "avx_vperm2f128<mode>3"
12004   [(set (match_operand:AVX256MODE2P 0 "register_operand" "")
12005         (unspec:AVX256MODE2P
12006           [(match_operand:AVX256MODE2P 1 "register_operand" "")
12007            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "")
12008            (match_operand:SI 3 "const_0_to_255_operand" "")]
12009           UNSPEC_VPERMIL2F128))]
12010   "TARGET_AVX"
12011 {
12012   int mask = INTVAL (operands[3]);
12013   if ((mask & 0x88) == 0)
12014     {
12015       rtx perm[<ssescalarnum>], t1, t2;
12016       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
12017
12018       base = (mask & 3) * nelt2;
12019       for (i = 0; i < nelt2; ++i)
12020         perm[i] = GEN_INT (base + i);
12021
12022       base = ((mask >> 4) & 3) * nelt2;
12023       for (i = 0; i < nelt2; ++i)
12024         perm[i + nelt2] = GEN_INT (base + i);
12025
12026       t2 = gen_rtx_VEC_CONCAT (<ssedoublesizemode>mode,
12027                                operands[1], operands[2]);
12028       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
12029       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
12030       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
12031       emit_insn (t2);
12032       DONE;
12033     }
12034 })
12035
12036 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
12037 ;; means that in order to represent this properly in rtl we'd have to
12038 ;; nest *another* vec_concat with a zero operand and do the select from
12039 ;; a 4x wide vector.  That doesn't seem very nice.
12040 (define_insn "*avx_vperm2f128<mode>_full"
12041   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
12042         (unspec:AVX256MODE2P
12043           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
12044            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
12045            (match_operand:SI 3 "const_0_to_255_operand" "n")]
12046           UNSPEC_VPERMIL2F128))]
12047   "TARGET_AVX"
12048   "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12049   [(set_attr "type" "sselog")
12050    (set_attr "prefix_extra" "1")
12051    (set_attr "length_immediate" "1")
12052    (set_attr "prefix" "vex")
12053    (set_attr "mode" "V8SF")])
12054
12055 (define_insn "*avx_vperm2f128<mode>_nozero"
12056   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
12057         (vec_select:AVX256MODE2P
12058           (vec_concat:<ssedoublesizemode>
12059             (match_operand:AVX256MODE2P 1 "register_operand" "x")
12060             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
12061           (match_parallel 3 "avx_vperm2f128_<mode>_operand"
12062             [(match_operand 4 "const_int_operand" "")])))]
12063   "TARGET_AVX"
12064 {
12065   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
12066   operands[3] = GEN_INT (mask);
12067   return "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}";
12068 }
12069   [(set_attr "type" "sselog")
12070    (set_attr "prefix_extra" "1")
12071    (set_attr "length_immediate" "1")
12072    (set_attr "prefix" "vex")
12073    (set_attr "mode" "V8SF")])
12074
12075 (define_expand "avx_vinsertf128<mode>"
12076   [(match_operand:AVX256MODE 0 "register_operand" "")
12077    (match_operand:AVX256MODE 1 "register_operand" "")
12078    (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "")
12079    (match_operand:SI 3 "const_0_to_1_operand" "")]
12080   "TARGET_AVX"
12081 {
12082   switch (INTVAL (operands[3]))
12083     {
12084     case 0:
12085       emit_insn (gen_vec_set_lo_<mode> (operands[0], operands[1],
12086                                         operands[2]));
12087       break;
12088     case 1:
12089       emit_insn (gen_vec_set_hi_<mode> (operands[0], operands[1],
12090                                         operands[2]));
12091       break;
12092     default:
12093       gcc_unreachable ();
12094     }
12095   DONE;
12096 })
12097
12098 (define_insn "vec_set_lo_<mode>"
12099   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12100         (vec_concat:AVX256MODE4P
12101           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12102           (vec_select:<avxhalfvecmode>
12103             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12104             (parallel [(const_int 2) (const_int 3)]))))]
12105   "TARGET_AVX"
12106   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12107   [(set_attr "type" "sselog")
12108    (set_attr "prefix_extra" "1")
12109    (set_attr "length_immediate" "1")
12110    (set_attr "prefix" "vex")
12111    (set_attr "mode" "V8SF")])
12112
12113 (define_insn "vec_set_hi_<mode>"
12114   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12115         (vec_concat:AVX256MODE4P
12116           (vec_select:<avxhalfvecmode>
12117             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12118             (parallel [(const_int 0) (const_int 1)]))
12119           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12120   "TARGET_AVX"
12121   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12122   [(set_attr "type" "sselog")
12123    (set_attr "prefix_extra" "1")
12124    (set_attr "length_immediate" "1")
12125    (set_attr "prefix" "vex")
12126    (set_attr "mode" "V8SF")])
12127
12128 (define_insn "vec_set_lo_<mode>"
12129   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12130         (vec_concat:AVX256MODE8P
12131           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12132           (vec_select:<avxhalfvecmode>
12133             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12134             (parallel [(const_int 4) (const_int 5)
12135                        (const_int 6) (const_int 7)]))))]
12136   "TARGET_AVX"
12137   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12138   [(set_attr "type" "sselog")
12139    (set_attr "prefix_extra" "1")
12140    (set_attr "length_immediate" "1")
12141    (set_attr "prefix" "vex")
12142    (set_attr "mode" "V8SF")])
12143
12144 (define_insn "vec_set_hi_<mode>"
12145   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12146         (vec_concat:AVX256MODE8P
12147           (vec_select:<avxhalfvecmode>
12148             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12149             (parallel [(const_int 0) (const_int 1)
12150                        (const_int 2) (const_int 3)]))
12151           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12152   "TARGET_AVX"
12153   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12154   [(set_attr "type" "sselog")
12155    (set_attr "prefix_extra" "1")
12156    (set_attr "length_immediate" "1")
12157    (set_attr "prefix" "vex")
12158    (set_attr "mode" "V8SF")])
12159
12160 (define_insn "vec_set_lo_v16hi"
12161   [(set (match_operand:V16HI 0 "register_operand" "=x")
12162         (vec_concat:V16HI
12163           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
12164           (vec_select:V8HI
12165             (match_operand:V16HI 1 "register_operand" "x")
12166             (parallel [(const_int 8) (const_int 9)
12167                        (const_int 10) (const_int 11)
12168                        (const_int 12) (const_int 13)
12169                        (const_int 14) (const_int 15)]))))]
12170   "TARGET_AVX"
12171   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12172   [(set_attr "type" "sselog")
12173    (set_attr "prefix_extra" "1")
12174    (set_attr "length_immediate" "1")
12175    (set_attr "prefix" "vex")
12176    (set_attr "mode" "V8SF")])
12177
12178 (define_insn "vec_set_hi_v16hi"
12179   [(set (match_operand:V16HI 0 "register_operand" "=x")
12180         (vec_concat:V16HI
12181           (vec_select:V8HI
12182             (match_operand:V16HI 1 "register_operand" "x")
12183             (parallel [(const_int 0) (const_int 1)
12184                        (const_int 2) (const_int 3)
12185                        (const_int 4) (const_int 5)
12186                        (const_int 6) (const_int 7)]))
12187           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
12188   "TARGET_AVX"
12189   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12190   [(set_attr "type" "sselog")
12191    (set_attr "prefix_extra" "1")
12192    (set_attr "length_immediate" "1")
12193    (set_attr "prefix" "vex")
12194    (set_attr "mode" "V8SF")])
12195
12196 (define_insn "vec_set_lo_v32qi"
12197   [(set (match_operand:V32QI 0 "register_operand" "=x")
12198         (vec_concat:V32QI
12199           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
12200           (vec_select:V16QI
12201             (match_operand:V32QI 1 "register_operand" "x")
12202             (parallel [(const_int 16) (const_int 17)
12203                        (const_int 18) (const_int 19)
12204                        (const_int 20) (const_int 21)
12205                        (const_int 22) (const_int 23)
12206                        (const_int 24) (const_int 25)
12207                        (const_int 26) (const_int 27)
12208                        (const_int 28) (const_int 29)
12209                        (const_int 30) (const_int 31)]))))]
12210   "TARGET_AVX"
12211   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12212   [(set_attr "type" "sselog")
12213    (set_attr "prefix_extra" "1")
12214    (set_attr "length_immediate" "1")
12215    (set_attr "prefix" "vex")
12216    (set_attr "mode" "V8SF")])
12217
12218 (define_insn "vec_set_hi_v32qi"
12219   [(set (match_operand:V32QI 0 "register_operand" "=x")
12220         (vec_concat:V32QI
12221           (vec_select:V16QI
12222             (match_operand:V32QI 1 "register_operand" "x")
12223             (parallel [(const_int 0) (const_int 1)
12224                        (const_int 2) (const_int 3)
12225                        (const_int 4) (const_int 5)
12226                        (const_int 6) (const_int 7)
12227                        (const_int 8) (const_int 9)
12228                        (const_int 10) (const_int 11)
12229                        (const_int 12) (const_int 13)
12230                        (const_int 14) (const_int 15)]))
12231           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
12232   "TARGET_AVX"
12233   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12234   [(set_attr "type" "sselog")
12235    (set_attr "prefix_extra" "1")
12236    (set_attr "length_immediate" "1")
12237    (set_attr "prefix" "vex")
12238    (set_attr "mode" "V8SF")])
12239
12240 (define_insn "avx_maskload<ssemodesuffix><avxmodesuffix>"
12241   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
12242         (unspec:AVXMODEF2P
12243           [(match_operand:AVXMODEF2P 1 "memory_operand" "m")
12244            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12245            (match_dup 0)]
12246           UNSPEC_MASKLOAD))]
12247   "TARGET_AVX"
12248   "vmaskmov<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
12249   [(set_attr "type" "sselog1")
12250    (set_attr "prefix_extra" "1")
12251    (set_attr "prefix" "vex")
12252    (set_attr "mode" "<MODE>")])
12253
12254 (define_insn "avx_maskstore<ssemodesuffix><avxmodesuffix>"
12255   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
12256         (unspec:AVXMODEF2P
12257           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
12258            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12259            (match_dup 0)]
12260           UNSPEC_MASKSTORE))]
12261   "TARGET_AVX"
12262   "vmaskmov<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
12263   [(set_attr "type" "sselog1")
12264    (set_attr "prefix_extra" "1")
12265    (set_attr "prefix" "vex")
12266    (set_attr "mode" "<MODE>")])
12267
12268 (define_insn_and_split "avx_<avxmodesuffixp><avxmodesuffix>_<avxmodesuffixp>"
12269   [(set (match_operand:AVX256MODE2P 0 "nonimmediate_operand" "=x,m")
12270         (unspec:AVX256MODE2P
12271           [(match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "xm,x")]
12272           UNSPEC_CAST))]
12273   "TARGET_AVX"
12274   "#"
12275   "&& reload_completed"
12276   [(const_int 0)]
12277 {
12278   rtx op1 = operands[1];
12279   if (REG_P (op1))
12280     op1 = gen_rtx_REG (<MODE>mode, REGNO (op1));
12281   else
12282     op1 = gen_lowpart (<MODE>mode, op1);
12283   emit_move_insn (operands[0], op1);
12284   DONE;
12285 })
12286
12287 (define_expand "vec_init<mode>"
12288   [(match_operand:AVX256MODE 0 "register_operand" "")
12289    (match_operand 1 "" "")]
12290   "TARGET_AVX"
12291 {
12292   ix86_expand_vector_init (false, operands[0], operands[1]);
12293   DONE;
12294 })
12295
12296 (define_insn "*vec_concat<mode>_avx"
12297   [(set (match_operand:AVX256MODE 0 "register_operand"   "=x,x")
12298         (vec_concat:AVX256MODE
12299           (match_operand:<avxhalfvecmode> 1 "register_operand" "x,x")
12300           (match_operand:<avxhalfvecmode> 2 "vector_move_operand" "xm,C")))]
12301   "TARGET_AVX"
12302 {
12303   switch (which_alternative)
12304     {
12305     case 0:
12306       return "vinsertf128\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
12307     case 1:
12308       switch (get_attr_mode (insn))
12309         {
12310         case MODE_V8SF:
12311           return "vmovaps\t{%1, %x0|%x0, %1}";
12312         case MODE_V4DF:
12313           return "vmovapd\t{%1, %x0|%x0, %1}";
12314         default:
12315           return "vmovdqa\t{%1, %x0|%x0, %1}";
12316         }
12317     default:
12318       gcc_unreachable ();
12319     }
12320 }
12321   [(set_attr "type" "sselog,ssemov")
12322    (set_attr "prefix_extra" "1,*")
12323    (set_attr "length_immediate" "1,*")
12324    (set_attr "prefix" "vex")
12325    (set_attr "mode" "<avxvecmode>")])
12326
12327 (define_insn "vcvtph2ps"
12328   [(set (match_operand:V4SF 0 "register_operand" "=x")
12329         (vec_select:V4SF
12330           (unspec:V8SF [(match_operand:V8HI 1 "register_operand" "x")]
12331                        UNSPEC_VCVTPH2PS)
12332           (parallel [(const_int 0) (const_int 1)
12333                      (const_int 1) (const_int 2)])))]
12334   "TARGET_F16C"
12335   "vcvtph2ps\t{%1, %0|%0, %1}"
12336   [(set_attr "type" "ssecvt")
12337    (set_attr "prefix" "vex")
12338    (set_attr "mode" "V4SF")])
12339
12340 (define_insn "*vcvtph2ps_load"
12341   [(set (match_operand:V4SF 0 "register_operand" "=x")
12342         (unspec:V4SF [(match_operand:V4HI 1 "memory_operand" "m")]
12343                      UNSPEC_VCVTPH2PS))]
12344   "TARGET_F16C"
12345   "vcvtph2ps\t{%1, %0|%0, %1}"
12346   [(set_attr "type" "ssecvt")
12347    (set_attr "prefix" "vex")
12348    (set_attr "mode" "V8SF")])
12349
12350 (define_insn "vcvtph2ps256"
12351   [(set (match_operand:V8SF 0 "register_operand" "=x")
12352         (unspec:V8SF [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
12353                      UNSPEC_VCVTPH2PS))]
12354   "TARGET_F16C"
12355   "vcvtph2ps\t{%1, %0|%0, %1}"
12356   [(set_attr "type" "ssecvt")
12357    (set_attr "prefix" "vex")
12358    (set_attr "mode" "V8SF")])
12359
12360 (define_expand "vcvtps2ph"
12361   [(set (match_operand:V8HI 0 "register_operand" "")
12362         (vec_concat:V8HI
12363           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "")
12364                         (match_operand:SI 2 "immediate_operand" "")]
12365                        UNSPEC_VCVTPS2PH)
12366           (match_dup 3)))]
12367   "TARGET_F16C"
12368   "operands[3] = CONST0_RTX (V4HImode);")
12369
12370 (define_insn "*vcvtps2ph"
12371   [(set (match_operand:V8HI 0 "register_operand" "=x")
12372         (vec_concat:V8HI
12373           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
12374                         (match_operand:SI 2 "immediate_operand" "N")]
12375                        UNSPEC_VCVTPS2PH)
12376           (match_operand:V4HI 3 "const0_operand" "")))]
12377   "TARGET_F16C"
12378   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12379   [(set_attr "type" "ssecvt")
12380    (set_attr "prefix" "vex")
12381    (set_attr "mode" "V4SF")])
12382
12383 (define_insn "*vcvtps2ph_store"
12384   [(set (match_operand:V4HI 0 "memory_operand" "=m")
12385         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
12386                       (match_operand:SI 2 "immediate_operand" "N")]
12387                      UNSPEC_VCVTPS2PH))]
12388   "TARGET_F16C"
12389   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12390   [(set_attr "type" "ssecvt")
12391    (set_attr "prefix" "vex")
12392    (set_attr "mode" "V4SF")])
12393
12394 (define_insn "vcvtps2ph256"
12395   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=xm")
12396         (unspec:V8HI [(match_operand:V8SF 1 "register_operand" "x")
12397                       (match_operand:SI 2 "immediate_operand" "N")]
12398                      UNSPEC_VCVTPS2PH))]
12399   "TARGET_F16C"
12400   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12401   [(set_attr "type" "ssecvt")
12402    (set_attr "prefix" "vex")
12403    (set_attr "mode" "V8SF")])