gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   7 ;; GCC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 3, or (at your option)
  10 ;; any later version.
  11 ;;
  12 ;; GCC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16 ;;
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21
  22 ;; 16 byte integral modes handled by SSE, minus TImode, which gets
  23 ;; special-cased for TARGET_64BIT.
  24 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  25
  26 ;; All 16-byte vector modes handled by SSE
  27 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI V4SF V2DF])
  28
  29 ;; 32 byte integral vector modes handled by AVX
  30 (define_mode_iterator AVX256MODEI [V32QI V16HI V8SI V4DI])
  31
  32 ;; All 32-byte vector modes handled by AVX
  33 (define_mode_iterator AVX256MODE [V32QI V16HI V8SI V4DI V8SF V4DF])
  34
  35 ;; All QI vector modes handled by AVX
  36 (define_mode_iterator AVXMODEQI [V32QI V16QI])
  37
  38 ;; All DI vector modes handled by AVX
  39 (define_mode_iterator AVXMODEDI [V4DI V2DI])
  40
  41 ;; All vector modes handled by AVX
  42 (define_mode_iterator AVXMODE [V16QI V8HI V4SI V2DI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  43
  44 ;; Mix-n-match
  45 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  46 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  47 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  48 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  49 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  50 (define_mode_iterator SSEMODE1248 [V16QI V8HI V4SI V2DI])
  51 (define_mode_iterator SSEMODEF4 [SF DF V4SF V2DF])
  52 (define_mode_iterator SSEMODEF2P [V4SF V2DF])
  53
  54 (define_mode_iterator AVX256MODEF2P [V8SF V4DF])
  55 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
  56 (define_mode_iterator AVX256MODE4P [V4DI V4DF])
  57 (define_mode_iterator AVX256MODE8P [V8SI V8SF])
  58 (define_mode_iterator AVXMODEF2P [V4SF V2DF V8SF V4DF])
  59 (define_mode_iterator AVXMODEF4P [V4SF V4DF])
  60 (define_mode_iterator AVXMODEDCVTDQ2PS [V4SF V8SF])
  61 (define_mode_iterator AVXMODEDCVTPS2DQ [V4SI V8SI])
  62
  63 ;; Int-float size matches
  64 (define_mode_iterator SSEMODE4S [V4SF V4SI])
  65 (define_mode_iterator SSEMODE2D [V2DF V2DI])
  66
  67 ;; Mapping from float mode to required SSE level
  68 (define_mode_attr sse [(SF "sse") (DF "sse2") (V4SF "sse") (V2DF "sse2")])
  69
  70 ;; Mapping from integer vector mode to mnemonic suffix
  71 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
  72
  73 ;; Mapping of the sse5 suffix
  74 (define_mode_attr ssemodesuffixf4 [(SF "ss") (DF "sd")
  75                                    (V4SF "ps") (V2DF "pd")])
  76 (define_mode_attr ssemodesuffixf2s [(SF "ss") (DF "sd")
  77                                     (V4SF "ss") (V2DF "sd")])
  78 (define_mode_attr ssemodesuffixf2c [(V4SF "s") (V2DF "d")])
  79
  80 ;; Mapping of the max integer size for sse5 rotate immediate constraint
  81 (define_mode_attr sserotatemax [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
  82
  83 ;; Mapping of vector modes back to the scalar modes
  84 (define_mode_attr ssescalarmode [(V4SF "SF") (V2DF "DF")
  85                                  (V16QI "QI") (V8HI "HI")
  86                                  (V4SI "SI") (V2DI "DI")])
  87
  88 ;; Mapping of vector modes to a vector mode of double size
  89 (define_mode_attr ssedoublesizemode [(V2DF "V4DF") (V2DI "V4DI")
  90                                      (V4SF "V8SF") (V4SI "V8SI")])
  91
  92 ;; Number of scalar elements in each vector type
  93 (define_mode_attr ssescalarnum [(V4SF "4") (V2DF "2")
  94                                 (V16QI "16") (V8HI "8")
  95                                 (V4SI "4") (V2DI "2")])
  96
  97 ;; Mapping for AVX
  98 (define_mode_attr avxvecmode
  99   [(V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V4SF "V4SF")
 100    (V2DF "V2DF") (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI")
 101    (V8SF "V8SF") (V4DF "V4DF")])
 102 (define_mode_attr avxvecpsmode
 103   [(V16QI "V4SF") (V8HI "V4SF") (V4SI "V4SF") (V2DI "V4SF")
 104    (V32QI "V8SF") (V16HI "V8SF") (V8SI "V8SF") (V4DI "V8SF")])
 105 (define_mode_attr avxhalfvecmode
 106   [(V4SF "V2SF") (V32QI "V16QI")  (V16HI "V8HI") (V8SI "V4SI")
 107    (V4DI "V2DI") (V8SF "V4SF") (V4DF "V2DF")])
 108 (define_mode_attr avxscalarmode
 109   [(V16QI "QI") (V8HI "HI") (V4SI "SI") (V4SF "SF") (V2DF "DF")
 110    (V8SF "SF") (V4DF "DF")])
 111 (define_mode_attr avxcvtvecmode
 112   [(V4SF "V4SI") (V8SF "V8SI") (V4SI "V4SF") (V8SI "V8SF")])
 113 (define_mode_attr avxpermvecmode
 114   [(V2DF "V2DI") (V4SF "V4SI") (V4DF "V4DI") (V8SF "V8SI")])
 115 (define_mode_attr avxmodesuffixf2c
 116   [(V4SF "s") (V2DF "d") (V8SF "s") (V4DF "d")])
 117 (define_mode_attr avxmodesuffixp
 118  [(V2DF "pd") (V4SI "si") (V4SF "ps") (V8SF "ps") (V8SI "si")
 119   (V4DF "pd")])
 120 (define_mode_attr avxmodesuffix
 121   [(V16QI "") (V32QI "256") (V4SI "") (V4SF "") (V2DF "")
 122    (V8SI "256") (V8SF "256") (V4DF "256")])
 123
 124 ;; Mapping of immediate bits for blend instructions
 125 (define_mode_attr blendbits
 126   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 127
 128 ;; Mapping of immediate bits for vpermil instructions
 129 (define_mode_attr vpermilbits
 130   [(V8SF "255") (V4SF "255") (V4DF "15") (V2DF "3")])
 131
 132 ;; Mapping of immediate bits for pinsr instructions
 133 (define_mode_attr pinsrbits [(V16QI "32768") (V8HI "128") (V4SI "8")])
 134
 135 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 136
 137 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 138 ;;
 139 ;; Move patterns
 140 ;;
 141 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 142
 143 (define_expand "mov<mode>"
 144   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 145         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 146   "TARGET_AVX"
 147 {
 148   ix86_expand_vector_move (<MODE>mode, operands);
 149   DONE;
 150 })
 151
 152 (define_insn "*avx_mov<mode>_internal"
 153   [(set (match_operand:AVXMODE 0 "nonimmediate_operand" "=x,x ,m")
 154         (match_operand:AVXMODE 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 155   "TARGET_AVX
 156    && (register_operand (operands[0], <MODE>mode)
 157        || register_operand (operands[1], <MODE>mode))"
 158 {
 159   switch (which_alternative)
 160     {
 161     case 0:
 162       return standard_sse_constant_opcode (insn, operands[1]);
 163     case 1:
 164     case 2:
 165       switch (get_attr_mode (insn))
 166         {
 167         case MODE_V8SF:
 168         case MODE_V4SF:
 169           return "vmovaps\t{%1, %0|%0, %1}";
 170         case MODE_V4DF:
 171         case MODE_V2DF:
 172           return "vmovapd\t{%1, %0|%0, %1}";
 173         default:
 174           return "vmovdqa\t{%1, %0|%0, %1}";
 175         }
 176     default:
 177       gcc_unreachable ();
 178     }
 179 }
 180   [(set_attr "type" "sselog1,ssemov,ssemov")
 181    (set_attr "prefix" "vex")
 182    (set_attr "mode" "<avxvecmode>")])
 183
 184 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 185 ;; This is essential for maintaining stable calling conventions.
 186
 187 (define_expand "mov<mode>"
 188   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "")
 189         (match_operand:SSEMODE 1 "nonimmediate_operand" ""))]
 190   "TARGET_SSE"
 191 {
 192   ix86_expand_vector_move (<MODE>mode, operands);
 193   DONE;
 194 })
 195
 196 (define_insn "*mov<mode>_internal"
 197   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "=x,x ,m")
 198         (match_operand:SSEMODE 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 199   "TARGET_SSE
 200    && (register_operand (operands[0], <MODE>mode)
 201        || register_operand (operands[1], <MODE>mode))"
 202 {
 203   switch (which_alternative)
 204     {
 205     case 0:
 206       return standard_sse_constant_opcode (insn, operands[1]);
 207     case 1:
 208     case 2:
 209       switch (get_attr_mode (insn))
 210         {
 211         case MODE_V4SF:
 212           return "movaps\t{%1, %0|%0, %1}";
 213         case MODE_V2DF:
 214           return "movapd\t{%1, %0|%0, %1}";
 215         default:
 216           return "movdqa\t{%1, %0|%0, %1}";
 217         }
 218     default:
 219       gcc_unreachable ();
 220     }
 221 }
 222   [(set_attr "type" "sselog1,ssemov,ssemov")
 223    (set (attr "mode")
 224         (cond [(ior (ior (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
 225                          (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 226                     (and (eq_attr "alternative" "2")
 227                          (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 228                              (const_int 0))))
 229                  (const_string "V4SF")
 230                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
 231                  (const_string "V4SF")
 232                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
 233                  (const_string "V2DF")
 234               ]
 235           (const_string "TI")))])
 236
 237 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 238 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 239 ;; from memory, we'd prefer to load the memory directly into the %xmm
 240 ;; register.  To facilitate this happy circumstance, this pattern won't
 241 ;; split until after register allocation.  If the 64-bit value didn't
 242 ;; come from memory, this is the best we can do.  This is much better
 243 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 244 ;; from there.
 245
 246 (define_insn_and_split "movdi_to_sse"
 247   [(parallel
 248     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 249           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 250      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 251   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 252   "#"
 253   "&& reload_completed"
 254   [(const_int 0)]
 255 {
 256  if (register_operand (operands[1], DImode))
 257    {
 258       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 259          Assemble the 64-bit DImode value in an xmm register.  */
 260       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 261                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 262       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 263                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 264       emit_insn (gen_sse2_punpckldq (operands[0], operands[0], operands[2]));
 265     }
 266  else if (memory_operand (operands[1], DImode))
 267       emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]), operands[1], const0_rtx));
 268  else
 269       gcc_unreachable ();
 270 })
 271
 272 (define_split
 273   [(set (match_operand:V4SF 0 "register_operand" "")
 274         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 275   "TARGET_SSE && reload_completed"
 276   [(set (match_dup 0)
 277         (vec_merge:V4SF
 278           (vec_duplicate:V4SF (match_dup 1))
 279           (match_dup 2)
 280           (const_int 1)))]
 281 {
 282   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 283   operands[2] = CONST0_RTX (V4SFmode);
 284 })
 285
 286 (define_split
 287   [(set (match_operand:V2DF 0 "register_operand" "")
 288         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 289   "TARGET_SSE2 && reload_completed"
 290   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 291 {
 292   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 293   operands[2] = CONST0_RTX (DFmode);
 294 })
 295
 296 (define_expand "push<mode>1"
 297   [(match_operand:AVX256MODE 0 "register_operand" "")]
 298   "TARGET_AVX"
 299 {
 300   ix86_expand_push (<MODE>mode, operands[0]);
 301   DONE;
 302 })
 303
 304 (define_expand "push<mode>1"
 305   [(match_operand:SSEMODE 0 "register_operand" "")]
 306   "TARGET_SSE"
 307 {
 308   ix86_expand_push (<MODE>mode, operands[0]);
 309   DONE;
 310 })
 311
 312 (define_expand "movmisalign<mode>"
 313   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 314         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 315   "TARGET_AVX"
 316 {
 317   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 318   DONE;
 319 })
 320
 321 (define_expand "movmisalign<mode>"
 322   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "")
 323         (match_operand:SSEMODE 1 "nonimmediate_operand" ""))]
 324   "TARGET_SSE"
 325 {
 326   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 327   DONE;
 328 })
 329
 330 (define_insn "avx_movup<avxmodesuffixf2c><avxmodesuffix>"
 331   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "=x,m")
 332         (unspec:AVXMODEF2P
 333           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm,x")]
 334           UNSPEC_MOVU))]
 335   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 336    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 337   "vmovup<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 338   [(set_attr "type" "ssemov")
 339    (set_attr "movu" "1")
 340    (set_attr "prefix" "vex")
 341    (set_attr "mode" "<MODE>")])
 342
 343 (define_insn "sse2_movq128"
 344   [(set (match_operand:V2DI 0 "register_operand" "=x")
 345         (vec_concat:V2DI
 346           (vec_select:DI
 347             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 348             (parallel [(const_int 0)]))
 349           (const_int 0)))]
 350   "TARGET_SSE2"
 351   "%vmovq\t{%1, %0|%0, %1}"
 352   [(set_attr "type" "ssemov")
 353    (set_attr "prefix" "maybe_vex")
 354    (set_attr "mode" "TI")])
 355
 356 (define_insn "<sse>_movup<ssemodesuffixf2c>"
 357   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m")
 358         (unspec:SSEMODEF2P
 359           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm,x")]
 360           UNSPEC_MOVU))]
 361   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 362    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 363   "movup<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 364   [(set_attr "type" "ssemov")
 365    (set_attr "movu" "1")
 366    (set_attr "mode" "<MODE>")])
 367
 368 (define_insn "avx_movdqu<avxmodesuffix>"
 369   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "=x,m")
 370         (unspec:AVXMODEQI
 371           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "xm,x")]
 372           UNSPEC_MOVU))]
 373   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 374   "vmovdqu\t{%1, %0|%0, %1}"
 375   [(set_attr "type" "ssemov")
 376    (set_attr "movu" "1")
 377    (set_attr "prefix" "vex")
 378    (set_attr "mode" "<avxvecmode>")])
 379
 380 (define_insn "sse2_movdqu"
 381   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 382         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 383                       UNSPEC_MOVU))]
 384   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 385   "movdqu\t{%1, %0|%0, %1}"
 386   [(set_attr "type" "ssemov")
 387    (set_attr "movu" "1")
 388    (set_attr "prefix_data16" "1")
 389    (set_attr "mode" "TI")])
 390
 391 (define_insn "avx_movnt<mode>"
 392   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
 393         (unspec:AVXMODEF2P
 394           [(match_operand:AVXMODEF2P 1 "register_operand" "x")]
 395           UNSPEC_MOVNT))]
 396   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 397   "vmovntp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
 398   [(set_attr "type" "ssemov")
 399    (set_attr "prefix" "vex")
 400    (set_attr "mode" "<MODE>")])
 401
 402 (define_insn "<sse>_movnt<mode>"
 403   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "=m")
 404         (unspec:SSEMODEF2P
 405           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
 406           UNSPEC_MOVNT))]
 407   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 408   "movntp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 409   [(set_attr "type" "ssemov")
 410    (set_attr "mode" "<MODE>")])
 411
 412 (define_insn "avx_movnt<mode>"
 413   [(set (match_operand:AVXMODEDI 0 "memory_operand" "=m")
 414         (unspec:AVXMODEDI
 415           [(match_operand:AVXMODEDI 1 "register_operand" "x")]
 416           UNSPEC_MOVNT))]
 417   "TARGET_AVX"
 418   "vmovntdq\t{%1, %0|%0, %1}"
 419   [(set_attr "type" "ssecvt")
 420    (set_attr "prefix" "vex")
 421    (set_attr "mode" "<avxvecmode>")])
 422
 423 (define_insn "sse2_movntv2di"
 424   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 425         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 426                      UNSPEC_MOVNT))]
 427   "TARGET_SSE2"
 428   "movntdq\t{%1, %0|%0, %1}"
 429   [(set_attr "type" "ssemov")
 430    (set_attr "prefix_data16" "1")
 431    (set_attr "mode" "TI")])
 432
 433 (define_insn "sse2_movntsi"
 434   [(set (match_operand:SI 0 "memory_operand" "=m")
 435         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 436                    UNSPEC_MOVNT))]
 437   "TARGET_SSE2"
 438   "movnti\t{%1, %0|%0, %1}"
 439   [(set_attr "type" "ssemov")
 440    (set_attr "prefix_data16" "0")
 441    (set_attr "mode" "V2DF")])
 442
 443 (define_insn "avx_lddqu<avxmodesuffix>"
 444   [(set (match_operand:AVXMODEQI 0 "register_operand" "=x")
 445         (unspec:AVXMODEQI
 446           [(match_operand:AVXMODEQI 1 "memory_operand" "m")]
 447           UNSPEC_LDDQU))]
 448   "TARGET_AVX"
 449   "vlddqu\t{%1, %0|%0, %1}"
 450   [(set_attr "type" "ssecvt")
 451    (set_attr "movu" "1")
 452    (set_attr "prefix" "vex")
 453    (set_attr "mode" "<avxvecmode>")])
 454
 455 (define_insn "sse3_lddqu"
 456   [(set (match_operand:V16QI 0 "register_operand" "=x")
 457         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 458                       UNSPEC_LDDQU))]
 459   "TARGET_SSE3"
 460   "lddqu\t{%1, %0|%0, %1}"
 461   [(set_attr "type" "ssemov")
 462    (set_attr "movu" "1")
 463    (set_attr "prefix_data16" "0")
 464    (set_attr "prefix_rep" "1")
 465    (set_attr "mode" "TI")])
 466
 467 ; Expand patterns for non-temporal stores.  At the moment, only those
 468 ; that directly map to insns are defined; it would be possible to
 469 ; define patterns for other modes that would expand to several insns.
 470
 471 (define_expand "storent<mode>"
 472   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "")
 473         (unspec:SSEMODEF2P
 474           [(match_operand:SSEMODEF2P 1 "register_operand" "")]
 475           UNSPEC_MOVNT))]
 476   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 477   "")
 478
 479 (define_expand "storent<mode>"
 480   [(set (match_operand:MODEF 0 "memory_operand" "")
 481         (unspec:MODEF
 482           [(match_operand:MODEF 1 "register_operand" "")]
 483           UNSPEC_MOVNT))]
 484   "TARGET_SSE4A"
 485   "")
 486
 487 (define_expand "storentv2di"
 488   [(set (match_operand:V2DI 0 "memory_operand" "")
 489         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "")]
 490                      UNSPEC_MOVNT))]
 491   "TARGET_SSE2"
 492   "")
 493
 494 (define_expand "storentsi"
 495   [(set (match_operand:SI 0 "memory_operand" "")
 496         (unspec:SI [(match_operand:SI 1 "register_operand" "")]
 497                    UNSPEC_MOVNT))]
 498   "TARGET_SSE2"
 499   "")
 500
 501 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 502 ;;
 503 ;; Parallel floating point arithmetic
 504 ;;
 505 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 506
 507 (define_expand "<code><mode>2"
 508   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 509         (absneg:SSEMODEF2P
 510           (match_operand:SSEMODEF2P 1 "register_operand" "")))]
 511   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 512   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 513
 514 (define_expand "<plusminus_insn><mode>3"
 515   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 516         (plusminus:AVX256MODEF2P
 517           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 518           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 519   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 520   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 521
 522 (define_insn "*avx_<plusminus_insn><mode>3"
 523   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 524         (plusminus:AVXMODEF2P
 525           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "<comm>x")
 526           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 527   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 528    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 529   "v<plusminus_mnemonic>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 530   [(set_attr "type" "sseadd")
 531    (set_attr "prefix" "vex")
 532    (set_attr "mode" "<avxvecmode>")])
 533
 534 (define_expand "<plusminus_insn><mode>3"
 535   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 536         (plusminus:SSEMODEF2P
 537           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 538           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 539   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 540   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 541
 542 (define_insn "*<plusminus_insn><mode>3"
 543   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 544         (plusminus:SSEMODEF2P
 545           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "<comm>0")
 546           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 547   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 548    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 549   "<plusminus_mnemonic>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 550   [(set_attr "type" "sseadd")
 551    (set_attr "mode" "<MODE>")])
 552
 553 (define_insn "*avx_vm<plusminus_insn><mode>3"
 554   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 555         (vec_merge:SSEMODEF2P
 556           (plusminus:SSEMODEF2P
 557             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 558             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 559           (match_dup 1)
 560           (const_int 1)))]
 561   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 562   "v<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 563   [(set_attr "type" "sseadd")
 564    (set_attr "prefix" "vex")
 565    (set_attr "mode" "<ssescalarmode>")])
 566
 567 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 568   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 569         (vec_merge:SSEMODEF2P
 570           (plusminus:SSEMODEF2P
 571             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 572             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 573           (match_dup 1)
 574           (const_int 1)))]
 575   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 576   "<plusminus_mnemonic>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 577   [(set_attr "type" "sseadd")
 578    (set_attr "mode" "<ssescalarmode>")])
 579
 580 (define_expand "mul<mode>3"
 581   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 582         (mult:AVX256MODEF2P
 583           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 584           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 585   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 586   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 587
 588 (define_insn "*avx_mul<mode>3"
 589   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 590         (mult:AVXMODEF2P
 591           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 592           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 593   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 594    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 595   "vmulp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 596   [(set_attr "type" "ssemul")
 597    (set_attr "prefix" "vex")
 598    (set_attr "mode" "<avxvecmode>")])
 599
 600 (define_expand "mul<mode>3"
 601   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 602         (mult:SSEMODEF2P
 603           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 604           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 605   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 606   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 607
 608 (define_insn "*mul<mode>3"
 609   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 610         (mult:SSEMODEF2P
 611           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 612           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 613   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 614    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 615   "mulp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 616   [(set_attr "type" "ssemul")
 617    (set_attr "mode" "<MODE>")])
 618
 619 (define_insn "*avx_vmmul<mode>3"
 620   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 621         (vec_merge:SSEMODEF2P
 622           (mult:SSEMODEF2P
 623             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 624             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 625           (match_dup 1)
 626           (const_int 1)))]
 627   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 628   "vmuls<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 629   [(set_attr "type" "ssemul")
 630    (set_attr "prefix" "vex")
 631    (set_attr "mode" "<ssescalarmode>")])
 632
 633 (define_insn "<sse>_vmmul<mode>3"
 634   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 635         (vec_merge:SSEMODEF2P
 636           (mult:SSEMODEF2P
 637             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 638             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 639           (match_dup 1)
 640           (const_int 1)))]
 641   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 642   "muls<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 643   [(set_attr "type" "ssemul")
 644    (set_attr "mode" "<ssescalarmode>")])
 645
 646 (define_expand "divv8sf3"
 647   [(set (match_operand:V8SF 0 "register_operand" "")
 648         (div:V8SF (match_operand:V8SF 1 "register_operand" "")
 649                   (match_operand:V8SF 2 "nonimmediate_operand" "")))]
 650   "TARGET_AVX"
 651 {
 652   ix86_fixup_binary_operands_no_copy (DIV, V8SFmode, operands);
 653
 654   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 655       && flag_finite_math_only && !flag_trapping_math
 656       && flag_unsafe_math_optimizations)
 657     {
 658       ix86_emit_swdivsf (operands[0], operands[1],
 659                          operands[2], V8SFmode);
 660       DONE;
 661     }
 662 })
 663
 664 (define_expand "divv4df3"
 665   [(set (match_operand:V4DF 0 "register_operand" "")
 666         (div:V4DF (match_operand:V4DF 1 "register_operand" "")
 667                   (match_operand:V4DF 2 "nonimmediate_operand" "")))]
 668   "TARGET_AVX"
 669   "ix86_fixup_binary_operands_no_copy (DIV, V4DFmode, operands);")
 670
 671 (define_insn "avx_div<mode>3"
 672   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 673         (div:AVXMODEF2P
 674           (match_operand:AVXMODEF2P 1 "register_operand" "x")
 675           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 676   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 677   "vdivp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 678   [(set_attr "type" "ssediv")
 679    (set_attr "prefix" "vex")
 680    (set_attr "mode" "<MODE>")])
 681
 682 (define_expand "divv4sf3"
 683   [(set (match_operand:V4SF 0 "register_operand" "")
 684         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 685                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 686   "TARGET_SSE"
 687 {
 688   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 689       && flag_finite_math_only && !flag_trapping_math
 690       && flag_unsafe_math_optimizations)
 691     {
 692       ix86_emit_swdivsf (operands[0], operands[1],
 693                          operands[2], V4SFmode);
 694       DONE;
 695     }
 696 })
 697
 698 (define_expand "divv2df3"
 699   [(set (match_operand:V2DF 0 "register_operand" "")
 700         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
 701                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
 702   "TARGET_SSE2"
 703   "")
 704
 705 (define_insn "*avx_div<mode>3"
 706   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 707         (div:SSEMODEF2P
 708           (match_operand:SSEMODEF2P 1 "register_operand" "x")
 709           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 710   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 711   "vdivp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 712   [(set_attr "type" "ssediv")
 713    (set_attr "prefix" "vex")
 714    (set_attr "mode" "<MODE>")])
 715
 716 (define_insn "<sse>_div<mode>3"
 717   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 718         (div:SSEMODEF2P
 719           (match_operand:SSEMODEF2P 1 "register_operand" "0")
 720           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 721   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 722   "divp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 723   [(set_attr "type" "ssediv")
 724    (set_attr "mode" "<MODE>")])
 725
 726 (define_insn "*avx_vmdiv<mode>3"
 727   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 728         (vec_merge:SSEMODEF2P
 729           (div:SSEMODEF2P
 730             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 731             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 732           (match_dup 1)
 733           (const_int 1)))]
 734   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 735   "vdivs<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 736   [(set_attr "type" "ssediv")
 737    (set_attr "prefix" "vex")
 738    (set_attr "mode" "<ssescalarmode>")])
 739
 740 (define_insn "<sse>_vmdiv<mode>3"
 741   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 742         (vec_merge:SSEMODEF2P
 743           (div:SSEMODEF2P
 744             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 745             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 746           (match_dup 1)
 747           (const_int 1)))]
 748   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 749   "divs<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
 750   [(set_attr "type" "ssediv")
 751    (set_attr "mode" "<ssescalarmode>")])
 752
 753 (define_insn "avx_rcpv8sf2"
 754   [(set (match_operand:V8SF 0 "register_operand" "=x")
 755         (unspec:V8SF
 756           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 757   "TARGET_AVX"
 758   "vrcpps\t{%1, %0|%0, %1}"
 759   [(set_attr "type" "sse")
 760    (set_attr "prefix" "vex")
 761    (set_attr "mode" "V8SF")])
 762
 763 (define_insn "sse_rcpv4sf2"
 764   [(set (match_operand:V4SF 0 "register_operand" "=x")
 765         (unspec:V4SF
 766           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 767   "TARGET_SSE"
 768   "%vrcpps\t{%1, %0|%0, %1}"
 769   [(set_attr "type" "sse")
 770    (set_attr "atom_sse_attr" "rcp")
 771    (set_attr "prefix" "maybe_vex")
 772    (set_attr "mode" "V4SF")])
 773
 774 (define_insn "*avx_vmrcpv4sf2"
 775   [(set (match_operand:V4SF 0 "register_operand" "=x")
 776         (vec_merge:V4SF
 777           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 778                        UNSPEC_RCP)
 779           (match_operand:V4SF 2 "register_operand" "x")
 780           (const_int 1)))]
 781   "TARGET_AVX"
 782   "vrcpss\t{%1, %2, %0|%0, %2, %1}"
 783   [(set_attr "type" "sse")
 784    (set_attr "prefix" "vex")
 785    (set_attr "mode" "SF")])
 786
 787 (define_insn "sse_vmrcpv4sf2"
 788   [(set (match_operand:V4SF 0 "register_operand" "=x")
 789         (vec_merge:V4SF
 790           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 791                        UNSPEC_RCP)
 792           (match_operand:V4SF 2 "register_operand" "0")
 793           (const_int 1)))]
 794   "TARGET_SSE"
 795   "rcpss\t{%1, %0|%0, %1}"
 796   [(set_attr "type" "sse")
 797    (set_attr "atom_sse_attr" "rcp")
 798    (set_attr "mode" "SF")])
 799
 800 (define_expand "sqrtv8sf2"
 801   [(set (match_operand:V8SF 0 "register_operand" "")
 802         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "")))]
 803   "TARGET_AVX"
 804 {
 805   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 806       && flag_finite_math_only && !flag_trapping_math
 807       && flag_unsafe_math_optimizations)
 808     {
 809       ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 0);
 810       DONE;
 811     }
 812 })
 813
 814 (define_insn "avx_sqrtv8sf2"
 815   [(set (match_operand:V8SF 0 "register_operand" "=x")
 816         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
 817   "TARGET_AVX"
 818   "vsqrtps\t{%1, %0|%0, %1}"
 819   [(set_attr "type" "sse")
 820    (set_attr "prefix" "vex")
 821    (set_attr "mode" "V8SF")])
 822
 823 (define_expand "sqrtv4sf2"
 824   [(set (match_operand:V4SF 0 "register_operand" "")
 825         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 826   "TARGET_SSE"
 827 {
 828   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 829       && flag_finite_math_only && !flag_trapping_math
 830       && flag_unsafe_math_optimizations)
 831     {
 832       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 833       DONE;
 834     }
 835 })
 836
 837 (define_insn "sse_sqrtv4sf2"
 838   [(set (match_operand:V4SF 0 "register_operand" "=x")
 839         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 840   "TARGET_SSE"
 841   "%vsqrtps\t{%1, %0|%0, %1}"
 842   [(set_attr "type" "sse")
 843    (set_attr "atom_sse_attr" "sqrt")
 844    (set_attr "prefix" "maybe_vex")
 845    (set_attr "mode" "V4SF")])
 846
 847 (define_insn "sqrtv4df2"
 848   [(set (match_operand:V4DF 0 "register_operand" "=x")
 849         (sqrt:V4DF (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
 850   "TARGET_AVX"
 851   "vsqrtpd\t{%1, %0|%0, %1}"
 852   [(set_attr "type" "sse")
 853    (set_attr "prefix" "vex")
 854    (set_attr "mode" "V4DF")])
 855
 856 (define_insn "sqrtv2df2"
 857   [(set (match_operand:V2DF 0 "register_operand" "=x")
 858         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
 859   "TARGET_SSE2"
 860   "%vsqrtpd\t{%1, %0|%0, %1}"
 861   [(set_attr "type" "sse")
 862    (set_attr "prefix" "maybe_vex")
 863    (set_attr "mode" "V2DF")])
 864
 865 (define_insn "*avx_vmsqrt<mode>2"
 866   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 867         (vec_merge:SSEMODEF2P
 868           (sqrt:SSEMODEF2P
 869             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 870           (match_operand:SSEMODEF2P 2 "register_operand" "x")
 871           (const_int 1)))]
 872   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 873   "vsqrts<ssemodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
 874   [(set_attr "type" "sse")
 875    (set_attr "prefix" "vex")
 876    (set_attr "mode" "<ssescalarmode>")])
 877
 878 (define_insn "<sse>_vmsqrt<mode>2"
 879   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 880         (vec_merge:SSEMODEF2P
 881           (sqrt:SSEMODEF2P
 882             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 883           (match_operand:SSEMODEF2P 2 "register_operand" "0")
 884           (const_int 1)))]
 885   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 886   "sqrts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
 887   [(set_attr "type" "sse")
 888    (set_attr "atom_sse_attr" "sqrt")
 889    (set_attr "mode" "<ssescalarmode>")])
 890
 891 (define_expand "rsqrtv8sf2"
 892   [(set (match_operand:V8SF 0 "register_operand" "")
 893         (unspec:V8SF
 894           [(match_operand:V8SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 895   "TARGET_AVX && TARGET_SSE_MATH"
 896 {
 897   ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 1);
 898   DONE;
 899 })
 900
 901 (define_insn "avx_rsqrtv8sf2"
 902   [(set (match_operand:V8SF 0 "register_operand" "=x")
 903         (unspec:V8SF
 904           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 905   "TARGET_AVX"
 906   "vrsqrtps\t{%1, %0|%0, %1}"
 907   [(set_attr "type" "sse")
 908    (set_attr "prefix" "vex")
 909    (set_attr "mode" "V8SF")])
 910
 911 (define_expand "rsqrtv4sf2"
 912   [(set (match_operand:V4SF 0 "register_operand" "")
 913         (unspec:V4SF
 914           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 915   "TARGET_SSE_MATH"
 916 {
 917   ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 918   DONE;
 919 })
 920
 921 (define_insn "sse_rsqrtv4sf2"
 922   [(set (match_operand:V4SF 0 "register_operand" "=x")
 923         (unspec:V4SF
 924           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 925   "TARGET_SSE"
 926   "%vrsqrtps\t{%1, %0|%0, %1}"
 927   [(set_attr "type" "sse")
 928    (set_attr "prefix" "maybe_vex")
 929    (set_attr "mode" "V4SF")])
 930
 931 (define_insn "*avx_vmrsqrtv4sf2"
 932   [(set (match_operand:V4SF 0 "register_operand" "=x")
 933         (vec_merge:V4SF
 934           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 935                        UNSPEC_RSQRT)
 936           (match_operand:V4SF 2 "register_operand" "x")
 937           (const_int 1)))]
 938   "TARGET_AVX"
 939   "vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
 940   [(set_attr "type" "sse")
 941    (set_attr "prefix" "vex")
 942    (set_attr "mode" "SF")])
 943
 944 (define_insn "sse_vmrsqrtv4sf2"
 945   [(set (match_operand:V4SF 0 "register_operand" "=x")
 946         (vec_merge:V4SF
 947           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 948                        UNSPEC_RSQRT)
 949           (match_operand:V4SF 2 "register_operand" "0")
 950           (const_int 1)))]
 951   "TARGET_SSE"
 952   "rsqrtss\t{%1, %0|%0, %1}"
 953   [(set_attr "type" "sse")
 954    (set_attr "mode" "SF")])
 955
 956 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
 957 ;; isn't really correct, as those rtl operators aren't defined when
 958 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
 959
 960 (define_expand "<code><mode>3"
 961   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 962         (smaxmin:AVX256MODEF2P
 963           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 964           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 965   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 966 {
 967   if (!flag_finite_math_only)
 968     operands[1] = force_reg (<MODE>mode, operands[1]);
 969   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
 970 })
 971
 972 (define_expand "<code><mode>3"
 973   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 974         (smaxmin:SSEMODEF2P
 975           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 976           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 977   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 978 {
 979   if (!flag_finite_math_only)
 980     operands[1] = force_reg (<MODE>mode, operands[1]);
 981   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
 982 })
 983
 984 (define_insn "*avx_<code><mode>3_finite"
 985   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 986         (smaxmin:AVXMODEF2P
 987           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 988           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 989   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
 990    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 991   "v<maxminfprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
 992   [(set_attr "type" "sseadd")
 993    (set_attr "prefix" "vex")
 994    (set_attr "mode" "<MODE>")])
 995
 996 (define_insn "*<code><mode>3_finite"
 997   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 998         (smaxmin:SSEMODEF2P
 999           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1000           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1001   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1002    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1003   "<maxminfprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1004   [(set_attr "type" "sseadd")
1005    (set_attr "mode" "<MODE>")])
1006
1007 (define_insn "*avx_<code><mode>3"
1008   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1009         (smaxmin:AVXMODEF2P
1010           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1011           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1012   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1013   "v<maxminfprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1014   [(set_attr "type" "sseadd")
1015    (set_attr "prefix" "vex")
1016    (set_attr "mode" "<avxvecmode>")])
1017
1018 (define_insn "*<code><mode>3"
1019   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1020         (smaxmin:SSEMODEF2P
1021           (match_operand:SSEMODEF2P 1 "register_operand" "0")
1022           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1023   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1024   "<maxminfprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1025   [(set_attr "type" "sseadd")
1026    (set_attr "mode" "<MODE>")])
1027
1028 (define_insn "*avx_vm<code><mode>3"
1029   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1030         (vec_merge:SSEMODEF2P
1031           (smaxmin:SSEMODEF2P
1032             (match_operand:SSEMODEF2P 1 "register_operand" "x")
1033             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1034          (match_dup 1)
1035          (const_int 1)))]
1036   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
1037   "v<maxminfprefix>s<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1038   [(set_attr "type" "sse")
1039    (set_attr "prefix" "vex")
1040    (set_attr "mode" "<ssescalarmode>")])
1041
1042 (define_insn "<sse>_vm<code><mode>3"
1043   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1044         (vec_merge:SSEMODEF2P
1045           (smaxmin:SSEMODEF2P
1046             (match_operand:SSEMODEF2P 1 "register_operand" "0")
1047             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1048          (match_dup 1)
1049          (const_int 1)))]
1050   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1051   "<maxminfprefix>s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1052   [(set_attr "type" "sseadd")
1053    (set_attr "mode" "<ssescalarmode>")])
1054
1055 ;; These versions of the min/max patterns implement exactly the operations
1056 ;;   min = (op1 < op2 ? op1 : op2)
1057 ;;   max = (!(op1 < op2) ? op1 : op2)
1058 ;; Their operands are not commutative, and thus they may be used in the
1059 ;; presence of -0.0 and NaN.
1060
1061 (define_insn "*avx_ieee_smin<mode>3"
1062   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1063         (unspec:AVXMODEF2P
1064           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1065            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1066          UNSPEC_IEEE_MIN))]
1067   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1068   "vminp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1069   [(set_attr "type" "sseadd")
1070    (set_attr "prefix" "vex")
1071    (set_attr "mode" "<avxvecmode>")])
1072
1073 (define_insn "*avx_ieee_smax<mode>3"
1074   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1075         (unspec:AVXMODEF2P
1076           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1077            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1078          UNSPEC_IEEE_MAX))]
1079   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1080   "vmaxp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1081   [(set_attr "type" "sseadd")
1082    (set_attr "prefix" "vex")
1083    (set_attr "mode" "<avxvecmode>")])
1084
1085 (define_insn "*ieee_smin<mode>3"
1086   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1087         (unspec:SSEMODEF2P
1088           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1089            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1090          UNSPEC_IEEE_MIN))]
1091   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1092   "minp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1093   [(set_attr "type" "sseadd")
1094    (set_attr "mode" "<MODE>")])
1095
1096 (define_insn "*ieee_smax<mode>3"
1097   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1098         (unspec:SSEMODEF2P
1099           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1100            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1101          UNSPEC_IEEE_MAX))]
1102   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1103   "maxp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1104   [(set_attr "type" "sseadd")
1105    (set_attr "mode" "<MODE>")])
1106
1107 (define_insn "avx_addsubv8sf3"
1108   [(set (match_operand:V8SF 0 "register_operand" "=x")
1109         (vec_merge:V8SF
1110           (plus:V8SF
1111             (match_operand:V8SF 1 "register_operand" "x")
1112             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1113           (minus:V8SF (match_dup 1) (match_dup 2))
1114           (const_int 170)))]
1115   "TARGET_AVX"
1116   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1117   [(set_attr "type" "sseadd")
1118    (set_attr "prefix" "vex")
1119    (set_attr "mode" "V8SF")])
1120
1121 (define_insn "avx_addsubv4df3"
1122   [(set (match_operand:V4DF 0 "register_operand" "=x")
1123         (vec_merge:V4DF
1124           (plus:V4DF
1125             (match_operand:V4DF 1 "register_operand" "x")
1126             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1127           (minus:V4DF (match_dup 1) (match_dup 2))
1128           (const_int 10)))]
1129   "TARGET_AVX"
1130   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1131   [(set_attr "type" "sseadd")
1132    (set_attr "prefix" "vex")
1133    (set_attr "mode" "V4DF")])
1134
1135 (define_insn "*avx_addsubv4sf3"
1136   [(set (match_operand:V4SF 0 "register_operand" "=x")
1137         (vec_merge:V4SF
1138           (plus:V4SF
1139             (match_operand:V4SF 1 "register_operand" "x")
1140             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1141           (minus:V4SF (match_dup 1) (match_dup 2))
1142           (const_int 10)))]
1143   "TARGET_AVX"
1144   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1145   [(set_attr "type" "sseadd")
1146    (set_attr "prefix" "vex")
1147    (set_attr "mode" "V4SF")])
1148
1149 (define_insn "sse3_addsubv4sf3"
1150   [(set (match_operand:V4SF 0 "register_operand" "=x")
1151         (vec_merge:V4SF
1152           (plus:V4SF
1153             (match_operand:V4SF 1 "register_operand" "0")
1154             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1155           (minus:V4SF (match_dup 1) (match_dup 2))
1156           (const_int 10)))]
1157   "TARGET_SSE3"
1158   "addsubps\t{%2, %0|%0, %2}"
1159   [(set_attr "type" "sseadd")
1160    (set_attr "prefix_rep" "1")
1161    (set_attr "mode" "V4SF")])
1162
1163 (define_insn "*avx_addsubv2df3"
1164   [(set (match_operand:V2DF 0 "register_operand" "=x")
1165         (vec_merge:V2DF
1166           (plus:V2DF
1167             (match_operand:V2DF 1 "register_operand" "x")
1168             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1169           (minus:V2DF (match_dup 1) (match_dup 2))
1170           (const_int 2)))]
1171   "TARGET_AVX"
1172   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1173   [(set_attr "type" "sseadd")
1174    (set_attr "prefix" "vex")
1175    (set_attr "mode" "V2DF")])
1176
1177 (define_insn "sse3_addsubv2df3"
1178   [(set (match_operand:V2DF 0 "register_operand" "=x")
1179         (vec_merge:V2DF
1180           (plus:V2DF
1181             (match_operand:V2DF 1 "register_operand" "0")
1182             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1183           (minus:V2DF (match_dup 1) (match_dup 2))
1184           (const_int 2)))]
1185   "TARGET_SSE3"
1186   "addsubpd\t{%2, %0|%0, %2}"
1187   [(set_attr "type" "sseadd")
1188    (set_attr "atom_unit" "complex")
1189    (set_attr "mode" "V2DF")])
1190
1191 (define_insn "avx_h<plusminus_insn>v4df3"
1192   [(set (match_operand:V4DF 0 "register_operand" "=x")
1193         (vec_concat:V4DF
1194           (vec_concat:V2DF
1195             (plusminus:DF
1196               (vec_select:DF
1197                 (match_operand:V4DF 1 "register_operand" "x")
1198                 (parallel [(const_int 0)]))
1199               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1200             (plusminus:DF
1201               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1202               (vec_select:DF (match_dup 1) (parallel [(const_int 3)]))))
1203           (vec_concat:V2DF
1204             (plusminus:DF
1205               (vec_select:DF
1206                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1207                 (parallel [(const_int 0)]))
1208               (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))
1209             (plusminus:DF
1210               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1211               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1212   "TARGET_AVX"
1213   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1214   [(set_attr "type" "sseadd")
1215    (set_attr "prefix" "vex")
1216    (set_attr "mode" "V4DF")])
1217
1218 (define_insn "avx_h<plusminus_insn>v8sf3"
1219   [(set (match_operand:V8SF 0 "register_operand" "=x")
1220         (vec_concat:V8SF
1221           (vec_concat:V4SF
1222             (vec_concat:V2SF
1223               (plusminus:SF
1224                 (vec_select:SF
1225                   (match_operand:V8SF 1 "register_operand" "x")
1226                   (parallel [(const_int 0)]))
1227                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1228               (plusminus:SF
1229                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1230                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1231             (vec_concat:V2SF
1232               (plusminus:SF
1233                 (vec_select:SF
1234                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1235                   (parallel [(const_int 0)]))
1236                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1237               (plusminus:SF
1238                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1239                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1240           (vec_concat:V4SF
1241             (vec_concat:V2SF
1242               (plusminus:SF
1243                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1244                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1245               (plusminus:SF
1246                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1247                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1248             (vec_concat:V2SF
1249               (plusminus:SF
1250                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1251                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1252               (plusminus:SF
1253                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1254                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1255   "TARGET_AVX"
1256   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1257   [(set_attr "type" "sseadd")
1258    (set_attr "prefix" "vex")
1259    (set_attr "mode" "V8SF")])
1260
1261 (define_insn "*avx_h<plusminus_insn>v4sf3"
1262   [(set (match_operand:V4SF 0 "register_operand" "=x")
1263         (vec_concat:V4SF
1264           (vec_concat:V2SF
1265             (plusminus:SF
1266               (vec_select:SF
1267                 (match_operand:V4SF 1 "register_operand" "x")
1268                 (parallel [(const_int 0)]))
1269               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1270             (plusminus:SF
1271               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1272               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1273           (vec_concat:V2SF
1274             (plusminus:SF
1275               (vec_select:SF
1276                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1277                 (parallel [(const_int 0)]))
1278               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1279             (plusminus:SF
1280               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1281               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1282   "TARGET_AVX"
1283   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1284   [(set_attr "type" "sseadd")
1285    (set_attr "prefix" "vex")
1286    (set_attr "mode" "V4SF")])
1287
1288 (define_insn "sse3_h<plusminus_insn>v4sf3"
1289   [(set (match_operand:V4SF 0 "register_operand" "=x")
1290         (vec_concat:V4SF
1291           (vec_concat:V2SF
1292             (plusminus:SF
1293               (vec_select:SF
1294                 (match_operand:V4SF 1 "register_operand" "0")
1295                 (parallel [(const_int 0)]))
1296               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1297             (plusminus:SF
1298               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1299               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1300           (vec_concat:V2SF
1301             (plusminus:SF
1302               (vec_select:SF
1303                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1304                 (parallel [(const_int 0)]))
1305               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1306             (plusminus:SF
1307               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1308               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1309   "TARGET_SSE3"
1310   "h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}"
1311   [(set_attr "type" "sseadd")
1312    (set_attr "atom_unit" "complex")
1313    (set_attr "prefix_rep" "1")
1314    (set_attr "mode" "V4SF")])
1315
1316 (define_insn "*avx_h<plusminus_insn>v2df3"
1317   [(set (match_operand:V2DF 0 "register_operand" "=x")
1318         (vec_concat:V2DF
1319           (plusminus:DF
1320             (vec_select:DF
1321               (match_operand:V2DF 1 "register_operand" "x")
1322               (parallel [(const_int 0)]))
1323             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1324           (plusminus:DF
1325             (vec_select:DF
1326               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1327               (parallel [(const_int 0)]))
1328             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1329   "TARGET_AVX"
1330   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1331   [(set_attr "type" "sseadd")
1332    (set_attr "prefix" "vex")
1333    (set_attr "mode" "V2DF")])
1334
1335 (define_insn "sse3_h<plusminus_insn>v2df3"
1336   [(set (match_operand:V2DF 0 "register_operand" "=x")
1337         (vec_concat:V2DF
1338           (plusminus:DF
1339             (vec_select:DF
1340               (match_operand:V2DF 1 "register_operand" "0")
1341               (parallel [(const_int 0)]))
1342             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1343           (plusminus:DF
1344             (vec_select:DF
1345               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1346               (parallel [(const_int 0)]))
1347             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1348   "TARGET_SSE3"
1349   "h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}"
1350   [(set_attr "type" "sseadd")
1351    (set_attr "mode" "V2DF")])
1352
1353 (define_expand "reduc_splus_v4sf"
1354   [(match_operand:V4SF 0 "register_operand" "")
1355    (match_operand:V4SF 1 "register_operand" "")]
1356   "TARGET_SSE"
1357 {
1358   if (TARGET_SSE3)
1359     {
1360       rtx tmp = gen_reg_rtx (V4SFmode);
1361       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1362       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1363     }
1364   else
1365     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
1366   DONE;
1367 })
1368
1369 (define_expand "reduc_splus_v2df"
1370   [(match_operand:V2DF 0 "register_operand" "")
1371    (match_operand:V2DF 1 "register_operand" "")]
1372   "TARGET_SSE3"
1373 {
1374   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1375   DONE;
1376 })
1377
1378 (define_expand "reduc_smax_v4sf"
1379   [(match_operand:V4SF 0 "register_operand" "")
1380    (match_operand:V4SF 1 "register_operand" "")]
1381   "TARGET_SSE"
1382 {
1383   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
1384   DONE;
1385 })
1386
1387 (define_expand "reduc_smin_v4sf"
1388   [(match_operand:V4SF 0 "register_operand" "")
1389    (match_operand:V4SF 1 "register_operand" "")]
1390   "TARGET_SSE"
1391 {
1392   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
1393   DONE;
1394 })
1395
1396 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1397 ;;
1398 ;; Parallel floating point comparisons
1399 ;;
1400 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1401
1402 (define_insn "avx_cmpp<avxmodesuffixf2c><mode>3"
1403   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1404         (unspec:AVXMODEF2P
1405           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1406            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
1407            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1408           UNSPEC_PCMP))]
1409   "TARGET_AVX"
1410   "vcmpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1411   [(set_attr "type" "ssecmp")
1412    (set_attr "length_immediate" "1")
1413    (set_attr "prefix" "vex")
1414    (set_attr "mode" "<MODE>")])
1415
1416 (define_insn "avx_cmps<ssemodesuffixf2c><mode>3"
1417   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1418         (vec_merge:SSEMODEF2P
1419           (unspec:SSEMODEF2P
1420             [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1421              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
1422              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1423             UNSPEC_PCMP)
1424          (match_dup 1)
1425          (const_int 1)))]
1426   "TARGET_AVX"
1427   "vcmps<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1428   [(set_attr "type" "ssecmp")
1429    (set_attr "length_immediate" "1")
1430    (set_attr "prefix" "vex")
1431    (set_attr "mode" "<ssescalarmode>")])
1432
1433 ;; We don't promote 128bit vector compare intrinsics. But vectorizer
1434 ;; may generate 256bit vector compare instructions.
1435 (define_insn "*avx_maskcmp<mode>3"
1436   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1437         (match_operator:AVXMODEF2P 3 "avx_comparison_float_operator"
1438                 [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1439                  (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]))]
1440   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1441   "vcmp%D3p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1442   [(set_attr "type" "ssecmp")
1443    (set_attr "prefix" "vex")
1444    (set_attr "length_immediate" "1")
1445    (set_attr "mode" "<avxvecmode>")])
1446
1447 (define_insn "<sse>_maskcmp<mode>3"
1448   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x")
1449         (match_operator:SSEMODEF4 3 "sse_comparison_operator"
1450                 [(match_operand:SSEMODEF4 1 "register_operand" "0")
1451                  (match_operand:SSEMODEF4 2 "nonimmediate_operand" "xm")]))]
1452   "(SSE_FLOAT_MODE_P (<MODE>mode) || SSE_VEC_FLOAT_MODE_P (<MODE>mode))
1453    && !TARGET_SSE5"
1454   "cmp%D3<ssemodesuffixf4>\t{%2, %0|%0, %2}"
1455   [(set_attr "type" "ssecmp")
1456    (set_attr "length_immediate" "1")
1457    (set_attr "mode" "<MODE>")])
1458
1459 (define_insn "<sse>_vmmaskcmp<mode>3"
1460   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1461         (vec_merge:SSEMODEF2P
1462          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1463                 [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1464                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1465          (match_dup 1)
1466          (const_int 1)))]
1467   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && !TARGET_SSE5"
1468   "cmp%D3s<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1469   [(set_attr "type" "ssecmp")
1470    (set_attr "length_immediate" "1")
1471    (set_attr "mode" "<ssescalarmode>")])
1472
1473 (define_insn "<sse>_comi"
1474   [(set (reg:CCFP FLAGS_REG)
1475         (compare:CCFP
1476           (vec_select:MODEF
1477             (match_operand:<ssevecmode> 0 "register_operand" "x")
1478             (parallel [(const_int 0)]))
1479           (vec_select:MODEF
1480             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1481             (parallel [(const_int 0)]))))]
1482   "SSE_FLOAT_MODE_P (<MODE>mode)"
1483   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1484   [(set_attr "type" "ssecomi")
1485    (set_attr "prefix" "maybe_vex")
1486    (set_attr "prefix_rep" "0")
1487    (set (attr "prefix_data16")
1488         (if_then_else (eq_attr "mode" "DF")
1489                       (const_string "1")
1490                       (const_string "0")))
1491    (set_attr "mode" "<MODE>")])
1492
1493 (define_insn "<sse>_ucomi"
1494   [(set (reg:CCFPU FLAGS_REG)
1495         (compare:CCFPU
1496           (vec_select:MODEF
1497             (match_operand:<ssevecmode> 0 "register_operand" "x")
1498             (parallel [(const_int 0)]))
1499           (vec_select:MODEF
1500             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1501             (parallel [(const_int 0)]))))]
1502   "SSE_FLOAT_MODE_P (<MODE>mode)"
1503   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1504   [(set_attr "type" "ssecomi")
1505    (set_attr "prefix" "maybe_vex")
1506    (set_attr "prefix_rep" "0")
1507    (set (attr "prefix_data16")
1508         (if_then_else (eq_attr "mode" "DF")
1509                       (const_string "1")
1510                       (const_string "0")))
1511    (set_attr "mode" "<MODE>")])
1512
1513 (define_expand "vcond<mode>"
1514   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1515         (if_then_else:SSEMODEF2P
1516           (match_operator 3 ""
1517             [(match_operand:SSEMODEF2P 4 "nonimmediate_operand" "")
1518              (match_operand:SSEMODEF2P 5 "nonimmediate_operand" "")])
1519           (match_operand:SSEMODEF2P 1 "general_operand" "")
1520           (match_operand:SSEMODEF2P 2 "general_operand" "")))]
1521   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1522 {
1523   if (ix86_expand_fp_vcond (operands))
1524     DONE;
1525   else
1526     FAIL;
1527 })
1528
1529 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1530 ;;
1531 ;; Parallel floating point logical operations
1532 ;;
1533 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1534
1535 (define_insn "avx_andnot<mode>3"
1536   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1537         (and:AVXMODEF2P
1538           (not:AVXMODEF2P
1539             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1540           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1541   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1542   "vandnp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1543   [(set_attr "type" "sselog")
1544    (set_attr "prefix" "vex")
1545    (set_attr "mode" "<avxvecmode>")])
1546
1547 (define_insn "<sse>_andnot<mode>3"
1548   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1549         (and:SSEMODEF2P
1550           (not:SSEMODEF2P
1551             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1552           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1553   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1554   "andnp<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1555   [(set_attr "type" "sselog")
1556    (set_attr "mode" "<MODE>")])
1557
1558 (define_expand "<code><mode>3"
1559   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1560         (plogic:AVX256MODEF2P
1561           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1562           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1563   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1564   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1565
1566 (define_insn "*avx_<code><mode>3"
1567   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1568         (plogic:AVXMODEF2P
1569           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1570           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1571   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1572    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1573   "v<plogicprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
1574   [(set_attr "type" "sselog")
1575    (set_attr "prefix" "vex")
1576    (set_attr "mode" "<avxvecmode>")])
1577
1578 (define_expand "<code><mode>3"
1579   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1580         (plogic:SSEMODEF2P
1581           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1582           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1583   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1584   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1585
1586 (define_insn "*<code><mode>3"
1587   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1588         (plogic:SSEMODEF2P
1589           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1590           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1591   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1592    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1593   "<plogicprefix>p<ssemodesuffixf2c>\t{%2, %0|%0, %2}"
1594   [(set_attr "type" "sselog")
1595    (set_attr "mode" "<MODE>")])
1596
1597 (define_expand "copysign<mode>3"
1598   [(set (match_dup 4)
1599         (and:SSEMODEF2P
1600           (not:SSEMODEF2P (match_dup 3))
1601           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")))
1602    (set (match_dup 5)
1603         (and:SSEMODEF2P (match_dup 3)
1604                         (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))
1605    (set (match_operand:SSEMODEF2P 0 "register_operand" "")
1606         (ior:SSEMODEF2P (match_dup 4) (match_dup 5)))]
1607   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1608 {
1609   operands[3] = ix86_build_signbit_mask (<ssescalarmode>mode, 1, 0);
1610
1611   operands[4] = gen_reg_rtx (<MODE>mode);
1612   operands[5] = gen_reg_rtx (<MODE>mode);
1613 })
1614
1615 ;; Also define scalar versions.  These are used for abs, neg, and
1616 ;; conditional move.  Using subregs into vector modes causes register
1617 ;; allocation lossage.  These patterns do not allow memory operands
1618 ;; because the native instructions read the full 128-bits.
1619
1620 (define_insn "*avx_andnot<mode>3"
1621   [(set (match_operand:MODEF 0 "register_operand" "=x")
1622         (and:MODEF
1623           (not:MODEF
1624             (match_operand:MODEF 1 "register_operand" "x"))
1625             (match_operand:MODEF 2 "register_operand" "x")))]
1626   "AVX_FLOAT_MODE_P (<MODE>mode)"
1627   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1628   [(set_attr "type" "sselog")
1629    (set_attr "prefix" "vex")
1630    (set_attr "mode" "<ssevecmode>")])
1631
1632 (define_insn "*andnot<mode>3"
1633   [(set (match_operand:MODEF 0 "register_operand" "=x")
1634         (and:MODEF
1635           (not:MODEF
1636             (match_operand:MODEF 1 "register_operand" "0"))
1637             (match_operand:MODEF 2 "register_operand" "x")))]
1638   "SSE_FLOAT_MODE_P (<MODE>mode)"
1639   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1640   [(set_attr "type" "sselog")
1641    (set_attr "mode" "<ssevecmode>")])
1642
1643 (define_insn "*avx_<code><mode>3"
1644   [(set (match_operand:MODEF 0 "register_operand" "=x")
1645         (plogic:MODEF
1646           (match_operand:MODEF 1 "register_operand" "x")
1647           (match_operand:MODEF 2 "register_operand" "x")))]
1648   "AVX_FLOAT_MODE_P (<MODE>mode)"
1649   "v<plogicprefix>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1650   [(set_attr "type" "sselog")
1651    (set_attr "prefix" "vex")
1652    (set_attr "mode" "<ssevecmode>")])
1653
1654 (define_insn "*<code><mode>3"
1655   [(set (match_operand:MODEF 0 "register_operand" "=x")
1656         (plogic:MODEF
1657           (match_operand:MODEF 1 "register_operand" "0")
1658           (match_operand:MODEF 2 "register_operand" "x")))]
1659   "SSE_FLOAT_MODE_P (<MODE>mode)"
1660   "<plogicprefix>p<ssemodefsuffix>\t{%2, %0|%0, %2}"
1661   [(set_attr "type" "sselog")
1662    (set_attr "mode" "<ssevecmode>")])
1663
1664 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1665 ;;
1666 ;; SSE5 floating point multiply/accumulate instructions This includes the
1667 ;; scalar version of the instructions as well as the vector
1668 ;;
1669 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1670
1671 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1672 ;; combine to generate a multiply/add with two memory references.  We then
1673 ;; split this insn, into loading up the destination register with one of the
1674 ;; memory operations.  If we don't manage to split the insn, reload will
1675 ;; generate the appropriate moves.  The reason this is needed, is that combine
1676 ;; has already folded one of the memory references into both the multiply and
1677 ;; add insns, and it can't generate a new pseudo.  I.e.:
1678 ;;      (set (reg1) (mem (addr1)))
1679 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1680 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1681
1682 (define_insn "sse5_fmadd<mode>4"
1683   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1684         (plus:SSEMODEF4
1685          (mult:SSEMODEF4
1686           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1687           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))
1688          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")))]
1689   "TARGET_SSE5 && TARGET_FUSED_MADD
1690    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1691   "fmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1692   [(set_attr "type" "ssemuladd")
1693    (set_attr "mode" "<MODE>")])
1694
1695 ;; Split fmadd with two memory operands into a load and the fmadd.
1696 (define_split
1697   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1698         (plus:SSEMODEF4
1699          (mult:SSEMODEF4
1700           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1701           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1702          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1703   "TARGET_SSE5
1704    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1705    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1706    && !reg_mentioned_p (operands[0], operands[1])
1707    && !reg_mentioned_p (operands[0], operands[2])
1708    && !reg_mentioned_p (operands[0], operands[3])"
1709   [(const_int 0)]
1710 {
1711   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1712   emit_insn (gen_sse5_fmadd<mode>4 (operands[0], operands[1],
1713                                     operands[2], operands[3]));
1714   DONE;
1715 })
1716
1717 ;; For the scalar operations, use operand1 for the upper words that aren't
1718 ;; modified, so restrict the forms that are generated.
1719 ;; Scalar version of fmadd
1720 (define_insn "sse5_vmfmadd<mode>4"
1721   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1722         (vec_merge:SSEMODEF2P
1723          (plus:SSEMODEF2P
1724           (mult:SSEMODEF2P
1725            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1726            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1727           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1728          (match_dup 1)
1729          (const_int 1)))]
1730   "TARGET_SSE5 && TARGET_FUSED_MADD
1731    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1732   "fmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1733   [(set_attr "type" "ssemuladd")
1734    (set_attr "mode" "<MODE>")])
1735
1736 ;; Floating multiply and subtract
1737 ;; Allow two memory operands the same as fmadd
1738 (define_insn "sse5_fmsub<mode>4"
1739   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1740         (minus:SSEMODEF4
1741          (mult:SSEMODEF4
1742           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1743           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))
1744          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")))]
1745   "TARGET_SSE5 && TARGET_FUSED_MADD
1746    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1747   "fmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1748   [(set_attr "type" "ssemuladd")
1749    (set_attr "mode" "<MODE>")])
1750
1751 ;; Split fmsub with two memory operands into a load and the fmsub.
1752 (define_split
1753   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1754         (minus:SSEMODEF4
1755          (mult:SSEMODEF4
1756           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1757           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1758          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1759   "TARGET_SSE5
1760    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1761    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1762    && !reg_mentioned_p (operands[0], operands[1])
1763    && !reg_mentioned_p (operands[0], operands[2])
1764    && !reg_mentioned_p (operands[0], operands[3])"
1765   [(const_int 0)]
1766 {
1767   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1768   emit_insn (gen_sse5_fmsub<mode>4 (operands[0], operands[1],
1769                                     operands[2], operands[3]));
1770   DONE;
1771 })
1772
1773 ;; For the scalar operations, use operand1 for the upper words that aren't
1774 ;; modified, so restrict the forms that are generated.
1775 ;; Scalar version of fmsub
1776 (define_insn "sse5_vmfmsub<mode>4"
1777   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1778         (vec_merge:SSEMODEF2P
1779          (minus:SSEMODEF2P
1780           (mult:SSEMODEF2P
1781            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1782            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1783           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1784          (match_dup 1)
1785          (const_int 1)))]
1786   "TARGET_SSE5 && TARGET_FUSED_MADD
1787    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
1788   "fmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1789   [(set_attr "type" "ssemuladd")
1790    (set_attr "mode" "<MODE>")])
1791
1792 ;; Floating point negative multiply and add
1793 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b)
1794 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
1795 ;; Allow two memory operands to help in optimizing.
1796 (define_insn "sse5_fnmadd<mode>4"
1797   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x,x,x")
1798         (minus:SSEMODEF4
1799          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x,0,0")
1800          (mult:SSEMODEF4
1801           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "%0,0,x,xm")
1802           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm,xm,x"))))]
1803   "TARGET_SSE5 && TARGET_FUSED_MADD
1804    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)"
1805   "fnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1806   [(set_attr "type" "ssemuladd")
1807    (set_attr "mode" "<MODE>")])
1808
1809 ;; Split fnmadd with two memory operands into a load and the fnmadd.
1810 (define_split
1811   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1812         (minus:SSEMODEF4
1813          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")
1814          (mult:SSEMODEF4
1815           (match_operand:SSEMODEF4 1 "nonimmediate_operand" "")
1816           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))))]
1817   "TARGET_SSE5
1818    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)
1819    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, true)
1820    && !reg_mentioned_p (operands[0], operands[1])
1821    && !reg_mentioned_p (operands[0], operands[2])
1822    && !reg_mentioned_p (operands[0], operands[3])"
1823   [(const_int 0)]
1824 {
1825   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1826   emit_insn (gen_sse5_fnmadd<mode>4 (operands[0], operands[1],
1827                                      operands[2], operands[3]));
1828   DONE;
1829 })
1830
1831 ;; For the scalar operations, use operand1 for the upper words that aren't
1832 ;; modified, so restrict the forms that are generated.
1833 ;; Scalar version of fnmadd
1834 (define_insn "sse5_vmfnmadd<mode>4"
1835   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1836         (vec_merge:SSEMODEF2P
1837          (minus:SSEMODEF2P
1838           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
1839           (mult:SSEMODEF2P
1840            (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0")
1841            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm")))
1842          (match_dup 1)
1843          (const_int 1)))]
1844   "TARGET_SSE5 && TARGET_FUSED_MADD
1845    && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1846   "fnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1847   [(set_attr "type" "ssemuladd")
1848    (set_attr "mode" "<MODE>")])
1849
1850 ;; Floating point negative multiply and subtract
1851 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c
1852 ;; Allow 2 memory operands to help with optimization
1853 (define_insn "sse5_fnmsub<mode>4"
1854   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x,x")
1855         (minus:SSEMODEF4
1856          (mult:SSEMODEF4
1857           (neg:SSEMODEF4
1858            (match_operand:SSEMODEF4 1 "nonimmediate_operand" "0,0"))
1859           (match_operand:SSEMODEF4 2 "nonimmediate_operand" "x,xm"))
1860          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "xm,x")))]
1861   "TARGET_SSE5 && TARGET_FUSED_MADD
1862    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)"
1863   "fnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1864   [(set_attr "type" "ssemuladd")
1865    (set_attr "mode" "<MODE>")])
1866
1867 ;; Split fnmsub with two memory operands into a load and the fmsub.
1868 (define_split
1869   [(set (match_operand:SSEMODEF4 0 "register_operand" "")
1870         (minus:SSEMODEF4
1871          (mult:SSEMODEF4
1872           (neg:SSEMODEF4
1873            (match_operand:SSEMODEF4 1 "nonimmediate_operand" ""))
1874           (match_operand:SSEMODEF4 2 "nonimmediate_operand" ""))
1875          (match_operand:SSEMODEF4 3 "nonimmediate_operand" "")))]
1876   "TARGET_SSE5
1877    && !ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)
1878    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)
1879    && !reg_mentioned_p (operands[0], operands[1])
1880    && !reg_mentioned_p (operands[0], operands[2])
1881    && !reg_mentioned_p (operands[0], operands[3])"
1882   [(const_int 0)]
1883 {
1884   ix86_expand_sse5_multiple_memory (operands, 4, <MODE>mode);
1885   emit_insn (gen_sse5_fnmsub<mode>4 (operands[0], operands[1],
1886                                      operands[2], operands[3]));
1887   DONE;
1888 })
1889
1890 ;; For the scalar operations, use operand1 for the upper words that aren't
1891 ;; modified, so restrict the forms that are generated.
1892 ;; Scalar version of fnmsub
1893 (define_insn "sse5_vmfnmsub<mode>4"
1894   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1895         (vec_merge:SSEMODEF2P
1896          (minus:SSEMODEF2P
1897           (mult:SSEMODEF2P
1898            (neg:SSEMODEF2P
1899             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0"))
1900            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
1901           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1902          (match_dup 1)
1903          (const_int 1)))]
1904   "TARGET_SSE5 && TARGET_FUSED_MADD
1905    && ix86_sse5_valid_op_p (operands, insn, 4, true, 2, false)"
1906   "fnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1907   [(set_attr "type" "ssemuladd")
1908    (set_attr "mode" "<MODE>")])
1909
1910 ;; The same instructions using an UNSPEC to allow the intrinsic to be used
1911 ;; even if the user used -mno-fused-madd
1912 ;; Parallel instructions.  During instruction generation, just default
1913 ;; to registers, and let combine later build the appropriate instruction.
1914 (define_expand "sse5i_fmadd<mode>4"
1915   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1916         (unspec:SSEMODEF2P
1917          [(plus:SSEMODEF2P
1918            (mult:SSEMODEF2P
1919             (match_operand:SSEMODEF2P 1 "register_operand" "")
1920             (match_operand:SSEMODEF2P 2 "register_operand" ""))
1921            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
1922          UNSPEC_SSE5_INTRINSIC))]
1923   "TARGET_SSE5"
1924 {
1925   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1926   if (TARGET_FUSED_MADD)
1927     {
1928       emit_insn (gen_sse5_fmadd<mode>4 (operands[0], operands[1],
1929                                         operands[2], operands[3]));
1930       DONE;
1931     }
1932 })
1933
1934 (define_insn "*sse5i_fmadd<mode>4"
1935   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
1936         (unspec:SSEMODEF2P
1937          [(plus:SSEMODEF2P
1938            (mult:SSEMODEF2P
1939             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
1940             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
1941            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
1942          UNSPEC_SSE5_INTRINSIC))]
1943   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1944   "fmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1945   [(set_attr "type" "ssemuladd")
1946    (set_attr "mode" "<MODE>")])
1947
1948 (define_expand "sse5i_fmsub<mode>4"
1949   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1950         (unspec:SSEMODEF2P
1951          [(minus:SSEMODEF2P
1952            (mult:SSEMODEF2P
1953             (match_operand:SSEMODEF2P 1 "register_operand" "")
1954             (match_operand:SSEMODEF2P 2 "register_operand" ""))
1955            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
1956          UNSPEC_SSE5_INTRINSIC))]
1957   "TARGET_SSE5"
1958 {
1959   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1960   if (TARGET_FUSED_MADD)
1961     {
1962       emit_insn (gen_sse5_fmsub<mode>4 (operands[0], operands[1],
1963                                         operands[2], operands[3]));
1964       DONE;
1965     }
1966 })
1967
1968 (define_insn "*sse5i_fmsub<mode>4"
1969   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
1970         (unspec:SSEMODEF2P
1971          [(minus:SSEMODEF2P
1972            (mult:SSEMODEF2P
1973             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
1974             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
1975            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
1976          UNSPEC_SSE5_INTRINSIC))]
1977   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
1978   "fmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1979   [(set_attr "type" "ssemuladd")
1980    (set_attr "mode" "<MODE>")])
1981
1982 ;; Rewrite (- (a * b) + c) into the canonical form: c - (a * b)
1983 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
1984 (define_expand "sse5i_fnmadd<mode>4"
1985   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1986         (unspec:SSEMODEF2P
1987          [(minus:SSEMODEF2P
1988            (match_operand:SSEMODEF2P 3 "register_operand" "")
1989            (mult:SSEMODEF2P
1990             (match_operand:SSEMODEF2P 1 "register_operand" "")
1991             (match_operand:SSEMODEF2P 2 "register_operand" "")))]
1992          UNSPEC_SSE5_INTRINSIC))]
1993   "TARGET_SSE5"
1994 {
1995   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
1996   if (TARGET_FUSED_MADD)
1997     {
1998       emit_insn (gen_sse5_fnmadd<mode>4 (operands[0], operands[1],
1999                                          operands[2], operands[3]));
2000       DONE;
2001     }
2002 })
2003
2004 (define_insn "*sse5i_fnmadd<mode>4"
2005   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
2006         (unspec:SSEMODEF2P
2007          [(minus:SSEMODEF2P
2008            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0")
2009            (mult:SSEMODEF2P
2010             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0,x,xm")
2011             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x")))]
2012          UNSPEC_SSE5_INTRINSIC))]
2013   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
2014   "fnmadd<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2015   [(set_attr "type" "ssemuladd")
2016    (set_attr "mode" "<MODE>")])
2017
2018 ;; Rewrite (- (a * b) - c) into the canonical form: ((-a) * b) - c
2019 (define_expand "sse5i_fnmsub<mode>4"
2020   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2021         (unspec:SSEMODEF2P
2022          [(minus:SSEMODEF2P
2023            (mult:SSEMODEF2P
2024             (neg:SSEMODEF2P
2025              (match_operand:SSEMODEF2P 1 "register_operand" ""))
2026             (match_operand:SSEMODEF2P 2 "register_operand" ""))
2027            (match_operand:SSEMODEF2P 3 "register_operand" ""))]
2028          UNSPEC_SSE5_INTRINSIC))]
2029   "TARGET_SSE5"
2030 {
2031   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2032   if (TARGET_FUSED_MADD)
2033     {
2034       emit_insn (gen_sse5_fnmsub<mode>4 (operands[0], operands[1],
2035                                          operands[2], operands[3]));
2036       DONE;
2037     }
2038 })
2039
2040 (define_insn "*sse5i_fnmsub<mode>4"
2041   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
2042         (unspec:SSEMODEF2P
2043          [(minus:SSEMODEF2P
2044            (mult:SSEMODEF2P
2045             (neg:SSEMODEF2P
2046              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0,x,xm"))
2047             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x"))
2048            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x,0,0"))]
2049          UNSPEC_SSE5_INTRINSIC))]
2050   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2051   "fnmsub<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2052   [(set_attr "type" "ssemuladd")
2053    (set_attr "mode" "<MODE>")])
2054
2055 ;; Scalar instructions
2056 (define_expand "sse5i_vmfmadd<mode>4"
2057   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2058         (unspec:SSEMODEF2P
2059          [(vec_merge:SSEMODEF2P
2060            (plus:SSEMODEF2P
2061             (mult:SSEMODEF2P
2062              (match_operand:SSEMODEF2P 1 "register_operand" "")
2063              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2064             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2065            (match_dup 1)
2066            (const_int 0))]
2067          UNSPEC_SSE5_INTRINSIC))]
2068   "TARGET_SSE5"
2069 {
2070   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2071   if (TARGET_FUSED_MADD)
2072     {
2073       emit_insn (gen_sse5_vmfmadd<mode>4 (operands[0], operands[1],
2074                                           operands[2], operands[3]));
2075       DONE;
2076     }
2077 })
2078
2079 ;; For the scalar operations, use operand1 for the upper words that aren't
2080 ;; modified, so restrict the forms that are accepted.
2081 (define_insn "*sse5i_vmfmadd<mode>4"
2082   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2083         (unspec:SSEMODEF2P
2084          [(vec_merge:SSEMODEF2P
2085            (plus:SSEMODEF2P
2086             (mult:SSEMODEF2P
2087              (match_operand:SSEMODEF2P 1 "register_operand" "0,0")
2088              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2089             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2090            (match_dup 0)
2091            (const_int 0))]
2092          UNSPEC_SSE5_INTRINSIC))]
2093   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2094   "fmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2095   [(set_attr "type" "ssemuladd")
2096    (set_attr "mode" "<ssescalarmode>")])
2097
2098 (define_expand "sse5i_vmfmsub<mode>4"
2099   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2100         (unspec:SSEMODEF2P
2101          [(vec_merge:SSEMODEF2P
2102            (minus:SSEMODEF2P
2103             (mult:SSEMODEF2P
2104              (match_operand:SSEMODEF2P 1 "register_operand" "")
2105              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2106             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2107            (match_dup 0)
2108            (const_int 1))]
2109          UNSPEC_SSE5_INTRINSIC))]
2110   "TARGET_SSE5"
2111 {
2112   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2113   if (TARGET_FUSED_MADD)
2114     {
2115       emit_insn (gen_sse5_vmfmsub<mode>4 (operands[0], operands[1],
2116                                           operands[2], operands[3]));
2117       DONE;
2118     }
2119 })
2120
2121 (define_insn "*sse5i_vmfmsub<mode>4"
2122   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2123         (unspec:SSEMODEF2P
2124          [(vec_merge:SSEMODEF2P
2125            (minus:SSEMODEF2P
2126             (mult:SSEMODEF2P
2127              (match_operand:SSEMODEF2P 1 "register_operand" "0,0")
2128              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2129             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2130            (match_dup 1)
2131            (const_int 1))]
2132          UNSPEC_SSE5_INTRINSIC))]
2133   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2134   "fmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2135   [(set_attr "type" "ssemuladd")
2136    (set_attr "mode" "<ssescalarmode>")])
2137
2138 ;; Note operands are out of order to simplify call to ix86_sse5_valid_p
2139 (define_expand "sse5i_vmfnmadd<mode>4"
2140   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2141         (unspec:SSEMODEF2P
2142          [(vec_merge:SSEMODEF2P
2143            (minus:SSEMODEF2P
2144             (match_operand:SSEMODEF2P 3 "register_operand" "")
2145             (mult:SSEMODEF2P
2146              (match_operand:SSEMODEF2P 1 "register_operand" "")
2147              (match_operand:SSEMODEF2P 2 "register_operand" "")))
2148            (match_dup 1)
2149            (const_int 1))]
2150          UNSPEC_SSE5_INTRINSIC))]
2151   "TARGET_SSE5"
2152 {
2153   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2154   if (TARGET_FUSED_MADD)
2155     {
2156       emit_insn (gen_sse5_vmfnmadd<mode>4 (operands[0], operands[1],
2157                                            operands[2], operands[3]));
2158       DONE;
2159     }
2160 })
2161
2162 (define_insn "*sse5i_vmfnmadd<mode>4"
2163   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2164         (unspec:SSEMODEF2P
2165          [(vec_merge:SSEMODEF2P
2166            (minus:SSEMODEF2P
2167             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")
2168             (mult:SSEMODEF2P
2169              (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0,0")
2170              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm")))
2171            (match_dup 1)
2172            (const_int 1))]
2173          UNSPEC_SSE5_INTRINSIC))]
2174   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, true)"
2175   "fnmadd<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2176   [(set_attr "type" "ssemuladd")
2177    (set_attr "mode" "<ssescalarmode>")])
2178
2179 (define_expand "sse5i_vmfnmsub<mode>4"
2180   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
2181         (unspec:SSEMODEF2P
2182          [(vec_merge:SSEMODEF2P
2183            (minus:SSEMODEF2P
2184             (mult:SSEMODEF2P
2185              (neg:SSEMODEF2P
2186               (match_operand:SSEMODEF2P 1 "register_operand" ""))
2187              (match_operand:SSEMODEF2P 2 "register_operand" ""))
2188             (match_operand:SSEMODEF2P 3 "register_operand" ""))
2189            (match_dup 1)
2190            (const_int 1))]
2191          UNSPEC_SSE5_INTRINSIC))]
2192   "TARGET_SSE5"
2193 {
2194   /* If we have -mfused-madd, emit the normal insn rather than the UNSPEC */
2195   if (TARGET_FUSED_MADD)
2196     {
2197       emit_insn (gen_sse5_vmfnmsub<mode>4 (operands[0], operands[1],
2198                                            operands[2], operands[3]));
2199       DONE;
2200     }
2201 })
2202
2203 (define_insn "*sse5i_vmfnmsub<mode>4"
2204   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
2205         (unspec:SSEMODEF2P
2206          [(vec_merge:SSEMODEF2P
2207            (minus:SSEMODEF2P
2208             (mult:SSEMODEF2P
2209              (neg:SSEMODEF2P
2210               (match_operand:SSEMODEF2P 1 "register_operand" "0,0"))
2211              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm"))
2212             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
2213            (match_dup 1)
2214            (const_int 1))]
2215          UNSPEC_SSE5_INTRINSIC))]
2216   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
2217   "fnmsub<ssemodesuffixf2s>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2218   [(set_attr "type" "ssemuladd")
2219    (set_attr "mode" "<ssescalarmode>")])
2220
2221 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2222 ;;
2223 ;; Parallel single-precision floating point conversion operations
2224 ;;
2225 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2226
2227 (define_insn "sse_cvtpi2ps"
2228   [(set (match_operand:V4SF 0 "register_operand" "=x")
2229         (vec_merge:V4SF
2230           (vec_duplicate:V4SF
2231             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2232           (match_operand:V4SF 1 "register_operand" "0")
2233           (const_int 3)))]
2234   "TARGET_SSE"
2235   "cvtpi2ps\t{%2, %0|%0, %2}"
2236   [(set_attr "type" "ssecvt")
2237    (set_attr "mode" "V4SF")])
2238
2239 (define_insn "sse_cvtps2pi"
2240   [(set (match_operand:V2SI 0 "register_operand" "=y")
2241         (vec_select:V2SI
2242           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2243                        UNSPEC_FIX_NOTRUNC)
2244           (parallel [(const_int 0) (const_int 1)])))]
2245   "TARGET_SSE"
2246   "cvtps2pi\t{%1, %0|%0, %1}"
2247   [(set_attr "type" "ssecvt")
2248    (set_attr "unit" "mmx")
2249    (set_attr "mode" "DI")])
2250
2251 (define_insn "sse_cvttps2pi"
2252   [(set (match_operand:V2SI 0 "register_operand" "=y")
2253         (vec_select:V2SI
2254           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2255           (parallel [(const_int 0) (const_int 1)])))]
2256   "TARGET_SSE"
2257   "cvttps2pi\t{%1, %0|%0, %1}"
2258   [(set_attr "type" "ssecvt")
2259    (set_attr "unit" "mmx")
2260    (set_attr "prefix_rep" "0")
2261    (set_attr "mode" "SF")])
2262
2263 (define_insn "*avx_cvtsi2ss"
2264   [(set (match_operand:V4SF 0 "register_operand" "=x")
2265         (vec_merge:V4SF
2266           (vec_duplicate:V4SF
2267             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2268           (match_operand:V4SF 1 "register_operand" "x")
2269           (const_int 1)))]
2270   "TARGET_AVX"
2271   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2272   [(set_attr "type" "sseicvt")
2273    (set_attr "prefix" "vex")
2274    (set_attr "mode" "SF")])
2275
2276 (define_insn "sse_cvtsi2ss"
2277   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2278         (vec_merge:V4SF
2279           (vec_duplicate:V4SF
2280             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2281           (match_operand:V4SF 1 "register_operand" "0,0")
2282           (const_int 1)))]
2283   "TARGET_SSE"
2284   "cvtsi2ss\t{%2, %0|%0, %2}"
2285   [(set_attr "type" "sseicvt")
2286    (set_attr "athlon_decode" "vector,double")
2287    (set_attr "amdfam10_decode" "vector,double")
2288    (set_attr "mode" "SF")])
2289
2290 (define_insn "*avx_cvtsi2ssq"
2291   [(set (match_operand:V4SF 0 "register_operand" "=x")
2292         (vec_merge:V4SF
2293           (vec_duplicate:V4SF
2294             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2295           (match_operand:V4SF 1 "register_operand" "x")
2296           (const_int 1)))]
2297   "TARGET_AVX && TARGET_64BIT"
2298   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2299   [(set_attr "type" "sseicvt")
2300    (set_attr "length_vex" "4")
2301    (set_attr "prefix" "vex")
2302    (set_attr "mode" "SF")])
2303
2304 (define_insn "sse_cvtsi2ssq"
2305   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2306         (vec_merge:V4SF
2307           (vec_duplicate:V4SF
2308             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2309           (match_operand:V4SF 1 "register_operand" "0,0")
2310           (const_int 1)))]
2311   "TARGET_SSE && TARGET_64BIT"
2312   "cvtsi2ssq\t{%2, %0|%0, %2}"
2313   [(set_attr "type" "sseicvt")
2314    (set_attr "prefix_rex" "1")
2315    (set_attr "athlon_decode" "vector,double")
2316    (set_attr "amdfam10_decode" "vector,double")
2317    (set_attr "mode" "SF")])
2318
2319 (define_insn "sse_cvtss2si"
2320   [(set (match_operand:SI 0 "register_operand" "=r,r")
2321         (unspec:SI
2322           [(vec_select:SF
2323              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2324              (parallel [(const_int 0)]))]
2325           UNSPEC_FIX_NOTRUNC))]
2326   "TARGET_SSE"
2327   "%vcvtss2si\t{%1, %0|%0, %1}"
2328   [(set_attr "type" "sseicvt")
2329    (set_attr "athlon_decode" "double,vector")
2330    (set_attr "prefix_rep" "1")
2331    (set_attr "prefix" "maybe_vex")
2332    (set_attr "mode" "SI")])
2333
2334 (define_insn "sse_cvtss2si_2"
2335   [(set (match_operand:SI 0 "register_operand" "=r,r")
2336         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2337                    UNSPEC_FIX_NOTRUNC))]
2338   "TARGET_SSE"
2339   "%vcvtss2si\t{%1, %0|%0, %1}"
2340   [(set_attr "type" "sseicvt")
2341    (set_attr "athlon_decode" "double,vector")
2342    (set_attr "amdfam10_decode" "double,double")
2343    (set_attr "prefix_rep" "1")
2344    (set_attr "prefix" "maybe_vex")
2345    (set_attr "mode" "SI")])
2346
2347 (define_insn "sse_cvtss2siq"
2348   [(set (match_operand:DI 0 "register_operand" "=r,r")
2349         (unspec:DI
2350           [(vec_select:SF
2351              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2352              (parallel [(const_int 0)]))]
2353           UNSPEC_FIX_NOTRUNC))]
2354   "TARGET_SSE && TARGET_64BIT"
2355   "%vcvtss2siq\t{%1, %0|%0, %1}"
2356   [(set_attr "type" "sseicvt")
2357    (set_attr "athlon_decode" "double,vector")
2358    (set_attr "prefix_rep" "1")
2359    (set_attr "prefix" "maybe_vex")
2360    (set_attr "mode" "DI")])
2361
2362 (define_insn "sse_cvtss2siq_2"
2363   [(set (match_operand:DI 0 "register_operand" "=r,r")
2364         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2365                    UNSPEC_FIX_NOTRUNC))]
2366   "TARGET_SSE && TARGET_64BIT"
2367   "%vcvtss2siq\t{%1, %0|%0, %1}"
2368   [(set_attr "type" "sseicvt")
2369    (set_attr "athlon_decode" "double,vector")
2370    (set_attr "amdfam10_decode" "double,double")
2371    (set_attr "prefix_rep" "1")
2372    (set_attr "prefix" "maybe_vex")
2373    (set_attr "mode" "DI")])
2374
2375 (define_insn "sse_cvttss2si"
2376   [(set (match_operand:SI 0 "register_operand" "=r,r")
2377         (fix:SI
2378           (vec_select:SF
2379             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2380             (parallel [(const_int 0)]))))]
2381   "TARGET_SSE"
2382   "%vcvttss2si\t{%1, %0|%0, %1}"
2383   [(set_attr "type" "sseicvt")
2384    (set_attr "athlon_decode" "double,vector")
2385    (set_attr "amdfam10_decode" "double,double")
2386    (set_attr "prefix_rep" "1")
2387    (set_attr "prefix" "maybe_vex")
2388    (set_attr "mode" "SI")])
2389
2390 (define_insn "sse_cvttss2siq"
2391   [(set (match_operand:DI 0 "register_operand" "=r,r")
2392         (fix:DI
2393           (vec_select:SF
2394             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2395             (parallel [(const_int 0)]))))]
2396   "TARGET_SSE && TARGET_64BIT"
2397   "%vcvttss2siq\t{%1, %0|%0, %1}"
2398   [(set_attr "type" "sseicvt")
2399    (set_attr "athlon_decode" "double,vector")
2400    (set_attr "amdfam10_decode" "double,double")
2401    (set_attr "prefix_rep" "1")
2402    (set_attr "prefix" "maybe_vex")
2403    (set_attr "mode" "DI")])
2404
2405 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2406   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2407         (float:AVXMODEDCVTDQ2PS
2408           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2409   "TARGET_AVX"
2410   "vcvtdq2ps\t{%1, %0|%0, %1}"
2411   [(set_attr "type" "ssecvt")
2412    (set_attr "prefix" "vex")
2413    (set_attr "mode" "<avxvecmode>")])
2414
2415 (define_insn "sse2_cvtdq2ps"
2416   [(set (match_operand:V4SF 0 "register_operand" "=x")
2417         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2418   "TARGET_SSE2"
2419   "cvtdq2ps\t{%1, %0|%0, %1}"
2420   [(set_attr "type" "ssecvt")
2421    (set_attr "mode" "V4SF")])
2422
2423 (define_expand "sse2_cvtudq2ps"
2424   [(set (match_dup 5)
2425         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "")))
2426    (set (match_dup 6)
2427         (lt:V4SF (match_dup 5) (match_dup 3)))
2428    (set (match_dup 7)
2429         (and:V4SF (match_dup 6) (match_dup 4)))
2430    (set (match_operand:V4SF 0 "register_operand" "")
2431         (plus:V4SF (match_dup 5) (match_dup 7)))]
2432   "TARGET_SSE2"
2433 {
2434   REAL_VALUE_TYPE TWO32r;
2435   rtx x;
2436   int i;
2437
2438   real_ldexp (&TWO32r, &dconst1, 32);
2439   x = const_double_from_real_value (TWO32r, SFmode);
2440
2441   operands[3] = force_reg (V4SFmode, CONST0_RTX (V4SFmode));
2442   operands[4] = force_reg (V4SFmode, ix86_build_const_vector (SFmode, 1, x));
2443
2444   for (i = 5; i < 8; i++)
2445     operands[i] = gen_reg_rtx (V4SFmode);
2446 })
2447
2448 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2449   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2450         (unspec:AVXMODEDCVTPS2DQ
2451           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2452           UNSPEC_FIX_NOTRUNC))]
2453   "TARGET_AVX"
2454   "vcvtps2dq\t{%1, %0|%0, %1}"
2455   [(set_attr "type" "ssecvt")
2456    (set_attr "prefix" "vex")
2457    (set_attr "mode" "<avxvecmode>")])
2458
2459 (define_insn "sse2_cvtps2dq"
2460   [(set (match_operand:V4SI 0 "register_operand" "=x")
2461         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2462                      UNSPEC_FIX_NOTRUNC))]
2463   "TARGET_SSE2"
2464   "cvtps2dq\t{%1, %0|%0, %1}"
2465   [(set_attr "type" "ssecvt")
2466    (set_attr "prefix_data16" "1")
2467    (set_attr "mode" "TI")])
2468
2469 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2470   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2471         (fix:AVXMODEDCVTPS2DQ
2472           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2473   "TARGET_AVX"
2474   "vcvttps2dq\t{%1, %0|%0, %1}"
2475   [(set_attr "type" "ssecvt")
2476    (set_attr "prefix" "vex")
2477    (set_attr "mode" "<avxvecmode>")])
2478
2479 (define_insn "sse2_cvttps2dq"
2480   [(set (match_operand:V4SI 0 "register_operand" "=x")
2481         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2482   "TARGET_SSE2"
2483   "cvttps2dq\t{%1, %0|%0, %1}"
2484   [(set_attr "type" "ssecvt")
2485    (set_attr "prefix_rep" "1")
2486    (set_attr "prefix_data16" "0")
2487    (set_attr "mode" "TI")])
2488
2489 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2490 ;;
2491 ;; Parallel double-precision floating point conversion operations
2492 ;;
2493 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2494
2495 (define_insn "sse2_cvtpi2pd"
2496   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2497         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2498   "TARGET_SSE2"
2499   "cvtpi2pd\t{%1, %0|%0, %1}"
2500   [(set_attr "type" "ssecvt")
2501    (set_attr "unit" "mmx,*")
2502    (set_attr "prefix_data16" "1,*")
2503    (set_attr "mode" "V2DF")])
2504
2505 (define_insn "sse2_cvtpd2pi"
2506   [(set (match_operand:V2SI 0 "register_operand" "=y")
2507         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2508                      UNSPEC_FIX_NOTRUNC))]
2509   "TARGET_SSE2"
2510   "cvtpd2pi\t{%1, %0|%0, %1}"
2511   [(set_attr "type" "ssecvt")
2512    (set_attr "unit" "mmx")
2513    (set_attr "prefix_data16" "1")
2514    (set_attr "mode" "DI")])
2515
2516 (define_insn "sse2_cvttpd2pi"
2517   [(set (match_operand:V2SI 0 "register_operand" "=y")
2518         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2519   "TARGET_SSE2"
2520   "cvttpd2pi\t{%1, %0|%0, %1}"
2521   [(set_attr "type" "ssecvt")
2522    (set_attr "unit" "mmx")
2523    (set_attr "prefix_data16" "1")
2524    (set_attr "mode" "TI")])
2525
2526 (define_insn "*avx_cvtsi2sd"
2527   [(set (match_operand:V2DF 0 "register_operand" "=x")
2528         (vec_merge:V2DF
2529           (vec_duplicate:V2DF
2530             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2531           (match_operand:V2DF 1 "register_operand" "x")
2532           (const_int 1)))]
2533   "TARGET_AVX"
2534   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2535   [(set_attr "type" "sseicvt")
2536    (set_attr "prefix" "vex")
2537    (set_attr "mode" "DF")])
2538
2539 (define_insn "sse2_cvtsi2sd"
2540   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2541         (vec_merge:V2DF
2542           (vec_duplicate:V2DF
2543             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2544           (match_operand:V2DF 1 "register_operand" "0,0")
2545           (const_int 1)))]
2546   "TARGET_SSE2"
2547   "cvtsi2sd\t{%2, %0|%0, %2}"
2548   [(set_attr "type" "sseicvt")
2549    (set_attr "mode" "DF")
2550    (set_attr "athlon_decode" "double,direct")
2551    (set_attr "amdfam10_decode" "vector,double")])
2552
2553 (define_insn "*avx_cvtsi2sdq"
2554   [(set (match_operand:V2DF 0 "register_operand" "=x")
2555         (vec_merge:V2DF
2556           (vec_duplicate:V2DF
2557             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2558           (match_operand:V2DF 1 "register_operand" "x")
2559           (const_int 1)))]
2560   "TARGET_AVX && TARGET_64BIT"
2561   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2562   [(set_attr "type" "sseicvt")
2563    (set_attr "length_vex" "4")
2564    (set_attr "prefix" "vex")
2565    (set_attr "mode" "DF")])
2566
2567 (define_insn "sse2_cvtsi2sdq"
2568   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2569         (vec_merge:V2DF
2570           (vec_duplicate:V2DF
2571             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2572           (match_operand:V2DF 1 "register_operand" "0,0")
2573           (const_int 1)))]
2574   "TARGET_SSE2 && TARGET_64BIT"
2575   "cvtsi2sdq\t{%2, %0|%0, %2}"
2576   [(set_attr "type" "sseicvt")
2577    (set_attr "prefix_rex" "1")
2578    (set_attr "mode" "DF")
2579    (set_attr "athlon_decode" "double,direct")
2580    (set_attr "amdfam10_decode" "vector,double")])
2581
2582 (define_insn "sse2_cvtsd2si"
2583   [(set (match_operand:SI 0 "register_operand" "=r,r")
2584         (unspec:SI
2585           [(vec_select:DF
2586              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2587              (parallel [(const_int 0)]))]
2588           UNSPEC_FIX_NOTRUNC))]
2589   "TARGET_SSE2"
2590   "%vcvtsd2si\t{%1, %0|%0, %1}"
2591   [(set_attr "type" "sseicvt")
2592    (set_attr "athlon_decode" "double,vector")
2593    (set_attr "prefix_rep" "1")
2594    (set_attr "prefix" "maybe_vex")
2595    (set_attr "mode" "SI")])
2596
2597 (define_insn "sse2_cvtsd2si_2"
2598   [(set (match_operand:SI 0 "register_operand" "=r,r")
2599         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2600                    UNSPEC_FIX_NOTRUNC))]
2601   "TARGET_SSE2"
2602   "%vcvtsd2si\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 "sse2_cvtsd2siq"
2611   [(set (match_operand:DI 0 "register_operand" "=r,r")
2612         (unspec:DI
2613           [(vec_select:DF
2614              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2615              (parallel [(const_int 0)]))]
2616           UNSPEC_FIX_NOTRUNC))]
2617   "TARGET_SSE2 && TARGET_64BIT"
2618   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2619   [(set_attr "type" "sseicvt")
2620    (set_attr "athlon_decode" "double,vector")
2621    (set_attr "prefix_rep" "1")
2622    (set_attr "prefix" "maybe_vex")
2623    (set_attr "mode" "DI")])
2624
2625 (define_insn "sse2_cvtsd2siq_2"
2626   [(set (match_operand:DI 0 "register_operand" "=r,r")
2627         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2628                    UNSPEC_FIX_NOTRUNC))]
2629   "TARGET_SSE2 && TARGET_64BIT"
2630   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2631   [(set_attr "type" "sseicvt")
2632    (set_attr "athlon_decode" "double,vector")
2633    (set_attr "amdfam10_decode" "double,double")
2634    (set_attr "prefix_rep" "1")
2635    (set_attr "prefix" "maybe_vex")
2636    (set_attr "mode" "DI")])
2637
2638 (define_insn "sse2_cvttsd2si"
2639   [(set (match_operand:SI 0 "register_operand" "=r,r")
2640         (fix:SI
2641           (vec_select:DF
2642             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2643             (parallel [(const_int 0)]))))]
2644   "TARGET_SSE2"
2645   "%vcvttsd2si\t{%1, %0|%0, %1}"
2646   [(set_attr "type" "sseicvt")
2647    (set_attr "prefix_rep" "1")
2648    (set_attr "prefix" "maybe_vex")
2649    (set_attr "mode" "SI")
2650    (set_attr "athlon_decode" "double,vector")
2651    (set_attr "amdfam10_decode" "double,double")])
2652
2653 (define_insn "sse2_cvttsd2siq"
2654   [(set (match_operand:DI 0 "register_operand" "=r,r")
2655         (fix:DI
2656           (vec_select:DF
2657             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2658             (parallel [(const_int 0)]))))]
2659   "TARGET_SSE2 && TARGET_64BIT"
2660   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2661   [(set_attr "type" "sseicvt")
2662    (set_attr "prefix_rep" "1")
2663    (set_attr "prefix" "maybe_vex")
2664    (set_attr "mode" "DI")
2665    (set_attr "athlon_decode" "double,vector")
2666    (set_attr "amdfam10_decode" "double,double")])
2667
2668 (define_insn "avx_cvtdq2pd256"
2669   [(set (match_operand:V4DF 0 "register_operand" "=x")
2670         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2671   "TARGET_AVX"
2672   "vcvtdq2pd\t{%1, %0|%0, %1}"
2673   [(set_attr "type" "ssecvt")
2674    (set_attr "prefix" "vex")
2675    (set_attr "mode" "V4DF")])
2676
2677 (define_insn "sse2_cvtdq2pd"
2678   [(set (match_operand:V2DF 0 "register_operand" "=x")
2679         (float:V2DF
2680           (vec_select:V2SI
2681             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2682             (parallel [(const_int 0) (const_int 1)]))))]
2683   "TARGET_SSE2"
2684   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2685   [(set_attr "type" "ssecvt")
2686    (set_attr "prefix" "maybe_vex")
2687    (set_attr "mode" "V2DF")])
2688
2689 (define_insn "avx_cvtpd2dq256"
2690   [(set (match_operand:V4SI 0 "register_operand" "=x")
2691         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2692                      UNSPEC_FIX_NOTRUNC))]
2693   "TARGET_AVX"
2694   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2695   [(set_attr "type" "ssecvt")
2696    (set_attr "prefix" "vex")
2697    (set_attr "mode" "OI")])
2698
2699 (define_expand "sse2_cvtpd2dq"
2700   [(set (match_operand:V4SI 0 "register_operand" "")
2701         (vec_concat:V4SI
2702           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2703                        UNSPEC_FIX_NOTRUNC)
2704           (match_dup 2)))]
2705   "TARGET_SSE2"
2706   "operands[2] = CONST0_RTX (V2SImode);")
2707
2708 (define_insn "*sse2_cvtpd2dq"
2709   [(set (match_operand:V4SI 0 "register_operand" "=x")
2710         (vec_concat:V4SI
2711           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2712                        UNSPEC_FIX_NOTRUNC)
2713           (match_operand:V2SI 2 "const0_operand" "")))]
2714   "TARGET_SSE2"
2715   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2716                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2717   [(set_attr "type" "ssecvt")
2718    (set_attr "prefix_rep" "1")
2719    (set_attr "prefix_data16" "0")
2720    (set_attr "prefix" "maybe_vex")
2721    (set_attr "mode" "TI")
2722    (set_attr "amdfam10_decode" "double")])
2723
2724 (define_insn "avx_cvttpd2dq256"
2725   [(set (match_operand:V4SI 0 "register_operand" "=x")
2726         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2727   "TARGET_AVX"
2728   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2729   [(set_attr "type" "ssecvt")
2730    (set_attr "prefix" "vex")
2731    (set_attr "mode" "OI")])
2732
2733 (define_expand "sse2_cvttpd2dq"
2734   [(set (match_operand:V4SI 0 "register_operand" "")
2735         (vec_concat:V4SI
2736           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2737           (match_dup 2)))]
2738   "TARGET_SSE2"
2739   "operands[2] = CONST0_RTX (V2SImode);")
2740
2741 (define_insn "*sse2_cvttpd2dq"
2742   [(set (match_operand:V4SI 0 "register_operand" "=x")
2743         (vec_concat:V4SI
2744           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2745           (match_operand:V2SI 2 "const0_operand" "")))]
2746   "TARGET_SSE2"
2747   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2748                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2749   [(set_attr "type" "ssecvt")
2750    (set_attr "prefix" "maybe_vex")
2751    (set_attr "mode" "TI")
2752    (set_attr "amdfam10_decode" "double")])
2753
2754 (define_insn "*avx_cvtsd2ss"
2755   [(set (match_operand:V4SF 0 "register_operand" "=x")
2756         (vec_merge:V4SF
2757           (vec_duplicate:V4SF
2758             (float_truncate:V2SF
2759               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2760           (match_operand:V4SF 1 "register_operand" "x")
2761           (const_int 1)))]
2762   "TARGET_AVX"
2763   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2764   [(set_attr "type" "ssecvt")
2765    (set_attr "prefix" "vex")
2766    (set_attr "mode" "SF")])
2767
2768 (define_insn "sse2_cvtsd2ss"
2769   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2770         (vec_merge:V4SF
2771           (vec_duplicate:V4SF
2772             (float_truncate:V2SF
2773               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2774           (match_operand:V4SF 1 "register_operand" "0,0")
2775           (const_int 1)))]
2776   "TARGET_SSE2"
2777   "cvtsd2ss\t{%2, %0|%0, %2}"
2778   [(set_attr "type" "ssecvt")
2779    (set_attr "athlon_decode" "vector,double")
2780    (set_attr "amdfam10_decode" "vector,double")
2781    (set_attr "mode" "SF")])
2782
2783 (define_insn "*avx_cvtss2sd"
2784   [(set (match_operand:V2DF 0 "register_operand" "=x")
2785         (vec_merge:V2DF
2786           (float_extend:V2DF
2787             (vec_select:V2SF
2788               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
2789               (parallel [(const_int 0) (const_int 1)])))
2790           (match_operand:V2DF 1 "register_operand" "x")
2791           (const_int 1)))]
2792   "TARGET_AVX"
2793   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2794   [(set_attr "type" "ssecvt")
2795    (set_attr "prefix" "vex")
2796    (set_attr "mode" "DF")])
2797
2798 (define_insn "sse2_cvtss2sd"
2799   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2800         (vec_merge:V2DF
2801           (float_extend:V2DF
2802             (vec_select:V2SF
2803               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2804               (parallel [(const_int 0) (const_int 1)])))
2805           (match_operand:V2DF 1 "register_operand" "0,0")
2806           (const_int 1)))]
2807   "TARGET_SSE2"
2808   "cvtss2sd\t{%2, %0|%0, %2}"
2809   [(set_attr "type" "ssecvt")
2810    (set_attr "amdfam10_decode" "vector,double")
2811    (set_attr "mode" "DF")])
2812
2813 (define_insn "avx_cvtpd2ps256"
2814   [(set (match_operand:V4SF 0 "register_operand" "=x")
2815         (float_truncate:V4SF
2816           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2817   "TARGET_AVX"
2818   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
2819   [(set_attr "type" "ssecvt")
2820    (set_attr "prefix" "vex")
2821    (set_attr "mode" "V4SF")])
2822
2823 (define_expand "sse2_cvtpd2ps"
2824   [(set (match_operand:V4SF 0 "register_operand" "")
2825         (vec_concat:V4SF
2826           (float_truncate:V2SF
2827             (match_operand:V2DF 1 "nonimmediate_operand" ""))
2828           (match_dup 2)))]
2829   "TARGET_SSE2"
2830   "operands[2] = CONST0_RTX (V2SFmode);")
2831
2832 (define_insn "*sse2_cvtpd2ps"
2833   [(set (match_operand:V4SF 0 "register_operand" "=x")
2834         (vec_concat:V4SF
2835           (float_truncate:V2SF
2836             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2837           (match_operand:V2SF 2 "const0_operand" "")))]
2838   "TARGET_SSE2"
2839   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
2840                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
2841   [(set_attr "type" "ssecvt")
2842    (set_attr "prefix_data16" "1")
2843    (set_attr "prefix" "maybe_vex")
2844    (set_attr "mode" "V4SF")
2845    (set_attr "amdfam10_decode" "double")])
2846
2847 (define_insn "avx_cvtps2pd256"
2848   [(set (match_operand:V4DF 0 "register_operand" "=x")
2849         (float_extend:V4DF
2850           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2851   "TARGET_AVX"
2852   "vcvtps2pd\t{%1, %0|%0, %1}"
2853   [(set_attr "type" "ssecvt")
2854    (set_attr "prefix" "vex")
2855    (set_attr "mode" "V4DF")])
2856
2857 (define_insn "sse2_cvtps2pd"
2858   [(set (match_operand:V2DF 0 "register_operand" "=x")
2859         (float_extend:V2DF
2860           (vec_select:V2SF
2861             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
2862             (parallel [(const_int 0) (const_int 1)]))))]
2863   "TARGET_SSE2"
2864   "%vcvtps2pd\t{%1, %0|%0, %1}"
2865   [(set_attr "type" "ssecvt")
2866    (set_attr "prefix" "maybe_vex")
2867    (set_attr "mode" "V2DF")
2868    (set_attr "prefix_data16" "0")
2869    (set_attr "amdfam10_decode" "direct")])
2870
2871 (define_expand "vec_unpacks_hi_v4sf"
2872   [(set (match_dup 2)
2873    (vec_select:V4SF
2874      (vec_concat:V8SF
2875        (match_dup 2)
2876        (match_operand:V4SF 1 "nonimmediate_operand" ""))
2877      (parallel [(const_int 6)
2878                 (const_int 7)
2879                 (const_int 2)
2880                 (const_int 3)])))
2881   (set (match_operand:V2DF 0 "register_operand" "")
2882    (float_extend:V2DF
2883      (vec_select:V2SF
2884        (match_dup 2)
2885        (parallel [(const_int 0) (const_int 1)]))))]
2886  "TARGET_SSE2"
2887 {
2888  operands[2] = gen_reg_rtx (V4SFmode);
2889 })
2890
2891 (define_expand "vec_unpacks_lo_v4sf"
2892   [(set (match_operand:V2DF 0 "register_operand" "")
2893         (float_extend:V2DF
2894           (vec_select:V2SF
2895             (match_operand:V4SF 1 "nonimmediate_operand" "")
2896             (parallel [(const_int 0) (const_int 1)]))))]
2897   "TARGET_SSE2")
2898
2899 (define_expand "vec_unpacks_float_hi_v8hi"
2900   [(match_operand:V4SF 0 "register_operand" "")
2901    (match_operand:V8HI 1 "register_operand" "")]
2902   "TARGET_SSE2"
2903 {
2904   rtx tmp = gen_reg_rtx (V4SImode);
2905
2906   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
2907   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2908   DONE;
2909 })
2910
2911 (define_expand "vec_unpacks_float_lo_v8hi"
2912   [(match_operand:V4SF 0 "register_operand" "")
2913    (match_operand:V8HI 1 "register_operand" "")]
2914   "TARGET_SSE2"
2915 {
2916   rtx tmp = gen_reg_rtx (V4SImode);
2917
2918   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
2919   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2920   DONE;
2921 })
2922
2923 (define_expand "vec_unpacku_float_hi_v8hi"
2924   [(match_operand:V4SF 0 "register_operand" "")
2925    (match_operand:V8HI 1 "register_operand" "")]
2926   "TARGET_SSE2"
2927 {
2928   rtx tmp = gen_reg_rtx (V4SImode);
2929
2930   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
2931   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2932   DONE;
2933 })
2934
2935 (define_expand "vec_unpacku_float_lo_v8hi"
2936   [(match_operand:V4SF 0 "register_operand" "")
2937    (match_operand:V8HI 1 "register_operand" "")]
2938   "TARGET_SSE2"
2939 {
2940   rtx tmp = gen_reg_rtx (V4SImode);
2941
2942   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
2943   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2944   DONE;
2945 })
2946
2947 (define_expand "vec_unpacks_float_hi_v4si"
2948   [(set (match_dup 2)
2949         (vec_select:V4SI
2950           (match_operand:V4SI 1 "nonimmediate_operand" "")
2951           (parallel [(const_int 2)
2952                      (const_int 3)
2953                      (const_int 2)
2954                      (const_int 3)])))
2955    (set (match_operand:V2DF 0 "register_operand" "")
2956         (float:V2DF
2957           (vec_select:V2SI
2958           (match_dup 2)
2959             (parallel [(const_int 0) (const_int 1)]))))]
2960  "TARGET_SSE2"
2961 {
2962  operands[2] = gen_reg_rtx (V4SImode);
2963 })
2964
2965 (define_expand "vec_unpacks_float_lo_v4si"
2966   [(set (match_operand:V2DF 0 "register_operand" "")
2967         (float:V2DF
2968           (vec_select:V2SI
2969             (match_operand:V4SI 1 "nonimmediate_operand" "")
2970             (parallel [(const_int 0) (const_int 1)]))))]
2971   "TARGET_SSE2")
2972
2973 (define_expand "vec_pack_trunc_v2df"
2974   [(match_operand:V4SF 0 "register_operand" "")
2975    (match_operand:V2DF 1 "nonimmediate_operand" "")
2976    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2977   "TARGET_SSE2"
2978 {
2979   rtx r1, r2;
2980
2981   r1 = gen_reg_rtx (V4SFmode);
2982   r2 = gen_reg_rtx (V4SFmode);
2983
2984   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
2985   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
2986   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
2987   DONE;
2988 })
2989
2990 (define_expand "vec_pack_sfix_trunc_v2df"
2991   [(match_operand:V4SI 0 "register_operand" "")
2992    (match_operand:V2DF 1 "nonimmediate_operand" "")
2993    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2994   "TARGET_SSE2"
2995 {
2996   rtx r1, r2;
2997
2998   r1 = gen_reg_rtx (V4SImode);
2999   r2 = gen_reg_rtx (V4SImode);
3000
3001   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
3002   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
3003   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
3004                                   gen_lowpart (V2DImode, r1),
3005                                   gen_lowpart (V2DImode, r2)));
3006   DONE;
3007 })
3008
3009 (define_expand "vec_pack_sfix_v2df"
3010   [(match_operand:V4SI 0 "register_operand" "")
3011    (match_operand:V2DF 1 "nonimmediate_operand" "")
3012    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3013   "TARGET_SSE2"
3014 {
3015   rtx r1, r2;
3016
3017   r1 = gen_reg_rtx (V4SImode);
3018   r2 = gen_reg_rtx (V4SImode);
3019
3020   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
3021   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
3022   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
3023                                   gen_lowpart (V2DImode, r1),
3024                                   gen_lowpart (V2DImode, r2)));
3025   DONE;
3026 })
3027
3028 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3029 ;;
3030 ;; Parallel single-precision floating point element swizzling
3031 ;;
3032 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3033
3034 (define_expand "sse_movhlps_exp"
3035   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3036         (vec_select:V4SF
3037           (vec_concat:V8SF
3038             (match_operand:V4SF 1 "nonimmediate_operand" "")
3039             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3040           (parallel [(const_int 6)
3041                      (const_int 7)
3042                      (const_int 2)
3043                      (const_int 3)])))]
3044   "TARGET_SSE"
3045   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3046
3047 (define_insn "*avx_movhlps"
3048   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3049         (vec_select:V4SF
3050           (vec_concat:V8SF
3051             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3052             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3053           (parallel [(const_int 6)
3054                      (const_int 7)
3055                      (const_int 2)
3056                      (const_int 3)])))]
3057   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3058   "@
3059    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3060    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3061    vmovhps\t{%2, %0|%0, %2}"
3062   [(set_attr "type" "ssemov")
3063    (set_attr "prefix" "vex")
3064    (set_attr "mode" "V4SF,V2SF,V2SF")])
3065
3066 (define_insn "sse_movhlps"
3067   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3068         (vec_select:V4SF
3069           (vec_concat:V8SF
3070             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3071             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3072           (parallel [(const_int 6)
3073                      (const_int 7)
3074                      (const_int 2)
3075                      (const_int 3)])))]
3076   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3077   "@
3078    movhlps\t{%2, %0|%0, %2}
3079    movlps\t{%H2, %0|%0, %H2}
3080    movhps\t{%2, %0|%0, %2}"
3081   [(set_attr "type" "ssemov")
3082    (set_attr "mode" "V4SF,V2SF,V2SF")])
3083
3084 (define_expand "sse_movlhps_exp"
3085   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3086         (vec_select:V4SF
3087           (vec_concat:V8SF
3088             (match_operand:V4SF 1 "nonimmediate_operand" "")
3089             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3090           (parallel [(const_int 0)
3091                      (const_int 1)
3092                      (const_int 4)
3093                      (const_int 5)])))]
3094   "TARGET_SSE"
3095   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3096
3097 (define_insn "*avx_movlhps"
3098   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3099         (vec_select:V4SF
3100           (vec_concat:V8SF
3101             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3102             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3103           (parallel [(const_int 0)
3104                      (const_int 1)
3105                      (const_int 4)
3106                      (const_int 5)])))]
3107   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3108   "@
3109    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3110    vmovhps\t{%2, %1, %0|%0, %1, %2}
3111    vmovlps\t{%2, %H0|%H0, %2}"
3112   [(set_attr "type" "ssemov")
3113    (set_attr "prefix" "vex")
3114    (set_attr "mode" "V4SF,V2SF,V2SF")])
3115
3116 (define_insn "sse_movlhps"
3117   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3118         (vec_select:V4SF
3119           (vec_concat:V8SF
3120             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3121             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3122           (parallel [(const_int 0)
3123                      (const_int 1)
3124                      (const_int 4)
3125                      (const_int 5)])))]
3126   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3127   "@
3128    movlhps\t{%2, %0|%0, %2}
3129    movhps\t{%2, %0|%0, %2}
3130    movlps\t{%2, %H0|%H0, %2}"
3131   [(set_attr "type" "ssemov")
3132    (set_attr "mode" "V4SF,V2SF,V2SF")])
3133
3134 (define_insn "avx_unpckhps256"
3135   [(set (match_operand:V8SF 0 "register_operand" "=x")
3136         (vec_select:V8SF
3137           (vec_concat:V16SF
3138             (match_operand:V8SF 1 "register_operand" "x")
3139             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3140           (parallel [(const_int 2) (const_int 10)
3141                      (const_int 3) (const_int 11)
3142                      (const_int 6) (const_int 14)
3143                      (const_int 7) (const_int 15)])))]
3144   "TARGET_AVX"
3145   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3146   [(set_attr "type" "sselog")
3147    (set_attr "prefix" "vex")
3148    (set_attr "mode" "V8SF")])
3149
3150 (define_insn "*avx_unpckhps"
3151   [(set (match_operand:V4SF 0 "register_operand" "=x")
3152         (vec_select:V4SF
3153           (vec_concat:V8SF
3154             (match_operand:V4SF 1 "register_operand" "x")
3155             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3156           (parallel [(const_int 2) (const_int 6)
3157                      (const_int 3) (const_int 7)])))]
3158   "TARGET_AVX"
3159   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3160   [(set_attr "type" "sselog")
3161    (set_attr "prefix" "vex")
3162    (set_attr "mode" "V4SF")])
3163
3164 (define_insn "sse_unpckhps"
3165   [(set (match_operand:V4SF 0 "register_operand" "=x")
3166         (vec_select:V4SF
3167           (vec_concat:V8SF
3168             (match_operand:V4SF 1 "register_operand" "0")
3169             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3170           (parallel [(const_int 2) (const_int 6)
3171                      (const_int 3) (const_int 7)])))]
3172   "TARGET_SSE"
3173   "unpckhps\t{%2, %0|%0, %2}"
3174   [(set_attr "type" "sselog")
3175    (set_attr "mode" "V4SF")])
3176
3177 (define_insn "avx_unpcklps256"
3178   [(set (match_operand:V8SF 0 "register_operand" "=x")
3179         (vec_select:V8SF
3180           (vec_concat:V16SF
3181             (match_operand:V8SF 1 "register_operand" "x")
3182             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3183           (parallel [(const_int 0) (const_int 8)
3184                      (const_int 1) (const_int 9)
3185                      (const_int 4) (const_int 12)
3186                      (const_int 5) (const_int 13)])))]
3187   "TARGET_AVX"
3188   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3189   [(set_attr "type" "sselog")
3190    (set_attr "prefix" "vex")
3191    (set_attr "mode" "V8SF")])
3192
3193 (define_insn "*avx_unpcklps"
3194   [(set (match_operand:V4SF 0 "register_operand" "=x")
3195         (vec_select:V4SF
3196           (vec_concat:V8SF
3197             (match_operand:V4SF 1 "register_operand" "x")
3198             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3199           (parallel [(const_int 0) (const_int 4)
3200                      (const_int 1) (const_int 5)])))]
3201   "TARGET_AVX"
3202   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3203   [(set_attr "type" "sselog")
3204    (set_attr "prefix" "vex")
3205    (set_attr "mode" "V4SF")])
3206
3207 (define_insn "sse_unpcklps"
3208   [(set (match_operand:V4SF 0 "register_operand" "=x")
3209         (vec_select:V4SF
3210           (vec_concat:V8SF
3211             (match_operand:V4SF 1 "register_operand" "0")
3212             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3213           (parallel [(const_int 0) (const_int 4)
3214                      (const_int 1) (const_int 5)])))]
3215   "TARGET_SSE"
3216   "unpcklps\t{%2, %0|%0, %2}"
3217   [(set_attr "type" "sselog")
3218    (set_attr "mode" "V4SF")])
3219
3220 ;; These are modeled with the same vec_concat as the others so that we
3221 ;; capture users of shufps that can use the new instructions
3222 (define_insn "avx_movshdup256"
3223   [(set (match_operand:V8SF 0 "register_operand" "=x")
3224         (vec_select:V8SF
3225           (vec_concat:V16SF
3226             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3227             (match_dup 1))
3228           (parallel [(const_int 1) (const_int 1)
3229                      (const_int 3) (const_int 3)
3230                      (const_int 5) (const_int 5)
3231                      (const_int 7) (const_int 7)])))]
3232   "TARGET_AVX"
3233   "vmovshdup\t{%1, %0|%0, %1}"
3234   [(set_attr "type" "sse")
3235    (set_attr "prefix" "vex")
3236    (set_attr "mode" "V8SF")])
3237
3238 (define_insn "sse3_movshdup"
3239   [(set (match_operand:V4SF 0 "register_operand" "=x")
3240         (vec_select:V4SF
3241           (vec_concat:V8SF
3242             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3243             (match_dup 1))
3244           (parallel [(const_int 1)
3245                      (const_int 1)
3246                      (const_int 7)
3247                      (const_int 7)])))]
3248   "TARGET_SSE3"
3249   "%vmovshdup\t{%1, %0|%0, %1}"
3250   [(set_attr "type" "sse")
3251    (set_attr "prefix_rep" "1")
3252    (set_attr "prefix" "maybe_vex")
3253    (set_attr "mode" "V4SF")])
3254
3255 (define_insn "avx_movsldup256"
3256   [(set (match_operand:V8SF 0 "register_operand" "=x")
3257         (vec_select:V8SF
3258           (vec_concat:V16SF
3259             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3260             (match_dup 1))
3261           (parallel [(const_int 0) (const_int 0)
3262                      (const_int 2) (const_int 2)
3263                      (const_int 4) (const_int 4)
3264                      (const_int 6) (const_int 6)])))]
3265   "TARGET_AVX"
3266   "vmovsldup\t{%1, %0|%0, %1}"
3267   [(set_attr "type" "sse")
3268    (set_attr "prefix" "vex")
3269    (set_attr "mode" "V8SF")])
3270
3271 (define_insn "sse3_movsldup"
3272   [(set (match_operand:V4SF 0 "register_operand" "=x")
3273         (vec_select:V4SF
3274           (vec_concat:V8SF
3275             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3276             (match_dup 1))
3277           (parallel [(const_int 0)
3278                      (const_int 0)
3279                      (const_int 6)
3280                      (const_int 6)])))]
3281   "TARGET_SSE3"
3282   "%vmovsldup\t{%1, %0|%0, %1}"
3283   [(set_attr "type" "sse")
3284    (set_attr "prefix_rep" "1")
3285    (set_attr "prefix" "maybe_vex")
3286    (set_attr "mode" "V4SF")])
3287
3288 (define_expand "avx_shufps256"
3289   [(match_operand:V8SF 0 "register_operand" "")
3290    (match_operand:V8SF 1 "register_operand" "")
3291    (match_operand:V8SF 2 "nonimmediate_operand" "")
3292    (match_operand:SI 3 "const_int_operand" "")]
3293   "TARGET_AVX"
3294 {
3295   int mask = INTVAL (operands[3]);
3296   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3297                                   GEN_INT ((mask >> 0) & 3),
3298                                   GEN_INT ((mask >> 2) & 3),
3299                                   GEN_INT (((mask >> 4) & 3) + 8),
3300                                   GEN_INT (((mask >> 6) & 3) + 8),
3301                                   GEN_INT (((mask >> 0) & 3) + 4),
3302                                   GEN_INT (((mask >> 2) & 3) + 4),
3303                                   GEN_INT (((mask >> 4) & 3) + 12),
3304                                   GEN_INT (((mask >> 6) & 3) + 12)));
3305   DONE;
3306 })
3307
3308 ;; One bit in mask selects 2 elements.
3309 (define_insn "avx_shufps256_1"
3310   [(set (match_operand:V8SF 0 "register_operand" "=x")
3311         (vec_select:V8SF
3312           (vec_concat:V16SF
3313             (match_operand:V8SF 1 "register_operand" "x")
3314             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3315           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3316                      (match_operand 4  "const_0_to_3_operand"   "")
3317                      (match_operand 5  "const_8_to_11_operand"  "")
3318                      (match_operand 6  "const_8_to_11_operand"  "")
3319                      (match_operand 7  "const_4_to_7_operand"   "")
3320                      (match_operand 8  "const_4_to_7_operand"   "")
3321                      (match_operand 9  "const_12_to_15_operand" "")
3322                      (match_operand 10 "const_12_to_15_operand" "")])))]
3323   "TARGET_AVX
3324    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3325        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3326        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3327        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3328 {
3329   int mask;
3330   mask = INTVAL (operands[3]);
3331   mask |= INTVAL (operands[4]) << 2;
3332   mask |= (INTVAL (operands[5]) - 8) << 4;
3333   mask |= (INTVAL (operands[6]) - 8) << 6;
3334   operands[3] = GEN_INT (mask);
3335
3336   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3337 }
3338   [(set_attr "type" "sselog")
3339    (set_attr "length_immediate" "1")
3340    (set_attr "prefix" "vex")
3341    (set_attr "mode" "V8SF")])
3342
3343 (define_expand "sse_shufps"
3344   [(match_operand:V4SF 0 "register_operand" "")
3345    (match_operand:V4SF 1 "register_operand" "")
3346    (match_operand:V4SF 2 "nonimmediate_operand" "")
3347    (match_operand:SI 3 "const_int_operand" "")]
3348   "TARGET_SSE"
3349 {
3350   int mask = INTVAL (operands[3]);
3351   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3352                                GEN_INT ((mask >> 0) & 3),
3353                                GEN_INT ((mask >> 2) & 3),
3354                                GEN_INT (((mask >> 4) & 3) + 4),
3355                                GEN_INT (((mask >> 6) & 3) + 4)));
3356   DONE;
3357 })
3358
3359 (define_insn "*avx_shufps_<mode>"
3360   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3361         (vec_select:SSEMODE4S
3362           (vec_concat:<ssedoublesizemode>
3363             (match_operand:SSEMODE4S 1 "register_operand" "x")
3364             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3365           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3366                      (match_operand 4 "const_0_to_3_operand" "")
3367                      (match_operand 5 "const_4_to_7_operand" "")
3368                      (match_operand 6 "const_4_to_7_operand" "")])))]
3369   "TARGET_AVX"
3370 {
3371   int mask = 0;
3372   mask |= INTVAL (operands[3]) << 0;
3373   mask |= INTVAL (operands[4]) << 2;
3374   mask |= (INTVAL (operands[5]) - 4) << 4;
3375   mask |= (INTVAL (operands[6]) - 4) << 6;
3376   operands[3] = GEN_INT (mask);
3377
3378   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3379 }
3380   [(set_attr "type" "sselog")
3381    (set_attr "length_immediate" "1")
3382    (set_attr "prefix" "vex")
3383    (set_attr "mode" "V4SF")])
3384
3385 (define_insn "sse_shufps_<mode>"
3386   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3387         (vec_select:SSEMODE4S
3388           (vec_concat:<ssedoublesizemode>
3389             (match_operand:SSEMODE4S 1 "register_operand" "0")
3390             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3391           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3392                      (match_operand 4 "const_0_to_3_operand" "")
3393                      (match_operand 5 "const_4_to_7_operand" "")
3394                      (match_operand 6 "const_4_to_7_operand" "")])))]
3395   "TARGET_SSE"
3396 {
3397   int mask = 0;
3398   mask |= INTVAL (operands[3]) << 0;
3399   mask |= INTVAL (operands[4]) << 2;
3400   mask |= (INTVAL (operands[5]) - 4) << 4;
3401   mask |= (INTVAL (operands[6]) - 4) << 6;
3402   operands[3] = GEN_INT (mask);
3403
3404   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3405 }
3406   [(set_attr "type" "sselog")
3407    (set_attr "length_immediate" "1")
3408    (set_attr "mode" "V4SF")])
3409
3410 (define_insn "sse_storehps"
3411   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3412         (vec_select:V2SF
3413           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3414           (parallel [(const_int 2) (const_int 3)])))]
3415   "TARGET_SSE"
3416   "@
3417    %vmovhps\t{%1, %0|%0, %1}
3418    %vmovhlps\t{%1, %d0|%d0, %1}
3419    %vmovlps\t{%H1, %d0|%d0, %H1}"
3420   [(set_attr "type" "ssemov")
3421    (set_attr "prefix" "maybe_vex")
3422    (set_attr "mode" "V2SF,V4SF,V2SF")])
3423
3424 (define_expand "sse_loadhps_exp"
3425   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3426         (vec_concat:V4SF
3427           (vec_select:V2SF
3428             (match_operand:V4SF 1 "nonimmediate_operand" "")
3429             (parallel [(const_int 0) (const_int 1)]))
3430           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3431   "TARGET_SSE"
3432   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3433
3434 (define_insn "*avx_loadhps"
3435   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3436         (vec_concat:V4SF
3437           (vec_select:V2SF
3438             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3439             (parallel [(const_int 0) (const_int 1)]))
3440           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3441   "TARGET_AVX"
3442   "@
3443    vmovhps\t{%2, %1, %0|%0, %1, %2}
3444    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3445    vmovlps\t{%2, %H0|%H0, %2}"
3446   [(set_attr "type" "ssemov")
3447    (set_attr "prefix" "vex")
3448    (set_attr "mode" "V2SF,V4SF,V2SF")])
3449
3450 (define_insn "sse_loadhps"
3451   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3452         (vec_concat:V4SF
3453           (vec_select:V2SF
3454             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3455             (parallel [(const_int 0) (const_int 1)]))
3456           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3457   "TARGET_SSE"
3458   "@
3459    movhps\t{%2, %0|%0, %2}
3460    movlhps\t{%2, %0|%0, %2}
3461    movlps\t{%2, %H0|%H0, %2}"
3462   [(set_attr "type" "ssemov")
3463    (set_attr "mode" "V2SF,V4SF,V2SF")])
3464
3465 (define_insn "*avx_storelps"
3466   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3467         (vec_select:V2SF
3468           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3469           (parallel [(const_int 0) (const_int 1)])))]
3470   "TARGET_AVX"
3471   "@
3472    vmovlps\t{%1, %0|%0, %1}
3473    vmovaps\t{%1, %0|%0, %1}
3474    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3475   [(set_attr "type" "ssemov")
3476    (set_attr "prefix" "vex")
3477    (set_attr "mode" "V2SF,V2DF,V2SF")])
3478
3479 (define_insn "sse_storelps"
3480   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3481         (vec_select:V2SF
3482           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3483           (parallel [(const_int 0) (const_int 1)])))]
3484   "TARGET_SSE"
3485   "@
3486    movlps\t{%1, %0|%0, %1}
3487    movaps\t{%1, %0|%0, %1}
3488    movlps\t{%1, %0|%0, %1}"
3489   [(set_attr "type" "ssemov")
3490    (set_attr "mode" "V2SF,V4SF,V2SF")])
3491
3492 (define_expand "sse_loadlps_exp"
3493   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3494         (vec_concat:V4SF
3495           (match_operand:V2SF 2 "nonimmediate_operand" "")
3496           (vec_select:V2SF
3497             (match_operand:V4SF 1 "nonimmediate_operand" "")
3498             (parallel [(const_int 2) (const_int 3)]))))]
3499   "TARGET_SSE"
3500   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3501
3502 (define_insn "*avx_loadlps"
3503   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3504         (vec_concat:V4SF
3505           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3506           (vec_select:V2SF
3507             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3508             (parallel [(const_int 2) (const_int 3)]))))]
3509   "TARGET_AVX"
3510   "@
3511    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3512    vmovlps\t{%2, %1, %0|%0, %1, %2}
3513    vmovlps\t{%2, %0|%0, %2}"
3514   [(set_attr "type" "sselog,ssemov,ssemov")
3515    (set_attr "length_immediate" "1,*,*")
3516    (set_attr "prefix" "vex")
3517    (set_attr "mode" "V4SF,V2SF,V2SF")])
3518
3519 (define_insn "sse_loadlps"
3520   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3521         (vec_concat:V4SF
3522           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3523           (vec_select:V2SF
3524             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3525             (parallel [(const_int 2) (const_int 3)]))))]
3526   "TARGET_SSE"
3527   "@
3528    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3529    movlps\t{%2, %0|%0, %2}
3530    movlps\t{%2, %0|%0, %2}"
3531   [(set_attr "type" "sselog,ssemov,ssemov")
3532    (set_attr "length_immediate" "1,*,*")
3533    (set_attr "mode" "V4SF,V2SF,V2SF")])
3534
3535 (define_insn "*avx_movss"
3536   [(set (match_operand:V4SF 0 "register_operand" "=x")
3537         (vec_merge:V4SF
3538           (match_operand:V4SF 2 "register_operand" "x")
3539           (match_operand:V4SF 1 "register_operand" "x")
3540           (const_int 1)))]
3541   "TARGET_AVX"
3542   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3543   [(set_attr "type" "ssemov")
3544    (set_attr "prefix" "vex")
3545    (set_attr "mode" "SF")])
3546
3547 (define_insn "sse_movss"
3548   [(set (match_operand:V4SF 0 "register_operand" "=x")
3549         (vec_merge:V4SF
3550           (match_operand:V4SF 2 "register_operand" "x")
3551           (match_operand:V4SF 1 "register_operand" "0")
3552           (const_int 1)))]
3553   "TARGET_SSE"
3554   "movss\t{%2, %0|%0, %2}"
3555   [(set_attr "type" "ssemov")
3556    (set_attr "mode" "SF")])
3557
3558 (define_insn "*vec_dupv4sf_avx"
3559   [(set (match_operand:V4SF 0 "register_operand" "=x")
3560         (vec_duplicate:V4SF
3561           (match_operand:SF 1 "register_operand" "x")))]
3562   "TARGET_AVX"
3563   "vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}"
3564   [(set_attr "type" "sselog1")
3565    (set_attr "length_immediate" "1")
3566    (set_attr "prefix" "vex")
3567    (set_attr "mode" "V4SF")])
3568
3569 (define_insn "*vec_dupv4sf"
3570   [(set (match_operand:V4SF 0 "register_operand" "=x")
3571         (vec_duplicate:V4SF
3572           (match_operand:SF 1 "register_operand" "0")))]
3573   "TARGET_SSE"
3574   "shufps\t{$0, %0, %0|%0, %0, 0}"
3575   [(set_attr "type" "sselog1")
3576    (set_attr "length_immediate" "1")
3577    (set_attr "mode" "V4SF")])
3578
3579 (define_insn "*vec_concatv2sf_avx"
3580   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3581         (vec_concat:V2SF
3582           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3583           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3584   "TARGET_AVX"
3585   "@
3586    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3587    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3588    vmovss\t{%1, %0|%0, %1}
3589    punpckldq\t{%2, %0|%0, %2}
3590    movd\t{%1, %0|%0, %1}"
3591   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3592    (set_attr "length_immediate" "*,1,*,*,*")
3593    (set_attr "prefix_extra" "*,1,*,*,*")
3594    (set (attr "prefix")
3595      (if_then_else (eq_attr "alternative" "3,4")
3596        (const_string "orig")
3597        (const_string "vex")))
3598    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3599
3600 ;; Although insertps takes register source, we prefer
3601 ;; unpcklps with register source since it is shorter.
3602 (define_insn "*vec_concatv2sf_sse4_1"
3603   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3604         (vec_concat:V2SF
3605           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3606           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3607   "TARGET_SSE4_1"
3608   "@
3609    unpcklps\t{%2, %0|%0, %2}
3610    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3611    movss\t{%1, %0|%0, %1}
3612    punpckldq\t{%2, %0|%0, %2}
3613    movd\t{%1, %0|%0, %1}"
3614   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3615    (set_attr "prefix_data16" "*,1,*,*,*")
3616    (set_attr "prefix_extra" "*,1,*,*,*")
3617    (set_attr "length_immediate" "*,1,*,*,*")
3618    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3619
3620 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3621 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3622 ;; alternatives pretty much forces the MMX alternative to be chosen.
3623 (define_insn "*vec_concatv2sf_sse"
3624   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3625         (vec_concat:V2SF
3626           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3627           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3628   "TARGET_SSE"
3629   "@
3630    unpcklps\t{%2, %0|%0, %2}
3631    movss\t{%1, %0|%0, %1}
3632    punpckldq\t{%2, %0|%0, %2}
3633    movd\t{%1, %0|%0, %1}"
3634   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3635    (set_attr "mode" "V4SF,SF,DI,DI")])
3636
3637 (define_insn "*vec_concatv4sf_avx"
3638   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3639         (vec_concat:V4SF
3640           (match_operand:V2SF 1 "register_operand" " x,x")
3641           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3642   "TARGET_AVX"
3643   "@
3644    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3645    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3646   [(set_attr "type" "ssemov")
3647    (set_attr "prefix" "vex")
3648    (set_attr "mode" "V4SF,V2SF")])
3649
3650 (define_insn "*vec_concatv4sf_sse"
3651   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3652         (vec_concat:V4SF
3653           (match_operand:V2SF 1 "register_operand" " 0,0")
3654           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3655   "TARGET_SSE"
3656   "@
3657    movlhps\t{%2, %0|%0, %2}
3658    movhps\t{%2, %0|%0, %2}"
3659   [(set_attr "type" "ssemov")
3660    (set_attr "mode" "V4SF,V2SF")])
3661
3662 (define_expand "vec_init<mode>"
3663   [(match_operand:SSEMODE 0 "register_operand" "")
3664    (match_operand 1 "" "")]
3665   "TARGET_SSE"
3666 {
3667   ix86_expand_vector_init (false, operands[0], operands[1]);
3668   DONE;
3669 })
3670
3671 (define_insn "*vec_setv4sf_0_avx"
3672   [(set (match_operand:V4SF 0 "nonimmediate_operand"  "=x,x,x,m")
3673         (vec_merge:V4SF
3674           (vec_duplicate:V4SF
3675             (match_operand:SF 2 "general_operand"     " x,m,*r,x*rfF"))
3676           (match_operand:V4SF 1 "vector_move_operand" " x,C,C ,0")
3677           (const_int 1)))]
3678   "TARGET_AVX"
3679   "@
3680    vmovss\t{%2, %1, %0|%0, %1, %2}
3681    vmovss\t{%2, %0|%0, %2}
3682    vmovd\t{%2, %0|%0, %2}
3683    #"
3684   [(set_attr "type" "ssemov")
3685    (set_attr "prefix" "vex")
3686    (set_attr "mode" "SF")])
3687
3688 (define_insn "vec_setv4sf_0"
3689   [(set (match_operand:V4SF 0 "nonimmediate_operand"  "=x,x,Y2,m")
3690         (vec_merge:V4SF
3691           (vec_duplicate:V4SF
3692             (match_operand:SF 2 "general_operand"     " x,m,*r,x*rfF"))
3693           (match_operand:V4SF 1 "vector_move_operand" " 0,C,C ,0")
3694           (const_int 1)))]
3695   "TARGET_SSE"
3696   "@
3697    movss\t{%2, %0|%0, %2}
3698    movss\t{%2, %0|%0, %2}
3699    movd\t{%2, %0|%0, %2}
3700    #"
3701   [(set_attr "type" "ssemov")
3702    (set_attr "mode" "SF")])
3703
3704 ;; A subset is vec_setv4sf.
3705 (define_insn "*vec_setv4sf_avx"
3706   [(set (match_operand:V4SF 0 "register_operand" "=x")
3707         (vec_merge:V4SF
3708           (vec_duplicate:V4SF
3709             (match_operand:SF 2 "nonimmediate_operand" "xm"))
3710           (match_operand:V4SF 1 "register_operand" "x")
3711           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
3712   "TARGET_AVX"
3713 {
3714   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
3715   return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3716 }
3717   [(set_attr "type" "sselog")
3718    (set_attr "prefix_extra" "1")
3719    (set_attr "length_immediate" "1")
3720    (set_attr "prefix" "vex")
3721    (set_attr "mode" "V4SF")])
3722
3723 (define_insn "*vec_setv4sf_sse4_1"
3724   [(set (match_operand:V4SF 0 "register_operand" "=x")
3725         (vec_merge:V4SF
3726           (vec_duplicate:V4SF
3727             (match_operand:SF 2 "nonimmediate_operand" "xm"))
3728           (match_operand:V4SF 1 "register_operand" "0")
3729           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
3730   "TARGET_SSE4_1"
3731 {
3732   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
3733   return "insertps\t{%3, %2, %0|%0, %2, %3}";
3734 }
3735   [(set_attr "type" "sselog")
3736    (set_attr "prefix_data16" "1")
3737    (set_attr "prefix_extra" "1")
3738    (set_attr "length_immediate" "1")
3739    (set_attr "mode" "V4SF")])
3740
3741 (define_insn "*avx_insertps"
3742   [(set (match_operand:V4SF 0 "register_operand" "=x")
3743         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
3744                       (match_operand:V4SF 1 "register_operand" "x")
3745                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
3746                      UNSPEC_INSERTPS))]
3747   "TARGET_AVX"
3748   "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3749   [(set_attr "type" "sselog")
3750    (set_attr "prefix" "vex")
3751    (set_attr "prefix_extra" "1")
3752    (set_attr "length_immediate" "1")
3753    (set_attr "mode" "V4SF")])
3754
3755 (define_insn "sse4_1_insertps"
3756   [(set (match_operand:V4SF 0 "register_operand" "=x")
3757         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
3758                       (match_operand:V4SF 1 "register_operand" "0")
3759                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
3760                      UNSPEC_INSERTPS))]
3761   "TARGET_SSE4_1"
3762   "insertps\t{%3, %2, %0|%0, %2, %3}";
3763   [(set_attr "type" "sselog")
3764    (set_attr "prefix_data16" "1")
3765    (set_attr "prefix_extra" "1")
3766    (set_attr "length_immediate" "1")
3767    (set_attr "mode" "V4SF")])
3768
3769 (define_split
3770   [(set (match_operand:V4SF 0 "memory_operand" "")
3771         (vec_merge:V4SF
3772           (vec_duplicate:V4SF
3773             (match_operand:SF 1 "nonmemory_operand" ""))
3774           (match_dup 0)
3775           (const_int 1)))]
3776   "TARGET_SSE && reload_completed"
3777   [(const_int 0)]
3778 {
3779   emit_move_insn (adjust_address (operands[0], SFmode, 0), operands[1]);
3780   DONE;
3781 })
3782
3783 (define_expand "vec_set<mode>"
3784   [(match_operand:SSEMODE 0 "register_operand" "")
3785    (match_operand:<ssescalarmode> 1 "register_operand" "")
3786    (match_operand 2 "const_int_operand" "")]
3787   "TARGET_SSE"
3788 {
3789   ix86_expand_vector_set (false, operands[0], operands[1],
3790                           INTVAL (operands[2]));
3791   DONE;
3792 })
3793
3794 (define_insn_and_split "*vec_extractv4sf_0"
3795   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
3796         (vec_select:SF
3797           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
3798           (parallel [(const_int 0)])))]
3799   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3800   "#"
3801   "&& reload_completed"
3802   [(const_int 0)]
3803 {
3804   rtx op1 = operands[1];
3805   if (REG_P (op1))
3806     op1 = gen_rtx_REG (SFmode, REGNO (op1));
3807   else
3808     op1 = gen_lowpart (SFmode, op1);
3809   emit_move_insn (operands[0], op1);
3810   DONE;
3811 })
3812
3813 (define_expand "avx_vextractf128<mode>"
3814   [(match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "")
3815    (match_operand:AVX256MODE 1 "register_operand" "")
3816    (match_operand:SI 2 "const_0_to_1_operand" "")]
3817   "TARGET_AVX"
3818 {
3819   switch (INTVAL (operands[2]))
3820     {
3821     case 0:
3822       emit_insn (gen_vec_extract_lo_<mode> (operands[0], operands[1]));
3823       break;
3824     case 1:
3825       emit_insn (gen_vec_extract_hi_<mode> (operands[0], operands[1]));
3826       break;
3827     default:
3828       gcc_unreachable ();
3829     }
3830   DONE;
3831 })
3832
3833 (define_insn "vec_extract_lo_<mode>"
3834   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3835         (vec_select:<avxhalfvecmode>
3836           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
3837           (parallel [(const_int 0) (const_int 1)])))]
3838   "TARGET_AVX"
3839   "vextractf128\t{$0x0, %1, %0|%0, %1, 0x0}"
3840   [(set_attr "type" "sselog")
3841    (set_attr "prefix_extra" "1")
3842    (set_attr "length_immediate" "1")
3843    (set_attr "memory" "none,store")
3844    (set_attr "prefix" "vex")
3845    (set_attr "mode" "V8SF")])
3846
3847 (define_insn "vec_extract_hi_<mode>"
3848   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3849         (vec_select:<avxhalfvecmode>
3850           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
3851           (parallel [(const_int 2) (const_int 3)])))]
3852   "TARGET_AVX"
3853   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3854   [(set_attr "type" "sselog")
3855    (set_attr "prefix_extra" "1")
3856    (set_attr "length_immediate" "1")
3857    (set_attr "memory" "none,store")
3858    (set_attr "prefix" "vex")
3859    (set_attr "mode" "V8SF")])
3860
3861 (define_insn "vec_extract_lo_<mode>"
3862   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3863         (vec_select:<avxhalfvecmode>
3864           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
3865           (parallel [(const_int 0) (const_int 1)
3866                      (const_int 2) (const_int 3)])))]
3867   "TARGET_AVX"
3868   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3869   [(set_attr "type" "sselog")
3870    (set_attr "prefix_extra" "1")
3871    (set_attr "length_immediate" "1")
3872    (set_attr "memory" "none,store")
3873    (set_attr "prefix" "vex")
3874    (set_attr "mode" "V8SF")])
3875
3876 (define_insn "vec_extract_hi_<mode>"
3877   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
3878         (vec_select:<avxhalfvecmode>
3879           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
3880           (parallel [(const_int 4) (const_int 5)
3881                      (const_int 6) (const_int 7)])))]
3882   "TARGET_AVX"
3883   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3884   [(set_attr "type" "sselog")
3885    (set_attr "prefix_extra" "1")
3886    (set_attr "length_immediate" "1")
3887    (set_attr "memory" "none,store")
3888    (set_attr "prefix" "vex")
3889    (set_attr "mode" "V8SF")])
3890
3891 (define_insn "vec_extract_lo_v16hi"
3892   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
3893         (vec_select:V8HI
3894           (match_operand:V16HI 1 "register_operand" "x,x")
3895           (parallel [(const_int 0) (const_int 1)
3896                      (const_int 2) (const_int 3)
3897                      (const_int 4) (const_int 5)
3898                      (const_int 6) (const_int 7)])))]
3899   "TARGET_AVX"
3900   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3901   [(set_attr "type" "sselog")
3902    (set_attr "prefix_extra" "1")
3903    (set_attr "length_immediate" "1")
3904    (set_attr "memory" "none,store")
3905    (set_attr "prefix" "vex")
3906    (set_attr "mode" "V8SF")])
3907
3908 (define_insn "vec_extract_hi_v16hi"
3909   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
3910         (vec_select:V8HI
3911           (match_operand:V16HI 1 "register_operand" "x,x")
3912           (parallel [(const_int 8) (const_int 9)
3913                      (const_int 10) (const_int 11)
3914                      (const_int 12) (const_int 13)
3915                      (const_int 14) (const_int 15)])))]
3916   "TARGET_AVX"
3917   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3918   [(set_attr "type" "sselog")
3919    (set_attr "prefix_extra" "1")
3920    (set_attr "length_immediate" "1")
3921    (set_attr "memory" "none,store")
3922    (set_attr "prefix" "vex")
3923    (set_attr "mode" "V8SF")])
3924
3925 (define_insn "vec_extract_lo_v32qi"
3926   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
3927         (vec_select:V16QI
3928           (match_operand:V32QI 1 "register_operand" "x,x")
3929           (parallel [(const_int 0) (const_int 1)
3930                      (const_int 2) (const_int 3)
3931                      (const_int 4) (const_int 5)
3932                      (const_int 6) (const_int 7)
3933                      (const_int 8) (const_int 9)
3934                      (const_int 10) (const_int 11)
3935                      (const_int 12) (const_int 13)
3936                      (const_int 14) (const_int 15)])))]
3937   "TARGET_AVX"
3938   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3939   [(set_attr "type" "sselog")
3940    (set_attr "prefix_extra" "1")
3941    (set_attr "length_immediate" "1")
3942    (set_attr "memory" "none,store")
3943    (set_attr "prefix" "vex")
3944    (set_attr "mode" "V8SF")])
3945
3946 (define_insn "vec_extract_hi_v32qi"
3947   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
3948         (vec_select:V16QI
3949           (match_operand:V32QI 1 "register_operand" "x,x")
3950           (parallel [(const_int 16) (const_int 17)
3951                      (const_int 18) (const_int 19)
3952                      (const_int 20) (const_int 21)
3953                      (const_int 22) (const_int 23)
3954                      (const_int 24) (const_int 25)
3955                      (const_int 26) (const_int 27)
3956                      (const_int 28) (const_int 29)
3957                      (const_int 30) (const_int 31)])))]
3958   "TARGET_AVX"
3959   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
3960   [(set_attr "type" "sselog")
3961    (set_attr "prefix_extra" "1")
3962    (set_attr "length_immediate" "1")
3963    (set_attr "memory" "none,store")
3964    (set_attr "prefix" "vex")
3965    (set_attr "mode" "V8SF")])
3966
3967 (define_insn "*sse4_1_extractps"
3968   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
3969         (vec_select:SF
3970           (match_operand:V4SF 1 "register_operand" "x")
3971           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
3972   "TARGET_SSE4_1"
3973   "%vextractps\t{%2, %1, %0|%0, %1, %2}"
3974   [(set_attr "type" "sselog")
3975    (set_attr "prefix_data16" "1")
3976    (set_attr "prefix_extra" "1")
3977    (set_attr "length_immediate" "1")
3978    (set_attr "prefix" "maybe_vex")
3979    (set_attr "mode" "V4SF")])
3980
3981 (define_insn_and_split "*vec_extract_v4sf_mem"
3982   [(set (match_operand:SF 0 "register_operand" "=x*rf")
3983        (vec_select:SF
3984          (match_operand:V4SF 1 "memory_operand" "o")
3985          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
3986   ""
3987   "#"
3988   "reload_completed"
3989   [(const_int 0)]
3990 {
3991   int i = INTVAL (operands[2]);
3992
3993   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
3994   DONE;
3995 })
3996
3997 (define_expand "vec_extract<mode>"
3998   [(match_operand:<ssescalarmode> 0 "register_operand" "")
3999    (match_operand:SSEMODE 1 "register_operand" "")
4000    (match_operand 2 "const_int_operand" "")]
4001   "TARGET_SSE"
4002 {
4003   ix86_expand_vector_extract (false, operands[0], operands[1],
4004                               INTVAL (operands[2]));
4005   DONE;
4006 })
4007
4008 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4009 ;;
4010 ;; Parallel double-precision floating point element swizzling
4011 ;;
4012 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4013
4014 (define_insn "avx_unpckhpd256"
4015   [(set (match_operand:V4DF 0 "register_operand" "=x")
4016         (vec_select:V4DF
4017           (vec_concat:V8DF
4018             (match_operand:V4DF 1 "register_operand" "x")
4019             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4020           (parallel [(const_int 1) (const_int 5)
4021                      (const_int 3) (const_int 7)])))]
4022   "TARGET_AVX"
4023   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
4024   [(set_attr "type" "sselog")
4025    (set_attr "prefix" "vex")
4026    (set_attr "mode" "V4DF")])
4027
4028 (define_expand "sse2_unpckhpd_exp"
4029   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4030         (vec_select:V2DF
4031           (vec_concat:V4DF
4032             (match_operand:V2DF 1 "nonimmediate_operand" "")
4033             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4034           (parallel [(const_int 1)
4035                      (const_int 3)])))]
4036   "TARGET_SSE2"
4037   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4038
4039 (define_insn "*avx_unpckhpd"
4040   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
4041         (vec_select:V2DF
4042           (vec_concat:V4DF
4043             (match_operand:V2DF 1 "nonimmediate_operand" " x,o,x")
4044             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,0"))
4045           (parallel [(const_int 1)
4046                      (const_int 3)])))]
4047   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4048   "@
4049    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
4050    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
4051    vmovhpd\t{%1, %0|%0, %1}"
4052   [(set_attr "type" "sselog,ssemov,ssemov")
4053    (set_attr "prefix" "vex")
4054    (set_attr "mode" "V2DF,V1DF,V1DF")])
4055
4056 (define_insn "sse2_unpckhpd"
4057   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
4058         (vec_select:V2DF
4059           (vec_concat:V4DF
4060             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
4061             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
4062           (parallel [(const_int 1)
4063                      (const_int 3)])))]
4064   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4065   "@
4066    unpckhpd\t{%2, %0|%0, %2}
4067    movlpd\t{%H1, %0|%0, %H1}
4068    movhpd\t{%1, %0|%0, %1}"
4069   [(set_attr "type" "sselog,ssemov,ssemov")
4070    (set_attr "prefix_data16" "*,1,1")
4071    (set_attr "mode" "V2DF,V1DF,V1DF")])
4072
4073 (define_insn "avx_movddup256"
4074   [(set (match_operand:V4DF 0 "register_operand" "=x")
4075         (vec_select:V4DF
4076           (vec_concat:V8DF
4077             (match_operand:V4DF 1 "nonimmediate_operand" "xm")
4078             (match_dup 1))
4079           (parallel [(const_int 0) (const_int 2)
4080                      (const_int 4) (const_int 6)])))]
4081   "TARGET_AVX"
4082   "vmovddup\t{%1, %0|%0, %1}"
4083   [(set_attr "type" "sselog1")
4084    (set_attr "prefix" "vex")
4085    (set_attr "mode" "V4DF")])
4086
4087 (define_insn "*avx_movddup"
4088   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,o")
4089         (vec_select:V2DF
4090           (vec_concat:V4DF
4091             (match_operand:V2DF 1 "nonimmediate_operand" "xm,x")
4092             (match_dup 1))
4093           (parallel [(const_int 0)
4094                      (const_int 2)])))]
4095   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4096   "@
4097    vmovddup\t{%1, %0|%0, %1}
4098    #"
4099   [(set_attr "type" "sselog1,ssemov")
4100    (set_attr "prefix" "vex")
4101    (set_attr "mode" "V2DF")])
4102
4103 (define_insn "*sse3_movddup"
4104   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,o")
4105         (vec_select:V2DF
4106           (vec_concat:V4DF
4107             (match_operand:V2DF 1 "nonimmediate_operand" "xm,x")
4108             (match_dup 1))
4109           (parallel [(const_int 0)
4110                      (const_int 2)])))]
4111   "TARGET_SSE3 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4112   "@
4113    movddup\t{%1, %0|%0, %1}
4114    #"
4115   [(set_attr "type" "sselog1,ssemov")
4116    (set_attr "mode" "V2DF")])
4117
4118 (define_split
4119   [(set (match_operand:V2DF 0 "memory_operand" "")
4120         (vec_select:V2DF
4121           (vec_concat:V4DF
4122             (match_operand:V2DF 1 "register_operand" "")
4123             (match_dup 1))
4124           (parallel [(const_int 0)
4125                      (const_int 2)])))]
4126   "TARGET_SSE3 && reload_completed"
4127   [(const_int 0)]
4128 {
4129   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4130   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4131   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4132   DONE;
4133 })
4134
4135 (define_insn "avx_unpcklpd256"
4136   [(set (match_operand:V4DF 0 "register_operand" "=x")
4137         (vec_select:V4DF
4138           (vec_concat:V8DF
4139             (match_operand:V4DF 1 "register_operand" "x")
4140             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4141           (parallel [(const_int 0) (const_int 4)
4142                      (const_int 2) (const_int 6)])))]
4143   "TARGET_AVX"
4144   "vunpcklpd\t{%2, %1, %0|%0, %1, %2}"
4145   [(set_attr "type" "sselog")
4146    (set_attr "prefix" "vex")
4147    (set_attr "mode" "V4DF")])
4148
4149 (define_expand "sse2_unpcklpd_exp"
4150   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4151         (vec_select:V2DF
4152           (vec_concat:V4DF
4153             (match_operand:V2DF 1 "nonimmediate_operand" "")
4154             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4155           (parallel [(const_int 0)
4156                      (const_int 2)])))]
4157   "TARGET_SSE2"
4158   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4159
4160 (define_insn "*avx_unpcklpd"
4161   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4162         (vec_select:V2DF
4163           (vec_concat:V4DF
4164             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0")
4165             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4166           (parallel [(const_int 0)
4167                      (const_int 2)])))]
4168   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4169   "@
4170    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4171    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4172    vmovlpd\t{%2, %H0|%H0, %2}"
4173   [(set_attr "type" "sselog,ssemov,ssemov")
4174    (set_attr "prefix" "vex")
4175    (set_attr "mode" "V2DF,V1DF,V1DF")])
4176
4177 (define_insn "sse2_unpcklpd"
4178   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4179         (vec_select:V2DF
4180           (vec_concat:V4DF
4181             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
4182             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4183           (parallel [(const_int 0)
4184                      (const_int 2)])))]
4185   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4186   "@
4187    unpcklpd\t{%2, %0|%0, %2}
4188    movhpd\t{%2, %0|%0, %2}
4189    movlpd\t{%2, %H0|%H0, %2}"
4190   [(set_attr "type" "sselog,ssemov,ssemov")
4191    (set_attr "prefix_data16" "*,1,1")
4192    (set_attr "mode" "V2DF,V1DF,V1DF")])
4193
4194 (define_expand "avx_shufpd256"
4195   [(match_operand:V4DF 0 "register_operand" "")
4196    (match_operand:V4DF 1 "register_operand" "")
4197    (match_operand:V4DF 2 "nonimmediate_operand" "")
4198    (match_operand:SI 3 "const_int_operand" "")]
4199   "TARGET_AVX"
4200 {
4201   int mask = INTVAL (operands[3]);
4202   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4203                                    GEN_INT (mask & 1),
4204                                    GEN_INT (mask & 2 ? 5 : 4),
4205                                    GEN_INT (mask & 4 ? 3 : 2),
4206                                    GEN_INT (mask & 8 ? 7 : 6)));
4207   DONE;
4208 })
4209
4210 (define_insn "avx_shufpd256_1"
4211   [(set (match_operand:V4DF 0 "register_operand" "=x")
4212         (vec_select:V4DF
4213           (vec_concat:V8DF
4214             (match_operand:V4DF 1 "register_operand" "x")
4215             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4216           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4217                      (match_operand 4 "const_4_to_5_operand" "")
4218                      (match_operand 5 "const_2_to_3_operand" "")
4219                      (match_operand 6 "const_6_to_7_operand" "")])))]
4220   "TARGET_AVX"
4221 {
4222   int mask;
4223   mask = INTVAL (operands[3]);
4224   mask |= (INTVAL (operands[4]) - 4) << 1;
4225   mask |= (INTVAL (operands[5]) - 2) << 2;
4226   mask |= (INTVAL (operands[6]) - 6) << 3;
4227   operands[3] = GEN_INT (mask);
4228
4229   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4230 }
4231   [(set_attr "type" "sselog")
4232    (set_attr "length_immediate" "1")
4233    (set_attr "prefix" "vex")
4234    (set_attr "mode" "V4DF")])
4235
4236 (define_expand "sse2_shufpd"
4237   [(match_operand:V2DF 0 "register_operand" "")
4238    (match_operand:V2DF 1 "register_operand" "")
4239    (match_operand:V2DF 2 "nonimmediate_operand" "")
4240    (match_operand:SI 3 "const_int_operand" "")]
4241   "TARGET_SSE2"
4242 {
4243   int mask = INTVAL (operands[3]);
4244   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4245                                 GEN_INT (mask & 1),
4246                                 GEN_INT (mask & 2 ? 3 : 2)));
4247   DONE;
4248 })
4249
4250 (define_expand "vec_extract_even<mode>"
4251   [(set (match_operand:SSEMODE4S 0 "register_operand" "")
4252         (vec_select:SSEMODE4S
4253           (vec_concat:<ssedoublesizemode>
4254             (match_operand:SSEMODE4S 1 "register_operand" "")
4255             (match_operand:SSEMODE4S 2 "nonimmediate_operand" ""))
4256           (parallel [(const_int 0)
4257                      (const_int 2)
4258                      (const_int 4)
4259                      (const_int 6)])))]
4260   "TARGET_SSE")
4261
4262 (define_expand "vec_extract_odd<mode>"
4263   [(set (match_operand:SSEMODE4S 0 "register_operand" "")
4264         (vec_select:SSEMODE4S
4265           (vec_concat:<ssedoublesizemode>
4266             (match_operand:SSEMODE4S 1 "register_operand" "")
4267             (match_operand:SSEMODE4S 2 "nonimmediate_operand" ""))
4268           (parallel [(const_int 1)
4269                      (const_int 3)
4270                      (const_int 5)
4271                      (const_int 7)])))]
4272   "TARGET_SSE")
4273
4274 (define_expand "vec_extract_even<mode>"
4275   [(set (match_operand:SSEMODE2D 0 "register_operand" "")
4276         (vec_select:SSEMODE2D
4277           (vec_concat:<ssedoublesizemode>
4278             (match_operand:SSEMODE2D 1 "register_operand" "")
4279             (match_operand:SSEMODE2D 2 "nonimmediate_operand" ""))
4280           (parallel [(const_int 0)
4281                      (const_int 2)])))]
4282   "TARGET_SSE2")
4283
4284 (define_expand "vec_extract_odd<mode>"
4285   [(set (match_operand:SSEMODE2D 0 "register_operand" "")
4286         (vec_select:SSEMODE2D
4287           (vec_concat:<ssedoublesizemode>
4288             (match_operand:SSEMODE2D 1 "register_operand" "")
4289             (match_operand:SSEMODE2D 2 "nonimmediate_operand" ""))
4290           (parallel [(const_int 1)
4291                      (const_int 3)])))]
4292   "TARGET_SSE2")
4293
4294 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4295 (define_insn "*avx_punpckhqdq"
4296   [(set (match_operand:V2DI 0 "register_operand" "=x")
4297         (vec_select:V2DI
4298           (vec_concat:V4DI
4299             (match_operand:V2DI 1 "register_operand" "x")
4300             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4301           (parallel [(const_int 1)
4302                      (const_int 3)])))]
4303   "TARGET_AVX"
4304   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4305   [(set_attr "type" "sselog")
4306    (set_attr "prefix" "vex")
4307    (set_attr "mode" "TI")])
4308
4309 (define_insn "sse2_punpckhqdq"
4310   [(set (match_operand:V2DI 0 "register_operand" "=x")
4311         (vec_select:V2DI
4312           (vec_concat:V4DI
4313             (match_operand:V2DI 1 "register_operand" "0")
4314             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4315           (parallel [(const_int 1)
4316                      (const_int 3)])))]
4317   "TARGET_SSE2"
4318   "punpckhqdq\t{%2, %0|%0, %2}"
4319   [(set_attr "type" "sselog")
4320    (set_attr "prefix_data16" "1")
4321    (set_attr "mode" "TI")])
4322
4323 (define_insn "*avx_punpcklqdq"
4324   [(set (match_operand:V2DI 0 "register_operand" "=x")
4325         (vec_select:V2DI
4326           (vec_concat:V4DI
4327             (match_operand:V2DI 1 "register_operand" "x")
4328             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4329           (parallel [(const_int 0)
4330                      (const_int 2)])))]
4331   "TARGET_AVX"
4332   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4333   [(set_attr "type" "sselog")
4334    (set_attr "prefix" "vex")
4335    (set_attr "mode" "TI")])
4336
4337 (define_insn "sse2_punpcklqdq"
4338   [(set (match_operand:V2DI 0 "register_operand" "=x")
4339         (vec_select:V2DI
4340           (vec_concat:V4DI
4341             (match_operand:V2DI 1 "register_operand" "0")
4342             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4343           (parallel [(const_int 0)
4344                      (const_int 2)])))]
4345   "TARGET_SSE2"
4346   "punpcklqdq\t{%2, %0|%0, %2}"
4347   [(set_attr "type" "sselog")
4348    (set_attr "prefix_data16" "1")
4349    (set_attr "mode" "TI")])
4350
4351 (define_insn "*avx_shufpd_<mode>"
4352   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4353         (vec_select:SSEMODE2D
4354           (vec_concat:<ssedoublesizemode>
4355             (match_operand:SSEMODE2D 1 "register_operand" "x")
4356             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4357           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4358                      (match_operand 4 "const_2_to_3_operand" "")])))]
4359   "TARGET_AVX"
4360 {
4361   int mask;
4362   mask = INTVAL (operands[3]);
4363   mask |= (INTVAL (operands[4]) - 2) << 1;
4364   operands[3] = GEN_INT (mask);
4365
4366   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4367 }
4368   [(set_attr "type" "sselog")
4369    (set_attr "length_immediate" "1")
4370    (set_attr "prefix" "vex")
4371    (set_attr "mode" "V2DF")])
4372
4373 (define_insn "sse2_shufpd_<mode>"
4374   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4375         (vec_select:SSEMODE2D
4376           (vec_concat:<ssedoublesizemode>
4377             (match_operand:SSEMODE2D 1 "register_operand" "0")
4378             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4379           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4380                      (match_operand 4 "const_2_to_3_operand" "")])))]
4381   "TARGET_SSE2"
4382 {
4383   int mask;
4384   mask = INTVAL (operands[3]);
4385   mask |= (INTVAL (operands[4]) - 2) << 1;
4386   operands[3] = GEN_INT (mask);
4387
4388   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4389 }
4390   [(set_attr "type" "sselog")
4391    (set_attr "length_immediate" "1")
4392    (set_attr "mode" "V2DF")])
4393
4394 ;; Avoid combining registers from different units in a single alternative,
4395 ;; see comment above inline_secondary_memory_needed function in i386.c
4396 (define_insn "*avx_storehpd"
4397   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4398         (vec_select:DF
4399           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,o,o,o")
4400           (parallel [(const_int 1)])))]
4401   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4402   "@
4403    vmovhpd\t{%1, %0|%0, %1}
4404    vunpckhpd\t{%1, %1, %0|%0, %1, %1}
4405    #
4406    #
4407    #"
4408   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4409    (set_attr "prefix" "vex")
4410    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4411
4412 (define_insn "sse2_storehpd"
4413   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4414         (vec_select:DF
4415           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o,o,o")
4416           (parallel [(const_int 1)])))]
4417   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4418   "@
4419    movhpd\t{%1, %0|%0, %1}
4420    unpckhpd\t%0, %0
4421    #
4422    #
4423    #"
4424   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4425    (set_attr "prefix_data16" "1,*,*,*,*")
4426    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4427
4428 (define_split
4429   [(set (match_operand:DF 0 "register_operand" "")
4430         (vec_select:DF
4431           (match_operand:V2DF 1 "memory_operand" "")
4432           (parallel [(const_int 1)])))]
4433   "TARGET_SSE2 && reload_completed"
4434   [(set (match_dup 0) (match_dup 1))]
4435 {
4436   operands[1] = adjust_address (operands[1], DFmode, 8);
4437 })
4438
4439 ;; Avoid combining registers from different units in a single alternative,
4440 ;; see comment above inline_secondary_memory_needed function in i386.c
4441 (define_insn "sse2_storelpd"
4442   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4443         (vec_select:DF
4444           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4445           (parallel [(const_int 0)])))]
4446   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4447   "@
4448    %vmovlpd\t{%1, %0|%0, %1}
4449    #
4450    #
4451    #
4452    #"
4453   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4454    (set_attr "prefix_data16" "1,*,*,*,*")
4455    (set_attr "prefix" "maybe_vex")
4456    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4457
4458 (define_split
4459   [(set (match_operand:DF 0 "register_operand" "")
4460         (vec_select:DF
4461           (match_operand:V2DF 1 "nonimmediate_operand" "")
4462           (parallel [(const_int 0)])))]
4463   "TARGET_SSE2 && reload_completed"
4464   [(const_int 0)]
4465 {
4466   rtx op1 = operands[1];
4467   if (REG_P (op1))
4468     op1 = gen_rtx_REG (DFmode, REGNO (op1));
4469   else
4470     op1 = gen_lowpart (DFmode, op1);
4471   emit_move_insn (operands[0], op1);
4472   DONE;
4473 })
4474
4475 (define_expand "sse2_loadhpd_exp"
4476   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4477         (vec_concat:V2DF
4478           (vec_select:DF
4479             (match_operand:V2DF 1 "nonimmediate_operand" "")
4480             (parallel [(const_int 0)]))
4481           (match_operand:DF 2 "nonimmediate_operand" "")))]
4482   "TARGET_SSE2"
4483   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4484
4485 ;; Avoid combining registers from different units in a single alternative,
4486 ;; see comment above inline_secondary_memory_needed function in i386.c
4487 (define_insn "*avx_loadhpd"
4488   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o,o,o")
4489         (vec_concat:V2DF
4490           (vec_select:DF
4491             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,0,0")
4492             (parallel [(const_int 0)]))
4493           (match_operand:DF 2 "nonimmediate_operand"     " m,x,x,*f,r")))]
4494   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4495   "@
4496    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4497    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4498    #
4499    #
4500    #"
4501   [(set_attr "type" "ssemov,sselog,ssemov,fmov,imov")
4502    (set_attr "prefix" "vex")
4503    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4504
4505 (define_insn "sse2_loadhpd"
4506   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
4507         (vec_concat:V2DF
4508           (vec_select:DF
4509             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0,0,0")
4510             (parallel [(const_int 0)]))
4511           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x,*f,r")))]
4512   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4513   "@
4514    movhpd\t{%2, %0|%0, %2}
4515    unpcklpd\t{%2, %0|%0, %2}
4516    shufpd\t{$1, %1, %0|%0, %1, 1}
4517    #
4518    #
4519    #"
4520   [(set_attr "type" "ssemov,sselog,sselog,ssemov,fmov,imov")
4521    (set_attr "prefix_data16" "1,*,*,*,*,*")
4522    (set_attr "length_immediate" "*,*,1,*,*,*")
4523    (set_attr "mode" "V1DF,V2DF,V2DF,DF,DF,DF")])
4524
4525 (define_split
4526   [(set (match_operand:V2DF 0 "memory_operand" "")
4527         (vec_concat:V2DF
4528           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
4529           (match_operand:DF 1 "register_operand" "")))]
4530   "TARGET_SSE2 && reload_completed"
4531   [(set (match_dup 0) (match_dup 1))]
4532 {
4533   operands[0] = adjust_address (operands[0], DFmode, 8);
4534 })
4535
4536 (define_expand "sse2_loadlpd_exp"
4537   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4538         (vec_concat:V2DF
4539           (match_operand:DF 2 "nonimmediate_operand" "")
4540           (vec_select:DF
4541             (match_operand:V2DF 1 "nonimmediate_operand" "")
4542             (parallel [(const_int 1)]))))]
4543   "TARGET_SSE2"
4544   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4545
4546 ;; Avoid combining registers from different units in a single alternative,
4547 ;; see comment above inline_secondary_memory_needed function in i386.c
4548 (define_insn "*avx_loadlpd"
4549   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,m,m,m")
4550         (vec_concat:V2DF
4551           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,x,x,*f,r")
4552           (vec_select:DF
4553             (match_operand:V2DF 1 "vector_move_operand" " C,x,x,o,0,0,0")
4554             (parallel [(const_int 1)]))))]
4555   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4556   "@
4557    vmovsd\t{%2, %0|%0, %2}
4558    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4559    vmovsd\t{%2, %1, %0|%0, %1, %2}
4560    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
4561    #
4562    #
4563    #"
4564   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov,fmov,imov")
4565    (set_attr "prefix" "vex")
4566    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
4567
4568 (define_insn "sse2_loadlpd"
4569   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
4570         (vec_concat:V2DF
4571           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x,*f,r")
4572           (vec_select:DF
4573             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0,0,0")
4574             (parallel [(const_int 1)]))))]
4575   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4576   "@
4577    movsd\t{%2, %0|%0, %2}
4578    movlpd\t{%2, %0|%0, %2}
4579    movsd\t{%2, %0|%0, %2}
4580    shufpd\t{$2, %2, %0|%0, %2, 2}
4581    movhpd\t{%H1, %0|%0, %H1}
4582    #
4583    #
4584    #"
4585   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,fmov,imov")
4586    (set_attr "prefix_data16" "*,1,*,*,1,*,*,*")
4587    (set_attr "length_immediate" "*,*,*,1,*,*,*,*")
4588    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF,DF,DF")])
4589
4590 (define_split
4591   [(set (match_operand:V2DF 0 "memory_operand" "")
4592         (vec_concat:V2DF
4593           (match_operand:DF 1 "register_operand" "")
4594           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
4595   "TARGET_SSE2 && reload_completed"
4596   [(set (match_dup 0) (match_dup 1))]
4597 {
4598   operands[0] = adjust_address (operands[0], DFmode, 8);
4599 })
4600
4601 ;; Not sure these two are ever used, but it doesn't hurt to have
4602 ;; them. -aoliva
4603 (define_insn "*vec_extractv2df_1_sse"
4604   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4605         (vec_select:DF
4606           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4607           (parallel [(const_int 1)])))]
4608   "!TARGET_SSE2 && TARGET_SSE
4609    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4610   "@
4611    movhps\t{%1, %0|%0, %1}
4612    movhlps\t{%1, %0|%0, %1}
4613    movlps\t{%H1, %0|%0, %H1}"
4614   [(set_attr "type" "ssemov")
4615    (set_attr "mode" "V2SF,V4SF,V2SF")])
4616
4617 (define_insn "*vec_extractv2df_0_sse"
4618   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4619         (vec_select:DF
4620           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
4621           (parallel [(const_int 0)])))]
4622   "!TARGET_SSE2 && TARGET_SSE
4623    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4624   "@
4625    movlps\t{%1, %0|%0, %1}
4626    movaps\t{%1, %0|%0, %1}
4627    movlps\t{%1, %0|%0, %1}"
4628   [(set_attr "type" "ssemov")
4629    (set_attr "mode" "V2SF,V4SF,V2SF")])
4630
4631 (define_insn "*avx_movsd"
4632   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,o")
4633         (vec_merge:V2DF
4634           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,x,0")
4635           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,o,x")
4636           (const_int 1)))]
4637   "TARGET_AVX"
4638   "@
4639    vmovsd\t{%2, %1, %0|%0, %1, %2}
4640    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4641    vmovlpd\t{%2, %0|%0, %2}
4642    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
4643    vmovhps\t{%1, %H0|%H0, %1}"
4644   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov")
4645    (set_attr "prefix" "vex")
4646    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF")])
4647
4648 (define_insn "sse2_movsd"
4649   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
4650         (vec_merge:V2DF
4651           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
4652           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
4653           (const_int 1)))]
4654   "TARGET_SSE2"
4655   "@
4656    movsd\t{%2, %0|%0, %2}
4657    movlpd\t{%2, %0|%0, %2}
4658    movlpd\t{%2, %0|%0, %2}
4659    shufpd\t{$2, %2, %0|%0, %2, 2}
4660    movhps\t{%H1, %0|%0, %H1}
4661    movhps\t{%1, %H0|%H0, %1}"
4662   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
4663    (set_attr "prefix_data16" "*,1,1,*,*,*")
4664    (set_attr "length_immediate" "*,*,*,1,*,*")
4665    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
4666
4667 (define_insn "*vec_dupv2df_sse3"
4668   [(set (match_operand:V2DF 0 "register_operand" "=x")
4669         (vec_duplicate:V2DF
4670           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
4671   "TARGET_SSE3"
4672   "%vmovddup\t{%1, %0|%0, %1}"
4673   [(set_attr "type" "sselog1")
4674    (set_attr "prefix" "maybe_vex")
4675    (set_attr "mode" "DF")])
4676
4677 (define_insn "vec_dupv2df"
4678   [(set (match_operand:V2DF 0 "register_operand" "=x")
4679         (vec_duplicate:V2DF
4680           (match_operand:DF 1 "register_operand" "0")))]
4681   "TARGET_SSE2"
4682   "unpcklpd\t%0, %0"
4683   [(set_attr "type" "sselog1")
4684    (set_attr "mode" "V2DF")])
4685
4686 (define_insn "*vec_concatv2df_sse3"
4687   [(set (match_operand:V2DF 0 "register_operand" "=x")
4688         (vec_concat:V2DF
4689           (match_operand:DF 1 "nonimmediate_operand" "xm")
4690           (match_dup 1)))]
4691   "TARGET_SSE3"
4692   "%vmovddup\t{%1, %0|%0, %1}"
4693   [(set_attr "type" "sselog1")
4694    (set_attr "prefix" "maybe_vex")
4695    (set_attr "mode" "DF")])
4696
4697 (define_insn "*vec_concatv2df_avx"
4698   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x")
4699         (vec_concat:V2DF
4700           (match_operand:DF 1 "nonimmediate_operand" " x,x,m")
4701           (match_operand:DF 2 "vector_move_operand"  " x,m,C")))]
4702   "TARGET_AVX"
4703   "@
4704    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4705    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4706    vmovsd\t{%1, %0|%0, %1}"
4707   [(set_attr "type" "ssemov")
4708    (set_attr "prefix" "vex")
4709    (set_attr "mode" "DF,V1DF,DF")])
4710
4711 (define_insn "*vec_concatv2df"
4712   [(set (match_operand:V2DF 0 "register_operand"     "=Y2,Y2,Y2,x,x")
4713         (vec_concat:V2DF
4714           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
4715           (match_operand:DF 2 "vector_move_operand"  " Y2,m ,C ,x,m")))]
4716   "TARGET_SSE"
4717   "@
4718    unpcklpd\t{%2, %0|%0, %2}
4719    movhpd\t{%2, %0|%0, %2}
4720    movsd\t{%1, %0|%0, %1}
4721    movlhps\t{%2, %0|%0, %2}
4722    movhps\t{%2, %0|%0, %2}"
4723   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
4724    (set_attr "prefix_data16" "*,1,*,*,*")
4725    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
4726
4727 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4728 ;;
4729 ;; Parallel integral arithmetic
4730 ;;
4731 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4732
4733 (define_expand "neg<mode>2"
4734   [(set (match_operand:SSEMODEI 0 "register_operand" "")
4735         (minus:SSEMODEI
4736           (match_dup 2)
4737           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
4738   "TARGET_SSE2"
4739   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
4740
4741 (define_expand "<plusminus_insn><mode>3"
4742   [(set (match_operand:SSEMODEI 0 "register_operand" "")
4743         (plusminus:SSEMODEI
4744           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
4745           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
4746   "TARGET_SSE2"
4747   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
4748
4749 (define_insn "*avx_<plusminus_insn><mode>3"
4750   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
4751         (plusminus:SSEMODEI
4752           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>x")
4753           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
4754   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4755   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
4756   [(set_attr "type" "sseiadd")
4757    (set_attr "prefix" "vex")
4758    (set_attr "mode" "TI")])
4759
4760 (define_insn "*<plusminus_insn><mode>3"
4761   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
4762         (plusminus:SSEMODEI
4763           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>0")
4764           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
4765   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4766   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
4767   [(set_attr "type" "sseiadd")
4768    (set_attr "prefix_data16" "1")
4769    (set_attr "mode" "TI")])
4770
4771 (define_expand "sse2_<plusminus_insn><mode>3"
4772   [(set (match_operand:SSEMODE12 0 "register_operand" "")
4773         (sat_plusminus:SSEMODE12
4774           (match_operand:SSEMODE12 1 "nonimmediate_operand" "")
4775           (match_operand:SSEMODE12 2 "nonimmediate_operand" "")))]
4776   "TARGET_SSE2"
4777   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
4778
4779 (define_insn "*avx_<plusminus_insn><mode>3"
4780   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
4781         (sat_plusminus:SSEMODE12
4782           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>x")
4783           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
4784   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4785   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
4786   [(set_attr "type" "sseiadd")
4787    (set_attr "prefix" "vex")
4788    (set_attr "mode" "TI")])
4789
4790 (define_insn "*sse2_<plusminus_insn><mode>3"
4791   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
4792         (sat_plusminus:SSEMODE12
4793           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>0")
4794           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
4795   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4796   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
4797   [(set_attr "type" "sseiadd")
4798    (set_attr "prefix_data16" "1")
4799    (set_attr "mode" "TI")])
4800
4801 (define_insn_and_split "mulv16qi3"
4802   [(set (match_operand:V16QI 0 "register_operand" "")
4803         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
4804                     (match_operand:V16QI 2 "register_operand" "")))]
4805   "TARGET_SSE2
4806    && can_create_pseudo_p ()"
4807   "#"
4808   "&& 1"
4809   [(const_int 0)]
4810 {
4811   rtx t[12], op0, op[3];
4812   int i;
4813
4814   if (TARGET_SSE5)
4815     {
4816       /* On SSE5, we can take advantage of the pperm instruction to pack and
4817          unpack the bytes.  Unpack data such that we've got a source byte in
4818          each low byte of each word.  We don't care what goes into the high
4819          byte, so put 0 there.  */
4820       for (i = 0; i < 6; ++i)
4821         t[i] = gen_reg_rtx (V8HImode);
4822
4823       for (i = 0; i < 2; i++)
4824         {
4825           op[0] = t[i];
4826           op[1] = operands[i+1];
4827           ix86_expand_sse5_unpack (op, true, true);             /* high bytes */
4828
4829           op[0] = t[i+2];
4830           ix86_expand_sse5_unpack (op, true, false);            /* low bytes */
4831         }
4832
4833       /* Multiply words.  */
4834       emit_insn (gen_mulv8hi3 (t[4], t[0], t[1]));              /* high bytes */
4835       emit_insn (gen_mulv8hi3 (t[5], t[2], t[3]));              /* low  bytes */
4836
4837       /* Pack the low byte of each word back into a single xmm */
4838       op[0] = operands[0];
4839       op[1] = t[5];
4840       op[2] = t[4];
4841       ix86_expand_sse5_pack (op);
4842       DONE;
4843     }
4844
4845   for (i = 0; i < 12; ++i)
4846     t[i] = gen_reg_rtx (V16QImode);
4847
4848   /* Unpack data such that we've got a source byte in each low byte of
4849      each word.  We don't care what goes into the high byte of each word.
4850      Rather than trying to get zero in there, most convenient is to let
4851      it be a copy of the low byte.  */
4852   emit_insn (gen_sse2_punpckhbw (t[0], operands[1], operands[1]));
4853   emit_insn (gen_sse2_punpckhbw (t[1], operands[2], operands[2]));
4854   emit_insn (gen_sse2_punpcklbw (t[2], operands[1], operands[1]));
4855   emit_insn (gen_sse2_punpcklbw (t[3], operands[2], operands[2]));
4856
4857   /* Multiply words.  The end-of-line annotations here give a picture of what
4858      the output of that instruction looks like.  Dot means don't care; the
4859      letters are the bytes of the result with A being the most significant.  */
4860   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
4861                            gen_lowpart (V8HImode, t[0]),
4862                            gen_lowpart (V8HImode, t[1])));
4863   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
4864                            gen_lowpart (V8HImode, t[2]),
4865                            gen_lowpart (V8HImode, t[3])));
4866
4867   /* Extract the relevant bytes and merge them back together.  */
4868   emit_insn (gen_sse2_punpckhbw (t[6], t[5], t[4]));    /* ..AI..BJ..CK..DL */
4869   emit_insn (gen_sse2_punpcklbw (t[7], t[5], t[4]));    /* ..EM..FN..GO..HP */
4870   emit_insn (gen_sse2_punpckhbw (t[8], t[7], t[6]));    /* ....AEIM....BFJN */
4871   emit_insn (gen_sse2_punpcklbw (t[9], t[7], t[6]));    /* ....CGKO....DHLP */
4872   emit_insn (gen_sse2_punpckhbw (t[10], t[9], t[8]));   /* ........ACEGIKMO */
4873   emit_insn (gen_sse2_punpcklbw (t[11], t[9], t[8]));   /* ........BDFHJLNP */
4874
4875   op0 = operands[0];
4876   emit_insn (gen_sse2_punpcklbw (op0, t[11], t[10]));   /* ABCDEFGHIJKLMNOP */
4877   DONE;
4878 })
4879
4880 (define_expand "mulv8hi3"
4881   [(set (match_operand:V8HI 0 "register_operand" "")
4882         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
4883                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
4884   "TARGET_SSE2"
4885   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4886
4887 (define_insn "*avx_mulv8hi3"
4888   [(set (match_operand:V8HI 0 "register_operand" "=x")
4889         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
4890                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
4891   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4892   "vpmullw\t{%2, %1, %0|%0, %1, %2}"
4893   [(set_attr "type" "sseimul")
4894    (set_attr "prefix" "vex")
4895    (set_attr "mode" "TI")])
4896
4897 (define_insn "*mulv8hi3"
4898   [(set (match_operand:V8HI 0 "register_operand" "=x")
4899         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
4900                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
4901   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4902   "pmullw\t{%2, %0|%0, %2}"
4903   [(set_attr "type" "sseimul")
4904    (set_attr "prefix_data16" "1")
4905    (set_attr "mode" "TI")])
4906
4907 (define_expand "smulv8hi3_highpart"
4908   [(set (match_operand:V8HI 0 "register_operand" "")
4909         (truncate:V8HI
4910           (lshiftrt:V8SI
4911             (mult:V8SI
4912               (sign_extend:V8SI
4913                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
4914               (sign_extend:V8SI
4915                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
4916             (const_int 16))))]
4917   "TARGET_SSE2"
4918   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4919
4920 (define_insn "*avxv8hi3_highpart"
4921   [(set (match_operand:V8HI 0 "register_operand" "=x")
4922         (truncate:V8HI
4923           (lshiftrt:V8SI
4924             (mult:V8SI
4925               (sign_extend:V8SI
4926                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
4927               (sign_extend:V8SI
4928                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4929             (const_int 16))))]
4930   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4931   "vpmulhw\t{%2, %1, %0|%0, %1, %2}"
4932   [(set_attr "type" "sseimul")
4933    (set_attr "prefix" "vex")
4934    (set_attr "mode" "TI")])
4935
4936 (define_insn "*smulv8hi3_highpart"
4937   [(set (match_operand:V8HI 0 "register_operand" "=x")
4938         (truncate:V8HI
4939           (lshiftrt:V8SI
4940             (mult:V8SI
4941               (sign_extend:V8SI
4942                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
4943               (sign_extend:V8SI
4944                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4945             (const_int 16))))]
4946   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4947   "pmulhw\t{%2, %0|%0, %2}"
4948   [(set_attr "type" "sseimul")
4949    (set_attr "prefix_data16" "1")
4950    (set_attr "mode" "TI")])
4951
4952 (define_expand "umulv8hi3_highpart"
4953   [(set (match_operand:V8HI 0 "register_operand" "")
4954         (truncate:V8HI
4955           (lshiftrt:V8SI
4956             (mult:V8SI
4957               (zero_extend:V8SI
4958                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
4959               (zero_extend:V8SI
4960                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
4961             (const_int 16))))]
4962   "TARGET_SSE2"
4963   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
4964
4965 (define_insn "*avx_umulv8hi3_highpart"
4966   [(set (match_operand:V8HI 0 "register_operand" "=x")
4967         (truncate:V8HI
4968           (lshiftrt:V8SI
4969             (mult:V8SI
4970               (zero_extend:V8SI
4971                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
4972               (zero_extend:V8SI
4973                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4974             (const_int 16))))]
4975   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4976   "vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
4977   [(set_attr "type" "sseimul")
4978    (set_attr "prefix" "vex")
4979    (set_attr "mode" "TI")])
4980
4981 (define_insn "*umulv8hi3_highpart"
4982   [(set (match_operand:V8HI 0 "register_operand" "=x")
4983         (truncate:V8HI
4984           (lshiftrt:V8SI
4985             (mult:V8SI
4986               (zero_extend:V8SI
4987                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
4988               (zero_extend:V8SI
4989                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
4990             (const_int 16))))]
4991   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
4992   "pmulhuw\t{%2, %0|%0, %2}"
4993   [(set_attr "type" "sseimul")
4994    (set_attr "prefix_data16" "1")
4995    (set_attr "mode" "TI")])
4996
4997 (define_expand "sse2_umulv2siv2di3"
4998   [(set (match_operand:V2DI 0 "register_operand" "")
4999         (mult:V2DI
5000           (zero_extend:V2DI
5001             (vec_select:V2SI
5002               (match_operand:V4SI 1 "nonimmediate_operand" "")
5003               (parallel [(const_int 0) (const_int 2)])))
5004           (zero_extend:V2DI
5005             (vec_select:V2SI
5006               (match_operand:V4SI 2 "nonimmediate_operand" "")
5007               (parallel [(const_int 0) (const_int 2)])))))]
5008   "TARGET_SSE2"
5009   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5010
5011 (define_insn "*avx_umulv2siv2di3"
5012   [(set (match_operand:V2DI 0 "register_operand" "=x")
5013         (mult:V2DI
5014           (zero_extend:V2DI
5015             (vec_select:V2SI
5016               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5017               (parallel [(const_int 0) (const_int 2)])))
5018           (zero_extend:V2DI
5019             (vec_select:V2SI
5020               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5021               (parallel [(const_int 0) (const_int 2)])))))]
5022   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5023   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5024   [(set_attr "type" "sseimul")
5025    (set_attr "prefix" "vex")
5026    (set_attr "mode" "TI")])
5027
5028 (define_insn "*sse2_umulv2siv2di3"
5029   [(set (match_operand:V2DI 0 "register_operand" "=x")
5030         (mult:V2DI
5031           (zero_extend:V2DI
5032             (vec_select:V2SI
5033               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5034               (parallel [(const_int 0) (const_int 2)])))
5035           (zero_extend:V2DI
5036             (vec_select:V2SI
5037               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5038               (parallel [(const_int 0) (const_int 2)])))))]
5039   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5040   "pmuludq\t{%2, %0|%0, %2}"
5041   [(set_attr "type" "sseimul")
5042    (set_attr "prefix_data16" "1")
5043    (set_attr "mode" "TI")])
5044
5045 (define_expand "sse4_1_mulv2siv2di3"
5046   [(set (match_operand:V2DI 0 "register_operand" "")
5047         (mult:V2DI
5048           (sign_extend:V2DI
5049             (vec_select:V2SI
5050               (match_operand:V4SI 1 "nonimmediate_operand" "")
5051               (parallel [(const_int 0) (const_int 2)])))
5052           (sign_extend:V2DI
5053             (vec_select:V2SI
5054               (match_operand:V4SI 2 "nonimmediate_operand" "")
5055               (parallel [(const_int 0) (const_int 2)])))))]
5056   "TARGET_SSE4_1"
5057   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5058
5059 (define_insn "*avx_mulv2siv2di3"
5060   [(set (match_operand:V2DI 0 "register_operand" "=x")
5061         (mult:V2DI
5062           (sign_extend:V2DI
5063             (vec_select:V2SI
5064               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5065               (parallel [(const_int 0) (const_int 2)])))
5066           (sign_extend:V2DI
5067             (vec_select:V2SI
5068               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5069               (parallel [(const_int 0) (const_int 2)])))))]
5070   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5071   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5072   [(set_attr "type" "sseimul")
5073    (set_attr "prefix_extra" "1")
5074    (set_attr "prefix" "vex")
5075    (set_attr "mode" "TI")])
5076
5077 (define_insn "*sse4_1_mulv2siv2di3"
5078   [(set (match_operand:V2DI 0 "register_operand" "=x")
5079         (mult:V2DI
5080           (sign_extend:V2DI
5081             (vec_select:V2SI
5082               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5083               (parallel [(const_int 0) (const_int 2)])))
5084           (sign_extend:V2DI
5085             (vec_select:V2SI
5086               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5087               (parallel [(const_int 0) (const_int 2)])))))]
5088   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5089   "pmuldq\t{%2, %0|%0, %2}"
5090   [(set_attr "type" "sseimul")
5091    (set_attr "prefix_extra" "1")
5092    (set_attr "mode" "TI")])
5093
5094 (define_expand "sse2_pmaddwd"
5095   [(set (match_operand:V4SI 0 "register_operand" "")
5096         (plus:V4SI
5097           (mult:V4SI
5098             (sign_extend:V4SI
5099               (vec_select:V4HI
5100                 (match_operand:V8HI 1 "nonimmediate_operand" "")
5101                 (parallel [(const_int 0)
5102                            (const_int 2)
5103                            (const_int 4)
5104                            (const_int 6)])))
5105             (sign_extend:V4SI
5106               (vec_select:V4HI
5107                 (match_operand:V8HI 2 "nonimmediate_operand" "")
5108                 (parallel [(const_int 0)
5109                            (const_int 2)
5110                            (const_int 4)
5111                            (const_int 6)]))))
5112           (mult:V4SI
5113             (sign_extend:V4SI
5114               (vec_select:V4HI (match_dup 1)
5115                 (parallel [(const_int 1)
5116                            (const_int 3)
5117                            (const_int 5)
5118                            (const_int 7)])))
5119             (sign_extend:V4SI
5120               (vec_select:V4HI (match_dup 2)
5121                 (parallel [(const_int 1)
5122                            (const_int 3)
5123                            (const_int 5)
5124                            (const_int 7)]))))))]
5125   "TARGET_SSE2"
5126   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5127
5128 (define_insn "*avx_pmaddwd"
5129   [(set (match_operand:V4SI 0 "register_operand" "=x")
5130         (plus:V4SI
5131           (mult:V4SI
5132             (sign_extend:V4SI
5133               (vec_select:V4HI
5134                 (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5135                 (parallel [(const_int 0)
5136                            (const_int 2)
5137                            (const_int 4)
5138                            (const_int 6)])))
5139             (sign_extend:V4SI
5140               (vec_select:V4HI
5141                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5142                 (parallel [(const_int 0)
5143                            (const_int 2)
5144                            (const_int 4)
5145                            (const_int 6)]))))
5146           (mult:V4SI
5147             (sign_extend:V4SI
5148               (vec_select:V4HI (match_dup 1)
5149                 (parallel [(const_int 1)
5150                            (const_int 3)
5151                            (const_int 5)
5152                            (const_int 7)])))
5153             (sign_extend:V4SI
5154               (vec_select:V4HI (match_dup 2)
5155                 (parallel [(const_int 1)
5156                            (const_int 3)
5157                            (const_int 5)
5158                            (const_int 7)]))))))]
5159   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5160   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5161   [(set_attr "type" "sseiadd")
5162    (set_attr "prefix" "vex")
5163    (set_attr "mode" "TI")])
5164
5165 (define_insn "*sse2_pmaddwd"
5166   [(set (match_operand:V4SI 0 "register_operand" "=x")
5167         (plus:V4SI
5168           (mult:V4SI
5169             (sign_extend:V4SI
5170               (vec_select:V4HI
5171                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5172                 (parallel [(const_int 0)
5173                            (const_int 2)
5174                            (const_int 4)
5175                            (const_int 6)])))
5176             (sign_extend:V4SI
5177               (vec_select:V4HI
5178                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5179                 (parallel [(const_int 0)
5180                            (const_int 2)
5181                            (const_int 4)
5182                            (const_int 6)]))))
5183           (mult:V4SI
5184             (sign_extend:V4SI
5185               (vec_select:V4HI (match_dup 1)
5186                 (parallel [(const_int 1)
5187                            (const_int 3)
5188                            (const_int 5)
5189                            (const_int 7)])))
5190             (sign_extend:V4SI
5191               (vec_select:V4HI (match_dup 2)
5192                 (parallel [(const_int 1)
5193                            (const_int 3)
5194                            (const_int 5)
5195                            (const_int 7)]))))))]
5196   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5197   "pmaddwd\t{%2, %0|%0, %2}"
5198   [(set_attr "type" "sseiadd")
5199    (set_attr "atom_unit" "simul")
5200    (set_attr "prefix_data16" "1")
5201    (set_attr "mode" "TI")])
5202
5203 (define_expand "mulv4si3"
5204   [(set (match_operand:V4SI 0 "register_operand" "")
5205         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5206                    (match_operand:V4SI 2 "register_operand" "")))]
5207   "TARGET_SSE2"
5208 {
5209   if (TARGET_SSE4_1 || TARGET_SSE5)
5210     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
5211 })
5212
5213 (define_insn "*avx_mulv4si3"
5214   [(set (match_operand:V4SI 0 "register_operand" "=x")
5215         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5216                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5217   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5218   "vpmulld\t{%2, %1, %0|%0, %1, %2}"
5219   [(set_attr "type" "sseimul")
5220    (set_attr "prefix_extra" "1")
5221    (set_attr "prefix" "vex")
5222    (set_attr "mode" "TI")])
5223
5224 (define_insn "*sse4_1_mulv4si3"
5225   [(set (match_operand:V4SI 0 "register_operand" "=x")
5226         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5227                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5228   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5229   "pmulld\t{%2, %0|%0, %2}"
5230   [(set_attr "type" "sseimul")
5231    (set_attr "prefix_extra" "1")
5232    (set_attr "mode" "TI")])
5233
5234 ;; We don't have a straight 32-bit parallel multiply on SSE5, so fake it with a
5235 ;; multiply/add.  In general, we expect the define_split to occur before
5236 ;; register allocation, so we have to handle the corner case where the target
5237 ;; is the same as one of the inputs.
5238 (define_insn_and_split "*sse5_mulv4si3"
5239   [(set (match_operand:V4SI 0 "register_operand" "=&x")
5240         (mult:V4SI (match_operand:V4SI 1 "register_operand" "%x")
5241                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5242   "TARGET_SSE5"
5243   "#"
5244   "&& (reload_completed
5245        || (!reg_mentioned_p (operands[0], operands[1])
5246            && !reg_mentioned_p (operands[0], operands[2])))"
5247   [(set (match_dup 0)
5248         (match_dup 3))
5249    (set (match_dup 0)
5250         (plus:V4SI (mult:V4SI (match_dup 1)
5251                               (match_dup 2))
5252                    (match_dup 0)))]
5253 {
5254   operands[3] = CONST0_RTX (V4SImode);
5255 }
5256   [(set_attr "type" "ssemuladd")
5257    (set_attr "mode" "TI")])
5258
5259 (define_insn_and_split "*sse2_mulv4si3"
5260   [(set (match_operand:V4SI 0 "register_operand" "")
5261         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5262                    (match_operand:V4SI 2 "register_operand" "")))]
5263   "TARGET_SSE2 && !TARGET_SSE4_1 && !TARGET_SSE5
5264    && can_create_pseudo_p ()"
5265   "#"
5266   "&& 1"
5267   [(const_int 0)]
5268 {
5269   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5270   rtx op0, op1, op2;
5271
5272   op0 = operands[0];
5273   op1 = operands[1];
5274   op2 = operands[2];
5275   t1 = gen_reg_rtx (V4SImode);
5276   t2 = gen_reg_rtx (V4SImode);
5277   t3 = gen_reg_rtx (V4SImode);
5278   t4 = gen_reg_rtx (V4SImode);
5279   t5 = gen_reg_rtx (V4SImode);
5280   t6 = gen_reg_rtx (V4SImode);
5281   thirtytwo = GEN_INT (32);
5282
5283   /* Multiply elements 2 and 0.  */
5284   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
5285                                      op1, op2));
5286
5287   /* Shift both input vectors down one element, so that elements 3
5288      and 1 are now in the slots for elements 2 and 0.  For K8, at
5289      least, this is faster than using a shuffle.  */
5290   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
5291                                gen_lowpart (TImode, op1),
5292                                thirtytwo));
5293   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
5294                                gen_lowpart (TImode, op2),
5295                                thirtytwo));
5296   /* Multiply elements 3 and 1.  */
5297   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
5298                                      t2, t3));
5299
5300   /* Move the results in element 2 down to element 1; we don't care
5301      what goes in elements 2 and 3.  */
5302   emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
5303                                 const0_rtx, const0_rtx));
5304   emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
5305                                 const0_rtx, const0_rtx));
5306
5307   /* Merge the parts back together.  */
5308   emit_insn (gen_sse2_punpckldq (op0, t5, t6));
5309   DONE;
5310 })
5311
5312 (define_insn_and_split "mulv2di3"
5313   [(set (match_operand:V2DI 0 "register_operand" "")
5314         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
5315                    (match_operand:V2DI 2 "register_operand" "")))]
5316   "TARGET_SSE2
5317    && can_create_pseudo_p ()"
5318   "#"
5319   "&& 1"
5320   [(const_int 0)]
5321 {
5322   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5323   rtx op0, op1, op2;
5324
5325   if (TARGET_SSE5)
5326     {
5327       /* op1: A,B,C,D, op2: E,F,G,H */
5328       op0 = operands[0];
5329       op1 = gen_lowpart (V4SImode, operands[1]);
5330       op2 = gen_lowpart (V4SImode, operands[2]);
5331       t1 = gen_reg_rtx (V4SImode);
5332       t2 = gen_reg_rtx (V4SImode);
5333       t3 = gen_reg_rtx (V4SImode);
5334       t4 = gen_reg_rtx (V2DImode);
5335       t5 = gen_reg_rtx (V2DImode);
5336
5337       /* t1: B,A,D,C */
5338       emit_insn (gen_sse2_pshufd_1 (t1, op1,
5339                                     GEN_INT (1),
5340                                     GEN_INT (0),
5341                                     GEN_INT (3),
5342                                     GEN_INT (2)));
5343
5344       /* t2: 0 */
5345       emit_move_insn (t2, CONST0_RTX (V4SImode));
5346
5347       /* t3: (B*E),(A*F),(D*G),(C*H) */
5348       emit_insn (gen_sse5_pmacsdd (t3, t1, op2, t2));
5349
5350       /* t4: (B*E)+(A*F), (D*G)+(C*H) */
5351       emit_insn (gen_sse5_phadddq (t4, t3));
5352
5353       /* t5: ((B*E)+(A*F))<<32, ((D*G)+(C*H))<<32 */
5354       emit_insn (gen_ashlv2di3 (t5, t4, GEN_INT (32)));
5355
5356       /* op0: (((B*E)+(A*F))<<32)+(B*F), (((D*G)+(C*H))<<32)+(D*H) */
5357       emit_insn (gen_sse5_pmacsdql (op0, op1, op2, t5));
5358       DONE;
5359     }
5360
5361   op0 = operands[0];
5362   op1 = operands[1];
5363   op2 = operands[2];
5364   t1 = gen_reg_rtx (V2DImode);
5365   t2 = gen_reg_rtx (V2DImode);
5366   t3 = gen_reg_rtx (V2DImode);
5367   t4 = gen_reg_rtx (V2DImode);
5368   t5 = gen_reg_rtx (V2DImode);
5369   t6 = gen_reg_rtx (V2DImode);
5370   thirtytwo = GEN_INT (32);
5371
5372   /* Multiply low parts.  */
5373   emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
5374                                      gen_lowpart (V4SImode, op2)));
5375
5376   /* Shift input vectors left 32 bits so we can multiply high parts.  */
5377   emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
5378   emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
5379
5380   /* Multiply high parts by low parts.  */
5381   emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
5382                                      gen_lowpart (V4SImode, t3)));
5383   emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
5384                                      gen_lowpart (V4SImode, t2)));
5385
5386   /* Shift them back.  */
5387   emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
5388   emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
5389
5390   /* Add the three parts together.  */
5391   emit_insn (gen_addv2di3 (t6, t1, t4));
5392   emit_insn (gen_addv2di3 (op0, t6, t5));
5393   DONE;
5394 })
5395
5396 (define_expand "vec_widen_smult_hi_v8hi"
5397   [(match_operand:V4SI 0 "register_operand" "")
5398    (match_operand:V8HI 1 "register_operand" "")
5399    (match_operand:V8HI 2 "register_operand" "")]
5400   "TARGET_SSE2"
5401 {
5402   rtx op1, op2, t1, t2, dest;
5403
5404   op1 = operands[1];
5405   op2 = operands[2];
5406   t1 = gen_reg_rtx (V8HImode);
5407   t2 = gen_reg_rtx (V8HImode);
5408   dest = gen_lowpart (V8HImode, operands[0]);
5409
5410   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5411   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5412   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5413   DONE;
5414 })
5415
5416 (define_expand "vec_widen_smult_lo_v8hi"
5417   [(match_operand:V4SI 0 "register_operand" "")
5418    (match_operand:V8HI 1 "register_operand" "")
5419    (match_operand:V8HI 2 "register_operand" "")]
5420   "TARGET_SSE2"
5421 {
5422   rtx op1, op2, t1, t2, dest;
5423
5424   op1 = operands[1];
5425   op2 = operands[2];
5426   t1 = gen_reg_rtx (V8HImode);
5427   t2 = gen_reg_rtx (V8HImode);
5428   dest = gen_lowpart (V8HImode, operands[0]);
5429
5430   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5431   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5432   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5433   DONE;
5434 })
5435
5436 (define_expand "vec_widen_umult_hi_v8hi"
5437   [(match_operand:V4SI 0 "register_operand" "")
5438    (match_operand:V8HI 1 "register_operand" "")
5439    (match_operand:V8HI 2 "register_operand" "")]
5440   "TARGET_SSE2"
5441 {
5442   rtx op1, op2, t1, t2, dest;
5443
5444   op1 = operands[1];
5445   op2 = operands[2];
5446   t1 = gen_reg_rtx (V8HImode);
5447   t2 = gen_reg_rtx (V8HImode);
5448   dest = gen_lowpart (V8HImode, operands[0]);
5449
5450   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5451   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5452   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5453   DONE;
5454 })
5455
5456 (define_expand "vec_widen_umult_lo_v8hi"
5457   [(match_operand:V4SI 0 "register_operand" "")
5458    (match_operand:V8HI 1 "register_operand" "")
5459    (match_operand:V8HI 2 "register_operand" "")]
5460   "TARGET_SSE2"
5461 {
5462   rtx op1, op2, t1, t2, dest;
5463
5464   op1 = operands[1];
5465   op2 = operands[2];
5466   t1 = gen_reg_rtx (V8HImode);
5467   t2 = gen_reg_rtx (V8HImode);
5468   dest = gen_lowpart (V8HImode, operands[0]);
5469
5470   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5471   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5472   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5473   DONE;
5474 })
5475
5476 (define_expand "vec_widen_smult_hi_v4si"
5477   [(match_operand:V2DI 0 "register_operand" "")
5478    (match_operand:V4SI 1 "register_operand" "")
5479    (match_operand:V4SI 2 "register_operand" "")]
5480   "TARGET_SSE5"
5481 {
5482   rtx t1, t2;
5483
5484   t1 = gen_reg_rtx (V4SImode);
5485   t2 = gen_reg_rtx (V4SImode);
5486
5487   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5488                                 GEN_INT (0),
5489                                 GEN_INT (2),
5490                                 GEN_INT (1),
5491                                 GEN_INT (3)));
5492   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5493                                 GEN_INT (0),
5494                                 GEN_INT (2),
5495                                 GEN_INT (1),
5496                                 GEN_INT (3)));
5497   emit_insn (gen_sse5_mulv2div2di3_high (operands[0], t1, t2));
5498   DONE;
5499 })
5500
5501 (define_expand "vec_widen_smult_lo_v4si"
5502   [(match_operand:V2DI 0 "register_operand" "")
5503    (match_operand:V4SI 1 "register_operand" "")
5504    (match_operand:V4SI 2 "register_operand" "")]
5505   "TARGET_SSE5"
5506 {
5507   rtx t1, t2;
5508
5509   t1 = gen_reg_rtx (V4SImode);
5510   t2 = gen_reg_rtx (V4SImode);
5511
5512   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5513                                 GEN_INT (0),
5514                                 GEN_INT (2),
5515                                 GEN_INT (1),
5516                                 GEN_INT (3)));
5517   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5518                                 GEN_INT (0),
5519                                 GEN_INT (2),
5520                                 GEN_INT (1),
5521                                 GEN_INT (3)));
5522   emit_insn (gen_sse5_mulv2div2di3_low (operands[0], t1, t2));
5523   DONE;
5524   DONE;
5525 })
5526
5527 (define_expand "vec_widen_umult_hi_v4si"
5528   [(match_operand:V2DI 0 "register_operand" "")
5529    (match_operand:V4SI 1 "register_operand" "")
5530    (match_operand:V4SI 2 "register_operand" "")]
5531   "TARGET_SSE2"
5532 {
5533   rtx op1, op2, t1, t2;
5534
5535   op1 = operands[1];
5536   op2 = operands[2];
5537   t1 = gen_reg_rtx (V4SImode);
5538   t2 = gen_reg_rtx (V4SImode);
5539
5540   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
5541   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
5542   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5543   DONE;
5544 })
5545
5546 (define_expand "vec_widen_umult_lo_v4si"
5547   [(match_operand:V2DI 0 "register_operand" "")
5548    (match_operand:V4SI 1 "register_operand" "")
5549    (match_operand:V4SI 2 "register_operand" "")]
5550   "TARGET_SSE2"
5551 {
5552   rtx op1, op2, t1, t2;
5553
5554   op1 = operands[1];
5555   op2 = operands[2];
5556   t1 = gen_reg_rtx (V4SImode);
5557   t2 = gen_reg_rtx (V4SImode);
5558
5559   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
5560   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
5561   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5562   DONE;
5563 })
5564
5565 (define_expand "sdot_prodv8hi"
5566   [(match_operand:V4SI 0 "register_operand" "")
5567    (match_operand:V8HI 1 "register_operand" "")
5568    (match_operand:V8HI 2 "register_operand" "")
5569    (match_operand:V4SI 3 "register_operand" "")]
5570   "TARGET_SSE2"
5571 {
5572   rtx t = gen_reg_rtx (V4SImode);
5573   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
5574   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
5575   DONE;
5576 })
5577
5578 (define_expand "udot_prodv4si"
5579   [(match_operand:V2DI 0 "register_operand" "")
5580    (match_operand:V4SI 1 "register_operand" "")
5581    (match_operand:V4SI 2 "register_operand" "")
5582    (match_operand:V2DI 3 "register_operand" "")]
5583   "TARGET_SSE2"
5584 {
5585   rtx t1, t2, t3, t4;
5586
5587   t1 = gen_reg_rtx (V2DImode);
5588   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
5589   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
5590
5591   t2 = gen_reg_rtx (V4SImode);
5592   t3 = gen_reg_rtx (V4SImode);
5593   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
5594                                gen_lowpart (TImode, operands[1]),
5595                                GEN_INT (32)));
5596   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
5597                                gen_lowpart (TImode, operands[2]),
5598                                GEN_INT (32)));
5599
5600   t4 = gen_reg_rtx (V2DImode);
5601   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
5602
5603   emit_insn (gen_addv2di3 (operands[0], t1, t4));
5604   DONE;
5605 })
5606
5607 (define_insn "*avx_ashr<mode>3"
5608   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5609         (ashiftrt:SSEMODE24
5610           (match_operand:SSEMODE24 1 "register_operand" "x")
5611           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5612   "TARGET_AVX"
5613   "vpsra<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5614   [(set_attr "type" "sseishft")
5615    (set_attr "prefix" "vex")
5616    (set (attr "length_immediate")
5617      (if_then_else (match_operand 2 "const_int_operand" "")
5618        (const_string "1")
5619        (const_string "0")))
5620    (set_attr "mode" "TI")])
5621
5622 (define_insn "ashr<mode>3"
5623   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5624         (ashiftrt:SSEMODE24
5625           (match_operand:SSEMODE24 1 "register_operand" "0")
5626           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5627   "TARGET_SSE2"
5628   "psra<ssevecsize>\t{%2, %0|%0, %2}"
5629   [(set_attr "type" "sseishft")
5630    (set_attr "prefix_data16" "1")
5631    (set (attr "length_immediate")
5632      (if_then_else (match_operand 2 "const_int_operand" "")
5633        (const_string "1")
5634        (const_string "0")))
5635    (set_attr "mode" "TI")])
5636
5637 (define_insn "*avx_lshr<mode>3"
5638   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5639         (lshiftrt:SSEMODE248
5640           (match_operand:SSEMODE248 1 "register_operand" "x")
5641           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5642   "TARGET_AVX"
5643   "vpsrl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5644   [(set_attr "type" "sseishft")
5645    (set_attr "prefix" "vex")
5646    (set (attr "length_immediate")
5647      (if_then_else (match_operand 2 "const_int_operand" "")
5648        (const_string "1")
5649        (const_string "0")))
5650    (set_attr "mode" "TI")])
5651
5652 (define_insn "lshr<mode>3"
5653   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5654         (lshiftrt:SSEMODE248
5655           (match_operand:SSEMODE248 1 "register_operand" "0")
5656           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5657   "TARGET_SSE2"
5658   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
5659   [(set_attr "type" "sseishft")
5660    (set_attr "prefix_data16" "1")
5661    (set (attr "length_immediate")
5662      (if_then_else (match_operand 2 "const_int_operand" "")
5663        (const_string "1")
5664        (const_string "0")))
5665    (set_attr "mode" "TI")])
5666
5667 (define_insn "*avx_ashl<mode>3"
5668   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5669         (ashift:SSEMODE248
5670           (match_operand:SSEMODE248 1 "register_operand" "x")
5671           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5672   "TARGET_AVX"
5673   "vpsll<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5674   [(set_attr "type" "sseishft")
5675    (set_attr "prefix" "vex")
5676    (set (attr "length_immediate")
5677      (if_then_else (match_operand 2 "const_int_operand" "")
5678        (const_string "1")
5679        (const_string "0")))
5680    (set_attr "mode" "TI")])
5681
5682 (define_insn "ashl<mode>3"
5683   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5684         (ashift:SSEMODE248
5685           (match_operand:SSEMODE248 1 "register_operand" "0")
5686           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5687   "TARGET_SSE2"
5688   "psll<ssevecsize>\t{%2, %0|%0, %2}"
5689   [(set_attr "type" "sseishft")
5690    (set_attr "prefix_data16" "1")
5691    (set (attr "length_immediate")
5692      (if_then_else (match_operand 2 "const_int_operand" "")
5693        (const_string "1")
5694        (const_string "0")))
5695    (set_attr "mode" "TI")])
5696
5697 (define_expand "vec_shl_<mode>"
5698   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5699         (ashift:TI (match_operand:SSEMODEI 1 "register_operand" "")
5700                    (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
5701   "TARGET_SSE2"
5702 {
5703   operands[0] = gen_lowpart (TImode, operands[0]);
5704   operands[1] = gen_lowpart (TImode, operands[1]);
5705 })
5706
5707 (define_expand "vec_shr_<mode>"
5708   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5709         (lshiftrt:TI (match_operand:SSEMODEI 1 "register_operand" "")
5710                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
5711   "TARGET_SSE2"
5712 {
5713   operands[0] = gen_lowpart (TImode, operands[0]);
5714   operands[1] = gen_lowpart (TImode, operands[1]);
5715 })
5716
5717 (define_insn "*avx_<code><mode>3"
5718   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5719         (maxmin:SSEMODE124
5720           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
5721           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5722   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5723   "vp<maxminiprefix><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5724   [(set_attr "type" "sseiadd")
5725    (set (attr "prefix_extra")
5726      (if_then_else
5727        (ne (symbol_ref "<MODE>mode != ((<CODE> == SMAX || <CODE> == SMIN) ? V8HImode : V16QImode)")
5728            (const_int 0))
5729        (const_string "1")
5730        (const_string "0")))
5731    (set_attr "prefix" "vex")
5732    (set_attr "mode" "TI")])
5733
5734 (define_expand "<code>v16qi3"
5735   [(set (match_operand:V16QI 0 "register_operand" "")
5736         (umaxmin:V16QI
5737           (match_operand:V16QI 1 "nonimmediate_operand" "")
5738           (match_operand:V16QI 2 "nonimmediate_operand" "")))]
5739   "TARGET_SSE2"
5740   "ix86_fixup_binary_operands_no_copy (<CODE>, V16QImode, operands);")
5741
5742 (define_insn "*<code>v16qi3"
5743   [(set (match_operand:V16QI 0 "register_operand" "=x")
5744         (umaxmin:V16QI
5745           (match_operand:V16QI 1 "nonimmediate_operand" "%0")
5746           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
5747   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
5748   "p<maxminiprefix>b\t{%2, %0|%0, %2}"
5749   [(set_attr "type" "sseiadd")
5750    (set_attr "prefix_data16" "1")
5751    (set_attr "mode" "TI")])
5752
5753 (define_expand "<code>v8hi3"
5754   [(set (match_operand:V8HI 0 "register_operand" "")
5755         (smaxmin:V8HI
5756           (match_operand:V8HI 1 "nonimmediate_operand" "")
5757           (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5758   "TARGET_SSE2"
5759   "ix86_fixup_binary_operands_no_copy (<CODE>, V8HImode, operands);")
5760
5761 (define_insn "*<code>v8hi3"
5762   [(set (match_operand:V8HI 0 "register_operand" "=x")
5763         (smaxmin:V8HI
5764           (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5765           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5766   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
5767   "p<maxminiprefix>w\t{%2, %0|%0, %2}"
5768   [(set_attr "type" "sseiadd")
5769    (set_attr "prefix_data16" "1")
5770    (set_attr "mode" "TI")])
5771
5772 (define_expand "umaxv8hi3"
5773   [(set (match_operand:V8HI 0 "register_operand" "")
5774         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
5775                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5776   "TARGET_SSE2"
5777 {
5778   if (TARGET_SSE4_1)
5779     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
5780   else
5781     {
5782       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
5783       if (rtx_equal_p (op3, op2))
5784         op3 = gen_reg_rtx (V8HImode);
5785       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
5786       emit_insn (gen_addv8hi3 (op0, op3, op2));
5787       DONE;
5788     }
5789 })
5790
5791 (define_expand "smax<mode>3"
5792   [(set (match_operand:SSEMODE14 0 "register_operand" "")
5793         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
5794                         (match_operand:SSEMODE14 2 "register_operand" "")))]
5795   "TARGET_SSE2"
5796 {
5797   if (TARGET_SSE4_1)
5798     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
5799   else
5800   {
5801     rtx xops[6];
5802     bool ok;
5803
5804     xops[0] = operands[0];
5805     xops[1] = operands[1];
5806     xops[2] = operands[2];
5807     xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
5808     xops[4] = operands[1];
5809     xops[5] = operands[2];
5810     ok = ix86_expand_int_vcond (xops);
5811     gcc_assert (ok);
5812     DONE;
5813   }
5814 })
5815
5816 (define_insn "*sse4_1_<code><mode>3"
5817   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
5818         (smaxmin:SSEMODE14
5819           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
5820           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
5821   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5822   "p<maxminiprefix><ssevecsize>\t{%2, %0|%0, %2}"
5823   [(set_attr "type" "sseiadd")
5824    (set_attr "prefix_extra" "1")
5825    (set_attr "mode" "TI")])
5826
5827 (define_expand "umaxv4si3"
5828   [(set (match_operand:V4SI 0 "register_operand" "")
5829         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
5830                    (match_operand:V4SI 2 "register_operand" "")))]
5831   "TARGET_SSE2"
5832 {
5833   if (TARGET_SSE4_1)
5834     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
5835   else
5836   {
5837     rtx xops[6];
5838     bool ok;
5839
5840     xops[0] = operands[0];
5841     xops[1] = operands[1];
5842     xops[2] = operands[2];
5843     xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
5844     xops[4] = operands[1];
5845     xops[5] = operands[2];
5846     ok = ix86_expand_int_vcond (xops);
5847     gcc_assert (ok);
5848     DONE;
5849   }
5850 })
5851
5852 (define_insn "*sse4_1_<code><mode>3"
5853   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5854         (umaxmin:SSEMODE24
5855           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
5856           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
5857   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5858   "p<maxminiprefix><ssevecsize>\t{%2, %0|%0, %2}"
5859   [(set_attr "type" "sseiadd")
5860    (set_attr "prefix_extra" "1")
5861    (set_attr "mode" "TI")])
5862
5863 (define_expand "smin<mode>3"
5864   [(set (match_operand:SSEMODE14 0 "register_operand" "")
5865         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
5866                         (match_operand:SSEMODE14 2 "register_operand" "")))]
5867   "TARGET_SSE2"
5868 {
5869   if (TARGET_SSE4_1)
5870     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
5871   else
5872     {
5873       rtx xops[6];
5874       bool ok;
5875
5876       xops[0] = operands[0];
5877       xops[1] = operands[2];
5878       xops[2] = operands[1];
5879       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
5880       xops[4] = operands[1];
5881       xops[5] = operands[2];
5882       ok = ix86_expand_int_vcond (xops);
5883       gcc_assert (ok);
5884       DONE;
5885     }
5886 })
5887
5888 (define_expand "umin<mode>3"
5889   [(set (match_operand:SSEMODE24 0 "register_operand" "")
5890         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
5891                         (match_operand:SSEMODE24 2 "register_operand" "")))]
5892   "TARGET_SSE2"
5893 {
5894   if (TARGET_SSE4_1)
5895     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
5896   else
5897     {
5898       rtx xops[6];
5899       bool ok;
5900
5901       xops[0] = operands[0];
5902       xops[1] = operands[2];
5903       xops[2] = operands[1];
5904       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
5905       xops[4] = operands[1];
5906       xops[5] = operands[2];
5907       ok = ix86_expand_int_vcond (xops);
5908       gcc_assert (ok);
5909       DONE;
5910     }
5911 })
5912
5913 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5914 ;;
5915 ;; Parallel integral comparisons
5916 ;;
5917 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5918
5919 (define_expand "sse2_eq<mode>3"
5920   [(set (match_operand:SSEMODE124 0 "register_operand" "")
5921         (eq:SSEMODE124
5922           (match_operand:SSEMODE124 1 "nonimmediate_operand" "")
5923           (match_operand:SSEMODE124 2 "nonimmediate_operand" "")))]
5924   "TARGET_SSE2 && !TARGET_SSE5"
5925   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
5926
5927 (define_insn "*avx_eq<mode>3"
5928   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
5929         (eq:SSEMODE1248
5930           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "%x")
5931           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
5932   "TARGET_AVX && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
5933   "vpcmpeq<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5934   [(set_attr "type" "ssecmp")
5935    (set (attr "prefix_extra")
5936      (if_then_else (match_operand:V2DI 0 "" "")
5937        (const_string "1")
5938        (const_string "*")))
5939    (set_attr "prefix" "vex")
5940    (set_attr "mode" "TI")])
5941
5942 (define_insn "*sse2_eq<mode>3"
5943   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5944         (eq:SSEMODE124
5945           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
5946           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5947   "TARGET_SSE2 && !TARGET_SSE5
5948    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
5949   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
5950   [(set_attr "type" "ssecmp")
5951    (set_attr "prefix_data16" "1")
5952    (set_attr "mode" "TI")])
5953
5954 (define_expand "sse4_1_eqv2di3"
5955   [(set (match_operand:V2DI 0 "register_operand" "")
5956         (eq:V2DI
5957           (match_operand:V2DI 1 "nonimmediate_operand" "")
5958           (match_operand:V2DI 2 "nonimmediate_operand" "")))]
5959   "TARGET_SSE4_1"
5960   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
5961
5962 (define_insn "*sse4_1_eqv2di3"
5963   [(set (match_operand:V2DI 0 "register_operand" "=x")
5964         (eq:V2DI
5965           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
5966           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
5967   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
5968   "pcmpeqq\t{%2, %0|%0, %2}"
5969   [(set_attr "type" "ssecmp")
5970    (set_attr "prefix_extra" "1")
5971    (set_attr "mode" "TI")])
5972
5973 (define_insn "*avx_gt<mode>3"
5974   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
5975         (gt:SSEMODE1248
5976           (match_operand:SSEMODE1248 1 "register_operand" "x")
5977           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
5978   "TARGET_AVX"
5979   "vpcmpgt<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5980   [(set_attr "type" "ssecmp")
5981    (set (attr "prefix_extra")
5982      (if_then_else (match_operand:V2DI 0 "" "")
5983        (const_string "1")
5984        (const_string "*")))
5985    (set_attr "prefix" "vex")
5986    (set_attr "mode" "TI")])
5987
5988 (define_insn "sse2_gt<mode>3"
5989   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5990         (gt:SSEMODE124
5991           (match_operand:SSEMODE124 1 "register_operand" "0")
5992           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
5993   "TARGET_SSE2 && !TARGET_SSE5"
5994   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
5995   [(set_attr "type" "ssecmp")
5996    (set_attr "prefix_data16" "1")
5997    (set_attr "mode" "TI")])
5998
5999 (define_insn "sse4_2_gtv2di3"
6000   [(set (match_operand:V2DI 0 "register_operand" "=x")
6001         (gt:V2DI
6002           (match_operand:V2DI 1 "register_operand" "0")
6003           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6004   "TARGET_SSE4_2"
6005   "pcmpgtq\t{%2, %0|%0, %2}"
6006   [(set_attr "type" "ssecmp")
6007    (set_attr "prefix_extra" "1")
6008    (set_attr "mode" "TI")])
6009
6010 (define_expand "vcond<mode>"
6011   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6012         (if_then_else:SSEMODEI
6013           (match_operator 3 ""
6014             [(match_operand:SSEMODEI 4 "nonimmediate_operand" "")
6015              (match_operand:SSEMODEI 5 "nonimmediate_operand" "")])
6016           (match_operand:SSEMODEI 1 "general_operand" "")
6017           (match_operand:SSEMODEI 2 "general_operand" "")))]
6018   "TARGET_SSE2"
6019 {
6020   if (ix86_expand_int_vcond (operands))
6021     DONE;
6022   else
6023     FAIL;
6024 })
6025
6026 (define_expand "vcondu<mode>"
6027   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6028         (if_then_else:SSEMODEI
6029           (match_operator 3 ""
6030             [(match_operand:SSEMODEI 4 "nonimmediate_operand" "")
6031              (match_operand:SSEMODEI 5 "nonimmediate_operand" "")])
6032           (match_operand:SSEMODEI 1 "general_operand" "")
6033           (match_operand:SSEMODEI 2 "general_operand" "")))]
6034   "TARGET_SSE2"
6035 {
6036   if (ix86_expand_int_vcond (operands))
6037     DONE;
6038   else
6039     FAIL;
6040 })
6041
6042 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6043 ;;
6044 ;; Parallel bitwise logical operations
6045 ;;
6046 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6047
6048 (define_expand "one_cmpl<mode>2"
6049   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6050         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6051                       (match_dup 2)))]
6052   "TARGET_SSE2"
6053 {
6054   int i, n = GET_MODE_NUNITS (<MODE>mode);
6055   rtvec v = rtvec_alloc (n);
6056
6057   for (i = 0; i < n; ++i)
6058     RTVEC_ELT (v, i) = constm1_rtx;
6059
6060   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
6061 })
6062
6063 (define_insn "*avx_andnot<mode>3"
6064   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6065         (and:AVX256MODEI
6066           (not:AVX256MODEI (match_operand:AVX256MODEI 1 "register_operand" "x"))
6067           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6068   "TARGET_AVX"
6069   "vandnps\t{%2, %1, %0|%0, %1, %2}"
6070   [(set_attr "type" "sselog")
6071    (set_attr "prefix" "vex")
6072    (set_attr "mode" "<avxvecpsmode>")])
6073
6074 (define_insn "*sse_andnot<mode>3"
6075   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6076         (and:SSEMODEI
6077           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6078           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6079   "(TARGET_SSE && !TARGET_SSE2)"
6080   "andnps\t{%2, %0|%0, %2}"
6081   [(set_attr "type" "sselog")
6082    (set_attr "mode" "V4SF")])
6083
6084 (define_insn "*avx_andnot<mode>3"
6085   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6086         (and:SSEMODEI
6087           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "x"))
6088           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6089   "TARGET_AVX"
6090   "vpandn\t{%2, %1, %0|%0, %1, %2}"
6091   [(set_attr "type" "sselog")
6092    (set_attr "prefix" "vex")
6093    (set_attr "mode" "TI")])
6094
6095 (define_insn "sse2_andnot<mode>3"
6096   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6097         (and:SSEMODEI
6098           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6099           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6100   "TARGET_SSE2"
6101   "pandn\t{%2, %0|%0, %2}"
6102   [(set_attr "type" "sselog")
6103    (set_attr "prefix_data16" "1")
6104    (set_attr "mode" "TI")])
6105
6106 (define_insn "*andnottf3"
6107   [(set (match_operand:TF 0 "register_operand" "=x")
6108         (and:TF
6109           (not:TF (match_operand:TF 1 "register_operand" "0"))
6110           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6111   "TARGET_SSE2"
6112   "pandn\t{%2, %0|%0, %2}"
6113   [(set_attr "type" "sselog")
6114    (set_attr "prefix_data16" "1")
6115    (set_attr "mode" "TI")])
6116
6117 (define_expand "<code><mode>3"
6118   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6119         (plogic:SSEMODEI
6120           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6121           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
6122   "TARGET_SSE"
6123   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
6124
6125 (define_insn "*avx_<code><mode>3"
6126   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6127         (plogic:AVX256MODEI
6128           (match_operand:AVX256MODEI 1 "nonimmediate_operand" "%x")
6129           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6130   "TARGET_AVX
6131    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6132   "v<plogicprefix>ps\t{%2, %1, %0|%0, %1, %2}"
6133   [(set_attr "type" "sselog")
6134    (set_attr "prefix" "vex")
6135    (set_attr "mode" "<avxvecpsmode>")])
6136
6137 (define_insn "*sse_<code><mode>3"
6138   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6139         (plogic:SSEMODEI
6140           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6141           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6142   "(TARGET_SSE && !TARGET_SSE2)
6143    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6144   "<plogicprefix>ps\t{%2, %0|%0, %2}"
6145   [(set_attr "type" "sselog")
6146    (set_attr "mode" "V4SF")])
6147
6148 (define_insn "*avx_<code><mode>3"
6149   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6150         (plogic:SSEMODEI
6151           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%x")
6152           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6153   "TARGET_AVX
6154    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6155   "vp<plogicprefix>\t{%2, %1, %0|%0, %1, %2}"
6156   [(set_attr "type" "sselog")
6157    (set_attr "prefix" "vex")
6158    (set_attr "mode" "TI")])
6159
6160 (define_insn "*sse2_<code><mode>3"
6161   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6162         (plogic:SSEMODEI
6163           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6164           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6165   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6166   "p<plogicprefix>\t{%2, %0|%0, %2}"
6167   [(set_attr "type" "sselog")
6168    (set_attr "prefix_data16" "1")
6169    (set_attr "mode" "TI")])
6170
6171 (define_expand "<code>tf3"
6172   [(set (match_operand:TF 0 "register_operand" "")
6173         (plogic:TF
6174           (match_operand:TF 1 "nonimmediate_operand" "")
6175           (match_operand:TF 2 "nonimmediate_operand" "")))]
6176   "TARGET_SSE2"
6177   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
6178
6179 (define_insn "*<code>tf3"
6180   [(set (match_operand:TF 0 "register_operand" "=x")
6181         (plogic:TF
6182           (match_operand:TF 1 "nonimmediate_operand" "%0")
6183           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6184   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
6185   "p<plogicprefix>\t{%2, %0|%0, %2}"
6186   [(set_attr "type" "sselog")
6187    (set_attr "prefix_data16" "1")
6188    (set_attr "mode" "TI")])
6189
6190 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6191 ;;
6192 ;; Parallel integral element swizzling
6193 ;;
6194 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6195
6196 ;; Reduce:
6197 ;;      op1 = abcdefghijklmnop
6198 ;;      op2 = qrstuvwxyz012345
6199 ;;       h1 = aqbrcsdteufvgwhx
6200 ;;       l1 = iyjzk0l1m2n3o4p5
6201 ;;       h2 = aiqybjrzcks0dlt1
6202 ;;       l2 = emu2fnv3gow4hpx5
6203 ;;       h3 = aeimquy2bfjnrvz3
6204 ;;       l3 = cgkosw04dhlptx15
6205 ;;   result = bdfhjlnprtvxz135
6206 (define_expand "vec_pack_trunc_v8hi"
6207   [(match_operand:V16QI 0 "register_operand" "")
6208    (match_operand:V8HI 1 "register_operand" "")
6209    (match_operand:V8HI 2 "register_operand" "")]
6210   "TARGET_SSE2"
6211 {
6212   rtx op1, op2, h1, l1, h2, l2, h3, l3;
6213
6214   if (TARGET_SSE5)
6215     {
6216       ix86_expand_sse5_pack (operands);
6217       DONE;
6218     }
6219
6220   op1 = gen_lowpart (V16QImode, operands[1]);
6221   op2 = gen_lowpart (V16QImode, operands[2]);
6222   h1 = gen_reg_rtx (V16QImode);
6223   l1 = gen_reg_rtx (V16QImode);
6224   h2 = gen_reg_rtx (V16QImode);
6225   l2 = gen_reg_rtx (V16QImode);
6226   h3 = gen_reg_rtx (V16QImode);
6227   l3 = gen_reg_rtx (V16QImode);
6228
6229   emit_insn (gen_vec_interleave_highv16qi (h1, op1, op2));
6230   emit_insn (gen_vec_interleave_lowv16qi (l1, op1, op2));
6231   emit_insn (gen_vec_interleave_highv16qi (h2, l1, h1));
6232   emit_insn (gen_vec_interleave_lowv16qi (l2, l1, h1));
6233   emit_insn (gen_vec_interleave_highv16qi (h3, l2, h2));
6234   emit_insn (gen_vec_interleave_lowv16qi (l3, l2, h2));
6235   emit_insn (gen_vec_interleave_lowv16qi (operands[0], l3, h3));
6236   DONE;
6237 })
6238
6239 ;; Reduce:
6240 ;;      op1 = abcdefgh
6241 ;;      op2 = ijklmnop
6242 ;;       h1 = aibjckdl
6243 ;;       l1 = emfngohp
6244 ;;       h2 = aeimbfjn
6245 ;;       l2 = cgkodhlp
6246 ;;   result = bdfhjlnp
6247 (define_expand "vec_pack_trunc_v4si"
6248   [(match_operand:V8HI 0 "register_operand" "")
6249    (match_operand:V4SI 1 "register_operand" "")
6250    (match_operand:V4SI 2 "register_operand" "")]
6251   "TARGET_SSE2"
6252 {
6253   rtx op1, op2, h1, l1, h2, l2;
6254
6255   if (TARGET_SSE5)
6256     {
6257       ix86_expand_sse5_pack (operands);
6258       DONE;
6259     }
6260
6261   op1 = gen_lowpart (V8HImode, operands[1]);
6262   op2 = gen_lowpart (V8HImode, operands[2]);
6263   h1 = gen_reg_rtx (V8HImode);
6264   l1 = gen_reg_rtx (V8HImode);
6265   h2 = gen_reg_rtx (V8HImode);
6266   l2 = gen_reg_rtx (V8HImode);
6267
6268   emit_insn (gen_vec_interleave_highv8hi (h1, op1, op2));
6269   emit_insn (gen_vec_interleave_lowv8hi (l1, op1, op2));
6270   emit_insn (gen_vec_interleave_highv8hi (h2, l1, h1));
6271   emit_insn (gen_vec_interleave_lowv8hi (l2, l1, h1));
6272   emit_insn (gen_vec_interleave_lowv8hi (operands[0], l2, h2));
6273   DONE;
6274 })
6275
6276 ;; Reduce:
6277 ;;     op1 = abcd
6278 ;;     op2 = efgh
6279 ;;      h1 = aebf
6280 ;;      l1 = cgdh
6281 ;;  result = bdfh
6282 (define_expand "vec_pack_trunc_v2di"
6283   [(match_operand:V4SI 0 "register_operand" "")
6284    (match_operand:V2DI 1 "register_operand" "")
6285    (match_operand:V2DI 2 "register_operand" "")]
6286   "TARGET_SSE2"
6287 {
6288   rtx op1, op2, h1, l1;
6289
6290   if (TARGET_SSE5)
6291     {
6292       ix86_expand_sse5_pack (operands);
6293       DONE;
6294     }
6295
6296   op1 = gen_lowpart (V4SImode, operands[1]);
6297   op2 = gen_lowpart (V4SImode, operands[2]);
6298   h1 = gen_reg_rtx (V4SImode);
6299   l1 = gen_reg_rtx (V4SImode);
6300
6301   emit_insn (gen_vec_interleave_highv4si (h1, op1, op2));
6302   emit_insn (gen_vec_interleave_lowv4si (l1, op1, op2));
6303   emit_insn (gen_vec_interleave_lowv4si (operands[0], l1, h1));
6304   DONE;
6305 })
6306
6307 (define_expand "vec_interleave_highv16qi"
6308   [(set (match_operand:V16QI 0 "register_operand" "")
6309         (vec_select:V16QI
6310           (vec_concat:V32QI
6311             (match_operand:V16QI 1 "register_operand" "")
6312             (match_operand:V16QI 2 "nonimmediate_operand" ""))
6313           (parallel [(const_int 8)  (const_int 24)
6314                      (const_int 9)  (const_int 25)
6315                      (const_int 10) (const_int 26)
6316                      (const_int 11) (const_int 27)
6317                      (const_int 12) (const_int 28)
6318                      (const_int 13) (const_int 29)
6319                      (const_int 14) (const_int 30)
6320                      (const_int 15) (const_int 31)])))]
6321   "TARGET_SSE2"
6322 {
6323   emit_insn (gen_sse2_punpckhbw (operands[0], operands[1], operands[2]));
6324   DONE;
6325 })
6326
6327 (define_expand "vec_interleave_lowv16qi"
6328   [(set (match_operand:V16QI 0 "register_operand" "")
6329         (vec_select:V16QI
6330           (vec_concat:V32QI
6331             (match_operand:V16QI 1 "register_operand" "")
6332             (match_operand:V16QI 2 "nonimmediate_operand" ""))
6333           (parallel [(const_int 0) (const_int 16)
6334                      (const_int 1) (const_int 17)
6335                      (const_int 2) (const_int 18)
6336                      (const_int 3) (const_int 19)
6337                      (const_int 4) (const_int 20)
6338                      (const_int 5) (const_int 21)
6339                      (const_int 6) (const_int 22)
6340                      (const_int 7) (const_int 23)])))]
6341   "TARGET_SSE2"
6342 {
6343   emit_insn (gen_sse2_punpcklbw (operands[0], operands[1], operands[2]));
6344   DONE;
6345 })
6346
6347 (define_expand "vec_interleave_highv8hi"
6348   [(set (match_operand:V8HI 0 "register_operand" "=")
6349         (vec_select:V8HI
6350           (vec_concat:V16HI
6351             (match_operand:V8HI 1 "register_operand" "")
6352             (match_operand:V8HI 2 "nonimmediate_operand" ""))
6353           (parallel [(const_int 4) (const_int 12)
6354                      (const_int 5) (const_int 13)
6355                      (const_int 6) (const_int 14)
6356                      (const_int 7) (const_int 15)])))]
6357   "TARGET_SSE2"
6358 {
6359   emit_insn (gen_sse2_punpckhwd (operands[0], operands[1], operands[2]));
6360   DONE;
6361 })
6362
6363 (define_expand "vec_interleave_lowv8hi"
6364   [(set (match_operand:V8HI 0 "register_operand" "")
6365         (vec_select:V8HI
6366           (vec_concat:V16HI
6367             (match_operand:V8HI 1 "register_operand" "")
6368             (match_operand:V8HI 2 "nonimmediate_operand" ""))
6369           (parallel [(const_int 0) (const_int 8)
6370                      (const_int 1) (const_int 9)
6371                      (const_int 2) (const_int 10)
6372                      (const_int 3) (const_int 11)])))]
6373   "TARGET_SSE2"
6374 {
6375   emit_insn (gen_sse2_punpcklwd (operands[0], operands[1], operands[2]));
6376   DONE;
6377 })
6378
6379 (define_expand "vec_interleave_highv4si"
6380   [(set (match_operand:V4SI 0 "register_operand" "")
6381         (vec_select:V4SI
6382           (vec_concat:V8SI
6383             (match_operand:V4SI 1 "register_operand" "")
6384             (match_operand:V4SI 2 "nonimmediate_operand" ""))
6385           (parallel [(const_int 2) (const_int 6)
6386                      (const_int 3) (const_int 7)])))]
6387   "TARGET_SSE2"
6388 {
6389   emit_insn (gen_sse2_punpckhdq (operands[0], operands[1], operands[2]));
6390   DONE;
6391 })
6392
6393 (define_expand "vec_interleave_lowv4si"
6394   [(set (match_operand:V4SI 0 "register_operand" "")
6395         (vec_select:V4SI
6396           (vec_concat:V8SI
6397             (match_operand:V4SI 1 "register_operand" "")
6398             (match_operand:V4SI 2 "nonimmediate_operand" ""))
6399           (parallel [(const_int 0) (const_int 4)
6400                      (const_int 1) (const_int 5)])))]
6401   "TARGET_SSE2"
6402 {
6403   emit_insn (gen_sse2_punpckldq (operands[0], operands[1], operands[2]));
6404   DONE;
6405 })
6406
6407 (define_expand "vec_interleave_highv2di"
6408   [(set (match_operand:V2DI 0 "register_operand" "")
6409         (vec_select:V2DI
6410           (vec_concat:V4DI
6411             (match_operand:V2DI 1 "register_operand" "")
6412             (match_operand:V2DI 2 "nonimmediate_operand" ""))
6413           (parallel [(const_int 1)
6414                      (const_int 3)])))]
6415   "TARGET_SSE2"
6416 {
6417   emit_insn (gen_sse2_punpckhqdq (operands[0], operands[1], operands[2]));
6418   DONE;
6419 })
6420
6421 (define_expand "vec_interleave_lowv2di"
6422   [(set (match_operand:V2DI 0 "register_operand" "")
6423         (vec_select:V2DI
6424           (vec_concat:V4DI
6425             (match_operand:V2DI 1 "register_operand" "")
6426             (match_operand:V2DI 2 "nonimmediate_operand" ""))
6427           (parallel [(const_int 0)
6428                      (const_int 2)])))]
6429   "TARGET_SSE2"
6430 {
6431   emit_insn (gen_sse2_punpcklqdq (operands[0], operands[1], operands[2]));
6432   DONE;
6433 })
6434
6435 (define_expand "vec_interleave_highv4sf"
6436   [(set (match_operand:V4SF 0 "register_operand" "")
6437         (vec_select:V4SF
6438           (vec_concat:V8SF
6439             (match_operand:V4SF 1 "register_operand" "")
6440             (match_operand:V4SF 2 "nonimmediate_operand" ""))
6441           (parallel [(const_int 2) (const_int 6)
6442                      (const_int 3) (const_int 7)])))]
6443   "TARGET_SSE")
6444
6445 (define_expand "vec_interleave_lowv4sf"
6446   [(set (match_operand:V4SF 0 "register_operand" "")
6447         (vec_select:V4SF
6448           (vec_concat:V8SF
6449             (match_operand:V4SF 1 "register_operand" "")
6450             (match_operand:V4SF 2 "nonimmediate_operand" ""))
6451           (parallel [(const_int 0) (const_int 4)
6452                      (const_int 1) (const_int 5)])))]
6453   "TARGET_SSE")
6454
6455 (define_expand "vec_interleave_highv2df"
6456   [(set (match_operand:V2DF 0 "register_operand" "")
6457         (vec_select:V2DF
6458           (vec_concat:V4DF
6459             (match_operand:V2DF 1 "register_operand" "")
6460             (match_operand:V2DF 2 "nonimmediate_operand" ""))
6461           (parallel [(const_int 1)
6462                      (const_int 3)])))]
6463   "TARGET_SSE2")
6464
6465 (define_expand "vec_interleave_lowv2df"
6466   [(set (match_operand:V2DF 0 "register_operand" "")
6467         (vec_select:V2DF
6468           (vec_concat:V4DF
6469             (match_operand:V2DF 1 "register_operand" "")
6470             (match_operand:V2DF 2 "nonimmediate_operand" ""))
6471           (parallel [(const_int 0)
6472                      (const_int 2)])))]
6473   "TARGET_SSE2")
6474
6475 (define_insn "*avx_packsswb"
6476   [(set (match_operand:V16QI 0 "register_operand" "=x")
6477         (vec_concat:V16QI
6478           (ss_truncate:V8QI
6479             (match_operand:V8HI 1 "register_operand" "x"))
6480           (ss_truncate:V8QI
6481             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6482   "TARGET_AVX"
6483   "vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6484   [(set_attr "type" "sselog")
6485    (set_attr "prefix" "vex")
6486    (set_attr "mode" "TI")])
6487
6488 (define_insn "sse2_packsswb"
6489   [(set (match_operand:V16QI 0 "register_operand" "=x")
6490         (vec_concat:V16QI
6491           (ss_truncate:V8QI
6492             (match_operand:V8HI 1 "register_operand" "0"))
6493           (ss_truncate:V8QI
6494             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6495   "TARGET_SSE2"
6496   "packsswb\t{%2, %0|%0, %2}"
6497   [(set_attr "type" "sselog")
6498    (set_attr "prefix_data16" "1")
6499    (set_attr "mode" "TI")])
6500
6501 (define_insn "*avx_packssdw"
6502   [(set (match_operand:V8HI 0 "register_operand" "=x")
6503         (vec_concat:V8HI
6504           (ss_truncate:V4HI
6505             (match_operand:V4SI 1 "register_operand" "x"))
6506           (ss_truncate:V4HI
6507             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6508   "TARGET_AVX"
6509   "vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6510   [(set_attr "type" "sselog")
6511    (set_attr "prefix" "vex")
6512    (set_attr "mode" "TI")])
6513
6514 (define_insn "sse2_packssdw"
6515   [(set (match_operand:V8HI 0 "register_operand" "=x")
6516         (vec_concat:V8HI
6517           (ss_truncate:V4HI
6518             (match_operand:V4SI 1 "register_operand" "0"))
6519           (ss_truncate:V4HI
6520             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6521   "TARGET_SSE2"
6522   "packssdw\t{%2, %0|%0, %2}"
6523   [(set_attr "type" "sselog")
6524    (set_attr "prefix_data16" "1")
6525    (set_attr "mode" "TI")])
6526
6527 (define_insn "*avx_packuswb"
6528   [(set (match_operand:V16QI 0 "register_operand" "=x")
6529         (vec_concat:V16QI
6530           (us_truncate:V8QI
6531             (match_operand:V8HI 1 "register_operand" "x"))
6532           (us_truncate:V8QI
6533             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6534   "TARGET_AVX"
6535   "vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6536   [(set_attr "type" "sselog")
6537    (set_attr "prefix" "vex")
6538    (set_attr "mode" "TI")])
6539
6540 (define_insn "sse2_packuswb"
6541   [(set (match_operand:V16QI 0 "register_operand" "=x")
6542         (vec_concat:V16QI
6543           (us_truncate:V8QI
6544             (match_operand:V8HI 1 "register_operand" "0"))
6545           (us_truncate:V8QI
6546             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6547   "TARGET_SSE2"
6548   "packuswb\t{%2, %0|%0, %2}"
6549   [(set_attr "type" "sselog")
6550    (set_attr "prefix_data16" "1")
6551    (set_attr "mode" "TI")])
6552
6553 (define_insn "*avx_punpckhbw"
6554   [(set (match_operand:V16QI 0 "register_operand" "=x")
6555         (vec_select:V16QI
6556           (vec_concat:V32QI
6557             (match_operand:V16QI 1 "register_operand" "x")
6558             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6559           (parallel [(const_int 8)  (const_int 24)
6560                      (const_int 9)  (const_int 25)
6561                      (const_int 10) (const_int 26)
6562                      (const_int 11) (const_int 27)
6563                      (const_int 12) (const_int 28)
6564                      (const_int 13) (const_int 29)
6565                      (const_int 14) (const_int 30)
6566                      (const_int 15) (const_int 31)])))]
6567   "TARGET_AVX"
6568   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6569   [(set_attr "type" "sselog")
6570    (set_attr "prefix" "vex")
6571    (set_attr "mode" "TI")])
6572
6573 (define_insn "sse2_punpckhbw"
6574   [(set (match_operand:V16QI 0 "register_operand" "=x")
6575         (vec_select:V16QI
6576           (vec_concat:V32QI
6577             (match_operand:V16QI 1 "register_operand" "0")
6578             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6579           (parallel [(const_int 8)  (const_int 24)
6580                      (const_int 9)  (const_int 25)
6581                      (const_int 10) (const_int 26)
6582                      (const_int 11) (const_int 27)
6583                      (const_int 12) (const_int 28)
6584                      (const_int 13) (const_int 29)
6585                      (const_int 14) (const_int 30)
6586                      (const_int 15) (const_int 31)])))]
6587   "TARGET_SSE2"
6588   "punpckhbw\t{%2, %0|%0, %2}"
6589   [(set_attr "type" "sselog")
6590    (set_attr "prefix_data16" "1")
6591    (set_attr "mode" "TI")])
6592
6593 (define_insn "*avx_punpcklbw"
6594   [(set (match_operand:V16QI 0 "register_operand" "=x")
6595         (vec_select:V16QI
6596           (vec_concat:V32QI
6597             (match_operand:V16QI 1 "register_operand" "x")
6598             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6599           (parallel [(const_int 0) (const_int 16)
6600                      (const_int 1) (const_int 17)
6601                      (const_int 2) (const_int 18)
6602                      (const_int 3) (const_int 19)
6603                      (const_int 4) (const_int 20)
6604                      (const_int 5) (const_int 21)
6605                      (const_int 6) (const_int 22)
6606                      (const_int 7) (const_int 23)])))]
6607   "TARGET_AVX"
6608   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6609   [(set_attr "type" "sselog")
6610    (set_attr "prefix" "vex")
6611    (set_attr "mode" "TI")])
6612
6613 (define_insn "sse2_punpcklbw"
6614   [(set (match_operand:V16QI 0 "register_operand" "=x")
6615         (vec_select:V16QI
6616           (vec_concat:V32QI
6617             (match_operand:V16QI 1 "register_operand" "0")
6618             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6619           (parallel [(const_int 0) (const_int 16)
6620                      (const_int 1) (const_int 17)
6621                      (const_int 2) (const_int 18)
6622                      (const_int 3) (const_int 19)
6623                      (const_int 4) (const_int 20)
6624                      (const_int 5) (const_int 21)
6625                      (const_int 6) (const_int 22)
6626                      (const_int 7) (const_int 23)])))]
6627   "TARGET_SSE2"
6628   "punpcklbw\t{%2, %0|%0, %2}"
6629   [(set_attr "type" "sselog")
6630    (set_attr "prefix_data16" "1")
6631    (set_attr "mode" "TI")])
6632
6633 (define_insn "*avx_punpckhwd"
6634   [(set (match_operand:V8HI 0 "register_operand" "=x")
6635         (vec_select:V8HI
6636           (vec_concat:V16HI
6637             (match_operand:V8HI 1 "register_operand" "x")
6638             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6639           (parallel [(const_int 4) (const_int 12)
6640                      (const_int 5) (const_int 13)
6641                      (const_int 6) (const_int 14)
6642                      (const_int 7) (const_int 15)])))]
6643   "TARGET_AVX"
6644   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6645   [(set_attr "type" "sselog")
6646    (set_attr "prefix" "vex")
6647    (set_attr "mode" "TI")])
6648
6649 (define_insn "sse2_punpckhwd"
6650   [(set (match_operand:V8HI 0 "register_operand" "=x")
6651         (vec_select:V8HI
6652           (vec_concat:V16HI
6653             (match_operand:V8HI 1 "register_operand" "0")
6654             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6655           (parallel [(const_int 4) (const_int 12)
6656                      (const_int 5) (const_int 13)
6657                      (const_int 6) (const_int 14)
6658                      (const_int 7) (const_int 15)])))]
6659   "TARGET_SSE2"
6660   "punpckhwd\t{%2, %0|%0, %2}"
6661   [(set_attr "type" "sselog")
6662    (set_attr "prefix_data16" "1")
6663    (set_attr "mode" "TI")])
6664
6665 (define_insn "*avx_punpcklwd"
6666   [(set (match_operand:V8HI 0 "register_operand" "=x")
6667         (vec_select:V8HI
6668           (vec_concat:V16HI
6669             (match_operand:V8HI 1 "register_operand" "x")
6670             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6671           (parallel [(const_int 0) (const_int 8)
6672                      (const_int 1) (const_int 9)
6673                      (const_int 2) (const_int 10)
6674                      (const_int 3) (const_int 11)])))]
6675   "TARGET_AVX"
6676   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6677   [(set_attr "type" "sselog")
6678    (set_attr "prefix" "vex")
6679    (set_attr "mode" "TI")])
6680
6681 (define_insn "sse2_punpcklwd"
6682   [(set (match_operand:V8HI 0 "register_operand" "=x")
6683         (vec_select:V8HI
6684           (vec_concat:V16HI
6685             (match_operand:V8HI 1 "register_operand" "0")
6686             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6687           (parallel [(const_int 0) (const_int 8)
6688                      (const_int 1) (const_int 9)
6689                      (const_int 2) (const_int 10)
6690                      (const_int 3) (const_int 11)])))]
6691   "TARGET_SSE2"
6692   "punpcklwd\t{%2, %0|%0, %2}"
6693   [(set_attr "type" "sselog")
6694    (set_attr "prefix_data16" "1")
6695    (set_attr "mode" "TI")])
6696
6697 (define_insn "*avx_punpckhdq"
6698   [(set (match_operand:V4SI 0 "register_operand" "=x")
6699         (vec_select:V4SI
6700           (vec_concat:V8SI
6701             (match_operand:V4SI 1 "register_operand" "x")
6702             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6703           (parallel [(const_int 2) (const_int 6)
6704                      (const_int 3) (const_int 7)])))]
6705   "TARGET_AVX"
6706   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6707   [(set_attr "type" "sselog")
6708    (set_attr "prefix" "vex")
6709    (set_attr "mode" "TI")])
6710
6711 (define_insn "sse2_punpckhdq"
6712   [(set (match_operand:V4SI 0 "register_operand" "=x")
6713         (vec_select:V4SI
6714           (vec_concat:V8SI
6715             (match_operand:V4SI 1 "register_operand" "0")
6716             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6717           (parallel [(const_int 2) (const_int 6)
6718                      (const_int 3) (const_int 7)])))]
6719   "TARGET_SSE2"
6720   "punpckhdq\t{%2, %0|%0, %2}"
6721   [(set_attr "type" "sselog")
6722    (set_attr "prefix_data16" "1")
6723    (set_attr "mode" "TI")])
6724
6725 (define_insn "*avx_punpckldq"
6726   [(set (match_operand:V4SI 0 "register_operand" "=x")
6727         (vec_select:V4SI
6728           (vec_concat:V8SI
6729             (match_operand:V4SI 1 "register_operand" "x")
6730             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6731           (parallel [(const_int 0) (const_int 4)
6732                      (const_int 1) (const_int 5)])))]
6733   "TARGET_AVX"
6734   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6735   [(set_attr "type" "sselog")
6736    (set_attr "prefix" "vex")
6737    (set_attr "mode" "TI")])
6738
6739 (define_insn "sse2_punpckldq"
6740   [(set (match_operand:V4SI 0 "register_operand" "=x")
6741         (vec_select:V4SI
6742           (vec_concat:V8SI
6743             (match_operand:V4SI 1 "register_operand" "0")
6744             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6745           (parallel [(const_int 0) (const_int 4)
6746                      (const_int 1) (const_int 5)])))]
6747   "TARGET_SSE2"
6748   "punpckldq\t{%2, %0|%0, %2}"
6749   [(set_attr "type" "sselog")
6750    (set_attr "prefix_data16" "1")
6751    (set_attr "mode" "TI")])
6752
6753 (define_insn "*avx_pinsr<ssevecsize>"
6754   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6755         (vec_merge:SSEMODE124
6756           (vec_duplicate:SSEMODE124
6757             (match_operand:<avxscalarmode> 2 "nonimmediate_operand" "rm"))
6758           (match_operand:SSEMODE124 1 "register_operand" "x")
6759           (match_operand:SI 3 "const_pow2_1_to_<pinsrbits>_operand" "n")))]
6760   "TARGET_AVX"
6761 {
6762   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6763   return "vpinsr<ssevecsize>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6764 }
6765   [(set_attr "type" "sselog")
6766    (set (attr "prefix_extra")
6767      (if_then_else (match_operand:V8HI 0 "register_operand" "")
6768        (const_string "0")
6769        (const_string "1")))
6770    (set_attr "length_immediate" "1")
6771    (set_attr "prefix" "vex")
6772    (set_attr "mode" "TI")])
6773
6774 (define_insn "*sse4_1_pinsrb"
6775   [(set (match_operand:V16QI 0 "register_operand" "=x")
6776         (vec_merge:V16QI
6777           (vec_duplicate:V16QI
6778             (match_operand:QI 2 "nonimmediate_operand" "rm"))
6779           (match_operand:V16QI 1 "register_operand" "0")
6780           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
6781   "TARGET_SSE4_1"
6782 {
6783   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6784   return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
6785 }
6786   [(set_attr "type" "sselog")
6787    (set_attr "prefix_extra" "1")
6788    (set_attr "length_immediate" "1")
6789    (set_attr "mode" "TI")])
6790
6791 (define_insn "*sse2_pinsrw"
6792   [(set (match_operand:V8HI 0 "register_operand" "=x")
6793         (vec_merge:V8HI
6794           (vec_duplicate:V8HI
6795             (match_operand:HI 2 "nonimmediate_operand" "rm"))
6796           (match_operand:V8HI 1 "register_operand" "0")
6797           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
6798   "TARGET_SSE2"
6799 {
6800   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6801   return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
6802 }
6803   [(set_attr "type" "sselog")
6804    (set_attr "prefix_data16" "1")
6805    (set_attr "length_immediate" "1")
6806    (set_attr "mode" "TI")])
6807
6808 ;; It must come before sse2_loadld since it is preferred.
6809 (define_insn "*sse4_1_pinsrd"
6810   [(set (match_operand:V4SI 0 "register_operand" "=x")
6811         (vec_merge:V4SI
6812           (vec_duplicate:V4SI
6813             (match_operand:SI 2 "nonimmediate_operand" "rm"))
6814           (match_operand:V4SI 1 "register_operand" "0")
6815           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
6816   "TARGET_SSE4_1"
6817 {
6818   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6819   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
6820 }
6821   [(set_attr "type" "sselog")
6822    (set_attr "prefix_extra" "1")
6823    (set_attr "length_immediate" "1")
6824    (set_attr "mode" "TI")])
6825
6826 (define_insn "*avx_pinsrq"
6827   [(set (match_operand:V2DI 0 "register_operand" "=x")
6828         (vec_merge:V2DI
6829           (vec_duplicate:V2DI
6830             (match_operand:DI 2 "nonimmediate_operand" "rm"))
6831           (match_operand:V2DI 1 "register_operand" "x")
6832           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
6833   "TARGET_AVX && TARGET_64BIT"
6834 {
6835   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6836   return "vpinsrq\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6837 }
6838   [(set_attr "type" "sselog")
6839    (set_attr "prefix_extra" "1")
6840    (set_attr "length_immediate" "1")
6841    (set_attr "prefix" "vex")
6842    (set_attr "mode" "TI")])
6843
6844 (define_insn "*sse4_1_pinsrq"
6845   [(set (match_operand:V2DI 0 "register_operand" "=x")
6846         (vec_merge:V2DI
6847           (vec_duplicate:V2DI
6848             (match_operand:DI 2 "nonimmediate_operand" "rm"))
6849           (match_operand:V2DI 1 "register_operand" "0")
6850           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
6851   "TARGET_SSE4_1 && TARGET_64BIT"
6852 {
6853   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6854   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
6855 }
6856   [(set_attr "type" "sselog")
6857    (set_attr "prefix_rex" "1")
6858    (set_attr "prefix_extra" "1")
6859    (set_attr "length_immediate" "1")
6860    (set_attr "mode" "TI")])
6861
6862 (define_insn "*sse4_1_pextrb"
6863   [(set (match_operand:SI 0 "register_operand" "=r")
6864         (zero_extend:SI
6865           (vec_select:QI
6866             (match_operand:V16QI 1 "register_operand" "x")
6867             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
6868   "TARGET_SSE4_1"
6869   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
6870   [(set_attr "type" "sselog")
6871    (set_attr "prefix_extra" "1")
6872    (set_attr "length_immediate" "1")
6873    (set_attr "prefix" "maybe_vex")
6874    (set_attr "mode" "TI")])
6875
6876 (define_insn "*sse4_1_pextrb_memory"
6877   [(set (match_operand:QI 0 "memory_operand" "=m")
6878         (vec_select:QI
6879           (match_operand:V16QI 1 "register_operand" "x")
6880           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
6881   "TARGET_SSE4_1"
6882   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
6883   [(set_attr "type" "sselog")
6884    (set_attr "prefix_extra" "1")
6885    (set_attr "length_immediate" "1")
6886    (set_attr "prefix" "maybe_vex")
6887    (set_attr "mode" "TI")])
6888
6889 (define_insn "*sse2_pextrw"
6890   [(set (match_operand:SI 0 "register_operand" "=r")
6891         (zero_extend:SI
6892           (vec_select:HI
6893             (match_operand:V8HI 1 "register_operand" "x")
6894             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
6895   "TARGET_SSE2"
6896   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
6897   [(set_attr "type" "sselog")
6898    (set_attr "prefix_data16" "1")
6899    (set_attr "length_immediate" "1")
6900    (set_attr "prefix" "maybe_vex")
6901    (set_attr "mode" "TI")])
6902
6903 (define_insn "*sse4_1_pextrw_memory"
6904   [(set (match_operand:HI 0 "memory_operand" "=m")
6905         (vec_select:HI
6906           (match_operand:V8HI 1 "register_operand" "x")
6907           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
6908   "TARGET_SSE4_1"
6909   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
6910   [(set_attr "type" "sselog")
6911    (set_attr "prefix_extra" "1")
6912    (set_attr "length_immediate" "1")
6913    (set_attr "prefix" "maybe_vex")
6914    (set_attr "mode" "TI")])
6915
6916 (define_insn "*sse4_1_pextrd"
6917   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
6918         (vec_select:SI
6919           (match_operand:V4SI 1 "register_operand" "x")
6920           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
6921   "TARGET_SSE4_1"
6922   "%vpextrd\t{%2, %1, %0|%0, %1, %2}"
6923   [(set_attr "type" "sselog")
6924    (set_attr "prefix_extra" "1")
6925    (set_attr "length_immediate" "1")
6926    (set_attr "prefix" "maybe_vex")
6927    (set_attr "mode" "TI")])
6928
6929 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
6930 (define_insn "*sse4_1_pextrq"
6931   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
6932         (vec_select:DI
6933           (match_operand:V2DI 1 "register_operand" "x")
6934           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
6935   "TARGET_SSE4_1 && TARGET_64BIT"
6936   "%vpextrq\t{%2, %1, %0|%0, %1, %2}"
6937   [(set_attr "type" "sselog")
6938    (set_attr "prefix_rex" "1")
6939    (set_attr "prefix_extra" "1")
6940    (set_attr "length_immediate" "1")
6941    (set_attr "prefix" "maybe_vex")
6942    (set_attr "mode" "TI")])
6943
6944 (define_expand "sse2_pshufd"
6945   [(match_operand:V4SI 0 "register_operand" "")
6946    (match_operand:V4SI 1 "nonimmediate_operand" "")
6947    (match_operand:SI 2 "const_int_operand" "")]
6948   "TARGET_SSE2"
6949 {
6950   int mask = INTVAL (operands[2]);
6951   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
6952                                 GEN_INT ((mask >> 0) & 3),
6953                                 GEN_INT ((mask >> 2) & 3),
6954                                 GEN_INT ((mask >> 4) & 3),
6955                                 GEN_INT ((mask >> 6) & 3)));
6956   DONE;
6957 })
6958
6959 (define_insn "sse2_pshufd_1"
6960   [(set (match_operand:V4SI 0 "register_operand" "=x")
6961         (vec_select:V4SI
6962           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
6963           (parallel [(match_operand 2 "const_0_to_3_operand" "")
6964                      (match_operand 3 "const_0_to_3_operand" "")
6965                      (match_operand 4 "const_0_to_3_operand" "")
6966                      (match_operand 5 "const_0_to_3_operand" "")])))]
6967   "TARGET_SSE2"
6968 {
6969   int mask = 0;
6970   mask |= INTVAL (operands[2]) << 0;
6971   mask |= INTVAL (operands[3]) << 2;
6972   mask |= INTVAL (operands[4]) << 4;
6973   mask |= INTVAL (operands[5]) << 6;
6974   operands[2] = GEN_INT (mask);
6975
6976   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
6977 }
6978   [(set_attr "type" "sselog1")
6979    (set_attr "prefix_data16" "1")
6980    (set_attr "prefix" "maybe_vex")
6981    (set_attr "length_immediate" "1")
6982    (set_attr "mode" "TI")])
6983
6984 (define_expand "sse2_pshuflw"
6985   [(match_operand:V8HI 0 "register_operand" "")
6986    (match_operand:V8HI 1 "nonimmediate_operand" "")
6987    (match_operand:SI 2 "const_int_operand" "")]
6988   "TARGET_SSE2"
6989 {
6990   int mask = INTVAL (operands[2]);
6991   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
6992                                  GEN_INT ((mask >> 0) & 3),
6993                                  GEN_INT ((mask >> 2) & 3),
6994                                  GEN_INT ((mask >> 4) & 3),
6995                                  GEN_INT ((mask >> 6) & 3)));
6996   DONE;
6997 })
6998
6999 (define_insn "sse2_pshuflw_1"
7000   [(set (match_operand:V8HI 0 "register_operand" "=x")
7001         (vec_select:V8HI
7002           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7003           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7004                      (match_operand 3 "const_0_to_3_operand" "")
7005                      (match_operand 4 "const_0_to_3_operand" "")
7006                      (match_operand 5 "const_0_to_3_operand" "")
7007                      (const_int 4)
7008                      (const_int 5)
7009                      (const_int 6)
7010                      (const_int 7)])))]
7011   "TARGET_SSE2"
7012 {
7013   int mask = 0;
7014   mask |= INTVAL (operands[2]) << 0;
7015   mask |= INTVAL (operands[3]) << 2;
7016   mask |= INTVAL (operands[4]) << 4;
7017   mask |= INTVAL (operands[5]) << 6;
7018   operands[2] = GEN_INT (mask);
7019
7020   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7021 }
7022   [(set_attr "type" "sselog")
7023    (set_attr "prefix_data16" "0")
7024    (set_attr "prefix_rep" "1")
7025    (set_attr "prefix" "maybe_vex")
7026    (set_attr "length_immediate" "1")
7027    (set_attr "mode" "TI")])
7028
7029 (define_expand "sse2_pshufhw"
7030   [(match_operand:V8HI 0 "register_operand" "")
7031    (match_operand:V8HI 1 "nonimmediate_operand" "")
7032    (match_operand:SI 2 "const_int_operand" "")]
7033   "TARGET_SSE2"
7034 {
7035   int mask = INTVAL (operands[2]);
7036   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
7037                                  GEN_INT (((mask >> 0) & 3) + 4),
7038                                  GEN_INT (((mask >> 2) & 3) + 4),
7039                                  GEN_INT (((mask >> 4) & 3) + 4),
7040                                  GEN_INT (((mask >> 6) & 3) + 4)));
7041   DONE;
7042 })
7043
7044 (define_insn "sse2_pshufhw_1"
7045   [(set (match_operand:V8HI 0 "register_operand" "=x")
7046         (vec_select:V8HI
7047           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7048           (parallel [(const_int 0)
7049                      (const_int 1)
7050                      (const_int 2)
7051                      (const_int 3)
7052                      (match_operand 2 "const_4_to_7_operand" "")
7053                      (match_operand 3 "const_4_to_7_operand" "")
7054                      (match_operand 4 "const_4_to_7_operand" "")
7055                      (match_operand 5 "const_4_to_7_operand" "")])))]
7056   "TARGET_SSE2"
7057 {
7058   int mask = 0;
7059   mask |= (INTVAL (operands[2]) - 4) << 0;
7060   mask |= (INTVAL (operands[3]) - 4) << 2;
7061   mask |= (INTVAL (operands[4]) - 4) << 4;
7062   mask |= (INTVAL (operands[5]) - 4) << 6;
7063   operands[2] = GEN_INT (mask);
7064
7065   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7066 }
7067   [(set_attr "type" "sselog")
7068    (set_attr "prefix_rep" "1")
7069    (set_attr "prefix_data16" "0")
7070    (set_attr "prefix" "maybe_vex")
7071    (set_attr "length_immediate" "1")
7072    (set_attr "mode" "TI")])
7073
7074 (define_expand "sse2_loadd"
7075   [(set (match_operand:V4SI 0 "register_operand" "")
7076         (vec_merge:V4SI
7077           (vec_duplicate:V4SI
7078             (match_operand:SI 1 "nonimmediate_operand" ""))
7079           (match_dup 2)
7080           (const_int 1)))]
7081   "TARGET_SSE"
7082   "operands[2] = CONST0_RTX (V4SImode);")
7083
7084 (define_insn "*avx_loadld"
7085   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x")
7086         (vec_merge:V4SI
7087           (vec_duplicate:V4SI
7088             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,x"))
7089           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,x")
7090           (const_int 1)))]
7091   "TARGET_AVX"
7092   "@
7093    vmovd\t{%2, %0|%0, %2}
7094    vmovd\t{%2, %0|%0, %2}
7095    vmovss\t{%2, %1, %0|%0, %1, %2}"
7096   [(set_attr "type" "ssemov")
7097    (set_attr "prefix" "vex")
7098    (set_attr "mode" "TI,TI,V4SF")])
7099
7100 (define_insn "sse2_loadld"
7101   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,Yi,x,x")
7102         (vec_merge:V4SI
7103           (vec_duplicate:V4SI
7104             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
7105           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
7106           (const_int 1)))]
7107   "TARGET_SSE"
7108   "@
7109    movd\t{%2, %0|%0, %2}
7110    movd\t{%2, %0|%0, %2}
7111    movss\t{%2, %0|%0, %2}
7112    movss\t{%2, %0|%0, %2}"
7113   [(set_attr "type" "ssemov")
7114    (set_attr "mode" "TI,TI,V4SF,SF")])
7115
7116 (define_insn_and_split "sse2_stored"
7117   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
7118         (vec_select:SI
7119           (match_operand:V4SI 1 "register_operand" "x,Yi")
7120           (parallel [(const_int 0)])))]
7121   "TARGET_SSE"
7122   "#"
7123   "&& reload_completed
7124    && (TARGET_INTER_UNIT_MOVES
7125        || MEM_P (operands [0])
7126        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7127   [(set (match_dup 0) (match_dup 1))]
7128 {
7129   operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));
7130 })
7131
7132 (define_insn_and_split "*vec_ext_v4si_mem"
7133   [(set (match_operand:SI 0 "register_operand" "=r")
7134         (vec_select:SI
7135           (match_operand:V4SI 1 "memory_operand" "o")
7136           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
7137   ""
7138   "#"
7139   "reload_completed"
7140   [(const_int 0)]
7141 {
7142   int i = INTVAL (operands[2]);
7143
7144   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
7145   DONE;
7146 })
7147
7148 (define_expand "sse_storeq"
7149   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7150         (vec_select:DI
7151           (match_operand:V2DI 1 "register_operand" "")
7152           (parallel [(const_int 0)])))]
7153   "TARGET_SSE"
7154   "")
7155
7156 (define_insn "*sse2_storeq_rex64"
7157   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,*r,r")
7158         (vec_select:DI
7159           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
7160           (parallel [(const_int 0)])))]
7161   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7162   "@
7163    #
7164    #
7165    %vmov{q}\t{%1, %0|%0, %1}"
7166   [(set_attr "type" "*,*,imov")
7167    (set_attr "prefix" "*,*,maybe_vex")
7168    (set_attr "mode" "*,*,DI")])
7169
7170 (define_insn "*sse2_storeq"
7171   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
7172         (vec_select:DI
7173           (match_operand:V2DI 1 "register_operand" "x")
7174           (parallel [(const_int 0)])))]
7175   "TARGET_SSE"
7176   "#")
7177
7178 (define_split
7179   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7180         (vec_select:DI
7181           (match_operand:V2DI 1 "register_operand" "")
7182           (parallel [(const_int 0)])))]
7183   "TARGET_SSE
7184    && reload_completed
7185    && (TARGET_INTER_UNIT_MOVES
7186        || MEM_P (operands [0])
7187        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7188   [(set (match_dup 0) (match_dup 1))]
7189 {
7190   operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));
7191 })
7192
7193 (define_insn "*vec_extractv2di_1_rex64_avx"
7194   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7195         (vec_select:DI
7196           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o,o")
7197           (parallel [(const_int 1)])))]
7198   "TARGET_64BIT
7199    && TARGET_AVX
7200    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7201   "@
7202    vmovhps\t{%1, %0|%0, %1}
7203    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7204    vmovq\t{%H1, %0|%0, %H1}
7205    vmov{q}\t{%H1, %0|%0, %H1}"
7206   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7207    (set_attr "length_immediate" "*,1,*,*")
7208    (set_attr "memory" "*,none,*,*")
7209    (set_attr "prefix" "vex")
7210    (set_attr "mode" "V2SF,TI,TI,DI")])
7211
7212 (define_insn "*vec_extractv2di_1_rex64"
7213   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7214         (vec_select:DI
7215           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
7216           (parallel [(const_int 1)])))]
7217   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7218   "@
7219    movhps\t{%1, %0|%0, %1}
7220    psrldq\t{$8, %0|%0, 8}
7221    movq\t{%H1, %0|%0, %H1}
7222    mov{q}\t{%H1, %0|%0, %H1}"
7223   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
7224    (set_attr "length_immediate" "*,1,*,*")
7225    (set_attr "atom_unit" "*,sishuf,*,*")
7226    (set_attr "memory" "*,none,*,*")
7227    (set_attr "mode" "V2SF,TI,TI,DI")])
7228
7229 (define_insn "*vec_extractv2di_1_avx"
7230   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7231         (vec_select:DI
7232           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7233           (parallel [(const_int 1)])))]
7234   "!TARGET_64BIT
7235    && TARGET_AVX
7236    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7237   "@
7238    vmovhps\t{%1, %0|%0, %1}
7239    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7240    vmovq\t{%H1, %0|%0, %H1}"
7241   [(set_attr "type" "ssemov,sseishft,ssemov")
7242    (set_attr "length_immediate" "*,1,*")
7243    (set_attr "memory" "*,none,*")
7244    (set_attr "prefix" "vex")
7245    (set_attr "mode" "V2SF,TI,TI")])
7246
7247 (define_insn "*vec_extractv2di_1_sse2"
7248   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7249         (vec_select:DI
7250           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
7251           (parallel [(const_int 1)])))]
7252   "!TARGET_64BIT
7253    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7254   "@
7255    movhps\t{%1, %0|%0, %1}
7256    psrldq\t{$8, %0|%0, 8}
7257    movq\t{%H1, %0|%0, %H1}"
7258   [(set_attr "type" "ssemov,sseishft,ssemov")
7259    (set_attr "length_immediate" "*,1,*")
7260    (set_attr "atom_unit" "*,sishuf,*")
7261    (set_attr "memory" "*,none,*")
7262    (set_attr "mode" "V2SF,TI,TI")])
7263
7264 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
7265 (define_insn "*vec_extractv2di_1_sse"
7266   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7267         (vec_select:DI
7268           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7269           (parallel [(const_int 1)])))]
7270   "!TARGET_SSE2 && TARGET_SSE
7271    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7272   "@
7273    movhps\t{%1, %0|%0, %1}
7274    movhlps\t{%1, %0|%0, %1}
7275    movlps\t{%H1, %0|%0, %H1}"
7276   [(set_attr "type" "ssemov")
7277    (set_attr "mode" "V2SF,V4SF,V2SF")])
7278
7279 (define_insn "*vec_dupv4si"
7280   [(set (match_operand:V4SI 0 "register_operand" "=Y2,x")
7281         (vec_duplicate:V4SI
7282           (match_operand:SI 1 "register_operand" " Y2,0")))]
7283   "TARGET_SSE"
7284   "@
7285    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7286    shufps\t{$0, %0, %0|%0, %0, 0}"
7287   [(set_attr "type" "sselog1")
7288    (set_attr "prefix" "maybe_vex,orig")
7289    (set_attr "length_immediate" "1")
7290    (set_attr "mode" "TI,V4SF")])
7291
7292 (define_insn "*vec_dupv2di_avx"
7293   [(set (match_operand:V2DI 0 "register_operand" "=x")
7294         (vec_duplicate:V2DI
7295           (match_operand:DI 1 "register_operand" "x")))]
7296   "TARGET_AVX"
7297   "vpunpcklqdq\t{%1, %1, %0|%0, %1, %1}"
7298   [(set_attr "type" "sselog1")
7299    (set_attr "prefix" "vex")
7300    (set_attr "mode" "TI")])
7301
7302 (define_insn "*vec_dupv2di"
7303   [(set (match_operand:V2DI 0 "register_operand" "=Y2,x")
7304         (vec_duplicate:V2DI
7305           (match_operand:DI 1 "register_operand" " 0 ,0")))]
7306   "TARGET_SSE"
7307   "@
7308    punpcklqdq\t%0, %0
7309    movlhps\t%0, %0"
7310   [(set_attr "type" "sselog1,ssemov")
7311    (set_attr "mode" "TI,V4SF")])
7312
7313 (define_insn "*vec_concatv2si_avx"
7314   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7315         (vec_concat:V2SI
7316           (match_operand:SI 1 "nonimmediate_operand" "x ,x,rm, 0 ,rm")
7317           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7318   "TARGET_AVX"
7319   "@
7320    vpinsrd\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7321    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7322    vmovd\t{%1, %0|%0, %1}
7323    punpckldq\t{%2, %0|%0, %2}
7324    movd\t{%1, %0|%0, %1}"
7325   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7326    (set_attr "prefix_extra" "1,*,*,*,*")
7327    (set_attr "length_immediate" "1,*,*,*,*")
7328    (set (attr "prefix")
7329      (if_then_else (eq_attr "alternative" "3,4")
7330        (const_string "orig")
7331        (const_string "vex")))
7332    (set_attr "mode" "TI,TI,TI,DI,DI")])
7333
7334 (define_insn "*vec_concatv2si_sse4_1"
7335   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7336         (vec_concat:V2SI
7337           (match_operand:SI 1 "nonimmediate_operand" "0 ,0,rm, 0 ,rm")
7338           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7339   "TARGET_SSE4_1"
7340   "@
7341    pinsrd\t{$0x1, %2, %0|%0, %2, 0x1}
7342    punpckldq\t{%2, %0|%0, %2}
7343    movd\t{%1, %0|%0, %1}
7344    punpckldq\t{%2, %0|%0, %2}
7345    movd\t{%1, %0|%0, %1}"
7346   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7347    (set_attr "prefix_extra" "1,*,*,*,*")
7348    (set_attr "length_immediate" "1,*,*,*,*")
7349    (set_attr "mode" "TI,TI,TI,DI,DI")])
7350
7351 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7352 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7353 ;; alternatives pretty much forces the MMX alternative to be chosen.
7354 (define_insn "*vec_concatv2si_sse2"
7355   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,*y")
7356         (vec_concat:V2SI
7357           (match_operand:SI 1 "nonimmediate_operand" " 0,rm, 0,rm")
7358           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,*y, C")))]
7359   "TARGET_SSE2"
7360   "@
7361    punpckldq\t{%2, %0|%0, %2}
7362    movd\t{%1, %0|%0, %1}
7363    punpckldq\t{%2, %0|%0, %2}
7364    movd\t{%1, %0|%0, %1}"
7365   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7366    (set_attr "mode" "TI,TI,DI,DI")])
7367
7368 (define_insn "*vec_concatv2si_sse"
7369   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
7370         (vec_concat:V2SI
7371           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
7372           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
7373   "TARGET_SSE"
7374   "@
7375    unpcklps\t{%2, %0|%0, %2}
7376    movss\t{%1, %0|%0, %1}
7377    punpckldq\t{%2, %0|%0, %2}
7378    movd\t{%1, %0|%0, %1}"
7379   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7380    (set_attr "mode" "V4SF,V4SF,DI,DI")])
7381
7382 (define_insn "*vec_concatv4si_1_avx"
7383   [(set (match_operand:V4SI 0 "register_operand"       "=x,x")
7384         (vec_concat:V4SI
7385           (match_operand:V2SI 1 "register_operand"     " x,x")
7386           (match_operand:V2SI 2 "nonimmediate_operand" " x,m")))]
7387   "TARGET_AVX"
7388   "@
7389    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7390    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7391   [(set_attr "type" "sselog,ssemov")
7392    (set_attr "prefix" "vex")
7393    (set_attr "mode" "TI,V2SF")])
7394
7395 (define_insn "*vec_concatv4si_1"
7396   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,x,x")
7397         (vec_concat:V4SI
7398           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
7399           (match_operand:V2SI 2 "nonimmediate_operand" " Y2,x,m")))]
7400   "TARGET_SSE"
7401   "@
7402    punpcklqdq\t{%2, %0|%0, %2}
7403    movlhps\t{%2, %0|%0, %2}
7404    movhps\t{%2, %0|%0, %2}"
7405   [(set_attr "type" "sselog,ssemov,ssemov")
7406    (set_attr "mode" "TI,V4SF,V2SF")])
7407
7408 (define_insn "*vec_concatv2di_avx"
7409   [(set (match_operand:V2DI 0 "register_operand"     "=x,?x,x,x")
7410         (vec_concat:V2DI
7411           (match_operand:DI 1 "nonimmediate_operand" " m,*y,x,x")
7412           (match_operand:DI 2 "vector_move_operand"  " C, C,x,m")))]
7413   "!TARGET_64BIT && TARGET_AVX"
7414   "@
7415    vmovq\t{%1, %0|%0, %1}
7416    movq2dq\t{%1, %0|%0, %1}
7417    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7418    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7419   [(set_attr "type" "ssemov,ssemov,sselog,ssemov")
7420    (set (attr "prefix")
7421      (if_then_else (eq_attr "alternative" "1")
7422        (const_string "orig")
7423        (const_string "vex")))
7424    (set_attr "mode" "TI,TI,TI,V2SF")])
7425
7426 (define_insn "vec_concatv2di"
7427   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,?Y2,Y2,x,x")
7428         (vec_concat:V2DI
7429           (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0")
7430           (match_operand:DI 2 "vector_move_operand"  " C  ,  C,Y2,x,m")))]
7431   "!TARGET_64BIT && TARGET_SSE"
7432   "@
7433    movq\t{%1, %0|%0, %1}
7434    movq2dq\t{%1, %0|%0, %1}
7435    punpcklqdq\t{%2, %0|%0, %2}
7436    movlhps\t{%2, %0|%0, %2}
7437    movhps\t{%2, %0|%0, %2}"
7438   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov")
7439    (set_attr "mode" "TI,TI,TI,V4SF,V2SF")])
7440
7441 (define_insn "*vec_concatv2di_rex64_avx"
7442   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,Yi,!x,x,x")
7443         (vec_concat:V2DI
7444           (match_operand:DI 1 "nonimmediate_operand" " x,m,r ,*y,x,x")
7445           (match_operand:DI 2 "vector_move_operand"  "rm,C,C ,C ,x,m")))]
7446   "TARGET_64BIT && TARGET_AVX"
7447   "@
7448    vpinsrq\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7449    vmovq\t{%1, %0|%0, %1}
7450    vmovq\t{%1, %0|%0, %1}
7451    movq2dq\t{%1, %0|%0, %1}
7452    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7453    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7454   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov")
7455    (set_attr "prefix_extra" "1,*,*,*,*,*")
7456    (set_attr "length_immediate" "1,*,*,*,*,*")
7457    (set (attr "prefix")
7458      (if_then_else (eq_attr "alternative" "3")
7459        (const_string "orig")
7460        (const_string "vex")))
7461    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
7462
7463 (define_insn "*vec_concatv2di_rex64_sse4_1"
7464   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
7465         (vec_concat:V2DI
7466           (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0")
7467           (match_operand:DI 2 "vector_move_operand"  " rm,C ,C ,C ,x,x,m")))]
7468   "TARGET_64BIT && TARGET_SSE4_1"
7469   "@
7470    pinsrq\t{$0x1, %2, %0|%0, %2, 0x1}
7471    movq\t{%1, %0|%0, %1}
7472    movq\t{%1, %0|%0, %1}
7473    movq2dq\t{%1, %0|%0, %1}
7474    punpcklqdq\t{%2, %0|%0, %2}
7475    movlhps\t{%2, %0|%0, %2}
7476    movhps\t{%2, %0|%0, %2}"
7477   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7478    (set_attr "prefix_rex" "1,*,1,*,*,*,*")
7479    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7480    (set_attr "length_immediate" "1,*,*,*,*,*,*")
7481    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
7482
7483 (define_insn "*vec_concatv2di_rex64_sse"
7484   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
7485         (vec_concat:V2DI
7486           (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0")
7487           (match_operand:DI 2 "vector_move_operand"  " C  ,C ,C  ,Y2,x,m")))]
7488   "TARGET_64BIT && TARGET_SSE"
7489   "@
7490    movq\t{%1, %0|%0, %1}
7491    movq\t{%1, %0|%0, %1}
7492    movq2dq\t{%1, %0|%0, %1}
7493    punpcklqdq\t{%2, %0|%0, %2}
7494    movlhps\t{%2, %0|%0, %2}
7495    movhps\t{%2, %0|%0, %2}"
7496   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7497    (set_attr "prefix_rex" "*,1,*,*,*,*")
7498    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")])
7499
7500 (define_expand "vec_unpacku_hi_v16qi"
7501   [(match_operand:V8HI 0 "register_operand" "")
7502    (match_operand:V16QI 1 "register_operand" "")]
7503   "TARGET_SSE2"
7504 {
7505   if (TARGET_SSE4_1)
7506     ix86_expand_sse4_unpack (operands, true, true);
7507   else if (TARGET_SSE5)
7508     ix86_expand_sse5_unpack (operands, true, true);
7509   else
7510     ix86_expand_sse_unpack (operands, true, true);
7511   DONE;
7512 })
7513
7514 (define_expand "vec_unpacks_hi_v16qi"
7515   [(match_operand:V8HI 0 "register_operand" "")
7516    (match_operand:V16QI 1 "register_operand" "")]
7517   "TARGET_SSE2"
7518 {
7519   if (TARGET_SSE4_1)
7520     ix86_expand_sse4_unpack (operands, false, true);
7521   else if (TARGET_SSE5)
7522     ix86_expand_sse5_unpack (operands, false, true);
7523   else
7524     ix86_expand_sse_unpack (operands, false, true);
7525   DONE;
7526 })
7527
7528 (define_expand "vec_unpacku_lo_v16qi"
7529   [(match_operand:V8HI 0 "register_operand" "")
7530    (match_operand:V16QI 1 "register_operand" "")]
7531   "TARGET_SSE2"
7532 {
7533   if (TARGET_SSE4_1)
7534     ix86_expand_sse4_unpack (operands, true, false);
7535   else if (TARGET_SSE5)
7536     ix86_expand_sse5_unpack (operands, true, false);
7537   else
7538     ix86_expand_sse_unpack (operands, true, false);
7539   DONE;
7540 })
7541
7542 (define_expand "vec_unpacks_lo_v16qi"
7543   [(match_operand:V8HI 0 "register_operand" "")
7544    (match_operand:V16QI 1 "register_operand" "")]
7545   "TARGET_SSE2"
7546 {
7547   if (TARGET_SSE4_1)
7548     ix86_expand_sse4_unpack (operands, false, false);
7549   else if (TARGET_SSE5)
7550     ix86_expand_sse5_unpack (operands, false, false);
7551   else
7552     ix86_expand_sse_unpack (operands, false, false);
7553   DONE;
7554 })
7555
7556 (define_expand "vec_unpacku_hi_v8hi"
7557   [(match_operand:V4SI 0 "register_operand" "")
7558    (match_operand:V8HI 1 "register_operand" "")]
7559   "TARGET_SSE2"
7560 {
7561   if (TARGET_SSE4_1)
7562     ix86_expand_sse4_unpack (operands, true, true);
7563   else if (TARGET_SSE5)
7564     ix86_expand_sse5_unpack (operands, true, true);
7565   else
7566     ix86_expand_sse_unpack (operands, true, true);
7567   DONE;
7568 })
7569
7570 (define_expand "vec_unpacks_hi_v8hi"
7571   [(match_operand:V4SI 0 "register_operand" "")
7572    (match_operand:V8HI 1 "register_operand" "")]
7573   "TARGET_SSE2"
7574 {
7575   if (TARGET_SSE4_1)
7576     ix86_expand_sse4_unpack (operands, false, true);
7577   else if (TARGET_SSE5)
7578     ix86_expand_sse5_unpack (operands, false, true);
7579   else
7580     ix86_expand_sse_unpack (operands, false, true);
7581   DONE;
7582 })
7583
7584 (define_expand "vec_unpacku_lo_v8hi"
7585   [(match_operand:V4SI 0 "register_operand" "")
7586    (match_operand:V8HI 1 "register_operand" "")]
7587   "TARGET_SSE2"
7588 {
7589   if (TARGET_SSE4_1)
7590     ix86_expand_sse4_unpack (operands, true, false);
7591   else if (TARGET_SSE5)
7592     ix86_expand_sse5_unpack (operands, true, false);
7593   else
7594     ix86_expand_sse_unpack (operands, true, false);
7595   DONE;
7596 })
7597
7598 (define_expand "vec_unpacks_lo_v8hi"
7599   [(match_operand:V4SI 0 "register_operand" "")
7600    (match_operand:V8HI 1 "register_operand" "")]
7601   "TARGET_SSE2"
7602 {
7603   if (TARGET_SSE4_1)
7604     ix86_expand_sse4_unpack (operands, false, false);
7605   else if (TARGET_SSE5)
7606     ix86_expand_sse5_unpack (operands, false, false);
7607   else
7608     ix86_expand_sse_unpack (operands, false, false);
7609   DONE;
7610 })
7611
7612 (define_expand "vec_unpacku_hi_v4si"
7613   [(match_operand:V2DI 0 "register_operand" "")
7614    (match_operand:V4SI 1 "register_operand" "")]
7615   "TARGET_SSE2"
7616 {
7617   if (TARGET_SSE4_1)
7618     ix86_expand_sse4_unpack (operands, true, true);
7619   else if (TARGET_SSE5)
7620     ix86_expand_sse5_unpack (operands, true, true);
7621   else
7622     ix86_expand_sse_unpack (operands, true, true);
7623   DONE;
7624 })
7625
7626 (define_expand "vec_unpacks_hi_v4si"
7627   [(match_operand:V2DI 0 "register_operand" "")
7628    (match_operand:V4SI 1 "register_operand" "")]
7629   "TARGET_SSE2"
7630 {
7631   if (TARGET_SSE4_1)
7632     ix86_expand_sse4_unpack (operands, false, true);
7633   else if (TARGET_SSE5)
7634     ix86_expand_sse5_unpack (operands, false, true);
7635   else
7636     ix86_expand_sse_unpack (operands, false, true);
7637   DONE;
7638 })
7639
7640 (define_expand "vec_unpacku_lo_v4si"
7641   [(match_operand:V2DI 0 "register_operand" "")
7642    (match_operand:V4SI 1 "register_operand" "")]
7643   "TARGET_SSE2"
7644 {
7645   if (TARGET_SSE4_1)
7646     ix86_expand_sse4_unpack (operands, true, false);
7647   else if (TARGET_SSE5)
7648     ix86_expand_sse5_unpack (operands, true, false);
7649   else
7650     ix86_expand_sse_unpack (operands, true, false);
7651   DONE;
7652 })
7653
7654 (define_expand "vec_unpacks_lo_v4si"
7655   [(match_operand:V2DI 0 "register_operand" "")
7656    (match_operand:V4SI 1 "register_operand" "")]
7657   "TARGET_SSE2"
7658 {
7659   if (TARGET_SSE4_1)
7660     ix86_expand_sse4_unpack (operands, false, false);
7661   else if (TARGET_SSE5)
7662     ix86_expand_sse5_unpack (operands, false, false);
7663   else
7664     ix86_expand_sse_unpack (operands, false, false);
7665   DONE;
7666 })
7667
7668 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7669 ;;
7670 ;; Miscellaneous
7671 ;;
7672 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7673
7674 (define_expand "sse2_uavgv16qi3"
7675   [(set (match_operand:V16QI 0 "register_operand" "")
7676         (truncate:V16QI
7677           (lshiftrt:V16HI
7678             (plus:V16HI
7679               (plus:V16HI
7680                 (zero_extend:V16HI
7681                   (match_operand:V16QI 1 "nonimmediate_operand" ""))
7682                 (zero_extend:V16HI
7683                   (match_operand:V16QI 2 "nonimmediate_operand" "")))
7684               (const_vector:V16QI [(const_int 1) (const_int 1)
7685                                    (const_int 1) (const_int 1)
7686                                    (const_int 1) (const_int 1)
7687                                    (const_int 1) (const_int 1)
7688                                    (const_int 1) (const_int 1)
7689                                    (const_int 1) (const_int 1)
7690                                    (const_int 1) (const_int 1)
7691                                    (const_int 1) (const_int 1)]))
7692             (const_int 1))))]
7693   "TARGET_SSE2"
7694   "ix86_fixup_binary_operands_no_copy (PLUS, V16QImode, operands);")
7695
7696 (define_insn "*avx_uavgv16qi3"
7697   [(set (match_operand:V16QI 0 "register_operand" "=x")
7698         (truncate:V16QI
7699           (lshiftrt:V16HI
7700             (plus:V16HI
7701               (plus:V16HI
7702                 (zero_extend:V16HI
7703                   (match_operand:V16QI 1 "nonimmediate_operand" "%x"))
7704                 (zero_extend:V16HI
7705                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7706               (const_vector:V16QI [(const_int 1) (const_int 1)
7707                                    (const_int 1) (const_int 1)
7708                                    (const_int 1) (const_int 1)
7709                                    (const_int 1) (const_int 1)
7710                                    (const_int 1) (const_int 1)
7711                                    (const_int 1) (const_int 1)
7712                                    (const_int 1) (const_int 1)
7713                                    (const_int 1) (const_int 1)]))
7714             (const_int 1))))]
7715   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7716   "vpavgb\t{%2, %1, %0|%0, %1, %2}"
7717   [(set_attr "type" "sseiadd")
7718    (set_attr "prefix" "vex")
7719    (set_attr "mode" "TI")])
7720
7721 (define_insn "*sse2_uavgv16qi3"
7722   [(set (match_operand:V16QI 0 "register_operand" "=x")
7723         (truncate:V16QI
7724           (lshiftrt:V16HI
7725             (plus:V16HI
7726               (plus:V16HI
7727                 (zero_extend:V16HI
7728                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
7729                 (zero_extend:V16HI
7730                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7731               (const_vector:V16QI [(const_int 1) (const_int 1)
7732                                    (const_int 1) (const_int 1)
7733                                    (const_int 1) (const_int 1)
7734                                    (const_int 1) (const_int 1)
7735                                    (const_int 1) (const_int 1)
7736                                    (const_int 1) (const_int 1)
7737                                    (const_int 1) (const_int 1)
7738                                    (const_int 1) (const_int 1)]))
7739             (const_int 1))))]
7740   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7741   "pavgb\t{%2, %0|%0, %2}"
7742   [(set_attr "type" "sseiadd")
7743    (set_attr "prefix_data16" "1")
7744    (set_attr "mode" "TI")])
7745
7746 (define_expand "sse2_uavgv8hi3"
7747   [(set (match_operand:V8HI 0 "register_operand" "")
7748         (truncate:V8HI
7749           (lshiftrt:V8SI
7750             (plus:V8SI
7751               (plus:V8SI
7752                 (zero_extend:V8SI
7753                   (match_operand:V8HI 1 "nonimmediate_operand" ""))
7754                 (zero_extend:V8SI
7755                   (match_operand:V8HI 2 "nonimmediate_operand" "")))
7756               (const_vector:V8HI [(const_int 1) (const_int 1)
7757                                   (const_int 1) (const_int 1)
7758                                   (const_int 1) (const_int 1)
7759                                   (const_int 1) (const_int 1)]))
7760             (const_int 1))))]
7761   "TARGET_SSE2"
7762   "ix86_fixup_binary_operands_no_copy (PLUS, V8HImode, operands);")
7763
7764 (define_insn "*avx_uavgv8hi3"
7765   [(set (match_operand:V8HI 0 "register_operand" "=x")
7766         (truncate:V8HI
7767           (lshiftrt:V8SI
7768             (plus:V8SI
7769               (plus:V8SI
7770                 (zero_extend:V8SI
7771                   (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
7772                 (zero_extend:V8SI
7773                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7774               (const_vector:V8HI [(const_int 1) (const_int 1)
7775                                   (const_int 1) (const_int 1)
7776                                   (const_int 1) (const_int 1)
7777                                   (const_int 1) (const_int 1)]))
7778             (const_int 1))))]
7779   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7780   "vpavgw\t{%2, %1, %0|%0, %1, %2}"
7781   [(set_attr "type" "sseiadd")
7782    (set_attr "prefix" "vex")
7783    (set_attr "mode" "TI")])
7784
7785 (define_insn "*sse2_uavgv8hi3"
7786   [(set (match_operand:V8HI 0 "register_operand" "=x")
7787         (truncate:V8HI
7788           (lshiftrt:V8SI
7789             (plus:V8SI
7790               (plus:V8SI
7791                 (zero_extend:V8SI
7792                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
7793                 (zero_extend:V8SI
7794                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7795               (const_vector:V8HI [(const_int 1) (const_int 1)
7796                                   (const_int 1) (const_int 1)
7797                                   (const_int 1) (const_int 1)
7798                                   (const_int 1) (const_int 1)]))
7799             (const_int 1))))]
7800   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7801   "pavgw\t{%2, %0|%0, %2}"
7802   [(set_attr "type" "sseiadd")
7803    (set_attr "prefix_data16" "1")
7804    (set_attr "mode" "TI")])
7805
7806 ;; The correct representation for this is absolutely enormous, and
7807 ;; surely not generally useful.
7808 (define_insn "*avx_psadbw"
7809   [(set (match_operand:V2DI 0 "register_operand" "=x")
7810         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "x")
7811                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7812                      UNSPEC_PSADBW))]
7813   "TARGET_AVX"
7814   "vpsadbw\t{%2, %1, %0|%0, %1, %2}"
7815   [(set_attr "type" "sseiadd")
7816    (set_attr "prefix" "vex")
7817    (set_attr "mode" "TI")])
7818
7819 (define_insn "sse2_psadbw"
7820   [(set (match_operand:V2DI 0 "register_operand" "=x")
7821         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
7822                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7823                      UNSPEC_PSADBW))]
7824   "TARGET_SSE2"
7825   "psadbw\t{%2, %0|%0, %2}"
7826   [(set_attr "type" "sseiadd")
7827    (set_attr "atom_unit" "simul")
7828    (set_attr "prefix_data16" "1")
7829    (set_attr "mode" "TI")])
7830
7831 (define_insn "avx_movmskp<avxmodesuffixf2c>256"
7832   [(set (match_operand:SI 0 "register_operand" "=r")
7833         (unspec:SI
7834           [(match_operand:AVX256MODEF2P 1 "register_operand" "x")]
7835           UNSPEC_MOVMSK))]
7836   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
7837   "vmovmskp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
7838   [(set_attr "type" "ssecvt")
7839    (set_attr "prefix" "vex")
7840    (set_attr "mode" "<MODE>")])
7841
7842 (define_insn "<sse>_movmskp<ssemodesuffixf2c>"
7843   [(set (match_operand:SI 0 "register_operand" "=r")
7844         (unspec:SI
7845           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
7846           UNSPEC_MOVMSK))]
7847   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
7848   "%vmovmskp<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
7849   [(set_attr "type" "ssemov")
7850    (set_attr "prefix" "maybe_vex")
7851    (set_attr "mode" "<MODE>")])
7852
7853 (define_insn "sse2_pmovmskb"
7854   [(set (match_operand:SI 0 "register_operand" "=r")
7855         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
7856                    UNSPEC_MOVMSK))]
7857   "TARGET_SSE2"
7858   "%vpmovmskb\t{%1, %0|%0, %1}"
7859   [(set_attr "type" "ssemov")
7860    (set_attr "prefix_data16" "1")
7861    (set_attr "prefix" "maybe_vex")
7862    (set_attr "mode" "SI")])
7863
7864 (define_expand "sse2_maskmovdqu"
7865   [(set (match_operand:V16QI 0 "memory_operand" "")
7866         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
7867                        (match_operand:V16QI 2 "register_operand" "")
7868                        (match_dup 0)]
7869                       UNSPEC_MASKMOV))]
7870   "TARGET_SSE2"
7871   "")
7872
7873 (define_insn "*sse2_maskmovdqu"
7874   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
7875         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
7876                        (match_operand:V16QI 2 "register_operand" "x")
7877                        (mem:V16QI (match_dup 0))]
7878                       UNSPEC_MASKMOV))]
7879   "TARGET_SSE2 && !TARGET_64BIT"
7880   ;; @@@ check ordering of operands in intel/nonintel syntax
7881   "%vmaskmovdqu\t{%2, %1|%1, %2}"
7882   [(set_attr "type" "ssemov")
7883    (set_attr "prefix_data16" "1")
7884    ;; The implicit %rdi operand confuses default length_vex computation.
7885    (set_attr "length_vex" "3")
7886    (set_attr "prefix" "maybe_vex")
7887    (set_attr "mode" "TI")])
7888
7889 (define_insn "*sse2_maskmovdqu_rex64"
7890   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
7891         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
7892                        (match_operand:V16QI 2 "register_operand" "x")
7893                        (mem:V16QI (match_dup 0))]
7894                       UNSPEC_MASKMOV))]
7895   "TARGET_SSE2 && TARGET_64BIT"
7896   ;; @@@ check ordering of operands in intel/nonintel syntax
7897   "%vmaskmovdqu\t{%2, %1|%1, %2}"
7898   [(set_attr "type" "ssemov")
7899    (set_attr "prefix_data16" "1")
7900    ;; The implicit %rdi operand confuses default length_vex computation.
7901    (set (attr "length_vex")
7902      (symbol_ref ("REGNO (operands[2]) >= FIRST_REX_SSE_REG ? 3 + 1 : 2 + 1")))
7903    (set_attr "prefix" "maybe_vex")
7904    (set_attr "mode" "TI")])
7905
7906 (define_insn "sse_ldmxcsr"
7907   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
7908                     UNSPECV_LDMXCSR)]
7909   "TARGET_SSE"
7910   "%vldmxcsr\t%0"
7911   [(set_attr "type" "sse")
7912    (set_attr "atom_sse_attr" "mxcsr")
7913    (set_attr "prefix" "maybe_vex")
7914    (set_attr "memory" "load")])
7915
7916 (define_insn "sse_stmxcsr"
7917   [(set (match_operand:SI 0 "memory_operand" "=m")
7918         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
7919   "TARGET_SSE"
7920   "%vstmxcsr\t%0"
7921   [(set_attr "type" "sse")
7922    (set_attr "atom_sse_attr" "mxcsr")
7923    (set_attr "prefix" "maybe_vex")
7924    (set_attr "memory" "store")])
7925
7926 (define_expand "sse_sfence"
7927   [(set (match_dup 0)
7928         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
7929   "TARGET_SSE || TARGET_3DNOW_A"
7930 {
7931   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7932   MEM_VOLATILE_P (operands[0]) = 1;
7933 })
7934
7935 (define_insn "*sse_sfence"
7936   [(set (match_operand:BLK 0 "" "")
7937         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
7938   "TARGET_SSE || TARGET_3DNOW_A"
7939   "sfence"
7940   [(set_attr "type" "sse")
7941    (set_attr "length_address" "0")
7942    (set_attr "atom_sse_attr" "fence")
7943    (set_attr "memory" "unknown")])
7944
7945 (define_insn "sse2_clflush"
7946   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
7947                     UNSPECV_CLFLUSH)]
7948   "TARGET_SSE2"
7949   "clflush\t%a0"
7950   [(set_attr "type" "sse")
7951    (set_attr "atom_sse_attr" "fence")
7952    (set_attr "memory" "unknown")])
7953
7954 (define_expand "sse2_mfence"
7955   [(set (match_dup 0)
7956         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
7957   "TARGET_SSE2"
7958 {
7959   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7960   MEM_VOLATILE_P (operands[0]) = 1;
7961 })
7962
7963 (define_insn "*sse2_mfence"
7964   [(set (match_operand:BLK 0 "" "")
7965         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
7966   "TARGET_64BIT || TARGET_SSE2"
7967   "mfence"
7968   [(set_attr "type" "sse")
7969    (set_attr "length_address" "0")
7970    (set_attr "atom_sse_attr" "fence")
7971    (set_attr "memory" "unknown")])
7972
7973 (define_expand "sse2_lfence"
7974   [(set (match_dup 0)
7975         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
7976   "TARGET_SSE2"
7977 {
7978   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
7979   MEM_VOLATILE_P (operands[0]) = 1;
7980 })
7981
7982 (define_insn "*sse2_lfence"
7983   [(set (match_operand:BLK 0 "" "")
7984         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
7985   "TARGET_SSE2"
7986   "lfence"
7987   [(set_attr "type" "sse")
7988    (set_attr "length_address" "0")
7989    (set_attr "atom_sse_attr" "lfence")
7990    (set_attr "memory" "unknown")])
7991
7992 (define_insn "sse3_mwait"
7993   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
7994                      (match_operand:SI 1 "register_operand" "c")]
7995                     UNSPECV_MWAIT)]
7996   "TARGET_SSE3"
7997 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
7998 ;; Since 32bit register operands are implicitly zero extended to 64bit,
7999 ;; we only need to set up 32bit registers.
8000   "mwait"
8001   [(set_attr "length" "3")])
8002
8003 (define_insn "sse3_monitor"
8004   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8005                      (match_operand:SI 1 "register_operand" "c")
8006                      (match_operand:SI 2 "register_operand" "d")]
8007                     UNSPECV_MONITOR)]
8008   "TARGET_SSE3 && !TARGET_64BIT"
8009   "monitor\t%0, %1, %2"
8010   [(set_attr "length" "3")])
8011
8012 (define_insn "sse3_monitor64"
8013   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
8014                      (match_operand:SI 1 "register_operand" "c")
8015                      (match_operand:SI 2 "register_operand" "d")]
8016                     UNSPECV_MONITOR)]
8017   "TARGET_SSE3 && TARGET_64BIT"
8018 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
8019 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
8020 ;; zero extended to 64bit, we only need to set up 32bit registers.
8021   "monitor"
8022   [(set_attr "length" "3")])
8023
8024 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8025 ;;
8026 ;; SSSE3 instructions
8027 ;;
8028 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8029
8030 (define_insn "*avx_phaddwv8hi3"
8031   [(set (match_operand:V8HI 0 "register_operand" "=x")
8032         (vec_concat:V8HI
8033           (vec_concat:V4HI
8034             (vec_concat:V2HI
8035               (plus:HI
8036                 (vec_select:HI
8037                   (match_operand:V8HI 1 "register_operand" "x")
8038                   (parallel [(const_int 0)]))
8039                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8040               (plus:HI
8041                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8042                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8043             (vec_concat:V2HI
8044               (plus:HI
8045                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8046                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8047               (plus:HI
8048                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8049                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8050           (vec_concat:V4HI
8051             (vec_concat:V2HI
8052               (plus:HI
8053                 (vec_select:HI
8054                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8055                   (parallel [(const_int 0)]))
8056                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8057               (plus:HI
8058                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8059                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8060             (vec_concat:V2HI
8061               (plus:HI
8062                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8063                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8064               (plus:HI
8065                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8066                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8067   "TARGET_AVX"
8068   "vphaddw\t{%2, %1, %0|%0, %1, %2}"
8069   [(set_attr "type" "sseiadd")
8070    (set_attr "prefix_extra" "1")
8071    (set_attr "prefix" "vex")
8072    (set_attr "mode" "TI")])
8073
8074 (define_insn "ssse3_phaddwv8hi3"
8075   [(set (match_operand:V8HI 0 "register_operand" "=x")
8076         (vec_concat:V8HI
8077           (vec_concat:V4HI
8078             (vec_concat:V2HI
8079               (plus:HI
8080                 (vec_select:HI
8081                   (match_operand:V8HI 1 "register_operand" "0")
8082                   (parallel [(const_int 0)]))
8083                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8084               (plus:HI
8085                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8086                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8087             (vec_concat:V2HI
8088               (plus:HI
8089                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8090                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8091               (plus:HI
8092                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8093                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8094           (vec_concat:V4HI
8095             (vec_concat:V2HI
8096               (plus:HI
8097                 (vec_select:HI
8098                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8099                   (parallel [(const_int 0)]))
8100                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8101               (plus:HI
8102                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8103                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8104             (vec_concat:V2HI
8105               (plus:HI
8106                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8107                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8108               (plus:HI
8109                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8110                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8111   "TARGET_SSSE3"
8112   "phaddw\t{%2, %0|%0, %2}"
8113   [(set_attr "type" "sseiadd")
8114    (set_attr "atom_unit" "complex")
8115    (set_attr "prefix_data16" "1")
8116    (set_attr "prefix_extra" "1")
8117    (set_attr "mode" "TI")])
8118
8119 (define_insn "ssse3_phaddwv4hi3"
8120   [(set (match_operand:V4HI 0 "register_operand" "=y")
8121         (vec_concat:V4HI
8122           (vec_concat:V2HI
8123             (plus:HI
8124               (vec_select:HI
8125                 (match_operand:V4HI 1 "register_operand" "0")
8126                 (parallel [(const_int 0)]))
8127               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8128             (plus:HI
8129               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8130               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8131           (vec_concat:V2HI
8132             (plus:HI
8133               (vec_select:HI
8134                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8135                 (parallel [(const_int 0)]))
8136               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8137             (plus:HI
8138               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8139               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8140   "TARGET_SSSE3"
8141   "phaddw\t{%2, %0|%0, %2}"
8142   [(set_attr "type" "sseiadd")
8143    (set_attr "atom_unit" "complex")
8144    (set_attr "prefix_extra" "1")
8145    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8146    (set_attr "mode" "DI")])
8147
8148 (define_insn "*avx_phadddv4si3"
8149   [(set (match_operand:V4SI 0 "register_operand" "=x")
8150         (vec_concat:V4SI
8151           (vec_concat:V2SI
8152             (plus:SI
8153               (vec_select:SI
8154                 (match_operand:V4SI 1 "register_operand" "x")
8155                 (parallel [(const_int 0)]))
8156               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8157             (plus:SI
8158               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8159               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8160           (vec_concat:V2SI
8161             (plus:SI
8162               (vec_select:SI
8163                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8164                 (parallel [(const_int 0)]))
8165               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8166             (plus:SI
8167               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8168               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8169   "TARGET_AVX"
8170   "vphaddd\t{%2, %1, %0|%0, %1, %2}"
8171   [(set_attr "type" "sseiadd")
8172    (set_attr "prefix_extra" "1")
8173    (set_attr "prefix" "vex")
8174    (set_attr "mode" "TI")])
8175
8176 (define_insn "ssse3_phadddv4si3"
8177   [(set (match_operand:V4SI 0 "register_operand" "=x")
8178         (vec_concat:V4SI
8179           (vec_concat:V2SI
8180             (plus:SI
8181               (vec_select:SI
8182                 (match_operand:V4SI 1 "register_operand" "0")
8183                 (parallel [(const_int 0)]))
8184               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8185             (plus:SI
8186               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8187               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8188           (vec_concat:V2SI
8189             (plus:SI
8190               (vec_select:SI
8191                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8192                 (parallel [(const_int 0)]))
8193               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8194             (plus:SI
8195               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8196               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8197   "TARGET_SSSE3"
8198   "phaddd\t{%2, %0|%0, %2}"
8199   [(set_attr "type" "sseiadd")
8200    (set_attr "atom_unit" "complex")
8201    (set_attr "prefix_data16" "1")
8202    (set_attr "prefix_extra" "1")
8203    (set_attr "mode" "TI")])
8204
8205 (define_insn "ssse3_phadddv2si3"
8206   [(set (match_operand:V2SI 0 "register_operand" "=y")
8207         (vec_concat:V2SI
8208           (plus:SI
8209             (vec_select:SI
8210               (match_operand:V2SI 1 "register_operand" "0")
8211               (parallel [(const_int 0)]))
8212             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8213           (plus:SI
8214             (vec_select:SI
8215               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8216               (parallel [(const_int 0)]))
8217             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8218   "TARGET_SSSE3"
8219   "phaddd\t{%2, %0|%0, %2}"
8220   [(set_attr "type" "sseiadd")
8221    (set_attr "atom_unit" "complex")
8222    (set_attr "prefix_extra" "1")
8223    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8224    (set_attr "mode" "DI")])
8225
8226 (define_insn "*avx_phaddswv8hi3"
8227   [(set (match_operand:V8HI 0 "register_operand" "=x")
8228         (vec_concat:V8HI
8229           (vec_concat:V4HI
8230             (vec_concat:V2HI
8231               (ss_plus:HI
8232                 (vec_select:HI
8233                   (match_operand:V8HI 1 "register_operand" "x")
8234                   (parallel [(const_int 0)]))
8235                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8236               (ss_plus:HI
8237                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8238                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8239             (vec_concat:V2HI
8240               (ss_plus:HI
8241                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8242                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8243               (ss_plus:HI
8244                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8245                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8246           (vec_concat:V4HI
8247             (vec_concat:V2HI
8248               (ss_plus:HI
8249                 (vec_select:HI
8250                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8251                   (parallel [(const_int 0)]))
8252                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8253               (ss_plus:HI
8254                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8255                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8256             (vec_concat:V2HI
8257               (ss_plus:HI
8258                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8259                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8260               (ss_plus:HI
8261                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8262                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8263   "TARGET_AVX"
8264   "vphaddsw\t{%2, %1, %0|%0, %1, %2}"
8265   [(set_attr "type" "sseiadd")
8266    (set_attr "prefix_extra" "1")
8267    (set_attr "prefix" "vex")
8268    (set_attr "mode" "TI")])
8269
8270 (define_insn "ssse3_phaddswv8hi3"
8271   [(set (match_operand:V8HI 0 "register_operand" "=x")
8272         (vec_concat:V8HI
8273           (vec_concat:V4HI
8274             (vec_concat:V2HI
8275               (ss_plus:HI
8276                 (vec_select:HI
8277                   (match_operand:V8HI 1 "register_operand" "0")
8278                   (parallel [(const_int 0)]))
8279                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8280               (ss_plus:HI
8281                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8282                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8283             (vec_concat:V2HI
8284               (ss_plus:HI
8285                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8286                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8287               (ss_plus:HI
8288                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8289                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8290           (vec_concat:V4HI
8291             (vec_concat:V2HI
8292               (ss_plus:HI
8293                 (vec_select:HI
8294                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8295                   (parallel [(const_int 0)]))
8296                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8297               (ss_plus:HI
8298                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8299                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8300             (vec_concat:V2HI
8301               (ss_plus:HI
8302                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8303                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8304               (ss_plus:HI
8305                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8306                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8307   "TARGET_SSSE3"
8308   "phaddsw\t{%2, %0|%0, %2}"
8309   [(set_attr "type" "sseiadd")
8310    (set_attr "atom_unit" "complex")
8311    (set_attr "prefix_data16" "1")
8312    (set_attr "prefix_extra" "1")
8313    (set_attr "mode" "TI")])
8314
8315 (define_insn "ssse3_phaddswv4hi3"
8316   [(set (match_operand:V4HI 0 "register_operand" "=y")
8317         (vec_concat:V4HI
8318           (vec_concat:V2HI
8319             (ss_plus:HI
8320               (vec_select:HI
8321                 (match_operand:V4HI 1 "register_operand" "0")
8322                 (parallel [(const_int 0)]))
8323               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8324             (ss_plus:HI
8325               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8326               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8327           (vec_concat:V2HI
8328             (ss_plus:HI
8329               (vec_select:HI
8330                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8331                 (parallel [(const_int 0)]))
8332               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8333             (ss_plus:HI
8334               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8335               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8336   "TARGET_SSSE3"
8337   "phaddsw\t{%2, %0|%0, %2}"
8338   [(set_attr "type" "sseiadd")
8339    (set_attr "atom_unit" "complex")
8340    (set_attr "prefix_extra" "1")
8341    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8342    (set_attr "mode" "DI")])
8343
8344 (define_insn "*avx_phsubwv8hi3"
8345   [(set (match_operand:V8HI 0 "register_operand" "=x")
8346         (vec_concat:V8HI
8347           (vec_concat:V4HI
8348             (vec_concat:V2HI
8349               (minus:HI
8350                 (vec_select:HI
8351                   (match_operand:V8HI 1 "register_operand" "x")
8352                   (parallel [(const_int 0)]))
8353                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8354               (minus:HI
8355                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8356                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8357             (vec_concat:V2HI
8358               (minus:HI
8359                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8360                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8361               (minus:HI
8362                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8363                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8364           (vec_concat:V4HI
8365             (vec_concat:V2HI
8366               (minus:HI
8367                 (vec_select:HI
8368                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8369                   (parallel [(const_int 0)]))
8370                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8371               (minus:HI
8372                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8373                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8374             (vec_concat:V2HI
8375               (minus:HI
8376                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8377                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8378               (minus:HI
8379                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8380                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8381   "TARGET_AVX"
8382   "vphsubw\t{%2, %1, %0|%0, %1, %2}"
8383   [(set_attr "type" "sseiadd")
8384    (set_attr "prefix_extra" "1")
8385    (set_attr "prefix" "vex")
8386    (set_attr "mode" "TI")])
8387
8388 (define_insn "ssse3_phsubwv8hi3"
8389   [(set (match_operand:V8HI 0 "register_operand" "=x")
8390         (vec_concat:V8HI
8391           (vec_concat:V4HI
8392             (vec_concat:V2HI
8393               (minus:HI
8394                 (vec_select:HI
8395                   (match_operand:V8HI 1 "register_operand" "0")
8396                   (parallel [(const_int 0)]))
8397                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8398               (minus:HI
8399                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8400                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8401             (vec_concat:V2HI
8402               (minus:HI
8403                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8404                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8405               (minus:HI
8406                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8407                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8408           (vec_concat:V4HI
8409             (vec_concat:V2HI
8410               (minus:HI
8411                 (vec_select:HI
8412                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8413                   (parallel [(const_int 0)]))
8414                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8415               (minus:HI
8416                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8417                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8418             (vec_concat:V2HI
8419               (minus:HI
8420                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8421                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8422               (minus:HI
8423                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8424                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8425   "TARGET_SSSE3"
8426   "phsubw\t{%2, %0|%0, %2}"
8427   [(set_attr "type" "sseiadd")
8428    (set_attr "atom_unit" "complex")
8429    (set_attr "prefix_data16" "1")
8430    (set_attr "prefix_extra" "1")
8431    (set_attr "mode" "TI")])
8432
8433 (define_insn "ssse3_phsubwv4hi3"
8434   [(set (match_operand:V4HI 0 "register_operand" "=y")
8435         (vec_concat:V4HI
8436           (vec_concat:V2HI
8437             (minus:HI
8438               (vec_select:HI
8439                 (match_operand:V4HI 1 "register_operand" "0")
8440                 (parallel [(const_int 0)]))
8441               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8442             (minus:HI
8443               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8444               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8445           (vec_concat:V2HI
8446             (minus:HI
8447               (vec_select:HI
8448                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8449                 (parallel [(const_int 0)]))
8450               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8451             (minus:HI
8452               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8453               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8454   "TARGET_SSSE3"
8455   "phsubw\t{%2, %0|%0, %2}"
8456   [(set_attr "type" "sseiadd")
8457    (set_attr "atom_unit" "complex")
8458    (set_attr "prefix_extra" "1")
8459    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8460    (set_attr "mode" "DI")])
8461
8462 (define_insn "*avx_phsubdv4si3"
8463   [(set (match_operand:V4SI 0 "register_operand" "=x")
8464         (vec_concat:V4SI
8465           (vec_concat:V2SI
8466             (minus:SI
8467               (vec_select:SI
8468                 (match_operand:V4SI 1 "register_operand" "x")
8469                 (parallel [(const_int 0)]))
8470               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8471             (minus:SI
8472               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8473               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8474           (vec_concat:V2SI
8475             (minus:SI
8476               (vec_select:SI
8477                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8478                 (parallel [(const_int 0)]))
8479               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8480             (minus:SI
8481               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8482               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8483   "TARGET_AVX"
8484   "vphsubd\t{%2, %1, %0|%0, %1, %2}"
8485   [(set_attr "type" "sseiadd")
8486    (set_attr "prefix_extra" "1")
8487    (set_attr "prefix" "vex")
8488    (set_attr "mode" "TI")])
8489
8490 (define_insn "ssse3_phsubdv4si3"
8491   [(set (match_operand:V4SI 0 "register_operand" "=x")
8492         (vec_concat:V4SI
8493           (vec_concat:V2SI
8494             (minus:SI
8495               (vec_select:SI
8496                 (match_operand:V4SI 1 "register_operand" "0")
8497                 (parallel [(const_int 0)]))
8498               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8499             (minus:SI
8500               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8501               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8502           (vec_concat:V2SI
8503             (minus:SI
8504               (vec_select:SI
8505                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8506                 (parallel [(const_int 0)]))
8507               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8508             (minus:SI
8509               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8510               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8511   "TARGET_SSSE3"
8512   "phsubd\t{%2, %0|%0, %2}"
8513   [(set_attr "type" "sseiadd")
8514    (set_attr "atom_unit" "complex")
8515    (set_attr "prefix_data16" "1")
8516    (set_attr "prefix_extra" "1")
8517    (set_attr "mode" "TI")])
8518
8519 (define_insn "ssse3_phsubdv2si3"
8520   [(set (match_operand:V2SI 0 "register_operand" "=y")
8521         (vec_concat:V2SI
8522           (minus:SI
8523             (vec_select:SI
8524               (match_operand:V2SI 1 "register_operand" "0")
8525               (parallel [(const_int 0)]))
8526             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8527           (minus:SI
8528             (vec_select:SI
8529               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8530               (parallel [(const_int 0)]))
8531             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8532   "TARGET_SSSE3"
8533   "phsubd\t{%2, %0|%0, %2}"
8534   [(set_attr "type" "sseiadd")
8535    (set_attr "atom_unit" "complex")
8536    (set_attr "prefix_extra" "1")
8537    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8538    (set_attr "mode" "DI")])
8539
8540 (define_insn "*avx_phsubswv8hi3"
8541   [(set (match_operand:V8HI 0 "register_operand" "=x")
8542         (vec_concat:V8HI
8543           (vec_concat:V4HI
8544             (vec_concat:V2HI
8545               (ss_minus:HI
8546                 (vec_select:HI
8547                   (match_operand:V8HI 1 "register_operand" "x")
8548                   (parallel [(const_int 0)]))
8549                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8550               (ss_minus:HI
8551                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8552                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8553             (vec_concat:V2HI
8554               (ss_minus:HI
8555                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8556                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8557               (ss_minus:HI
8558                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8559                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8560           (vec_concat:V4HI
8561             (vec_concat:V2HI
8562               (ss_minus:HI
8563                 (vec_select:HI
8564                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8565                   (parallel [(const_int 0)]))
8566                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8567               (ss_minus:HI
8568                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8569                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8570             (vec_concat:V2HI
8571               (ss_minus:HI
8572                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8573                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8574               (ss_minus:HI
8575                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8576                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8577   "TARGET_AVX"
8578   "vphsubsw\t{%2, %1, %0|%0, %1, %2}"
8579   [(set_attr "type" "sseiadd")
8580    (set_attr "prefix_extra" "1")
8581    (set_attr "prefix" "vex")
8582    (set_attr "mode" "TI")])
8583
8584 (define_insn "ssse3_phsubswv8hi3"
8585   [(set (match_operand:V8HI 0 "register_operand" "=x")
8586         (vec_concat:V8HI
8587           (vec_concat:V4HI
8588             (vec_concat:V2HI
8589               (ss_minus:HI
8590                 (vec_select:HI
8591                   (match_operand:V8HI 1 "register_operand" "0")
8592                   (parallel [(const_int 0)]))
8593                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8594               (ss_minus:HI
8595                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8596                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8597             (vec_concat:V2HI
8598               (ss_minus:HI
8599                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8600                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8601               (ss_minus:HI
8602                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8603                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8604           (vec_concat:V4HI
8605             (vec_concat:V2HI
8606               (ss_minus:HI
8607                 (vec_select:HI
8608                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8609                   (parallel [(const_int 0)]))
8610                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8611               (ss_minus:HI
8612                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8613                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8614             (vec_concat:V2HI
8615               (ss_minus:HI
8616                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8617                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8618               (ss_minus:HI
8619                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8620                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8621   "TARGET_SSSE3"
8622   "phsubsw\t{%2, %0|%0, %2}"
8623   [(set_attr "type" "sseiadd")
8624    (set_attr "atom_unit" "complex")
8625    (set_attr "prefix_data16" "1")
8626    (set_attr "prefix_extra" "1")
8627    (set_attr "mode" "TI")])
8628
8629 (define_insn "ssse3_phsubswv4hi3"
8630   [(set (match_operand:V4HI 0 "register_operand" "=y")
8631         (vec_concat:V4HI
8632           (vec_concat:V2HI
8633             (ss_minus:HI
8634               (vec_select:HI
8635                 (match_operand:V4HI 1 "register_operand" "0")
8636                 (parallel [(const_int 0)]))
8637               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8638             (ss_minus:HI
8639               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8640               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8641           (vec_concat:V2HI
8642             (ss_minus:HI
8643               (vec_select:HI
8644                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8645                 (parallel [(const_int 0)]))
8646               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8647             (ss_minus:HI
8648               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8649               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8650   "TARGET_SSSE3"
8651   "phsubsw\t{%2, %0|%0, %2}"
8652   [(set_attr "type" "sseiadd")
8653    (set_attr "atom_unit" "complex")
8654    (set_attr "prefix_extra" "1")
8655    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8656    (set_attr "mode" "DI")])
8657
8658 (define_insn "*avx_pmaddubsw128"
8659   [(set (match_operand:V8HI 0 "register_operand" "=x")
8660         (ss_plus:V8HI
8661           (mult:V8HI
8662             (zero_extend:V8HI
8663               (vec_select:V4QI
8664                 (match_operand:V16QI 1 "register_operand" "x")
8665                 (parallel [(const_int 0)
8666                            (const_int 2)
8667                            (const_int 4)
8668                            (const_int 6)
8669                            (const_int 8)
8670                            (const_int 10)
8671                            (const_int 12)
8672                            (const_int 14)])))
8673             (sign_extend:V8HI
8674               (vec_select:V8QI
8675                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8676                 (parallel [(const_int 0)
8677                            (const_int 2)
8678                            (const_int 4)
8679                            (const_int 6)
8680                            (const_int 8)
8681                            (const_int 10)
8682                            (const_int 12)
8683                            (const_int 14)]))))
8684           (mult:V8HI
8685             (zero_extend:V8HI
8686               (vec_select:V16QI (match_dup 1)
8687                 (parallel [(const_int 1)
8688                            (const_int 3)
8689                            (const_int 5)
8690                            (const_int 7)
8691                            (const_int 9)
8692                            (const_int 11)
8693                            (const_int 13)
8694                            (const_int 15)])))
8695             (sign_extend:V8HI
8696               (vec_select:V16QI (match_dup 2)
8697                 (parallel [(const_int 1)
8698                            (const_int 3)
8699                            (const_int 5)
8700                            (const_int 7)
8701                            (const_int 9)
8702                            (const_int 11)
8703                            (const_int 13)
8704                            (const_int 15)]))))))]
8705   "TARGET_AVX"
8706   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8707   [(set_attr "type" "sseiadd")
8708    (set_attr "prefix_extra" "1")
8709    (set_attr "prefix" "vex")
8710    (set_attr "mode" "TI")])
8711
8712 (define_insn "ssse3_pmaddubsw128"
8713   [(set (match_operand:V8HI 0 "register_operand" "=x")
8714         (ss_plus:V8HI
8715           (mult:V8HI
8716             (zero_extend:V8HI
8717               (vec_select:V4QI
8718                 (match_operand:V16QI 1 "register_operand" "0")
8719                 (parallel [(const_int 0)
8720                            (const_int 2)
8721                            (const_int 4)
8722                            (const_int 6)
8723                            (const_int 8)
8724                            (const_int 10)
8725                            (const_int 12)
8726                            (const_int 14)])))
8727             (sign_extend:V8HI
8728               (vec_select:V8QI
8729                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8730                 (parallel [(const_int 0)
8731                            (const_int 2)
8732                            (const_int 4)
8733                            (const_int 6)
8734                            (const_int 8)
8735                            (const_int 10)
8736                            (const_int 12)
8737                            (const_int 14)]))))
8738           (mult:V8HI
8739             (zero_extend:V8HI
8740               (vec_select:V16QI (match_dup 1)
8741                 (parallel [(const_int 1)
8742                            (const_int 3)
8743                            (const_int 5)
8744                            (const_int 7)
8745                            (const_int 9)
8746                            (const_int 11)
8747                            (const_int 13)
8748                            (const_int 15)])))
8749             (sign_extend:V8HI
8750               (vec_select:V16QI (match_dup 2)
8751                 (parallel [(const_int 1)
8752                            (const_int 3)
8753                            (const_int 5)
8754                            (const_int 7)
8755                            (const_int 9)
8756                            (const_int 11)
8757                            (const_int 13)
8758                            (const_int 15)]))))))]
8759   "TARGET_SSSE3"
8760   "pmaddubsw\t{%2, %0|%0, %2}"
8761   [(set_attr "type" "sseiadd")
8762    (set_attr "atom_unit" "simul")
8763    (set_attr "prefix_data16" "1")
8764    (set_attr "prefix_extra" "1")
8765    (set_attr "mode" "TI")])
8766
8767 (define_insn "ssse3_pmaddubsw"
8768   [(set (match_operand:V4HI 0 "register_operand" "=y")
8769         (ss_plus:V4HI
8770           (mult:V4HI
8771             (zero_extend:V4HI
8772               (vec_select:V4QI
8773                 (match_operand:V8QI 1 "register_operand" "0")
8774                 (parallel [(const_int 0)
8775                            (const_int 2)
8776                            (const_int 4)
8777                            (const_int 6)])))
8778             (sign_extend:V4HI
8779               (vec_select:V4QI
8780                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8781                 (parallel [(const_int 0)
8782                            (const_int 2)
8783                            (const_int 4)
8784                            (const_int 6)]))))
8785           (mult:V4HI
8786             (zero_extend:V4HI
8787               (vec_select:V8QI (match_dup 1)
8788                 (parallel [(const_int 1)
8789                            (const_int 3)
8790                            (const_int 5)
8791                            (const_int 7)])))
8792             (sign_extend:V4HI
8793               (vec_select:V8QI (match_dup 2)
8794                 (parallel [(const_int 1)
8795                            (const_int 3)
8796                            (const_int 5)
8797                            (const_int 7)]))))))]
8798   "TARGET_SSSE3"
8799   "pmaddubsw\t{%2, %0|%0, %2}"
8800   [(set_attr "type" "sseiadd")
8801    (set_attr "atom_unit" "simul")
8802    (set_attr "prefix_extra" "1")
8803    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8804    (set_attr "mode" "DI")])
8805
8806 (define_expand "ssse3_pmulhrswv8hi3"
8807   [(set (match_operand:V8HI 0 "register_operand" "")
8808         (truncate:V8HI
8809           (lshiftrt:V8SI
8810             (plus:V8SI
8811               (lshiftrt:V8SI
8812                 (mult:V8SI
8813                   (sign_extend:V8SI
8814                     (match_operand:V8HI 1 "nonimmediate_operand" ""))
8815                   (sign_extend:V8SI
8816                     (match_operand:V8HI 2 "nonimmediate_operand" "")))
8817                 (const_int 14))
8818               (const_vector:V8HI [(const_int 1) (const_int 1)
8819                                   (const_int 1) (const_int 1)
8820                                   (const_int 1) (const_int 1)
8821                                   (const_int 1) (const_int 1)]))
8822             (const_int 1))))]
8823   "TARGET_SSSE3"
8824   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
8825
8826 (define_insn "*avx_pmulhrswv8hi3"
8827   [(set (match_operand:V8HI 0 "register_operand" "=x")
8828         (truncate:V8HI
8829           (lshiftrt:V8SI
8830             (plus:V8SI
8831               (lshiftrt:V8SI
8832                 (mult:V8SI
8833                   (sign_extend:V8SI
8834                     (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
8835                   (sign_extend:V8SI
8836                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8837                 (const_int 14))
8838               (const_vector:V8HI [(const_int 1) (const_int 1)
8839                                   (const_int 1) (const_int 1)
8840                                   (const_int 1) (const_int 1)
8841                                   (const_int 1) (const_int 1)]))
8842             (const_int 1))))]
8843   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8844   "vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
8845   [(set_attr "type" "sseimul")
8846    (set_attr "prefix_extra" "1")
8847    (set_attr "prefix" "vex")
8848    (set_attr "mode" "TI")])
8849
8850 (define_insn "*ssse3_pmulhrswv8hi3"
8851   [(set (match_operand:V8HI 0 "register_operand" "=x")
8852         (truncate:V8HI
8853           (lshiftrt:V8SI
8854             (plus:V8SI
8855               (lshiftrt:V8SI
8856                 (mult:V8SI
8857                   (sign_extend:V8SI
8858                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
8859                   (sign_extend:V8SI
8860                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
8861                 (const_int 14))
8862               (const_vector:V8HI [(const_int 1) (const_int 1)
8863                                   (const_int 1) (const_int 1)
8864                                   (const_int 1) (const_int 1)
8865                                   (const_int 1) (const_int 1)]))
8866             (const_int 1))))]
8867   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8868   "pmulhrsw\t{%2, %0|%0, %2}"
8869   [(set_attr "type" "sseimul")
8870    (set_attr "prefix_data16" "1")
8871    (set_attr "prefix_extra" "1")
8872    (set_attr "mode" "TI")])
8873
8874 (define_expand "ssse3_pmulhrswv4hi3"
8875   [(set (match_operand:V4HI 0 "register_operand" "")
8876         (truncate:V4HI
8877           (lshiftrt:V4SI
8878             (plus:V4SI
8879               (lshiftrt:V4SI
8880                 (mult:V4SI
8881                   (sign_extend:V4SI
8882                     (match_operand:V4HI 1 "nonimmediate_operand" ""))
8883                   (sign_extend:V4SI
8884                     (match_operand:V4HI 2 "nonimmediate_operand" "")))
8885                 (const_int 14))
8886               (const_vector:V4HI [(const_int 1) (const_int 1)
8887                                   (const_int 1) (const_int 1)]))
8888             (const_int 1))))]
8889   "TARGET_SSSE3"
8890   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
8891
8892 (define_insn "*ssse3_pmulhrswv4hi3"
8893   [(set (match_operand:V4HI 0 "register_operand" "=y")
8894         (truncate:V4HI
8895           (lshiftrt:V4SI
8896             (plus:V4SI
8897               (lshiftrt:V4SI
8898                 (mult:V4SI
8899                   (sign_extend:V4SI
8900                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
8901                   (sign_extend:V4SI
8902                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
8903                 (const_int 14))
8904               (const_vector:V4HI [(const_int 1) (const_int 1)
8905                                   (const_int 1) (const_int 1)]))
8906             (const_int 1))))]
8907   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
8908   "pmulhrsw\t{%2, %0|%0, %2}"
8909   [(set_attr "type" "sseimul")
8910    (set_attr "prefix_extra" "1")
8911    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8912    (set_attr "mode" "DI")])
8913
8914 (define_insn "*avx_pshufbv16qi3"
8915   [(set (match_operand:V16QI 0 "register_operand" "=x")
8916         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8917                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8918                       UNSPEC_PSHUFB))]
8919   "TARGET_AVX"
8920   "vpshufb\t{%2, %1, %0|%0, %1, %2}";
8921   [(set_attr "type" "sselog1")
8922    (set_attr "prefix_extra" "1")
8923    (set_attr "prefix" "vex")
8924    (set_attr "mode" "TI")])
8925
8926 (define_insn "ssse3_pshufbv16qi3"
8927   [(set (match_operand:V16QI 0 "register_operand" "=x")
8928         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
8929                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8930                       UNSPEC_PSHUFB))]
8931   "TARGET_SSSE3"
8932   "pshufb\t{%2, %0|%0, %2}";
8933   [(set_attr "type" "sselog1")
8934    (set_attr "prefix_data16" "1")
8935    (set_attr "prefix_extra" "1")
8936    (set_attr "mode" "TI")])
8937
8938 (define_insn "ssse3_pshufbv8qi3"
8939   [(set (match_operand:V8QI 0 "register_operand" "=y")
8940         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
8941                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
8942                      UNSPEC_PSHUFB))]
8943   "TARGET_SSSE3"
8944   "pshufb\t{%2, %0|%0, %2}";
8945   [(set_attr "type" "sselog1")
8946    (set_attr "prefix_extra" "1")
8947    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8948    (set_attr "mode" "DI")])
8949
8950 (define_insn "*avx_psign<mode>3"
8951   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
8952         (unspec:SSEMODE124
8953           [(match_operand:SSEMODE124 1 "register_operand" "x")
8954            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
8955           UNSPEC_PSIGN))]
8956   "TARGET_AVX"
8957   "vpsign<ssevecsize>\t{%2, %1, %0|%0, %1, %2}";
8958   [(set_attr "type" "sselog1")
8959    (set_attr "prefix_extra" "1")
8960    (set_attr "prefix" "vex")
8961    (set_attr "mode" "TI")])
8962
8963 (define_insn "ssse3_psign<mode>3"
8964   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
8965         (unspec:SSEMODE124
8966           [(match_operand:SSEMODE124 1 "register_operand" "0")
8967            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
8968           UNSPEC_PSIGN))]
8969   "TARGET_SSSE3"
8970   "psign<ssevecsize>\t{%2, %0|%0, %2}";
8971   [(set_attr "type" "sselog1")
8972    (set_attr "prefix_data16" "1")
8973    (set_attr "prefix_extra" "1")
8974    (set_attr "mode" "TI")])
8975
8976 (define_insn "ssse3_psign<mode>3"
8977   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
8978         (unspec:MMXMODEI
8979           [(match_operand:MMXMODEI 1 "register_operand" "0")
8980            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
8981           UNSPEC_PSIGN))]
8982   "TARGET_SSSE3"
8983   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
8984   [(set_attr "type" "sselog1")
8985    (set_attr "prefix_extra" "1")
8986    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8987    (set_attr "mode" "DI")])
8988
8989 (define_insn "*avx_palignrti"
8990   [(set (match_operand:TI 0 "register_operand" "=x")
8991         (unspec:TI [(match_operand:TI 1 "register_operand" "x")
8992                     (match_operand:TI 2 "nonimmediate_operand" "xm")
8993                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
8994                    UNSPEC_PALIGNR))]
8995   "TARGET_AVX"
8996 {
8997   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8998   return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
8999 }
9000   [(set_attr "type" "sseishft")
9001    (set_attr "prefix_extra" "1")
9002    (set_attr "length_immediate" "1")
9003    (set_attr "prefix" "vex")
9004    (set_attr "mode" "TI")])
9005
9006 (define_insn "ssse3_palignrti"
9007   [(set (match_operand:TI 0 "register_operand" "=x")
9008         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
9009                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9010                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9011                    UNSPEC_PALIGNR))]
9012   "TARGET_SSSE3"
9013 {
9014   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9015   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9016 }
9017   [(set_attr "type" "sseishft")
9018    (set_attr "atom_unit" "sishuf")
9019    (set_attr "prefix_data16" "1")
9020    (set_attr "prefix_extra" "1")
9021    (set_attr "length_immediate" "1")
9022    (set_attr "mode" "TI")])
9023
9024 (define_insn "ssse3_palignrdi"
9025   [(set (match_operand:DI 0 "register_operand" "=y")
9026         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
9027                     (match_operand:DI 2 "nonimmediate_operand" "ym")
9028                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9029                    UNSPEC_PALIGNR))]
9030   "TARGET_SSSE3"
9031 {
9032   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9033   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9034 }
9035   [(set_attr "type" "sseishft")
9036    (set_attr "atom_unit" "sishuf")
9037    (set_attr "prefix_extra" "1")
9038    (set_attr "length_immediate" "1")
9039    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9040    (set_attr "mode" "DI")])
9041
9042 (define_insn "abs<mode>2"
9043   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9044         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
9045   "TARGET_SSSE3"
9046   "%vpabs<ssevecsize>\t{%1, %0|%0, %1}"
9047   [(set_attr "type" "sselog1")
9048    (set_attr "prefix_data16" "1")
9049    (set_attr "prefix_extra" "1")
9050    (set_attr "prefix" "maybe_vex")
9051    (set_attr "mode" "TI")])
9052
9053 (define_insn "abs<mode>2"
9054   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9055         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
9056   "TARGET_SSSE3"
9057   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
9058   [(set_attr "type" "sselog1")
9059    (set_attr "prefix_rep" "0")
9060    (set_attr "prefix_extra" "1")
9061    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9062    (set_attr "mode" "DI")])
9063
9064 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9065 ;;
9066 ;; AMD SSE4A instructions
9067 ;;
9068 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9069
9070 (define_insn "sse4a_movnt<mode>"
9071   [(set (match_operand:MODEF 0 "memory_operand" "=m")
9072         (unspec:MODEF
9073           [(match_operand:MODEF 1 "register_operand" "x")]
9074           UNSPEC_MOVNT))]
9075   "TARGET_SSE4A"
9076   "movnts<ssemodefsuffix>\t{%1, %0|%0, %1}"
9077   [(set_attr "type" "ssemov")
9078    (set_attr "mode" "<MODE>")])
9079
9080 (define_insn "sse4a_vmmovnt<mode>"
9081   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
9082         (unspec:<ssescalarmode>
9083           [(vec_select:<ssescalarmode>
9084              (match_operand:SSEMODEF2P 1 "register_operand" "x")
9085              (parallel [(const_int 0)]))]
9086           UNSPEC_MOVNT))]
9087   "TARGET_SSE4A"
9088   "movnts<ssemodesuffixf2c>\t{%1, %0|%0, %1}"
9089   [(set_attr "type" "ssemov")
9090    (set_attr "mode" "<ssescalarmode>")])
9091
9092 (define_insn "sse4a_extrqi"
9093   [(set (match_operand:V2DI 0 "register_operand" "=x")
9094         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9095                       (match_operand 2 "const_int_operand" "")
9096                       (match_operand 3 "const_int_operand" "")]
9097                      UNSPEC_EXTRQI))]
9098   "TARGET_SSE4A"
9099   "extrq\t{%3, %2, %0|%0, %2, %3}"
9100   [(set_attr "type" "sse")
9101    (set_attr "prefix_data16" "1")
9102    (set_attr "length_immediate" "2")
9103    (set_attr "mode" "TI")])
9104
9105 (define_insn "sse4a_extrq"
9106   [(set (match_operand:V2DI 0 "register_operand" "=x")
9107         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9108                       (match_operand:V16QI 2 "register_operand" "x")]
9109                      UNSPEC_EXTRQ))]
9110   "TARGET_SSE4A"
9111   "extrq\t{%2, %0|%0, %2}"
9112   [(set_attr "type" "sse")
9113    (set_attr "prefix_data16" "1")
9114    (set_attr "mode" "TI")])
9115
9116 (define_insn "sse4a_insertqi"
9117   [(set (match_operand:V2DI 0 "register_operand" "=x")
9118         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9119                       (match_operand:V2DI 2 "register_operand" "x")
9120                       (match_operand 3 "const_int_operand" "")
9121                       (match_operand 4 "const_int_operand" "")]
9122                      UNSPEC_INSERTQI))]
9123   "TARGET_SSE4A"
9124   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
9125   [(set_attr "type" "sseins")
9126    (set_attr "prefix_data16" "0")
9127    (set_attr "prefix_rep" "1")
9128    (set_attr "length_immediate" "2")
9129    (set_attr "mode" "TI")])
9130
9131 (define_insn "sse4a_insertq"
9132   [(set (match_operand:V2DI 0 "register_operand" "=x")
9133         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9134                       (match_operand:V2DI 2 "register_operand" "x")]
9135                      UNSPEC_INSERTQ))]
9136   "TARGET_SSE4A"
9137   "insertq\t{%2, %0|%0, %2}"
9138   [(set_attr "type" "sseins")
9139    (set_attr "prefix_data16" "0")
9140    (set_attr "prefix_rep" "1")
9141    (set_attr "mode" "TI")])
9142
9143 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9144 ;;
9145 ;; Intel SSE4.1 instructions
9146 ;;
9147 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9148
9149 (define_insn "avx_blendp<avxmodesuffixf2c><avxmodesuffix>"
9150   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9151         (vec_merge:AVXMODEF2P
9152           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9153           (match_operand:AVXMODEF2P 1 "register_operand" "x")
9154           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9155   "TARGET_AVX"
9156   "vblendp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9157   [(set_attr "type" "ssemov")
9158    (set_attr "prefix_extra" "1")
9159    (set_attr "length_immediate" "1")
9160    (set_attr "prefix" "vex")
9161    (set_attr "mode" "<avxvecmode>")])
9162
9163 (define_insn "avx_blendvp<avxmodesuffixf2c><avxmodesuffix>"
9164   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9165         (unspec:AVXMODEF2P
9166           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
9167            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9168            (match_operand:AVXMODEF2P 3 "register_operand" "x")]
9169           UNSPEC_BLENDV))]
9170   "TARGET_AVX"
9171   "vblendvp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9172   [(set_attr "type" "ssemov")
9173    (set_attr "prefix_extra" "1")
9174    (set_attr "length_immediate" "1")
9175    (set_attr "prefix" "vex")
9176    (set_attr "mode" "<avxvecmode>")])
9177
9178 (define_insn "sse4_1_blendp<ssemodesuffixf2c>"
9179   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9180         (vec_merge:SSEMODEF2P
9181           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9182           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9183           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9184   "TARGET_SSE4_1"
9185   "blendp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9186   [(set_attr "type" "ssemov")
9187    (set_attr "prefix_data16" "1")
9188    (set_attr "prefix_extra" "1")
9189    (set_attr "length_immediate" "1")
9190    (set_attr "mode" "<MODE>")])
9191
9192 (define_insn "sse4_1_blendvp<ssemodesuffixf2c>"
9193   [(set (match_operand:SSEMODEF2P 0 "reg_not_xmm0_operand" "=x")
9194         (unspec:SSEMODEF2P
9195           [(match_operand:SSEMODEF2P 1 "reg_not_xmm0_operand" "0")
9196            (match_operand:SSEMODEF2P 2 "nonimm_not_xmm0_operand" "xm")
9197            (match_operand:SSEMODEF2P 3 "register_operand" "Yz")]
9198           UNSPEC_BLENDV))]
9199   "TARGET_SSE4_1"
9200   "blendvp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9201   [(set_attr "type" "ssemov")
9202    (set_attr "prefix_data16" "1")
9203    (set_attr "prefix_extra" "1")
9204    (set_attr "mode" "<MODE>")])
9205
9206 (define_insn "avx_dpp<avxmodesuffixf2c><avxmodesuffix>"
9207   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9208         (unspec:AVXMODEF2P
9209           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
9210            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9211            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9212           UNSPEC_DP))]
9213   "TARGET_AVX"
9214   "vdpp<avxmodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9215   [(set_attr "type" "ssemul")
9216    (set_attr "prefix" "vex")
9217    (set_attr "prefix_extra" "1")
9218    (set_attr "length_immediate" "1")
9219    (set_attr "mode" "<avxvecmode>")])
9220
9221 (define_insn "sse4_1_dpp<ssemodesuffixf2c>"
9222   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9223         (unspec:SSEMODEF2P
9224           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
9225            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9226            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9227           UNSPEC_DP))]
9228   "TARGET_SSE4_1"
9229   "dpp<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9230   [(set_attr "type" "ssemul")
9231    (set_attr "prefix_data16" "1")
9232    (set_attr "prefix_extra" "1")
9233    (set_attr "length_immediate" "1")
9234    (set_attr "mode" "<MODE>")])
9235
9236 (define_insn "sse4_1_movntdqa"
9237   [(set (match_operand:V2DI 0 "register_operand" "=x")
9238         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
9239                      UNSPEC_MOVNTDQA))]
9240   "TARGET_SSE4_1"
9241   "%vmovntdqa\t{%1, %0|%0, %1}"
9242   [(set_attr "type" "ssemov")
9243    (set_attr "prefix_extra" "1")
9244    (set_attr "prefix" "maybe_vex")
9245    (set_attr "mode" "TI")])
9246
9247 (define_insn "*avx_mpsadbw"
9248   [(set (match_operand:V16QI 0 "register_operand" "=x")
9249         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9250                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9251                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9252                       UNSPEC_MPSADBW))]
9253   "TARGET_AVX"
9254   "vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9255   [(set_attr "type" "sselog1")
9256    (set_attr "prefix" "vex")
9257    (set_attr "prefix_extra" "1")
9258    (set_attr "length_immediate" "1")
9259    (set_attr "mode" "TI")])
9260
9261 (define_insn "sse4_1_mpsadbw"
9262   [(set (match_operand:V16QI 0 "register_operand" "=x")
9263         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9264                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9265                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9266                       UNSPEC_MPSADBW))]
9267   "TARGET_SSE4_1"
9268   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
9269   [(set_attr "type" "sselog1")
9270    (set_attr "prefix_extra" "1")
9271    (set_attr "length_immediate" "1")
9272    (set_attr "mode" "TI")])
9273
9274 (define_insn "*avx_packusdw"
9275   [(set (match_operand:V8HI 0 "register_operand" "=x")
9276         (vec_concat:V8HI
9277           (us_truncate:V4HI
9278             (match_operand:V4SI 1 "register_operand" "x"))
9279           (us_truncate:V4HI
9280             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9281   "TARGET_AVX"
9282   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
9283   [(set_attr "type" "sselog")
9284    (set_attr "prefix_extra" "1")
9285    (set_attr "prefix" "vex")
9286    (set_attr "mode" "TI")])
9287
9288 (define_insn "sse4_1_packusdw"
9289   [(set (match_operand:V8HI 0 "register_operand" "=x")
9290         (vec_concat:V8HI
9291           (us_truncate:V4HI
9292             (match_operand:V4SI 1 "register_operand" "0"))
9293           (us_truncate:V4HI
9294             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9295   "TARGET_SSE4_1"
9296   "packusdw\t{%2, %0|%0, %2}"
9297   [(set_attr "type" "sselog")
9298    (set_attr "prefix_extra" "1")
9299    (set_attr "mode" "TI")])
9300
9301 (define_insn "*avx_pblendvb"
9302   [(set (match_operand:V16QI 0 "register_operand" "=x")
9303         (unspec:V16QI [(match_operand:V16QI 1 "register_operand"  "x")
9304                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9305                        (match_operand:V16QI 3 "register_operand" "x")]
9306                       UNSPEC_BLENDV))]
9307   "TARGET_AVX"
9308   "vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9309   [(set_attr "type" "ssemov")
9310    (set_attr "prefix_extra" "1")
9311    (set_attr "length_immediate" "1")
9312    (set_attr "prefix" "vex")
9313    (set_attr "mode" "TI")])
9314
9315 (define_insn "sse4_1_pblendvb"
9316   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
9317         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
9318                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
9319                        (match_operand:V16QI 3 "register_operand" "Yz")]
9320                       UNSPEC_BLENDV))]
9321   "TARGET_SSE4_1"
9322   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
9323   [(set_attr "type" "ssemov")
9324    (set_attr "prefix_extra" "1")
9325    (set_attr "mode" "TI")])
9326
9327 (define_insn "*avx_pblendw"
9328   [(set (match_operand:V8HI 0 "register_operand" "=x")
9329         (vec_merge:V8HI
9330           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9331           (match_operand:V8HI 1 "register_operand" "x")
9332           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9333   "TARGET_AVX"
9334   "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9335   [(set_attr "type" "ssemov")
9336    (set_attr "prefix" "vex")
9337    (set_attr "prefix_extra" "1")
9338    (set_attr "length_immediate" "1")
9339    (set_attr "mode" "TI")])
9340
9341 (define_insn "sse4_1_pblendw"
9342   [(set (match_operand:V8HI 0 "register_operand" "=x")
9343         (vec_merge:V8HI
9344           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9345           (match_operand:V8HI 1 "register_operand" "0")
9346           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9347   "TARGET_SSE4_1"
9348   "pblendw\t{%3, %2, %0|%0, %2, %3}"
9349   [(set_attr "type" "ssemov")
9350    (set_attr "prefix_extra" "1")
9351    (set_attr "length_immediate" "1")
9352    (set_attr "mode" "TI")])
9353
9354 (define_insn "sse4_1_phminposuw"
9355   [(set (match_operand:V8HI 0 "register_operand" "=x")
9356         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
9357                      UNSPEC_PHMINPOSUW))]
9358   "TARGET_SSE4_1"
9359   "%vphminposuw\t{%1, %0|%0, %1}"
9360   [(set_attr "type" "sselog1")
9361    (set_attr "prefix_extra" "1")
9362    (set_attr "prefix" "maybe_vex")
9363    (set_attr "mode" "TI")])
9364
9365 (define_insn "sse4_1_extendv8qiv8hi2"
9366   [(set (match_operand:V8HI 0 "register_operand" "=x")
9367         (sign_extend:V8HI
9368           (vec_select:V8QI
9369             (match_operand:V16QI 1 "register_operand" "x")
9370             (parallel [(const_int 0)
9371                        (const_int 1)
9372                        (const_int 2)
9373                        (const_int 3)
9374                        (const_int 4)
9375                        (const_int 5)
9376                        (const_int 6)
9377                        (const_int 7)]))))]
9378   "TARGET_SSE4_1"
9379   "%vpmovsxbw\t{%1, %0|%0, %1}"
9380   [(set_attr "type" "ssemov")
9381    (set_attr "prefix_extra" "1")
9382    (set_attr "prefix" "maybe_vex")
9383    (set_attr "mode" "TI")])
9384
9385 (define_insn "*sse4_1_extendv8qiv8hi2"
9386   [(set (match_operand:V8HI 0 "register_operand" "=x")
9387         (sign_extend:V8HI
9388           (vec_select:V8QI
9389             (vec_duplicate:V16QI
9390               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9391             (parallel [(const_int 0)
9392                        (const_int 1)
9393                        (const_int 2)
9394                        (const_int 3)
9395                        (const_int 4)
9396                        (const_int 5)
9397                        (const_int 6)
9398                        (const_int 7)]))))]
9399   "TARGET_SSE4_1"
9400   "%vpmovsxbw\t{%1, %0|%0, %1}"
9401   [(set_attr "type" "ssemov")
9402    (set_attr "prefix_extra" "1")
9403    (set_attr "prefix" "maybe_vex")
9404    (set_attr "mode" "TI")])
9405
9406 (define_insn "sse4_1_extendv4qiv4si2"
9407   [(set (match_operand:V4SI 0 "register_operand" "=x")
9408         (sign_extend:V4SI
9409           (vec_select:V4QI
9410             (match_operand:V16QI 1 "register_operand" "x")
9411             (parallel [(const_int 0)
9412                        (const_int 1)
9413                        (const_int 2)
9414                        (const_int 3)]))))]
9415   "TARGET_SSE4_1"
9416   "%vpmovsxbd\t{%1, %0|%0, %1}"
9417   [(set_attr "type" "ssemov")
9418    (set_attr "prefix_extra" "1")
9419    (set_attr "prefix" "maybe_vex")
9420    (set_attr "mode" "TI")])
9421
9422 (define_insn "*sse4_1_extendv4qiv4si2"
9423   [(set (match_operand:V4SI 0 "register_operand" "=x")
9424         (sign_extend:V4SI
9425           (vec_select:V4QI
9426             (vec_duplicate:V16QI
9427               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9428             (parallel [(const_int 0)
9429                        (const_int 1)
9430                        (const_int 2)
9431                        (const_int 3)]))))]
9432   "TARGET_SSE4_1"
9433   "%vpmovsxbd\t{%1, %0|%0, %1}"
9434   [(set_attr "type" "ssemov")
9435    (set_attr "prefix_extra" "1")
9436    (set_attr "prefix" "maybe_vex")
9437    (set_attr "mode" "TI")])
9438
9439 (define_insn "sse4_1_extendv2qiv2di2"
9440   [(set (match_operand:V2DI 0 "register_operand" "=x")
9441         (sign_extend:V2DI
9442           (vec_select:V2QI
9443             (match_operand:V16QI 1 "register_operand" "x")
9444             (parallel [(const_int 0)
9445                        (const_int 1)]))))]
9446   "TARGET_SSE4_1"
9447   "%vpmovsxbq\t{%1, %0|%0, %1}"
9448   [(set_attr "type" "ssemov")
9449    (set_attr "prefix_extra" "1")
9450    (set_attr "prefix" "maybe_vex")
9451    (set_attr "mode" "TI")])
9452
9453 (define_insn "*sse4_1_extendv2qiv2di2"
9454   [(set (match_operand:V2DI 0 "register_operand" "=x")
9455         (sign_extend:V2DI
9456           (vec_select:V2QI
9457             (vec_duplicate:V16QI
9458               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9459             (parallel [(const_int 0)
9460                        (const_int 1)]))))]
9461   "TARGET_SSE4_1"
9462   "%vpmovsxbq\t{%1, %0|%0, %1}"
9463   [(set_attr "type" "ssemov")
9464    (set_attr "prefix_extra" "1")
9465    (set_attr "prefix" "maybe_vex")
9466    (set_attr "mode" "TI")])
9467
9468 (define_insn "sse4_1_extendv4hiv4si2"
9469   [(set (match_operand:V4SI 0 "register_operand" "=x")
9470         (sign_extend:V4SI
9471           (vec_select:V4HI
9472             (match_operand:V8HI 1 "register_operand" "x")
9473             (parallel [(const_int 0)
9474                        (const_int 1)
9475                        (const_int 2)
9476                        (const_int 3)]))))]
9477   "TARGET_SSE4_1"
9478   "%vpmovsxwd\t{%1, %0|%0, %1}"
9479   [(set_attr "type" "ssemov")
9480    (set_attr "prefix_extra" "1")
9481    (set_attr "prefix" "maybe_vex")
9482    (set_attr "mode" "TI")])
9483
9484 (define_insn "*sse4_1_extendv4hiv4si2"
9485   [(set (match_operand:V4SI 0 "register_operand" "=x")
9486         (sign_extend:V4SI
9487           (vec_select:V4HI
9488             (vec_duplicate:V8HI
9489               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9490             (parallel [(const_int 0)
9491                        (const_int 1)
9492                        (const_int 2)
9493                        (const_int 3)]))))]
9494   "TARGET_SSE4_1"
9495   "%vpmovsxwd\t{%1, %0|%0, %1}"
9496   [(set_attr "type" "ssemov")
9497    (set_attr "prefix_extra" "1")
9498    (set_attr "prefix" "maybe_vex")
9499    (set_attr "mode" "TI")])
9500
9501 (define_insn "sse4_1_extendv2hiv2di2"
9502   [(set (match_operand:V2DI 0 "register_operand" "=x")
9503         (sign_extend:V2DI
9504           (vec_select:V2HI
9505             (match_operand:V8HI 1 "register_operand" "x")
9506             (parallel [(const_int 0)
9507                        (const_int 1)]))))]
9508   "TARGET_SSE4_1"
9509   "%vpmovsxwq\t{%1, %0|%0, %1}"
9510   [(set_attr "type" "ssemov")
9511    (set_attr "prefix_extra" "1")
9512    (set_attr "prefix" "maybe_vex")
9513    (set_attr "mode" "TI")])
9514
9515 (define_insn "*sse4_1_extendv2hiv2di2"
9516   [(set (match_operand:V2DI 0 "register_operand" "=x")
9517         (sign_extend:V2DI
9518           (vec_select:V2HI
9519             (vec_duplicate:V8HI
9520               (match_operand:V8HI 1 "nonimmediate_operand" "xm"))
9521             (parallel [(const_int 0)
9522                        (const_int 1)]))))]
9523   "TARGET_SSE4_1"
9524   "%vpmovsxwq\t{%1, %0|%0, %1}"
9525   [(set_attr "type" "ssemov")
9526    (set_attr "prefix_extra" "1")
9527    (set_attr "prefix" "maybe_vex")
9528    (set_attr "mode" "TI")])
9529
9530 (define_insn "sse4_1_extendv2siv2di2"
9531   [(set (match_operand:V2DI 0 "register_operand" "=x")
9532         (sign_extend:V2DI
9533           (vec_select:V2SI
9534             (match_operand:V4SI 1 "register_operand" "x")
9535             (parallel [(const_int 0)
9536                        (const_int 1)]))))]
9537   "TARGET_SSE4_1"
9538   "%vpmovsxdq\t{%1, %0|%0, %1}"
9539   [(set_attr "type" "ssemov")
9540    (set_attr "prefix_extra" "1")
9541    (set_attr "prefix" "maybe_vex")
9542    (set_attr "mode" "TI")])
9543
9544 (define_insn "*sse4_1_extendv2siv2di2"
9545   [(set (match_operand:V2DI 0 "register_operand" "=x")
9546         (sign_extend:V2DI
9547           (vec_select:V2SI
9548             (vec_duplicate:V4SI
9549               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9550             (parallel [(const_int 0)
9551                        (const_int 1)]))))]
9552   "TARGET_SSE4_1"
9553   "%vpmovsxdq\t{%1, %0|%0, %1}"
9554   [(set_attr "type" "ssemov")
9555    (set_attr "prefix_extra" "1")
9556    (set_attr "prefix" "maybe_vex")
9557    (set_attr "mode" "TI")])
9558
9559 (define_insn "sse4_1_zero_extendv8qiv8hi2"
9560   [(set (match_operand:V8HI 0 "register_operand" "=x")
9561         (zero_extend:V8HI
9562           (vec_select:V8QI
9563             (match_operand:V16QI 1 "register_operand" "x")
9564             (parallel [(const_int 0)
9565                        (const_int 1)
9566                        (const_int 2)
9567                        (const_int 3)
9568                        (const_int 4)
9569                        (const_int 5)
9570                        (const_int 6)
9571                        (const_int 7)]))))]
9572   "TARGET_SSE4_1"
9573   "%vpmovzxbw\t{%1, %0|%0, %1}"
9574   [(set_attr "type" "ssemov")
9575    (set_attr "prefix_extra" "1")
9576    (set_attr "prefix" "maybe_vex")
9577    (set_attr "mode" "TI")])
9578
9579 (define_insn "*sse4_1_zero_extendv8qiv8hi2"
9580   [(set (match_operand:V8HI 0 "register_operand" "=x")
9581         (zero_extend:V8HI
9582           (vec_select:V8QI
9583             (vec_duplicate:V16QI
9584               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
9585             (parallel [(const_int 0)
9586                        (const_int 1)
9587                        (const_int 2)
9588                        (const_int 3)
9589                        (const_int 4)
9590                        (const_int 5)
9591                        (const_int 6)
9592                        (const_int 7)]))))]
9593   "TARGET_SSE4_1"
9594   "%vpmovzxbw\t{%1, %0|%0, %1}"
9595   [(set_attr "type" "ssemov")
9596    (set_attr "prefix_extra" "1")
9597    (set_attr "prefix" "maybe_vex")
9598    (set_attr "mode" "TI")])
9599
9600 (define_insn "sse4_1_zero_extendv4qiv4si2"
9601   [(set (match_operand:V4SI 0 "register_operand" "=x")
9602         (zero_extend:V4SI
9603           (vec_select:V4QI
9604             (match_operand:V16QI 1 "register_operand" "x")
9605             (parallel [(const_int 0)
9606                        (const_int 1)
9607                        (const_int 2)
9608                        (const_int 3)]))))]
9609   "TARGET_SSE4_1"
9610   "%vpmovzxbd\t{%1, %0|%0, %1}"
9611   [(set_attr "type" "ssemov")
9612    (set_attr "prefix_extra" "1")
9613    (set_attr "prefix" "maybe_vex")
9614    (set_attr "mode" "TI")])
9615
9616 (define_insn "*sse4_1_zero_extendv4qiv4si2"
9617   [(set (match_operand:V4SI 0 "register_operand" "=x")
9618         (zero_extend:V4SI
9619           (vec_select:V4QI
9620             (vec_duplicate:V16QI
9621               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
9622             (parallel [(const_int 0)
9623                        (const_int 1)
9624                        (const_int 2)
9625                        (const_int 3)]))))]
9626   "TARGET_SSE4_1"
9627   "%vpmovzxbd\t{%1, %0|%0, %1}"
9628   [(set_attr "type" "ssemov")
9629    (set_attr "prefix_extra" "1")
9630    (set_attr "prefix" "maybe_vex")
9631    (set_attr "mode" "TI")])
9632
9633 (define_insn "sse4_1_zero_extendv2qiv2di2"
9634   [(set (match_operand:V2DI 0 "register_operand" "=x")
9635         (zero_extend:V2DI
9636           (vec_select:V2QI
9637             (match_operand:V16QI 1 "register_operand" "x")
9638             (parallel [(const_int 0)
9639                        (const_int 1)]))))]
9640   "TARGET_SSE4_1"
9641   "%vpmovzxbq\t{%1, %0|%0, %1}"
9642   [(set_attr "type" "ssemov")
9643    (set_attr "prefix_extra" "1")
9644    (set_attr "prefix" "maybe_vex")
9645    (set_attr "mode" "TI")])
9646
9647 (define_insn "*sse4_1_zero_extendv2qiv2di2"
9648   [(set (match_operand:V2DI 0 "register_operand" "=x")
9649         (zero_extend:V2DI
9650           (vec_select:V2QI
9651             (vec_duplicate:V16QI
9652               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
9653             (parallel [(const_int 0)
9654                        (const_int 1)]))))]
9655   "TARGET_SSE4_1"
9656   "%vpmovzxbq\t{%1, %0|%0, %1}"
9657   [(set_attr "type" "ssemov")
9658    (set_attr "prefix_extra" "1")
9659    (set_attr "prefix" "maybe_vex")
9660    (set_attr "mode" "TI")])
9661
9662 (define_insn "sse4_1_zero_extendv4hiv4si2"
9663   [(set (match_operand:V4SI 0 "register_operand" "=x")
9664         (zero_extend:V4SI
9665           (vec_select:V4HI
9666             (match_operand:V8HI 1 "register_operand" "x")
9667             (parallel [(const_int 0)
9668                        (const_int 1)
9669                        (const_int 2)
9670                        (const_int 3)]))))]
9671   "TARGET_SSE4_1"
9672   "%vpmovzxwd\t{%1, %0|%0, %1}"
9673   [(set_attr "type" "ssemov")
9674    (set_attr "prefix_extra" "1")
9675    (set_attr "prefix" "maybe_vex")
9676    (set_attr "mode" "TI")])
9677
9678 (define_insn "*sse4_1_zero_extendv4hiv4si2"
9679   [(set (match_operand:V4SI 0 "register_operand" "=x")
9680         (zero_extend:V4SI
9681           (vec_select:V4HI
9682             (vec_duplicate:V8HI
9683               (match_operand:V4HI 1 "nonimmediate_operand" "xm"))
9684             (parallel [(const_int 0)
9685                        (const_int 1)
9686                        (const_int 2)
9687                        (const_int 3)]))))]
9688   "TARGET_SSE4_1"
9689   "%vpmovzxwd\t{%1, %0|%0, %1}"
9690   [(set_attr "type" "ssemov")
9691    (set_attr "prefix_extra" "1")
9692    (set_attr "prefix" "maybe_vex")
9693    (set_attr "mode" "TI")])
9694
9695 (define_insn "sse4_1_zero_extendv2hiv2di2"
9696   [(set (match_operand:V2DI 0 "register_operand" "=x")
9697         (zero_extend:V2DI
9698           (vec_select:V2HI
9699             (match_operand:V8HI 1 "register_operand" "x")
9700             (parallel [(const_int 0)
9701                        (const_int 1)]))))]
9702   "TARGET_SSE4_1"
9703   "%vpmovzxwq\t{%1, %0|%0, %1}"
9704   [(set_attr "type" "ssemov")
9705    (set_attr "prefix_extra" "1")
9706    (set_attr "prefix" "maybe_vex")
9707    (set_attr "mode" "TI")])
9708
9709 (define_insn "*sse4_1_zero_extendv2hiv2di2"
9710   [(set (match_operand:V2DI 0 "register_operand" "=x")
9711         (zero_extend:V2DI
9712           (vec_select:V2HI
9713             (vec_duplicate:V8HI
9714               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
9715             (parallel [(const_int 0)
9716                        (const_int 1)]))))]
9717   "TARGET_SSE4_1"
9718   "%vpmovzxwq\t{%1, %0|%0, %1}"
9719   [(set_attr "type" "ssemov")
9720    (set_attr "prefix_extra" "1")
9721    (set_attr "prefix" "maybe_vex")
9722    (set_attr "mode" "TI")])
9723
9724 (define_insn "sse4_1_zero_extendv2siv2di2"
9725   [(set (match_operand:V2DI 0 "register_operand" "=x")
9726         (zero_extend:V2DI
9727           (vec_select:V2SI
9728             (match_operand:V4SI 1 "register_operand" "x")
9729             (parallel [(const_int 0)
9730                        (const_int 1)]))))]
9731   "TARGET_SSE4_1"
9732   "%vpmovzxdq\t{%1, %0|%0, %1}"
9733   [(set_attr "type" "ssemov")
9734    (set_attr "prefix_extra" "1")
9735    (set_attr "prefix" "maybe_vex")
9736    (set_attr "mode" "TI")])
9737
9738 (define_insn "*sse4_1_zero_extendv2siv2di2"
9739   [(set (match_operand:V2DI 0 "register_operand" "=x")
9740         (zero_extend:V2DI
9741           (vec_select:V2SI
9742             (vec_duplicate:V4SI
9743               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
9744             (parallel [(const_int 0)
9745                        (const_int 1)]))))]
9746   "TARGET_SSE4_1"
9747   "%vpmovzxdq\t{%1, %0|%0, %1}"
9748   [(set_attr "type" "ssemov")
9749    (set_attr "prefix_extra" "1")
9750    (set_attr "prefix" "maybe_vex")
9751    (set_attr "mode" "TI")])
9752
9753 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
9754 ;; setting FLAGS_REG. But it is not a really compare instruction.
9755 (define_insn "avx_vtestp<avxmodesuffixf2c><avxmodesuffix>"
9756   [(set (reg:CC FLAGS_REG)
9757         (unspec:CC [(match_operand:AVXMODEF2P 0 "register_operand" "x")
9758                     (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")]
9759                    UNSPEC_VTESTP))]
9760   "TARGET_AVX"
9761   "vtestp<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
9762   [(set_attr "type" "ssecomi")
9763    (set_attr "prefix_extra" "1")
9764    (set_attr "prefix" "vex")
9765    (set_attr "mode" "<MODE>")])
9766
9767 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
9768 ;; But it is not a really compare instruction.
9769 (define_insn "avx_ptest256"
9770   [(set (reg:CC FLAGS_REG)
9771         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
9772                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
9773                    UNSPEC_PTEST))]
9774   "TARGET_AVX"
9775   "vptest\t{%1, %0|%0, %1}"
9776   [(set_attr "type" "ssecomi")
9777    (set_attr "prefix_extra" "1")
9778    (set_attr "prefix" "vex")
9779    (set_attr "mode" "OI")])
9780
9781 (define_insn "sse4_1_ptest"
9782   [(set (reg:CC FLAGS_REG)
9783         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
9784                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
9785                    UNSPEC_PTEST))]
9786   "TARGET_SSE4_1"
9787   "%vptest\t{%1, %0|%0, %1}"
9788   [(set_attr "type" "ssecomi")
9789    (set_attr "prefix_extra" "1")
9790    (set_attr "prefix" "maybe_vex")
9791    (set_attr "mode" "TI")])
9792
9793 (define_insn "avx_roundp<avxmodesuffixf2c>256"
9794   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
9795         (unspec:AVX256MODEF2P
9796           [(match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "xm")
9797            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9798           UNSPEC_ROUND))]
9799   "TARGET_AVX"
9800   "vroundp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9801   [(set_attr "type" "ssecvt")
9802    (set_attr "prefix_extra" "1")
9803    (set_attr "length_immediate" "1")
9804    (set_attr "prefix" "vex")
9805    (set_attr "mode" "<MODE>")])
9806
9807 (define_insn "sse4_1_roundp<ssemodesuffixf2c>"
9808   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9809         (unspec:SSEMODEF2P
9810           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")
9811            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9812           UNSPEC_ROUND))]
9813   "TARGET_ROUND"
9814   "%vroundp<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
9815   [(set_attr "type" "ssecvt")
9816    (set_attr "prefix_data16" "1")
9817    (set_attr "prefix_extra" "1")
9818    (set_attr "length_immediate" "1")
9819    (set_attr "prefix" "maybe_vex")
9820    (set_attr "mode" "<MODE>")])
9821
9822 (define_insn "*avx_rounds<ssemodesuffixf2c>"
9823   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9824         (vec_merge:SSEMODEF2P
9825           (unspec:SSEMODEF2P
9826             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9827              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9828             UNSPEC_ROUND)
9829           (match_operand:SSEMODEF2P 1 "register_operand" "x")
9830           (const_int 1)))]
9831   "TARGET_AVX"
9832   "vrounds<ssemodesuffixf2c>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9833   [(set_attr "type" "ssecvt")
9834    (set_attr "prefix_extra" "1")
9835    (set_attr "length_immediate" "1")
9836    (set_attr "prefix" "vex")
9837    (set_attr "mode" "<MODE>")])
9838
9839 (define_insn "sse4_1_rounds<ssemodesuffixf2c>"
9840   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9841         (vec_merge:SSEMODEF2P
9842           (unspec:SSEMODEF2P
9843             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9844              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9845             UNSPEC_ROUND)
9846           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9847           (const_int 1)))]
9848   "TARGET_ROUND"
9849   "rounds<ssemodesuffixf2c>\t{%3, %2, %0|%0, %2, %3}"
9850   [(set_attr "type" "ssecvt")
9851    (set_attr "prefix_data16" "1")
9852    (set_attr "prefix_extra" "1")
9853    (set_attr "length_immediate" "1")
9854    (set_attr "mode" "<MODE>")])
9855
9856 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9857 ;;
9858 ;; Intel SSE4.2 string/text processing instructions
9859 ;;
9860 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9861
9862 (define_insn_and_split "sse4_2_pcmpestr"
9863   [(set (match_operand:SI 0 "register_operand" "=c,c")
9864         (unspec:SI
9865           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
9866            (match_operand:SI 3 "register_operand" "a,a")
9867            (match_operand:V16QI 4 "nonimm_not_xmm0_operand" "x,m")
9868            (match_operand:SI 5 "register_operand" "d,d")
9869            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
9870           UNSPEC_PCMPESTR))
9871    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9872         (unspec:V16QI
9873           [(match_dup 2)
9874            (match_dup 3)
9875            (match_dup 4)
9876            (match_dup 5)
9877            (match_dup 6)]
9878           UNSPEC_PCMPESTR))
9879    (set (reg:CC FLAGS_REG)
9880         (unspec:CC
9881           [(match_dup 2)
9882            (match_dup 3)
9883            (match_dup 4)
9884            (match_dup 5)
9885            (match_dup 6)]
9886           UNSPEC_PCMPESTR))]
9887   "TARGET_SSE4_2
9888    && can_create_pseudo_p ()"
9889   "#"
9890   "&& 1"
9891   [(const_int 0)]
9892 {
9893   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9894   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9895   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9896
9897   if (ecx)
9898     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
9899                                      operands[3], operands[4],
9900                                      operands[5], operands[6]));
9901   if (xmm0)
9902     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
9903                                      operands[3], operands[4],
9904                                      operands[5], operands[6]));
9905   if (flags && !(ecx || xmm0))
9906     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
9907                                            operands[2], operands[3],
9908                                            operands[4], operands[5],
9909                                            operands[6]));
9910   DONE;
9911 }
9912   [(set_attr "type" "sselog")
9913    (set_attr "prefix_data16" "1")
9914    (set_attr "prefix_extra" "1")
9915    (set_attr "length_immediate" "1")
9916    (set_attr "memory" "none,load")
9917    (set_attr "mode" "TI")])
9918
9919 (define_insn "sse4_2_pcmpestri"
9920   [(set (match_operand:SI 0 "register_operand" "=c,c")
9921         (unspec:SI
9922           [(match_operand:V16QI 1 "register_operand" "x,x")
9923            (match_operand:SI 2 "register_operand" "a,a")
9924            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9925            (match_operand:SI 4 "register_operand" "d,d")
9926            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9927           UNSPEC_PCMPESTR))
9928    (set (reg:CC FLAGS_REG)
9929         (unspec:CC
9930           [(match_dup 1)
9931            (match_dup 2)
9932            (match_dup 3)
9933            (match_dup 4)
9934            (match_dup 5)]
9935           UNSPEC_PCMPESTR))]
9936   "TARGET_SSE4_2"
9937   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
9938   [(set_attr "type" "sselog")
9939    (set_attr "prefix_data16" "1")
9940    (set_attr "prefix_extra" "1")
9941    (set_attr "prefix" "maybe_vex")
9942    (set_attr "length_immediate" "1")
9943    (set_attr "memory" "none,load")
9944    (set_attr "mode" "TI")])
9945
9946 (define_insn "sse4_2_pcmpestrm"
9947   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9948         (unspec:V16QI
9949           [(match_operand:V16QI 1 "register_operand" "x,x")
9950            (match_operand:SI 2 "register_operand" "a,a")
9951            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9952            (match_operand:SI 4 "register_operand" "d,d")
9953            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9954           UNSPEC_PCMPESTR))
9955    (set (reg:CC FLAGS_REG)
9956         (unspec:CC
9957           [(match_dup 1)
9958            (match_dup 2)
9959            (match_dup 3)
9960            (match_dup 4)
9961            (match_dup 5)]
9962           UNSPEC_PCMPESTR))]
9963   "TARGET_SSE4_2"
9964   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
9965   [(set_attr "type" "sselog")
9966    (set_attr "prefix_data16" "1")
9967    (set_attr "prefix_extra" "1")
9968    (set_attr "length_immediate" "1")
9969    (set_attr "prefix" "maybe_vex")
9970    (set_attr "memory" "none,load")
9971    (set_attr "mode" "TI")])
9972
9973 (define_insn "sse4_2_pcmpestr_cconly"
9974   [(set (reg:CC FLAGS_REG)
9975         (unspec:CC
9976           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9977            (match_operand:SI 3 "register_operand" "a,a,a,a")
9978            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
9979            (match_operand:SI 5 "register_operand" "d,d,d,d")
9980            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
9981           UNSPEC_PCMPESTR))
9982    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9983    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9984   "TARGET_SSE4_2"
9985   "@
9986    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9987    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9988    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
9989    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
9990   [(set_attr "type" "sselog")
9991    (set_attr "prefix_data16" "1")
9992    (set_attr "prefix_extra" "1")
9993    (set_attr "length_immediate" "1")
9994    (set_attr "memory" "none,load,none,load")
9995    (set_attr "prefix" "maybe_vex")
9996    (set_attr "mode" "TI")])
9997
9998 (define_insn_and_split "sse4_2_pcmpistr"
9999   [(set (match_operand:SI 0 "register_operand" "=c,c")
10000         (unspec:SI
10001           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
10002            (match_operand:V16QI 3 "nonimm_not_xmm0_operand" "x,m")
10003            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
10004           UNSPEC_PCMPISTR))
10005    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
10006         (unspec:V16QI
10007           [(match_dup 2)
10008            (match_dup 3)
10009            (match_dup 4)]
10010           UNSPEC_PCMPISTR))
10011    (set (reg:CC FLAGS_REG)
10012         (unspec:CC
10013           [(match_dup 2)
10014            (match_dup 3)
10015            (match_dup 4)]
10016           UNSPEC_PCMPISTR))]
10017   "TARGET_SSE4_2
10018    && can_create_pseudo_p ()"
10019   "#"
10020   "&& 1"
10021   [(const_int 0)]
10022 {
10023   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
10024   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
10025   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
10026
10027   if (ecx)
10028     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
10029                                      operands[3], operands[4]));
10030   if (xmm0)
10031     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
10032                                      operands[3], operands[4]));
10033   if (flags && !(ecx || xmm0))
10034     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
10035                                            operands[2], operands[3],
10036                                            operands[4]));
10037   DONE;
10038 }
10039   [(set_attr "type" "sselog")
10040    (set_attr "prefix_data16" "1")
10041    (set_attr "prefix_extra" "1")
10042    (set_attr "length_immediate" "1")
10043    (set_attr "memory" "none,load")
10044    (set_attr "mode" "TI")])
10045
10046 (define_insn "sse4_2_pcmpistri"
10047   [(set (match_operand:SI 0 "register_operand" "=c,c")
10048         (unspec:SI
10049           [(match_operand:V16QI 1 "register_operand" "x,x")
10050            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10051            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10052           UNSPEC_PCMPISTR))
10053    (set (reg:CC FLAGS_REG)
10054         (unspec:CC
10055           [(match_dup 1)
10056            (match_dup 2)
10057            (match_dup 3)]
10058           UNSPEC_PCMPISTR))]
10059   "TARGET_SSE4_2"
10060   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
10061   [(set_attr "type" "sselog")
10062    (set_attr "prefix_data16" "1")
10063    (set_attr "prefix_extra" "1")
10064    (set_attr "length_immediate" "1")
10065    (set_attr "prefix" "maybe_vex")
10066    (set_attr "memory" "none,load")
10067    (set_attr "mode" "TI")])
10068
10069 (define_insn "sse4_2_pcmpistrm"
10070   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
10071         (unspec:V16QI
10072           [(match_operand:V16QI 1 "register_operand" "x,x")
10073            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10074            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10075           UNSPEC_PCMPISTR))
10076    (set (reg:CC FLAGS_REG)
10077         (unspec:CC
10078           [(match_dup 1)
10079            (match_dup 2)
10080            (match_dup 3)]
10081           UNSPEC_PCMPISTR))]
10082   "TARGET_SSE4_2"
10083   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
10084   [(set_attr "type" "sselog")
10085    (set_attr "prefix_data16" "1")
10086    (set_attr "prefix_extra" "1")
10087    (set_attr "length_immediate" "1")
10088    (set_attr "prefix" "maybe_vex")
10089    (set_attr "memory" "none,load")
10090    (set_attr "mode" "TI")])
10091
10092 (define_insn "sse4_2_pcmpistr_cconly"
10093   [(set (reg:CC FLAGS_REG)
10094         (unspec:CC
10095           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
10096            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
10097            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
10098           UNSPEC_PCMPISTR))
10099    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
10100    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
10101   "TARGET_SSE4_2"
10102   "@
10103    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10104    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
10105    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
10106    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
10107   [(set_attr "type" "sselog")
10108    (set_attr "prefix_data16" "1")
10109    (set_attr "prefix_extra" "1")
10110    (set_attr "length_immediate" "1")
10111    (set_attr "memory" "none,load,none,load")
10112    (set_attr "prefix" "maybe_vex")
10113    (set_attr "mode" "TI")])
10114
10115 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10116 ;;
10117 ;; SSE5 instructions
10118 ;;
10119 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10120
10121 ;; SSE5 parallel integer multiply/add instructions.
10122 ;; Note the instruction does not allow the value being added to be a memory
10123 ;; operation.  However by pretending via the nonimmediate_operand predicate
10124 ;; that it does and splitting it later allows the following to be recognized:
10125 ;;      a[i] = b[i] * c[i] + d[i];
10126 (define_insn "sse5_pmacsww"
10127   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x")
10128         (plus:V8HI
10129          (mult:V8HI
10130           (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,xm")
10131           (match_operand:V8HI 2 "nonimmediate_operand" "x,xm,x"))
10132          (match_operand:V8HI 3 "register_operand" "0,0,0")))]
10133   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)"
10134   "@
10135    pmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}
10136    pmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}
10137    pmacsww\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10138   [(set_attr "type" "ssemuladd")
10139    (set_attr "mode" "TI")])
10140
10141 ;; Split pmacsww with two memory operands into a load and the pmacsww.
10142 (define_split
10143   [(set (match_operand:V8HI 0 "register_operand" "")
10144         (plus:V8HI
10145          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
10146                     (match_operand:V8HI 2 "nonimmediate_operand" ""))
10147          (match_operand:V8HI 3 "nonimmediate_operand" "")))]
10148   "TARGET_SSE5
10149    && !ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)
10150    && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)
10151    && !reg_mentioned_p (operands[0], operands[1])
10152    && !reg_mentioned_p (operands[0], operands[2])
10153    && !reg_mentioned_p (operands[0], operands[3])"
10154   [(const_int 0)]
10155 {
10156   ix86_expand_sse5_multiple_memory (operands, 4, V8HImode);
10157   emit_insn (gen_sse5_pmacsww (operands[0], operands[1], operands[2],
10158                                operands[3]));
10159   DONE;
10160 })
10161
10162 (define_insn "sse5_pmacssww"
10163   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x")
10164         (ss_plus:V8HI
10165          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10166                     (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x"))
10167          (match_operand:V8HI 3 "register_operand" "0,0,0")))]
10168   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10169   "@
10170    pmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}
10171    pmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}
10172    pmacssww\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10173   [(set_attr "type" "ssemuladd")
10174    (set_attr "mode" "TI")])
10175
10176 ;; Note the instruction does not allow the value being added to be a memory
10177 ;; operation.  However by pretending via the nonimmediate_operand predicate
10178 ;; that it does and splitting it later allows the following to be recognized:
10179 ;;      a[i] = b[i] * c[i] + d[i];
10180 (define_insn "sse5_pmacsdd"
10181   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10182         (plus:V4SI
10183          (mult:V4SI
10184           (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10185           (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x"))
10186          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10187   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)"
10188   "@
10189    pmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10190    pmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10191    pmacsdd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10192   [(set_attr "type" "ssemuladd")
10193    (set_attr "mode" "TI")])
10194
10195 ;; Split pmacsdd with two memory operands into a load and the pmacsdd.
10196 (define_split
10197   [(set (match_operand:V4SI 0 "register_operand" "")
10198         (plus:V4SI
10199          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "")
10200                     (match_operand:V4SI 2 "nonimmediate_operand" ""))
10201          (match_operand:V4SI 3 "nonimmediate_operand" "")))]
10202   "TARGET_SSE5
10203    && !ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)
10204    && ix86_sse5_valid_op_p (operands, insn, 4, false, 2, true)
10205    && !reg_mentioned_p (operands[0], operands[1])
10206    && !reg_mentioned_p (operands[0], operands[2])
10207    && !reg_mentioned_p (operands[0], operands[3])"
10208   [(const_int 0)]
10209 {
10210   ix86_expand_sse5_multiple_memory (operands, 4, V4SImode);
10211   emit_insn (gen_sse5_pmacsdd (operands[0], operands[1], operands[2],
10212                                operands[3]));
10213   DONE;
10214 })
10215
10216 (define_insn "sse5_pmacssdd"
10217   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10218         (ss_plus:V4SI
10219          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10220                     (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x"))
10221          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10222   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10223   "@
10224    pmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10225    pmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10226    pmacssdd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10227   [(set_attr "type" "ssemuladd")
10228    (set_attr "mode" "TI")])
10229
10230 (define_insn "sse5_pmacssdql"
10231   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
10232         (ss_plus:V2DI
10233          (mult:V2DI
10234           (sign_extend:V2DI
10235            (vec_select:V2SI
10236             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10237             (parallel [(const_int 1)
10238                        (const_int 3)])))
10239            (vec_select:V2SI
10240             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10241             (parallel [(const_int 1)
10242                        (const_int 3)])))
10243          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
10244   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10245   "@
10246    pmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
10247    pmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
10248    pmacssdql\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10249   [(set_attr "type" "ssemuladd")
10250    (set_attr "mode" "TI")])
10251
10252 (define_insn "sse5_pmacssdqh"
10253   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
10254         (ss_plus:V2DI
10255          (mult:V2DI
10256           (sign_extend:V2DI
10257            (vec_select:V2SI
10258             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10259             (parallel [(const_int 0)
10260                        (const_int 2)])))
10261           (sign_extend:V2DI
10262            (vec_select:V2SI
10263             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10264             (parallel [(const_int 0)
10265                        (const_int 2)]))))
10266          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
10267   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10268   "@
10269    pmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10270    pmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10271    pmacssdqh\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10272   [(set_attr "type" "ssemuladd")
10273    (set_attr "mode" "TI")])
10274
10275 (define_insn "sse5_pmacsdql"
10276   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
10277         (plus:V2DI
10278          (mult:V2DI
10279           (sign_extend:V2DI
10280            (vec_select:V2SI
10281             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10282             (parallel [(const_int 1)
10283                        (const_int 3)])))
10284           (sign_extend:V2DI
10285            (vec_select:V2SI
10286             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10287             (parallel [(const_int 1)
10288                        (const_int 3)]))))
10289          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
10290   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10291   "@
10292    pmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
10293    pmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}
10294    pmacsdql\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10295   [(set_attr "type" "ssemuladd")
10296    (set_attr "mode" "TI")])
10297
10298 (define_insn_and_split "*sse5_pmacsdql_mem"
10299   [(set (match_operand:V2DI 0 "register_operand" "=&x,&x,&x")
10300         (plus:V2DI
10301          (mult:V2DI
10302           (sign_extend:V2DI
10303            (vec_select:V2SI
10304             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10305             (parallel [(const_int 1)
10306                        (const_int 3)])))
10307           (sign_extend:V2DI
10308            (vec_select:V2SI
10309             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10310             (parallel [(const_int 1)
10311                        (const_int 3)]))))
10312          (match_operand:V2DI 3 "memory_operand" "m,m,m")))]
10313   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, -1, true)"
10314   "#"
10315   "&& (reload_completed
10316        || (!reg_mentioned_p (operands[0], operands[1])
10317            && !reg_mentioned_p (operands[0], operands[2])))"
10318   [(set (match_dup 0)
10319         (match_dup 3))
10320    (set (match_dup 0)
10321         (plus:V2DI
10322          (mult:V2DI
10323           (sign_extend:V2DI
10324            (vec_select:V2SI
10325             (match_dup 1)
10326             (parallel [(const_int 1)
10327                        (const_int 3)])))
10328           (sign_extend:V2DI
10329            (vec_select:V2SI
10330             (match_dup 2)
10331             (parallel [(const_int 1)
10332                        (const_int 3)]))))
10333          (match_dup 0)))])
10334
10335 ;; We don't have a straight 32-bit parallel multiply and extend on SSE5, so
10336 ;; fake it with a multiply/add.  In general, we expect the define_split to
10337 ;; occur before register allocation, so we have to handle the corner case where
10338 ;; the target is the same as operands 1/2
10339 (define_insn_and_split "sse5_mulv2div2di3_low"
10340   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10341         (mult:V2DI
10342           (sign_extend:V2DI
10343             (vec_select:V2SI
10344               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10345               (parallel [(const_int 1)
10346                          (const_int 3)])))
10347           (sign_extend:V2DI
10348             (vec_select:V2SI
10349               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10350               (parallel [(const_int 1)
10351                          (const_int 3)])))))]
10352   "TARGET_SSE5"
10353   "#"
10354   "&& (reload_completed
10355        || (!reg_mentioned_p (operands[0], operands[1])
10356            && !reg_mentioned_p (operands[0], operands[2])))"
10357   [(set (match_dup 0)
10358         (match_dup 3))
10359    (set (match_dup 0)
10360         (plus:V2DI
10361          (mult:V2DI
10362           (sign_extend:V2DI
10363            (vec_select:V2SI
10364             (match_dup 1)
10365             (parallel [(const_int 1)
10366                        (const_int 3)])))
10367           (sign_extend:V2DI
10368            (vec_select:V2SI
10369             (match_dup 2)
10370             (parallel [(const_int 1)
10371                        (const_int 3)]))))
10372          (match_dup 0)))]
10373 {
10374   operands[3] = CONST0_RTX (V2DImode);
10375 }
10376   [(set_attr "type" "ssemuladd")
10377    (set_attr "mode" "TI")])
10378
10379 (define_insn "sse5_pmacsdqh"
10380   [(set (match_operand:V2DI 0 "register_operand" "=x,x,x")
10381         (plus:V2DI
10382          (mult:V2DI
10383           (sign_extend:V2DI
10384            (vec_select:V2SI
10385             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10386             (parallel [(const_int 0)
10387                        (const_int 2)])))
10388           (sign_extend:V2DI
10389            (vec_select:V2SI
10390             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10391             (parallel [(const_int 0)
10392                        (const_int 2)]))))
10393          (match_operand:V2DI 3 "register_operand" "0,0,0")))]
10394   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10395   "@
10396    pmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10397    pmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}
10398    pmacsdqh\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10399   [(set_attr "type" "ssemuladd")
10400    (set_attr "mode" "TI")])
10401
10402 (define_insn_and_split "*sse5_pmacsdqh_mem"
10403   [(set (match_operand:V2DI 0 "register_operand" "=&x,&x,&x")
10404         (plus:V2DI
10405          (mult:V2DI
10406           (sign_extend:V2DI
10407            (vec_select:V2SI
10408             (match_operand:V4SI 1 "nonimmediate_operand" "%x,x,m")
10409             (parallel [(const_int 0)
10410                        (const_int 2)])))
10411           (sign_extend:V2DI
10412            (vec_select:V2SI
10413             (match_operand:V4SI 2 "nonimmediate_operand" "x,m,x")
10414             (parallel [(const_int 0)
10415                        (const_int 2)]))))
10416          (match_operand:V2DI 3 "memory_operand" "m,m,m")))]
10417   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, -1, true)"
10418   "#"
10419   "&& (reload_completed
10420        || (!reg_mentioned_p (operands[0], operands[1])
10421            && !reg_mentioned_p (operands[0], operands[2])))"
10422   [(set (match_dup 0)
10423         (match_dup 3))
10424    (set (match_dup 0)
10425         (plus:V2DI
10426          (mult:V2DI
10427           (sign_extend:V2DI
10428            (vec_select:V2SI
10429             (match_dup 1)
10430             (parallel [(const_int 0)
10431                        (const_int 2)])))
10432           (sign_extend:V2DI
10433            (vec_select:V2SI
10434             (match_dup 2)
10435             (parallel [(const_int 0)
10436                        (const_int 2)]))))
10437          (match_dup 0)))])
10438
10439 ;; We don't have a straight 32-bit parallel multiply and extend on SSE5, so
10440 ;; fake it with a multiply/add.  In general, we expect the define_split to
10441 ;; occur before register allocation, so we have to handle the corner case where
10442 ;; the target is the same as either operands[1] or operands[2]
10443 (define_insn_and_split "sse5_mulv2div2di3_high"
10444   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10445         (mult:V2DI
10446           (sign_extend:V2DI
10447             (vec_select:V2SI
10448               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10449               (parallel [(const_int 0)
10450                          (const_int 2)])))
10451           (sign_extend:V2DI
10452             (vec_select:V2SI
10453               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10454               (parallel [(const_int 0)
10455                          (const_int 2)])))))]
10456   "TARGET_SSE5"
10457   "#"
10458   "&& (reload_completed
10459        || (!reg_mentioned_p (operands[0], operands[1])
10460            && !reg_mentioned_p (operands[0], operands[2])))"
10461   [(set (match_dup 0)
10462         (match_dup 3))
10463    (set (match_dup 0)
10464         (plus:V2DI
10465          (mult:V2DI
10466           (sign_extend:V2DI
10467            (vec_select:V2SI
10468             (match_dup 1)
10469             (parallel [(const_int 0)
10470                        (const_int 2)])))
10471           (sign_extend:V2DI
10472            (vec_select:V2SI
10473             (match_dup 2)
10474             (parallel [(const_int 0)
10475                        (const_int 2)]))))
10476          (match_dup 0)))]
10477 {
10478   operands[3] = CONST0_RTX (V2DImode);
10479 }
10480   [(set_attr "type" "ssemuladd")
10481    (set_attr "mode" "TI")])
10482
10483 ;; SSE5 parallel integer multiply/add instructions for the intrinisics
10484 (define_insn "sse5_pmacsswd"
10485   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10486         (ss_plus:V4SI
10487          (mult:V4SI
10488           (sign_extend:V4SI
10489            (vec_select:V4HI
10490             (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10491             (parallel [(const_int 1)
10492                        (const_int 3)
10493                        (const_int 5)
10494                        (const_int 7)])))
10495           (sign_extend:V4SI
10496            (vec_select:V4HI
10497             (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10498             (parallel [(const_int 1)
10499                        (const_int 3)
10500                        (const_int 5)
10501                        (const_int 7)]))))
10502          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10503   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10504   "@
10505    pmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10506    pmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10507    pmacsswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10508   [(set_attr "type" "ssemuladd")
10509    (set_attr "mode" "TI")])
10510
10511 (define_insn "sse5_pmacswd"
10512   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10513         (plus:V4SI
10514          (mult:V4SI
10515           (sign_extend:V4SI
10516            (vec_select:V4HI
10517             (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10518             (parallel [(const_int 1)
10519                        (const_int 3)
10520                        (const_int 5)
10521                        (const_int 7)])))
10522           (sign_extend:V4SI
10523            (vec_select:V4HI
10524             (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10525             (parallel [(const_int 1)
10526                        (const_int 3)
10527                        (const_int 5)
10528                        (const_int 7)]))))
10529          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10530   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10531   "@
10532    pmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10533    pmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10534    pmacswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10535   [(set_attr "type" "ssemuladd")
10536    (set_attr "mode" "TI")])
10537
10538 (define_insn "sse5_pmadcsswd"
10539   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10540         (ss_plus:V4SI
10541          (plus:V4SI
10542           (mult:V4SI
10543            (sign_extend:V4SI
10544             (vec_select:V4HI
10545              (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10546              (parallel [(const_int 0)
10547                         (const_int 2)
10548                         (const_int 4)
10549                         (const_int 6)])))
10550            (sign_extend:V4SI
10551             (vec_select:V4HI
10552              (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10553              (parallel [(const_int 0)
10554                         (const_int 2)
10555                         (const_int 4)
10556                         (const_int 6)]))))
10557           (mult:V4SI
10558            (sign_extend:V4SI
10559             (vec_select:V4HI
10560              (match_dup 1)
10561              (parallel [(const_int 1)
10562                         (const_int 3)
10563                         (const_int 5)
10564                         (const_int 7)])))
10565            (sign_extend:V4SI
10566             (vec_select:V4HI
10567              (match_dup 2)
10568              (parallel [(const_int 1)
10569                         (const_int 3)
10570                         (const_int 5)
10571                         (const_int 7)])))))
10572          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10573   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10574   "@
10575    pmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10576    pmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10577    pmadcsswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10578   [(set_attr "type" "ssemuladd")
10579    (set_attr "mode" "TI")])
10580
10581 (define_insn "sse5_pmadcswd"
10582   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x")
10583         (plus:V4SI
10584          (plus:V4SI
10585           (mult:V4SI
10586            (sign_extend:V4SI
10587             (vec_select:V4HI
10588              (match_operand:V8HI 1 "nonimmediate_operand" "%x,x,m")
10589              (parallel [(const_int 0)
10590                         (const_int 2)
10591                         (const_int 4)
10592                         (const_int 6)])))
10593            (sign_extend:V4SI
10594             (vec_select:V4HI
10595              (match_operand:V8HI 2 "nonimmediate_operand" "x,m,x")
10596              (parallel [(const_int 0)
10597                         (const_int 2)
10598                         (const_int 4)
10599                         (const_int 6)]))))
10600           (mult:V4SI
10601            (sign_extend:V4SI
10602             (vec_select:V4HI
10603              (match_dup 1)
10604              (parallel [(const_int 1)
10605                         (const_int 3)
10606                         (const_int 5)
10607                         (const_int 7)])))
10608            (sign_extend:V4SI
10609             (vec_select:V4HI
10610              (match_dup 2)
10611              (parallel [(const_int 1)
10612                         (const_int 3)
10613                         (const_int 5)
10614                         (const_int 7)])))))
10615          (match_operand:V4SI 3 "register_operand" "0,0,0")))]
10616   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, false, 1, true)"
10617   "@
10618    pmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10619    pmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}
10620    pmadcswd\t{%3, %1, %2, %0|%0, %2, %1, %3}"
10621   [(set_attr "type" "ssemuladd")
10622    (set_attr "mode" "TI")])
10623
10624 ;; SSE5 parallel XMM conditional moves
10625 (define_insn "sse5_pcmov_<mode>"
10626   [(set (match_operand:SSEMODE 0 "register_operand" "=x,x,x,x")
10627         (if_then_else:SSEMODE
10628           (match_operand:SSEMODE 3 "nonimmediate_operand" "0,0,xm,x")
10629           (match_operand:SSEMODE 1 "vector_move_operand" "x,xm,0,0")
10630           (match_operand:SSEMODE 2 "vector_move_operand" "xm,x,x,xm")))]
10631   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
10632   "@
10633    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10634    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10635    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}
10636    pcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10637   [(set_attr "type" "sse4arg")])
10638
10639 ;; SSE5 horizontal add/subtract instructions
10640 (define_insn "sse5_phaddbw"
10641   [(set (match_operand:V8HI 0 "register_operand" "=x")
10642         (plus:V8HI
10643          (sign_extend:V8HI
10644           (vec_select:V8QI
10645            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10646            (parallel [(const_int 0)
10647                       (const_int 2)
10648                       (const_int 4)
10649                       (const_int 6)
10650                       (const_int 8)
10651                       (const_int 10)
10652                       (const_int 12)
10653                       (const_int 14)])))
10654          (sign_extend:V8HI
10655           (vec_select:V8QI
10656            (match_dup 1)
10657            (parallel [(const_int 1)
10658                       (const_int 3)
10659                       (const_int 5)
10660                       (const_int 7)
10661                       (const_int 9)
10662                       (const_int 11)
10663                       (const_int 13)
10664                       (const_int 15)])))))]
10665   "TARGET_SSE5"
10666   "phaddbw\t{%1, %0|%0, %1}"
10667   [(set_attr "type" "sseiadd1")])
10668
10669 (define_insn "sse5_phaddbd"
10670   [(set (match_operand:V4SI 0 "register_operand" "=x")
10671         (plus:V4SI
10672          (plus:V4SI
10673           (sign_extend:V4SI
10674            (vec_select:V4QI
10675             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10676             (parallel [(const_int 0)
10677                        (const_int 4)
10678                        (const_int 8)
10679                        (const_int 12)])))
10680           (sign_extend:V4SI
10681            (vec_select:V4QI
10682             (match_dup 1)
10683             (parallel [(const_int 1)
10684                        (const_int 5)
10685                        (const_int 9)
10686                        (const_int 13)]))))
10687          (plus:V4SI
10688           (sign_extend:V4SI
10689            (vec_select:V4QI
10690             (match_dup 1)
10691             (parallel [(const_int 2)
10692                        (const_int 6)
10693                        (const_int 10)
10694                        (const_int 14)])))
10695           (sign_extend:V4SI
10696            (vec_select:V4QI
10697             (match_dup 1)
10698             (parallel [(const_int 3)
10699                        (const_int 7)
10700                        (const_int 11)
10701                        (const_int 15)]))))))]
10702   "TARGET_SSE5"
10703   "phaddbd\t{%1, %0|%0, %1}"
10704   [(set_attr "type" "sseiadd1")])
10705
10706 (define_insn "sse5_phaddbq"
10707   [(set (match_operand:V2DI 0 "register_operand" "=x")
10708         (plus:V2DI
10709          (plus:V2DI
10710           (plus:V2DI
10711            (sign_extend:V2DI
10712             (vec_select:V2QI
10713              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10714              (parallel [(const_int 0)
10715                         (const_int 4)])))
10716            (sign_extend:V2DI
10717             (vec_select:V2QI
10718              (match_dup 1)
10719              (parallel [(const_int 1)
10720                         (const_int 5)]))))
10721           (plus:V2DI
10722            (sign_extend:V2DI
10723             (vec_select:V2QI
10724              (match_dup 1)
10725              (parallel [(const_int 2)
10726                         (const_int 6)])))
10727            (sign_extend:V2DI
10728             (vec_select:V2QI
10729              (match_dup 1)
10730              (parallel [(const_int 3)
10731                         (const_int 7)])))))
10732          (plus:V2DI
10733           (plus:V2DI
10734            (sign_extend:V2DI
10735             (vec_select:V2QI
10736              (match_dup 1)
10737              (parallel [(const_int 8)
10738                         (const_int 12)])))
10739            (sign_extend:V2DI
10740             (vec_select:V2QI
10741              (match_dup 1)
10742              (parallel [(const_int 9)
10743                         (const_int 13)]))))
10744           (plus:V2DI
10745            (sign_extend:V2DI
10746             (vec_select:V2QI
10747              (match_dup 1)
10748              (parallel [(const_int 10)
10749                         (const_int 14)])))
10750            (sign_extend:V2DI
10751             (vec_select:V2QI
10752              (match_dup 1)
10753              (parallel [(const_int 11)
10754                         (const_int 15)])))))))]
10755   "TARGET_SSE5"
10756   "phaddbq\t{%1, %0|%0, %1}"
10757   [(set_attr "type" "sseiadd1")])
10758
10759 (define_insn "sse5_phaddwd"
10760   [(set (match_operand:V4SI 0 "register_operand" "=x")
10761         (plus:V4SI
10762          (sign_extend:V4SI
10763           (vec_select:V4HI
10764            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10765            (parallel [(const_int 0)
10766                       (const_int 2)
10767                       (const_int 4)
10768                       (const_int 6)])))
10769          (sign_extend:V4SI
10770           (vec_select:V4HI
10771            (match_dup 1)
10772            (parallel [(const_int 1)
10773                       (const_int 3)
10774                       (const_int 5)
10775                       (const_int 7)])))))]
10776   "TARGET_SSE5"
10777   "phaddwd\t{%1, %0|%0, %1}"
10778   [(set_attr "type" "sseiadd1")])
10779
10780 (define_insn "sse5_phaddwq"
10781   [(set (match_operand:V2DI 0 "register_operand" "=x")
10782         (plus:V2DI
10783          (plus:V2DI
10784           (sign_extend:V2DI
10785            (vec_select:V2HI
10786             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10787             (parallel [(const_int 0)
10788                        (const_int 4)])))
10789           (sign_extend:V2DI
10790            (vec_select:V2HI
10791             (match_dup 1)
10792             (parallel [(const_int 1)
10793                        (const_int 5)]))))
10794          (plus:V2DI
10795           (sign_extend:V2DI
10796            (vec_select:V2HI
10797             (match_dup 1)
10798             (parallel [(const_int 2)
10799                        (const_int 6)])))
10800           (sign_extend:V2DI
10801            (vec_select:V2HI
10802             (match_dup 1)
10803             (parallel [(const_int 3)
10804                        (const_int 7)]))))))]
10805   "TARGET_SSE5"
10806   "phaddwq\t{%1, %0|%0, %1}"
10807   [(set_attr "type" "sseiadd1")])
10808
10809 (define_insn "sse5_phadddq"
10810   [(set (match_operand:V2DI 0 "register_operand" "=x")
10811         (plus:V2DI
10812          (sign_extend:V2DI
10813           (vec_select:V2SI
10814            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10815            (parallel [(const_int 0)
10816                       (const_int 2)])))
10817          (sign_extend:V2DI
10818           (vec_select:V2SI
10819            (match_dup 1)
10820            (parallel [(const_int 1)
10821                       (const_int 3)])))))]
10822   "TARGET_SSE5"
10823   "phadddq\t{%1, %0|%0, %1}"
10824   [(set_attr "type" "sseiadd1")])
10825
10826 (define_insn "sse5_phaddubw"
10827   [(set (match_operand:V8HI 0 "register_operand" "=x")
10828         (plus:V8HI
10829          (zero_extend:V8HI
10830           (vec_select:V8QI
10831            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10832            (parallel [(const_int 0)
10833                       (const_int 2)
10834                       (const_int 4)
10835                       (const_int 6)
10836                       (const_int 8)
10837                       (const_int 10)
10838                       (const_int 12)
10839                       (const_int 14)])))
10840          (zero_extend:V8HI
10841           (vec_select:V8QI
10842            (match_dup 1)
10843            (parallel [(const_int 1)
10844                       (const_int 3)
10845                       (const_int 5)
10846                       (const_int 7)
10847                       (const_int 9)
10848                       (const_int 11)
10849                       (const_int 13)
10850                       (const_int 15)])))))]
10851   "TARGET_SSE5"
10852   "phaddubw\t{%1, %0|%0, %1}"
10853   [(set_attr "type" "sseiadd1")])
10854
10855 (define_insn "sse5_phaddubd"
10856   [(set (match_operand:V4SI 0 "register_operand" "=x")
10857         (plus:V4SI
10858          (plus:V4SI
10859           (zero_extend:V4SI
10860            (vec_select:V4QI
10861             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10862             (parallel [(const_int 0)
10863                        (const_int 4)
10864                        (const_int 8)
10865                        (const_int 12)])))
10866           (zero_extend:V4SI
10867            (vec_select:V4QI
10868             (match_dup 1)
10869             (parallel [(const_int 1)
10870                        (const_int 5)
10871                        (const_int 9)
10872                        (const_int 13)]))))
10873          (plus:V4SI
10874           (zero_extend:V4SI
10875            (vec_select:V4QI
10876             (match_dup 1)
10877             (parallel [(const_int 2)
10878                        (const_int 6)
10879                        (const_int 10)
10880                        (const_int 14)])))
10881           (zero_extend:V4SI
10882            (vec_select:V4QI
10883             (match_dup 1)
10884             (parallel [(const_int 3)
10885                        (const_int 7)
10886                        (const_int 11)
10887                        (const_int 15)]))))))]
10888   "TARGET_SSE5"
10889   "phaddubd\t{%1, %0|%0, %1}"
10890   [(set_attr "type" "sseiadd1")])
10891
10892 (define_insn "sse5_phaddubq"
10893   [(set (match_operand:V2DI 0 "register_operand" "=x")
10894         (plus:V2DI
10895          (plus:V2DI
10896           (plus:V2DI
10897            (zero_extend:V2DI
10898             (vec_select:V2QI
10899              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10900              (parallel [(const_int 0)
10901                         (const_int 4)])))
10902            (sign_extend:V2DI
10903             (vec_select:V2QI
10904              (match_dup 1)
10905              (parallel [(const_int 1)
10906                         (const_int 5)]))))
10907           (plus:V2DI
10908            (zero_extend:V2DI
10909             (vec_select:V2QI
10910              (match_dup 1)
10911              (parallel [(const_int 2)
10912                         (const_int 6)])))
10913            (zero_extend:V2DI
10914             (vec_select:V2QI
10915              (match_dup 1)
10916              (parallel [(const_int 3)
10917                         (const_int 7)])))))
10918          (plus:V2DI
10919           (plus:V2DI
10920            (zero_extend:V2DI
10921             (vec_select:V2QI
10922              (match_dup 1)
10923              (parallel [(const_int 8)
10924                         (const_int 12)])))
10925            (sign_extend:V2DI
10926             (vec_select:V2QI
10927              (match_dup 1)
10928              (parallel [(const_int 9)
10929                         (const_int 13)]))))
10930           (plus:V2DI
10931            (zero_extend:V2DI
10932             (vec_select:V2QI
10933              (match_dup 1)
10934              (parallel [(const_int 10)
10935                         (const_int 14)])))
10936            (zero_extend:V2DI
10937             (vec_select:V2QI
10938              (match_dup 1)
10939              (parallel [(const_int 11)
10940                         (const_int 15)])))))))]
10941   "TARGET_SSE5"
10942   "phaddubq\t{%1, %0|%0, %1}"
10943   [(set_attr "type" "sseiadd1")])
10944
10945 (define_insn "sse5_phadduwd"
10946   [(set (match_operand:V4SI 0 "register_operand" "=x")
10947         (plus:V4SI
10948          (zero_extend:V4SI
10949           (vec_select:V4HI
10950            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10951            (parallel [(const_int 0)
10952                       (const_int 2)
10953                       (const_int 4)
10954                       (const_int 6)])))
10955          (zero_extend:V4SI
10956           (vec_select:V4HI
10957            (match_dup 1)
10958            (parallel [(const_int 1)
10959                       (const_int 3)
10960                       (const_int 5)
10961                       (const_int 7)])))))]
10962   "TARGET_SSE5"
10963   "phadduwd\t{%1, %0|%0, %1}"
10964   [(set_attr "type" "sseiadd1")])
10965
10966 (define_insn "sse5_phadduwq"
10967   [(set (match_operand:V2DI 0 "register_operand" "=x")
10968         (plus:V2DI
10969          (plus:V2DI
10970           (zero_extend:V2DI
10971            (vec_select:V2HI
10972             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10973             (parallel [(const_int 0)
10974                        (const_int 4)])))
10975           (zero_extend:V2DI
10976            (vec_select:V2HI
10977             (match_dup 1)
10978             (parallel [(const_int 1)
10979                        (const_int 5)]))))
10980          (plus:V2DI
10981           (zero_extend:V2DI
10982            (vec_select:V2HI
10983             (match_dup 1)
10984             (parallel [(const_int 2)
10985                        (const_int 6)])))
10986           (zero_extend:V2DI
10987            (vec_select:V2HI
10988             (match_dup 1)
10989             (parallel [(const_int 3)
10990                        (const_int 7)]))))))]
10991   "TARGET_SSE5"
10992   "phadduwq\t{%1, %0|%0, %1}"
10993   [(set_attr "type" "sseiadd1")])
10994
10995 (define_insn "sse5_phaddudq"
10996   [(set (match_operand:V2DI 0 "register_operand" "=x")
10997         (plus:V2DI
10998          (zero_extend:V2DI
10999           (vec_select:V2SI
11000            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11001            (parallel [(const_int 0)
11002                       (const_int 2)])))
11003          (zero_extend:V2DI
11004           (vec_select:V2SI
11005            (match_dup 1)
11006            (parallel [(const_int 1)
11007                       (const_int 3)])))))]
11008   "TARGET_SSE5"
11009   "phaddudq\t{%1, %0|%0, %1}"
11010   [(set_attr "type" "sseiadd1")])
11011
11012 (define_insn "sse5_phsubbw"
11013   [(set (match_operand:V8HI 0 "register_operand" "=x")
11014         (minus:V8HI
11015          (sign_extend:V8HI
11016           (vec_select:V8QI
11017            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11018            (parallel [(const_int 0)
11019                       (const_int 2)
11020                       (const_int 4)
11021                       (const_int 6)
11022                       (const_int 8)
11023                       (const_int 10)
11024                       (const_int 12)
11025                       (const_int 14)])))
11026          (sign_extend:V8HI
11027           (vec_select:V8QI
11028            (match_dup 1)
11029            (parallel [(const_int 1)
11030                       (const_int 3)
11031                       (const_int 5)
11032                       (const_int 7)
11033                       (const_int 9)
11034                       (const_int 11)
11035                       (const_int 13)
11036                       (const_int 15)])))))]
11037   "TARGET_SSE5"
11038   "phsubbw\t{%1, %0|%0, %1}"
11039   [(set_attr "type" "sseiadd1")])
11040
11041 (define_insn "sse5_phsubwd"
11042   [(set (match_operand:V4SI 0 "register_operand" "=x")
11043         (minus:V4SI
11044          (sign_extend:V4SI
11045           (vec_select:V4HI
11046            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11047            (parallel [(const_int 0)
11048                       (const_int 2)
11049                       (const_int 4)
11050                       (const_int 6)])))
11051          (sign_extend:V4SI
11052           (vec_select:V4HI
11053            (match_dup 1)
11054            (parallel [(const_int 1)
11055                       (const_int 3)
11056                       (const_int 5)
11057                       (const_int 7)])))))]
11058   "TARGET_SSE5"
11059   "phsubwd\t{%1, %0|%0, %1}"
11060   [(set_attr "type" "sseiadd1")])
11061
11062 (define_insn "sse5_phsubdq"
11063   [(set (match_operand:V2DI 0 "register_operand" "=x")
11064         (minus:V2DI
11065          (sign_extend:V2DI
11066           (vec_select:V2SI
11067            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11068            (parallel [(const_int 0)
11069                       (const_int 2)])))
11070          (sign_extend:V2DI
11071           (vec_select:V2SI
11072            (match_dup 1)
11073            (parallel [(const_int 1)
11074                       (const_int 3)])))))]
11075   "TARGET_SSE5"
11076   "phsubdq\t{%1, %0|%0, %1}"
11077   [(set_attr "type" "sseiadd1")])
11078
11079 ;; SSE5 permute instructions
11080 (define_insn "sse5_pperm"
11081   [(set (match_operand:V16QI 0 "register_operand" "=x,x,x,x")
11082         (unspec:V16QI
11083           [(match_operand:V16QI 1 "nonimmediate_operand" "0,0,x,xm")
11084            (match_operand:V16QI 2 "nonimmediate_operand" "x,xm,xm,x")
11085            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0")]
11086           UNSPEC_SSE5_PERMUTE))]
11087   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
11088   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11089   [(set_attr "type" "sse4arg")
11090    (set_attr "mode" "TI")])
11091
11092 ;; The following are for the various unpack insns which doesn't need the first
11093 ;; source operand, so we can just use the output operand for the first operand.
11094 ;; This allows either of the other two operands to be a memory operand.  We
11095 ;; can't just use the first operand as an argument to the normal pperm because
11096 ;; then an output only argument, suddenly becomes an input operand.
11097 (define_insn "sse5_pperm_zero_v16qi_v8hi"
11098   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11099         (zero_extend:V8HI
11100          (vec_select:V8QI
11101           (match_operand:V16QI 1 "nonimmediate_operand" "xm,x")
11102           (match_operand 2 "" ""))))    ;; parallel with const_int's
11103    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11104   "TARGET_SSE5
11105    && (register_operand (operands[1], V16QImode)
11106        || register_operand (operands[2], V16QImode))"
11107   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11108   [(set_attr "type" "sseadd")
11109    (set_attr "prefix_data16" "0")
11110    (set_attr "prefix_extra" "2")
11111    (set_attr "mode" "TI")])
11112
11113 (define_insn "sse5_pperm_sign_v16qi_v8hi"
11114   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11115         (sign_extend:V8HI
11116          (vec_select:V8QI
11117           (match_operand:V16QI 1 "nonimmediate_operand" "xm,x")
11118           (match_operand 2 "" ""))))    ;; parallel with const_int's
11119    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11120   "TARGET_SSE5
11121    && (register_operand (operands[1], V16QImode)
11122        || register_operand (operands[2], V16QImode))"
11123   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11124   [(set_attr "type" "sseadd")
11125    (set_attr "prefix_data16" "0")
11126    (set_attr "prefix_extra" "2")
11127    (set_attr "mode" "TI")])
11128
11129 (define_insn "sse5_pperm_zero_v8hi_v4si"
11130   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
11131         (zero_extend:V4SI
11132          (vec_select:V4HI
11133           (match_operand:V8HI 1 "nonimmediate_operand" "xm,x")
11134           (match_operand 2 "" ""))))    ;; parallel with const_int's
11135    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11136   "TARGET_SSE5
11137    && (register_operand (operands[1], V8HImode)
11138        || register_operand (operands[2], V16QImode))"
11139   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11140   [(set_attr "type" "sseadd")
11141    (set_attr "prefix_data16" "0")
11142    (set_attr "prefix_extra" "2")
11143    (set_attr "mode" "TI")])
11144
11145 (define_insn "sse5_pperm_sign_v8hi_v4si"
11146   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
11147         (sign_extend:V4SI
11148          (vec_select:V4HI
11149           (match_operand:V8HI 1 "nonimmediate_operand" "xm,x")
11150           (match_operand 2 "" ""))))    ;; parallel with const_int's
11151    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11152   "TARGET_SSE5
11153    && (register_operand (operands[1], V8HImode)
11154        || register_operand (operands[2], V16QImode))"
11155   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11156   [(set_attr "type" "sseadd")
11157    (set_attr "prefix_data16" "0")
11158    (set_attr "prefix_extra" "2")
11159    (set_attr "mode" "TI")])
11160
11161 (define_insn "sse5_pperm_zero_v4si_v2di"
11162   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
11163         (zero_extend:V2DI
11164          (vec_select:V2SI
11165           (match_operand:V4SI 1 "nonimmediate_operand" "xm,x")
11166           (match_operand 2 "" ""))))    ;; parallel with const_int's
11167    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11168   "TARGET_SSE5
11169    && (register_operand (operands[1], V4SImode)
11170        || register_operand (operands[2], V16QImode))"
11171   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11172   [(set_attr "type" "sseadd")
11173    (set_attr "prefix_data16" "0")
11174    (set_attr "prefix_extra" "2")
11175    (set_attr "mode" "TI")])
11176
11177 (define_insn "sse5_pperm_sign_v4si_v2di"
11178   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
11179         (sign_extend:V2DI
11180          (vec_select:V2SI
11181           (match_operand:V4SI 1 "nonimmediate_operand" "xm,x")
11182           (match_operand 2 "" ""))))    ;; parallel with const_int's
11183    (use (match_operand:V16QI 3 "nonimmediate_operand" "x,xm"))]
11184   "TARGET_SSE5
11185    && (register_operand (operands[1], V4SImode)
11186        || register_operand (operands[2], V16QImode))"
11187   "pperm\t{%3, %1, %0, %0|%0, %0, %1, %3}"
11188   [(set_attr "type" "sseadd")
11189    (set_attr "prefix_data16" "0")
11190    (set_attr "prefix_extra" "2")
11191    (set_attr "mode" "TI")])
11192
11193 ;; SSE5 pack instructions that combine two vectors into a smaller vector
11194 (define_insn "sse5_pperm_pack_v2di_v4si"
11195   [(set (match_operand:V4SI 0 "register_operand" "=x,x,x,x")
11196         (vec_concat:V4SI
11197          (truncate:V2SI
11198           (match_operand:V2DI 1 "nonimmediate_operand" "0,0,x,xm"))
11199          (truncate:V2SI
11200           (match_operand:V2DI 2 "nonimmediate_operand" "x,xm,xm,x"))))
11201    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
11202   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
11203   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11204   [(set_attr "type" "sse4arg")
11205    (set_attr "mode" "TI")])
11206
11207 (define_insn "sse5_pperm_pack_v4si_v8hi"
11208   [(set (match_operand:V8HI 0 "register_operand" "=x,x,x,x")
11209         (vec_concat:V8HI
11210          (truncate:V4HI
11211           (match_operand:V4SI 1 "nonimmediate_operand" "0,0,x,xm"))
11212          (truncate:V4HI
11213           (match_operand:V4SI 2 "nonimmediate_operand" "x,xm,xm,x"))))
11214    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
11215   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
11216   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11217   [(set_attr "type" "sse4arg")
11218    (set_attr "mode" "TI")])
11219
11220 (define_insn "sse5_pperm_pack_v8hi_v16qi"
11221   [(set (match_operand:V16QI 0 "register_operand" "=x,x,x,x")
11222         (vec_concat:V16QI
11223          (truncate:V8QI
11224           (match_operand:V8HI 1 "nonimmediate_operand" "0,0,x,xm"))
11225          (truncate:V8QI
11226           (match_operand:V8HI 2 "nonimmediate_operand" "x,xm,xm,x"))))
11227    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0"))]
11228   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
11229   "pperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11230   [(set_attr "type" "sse4arg")
11231    (set_attr "mode" "TI")])
11232
11233 ;; Floating point permutation (permps, permpd)
11234 (define_insn "sse5_perm<mode>"
11235   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x,x,x")
11236         (unspec:SSEMODEF2P
11237          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "0,0,x,xm")
11238           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "x,xm,xm,x")
11239           (match_operand:V16QI 3 "nonimmediate_operand" "xm,x,0,0")]
11240          UNSPEC_SSE5_PERMUTE))]
11241   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 4, true, 1, false)"
11242   "perm<ssemodesuffixf4>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11243   [(set_attr "type" "sse4arg")
11244    (set_attr "mode" "<MODE>")])
11245
11246 ;; SSE5 packed rotate instructions
11247 (define_expand "rotl<mode>3"
11248   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11249         (rotate:SSEMODE1248
11250          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11251          (match_operand:SI 2 "general_operand")))]
11252   "TARGET_SSE5"
11253 {
11254   /* If we were given a scalar, convert it to parallel */
11255   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11256     {
11257       rtvec vs = rtvec_alloc (<ssescalarnum>);
11258       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11259       rtx reg = gen_reg_rtx (<MODE>mode);
11260       rtx op2 = operands[2];
11261       int i;
11262
11263       if (GET_MODE (op2) != <ssescalarmode>mode)
11264         {
11265           op2 = gen_reg_rtx (<ssescalarmode>mode);
11266           convert_move (op2, operands[2], false);
11267         }
11268
11269       for (i = 0; i < <ssescalarnum>; i++)
11270         RTVEC_ELT (vs, i) = op2;
11271
11272       emit_insn (gen_vec_init<mode> (reg, par));
11273       emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], reg));
11274       DONE;
11275     }
11276 })
11277
11278 (define_expand "rotr<mode>3"
11279   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
11280         (rotatert:SSEMODE1248
11281          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
11282          (match_operand:SI 2 "general_operand")))]
11283   "TARGET_SSE5"
11284 {
11285   /* If we were given a scalar, convert it to parallel */
11286   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
11287     {
11288       rtvec vs = rtvec_alloc (<ssescalarnum>);
11289       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
11290       rtx neg = gen_reg_rtx (<MODE>mode);
11291       rtx reg = gen_reg_rtx (<MODE>mode);
11292       rtx op2 = operands[2];
11293       int i;
11294
11295       if (GET_MODE (op2) != <ssescalarmode>mode)
11296         {
11297           op2 = gen_reg_rtx (<ssescalarmode>mode);
11298           convert_move (op2, operands[2], false);
11299         }
11300
11301       for (i = 0; i < <ssescalarnum>; i++)
11302         RTVEC_ELT (vs, i) = op2;
11303
11304       emit_insn (gen_vec_init<mode> (reg, par));
11305       emit_insn (gen_neg<mode>2 (neg, reg));
11306       emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], neg));
11307       DONE;
11308     }
11309 })
11310
11311 (define_insn "sse5_rotl<mode>3"
11312   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11313         (rotate:SSEMODE1248
11314          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11315          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11316   "TARGET_SSE5"
11317   "prot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11318   [(set_attr "type" "sseishft")
11319    (set_attr "length_immediate" "1")
11320    (set_attr "mode" "TI")])
11321
11322 (define_insn "sse5_rotr<mode>3"
11323   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11324         (rotatert:SSEMODE1248
11325          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
11326          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
11327   "TARGET_SSE5"
11328 {
11329   operands[3] = GEN_INT ((<ssescalarnum> * 8) - INTVAL (operands[2]));
11330   return \"prot<ssevecsize>\t{%3, %1, %0|%0, %1, %3}\";
11331 }
11332   [(set_attr "type" "sseishft")
11333    (set_attr "length_immediate" "1")
11334    (set_attr "mode" "TI")])
11335
11336 (define_expand "vrotr<mode>3"
11337   [(match_operand:SSEMODE1248 0 "register_operand" "")
11338    (match_operand:SSEMODE1248 1 "register_operand" "")
11339    (match_operand:SSEMODE1248 2 "register_operand" "")]
11340   "TARGET_SSE5"
11341 {
11342   rtx reg = gen_reg_rtx (<MODE>mode);
11343   emit_insn (gen_neg<mode>2 (reg, operands[2]));
11344   emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], reg));
11345   DONE;
11346 })
11347
11348 (define_expand "vrotl<mode>3"
11349   [(match_operand:SSEMODE1248 0 "register_operand" "")
11350    (match_operand:SSEMODE1248 1 "register_operand" "")
11351    (match_operand:SSEMODE1248 2 "register_operand" "")]
11352   "TARGET_SSE5"
11353 {
11354   emit_insn (gen_sse5_vrotl<mode>3 (operands[0], operands[1], operands[2]));
11355   DONE;
11356 })
11357
11358 (define_insn "sse5_vrotl<mode>3"
11359   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11360         (if_then_else:SSEMODE1248
11361          (ge:SSEMODE1248
11362           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11363           (const_int 0))
11364          (rotate:SSEMODE1248
11365           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11366           (match_dup 2))
11367          (rotatert:SSEMODE1248
11368           (match_dup 1)
11369           (neg:SSEMODE1248 (match_dup 2)))))]
11370   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11371   "prot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11372   [(set_attr "type" "sseishft")
11373    (set_attr "prefix_data16" "0")
11374    (set_attr "prefix_extra" "2")
11375    (set_attr "mode" "TI")])
11376
11377 ;; SSE5 packed shift instructions.
11378 ;; FIXME: add V2DI back in
11379 (define_expand "vlshr<mode>3"
11380   [(match_operand:SSEMODE124 0 "register_operand" "")
11381    (match_operand:SSEMODE124 1 "register_operand" "")
11382    (match_operand:SSEMODE124 2 "register_operand" "")]
11383   "TARGET_SSE5"
11384 {
11385   rtx neg = gen_reg_rtx (<MODE>mode);
11386   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11387   emit_insn (gen_sse5_lshl<mode>3 (operands[0], operands[1], neg));
11388   DONE;
11389 })
11390
11391 (define_expand "vashr<mode>3"
11392   [(match_operand:SSEMODE124 0 "register_operand" "")
11393    (match_operand:SSEMODE124 1 "register_operand" "")
11394    (match_operand:SSEMODE124 2 "register_operand" "")]
11395   "TARGET_SSE5"
11396 {
11397   rtx neg = gen_reg_rtx (<MODE>mode);
11398   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11399   emit_insn (gen_sse5_ashl<mode>3 (operands[0], operands[1], neg));
11400   DONE;
11401 })
11402
11403 (define_expand "vashl<mode>3"
11404   [(match_operand:SSEMODE124 0 "register_operand" "")
11405    (match_operand:SSEMODE124 1 "register_operand" "")
11406    (match_operand:SSEMODE124 2 "register_operand" "")]
11407   "TARGET_SSE5"
11408 {
11409   emit_insn (gen_sse5_ashl<mode>3 (operands[0], operands[1], operands[2]));
11410   DONE;
11411 })
11412
11413 (define_insn "sse5_ashl<mode>3"
11414   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11415         (if_then_else:SSEMODE1248
11416          (ge:SSEMODE1248
11417           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11418           (const_int 0))
11419          (ashift:SSEMODE1248
11420           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11421           (match_dup 2))
11422          (ashiftrt:SSEMODE1248
11423           (match_dup 1)
11424           (neg:SSEMODE1248 (match_dup 2)))))]
11425   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11426   "psha<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11427   [(set_attr "type" "sseishft")
11428    (set_attr "prefix_data16" "0")
11429    (set_attr "prefix_extra" "2")
11430    (set_attr "mode" "TI")])
11431
11432 (define_insn "sse5_lshl<mode>3"
11433   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11434         (if_then_else:SSEMODE1248
11435          (ge:SSEMODE1248
11436           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm,x")
11437           (const_int 0))
11438          (ashift:SSEMODE1248
11439           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "x,xm")
11440           (match_dup 2))
11441          (lshiftrt:SSEMODE1248
11442           (match_dup 1)
11443           (neg:SSEMODE1248 (match_dup 2)))))]
11444   "TARGET_SSE5 && ix86_sse5_valid_op_p (operands, insn, 3, true, 1, false)"
11445   "pshl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11446   [(set_attr "type" "sseishft")
11447    (set_attr "prefix_data16" "0")
11448    (set_attr "prefix_extra" "2")
11449    (set_attr "mode" "TI")])
11450
11451 ;; SSE2 doesn't have some shift varients, so define versions for SSE5
11452 (define_expand "ashlv16qi3"
11453   [(match_operand:V16QI 0 "register_operand" "")
11454    (match_operand:V16QI 1 "register_operand" "")
11455    (match_operand:SI 2 "nonmemory_operand" "")]
11456   "TARGET_SSE5"
11457 {
11458   rtvec vs = rtvec_alloc (16);
11459   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11460   rtx reg = gen_reg_rtx (V16QImode);
11461   int i;
11462   for (i = 0; i < 16; i++)
11463     RTVEC_ELT (vs, i) = operands[2];
11464
11465   emit_insn (gen_vec_initv16qi (reg, par));
11466   emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], reg));
11467   DONE;
11468 })
11469
11470 (define_expand "lshlv16qi3"
11471   [(match_operand:V16QI 0 "register_operand" "")
11472    (match_operand:V16QI 1 "register_operand" "")
11473    (match_operand:SI 2 "nonmemory_operand" "")]
11474   "TARGET_SSE5"
11475 {
11476   rtvec vs = rtvec_alloc (16);
11477   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11478   rtx reg = gen_reg_rtx (V16QImode);
11479   int i;
11480   for (i = 0; i < 16; i++)
11481     RTVEC_ELT (vs, i) = operands[2];
11482
11483   emit_insn (gen_vec_initv16qi (reg, par));
11484   emit_insn (gen_sse5_lshlv16qi3 (operands[0], operands[1], reg));
11485   DONE;
11486 })
11487
11488 (define_expand "ashrv16qi3"
11489   [(match_operand:V16QI 0 "register_operand" "")
11490    (match_operand:V16QI 1 "register_operand" "")
11491    (match_operand:SI 2 "nonmemory_operand" "")]
11492   "TARGET_SSE5"
11493 {
11494   rtvec vs = rtvec_alloc (16);
11495   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11496   rtx reg = gen_reg_rtx (V16QImode);
11497   int i;
11498   rtx ele = ((CONST_INT_P (operands[2]))
11499              ? GEN_INT (- INTVAL (operands[2]))
11500              : operands[2]);
11501
11502   for (i = 0; i < 16; i++)
11503     RTVEC_ELT (vs, i) = ele;
11504
11505   emit_insn (gen_vec_initv16qi (reg, par));
11506
11507   if (!CONST_INT_P (operands[2]))
11508     {
11509       rtx neg = gen_reg_rtx (V16QImode);
11510       emit_insn (gen_negv16qi2 (neg, reg));
11511       emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], neg));
11512     }
11513   else
11514     emit_insn (gen_sse5_ashlv16qi3 (operands[0], operands[1], reg));
11515
11516   DONE;
11517 })
11518
11519 (define_expand "ashrv2di3"
11520   [(match_operand:V2DI 0 "register_operand" "")
11521    (match_operand:V2DI 1 "register_operand" "")
11522    (match_operand:DI 2 "nonmemory_operand" "")]
11523   "TARGET_SSE5"
11524 {
11525   rtvec vs = rtvec_alloc (2);
11526   rtx par = gen_rtx_PARALLEL (V2DImode, vs);
11527   rtx reg = gen_reg_rtx (V2DImode);
11528   rtx ele;
11529
11530   if (CONST_INT_P (operands[2]))
11531     ele = GEN_INT (- INTVAL (operands[2]));
11532   else if (GET_MODE (operands[2]) != DImode)
11533     {
11534       rtx move = gen_reg_rtx (DImode);
11535       ele = gen_reg_rtx (DImode);
11536       convert_move (move, operands[2], false);
11537       emit_insn (gen_negdi2 (ele, move));
11538     }
11539   else
11540     {
11541       ele = gen_reg_rtx (DImode);
11542       emit_insn (gen_negdi2 (ele, operands[2]));
11543     }
11544
11545   RTVEC_ELT (vs, 0) = ele;
11546   RTVEC_ELT (vs, 1) = ele;
11547   emit_insn (gen_vec_initv2di (reg, par));
11548   emit_insn (gen_sse5_ashlv2di3 (operands[0], operands[1], reg));
11549   DONE;
11550 })
11551
11552 ;; SSE5 FRCZ support
11553 ;; parallel insns
11554 (define_insn "sse5_frcz<mode>2"
11555   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11556         (unspec:SSEMODEF2P
11557          [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")]
11558          UNSPEC_FRCZ))]
11559   "TARGET_SSE5"
11560   "frcz<ssemodesuffixf4>\t{%1, %0|%0, %1}"
11561   [(set_attr "type" "ssecvt1")
11562    (set_attr "mode" "<MODE>")])
11563
11564 ;; scalar insns
11565 (define_insn "sse5_vmfrcz<mode>2"
11566   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11567         (vec_merge:SSEMODEF2P
11568           (unspec:SSEMODEF2P
11569            [(match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
11570            UNSPEC_FRCZ)
11571           (match_operand:SSEMODEF2P 1 "register_operand" "0")
11572           (const_int 1)))]
11573   "TARGET_SSE5"
11574   "frcz<ssemodesuffixf2s>\t{%2, %0|%0, %2}"
11575   [(set_attr "type" "ssecvt1")
11576    (set_attr "mode" "<MODE>")])
11577
11578 (define_insn "sse5_cvtph2ps"
11579   [(set (match_operand:V4SF 0 "register_operand" "=x")
11580         (unspec:V4SF [(match_operand:V4HI 1 "nonimmediate_operand" "xm")]
11581                      UNSPEC_CVTPH2PS))]
11582   "TARGET_SSE5"
11583   "cvtph2ps\t{%1, %0|%0, %1}"
11584   [(set_attr "type" "ssecvt")
11585    (set_attr "mode" "V4SF")])
11586
11587 (define_insn "sse5_cvtps2ph"
11588   [(set (match_operand:V4HI 0 "nonimmediate_operand" "=xm")
11589         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")]
11590                      UNSPEC_CVTPS2PH))]
11591   "TARGET_SSE5"
11592   "cvtps2ph\t{%1, %0|%0, %1}"
11593   [(set_attr "type" "ssecvt")
11594    (set_attr "mode" "V4SF")])
11595
11596 ;; Scalar versions of the com instructions that use vector types that are
11597 ;; called from the intrinsics.  Unlike the the other s{s,d} instructions, the
11598 ;; com instructions fill in 0's in the upper bits instead of leaving them
11599 ;; unmodified, so we use const_vector of 0 instead of match_dup.
11600 (define_expand "sse5_vmmaskcmp<mode>3"
11601   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
11602         (vec_merge:SSEMODEF2P
11603          (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11604           [(match_operand:SSEMODEF2P 2 "register_operand" "")
11605            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "")])
11606          (match_dup 4)
11607          (const_int 1)))]
11608   "TARGET_SSE5"
11609 {
11610   operands[4] = CONST0_RTX (<MODE>mode);
11611 })
11612
11613 (define_insn "*sse5_vmmaskcmp<mode>3"
11614   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11615         (vec_merge:SSEMODEF2P
11616          (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11617           [(match_operand:SSEMODEF2P 2 "register_operand" "x")
11618            (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm")])
11619           (match_operand:SSEMODEF2P 4 "")
11620           (const_int 1)))]
11621   "TARGET_SSE5"
11622   "com%Y1<ssemodesuffixf2s>\t{%3, %2, %0|%0, %2, %3}"
11623   [(set_attr "type" "sse4arg")
11624    (set_attr "prefix_data16" "0")
11625    (set_attr "prefix_rep" "0")
11626    (set_attr "prefix_extra" "2")
11627    (set_attr "length_immediate" "1")
11628    (set_attr "mode" "<ssescalarmode>")])
11629
11630 ;; We don't have a comparison operator that always returns true/false, so
11631 ;; handle comfalse and comtrue specially.
11632 (define_insn "sse5_com_tf<mode>3"
11633   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11634         (unspec:SSEMODEF2P
11635          [(match_operand:SSEMODEF2P 1 "register_operand" "x")
11636           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
11637           (match_operand:SI 3 "const_int_operand" "n")]
11638          UNSPEC_SSE5_TRUEFALSE))]
11639   "TARGET_SSE5"
11640 {
11641   const char *ret = NULL;
11642
11643   switch (INTVAL (operands[3]))
11644     {
11645     case COM_FALSE_S:
11646       ret = \"comfalses<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11647       break;
11648
11649     case COM_FALSE_P:
11650       ret = \"comfalsep<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11651       break;
11652
11653     case COM_TRUE_S:
11654       ret = \"comfalses<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11655       break;
11656
11657     case COM_TRUE_P:
11658       ret = \"comfalsep<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}\";
11659       break;
11660
11661     default:
11662       gcc_unreachable ();
11663     }
11664
11665   return ret;
11666 }
11667   [(set_attr "type" "ssecmp")
11668    (set_attr "prefix_data16" "0")
11669    (set_attr "prefix_rep" "0")
11670    (set_attr "prefix_extra" "2")
11671    (set_attr "length_immediate" "1")
11672    (set_attr "mode" "<MODE>")])
11673
11674 (define_insn "sse5_maskcmp<mode>3"
11675   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11676         (match_operator:SSEMODEF2P 1 "sse5_comparison_float_operator"
11677          [(match_operand:SSEMODEF2P 2 "register_operand" "x")
11678           (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm")]))]
11679   "TARGET_SSE5"
11680   "com%Y1<ssemodesuffixf4>\t{%3, %2, %0|%0, %2, %3}"
11681   [(set_attr "type" "ssecmp")
11682    (set_attr "prefix_data16" "0")
11683    (set_attr "prefix_rep" "0")
11684    (set_attr "prefix_extra" "2")
11685    (set_attr "length_immediate" "1")
11686    (set_attr "mode" "<MODE>")])
11687
11688 (define_insn "sse5_maskcmp<mode>3"
11689   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11690         (match_operator:SSEMODE1248 1 "ix86_comparison_int_operator"
11691          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11692           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11693   "TARGET_SSE5"
11694   "pcom%Y1<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11695   [(set_attr "type" "sse4arg")
11696    (set_attr "prefix_data16" "0")
11697    (set_attr "prefix_rep" "0")
11698    (set_attr "prefix_extra" "2")
11699    (set_attr "length_immediate" "1")
11700    (set_attr "mode" "TI")])
11701
11702 (define_insn "sse5_maskcmp_uns<mode>3"
11703   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11704         (match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11705          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11706           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11707   "TARGET_SSE5"
11708   "pcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11709   [(set_attr "type" "ssecmp")
11710    (set_attr "prefix_data16" "0")
11711    (set_attr "prefix_rep" "0")
11712    (set_attr "prefix_extra" "2")
11713    (set_attr "length_immediate" "1")
11714    (set_attr "mode" "TI")])
11715
11716 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
11717 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
11718 ;; the exact instruction generated for the intrinsic.
11719 (define_insn "sse5_maskcmp_uns2<mode>3"
11720   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11721         (unspec:SSEMODE1248
11722          [(match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11723           [(match_operand:SSEMODE1248 2 "register_operand" "x")
11724            (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")])]
11725          UNSPEC_SSE5_UNSIGNED_CMP))]
11726   "TARGET_SSE5"
11727   "pcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11728   [(set_attr "type" "ssecmp")
11729    (set_attr "prefix_data16" "0")
11730    (set_attr "prefix_extra" "2")
11731    (set_attr "length_immediate" "1")
11732    (set_attr "mode" "TI")])
11733
11734 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
11735 ;; being added here to be complete.
11736 (define_insn "sse5_pcom_tf<mode>3"
11737   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11738         (unspec:SSEMODE1248
11739           [(match_operand:SSEMODE1248 1 "register_operand" "x")
11740            (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")
11741            (match_operand:SI 3 "const_int_operand" "n")]
11742           UNSPEC_SSE5_TRUEFALSE))]
11743   "TARGET_SSE5"
11744 {
11745   return ((INTVAL (operands[3]) != 0)
11746           ? "pcomtrue<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11747           : "pcomfalse<ssevecsize>\t{%2, %1, %0|%0, %1, %2}");
11748 }
11749   [(set_attr "type" "ssecmp")
11750    (set_attr "prefix_data16" "0")
11751    (set_attr "prefix_extra" "2")
11752    (set_attr "length_immediate" "1")
11753    (set_attr "mode" "TI")])
11754
11755 (define_insn "*avx_aesenc"
11756   [(set (match_operand:V2DI 0 "register_operand" "=x")
11757         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11758                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11759                       UNSPEC_AESENC))]
11760   "TARGET_AES && TARGET_AVX"
11761   "vaesenc\t{%2, %1, %0|%0, %1, %2}"
11762   [(set_attr "type" "sselog1")
11763    (set_attr "prefix_extra" "1")
11764    (set_attr "prefix" "vex")
11765    (set_attr "mode" "TI")])
11766
11767 (define_insn "aesenc"
11768   [(set (match_operand:V2DI 0 "register_operand" "=x")
11769         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11770                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11771                       UNSPEC_AESENC))]
11772   "TARGET_AES"
11773   "aesenc\t{%2, %0|%0, %2}"
11774   [(set_attr "type" "sselog1")
11775    (set_attr "prefix_extra" "1")
11776    (set_attr "mode" "TI")])
11777
11778 (define_insn "*avx_aesenclast"
11779   [(set (match_operand:V2DI 0 "register_operand" "=x")
11780         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11781                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11782                       UNSPEC_AESENCLAST))]
11783   "TARGET_AES && TARGET_AVX"
11784   "vaesenclast\t{%2, %1, %0|%0, %1, %2}"
11785   [(set_attr "type" "sselog1")
11786    (set_attr "prefix_extra" "1")
11787    (set_attr "prefix" "vex")
11788    (set_attr "mode" "TI")])
11789
11790 (define_insn "aesenclast"
11791   [(set (match_operand:V2DI 0 "register_operand" "=x")
11792         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11793                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11794                       UNSPEC_AESENCLAST))]
11795   "TARGET_AES"
11796   "aesenclast\t{%2, %0|%0, %2}"
11797   [(set_attr "type" "sselog1")
11798    (set_attr "prefix_extra" "1")
11799    (set_attr "mode" "TI")])
11800
11801 (define_insn "*avx_aesdec"
11802   [(set (match_operand:V2DI 0 "register_operand" "=x")
11803         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11804                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11805                       UNSPEC_AESDEC))]
11806   "TARGET_AES && TARGET_AVX"
11807   "vaesdec\t{%2, %1, %0|%0, %1, %2}"
11808   [(set_attr "type" "sselog1")
11809    (set_attr "prefix_extra" "1")
11810    (set_attr "prefix" "vex")
11811    (set_attr "mode" "TI")])
11812
11813 (define_insn "aesdec"
11814   [(set (match_operand:V2DI 0 "register_operand" "=x")
11815         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11816                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11817                       UNSPEC_AESDEC))]
11818   "TARGET_AES"
11819   "aesdec\t{%2, %0|%0, %2}"
11820   [(set_attr "type" "sselog1")
11821    (set_attr "prefix_extra" "1")
11822    (set_attr "mode" "TI")])
11823
11824 (define_insn "*avx_aesdeclast"
11825   [(set (match_operand:V2DI 0 "register_operand" "=x")
11826         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11827                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11828                       UNSPEC_AESDECLAST))]
11829   "TARGET_AES && TARGET_AVX"
11830   "vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
11831   [(set_attr "type" "sselog1")
11832    (set_attr "prefix_extra" "1")
11833    (set_attr "prefix" "vex")
11834    (set_attr "mode" "TI")])
11835
11836 (define_insn "aesdeclast"
11837   [(set (match_operand:V2DI 0 "register_operand" "=x")
11838         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11839                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11840                       UNSPEC_AESDECLAST))]
11841   "TARGET_AES"
11842   "aesdeclast\t{%2, %0|%0, %2}"
11843   [(set_attr "type" "sselog1")
11844    (set_attr "prefix_extra" "1")
11845    (set_attr "mode" "TI")])
11846
11847 (define_insn "aesimc"
11848   [(set (match_operand:V2DI 0 "register_operand" "=x")
11849         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11850                       UNSPEC_AESIMC))]
11851   "TARGET_AES"
11852   "%vaesimc\t{%1, %0|%0, %1}"
11853   [(set_attr "type" "sselog1")
11854    (set_attr "prefix_extra" "1")
11855    (set_attr "prefix" "maybe_vex")
11856    (set_attr "mode" "TI")])
11857
11858 (define_insn "aeskeygenassist"
11859   [(set (match_operand:V2DI 0 "register_operand" "=x")
11860         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
11861                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
11862                      UNSPEC_AESKEYGENASSIST))]
11863   "TARGET_AES"
11864   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
11865   [(set_attr "type" "sselog1")
11866    (set_attr "prefix_extra" "1")
11867    (set_attr "length_immediate" "1")
11868    (set_attr "prefix" "maybe_vex")
11869    (set_attr "mode" "TI")])
11870
11871 (define_insn "*vpclmulqdq"
11872   [(set (match_operand:V2DI 0 "register_operand" "=x")
11873         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11874                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11875                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11876                      UNSPEC_PCLMUL))]
11877   "TARGET_PCLMUL && TARGET_AVX"
11878   "vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11879   [(set_attr "type" "sselog1")
11880    (set_attr "prefix_extra" "1")
11881    (set_attr "length_immediate" "1")
11882    (set_attr "prefix" "vex")
11883    (set_attr "mode" "TI")])
11884
11885 (define_insn "pclmulqdq"
11886   [(set (match_operand:V2DI 0 "register_operand" "=x")
11887         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11888                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11889                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11890                      UNSPEC_PCLMUL))]
11891   "TARGET_PCLMUL"
11892   "pclmulqdq\t{%3, %2, %0|%0, %2, %3}"
11893   [(set_attr "type" "sselog1")
11894    (set_attr "prefix_extra" "1")
11895    (set_attr "length_immediate" "1")
11896    (set_attr "mode" "TI")])
11897
11898 (define_expand "avx_vzeroall"
11899   [(match_par_dup 0 [(const_int 0)])]
11900   "TARGET_AVX"
11901 {
11902   int nregs = TARGET_64BIT ? 16 : 8;
11903   int regno;
11904
11905   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11906
11907   XVECEXP (operands[0], 0, 0)
11908     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11909                                UNSPECV_VZEROALL);
11910
11911   for (regno = 0; regno < nregs; regno++)
11912     XVECEXP (operands[0], 0, regno + 1)
11913       = gen_rtx_SET (VOIDmode,
11914                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
11915                      CONST0_RTX (V8SImode));
11916 })
11917
11918 (define_insn "*avx_vzeroall"
11919   [(match_parallel 0 "vzeroall_operation"
11920     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)
11921      (set (match_operand 1 "register_operand" "=x")
11922           (match_operand 2 "const0_operand" "X"))])]
11923   "TARGET_AVX"
11924   "vzeroall"
11925   [(set_attr "type" "sse")
11926    (set_attr "modrm" "0")
11927    (set_attr "memory" "none")
11928    (set_attr "prefix" "vex")
11929    (set_attr "mode" "OI")])
11930
11931 ;; vzeroupper clobbers the upper 128bits of AVX registers.
11932 (define_insn "avx_vzeroupper"
11933   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)
11934    (clobber (reg:V8SI XMM0_REG))
11935    (clobber (reg:V8SI XMM1_REG))
11936    (clobber (reg:V8SI XMM2_REG))
11937    (clobber (reg:V8SI XMM3_REG))
11938    (clobber (reg:V8SI XMM4_REG))
11939    (clobber (reg:V8SI XMM5_REG))
11940    (clobber (reg:V8SI XMM6_REG))
11941    (clobber (reg:V8SI XMM7_REG))]
11942   "TARGET_AVX && !TARGET_64BIT"
11943   "vzeroupper"
11944   [(set_attr "type" "sse")
11945    (set_attr "modrm" "0")
11946    (set_attr "memory" "none")
11947    (set_attr "prefix" "vex")
11948    (set_attr "mode" "OI")])
11949
11950 (define_insn "avx_vzeroupper_rex64"
11951   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)
11952    (clobber (reg:V8SI XMM0_REG))
11953    (clobber (reg:V8SI XMM1_REG))
11954    (clobber (reg:V8SI XMM2_REG))
11955    (clobber (reg:V8SI XMM3_REG))
11956    (clobber (reg:V8SI XMM4_REG))
11957    (clobber (reg:V8SI XMM5_REG))
11958    (clobber (reg:V8SI XMM6_REG))
11959    (clobber (reg:V8SI XMM7_REG))
11960    (clobber (reg:V8SI XMM8_REG))
11961    (clobber (reg:V8SI XMM9_REG))
11962    (clobber (reg:V8SI XMM10_REG))
11963    (clobber (reg:V8SI XMM11_REG))
11964    (clobber (reg:V8SI XMM12_REG))
11965    (clobber (reg:V8SI XMM13_REG))
11966    (clobber (reg:V8SI XMM14_REG))
11967    (clobber (reg:V8SI XMM15_REG))]
11968   "TARGET_AVX && TARGET_64BIT"
11969   "vzeroupper"
11970   [(set_attr "type" "sse")
11971    (set_attr "modrm" "0")
11972    (set_attr "memory" "none")
11973    (set_attr "prefix" "vex")
11974    (set_attr "mode" "OI")])
11975
11976 (define_insn "avx_vpermil<mode>"
11977   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11978         (unspec:AVXMODEF2P
11979           [(match_operand:AVXMODEF2P 1 "register_operand" "xm")
11980            (match_operand:SI 2 "const_0_to_<vpermilbits>_operand" "n")]
11981           UNSPEC_VPERMIL))]
11982   "TARGET_AVX"
11983   "vpermilp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
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   "vpermilp<avxmodesuffixf2c>\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_insn "avx_vperm2f128<mode>3"
12004   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
12005         (unspec:AVX256MODE2P
12006           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
12007            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
12008            (match_operand:SI 3 "const_0_to_255_operand" "n")]
12009           UNSPEC_VPERMIL2F128))]
12010   "TARGET_AVX"
12011   "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12012   [(set_attr "type" "sselog")
12013    (set_attr "prefix_extra" "1")
12014    (set_attr "length_immediate" "1")
12015    (set_attr "prefix" "vex")
12016    (set_attr "mode" "V8SF")])
12017
12018 (define_insn "avx_vbroadcasts<avxmodesuffixf2c><avxmodesuffix>"
12019   [(set (match_operand:AVXMODEF4P 0 "register_operand" "=x")
12020         (vec_concat:AVXMODEF4P
12021           (vec_concat:<avxhalfvecmode>
12022             (match_operand:<avxscalarmode> 1 "memory_operand" "m")
12023             (match_dup 1))
12024           (vec_concat:<avxhalfvecmode>
12025             (match_dup 1)
12026             (match_dup 1))))]
12027   "TARGET_AVX"
12028   "vbroadcasts<avxmodesuffixf2c>\t{%1, %0|%0, %1}"
12029   [(set_attr "type" "ssemov")
12030    (set_attr "prefix_extra" "1")
12031    (set_attr "prefix" "vex")
12032    (set_attr "mode" "<avxscalarmode>")])
12033
12034 (define_insn "avx_vbroadcastss256"
12035   [(set (match_operand:V8SF 0 "register_operand" "=x")
12036         (vec_concat:V8SF
12037           (vec_concat:V4SF
12038             (vec_concat:V2SF
12039               (match_operand:SF 1 "memory_operand" "m")
12040               (match_dup 1))
12041             (vec_concat:V2SF
12042               (match_dup 1)
12043               (match_dup 1)))
12044           (vec_concat:V4SF
12045             (vec_concat:V2SF
12046               (match_dup 1)
12047               (match_dup 1))
12048             (vec_concat:V2SF
12049               (match_dup 1)
12050               (match_dup 1)))))]
12051   "TARGET_AVX"
12052   "vbroadcastss\t{%1, %0|%0, %1}"
12053   [(set_attr "type" "ssemov")
12054    (set_attr "prefix_extra" "1")
12055    (set_attr "prefix" "vex")
12056    (set_attr "mode" "SF")])
12057
12058 (define_insn "avx_vbroadcastf128_p<avxmodesuffixf2c>256"
12059   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
12060         (vec_concat:AVX256MODEF2P
12061           (match_operand:<avxhalfvecmode> 1 "memory_operand" "m")
12062           (match_dup 1)))]
12063   "TARGET_AVX"
12064   "vbroadcastf128\t{%1, %0|%0, %1}"
12065   [(set_attr "type" "ssemov")
12066    (set_attr "prefix_extra" "1")
12067    (set_attr "prefix" "vex")
12068    (set_attr "mode" "V4SF")])
12069
12070 (define_expand "avx_vinsertf128<mode>"
12071   [(match_operand:AVX256MODE 0 "register_operand" "")
12072    (match_operand:AVX256MODE 1 "register_operand" "")
12073    (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "")
12074    (match_operand:SI 3 "const_0_to_1_operand" "")]
12075   "TARGET_AVX"
12076 {
12077   switch (INTVAL (operands[3]))
12078     {
12079     case 0:
12080       emit_insn (gen_vec_set_lo_<mode> (operands[0], operands[1],
12081                                         operands[2]));
12082       break;
12083     case 1:
12084       emit_insn (gen_vec_set_hi_<mode> (operands[0], operands[1],
12085                                         operands[2]));
12086       break;
12087     default:
12088       gcc_unreachable ();
12089     }
12090   DONE;
12091 })
12092
12093 (define_insn "vec_set_lo_<mode>"
12094   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12095         (vec_concat:AVX256MODE4P
12096           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12097           (vec_select:<avxhalfvecmode>
12098             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12099             (parallel [(const_int 2) (const_int 3)]))))]
12100   "TARGET_AVX"
12101   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12102   [(set_attr "type" "sselog")
12103    (set_attr "prefix_extra" "1")
12104    (set_attr "length_immediate" "1")
12105    (set_attr "prefix" "vex")
12106    (set_attr "mode" "V8SF")])
12107
12108 (define_insn "vec_set_hi_<mode>"
12109   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
12110         (vec_concat:AVX256MODE4P
12111           (vec_select:<avxhalfvecmode>
12112             (match_operand:AVX256MODE4P 1 "register_operand" "x")
12113             (parallel [(const_int 0) (const_int 1)]))
12114           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12115   "TARGET_AVX"
12116   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12117   [(set_attr "type" "sselog")
12118    (set_attr "prefix_extra" "1")
12119    (set_attr "length_immediate" "1")
12120    (set_attr "prefix" "vex")
12121    (set_attr "mode" "V8SF")])
12122
12123 (define_insn "vec_set_lo_<mode>"
12124   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12125         (vec_concat:AVX256MODE8P
12126           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
12127           (vec_select:<avxhalfvecmode>
12128             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12129             (parallel [(const_int 4) (const_int 5)
12130                        (const_int 6) (const_int 7)]))))]
12131   "TARGET_AVX"
12132   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12133   [(set_attr "type" "sselog")
12134    (set_attr "prefix_extra" "1")
12135    (set_attr "length_immediate" "1")
12136    (set_attr "prefix" "vex")
12137    (set_attr "mode" "V8SF")])
12138
12139 (define_insn "vec_set_hi_<mode>"
12140   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
12141         (vec_concat:AVX256MODE8P
12142           (vec_select:<avxhalfvecmode>
12143             (match_operand:AVX256MODE8P 1 "register_operand" "x")
12144             (parallel [(const_int 0) (const_int 1)
12145                        (const_int 2) (const_int 3)]))
12146           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
12147   "TARGET_AVX"
12148   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12149   [(set_attr "type" "sselog")
12150    (set_attr "prefix_extra" "1")
12151    (set_attr "length_immediate" "1")
12152    (set_attr "prefix" "vex")
12153    (set_attr "mode" "V8SF")])
12154
12155 (define_insn "vec_set_lo_v16hi"
12156   [(set (match_operand:V16HI 0 "register_operand" "=x")
12157         (vec_concat:V16HI
12158           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
12159           (vec_select:V8HI
12160             (match_operand:V16HI 1 "register_operand" "x")
12161             (parallel [(const_int 8) (const_int 9)
12162                        (const_int 10) (const_int 11)
12163                        (const_int 12) (const_int 13)
12164                        (const_int 14) (const_int 15)]))))]
12165   "TARGET_AVX"
12166   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12167   [(set_attr "type" "sselog")
12168    (set_attr "prefix_extra" "1")
12169    (set_attr "length_immediate" "1")
12170    (set_attr "prefix" "vex")
12171    (set_attr "mode" "V8SF")])
12172
12173 (define_insn "vec_set_hi_v16hi"
12174   [(set (match_operand:V16HI 0 "register_operand" "=x")
12175         (vec_concat:V16HI
12176           (vec_select:V8HI
12177             (match_operand:V16HI 1 "register_operand" "x")
12178             (parallel [(const_int 0) (const_int 1)
12179                        (const_int 2) (const_int 3)
12180                        (const_int 4) (const_int 5)
12181                        (const_int 6) (const_int 7)]))
12182           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
12183   "TARGET_AVX"
12184   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12185   [(set_attr "type" "sselog")
12186    (set_attr "prefix_extra" "1")
12187    (set_attr "length_immediate" "1")
12188    (set_attr "prefix" "vex")
12189    (set_attr "mode" "V8SF")])
12190
12191 (define_insn "vec_set_lo_v32qi"
12192   [(set (match_operand:V32QI 0 "register_operand" "=x")
12193         (vec_concat:V32QI
12194           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
12195           (vec_select:V16QI
12196             (match_operand:V32QI 1 "register_operand" "x")
12197             (parallel [(const_int 16) (const_int 17)
12198                        (const_int 18) (const_int 19)
12199                        (const_int 20) (const_int 21)
12200                        (const_int 22) (const_int 23)
12201                        (const_int 24) (const_int 25)
12202                        (const_int 26) (const_int 27)
12203                        (const_int 28) (const_int 29)
12204                        (const_int 30) (const_int 31)]))))]
12205   "TARGET_AVX"
12206   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
12207   [(set_attr "type" "sselog")
12208    (set_attr "prefix_extra" "1")
12209    (set_attr "length_immediate" "1")
12210    (set_attr "prefix" "vex")
12211    (set_attr "mode" "V8SF")])
12212
12213 (define_insn "vec_set_hi_v32qi"
12214   [(set (match_operand:V32QI 0 "register_operand" "=x")
12215         (vec_concat:V32QI
12216           (vec_select:V16QI
12217             (match_operand:V32QI 1 "register_operand" "x")
12218             (parallel [(const_int 0) (const_int 1)
12219                        (const_int 2) (const_int 3)
12220                        (const_int 4) (const_int 5)
12221                        (const_int 6) (const_int 7)
12222                        (const_int 8) (const_int 9)
12223                        (const_int 10) (const_int 11)
12224                        (const_int 12) (const_int 13)
12225                        (const_int 14) (const_int 15)]))
12226           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
12227   "TARGET_AVX"
12228   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
12229   [(set_attr "type" "sselog")
12230    (set_attr "prefix_extra" "1")
12231    (set_attr "length_immediate" "1")
12232    (set_attr "prefix" "vex")
12233    (set_attr "mode" "V8SF")])
12234
12235 (define_insn "avx_maskloadp<avxmodesuffixf2c><avxmodesuffix>"
12236   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
12237         (unspec:AVXMODEF2P
12238           [(match_operand:AVXMODEF2P 1 "memory_operand" "m")
12239            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12240            (match_dup 0)]
12241           UNSPEC_MASKLOAD))]
12242   "TARGET_AVX"
12243   "vmaskmovp<avxmodesuffixf2c>\t{%1, %2, %0|%0, %2, %1}"
12244   [(set_attr "type" "sselog1")
12245    (set_attr "prefix_extra" "1")
12246    (set_attr "prefix" "vex")
12247    (set_attr "mode" "<MODE>")])
12248
12249 (define_insn "avx_maskstorep<avxmodesuffixf2c><avxmodesuffix>"
12250   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
12251         (unspec:AVXMODEF2P
12252           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
12253            (match_operand:AVXMODEF2P 2 "register_operand" "x")
12254            (match_dup 0)]
12255           UNSPEC_MASKSTORE))]
12256   "TARGET_AVX"
12257   "vmaskmovp<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
12258   [(set_attr "type" "sselog1")
12259    (set_attr "prefix_extra" "1")
12260    (set_attr "prefix" "vex")
12261    (set_attr "mode" "<MODE>")])
12262
12263 (define_insn "avx_<avxmodesuffixp><avxmodesuffix>_<avxmodesuffixp>"
12264   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x,x")
12265         (unspec:AVX256MODE2P
12266           [(match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "0,xm")]
12267           UNSPEC_CAST))]
12268   "TARGET_AVX"
12269 {
12270   switch (which_alternative)
12271     {
12272     case 0:
12273       return "";
12274     case 1:
12275       switch (get_attr_mode (insn))
12276         {
12277         case MODE_V8SF:
12278           return "vmovaps\t{%1, %x0|%x0, %1}";
12279         case MODE_V4DF:
12280           return "vmovapd\t{%1, %x0|%x0, %1}";
12281         case MODE_OI:
12282           return "vmovdqa\t{%1, %x0|%x0, %1}";
12283         default:
12284           break;
12285         }
12286     default:
12287       break;
12288     }
12289   gcc_unreachable ();
12290 }
12291   [(set_attr "type" "ssemov")
12292    (set_attr "prefix" "vex")
12293    (set_attr "mode" "<avxvecmode>")
12294    (set (attr "length")
12295     (if_then_else (eq_attr "alternative" "0")
12296        (const_string "0")
12297        (const_string "*")))])
12298
12299 (define_insn "avx_<avxmodesuffixp>_<avxmodesuffixp><avxmodesuffix>"
12300   [(set (match_operand:<avxhalfvecmode> 0 "register_operand" "=x,x")
12301         (unspec:<avxhalfvecmode>
12302           [(match_operand:AVX256MODE2P 1 "nonimmediate_operand" "0,xm")]
12303           UNSPEC_CAST))]
12304   "TARGET_AVX"
12305 {
12306   switch (which_alternative)
12307     {
12308     case 0:
12309       return "";
12310     case 1:
12311       switch (get_attr_mode (insn))
12312         {
12313         case MODE_V8SF:
12314           return "vmovaps\t{%x1, %0|%0, %x1}";
12315         case MODE_V4DF:
12316           return "vmovapd\t{%x1, %0|%0, %x1}";
12317         case MODE_OI:
12318           return "vmovdqa\t{%x1, %0|%0, %x1}";
12319         default:
12320           break;
12321         }
12322     default:
12323       break;
12324     }
12325   gcc_unreachable ();
12326 }
12327   [(set_attr "type" "ssemov")
12328    (set_attr "prefix" "vex")
12329    (set_attr "mode" "<avxvecmode>")
12330    (set (attr "length")
12331     (if_then_else (eq_attr "alternative" "0")
12332        (const_string "0")
12333        (const_string "*")))])
12334
12335 (define_expand "vec_init<mode>"
12336   [(match_operand:AVX256MODE 0 "register_operand" "")
12337    (match_operand 1 "" "")]
12338   "TARGET_AVX"
12339 {
12340   ix86_expand_vector_init (false, operands[0], operands[1]);
12341   DONE;
12342 })
12343
12344 (define_insn "*vec_concat<mode>_avx"
12345   [(set (match_operand:AVX256MODE 0 "register_operand"   "=x,x")
12346         (vec_concat:AVX256MODE
12347           (match_operand:<avxhalfvecmode> 1 "register_operand" "x,x")
12348           (match_operand:<avxhalfvecmode> 2 "vector_move_operand" "xm,C")))]
12349   "TARGET_AVX"
12350 {
12351   switch (which_alternative)
12352     {
12353     case 0:
12354       return "vinsertf128\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
12355     case 1:
12356       switch (get_attr_mode (insn))
12357         {
12358         case MODE_V8SF:
12359           return "vmovaps\t{%1, %x0|%x0, %1}";
12360         case MODE_V4DF:
12361           return "vmovapd\t{%1, %x0|%x0, %1}";
12362         default:
12363           return "vmovdqa\t{%1, %x0|%x0, %1}";
12364         }
12365     default:
12366       gcc_unreachable ();
12367     }
12368 }
12369   [(set_attr "type" "sselog,ssemov")
12370    (set_attr "prefix_extra" "1,*")
12371    (set_attr "length_immediate" "1,*")
12372    (set_attr "prefix" "vex")
12373    (set_attr "mode" "<avxvecmode>")])