gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   7 ;; GCC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 3, or (at your option)
  10 ;; any later version.
  11 ;;
  12 ;; GCC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16 ;;
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21
  22 ;; Instruction suffix for sign and zero extensions.
  23 (define_code_attr extsuffix [(sign_extend "sx") (zero_extend "zx")])
  24
  25 ;; 16 byte integral modes handled by SSE
  26 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  27
  28 ;; All 16-byte vector modes handled by SSE
  29 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI V4SF V2DF])
  30 (define_mode_iterator SSEMODE16 [V16QI V8HI V4SI V2DI V1TI V4SF V2DF])
  31
  32 ;; 32 byte integral vector modes handled by AVX
  33 (define_mode_iterator AVX256MODEI [V32QI V16HI V8SI V4DI])
  34
  35 ;; All 32-byte vector modes handled by AVX
  36 (define_mode_iterator AVX256MODE [V32QI V16HI V8SI V4DI V8SF V4DF])
  37
  38 ;; All QI vector modes handled by AVX
  39 (define_mode_iterator AVXMODEQI [V32QI V16QI])
  40
  41 ;; All DI vector modes handled by AVX
  42 (define_mode_iterator AVXMODEDI [V4DI V2DI])
  43
  44 ;; All vector modes handled by AVX
  45 (define_mode_iterator AVXMODE
  46   [V16QI V8HI V4SI V2DI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  47 (define_mode_iterator AVXMODE16
  48   [V16QI V8HI V4SI V2DI V1TI V4SF V2DF V32QI V16HI V8SI V4DI V8SF V4DF])
  49
  50 ;; Mix-n-match
  51 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  52 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  53 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  54 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  55 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  56 (define_mode_iterator SSEMODE1248 [V16QI V8HI V4SI V2DI])
  57 (define_mode_iterator SSEMODEF4 [SF DF V4SF V2DF])
  58 (define_mode_iterator SSEMODEF2P [V4SF V2DF])
  59
  60 (define_mode_iterator AVX256MODEF2P [V8SF V4DF])
  61 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
  62 (define_mode_iterator AVX256MODE24P [V8SI V8SF V4DI V4DF])
  63 (define_mode_iterator AVX256MODE4P [V4DI V4DF])
  64 (define_mode_iterator AVX256MODE8P [V8SI V8SF])
  65 (define_mode_iterator AVXMODEF2P [V4SF V2DF V8SF V4DF])
  66 (define_mode_iterator AVXMODEF4P [V4SF V4DF])
  67 (define_mode_iterator AVXMODEFDP [V2DF V4DF])
  68 (define_mode_iterator AVXMODEFSP [V4SF V8SF])
  69 (define_mode_iterator AVXMODEDCVTDQ2PS [V4SF V8SF])
  70 (define_mode_iterator AVXMODEDCVTPS2DQ [V4SI V8SI])
  71
  72 (define_mode_iterator FMAMODE [SF DF V4SF V2DF V8SF V4DF])
  73
  74 ;; Int-float size matches
  75 (define_mode_iterator SSEMODE4S [V4SF V4SI])
  76 (define_mode_iterator SSEMODE2D [V2DF V2DI])
  77
  78 ;; Modes handled by integer vcond pattern
  79 (define_mode_iterator SSEMODE124C8 [V16QI V8HI V4SI
  80                                     (V2DI "TARGET_SSE4_2")])
  81
  82 ;; Modes handled by vec_extract_even/odd pattern.
  83 (define_mode_iterator SSEMODE_EO
  84   [(V4SF "TARGET_SSE")
  85    (V2DF "TARGET_SSE2")
  86    (V2DI "TARGET_SSE2") (V4SI "TARGET_SSE2")
  87    (V8HI "TARGET_SSE2") (V16QI "TARGET_SSE2")
  88    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
  89
  90 ;; Modes handled by storent patterns.
  91 (define_mode_iterator STORENT_MODE
  92   [(SF "TARGET_SSE4A") (DF "TARGET_SSE4A")
  93    (SI "TARGET_SSE2") (V2DI "TARGET_SSE2") (V2DF "TARGET_SSE2")
  94    (V4SF "TARGET_SSE")
  95    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
  96
  97 ;; Modes handled by vector float patterns.
  98 (define_mode_iterator VEC_FLOAT_MODE
  99   [(V2DF "TARGET_SSE2") (V4SF "TARGET_SSE")
 100    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
 101
 102 ;; Modes handled by vector extract patterns.
 103 (define_mode_iterator VEC_EXTRACT_MODE
 104   [(V2DI "TARGET_SSE") (V4SI "TARGET_SSE")
 105    (V8HI "TARGET_SSE") (V16QI "TARGET_SSE")
 106    (V2DF "TARGET_SSE") (V4SF "TARGET_SSE")
 107    (V4DF "TARGET_AVX") (V8SF "TARGET_AVX")])
 108
 109 ;; Mapping from float mode to required SSE level
 110 (define_mode_attr sse [(SF "sse") (DF "sse2") (V4SF "sse") (V2DF "sse2")])
 111
 112 ;; Mapping from integer vector mode to mnemonic suffix
 113 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
 114
 115 ;; Mapping of the insn mnemonic suffix
 116 (define_mode_attr ssemodesuffix
 117   [(SF "ss") (DF "sd") (V4SF "ps") (V2DF "pd") (V8SF "ps") (V4DF "pd")
 118    (V8SI "ps") (V4DI "pd")])
 119 (define_mode_attr ssescalarmodesuffix
 120   [(SF "ss") (DF "sd") (V4SF "ss") (V2DF "sd") (V8SF "ss") (V8SI "ss")
 121    (V4DF "sd") (V4SI "d") (V4DI "sd")])
 122
 123 ;; Mapping of the max integer size for xop rotate immediate constraint
 124 (define_mode_attr sserotatemax [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
 125
 126 ;; Mapping of vector modes back to the scalar modes
 127 (define_mode_attr ssescalarmode [(V4SF "SF") (V2DF "DF")
 128                                  (V16QI "QI") (V8HI "HI")
 129                                  (V4SI "SI") (V2DI "DI")])
 130
 131 ;; Mapping of vector modes to a vector mode of double size
 132 (define_mode_attr ssedoublesizemode
 133   [(V2DF "V4DF") (V2DI "V4DI") (V4SF "V8SF") (V4SI "V8SI")
 134    (V8HI "V16HI") (V16QI "V32QI")
 135    (V4DF "V8DF") (V8SF "V16SF")
 136    (V4DI "V8DI") (V8SI "V16SI") (V16HI "V32HI") (V32QI "V64QI")])
 137
 138 ;; Number of scalar elements in each vector type
 139 (define_mode_attr ssescalarnum
 140   [(V4SF "4") (V2DF "2") (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
 141    (V8SF "8") (V4DF "4") (V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")])
 142
 143 ;; Mapping for AVX
 144 (define_mode_attr avxvecmode
 145   [(V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
 146    (V4SF "V4SF") (V8SF "V8SF") (V2DF "V2DF") (V4DF "V4DF")
 147    (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI")])
 148 (define_mode_attr avxvecpsmode
 149   [(V16QI "V4SF") (V8HI "V4SF") (V4SI "V4SF") (V2DI "V4SF")
 150    (V32QI "V8SF") (V16HI "V8SF") (V8SI "V8SF") (V4DI "V8SF")])
 151 (define_mode_attr avxhalfvecmode
 152   [(V32QI "V16QI") (V16HI "V8HI") (V8SI "V4SI") (V4DI "V2DI")
 153    (V8SF "V4SF") (V4DF "V2DF")
 154    (V16QI  "V8QI") (V8HI  "V4HI") (V4SI "V2SI") (V4SF "V2SF")])
 155 (define_mode_attr avxscalarmode
 156   [(V16QI "QI") (V8HI  "HI") (V4SI "SI") (V2DI "DI") (V4SF "SF") (V2DF "DF")
 157    (V32QI "QI") (V16HI "HI") (V8SI "SI") (V4DI "DI") (V8SF "SF") (V4DF "DF")])
 158 (define_mode_attr avxcvtvecmode
 159   [(V4SF "V4SI") (V8SF "V8SI") (V4SI "V4SF") (V8SI "V8SF")])
 160 (define_mode_attr avxpermvecmode
 161   [(V2DF "V2DI") (V4SF "V4SI") (V4DF "V4DI") (V8SF "V8SI")])
 162 (define_mode_attr avxmodesuffixp
 163  [(V2DF "pd") (V4SI "si") (V4SF "ps") (V8SF "ps") (V8SI "si")
 164   (V4DF "pd")])
 165 (define_mode_attr avxmodesuffix
 166   [(V16QI "") (V32QI "256") (V4SI "") (V4SF "") (V2DF "")
 167    (V8SI "256") (V8SF "256") (V4DF "256")])
 168
 169 ;; Mapping of immediate bits for blend instructions
 170 (define_mode_attr blendbits
 171   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 172
 173 ;; Mapping of immediate bits for pinsr instructions
 174 (define_mode_attr pinsrbits [(V16QI "32768") (V8HI "128") (V4SI "8")])
 175
 176 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 177
 178 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 179 ;;
 180 ;; Move patterns
 181 ;;
 182 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 183
 184 (define_expand "mov<mode>"
 185   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 186         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 187   "TARGET_AVX"
 188 {
 189   ix86_expand_vector_move (<MODE>mode, operands);
 190   DONE;
 191 })
 192
 193 (define_insn "*avx_mov<mode>_internal"
 194   [(set (match_operand:AVXMODE16 0 "nonimmediate_operand" "=x,x ,m")
 195         (match_operand:AVXMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 196   "TARGET_AVX
 197    && (register_operand (operands[0], <MODE>mode)
 198        || register_operand (operands[1], <MODE>mode))"
 199 {
 200   switch (which_alternative)
 201     {
 202     case 0:
 203       return standard_sse_constant_opcode (insn, operands[1]);
 204     case 1:
 205     case 2:
 206       switch (get_attr_mode (insn))
 207         {
 208         case MODE_V8SF:
 209         case MODE_V4SF:
 210           return "vmovaps\t{%1, %0|%0, %1}";
 211         case MODE_V4DF:
 212         case MODE_V2DF:
 213           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 214             return "vmovaps\t{%1, %0|%0, %1}";
 215           else
 216             return "vmovapd\t{%1, %0|%0, %1}";
 217         default:
 218           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 219             return "vmovaps\t{%1, %0|%0, %1}";
 220           else
 221             return "vmovdqa\t{%1, %0|%0, %1}";
 222         }
 223     default:
 224       gcc_unreachable ();
 225     }
 226 }
 227   [(set_attr "type" "sselog1,ssemov,ssemov")
 228    (set_attr "prefix" "vex")
 229    (set_attr "mode" "<avxvecmode>")])
 230
 231 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 232 ;; This is essential for maintaining stable calling conventions.
 233
 234 (define_expand "mov<mode>"
 235   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 236         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 237   "TARGET_SSE"
 238 {
 239   ix86_expand_vector_move (<MODE>mode, operands);
 240   DONE;
 241 })
 242
 243 (define_insn "*mov<mode>_internal"
 244   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "=x,x ,m")
 245         (match_operand:SSEMODE16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 246   "TARGET_SSE
 247    && (register_operand (operands[0], <MODE>mode)
 248        || register_operand (operands[1], <MODE>mode))"
 249 {
 250   switch (which_alternative)
 251     {
 252     case 0:
 253       return standard_sse_constant_opcode (insn, operands[1]);
 254     case 1:
 255     case 2:
 256       switch (get_attr_mode (insn))
 257         {
 258         case MODE_V4SF:
 259           return "movaps\t{%1, %0|%0, %1}";
 260         case MODE_V2DF:
 261           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 262             return "movaps\t{%1, %0|%0, %1}";
 263           else
 264             return "movapd\t{%1, %0|%0, %1}";
 265         default:
 266           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
 267             return "movaps\t{%1, %0|%0, %1}";
 268           else
 269             return "movdqa\t{%1, %0|%0, %1}";
 270         }
 271     default:
 272       gcc_unreachable ();
 273     }
 274 }
 275   [(set_attr "type" "sselog1,ssemov,ssemov")
 276    (set (attr "mode")
 277         (cond [(ior (ior (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
 278                          (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 279                     (and (eq_attr "alternative" "2")
 280                          (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 281                              (const_int 0))))
 282                  (const_string "V4SF")
 283                (eq (const_string "<MODE>mode") (const_string "V4SFmode"))
 284                  (const_string "V4SF")
 285                (eq (const_string "<MODE>mode") (const_string "V2DFmode"))
 286                  (const_string "V2DF")
 287               ]
 288           (const_string "TI")))])
 289
 290 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 291 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 292 ;; from memory, we'd prefer to load the memory directly into the %xmm
 293 ;; register.  To facilitate this happy circumstance, this pattern won't
 294 ;; split until after register allocation.  If the 64-bit value didn't
 295 ;; come from memory, this is the best we can do.  This is much better
 296 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 297 ;; from there.
 298
 299 (define_insn_and_split "movdi_to_sse"
 300   [(parallel
 301     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 302           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 303      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 304   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 305   "#"
 306   "&& reload_completed"
 307   [(const_int 0)]
 308 {
 309  if (register_operand (operands[1], DImode))
 310    {
 311       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 312          Assemble the 64-bit DImode value in an xmm register.  */
 313       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 314                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 315       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 316                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 317       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
 318                                              operands[2]));
 319     }
 320  else if (memory_operand (operands[1], DImode))
 321    emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]),
 322                                   operands[1], const0_rtx));
 323  else
 324    gcc_unreachable ();
 325 })
 326
 327 (define_split
 328   [(set (match_operand:V4SF 0 "register_operand" "")
 329         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 330   "TARGET_SSE && reload_completed"
 331   [(set (match_dup 0)
 332         (vec_merge:V4SF
 333           (vec_duplicate:V4SF (match_dup 1))
 334           (match_dup 2)
 335           (const_int 1)))]
 336 {
 337   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 338   operands[2] = CONST0_RTX (V4SFmode);
 339 })
 340
 341 (define_split
 342   [(set (match_operand:V2DF 0 "register_operand" "")
 343         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 344   "TARGET_SSE2 && reload_completed"
 345   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 346 {
 347   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 348   operands[2] = CONST0_RTX (DFmode);
 349 })
 350
 351 (define_expand "push<mode>1"
 352   [(match_operand:AVX256MODE 0 "register_operand" "")]
 353   "TARGET_AVX"
 354 {
 355   ix86_expand_push (<MODE>mode, operands[0]);
 356   DONE;
 357 })
 358
 359 (define_expand "push<mode>1"
 360   [(match_operand:SSEMODE16 0 "register_operand" "")]
 361   "TARGET_SSE"
 362 {
 363   ix86_expand_push (<MODE>mode, operands[0]);
 364   DONE;
 365 })
 366
 367 (define_expand "movmisalign<mode>"
 368   [(set (match_operand:AVX256MODE 0 "nonimmediate_operand" "")
 369         (match_operand:AVX256MODE 1 "nonimmediate_operand" ""))]
 370   "TARGET_AVX"
 371 {
 372   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 373   DONE;
 374 })
 375
 376 (define_expand "movmisalign<mode>"
 377   [(set (match_operand:SSEMODE16 0 "nonimmediate_operand" "")
 378         (match_operand:SSEMODE16 1 "nonimmediate_operand" ""))]
 379   "TARGET_SSE"
 380 {
 381   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 382   DONE;
 383 })
 384
 385 (define_expand "avx_movu<ssemodesuffix><avxmodesuffix>"
 386   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "")
 387         (unspec:AVXMODEF2P
 388           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "")]
 389           UNSPEC_MOVU))]
 390   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 391 {
 392   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 393     operands[1] = force_reg (<MODE>mode, operands[1]);
 394 })
 395
 396 (define_insn "*avx_movu<ssemodesuffix><avxmodesuffix>"
 397   [(set (match_operand:AVXMODEF2P 0 "nonimmediate_operand" "=x,m")
 398         (unspec:AVXMODEF2P
 399           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm,x")]
 400           UNSPEC_MOVU))]
 401   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 402    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 403   "vmovu<ssemodesuffix>\t{%1, %0|%0, %1}"
 404   [(set_attr "type" "ssemov")
 405    (set_attr "movu" "1")
 406    (set_attr "prefix" "vex")
 407    (set_attr "mode" "<MODE>")])
 408
 409 (define_insn "sse2_movq128"
 410   [(set (match_operand:V2DI 0 "register_operand" "=x")
 411         (vec_concat:V2DI
 412           (vec_select:DI
 413             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 414             (parallel [(const_int 0)]))
 415           (const_int 0)))]
 416   "TARGET_SSE2"
 417   "%vmovq\t{%1, %0|%0, %1}"
 418   [(set_attr "type" "ssemov")
 419    (set_attr "prefix" "maybe_vex")
 420    (set_attr "mode" "TI")])
 421
 422 (define_expand "<sse>_movu<ssemodesuffix>"
 423   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "")
 424         (unspec:SSEMODEF2P
 425           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")]
 426           UNSPEC_MOVU))]
 427   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 428 {
 429   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 430     operands[1] = force_reg (<MODE>mode, operands[1]);
 431 })
 432
 433 (define_insn "*<sse>_movu<ssemodesuffix>"
 434   [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m")
 435         (unspec:SSEMODEF2P
 436           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm,x")]
 437           UNSPEC_MOVU))]
 438   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 439    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 440   "movu<ssemodesuffix>\t{%1, %0|%0, %1}"
 441   [(set_attr "type" "ssemov")
 442    (set_attr "movu" "1")
 443    (set_attr "mode" "<MODE>")])
 444
 445 (define_expand "avx_movdqu<avxmodesuffix>"
 446   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "")
 447         (unspec:AVXMODEQI
 448           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "")]
 449           UNSPEC_MOVU))]
 450   "TARGET_AVX"
 451 {
 452   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 453     operands[1] = force_reg (<MODE>mode, operands[1]);
 454 })
 455
 456 (define_insn "*avx_movdqu<avxmodesuffix>"
 457   [(set (match_operand:AVXMODEQI 0 "nonimmediate_operand" "=x,m")
 458         (unspec:AVXMODEQI
 459           [(match_operand:AVXMODEQI 1 "nonimmediate_operand" "xm,x")]
 460           UNSPEC_MOVU))]
 461   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 462   "vmovdqu\t{%1, %0|%0, %1}"
 463   [(set_attr "type" "ssemov")
 464    (set_attr "movu" "1")
 465    (set_attr "prefix" "vex")
 466    (set_attr "mode" "<avxvecmode>")])
 467
 468 (define_expand "sse2_movdqu"
 469   [(set (match_operand:V16QI 0 "nonimmediate_operand" "")
 470         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "")]
 471                       UNSPEC_MOVU))]
 472   "TARGET_SSE2"
 473 {
 474   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 475     operands[1] = force_reg (V16QImode, operands[1]);
 476 })
 477
 478 (define_insn "*sse2_movdqu"
 479   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 480         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 481                       UNSPEC_MOVU))]
 482   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 483   "movdqu\t{%1, %0|%0, %1}"
 484   [(set_attr "type" "ssemov")
 485    (set_attr "movu" "1")
 486    (set_attr "prefix_data16" "1")
 487    (set_attr "mode" "TI")])
 488
 489 (define_insn "avx_movnt<mode>"
 490   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
 491         (unspec:AVXMODEF2P
 492           [(match_operand:AVXMODEF2P 1 "register_operand" "x")]
 493           UNSPEC_MOVNT))]
 494   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 495   "vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
 496   [(set_attr "type" "ssemov")
 497    (set_attr "prefix" "vex")
 498    (set_attr "mode" "<MODE>")])
 499
 500 (define_insn "<sse>_movnt<mode>"
 501   [(set (match_operand:SSEMODEF2P 0 "memory_operand" "=m")
 502         (unspec:SSEMODEF2P
 503           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
 504           UNSPEC_MOVNT))]
 505   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 506   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
 507   [(set_attr "type" "ssemov")
 508    (set_attr "mode" "<MODE>")])
 509
 510 (define_insn "avx_movnt<mode>"
 511   [(set (match_operand:AVXMODEDI 0 "memory_operand" "=m")
 512         (unspec:AVXMODEDI
 513           [(match_operand:AVXMODEDI 1 "register_operand" "x")]
 514           UNSPEC_MOVNT))]
 515   "TARGET_AVX"
 516   "vmovntdq\t{%1, %0|%0, %1}"
 517   [(set_attr "type" "ssecvt")
 518    (set_attr "prefix" "vex")
 519    (set_attr "mode" "<avxvecmode>")])
 520
 521 (define_insn "sse2_movntv2di"
 522   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 523         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 524                      UNSPEC_MOVNT))]
 525   "TARGET_SSE2"
 526   "movntdq\t{%1, %0|%0, %1}"
 527   [(set_attr "type" "ssemov")
 528    (set_attr "prefix_data16" "1")
 529    (set_attr "mode" "TI")])
 530
 531 (define_insn "sse2_movntsi"
 532   [(set (match_operand:SI 0 "memory_operand" "=m")
 533         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 534                    UNSPEC_MOVNT))]
 535   "TARGET_SSE2"
 536   "movnti\t{%1, %0|%0, %1}"
 537   [(set_attr "type" "ssemov")
 538    (set_attr "prefix_data16" "0")
 539    (set_attr "mode" "V2DF")])
 540
 541 (define_insn "avx_lddqu<avxmodesuffix>"
 542   [(set (match_operand:AVXMODEQI 0 "register_operand" "=x")
 543         (unspec:AVXMODEQI
 544           [(match_operand:AVXMODEQI 1 "memory_operand" "m")]
 545           UNSPEC_LDDQU))]
 546   "TARGET_AVX"
 547   "vlddqu\t{%1, %0|%0, %1}"
 548   [(set_attr "type" "ssecvt")
 549    (set_attr "movu" "1")
 550    (set_attr "prefix" "vex")
 551    (set_attr "mode" "<avxvecmode>")])
 552
 553 (define_insn "sse3_lddqu"
 554   [(set (match_operand:V16QI 0 "register_operand" "=x")
 555         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 556                       UNSPEC_LDDQU))]
 557   "TARGET_SSE3"
 558   "lddqu\t{%1, %0|%0, %1}"
 559   [(set_attr "type" "ssemov")
 560    (set_attr "movu" "1")
 561    (set_attr "prefix_data16" "0")
 562    (set_attr "prefix_rep" "1")
 563    (set_attr "mode" "TI")])
 564
 565 ; Expand patterns for non-temporal stores.  At the moment, only those
 566 ; that directly map to insns are defined; it would be possible to
 567 ; define patterns for other modes that would expand to several insns.
 568
 569 (define_expand "storent<mode>"
 570   [(set (match_operand:STORENT_MODE 0 "memory_operand" "")
 571         (unspec:STORENT_MODE
 572           [(match_operand:STORENT_MODE 1 "register_operand" "")]
 573           UNSPEC_MOVNT))])
 574
 575 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 576 ;;
 577 ;; Parallel floating point arithmetic
 578 ;;
 579 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 580
 581 (define_expand "<code><mode>2"
 582   [(set (match_operand:VEC_FLOAT_MODE 0 "register_operand" "")
 583         (absneg:VEC_FLOAT_MODE
 584           (match_operand:VEC_FLOAT_MODE 1 "register_operand" "")))]
 585   ""
 586   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 587
 588 (define_expand "<plusminus_insn><mode>3"
 589   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 590         (plusminus:AVX256MODEF2P
 591           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 592           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 593   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 594   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 595
 596 (define_insn "*avx_<plusminus_insn><mode>3"
 597   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 598         (plusminus:AVXMODEF2P
 599           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "<comm>x")
 600           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 601   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 602    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 603   "v<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 604   [(set_attr "type" "sseadd")
 605    (set_attr "prefix" "vex")
 606    (set_attr "mode" "<avxvecmode>")])
 607
 608 (define_expand "<plusminus_insn><mode>3"
 609   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 610         (plusminus:SSEMODEF2P
 611           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 612           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 613   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 614   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 615
 616 (define_insn "*<plusminus_insn><mode>3"
 617   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 618         (plusminus:SSEMODEF2P
 619           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "<comm>0")
 620           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 621   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 622    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 623   "<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}"
 624   [(set_attr "type" "sseadd")
 625    (set_attr "mode" "<MODE>")])
 626
 627 (define_insn "*avx_vm<plusminus_insn><mode>3"
 628   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 629         (vec_merge:SSEMODEF2P
 630           (plusminus:SSEMODEF2P
 631             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 632             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 633           (match_dup 1)
 634           (const_int 1)))]
 635   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 636   "v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 637   [(set_attr "type" "sseadd")
 638    (set_attr "prefix" "vex")
 639    (set_attr "mode" "<ssescalarmode>")])
 640
 641 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 642   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 643         (vec_merge:SSEMODEF2P
 644           (plusminus:SSEMODEF2P
 645             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 646             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 647           (match_dup 1)
 648           (const_int 1)))]
 649   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 650   "<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 651   [(set_attr "type" "sseadd")
 652    (set_attr "mode" "<ssescalarmode>")])
 653
 654 (define_expand "mul<mode>3"
 655   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
 656         (mult:AVX256MODEF2P
 657           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
 658           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
 659   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
 660   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 661
 662 (define_insn "*avx_mul<mode>3"
 663   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 664         (mult:AVXMODEF2P
 665           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
 666           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 667   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
 668    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 669   "vmul<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 670   [(set_attr "type" "ssemul")
 671    (set_attr "prefix" "vex")
 672    (set_attr "mode" "<avxvecmode>")])
 673
 674 (define_expand "mul<mode>3"
 675   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
 676         (mult:SSEMODEF2P
 677           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
 678           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
 679   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 680   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 681
 682 (define_insn "*mul<mode>3"
 683   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 684         (mult:SSEMODEF2P
 685           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
 686           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 687   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
 688    && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 689   "mul<ssemodesuffix>\t{%2, %0|%0, %2}"
 690   [(set_attr "type" "ssemul")
 691    (set_attr "mode" "<MODE>")])
 692
 693 (define_insn "*avx_vmmul<mode>3"
 694   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 695         (vec_merge:SSEMODEF2P
 696           (mult:SSEMODEF2P
 697             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 698             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 699           (match_dup 1)
 700           (const_int 1)))]
 701   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 702   "vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 703   [(set_attr "type" "ssemul")
 704    (set_attr "prefix" "vex")
 705    (set_attr "mode" "<ssescalarmode>")])
 706
 707 (define_insn "<sse>_vmmul<mode>3"
 708   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 709         (vec_merge:SSEMODEF2P
 710           (mult:SSEMODEF2P
 711             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 712             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 713           (match_dup 1)
 714           (const_int 1)))]
 715   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 716   "mul<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 717   [(set_attr "type" "ssemul")
 718    (set_attr "mode" "<ssescalarmode>")])
 719
 720 (define_expand "divv8sf3"
 721   [(set (match_operand:V8SF 0 "register_operand" "")
 722         (div:V8SF (match_operand:V8SF 1 "register_operand" "")
 723                   (match_operand:V8SF 2 "nonimmediate_operand" "")))]
 724   "TARGET_AVX"
 725 {
 726   ix86_fixup_binary_operands_no_copy (DIV, V8SFmode, operands);
 727
 728   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 729       && flag_finite_math_only && !flag_trapping_math
 730       && flag_unsafe_math_optimizations)
 731     {
 732       ix86_emit_swdivsf (operands[0], operands[1],
 733                          operands[2], V8SFmode);
 734       DONE;
 735     }
 736 })
 737
 738 (define_expand "divv4df3"
 739   [(set (match_operand:V4DF 0 "register_operand" "")
 740         (div:V4DF (match_operand:V4DF 1 "register_operand" "")
 741                   (match_operand:V4DF 2 "nonimmediate_operand" "")))]
 742   "TARGET_AVX"
 743   "ix86_fixup_binary_operands_no_copy (DIV, V4DFmode, operands);")
 744
 745 (define_insn "avx_div<mode>3"
 746   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
 747         (div:AVXMODEF2P
 748           (match_operand:AVXMODEF2P 1 "register_operand" "x")
 749           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
 750   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 751   "vdiv<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 752   [(set_attr "type" "ssediv")
 753    (set_attr "prefix" "vex")
 754    (set_attr "mode" "<MODE>")])
 755
 756 (define_expand "divv4sf3"
 757   [(set (match_operand:V4SF 0 "register_operand" "")
 758         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 759                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 760   "TARGET_SSE"
 761 {
 762   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 763       && flag_finite_math_only && !flag_trapping_math
 764       && flag_unsafe_math_optimizations)
 765     {
 766       ix86_emit_swdivsf (operands[0], operands[1],
 767                          operands[2], V4SFmode);
 768       DONE;
 769     }
 770 })
 771
 772 (define_expand "divv2df3"
 773   [(set (match_operand:V2DF 0 "register_operand" "")
 774         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
 775                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
 776   "TARGET_SSE2")
 777
 778 (define_insn "*avx_div<mode>3"
 779   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 780         (div:SSEMODEF2P
 781           (match_operand:SSEMODEF2P 1 "register_operand" "x")
 782           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 783   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 784   "vdiv<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 785   [(set_attr "type" "ssediv")
 786    (set_attr "prefix" "vex")
 787    (set_attr "mode" "<MODE>")])
 788
 789 (define_insn "<sse>_div<mode>3"
 790   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 791         (div:SSEMODEF2P
 792           (match_operand:SSEMODEF2P 1 "register_operand" "0")
 793           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
 794   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 795   "div<ssemodesuffix>\t{%2, %0|%0, %2}"
 796   [(set_attr "type" "ssediv")
 797    (set_attr "mode" "<MODE>")])
 798
 799 (define_insn "*avx_vmdiv<mode>3"
 800   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 801         (vec_merge:SSEMODEF2P
 802           (div:SSEMODEF2P
 803             (match_operand:SSEMODEF2P 1 "register_operand" "x")
 804             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 805           (match_dup 1)
 806           (const_int 1)))]
 807   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
 808   "vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 809   [(set_attr "type" "ssediv")
 810    (set_attr "prefix" "vex")
 811    (set_attr "mode" "<ssescalarmode>")])
 812
 813 (define_insn "<sse>_vmdiv<mode>3"
 814   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 815         (vec_merge:SSEMODEF2P
 816           (div:SSEMODEF2P
 817             (match_operand:SSEMODEF2P 1 "register_operand" "0")
 818             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
 819           (match_dup 1)
 820           (const_int 1)))]
 821   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 822   "div<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
 823   [(set_attr "type" "ssediv")
 824    (set_attr "mode" "<ssescalarmode>")])
 825
 826 (define_insn "avx_rcpv8sf2"
 827   [(set (match_operand:V8SF 0 "register_operand" "=x")
 828         (unspec:V8SF
 829           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 830   "TARGET_AVX"
 831   "vrcpps\t{%1, %0|%0, %1}"
 832   [(set_attr "type" "sse")
 833    (set_attr "prefix" "vex")
 834    (set_attr "mode" "V8SF")])
 835
 836 (define_insn "sse_rcpv4sf2"
 837   [(set (match_operand:V4SF 0 "register_operand" "=x")
 838         (unspec:V4SF
 839           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 840   "TARGET_SSE"
 841   "%vrcpps\t{%1, %0|%0, %1}"
 842   [(set_attr "type" "sse")
 843    (set_attr "atom_sse_attr" "rcp")
 844    (set_attr "prefix" "maybe_vex")
 845    (set_attr "mode" "V4SF")])
 846
 847 (define_insn "*avx_vmrcpv4sf2"
 848   [(set (match_operand:V4SF 0 "register_operand" "=x")
 849         (vec_merge:V4SF
 850           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 851                        UNSPEC_RCP)
 852           (match_operand:V4SF 2 "register_operand" "x")
 853           (const_int 1)))]
 854   "TARGET_AVX"
 855   "vrcpss\t{%1, %2, %0|%0, %2, %1}"
 856   [(set_attr "type" "sse")
 857    (set_attr "prefix" "vex")
 858    (set_attr "mode" "SF")])
 859
 860 (define_insn "sse_vmrcpv4sf2"
 861   [(set (match_operand:V4SF 0 "register_operand" "=x")
 862         (vec_merge:V4SF
 863           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 864                        UNSPEC_RCP)
 865           (match_operand:V4SF 2 "register_operand" "0")
 866           (const_int 1)))]
 867   "TARGET_SSE"
 868   "rcpss\t{%1, %0|%0, %1}"
 869   [(set_attr "type" "sse")
 870    (set_attr "atom_sse_attr" "rcp")
 871    (set_attr "mode" "SF")])
 872
 873 (define_expand "sqrtv8sf2"
 874   [(set (match_operand:V8SF 0 "register_operand" "")
 875         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "")))]
 876   "TARGET_AVX"
 877 {
 878   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p ()
 879       && flag_finite_math_only && !flag_trapping_math
 880       && flag_unsafe_math_optimizations)
 881     {
 882       ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 0);
 883       DONE;
 884     }
 885 })
 886
 887 (define_insn "avx_sqrtv8sf2"
 888   [(set (match_operand:V8SF 0 "register_operand" "=x")
 889         (sqrt:V8SF (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
 890   "TARGET_AVX"
 891   "vsqrtps\t{%1, %0|%0, %1}"
 892   [(set_attr "type" "sse")
 893    (set_attr "prefix" "vex")
 894    (set_attr "mode" "V8SF")])
 895
 896 (define_expand "sqrtv4sf2"
 897   [(set (match_operand:V4SF 0 "register_operand" "")
 898         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 899   "TARGET_SSE"
 900 {
 901   if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p ()
 902       && flag_finite_math_only && !flag_trapping_math
 903       && flag_unsafe_math_optimizations)
 904     {
 905       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 906       DONE;
 907     }
 908 })
 909
 910 (define_insn "sse_sqrtv4sf2"
 911   [(set (match_operand:V4SF 0 "register_operand" "=x")
 912         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 913   "TARGET_SSE"
 914   "%vsqrtps\t{%1, %0|%0, %1}"
 915   [(set_attr "type" "sse")
 916    (set_attr "atom_sse_attr" "sqrt")
 917    (set_attr "prefix" "maybe_vex")
 918    (set_attr "mode" "V4SF")])
 919
 920 (define_insn "sqrtv4df2"
 921   [(set (match_operand:V4DF 0 "register_operand" "=x")
 922         (sqrt:V4DF (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
 923   "TARGET_AVX"
 924   "vsqrtpd\t{%1, %0|%0, %1}"
 925   [(set_attr "type" "sse")
 926    (set_attr "prefix" "vex")
 927    (set_attr "mode" "V4DF")])
 928
 929 (define_insn "sqrtv2df2"
 930   [(set (match_operand:V2DF 0 "register_operand" "=x")
 931         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
 932   "TARGET_SSE2"
 933   "%vsqrtpd\t{%1, %0|%0, %1}"
 934   [(set_attr "type" "sse")
 935    (set_attr "prefix" "maybe_vex")
 936    (set_attr "mode" "V2DF")])
 937
 938 (define_insn "*avx_vmsqrt<mode>2"
 939   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 940         (vec_merge:SSEMODEF2P
 941           (sqrt:SSEMODEF2P
 942             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 943           (match_operand:SSEMODEF2P 2 "register_operand" "x")
 944           (const_int 1)))]
 945   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
 946   "vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}"
 947   [(set_attr "type" "sse")
 948    (set_attr "prefix" "vex")
 949    (set_attr "mode" "<ssescalarmode>")])
 950
 951 (define_insn "<sse>_vmsqrt<mode>2"
 952   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
 953         (vec_merge:SSEMODEF2P
 954           (sqrt:SSEMODEF2P
 955             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm"))
 956           (match_operand:SSEMODEF2P 2 "register_operand" "0")
 957           (const_int 1)))]
 958   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
 959   "sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
 960   [(set_attr "type" "sse")
 961    (set_attr "atom_sse_attr" "sqrt")
 962    (set_attr "mode" "<ssescalarmode>")])
 963
 964 (define_expand "rsqrtv8sf2"
 965   [(set (match_operand:V8SF 0 "register_operand" "")
 966         (unspec:V8SF
 967           [(match_operand:V8SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 968   "TARGET_AVX && TARGET_SSE_MATH"
 969 {
 970   ix86_emit_swsqrtsf (operands[0], operands[1], V8SFmode, 1);
 971   DONE;
 972 })
 973
 974 (define_insn "avx_rsqrtv8sf2"
 975   [(set (match_operand:V8SF 0 "register_operand" "=x")
 976         (unspec:V8SF
 977           [(match_operand:V8SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 978   "TARGET_AVX"
 979   "vrsqrtps\t{%1, %0|%0, %1}"
 980   [(set_attr "type" "sse")
 981    (set_attr "prefix" "vex")
 982    (set_attr "mode" "V8SF")])
 983
 984 (define_expand "rsqrtv4sf2"
 985   [(set (match_operand:V4SF 0 "register_operand" "")
 986         (unspec:V4SF
 987           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 988   "TARGET_SSE_MATH"
 989 {
 990   ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 991   DONE;
 992 })
 993
 994 (define_insn "sse_rsqrtv4sf2"
 995   [(set (match_operand:V4SF 0 "register_operand" "=x")
 996         (unspec:V4SF
 997           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 998   "TARGET_SSE"
 999   "%vrsqrtps\t{%1, %0|%0, %1}"
1000   [(set_attr "type" "sse")
1001    (set_attr "prefix" "maybe_vex")
1002    (set_attr "mode" "V4SF")])
1003
1004 (define_insn "*avx_vmrsqrtv4sf2"
1005   [(set (match_operand:V4SF 0 "register_operand" "=x")
1006         (vec_merge:V4SF
1007           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
1008                        UNSPEC_RSQRT)
1009           (match_operand:V4SF 2 "register_operand" "x")
1010           (const_int 1)))]
1011   "TARGET_AVX"
1012   "vrsqrtss\t{%1, %2, %0|%0, %2, %1}"
1013   [(set_attr "type" "sse")
1014    (set_attr "prefix" "vex")
1015    (set_attr "mode" "SF")])
1016
1017 (define_insn "sse_vmrsqrtv4sf2"
1018   [(set (match_operand:V4SF 0 "register_operand" "=x")
1019         (vec_merge:V4SF
1020           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
1021                        UNSPEC_RSQRT)
1022           (match_operand:V4SF 2 "register_operand" "0")
1023           (const_int 1)))]
1024   "TARGET_SSE"
1025   "rsqrtss\t{%1, %0|%0, %1}"
1026   [(set_attr "type" "sse")
1027    (set_attr "mode" "SF")])
1028
1029 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
1030 ;; isn't really correct, as those rtl operators aren't defined when
1031 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
1032
1033 (define_expand "<code><mode>3"
1034   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1035         (smaxmin:AVX256MODEF2P
1036           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1037           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1038   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1039 {
1040   if (!flag_finite_math_only)
1041     operands[1] = force_reg (<MODE>mode, operands[1]);
1042   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1043 })
1044
1045 (define_expand "<code><mode>3"
1046   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1047         (smaxmin:SSEMODEF2P
1048           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1049           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1050   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1051 {
1052   if (!flag_finite_math_only)
1053     operands[1] = force_reg (<MODE>mode, operands[1]);
1054   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1055 })
1056
1057 (define_insn "*avx_<code><mode>3_finite"
1058   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1059         (smaxmin:AVXMODEF2P
1060           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1061           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1062   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1063    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1064   "v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1065   [(set_attr "type" "sseadd")
1066    (set_attr "prefix" "vex")
1067    (set_attr "mode" "<MODE>")])
1068
1069 (define_insn "*<code><mode>3_finite"
1070   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1071         (smaxmin:SSEMODEF2P
1072           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1073           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1074   "SSE_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
1075    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1076   "<maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}"
1077   [(set_attr "type" "sseadd")
1078    (set_attr "mode" "<MODE>")])
1079
1080 (define_insn "*avx_<code><mode>3"
1081   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1082         (smaxmin:AVXMODEF2P
1083           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1084           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1085   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1086   "v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1087   [(set_attr "type" "sseadd")
1088    (set_attr "prefix" "vex")
1089    (set_attr "mode" "<avxvecmode>")])
1090
1091 (define_insn "*<code><mode>3"
1092   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1093         (smaxmin:SSEMODEF2P
1094           (match_operand:SSEMODEF2P 1 "register_operand" "0")
1095           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1096   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1097   "<maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}"
1098   [(set_attr "type" "sseadd")
1099    (set_attr "mode" "<MODE>")])
1100
1101 (define_insn "*avx_vm<code><mode>3"
1102   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1103         (vec_merge:SSEMODEF2P
1104           (smaxmin:SSEMODEF2P
1105             (match_operand:SSEMODEF2P 1 "register_operand" "x")
1106             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1107          (match_dup 1)
1108          (const_int 1)))]
1109   "AVX128_VEC_FLOAT_MODE_P (<MODE>mode)"
1110   "v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1111   [(set_attr "type" "sse")
1112    (set_attr "prefix" "vex")
1113    (set_attr "mode" "<ssescalarmode>")])
1114
1115 (define_insn "<sse>_vm<code><mode>3"
1116   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1117         (vec_merge:SSEMODEF2P
1118           (smaxmin:SSEMODEF2P
1119             (match_operand:SSEMODEF2P 1 "register_operand" "0")
1120             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm"))
1121          (match_dup 1)
1122          (const_int 1)))]
1123   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1124   "<maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %2}"
1125   [(set_attr "type" "sseadd")
1126    (set_attr "mode" "<ssescalarmode>")])
1127
1128 ;; These versions of the min/max patterns implement exactly the operations
1129 ;;   min = (op1 < op2 ? op1 : op2)
1130 ;;   max = (!(op1 < op2) ? op1 : op2)
1131 ;; Their operands are not commutative, and thus they may be used in the
1132 ;; presence of -0.0 and NaN.
1133
1134 (define_insn "*avx_ieee_smin<mode>3"
1135   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1136         (unspec:AVXMODEF2P
1137           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1138            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1139          UNSPEC_IEEE_MIN))]
1140   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1141   "vmin<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1142   [(set_attr "type" "sseadd")
1143    (set_attr "prefix" "vex")
1144    (set_attr "mode" "<avxvecmode>")])
1145
1146 (define_insn "*avx_ieee_smax<mode>3"
1147   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1148         (unspec:AVXMODEF2P
1149           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1150            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]
1151          UNSPEC_IEEE_MAX))]
1152   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1153   "vmax<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1154   [(set_attr "type" "sseadd")
1155    (set_attr "prefix" "vex")
1156    (set_attr "mode" "<avxvecmode>")])
1157
1158 (define_insn "*ieee_smin<mode>3"
1159   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1160         (unspec:SSEMODEF2P
1161           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1162            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1163          UNSPEC_IEEE_MIN))]
1164   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1165   "min<ssemodesuffix>\t{%2, %0|%0, %2}"
1166   [(set_attr "type" "sseadd")
1167    (set_attr "mode" "<MODE>")])
1168
1169 (define_insn "*ieee_smax<mode>3"
1170   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1171         (unspec:SSEMODEF2P
1172           [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1173            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")]
1174          UNSPEC_IEEE_MAX))]
1175   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1176   "max<ssemodesuffix>\t{%2, %0|%0, %2}"
1177   [(set_attr "type" "sseadd")
1178    (set_attr "mode" "<MODE>")])
1179
1180 (define_insn "avx_addsubv8sf3"
1181   [(set (match_operand:V8SF 0 "register_operand" "=x")
1182         (vec_merge:V8SF
1183           (plus:V8SF
1184             (match_operand:V8SF 1 "register_operand" "x")
1185             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1186           (minus:V8SF (match_dup 1) (match_dup 2))
1187           (const_int 170)))]
1188   "TARGET_AVX"
1189   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1190   [(set_attr "type" "sseadd")
1191    (set_attr "prefix" "vex")
1192    (set_attr "mode" "V8SF")])
1193
1194 (define_insn "avx_addsubv4df3"
1195   [(set (match_operand:V4DF 0 "register_operand" "=x")
1196         (vec_merge:V4DF
1197           (plus:V4DF
1198             (match_operand:V4DF 1 "register_operand" "x")
1199             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1200           (minus:V4DF (match_dup 1) (match_dup 2))
1201           (const_int 10)))]
1202   "TARGET_AVX"
1203   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1204   [(set_attr "type" "sseadd")
1205    (set_attr "prefix" "vex")
1206    (set_attr "mode" "V4DF")])
1207
1208 (define_insn "*avx_addsubv4sf3"
1209   [(set (match_operand:V4SF 0 "register_operand" "=x")
1210         (vec_merge:V4SF
1211           (plus:V4SF
1212             (match_operand:V4SF 1 "register_operand" "x")
1213             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1214           (minus:V4SF (match_dup 1) (match_dup 2))
1215           (const_int 10)))]
1216   "TARGET_AVX"
1217   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1218   [(set_attr "type" "sseadd")
1219    (set_attr "prefix" "vex")
1220    (set_attr "mode" "V4SF")])
1221
1222 (define_insn "sse3_addsubv4sf3"
1223   [(set (match_operand:V4SF 0 "register_operand" "=x")
1224         (vec_merge:V4SF
1225           (plus:V4SF
1226             (match_operand:V4SF 1 "register_operand" "0")
1227             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1228           (minus:V4SF (match_dup 1) (match_dup 2))
1229           (const_int 10)))]
1230   "TARGET_SSE3"
1231   "addsubps\t{%2, %0|%0, %2}"
1232   [(set_attr "type" "sseadd")
1233    (set_attr "prefix_rep" "1")
1234    (set_attr "mode" "V4SF")])
1235
1236 (define_insn "*avx_addsubv2df3"
1237   [(set (match_operand:V2DF 0 "register_operand" "=x")
1238         (vec_merge:V2DF
1239           (plus:V2DF
1240             (match_operand:V2DF 1 "register_operand" "x")
1241             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1242           (minus:V2DF (match_dup 1) (match_dup 2))
1243           (const_int 2)))]
1244   "TARGET_AVX"
1245   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1246   [(set_attr "type" "sseadd")
1247    (set_attr "prefix" "vex")
1248    (set_attr "mode" "V2DF")])
1249
1250 (define_insn "sse3_addsubv2df3"
1251   [(set (match_operand:V2DF 0 "register_operand" "=x")
1252         (vec_merge:V2DF
1253           (plus:V2DF
1254             (match_operand:V2DF 1 "register_operand" "0")
1255             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1256           (minus:V2DF (match_dup 1) (match_dup 2))
1257           (const_int 2)))]
1258   "TARGET_SSE3"
1259   "addsubpd\t{%2, %0|%0, %2}"
1260   [(set_attr "type" "sseadd")
1261    (set_attr "atom_unit" "complex")
1262    (set_attr "mode" "V2DF")])
1263
1264 (define_insn "avx_h<plusminus_insn>v4df3"
1265   [(set (match_operand:V4DF 0 "register_operand" "=x")
1266         (vec_concat:V4DF
1267           (vec_concat:V2DF
1268             (plusminus:DF
1269               (vec_select:DF
1270                 (match_operand:V4DF 1 "register_operand" "x")
1271                 (parallel [(const_int 0)]))
1272               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1273             (plusminus:DF
1274               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1275               (vec_select:DF (match_dup 1) (parallel [(const_int 3)]))))
1276           (vec_concat:V2DF
1277             (plusminus:DF
1278               (vec_select:DF
1279                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1280                 (parallel [(const_int 0)]))
1281               (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))
1282             (plusminus:DF
1283               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1284               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1285   "TARGET_AVX"
1286   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1287   [(set_attr "type" "sseadd")
1288    (set_attr "prefix" "vex")
1289    (set_attr "mode" "V4DF")])
1290
1291 (define_insn "avx_h<plusminus_insn>v8sf3"
1292   [(set (match_operand:V8SF 0 "register_operand" "=x")
1293         (vec_concat:V8SF
1294           (vec_concat:V4SF
1295             (vec_concat:V2SF
1296               (plusminus:SF
1297                 (vec_select:SF
1298                   (match_operand:V8SF 1 "register_operand" "x")
1299                   (parallel [(const_int 0)]))
1300                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1301               (plusminus:SF
1302                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1303                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1304             (vec_concat:V2SF
1305               (plusminus:SF
1306                 (vec_select:SF
1307                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1308                   (parallel [(const_int 0)]))
1309                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1310               (plusminus:SF
1311                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1312                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1313           (vec_concat:V4SF
1314             (vec_concat:V2SF
1315               (plusminus:SF
1316                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1317                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1318               (plusminus:SF
1319                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1320                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1321             (vec_concat:V2SF
1322               (plusminus:SF
1323                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1324                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1325               (plusminus:SF
1326                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1327                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1328   "TARGET_AVX"
1329   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1330   [(set_attr "type" "sseadd")
1331    (set_attr "prefix" "vex")
1332    (set_attr "mode" "V8SF")])
1333
1334 (define_insn "*avx_h<plusminus_insn>v4sf3"
1335   [(set (match_operand:V4SF 0 "register_operand" "=x")
1336         (vec_concat:V4SF
1337           (vec_concat:V2SF
1338             (plusminus:SF
1339               (vec_select:SF
1340                 (match_operand:V4SF 1 "register_operand" "x")
1341                 (parallel [(const_int 0)]))
1342               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1343             (plusminus:SF
1344               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1345               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1346           (vec_concat:V2SF
1347             (plusminus:SF
1348               (vec_select:SF
1349                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1350                 (parallel [(const_int 0)]))
1351               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1352             (plusminus:SF
1353               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1354               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1355   "TARGET_AVX"
1356   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1357   [(set_attr "type" "sseadd")
1358    (set_attr "prefix" "vex")
1359    (set_attr "mode" "V4SF")])
1360
1361 (define_insn "sse3_h<plusminus_insn>v4sf3"
1362   [(set (match_operand:V4SF 0 "register_operand" "=x")
1363         (vec_concat:V4SF
1364           (vec_concat:V2SF
1365             (plusminus:SF
1366               (vec_select:SF
1367                 (match_operand:V4SF 1 "register_operand" "0")
1368                 (parallel [(const_int 0)]))
1369               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1370             (plusminus:SF
1371               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1372               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1373           (vec_concat:V2SF
1374             (plusminus:SF
1375               (vec_select:SF
1376                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
1377                 (parallel [(const_int 0)]))
1378               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1379             (plusminus:SF
1380               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1381               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1382   "TARGET_SSE3"
1383   "h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}"
1384   [(set_attr "type" "sseadd")
1385    (set_attr "atom_unit" "complex")
1386    (set_attr "prefix_rep" "1")
1387    (set_attr "mode" "V4SF")])
1388
1389 (define_insn "*avx_h<plusminus_insn>v2df3"
1390   [(set (match_operand:V2DF 0 "register_operand" "=x")
1391         (vec_concat:V2DF
1392           (plusminus:DF
1393             (vec_select:DF
1394               (match_operand:V2DF 1 "register_operand" "x")
1395               (parallel [(const_int 0)]))
1396             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1397           (plusminus:DF
1398             (vec_select:DF
1399               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1400               (parallel [(const_int 0)]))
1401             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1402   "TARGET_AVX"
1403   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1404   [(set_attr "type" "sseadd")
1405    (set_attr "prefix" "vex")
1406    (set_attr "mode" "V2DF")])
1407
1408 (define_insn "sse3_h<plusminus_insn>v2df3"
1409   [(set (match_operand:V2DF 0 "register_operand" "=x")
1410         (vec_concat:V2DF
1411           (plusminus:DF
1412             (vec_select:DF
1413               (match_operand:V2DF 1 "register_operand" "0")
1414               (parallel [(const_int 0)]))
1415             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1416           (plusminus:DF
1417             (vec_select:DF
1418               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1419               (parallel [(const_int 0)]))
1420             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1421   "TARGET_SSE3"
1422   "h<plusminus_mnemonic>pd\t{%2, %0|%0, %2}"
1423   [(set_attr "type" "sseadd")
1424    (set_attr "mode" "V2DF")])
1425
1426 (define_expand "reduc_splus_v8sf"
1427   [(match_operand:V8SF 0 "register_operand" "")
1428    (match_operand:V8SF 1 "register_operand" "")]
1429   "TARGET_AVX"
1430 {
1431   rtx tmp = gen_reg_rtx (V8SFmode);
1432   rtx tmp2 = gen_reg_rtx (V8SFmode);
1433   emit_insn (gen_avx_haddv8sf3 (tmp, operands[1], operands[1]));
1434   emit_insn (gen_avx_haddv8sf3 (tmp2, tmp, tmp));
1435   emit_insn (gen_avx_vperm2f128v8sf3 (tmp, tmp2, tmp2, GEN_INT (1)));
1436   emit_insn (gen_addv8sf3 (operands[0], tmp, tmp2));
1437   DONE;
1438 })
1439
1440 (define_expand "reduc_splus_v4sf"
1441   [(match_operand:V4SF 0 "register_operand" "")
1442    (match_operand:V4SF 1 "register_operand" "")]
1443   "TARGET_SSE"
1444 {
1445   if (TARGET_SSE3)
1446     {
1447       rtx tmp = gen_reg_rtx (V4SFmode);
1448       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1449       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1450     }
1451   else
1452     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
1453   DONE;
1454 })
1455
1456 (define_expand "reduc_splus_v4df"
1457   [(match_operand:V4DF 0 "register_operand" "")
1458    (match_operand:V4DF 1 "register_operand" "")]
1459   "TARGET_AVX"
1460 {
1461   rtx tmp = gen_reg_rtx (V4DFmode);
1462   rtx tmp2 = gen_reg_rtx (V4DFmode);
1463   emit_insn (gen_avx_haddv4df3 (tmp, operands[1], operands[1]));
1464   emit_insn (gen_avx_vperm2f128v4df3 (tmp2, tmp, tmp, GEN_INT (1)));
1465   emit_insn (gen_addv4df3 (operands[0], tmp, tmp2));
1466   DONE;
1467 })
1468
1469 (define_expand "reduc_splus_v2df"
1470   [(match_operand:V2DF 0 "register_operand" "")
1471    (match_operand:V2DF 1 "register_operand" "")]
1472   "TARGET_SSE3"
1473 {
1474   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1475   DONE;
1476 })
1477
1478 (define_expand "reduc_smax_v4sf"
1479   [(match_operand:V4SF 0 "register_operand" "")
1480    (match_operand:V4SF 1 "register_operand" "")]
1481   "TARGET_SSE"
1482 {
1483   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
1484   DONE;
1485 })
1486
1487 (define_expand "reduc_smin_v4sf"
1488   [(match_operand:V4SF 0 "register_operand" "")
1489    (match_operand:V4SF 1 "register_operand" "")]
1490   "TARGET_SSE"
1491 {
1492   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
1493   DONE;
1494 })
1495
1496 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1497 ;;
1498 ;; Parallel floating point comparisons
1499 ;;
1500 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1501
1502 (define_insn "avx_cmp<ssemodesuffix><mode>3"
1503   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1504         (unspec:AVXMODEF2P
1505           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1506            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
1507            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1508           UNSPEC_PCMP))]
1509   "TARGET_AVX"
1510   "vcmp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1511   [(set_attr "type" "ssecmp")
1512    (set_attr "length_immediate" "1")
1513    (set_attr "prefix" "vex")
1514    (set_attr "mode" "<MODE>")])
1515
1516 (define_insn "avx_cmp<ssescalarmodesuffix><mode>3"
1517   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1518         (vec_merge:SSEMODEF2P
1519           (unspec:SSEMODEF2P
1520             [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1521              (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
1522              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1523             UNSPEC_PCMP)
1524          (match_dup 1)
1525          (const_int 1)))]
1526   "TARGET_AVX"
1527   "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1528   [(set_attr "type" "ssecmp")
1529    (set_attr "length_immediate" "1")
1530    (set_attr "prefix" "vex")
1531    (set_attr "mode" "<ssescalarmode>")])
1532
1533 ;; We don't promote 128bit vector compare intrinsics. But vectorizer
1534 ;; may generate 256bit vector compare instructions.
1535 (define_insn "*avx_maskcmp<mode>3"
1536   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1537         (match_operator:AVXMODEF2P 3 "avx_comparison_float_operator"
1538                 [(match_operand:AVXMODEF2P 1 "register_operand" "x")
1539                  (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")]))]
1540   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1541   "vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1542   [(set_attr "type" "ssecmp")
1543    (set_attr "prefix" "vex")
1544    (set_attr "length_immediate" "1")
1545    (set_attr "mode" "<avxvecmode>")])
1546
1547 (define_insn "<sse>_maskcmp<mode>3"
1548   [(set (match_operand:SSEMODEF4 0 "register_operand" "=x")
1549         (match_operator:SSEMODEF4 3 "sse_comparison_operator"
1550                 [(match_operand:SSEMODEF4 1 "register_operand" "0")
1551                  (match_operand:SSEMODEF4 2 "nonimmediate_operand" "xm")]))]
1552   "!TARGET_XOP
1553   && (SSE_FLOAT_MODE_P (<MODE>mode) || SSE_VEC_FLOAT_MODE_P (<MODE>mode))"
1554   "cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}"
1555   [(set_attr "type" "ssecmp")
1556    (set_attr "length_immediate" "1")
1557    (set_attr "mode" "<MODE>")])
1558
1559 (define_insn "*avx_vmmaskcmp<mode>3"
1560   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1561         (vec_merge:SSEMODEF2P
1562          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1563                 [(match_operand:SSEMODEF2P 1 "register_operand" "x")
1564                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1565          (match_dup 1)
1566          (const_int 1)))]
1567   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1568   "vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1569   [(set_attr "type" "ssecmp")
1570    (set_attr "prefix" "vex")
1571    (set_attr "mode" "<ssescalarmode>")])
1572
1573 (define_insn "<sse>_vmmaskcmp<mode>3"
1574   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1575         (vec_merge:SSEMODEF2P
1576          (match_operator:SSEMODEF2P 3 "sse_comparison_operator"
1577                 [(match_operand:SSEMODEF2P 1 "register_operand" "0")
1578                  (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")])
1579          (match_dup 1)
1580          (const_int 1)))]
1581   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1582   "cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %2}"
1583   [(set_attr "type" "ssecmp")
1584    (set_attr "length_immediate" "1")
1585    (set_attr "mode" "<ssescalarmode>")])
1586
1587 (define_insn "<sse>_comi"
1588   [(set (reg:CCFP FLAGS_REG)
1589         (compare:CCFP
1590           (vec_select:MODEF
1591             (match_operand:<ssevecmode> 0 "register_operand" "x")
1592             (parallel [(const_int 0)]))
1593           (vec_select:MODEF
1594             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1595             (parallel [(const_int 0)]))))]
1596   "SSE_FLOAT_MODE_P (<MODE>mode)"
1597   "%vcomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1598   [(set_attr "type" "ssecomi")
1599    (set_attr "prefix" "maybe_vex")
1600    (set_attr "prefix_rep" "0")
1601    (set (attr "prefix_data16")
1602         (if_then_else (eq_attr "mode" "DF")
1603                       (const_string "1")
1604                       (const_string "0")))
1605    (set_attr "mode" "<MODE>")])
1606
1607 (define_insn "<sse>_ucomi"
1608   [(set (reg:CCFPU FLAGS_REG)
1609         (compare:CCFPU
1610           (vec_select:MODEF
1611             (match_operand:<ssevecmode> 0 "register_operand" "x")
1612             (parallel [(const_int 0)]))
1613           (vec_select:MODEF
1614             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1615             (parallel [(const_int 0)]))))]
1616   "SSE_FLOAT_MODE_P (<MODE>mode)"
1617   "%vucomis<ssemodefsuffix>\t{%1, %0|%0, %1}"
1618   [(set_attr "type" "ssecomi")
1619    (set_attr "prefix" "maybe_vex")
1620    (set_attr "prefix_rep" "0")
1621    (set (attr "prefix_data16")
1622         (if_then_else (eq_attr "mode" "DF")
1623                       (const_string "1")
1624                       (const_string "0")))
1625    (set_attr "mode" "<MODE>")])
1626
1627 (define_expand "vcond<mode>"
1628   [(set (match_operand:AVXMODEF2P 0 "register_operand" "")
1629         (if_then_else:AVXMODEF2P
1630           (match_operator 3 ""
1631             [(match_operand:AVXMODEF2P 4 "nonimmediate_operand" "")
1632              (match_operand:AVXMODEF2P 5 "nonimmediate_operand" "")])
1633           (match_operand:AVXMODEF2P 1 "general_operand" "")
1634           (match_operand:AVXMODEF2P 2 "general_operand" "")))]
1635   "(SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1636     || AVX_VEC_FLOAT_MODE_P (<MODE>mode))"
1637 {
1638   bool ok = ix86_expand_fp_vcond (operands);
1639   gcc_assert (ok);
1640   DONE;
1641 })
1642
1643 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1644 ;;
1645 ;; Parallel floating point logical operations
1646 ;;
1647 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1648
1649 (define_insn "avx_andnot<mode>3"
1650   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1651         (and:AVXMODEF2P
1652           (not:AVXMODEF2P
1653             (match_operand:AVXMODEF2P 1 "register_operand" "x"))
1654           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1655   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)"
1656   "vandn<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1657   [(set_attr "type" "sselog")
1658    (set_attr "prefix" "vex")
1659    (set_attr "mode" "<avxvecmode>")])
1660
1661 (define_insn "<sse>_andnot<mode>3"
1662   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1663         (and:SSEMODEF2P
1664           (not:SSEMODEF2P
1665             (match_operand:SSEMODEF2P 1 "register_operand" "0"))
1666           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1667   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1668   "andn<ssemodesuffix>\t{%2, %0|%0, %2}"
1669   [(set_attr "type" "sselog")
1670    (set_attr "mode" "<MODE>")])
1671
1672 (define_expand "<code><mode>3"
1673   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "")
1674         (any_logic:AVX256MODEF2P
1675           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "")
1676           (match_operand:AVX256MODEF2P 2 "nonimmediate_operand" "")))]
1677   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
1678   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1679
1680 (define_insn "*avx_<code><mode>3"
1681   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
1682         (any_logic:AVXMODEF2P
1683           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
1684           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
1685   "AVX_VEC_FLOAT_MODE_P (<MODE>mode)
1686    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1687 {
1688   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1689     return "v<logic>ps\t{%2, %1, %0|%0, %1, %2}";
1690   else
1691     return "v<logic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
1692 }
1693   [(set_attr "type" "sselog")
1694    (set_attr "prefix" "vex")
1695    (set_attr "mode" "<avxvecmode>")])
1696
1697 (define_expand "<code><mode>3"
1698   [(set (match_operand:SSEMODEF2P 0 "register_operand" "")
1699         (any_logic:SSEMODEF2P
1700           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "")
1701           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "")))]
1702   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
1703   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1704
1705 (define_insn "*<code><mode>3"
1706   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
1707         (any_logic:SSEMODEF2P
1708           (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
1709           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")))]
1710   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)
1711    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1712 {
1713   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1714     return "<logic>ps\t{%2, %0|%0, %2}";
1715   else
1716     return "<logic><ssemodesuffix>\t{%2, %0|%0, %2}";
1717 }
1718   [(set_attr "type" "sselog")
1719    (set_attr "mode" "<MODE>")])
1720
1721 (define_expand "copysign<mode>3"
1722   [(set (match_dup 4)
1723         (and:VEC_FLOAT_MODE
1724           (not:VEC_FLOAT_MODE (match_dup 3))
1725           (match_operand:VEC_FLOAT_MODE 1 "nonimmediate_operand" "")))
1726    (set (match_dup 5)
1727         (and:VEC_FLOAT_MODE (match_dup 3)
1728                             (match_operand:VEC_FLOAT_MODE 2 "nonimmediate_operand" "")))
1729    (set (match_operand:VEC_FLOAT_MODE 0 "register_operand" "")
1730         (ior:VEC_FLOAT_MODE (match_dup 4) (match_dup 5)))]
1731   ""
1732 {
1733   operands[3] = ix86_build_signbit_mask (<MODE>mode, 1, 0);
1734
1735   operands[4] = gen_reg_rtx (<MODE>mode);
1736   operands[5] = gen_reg_rtx (<MODE>mode);
1737 })
1738
1739 ;; Also define scalar versions.  These are used for abs, neg, and
1740 ;; conditional move.  Using subregs into vector modes causes register
1741 ;; allocation lossage.  These patterns do not allow memory operands
1742 ;; because the native instructions read the full 128-bits.
1743
1744 (define_insn "*avx_andnot<mode>3"
1745   [(set (match_operand:MODEF 0 "register_operand" "=x")
1746         (and:MODEF
1747           (not:MODEF
1748             (match_operand:MODEF 1 "register_operand" "x"))
1749             (match_operand:MODEF 2 "register_operand" "x")))]
1750   "AVX_FLOAT_MODE_P (<MODE>mode)"
1751   "vandnp<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}"
1752   [(set_attr "type" "sselog")
1753    (set_attr "prefix" "vex")
1754    (set_attr "mode" "<ssevecmode>")])
1755
1756 (define_insn "*andnot<mode>3"
1757   [(set (match_operand:MODEF 0 "register_operand" "=x")
1758         (and:MODEF
1759           (not:MODEF
1760             (match_operand:MODEF 1 "register_operand" "0"))
1761             (match_operand:MODEF 2 "register_operand" "x")))]
1762   "SSE_FLOAT_MODE_P (<MODE>mode)"
1763   "andnp<ssemodefsuffix>\t{%2, %0|%0, %2}"
1764   [(set_attr "type" "sselog")
1765    (set_attr "mode" "<ssevecmode>")])
1766
1767 (define_insn "*avx_<code><mode>3"
1768   [(set (match_operand:MODEF 0 "register_operand" "=x")
1769         (any_logic:MODEF
1770           (match_operand:MODEF 1 "register_operand" "x")
1771           (match_operand:MODEF 2 "register_operand" "x")))]
1772   "AVX_FLOAT_MODE_P (<MODE>mode)"
1773 {
1774   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1775     return "v<logic>ps\t{%2, %1, %0|%0, %1, %2}";
1776   else
1777     return "v<logic>p<ssemodefsuffix>\t{%2, %1, %0|%0, %1, %2}";
1778 }
1779   [(set_attr "type" "sselog")
1780    (set_attr "prefix" "vex")
1781    (set_attr "mode" "<ssevecmode>")])
1782
1783 (define_insn "*<code><mode>3"
1784   [(set (match_operand:MODEF 0 "register_operand" "=x")
1785         (any_logic:MODEF
1786           (match_operand:MODEF 1 "register_operand" "0")
1787           (match_operand:MODEF 2 "register_operand" "x")))]
1788   "SSE_FLOAT_MODE_P (<MODE>mode)"
1789 {
1790   if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
1791     return "<logic>ps\t{%2, %0|%0, %2}";
1792   else
1793     return "<logic>p<ssemodefsuffix>\t{%2, %0|%0, %2}";
1794 }
1795   [(set_attr "type" "sselog")
1796    (set_attr "mode" "<ssevecmode>")])
1797
1798 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1799 ;;
1800 ;; FMA4 floating point multiply/accumulate instructions.  This
1801 ;; includes the scalar version of the instructions as well as the
1802 ;; vector.
1803 ;;
1804 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1805
1806 ;; In order to match (*a * *b) + *c, particularly when vectorizing, allow
1807 ;; combine to generate a multiply/add with two memory references.  We then
1808 ;; split this insn, into loading up the destination register with one of the
1809 ;; memory operations.  If we don't manage to split the insn, reload will
1810 ;; generate the appropriate moves.  The reason this is needed, is that combine
1811 ;; has already folded one of the memory references into both the multiply and
1812 ;; add insns, and it can't generate a new pseudo.  I.e.:
1813 ;;      (set (reg1) (mem (addr1)))
1814 ;;      (set (reg2) (mult (reg1) (mem (addr2))))
1815 ;;      (set (reg3) (plus (reg2) (mem (addr3))))
1816
1817 ;; Intrinsic FMA operations.
1818
1819 ;; The standard name for fma is only available with SSE math enabled.
1820 (define_expand "fma<mode>4"
1821   [(set (match_operand:FMAMODE 0 "register_operand")
1822         (fma:FMAMODE
1823           (match_operand:FMAMODE 1 "nonimmediate_operand")
1824           (match_operand:FMAMODE 2 "nonimmediate_operand")
1825           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
1826   "(TARGET_FMA || TARGET_FMA4) && TARGET_SSE_MATH"
1827   "")
1828
1829 ;; The builtin for fma4intrin.h is not constrained by SSE math enabled.
1830 (define_expand "fma4i_fmadd_<mode>"
1831   [(set (match_operand:FMAMODE 0 "register_operand")
1832         (fma:FMAMODE
1833           (match_operand:FMAMODE 1 "nonimmediate_operand")
1834           (match_operand:FMAMODE 2 "nonimmediate_operand")
1835           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
1836   "TARGET_FMA || TARGET_FMA4"
1837   "")
1838
1839 (define_insn "*fma4i_fmadd_<mode>"
1840   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1841         (fma:FMAMODE
1842           (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x")
1843           (match_operand:FMAMODE 2 "nonimmediate_operand" " x,m")
1844           (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x")))]
1845   "TARGET_FMA4"
1846   "vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1847   [(set_attr "type" "ssemuladd")
1848    (set_attr "mode" "<MODE>")])
1849
1850 (define_insn "*fma4i_fmsub_<mode>"
1851   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1852         (fma:FMAMODE
1853           (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x")
1854           (match_operand:FMAMODE 2 "nonimmediate_operand" " x,m")
1855           (neg:FMAMODE
1856             (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x"))))]
1857   "TARGET_FMA4"
1858   "vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1859   [(set_attr "type" "ssemuladd")
1860    (set_attr "mode" "<MODE>")])
1861
1862 (define_insn "*fma4i_fnmadd_<mode>"
1863   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1864         (fma:FMAMODE
1865           (neg:FMAMODE
1866             (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x"))
1867           (match_operand:FMAMODE   2 "nonimmediate_operand" " x,m")
1868           (match_operand:FMAMODE   3 "nonimmediate_operand" "xm,x")))]
1869   "TARGET_FMA4"
1870   "vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1871   [(set_attr "type" "ssemuladd")
1872    (set_attr "mode" "<MODE>")])
1873
1874 (define_insn "*fma4i_fnmsub_<mode>"
1875   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x")
1876         (fma:FMAMODE
1877           (neg:FMAMODE
1878             (match_operand:FMAMODE 1 "nonimmediate_operand" "%x,x"))
1879           (match_operand:FMAMODE   2 "nonimmediate_operand" " x,m")
1880           (neg:FMAMODE
1881             (match_operand:FMAMODE 3 "nonimmediate_operand" "xm,x"))))]
1882   "TARGET_FMA4"
1883   "vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1884   [(set_attr "type" "ssemuladd")
1885    (set_attr "mode" "<MODE>")])
1886
1887 ;; Scalar versions of the above.  Unlike ADDSS et al, these write the
1888 ;; entire destination register, with the high-order elements zeroed.
1889
1890 (define_expand "fma4i_vmfmadd_<mode>"
1891   [(set (match_operand:SSEMODEF2P 0 "register_operand")
1892         (vec_merge:SSEMODEF2P
1893           (fma:SSEMODEF2P
1894             (match_operand:SSEMODEF2P 1 "nonimmediate_operand")
1895             (match_operand:SSEMODEF2P 2 "nonimmediate_operand")
1896             (match_operand:SSEMODEF2P 3 "nonimmediate_operand"))
1897           (match_dup 4)
1898           (const_int 1)))]
1899   "TARGET_FMA4"
1900 {
1901   operands[4] = CONST0_RTX (<MODE>mode);
1902 })
1903
1904 (define_insn "*fma4i_vmfmadd_<mode>"
1905   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1906         (vec_merge:SSEMODEF2P
1907           (fma:SSEMODEF2P
1908             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1909             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" " x,m")
1910             (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x"))
1911           (match_operand:SSEMODEF2P 4 "const0_operand" "")
1912           (const_int 1)))]
1913   "TARGET_FMA4"
1914   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1915   [(set_attr "type" "ssemuladd")
1916    (set_attr "mode" "<MODE>")])
1917
1918 (define_insn "*fma4i_vmfmsub_<mode>"
1919   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1920         (vec_merge:SSEMODEF2P
1921           (fma:SSEMODEF2P
1922             (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x")
1923             (match_operand:SSEMODEF2P 2 "nonimmediate_operand" " x,m")
1924             (neg:SSEMODEF2P
1925               (match_operand:SSEMODEF2P 3 "nonimmediate_operand" "xm,x")))
1926           (match_operand:SSEMODEF2P 4 "const0_operand" "")
1927           (const_int 1)))]
1928   "TARGET_FMA4"
1929   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1930   [(set_attr "type" "ssemuladd")
1931    (set_attr "mode" "<MODE>")])
1932
1933 (define_insn "*fma4i_vmfnmadd_<mode>"
1934   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1935         (vec_merge:SSEMODEF2P
1936           (fma:SSEMODEF2P
1937             (neg:SSEMODEF2P
1938               (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1939             (match_operand:SSEMODEF2P   2 "nonimmediate_operand" " x,m")
1940             (match_operand:SSEMODEF2P   3 "nonimmediate_operand" "xm,x"))
1941           (match_operand:SSEMODEF2P 4 "const0_operand" "")
1942           (const_int 1)))]
1943   "TARGET_FMA4"
1944   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1945   [(set_attr "type" "ssemuladd")
1946    (set_attr "mode" "<MODE>")])
1947
1948 (define_insn "*fma4i_vmfnmsub_<mode>"
1949   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x,x")
1950         (vec_merge:SSEMODEF2P
1951           (fma:SSEMODEF2P
1952             (neg:SSEMODEF2P
1953               (match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%x,x"))
1954             (match_operand:SSEMODEF2P   2 "nonimmediate_operand" " x,m")
1955             (neg:SSEMODEF2P
1956               (match_operand:SSEMODEF2P   3 "nonimmediate_operand" "xm,x")))
1957           (match_operand:SSEMODEF2P 4 "const0_operand" "")
1958           (const_int 1)))]
1959   "TARGET_FMA4"
1960   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1961   [(set_attr "type" "ssemuladd")
1962    (set_attr "mode" "<MODE>")])
1963
1964 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1965 ;;
1966 ;; FMA4 Parallel floating point multiply addsub and subadd operations.
1967 ;;
1968 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1969
1970 ;; It would be possible to represent these without the UNSPEC as
1971 ;;
1972 ;; (vec_merge
1973 ;;   (fma op1 op2 op3)
1974 ;;   (fma op1 op2 (neg op3))
1975 ;;   (merge-const))
1976 ;;
1977 ;; But this doesn't seem useful in practice.
1978
1979 (define_expand "fmaddsub_<mode>"
1980   [(set (match_operand:AVXMODEF2P 0 "register_operand")
1981         (unspec:AVXMODEF2P
1982           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand")
1983            (match_operand:AVXMODEF2P 2 "nonimmediate_operand")
1984            (match_operand:AVXMODEF2P 3 "nonimmediate_operand")]
1985           UNSPEC_FMADDSUB))]
1986   "TARGET_FMA || TARGET_FMA4"
1987   "")
1988
1989 (define_insn "*fma4_fmaddsub_<mode>"
1990   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x,x")
1991         (unspec:AVXMODEF2P
1992           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x,x")
1993            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" " x,m")
1994            (match_operand:AVXMODEF2P 3 "nonimmediate_operand" "xm,x")]
1995           UNSPEC_FMADDSUB))]
1996   "TARGET_FMA4"
1997   "vfmaddsubps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1998   [(set_attr "type" "ssemuladd")
1999    (set_attr "mode" "<MODE>")])
2000
2001 (define_insn "*fma4_fmsubadd_<mode>"
2002   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x,x")
2003         (unspec:AVXMODEF2P
2004           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x,x")
2005            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" " x,m")
2006            (neg:AVXMODEF2P
2007              (match_operand:AVXMODEF2P 3 "nonimmediate_operand" "xm,x"))]
2008           UNSPEC_FMADDSUB))]
2009   "TARGET_FMA4"
2010   "vfmsubaddps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2011   [(set_attr "type" "ssemuladd")
2012    (set_attr "mode" "<MODE>")])
2013
2014 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2015 ;;
2016 ;; FMA3 floating point multiply/accumulate instructions.
2017 ;;
2018 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2019
2020 (define_insn "*fma_fmadd_<mode>"
2021   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2022         (fma:FMAMODE
2023           (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x")
2024           (match_operand:FMAMODE 2 "nonimmediate_operand" "xm, x,xm")
2025           (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0")))]
2026   "TARGET_FMA"
2027   "@
2028    vfmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2029    vfmadd312<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2030    vfmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2031   [(set_attr "type" "ssemuladd")
2032    (set_attr "mode" "<MODE>")])
2033
2034 (define_insn "*fma_fmsub_<mode>"
2035   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2036         (fma:FMAMODE
2037           (match_operand:FMAMODE   1 "nonimmediate_operand" "%0, 0,x")
2038           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2039           (neg:FMAMODE
2040             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0"))))]
2041   "TARGET_FMA"
2042   "@
2043    vfmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2044    vfmsub312<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2045    vfmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2046   [(set_attr "type" "ssemuladd")
2047    (set_attr "mode" "<MODE>")])
2048
2049 (define_insn "*fma_fmadd_<mode>"
2050   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2051         (fma:FMAMODE
2052           (neg:FMAMODE
2053             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x"))
2054           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2055           (match_operand:FMAMODE   3 "nonimmediate_operand" " x,xm,0")))]
2056   "TARGET_FMA"
2057   "@
2058    vfnmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2059    vfnmadd312<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2060    vfnmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2061   [(set_attr "type" "ssemuladd")
2062    (set_attr "mode" "<MODE>")])
2063
2064 (define_insn "*fma_fmsub_<mode>"
2065   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x")
2066         (fma:FMAMODE
2067           (neg:FMAMODE
2068             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x"))
2069           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm")
2070           (neg:FMAMODE
2071             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0"))))]
2072   "TARGET_FMA"
2073   "@
2074    vfnmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2075    vfnmsub312<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2076    vfnmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2077   [(set_attr "type" "ssemuladd")
2078    (set_attr "mode" "<MODE>")])
2079
2080 (define_insn "*fma_fmaddsub_<mode>"
2081   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x,x,x")
2082         (unspec:AVXMODEF2P
2083           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%0, 0,x")
2084            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm, x,xm")
2085            (match_operand:AVXMODEF2P 3 "nonimmediate_operand" " x,xm,0")]
2086           UNSPEC_FMADDSUB))]
2087   "TARGET_FMA"
2088   "@
2089    vfmaddsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2090    vfmaddsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2091    vfmaddsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2092   [(set_attr "type" "ssemuladd")
2093    (set_attr "mode" "<MODE>")])
2094
2095 (define_insn "*fma_fmsubadd_<mode>"
2096   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x,x,x")
2097         (unspec:AVXMODEF2P
2098           [(match_operand:AVXMODEF2P   1 "nonimmediate_operand" "%0, 0,x")
2099            (match_operand:AVXMODEF2P   2 "nonimmediate_operand" "xm, x,xm")
2100            (neg:AVXMODEF2P
2101              (match_operand:AVXMODEF2P 3 "nonimmediate_operand" " x,xm,0"))]
2102           UNSPEC_FMADDSUB))]
2103   "TARGET_FMA"
2104   "@
2105    vfmsubadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2106    vfmsubadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2107    vfmsubadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2108   [(set_attr "type" "ssemuladd")
2109    (set_attr "mode" "<MODE>")])
2110
2111 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2112 ;;
2113 ;; Non-intrinsic versions, matched when fused-multiply-add is allowed.
2114 ;;
2115 ;; ??? If fused-madd were a generic flag, combine could do this without
2116 ;; needing splitters here in the backend.  Irritatingly, combine won't
2117 ;; recognize many of these with mere splits, since only 3 or more insns
2118 ;; are allowed to split during combine.  Thankfully, there's always a
2119 ;; split_all_insns pass that runs before reload.
2120 ;;
2121 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2122
2123 (define_insn_and_split "*split_fma"
2124   [(set (match_operand:FMAMODE 0 "register_operand")
2125         (plus:FMAMODE
2126           (mult:FMAMODE
2127             (match_operand:FMAMODE 1 "nonimmediate_operand")
2128             (match_operand:FMAMODE 2 "nonimmediate_operand"))
2129           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
2130   "TARGET_SSE_MATH && TARGET_FUSED_MADD
2131    && (TARGET_FMA || TARGET_FMA4)
2132    && !(reload_in_progress || reload_completed)"
2133   { gcc_unreachable (); }
2134   "&& 1"
2135   [(set (match_dup 0)
2136         (fma:FMAMODE
2137           (match_dup 1)
2138           (match_dup 2)
2139           (match_dup 3)))]
2140   "")
2141
2142 ;; Floating multiply and subtract.
2143 (define_insn_and_split "*split_fms"
2144   [(set (match_operand:FMAMODE 0 "register_operand")
2145         (minus:FMAMODE
2146           (mult:FMAMODE
2147             (match_operand:FMAMODE 1 "nonimmediate_operand")
2148             (match_operand:FMAMODE 2 "nonimmediate_operand"))
2149           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
2150   "TARGET_SSE_MATH && TARGET_FUSED_MADD
2151    && (TARGET_FMA || TARGET_FMA4)
2152    && !(reload_in_progress || reload_completed)"
2153   { gcc_unreachable (); }
2154   "&& 1"
2155   [(set (match_dup 0)
2156         (fma:FMAMODE
2157           (match_dup 1)
2158           (match_dup 2)
2159           (neg:FMAMODE (match_dup 3))))]
2160   "")
2161
2162 ;; Floating point negative multiply and add.
2163 ;; Recognize (-a * b + c) via the canonical form: c - (a * b).
2164 (define_insn_and_split "*split_fnma"
2165   [(set (match_operand:FMAMODE 0 "register_operand")
2166         (minus:FMAMODE
2167          (match_operand:FMAMODE 3 "nonimmediate_operand")
2168          (mult:FMAMODE
2169           (match_operand:FMAMODE 1 "nonimmediate_operand")
2170           (match_operand:FMAMODE 2 "nonimmediate_operand"))))]
2171   "TARGET_SSE_MATH && TARGET_FUSED_MADD
2172    && (TARGET_FMA || TARGET_FMA4)
2173    && !(reload_in_progress || reload_completed)"
2174   { gcc_unreachable (); }
2175   "&& 1"
2176   [(set (match_dup 0)
2177         (fma:FMAMODE
2178           (neg:FMAMODE (match_dup 1))
2179           (match_dup 2)
2180           (match_dup 3)))]
2181   "")
2182
2183 ;; Floating point negative multiply and subtract.
2184 ;; Recognize (-a * b - c) via the canonical form: c - (-a * b).
2185 (define_insn_and_split "*split_fnms"
2186   [(set (match_operand:FMAMODE 0 "register_operand")
2187         (minus:FMAMODE
2188           (mult:FMAMODE
2189             (neg:FMAMODE
2190               (match_operand:FMAMODE 1 "nonimmediate_operand"))
2191             (match_operand:FMAMODE 2 "nonimmediate_operand"))
2192          (match_operand:FMAMODE 3 "nonimmediate_operand")))]
2193   "TARGET_SSE_MATH && TARGET_FUSED_MADD
2194    && (TARGET_FMA || TARGET_FMA4)
2195    && !(reload_in_progress || reload_completed)"
2196   { gcc_unreachable (); }
2197   "&& 1"
2198   [(set (match_dup 0)
2199         (fma:FMAMODE
2200           (neg:FMAMODE (match_dup 1))
2201           (match_dup 2)
2202           (neg:FMAMODE (match_dup 3))))]
2203   "")
2204
2205 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2206 ;;
2207 ;; Parallel single-precision floating point conversion operations
2208 ;;
2209 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2210
2211 (define_insn "sse_cvtpi2ps"
2212   [(set (match_operand:V4SF 0 "register_operand" "=x")
2213         (vec_merge:V4SF
2214           (vec_duplicate:V4SF
2215             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2216           (match_operand:V4SF 1 "register_operand" "0")
2217           (const_int 3)))]
2218   "TARGET_SSE"
2219   "cvtpi2ps\t{%2, %0|%0, %2}"
2220   [(set_attr "type" "ssecvt")
2221    (set_attr "mode" "V4SF")])
2222
2223 (define_insn "sse_cvtps2pi"
2224   [(set (match_operand:V2SI 0 "register_operand" "=y")
2225         (vec_select:V2SI
2226           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2227                        UNSPEC_FIX_NOTRUNC)
2228           (parallel [(const_int 0) (const_int 1)])))]
2229   "TARGET_SSE"
2230   "cvtps2pi\t{%1, %0|%0, %1}"
2231   [(set_attr "type" "ssecvt")
2232    (set_attr "unit" "mmx")
2233    (set_attr "mode" "DI")])
2234
2235 (define_insn "sse_cvttps2pi"
2236   [(set (match_operand:V2SI 0 "register_operand" "=y")
2237         (vec_select:V2SI
2238           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2239           (parallel [(const_int 0) (const_int 1)])))]
2240   "TARGET_SSE"
2241   "cvttps2pi\t{%1, %0|%0, %1}"
2242   [(set_attr "type" "ssecvt")
2243    (set_attr "unit" "mmx")
2244    (set_attr "prefix_rep" "0")
2245    (set_attr "mode" "SF")])
2246
2247 (define_insn "*avx_cvtsi2ss"
2248   [(set (match_operand:V4SF 0 "register_operand" "=x")
2249         (vec_merge:V4SF
2250           (vec_duplicate:V4SF
2251             (float:SF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2252           (match_operand:V4SF 1 "register_operand" "x")
2253           (const_int 1)))]
2254   "TARGET_AVX"
2255   "vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2256   [(set_attr "type" "sseicvt")
2257    (set_attr "prefix" "vex")
2258    (set_attr "mode" "SF")])
2259
2260 (define_insn "sse_cvtsi2ss"
2261   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2262         (vec_merge:V4SF
2263           (vec_duplicate:V4SF
2264             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2265           (match_operand:V4SF 1 "register_operand" "0,0")
2266           (const_int 1)))]
2267   "TARGET_SSE"
2268   "cvtsi2ss\t{%2, %0|%0, %2}"
2269   [(set_attr "type" "sseicvt")
2270    (set_attr "athlon_decode" "vector,double")
2271    (set_attr "amdfam10_decode" "vector,double")
2272    (set_attr "bdver1_decode" "double,direct")
2273    (set_attr "mode" "SF")])
2274
2275 (define_insn "*avx_cvtsi2ssq"
2276   [(set (match_operand:V4SF 0 "register_operand" "=x")
2277         (vec_merge:V4SF
2278           (vec_duplicate:V4SF
2279             (float:SF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2280           (match_operand:V4SF 1 "register_operand" "x")
2281           (const_int 1)))]
2282   "TARGET_AVX && TARGET_64BIT"
2283   "vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2284   [(set_attr "type" "sseicvt")
2285    (set_attr "length_vex" "4")
2286    (set_attr "prefix" "vex")
2287    (set_attr "mode" "SF")])
2288
2289 (define_insn "sse_cvtsi2ssq"
2290   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2291         (vec_merge:V4SF
2292           (vec_duplicate:V4SF
2293             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
2294           (match_operand:V4SF 1 "register_operand" "0,0")
2295           (const_int 1)))]
2296   "TARGET_SSE && TARGET_64BIT"
2297   "cvtsi2ssq\t{%2, %0|%0, %2}"
2298   [(set_attr "type" "sseicvt")
2299    (set_attr "prefix_rex" "1")
2300    (set_attr "athlon_decode" "vector,double")
2301    (set_attr "amdfam10_decode" "vector,double")
2302    (set_attr "bdver1_decode" "double,direct")
2303    (set_attr "mode" "SF")])
2304
2305 (define_insn "sse_cvtss2si"
2306   [(set (match_operand:SI 0 "register_operand" "=r,r")
2307         (unspec:SI
2308           [(vec_select:SF
2309              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2310              (parallel [(const_int 0)]))]
2311           UNSPEC_FIX_NOTRUNC))]
2312   "TARGET_SSE"
2313   "%vcvtss2si\t{%1, %0|%0, %1}"
2314   [(set_attr "type" "sseicvt")
2315    (set_attr "athlon_decode" "double,vector")
2316    (set_attr "bdver1_decode" "double,double")
2317    (set_attr "prefix_rep" "1")
2318    (set_attr "prefix" "maybe_vex")
2319    (set_attr "mode" "SI")])
2320
2321 (define_insn "sse_cvtss2si_2"
2322   [(set (match_operand:SI 0 "register_operand" "=r,r")
2323         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2324                    UNSPEC_FIX_NOTRUNC))]
2325   "TARGET_SSE"
2326   "%vcvtss2si\t{%1, %0|%0, %1}"
2327   [(set_attr "type" "sseicvt")
2328    (set_attr "athlon_decode" "double,vector")
2329    (set_attr "amdfam10_decode" "double,double")
2330    (set_attr "bdver1_decode" "double,double")
2331    (set_attr "prefix_rep" "1")
2332    (set_attr "prefix" "maybe_vex")
2333    (set_attr "mode" "SI")])
2334
2335 (define_insn "sse_cvtss2siq"
2336   [(set (match_operand:DI 0 "register_operand" "=r,r")
2337         (unspec:DI
2338           [(vec_select:SF
2339              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2340              (parallel [(const_int 0)]))]
2341           UNSPEC_FIX_NOTRUNC))]
2342   "TARGET_SSE && TARGET_64BIT"
2343   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2344   [(set_attr "type" "sseicvt")
2345    (set_attr "athlon_decode" "double,vector")
2346    (set_attr "bdver1_decode" "double,double")
2347    (set_attr "prefix_rep" "1")
2348    (set_attr "prefix" "maybe_vex")
2349    (set_attr "mode" "DI")])
2350
2351 (define_insn "sse_cvtss2siq_2"
2352   [(set (match_operand:DI 0 "register_operand" "=r,r")
2353         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2354                    UNSPEC_FIX_NOTRUNC))]
2355   "TARGET_SSE && TARGET_64BIT"
2356   "%vcvtss2si{q}\t{%1, %0|%0, %1}"
2357   [(set_attr "type" "sseicvt")
2358    (set_attr "athlon_decode" "double,vector")
2359    (set_attr "amdfam10_decode" "double,double")
2360    (set_attr "bdver1_decode" "double,double")
2361    (set_attr "prefix_rep" "1")
2362    (set_attr "prefix" "maybe_vex")
2363    (set_attr "mode" "DI")])
2364
2365 (define_insn "sse_cvttss2si"
2366   [(set (match_operand:SI 0 "register_operand" "=r,r")
2367         (fix:SI
2368           (vec_select:SF
2369             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2370             (parallel [(const_int 0)]))))]
2371   "TARGET_SSE"
2372   "%vcvttss2si\t{%1, %0|%0, %1}"
2373   [(set_attr "type" "sseicvt")
2374    (set_attr "athlon_decode" "double,vector")
2375    (set_attr "amdfam10_decode" "double,double")
2376    (set_attr "bdver1_decode" "double,double")
2377    (set_attr "prefix_rep" "1")
2378    (set_attr "prefix" "maybe_vex")
2379    (set_attr "mode" "SI")])
2380
2381 (define_insn "sse_cvttss2siq"
2382   [(set (match_operand:DI 0 "register_operand" "=r,r")
2383         (fix:DI
2384           (vec_select:SF
2385             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2386             (parallel [(const_int 0)]))))]
2387   "TARGET_SSE && TARGET_64BIT"
2388   "%vcvttss2si{q}\t{%1, %0|%0, %1}"
2389   [(set_attr "type" "sseicvt")
2390    (set_attr "athlon_decode" "double,vector")
2391    (set_attr "amdfam10_decode" "double,double")
2392    (set_attr "bdver1_decode" "double,double")
2393    (set_attr "prefix_rep" "1")
2394    (set_attr "prefix" "maybe_vex")
2395    (set_attr "mode" "DI")])
2396
2397 (define_insn "avx_cvtdq2ps<avxmodesuffix>"
2398   [(set (match_operand:AVXMODEDCVTDQ2PS 0 "register_operand" "=x")
2399         (float:AVXMODEDCVTDQ2PS
2400           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2401   "TARGET_AVX"
2402   "vcvtdq2ps\t{%1, %0|%0, %1}"
2403   [(set_attr "type" "ssecvt")
2404    (set_attr "prefix" "vex")
2405    (set_attr "mode" "<avxvecmode>")])
2406
2407 (define_insn "sse2_cvtdq2ps"
2408   [(set (match_operand:V4SF 0 "register_operand" "=x")
2409         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2410   "TARGET_SSE2"
2411   "cvtdq2ps\t{%1, %0|%0, %1}"
2412   [(set_attr "type" "ssecvt")
2413    (set_attr "mode" "V4SF")])
2414
2415 (define_expand "sse2_cvtudq2ps"
2416   [(set (match_dup 5)
2417         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "")))
2418    (set (match_dup 6)
2419         (lt:V4SF (match_dup 5) (match_dup 3)))
2420    (set (match_dup 7)
2421         (and:V4SF (match_dup 6) (match_dup 4)))
2422    (set (match_operand:V4SF 0 "register_operand" "")
2423         (plus:V4SF (match_dup 5) (match_dup 7)))]
2424   "TARGET_SSE2"
2425 {
2426   REAL_VALUE_TYPE TWO32r;
2427   rtx x;
2428   int i;
2429
2430   real_ldexp (&TWO32r, &dconst1, 32);
2431   x = const_double_from_real_value (TWO32r, SFmode);
2432
2433   operands[3] = force_reg (V4SFmode, CONST0_RTX (V4SFmode));
2434   operands[4] = force_reg (V4SFmode,
2435                            ix86_build_const_vector (V4SFmode, 1, x));
2436
2437   for (i = 5; i < 8; i++)
2438     operands[i] = gen_reg_rtx (V4SFmode);
2439 })
2440
2441 (define_insn "avx_cvtps2dq<avxmodesuffix>"
2442   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2443         (unspec:AVXMODEDCVTPS2DQ
2444           [(match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")]
2445           UNSPEC_FIX_NOTRUNC))]
2446   "TARGET_AVX"
2447   "vcvtps2dq\t{%1, %0|%0, %1}"
2448   [(set_attr "type" "ssecvt")
2449    (set_attr "prefix" "vex")
2450    (set_attr "mode" "<avxvecmode>")])
2451
2452 (define_insn "sse2_cvtps2dq"
2453   [(set (match_operand:V4SI 0 "register_operand" "=x")
2454         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2455                      UNSPEC_FIX_NOTRUNC))]
2456   "TARGET_SSE2"
2457   "cvtps2dq\t{%1, %0|%0, %1}"
2458   [(set_attr "type" "ssecvt")
2459    (set_attr "prefix_data16" "1")
2460    (set_attr "mode" "TI")])
2461
2462 (define_insn "avx_cvttps2dq<avxmodesuffix>"
2463   [(set (match_operand:AVXMODEDCVTPS2DQ 0 "register_operand" "=x")
2464         (fix:AVXMODEDCVTPS2DQ
2465           (match_operand:<avxcvtvecmode> 1 "nonimmediate_operand" "xm")))]
2466   "TARGET_AVX"
2467   "vcvttps2dq\t{%1, %0|%0, %1}"
2468   [(set_attr "type" "ssecvt")
2469    (set_attr "prefix" "vex")
2470    (set_attr "mode" "<avxvecmode>")])
2471
2472 (define_insn "sse2_cvttps2dq"
2473   [(set (match_operand:V4SI 0 "register_operand" "=x")
2474         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2475   "TARGET_SSE2"
2476   "cvttps2dq\t{%1, %0|%0, %1}"
2477   [(set_attr "type" "ssecvt")
2478    (set_attr "prefix_rep" "1")
2479    (set_attr "prefix_data16" "0")
2480    (set_attr "mode" "TI")])
2481
2482 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2483 ;;
2484 ;; Parallel double-precision floating point conversion operations
2485 ;;
2486 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2487
2488 (define_insn "sse2_cvtpi2pd"
2489   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2490         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2491   "TARGET_SSE2"
2492   "cvtpi2pd\t{%1, %0|%0, %1}"
2493   [(set_attr "type" "ssecvt")
2494    (set_attr "unit" "mmx,*")
2495    (set_attr "prefix_data16" "1,*")
2496    (set_attr "mode" "V2DF")])
2497
2498 (define_insn "sse2_cvtpd2pi"
2499   [(set (match_operand:V2SI 0 "register_operand" "=y")
2500         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2501                      UNSPEC_FIX_NOTRUNC))]
2502   "TARGET_SSE2"
2503   "cvtpd2pi\t{%1, %0|%0, %1}"
2504   [(set_attr "type" "ssecvt")
2505    (set_attr "unit" "mmx")
2506    (set_attr "prefix_data16" "1")
2507    (set_attr "mode" "DI")
2508    (set_attr "bdver1_decode" "double")])
2509
2510 (define_insn "sse2_cvttpd2pi"
2511   [(set (match_operand:V2SI 0 "register_operand" "=y")
2512         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2513   "TARGET_SSE2"
2514   "cvttpd2pi\t{%1, %0|%0, %1}"
2515   [(set_attr "type" "ssecvt")
2516    (set_attr "unit" "mmx")
2517    (set_attr "prefix_data16" "1")
2518    (set_attr "mode" "TI")
2519    (set_attr "bdver1_decode" "double")])
2520
2521 (define_insn "*avx_cvtsi2sd"
2522   [(set (match_operand:V2DF 0 "register_operand" "=x")
2523         (vec_merge:V2DF
2524           (vec_duplicate:V2DF
2525             (float:DF (match_operand:SI 2 "nonimmediate_operand" "rm")))
2526           (match_operand:V2DF 1 "register_operand" "x")
2527           (const_int 1)))]
2528   "TARGET_AVX"
2529   "vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2530   [(set_attr "type" "sseicvt")
2531    (set_attr "prefix" "vex")
2532    (set_attr "mode" "DF")])
2533
2534 (define_insn "sse2_cvtsi2sd"
2535   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2536         (vec_merge:V2DF
2537           (vec_duplicate:V2DF
2538             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2539           (match_operand:V2DF 1 "register_operand" "0,0")
2540           (const_int 1)))]
2541   "TARGET_SSE2"
2542   "cvtsi2sd\t{%2, %0|%0, %2}"
2543   [(set_attr "type" "sseicvt")
2544    (set_attr "mode" "DF")
2545    (set_attr "athlon_decode" "double,direct")
2546    (set_attr "amdfam10_decode" "vector,double")
2547    (set_attr "bdver1_decode" "double,direct")])
2548
2549 (define_insn "*avx_cvtsi2sdq"
2550   [(set (match_operand:V2DF 0 "register_operand" "=x")
2551         (vec_merge:V2DF
2552           (vec_duplicate:V2DF
2553             (float:DF (match_operand:DI 2 "nonimmediate_operand" "rm")))
2554           (match_operand:V2DF 1 "register_operand" "x")
2555           (const_int 1)))]
2556   "TARGET_AVX && TARGET_64BIT"
2557   "vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2558   [(set_attr "type" "sseicvt")
2559    (set_attr "length_vex" "4")
2560    (set_attr "prefix" "vex")
2561    (set_attr "mode" "DF")])
2562
2563 (define_insn "sse2_cvtsi2sdq"
2564   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2565         (vec_merge:V2DF
2566           (vec_duplicate:V2DF
2567             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2568           (match_operand:V2DF 1 "register_operand" "0,0")
2569           (const_int 1)))]
2570   "TARGET_SSE2 && TARGET_64BIT"
2571   "cvtsi2sdq\t{%2, %0|%0, %2}"
2572   [(set_attr "type" "sseicvt")
2573    (set_attr "prefix_rex" "1")
2574    (set_attr "mode" "DF")
2575    (set_attr "athlon_decode" "double,direct")
2576    (set_attr "amdfam10_decode" "vector,double")
2577    (set_attr "bdver1_decode" "double,direct")])
2578
2579 (define_insn "sse2_cvtsd2si"
2580   [(set (match_operand:SI 0 "register_operand" "=r,r")
2581         (unspec:SI
2582           [(vec_select:DF
2583              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2584              (parallel [(const_int 0)]))]
2585           UNSPEC_FIX_NOTRUNC))]
2586   "TARGET_SSE2"
2587   "%vcvtsd2si\t{%1, %0|%0, %1}"
2588   [(set_attr "type" "sseicvt")
2589    (set_attr "athlon_decode" "double,vector")
2590    (set_attr "bdver1_decode" "double,double")
2591    (set_attr "prefix_rep" "1")
2592    (set_attr "prefix" "maybe_vex")
2593    (set_attr "mode" "SI")])
2594
2595 (define_insn "sse2_cvtsd2si_2"
2596   [(set (match_operand:SI 0 "register_operand" "=r,r")
2597         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2598                    UNSPEC_FIX_NOTRUNC))]
2599   "TARGET_SSE2"
2600   "%vcvtsd2si\t{%1, %0|%0, %1}"
2601   [(set_attr "type" "sseicvt")
2602    (set_attr "athlon_decode" "double,vector")
2603    (set_attr "amdfam10_decode" "double,double")
2604    (set_attr "bdver1_decode" "double,double")
2605    (set_attr "prefix_rep" "1")
2606    (set_attr "prefix" "maybe_vex")
2607    (set_attr "mode" "SI")])
2608
2609 (define_insn "sse2_cvtsd2siq"
2610   [(set (match_operand:DI 0 "register_operand" "=r,r")
2611         (unspec:DI
2612           [(vec_select:DF
2613              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2614              (parallel [(const_int 0)]))]
2615           UNSPEC_FIX_NOTRUNC))]
2616   "TARGET_SSE2 && TARGET_64BIT"
2617   "%vcvtsd2siq\t{%1, %0|%0, %1}"
2618   [(set_attr "type" "sseicvt")
2619    (set_attr "athlon_decode" "double,vector")
2620    (set_attr "bdver1_decode" "double,double")
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 "bdver1_decode" "double,double")
2635    (set_attr "prefix_rep" "1")
2636    (set_attr "prefix" "maybe_vex")
2637    (set_attr "mode" "DI")])
2638
2639 (define_insn "sse2_cvttsd2si"
2640   [(set (match_operand:SI 0 "register_operand" "=r,r")
2641         (fix:SI
2642           (vec_select:DF
2643             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2644             (parallel [(const_int 0)]))))]
2645   "TARGET_SSE2"
2646   "%vcvttsd2si\t{%1, %0|%0, %1}"
2647   [(set_attr "type" "sseicvt")
2648    (set_attr "prefix_rep" "1")
2649    (set_attr "prefix" "maybe_vex")
2650    (set_attr "mode" "SI")
2651    (set_attr "athlon_decode" "double,vector")
2652    (set_attr "amdfam10_decode" "double,double")
2653    (set_attr "bdver1_decode" "double,double")])
2654
2655 (define_insn "sse2_cvttsd2siq"
2656   [(set (match_operand:DI 0 "register_operand" "=r,r")
2657         (fix:DI
2658           (vec_select:DF
2659             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2660             (parallel [(const_int 0)]))))]
2661   "TARGET_SSE2 && TARGET_64BIT"
2662   "%vcvttsd2siq\t{%1, %0|%0, %1}"
2663   [(set_attr "type" "sseicvt")
2664    (set_attr "prefix_rep" "1")
2665    (set_attr "prefix" "maybe_vex")
2666    (set_attr "mode" "DI")
2667    (set_attr "athlon_decode" "double,vector")
2668    (set_attr "amdfam10_decode" "double,double")
2669    (set_attr "bdver1_decode" "double,double")])
2670
2671 (define_insn "avx_cvtdq2pd256"
2672   [(set (match_operand:V4DF 0 "register_operand" "=x")
2673         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2674   "TARGET_AVX"
2675   "vcvtdq2pd\t{%1, %0|%0, %1}"
2676   [(set_attr "type" "ssecvt")
2677    (set_attr "prefix" "vex")
2678    (set_attr "mode" "V4DF")])
2679
2680 (define_insn "*avx_cvtdq2pd256_2"
2681   [(set (match_operand:V4DF 0 "register_operand" "=x")
2682         (float:V4DF
2683           (vec_select:V4SI
2684             (match_operand:V8SI 1 "nonimmediate_operand" "xm")
2685             (parallel [(const_int 0) (const_int 1) (const_int 2) (const_int 3)]))))]
2686   "TARGET_AVX"
2687   "vcvtdq2pd\t{%x1, %0|%0, %x1}"
2688   [(set_attr "type" "ssecvt")
2689    (set_attr "prefix" "vex")
2690    (set_attr "mode" "V4DF")])
2691
2692 (define_insn "sse2_cvtdq2pd"
2693   [(set (match_operand:V2DF 0 "register_operand" "=x")
2694         (float:V2DF
2695           (vec_select:V2SI
2696             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2697             (parallel [(const_int 0) (const_int 1)]))))]
2698   "TARGET_SSE2"
2699   "%vcvtdq2pd\t{%1, %0|%0, %1}"
2700   [(set_attr "type" "ssecvt")
2701    (set_attr "prefix" "maybe_vex")
2702    (set_attr "mode" "V2DF")])
2703
2704 (define_insn "avx_cvtpd2dq256"
2705   [(set (match_operand:V4SI 0 "register_operand" "=x")
2706         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2707                      UNSPEC_FIX_NOTRUNC))]
2708   "TARGET_AVX"
2709   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2710   [(set_attr "type" "ssecvt")
2711    (set_attr "prefix" "vex")
2712    (set_attr "mode" "OI")])
2713
2714 (define_expand "sse2_cvtpd2dq"
2715   [(set (match_operand:V4SI 0 "register_operand" "")
2716         (vec_concat:V4SI
2717           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2718                        UNSPEC_FIX_NOTRUNC)
2719           (match_dup 2)))]
2720   "TARGET_SSE2"
2721   "operands[2] = CONST0_RTX (V2SImode);")
2722
2723 (define_insn "*sse2_cvtpd2dq"
2724   [(set (match_operand:V4SI 0 "register_operand" "=x")
2725         (vec_concat:V4SI
2726           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2727                        UNSPEC_FIX_NOTRUNC)
2728           (match_operand:V2SI 2 "const0_operand" "")))]
2729   "TARGET_SSE2"
2730   "* return TARGET_AVX ? \"vcvtpd2dq{x}\t{%1, %0|%0, %1}\"
2731                        : \"cvtpd2dq\t{%1, %0|%0, %1}\";"
2732   [(set_attr "type" "ssecvt")
2733    (set_attr "prefix_rep" "1")
2734    (set_attr "prefix_data16" "0")
2735    (set_attr "prefix" "maybe_vex")
2736    (set_attr "mode" "TI")
2737    (set_attr "amdfam10_decode" "double")
2738    (set_attr "bdver1_decode" "double")])
2739
2740 (define_insn "avx_cvttpd2dq256"
2741   [(set (match_operand:V4SI 0 "register_operand" "=x")
2742         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2743   "TARGET_AVX"
2744   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2745   [(set_attr "type" "ssecvt")
2746    (set_attr "prefix" "vex")
2747    (set_attr "mode" "OI")])
2748
2749 (define_expand "sse2_cvttpd2dq"
2750   [(set (match_operand:V4SI 0 "register_operand" "")
2751         (vec_concat:V4SI
2752           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2753           (match_dup 2)))]
2754   "TARGET_SSE2"
2755   "operands[2] = CONST0_RTX (V2SImode);")
2756
2757 (define_insn "*sse2_cvttpd2dq"
2758   [(set (match_operand:V4SI 0 "register_operand" "=x")
2759         (vec_concat:V4SI
2760           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2761           (match_operand:V2SI 2 "const0_operand" "")))]
2762   "TARGET_SSE2"
2763   "* return TARGET_AVX ? \"vcvttpd2dq{x}\t{%1, %0|%0, %1}\"
2764                        : \"cvttpd2dq\t{%1, %0|%0, %1}\";"
2765   [(set_attr "type" "ssecvt")
2766    (set_attr "prefix" "maybe_vex")
2767    (set_attr "mode" "TI")
2768    (set_attr "amdfam10_decode" "double")
2769    (set_attr "bdver1_decode" "double")])
2770
2771 (define_insn "*avx_cvtsd2ss"
2772   [(set (match_operand:V4SF 0 "register_operand" "=x")
2773         (vec_merge:V4SF
2774           (vec_duplicate:V4SF
2775             (float_truncate:V2SF
2776               (match_operand:V2DF 2 "nonimmediate_operand" "xm")))
2777           (match_operand:V4SF 1 "register_operand" "x")
2778           (const_int 1)))]
2779   "TARGET_AVX"
2780   "vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}"
2781   [(set_attr "type" "ssecvt")
2782    (set_attr "prefix" "vex")
2783    (set_attr "mode" "SF")])
2784
2785 (define_insn "sse2_cvtsd2ss"
2786   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2787         (vec_merge:V4SF
2788           (vec_duplicate:V4SF
2789             (float_truncate:V2SF
2790               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2791           (match_operand:V4SF 1 "register_operand" "0,0")
2792           (const_int 1)))]
2793   "TARGET_SSE2"
2794   "cvtsd2ss\t{%2, %0|%0, %2}"
2795   [(set_attr "type" "ssecvt")
2796    (set_attr "athlon_decode" "vector,double")
2797    (set_attr "amdfam10_decode" "vector,double")
2798    (set_attr "bdver1_decode" "direct,direct")
2799    (set_attr "mode" "SF")])
2800
2801 (define_insn "*avx_cvtss2sd"
2802   [(set (match_operand:V2DF 0 "register_operand" "=x")
2803         (vec_merge:V2DF
2804           (float_extend:V2DF
2805             (vec_select:V2SF
2806               (match_operand:V4SF 2 "nonimmediate_operand" "xm")
2807               (parallel [(const_int 0) (const_int 1)])))
2808           (match_operand:V2DF 1 "register_operand" "x")
2809           (const_int 1)))]
2810   "TARGET_AVX"
2811   "vcvtss2sd\t{%2, %1, %0|%0, %1, %2}"
2812   [(set_attr "type" "ssecvt")
2813    (set_attr "prefix" "vex")
2814    (set_attr "mode" "DF")])
2815
2816 (define_insn "sse2_cvtss2sd"
2817   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2818         (vec_merge:V2DF
2819           (float_extend:V2DF
2820             (vec_select:V2SF
2821               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2822               (parallel [(const_int 0) (const_int 1)])))
2823           (match_operand:V2DF 1 "register_operand" "0,0")
2824           (const_int 1)))]
2825   "TARGET_SSE2"
2826   "cvtss2sd\t{%2, %0|%0, %2}"
2827   [(set_attr "type" "ssecvt")
2828    (set_attr "amdfam10_decode" "vector,double")
2829    (set_attr "bdver1_decode" "direct,direct")
2830    (set_attr "mode" "DF")])
2831
2832 (define_insn "avx_cvtpd2ps256"
2833   [(set (match_operand:V4SF 0 "register_operand" "=x")
2834         (float_truncate:V4SF
2835           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2836   "TARGET_AVX"
2837   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
2838   [(set_attr "type" "ssecvt")
2839    (set_attr "prefix" "vex")
2840    (set_attr "mode" "V4SF")])
2841
2842 (define_expand "sse2_cvtpd2ps"
2843   [(set (match_operand:V4SF 0 "register_operand" "")
2844         (vec_concat:V4SF
2845           (float_truncate:V2SF
2846             (match_operand:V2DF 1 "nonimmediate_operand" ""))
2847           (match_dup 2)))]
2848   "TARGET_SSE2"
2849   "operands[2] = CONST0_RTX (V2SFmode);")
2850
2851 (define_insn "*sse2_cvtpd2ps"
2852   [(set (match_operand:V4SF 0 "register_operand" "=x")
2853         (vec_concat:V4SF
2854           (float_truncate:V2SF
2855             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2856           (match_operand:V2SF 2 "const0_operand" "")))]
2857   "TARGET_SSE2"
2858   "* return TARGET_AVX ? \"vcvtpd2ps{x}\t{%1, %0|%0, %1}\"
2859                        : \"cvtpd2ps\t{%1, %0|%0, %1}\";"
2860   [(set_attr "type" "ssecvt")
2861    (set_attr "prefix_data16" "1")
2862    (set_attr "prefix" "maybe_vex")
2863    (set_attr "mode" "V4SF")
2864    (set_attr "amdfam10_decode" "double")
2865    (set_attr "bdver1_decode" "double")])
2866
2867 (define_insn "avx_cvtps2pd256"
2868   [(set (match_operand:V4DF 0 "register_operand" "=x")
2869         (float_extend:V4DF
2870           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2871   "TARGET_AVX"
2872   "vcvtps2pd\t{%1, %0|%0, %1}"
2873   [(set_attr "type" "ssecvt")
2874    (set_attr "prefix" "vex")
2875    (set_attr "mode" "V4DF")])
2876
2877 (define_insn "*avx_cvtps2pd256_2"
2878   [(set (match_operand:V4DF 0 "register_operand" "=x")
2879         (float_extend:V4DF
2880           (vec_select:V4SF
2881             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
2882             (parallel [(const_int 0) (const_int 1) (const_int 2) (const_int 3)]))))]
2883   "TARGET_AVX"
2884   "vcvtps2pd\t{%x1, %0|%0, %x1}"
2885   [(set_attr "type" "ssecvt")
2886    (set_attr "prefix" "vex")
2887    (set_attr "mode" "V4DF")])
2888
2889 (define_insn "sse2_cvtps2pd"
2890   [(set (match_operand:V2DF 0 "register_operand" "=x")
2891         (float_extend:V2DF
2892           (vec_select:V2SF
2893             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
2894             (parallel [(const_int 0) (const_int 1)]))))]
2895   "TARGET_SSE2"
2896   "%vcvtps2pd\t{%1, %0|%0, %1}"
2897   [(set_attr "type" "ssecvt")
2898    (set_attr "prefix" "maybe_vex")
2899    (set_attr "mode" "V2DF")
2900    (set_attr "prefix_data16" "0")
2901    (set_attr "amdfam10_decode" "direct")
2902    (set_attr "bdver1_decode" "double")])
2903
2904 (define_expand "vec_unpacks_hi_v4sf"
2905   [(set (match_dup 2)
2906    (vec_select:V4SF
2907      (vec_concat:V8SF
2908        (match_dup 2)
2909        (match_operand:V4SF 1 "nonimmediate_operand" ""))
2910      (parallel [(const_int 6)
2911                 (const_int 7)
2912                 (const_int 2)
2913                 (const_int 3)])))
2914   (set (match_operand:V2DF 0 "register_operand" "")
2915    (float_extend:V2DF
2916      (vec_select:V2SF
2917        (match_dup 2)
2918        (parallel [(const_int 0) (const_int 1)]))))]
2919   "TARGET_SSE2"
2920   "operands[2] = gen_reg_rtx (V4SFmode);")
2921
2922 (define_expand "vec_unpacks_hi_v8sf"
2923   [(set (match_dup 2)
2924         (vec_select:V4SF
2925           (match_operand:V8SF 1 "nonimmediate_operand" "")
2926           (parallel [(const_int 4)
2927                      (const_int 5)
2928                      (const_int 6)
2929                      (const_int 7)])))
2930    (set (match_operand:V4DF 0 "register_operand" "")
2931         (float_extend:V4DF
2932           (match_dup 2)))]
2933   "TARGET_AVX"
2934 {
2935   operands[2] = gen_reg_rtx (V4SFmode);
2936 })
2937
2938 (define_expand "vec_unpacks_lo_v4sf"
2939   [(set (match_operand:V2DF 0 "register_operand" "")
2940         (float_extend:V2DF
2941           (vec_select:V2SF
2942             (match_operand:V4SF 1 "nonimmediate_operand" "")
2943             (parallel [(const_int 0) (const_int 1)]))))]
2944   "TARGET_SSE2")
2945
2946 (define_expand "vec_unpacks_lo_v8sf"
2947   [(set (match_operand:V4DF 0 "register_operand" "")
2948         (float_extend:V4DF
2949           (vec_select:V4SF
2950             (match_operand:V8SF 1 "nonimmediate_operand" "")
2951             (parallel [(const_int 0) (const_int 1) (const_int 2) (const_int 3)]))))]
2952   "TARGET_AVX")
2953
2954 (define_expand "vec_unpacks_float_hi_v8hi"
2955   [(match_operand:V4SF 0 "register_operand" "")
2956    (match_operand:V8HI 1 "register_operand" "")]
2957   "TARGET_SSE2"
2958 {
2959   rtx tmp = gen_reg_rtx (V4SImode);
2960
2961   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
2962   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2963   DONE;
2964 })
2965
2966 (define_expand "vec_unpacks_float_lo_v8hi"
2967   [(match_operand:V4SF 0 "register_operand" "")
2968    (match_operand:V8HI 1 "register_operand" "")]
2969   "TARGET_SSE2"
2970 {
2971   rtx tmp = gen_reg_rtx (V4SImode);
2972
2973   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
2974   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2975   DONE;
2976 })
2977
2978 (define_expand "vec_unpacku_float_hi_v8hi"
2979   [(match_operand:V4SF 0 "register_operand" "")
2980    (match_operand:V8HI 1 "register_operand" "")]
2981   "TARGET_SSE2"
2982 {
2983   rtx tmp = gen_reg_rtx (V4SImode);
2984
2985   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
2986   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2987   DONE;
2988 })
2989
2990 (define_expand "vec_unpacku_float_lo_v8hi"
2991   [(match_operand:V4SF 0 "register_operand" "")
2992    (match_operand:V8HI 1 "register_operand" "")]
2993   "TARGET_SSE2"
2994 {
2995   rtx tmp = gen_reg_rtx (V4SImode);
2996
2997   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
2998   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2999   DONE;
3000 })
3001
3002 (define_expand "vec_unpacks_float_hi_v4si"
3003   [(set (match_dup 2)
3004         (vec_select:V4SI
3005           (match_operand:V4SI 1 "nonimmediate_operand" "")
3006           (parallel [(const_int 2)
3007                      (const_int 3)
3008                      (const_int 2)
3009                      (const_int 3)])))
3010    (set (match_operand:V2DF 0 "register_operand" "")
3011         (float:V2DF
3012           (vec_select:V2SI
3013           (match_dup 2)
3014             (parallel [(const_int 0) (const_int 1)]))))]
3015   "TARGET_SSE2"
3016   "operands[2] = gen_reg_rtx (V4SImode);")
3017
3018 (define_expand "vec_unpacks_float_lo_v4si"
3019   [(set (match_operand:V2DF 0 "register_operand" "")
3020         (float:V2DF
3021           (vec_select:V2SI
3022             (match_operand:V4SI 1 "nonimmediate_operand" "")
3023             (parallel [(const_int 0) (const_int 1)]))))]
3024   "TARGET_SSE2")
3025
3026 (define_expand "vec_unpacks_float_hi_v8si"
3027   [(set (match_dup 2)
3028         (vec_select:V4SI
3029           (match_operand:V8SI 1 "nonimmediate_operand" "")
3030           (parallel [(const_int 4)
3031                      (const_int 5)
3032                      (const_int 6)
3033                      (const_int 7)])))
3034    (set (match_operand:V4DF 0 "register_operand" "")
3035         (float:V4DF
3036           (match_dup 2)))]
3037   "TARGET_AVX"
3038   "operands[2] = gen_reg_rtx (V4SImode);")
3039
3040 (define_expand "vec_unpacks_float_lo_v8si"
3041   [(set (match_operand:V4DF 0 "register_operand" "")
3042         (float:V4DF
3043           (vec_select:V4SI
3044             (match_operand:V8SI 1 "nonimmediate_operand" "")
3045             (parallel [(const_int 0) (const_int 1) (const_int 2) (const_int 3)]))))]
3046   "TARGET_AVX")
3047
3048 (define_expand "vec_unpacku_float_hi_v4si"
3049   [(set (match_dup 5)
3050         (vec_select:V4SI
3051           (match_operand:V4SI 1 "nonimmediate_operand" "")
3052           (parallel [(const_int 2)
3053                      (const_int 3)
3054                      (const_int 2)
3055                      (const_int 3)])))
3056    (set (match_dup 6)
3057         (float:V2DF
3058           (vec_select:V2SI
3059           (match_dup 5)
3060             (parallel [(const_int 0) (const_int 1)]))))
3061    (set (match_dup 7)
3062         (lt:V2DF (match_dup 6) (match_dup 3)))
3063    (set (match_dup 8)
3064         (and:V2DF (match_dup 7) (match_dup 4)))
3065    (set (match_operand:V2DF 0 "register_operand" "")
3066         (plus:V2DF (match_dup 6) (match_dup 8)))]
3067   "TARGET_SSE2"
3068 {
3069   REAL_VALUE_TYPE TWO32r;
3070   rtx x;
3071   int i;
3072
3073   real_ldexp (&TWO32r, &dconst1, 32);
3074   x = const_double_from_real_value (TWO32r, DFmode);
3075
3076   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3077   operands[4] = force_reg (V2DFmode,
3078                            ix86_build_const_vector (V2DFmode, 1, x));
3079
3080   operands[5] = gen_reg_rtx (V4SImode);
3081
3082   for (i = 6; i < 9; i++)
3083     operands[i] = gen_reg_rtx (V2DFmode);
3084 })
3085
3086 (define_expand "vec_unpacku_float_lo_v4si"
3087   [(set (match_dup 5)
3088         (float:V2DF
3089           (vec_select:V2SI
3090             (match_operand:V4SI 1 "nonimmediate_operand" "")
3091             (parallel [(const_int 0) (const_int 1)]))))
3092    (set (match_dup 6)
3093         (lt:V2DF (match_dup 5) (match_dup 3)))
3094    (set (match_dup 7)
3095         (and:V2DF (match_dup 6) (match_dup 4)))
3096    (set (match_operand:V2DF 0 "register_operand" "")
3097         (plus:V2DF (match_dup 5) (match_dup 7)))]
3098   "TARGET_SSE2"
3099 {
3100   REAL_VALUE_TYPE TWO32r;
3101   rtx x;
3102   int i;
3103
3104   real_ldexp (&TWO32r, &dconst1, 32);
3105   x = const_double_from_real_value (TWO32r, DFmode);
3106
3107   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3108   operands[4] = force_reg (V2DFmode,
3109                            ix86_build_const_vector (V2DFmode, 1, x));
3110
3111   for (i = 5; i < 8; i++)
3112     operands[i] = gen_reg_rtx (V2DFmode);
3113 })
3114
3115 (define_expand "vec_pack_trunc_v4df"
3116   [(set (match_dup 3)
3117         (float_truncate:V4SF
3118           (match_operand:V4DF 1 "nonimmediate_operand" "")))
3119    (set (match_dup 4)
3120         (float_truncate:V4SF
3121           (match_operand:V4DF 2 "nonimmediate_operand" "")))
3122    (set (match_operand:V8SF 0 "register_operand" "")
3123         (vec_concat:V8SF
3124           (match_dup 3)
3125           (match_dup 4)))]
3126   "TARGET_AVX"
3127 {
3128   operands[3] = gen_reg_rtx (V4SFmode);
3129   operands[4] = gen_reg_rtx (V4SFmode);
3130 })
3131
3132 (define_expand "vec_pack_trunc_v2df"
3133   [(match_operand:V4SF 0 "register_operand" "")
3134    (match_operand:V2DF 1 "nonimmediate_operand" "")
3135    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3136   "TARGET_SSE2"
3137 {
3138   rtx r1, r2;
3139
3140   r1 = gen_reg_rtx (V4SFmode);
3141   r2 = gen_reg_rtx (V4SFmode);
3142
3143   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
3144   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
3145   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
3146   DONE;
3147 })
3148
3149 (define_expand "vec_pack_sfix_trunc_v2df"
3150   [(match_operand:V4SI 0 "register_operand" "")
3151    (match_operand:V2DF 1 "nonimmediate_operand" "")
3152    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3153   "TARGET_SSE2"
3154 {
3155   rtx r1, r2;
3156
3157   r1 = gen_reg_rtx (V4SImode);
3158   r2 = gen_reg_rtx (V4SImode);
3159
3160   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
3161   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
3162   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3163                                          gen_lowpart (V2DImode, r1),
3164                                          gen_lowpart (V2DImode, r2)));
3165   DONE;
3166 })
3167
3168 (define_expand "vec_pack_sfix_v2df"
3169   [(match_operand:V4SI 0 "register_operand" "")
3170    (match_operand:V2DF 1 "nonimmediate_operand" "")
3171    (match_operand:V2DF 2 "nonimmediate_operand" "")]
3172   "TARGET_SSE2"
3173 {
3174   rtx r1, r2;
3175
3176   r1 = gen_reg_rtx (V4SImode);
3177   r2 = gen_reg_rtx (V4SImode);
3178
3179   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
3180   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
3181   emit_insn (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3182                                          gen_lowpart (V2DImode, r1),
3183                                          gen_lowpart (V2DImode, r2)));
3184   DONE;
3185 })
3186
3187 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3188 ;;
3189 ;; Parallel single-precision floating point element swizzling
3190 ;;
3191 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3192
3193 (define_expand "sse_movhlps_exp"
3194   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3195         (vec_select:V4SF
3196           (vec_concat:V8SF
3197             (match_operand:V4SF 1 "nonimmediate_operand" "")
3198             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3199           (parallel [(const_int 6)
3200                      (const_int 7)
3201                      (const_int 2)
3202                      (const_int 3)])))]
3203   "TARGET_SSE"
3204   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3205
3206 (define_insn "*avx_movhlps"
3207   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3208         (vec_select:V4SF
3209           (vec_concat:V8SF
3210             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3211             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3212           (parallel [(const_int 6)
3213                      (const_int 7)
3214                      (const_int 2)
3215                      (const_int 3)])))]
3216   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3217   "@
3218    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3219    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3220    vmovhps\t{%2, %0|%0, %2}"
3221   [(set_attr "type" "ssemov")
3222    (set_attr "prefix" "vex")
3223    (set_attr "mode" "V4SF,V2SF,V2SF")])
3224
3225 (define_insn "sse_movhlps"
3226   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
3227         (vec_select:V4SF
3228           (vec_concat:V8SF
3229             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3230             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
3231           (parallel [(const_int 6)
3232                      (const_int 7)
3233                      (const_int 2)
3234                      (const_int 3)])))]
3235   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3236   "@
3237    movhlps\t{%2, %0|%0, %2}
3238    movlps\t{%H2, %0|%0, %H2}
3239    movhps\t{%2, %0|%0, %2}"
3240   [(set_attr "type" "ssemov")
3241    (set_attr "mode" "V4SF,V2SF,V2SF")])
3242
3243 (define_expand "sse_movlhps_exp"
3244   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3245         (vec_select:V4SF
3246           (vec_concat:V8SF
3247             (match_operand:V4SF 1 "nonimmediate_operand" "")
3248             (match_operand:V4SF 2 "nonimmediate_operand" ""))
3249           (parallel [(const_int 0)
3250                      (const_int 1)
3251                      (const_int 4)
3252                      (const_int 5)])))]
3253   "TARGET_SSE"
3254   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3255
3256 (define_insn "*avx_movlhps"
3257   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3258         (vec_select:V4SF
3259           (vec_concat:V8SF
3260             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0")
3261             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3262           (parallel [(const_int 0)
3263                      (const_int 1)
3264                      (const_int 4)
3265                      (const_int 5)])))]
3266   "TARGET_AVX && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3267   "@
3268    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3269    vmovhps\t{%2, %1, %0|%0, %1, %2}
3270    vmovlps\t{%2, %H0|%H0, %2}"
3271   [(set_attr "type" "ssemov")
3272    (set_attr "prefix" "vex")
3273    (set_attr "mode" "V4SF,V2SF,V2SF")])
3274
3275 (define_insn "sse_movlhps"
3276   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
3277         (vec_select:V4SF
3278           (vec_concat:V8SF
3279             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
3280             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
3281           (parallel [(const_int 0)
3282                      (const_int 1)
3283                      (const_int 4)
3284                      (const_int 5)])))]
3285   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3286   "@
3287    movlhps\t{%2, %0|%0, %2}
3288    movhps\t{%2, %0|%0, %2}
3289    movlps\t{%2, %H0|%H0, %2}"
3290   [(set_attr "type" "ssemov")
3291    (set_attr "mode" "V4SF,V2SF,V2SF")])
3292
3293 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3294 (define_insn "avx_unpckhps256"
3295   [(set (match_operand:V8SF 0 "register_operand" "=x")
3296         (vec_select:V8SF
3297           (vec_concat:V16SF
3298             (match_operand:V8SF 1 "register_operand" "x")
3299             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3300           (parallel [(const_int 2) (const_int 10)
3301                      (const_int 3) (const_int 11)
3302                      (const_int 6) (const_int 14)
3303                      (const_int 7) (const_int 15)])))]
3304   "TARGET_AVX"
3305   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3306   [(set_attr "type" "sselog")
3307    (set_attr "prefix" "vex")
3308    (set_attr "mode" "V8SF")])
3309
3310 (define_insn "*avx_interleave_highv4sf"
3311   [(set (match_operand:V4SF 0 "register_operand" "=x")
3312         (vec_select:V4SF
3313           (vec_concat:V8SF
3314             (match_operand:V4SF 1 "register_operand" "x")
3315             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3316           (parallel [(const_int 2) (const_int 6)
3317                      (const_int 3) (const_int 7)])))]
3318   "TARGET_AVX"
3319   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3320   [(set_attr "type" "sselog")
3321    (set_attr "prefix" "vex")
3322    (set_attr "mode" "V4SF")])
3323
3324 (define_expand "vec_interleave_highv8sf"
3325   [(set (match_dup 3)
3326         (vec_select:V8SF
3327           (vec_concat:V16SF
3328             (match_operand:V8SF 1 "register_operand" "x")
3329             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3330           (parallel [(const_int 0) (const_int 8)
3331                      (const_int 1) (const_int 9)
3332                      (const_int 4) (const_int 12)
3333                      (const_int 5) (const_int 13)])))
3334    (set (match_dup 4)
3335         (vec_select:V8SF
3336           (vec_concat:V16SF
3337             (match_dup 1)
3338             (match_dup 2))
3339           (parallel [(const_int 2) (const_int 10)
3340                      (const_int 3) (const_int 11)
3341                      (const_int 6) (const_int 14)
3342                      (const_int 7) (const_int 15)])))
3343    (set (match_operand:V8SF 0 "register_operand" "")
3344         (vec_select:V8SF
3345           (vec_concat:V16SF
3346             (match_dup 3)
3347             (match_dup 4))
3348           (parallel [(const_int 4) (const_int 5)
3349                      (const_int 6) (const_int 7)
3350                      (const_int 12) (const_int 13)
3351                      (const_int 14) (const_int 15)])))]
3352  "TARGET_AVX"
3353 {
3354   operands[3] = gen_reg_rtx (V8SFmode);
3355   operands[4] = gen_reg_rtx (V8SFmode);
3356 })
3357
3358 (define_insn "vec_interleave_highv4sf"
3359   [(set (match_operand:V4SF 0 "register_operand" "=x")
3360         (vec_select:V4SF
3361           (vec_concat:V8SF
3362             (match_operand:V4SF 1 "register_operand" "0")
3363             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3364           (parallel [(const_int 2) (const_int 6)
3365                      (const_int 3) (const_int 7)])))]
3366   "TARGET_SSE"
3367   "unpckhps\t{%2, %0|%0, %2}"
3368   [(set_attr "type" "sselog")
3369    (set_attr "mode" "V4SF")])
3370
3371 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3372 (define_insn "avx_unpcklps256"
3373   [(set (match_operand:V8SF 0 "register_operand" "=x")
3374         (vec_select:V8SF
3375           (vec_concat:V16SF
3376             (match_operand:V8SF 1 "register_operand" "x")
3377             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3378           (parallel [(const_int 0) (const_int 8)
3379                      (const_int 1) (const_int 9)
3380                      (const_int 4) (const_int 12)
3381                      (const_int 5) (const_int 13)])))]
3382   "TARGET_AVX"
3383   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3384   [(set_attr "type" "sselog")
3385    (set_attr "prefix" "vex")
3386    (set_attr "mode" "V8SF")])
3387
3388 (define_insn "*avx_interleave_lowv4sf"
3389   [(set (match_operand:V4SF 0 "register_operand" "=x")
3390         (vec_select:V4SF
3391           (vec_concat:V8SF
3392             (match_operand:V4SF 1 "register_operand" "x")
3393             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3394           (parallel [(const_int 0) (const_int 4)
3395                      (const_int 1) (const_int 5)])))]
3396   "TARGET_AVX"
3397   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3398   [(set_attr "type" "sselog")
3399    (set_attr "prefix" "vex")
3400    (set_attr "mode" "V4SF")])
3401
3402 (define_expand "vec_interleave_lowv8sf"
3403   [(set (match_dup 3)
3404         (vec_select:V8SF
3405           (vec_concat:V16SF
3406             (match_operand:V8SF 1 "register_operand" "x")
3407             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3408           (parallel [(const_int 0) (const_int 8)
3409                      (const_int 1) (const_int 9)
3410                      (const_int 4) (const_int 12)
3411                      (const_int 5) (const_int 13)])))
3412    (set (match_dup 4)
3413         (vec_select:V8SF
3414           (vec_concat:V16SF
3415             (match_dup 1)
3416             (match_dup 2))
3417           (parallel [(const_int 2) (const_int 10)
3418                      (const_int 3) (const_int 11)
3419                      (const_int 6) (const_int 14)
3420                      (const_int 7) (const_int 15)])))
3421    (set (match_operand:V8SF 0 "register_operand" "")
3422         (vec_select:V8SF
3423           (vec_concat:V16SF
3424             (match_dup 3)
3425             (match_dup 4))
3426           (parallel [(const_int 0) (const_int 1)
3427                      (const_int 2) (const_int 3)
3428                      (const_int 8) (const_int 9)
3429                      (const_int 10) (const_int 11)])))]
3430  "TARGET_AVX"
3431 {
3432   operands[3] = gen_reg_rtx (V8SFmode);
3433   operands[4] = gen_reg_rtx (V8SFmode);
3434 })
3435
3436 (define_insn "vec_interleave_lowv4sf"
3437   [(set (match_operand:V4SF 0 "register_operand" "=x")
3438         (vec_select:V4SF
3439           (vec_concat:V8SF
3440             (match_operand:V4SF 1 "register_operand" "0")
3441             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
3442           (parallel [(const_int 0) (const_int 4)
3443                      (const_int 1) (const_int 5)])))]
3444   "TARGET_SSE"
3445   "unpcklps\t{%2, %0|%0, %2}"
3446   [(set_attr "type" "sselog")
3447    (set_attr "mode" "V4SF")])
3448
3449 ;; These are modeled with the same vec_concat as the others so that we
3450 ;; capture users of shufps that can use the new instructions
3451 (define_insn "avx_movshdup256"
3452   [(set (match_operand:V8SF 0 "register_operand" "=x")
3453         (vec_select:V8SF
3454           (vec_concat:V16SF
3455             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3456             (match_dup 1))
3457           (parallel [(const_int 1) (const_int 1)
3458                      (const_int 3) (const_int 3)
3459                      (const_int 5) (const_int 5)
3460                      (const_int 7) (const_int 7)])))]
3461   "TARGET_AVX"
3462   "vmovshdup\t{%1, %0|%0, %1}"
3463   [(set_attr "type" "sse")
3464    (set_attr "prefix" "vex")
3465    (set_attr "mode" "V8SF")])
3466
3467 (define_insn "sse3_movshdup"
3468   [(set (match_operand:V4SF 0 "register_operand" "=x")
3469         (vec_select:V4SF
3470           (vec_concat:V8SF
3471             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3472             (match_dup 1))
3473           (parallel [(const_int 1)
3474                      (const_int 1)
3475                      (const_int 7)
3476                      (const_int 7)])))]
3477   "TARGET_SSE3"
3478   "%vmovshdup\t{%1, %0|%0, %1}"
3479   [(set_attr "type" "sse")
3480    (set_attr "prefix_rep" "1")
3481    (set_attr "prefix" "maybe_vex")
3482    (set_attr "mode" "V4SF")])
3483
3484 (define_insn "avx_movsldup256"
3485   [(set (match_operand:V8SF 0 "register_operand" "=x")
3486         (vec_select:V8SF
3487           (vec_concat:V16SF
3488             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3489             (match_dup 1))
3490           (parallel [(const_int 0) (const_int 0)
3491                      (const_int 2) (const_int 2)
3492                      (const_int 4) (const_int 4)
3493                      (const_int 6) (const_int 6)])))]
3494   "TARGET_AVX"
3495   "vmovsldup\t{%1, %0|%0, %1}"
3496   [(set_attr "type" "sse")
3497    (set_attr "prefix" "vex")
3498    (set_attr "mode" "V8SF")])
3499
3500 (define_insn "sse3_movsldup"
3501   [(set (match_operand:V4SF 0 "register_operand" "=x")
3502         (vec_select:V4SF
3503           (vec_concat:V8SF
3504             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3505             (match_dup 1))
3506           (parallel [(const_int 0)
3507                      (const_int 0)
3508                      (const_int 6)
3509                      (const_int 6)])))]
3510   "TARGET_SSE3"
3511   "%vmovsldup\t{%1, %0|%0, %1}"
3512   [(set_attr "type" "sse")
3513    (set_attr "prefix_rep" "1")
3514    (set_attr "prefix" "maybe_vex")
3515    (set_attr "mode" "V4SF")])
3516
3517 (define_expand "avx_shufps256"
3518   [(match_operand:V8SF 0 "register_operand" "")
3519    (match_operand:V8SF 1 "register_operand" "")
3520    (match_operand:V8SF 2 "nonimmediate_operand" "")
3521    (match_operand:SI 3 "const_int_operand" "")]
3522   "TARGET_AVX"
3523 {
3524   int mask = INTVAL (operands[3]);
3525   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3526                                   GEN_INT ((mask >> 0) & 3),
3527                                   GEN_INT ((mask >> 2) & 3),
3528                                   GEN_INT (((mask >> 4) & 3) + 8),
3529                                   GEN_INT (((mask >> 6) & 3) + 8),
3530                                   GEN_INT (((mask >> 0) & 3) + 4),
3531                                   GEN_INT (((mask >> 2) & 3) + 4),
3532                                   GEN_INT (((mask >> 4) & 3) + 12),
3533                                   GEN_INT (((mask >> 6) & 3) + 12)));
3534   DONE;
3535 })
3536
3537 ;; One bit in mask selects 2 elements.
3538 (define_insn "avx_shufps256_1"
3539   [(set (match_operand:V8SF 0 "register_operand" "=x")
3540         (vec_select:V8SF
3541           (vec_concat:V16SF
3542             (match_operand:V8SF 1 "register_operand" "x")
3543             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3544           (parallel [(match_operand 3  "const_0_to_3_operand"   "")
3545                      (match_operand 4  "const_0_to_3_operand"   "")
3546                      (match_operand 5  "const_8_to_11_operand"  "")
3547                      (match_operand 6  "const_8_to_11_operand"  "")
3548                      (match_operand 7  "const_4_to_7_operand"   "")
3549                      (match_operand 8  "const_4_to_7_operand"   "")
3550                      (match_operand 9  "const_12_to_15_operand" "")
3551                      (match_operand 10 "const_12_to_15_operand" "")])))]
3552   "TARGET_AVX
3553    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3554        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3555        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3556        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3557 {
3558   int mask;
3559   mask = INTVAL (operands[3]);
3560   mask |= INTVAL (operands[4]) << 2;
3561   mask |= (INTVAL (operands[5]) - 8) << 4;
3562   mask |= (INTVAL (operands[6]) - 8) << 6;
3563   operands[3] = GEN_INT (mask);
3564
3565   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3566 }
3567   [(set_attr "type" "sselog")
3568    (set_attr "length_immediate" "1")
3569    (set_attr "prefix" "vex")
3570    (set_attr "mode" "V8SF")])
3571
3572 (define_expand "sse_shufps"
3573   [(match_operand:V4SF 0 "register_operand" "")
3574    (match_operand:V4SF 1 "register_operand" "")
3575    (match_operand:V4SF 2 "nonimmediate_operand" "")
3576    (match_operand:SI 3 "const_int_operand" "")]
3577   "TARGET_SSE"
3578 {
3579   int mask = INTVAL (operands[3]);
3580   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3581                                GEN_INT ((mask >> 0) & 3),
3582                                GEN_INT ((mask >> 2) & 3),
3583                                GEN_INT (((mask >> 4) & 3) + 4),
3584                                GEN_INT (((mask >> 6) & 3) + 4)));
3585   DONE;
3586 })
3587
3588 (define_insn "*avx_shufps_<mode>"
3589   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3590         (vec_select:SSEMODE4S
3591           (vec_concat:<ssedoublesizemode>
3592             (match_operand:SSEMODE4S 1 "register_operand" "x")
3593             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3594           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3595                      (match_operand 4 "const_0_to_3_operand" "")
3596                      (match_operand 5 "const_4_to_7_operand" "")
3597                      (match_operand 6 "const_4_to_7_operand" "")])))]
3598   "TARGET_AVX"
3599 {
3600   int mask = 0;
3601   mask |= INTVAL (operands[3]) << 0;
3602   mask |= INTVAL (operands[4]) << 2;
3603   mask |= (INTVAL (operands[5]) - 4) << 4;
3604   mask |= (INTVAL (operands[6]) - 4) << 6;
3605   operands[3] = GEN_INT (mask);
3606
3607   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3608 }
3609   [(set_attr "type" "sselog")
3610    (set_attr "length_immediate" "1")
3611    (set_attr "prefix" "vex")
3612    (set_attr "mode" "V4SF")])
3613
3614 (define_insn "sse_shufps_<mode>"
3615   [(set (match_operand:SSEMODE4S 0 "register_operand" "=x")
3616         (vec_select:SSEMODE4S
3617           (vec_concat:<ssedoublesizemode>
3618             (match_operand:SSEMODE4S 1 "register_operand" "0")
3619             (match_operand:SSEMODE4S 2 "nonimmediate_operand" "xm"))
3620           (parallel [(match_operand 3 "const_0_to_3_operand" "")
3621                      (match_operand 4 "const_0_to_3_operand" "")
3622                      (match_operand 5 "const_4_to_7_operand" "")
3623                      (match_operand 6 "const_4_to_7_operand" "")])))]
3624   "TARGET_SSE"
3625 {
3626   int mask = 0;
3627   mask |= INTVAL (operands[3]) << 0;
3628   mask |= INTVAL (operands[4]) << 2;
3629   mask |= (INTVAL (operands[5]) - 4) << 4;
3630   mask |= (INTVAL (operands[6]) - 4) << 6;
3631   operands[3] = GEN_INT (mask);
3632
3633   return "shufps\t{%3, %2, %0|%0, %2, %3}";
3634 }
3635   [(set_attr "type" "sselog")
3636    (set_attr "length_immediate" "1")
3637    (set_attr "mode" "V4SF")])
3638
3639 (define_insn "sse_storehps"
3640   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3641         (vec_select:V2SF
3642           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3643           (parallel [(const_int 2) (const_int 3)])))]
3644   "TARGET_SSE"
3645   "@
3646    %vmovhps\t{%1, %0|%0, %1}
3647    %vmovhlps\t{%1, %d0|%d0, %1}
3648    %vmovlps\t{%H1, %d0|%d0, %H1}"
3649   [(set_attr "type" "ssemov")
3650    (set_attr "prefix" "maybe_vex")
3651    (set_attr "mode" "V2SF,V4SF,V2SF")])
3652
3653 (define_expand "sse_loadhps_exp"
3654   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3655         (vec_concat:V4SF
3656           (vec_select:V2SF
3657             (match_operand:V4SF 1 "nonimmediate_operand" "")
3658             (parallel [(const_int 0) (const_int 1)]))
3659           (match_operand:V2SF 2 "nonimmediate_operand" "")))]
3660   "TARGET_SSE"
3661   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3662
3663 (define_insn "*avx_loadhps"
3664   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3665         (vec_concat:V4SF
3666           (vec_select:V2SF
3667             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3668             (parallel [(const_int 0) (const_int 1)]))
3669           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3670   "TARGET_AVX"
3671   "@
3672    vmovhps\t{%2, %1, %0|%0, %1, %2}
3673    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3674    vmovlps\t{%2, %H0|%H0, %2}"
3675   [(set_attr "type" "ssemov")
3676    (set_attr "prefix" "vex")
3677    (set_attr "mode" "V2SF,V4SF,V2SF")])
3678
3679 (define_insn "sse_loadhps"
3680   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
3681         (vec_concat:V4SF
3682           (vec_select:V2SF
3683             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
3684             (parallel [(const_int 0) (const_int 1)]))
3685           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
3686   "TARGET_SSE"
3687   "@
3688    movhps\t{%2, %0|%0, %2}
3689    movlhps\t{%2, %0|%0, %2}
3690    movlps\t{%2, %H0|%H0, %2}"
3691   [(set_attr "type" "ssemov")
3692    (set_attr "mode" "V2SF,V4SF,V2SF")])
3693
3694 (define_insn "*avx_storelps"
3695   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3696         (vec_select:V2SF
3697           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3698           (parallel [(const_int 0) (const_int 1)])))]
3699   "TARGET_AVX"
3700   "@
3701    vmovlps\t{%1, %0|%0, %1}
3702    vmovaps\t{%1, %0|%0, %1}
3703    vmovlps\t{%1, %0, %0|%0, %0, %1}"
3704   [(set_attr "type" "ssemov")
3705    (set_attr "prefix" "vex")
3706    (set_attr "mode" "V2SF,V2DF,V2SF")])
3707
3708 (define_insn "sse_storelps"
3709   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3710         (vec_select:V2SF
3711           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
3712           (parallel [(const_int 0) (const_int 1)])))]
3713   "TARGET_SSE"
3714   "@
3715    movlps\t{%1, %0|%0, %1}
3716    movaps\t{%1, %0|%0, %1}
3717    movlps\t{%1, %0|%0, %1}"
3718   [(set_attr "type" "ssemov")
3719    (set_attr "mode" "V2SF,V4SF,V2SF")])
3720
3721 (define_expand "sse_loadlps_exp"
3722   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
3723         (vec_concat:V4SF
3724           (match_operand:V2SF 2 "nonimmediate_operand" "")
3725           (vec_select:V2SF
3726             (match_operand:V4SF 1 "nonimmediate_operand" "")
3727             (parallel [(const_int 2) (const_int 3)]))))]
3728   "TARGET_SSE"
3729   "ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);")
3730
3731 (define_insn "*avx_loadlps"
3732   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3733         (vec_concat:V4SF
3734           (match_operand:V2SF 2 "nonimmediate_operand" "x,m,x")
3735           (vec_select:V2SF
3736             (match_operand:V4SF 1 "nonimmediate_operand" "x,x,0")
3737             (parallel [(const_int 2) (const_int 3)]))))]
3738   "TARGET_AVX"
3739   "@
3740    shufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
3741    vmovlps\t{%2, %1, %0|%0, %1, %2}
3742    vmovlps\t{%2, %0|%0, %2}"
3743   [(set_attr "type" "sselog,ssemov,ssemov")
3744    (set_attr "length_immediate" "1,*,*")
3745    (set_attr "prefix" "vex")
3746    (set_attr "mode" "V4SF,V2SF,V2SF")])
3747
3748 (define_insn "sse_loadlps"
3749   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
3750         (vec_concat:V4SF
3751           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
3752           (vec_select:V2SF
3753             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
3754             (parallel [(const_int 2) (const_int 3)]))))]
3755   "TARGET_SSE"
3756   "@
3757    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
3758    movlps\t{%2, %0|%0, %2}
3759    movlps\t{%2, %0|%0, %2}"
3760   [(set_attr "type" "sselog,ssemov,ssemov")
3761    (set_attr "length_immediate" "1,*,*")
3762    (set_attr "mode" "V4SF,V2SF,V2SF")])
3763
3764 (define_insn "*avx_movss"
3765   [(set (match_operand:V4SF 0 "register_operand" "=x")
3766         (vec_merge:V4SF
3767           (match_operand:V4SF 2 "register_operand" "x")
3768           (match_operand:V4SF 1 "register_operand" "x")
3769           (const_int 1)))]
3770   "TARGET_AVX"
3771   "vmovss\t{%2, %1, %0|%0, %1, %2}"
3772   [(set_attr "type" "ssemov")
3773    (set_attr "prefix" "vex")
3774    (set_attr "mode" "SF")])
3775
3776 (define_insn "sse_movss"
3777   [(set (match_operand:V4SF 0 "register_operand" "=x")
3778         (vec_merge:V4SF
3779           (match_operand:V4SF 2 "register_operand" "x")
3780           (match_operand:V4SF 1 "register_operand" "0")
3781           (const_int 1)))]
3782   "TARGET_SSE"
3783   "movss\t{%2, %0|%0, %2}"
3784   [(set_attr "type" "ssemov")
3785    (set_attr "mode" "SF")])
3786
3787 (define_expand "vec_dupv4sf"
3788   [(set (match_operand:V4SF 0 "register_operand" "")
3789         (vec_duplicate:V4SF
3790           (match_operand:SF 1 "nonimmediate_operand" "")))]
3791   "TARGET_SSE"
3792 {
3793   if (!TARGET_AVX)
3794     operands[1] = force_reg (V4SFmode, operands[1]);
3795 })
3796
3797 (define_insn "*vec_dupv4sf_avx"
3798   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3799         (vec_duplicate:V4SF
3800           (match_operand:SF 1 "nonimmediate_operand" "x,m")))]
3801   "TARGET_AVX"
3802   "@
3803    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
3804    vbroadcastss\t{%1, %0|%0, %1}"
3805   [(set_attr "type" "sselog1,ssemov")
3806    (set_attr "length_immediate" "1,0")
3807    (set_attr "prefix_extra" "0,1")
3808    (set_attr "prefix" "vex")
3809    (set_attr "mode" "V4SF")])
3810
3811 (define_insn "*vec_dupv4sf"
3812   [(set (match_operand:V4SF 0 "register_operand" "=x")
3813         (vec_duplicate:V4SF
3814           (match_operand:SF 1 "register_operand" "0")))]
3815   "TARGET_SSE"
3816   "shufps\t{$0, %0, %0|%0, %0, 0}"
3817   [(set_attr "type" "sselog1")
3818    (set_attr "length_immediate" "1")
3819    (set_attr "mode" "V4SF")])
3820
3821 (define_insn "*vec_concatv2sf_avx"
3822   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3823         (vec_concat:V2SF
3824           (match_operand:SF 1 "nonimmediate_operand" " x,x,m, x , m")
3825           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3826   "TARGET_AVX"
3827   "@
3828    vunpcklps\t{%2, %1, %0|%0, %1, %2}
3829    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
3830    vmovss\t{%1, %0|%0, %1}
3831    punpckldq\t{%2, %0|%0, %2}
3832    movd\t{%1, %0|%0, %1}"
3833   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3834    (set_attr "length_immediate" "*,1,*,*,*")
3835    (set_attr "prefix_extra" "*,1,*,*,*")
3836    (set (attr "prefix")
3837      (if_then_else (eq_attr "alternative" "3,4")
3838        (const_string "orig")
3839        (const_string "vex")))
3840    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3841
3842 ;; Although insertps takes register source, we prefer
3843 ;; unpcklps with register source since it is shorter.
3844 (define_insn "*vec_concatv2sf_sse4_1"
3845   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,*y ,*y")
3846         (vec_concat:V2SF
3847           (match_operand:SF 1 "nonimmediate_operand" " 0,0,m, 0 , m")
3848           (match_operand:SF 2 "vector_move_operand"  " x,m,C,*ym, C")))]
3849   "TARGET_SSE4_1"
3850   "@
3851    unpcklps\t{%2, %0|%0, %2}
3852    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
3853    movss\t{%1, %0|%0, %1}
3854    punpckldq\t{%2, %0|%0, %2}
3855    movd\t{%1, %0|%0, %1}"
3856   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
3857    (set_attr "prefix_data16" "*,1,*,*,*")
3858    (set_attr "prefix_extra" "*,1,*,*,*")
3859    (set_attr "length_immediate" "*,1,*,*,*")
3860    (set_attr "mode" "V4SF,V4SF,SF,DI,DI")])
3861
3862 ;; ??? In theory we can match memory for the MMX alternative, but allowing
3863 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
3864 ;; alternatives pretty much forces the MMX alternative to be chosen.
3865 (define_insn "*vec_concatv2sf_sse"
3866   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
3867         (vec_concat:V2SF
3868           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
3869           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
3870   "TARGET_SSE"
3871   "@
3872    unpcklps\t{%2, %0|%0, %2}
3873    movss\t{%1, %0|%0, %1}
3874    punpckldq\t{%2, %0|%0, %2}
3875    movd\t{%1, %0|%0, %1}"
3876   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
3877    (set_attr "mode" "V4SF,SF,DI,DI")])
3878
3879 (define_insn "*vec_concatv4sf_avx"
3880   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3881         (vec_concat:V4SF
3882           (match_operand:V2SF 1 "register_operand" " x,x")
3883           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3884   "TARGET_AVX"
3885   "@
3886    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3887    vmovhps\t{%2, %1, %0|%0, %1, %2}"
3888   [(set_attr "type" "ssemov")
3889    (set_attr "prefix" "vex")
3890    (set_attr "mode" "V4SF,V2SF")])
3891
3892 (define_insn "*vec_concatv4sf_sse"
3893   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
3894         (vec_concat:V4SF
3895           (match_operand:V2SF 1 "register_operand" " 0,0")
3896           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
3897   "TARGET_SSE"
3898   "@
3899    movlhps\t{%2, %0|%0, %2}
3900    movhps\t{%2, %0|%0, %2}"
3901   [(set_attr "type" "ssemov")
3902    (set_attr "mode" "V4SF,V2SF")])
3903
3904 (define_expand "vec_init<mode>"
3905   [(match_operand:SSEMODE 0 "register_operand" "")
3906    (match_operand 1 "" "")]
3907   "TARGET_SSE"
3908 {
3909   ix86_expand_vector_init (false, operands[0], operands[1]);
3910   DONE;
3911 })
3912
3913 (define_insn "*vec_set<mode>_0_avx"
3914   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3915         (vec_merge:SSEMODE4S
3916           (vec_duplicate:SSEMODE4S
3917             (match_operand:<ssescalarmode> 2
3918               "general_operand"                            " x,m,*r,x,*rm,x*rfF"))
3919           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,x,  x,0")
3920           (const_int 1)))]
3921   "TARGET_AVX"
3922   "@
3923    vinsertps\t{$0xe, %2, %2, %0|%0, %2, %2, 0xe}
3924    vmov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
3925    vmovd\t{%2, %0|%0, %2}
3926    vmovss\t{%2, %1, %0|%0, %1, %2}
3927    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
3928    #"
3929   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
3930    (set_attr "prefix_extra" "*,*,*,*,1,*")
3931    (set_attr "length_immediate" "*,*,*,*,1,*")
3932    (set_attr "prefix" "vex")
3933    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
3934
3935 (define_insn "*vec_set<mode>_0_sse4_1"
3936   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x, x,x,  x,m")
3937         (vec_merge:SSEMODE4S
3938           (vec_duplicate:SSEMODE4S
3939             (match_operand:<ssescalarmode> 2
3940               "general_operand"                            " x,m,*r,x,*rm,*rfF"))
3941           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,C, C,0,  0,0")
3942           (const_int 1)))]
3943   "TARGET_SSE4_1"
3944   "@
3945    insertps\t{$0xe, %2, %0|%0, %2, 0xe}
3946    mov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
3947    movd\t{%2, %0|%0, %2}
3948    movss\t{%2, %0|%0, %2}
3949    pinsrd\t{$0, %2, %0|%0, %2, 0}
3950    #"
3951   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,*")
3952    (set_attr "prefix_extra" "*,*,*,*,1,*")
3953    (set_attr "length_immediate" "*,*,*,*,1,*")
3954    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,TI,*")])
3955
3956 (define_insn "*vec_set<mode>_0_sse2"
3957   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x, x,x,m")
3958         (vec_merge:SSEMODE4S
3959           (vec_duplicate:SSEMODE4S
3960             (match_operand:<ssescalarmode> 2
3961               "general_operand"                            " m,*r,x,x*rfF"))
3962           (match_operand:SSEMODE4S 1 "vector_move_operand" " C, C,0,0")
3963           (const_int 1)))]
3964   "TARGET_SSE2"
3965   "@
3966    mov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
3967    movd\t{%2, %0|%0, %2}
3968    movss\t{%2, %0|%0, %2}
3969    #"
3970   [(set_attr "type" "ssemov")
3971    (set_attr "mode" "<ssescalarmode>,SI,SF,*")])
3972
3973 (define_insn "vec_set<mode>_0"
3974   [(set (match_operand:SSEMODE4S 0 "nonimmediate_operand"  "=x,x,m")
3975         (vec_merge:SSEMODE4S
3976           (vec_duplicate:SSEMODE4S
3977             (match_operand:<ssescalarmode> 2
3978               "general_operand"                            " m,x,x*rfF"))
3979           (match_operand:SSEMODE4S 1 "vector_move_operand" " C,0,0")
3980           (const_int 1)))]
3981   "TARGET_SSE"
3982   "@
3983    movss\t{%2, %0|%0, %2}
3984    movss\t{%2, %0|%0, %2}
3985    #"
3986   [(set_attr "type" "ssemov")
3987    (set_attr "mode" "SF,SF,*")])
3988
3989 ;; A subset is vec_setv4sf.
3990 (define_insn "*vec_setv4sf_avx"
3991   [(set (match_operand:V4SF 0 "register_operand" "=x")
3992         (vec_merge:V4SF
3993           (vec_duplicate:V4SF
3994             (match_operand:SF 2 "nonimmediate_operand" "xm"))
3995           (match_operand:V4SF 1 "register_operand" "x")
3996           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
3997   "TARGET_AVX"
3998 {
3999   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4000   return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4001 }
4002   [(set_attr "type" "sselog")
4003    (set_attr "prefix_extra" "1")
4004    (set_attr "length_immediate" "1")
4005    (set_attr "prefix" "vex")
4006    (set_attr "mode" "V4SF")])
4007
4008 (define_insn "*vec_setv4sf_sse4_1"
4009   [(set (match_operand:V4SF 0 "register_operand" "=x")
4010         (vec_merge:V4SF
4011           (vec_duplicate:V4SF
4012             (match_operand:SF 2 "nonimmediate_operand" "xm"))
4013           (match_operand:V4SF 1 "register_operand" "0")
4014           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4015   "TARGET_SSE4_1"
4016 {
4017   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4018   return "insertps\t{%3, %2, %0|%0, %2, %3}";
4019 }
4020   [(set_attr "type" "sselog")
4021    (set_attr "prefix_data16" "1")
4022    (set_attr "prefix_extra" "1")
4023    (set_attr "length_immediate" "1")
4024    (set_attr "mode" "V4SF")])
4025
4026 (define_insn "*avx_insertps"
4027   [(set (match_operand:V4SF 0 "register_operand" "=x")
4028         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm")
4029                       (match_operand:V4SF 1 "register_operand" "x")
4030                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4031                      UNSPEC_INSERTPS))]
4032   "TARGET_AVX"
4033   "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4034   [(set_attr "type" "sselog")
4035    (set_attr "prefix" "vex")
4036    (set_attr "prefix_extra" "1")
4037    (set_attr "length_immediate" "1")
4038    (set_attr "mode" "V4SF")])
4039
4040 (define_insn "sse4_1_insertps"
4041   [(set (match_operand:V4SF 0 "register_operand" "=x")
4042         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
4043                       (match_operand:V4SF 1 "register_operand" "0")
4044                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
4045                      UNSPEC_INSERTPS))]
4046   "TARGET_SSE4_1"
4047   "insertps\t{%3, %2, %0|%0, %2, %3}";
4048   [(set_attr "type" "sselog")
4049    (set_attr "prefix_data16" "1")
4050    (set_attr "prefix_extra" "1")
4051    (set_attr "length_immediate" "1")
4052    (set_attr "mode" "V4SF")])
4053
4054 (define_split
4055   [(set (match_operand:SSEMODE4S 0 "memory_operand" "")
4056         (vec_merge:SSEMODE4S
4057           (vec_duplicate:SSEMODE4S
4058             (match_operand:<ssescalarmode> 1 "nonmemory_operand" ""))
4059           (match_dup 0)
4060           (const_int 1)))]
4061   "TARGET_SSE && reload_completed"
4062   [(const_int 0)]
4063 {
4064   emit_move_insn (adjust_address (operands[0], <ssescalarmode>mode, 0),
4065                   operands[1]);
4066   DONE;
4067 })
4068
4069 (define_expand "vec_set<mode>"
4070   [(match_operand:SSEMODE 0 "register_operand" "")
4071    (match_operand:<ssescalarmode> 1 "register_operand" "")
4072    (match_operand 2 "const_int_operand" "")]
4073   "TARGET_SSE"
4074 {
4075   ix86_expand_vector_set (false, operands[0], operands[1],
4076                           INTVAL (operands[2]));
4077   DONE;
4078 })
4079
4080 (define_insn_and_split "*vec_extractv4sf_0"
4081   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
4082         (vec_select:SF
4083           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
4084           (parallel [(const_int 0)])))]
4085   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4086   "#"
4087   "&& reload_completed"
4088   [(const_int 0)]
4089 {
4090   rtx op1 = operands[1];
4091   if (REG_P (op1))
4092     op1 = gen_rtx_REG (SFmode, REGNO (op1));
4093   else
4094     op1 = gen_lowpart (SFmode, op1);
4095   emit_move_insn (operands[0], op1);
4096   DONE;
4097 })
4098
4099 (define_expand "avx_vextractf128<mode>"
4100   [(match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "")
4101    (match_operand:AVX256MODE 1 "register_operand" "")
4102    (match_operand:SI 2 "const_0_to_1_operand" "")]
4103   "TARGET_AVX"
4104 {
4105   switch (INTVAL (operands[2]))
4106     {
4107     case 0:
4108       emit_insn (gen_vec_extract_lo_<mode> (operands[0], operands[1]));
4109       break;
4110     case 1:
4111       emit_insn (gen_vec_extract_hi_<mode> (operands[0], operands[1]));
4112       break;
4113     default:
4114       gcc_unreachable ();
4115     }
4116   DONE;
4117 })
4118
4119 (define_insn_and_split "vec_extract_lo_<mode>"
4120   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4121         (vec_select:<avxhalfvecmode>
4122           (match_operand:AVX256MODE4P 1 "nonimmediate_operand" "xm,x")
4123           (parallel [(const_int 0) (const_int 1)])))]
4124   "TARGET_AVX"
4125   "#"
4126   "&& reload_completed"
4127   [(const_int 0)]
4128 {
4129   rtx op1 = operands[1];
4130   if (REG_P (op1))
4131     op1 = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (op1));
4132   else
4133     op1 = gen_lowpart (<avxhalfvecmode>mode, op1);
4134   emit_move_insn (operands[0], op1);
4135   DONE;
4136 })
4137
4138 (define_insn "vec_extract_hi_<mode>"
4139   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4140         (vec_select:<avxhalfvecmode>
4141           (match_operand:AVX256MODE4P 1 "register_operand" "x,x")
4142           (parallel [(const_int 2) (const_int 3)])))]
4143   "TARGET_AVX"
4144   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4145   [(set_attr "type" "sselog")
4146    (set_attr "prefix_extra" "1")
4147    (set_attr "length_immediate" "1")
4148    (set_attr "memory" "none,store")
4149    (set_attr "prefix" "vex")
4150    (set_attr "mode" "V8SF")])
4151
4152 (define_insn_and_split "vec_extract_lo_<mode>"
4153   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4154         (vec_select:<avxhalfvecmode>
4155           (match_operand:AVX256MODE8P 1 "nonimmediate_operand" "xm,x")
4156           (parallel [(const_int 0) (const_int 1)
4157                      (const_int 2) (const_int 3)])))]
4158   "TARGET_AVX"
4159   "#"
4160   "&& reload_completed"
4161   [(const_int 0)]
4162 {
4163   rtx op1 = operands[1];
4164   if (REG_P (op1))
4165     op1 = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (op1));
4166   else
4167     op1 = gen_lowpart (<avxhalfvecmode>mode, op1);
4168   emit_move_insn (operands[0], op1);
4169   DONE;
4170 })
4171
4172 (define_insn "vec_extract_hi_<mode>"
4173   [(set (match_operand:<avxhalfvecmode> 0 "nonimmediate_operand" "=x,m")
4174         (vec_select:<avxhalfvecmode>
4175           (match_operand:AVX256MODE8P 1 "register_operand" "x,x")
4176           (parallel [(const_int 4) (const_int 5)
4177                      (const_int 6) (const_int 7)])))]
4178   "TARGET_AVX"
4179   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4180   [(set_attr "type" "sselog")
4181    (set_attr "prefix_extra" "1")
4182    (set_attr "length_immediate" "1")
4183    (set_attr "memory" "none,store")
4184    (set_attr "prefix" "vex")
4185    (set_attr "mode" "V8SF")])
4186
4187 (define_insn_and_split "vec_extract_lo_v16hi"
4188   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4189         (vec_select:V8HI
4190           (match_operand:V16HI 1 "nonimmediate_operand" "xm,x")
4191           (parallel [(const_int 0) (const_int 1)
4192                      (const_int 2) (const_int 3)
4193                      (const_int 4) (const_int 5)
4194                      (const_int 6) (const_int 7)])))]
4195   "TARGET_AVX"
4196   "#"
4197   "&& reload_completed"
4198   [(const_int 0)]
4199 {
4200   rtx op1 = operands[1];
4201   if (REG_P (op1))
4202     op1 = gen_rtx_REG (V8HImode, REGNO (op1));
4203   else
4204     op1 = gen_lowpart (V8HImode, op1);
4205   emit_move_insn (operands[0], op1);
4206   DONE;
4207 })
4208
4209 (define_insn "vec_extract_hi_v16hi"
4210   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4211         (vec_select:V8HI
4212           (match_operand:V16HI 1 "register_operand" "x,x")
4213           (parallel [(const_int 8) (const_int 9)
4214                      (const_int 10) (const_int 11)
4215                      (const_int 12) (const_int 13)
4216                      (const_int 14) (const_int 15)])))]
4217   "TARGET_AVX"
4218   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4219   [(set_attr "type" "sselog")
4220    (set_attr "prefix_extra" "1")
4221    (set_attr "length_immediate" "1")
4222    (set_attr "memory" "none,store")
4223    (set_attr "prefix" "vex")
4224    (set_attr "mode" "V8SF")])
4225
4226 (define_insn_and_split "vec_extract_lo_v32qi"
4227   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4228         (vec_select:V16QI
4229           (match_operand:V32QI 1 "nonimmediate_operand" "xm,x")
4230           (parallel [(const_int 0) (const_int 1)
4231                      (const_int 2) (const_int 3)
4232                      (const_int 4) (const_int 5)
4233                      (const_int 6) (const_int 7)
4234                      (const_int 8) (const_int 9)
4235                      (const_int 10) (const_int 11)
4236                      (const_int 12) (const_int 13)
4237                      (const_int 14) (const_int 15)])))]
4238   "TARGET_AVX"
4239   "#"
4240   "&& reload_completed"
4241   [(const_int 0)]
4242 {
4243   rtx op1 = operands[1];
4244   if (REG_P (op1))
4245     op1 = gen_rtx_REG (V16QImode, REGNO (op1));
4246   else
4247     op1 = gen_lowpart (V16QImode, op1);
4248   emit_move_insn (operands[0], op1);
4249   DONE;
4250 })
4251
4252 (define_insn "vec_extract_hi_v32qi"
4253   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4254         (vec_select:V16QI
4255           (match_operand:V32QI 1 "register_operand" "x,x")
4256           (parallel [(const_int 16) (const_int 17)
4257                      (const_int 18) (const_int 19)
4258                      (const_int 20) (const_int 21)
4259                      (const_int 22) (const_int 23)
4260                      (const_int 24) (const_int 25)
4261                      (const_int 26) (const_int 27)
4262                      (const_int 28) (const_int 29)
4263                      (const_int 30) (const_int 31)])))]
4264   "TARGET_AVX"
4265   "vextractf128\t{$0x1, %1, %0|%0, %1, 0x1}"
4266   [(set_attr "type" "sselog")
4267    (set_attr "prefix_extra" "1")
4268    (set_attr "length_immediate" "1")
4269    (set_attr "memory" "none,store")
4270    (set_attr "prefix" "vex")
4271    (set_attr "mode" "V8SF")])
4272
4273 (define_insn "*sse4_1_extractps"
4274   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
4275         (vec_select:SF
4276           (match_operand:V4SF 1 "register_operand" "x")
4277           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
4278   "TARGET_SSE4_1"
4279   "%vextractps\t{%2, %1, %0|%0, %1, %2}"
4280   [(set_attr "type" "sselog")
4281    (set_attr "prefix_data16" "1")
4282    (set_attr "prefix_extra" "1")
4283    (set_attr "length_immediate" "1")
4284    (set_attr "prefix" "maybe_vex")
4285    (set_attr "mode" "V4SF")])
4286
4287 (define_insn_and_split "*vec_extract_v4sf_mem"
4288   [(set (match_operand:SF 0 "register_operand" "=x*rf")
4289        (vec_select:SF
4290          (match_operand:V4SF 1 "memory_operand" "o")
4291          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
4292   ""
4293   "#"
4294   "reload_completed"
4295   [(const_int 0)]
4296 {
4297   int i = INTVAL (operands[2]);
4298
4299   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
4300   DONE;
4301 })
4302
4303 (define_expand "vec_extract<mode>"
4304   [(match_operand:<avxscalarmode> 0 "register_operand" "")
4305    (match_operand:VEC_EXTRACT_MODE 1 "register_operand" "")
4306    (match_operand 2 "const_int_operand" "")]
4307   "TARGET_SSE"
4308 {
4309   ix86_expand_vector_extract (false, operands[0], operands[1],
4310                               INTVAL (operands[2]));
4311   DONE;
4312 })
4313
4314 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4315 ;;
4316 ;; Parallel double-precision floating point element swizzling
4317 ;;
4318 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4319
4320 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4321 (define_insn "avx_unpckhpd256"
4322   [(set (match_operand:V4DF 0 "register_operand" "=x")
4323         (vec_select:V4DF
4324           (vec_concat:V8DF
4325             (match_operand:V4DF 1 "register_operand" "x")
4326             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4327           (parallel [(const_int 1) (const_int 5)
4328                      (const_int 3) (const_int 7)])))]
4329   "TARGET_AVX"
4330   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
4331   [(set_attr "type" "sselog")
4332    (set_attr "prefix" "vex")
4333    (set_attr "mode" "V4DF")])
4334
4335 (define_expand "vec_interleave_highv4df"
4336   [(set (match_dup 3)
4337         (vec_select:V4DF
4338           (vec_concat:V8DF
4339             (match_operand:V4DF 1 "register_operand" "x")
4340             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4341           (parallel [(const_int 0) (const_int 4)
4342                      (const_int 2) (const_int 6)])))
4343    (set (match_dup 4)
4344         (vec_select:V4DF
4345           (vec_concat:V8DF
4346             (match_dup 1)
4347             (match_dup 2))
4348           (parallel [(const_int 1) (const_int 5)
4349                      (const_int 3) (const_int 7)])))
4350    (set (match_operand:V4DF 0 "register_operand" "")
4351         (vec_select:V4DF
4352           (vec_concat:V8DF
4353             (match_dup 3)
4354             (match_dup 4))
4355           (parallel [(const_int 2) (const_int 3)
4356                      (const_int 6) (const_int 7)])))]
4357  "TARGET_AVX"
4358 {
4359   operands[3] = gen_reg_rtx (V4DFmode);
4360   operands[4] = gen_reg_rtx (V4DFmode);
4361 })
4362
4363
4364 (define_expand "vec_interleave_highv2df"
4365   [(set (match_operand:V2DF 0 "register_operand" "")
4366         (vec_select:V2DF
4367           (vec_concat:V4DF
4368             (match_operand:V2DF 1 "nonimmediate_operand" "")
4369             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4370           (parallel [(const_int 1)
4371                      (const_int 3)])))]
4372   "TARGET_SSE2"
4373 {
4374   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
4375     operands[2] = force_reg (V2DFmode, operands[2]);
4376 })
4377
4378 (define_insn "*avx_interleave_highv2df"
4379   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4380         (vec_select:V2DF
4381           (vec_concat:V4DF
4382             (match_operand:V2DF 1 "nonimmediate_operand" " x,o,o,x")
4383             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,x,0"))
4384           (parallel [(const_int 1)
4385                      (const_int 3)])))]
4386   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4387   "@
4388    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
4389    vmovddup\t{%H1, %0|%0, %H1}
4390    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
4391    vmovhpd\t{%1, %0|%0, %1}"
4392   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4393    (set_attr "prefix" "vex")
4394    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4395
4396 (define_insn "*sse3_interleave_highv2df"
4397   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,m")
4398         (vec_select:V2DF
4399           (vec_concat:V4DF
4400             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,o,x")
4401             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,0,0"))
4402           (parallel [(const_int 1)
4403                      (const_int 3)])))]
4404   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4405   "@
4406    unpckhpd\t{%2, %0|%0, %2}
4407    movddup\t{%H1, %0|%0, %H1}
4408    movlpd\t{%H1, %0|%0, %H1}
4409    movhpd\t{%1, %0|%0, %1}"
4410   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4411    (set_attr "prefix_data16" "*,*,1,1")
4412    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4413
4414 (define_insn "*sse2_interleave_highv2df"
4415   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
4416         (vec_select:V2DF
4417           (vec_concat:V4DF
4418             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
4419             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
4420           (parallel [(const_int 1)
4421                      (const_int 3)])))]
4422   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4423   "@
4424    unpckhpd\t{%2, %0|%0, %2}
4425    movlpd\t{%H1, %0|%0, %H1}
4426    movhpd\t{%1, %0|%0, %1}"
4427   [(set_attr "type" "sselog,ssemov,ssemov")
4428    (set_attr "prefix_data16" "*,1,1")
4429    (set_attr "mode" "V2DF,V1DF,V1DF")])
4430
4431 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4432 (define_expand "avx_movddup256"
4433   [(set (match_operand:V4DF 0 "register_operand" "")
4434         (vec_select:V4DF
4435           (vec_concat:V8DF
4436             (match_operand:V4DF 1 "nonimmediate_operand" "")
4437             (match_dup 1))
4438           (parallel [(const_int 0) (const_int 4)
4439                      (const_int 2) (const_int 6)])))]
4440   "TARGET_AVX")
4441
4442 (define_expand "avx_unpcklpd256"
4443   [(set (match_operand:V4DF 0 "register_operand" "")
4444         (vec_select:V4DF
4445           (vec_concat:V8DF
4446             (match_operand:V4DF 1 "register_operand" "")
4447             (match_operand:V4DF 2 "nonimmediate_operand" ""))
4448           (parallel [(const_int 0) (const_int 4)
4449                      (const_int 2) (const_int 6)])))]
4450   "TARGET_AVX")
4451
4452 (define_insn "*avx_unpcklpd256"
4453   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
4454         (vec_select:V4DF
4455           (vec_concat:V8DF
4456             (match_operand:V4DF 1 "nonimmediate_operand" "xm,x")
4457             (match_operand:V4DF 2 "nonimmediate_operand" " 1,xm"))
4458           (parallel [(const_int 0) (const_int 4)
4459                      (const_int 2) (const_int 6)])))]
4460   "TARGET_AVX
4461    && (!MEM_P (operands[1]) || rtx_equal_p (operands[1], operands[2]))"
4462   "@
4463    vmovddup\t{%1, %0|%0, %1}
4464    vunpcklpd\t{%2, %1, %0|%0, %1, %2}"
4465   [(set_attr "type" "sselog")
4466    (set_attr "prefix" "vex")
4467    (set_attr "mode" "V4DF")])
4468
4469 (define_expand "vec_interleave_lowv4df"
4470   [(set (match_dup 3)
4471         (vec_select:V4DF
4472           (vec_concat:V8DF
4473             (match_operand:V4DF 1 "register_operand" "x")
4474             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4475           (parallel [(const_int 0) (const_int 4)
4476                      (const_int 2) (const_int 6)])))
4477    (set (match_dup 4)
4478         (vec_select:V4DF
4479           (vec_concat:V8DF
4480             (match_dup 1)
4481             (match_dup 2))
4482           (parallel [(const_int 1) (const_int 5)
4483                      (const_int 3) (const_int 7)])))
4484    (set (match_operand:V4DF 0 "register_operand" "")
4485         (vec_select:V4DF
4486           (vec_concat:V8DF
4487             (match_dup 3)
4488             (match_dup 4))
4489           (parallel [(const_int 0) (const_int 1)
4490                      (const_int 4) (const_int 5)])))]
4491  "TARGET_AVX"
4492 {
4493   operands[3] = gen_reg_rtx (V4DFmode);
4494   operands[4] = gen_reg_rtx (V4DFmode);
4495 })
4496
4497 (define_expand "vec_interleave_lowv2df"
4498   [(set (match_operand:V2DF 0 "register_operand" "")
4499         (vec_select:V2DF
4500           (vec_concat:V4DF
4501             (match_operand:V2DF 1 "nonimmediate_operand" "")
4502             (match_operand:V2DF 2 "nonimmediate_operand" ""))
4503           (parallel [(const_int 0)
4504                      (const_int 2)])))]
4505   "TARGET_SSE2"
4506 {
4507   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
4508     operands[1] = force_reg (V2DFmode, operands[1]);
4509 })
4510
4511 (define_insn "*avx_interleave_lowv2df"
4512   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4513         (vec_select:V2DF
4514           (vec_concat:V4DF
4515             (match_operand:V2DF 1 "nonimmediate_operand" " x,m,x,0")
4516             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4517           (parallel [(const_int 0)
4518                      (const_int 2)])))]
4519   "TARGET_AVX && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4520   "@
4521    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4522    vmovddup\t{%1, %0|%0, %1}
4523    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4524    vmovlpd\t{%2, %H0|%H0, %2}"
4525   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4526    (set_attr "prefix" "vex")
4527    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4528
4529 (define_insn "*sse3_interleave_lowv2df"
4530   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
4531         (vec_select:V2DF
4532           (vec_concat:V4DF
4533             (match_operand:V2DF 1 "nonimmediate_operand" " 0,m,0,0")
4534             (match_operand:V2DF 2 "nonimmediate_operand" " x,1,m,x"))
4535           (parallel [(const_int 0)
4536                      (const_int 2)])))]
4537   "TARGET_SSE3 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4538   "@
4539    unpcklpd\t{%2, %0|%0, %2}
4540    movddup\t{%1, %0|%0, %1}
4541    movhpd\t{%2, %0|%0, %2}
4542    movlpd\t{%2, %H0|%H0, %2}"
4543   [(set_attr "type" "sselog,sselog,ssemov,ssemov")
4544    (set_attr "prefix_data16" "*,*,1,1")
4545    (set_attr "mode" "V2DF,V2DF,V1DF,V1DF")])
4546
4547 (define_insn "*sse2_interleave_lowv2df"
4548   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
4549         (vec_select:V2DF
4550           (vec_concat:V4DF
4551             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
4552             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
4553           (parallel [(const_int 0)
4554                      (const_int 2)])))]
4555   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4556   "@
4557    unpcklpd\t{%2, %0|%0, %2}
4558    movhpd\t{%2, %0|%0, %2}
4559    movlpd\t{%2, %H0|%H0, %2}"
4560   [(set_attr "type" "sselog,ssemov,ssemov")
4561    (set_attr "prefix_data16" "*,1,1")
4562    (set_attr "mode" "V2DF,V1DF,V1DF")])
4563
4564 (define_split
4565   [(set (match_operand:V2DF 0 "memory_operand" "")
4566         (vec_select:V2DF
4567           (vec_concat:V4DF
4568             (match_operand:V2DF 1 "register_operand" "")
4569             (match_dup 1))
4570           (parallel [(const_int 0)
4571                      (const_int 2)])))]
4572   "TARGET_SSE3 && reload_completed"
4573   [(const_int 0)]
4574 {
4575   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4576   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4577   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4578   DONE;
4579 })
4580
4581 (define_split
4582   [(set (match_operand:V2DF 0 "register_operand" "")
4583         (vec_select:V2DF
4584           (vec_concat:V4DF
4585             (match_operand:V2DF 1 "memory_operand" "")
4586             (match_dup 1))
4587           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "")
4588                      (match_operand:SI 3 "const_int_operand" "")])))]
4589   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
4590   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
4591 {
4592   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
4593 })
4594
4595 (define_expand "avx_shufpd256"
4596   [(match_operand:V4DF 0 "register_operand" "")
4597    (match_operand:V4DF 1 "register_operand" "")
4598    (match_operand:V4DF 2 "nonimmediate_operand" "")
4599    (match_operand:SI 3 "const_int_operand" "")]
4600   "TARGET_AVX"
4601 {
4602   int mask = INTVAL (operands[3]);
4603   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4604                                    GEN_INT (mask & 1),
4605                                    GEN_INT (mask & 2 ? 5 : 4),
4606                                    GEN_INT (mask & 4 ? 3 : 2),
4607                                    GEN_INT (mask & 8 ? 7 : 6)));
4608   DONE;
4609 })
4610
4611 (define_insn "avx_shufpd256_1"
4612   [(set (match_operand:V4DF 0 "register_operand" "=x")
4613         (vec_select:V4DF
4614           (vec_concat:V8DF
4615             (match_operand:V4DF 1 "register_operand" "x")
4616             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4617           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4618                      (match_operand 4 "const_4_to_5_operand" "")
4619                      (match_operand 5 "const_2_to_3_operand" "")
4620                      (match_operand 6 "const_6_to_7_operand" "")])))]
4621   "TARGET_AVX"
4622 {
4623   int mask;
4624   mask = INTVAL (operands[3]);
4625   mask |= (INTVAL (operands[4]) - 4) << 1;
4626   mask |= (INTVAL (operands[5]) - 2) << 2;
4627   mask |= (INTVAL (operands[6]) - 6) << 3;
4628   operands[3] = GEN_INT (mask);
4629
4630   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4631 }
4632   [(set_attr "type" "sselog")
4633    (set_attr "length_immediate" "1")
4634    (set_attr "prefix" "vex")
4635    (set_attr "mode" "V4DF")])
4636
4637 (define_expand "sse2_shufpd"
4638   [(match_operand:V2DF 0 "register_operand" "")
4639    (match_operand:V2DF 1 "register_operand" "")
4640    (match_operand:V2DF 2 "nonimmediate_operand" "")
4641    (match_operand:SI 3 "const_int_operand" "")]
4642   "TARGET_SSE2"
4643 {
4644   int mask = INTVAL (operands[3]);
4645   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4646                                 GEN_INT (mask & 1),
4647                                 GEN_INT (mask & 2 ? 3 : 2)));
4648   DONE;
4649 })
4650
4651 (define_expand "vec_extract_even<mode>"
4652   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4653    (match_operand:SSEMODE_EO 1 "register_operand" "")
4654    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4655   ""
4656 {
4657   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 0);
4658   DONE;
4659 })
4660
4661 (define_expand "vec_extract_odd<mode>"
4662   [(match_operand:SSEMODE_EO 0 "register_operand" "")
4663    (match_operand:SSEMODE_EO 1 "register_operand" "")
4664    (match_operand:SSEMODE_EO 2 "register_operand" "")]
4665   ""
4666 {
4667   ix86_expand_vec_extract_even_odd (operands[0], operands[1], operands[2], 1);
4668   DONE;
4669 })
4670
4671 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4672 (define_insn "*avx_interleave_highv2di"
4673   [(set (match_operand:V2DI 0 "register_operand" "=x")
4674         (vec_select:V2DI
4675           (vec_concat:V4DI
4676             (match_operand:V2DI 1 "register_operand" "x")
4677             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4678           (parallel [(const_int 1)
4679                      (const_int 3)])))]
4680   "TARGET_AVX"
4681   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4682   [(set_attr "type" "sselog")
4683    (set_attr "prefix" "vex")
4684    (set_attr "mode" "TI")])
4685
4686 (define_insn "vec_interleave_highv2di"
4687   [(set (match_operand:V2DI 0 "register_operand" "=x")
4688         (vec_select:V2DI
4689           (vec_concat:V4DI
4690             (match_operand:V2DI 1 "register_operand" "0")
4691             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4692           (parallel [(const_int 1)
4693                      (const_int 3)])))]
4694   "TARGET_SSE2"
4695   "punpckhqdq\t{%2, %0|%0, %2}"
4696   [(set_attr "type" "sselog")
4697    (set_attr "prefix_data16" "1")
4698    (set_attr "mode" "TI")])
4699
4700 (define_insn "*avx_interleave_lowv2di"
4701   [(set (match_operand:V2DI 0 "register_operand" "=x")
4702         (vec_select:V2DI
4703           (vec_concat:V4DI
4704             (match_operand:V2DI 1 "register_operand" "x")
4705             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4706           (parallel [(const_int 0)
4707                      (const_int 2)])))]
4708   "TARGET_AVX"
4709   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4710   [(set_attr "type" "sselog")
4711    (set_attr "prefix" "vex")
4712    (set_attr "mode" "TI")])
4713
4714 (define_insn "vec_interleave_lowv2di"
4715   [(set (match_operand:V2DI 0 "register_operand" "=x")
4716         (vec_select:V2DI
4717           (vec_concat:V4DI
4718             (match_operand:V2DI 1 "register_operand" "0")
4719             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4720           (parallel [(const_int 0)
4721                      (const_int 2)])))]
4722   "TARGET_SSE2"
4723   "punpcklqdq\t{%2, %0|%0, %2}"
4724   [(set_attr "type" "sselog")
4725    (set_attr "prefix_data16" "1")
4726    (set_attr "mode" "TI")])
4727
4728 (define_insn "*avx_shufpd_<mode>"
4729   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4730         (vec_select:SSEMODE2D
4731           (vec_concat:<ssedoublesizemode>
4732             (match_operand:SSEMODE2D 1 "register_operand" "x")
4733             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4734           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4735                      (match_operand 4 "const_2_to_3_operand" "")])))]
4736   "TARGET_AVX"
4737 {
4738   int mask;
4739   mask = INTVAL (operands[3]);
4740   mask |= (INTVAL (operands[4]) - 2) << 1;
4741   operands[3] = GEN_INT (mask);
4742
4743   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4744 }
4745   [(set_attr "type" "sselog")
4746    (set_attr "length_immediate" "1")
4747    (set_attr "prefix" "vex")
4748    (set_attr "mode" "V2DF")])
4749
4750 (define_insn "sse2_shufpd_<mode>"
4751   [(set (match_operand:SSEMODE2D 0 "register_operand" "=x")
4752         (vec_select:SSEMODE2D
4753           (vec_concat:<ssedoublesizemode>
4754             (match_operand:SSEMODE2D 1 "register_operand" "0")
4755             (match_operand:SSEMODE2D 2 "nonimmediate_operand" "xm"))
4756           (parallel [(match_operand 3 "const_0_to_1_operand" "")
4757                      (match_operand 4 "const_2_to_3_operand" "")])))]
4758   "TARGET_SSE2"
4759 {
4760   int mask;
4761   mask = INTVAL (operands[3]);
4762   mask |= (INTVAL (operands[4]) - 2) << 1;
4763   operands[3] = GEN_INT (mask);
4764
4765   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4766 }
4767   [(set_attr "type" "sselog")
4768    (set_attr "length_immediate" "1")
4769    (set_attr "mode" "V2DF")])
4770
4771 ;; Avoid combining registers from different units in a single alternative,
4772 ;; see comment above inline_secondary_memory_needed function in i386.c
4773 (define_insn "*avx_storehpd"
4774   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4775         (vec_select:DF
4776           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,o,o,o")
4777           (parallel [(const_int 1)])))]
4778   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4779   "@
4780    vmovhpd\t{%1, %0|%0, %1}
4781    vunpckhpd\t{%1, %1, %0|%0, %1, %1}
4782    #
4783    #
4784    #"
4785   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4786    (set_attr "prefix" "vex")
4787    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4788
4789 (define_insn "sse2_storehpd"
4790   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4791         (vec_select:DF
4792           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o,o,o")
4793           (parallel [(const_int 1)])))]
4794   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4795   "@
4796    movhpd\t{%1, %0|%0, %1}
4797    unpckhpd\t%0, %0
4798    #
4799    #
4800    #"
4801   [(set_attr "type" "ssemov,sselog1,ssemov,fmov,imov")
4802    (set_attr "prefix_data16" "1,*,*,*,*")
4803    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4804
4805 (define_split
4806   [(set (match_operand:DF 0 "register_operand" "")
4807         (vec_select:DF
4808           (match_operand:V2DF 1 "memory_operand" "")
4809           (parallel [(const_int 1)])))]
4810   "TARGET_SSE2 && reload_completed"
4811   [(set (match_dup 0) (match_dup 1))]
4812   "operands[1] = adjust_address (operands[1], DFmode, 8);")
4813
4814 ;; Avoid combining registers from different units in a single alternative,
4815 ;; see comment above inline_secondary_memory_needed function in i386.c
4816 (define_insn "sse2_storelpd"
4817   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4818         (vec_select:DF
4819           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4820           (parallel [(const_int 0)])))]
4821   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4822   "@
4823    %vmovlpd\t{%1, %0|%0, %1}
4824    #
4825    #
4826    #
4827    #"
4828   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4829    (set_attr "prefix_data16" "1,*,*,*,*")
4830    (set_attr "prefix" "maybe_vex")
4831    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4832
4833 (define_split
4834   [(set (match_operand:DF 0 "register_operand" "")
4835         (vec_select:DF
4836           (match_operand:V2DF 1 "nonimmediate_operand" "")
4837           (parallel [(const_int 0)])))]
4838   "TARGET_SSE2 && reload_completed"
4839   [(const_int 0)]
4840 {
4841   rtx op1 = operands[1];
4842   if (REG_P (op1))
4843     op1 = gen_rtx_REG (DFmode, REGNO (op1));
4844   else
4845     op1 = gen_lowpart (DFmode, op1);
4846   emit_move_insn (operands[0], op1);
4847   DONE;
4848 })
4849
4850 (define_expand "sse2_loadhpd_exp"
4851   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4852         (vec_concat:V2DF
4853           (vec_select:DF
4854             (match_operand:V2DF 1 "nonimmediate_operand" "")
4855             (parallel [(const_int 0)]))
4856           (match_operand:DF 2 "nonimmediate_operand" "")))]
4857   "TARGET_SSE2"
4858   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4859
4860 ;; Avoid combining registers from different units in a single alternative,
4861 ;; see comment above inline_secondary_memory_needed function in i386.c
4862 (define_insn "*avx_loadhpd"
4863   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o,o,o")
4864         (vec_concat:V2DF
4865           (vec_select:DF
4866             (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,0,0")
4867             (parallel [(const_int 0)]))
4868           (match_operand:DF 2 "nonimmediate_operand"     " m,x,x,*f,r")))]
4869   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4870   "@
4871    vmovhpd\t{%2, %1, %0|%0, %1, %2}
4872    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4873    #
4874    #
4875    #"
4876   [(set_attr "type" "ssemov,sselog,ssemov,fmov,imov")
4877    (set_attr "prefix" "vex")
4878    (set_attr "mode" "V1DF,V2DF,DF,DF,DF")])
4879
4880 (define_insn "sse2_loadhpd"
4881   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o,o,o")
4882         (vec_concat:V2DF
4883           (vec_select:DF
4884             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0,0,0")
4885             (parallel [(const_int 0)]))
4886           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x,*f,r")))]
4887   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4888   "@
4889    movhpd\t{%2, %0|%0, %2}
4890    unpcklpd\t{%2, %0|%0, %2}
4891    shufpd\t{$1, %1, %0|%0, %1, 1}
4892    #
4893    #
4894    #"
4895   [(set_attr "type" "ssemov,sselog,sselog,ssemov,fmov,imov")
4896    (set_attr "prefix_data16" "1,*,*,*,*,*")
4897    (set_attr "length_immediate" "*,*,1,*,*,*")
4898    (set_attr "mode" "V1DF,V2DF,V2DF,DF,DF,DF")])
4899
4900 (define_split
4901   [(set (match_operand:V2DF 0 "memory_operand" "")
4902         (vec_concat:V2DF
4903           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
4904           (match_operand:DF 1 "register_operand" "")))]
4905   "TARGET_SSE2 && reload_completed"
4906   [(set (match_dup 0) (match_dup 1))]
4907   "operands[0] = adjust_address (operands[0], DFmode, 8);")
4908
4909 (define_expand "sse2_loadlpd_exp"
4910   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
4911         (vec_concat:V2DF
4912           (match_operand:DF 2 "nonimmediate_operand" "")
4913           (vec_select:DF
4914             (match_operand:V2DF 1 "nonimmediate_operand" "")
4915             (parallel [(const_int 1)]))))]
4916   "TARGET_SSE2"
4917   "ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);")
4918
4919 ;; Avoid combining registers from different units in a single alternative,
4920 ;; see comment above inline_secondary_memory_needed function in i386.c
4921 (define_insn "*avx_loadlpd"
4922   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,m,m,m")
4923         (vec_concat:V2DF
4924           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,x,x,*f,r")
4925           (vec_select:DF
4926             (match_operand:V2DF 1 "vector_move_operand" " C,x,x,o,0,0,0")
4927             (parallel [(const_int 1)]))))]
4928   "TARGET_AVX && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4929   "@
4930    vmovsd\t{%2, %0|%0, %2}
4931    vmovlpd\t{%2, %1, %0|%0, %1, %2}
4932    vmovsd\t{%2, %1, %0|%0, %1, %2}
4933    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
4934    #
4935    #
4936    #"
4937   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov,fmov,imov")
4938    (set_attr "prefix" "vex")
4939    (set_attr "mode" "DF,V1DF,V1DF,V1DF,DF,DF,DF")])
4940
4941 (define_insn "sse2_loadlpd"
4942   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m,m,m")
4943         (vec_concat:V2DF
4944           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x,*f,r")
4945           (vec_select:DF
4946             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0,0,0")
4947             (parallel [(const_int 1)]))))]
4948   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4949   "@
4950    movsd\t{%2, %0|%0, %2}
4951    movlpd\t{%2, %0|%0, %2}
4952    movsd\t{%2, %0|%0, %2}
4953    shufpd\t{$2, %2, %0|%0, %2, 2}
4954    movhpd\t{%H1, %0|%0, %H1}
4955    #
4956    #
4957    #"
4958   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,fmov,imov")
4959    (set_attr "prefix_data16" "*,1,*,*,1,*,*,*")
4960    (set_attr "length_immediate" "*,*,*,1,*,*,*,*")
4961    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF,DF,DF")])
4962
4963 (define_split
4964   [(set (match_operand:V2DF 0 "memory_operand" "")
4965         (vec_concat:V2DF
4966           (match_operand:DF 1 "register_operand" "")
4967           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
4968   "TARGET_SSE2 && reload_completed"
4969   [(set (match_dup 0) (match_dup 1))]
4970   "operands[0] = adjust_address (operands[0], DFmode, 8);")
4971
4972 ;; Not sure these two are ever used, but it doesn't hurt to have
4973 ;; them. -aoliva
4974 (define_insn "*vec_extractv2df_1_sse"
4975   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4976         (vec_select:DF
4977           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4978           (parallel [(const_int 1)])))]
4979   "!TARGET_SSE2 && TARGET_SSE
4980    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4981   "@
4982    movhps\t{%1, %0|%0, %1}
4983    movhlps\t{%1, %0|%0, %1}
4984    movlps\t{%H1, %0|%0, %H1}"
4985   [(set_attr "type" "ssemov")
4986    (set_attr "mode" "V2SF,V4SF,V2SF")])
4987
4988 (define_insn "*vec_extractv2df_0_sse"
4989   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4990         (vec_select:DF
4991           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
4992           (parallel [(const_int 0)])))]
4993   "!TARGET_SSE2 && TARGET_SSE
4994    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4995   "@
4996    movlps\t{%1, %0|%0, %1}
4997    movaps\t{%1, %0|%0, %1}
4998    movlps\t{%1, %0|%0, %1}"
4999   [(set_attr "type" "ssemov")
5000    (set_attr "mode" "V2SF,V4SF,V2SF")])
5001
5002 (define_insn "*avx_movsd"
5003   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,o")
5004         (vec_merge:V2DF
5005           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,x,0")
5006           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,0,o,x")
5007           (const_int 1)))]
5008   "TARGET_AVX"
5009   "@
5010    vmovsd\t{%2, %1, %0|%0, %1, %2}
5011    vmovlpd\t{%2, %1, %0|%0, %1, %2}
5012    vmovlpd\t{%2, %0|%0, %2}
5013    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
5014    vmovhps\t{%1, %H0|%H0, %1}"
5015   [(set_attr "type" "ssemov,ssemov,ssemov,ssemov,ssemov")
5016    (set_attr "prefix" "vex")
5017    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF")])
5018
5019 (define_insn "sse2_movsd"
5020   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
5021         (vec_merge:V2DF
5022           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
5023           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
5024           (const_int 1)))]
5025   "TARGET_SSE2"
5026   "@
5027    movsd\t{%2, %0|%0, %2}
5028    movlpd\t{%2, %0|%0, %2}
5029    movlpd\t{%2, %0|%0, %2}
5030    shufpd\t{$2, %2, %0|%0, %2, 2}
5031    movhps\t{%H1, %0|%0, %H1}
5032    movhps\t{%1, %H0|%H0, %1}"
5033   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
5034    (set_attr "prefix_data16" "*,1,1,*,*,*")
5035    (set_attr "length_immediate" "*,*,*,1,*,*")
5036    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
5037
5038 (define_insn "*vec_dupv2df_sse3"
5039   [(set (match_operand:V2DF 0 "register_operand" "=x")
5040         (vec_duplicate:V2DF
5041           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
5042   "TARGET_SSE3"
5043   "%vmovddup\t{%1, %0|%0, %1}"
5044   [(set_attr "type" "sselog1")
5045    (set_attr "prefix" "maybe_vex")
5046    (set_attr "mode" "DF")])
5047
5048 (define_insn "vec_dupv2df"
5049   [(set (match_operand:V2DF 0 "register_operand" "=x")
5050         (vec_duplicate:V2DF
5051           (match_operand:DF 1 "register_operand" "0")))]
5052   "TARGET_SSE2"
5053   "unpcklpd\t%0, %0"
5054   [(set_attr "type" "sselog1")
5055    (set_attr "mode" "V2DF")])
5056
5057 (define_insn "*vec_concatv2df_sse3"
5058   [(set (match_operand:V2DF 0 "register_operand" "=x")
5059         (vec_concat:V2DF
5060           (match_operand:DF 1 "nonimmediate_operand" "xm")
5061           (match_dup 1)))]
5062   "TARGET_SSE3"
5063   "%vmovddup\t{%1, %0|%0, %1}"
5064   [(set_attr "type" "sselog1")
5065    (set_attr "prefix" "maybe_vex")
5066    (set_attr "mode" "DF")])
5067
5068 (define_insn "*vec_concatv2df_avx"
5069   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x")
5070         (vec_concat:V2DF
5071           (match_operand:DF 1 "nonimmediate_operand" " x,x,m")
5072           (match_operand:DF 2 "vector_move_operand"  " x,m,C")))]
5073   "TARGET_AVX"
5074   "@
5075    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
5076    vmovhpd\t{%2, %1, %0|%0, %1, %2}
5077    vmovsd\t{%1, %0|%0, %1}"
5078   [(set_attr "type" "ssemov")
5079    (set_attr "prefix" "vex")
5080    (set_attr "mode" "DF,V1DF,DF")])
5081
5082 (define_insn "*vec_concatv2df"
5083   [(set (match_operand:V2DF 0 "register_operand"     "=Y2,Y2,Y2,x,x")
5084         (vec_concat:V2DF
5085           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
5086           (match_operand:DF 2 "vector_move_operand"  " Y2,m ,C ,x,m")))]
5087   "TARGET_SSE"
5088   "@
5089    unpcklpd\t{%2, %0|%0, %2}
5090    movhpd\t{%2, %0|%0, %2}
5091    movsd\t{%1, %0|%0, %1}
5092    movlhps\t{%2, %0|%0, %2}
5093    movhps\t{%2, %0|%0, %2}"
5094   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
5095    (set_attr "prefix_data16" "*,1,*,*,*")
5096    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
5097
5098 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5099 ;;
5100 ;; Parallel integral arithmetic
5101 ;;
5102 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5103
5104 (define_expand "neg<mode>2"
5105   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5106         (minus:SSEMODEI
5107           (match_dup 2)
5108           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
5109   "TARGET_SSE2"
5110   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
5111
5112 (define_expand "<plusminus_insn><mode>3"
5113   [(set (match_operand:SSEMODEI 0 "register_operand" "")
5114         (plusminus:SSEMODEI
5115           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
5116           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
5117   "TARGET_SSE2"
5118   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5119
5120 (define_insn "*avx_<plusminus_insn><mode>3"
5121   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5122         (plusminus:SSEMODEI
5123           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>x")
5124           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5125   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5126   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5127   [(set_attr "type" "sseiadd")
5128    (set_attr "prefix" "vex")
5129    (set_attr "mode" "TI")])
5130
5131 (define_insn "*<plusminus_insn><mode>3"
5132   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
5133         (plusminus:SSEMODEI
5134           (match_operand:SSEMODEI 1 "nonimmediate_operand" "<comm>0")
5135           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
5136   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5137   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5138   [(set_attr "type" "sseiadd")
5139    (set_attr "prefix_data16" "1")
5140    (set_attr "mode" "TI")])
5141
5142 (define_expand "sse2_<plusminus_insn><mode>3"
5143   [(set (match_operand:SSEMODE12 0 "register_operand" "")
5144         (sat_plusminus:SSEMODE12
5145           (match_operand:SSEMODE12 1 "nonimmediate_operand" "")
5146           (match_operand:SSEMODE12 2 "nonimmediate_operand" "")))]
5147   "TARGET_SSE2"
5148   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5149
5150 (define_insn "*avx_<plusminus_insn><mode>3"
5151   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5152         (sat_plusminus:SSEMODE12
5153           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>x")
5154           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5155   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5156   "vp<plusminus_mnemonic><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5157   [(set_attr "type" "sseiadd")
5158    (set_attr "prefix" "vex")
5159    (set_attr "mode" "TI")])
5160
5161 (define_insn "*sse2_<plusminus_insn><mode>3"
5162   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
5163         (sat_plusminus:SSEMODE12
5164           (match_operand:SSEMODE12 1 "nonimmediate_operand" "<comm>0")
5165           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
5166   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5167   "p<plusminus_mnemonic><ssevecsize>\t{%2, %0|%0, %2}"
5168   [(set_attr "type" "sseiadd")
5169    (set_attr "prefix_data16" "1")
5170    (set_attr "mode" "TI")])
5171
5172 (define_insn_and_split "mulv16qi3"
5173   [(set (match_operand:V16QI 0 "register_operand" "")
5174         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
5175                     (match_operand:V16QI 2 "register_operand" "")))]
5176   "TARGET_SSE2
5177    && can_create_pseudo_p ()"
5178   "#"
5179   "&& 1"
5180   [(const_int 0)]
5181 {
5182   rtx t[6];
5183   int i;
5184
5185   for (i = 0; i < 6; ++i)
5186     t[i] = gen_reg_rtx (V16QImode);
5187
5188   /* Unpack data such that we've got a source byte in each low byte of
5189      each word.  We don't care what goes into the high byte of each word.
5190      Rather than trying to get zero in there, most convenient is to let
5191      it be a copy of the low byte.  */
5192   emit_insn (gen_vec_interleave_highv16qi (t[0], operands[1], operands[1]));
5193   emit_insn (gen_vec_interleave_highv16qi (t[1], operands[2], operands[2]));
5194   emit_insn (gen_vec_interleave_lowv16qi (t[2], operands[1], operands[1]));
5195   emit_insn (gen_vec_interleave_lowv16qi (t[3], operands[2], operands[2]));
5196
5197   /* Multiply words.  The end-of-line annotations here give a picture of what
5198      the output of that instruction looks like.  Dot means don't care; the
5199      letters are the bytes of the result with A being the most significant.  */
5200   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
5201                            gen_lowpart (V8HImode, t[0]),
5202                            gen_lowpart (V8HImode, t[1])));
5203   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
5204                            gen_lowpart (V8HImode, t[2]),
5205                            gen_lowpart (V8HImode, t[3])));
5206
5207   /* Extract the even bytes and merge them back together.  */
5208   ix86_expand_vec_extract_even_odd (operands[0], t[5], t[4], 0);
5209   DONE;
5210 })
5211
5212 (define_expand "mulv8hi3"
5213   [(set (match_operand:V8HI 0 "register_operand" "")
5214         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
5215                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
5216   "TARGET_SSE2"
5217   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5218
5219 (define_insn "*avx_mulv8hi3"
5220   [(set (match_operand:V8HI 0 "register_operand" "=x")
5221         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5222                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5223   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5224   "vpmullw\t{%2, %1, %0|%0, %1, %2}"
5225   [(set_attr "type" "sseimul")
5226    (set_attr "prefix" "vex")
5227    (set_attr "mode" "TI")])
5228
5229 (define_insn "*mulv8hi3"
5230   [(set (match_operand:V8HI 0 "register_operand" "=x")
5231         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5232                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
5233   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5234   "pmullw\t{%2, %0|%0, %2}"
5235   [(set_attr "type" "sseimul")
5236    (set_attr "prefix_data16" "1")
5237    (set_attr "mode" "TI")])
5238
5239 (define_expand "<s>mulv8hi3_highpart"
5240   [(set (match_operand:V8HI 0 "register_operand" "")
5241         (truncate:V8HI
5242           (lshiftrt:V8SI
5243             (mult:V8SI
5244               (any_extend:V8SI
5245                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
5246               (any_extend:V8SI
5247                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
5248             (const_int 16))))]
5249   "TARGET_SSE2"
5250   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5251
5252 (define_insn "*avx_<s>mulv8hi3_highpart"
5253   [(set (match_operand:V8HI 0 "register_operand" "=x")
5254         (truncate:V8HI
5255           (lshiftrt:V8SI
5256             (mult:V8SI
5257               (any_extend:V8SI
5258                 (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
5259               (any_extend:V8SI
5260                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5261             (const_int 16))))]
5262   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5263   "vpmulh<u>w\t{%2, %1, %0|%0, %1, %2}"
5264   [(set_attr "type" "sseimul")
5265    (set_attr "prefix" "vex")
5266    (set_attr "mode" "TI")])
5267
5268 (define_insn "*<s>mulv8hi3_highpart"
5269   [(set (match_operand:V8HI 0 "register_operand" "=x")
5270         (truncate:V8HI
5271           (lshiftrt:V8SI
5272             (mult:V8SI
5273               (any_extend:V8SI
5274                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5275               (any_extend:V8SI
5276                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5277             (const_int 16))))]
5278   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5279   "pmulh<u>w\t{%2, %0|%0, %2}"
5280   [(set_attr "type" "sseimul")
5281    (set_attr "prefix_data16" "1")
5282    (set_attr "mode" "TI")])
5283
5284 (define_expand "sse2_umulv2siv2di3"
5285   [(set (match_operand:V2DI 0 "register_operand" "")
5286         (mult:V2DI
5287           (zero_extend:V2DI
5288             (vec_select:V2SI
5289               (match_operand:V4SI 1 "nonimmediate_operand" "")
5290               (parallel [(const_int 0) (const_int 2)])))
5291           (zero_extend:V2DI
5292             (vec_select:V2SI
5293               (match_operand:V4SI 2 "nonimmediate_operand" "")
5294               (parallel [(const_int 0) (const_int 2)])))))]
5295   "TARGET_SSE2"
5296   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5297
5298 (define_insn "*avx_umulv2siv2di3"
5299   [(set (match_operand:V2DI 0 "register_operand" "=x")
5300         (mult:V2DI
5301           (zero_extend:V2DI
5302             (vec_select:V2SI
5303               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5304               (parallel [(const_int 0) (const_int 2)])))
5305           (zero_extend:V2DI
5306             (vec_select:V2SI
5307               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5308               (parallel [(const_int 0) (const_int 2)])))))]
5309   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5310   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5311   [(set_attr "type" "sseimul")
5312    (set_attr "prefix" "vex")
5313    (set_attr "mode" "TI")])
5314
5315 (define_insn "*sse2_umulv2siv2di3"
5316   [(set (match_operand:V2DI 0 "register_operand" "=x")
5317         (mult:V2DI
5318           (zero_extend:V2DI
5319             (vec_select:V2SI
5320               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5321               (parallel [(const_int 0) (const_int 2)])))
5322           (zero_extend:V2DI
5323             (vec_select:V2SI
5324               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5325               (parallel [(const_int 0) (const_int 2)])))))]
5326   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5327   "pmuludq\t{%2, %0|%0, %2}"
5328   [(set_attr "type" "sseimul")
5329    (set_attr "prefix_data16" "1")
5330    (set_attr "mode" "TI")])
5331
5332 (define_expand "sse4_1_mulv2siv2di3"
5333   [(set (match_operand:V2DI 0 "register_operand" "")
5334         (mult:V2DI
5335           (sign_extend:V2DI
5336             (vec_select:V2SI
5337               (match_operand:V4SI 1 "nonimmediate_operand" "")
5338               (parallel [(const_int 0) (const_int 2)])))
5339           (sign_extend:V2DI
5340             (vec_select:V2SI
5341               (match_operand:V4SI 2 "nonimmediate_operand" "")
5342               (parallel [(const_int 0) (const_int 2)])))))]
5343   "TARGET_SSE4_1"
5344   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5345
5346 (define_insn "*avx_mulv2siv2di3"
5347   [(set (match_operand:V2DI 0 "register_operand" "=x")
5348         (mult:V2DI
5349           (sign_extend:V2DI
5350             (vec_select:V2SI
5351               (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5352               (parallel [(const_int 0) (const_int 2)])))
5353           (sign_extend:V2DI
5354             (vec_select:V2SI
5355               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5356               (parallel [(const_int 0) (const_int 2)])))))]
5357   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5358   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5359   [(set_attr "type" "sseimul")
5360    (set_attr "prefix_extra" "1")
5361    (set_attr "prefix" "vex")
5362    (set_attr "mode" "TI")])
5363
5364 (define_insn "*sse4_1_mulv2siv2di3"
5365   [(set (match_operand:V2DI 0 "register_operand" "=x")
5366         (mult:V2DI
5367           (sign_extend:V2DI
5368             (vec_select:V2SI
5369               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5370               (parallel [(const_int 0) (const_int 2)])))
5371           (sign_extend:V2DI
5372             (vec_select:V2SI
5373               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5374               (parallel [(const_int 0) (const_int 2)])))))]
5375   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5376   "pmuldq\t{%2, %0|%0, %2}"
5377   [(set_attr "type" "sseimul")
5378    (set_attr "prefix_extra" "1")
5379    (set_attr "mode" "TI")])
5380
5381 (define_expand "sse2_pmaddwd"
5382   [(set (match_operand:V4SI 0 "register_operand" "")
5383         (plus:V4SI
5384           (mult:V4SI
5385             (sign_extend:V4SI
5386               (vec_select:V4HI
5387                 (match_operand:V8HI 1 "nonimmediate_operand" "")
5388                 (parallel [(const_int 0)
5389                            (const_int 2)
5390                            (const_int 4)
5391                            (const_int 6)])))
5392             (sign_extend:V4SI
5393               (vec_select:V4HI
5394                 (match_operand:V8HI 2 "nonimmediate_operand" "")
5395                 (parallel [(const_int 0)
5396                            (const_int 2)
5397                            (const_int 4)
5398                            (const_int 6)]))))
5399           (mult:V4SI
5400             (sign_extend:V4SI
5401               (vec_select:V4HI (match_dup 1)
5402                 (parallel [(const_int 1)
5403                            (const_int 3)
5404                            (const_int 5)
5405                            (const_int 7)])))
5406             (sign_extend:V4SI
5407               (vec_select:V4HI (match_dup 2)
5408                 (parallel [(const_int 1)
5409                            (const_int 3)
5410                            (const_int 5)
5411                            (const_int 7)]))))))]
5412   "TARGET_SSE2"
5413   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5414
5415 (define_insn "*avx_pmaddwd"
5416   [(set (match_operand:V4SI 0 "register_operand" "=x")
5417         (plus:V4SI
5418           (mult:V4SI
5419             (sign_extend:V4SI
5420               (vec_select:V4HI
5421                 (match_operand:V8HI 1 "nonimmediate_operand" "%x")
5422                 (parallel [(const_int 0)
5423                            (const_int 2)
5424                            (const_int 4)
5425                            (const_int 6)])))
5426             (sign_extend:V4SI
5427               (vec_select:V4HI
5428                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5429                 (parallel [(const_int 0)
5430                            (const_int 2)
5431                            (const_int 4)
5432                            (const_int 6)]))))
5433           (mult:V4SI
5434             (sign_extend:V4SI
5435               (vec_select:V4HI (match_dup 1)
5436                 (parallel [(const_int 1)
5437                            (const_int 3)
5438                            (const_int 5)
5439                            (const_int 7)])))
5440             (sign_extend:V4SI
5441               (vec_select:V4HI (match_dup 2)
5442                 (parallel [(const_int 1)
5443                            (const_int 3)
5444                            (const_int 5)
5445                            (const_int 7)]))))))]
5446   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5447   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5448   [(set_attr "type" "sseiadd")
5449    (set_attr "prefix" "vex")
5450    (set_attr "mode" "TI")])
5451
5452 (define_insn "*sse2_pmaddwd"
5453   [(set (match_operand:V4SI 0 "register_operand" "=x")
5454         (plus:V4SI
5455           (mult:V4SI
5456             (sign_extend:V4SI
5457               (vec_select:V4HI
5458                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
5459                 (parallel [(const_int 0)
5460                            (const_int 2)
5461                            (const_int 4)
5462                            (const_int 6)])))
5463             (sign_extend:V4SI
5464               (vec_select:V4HI
5465                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5466                 (parallel [(const_int 0)
5467                            (const_int 2)
5468                            (const_int 4)
5469                            (const_int 6)]))))
5470           (mult:V4SI
5471             (sign_extend:V4SI
5472               (vec_select:V4HI (match_dup 1)
5473                 (parallel [(const_int 1)
5474                            (const_int 3)
5475                            (const_int 5)
5476                            (const_int 7)])))
5477             (sign_extend:V4SI
5478               (vec_select:V4HI (match_dup 2)
5479                 (parallel [(const_int 1)
5480                            (const_int 3)
5481                            (const_int 5)
5482                            (const_int 7)]))))))]
5483   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5484   "pmaddwd\t{%2, %0|%0, %2}"
5485   [(set_attr "type" "sseiadd")
5486    (set_attr "atom_unit" "simul")
5487    (set_attr "prefix_data16" "1")
5488    (set_attr "mode" "TI")])
5489
5490 (define_expand "mulv4si3"
5491   [(set (match_operand:V4SI 0 "register_operand" "")
5492         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5493                    (match_operand:V4SI 2 "register_operand" "")))]
5494   "TARGET_SSE2"
5495 {
5496   if (TARGET_SSE4_1 || TARGET_AVX)
5497     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
5498 })
5499
5500 (define_insn "*avx_mulv4si3"
5501   [(set (match_operand:V4SI 0 "register_operand" "=x")
5502         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
5503                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5504   "TARGET_AVX && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5505   "vpmulld\t{%2, %1, %0|%0, %1, %2}"
5506   [(set_attr "type" "sseimul")
5507    (set_attr "prefix_extra" "1")
5508    (set_attr "prefix" "vex")
5509    (set_attr "mode" "TI")])
5510
5511 (define_insn "*sse4_1_mulv4si3"
5512   [(set (match_operand:V4SI 0 "register_operand" "=x")
5513         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
5514                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
5515   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5516   "pmulld\t{%2, %0|%0, %2}"
5517   [(set_attr "type" "sseimul")
5518    (set_attr "prefix_extra" "1")
5519    (set_attr "mode" "TI")])
5520
5521 (define_insn_and_split "*sse2_mulv4si3"
5522   [(set (match_operand:V4SI 0 "register_operand" "")
5523         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
5524                    (match_operand:V4SI 2 "register_operand" "")))]
5525   "TARGET_SSE2 && !TARGET_SSE4_1 && !TARGET_AVX
5526    && can_create_pseudo_p ()"
5527   "#"
5528   "&& 1"
5529   [(const_int 0)]
5530 {
5531   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5532   rtx op0, op1, op2;
5533
5534   op0 = operands[0];
5535   op1 = operands[1];
5536   op2 = operands[2];
5537   t1 = gen_reg_rtx (V4SImode);
5538   t2 = gen_reg_rtx (V4SImode);
5539   t3 = gen_reg_rtx (V4SImode);
5540   t4 = gen_reg_rtx (V4SImode);
5541   t5 = gen_reg_rtx (V4SImode);
5542   t6 = gen_reg_rtx (V4SImode);
5543   thirtytwo = GEN_INT (32);
5544
5545   /* Multiply elements 2 and 0.  */
5546   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
5547                                      op1, op2));
5548
5549   /* Shift both input vectors down one element, so that elements 3
5550      and 1 are now in the slots for elements 2 and 0.  For K8, at
5551      least, this is faster than using a shuffle.  */
5552   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5553                                  gen_lowpart (V1TImode, op1),
5554                                  thirtytwo));
5555   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5556                                  gen_lowpart (V1TImode, op2),
5557                                  thirtytwo));
5558   /* Multiply elements 3 and 1.  */
5559   emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
5560                                      t2, t3));
5561
5562   /* Move the results in element 2 down to element 1; we don't care
5563      what goes in elements 2 and 3.  */
5564   emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
5565                                 const0_rtx, const0_rtx));
5566   emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
5567                                 const0_rtx, const0_rtx));
5568
5569   /* Merge the parts back together.  */
5570   emit_insn (gen_vec_interleave_lowv4si (op0, t5, t6));
5571   DONE;
5572 })
5573
5574 (define_insn_and_split "mulv2di3"
5575   [(set (match_operand:V2DI 0 "register_operand" "")
5576         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
5577                    (match_operand:V2DI 2 "register_operand" "")))]
5578   "TARGET_SSE2
5579    && can_create_pseudo_p ()"
5580   "#"
5581   "&& 1"
5582   [(const_int 0)]
5583 {
5584   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
5585   rtx op0, op1, op2;
5586
5587   op0 = operands[0];
5588   op1 = operands[1];
5589   op2 = operands[2];
5590
5591   if (TARGET_XOP)
5592     {
5593       /* op1: A,B,C,D, op2: E,F,G,H */
5594       op1 = gen_lowpart (V4SImode, op1);
5595       op2 = gen_lowpart (V4SImode, op2);
5596
5597       t1 = gen_reg_rtx (V4SImode);
5598       t2 = gen_reg_rtx (V4SImode);
5599       t3 = gen_reg_rtx (V2DImode);
5600       t4 = gen_reg_rtx (V2DImode);
5601
5602       /* t1: B,A,D,C */
5603       emit_insn (gen_sse2_pshufd_1 (t1, op1,
5604                                     GEN_INT (1),
5605                                     GEN_INT (0),
5606                                     GEN_INT (3),
5607                                     GEN_INT (2)));
5608
5609       /* t2: (B*E),(A*F),(D*G),(C*H) */
5610       emit_insn (gen_mulv4si3 (t2, t1, op2));
5611
5612       /* t4: (B*E)+(A*F), (D*G)+(C*H) */
5613       emit_insn (gen_xop_phadddq (t3, t2));
5614
5615       /* t5: ((B*E)+(A*F))<<32, ((D*G)+(C*H))<<32 */
5616       emit_insn (gen_ashlv2di3 (t4, t3, GEN_INT (32)));
5617
5618       /* op0: (((B*E)+(A*F))<<32)+(B*F), (((D*G)+(C*H))<<32)+(D*H) */
5619       emit_insn (gen_xop_pmacsdql (op0, op1, op2, t4));
5620     }
5621   else
5622     {
5623       t1 = gen_reg_rtx (V2DImode);
5624       t2 = gen_reg_rtx (V2DImode);
5625       t3 = gen_reg_rtx (V2DImode);
5626       t4 = gen_reg_rtx (V2DImode);
5627       t5 = gen_reg_rtx (V2DImode);
5628       t6 = gen_reg_rtx (V2DImode);
5629       thirtytwo = GEN_INT (32);
5630
5631       /* Multiply low parts.  */
5632       emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
5633                                          gen_lowpart (V4SImode, op2)));
5634
5635       /* Shift input vectors left 32 bits so we can multiply high parts.  */
5636       emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
5637       emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
5638
5639       /* Multiply high parts by low parts.  */
5640       emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
5641                                          gen_lowpart (V4SImode, t3)));
5642       emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
5643                                          gen_lowpart (V4SImode, t2)));
5644
5645       /* Shift them back.  */
5646       emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
5647       emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
5648
5649       /* Add the three parts together.  */
5650       emit_insn (gen_addv2di3 (t6, t1, t4));
5651       emit_insn (gen_addv2di3 (op0, t6, t5));
5652     }
5653   DONE;
5654 })
5655
5656 (define_expand "vec_widen_smult_hi_v8hi"
5657   [(match_operand:V4SI 0 "register_operand" "")
5658    (match_operand:V8HI 1 "register_operand" "")
5659    (match_operand:V8HI 2 "register_operand" "")]
5660   "TARGET_SSE2"
5661 {
5662   rtx op1, op2, t1, t2, dest;
5663
5664   op1 = operands[1];
5665   op2 = operands[2];
5666   t1 = gen_reg_rtx (V8HImode);
5667   t2 = gen_reg_rtx (V8HImode);
5668   dest = gen_lowpart (V8HImode, operands[0]);
5669
5670   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5671   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5672   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5673   DONE;
5674 })
5675
5676 (define_expand "vec_widen_smult_lo_v8hi"
5677   [(match_operand:V4SI 0 "register_operand" "")
5678    (match_operand:V8HI 1 "register_operand" "")
5679    (match_operand:V8HI 2 "register_operand" "")]
5680   "TARGET_SSE2"
5681 {
5682   rtx op1, op2, t1, t2, dest;
5683
5684   op1 = operands[1];
5685   op2 = operands[2];
5686   t1 = gen_reg_rtx (V8HImode);
5687   t2 = gen_reg_rtx (V8HImode);
5688   dest = gen_lowpart (V8HImode, operands[0]);
5689
5690   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5691   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
5692   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5693   DONE;
5694 })
5695
5696 (define_expand "vec_widen_umult_hi_v8hi"
5697   [(match_operand:V4SI 0 "register_operand" "")
5698    (match_operand:V8HI 1 "register_operand" "")
5699    (match_operand:V8HI 2 "register_operand" "")]
5700   "TARGET_SSE2"
5701 {
5702   rtx op1, op2, t1, t2, dest;
5703
5704   op1 = operands[1];
5705   op2 = operands[2];
5706   t1 = gen_reg_rtx (V8HImode);
5707   t2 = gen_reg_rtx (V8HImode);
5708   dest = gen_lowpart (V8HImode, operands[0]);
5709
5710   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5711   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5712   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
5713   DONE;
5714 })
5715
5716 (define_expand "vec_widen_umult_lo_v8hi"
5717   [(match_operand:V4SI 0 "register_operand" "")
5718    (match_operand:V8HI 1 "register_operand" "")
5719    (match_operand:V8HI 2 "register_operand" "")]
5720   "TARGET_SSE2"
5721 {
5722   rtx op1, op2, t1, t2, dest;
5723
5724   op1 = operands[1];
5725   op2 = operands[2];
5726   t1 = gen_reg_rtx (V8HImode);
5727   t2 = gen_reg_rtx (V8HImode);
5728   dest = gen_lowpart (V8HImode, operands[0]);
5729
5730   emit_insn (gen_mulv8hi3 (t1, op1, op2));
5731   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
5732   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
5733   DONE;
5734 })
5735
5736 (define_expand "vec_widen_smult_hi_v4si"
5737   [(match_operand:V2DI 0 "register_operand" "")
5738    (match_operand:V4SI 1 "register_operand" "")
5739    (match_operand:V4SI 2 "register_operand" "")]
5740   "TARGET_XOP"
5741 {
5742   rtx t1, t2;
5743
5744   t1 = gen_reg_rtx (V4SImode);
5745   t2 = gen_reg_rtx (V4SImode);
5746
5747   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5748                                 GEN_INT (0),
5749                                 GEN_INT (2),
5750                                 GEN_INT (1),
5751                                 GEN_INT (3)));
5752   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5753                                 GEN_INT (0),
5754                                 GEN_INT (2),
5755                                 GEN_INT (1),
5756                                 GEN_INT (3)));
5757   emit_insn (gen_xop_mulv2div2di3_high (operands[0], t1, t2));
5758   DONE;
5759 })
5760
5761 (define_expand "vec_widen_smult_lo_v4si"
5762   [(match_operand:V2DI 0 "register_operand" "")
5763    (match_operand:V4SI 1 "register_operand" "")
5764    (match_operand:V4SI 2 "register_operand" "")]
5765   "TARGET_XOP"
5766 {
5767   rtx t1, t2;
5768
5769   t1 = gen_reg_rtx (V4SImode);
5770   t2 = gen_reg_rtx (V4SImode);
5771
5772   emit_insn (gen_sse2_pshufd_1 (t1, operands[1],
5773                                 GEN_INT (0),
5774                                 GEN_INT (2),
5775                                 GEN_INT (1),
5776                                 GEN_INT (3)));
5777   emit_insn (gen_sse2_pshufd_1 (t2, operands[2],
5778                                 GEN_INT (0),
5779                                 GEN_INT (2),
5780                                 GEN_INT (1),
5781                                 GEN_INT (3)));
5782   emit_insn (gen_xop_mulv2div2di3_low (operands[0], t1, t2));
5783   DONE;
5784 })
5785
5786 (define_expand "vec_widen_umult_hi_v4si"
5787   [(match_operand:V2DI 0 "register_operand" "")
5788    (match_operand:V4SI 1 "register_operand" "")
5789    (match_operand:V4SI 2 "register_operand" "")]
5790   "TARGET_SSE2"
5791 {
5792   rtx op1, op2, t1, t2;
5793
5794   op1 = operands[1];
5795   op2 = operands[2];
5796   t1 = gen_reg_rtx (V4SImode);
5797   t2 = gen_reg_rtx (V4SImode);
5798
5799   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
5800   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
5801   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5802   DONE;
5803 })
5804
5805 (define_expand "vec_widen_umult_lo_v4si"
5806   [(match_operand:V2DI 0 "register_operand" "")
5807    (match_operand:V4SI 1 "register_operand" "")
5808    (match_operand:V4SI 2 "register_operand" "")]
5809   "TARGET_SSE2"
5810 {
5811   rtx op1, op2, t1, t2;
5812
5813   op1 = operands[1];
5814   op2 = operands[2];
5815   t1 = gen_reg_rtx (V4SImode);
5816   t2 = gen_reg_rtx (V4SImode);
5817
5818   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
5819   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
5820   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
5821   DONE;
5822 })
5823
5824 (define_expand "sdot_prodv8hi"
5825   [(match_operand:V4SI 0 "register_operand" "")
5826    (match_operand:V8HI 1 "register_operand" "")
5827    (match_operand:V8HI 2 "register_operand" "")
5828    (match_operand:V4SI 3 "register_operand" "")]
5829   "TARGET_SSE2"
5830 {
5831   rtx t = gen_reg_rtx (V4SImode);
5832   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
5833   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
5834   DONE;
5835 })
5836
5837 (define_expand "udot_prodv4si"
5838   [(match_operand:V2DI 0 "register_operand" "")
5839    (match_operand:V4SI 1 "register_operand" "")
5840    (match_operand:V4SI 2 "register_operand" "")
5841    (match_operand:V2DI 3 "register_operand" "")]
5842   "TARGET_SSE2"
5843 {
5844   rtx t1, t2, t3, t4;
5845
5846   t1 = gen_reg_rtx (V2DImode);
5847   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
5848   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
5849
5850   t2 = gen_reg_rtx (V4SImode);
5851   t3 = gen_reg_rtx (V4SImode);
5852   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t2),
5853                                  gen_lowpart (V1TImode, operands[1]),
5854                                  GEN_INT (32)));
5855   emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, t3),
5856                                  gen_lowpart (V1TImode, operands[2]),
5857                                  GEN_INT (32)));
5858
5859   t4 = gen_reg_rtx (V2DImode);
5860   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
5861
5862   emit_insn (gen_addv2di3 (operands[0], t1, t4));
5863   DONE;
5864 })
5865
5866 (define_insn "*avx_ashr<mode>3"
5867   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5868         (ashiftrt:SSEMODE24
5869           (match_operand:SSEMODE24 1 "register_operand" "x")
5870           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5871   "TARGET_AVX"
5872   "vpsra<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5873   [(set_attr "type" "sseishft")
5874    (set_attr "prefix" "vex")
5875    (set (attr "length_immediate")
5876      (if_then_else (match_operand 2 "const_int_operand" "")
5877        (const_string "1")
5878        (const_string "0")))
5879    (set_attr "mode" "TI")])
5880
5881 (define_insn "ashr<mode>3"
5882   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
5883         (ashiftrt:SSEMODE24
5884           (match_operand:SSEMODE24 1 "register_operand" "0")
5885           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5886   "TARGET_SSE2"
5887   "psra<ssevecsize>\t{%2, %0|%0, %2}"
5888   [(set_attr "type" "sseishft")
5889    (set_attr "prefix_data16" "1")
5890    (set (attr "length_immediate")
5891      (if_then_else (match_operand 2 "const_int_operand" "")
5892        (const_string "1")
5893        (const_string "0")))
5894    (set_attr "mode" "TI")])
5895
5896 (define_insn "*avx_lshrv1ti3"
5897   [(set (match_operand:V1TI 0 "register_operand" "=x")
5898         (lshiftrt:V1TI
5899          (match_operand:V1TI 1 "register_operand" "x")
5900          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5901   "TARGET_AVX"
5902 {
5903   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5904   return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5905 }
5906   [(set_attr "type" "sseishft")
5907    (set_attr "prefix" "vex")
5908    (set_attr "length_immediate" "1")
5909    (set_attr "mode" "TI")])
5910
5911 (define_insn "*avx_lshr<mode>3"
5912   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5913         (lshiftrt:SSEMODE248
5914           (match_operand:SSEMODE248 1 "register_operand" "x")
5915           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5916   "TARGET_AVX"
5917   "vpsrl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5918   [(set_attr "type" "sseishft")
5919    (set_attr "prefix" "vex")
5920    (set (attr "length_immediate")
5921      (if_then_else (match_operand 2 "const_int_operand" "")
5922        (const_string "1")
5923        (const_string "0")))
5924    (set_attr "mode" "TI")])
5925
5926 (define_insn "sse2_lshrv1ti3"
5927   [(set (match_operand:V1TI 0 "register_operand" "=x")
5928         (lshiftrt:V1TI
5929          (match_operand:V1TI 1 "register_operand" "0")
5930          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5931   "TARGET_SSE2"
5932 {
5933   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5934   return "psrldq\t{%2, %0|%0, %2}";
5935 }
5936   [(set_attr "type" "sseishft")
5937    (set_attr "prefix_data16" "1")
5938    (set_attr "length_immediate" "1")
5939    (set_attr "atom_unit" "sishuf")
5940    (set_attr "mode" "TI")])
5941
5942 (define_insn "lshr<mode>3"
5943   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5944         (lshiftrt:SSEMODE248
5945           (match_operand:SSEMODE248 1 "register_operand" "0")
5946           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5947   "TARGET_SSE2"
5948   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
5949   [(set_attr "type" "sseishft")
5950    (set_attr "prefix_data16" "1")
5951    (set (attr "length_immediate")
5952      (if_then_else (match_operand 2 "const_int_operand" "")
5953        (const_string "1")
5954        (const_string "0")))
5955    (set_attr "mode" "TI")])
5956
5957 (define_insn "*avx_ashlv1ti3"
5958   [(set (match_operand:V1TI 0 "register_operand" "=x")
5959         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "x")
5960                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5961   "TARGET_AVX"
5962 {
5963   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5964   return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
5965 }
5966   [(set_attr "type" "sseishft")
5967    (set_attr "prefix" "vex")
5968    (set_attr "length_immediate" "1")
5969    (set_attr "mode" "TI")])
5970
5971 (define_insn "*avx_ashl<mode>3"
5972   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
5973         (ashift:SSEMODE248
5974           (match_operand:SSEMODE248 1 "register_operand" "x")
5975           (match_operand:SI 2 "nonmemory_operand" "xN")))]
5976   "TARGET_AVX"
5977   "vpsll<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
5978   [(set_attr "type" "sseishft")
5979    (set_attr "prefix" "vex")
5980    (set (attr "length_immediate")
5981      (if_then_else (match_operand 2 "const_int_operand" "")
5982        (const_string "1")
5983        (const_string "0")))
5984    (set_attr "mode" "TI")])
5985
5986 (define_insn "sse2_ashlv1ti3"
5987   [(set (match_operand:V1TI 0 "register_operand" "=x")
5988         (ashift:V1TI (match_operand:V1TI 1 "register_operand" "0")
5989                      (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n")))]
5990   "TARGET_SSE2"
5991 {
5992   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5993   return "pslldq\t{%2, %0|%0, %2}";
5994 }
5995   [(set_attr "type" "sseishft")
5996    (set_attr "prefix_data16" "1")
5997    (set_attr "length_immediate" "1")
5998    (set_attr "mode" "TI")])
5999
6000 (define_insn "ashl<mode>3"
6001   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
6002         (ashift:SSEMODE248
6003           (match_operand:SSEMODE248 1 "register_operand" "0")
6004           (match_operand:SI 2 "nonmemory_operand" "xN")))]
6005   "TARGET_SSE2"
6006   "psll<ssevecsize>\t{%2, %0|%0, %2}"
6007   [(set_attr "type" "sseishft")
6008    (set_attr "prefix_data16" "1")
6009    (set (attr "length_immediate")
6010      (if_then_else (match_operand 2 "const_int_operand" "")
6011        (const_string "1")
6012        (const_string "0")))
6013    (set_attr "mode" "TI")])
6014
6015 (define_expand "vec_shl_<mode>"
6016   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6017         (ashift:V1TI
6018          (match_operand:SSEMODEI 1 "register_operand" "")
6019          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6020   "TARGET_SSE2"
6021 {
6022   operands[0] = gen_lowpart (V1TImode, operands[0]);
6023   operands[1] = gen_lowpart (V1TImode, operands[1]);
6024 })
6025
6026 (define_expand "vec_shr_<mode>"
6027   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6028         (lshiftrt:V1TI
6029          (match_operand:SSEMODEI 1 "register_operand" "")
6030          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "")))]
6031   "TARGET_SSE2"
6032 {
6033   operands[0] = gen_lowpart (V1TImode, operands[0]);
6034   operands[1] = gen_lowpart (V1TImode, operands[1]);
6035 })
6036
6037 (define_insn "*avx_<code><mode>3"
6038   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6039         (umaxmin:SSEMODE124
6040           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
6041           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6042   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6043   "vp<maxmin_int><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6044   [(set_attr "type" "sseiadd")
6045    (set (attr "prefix_extra")
6046      (if_then_else (match_operand:V16QI 0 "" "")
6047        (const_string "0")
6048        (const_string "1")))
6049    (set_attr "prefix" "vex")
6050    (set_attr "mode" "TI")])
6051
6052 (define_expand "<code>v16qi3"
6053   [(set (match_operand:V16QI 0 "register_operand" "")
6054         (umaxmin:V16QI
6055           (match_operand:V16QI 1 "nonimmediate_operand" "")
6056           (match_operand:V16QI 2 "nonimmediate_operand" "")))]
6057   "TARGET_SSE2"
6058   "ix86_fixup_binary_operands_no_copy (<CODE>, V16QImode, operands);")
6059
6060 (define_insn "*<code>v16qi3"
6061   [(set (match_operand:V16QI 0 "register_operand" "=x")
6062         (umaxmin:V16QI
6063           (match_operand:V16QI 1 "nonimmediate_operand" "%0")
6064           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
6065   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
6066   "p<maxmin_int>b\t{%2, %0|%0, %2}"
6067   [(set_attr "type" "sseiadd")
6068    (set_attr "prefix_data16" "1")
6069    (set_attr "mode" "TI")])
6070
6071 (define_insn "*avx_<code><mode>3"
6072   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6073         (smaxmin:SSEMODE124
6074           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%x")
6075           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6076   "TARGET_AVX && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6077   "vp<maxmin_int><ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6078   [(set_attr "type" "sseiadd")
6079    (set (attr "prefix_extra")
6080      (if_then_else (match_operand:V8HI 0 "" "")
6081        (const_string "0")
6082        (const_string "1")))
6083    (set_attr "prefix" "vex")
6084    (set_attr "mode" "TI")])
6085
6086 (define_expand "<code>v8hi3"
6087   [(set (match_operand:V8HI 0 "register_operand" "")
6088         (smaxmin:V8HI
6089           (match_operand:V8HI 1 "nonimmediate_operand" "")
6090           (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6091   "TARGET_SSE2"
6092   "ix86_fixup_binary_operands_no_copy (<CODE>, V8HImode, operands);")
6093
6094 (define_insn "*<code>v8hi3"
6095   [(set (match_operand:V8HI 0 "register_operand" "=x")
6096         (smaxmin:V8HI
6097           (match_operand:V8HI 1 "nonimmediate_operand" "%0")
6098           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
6099   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
6100   "p<maxmin_int>w\t{%2, %0|%0, %2}"
6101   [(set_attr "type" "sseiadd")
6102    (set_attr "prefix_data16" "1")
6103    (set_attr "mode" "TI")])
6104
6105 (define_expand "umaxv8hi3"
6106   [(set (match_operand:V8HI 0 "register_operand" "")
6107         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
6108                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
6109   "TARGET_SSE2"
6110 {
6111   if (TARGET_SSE4_1)
6112     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
6113   else
6114     {
6115       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
6116       if (rtx_equal_p (op3, op2))
6117         op3 = gen_reg_rtx (V8HImode);
6118       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
6119       emit_insn (gen_addv8hi3 (op0, op3, op2));
6120       DONE;
6121     }
6122 })
6123
6124 (define_expand "smax<mode>3"
6125   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6126         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6127                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6128   "TARGET_SSE2"
6129 {
6130   if (TARGET_SSE4_1)
6131     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
6132   else
6133     {
6134       rtx xops[6];
6135       bool ok;
6136
6137       xops[0] = operands[0];
6138       xops[1] = operands[1];
6139       xops[2] = operands[2];
6140       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6141       xops[4] = operands[1];
6142       xops[5] = operands[2];
6143       ok = ix86_expand_int_vcond (xops);
6144       gcc_assert (ok);
6145       DONE;
6146     }
6147 })
6148
6149 (define_insn "*sse4_1_<code><mode>3"
6150   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
6151         (smaxmin:SSEMODE14
6152           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
6153           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
6154   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6155   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6156   [(set_attr "type" "sseiadd")
6157    (set_attr "prefix_extra" "1")
6158    (set_attr "mode" "TI")])
6159
6160 (define_expand "smaxv2di3"
6161   [(set (match_operand:V2DI 0 "register_operand" "")
6162         (smax:V2DI (match_operand:V2DI 1 "register_operand" "")
6163                    (match_operand:V2DI 2 "register_operand" "")))]
6164   "TARGET_SSE4_2"
6165 {
6166   rtx xops[6];
6167   bool ok;
6168
6169   xops[0] = operands[0];
6170   xops[1] = operands[1];
6171   xops[2] = operands[2];
6172   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6173   xops[4] = operands[1];
6174   xops[5] = operands[2];
6175   ok = ix86_expand_int_vcond (xops);
6176   gcc_assert (ok);
6177   DONE;
6178 })
6179
6180 (define_expand "umaxv4si3"
6181   [(set (match_operand:V4SI 0 "register_operand" "")
6182         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
6183                    (match_operand:V4SI 2 "register_operand" "")))]
6184   "TARGET_SSE2"
6185 {
6186   if (TARGET_SSE4_1)
6187     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
6188   else
6189     {
6190       rtx xops[6];
6191       bool ok;
6192
6193       xops[0] = operands[0];
6194       xops[1] = operands[1];
6195       xops[2] = operands[2];
6196       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6197       xops[4] = operands[1];
6198       xops[5] = operands[2];
6199       ok = ix86_expand_int_vcond (xops);
6200       gcc_assert (ok);
6201       DONE;
6202     }
6203 })
6204
6205 (define_insn "*sse4_1_<code><mode>3"
6206   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
6207         (umaxmin:SSEMODE24
6208           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
6209           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
6210   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6211   "p<maxmin_int><ssevecsize>\t{%2, %0|%0, %2}"
6212   [(set_attr "type" "sseiadd")
6213    (set_attr "prefix_extra" "1")
6214    (set_attr "mode" "TI")])
6215
6216 (define_expand "umaxv2di3"
6217   [(set (match_operand:V2DI 0 "register_operand" "")
6218         (umax:V2DI (match_operand:V2DI 1 "register_operand" "")
6219                    (match_operand:V2DI 2 "register_operand" "")))]
6220   "TARGET_SSE4_2"
6221 {
6222   rtx xops[6];
6223   bool ok;
6224
6225   xops[0] = operands[0];
6226   xops[1] = operands[1];
6227   xops[2] = operands[2];
6228   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6229   xops[4] = operands[1];
6230   xops[5] = operands[2];
6231   ok = ix86_expand_int_vcond (xops);
6232   gcc_assert (ok);
6233   DONE;
6234 })
6235
6236 (define_expand "smin<mode>3"
6237   [(set (match_operand:SSEMODE14 0 "register_operand" "")
6238         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
6239                         (match_operand:SSEMODE14 2 "register_operand" "")))]
6240   "TARGET_SSE2"
6241 {
6242   if (TARGET_SSE4_1)
6243     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
6244   else
6245     {
6246       rtx xops[6];
6247       bool ok;
6248
6249       xops[0] = operands[0];
6250       xops[1] = operands[2];
6251       xops[2] = operands[1];
6252       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6253       xops[4] = operands[1];
6254       xops[5] = operands[2];
6255       ok = ix86_expand_int_vcond (xops);
6256       gcc_assert (ok);
6257       DONE;
6258     }
6259 })
6260
6261 (define_expand "sminv2di3"
6262   [(set (match_operand:V2DI 0 "register_operand" "")
6263         (smin:V2DI (match_operand:V2DI 1 "register_operand" "")
6264                    (match_operand:V2DI 2 "register_operand" "")))]
6265   "TARGET_SSE4_2"
6266 {
6267   rtx xops[6];
6268   bool ok;
6269
6270   xops[0] = operands[0];
6271   xops[1] = operands[2];
6272   xops[2] = operands[1];
6273   xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
6274   xops[4] = operands[1];
6275   xops[5] = operands[2];
6276   ok = ix86_expand_int_vcond (xops);
6277   gcc_assert (ok);
6278   DONE;
6279 })
6280
6281 (define_expand "umin<mode>3"
6282   [(set (match_operand:SSEMODE24 0 "register_operand" "")
6283         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
6284                         (match_operand:SSEMODE24 2 "register_operand" "")))]
6285   "TARGET_SSE2"
6286 {
6287   if (TARGET_SSE4_1)
6288     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
6289   else
6290     {
6291       rtx xops[6];
6292       bool ok;
6293
6294       xops[0] = operands[0];
6295       xops[1] = operands[2];
6296       xops[2] = operands[1];
6297       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6298       xops[4] = operands[1];
6299       xops[5] = operands[2];
6300       ok = ix86_expand_int_vcond (xops);
6301       gcc_assert (ok);
6302       DONE;
6303     }
6304 })
6305
6306 (define_expand "uminv2di3"
6307   [(set (match_operand:V2DI 0 "register_operand" "")
6308         (umin:V2DI (match_operand:V2DI 1 "register_operand" "")
6309                    (match_operand:V2DI 2 "register_operand" "")))]
6310   "TARGET_SSE4_2"
6311 {
6312   rtx xops[6];
6313   bool ok;
6314
6315   xops[0] = operands[0];
6316   xops[1] = operands[2];
6317   xops[2] = operands[1];
6318   xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6319   xops[4] = operands[1];
6320   xops[5] = operands[2];
6321   ok = ix86_expand_int_vcond (xops);
6322   gcc_assert (ok);
6323   DONE;
6324 })
6325
6326 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6327 ;;
6328 ;; Parallel integral comparisons
6329 ;;
6330 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6331
6332 (define_expand "sse2_eq<mode>3"
6333   [(set (match_operand:SSEMODE124 0 "register_operand" "")
6334         (eq:SSEMODE124
6335           (match_operand:SSEMODE124 1 "nonimmediate_operand" "")
6336           (match_operand:SSEMODE124 2 "nonimmediate_operand" "")))]
6337   "TARGET_SSE2 && !TARGET_XOP "
6338   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
6339
6340 (define_insn "*avx_eq<mode>3"
6341   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6342         (eq:SSEMODE1248
6343           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "%x")
6344           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6345   "TARGET_AVX && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6346   "vpcmpeq<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6347   [(set_attr "type" "ssecmp")
6348    (set (attr "prefix_extra")
6349      (if_then_else (match_operand:V2DI 0 "" "")
6350        (const_string "1")
6351        (const_string "*")))
6352    (set_attr "prefix" "vex")
6353    (set_attr "mode" "TI")])
6354
6355 (define_insn "*sse2_eq<mode>3"
6356   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6357         (eq:SSEMODE124
6358           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
6359           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6360   "TARGET_SSE2 && !TARGET_XOP
6361    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6362   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
6363   [(set_attr "type" "ssecmp")
6364    (set_attr "prefix_data16" "1")
6365    (set_attr "mode" "TI")])
6366
6367 (define_expand "sse4_1_eqv2di3"
6368   [(set (match_operand:V2DI 0 "register_operand" "")
6369         (eq:V2DI
6370           (match_operand:V2DI 1 "nonimmediate_operand" "")
6371           (match_operand:V2DI 2 "nonimmediate_operand" "")))]
6372   "TARGET_SSE4_1"
6373   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
6374
6375 (define_insn "*sse4_1_eqv2di3"
6376   [(set (match_operand:V2DI 0 "register_operand" "=x")
6377         (eq:V2DI
6378           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
6379           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6380   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
6381   "pcmpeqq\t{%2, %0|%0, %2}"
6382   [(set_attr "type" "ssecmp")
6383    (set_attr "prefix_extra" "1")
6384    (set_attr "mode" "TI")])
6385
6386 (define_insn "*avx_gt<mode>3"
6387   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
6388         (gt:SSEMODE1248
6389           (match_operand:SSEMODE1248 1 "register_operand" "x")
6390           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")))]
6391   "TARGET_AVX"
6392   "vpcmpgt<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
6393   [(set_attr "type" "ssecmp")
6394    (set (attr "prefix_extra")
6395      (if_then_else (match_operand:V2DI 0 "" "")
6396        (const_string "1")
6397        (const_string "*")))
6398    (set_attr "prefix" "vex")
6399    (set_attr "mode" "TI")])
6400
6401 (define_insn "sse2_gt<mode>3"
6402   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6403         (gt:SSEMODE124
6404           (match_operand:SSEMODE124 1 "register_operand" "0")
6405           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
6406   "TARGET_SSE2 && !TARGET_XOP"
6407   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
6408   [(set_attr "type" "ssecmp")
6409    (set_attr "prefix_data16" "1")
6410    (set_attr "mode" "TI")])
6411
6412 (define_insn "sse4_2_gtv2di3"
6413   [(set (match_operand:V2DI 0 "register_operand" "=x")
6414         (gt:V2DI
6415           (match_operand:V2DI 1 "register_operand" "0")
6416           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
6417   "TARGET_SSE4_2"
6418   "pcmpgtq\t{%2, %0|%0, %2}"
6419   [(set_attr "type" "ssecmp")
6420    (set_attr "prefix_extra" "1")
6421    (set_attr "mode" "TI")])
6422
6423 (define_expand "vcond<mode>"
6424   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6425         (if_then_else:SSEMODE124C8
6426           (match_operator 3 ""
6427             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6428              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6429           (match_operand:SSEMODE124C8 1 "general_operand" "")
6430           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6431   "TARGET_SSE2"
6432 {
6433   bool ok = ix86_expand_int_vcond (operands);
6434   gcc_assert (ok);
6435   DONE;
6436 })
6437
6438 (define_expand "vcondu<mode>"
6439   [(set (match_operand:SSEMODE124C8 0 "register_operand" "")
6440         (if_then_else:SSEMODE124C8
6441           (match_operator 3 ""
6442             [(match_operand:SSEMODE124C8 4 "nonimmediate_operand" "")
6443              (match_operand:SSEMODE124C8 5 "nonimmediate_operand" "")])
6444           (match_operand:SSEMODE124C8 1 "general_operand" "")
6445           (match_operand:SSEMODE124C8 2 "general_operand" "")))]
6446   "TARGET_SSE2"
6447 {
6448   bool ok = ix86_expand_int_vcond (operands);
6449   gcc_assert (ok);
6450   DONE;
6451 })
6452
6453 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6454 ;;
6455 ;; Parallel bitwise logical operations
6456 ;;
6457 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6458
6459 (define_expand "one_cmpl<mode>2"
6460   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6461         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6462                       (match_dup 2)))]
6463   "TARGET_SSE2"
6464 {
6465   int i, n = GET_MODE_NUNITS (<MODE>mode);
6466   rtvec v = rtvec_alloc (n);
6467
6468   for (i = 0; i < n; ++i)
6469     RTVEC_ELT (v, i) = constm1_rtx;
6470
6471   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
6472 })
6473
6474 (define_insn "*avx_andnot<mode>3"
6475   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6476         (and:AVX256MODEI
6477           (not:AVX256MODEI (match_operand:AVX256MODEI 1 "register_operand" "x"))
6478           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6479   "TARGET_AVX"
6480   "vandnps\t{%2, %1, %0|%0, %1, %2}"
6481   [(set_attr "type" "sselog")
6482    (set_attr "prefix" "vex")
6483    (set_attr "mode" "<avxvecpsmode>")])
6484
6485 (define_insn "*sse_andnot<mode>3"
6486   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6487         (and:SSEMODEI
6488           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6489           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6490   "(TARGET_SSE && !TARGET_SSE2)"
6491   "andnps\t{%2, %0|%0, %2}"
6492   [(set_attr "type" "sselog")
6493    (set_attr "mode" "V4SF")])
6494
6495 (define_insn "*avx_andnot<mode>3"
6496   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6497         (and:SSEMODEI
6498           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "x"))
6499           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6500   "TARGET_AVX"
6501   "vpandn\t{%2, %1, %0|%0, %1, %2}"
6502   [(set_attr "type" "sselog")
6503    (set_attr "prefix" "vex")
6504    (set_attr "mode" "TI")])
6505
6506 (define_insn "sse2_andnot<mode>3"
6507   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6508         (and:SSEMODEI
6509           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
6510           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6511   "TARGET_SSE2"
6512   "pandn\t{%2, %0|%0, %2}"
6513   [(set_attr "type" "sselog")
6514    (set_attr "prefix_data16" "1")
6515    (set_attr "mode" "TI")])
6516
6517 (define_insn "*andnottf3"
6518   [(set (match_operand:TF 0 "register_operand" "=x")
6519         (and:TF
6520           (not:TF (match_operand:TF 1 "register_operand" "0"))
6521           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6522   "TARGET_SSE2"
6523   "pandn\t{%2, %0|%0, %2}"
6524   [(set_attr "type" "sselog")
6525    (set_attr "prefix_data16" "1")
6526    (set_attr "mode" "TI")])
6527
6528 (define_expand "<code><mode>3"
6529   [(set (match_operand:SSEMODEI 0 "register_operand" "")
6530         (any_logic:SSEMODEI
6531           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
6532           (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
6533   "TARGET_SSE"
6534   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
6535
6536 (define_insn "*avx_<code><mode>3"
6537   [(set (match_operand:AVX256MODEI 0 "register_operand" "=x")
6538         (any_logic:AVX256MODEI
6539           (match_operand:AVX256MODEI 1 "nonimmediate_operand" "%x")
6540           (match_operand:AVX256MODEI 2 "nonimmediate_operand" "xm")))]
6541   "TARGET_AVX
6542    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6543   "v<logic>ps\t{%2, %1, %0|%0, %1, %2}"
6544   [(set_attr "type" "sselog")
6545    (set_attr "prefix" "vex")
6546    (set_attr "mode" "<avxvecpsmode>")])
6547
6548 (define_insn "*sse_<code><mode>3"
6549   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6550         (any_logic:SSEMODEI
6551           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6552           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6553   "(TARGET_SSE && !TARGET_SSE2)
6554    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6555   "<logic>ps\t{%2, %0|%0, %2}"
6556   [(set_attr "type" "sselog")
6557    (set_attr "mode" "V4SF")])
6558
6559 (define_insn "*avx_<code><mode>3"
6560   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6561         (any_logic:SSEMODEI
6562           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%x")
6563           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6564   "TARGET_AVX
6565    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6566   "vp<logic>\t{%2, %1, %0|%0, %1, %2}"
6567   [(set_attr "type" "sselog")
6568    (set_attr "prefix" "vex")
6569    (set_attr "mode" "TI")])
6570
6571 (define_insn "*sse2_<code><mode>3"
6572   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
6573         (any_logic:SSEMODEI
6574           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
6575           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
6576   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6577   "p<logic>\t{%2, %0|%0, %2}"
6578   [(set_attr "type" "sselog")
6579    (set_attr "prefix_data16" "1")
6580    (set_attr "mode" "TI")])
6581
6582 (define_expand "<code>tf3"
6583   [(set (match_operand:TF 0 "register_operand" "")
6584         (any_logic:TF
6585           (match_operand:TF 1 "nonimmediate_operand" "")
6586           (match_operand:TF 2 "nonimmediate_operand" "")))]
6587   "TARGET_SSE2"
6588   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
6589
6590 (define_insn "*<code>tf3"
6591   [(set (match_operand:TF 0 "register_operand" "=x")
6592         (any_logic:TF
6593           (match_operand:TF 1 "nonimmediate_operand" "%0")
6594           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
6595   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
6596   "p<logic>\t{%2, %0|%0, %2}"
6597   [(set_attr "type" "sselog")
6598    (set_attr "prefix_data16" "1")
6599    (set_attr "mode" "TI")])
6600
6601 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6602 ;;
6603 ;; Parallel integral element swizzling
6604 ;;
6605 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6606
6607 (define_expand "vec_pack_trunc_v8hi"
6608   [(match_operand:V16QI 0 "register_operand" "")
6609    (match_operand:V8HI 1 "register_operand" "")
6610    (match_operand:V8HI 2 "register_operand" "")]
6611   "TARGET_SSE2"
6612 {
6613   rtx op1 = gen_lowpart (V16QImode, operands[1]);
6614   rtx op2 = gen_lowpart (V16QImode, operands[2]);
6615   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6616   DONE;
6617 })
6618
6619 (define_expand "vec_pack_trunc_v4si"
6620   [(match_operand:V8HI 0 "register_operand" "")
6621    (match_operand:V4SI 1 "register_operand" "")
6622    (match_operand:V4SI 2 "register_operand" "")]
6623   "TARGET_SSE2"
6624 {
6625   rtx op1 = gen_lowpart (V8HImode, operands[1]);
6626   rtx op2 = gen_lowpart (V8HImode, operands[2]);
6627   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6628   DONE;
6629 })
6630
6631 (define_expand "vec_pack_trunc_v2di"
6632   [(match_operand:V4SI 0 "register_operand" "")
6633    (match_operand:V2DI 1 "register_operand" "")
6634    (match_operand:V2DI 2 "register_operand" "")]
6635   "TARGET_SSE2"
6636 {
6637   rtx op1 = gen_lowpart (V4SImode, operands[1]);
6638   rtx op2 = gen_lowpart (V4SImode, operands[2]);
6639   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6640   DONE;
6641 })
6642
6643 (define_insn "*avx_packsswb"
6644   [(set (match_operand:V16QI 0 "register_operand" "=x")
6645         (vec_concat:V16QI
6646           (ss_truncate:V8QI
6647             (match_operand:V8HI 1 "register_operand" "x"))
6648           (ss_truncate:V8QI
6649             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6650   "TARGET_AVX"
6651   "vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6652   [(set_attr "type" "sselog")
6653    (set_attr "prefix" "vex")
6654    (set_attr "mode" "TI")])
6655
6656 (define_insn "sse2_packsswb"
6657   [(set (match_operand:V16QI 0 "register_operand" "=x")
6658         (vec_concat:V16QI
6659           (ss_truncate:V8QI
6660             (match_operand:V8HI 1 "register_operand" "0"))
6661           (ss_truncate:V8QI
6662             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6663   "TARGET_SSE2"
6664   "packsswb\t{%2, %0|%0, %2}"
6665   [(set_attr "type" "sselog")
6666    (set_attr "prefix_data16" "1")
6667    (set_attr "mode" "TI")])
6668
6669 (define_insn "*avx_packssdw"
6670   [(set (match_operand:V8HI 0 "register_operand" "=x")
6671         (vec_concat:V8HI
6672           (ss_truncate:V4HI
6673             (match_operand:V4SI 1 "register_operand" "x"))
6674           (ss_truncate:V4HI
6675             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6676   "TARGET_AVX"
6677   "vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6678   [(set_attr "type" "sselog")
6679    (set_attr "prefix" "vex")
6680    (set_attr "mode" "TI")])
6681
6682 (define_insn "sse2_packssdw"
6683   [(set (match_operand:V8HI 0 "register_operand" "=x")
6684         (vec_concat:V8HI
6685           (ss_truncate:V4HI
6686             (match_operand:V4SI 1 "register_operand" "0"))
6687           (ss_truncate:V4HI
6688             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6689   "TARGET_SSE2"
6690   "packssdw\t{%2, %0|%0, %2}"
6691   [(set_attr "type" "sselog")
6692    (set_attr "prefix_data16" "1")
6693    (set_attr "mode" "TI")])
6694
6695 (define_insn "*avx_packuswb"
6696   [(set (match_operand:V16QI 0 "register_operand" "=x")
6697         (vec_concat:V16QI
6698           (us_truncate:V8QI
6699             (match_operand:V8HI 1 "register_operand" "x"))
6700           (us_truncate:V8QI
6701             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6702   "TARGET_AVX"
6703   "vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6704   [(set_attr "type" "sselog")
6705    (set_attr "prefix" "vex")
6706    (set_attr "mode" "TI")])
6707
6708 (define_insn "sse2_packuswb"
6709   [(set (match_operand:V16QI 0 "register_operand" "=x")
6710         (vec_concat:V16QI
6711           (us_truncate:V8QI
6712             (match_operand:V8HI 1 "register_operand" "0"))
6713           (us_truncate:V8QI
6714             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
6715   "TARGET_SSE2"
6716   "packuswb\t{%2, %0|%0, %2}"
6717   [(set_attr "type" "sselog")
6718    (set_attr "prefix_data16" "1")
6719    (set_attr "mode" "TI")])
6720
6721 (define_insn "*avx_interleave_highv16qi"
6722   [(set (match_operand:V16QI 0 "register_operand" "=x")
6723         (vec_select:V16QI
6724           (vec_concat:V32QI
6725             (match_operand:V16QI 1 "register_operand" "x")
6726             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6727           (parallel [(const_int 8)  (const_int 24)
6728                      (const_int 9)  (const_int 25)
6729                      (const_int 10) (const_int 26)
6730                      (const_int 11) (const_int 27)
6731                      (const_int 12) (const_int 28)
6732                      (const_int 13) (const_int 29)
6733                      (const_int 14) (const_int 30)
6734                      (const_int 15) (const_int 31)])))]
6735   "TARGET_AVX"
6736   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6737   [(set_attr "type" "sselog")
6738    (set_attr "prefix" "vex")
6739    (set_attr "mode" "TI")])
6740
6741 (define_insn "vec_interleave_highv16qi"
6742   [(set (match_operand:V16QI 0 "register_operand" "=x")
6743         (vec_select:V16QI
6744           (vec_concat:V32QI
6745             (match_operand:V16QI 1 "register_operand" "0")
6746             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6747           (parallel [(const_int 8)  (const_int 24)
6748                      (const_int 9)  (const_int 25)
6749                      (const_int 10) (const_int 26)
6750                      (const_int 11) (const_int 27)
6751                      (const_int 12) (const_int 28)
6752                      (const_int 13) (const_int 29)
6753                      (const_int 14) (const_int 30)
6754                      (const_int 15) (const_int 31)])))]
6755   "TARGET_SSE2"
6756   "punpckhbw\t{%2, %0|%0, %2}"
6757   [(set_attr "type" "sselog")
6758    (set_attr "prefix_data16" "1")
6759    (set_attr "mode" "TI")])
6760
6761 (define_insn "*avx_interleave_lowv16qi"
6762   [(set (match_operand:V16QI 0 "register_operand" "=x")
6763         (vec_select:V16QI
6764           (vec_concat:V32QI
6765             (match_operand:V16QI 1 "register_operand" "x")
6766             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6767           (parallel [(const_int 0) (const_int 16)
6768                      (const_int 1) (const_int 17)
6769                      (const_int 2) (const_int 18)
6770                      (const_int 3) (const_int 19)
6771                      (const_int 4) (const_int 20)
6772                      (const_int 5) (const_int 21)
6773                      (const_int 6) (const_int 22)
6774                      (const_int 7) (const_int 23)])))]
6775   "TARGET_AVX"
6776   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6777   [(set_attr "type" "sselog")
6778    (set_attr "prefix" "vex")
6779    (set_attr "mode" "TI")])
6780
6781 (define_insn "vec_interleave_lowv16qi"
6782   [(set (match_operand:V16QI 0 "register_operand" "=x")
6783         (vec_select:V16QI
6784           (vec_concat:V32QI
6785             (match_operand:V16QI 1 "register_operand" "0")
6786             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
6787           (parallel [(const_int 0) (const_int 16)
6788                      (const_int 1) (const_int 17)
6789                      (const_int 2) (const_int 18)
6790                      (const_int 3) (const_int 19)
6791                      (const_int 4) (const_int 20)
6792                      (const_int 5) (const_int 21)
6793                      (const_int 6) (const_int 22)
6794                      (const_int 7) (const_int 23)])))]
6795   "TARGET_SSE2"
6796   "punpcklbw\t{%2, %0|%0, %2}"
6797   [(set_attr "type" "sselog")
6798    (set_attr "prefix_data16" "1")
6799    (set_attr "mode" "TI")])
6800
6801 (define_insn "*avx_interleave_highv8hi"
6802   [(set (match_operand:V8HI 0 "register_operand" "=x")
6803         (vec_select:V8HI
6804           (vec_concat:V16HI
6805             (match_operand:V8HI 1 "register_operand" "x")
6806             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6807           (parallel [(const_int 4) (const_int 12)
6808                      (const_int 5) (const_int 13)
6809                      (const_int 6) (const_int 14)
6810                      (const_int 7) (const_int 15)])))]
6811   "TARGET_AVX"
6812   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6813   [(set_attr "type" "sselog")
6814    (set_attr "prefix" "vex")
6815    (set_attr "mode" "TI")])
6816
6817 (define_insn "vec_interleave_highv8hi"
6818   [(set (match_operand:V8HI 0 "register_operand" "=x")
6819         (vec_select:V8HI
6820           (vec_concat:V16HI
6821             (match_operand:V8HI 1 "register_operand" "0")
6822             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6823           (parallel [(const_int 4) (const_int 12)
6824                      (const_int 5) (const_int 13)
6825                      (const_int 6) (const_int 14)
6826                      (const_int 7) (const_int 15)])))]
6827   "TARGET_SSE2"
6828   "punpckhwd\t{%2, %0|%0, %2}"
6829   [(set_attr "type" "sselog")
6830    (set_attr "prefix_data16" "1")
6831    (set_attr "mode" "TI")])
6832
6833 (define_insn "*avx_interleave_lowv8hi"
6834   [(set (match_operand:V8HI 0 "register_operand" "=x")
6835         (vec_select:V8HI
6836           (vec_concat:V16HI
6837             (match_operand:V8HI 1 "register_operand" "x")
6838             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6839           (parallel [(const_int 0) (const_int 8)
6840                      (const_int 1) (const_int 9)
6841                      (const_int 2) (const_int 10)
6842                      (const_int 3) (const_int 11)])))]
6843   "TARGET_AVX"
6844   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6845   [(set_attr "type" "sselog")
6846    (set_attr "prefix" "vex")
6847    (set_attr "mode" "TI")])
6848
6849 (define_insn "vec_interleave_lowv8hi"
6850   [(set (match_operand:V8HI 0 "register_operand" "=x")
6851         (vec_select:V8HI
6852           (vec_concat:V16HI
6853             (match_operand:V8HI 1 "register_operand" "0")
6854             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
6855           (parallel [(const_int 0) (const_int 8)
6856                      (const_int 1) (const_int 9)
6857                      (const_int 2) (const_int 10)
6858                      (const_int 3) (const_int 11)])))]
6859   "TARGET_SSE2"
6860   "punpcklwd\t{%2, %0|%0, %2}"
6861   [(set_attr "type" "sselog")
6862    (set_attr "prefix_data16" "1")
6863    (set_attr "mode" "TI")])
6864
6865 (define_insn "*avx_interleave_highv4si"
6866   [(set (match_operand:V4SI 0 "register_operand" "=x")
6867         (vec_select:V4SI
6868           (vec_concat:V8SI
6869             (match_operand:V4SI 1 "register_operand" "x")
6870             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6871           (parallel [(const_int 2) (const_int 6)
6872                      (const_int 3) (const_int 7)])))]
6873   "TARGET_AVX"
6874   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6875   [(set_attr "type" "sselog")
6876    (set_attr "prefix" "vex")
6877    (set_attr "mode" "TI")])
6878
6879 (define_insn "vec_interleave_highv4si"
6880   [(set (match_operand:V4SI 0 "register_operand" "=x")
6881         (vec_select:V4SI
6882           (vec_concat:V8SI
6883             (match_operand:V4SI 1 "register_operand" "0")
6884             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6885           (parallel [(const_int 2) (const_int 6)
6886                      (const_int 3) (const_int 7)])))]
6887   "TARGET_SSE2"
6888   "punpckhdq\t{%2, %0|%0, %2}"
6889   [(set_attr "type" "sselog")
6890    (set_attr "prefix_data16" "1")
6891    (set_attr "mode" "TI")])
6892
6893 (define_insn "*avx_interleave_lowv4si"
6894   [(set (match_operand:V4SI 0 "register_operand" "=x")
6895         (vec_select:V4SI
6896           (vec_concat:V8SI
6897             (match_operand:V4SI 1 "register_operand" "x")
6898             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6899           (parallel [(const_int 0) (const_int 4)
6900                      (const_int 1) (const_int 5)])))]
6901   "TARGET_AVX"
6902   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6903   [(set_attr "type" "sselog")
6904    (set_attr "prefix" "vex")
6905    (set_attr "mode" "TI")])
6906
6907 (define_insn "vec_interleave_lowv4si"
6908   [(set (match_operand:V4SI 0 "register_operand" "=x")
6909         (vec_select:V4SI
6910           (vec_concat:V8SI
6911             (match_operand:V4SI 1 "register_operand" "0")
6912             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
6913           (parallel [(const_int 0) (const_int 4)
6914                      (const_int 1) (const_int 5)])))]
6915   "TARGET_SSE2"
6916   "punpckldq\t{%2, %0|%0, %2}"
6917   [(set_attr "type" "sselog")
6918    (set_attr "prefix_data16" "1")
6919    (set_attr "mode" "TI")])
6920
6921 (define_insn "*avx_pinsr<ssevecsize>"
6922   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
6923         (vec_merge:SSEMODE124
6924           (vec_duplicate:SSEMODE124
6925             (match_operand:<avxscalarmode> 2 "nonimmediate_operand" "rm"))
6926           (match_operand:SSEMODE124 1 "register_operand" "x")
6927           (match_operand:SI 3 "const_pow2_1_to_<pinsrbits>_operand" "n")))]
6928   "TARGET_AVX"
6929 {
6930   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6931   if (MEM_P (operands[2]))
6932     return "vpinsr<ssevecsize>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6933   else
6934     return "vpinsr<ssevecsize>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6935 }
6936   [(set_attr "type" "sselog")
6937    (set (attr "prefix_extra")
6938      (if_then_else (match_operand:V8HI 0 "" "")
6939        (const_string "0")
6940        (const_string "1")))
6941    (set_attr "length_immediate" "1")
6942    (set_attr "prefix" "vex")
6943    (set_attr "mode" "TI")])
6944
6945 (define_insn "*sse4_1_pinsrb"
6946   [(set (match_operand:V16QI 0 "register_operand" "=x")
6947         (vec_merge:V16QI
6948           (vec_duplicate:V16QI
6949             (match_operand:QI 2 "nonimmediate_operand" "rm"))
6950           (match_operand:V16QI 1 "register_operand" "0")
6951           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
6952   "TARGET_SSE4_1"
6953 {
6954   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6955   if (MEM_P (operands[2]))
6956     return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
6957   else
6958     return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
6959 }
6960   [(set_attr "type" "sselog")
6961    (set_attr "prefix_extra" "1")
6962    (set_attr "length_immediate" "1")
6963    (set_attr "mode" "TI")])
6964
6965 (define_insn "*sse2_pinsrw"
6966   [(set (match_operand:V8HI 0 "register_operand" "=x")
6967         (vec_merge:V8HI
6968           (vec_duplicate:V8HI
6969             (match_operand:HI 2 "nonimmediate_operand" "rm"))
6970           (match_operand:V8HI 1 "register_operand" "0")
6971           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
6972   "TARGET_SSE2"
6973 {
6974   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6975   if (MEM_P (operands[2]))
6976     return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
6977   else
6978     return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
6979 }
6980   [(set_attr "type" "sselog")
6981    (set_attr "prefix_data16" "1")
6982    (set_attr "length_immediate" "1")
6983    (set_attr "mode" "TI")])
6984
6985 ;; It must come before sse2_loadld since it is preferred.
6986 (define_insn "*sse4_1_pinsrd"
6987   [(set (match_operand:V4SI 0 "register_operand" "=x")
6988         (vec_merge:V4SI
6989           (vec_duplicate:V4SI
6990             (match_operand:SI 2 "nonimmediate_operand" "rm"))
6991           (match_operand:V4SI 1 "register_operand" "0")
6992           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
6993   "TARGET_SSE4_1"
6994 {
6995   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6996   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
6997 }
6998   [(set_attr "type" "sselog")
6999    (set_attr "prefix_extra" "1")
7000    (set_attr "length_immediate" "1")
7001    (set_attr "mode" "TI")])
7002
7003 (define_insn "*avx_pinsrq"
7004   [(set (match_operand:V2DI 0 "register_operand" "=x")
7005         (vec_merge:V2DI
7006           (vec_duplicate:V2DI
7007             (match_operand:DI 2 "nonimmediate_operand" "rm"))
7008           (match_operand:V2DI 1 "register_operand" "x")
7009           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
7010   "TARGET_AVX && TARGET_64BIT"
7011 {
7012   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7013   return "vpinsrq\t{%3, %2, %1, %0|%0, %1, %2, %3}";
7014 }
7015   [(set_attr "type" "sselog")
7016    (set_attr "prefix_extra" "1")
7017    (set_attr "length_immediate" "1")
7018    (set_attr "prefix" "vex")
7019    (set_attr "mode" "TI")])
7020
7021 (define_insn "*sse4_1_pinsrq"
7022   [(set (match_operand:V2DI 0 "register_operand" "=x")
7023         (vec_merge:V2DI
7024           (vec_duplicate:V2DI
7025             (match_operand:DI 2 "nonimmediate_operand" "rm"))
7026           (match_operand:V2DI 1 "register_operand" "0")
7027           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
7028   "TARGET_SSE4_1 && TARGET_64BIT"
7029 {
7030   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
7031   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
7032 }
7033   [(set_attr "type" "sselog")
7034    (set_attr "prefix_rex" "1")
7035    (set_attr "prefix_extra" "1")
7036    (set_attr "length_immediate" "1")
7037    (set_attr "mode" "TI")])
7038
7039 (define_insn "*sse4_1_pextrb_<mode>"
7040   [(set (match_operand:SWI48 0 "register_operand" "=r")
7041         (zero_extend:SWI48
7042           (vec_select:QI
7043             (match_operand:V16QI 1 "register_operand" "x")
7044             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
7045   "TARGET_SSE4_1"
7046   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
7047   [(set_attr "type" "sselog")
7048    (set_attr "prefix_extra" "1")
7049    (set_attr "length_immediate" "1")
7050    (set_attr "prefix" "maybe_vex")
7051    (set_attr "mode" "TI")])
7052
7053 (define_insn "*sse4_1_pextrb_memory"
7054   [(set (match_operand:QI 0 "memory_operand" "=m")
7055         (vec_select:QI
7056           (match_operand:V16QI 1 "register_operand" "x")
7057           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
7058   "TARGET_SSE4_1"
7059   "%vpextrb\t{%2, %1, %0|%0, %1, %2}"
7060   [(set_attr "type" "sselog")
7061    (set_attr "prefix_extra" "1")
7062    (set_attr "length_immediate" "1")
7063    (set_attr "prefix" "maybe_vex")
7064    (set_attr "mode" "TI")])
7065
7066 (define_insn "*sse2_pextrw_<mode>"
7067   [(set (match_operand:SWI48 0 "register_operand" "=r")
7068         (zero_extend:SWI48
7069           (vec_select:HI
7070             (match_operand:V8HI 1 "register_operand" "x")
7071             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
7072   "TARGET_SSE2"
7073   "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
7074   [(set_attr "type" "sselog")
7075    (set_attr "prefix_data16" "1")
7076    (set_attr "length_immediate" "1")
7077    (set_attr "prefix" "maybe_vex")
7078    (set_attr "mode" "TI")])
7079
7080 (define_insn "*sse4_1_pextrw_memory"
7081   [(set (match_operand:HI 0 "memory_operand" "=m")
7082         (vec_select:HI
7083           (match_operand:V8HI 1 "register_operand" "x")
7084           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
7085   "TARGET_SSE4_1"
7086   "%vpextrw\t{%2, %1, %0|%0, %1, %2}"
7087   [(set_attr "type" "sselog")
7088    (set_attr "prefix_extra" "1")
7089    (set_attr "length_immediate" "1")
7090    (set_attr "prefix" "maybe_vex")
7091    (set_attr "mode" "TI")])
7092
7093 (define_insn "*sse4_1_pextrd"
7094   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
7095         (vec_select:SI
7096           (match_operand:V4SI 1 "register_operand" "x")
7097           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
7098   "TARGET_SSE4_1"
7099   "%vpextrd\t{%2, %1, %0|%0, %1, %2}"
7100   [(set_attr "type" "sselog")
7101    (set_attr "prefix_extra" "1")
7102    (set_attr "length_immediate" "1")
7103    (set_attr "prefix" "maybe_vex")
7104    (set_attr "mode" "TI")])
7105
7106 (define_insn "*sse4_1_pextrd_zext"
7107   [(set (match_operand:DI 0 "register_operand" "=r")
7108         (zero_extend:DI
7109           (vec_select:SI
7110             (match_operand:V4SI 1 "register_operand" "x")
7111             (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")]))))]
7112   "TARGET_64BIT && TARGET_SSE4_1"
7113   "%vpextrd\t{%2, %1, %k0|%k0, %1, %2}"
7114   [(set_attr "type" "sselog")
7115    (set_attr "prefix_extra" "1")
7116    (set_attr "length_immediate" "1")
7117    (set_attr "prefix" "maybe_vex")
7118    (set_attr "mode" "TI")])
7119
7120 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
7121 (define_insn "*sse4_1_pextrq"
7122   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
7123         (vec_select:DI
7124           (match_operand:V2DI 1 "register_operand" "x")
7125           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
7126   "TARGET_SSE4_1 && TARGET_64BIT"
7127   "%vpextrq\t{%2, %1, %0|%0, %1, %2}"
7128   [(set_attr "type" "sselog")
7129    (set_attr "prefix_rex" "1")
7130    (set_attr "prefix_extra" "1")
7131    (set_attr "length_immediate" "1")
7132    (set_attr "prefix" "maybe_vex")
7133    (set_attr "mode" "TI")])
7134
7135 (define_expand "sse2_pshufd"
7136   [(match_operand:V4SI 0 "register_operand" "")
7137    (match_operand:V4SI 1 "nonimmediate_operand" "")
7138    (match_operand:SI 2 "const_int_operand" "")]
7139   "TARGET_SSE2"
7140 {
7141   int mask = INTVAL (operands[2]);
7142   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
7143                                 GEN_INT ((mask >> 0) & 3),
7144                                 GEN_INT ((mask >> 2) & 3),
7145                                 GEN_INT ((mask >> 4) & 3),
7146                                 GEN_INT ((mask >> 6) & 3)));
7147   DONE;
7148 })
7149
7150 (define_insn "sse2_pshufd_1"
7151   [(set (match_operand:V4SI 0 "register_operand" "=x")
7152         (vec_select:V4SI
7153           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
7154           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7155                      (match_operand 3 "const_0_to_3_operand" "")
7156                      (match_operand 4 "const_0_to_3_operand" "")
7157                      (match_operand 5 "const_0_to_3_operand" "")])))]
7158   "TARGET_SSE2"
7159 {
7160   int mask = 0;
7161   mask |= INTVAL (operands[2]) << 0;
7162   mask |= INTVAL (operands[3]) << 2;
7163   mask |= INTVAL (operands[4]) << 4;
7164   mask |= INTVAL (operands[5]) << 6;
7165   operands[2] = GEN_INT (mask);
7166
7167   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
7168 }
7169   [(set_attr "type" "sselog1")
7170    (set_attr "prefix_data16" "1")
7171    (set_attr "prefix" "maybe_vex")
7172    (set_attr "length_immediate" "1")
7173    (set_attr "mode" "TI")])
7174
7175 (define_expand "sse2_pshuflw"
7176   [(match_operand:V8HI 0 "register_operand" "")
7177    (match_operand:V8HI 1 "nonimmediate_operand" "")
7178    (match_operand:SI 2 "const_int_operand" "")]
7179   "TARGET_SSE2"
7180 {
7181   int mask = INTVAL (operands[2]);
7182   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
7183                                  GEN_INT ((mask >> 0) & 3),
7184                                  GEN_INT ((mask >> 2) & 3),
7185                                  GEN_INT ((mask >> 4) & 3),
7186                                  GEN_INT ((mask >> 6) & 3)));
7187   DONE;
7188 })
7189
7190 (define_insn "sse2_pshuflw_1"
7191   [(set (match_operand:V8HI 0 "register_operand" "=x")
7192         (vec_select:V8HI
7193           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7194           (parallel [(match_operand 2 "const_0_to_3_operand" "")
7195                      (match_operand 3 "const_0_to_3_operand" "")
7196                      (match_operand 4 "const_0_to_3_operand" "")
7197                      (match_operand 5 "const_0_to_3_operand" "")
7198                      (const_int 4)
7199                      (const_int 5)
7200                      (const_int 6)
7201                      (const_int 7)])))]
7202   "TARGET_SSE2"
7203 {
7204   int mask = 0;
7205   mask |= INTVAL (operands[2]) << 0;
7206   mask |= INTVAL (operands[3]) << 2;
7207   mask |= INTVAL (operands[4]) << 4;
7208   mask |= INTVAL (operands[5]) << 6;
7209   operands[2] = GEN_INT (mask);
7210
7211   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7212 }
7213   [(set_attr "type" "sselog")
7214    (set_attr "prefix_data16" "0")
7215    (set_attr "prefix_rep" "1")
7216    (set_attr "prefix" "maybe_vex")
7217    (set_attr "length_immediate" "1")
7218    (set_attr "mode" "TI")])
7219
7220 (define_expand "sse2_pshufhw"
7221   [(match_operand:V8HI 0 "register_operand" "")
7222    (match_operand:V8HI 1 "nonimmediate_operand" "")
7223    (match_operand:SI 2 "const_int_operand" "")]
7224   "TARGET_SSE2"
7225 {
7226   int mask = INTVAL (operands[2]);
7227   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
7228                                  GEN_INT (((mask >> 0) & 3) + 4),
7229                                  GEN_INT (((mask >> 2) & 3) + 4),
7230                                  GEN_INT (((mask >> 4) & 3) + 4),
7231                                  GEN_INT (((mask >> 6) & 3) + 4)));
7232   DONE;
7233 })
7234
7235 (define_insn "sse2_pshufhw_1"
7236   [(set (match_operand:V8HI 0 "register_operand" "=x")
7237         (vec_select:V8HI
7238           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7239           (parallel [(const_int 0)
7240                      (const_int 1)
7241                      (const_int 2)
7242                      (const_int 3)
7243                      (match_operand 2 "const_4_to_7_operand" "")
7244                      (match_operand 3 "const_4_to_7_operand" "")
7245                      (match_operand 4 "const_4_to_7_operand" "")
7246                      (match_operand 5 "const_4_to_7_operand" "")])))]
7247   "TARGET_SSE2"
7248 {
7249   int mask = 0;
7250   mask |= (INTVAL (operands[2]) - 4) << 0;
7251   mask |= (INTVAL (operands[3]) - 4) << 2;
7252   mask |= (INTVAL (operands[4]) - 4) << 4;
7253   mask |= (INTVAL (operands[5]) - 4) << 6;
7254   operands[2] = GEN_INT (mask);
7255
7256   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7257 }
7258   [(set_attr "type" "sselog")
7259    (set_attr "prefix_rep" "1")
7260    (set_attr "prefix_data16" "0")
7261    (set_attr "prefix" "maybe_vex")
7262    (set_attr "length_immediate" "1")
7263    (set_attr "mode" "TI")])
7264
7265 (define_expand "sse2_loadd"
7266   [(set (match_operand:V4SI 0 "register_operand" "")
7267         (vec_merge:V4SI
7268           (vec_duplicate:V4SI
7269             (match_operand:SI 1 "nonimmediate_operand" ""))
7270           (match_dup 2)
7271           (const_int 1)))]
7272   "TARGET_SSE"
7273   "operands[2] = CONST0_RTX (V4SImode);")
7274
7275 (define_insn "*avx_loadld"
7276   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x")
7277         (vec_merge:V4SI
7278           (vec_duplicate:V4SI
7279             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,x"))
7280           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,x")
7281           (const_int 1)))]
7282   "TARGET_AVX"
7283   "@
7284    vmovd\t{%2, %0|%0, %2}
7285    vmovd\t{%2, %0|%0, %2}
7286    vmovss\t{%2, %1, %0|%0, %1, %2}"
7287   [(set_attr "type" "ssemov")
7288    (set_attr "prefix" "vex")
7289    (set_attr "mode" "TI,TI,V4SF")])
7290
7291 (define_insn "sse2_loadld"
7292   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,Yi,x,x")
7293         (vec_merge:V4SI
7294           (vec_duplicate:V4SI
7295             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
7296           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
7297           (const_int 1)))]
7298   "TARGET_SSE"
7299   "@
7300    movd\t{%2, %0|%0, %2}
7301    movd\t{%2, %0|%0, %2}
7302    movss\t{%2, %0|%0, %2}
7303    movss\t{%2, %0|%0, %2}"
7304   [(set_attr "type" "ssemov")
7305    (set_attr "mode" "TI,TI,V4SF,SF")])
7306
7307 (define_insn_and_split "sse2_stored"
7308   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
7309         (vec_select:SI
7310           (match_operand:V4SI 1 "register_operand" "x,Yi")
7311           (parallel [(const_int 0)])))]
7312   "TARGET_SSE"
7313   "#"
7314   "&& reload_completed
7315    && (TARGET_INTER_UNIT_MOVES
7316        || MEM_P (operands [0])
7317        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7318   [(set (match_dup 0) (match_dup 1))]
7319   "operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));")
7320
7321 (define_insn_and_split "*vec_ext_v4si_mem"
7322   [(set (match_operand:SI 0 "register_operand" "=r")
7323         (vec_select:SI
7324           (match_operand:V4SI 1 "memory_operand" "o")
7325           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
7326   ""
7327   "#"
7328   "reload_completed"
7329   [(const_int 0)]
7330 {
7331   int i = INTVAL (operands[2]);
7332
7333   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
7334   DONE;
7335 })
7336
7337 (define_expand "sse_storeq"
7338   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7339         (vec_select:DI
7340           (match_operand:V2DI 1 "register_operand" "")
7341           (parallel [(const_int 0)])))]
7342   "TARGET_SSE")
7343
7344 (define_insn "*sse2_storeq_rex64"
7345   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,*r,r")
7346         (vec_select:DI
7347           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
7348           (parallel [(const_int 0)])))]
7349   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7350   "@
7351    #
7352    #
7353    %vmov{q}\t{%1, %0|%0, %1}"
7354   [(set_attr "type" "*,*,imov")
7355    (set_attr "prefix" "*,*,maybe_vex")
7356    (set_attr "mode" "*,*,DI")])
7357
7358 (define_insn "*sse2_storeq"
7359   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
7360         (vec_select:DI
7361           (match_operand:V2DI 1 "register_operand" "x")
7362           (parallel [(const_int 0)])))]
7363   "TARGET_SSE"
7364   "#")
7365
7366 (define_split
7367   [(set (match_operand:DI 0 "nonimmediate_operand" "")
7368         (vec_select:DI
7369           (match_operand:V2DI 1 "register_operand" "")
7370           (parallel [(const_int 0)])))]
7371   "TARGET_SSE
7372    && reload_completed
7373    && (TARGET_INTER_UNIT_MOVES
7374        || MEM_P (operands [0])
7375        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
7376   [(set (match_dup 0) (match_dup 1))]
7377   "operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));")
7378
7379 (define_insn "*vec_extractv2di_1_rex64_avx"
7380   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7381         (vec_select:DI
7382           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o,o")
7383           (parallel [(const_int 1)])))]
7384   "TARGET_64BIT
7385    && TARGET_AVX
7386    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7387   "@
7388    vmovhps\t{%1, %0|%0, %1}
7389    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7390    vmovq\t{%H1, %0|%0, %H1}
7391    vmov{q}\t{%H1, %0|%0, %H1}"
7392   [(set_attr "type" "ssemov,sseishft1,ssemov,imov")
7393    (set_attr "length_immediate" "*,1,*,*")
7394    (set_attr "memory" "*,none,*,*")
7395    (set_attr "prefix" "vex")
7396    (set_attr "mode" "V2SF,TI,TI,DI")])
7397
7398 (define_insn "*vec_extractv2di_1_rex64"
7399   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
7400         (vec_select:DI
7401           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
7402           (parallel [(const_int 1)])))]
7403   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7404   "@
7405    movhps\t{%1, %0|%0, %1}
7406    psrldq\t{$8, %0|%0, 8}
7407    movq\t{%H1, %0|%0, %H1}
7408    mov{q}\t{%H1, %0|%0, %H1}"
7409   [(set_attr "type" "ssemov,sseishft1,ssemov,imov")
7410    (set_attr "length_immediate" "*,1,*,*")
7411    (set_attr "memory" "*,none,*,*")
7412    (set_attr "mode" "V2SF,TI,TI,DI")])
7413
7414 (define_insn "*vec_extractv2di_1_avx"
7415   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7416         (vec_select:DI
7417           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7418           (parallel [(const_int 1)])))]
7419   "!TARGET_64BIT
7420    && TARGET_AVX
7421    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7422   "@
7423    vmovhps\t{%1, %0|%0, %1}
7424    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7425    vmovq\t{%H1, %0|%0, %H1}"
7426   [(set_attr "type" "ssemov,sseishft1,ssemov")
7427    (set_attr "length_immediate" "*,1,*")
7428    (set_attr "memory" "*,none,*")
7429    (set_attr "prefix" "vex")
7430    (set_attr "mode" "V2SF,TI,TI")])
7431
7432 (define_insn "*vec_extractv2di_1_sse2"
7433   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7434         (vec_select:DI
7435           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
7436           (parallel [(const_int 1)])))]
7437   "!TARGET_64BIT
7438    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7439   "@
7440    movhps\t{%1, %0|%0, %1}
7441    psrldq\t{$8, %0|%0, 8}
7442    movq\t{%H1, %0|%0, %H1}"
7443   [(set_attr "type" "ssemov,sseishft1,ssemov")
7444    (set_attr "length_immediate" "*,1,*")
7445    (set_attr "memory" "*,none,*")
7446    (set_attr "mode" "V2SF,TI,TI")])
7447
7448 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
7449 (define_insn "*vec_extractv2di_1_sse"
7450   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
7451         (vec_select:DI
7452           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
7453           (parallel [(const_int 1)])))]
7454   "!TARGET_SSE2 && TARGET_SSE
7455    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7456   "@
7457    movhps\t{%1, %0|%0, %1}
7458    movhlps\t{%1, %0|%0, %1}
7459    movlps\t{%H1, %0|%0, %H1}"
7460   [(set_attr "type" "ssemov")
7461    (set_attr "mode" "V2SF,V4SF,V2SF")])
7462
7463 (define_insn "*vec_dupv4si_avx"
7464   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
7465         (vec_duplicate:V4SI
7466           (match_operand:SI 1 "register_operand" "x,m")))]
7467   "TARGET_AVX"
7468   "@
7469    vpshufd\t{$0, %1, %0|%0, %1, 0}
7470    vbroadcastss\t{%1, %0|%0, %1}"
7471   [(set_attr "type" "sselog1,ssemov")
7472    (set_attr "length_immediate" "1,0")
7473    (set_attr "prefix_extra" "0,1")
7474    (set_attr "prefix" "vex")
7475    (set_attr "mode" "TI,V4SF")])
7476
7477 (define_insn "*vec_dupv4si"
7478   [(set (match_operand:V4SI 0 "register_operand" "=Y2,x")
7479         (vec_duplicate:V4SI
7480           (match_operand:SI 1 "register_operand" " Y2,0")))]
7481   "TARGET_SSE"
7482   "@
7483    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7484    shufps\t{$0, %0, %0|%0, %0, 0}"
7485   [(set_attr "type" "sselog1")
7486    (set_attr "length_immediate" "1")
7487    (set_attr "mode" "TI,V4SF")])
7488
7489 (define_insn "*vec_dupv2di_avx"
7490   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7491         (vec_duplicate:V2DI
7492           (match_operand:DI 1 "nonimmediate_operand" " x,m")))]
7493   "TARGET_AVX"
7494   "@
7495    vpunpcklqdq\t{%1, %1, %0|%0, %1, %1}
7496    vmovddup\t{%1, %0|%0, %1}"
7497   [(set_attr "type" "sselog1")
7498    (set_attr "prefix" "vex")
7499    (set_attr "mode" "TI,DF")])
7500
7501 (define_insn "*vec_dupv2di_sse3"
7502   [(set (match_operand:V2DI 0 "register_operand"     "=x,x")
7503         (vec_duplicate:V2DI
7504           (match_operand:DI 1 "nonimmediate_operand" " 0,m")))]
7505   "TARGET_SSE3"
7506   "@
7507    punpcklqdq\t%0, %0
7508    movddup\t{%1, %0|%0, %1}"
7509   [(set_attr "type" "sselog1")
7510    (set_attr "mode" "TI,DF")])
7511
7512 (define_insn "*vec_dupv2di"
7513   [(set (match_operand:V2DI 0 "register_operand" "=Y2,x")
7514         (vec_duplicate:V2DI
7515           (match_operand:DI 1 "register_operand" " 0 ,0")))]
7516   "TARGET_SSE"
7517   "@
7518    punpcklqdq\t%0, %0
7519    movlhps\t%0, %0"
7520   [(set_attr "type" "sselog1,ssemov")
7521    (set_attr "mode" "TI,V4SF")])
7522
7523 (define_insn "*vec_concatv2si_avx"
7524   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7525         (vec_concat:V2SI
7526           (match_operand:SI 1 "nonimmediate_operand" "x ,x,rm, 0 ,rm")
7527           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7528   "TARGET_AVX"
7529   "@
7530    vpinsrd\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7531    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7532    vmovd\t{%1, %0|%0, %1}
7533    punpckldq\t{%2, %0|%0, %2}
7534    movd\t{%1, %0|%0, %1}"
7535   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7536    (set_attr "prefix_extra" "1,*,*,*,*")
7537    (set_attr "length_immediate" "1,*,*,*,*")
7538    (set (attr "prefix")
7539      (if_then_else (eq_attr "alternative" "3,4")
7540        (const_string "orig")
7541        (const_string "vex")))
7542    (set_attr "mode" "TI,TI,TI,DI,DI")])
7543
7544 (define_insn "*vec_concatv2si_sse4_1"
7545   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,x ,*y ,*y")
7546         (vec_concat:V2SI
7547           (match_operand:SI 1 "nonimmediate_operand" "0 ,0,rm, 0 ,rm")
7548           (match_operand:SI 2 "vector_move_operand"  "rm,x,C ,*ym,C")))]
7549   "TARGET_SSE4_1"
7550   "@
7551    pinsrd\t{$0x1, %2, %0|%0, %2, 0x1}
7552    punpckldq\t{%2, %0|%0, %2}
7553    movd\t{%1, %0|%0, %1}
7554    punpckldq\t{%2, %0|%0, %2}
7555    movd\t{%1, %0|%0, %1}"
7556   [(set_attr "type" "sselog,sselog,ssemov,mmxcvt,mmxmov")
7557    (set_attr "prefix_extra" "1,*,*,*,*")
7558    (set_attr "length_immediate" "1,*,*,*,*")
7559    (set_attr "mode" "TI,TI,TI,DI,DI")])
7560
7561 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7562 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7563 ;; alternatives pretty much forces the MMX alternative to be chosen.
7564 (define_insn "*vec_concatv2si_sse2"
7565   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,*y")
7566         (vec_concat:V2SI
7567           (match_operand:SI 1 "nonimmediate_operand" " 0,rm, 0,rm")
7568           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,*y, C")))]
7569   "TARGET_SSE2"
7570   "@
7571    punpckldq\t{%2, %0|%0, %2}
7572    movd\t{%1, %0|%0, %1}
7573    punpckldq\t{%2, %0|%0, %2}
7574    movd\t{%1, %0|%0, %1}"
7575   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7576    (set_attr "mode" "TI,TI,DI,DI")])
7577
7578 (define_insn "*vec_concatv2si_sse"
7579   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
7580         (vec_concat:V2SI
7581           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
7582           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
7583   "TARGET_SSE"
7584   "@
7585    unpcklps\t{%2, %0|%0, %2}
7586    movss\t{%1, %0|%0, %1}
7587    punpckldq\t{%2, %0|%0, %2}
7588    movd\t{%1, %0|%0, %1}"
7589   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
7590    (set_attr "mode" "V4SF,V4SF,DI,DI")])
7591
7592 (define_insn "*vec_concatv4si_1_avx"
7593   [(set (match_operand:V4SI 0 "register_operand"       "=x,x")
7594         (vec_concat:V4SI
7595           (match_operand:V2SI 1 "register_operand"     " x,x")
7596           (match_operand:V2SI 2 "nonimmediate_operand" " x,m")))]
7597   "TARGET_AVX"
7598   "@
7599    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7600    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7601   [(set_attr "type" "sselog,ssemov")
7602    (set_attr "prefix" "vex")
7603    (set_attr "mode" "TI,V2SF")])
7604
7605 (define_insn "*vec_concatv4si_1"
7606   [(set (match_operand:V4SI 0 "register_operand"       "=Y2,x,x")
7607         (vec_concat:V4SI
7608           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
7609           (match_operand:V2SI 2 "nonimmediate_operand" " Y2,x,m")))]
7610   "TARGET_SSE"
7611   "@
7612    punpcklqdq\t{%2, %0|%0, %2}
7613    movlhps\t{%2, %0|%0, %2}
7614    movhps\t{%2, %0|%0, %2}"
7615   [(set_attr "type" "sselog,ssemov,ssemov")
7616    (set_attr "mode" "TI,V4SF,V2SF")])
7617
7618 (define_insn "*vec_concatv2di_avx"
7619   [(set (match_operand:V2DI 0 "register_operand"     "=x,?x,x,x")
7620         (vec_concat:V2DI
7621           (match_operand:DI 1 "nonimmediate_operand" " m,*y,x,x")
7622           (match_operand:DI 2 "vector_move_operand"  " C, C,x,m")))]
7623   "!TARGET_64BIT && TARGET_AVX"
7624   "@
7625    vmovq\t{%1, %0|%0, %1}
7626    movq2dq\t{%1, %0|%0, %1}
7627    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7628    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7629   [(set_attr "type" "ssemov,ssemov,sselog,ssemov")
7630    (set (attr "prefix")
7631      (if_then_else (eq_attr "alternative" "1")
7632        (const_string "orig")
7633        (const_string "vex")))
7634    (set_attr "mode" "TI,TI,TI,V2SF")])
7635
7636 (define_insn "vec_concatv2di"
7637   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,?Y2,Y2,x,x")
7638         (vec_concat:V2DI
7639           (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0")
7640           (match_operand:DI 2 "vector_move_operand"  " C  ,  C,Y2,x,m")))]
7641   "!TARGET_64BIT && TARGET_SSE"
7642   "@
7643    movq\t{%1, %0|%0, %1}
7644    movq2dq\t{%1, %0|%0, %1}
7645    punpcklqdq\t{%2, %0|%0, %2}
7646    movlhps\t{%2, %0|%0, %2}
7647    movhps\t{%2, %0|%0, %2}"
7648   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov")
7649    (set_attr "mode" "TI,TI,TI,V4SF,V2SF")])
7650
7651 (define_insn "*vec_concatv2di_rex64_avx"
7652   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,Yi,!x,x,x")
7653         (vec_concat:V2DI
7654           (match_operand:DI 1 "nonimmediate_operand" " x,m,r ,*y,x,x")
7655           (match_operand:DI 2 "vector_move_operand"  "rm,C,C ,C ,x,m")))]
7656   "TARGET_64BIT && TARGET_AVX"
7657   "@
7658    vpinsrq\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}
7659    vmovq\t{%1, %0|%0, %1}
7660    vmovq\t{%1, %0|%0, %1}
7661    movq2dq\t{%1, %0|%0, %1}
7662    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7663    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7664   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov")
7665    (set_attr "prefix_extra" "1,*,*,*,*,*")
7666    (set_attr "length_immediate" "1,*,*,*,*,*")
7667    (set (attr "prefix")
7668      (if_then_else (eq_attr "alternative" "3")
7669        (const_string "orig")
7670        (const_string "vex")))
7671    (set_attr "mode" "TI,TI,TI,TI,TI,V2SF")])
7672
7673 (define_insn "*vec_concatv2di_rex64_sse4_1"
7674   [(set (match_operand:V2DI 0 "register_operand"     "=x ,x ,Yi,!x,x,x,x")
7675         (vec_concat:V2DI
7676           (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0")
7677           (match_operand:DI 2 "vector_move_operand"  " rm,C ,C ,C ,x,x,m")))]
7678   "TARGET_64BIT && TARGET_SSE4_1"
7679   "@
7680    pinsrq\t{$0x1, %2, %0|%0, %2, 0x1}
7681    movq\t{%1, %0|%0, %1}
7682    movq\t{%1, %0|%0, %1}
7683    movq2dq\t{%1, %0|%0, %1}
7684    punpcklqdq\t{%2, %0|%0, %2}
7685    movlhps\t{%2, %0|%0, %2}
7686    movhps\t{%2, %0|%0, %2}"
7687   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7688    (set_attr "prefix_rex" "1,*,1,*,*,*,*")
7689    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7690    (set_attr "length_immediate" "1,*,*,*,*,*,*")
7691    (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")])
7692
7693 (define_insn "*vec_concatv2di_rex64_sse"
7694   [(set (match_operand:V2DI 0 "register_operand"     "=Y2 ,Yi,!Y2,Y2,x,x")
7695         (vec_concat:V2DI
7696           (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0")
7697           (match_operand:DI 2 "vector_move_operand"  " C  ,C ,C  ,Y2,x,m")))]
7698   "TARGET_64BIT && TARGET_SSE"
7699   "@
7700    movq\t{%1, %0|%0, %1}
7701    movq\t{%1, %0|%0, %1}
7702    movq2dq\t{%1, %0|%0, %1}
7703    punpcklqdq\t{%2, %0|%0, %2}
7704    movlhps\t{%2, %0|%0, %2}
7705    movhps\t{%2, %0|%0, %2}"
7706   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
7707    (set_attr "prefix_rex" "*,1,*,*,*,*")
7708    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")])
7709
7710 (define_expand "vec_unpacku_hi_v16qi"
7711   [(match_operand:V8HI 0 "register_operand" "")
7712    (match_operand:V16QI 1 "register_operand" "")]
7713   "TARGET_SSE2"
7714 {
7715   if (TARGET_SSE4_1)
7716     ix86_expand_sse4_unpack (operands, true, true);
7717   else
7718     ix86_expand_sse_unpack (operands, true, true);
7719   DONE;
7720 })
7721
7722 (define_expand "vec_unpacks_hi_v16qi"
7723   [(match_operand:V8HI 0 "register_operand" "")
7724    (match_operand:V16QI 1 "register_operand" "")]
7725   "TARGET_SSE2"
7726 {
7727   if (TARGET_SSE4_1)
7728     ix86_expand_sse4_unpack (operands, false, true);
7729   else
7730     ix86_expand_sse_unpack (operands, false, true);
7731   DONE;
7732 })
7733
7734 (define_expand "vec_unpacku_lo_v16qi"
7735   [(match_operand:V8HI 0 "register_operand" "")
7736    (match_operand:V16QI 1 "register_operand" "")]
7737   "TARGET_SSE2"
7738 {
7739   if (TARGET_SSE4_1)
7740     ix86_expand_sse4_unpack (operands, true, false);
7741   else
7742     ix86_expand_sse_unpack (operands, true, false);
7743   DONE;
7744 })
7745
7746 (define_expand "vec_unpacks_lo_v16qi"
7747   [(match_operand:V8HI 0 "register_operand" "")
7748    (match_operand:V16QI 1 "register_operand" "")]
7749   "TARGET_SSE2"
7750 {
7751   if (TARGET_SSE4_1)
7752     ix86_expand_sse4_unpack (operands, false, false);
7753   else
7754     ix86_expand_sse_unpack (operands, false, false);
7755   DONE;
7756 })
7757
7758 (define_expand "vec_unpacku_hi_v8hi"
7759   [(match_operand:V4SI 0 "register_operand" "")
7760    (match_operand:V8HI 1 "register_operand" "")]
7761   "TARGET_SSE2"
7762 {
7763   if (TARGET_SSE4_1)
7764     ix86_expand_sse4_unpack (operands, true, true);
7765   else
7766     ix86_expand_sse_unpack (operands, true, true);
7767   DONE;
7768 })
7769
7770 (define_expand "vec_unpacks_hi_v8hi"
7771   [(match_operand:V4SI 0 "register_operand" "")
7772    (match_operand:V8HI 1 "register_operand" "")]
7773   "TARGET_SSE2"
7774 {
7775   if (TARGET_SSE4_1)
7776     ix86_expand_sse4_unpack (operands, false, true);
7777   else
7778     ix86_expand_sse_unpack (operands, false, true);
7779   DONE;
7780 })
7781
7782 (define_expand "vec_unpacku_lo_v8hi"
7783   [(match_operand:V4SI 0 "register_operand" "")
7784    (match_operand:V8HI 1 "register_operand" "")]
7785   "TARGET_SSE2"
7786 {
7787   if (TARGET_SSE4_1)
7788     ix86_expand_sse4_unpack (operands, true, false);
7789   else
7790     ix86_expand_sse_unpack (operands, true, false);
7791   DONE;
7792 })
7793
7794 (define_expand "vec_unpacks_lo_v8hi"
7795   [(match_operand:V4SI 0 "register_operand" "")
7796    (match_operand:V8HI 1 "register_operand" "")]
7797   "TARGET_SSE2"
7798 {
7799   if (TARGET_SSE4_1)
7800     ix86_expand_sse4_unpack (operands, false, false);
7801   else
7802     ix86_expand_sse_unpack (operands, false, false);
7803   DONE;
7804 })
7805
7806 (define_expand "vec_unpacku_hi_v4si"
7807   [(match_operand:V2DI 0 "register_operand" "")
7808    (match_operand:V4SI 1 "register_operand" "")]
7809   "TARGET_SSE2"
7810 {
7811   if (TARGET_SSE4_1)
7812     ix86_expand_sse4_unpack (operands, true, true);
7813   else
7814     ix86_expand_sse_unpack (operands, true, true);
7815   DONE;
7816 })
7817
7818 (define_expand "vec_unpacks_hi_v4si"
7819   [(match_operand:V2DI 0 "register_operand" "")
7820    (match_operand:V4SI 1 "register_operand" "")]
7821   "TARGET_SSE2"
7822 {
7823   if (TARGET_SSE4_1)
7824     ix86_expand_sse4_unpack (operands, false, true);
7825   else
7826     ix86_expand_sse_unpack (operands, false, true);
7827   DONE;
7828 })
7829
7830 (define_expand "vec_unpacku_lo_v4si"
7831   [(match_operand:V2DI 0 "register_operand" "")
7832    (match_operand:V4SI 1 "register_operand" "")]
7833   "TARGET_SSE2"
7834 {
7835   if (TARGET_SSE4_1)
7836     ix86_expand_sse4_unpack (operands, true, false);
7837   else
7838     ix86_expand_sse_unpack (operands, true, false);
7839   DONE;
7840 })
7841
7842 (define_expand "vec_unpacks_lo_v4si"
7843   [(match_operand:V2DI 0 "register_operand" "")
7844    (match_operand:V4SI 1 "register_operand" "")]
7845   "TARGET_SSE2"
7846 {
7847   if (TARGET_SSE4_1)
7848     ix86_expand_sse4_unpack (operands, false, false);
7849   else
7850     ix86_expand_sse_unpack (operands, false, false);
7851   DONE;
7852 })
7853
7854 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7855 ;;
7856 ;; Miscellaneous
7857 ;;
7858 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7859
7860 (define_expand "sse2_uavgv16qi3"
7861   [(set (match_operand:V16QI 0 "register_operand" "")
7862         (truncate:V16QI
7863           (lshiftrt:V16HI
7864             (plus:V16HI
7865               (plus:V16HI
7866                 (zero_extend:V16HI
7867                   (match_operand:V16QI 1 "nonimmediate_operand" ""))
7868                 (zero_extend:V16HI
7869                   (match_operand:V16QI 2 "nonimmediate_operand" "")))
7870               (const_vector:V16QI [(const_int 1) (const_int 1)
7871                                    (const_int 1) (const_int 1)
7872                                    (const_int 1) (const_int 1)
7873                                    (const_int 1) (const_int 1)
7874                                    (const_int 1) (const_int 1)
7875                                    (const_int 1) (const_int 1)
7876                                    (const_int 1) (const_int 1)
7877                                    (const_int 1) (const_int 1)]))
7878             (const_int 1))))]
7879   "TARGET_SSE2"
7880   "ix86_fixup_binary_operands_no_copy (PLUS, V16QImode, operands);")
7881
7882 (define_insn "*avx_uavgv16qi3"
7883   [(set (match_operand:V16QI 0 "register_operand" "=x")
7884         (truncate:V16QI
7885           (lshiftrt:V16HI
7886             (plus:V16HI
7887               (plus:V16HI
7888                 (zero_extend:V16HI
7889                   (match_operand:V16QI 1 "nonimmediate_operand" "%x"))
7890                 (zero_extend:V16HI
7891                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7892               (const_vector:V16QI [(const_int 1) (const_int 1)
7893                                    (const_int 1) (const_int 1)
7894                                    (const_int 1) (const_int 1)
7895                                    (const_int 1) (const_int 1)
7896                                    (const_int 1) (const_int 1)
7897                                    (const_int 1) (const_int 1)
7898                                    (const_int 1) (const_int 1)
7899                                    (const_int 1) (const_int 1)]))
7900             (const_int 1))))]
7901   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7902   "vpavgb\t{%2, %1, %0|%0, %1, %2}"
7903   [(set_attr "type" "sseiadd")
7904    (set_attr "prefix" "vex")
7905    (set_attr "mode" "TI")])
7906
7907 (define_insn "*sse2_uavgv16qi3"
7908   [(set (match_operand:V16QI 0 "register_operand" "=x")
7909         (truncate:V16QI
7910           (lshiftrt:V16HI
7911             (plus:V16HI
7912               (plus:V16HI
7913                 (zero_extend:V16HI
7914                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
7915                 (zero_extend:V16HI
7916                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
7917               (const_vector:V16QI [(const_int 1) (const_int 1)
7918                                    (const_int 1) (const_int 1)
7919                                    (const_int 1) (const_int 1)
7920                                    (const_int 1) (const_int 1)
7921                                    (const_int 1) (const_int 1)
7922                                    (const_int 1) (const_int 1)
7923                                    (const_int 1) (const_int 1)
7924                                    (const_int 1) (const_int 1)]))
7925             (const_int 1))))]
7926   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
7927   "pavgb\t{%2, %0|%0, %2}"
7928   [(set_attr "type" "sseiadd")
7929    (set_attr "prefix_data16" "1")
7930    (set_attr "mode" "TI")])
7931
7932 (define_expand "sse2_uavgv8hi3"
7933   [(set (match_operand:V8HI 0 "register_operand" "")
7934         (truncate:V8HI
7935           (lshiftrt:V8SI
7936             (plus:V8SI
7937               (plus:V8SI
7938                 (zero_extend:V8SI
7939                   (match_operand:V8HI 1 "nonimmediate_operand" ""))
7940                 (zero_extend:V8SI
7941                   (match_operand:V8HI 2 "nonimmediate_operand" "")))
7942               (const_vector:V8HI [(const_int 1) (const_int 1)
7943                                   (const_int 1) (const_int 1)
7944                                   (const_int 1) (const_int 1)
7945                                   (const_int 1) (const_int 1)]))
7946             (const_int 1))))]
7947   "TARGET_SSE2"
7948   "ix86_fixup_binary_operands_no_copy (PLUS, V8HImode, operands);")
7949
7950 (define_insn "*avx_uavgv8hi3"
7951   [(set (match_operand:V8HI 0 "register_operand" "=x")
7952         (truncate:V8HI
7953           (lshiftrt:V8SI
7954             (plus:V8SI
7955               (plus:V8SI
7956                 (zero_extend:V8SI
7957                   (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
7958                 (zero_extend:V8SI
7959                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7960               (const_vector:V8HI [(const_int 1) (const_int 1)
7961                                   (const_int 1) (const_int 1)
7962                                   (const_int 1) (const_int 1)
7963                                   (const_int 1) (const_int 1)]))
7964             (const_int 1))))]
7965   "TARGET_AVX && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7966   "vpavgw\t{%2, %1, %0|%0, %1, %2}"
7967   [(set_attr "type" "sseiadd")
7968    (set_attr "prefix" "vex")
7969    (set_attr "mode" "TI")])
7970
7971 (define_insn "*sse2_uavgv8hi3"
7972   [(set (match_operand:V8HI 0 "register_operand" "=x")
7973         (truncate:V8HI
7974           (lshiftrt:V8SI
7975             (plus:V8SI
7976               (plus:V8SI
7977                 (zero_extend:V8SI
7978                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
7979                 (zero_extend:V8SI
7980                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
7981               (const_vector:V8HI [(const_int 1) (const_int 1)
7982                                   (const_int 1) (const_int 1)
7983                                   (const_int 1) (const_int 1)
7984                                   (const_int 1) (const_int 1)]))
7985             (const_int 1))))]
7986   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
7987   "pavgw\t{%2, %0|%0, %2}"
7988   [(set_attr "type" "sseiadd")
7989    (set_attr "prefix_data16" "1")
7990    (set_attr "mode" "TI")])
7991
7992 ;; The correct representation for this is absolutely enormous, and
7993 ;; surely not generally useful.
7994 (define_insn "*avx_psadbw"
7995   [(set (match_operand:V2DI 0 "register_operand" "=x")
7996         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "x")
7997                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
7998                      UNSPEC_PSADBW))]
7999   "TARGET_AVX"
8000   "vpsadbw\t{%2, %1, %0|%0, %1, %2}"
8001   [(set_attr "type" "sseiadd")
8002    (set_attr "prefix" "vex")
8003    (set_attr "mode" "TI")])
8004
8005 (define_insn "sse2_psadbw"
8006   [(set (match_operand:V2DI 0 "register_operand" "=x")
8007         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
8008                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
8009                      UNSPEC_PSADBW))]
8010   "TARGET_SSE2"
8011   "psadbw\t{%2, %0|%0, %2}"
8012   [(set_attr "type" "sseiadd")
8013    (set_attr "atom_unit" "simul")
8014    (set_attr "prefix_data16" "1")
8015    (set_attr "mode" "TI")])
8016
8017 (define_insn "avx_movmsk<ssemodesuffix>256"
8018   [(set (match_operand:SI 0 "register_operand" "=r")
8019         (unspec:SI
8020           [(match_operand:AVX256MODEF2P 1 "register_operand" "x")]
8021           UNSPEC_MOVMSK))]
8022   "AVX256_VEC_FLOAT_MODE_P (<MODE>mode)"
8023   "vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
8024   [(set_attr "type" "ssecvt")
8025    (set_attr "prefix" "vex")
8026    (set_attr "mode" "<MODE>")])
8027
8028 (define_insn "<sse>_movmsk<ssemodesuffix>"
8029   [(set (match_operand:SI 0 "register_operand" "=r")
8030         (unspec:SI
8031           [(match_operand:SSEMODEF2P 1 "register_operand" "x")]
8032           UNSPEC_MOVMSK))]
8033   "SSE_VEC_FLOAT_MODE_P (<MODE>mode)"
8034   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
8035   [(set_attr "type" "ssemov")
8036    (set_attr "prefix" "maybe_vex")
8037    (set_attr "mode" "<MODE>")])
8038
8039 (define_insn "sse2_pmovmskb"
8040   [(set (match_operand:SI 0 "register_operand" "=r")
8041         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
8042                    UNSPEC_MOVMSK))]
8043   "TARGET_SSE2"
8044   "%vpmovmskb\t{%1, %0|%0, %1}"
8045   [(set_attr "type" "ssemov")
8046    (set_attr "prefix_data16" "1")
8047    (set_attr "prefix" "maybe_vex")
8048    (set_attr "mode" "SI")])
8049
8050 (define_expand "sse2_maskmovdqu"
8051   [(set (match_operand:V16QI 0 "memory_operand" "")
8052         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "")
8053                        (match_operand:V16QI 2 "register_operand" "")
8054                        (match_dup 0)]
8055                       UNSPEC_MASKMOV))]
8056   "TARGET_SSE2")
8057
8058 (define_insn "*sse2_maskmovdqu"
8059   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
8060         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8061                        (match_operand:V16QI 2 "register_operand" "x")
8062                        (mem:V16QI (match_dup 0))]
8063                       UNSPEC_MASKMOV))]
8064   "TARGET_SSE2 && !TARGET_64BIT"
8065   ;; @@@ check ordering of operands in intel/nonintel syntax
8066   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8067   [(set_attr "type" "ssemov")
8068    (set_attr "prefix_data16" "1")
8069    ;; The implicit %rdi operand confuses default length_vex computation.
8070    (set_attr "length_vex" "3")
8071    (set_attr "prefix" "maybe_vex")
8072    (set_attr "mode" "TI")])
8073
8074 (define_insn "*sse2_maskmovdqu_rex64"
8075   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
8076         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
8077                        (match_operand:V16QI 2 "register_operand" "x")
8078                        (mem:V16QI (match_dup 0))]
8079                       UNSPEC_MASKMOV))]
8080   "TARGET_SSE2 && TARGET_64BIT"
8081   ;; @@@ check ordering of operands in intel/nonintel syntax
8082   "%vmaskmovdqu\t{%2, %1|%1, %2}"
8083   [(set_attr "type" "ssemov")
8084    (set_attr "prefix_data16" "1")
8085    ;; The implicit %rdi operand confuses default length_vex computation.
8086    (set (attr "length_vex")
8087      (symbol_ref ("REGNO (operands[2]) >= FIRST_REX_SSE_REG ? 3 + 1 : 2 + 1")))
8088    (set_attr "prefix" "maybe_vex")
8089    (set_attr "mode" "TI")])
8090
8091 (define_insn "sse_ldmxcsr"
8092   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
8093                     UNSPECV_LDMXCSR)]
8094   "TARGET_SSE"
8095   "%vldmxcsr\t%0"
8096   [(set_attr "type" "sse")
8097    (set_attr "atom_sse_attr" "mxcsr")
8098    (set_attr "prefix" "maybe_vex")
8099    (set_attr "memory" "load")])
8100
8101 (define_insn "sse_stmxcsr"
8102   [(set (match_operand:SI 0 "memory_operand" "=m")
8103         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
8104   "TARGET_SSE"
8105   "%vstmxcsr\t%0"
8106   [(set_attr "type" "sse")
8107    (set_attr "atom_sse_attr" "mxcsr")
8108    (set_attr "prefix" "maybe_vex")
8109    (set_attr "memory" "store")])
8110
8111 (define_expand "sse_sfence"
8112   [(set (match_dup 0)
8113         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8114   "TARGET_SSE || TARGET_3DNOW_A"
8115 {
8116   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8117   MEM_VOLATILE_P (operands[0]) = 1;
8118 })
8119
8120 (define_insn "*sse_sfence"
8121   [(set (match_operand:BLK 0 "" "")
8122         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
8123   "TARGET_SSE || TARGET_3DNOW_A"
8124   "sfence"
8125   [(set_attr "type" "sse")
8126    (set_attr "length_address" "0")
8127    (set_attr "atom_sse_attr" "fence")
8128    (set_attr "memory" "unknown")])
8129
8130 (define_insn "sse2_clflush"
8131   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
8132                     UNSPECV_CLFLUSH)]
8133   "TARGET_SSE2"
8134   "clflush\t%a0"
8135   [(set_attr "type" "sse")
8136    (set_attr "atom_sse_attr" "fence")
8137    (set_attr "memory" "unknown")])
8138
8139 (define_expand "sse2_mfence"
8140   [(set (match_dup 0)
8141         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8142   "TARGET_SSE2"
8143 {
8144   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8145   MEM_VOLATILE_P (operands[0]) = 1;
8146 })
8147
8148 (define_insn "*sse2_mfence"
8149   [(set (match_operand:BLK 0 "" "")
8150         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
8151   "TARGET_64BIT || TARGET_SSE2"
8152   "mfence"
8153   [(set_attr "type" "sse")
8154    (set_attr "length_address" "0")
8155    (set_attr "atom_sse_attr" "fence")
8156    (set_attr "memory" "unknown")])
8157
8158 (define_expand "sse2_lfence"
8159   [(set (match_dup 0)
8160         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8161   "TARGET_SSE2"
8162 {
8163   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
8164   MEM_VOLATILE_P (operands[0]) = 1;
8165 })
8166
8167 (define_insn "*sse2_lfence"
8168   [(set (match_operand:BLK 0 "" "")
8169         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
8170   "TARGET_SSE2"
8171   "lfence"
8172   [(set_attr "type" "sse")
8173    (set_attr "length_address" "0")
8174    (set_attr "atom_sse_attr" "lfence")
8175    (set_attr "memory" "unknown")])
8176
8177 (define_insn "sse3_mwait"
8178   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8179                      (match_operand:SI 1 "register_operand" "c")]
8180                     UNSPECV_MWAIT)]
8181   "TARGET_SSE3"
8182 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
8183 ;; Since 32bit register operands are implicitly zero extended to 64bit,
8184 ;; we only need to set up 32bit registers.
8185   "mwait"
8186   [(set_attr "length" "3")])
8187
8188 (define_insn "sse3_monitor"
8189   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
8190                      (match_operand:SI 1 "register_operand" "c")
8191                      (match_operand:SI 2 "register_operand" "d")]
8192                     UNSPECV_MONITOR)]
8193   "TARGET_SSE3 && !TARGET_64BIT"
8194   "monitor\t%0, %1, %2"
8195   [(set_attr "length" "3")])
8196
8197 (define_insn "sse3_monitor64"
8198   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
8199                      (match_operand:SI 1 "register_operand" "c")
8200                      (match_operand:SI 2 "register_operand" "d")]
8201                     UNSPECV_MONITOR)]
8202   "TARGET_SSE3 && TARGET_64BIT"
8203 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
8204 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
8205 ;; zero extended to 64bit, we only need to set up 32bit registers.
8206   "monitor"
8207   [(set_attr "length" "3")])
8208
8209 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8210 ;;
8211 ;; SSSE3 instructions
8212 ;;
8213 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8214
8215 (define_insn "*avx_phaddwv8hi3"
8216   [(set (match_operand:V8HI 0 "register_operand" "=x")
8217         (vec_concat:V8HI
8218           (vec_concat:V4HI
8219             (vec_concat:V2HI
8220               (plus:HI
8221                 (vec_select:HI
8222                   (match_operand:V8HI 1 "register_operand" "x")
8223                   (parallel [(const_int 0)]))
8224                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8225               (plus:HI
8226                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8227                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8228             (vec_concat:V2HI
8229               (plus:HI
8230                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8231                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8232               (plus:HI
8233                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8234                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8235           (vec_concat:V4HI
8236             (vec_concat:V2HI
8237               (plus:HI
8238                 (vec_select:HI
8239                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8240                   (parallel [(const_int 0)]))
8241                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8242               (plus:HI
8243                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8244                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8245             (vec_concat:V2HI
8246               (plus:HI
8247                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8248                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8249               (plus:HI
8250                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8251                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8252   "TARGET_AVX"
8253   "vphaddw\t{%2, %1, %0|%0, %1, %2}"
8254   [(set_attr "type" "sseiadd")
8255    (set_attr "prefix_extra" "1")
8256    (set_attr "prefix" "vex")
8257    (set_attr "mode" "TI")])
8258
8259 (define_insn "ssse3_phaddwv8hi3"
8260   [(set (match_operand:V8HI 0 "register_operand" "=x")
8261         (vec_concat:V8HI
8262           (vec_concat:V4HI
8263             (vec_concat:V2HI
8264               (plus:HI
8265                 (vec_select:HI
8266                   (match_operand:V8HI 1 "register_operand" "0")
8267                   (parallel [(const_int 0)]))
8268                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8269               (plus:HI
8270                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8271                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8272             (vec_concat:V2HI
8273               (plus:HI
8274                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8275                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8276               (plus:HI
8277                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8278                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8279           (vec_concat:V4HI
8280             (vec_concat:V2HI
8281               (plus:HI
8282                 (vec_select:HI
8283                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8284                   (parallel [(const_int 0)]))
8285                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8286               (plus:HI
8287                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8288                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8289             (vec_concat:V2HI
8290               (plus:HI
8291                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8292                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8293               (plus:HI
8294                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8295                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8296   "TARGET_SSSE3"
8297   "phaddw\t{%2, %0|%0, %2}"
8298   [(set_attr "type" "sseiadd")
8299    (set_attr "atom_unit" "complex")
8300    (set_attr "prefix_data16" "1")
8301    (set_attr "prefix_extra" "1")
8302    (set_attr "mode" "TI")])
8303
8304 (define_insn "ssse3_phaddwv4hi3"
8305   [(set (match_operand:V4HI 0 "register_operand" "=y")
8306         (vec_concat:V4HI
8307           (vec_concat:V2HI
8308             (plus:HI
8309               (vec_select:HI
8310                 (match_operand:V4HI 1 "register_operand" "0")
8311                 (parallel [(const_int 0)]))
8312               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8313             (plus:HI
8314               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8315               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8316           (vec_concat:V2HI
8317             (plus:HI
8318               (vec_select:HI
8319                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8320                 (parallel [(const_int 0)]))
8321               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8322             (plus:HI
8323               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8324               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8325   "TARGET_SSSE3"
8326   "phaddw\t{%2, %0|%0, %2}"
8327   [(set_attr "type" "sseiadd")
8328    (set_attr "atom_unit" "complex")
8329    (set_attr "prefix_extra" "1")
8330    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8331    (set_attr "mode" "DI")])
8332
8333 (define_insn "*avx_phadddv4si3"
8334   [(set (match_operand:V4SI 0 "register_operand" "=x")
8335         (vec_concat:V4SI
8336           (vec_concat:V2SI
8337             (plus:SI
8338               (vec_select:SI
8339                 (match_operand:V4SI 1 "register_operand" "x")
8340                 (parallel [(const_int 0)]))
8341               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8342             (plus:SI
8343               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8344               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8345           (vec_concat:V2SI
8346             (plus:SI
8347               (vec_select:SI
8348                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8349                 (parallel [(const_int 0)]))
8350               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8351             (plus:SI
8352               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8353               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8354   "TARGET_AVX"
8355   "vphaddd\t{%2, %1, %0|%0, %1, %2}"
8356   [(set_attr "type" "sseiadd")
8357    (set_attr "prefix_extra" "1")
8358    (set_attr "prefix" "vex")
8359    (set_attr "mode" "TI")])
8360
8361 (define_insn "ssse3_phadddv4si3"
8362   [(set (match_operand:V4SI 0 "register_operand" "=x")
8363         (vec_concat:V4SI
8364           (vec_concat:V2SI
8365             (plus:SI
8366               (vec_select:SI
8367                 (match_operand:V4SI 1 "register_operand" "0")
8368                 (parallel [(const_int 0)]))
8369               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8370             (plus:SI
8371               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8372               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8373           (vec_concat:V2SI
8374             (plus:SI
8375               (vec_select:SI
8376                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8377                 (parallel [(const_int 0)]))
8378               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8379             (plus:SI
8380               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8381               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8382   "TARGET_SSSE3"
8383   "phaddd\t{%2, %0|%0, %2}"
8384   [(set_attr "type" "sseiadd")
8385    (set_attr "atom_unit" "complex")
8386    (set_attr "prefix_data16" "1")
8387    (set_attr "prefix_extra" "1")
8388    (set_attr "mode" "TI")])
8389
8390 (define_insn "ssse3_phadddv2si3"
8391   [(set (match_operand:V2SI 0 "register_operand" "=y")
8392         (vec_concat:V2SI
8393           (plus:SI
8394             (vec_select:SI
8395               (match_operand:V2SI 1 "register_operand" "0")
8396               (parallel [(const_int 0)]))
8397             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8398           (plus:SI
8399             (vec_select:SI
8400               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8401               (parallel [(const_int 0)]))
8402             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8403   "TARGET_SSSE3"
8404   "phaddd\t{%2, %0|%0, %2}"
8405   [(set_attr "type" "sseiadd")
8406    (set_attr "atom_unit" "complex")
8407    (set_attr "prefix_extra" "1")
8408    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8409    (set_attr "mode" "DI")])
8410
8411 (define_insn "*avx_phaddswv8hi3"
8412   [(set (match_operand:V8HI 0 "register_operand" "=x")
8413         (vec_concat:V8HI
8414           (vec_concat:V4HI
8415             (vec_concat:V2HI
8416               (ss_plus:HI
8417                 (vec_select:HI
8418                   (match_operand:V8HI 1 "register_operand" "x")
8419                   (parallel [(const_int 0)]))
8420                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8421               (ss_plus:HI
8422                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8423                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8424             (vec_concat:V2HI
8425               (ss_plus:HI
8426                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8427                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8428               (ss_plus:HI
8429                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8430                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8431           (vec_concat:V4HI
8432             (vec_concat:V2HI
8433               (ss_plus:HI
8434                 (vec_select:HI
8435                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8436                   (parallel [(const_int 0)]))
8437                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8438               (ss_plus:HI
8439                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8440                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8441             (vec_concat:V2HI
8442               (ss_plus:HI
8443                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8444                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8445               (ss_plus:HI
8446                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8447                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8448   "TARGET_AVX"
8449   "vphaddsw\t{%2, %1, %0|%0, %1, %2}"
8450   [(set_attr "type" "sseiadd")
8451    (set_attr "prefix_extra" "1")
8452    (set_attr "prefix" "vex")
8453    (set_attr "mode" "TI")])
8454
8455 (define_insn "ssse3_phaddswv8hi3"
8456   [(set (match_operand:V8HI 0 "register_operand" "=x")
8457         (vec_concat:V8HI
8458           (vec_concat:V4HI
8459             (vec_concat:V2HI
8460               (ss_plus:HI
8461                 (vec_select:HI
8462                   (match_operand:V8HI 1 "register_operand" "0")
8463                   (parallel [(const_int 0)]))
8464                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8465               (ss_plus:HI
8466                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8467                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8468             (vec_concat:V2HI
8469               (ss_plus:HI
8470                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8471                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8472               (ss_plus:HI
8473                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8474                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8475           (vec_concat:V4HI
8476             (vec_concat:V2HI
8477               (ss_plus:HI
8478                 (vec_select:HI
8479                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8480                   (parallel [(const_int 0)]))
8481                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8482               (ss_plus:HI
8483                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8484                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8485             (vec_concat:V2HI
8486               (ss_plus:HI
8487                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8488                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8489               (ss_plus:HI
8490                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8491                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8492   "TARGET_SSSE3"
8493   "phaddsw\t{%2, %0|%0, %2}"
8494   [(set_attr "type" "sseiadd")
8495    (set_attr "atom_unit" "complex")
8496    (set_attr "prefix_data16" "1")
8497    (set_attr "prefix_extra" "1")
8498    (set_attr "mode" "TI")])
8499
8500 (define_insn "ssse3_phaddswv4hi3"
8501   [(set (match_operand:V4HI 0 "register_operand" "=y")
8502         (vec_concat:V4HI
8503           (vec_concat:V2HI
8504             (ss_plus:HI
8505               (vec_select:HI
8506                 (match_operand:V4HI 1 "register_operand" "0")
8507                 (parallel [(const_int 0)]))
8508               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8509             (ss_plus:HI
8510               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8511               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8512           (vec_concat:V2HI
8513             (ss_plus:HI
8514               (vec_select:HI
8515                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8516                 (parallel [(const_int 0)]))
8517               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8518             (ss_plus:HI
8519               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8520               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8521   "TARGET_SSSE3"
8522   "phaddsw\t{%2, %0|%0, %2}"
8523   [(set_attr "type" "sseiadd")
8524    (set_attr "atom_unit" "complex")
8525    (set_attr "prefix_extra" "1")
8526    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8527    (set_attr "mode" "DI")])
8528
8529 (define_insn "*avx_phsubwv8hi3"
8530   [(set (match_operand:V8HI 0 "register_operand" "=x")
8531         (vec_concat:V8HI
8532           (vec_concat:V4HI
8533             (vec_concat:V2HI
8534               (minus:HI
8535                 (vec_select:HI
8536                   (match_operand:V8HI 1 "register_operand" "x")
8537                   (parallel [(const_int 0)]))
8538                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8539               (minus:HI
8540                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8541                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8542             (vec_concat:V2HI
8543               (minus:HI
8544                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8545                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8546               (minus:HI
8547                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8548                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8549           (vec_concat:V4HI
8550             (vec_concat:V2HI
8551               (minus:HI
8552                 (vec_select:HI
8553                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8554                   (parallel [(const_int 0)]))
8555                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8556               (minus:HI
8557                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8558                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8559             (vec_concat:V2HI
8560               (minus:HI
8561                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8562                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8563               (minus:HI
8564                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8565                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8566   "TARGET_AVX"
8567   "vphsubw\t{%2, %1, %0|%0, %1, %2}"
8568   [(set_attr "type" "sseiadd")
8569    (set_attr "prefix_extra" "1")
8570    (set_attr "prefix" "vex")
8571    (set_attr "mode" "TI")])
8572
8573 (define_insn "ssse3_phsubwv8hi3"
8574   [(set (match_operand:V8HI 0 "register_operand" "=x")
8575         (vec_concat:V8HI
8576           (vec_concat:V4HI
8577             (vec_concat:V2HI
8578               (minus:HI
8579                 (vec_select:HI
8580                   (match_operand:V8HI 1 "register_operand" "0")
8581                   (parallel [(const_int 0)]))
8582                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8583               (minus:HI
8584                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8585                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8586             (vec_concat:V2HI
8587               (minus:HI
8588                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8589                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8590               (minus:HI
8591                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8592                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8593           (vec_concat:V4HI
8594             (vec_concat:V2HI
8595               (minus:HI
8596                 (vec_select:HI
8597                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8598                   (parallel [(const_int 0)]))
8599                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8600               (minus:HI
8601                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8602                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8603             (vec_concat:V2HI
8604               (minus:HI
8605                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8606                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8607               (minus:HI
8608                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8609                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8610   "TARGET_SSSE3"
8611   "phsubw\t{%2, %0|%0, %2}"
8612   [(set_attr "type" "sseiadd")
8613    (set_attr "atom_unit" "complex")
8614    (set_attr "prefix_data16" "1")
8615    (set_attr "prefix_extra" "1")
8616    (set_attr "mode" "TI")])
8617
8618 (define_insn "ssse3_phsubwv4hi3"
8619   [(set (match_operand:V4HI 0 "register_operand" "=y")
8620         (vec_concat:V4HI
8621           (vec_concat:V2HI
8622             (minus:HI
8623               (vec_select:HI
8624                 (match_operand:V4HI 1 "register_operand" "0")
8625                 (parallel [(const_int 0)]))
8626               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8627             (minus:HI
8628               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8629               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8630           (vec_concat:V2HI
8631             (minus:HI
8632               (vec_select:HI
8633                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8634                 (parallel [(const_int 0)]))
8635               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8636             (minus:HI
8637               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8638               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8639   "TARGET_SSSE3"
8640   "phsubw\t{%2, %0|%0, %2}"
8641   [(set_attr "type" "sseiadd")
8642    (set_attr "atom_unit" "complex")
8643    (set_attr "prefix_extra" "1")
8644    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8645    (set_attr "mode" "DI")])
8646
8647 (define_insn "*avx_phsubdv4si3"
8648   [(set (match_operand:V4SI 0 "register_operand" "=x")
8649         (vec_concat:V4SI
8650           (vec_concat:V2SI
8651             (minus:SI
8652               (vec_select:SI
8653                 (match_operand:V4SI 1 "register_operand" "x")
8654                 (parallel [(const_int 0)]))
8655               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8656             (minus:SI
8657               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8658               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8659           (vec_concat:V2SI
8660             (minus:SI
8661               (vec_select:SI
8662                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8663                 (parallel [(const_int 0)]))
8664               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8665             (minus:SI
8666               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8667               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8668   "TARGET_AVX"
8669   "vphsubd\t{%2, %1, %0|%0, %1, %2}"
8670   [(set_attr "type" "sseiadd")
8671    (set_attr "prefix_extra" "1")
8672    (set_attr "prefix" "vex")
8673    (set_attr "mode" "TI")])
8674
8675 (define_insn "ssse3_phsubdv4si3"
8676   [(set (match_operand:V4SI 0 "register_operand" "=x")
8677         (vec_concat:V4SI
8678           (vec_concat:V2SI
8679             (minus:SI
8680               (vec_select:SI
8681                 (match_operand:V4SI 1 "register_operand" "0")
8682                 (parallel [(const_int 0)]))
8683               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8684             (minus:SI
8685               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8686               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8687           (vec_concat:V2SI
8688             (minus:SI
8689               (vec_select:SI
8690                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
8691                 (parallel [(const_int 0)]))
8692               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8693             (minus:SI
8694               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8695               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8696   "TARGET_SSSE3"
8697   "phsubd\t{%2, %0|%0, %2}"
8698   [(set_attr "type" "sseiadd")
8699    (set_attr "atom_unit" "complex")
8700    (set_attr "prefix_data16" "1")
8701    (set_attr "prefix_extra" "1")
8702    (set_attr "mode" "TI")])
8703
8704 (define_insn "ssse3_phsubdv2si3"
8705   [(set (match_operand:V2SI 0 "register_operand" "=y")
8706         (vec_concat:V2SI
8707           (minus:SI
8708             (vec_select:SI
8709               (match_operand:V2SI 1 "register_operand" "0")
8710               (parallel [(const_int 0)]))
8711             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8712           (minus:SI
8713             (vec_select:SI
8714               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8715               (parallel [(const_int 0)]))
8716             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8717   "TARGET_SSSE3"
8718   "phsubd\t{%2, %0|%0, %2}"
8719   [(set_attr "type" "sseiadd")
8720    (set_attr "atom_unit" "complex")
8721    (set_attr "prefix_extra" "1")
8722    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8723    (set_attr "mode" "DI")])
8724
8725 (define_insn "*avx_phsubswv8hi3"
8726   [(set (match_operand:V8HI 0 "register_operand" "=x")
8727         (vec_concat:V8HI
8728           (vec_concat:V4HI
8729             (vec_concat:V2HI
8730               (ss_minus:HI
8731                 (vec_select:HI
8732                   (match_operand:V8HI 1 "register_operand" "x")
8733                   (parallel [(const_int 0)]))
8734                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8735               (ss_minus:HI
8736                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8737                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8738             (vec_concat:V2HI
8739               (ss_minus:HI
8740                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8741                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8742               (ss_minus:HI
8743                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8744                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8745           (vec_concat:V4HI
8746             (vec_concat:V2HI
8747               (ss_minus:HI
8748                 (vec_select:HI
8749                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8750                   (parallel [(const_int 0)]))
8751                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8752               (ss_minus:HI
8753                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8754                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8755             (vec_concat:V2HI
8756               (ss_minus:HI
8757                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8758                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8759               (ss_minus:HI
8760                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8761                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8762   "TARGET_AVX"
8763   "vphsubsw\t{%2, %1, %0|%0, %1, %2}"
8764   [(set_attr "type" "sseiadd")
8765    (set_attr "prefix_extra" "1")
8766    (set_attr "prefix" "vex")
8767    (set_attr "mode" "TI")])
8768
8769 (define_insn "ssse3_phsubswv8hi3"
8770   [(set (match_operand:V8HI 0 "register_operand" "=x")
8771         (vec_concat:V8HI
8772           (vec_concat:V4HI
8773             (vec_concat:V2HI
8774               (ss_minus:HI
8775                 (vec_select:HI
8776                   (match_operand:V8HI 1 "register_operand" "0")
8777                   (parallel [(const_int 0)]))
8778                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8779               (ss_minus:HI
8780                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8781                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8782             (vec_concat:V2HI
8783               (ss_minus:HI
8784                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
8785                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
8786               (ss_minus:HI
8787                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
8788                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
8789           (vec_concat:V4HI
8790             (vec_concat:V2HI
8791               (ss_minus:HI
8792                 (vec_select:HI
8793                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
8794                   (parallel [(const_int 0)]))
8795                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8796               (ss_minus:HI
8797                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8798                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
8799             (vec_concat:V2HI
8800               (ss_minus:HI
8801                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
8802                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
8803               (ss_minus:HI
8804                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
8805                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
8806   "TARGET_SSSE3"
8807   "phsubsw\t{%2, %0|%0, %2}"
8808   [(set_attr "type" "sseiadd")
8809    (set_attr "atom_unit" "complex")
8810    (set_attr "prefix_data16" "1")
8811    (set_attr "prefix_extra" "1")
8812    (set_attr "mode" "TI")])
8813
8814 (define_insn "ssse3_phsubswv4hi3"
8815   [(set (match_operand:V4HI 0 "register_operand" "=y")
8816         (vec_concat:V4HI
8817           (vec_concat:V2HI
8818             (ss_minus:HI
8819               (vec_select:HI
8820                 (match_operand:V4HI 1 "register_operand" "0")
8821                 (parallel [(const_int 0)]))
8822               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
8823             (ss_minus:HI
8824               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
8825               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
8826           (vec_concat:V2HI
8827             (ss_minus:HI
8828               (vec_select:HI
8829                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
8830                 (parallel [(const_int 0)]))
8831               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
8832             (ss_minus:HI
8833               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
8834               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
8835   "TARGET_SSSE3"
8836   "phsubsw\t{%2, %0|%0, %2}"
8837   [(set_attr "type" "sseiadd")
8838    (set_attr "atom_unit" "complex")
8839    (set_attr "prefix_extra" "1")
8840    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8841    (set_attr "mode" "DI")])
8842
8843 (define_insn "*avx_pmaddubsw128"
8844   [(set (match_operand:V8HI 0 "register_operand" "=x")
8845         (ss_plus:V8HI
8846           (mult:V8HI
8847             (zero_extend:V8HI
8848               (vec_select:V4QI
8849                 (match_operand:V16QI 1 "register_operand" "x")
8850                 (parallel [(const_int 0)
8851                            (const_int 2)
8852                            (const_int 4)
8853                            (const_int 6)
8854                            (const_int 8)
8855                            (const_int 10)
8856                            (const_int 12)
8857                            (const_int 14)])))
8858             (sign_extend:V8HI
8859               (vec_select:V8QI
8860                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8861                 (parallel [(const_int 0)
8862                            (const_int 2)
8863                            (const_int 4)
8864                            (const_int 6)
8865                            (const_int 8)
8866                            (const_int 10)
8867                            (const_int 12)
8868                            (const_int 14)]))))
8869           (mult:V8HI
8870             (zero_extend:V8HI
8871               (vec_select:V16QI (match_dup 1)
8872                 (parallel [(const_int 1)
8873                            (const_int 3)
8874                            (const_int 5)
8875                            (const_int 7)
8876                            (const_int 9)
8877                            (const_int 11)
8878                            (const_int 13)
8879                            (const_int 15)])))
8880             (sign_extend:V8HI
8881               (vec_select:V16QI (match_dup 2)
8882                 (parallel [(const_int 1)
8883                            (const_int 3)
8884                            (const_int 5)
8885                            (const_int 7)
8886                            (const_int 9)
8887                            (const_int 11)
8888                            (const_int 13)
8889                            (const_int 15)]))))))]
8890   "TARGET_AVX"
8891   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8892   [(set_attr "type" "sseiadd")
8893    (set_attr "prefix_extra" "1")
8894    (set_attr "prefix" "vex")
8895    (set_attr "mode" "TI")])
8896
8897 (define_insn "ssse3_pmaddubsw128"
8898   [(set (match_operand:V8HI 0 "register_operand" "=x")
8899         (ss_plus:V8HI
8900           (mult:V8HI
8901             (zero_extend:V8HI
8902               (vec_select:V4QI
8903                 (match_operand:V16QI 1 "register_operand" "0")
8904                 (parallel [(const_int 0)
8905                            (const_int 2)
8906                            (const_int 4)
8907                            (const_int 6)
8908                            (const_int 8)
8909                            (const_int 10)
8910                            (const_int 12)
8911                            (const_int 14)])))
8912             (sign_extend:V8HI
8913               (vec_select:V8QI
8914                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
8915                 (parallel [(const_int 0)
8916                            (const_int 2)
8917                            (const_int 4)
8918                            (const_int 6)
8919                            (const_int 8)
8920                            (const_int 10)
8921                            (const_int 12)
8922                            (const_int 14)]))))
8923           (mult:V8HI
8924             (zero_extend:V8HI
8925               (vec_select:V16QI (match_dup 1)
8926                 (parallel [(const_int 1)
8927                            (const_int 3)
8928                            (const_int 5)
8929                            (const_int 7)
8930                            (const_int 9)
8931                            (const_int 11)
8932                            (const_int 13)
8933                            (const_int 15)])))
8934             (sign_extend:V8HI
8935               (vec_select:V16QI (match_dup 2)
8936                 (parallel [(const_int 1)
8937                            (const_int 3)
8938                            (const_int 5)
8939                            (const_int 7)
8940                            (const_int 9)
8941                            (const_int 11)
8942                            (const_int 13)
8943                            (const_int 15)]))))))]
8944   "TARGET_SSSE3"
8945   "pmaddubsw\t{%2, %0|%0, %2}"
8946   [(set_attr "type" "sseiadd")
8947    (set_attr "atom_unit" "simul")
8948    (set_attr "prefix_data16" "1")
8949    (set_attr "prefix_extra" "1")
8950    (set_attr "mode" "TI")])
8951
8952 (define_insn "ssse3_pmaddubsw"
8953   [(set (match_operand:V4HI 0 "register_operand" "=y")
8954         (ss_plus:V4HI
8955           (mult:V4HI
8956             (zero_extend:V4HI
8957               (vec_select:V4QI
8958                 (match_operand:V8QI 1 "register_operand" "0")
8959                 (parallel [(const_int 0)
8960                            (const_int 2)
8961                            (const_int 4)
8962                            (const_int 6)])))
8963             (sign_extend:V4HI
8964               (vec_select:V4QI
8965                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8966                 (parallel [(const_int 0)
8967                            (const_int 2)
8968                            (const_int 4)
8969                            (const_int 6)]))))
8970           (mult:V4HI
8971             (zero_extend:V4HI
8972               (vec_select:V8QI (match_dup 1)
8973                 (parallel [(const_int 1)
8974                            (const_int 3)
8975                            (const_int 5)
8976                            (const_int 7)])))
8977             (sign_extend:V4HI
8978               (vec_select:V8QI (match_dup 2)
8979                 (parallel [(const_int 1)
8980                            (const_int 3)
8981                            (const_int 5)
8982                            (const_int 7)]))))))]
8983   "TARGET_SSSE3"
8984   "pmaddubsw\t{%2, %0|%0, %2}"
8985   [(set_attr "type" "sseiadd")
8986    (set_attr "atom_unit" "simul")
8987    (set_attr "prefix_extra" "1")
8988    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8989    (set_attr "mode" "DI")])
8990
8991 (define_expand "ssse3_pmulhrswv8hi3"
8992   [(set (match_operand:V8HI 0 "register_operand" "")
8993         (truncate:V8HI
8994           (lshiftrt:V8SI
8995             (plus:V8SI
8996               (lshiftrt:V8SI
8997                 (mult:V8SI
8998                   (sign_extend:V8SI
8999                     (match_operand:V8HI 1 "nonimmediate_operand" ""))
9000                   (sign_extend:V8SI
9001                     (match_operand:V8HI 2 "nonimmediate_operand" "")))
9002                 (const_int 14))
9003               (const_vector:V8HI [(const_int 1) (const_int 1)
9004                                   (const_int 1) (const_int 1)
9005                                   (const_int 1) (const_int 1)
9006                                   (const_int 1) (const_int 1)]))
9007             (const_int 1))))]
9008   "TARGET_SSSE3"
9009   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
9010
9011 (define_insn "*avx_pmulhrswv8hi3"
9012   [(set (match_operand:V8HI 0 "register_operand" "=x")
9013         (truncate:V8HI
9014           (lshiftrt:V8SI
9015             (plus:V8SI
9016               (lshiftrt:V8SI
9017                 (mult:V8SI
9018                   (sign_extend:V8SI
9019                     (match_operand:V8HI 1 "nonimmediate_operand" "%x"))
9020                   (sign_extend:V8SI
9021                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
9022                 (const_int 14))
9023               (const_vector:V8HI [(const_int 1) (const_int 1)
9024                                   (const_int 1) (const_int 1)
9025                                   (const_int 1) (const_int 1)
9026                                   (const_int 1) (const_int 1)]))
9027             (const_int 1))))]
9028   "TARGET_AVX && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9029   "vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
9030   [(set_attr "type" "sseimul")
9031    (set_attr "prefix_extra" "1")
9032    (set_attr "prefix" "vex")
9033    (set_attr "mode" "TI")])
9034
9035 (define_insn "*ssse3_pmulhrswv8hi3"
9036   [(set (match_operand:V8HI 0 "register_operand" "=x")
9037         (truncate:V8HI
9038           (lshiftrt:V8SI
9039             (plus:V8SI
9040               (lshiftrt:V8SI
9041                 (mult:V8SI
9042                   (sign_extend:V8SI
9043                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
9044                   (sign_extend:V8SI
9045                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
9046                 (const_int 14))
9047               (const_vector:V8HI [(const_int 1) (const_int 1)
9048                                   (const_int 1) (const_int 1)
9049                                   (const_int 1) (const_int 1)
9050                                   (const_int 1) (const_int 1)]))
9051             (const_int 1))))]
9052   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
9053   "pmulhrsw\t{%2, %0|%0, %2}"
9054   [(set_attr "type" "sseimul")
9055    (set_attr "prefix_data16" "1")
9056    (set_attr "prefix_extra" "1")
9057    (set_attr "mode" "TI")])
9058
9059 (define_expand "ssse3_pmulhrswv4hi3"
9060   [(set (match_operand:V4HI 0 "register_operand" "")
9061         (truncate:V4HI
9062           (lshiftrt:V4SI
9063             (plus:V4SI
9064               (lshiftrt:V4SI
9065                 (mult:V4SI
9066                   (sign_extend:V4SI
9067                     (match_operand:V4HI 1 "nonimmediate_operand" ""))
9068                   (sign_extend:V4SI
9069                     (match_operand:V4HI 2 "nonimmediate_operand" "")))
9070                 (const_int 14))
9071               (const_vector:V4HI [(const_int 1) (const_int 1)
9072                                   (const_int 1) (const_int 1)]))
9073             (const_int 1))))]
9074   "TARGET_SSSE3"
9075   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
9076
9077 (define_insn "*ssse3_pmulhrswv4hi3"
9078   [(set (match_operand:V4HI 0 "register_operand" "=y")
9079         (truncate:V4HI
9080           (lshiftrt:V4SI
9081             (plus:V4SI
9082               (lshiftrt:V4SI
9083                 (mult:V4SI
9084                   (sign_extend:V4SI
9085                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
9086                   (sign_extend:V4SI
9087                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
9088                 (const_int 14))
9089               (const_vector:V4HI [(const_int 1) (const_int 1)
9090                                   (const_int 1) (const_int 1)]))
9091             (const_int 1))))]
9092   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
9093   "pmulhrsw\t{%2, %0|%0, %2}"
9094   [(set_attr "type" "sseimul")
9095    (set_attr "prefix_extra" "1")
9096    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9097    (set_attr "mode" "DI")])
9098
9099 (define_insn "*avx_pshufbv16qi3"
9100   [(set (match_operand:V16QI 0 "register_operand" "=x")
9101         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9102                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9103                       UNSPEC_PSHUFB))]
9104   "TARGET_AVX"
9105   "vpshufb\t{%2, %1, %0|%0, %1, %2}";
9106   [(set_attr "type" "sselog1")
9107    (set_attr "prefix_extra" "1")
9108    (set_attr "prefix" "vex")
9109    (set_attr "mode" "TI")])
9110
9111 (define_insn "ssse3_pshufbv16qi3"
9112   [(set (match_operand:V16QI 0 "register_operand" "=x")
9113         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9114                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
9115                       UNSPEC_PSHUFB))]
9116   "TARGET_SSSE3"
9117   "pshufb\t{%2, %0|%0, %2}";
9118   [(set_attr "type" "sselog1")
9119    (set_attr "prefix_data16" "1")
9120    (set_attr "prefix_extra" "1")
9121    (set_attr "mode" "TI")])
9122
9123 (define_insn "ssse3_pshufbv8qi3"
9124   [(set (match_operand:V8QI 0 "register_operand" "=y")
9125         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
9126                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
9127                      UNSPEC_PSHUFB))]
9128   "TARGET_SSSE3"
9129   "pshufb\t{%2, %0|%0, %2}";
9130   [(set_attr "type" "sselog1")
9131    (set_attr "prefix_extra" "1")
9132    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9133    (set_attr "mode" "DI")])
9134
9135 (define_insn "*avx_psign<mode>3"
9136   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9137         (unspec:SSEMODE124
9138           [(match_operand:SSEMODE124 1 "register_operand" "x")
9139            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9140           UNSPEC_PSIGN))]
9141   "TARGET_AVX"
9142   "vpsign<ssevecsize>\t{%2, %1, %0|%0, %1, %2}";
9143   [(set_attr "type" "sselog1")
9144    (set_attr "prefix_extra" "1")
9145    (set_attr "prefix" "vex")
9146    (set_attr "mode" "TI")])
9147
9148 (define_insn "ssse3_psign<mode>3"
9149   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9150         (unspec:SSEMODE124
9151           [(match_operand:SSEMODE124 1 "register_operand" "0")
9152            (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
9153           UNSPEC_PSIGN))]
9154   "TARGET_SSSE3"
9155   "psign<ssevecsize>\t{%2, %0|%0, %2}";
9156   [(set_attr "type" "sselog1")
9157    (set_attr "prefix_data16" "1")
9158    (set_attr "prefix_extra" "1")
9159    (set_attr "mode" "TI")])
9160
9161 (define_insn "ssse3_psign<mode>3"
9162   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9163         (unspec:MMXMODEI
9164           [(match_operand:MMXMODEI 1 "register_operand" "0")
9165            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
9166           UNSPEC_PSIGN))]
9167   "TARGET_SSSE3"
9168   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
9169   [(set_attr "type" "sselog1")
9170    (set_attr "prefix_extra" "1")
9171    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9172    (set_attr "mode" "DI")])
9173
9174 (define_insn "*avx_palignrti"
9175   [(set (match_operand:TI 0 "register_operand" "=x")
9176         (unspec:TI [(match_operand:TI 1 "register_operand" "x")
9177                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9178                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9179                    UNSPEC_PALIGNR))]
9180   "TARGET_AVX"
9181 {
9182   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9183   return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
9184 }
9185   [(set_attr "type" "sseishft")
9186    (set_attr "prefix_extra" "1")
9187    (set_attr "length_immediate" "1")
9188    (set_attr "prefix" "vex")
9189    (set_attr "mode" "TI")])
9190
9191 (define_insn "ssse3_palignrti"
9192   [(set (match_operand:TI 0 "register_operand" "=x")
9193         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
9194                     (match_operand:TI 2 "nonimmediate_operand" "xm")
9195                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9196                    UNSPEC_PALIGNR))]
9197   "TARGET_SSSE3"
9198 {
9199   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9200   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9201 }
9202   [(set_attr "type" "sseishft")
9203    (set_attr "atom_unit" "sishuf")
9204    (set_attr "prefix_data16" "1")
9205    (set_attr "prefix_extra" "1")
9206    (set_attr "length_immediate" "1")
9207    (set_attr "mode" "TI")])
9208
9209 (define_insn "ssse3_palignrdi"
9210   [(set (match_operand:DI 0 "register_operand" "=y")
9211         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
9212                     (match_operand:DI 2 "nonimmediate_operand" "ym")
9213                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
9214                    UNSPEC_PALIGNR))]
9215   "TARGET_SSSE3"
9216 {
9217   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
9218   return "palignr\t{%3, %2, %0|%0, %2, %3}";
9219 }
9220   [(set_attr "type" "sseishft")
9221    (set_attr "atom_unit" "sishuf")
9222    (set_attr "prefix_extra" "1")
9223    (set_attr "length_immediate" "1")
9224    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9225    (set_attr "mode" "DI")])
9226
9227 (define_insn "abs<mode>2"
9228   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
9229         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
9230   "TARGET_SSSE3"
9231   "%vpabs<ssevecsize>\t{%1, %0|%0, %1}"
9232   [(set_attr "type" "sselog1")
9233    (set_attr "prefix_data16" "1")
9234    (set_attr "prefix_extra" "1")
9235    (set_attr "prefix" "maybe_vex")
9236    (set_attr "mode" "TI")])
9237
9238 (define_insn "abs<mode>2"
9239   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
9240         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
9241   "TARGET_SSSE3"
9242   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
9243   [(set_attr "type" "sselog1")
9244    (set_attr "prefix_rep" "0")
9245    (set_attr "prefix_extra" "1")
9246    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
9247    (set_attr "mode" "DI")])
9248
9249 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9250 ;;
9251 ;; AMD SSE4A instructions
9252 ;;
9253 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9254
9255 (define_insn "sse4a_movnt<mode>"
9256   [(set (match_operand:MODEF 0 "memory_operand" "=m")
9257         (unspec:MODEF
9258           [(match_operand:MODEF 1 "register_operand" "x")]
9259           UNSPEC_MOVNT))]
9260   "TARGET_SSE4A"
9261   "movnts<ssemodefsuffix>\t{%1, %0|%0, %1}"
9262   [(set_attr "type" "ssemov")
9263    (set_attr "mode" "<MODE>")])
9264
9265 (define_insn "sse4a_vmmovnt<mode>"
9266   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
9267         (unspec:<ssescalarmode>
9268           [(vec_select:<ssescalarmode>
9269              (match_operand:SSEMODEF2P 1 "register_operand" "x")
9270              (parallel [(const_int 0)]))]
9271           UNSPEC_MOVNT))]
9272   "TARGET_SSE4A"
9273   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
9274   [(set_attr "type" "ssemov")
9275    (set_attr "mode" "<ssescalarmode>")])
9276
9277 (define_insn "sse4a_extrqi"
9278   [(set (match_operand:V2DI 0 "register_operand" "=x")
9279         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9280                       (match_operand 2 "const_int_operand" "")
9281                       (match_operand 3 "const_int_operand" "")]
9282                      UNSPEC_EXTRQI))]
9283   "TARGET_SSE4A"
9284   "extrq\t{%3, %2, %0|%0, %2, %3}"
9285   [(set_attr "type" "sse")
9286    (set_attr "prefix_data16" "1")
9287    (set_attr "length_immediate" "2")
9288    (set_attr "mode" "TI")])
9289
9290 (define_insn "sse4a_extrq"
9291   [(set (match_operand:V2DI 0 "register_operand" "=x")
9292         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9293                       (match_operand:V16QI 2 "register_operand" "x")]
9294                      UNSPEC_EXTRQ))]
9295   "TARGET_SSE4A"
9296   "extrq\t{%2, %0|%0, %2}"
9297   [(set_attr "type" "sse")
9298    (set_attr "prefix_data16" "1")
9299    (set_attr "mode" "TI")])
9300
9301 (define_insn "sse4a_insertqi"
9302   [(set (match_operand:V2DI 0 "register_operand" "=x")
9303         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9304                       (match_operand:V2DI 2 "register_operand" "x")
9305                       (match_operand 3 "const_int_operand" "")
9306                       (match_operand 4 "const_int_operand" "")]
9307                      UNSPEC_INSERTQI))]
9308   "TARGET_SSE4A"
9309   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
9310   [(set_attr "type" "sseins")
9311    (set_attr "prefix_data16" "0")
9312    (set_attr "prefix_rep" "1")
9313    (set_attr "length_immediate" "2")
9314    (set_attr "mode" "TI")])
9315
9316 (define_insn "sse4a_insertq"
9317   [(set (match_operand:V2DI 0 "register_operand" "=x")
9318         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
9319                       (match_operand:V2DI 2 "register_operand" "x")]
9320                      UNSPEC_INSERTQ))]
9321   "TARGET_SSE4A"
9322   "insertq\t{%2, %0|%0, %2}"
9323   [(set_attr "type" "sseins")
9324    (set_attr "prefix_data16" "0")
9325    (set_attr "prefix_rep" "1")
9326    (set_attr "mode" "TI")])
9327
9328 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9329 ;;
9330 ;; Intel SSE4.1 instructions
9331 ;;
9332 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9333
9334 (define_insn "avx_blend<ssemodesuffix><avxmodesuffix>"
9335   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9336         (vec_merge:AVXMODEF2P
9337           (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9338           (match_operand:AVXMODEF2P 1 "register_operand" "x")
9339           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9340   "TARGET_AVX"
9341   "vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9342   [(set_attr "type" "ssemov")
9343    (set_attr "prefix_extra" "1")
9344    (set_attr "length_immediate" "1")
9345    (set_attr "prefix" "vex")
9346    (set_attr "mode" "<avxvecmode>")])
9347
9348 (define_insn "avx_blendv<ssemodesuffix><avxmodesuffix>"
9349   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9350         (unspec:AVXMODEF2P
9351           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
9352            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9353            (match_operand:AVXMODEF2P 3 "register_operand" "x")]
9354           UNSPEC_BLENDV))]
9355   "TARGET_AVX"
9356   "vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9357   [(set_attr "type" "ssemov")
9358    (set_attr "prefix_extra" "1")
9359    (set_attr "length_immediate" "1")
9360    (set_attr "prefix" "vex")
9361    (set_attr "mode" "<avxvecmode>")])
9362
9363 (define_insn "sse4_1_blend<ssemodesuffix>"
9364   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9365         (vec_merge:SSEMODEF2P
9366           (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9367           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9368           (match_operand:SI 3 "const_0_to_<blendbits>_operand" "n")))]
9369   "TARGET_SSE4_1"
9370   "blend<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9371   [(set_attr "type" "ssemov")
9372    (set_attr "prefix_data16" "1")
9373    (set_attr "prefix_extra" "1")
9374    (set_attr "length_immediate" "1")
9375    (set_attr "mode" "<MODE>")])
9376
9377 (define_insn "sse4_1_blendv<ssemodesuffix>"
9378   [(set (match_operand:SSEMODEF2P 0 "reg_not_xmm0_operand" "=x")
9379         (unspec:SSEMODEF2P
9380           [(match_operand:SSEMODEF2P 1 "reg_not_xmm0_operand" "0")
9381            (match_operand:SSEMODEF2P 2 "nonimm_not_xmm0_operand" "xm")
9382            (match_operand:SSEMODEF2P 3 "register_operand" "Yz")]
9383           UNSPEC_BLENDV))]
9384   "TARGET_SSE4_1"
9385   "blendv<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9386   [(set_attr "type" "ssemov")
9387    (set_attr "prefix_data16" "1")
9388    (set_attr "prefix_extra" "1")
9389    (set_attr "mode" "<MODE>")])
9390
9391 (define_insn "avx_dp<ssemodesuffix><avxmodesuffix>"
9392   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
9393         (unspec:AVXMODEF2P
9394           [(match_operand:AVXMODEF2P 1 "nonimmediate_operand" "%x")
9395            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")
9396            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9397           UNSPEC_DP))]
9398   "TARGET_AVX"
9399   "vdp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9400   [(set_attr "type" "ssemul")
9401    (set_attr "prefix" "vex")
9402    (set_attr "prefix_extra" "1")
9403    (set_attr "length_immediate" "1")
9404    (set_attr "mode" "<avxvecmode>")])
9405
9406 (define_insn "sse4_1_dp<ssemodesuffix>"
9407   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9408         (unspec:SSEMODEF2P
9409           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "%0")
9410            (match_operand:SSEMODEF2P 2 "nonimmediate_operand" "xm")
9411            (match_operand:SI 3 "const_0_to_255_operand" "n")]
9412           UNSPEC_DP))]
9413   "TARGET_SSE4_1"
9414   "dp<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9415   [(set_attr "type" "ssemul")
9416    (set_attr "prefix_data16" "1")
9417    (set_attr "prefix_extra" "1")
9418    (set_attr "length_immediate" "1")
9419    (set_attr "mode" "<MODE>")])
9420
9421 (define_insn "sse4_1_movntdqa"
9422   [(set (match_operand:V2DI 0 "register_operand" "=x")
9423         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
9424                      UNSPEC_MOVNTDQA))]
9425   "TARGET_SSE4_1"
9426   "%vmovntdqa\t{%1, %0|%0, %1}"
9427   [(set_attr "type" "ssemov")
9428    (set_attr "prefix_extra" "1")
9429    (set_attr "prefix" "maybe_vex")
9430    (set_attr "mode" "TI")])
9431
9432 (define_insn "*avx_mpsadbw"
9433   [(set (match_operand:V16QI 0 "register_operand" "=x")
9434         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
9435                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9436                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9437                       UNSPEC_MPSADBW))]
9438   "TARGET_AVX"
9439   "vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9440   [(set_attr "type" "sselog1")
9441    (set_attr "prefix" "vex")
9442    (set_attr "prefix_extra" "1")
9443    (set_attr "length_immediate" "1")
9444    (set_attr "mode" "TI")])
9445
9446 (define_insn "sse4_1_mpsadbw"
9447   [(set (match_operand:V16QI 0 "register_operand" "=x")
9448         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
9449                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9450                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
9451                       UNSPEC_MPSADBW))]
9452   "TARGET_SSE4_1"
9453   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
9454   [(set_attr "type" "sselog1")
9455    (set_attr "prefix_extra" "1")
9456    (set_attr "length_immediate" "1")
9457    (set_attr "mode" "TI")])
9458
9459 (define_insn "*avx_packusdw"
9460   [(set (match_operand:V8HI 0 "register_operand" "=x")
9461         (vec_concat:V8HI
9462           (us_truncate:V4HI
9463             (match_operand:V4SI 1 "register_operand" "x"))
9464           (us_truncate:V4HI
9465             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9466   "TARGET_AVX"
9467   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
9468   [(set_attr "type" "sselog")
9469    (set_attr "prefix_extra" "1")
9470    (set_attr "prefix" "vex")
9471    (set_attr "mode" "TI")])
9472
9473 (define_insn "sse4_1_packusdw"
9474   [(set (match_operand:V8HI 0 "register_operand" "=x")
9475         (vec_concat:V8HI
9476           (us_truncate:V4HI
9477             (match_operand:V4SI 1 "register_operand" "0"))
9478           (us_truncate:V4HI
9479             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
9480   "TARGET_SSE4_1"
9481   "packusdw\t{%2, %0|%0, %2}"
9482   [(set_attr "type" "sselog")
9483    (set_attr "prefix_extra" "1")
9484    (set_attr "mode" "TI")])
9485
9486 (define_insn "*avx_pblendvb"
9487   [(set (match_operand:V16QI 0 "register_operand" "=x")
9488         (unspec:V16QI [(match_operand:V16QI 1 "register_operand"  "x")
9489                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
9490                        (match_operand:V16QI 3 "register_operand" "x")]
9491                       UNSPEC_BLENDV))]
9492   "TARGET_AVX"
9493   "vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9494   [(set_attr "type" "ssemov")
9495    (set_attr "prefix_extra" "1")
9496    (set_attr "length_immediate" "1")
9497    (set_attr "prefix" "vex")
9498    (set_attr "mode" "TI")])
9499
9500 (define_insn "sse4_1_pblendvb"
9501   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
9502         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
9503                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
9504                        (match_operand:V16QI 3 "register_operand" "Yz")]
9505                       UNSPEC_BLENDV))]
9506   "TARGET_SSE4_1"
9507   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
9508   [(set_attr "type" "ssemov")
9509    (set_attr "prefix_extra" "1")
9510    (set_attr "mode" "TI")])
9511
9512 (define_insn "*avx_pblendw"
9513   [(set (match_operand:V8HI 0 "register_operand" "=x")
9514         (vec_merge:V8HI
9515           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9516           (match_operand:V8HI 1 "register_operand" "x")
9517           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9518   "TARGET_AVX"
9519   "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9520   [(set_attr "type" "ssemov")
9521    (set_attr "prefix" "vex")
9522    (set_attr "prefix_extra" "1")
9523    (set_attr "length_immediate" "1")
9524    (set_attr "mode" "TI")])
9525
9526 (define_insn "sse4_1_pblendw"
9527   [(set (match_operand:V8HI 0 "register_operand" "=x")
9528         (vec_merge:V8HI
9529           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9530           (match_operand:V8HI 1 "register_operand" "0")
9531           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
9532   "TARGET_SSE4_1"
9533   "pblendw\t{%3, %2, %0|%0, %2, %3}"
9534   [(set_attr "type" "ssemov")
9535    (set_attr "prefix_extra" "1")
9536    (set_attr "length_immediate" "1")
9537    (set_attr "mode" "TI")])
9538
9539 (define_insn "sse4_1_phminposuw"
9540   [(set (match_operand:V8HI 0 "register_operand" "=x")
9541         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
9542                      UNSPEC_PHMINPOSUW))]
9543   "TARGET_SSE4_1"
9544   "%vphminposuw\t{%1, %0|%0, %1}"
9545   [(set_attr "type" "sselog1")
9546    (set_attr "prefix_extra" "1")
9547    (set_attr "prefix" "maybe_vex")
9548    (set_attr "mode" "TI")])
9549
9550 (define_insn "sse4_1_<code>v8qiv8hi2"
9551   [(set (match_operand:V8HI 0 "register_operand" "=x")
9552         (any_extend:V8HI
9553           (vec_select:V8QI
9554             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9555             (parallel [(const_int 0)
9556                        (const_int 1)
9557                        (const_int 2)
9558                        (const_int 3)
9559                        (const_int 4)
9560                        (const_int 5)
9561                        (const_int 6)
9562                        (const_int 7)]))))]
9563   "TARGET_SSE4_1"
9564   "%vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
9565   [(set_attr "type" "ssemov")
9566    (set_attr "prefix_extra" "1")
9567    (set_attr "prefix" "maybe_vex")
9568    (set_attr "mode" "TI")])
9569
9570 (define_insn "sse4_1_<code>v4qiv4si2"
9571   [(set (match_operand:V4SI 0 "register_operand" "=x")
9572         (any_extend:V4SI
9573           (vec_select:V4QI
9574             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9575             (parallel [(const_int 0)
9576                        (const_int 1)
9577                        (const_int 2)
9578                        (const_int 3)]))))]
9579   "TARGET_SSE4_1"
9580   "%vpmov<extsuffix>bd\t{%1, %0|%0, %1}"
9581   [(set_attr "type" "ssemov")
9582    (set_attr "prefix_extra" "1")
9583    (set_attr "prefix" "maybe_vex")
9584    (set_attr "mode" "TI")])
9585
9586 (define_insn "sse4_1_<code>v4hiv4si2"
9587   [(set (match_operand:V4SI 0 "register_operand" "=x")
9588         (any_extend:V4SI
9589           (vec_select:V4HI
9590             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
9591             (parallel [(const_int 0)
9592                        (const_int 1)
9593                        (const_int 2)
9594                        (const_int 3)]))))]
9595   "TARGET_SSE4_1"
9596   "%vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
9597   [(set_attr "type" "ssemov")
9598    (set_attr "prefix_extra" "1")
9599    (set_attr "prefix" "maybe_vex")
9600    (set_attr "mode" "TI")])
9601
9602 (define_insn "sse4_1_<code>v2qiv2di2"
9603   [(set (match_operand:V2DI 0 "register_operand" "=x")
9604         (any_extend:V2DI
9605           (vec_select:V2QI
9606             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9607             (parallel [(const_int 0)
9608                        (const_int 1)]))))]
9609   "TARGET_SSE4_1"
9610   "%vpmov<extsuffix>bq\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_<code>v2hiv2di2"
9617   [(set (match_operand:V2DI 0 "register_operand" "=x")
9618         (any_extend:V2DI
9619           (vec_select:V2HI
9620             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
9621             (parallel [(const_int 0)
9622                        (const_int 1)]))))]
9623   "TARGET_SSE4_1"
9624   "%vpmov<extsuffix>wq\t{%1, %0|%0, %1}"
9625   [(set_attr "type" "ssemov")
9626    (set_attr "prefix_extra" "1")
9627    (set_attr "prefix" "maybe_vex")
9628    (set_attr "mode" "TI")])
9629
9630 (define_insn "sse4_1_<code>v2siv2di2"
9631   [(set (match_operand:V2DI 0 "register_operand" "=x")
9632         (any_extend:V2DI
9633           (vec_select:V2SI
9634             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
9635             (parallel [(const_int 0)
9636                        (const_int 1)]))))]
9637   "TARGET_SSE4_1"
9638   "%vpmov<extsuffix>dq\t{%1, %0|%0, %1}"
9639   [(set_attr "type" "ssemov")
9640    (set_attr "prefix_extra" "1")
9641    (set_attr "prefix" "maybe_vex")
9642    (set_attr "mode" "TI")])
9643
9644 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
9645 ;; setting FLAGS_REG. But it is not a really compare instruction.
9646 (define_insn "avx_vtest<ssemodesuffix><avxmodesuffix>"
9647   [(set (reg:CC FLAGS_REG)
9648         (unspec:CC [(match_operand:AVXMODEF2P 0 "register_operand" "x")
9649                     (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")]
9650                    UNSPEC_VTESTP))]
9651   "TARGET_AVX"
9652   "vtest<ssemodesuffix>\t{%1, %0|%0, %1}"
9653   [(set_attr "type" "ssecomi")
9654    (set_attr "prefix_extra" "1")
9655    (set_attr "prefix" "vex")
9656    (set_attr "mode" "<MODE>")])
9657
9658 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
9659 ;; But it is not a really compare instruction.
9660 (define_insn "avx_ptest256"
9661   [(set (reg:CC FLAGS_REG)
9662         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
9663                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
9664                    UNSPEC_PTEST))]
9665   "TARGET_AVX"
9666   "vptest\t{%1, %0|%0, %1}"
9667   [(set_attr "type" "ssecomi")
9668    (set_attr "prefix_extra" "1")
9669    (set_attr "prefix" "vex")
9670    (set_attr "mode" "OI")])
9671
9672 (define_insn "sse4_1_ptest"
9673   [(set (reg:CC FLAGS_REG)
9674         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
9675                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
9676                    UNSPEC_PTEST))]
9677   "TARGET_SSE4_1"
9678   "%vptest\t{%1, %0|%0, %1}"
9679   [(set_attr "type" "ssecomi")
9680    (set_attr "prefix_extra" "1")
9681    (set_attr "prefix" "maybe_vex")
9682    (set_attr "mode" "TI")])
9683
9684 (define_insn "avx_round<ssemodesuffix>256"
9685   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x")
9686         (unspec:AVX256MODEF2P
9687           [(match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "xm")
9688            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9689           UNSPEC_ROUND))]
9690   "TARGET_AVX"
9691   "vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
9692   [(set_attr "type" "ssecvt")
9693    (set_attr "prefix_extra" "1")
9694    (set_attr "length_immediate" "1")
9695    (set_attr "prefix" "vex")
9696    (set_attr "mode" "<MODE>")])
9697
9698 (define_insn "sse4_1_round<ssemodesuffix>"
9699   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9700         (unspec:SSEMODEF2P
9701           [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")
9702            (match_operand:SI 2 "const_0_to_15_operand" "n")]
9703           UNSPEC_ROUND))]
9704   "TARGET_ROUND"
9705   "%vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
9706   [(set_attr "type" "ssecvt")
9707    (set_attr "prefix_data16" "1")
9708    (set_attr "prefix_extra" "1")
9709    (set_attr "length_immediate" "1")
9710    (set_attr "prefix" "maybe_vex")
9711    (set_attr "mode" "<MODE>")])
9712
9713 (define_insn "*avx_round<ssescalarmodesuffix>"
9714   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9715         (vec_merge:SSEMODEF2P
9716           (unspec:SSEMODEF2P
9717             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9718              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9719             UNSPEC_ROUND)
9720           (match_operand:SSEMODEF2P 1 "register_operand" "x")
9721           (const_int 1)))]
9722   "TARGET_AVX"
9723   "vround<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9724   [(set_attr "type" "ssecvt")
9725    (set_attr "prefix_extra" "1")
9726    (set_attr "length_immediate" "1")
9727    (set_attr "prefix" "vex")
9728    (set_attr "mode" "<MODE>")])
9729
9730 (define_insn "sse4_1_round<ssescalarmodesuffix>"
9731   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
9732         (vec_merge:SSEMODEF2P
9733           (unspec:SSEMODEF2P
9734             [(match_operand:SSEMODEF2P 2 "register_operand" "x")
9735              (match_operand:SI 3 "const_0_to_15_operand" "n")]
9736             UNSPEC_ROUND)
9737           (match_operand:SSEMODEF2P 1 "register_operand" "0")
9738           (const_int 1)))]
9739   "TARGET_ROUND"
9740   "round<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}"
9741   [(set_attr "type" "ssecvt")
9742    (set_attr "prefix_data16" "1")
9743    (set_attr "prefix_extra" "1")
9744    (set_attr "length_immediate" "1")
9745    (set_attr "mode" "<MODE>")])
9746
9747 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9748 ;;
9749 ;; Intel SSE4.2 string/text processing instructions
9750 ;;
9751 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9752
9753 (define_insn_and_split "sse4_2_pcmpestr"
9754   [(set (match_operand:SI 0 "register_operand" "=c,c")
9755         (unspec:SI
9756           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
9757            (match_operand:SI 3 "register_operand" "a,a")
9758            (match_operand:V16QI 4 "nonimm_not_xmm0_operand" "x,m")
9759            (match_operand:SI 5 "register_operand" "d,d")
9760            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
9761           UNSPEC_PCMPESTR))
9762    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9763         (unspec:V16QI
9764           [(match_dup 2)
9765            (match_dup 3)
9766            (match_dup 4)
9767            (match_dup 5)
9768            (match_dup 6)]
9769           UNSPEC_PCMPESTR))
9770    (set (reg:CC FLAGS_REG)
9771         (unspec:CC
9772           [(match_dup 2)
9773            (match_dup 3)
9774            (match_dup 4)
9775            (match_dup 5)
9776            (match_dup 6)]
9777           UNSPEC_PCMPESTR))]
9778   "TARGET_SSE4_2
9779    && can_create_pseudo_p ()"
9780   "#"
9781   "&& 1"
9782   [(const_int 0)]
9783 {
9784   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9785   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9786   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9787
9788   if (ecx)
9789     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
9790                                      operands[3], operands[4],
9791                                      operands[5], operands[6]));
9792   if (xmm0)
9793     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
9794                                      operands[3], operands[4],
9795                                      operands[5], operands[6]));
9796   if (flags && !(ecx || xmm0))
9797     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
9798                                            operands[2], operands[3],
9799                                            operands[4], operands[5],
9800                                            operands[6]));
9801   DONE;
9802 }
9803   [(set_attr "type" "sselog")
9804    (set_attr "prefix_data16" "1")
9805    (set_attr "prefix_extra" "1")
9806    (set_attr "length_immediate" "1")
9807    (set_attr "memory" "none,load")
9808    (set_attr "mode" "TI")])
9809
9810 (define_insn "sse4_2_pcmpestri"
9811   [(set (match_operand:SI 0 "register_operand" "=c,c")
9812         (unspec:SI
9813           [(match_operand:V16QI 1 "register_operand" "x,x")
9814            (match_operand:SI 2 "register_operand" "a,a")
9815            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9816            (match_operand:SI 4 "register_operand" "d,d")
9817            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9818           UNSPEC_PCMPESTR))
9819    (set (reg:CC FLAGS_REG)
9820         (unspec:CC
9821           [(match_dup 1)
9822            (match_dup 2)
9823            (match_dup 3)
9824            (match_dup 4)
9825            (match_dup 5)]
9826           UNSPEC_PCMPESTR))]
9827   "TARGET_SSE4_2"
9828   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
9829   [(set_attr "type" "sselog")
9830    (set_attr "prefix_data16" "1")
9831    (set_attr "prefix_extra" "1")
9832    (set_attr "prefix" "maybe_vex")
9833    (set_attr "length_immediate" "1")
9834    (set_attr "memory" "none,load")
9835    (set_attr "mode" "TI")])
9836
9837 (define_insn "sse4_2_pcmpestrm"
9838   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9839         (unspec:V16QI
9840           [(match_operand:V16QI 1 "register_operand" "x,x")
9841            (match_operand:SI 2 "register_operand" "a,a")
9842            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9843            (match_operand:SI 4 "register_operand" "d,d")
9844            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9845           UNSPEC_PCMPESTR))
9846    (set (reg:CC FLAGS_REG)
9847         (unspec:CC
9848           [(match_dup 1)
9849            (match_dup 2)
9850            (match_dup 3)
9851            (match_dup 4)
9852            (match_dup 5)]
9853           UNSPEC_PCMPESTR))]
9854   "TARGET_SSE4_2"
9855   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
9856   [(set_attr "type" "sselog")
9857    (set_attr "prefix_data16" "1")
9858    (set_attr "prefix_extra" "1")
9859    (set_attr "length_immediate" "1")
9860    (set_attr "prefix" "maybe_vex")
9861    (set_attr "memory" "none,load")
9862    (set_attr "mode" "TI")])
9863
9864 (define_insn "sse4_2_pcmpestr_cconly"
9865   [(set (reg:CC FLAGS_REG)
9866         (unspec:CC
9867           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9868            (match_operand:SI 3 "register_operand" "a,a,a,a")
9869            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
9870            (match_operand:SI 5 "register_operand" "d,d,d,d")
9871            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
9872           UNSPEC_PCMPESTR))
9873    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9874    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9875   "TARGET_SSE4_2"
9876   "@
9877    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9878    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9879    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
9880    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
9881   [(set_attr "type" "sselog")
9882    (set_attr "prefix_data16" "1")
9883    (set_attr "prefix_extra" "1")
9884    (set_attr "length_immediate" "1")
9885    (set_attr "memory" "none,load,none,load")
9886    (set_attr "prefix" "maybe_vex")
9887    (set_attr "mode" "TI")])
9888
9889 (define_insn_and_split "sse4_2_pcmpistr"
9890   [(set (match_operand:SI 0 "register_operand" "=c,c")
9891         (unspec:SI
9892           [(match_operand:V16QI 2 "reg_not_xmm0_operand" "x,x")
9893            (match_operand:V16QI 3 "nonimm_not_xmm0_operand" "x,m")
9894            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
9895           UNSPEC_PCMPISTR))
9896    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9897         (unspec:V16QI
9898           [(match_dup 2)
9899            (match_dup 3)
9900            (match_dup 4)]
9901           UNSPEC_PCMPISTR))
9902    (set (reg:CC FLAGS_REG)
9903         (unspec:CC
9904           [(match_dup 2)
9905            (match_dup 3)
9906            (match_dup 4)]
9907           UNSPEC_PCMPISTR))]
9908   "TARGET_SSE4_2
9909    && can_create_pseudo_p ()"
9910   "#"
9911   "&& 1"
9912   [(const_int 0)]
9913 {
9914   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9915   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9916   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9917
9918   if (ecx)
9919     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
9920                                      operands[3], operands[4]));
9921   if (xmm0)
9922     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
9923                                      operands[3], operands[4]));
9924   if (flags && !(ecx || xmm0))
9925     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
9926                                            operands[2], operands[3],
9927                                            operands[4]));
9928   DONE;
9929 }
9930   [(set_attr "type" "sselog")
9931    (set_attr "prefix_data16" "1")
9932    (set_attr "prefix_extra" "1")
9933    (set_attr "length_immediate" "1")
9934    (set_attr "memory" "none,load")
9935    (set_attr "mode" "TI")])
9936
9937 (define_insn "sse4_2_pcmpistri"
9938   [(set (match_operand:SI 0 "register_operand" "=c,c")
9939         (unspec:SI
9940           [(match_operand:V16QI 1 "register_operand" "x,x")
9941            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9942            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9943           UNSPEC_PCMPISTR))
9944    (set (reg:CC FLAGS_REG)
9945         (unspec:CC
9946           [(match_dup 1)
9947            (match_dup 2)
9948            (match_dup 3)]
9949           UNSPEC_PCMPISTR))]
9950   "TARGET_SSE4_2"
9951   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
9952   [(set_attr "type" "sselog")
9953    (set_attr "prefix_data16" "1")
9954    (set_attr "prefix_extra" "1")
9955    (set_attr "length_immediate" "1")
9956    (set_attr "prefix" "maybe_vex")
9957    (set_attr "memory" "none,load")
9958    (set_attr "mode" "TI")])
9959
9960 (define_insn "sse4_2_pcmpistrm"
9961   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9962         (unspec:V16QI
9963           [(match_operand:V16QI 1 "register_operand" "x,x")
9964            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9965            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9966           UNSPEC_PCMPISTR))
9967    (set (reg:CC FLAGS_REG)
9968         (unspec:CC
9969           [(match_dup 1)
9970            (match_dup 2)
9971            (match_dup 3)]
9972           UNSPEC_PCMPISTR))]
9973   "TARGET_SSE4_2"
9974   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
9975   [(set_attr "type" "sselog")
9976    (set_attr "prefix_data16" "1")
9977    (set_attr "prefix_extra" "1")
9978    (set_attr "length_immediate" "1")
9979    (set_attr "prefix" "maybe_vex")
9980    (set_attr "memory" "none,load")
9981    (set_attr "mode" "TI")])
9982
9983 (define_insn "sse4_2_pcmpistr_cconly"
9984   [(set (reg:CC FLAGS_REG)
9985         (unspec:CC
9986           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9987            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
9988            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
9989           UNSPEC_PCMPISTR))
9990    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9991    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9992   "TARGET_SSE4_2"
9993   "@
9994    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9995    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9996    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
9997    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
9998   [(set_attr "type" "sselog")
9999    (set_attr "prefix_data16" "1")
10000    (set_attr "prefix_extra" "1")
10001    (set_attr "length_immediate" "1")
10002    (set_attr "memory" "none,load,none,load")
10003    (set_attr "prefix" "maybe_vex")
10004    (set_attr "mode" "TI")])
10005
10006 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10007 ;;
10008 ;; XOP instructions
10009 ;;
10010 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10011
10012 ;; XOP parallel integer multiply/add instructions.
10013 ;; Note the XOP multiply/add instructions
10014 ;;     a[i] = b[i] * c[i] + d[i];
10015 ;; do not allow the value being added to be a memory operation.
10016 (define_insn "xop_pmacsww"
10017   [(set (match_operand:V8HI 0 "register_operand" "=x")
10018         (plus:V8HI
10019          (mult:V8HI
10020           (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10021           (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10022          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10023   "TARGET_XOP"
10024   "vpmacsww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10025   [(set_attr "type" "ssemuladd")
10026    (set_attr "mode" "TI")])
10027
10028 (define_insn "xop_pmacssww"
10029   [(set (match_operand:V8HI 0 "register_operand" "=x")
10030         (ss_plus:V8HI
10031          (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10032                     (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
10033          (match_operand:V8HI 3 "nonimmediate_operand" "x")))]
10034   "TARGET_XOP"
10035   "vpmacssww\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10036   [(set_attr "type" "ssemuladd")
10037    (set_attr "mode" "TI")])
10038
10039 (define_insn "xop_pmacsdd"
10040   [(set (match_operand:V4SI 0 "register_operand" "=x")
10041         (plus:V4SI
10042          (mult:V4SI
10043           (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10044           (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10045          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10046   "TARGET_XOP"
10047   "vpmacsdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10048   [(set_attr "type" "ssemuladd")
10049    (set_attr "mode" "TI")])
10050
10051 (define_insn "xop_pmacssdd"
10052   [(set (match_operand:V4SI 0 "register_operand" "=x")
10053         (ss_plus:V4SI
10054          (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10055                     (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
10056          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10057   "TARGET_XOP"
10058   "vpmacssdd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10059   [(set_attr "type" "ssemuladd")
10060    (set_attr "mode" "TI")])
10061
10062 (define_insn "xop_pmacssdql"
10063   [(set (match_operand:V2DI 0 "register_operand" "=x")
10064         (ss_plus:V2DI
10065          (mult:V2DI
10066           (sign_extend:V2DI
10067            (vec_select:V2SI
10068             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10069             (parallel [(const_int 1)
10070                        (const_int 3)])))
10071           (vec_select:V2SI
10072            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10073            (parallel [(const_int 1)
10074                       (const_int 3)])))
10075          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10076   "TARGET_XOP"
10077   "vpmacssdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10078   [(set_attr "type" "ssemuladd")
10079    (set_attr "mode" "TI")])
10080
10081 (define_insn "xop_pmacssdqh"
10082   [(set (match_operand:V2DI 0 "register_operand" "=x")
10083         (ss_plus:V2DI
10084          (mult:V2DI
10085           (sign_extend:V2DI
10086            (vec_select:V2SI
10087             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10088             (parallel [(const_int 0)
10089                        (const_int 2)])))
10090           (sign_extend:V2DI
10091            (vec_select:V2SI
10092             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10093             (parallel [(const_int 0)
10094                        (const_int 2)]))))
10095          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10096   "TARGET_XOP"
10097   "vpmacssdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10098   [(set_attr "type" "ssemuladd")
10099    (set_attr "mode" "TI")])
10100
10101 (define_insn "xop_pmacsdql"
10102   [(set (match_operand:V2DI 0 "register_operand" "=x")
10103         (plus:V2DI
10104          (mult:V2DI
10105           (sign_extend:V2DI
10106            (vec_select:V2SI
10107             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10108             (parallel [(const_int 1)
10109                        (const_int 3)])))
10110           (sign_extend:V2DI
10111            (vec_select:V2SI
10112             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10113             (parallel [(const_int 1)
10114                        (const_int 3)]))))
10115          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10116   "TARGET_XOP"
10117   "vpmacsdql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10118   [(set_attr "type" "ssemuladd")
10119    (set_attr "mode" "TI")])
10120
10121 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10122 ;; fake it with a multiply/add.  In general, we expect the define_split to
10123 ;; occur before register allocation, so we have to handle the corner case where
10124 ;; the target is the same as operands 1/2
10125 (define_insn_and_split "xop_mulv2div2di3_low"
10126   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10127         (mult:V2DI
10128           (sign_extend:V2DI
10129             (vec_select:V2SI
10130               (match_operand:V4SI 1 "register_operand" "%x")
10131               (parallel [(const_int 1)
10132                          (const_int 3)])))
10133           (sign_extend:V2DI
10134             (vec_select:V2SI
10135               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10136               (parallel [(const_int 1)
10137                          (const_int 3)])))))]
10138   "TARGET_XOP"
10139   "#"
10140   "&& reload_completed"
10141   [(set (match_dup 0)
10142         (match_dup 3))
10143    (set (match_dup 0)
10144         (plus:V2DI
10145          (mult:V2DI
10146           (sign_extend:V2DI
10147            (vec_select:V2SI
10148             (match_dup 1)
10149             (parallel [(const_int 1)
10150                        (const_int 3)])))
10151           (sign_extend:V2DI
10152            (vec_select:V2SI
10153             (match_dup 2)
10154             (parallel [(const_int 1)
10155                        (const_int 3)]))))
10156          (match_dup 0)))]
10157 {
10158   operands[3] = CONST0_RTX (V2DImode);
10159 }
10160   [(set_attr "type" "ssemul")
10161    (set_attr "mode" "TI")])
10162
10163 (define_insn "xop_pmacsdqh"
10164   [(set (match_operand:V2DI 0 "register_operand" "=x")
10165         (plus:V2DI
10166          (mult:V2DI
10167           (sign_extend:V2DI
10168            (vec_select:V2SI
10169             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
10170             (parallel [(const_int 0)
10171                        (const_int 2)])))
10172           (sign_extend:V2DI
10173            (vec_select:V2SI
10174             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10175             (parallel [(const_int 0)
10176                        (const_int 2)]))))
10177          (match_operand:V2DI 3 "nonimmediate_operand" "x")))]
10178   "TARGET_XOP"
10179   "vpmacsdqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10180   [(set_attr "type" "ssemuladd")
10181    (set_attr "mode" "TI")])
10182
10183 ;; We don't have a straight 32-bit parallel multiply and extend on XOP, so
10184 ;; fake it with a multiply/add.  In general, we expect the define_split to
10185 ;; occur before register allocation, so we have to handle the corner case where
10186 ;; the target is the same as either operands[1] or operands[2]
10187 (define_insn_and_split "xop_mulv2div2di3_high"
10188   [(set (match_operand:V2DI 0 "register_operand" "=&x")
10189         (mult:V2DI
10190           (sign_extend:V2DI
10191             (vec_select:V2SI
10192               (match_operand:V4SI 1 "register_operand" "%x")
10193               (parallel [(const_int 0)
10194                          (const_int 2)])))
10195           (sign_extend:V2DI
10196             (vec_select:V2SI
10197               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
10198               (parallel [(const_int 0)
10199                          (const_int 2)])))))]
10200   "TARGET_XOP"
10201   "#"
10202   "&& reload_completed"
10203   [(set (match_dup 0)
10204         (match_dup 3))
10205    (set (match_dup 0)
10206         (plus:V2DI
10207          (mult:V2DI
10208           (sign_extend:V2DI
10209            (vec_select:V2SI
10210             (match_dup 1)
10211             (parallel [(const_int 0)
10212                        (const_int 2)])))
10213           (sign_extend:V2DI
10214            (vec_select:V2SI
10215             (match_dup 2)
10216             (parallel [(const_int 0)
10217                        (const_int 2)]))))
10218          (match_dup 0)))]
10219 {
10220   operands[3] = CONST0_RTX (V2DImode);
10221 }
10222   [(set_attr "type" "ssemul")
10223    (set_attr "mode" "TI")])
10224
10225 ;; XOP parallel integer multiply/add instructions for the intrinisics
10226 (define_insn "xop_pmacsswd"
10227   [(set (match_operand:V4SI 0 "register_operand" "=x")
10228         (ss_plus:V4SI
10229          (mult:V4SI
10230           (sign_extend:V4SI
10231            (vec_select:V4HI
10232             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10233             (parallel [(const_int 1)
10234                        (const_int 3)
10235                        (const_int 5)
10236                        (const_int 7)])))
10237           (sign_extend:V4SI
10238            (vec_select:V4HI
10239             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10240             (parallel [(const_int 1)
10241                        (const_int 3)
10242                        (const_int 5)
10243                        (const_int 7)]))))
10244          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10245   "TARGET_XOP"
10246   "vpmacsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10247   [(set_attr "type" "ssemuladd")
10248    (set_attr "mode" "TI")])
10249
10250 (define_insn "xop_pmacswd"
10251   [(set (match_operand:V4SI 0 "register_operand" "=x")
10252         (plus:V4SI
10253          (mult:V4SI
10254           (sign_extend:V4SI
10255            (vec_select:V4HI
10256             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10257             (parallel [(const_int 1)
10258                        (const_int 3)
10259                        (const_int 5)
10260                        (const_int 7)])))
10261           (sign_extend:V4SI
10262            (vec_select:V4HI
10263             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10264             (parallel [(const_int 1)
10265                        (const_int 3)
10266                        (const_int 5)
10267                        (const_int 7)]))))
10268          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10269   "TARGET_XOP"
10270   "vpmacswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10271   [(set_attr "type" "ssemuladd")
10272    (set_attr "mode" "TI")])
10273
10274 (define_insn "xop_pmadcsswd"
10275   [(set (match_operand:V4SI 0 "register_operand" "=x")
10276         (ss_plus:V4SI
10277          (plus:V4SI
10278           (mult:V4SI
10279            (sign_extend:V4SI
10280             (vec_select:V4HI
10281              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10282              (parallel [(const_int 0)
10283                         (const_int 2)
10284                         (const_int 4)
10285                         (const_int 6)])))
10286            (sign_extend:V4SI
10287             (vec_select:V4HI
10288              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10289              (parallel [(const_int 0)
10290                         (const_int 2)
10291                         (const_int 4)
10292                         (const_int 6)]))))
10293           (mult:V4SI
10294            (sign_extend:V4SI
10295             (vec_select:V4HI
10296              (match_dup 1)
10297              (parallel [(const_int 1)
10298                         (const_int 3)
10299                         (const_int 5)
10300                         (const_int 7)])))
10301            (sign_extend:V4SI
10302             (vec_select:V4HI
10303              (match_dup 2)
10304              (parallel [(const_int 1)
10305                         (const_int 3)
10306                         (const_int 5)
10307                         (const_int 7)])))))
10308          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10309   "TARGET_XOP"
10310   "vpmadcsswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10311   [(set_attr "type" "ssemuladd")
10312    (set_attr "mode" "TI")])
10313
10314 (define_insn "xop_pmadcswd"
10315   [(set (match_operand:V4SI 0 "register_operand" "=x")
10316         (plus:V4SI
10317          (plus:V4SI
10318           (mult:V4SI
10319            (sign_extend:V4SI
10320             (vec_select:V4HI
10321              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
10322              (parallel [(const_int 0)
10323                         (const_int 2)
10324                         (const_int 4)
10325                         (const_int 6)])))
10326            (sign_extend:V4SI
10327             (vec_select:V4HI
10328              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10329              (parallel [(const_int 0)
10330                         (const_int 2)
10331                         (const_int 4)
10332                         (const_int 6)]))))
10333           (mult:V4SI
10334            (sign_extend:V4SI
10335             (vec_select:V4HI
10336              (match_dup 1)
10337              (parallel [(const_int 1)
10338                         (const_int 3)
10339                         (const_int 5)
10340                         (const_int 7)])))
10341            (sign_extend:V4SI
10342             (vec_select:V4HI
10343              (match_dup 2)
10344              (parallel [(const_int 1)
10345                         (const_int 3)
10346                         (const_int 5)
10347                         (const_int 7)])))))
10348          (match_operand:V4SI 3 "nonimmediate_operand" "x")))]
10349   "TARGET_XOP"
10350   "vpmadcswd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10351   [(set_attr "type" "ssemuladd")
10352    (set_attr "mode" "TI")])
10353
10354 ;; XOP parallel XMM conditional moves
10355 (define_insn "xop_pcmov_<mode>"
10356   [(set (match_operand:SSEMODE 0 "register_operand" "=x,x")
10357         (if_then_else:SSEMODE
10358           (match_operand:SSEMODE 3 "nonimmediate_operand" "x,m")
10359           (match_operand:SSEMODE 1 "vector_move_operand" "x,x")
10360           (match_operand:SSEMODE 2 "vector_move_operand" "xm,x")))]
10361   "TARGET_XOP"
10362   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10363   [(set_attr "type" "sse4arg")])
10364
10365 (define_insn "xop_pcmov_<mode>256"
10366   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x")
10367         (if_then_else:AVX256MODE
10368           (match_operand:AVX256MODE 3 "nonimmediate_operand" "x,m")
10369           (match_operand:AVX256MODE 1 "vector_move_operand" "x,x")
10370           (match_operand:AVX256MODE 2 "vector_move_operand" "xm,x")))]
10371   "TARGET_XOP"
10372   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10373   [(set_attr "type" "sse4arg")])
10374
10375 ;; XOP horizontal add/subtract instructions
10376 (define_insn "xop_phaddbw"
10377   [(set (match_operand:V8HI 0 "register_operand" "=x")
10378         (plus:V8HI
10379          (sign_extend:V8HI
10380           (vec_select:V8QI
10381            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10382            (parallel [(const_int 0)
10383                       (const_int 2)
10384                       (const_int 4)
10385                       (const_int 6)
10386                       (const_int 8)
10387                       (const_int 10)
10388                       (const_int 12)
10389                       (const_int 14)])))
10390          (sign_extend:V8HI
10391           (vec_select:V8QI
10392            (match_dup 1)
10393            (parallel [(const_int 1)
10394                       (const_int 3)
10395                       (const_int 5)
10396                       (const_int 7)
10397                       (const_int 9)
10398                       (const_int 11)
10399                       (const_int 13)
10400                       (const_int 15)])))))]
10401   "TARGET_XOP"
10402   "vphaddbw\t{%1, %0|%0, %1}"
10403   [(set_attr "type" "sseiadd1")])
10404
10405 (define_insn "xop_phaddbd"
10406   [(set (match_operand:V4SI 0 "register_operand" "=x")
10407         (plus:V4SI
10408          (plus:V4SI
10409           (sign_extend:V4SI
10410            (vec_select:V4QI
10411             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10412             (parallel [(const_int 0)
10413                        (const_int 4)
10414                        (const_int 8)
10415                        (const_int 12)])))
10416           (sign_extend:V4SI
10417            (vec_select:V4QI
10418             (match_dup 1)
10419             (parallel [(const_int 1)
10420                        (const_int 5)
10421                        (const_int 9)
10422                        (const_int 13)]))))
10423          (plus:V4SI
10424           (sign_extend:V4SI
10425            (vec_select:V4QI
10426             (match_dup 1)
10427             (parallel [(const_int 2)
10428                        (const_int 6)
10429                        (const_int 10)
10430                        (const_int 14)])))
10431           (sign_extend:V4SI
10432            (vec_select:V4QI
10433             (match_dup 1)
10434             (parallel [(const_int 3)
10435                        (const_int 7)
10436                        (const_int 11)
10437                        (const_int 15)]))))))]
10438   "TARGET_XOP"
10439   "vphaddbd\t{%1, %0|%0, %1}"
10440   [(set_attr "type" "sseiadd1")])
10441
10442 (define_insn "xop_phaddbq"
10443   [(set (match_operand:V2DI 0 "register_operand" "=x")
10444         (plus:V2DI
10445          (plus:V2DI
10446           (plus:V2DI
10447            (sign_extend:V2DI
10448             (vec_select:V2QI
10449              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10450              (parallel [(const_int 0)
10451                         (const_int 4)])))
10452            (sign_extend:V2DI
10453             (vec_select:V2QI
10454              (match_dup 1)
10455              (parallel [(const_int 1)
10456                         (const_int 5)]))))
10457           (plus:V2DI
10458            (sign_extend:V2DI
10459             (vec_select:V2QI
10460              (match_dup 1)
10461              (parallel [(const_int 2)
10462                         (const_int 6)])))
10463            (sign_extend:V2DI
10464             (vec_select:V2QI
10465              (match_dup 1)
10466              (parallel [(const_int 3)
10467                         (const_int 7)])))))
10468          (plus:V2DI
10469           (plus:V2DI
10470            (sign_extend:V2DI
10471             (vec_select:V2QI
10472              (match_dup 1)
10473              (parallel [(const_int 8)
10474                         (const_int 12)])))
10475            (sign_extend:V2DI
10476             (vec_select:V2QI
10477              (match_dup 1)
10478              (parallel [(const_int 9)
10479                         (const_int 13)]))))
10480           (plus:V2DI
10481            (sign_extend:V2DI
10482             (vec_select:V2QI
10483              (match_dup 1)
10484              (parallel [(const_int 10)
10485                         (const_int 14)])))
10486            (sign_extend:V2DI
10487             (vec_select:V2QI
10488              (match_dup 1)
10489              (parallel [(const_int 11)
10490                         (const_int 15)])))))))]
10491   "TARGET_XOP"
10492   "vphaddbq\t{%1, %0|%0, %1}"
10493   [(set_attr "type" "sseiadd1")])
10494
10495 (define_insn "xop_phaddwd"
10496   [(set (match_operand:V4SI 0 "register_operand" "=x")
10497         (plus:V4SI
10498          (sign_extend:V4SI
10499           (vec_select:V4HI
10500            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10501            (parallel [(const_int 0)
10502                       (const_int 2)
10503                       (const_int 4)
10504                       (const_int 6)])))
10505          (sign_extend:V4SI
10506           (vec_select:V4HI
10507            (match_dup 1)
10508            (parallel [(const_int 1)
10509                       (const_int 3)
10510                       (const_int 5)
10511                       (const_int 7)])))))]
10512   "TARGET_XOP"
10513   "vphaddwd\t{%1, %0|%0, %1}"
10514   [(set_attr "type" "sseiadd1")])
10515
10516 (define_insn "xop_phaddwq"
10517   [(set (match_operand:V2DI 0 "register_operand" "=x")
10518         (plus:V2DI
10519          (plus:V2DI
10520           (sign_extend:V2DI
10521            (vec_select:V2HI
10522             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10523             (parallel [(const_int 0)
10524                        (const_int 4)])))
10525           (sign_extend:V2DI
10526            (vec_select:V2HI
10527             (match_dup 1)
10528             (parallel [(const_int 1)
10529                        (const_int 5)]))))
10530          (plus:V2DI
10531           (sign_extend:V2DI
10532            (vec_select:V2HI
10533             (match_dup 1)
10534             (parallel [(const_int 2)
10535                        (const_int 6)])))
10536           (sign_extend:V2DI
10537            (vec_select:V2HI
10538             (match_dup 1)
10539             (parallel [(const_int 3)
10540                        (const_int 7)]))))))]
10541   "TARGET_XOP"
10542   "vphaddwq\t{%1, %0|%0, %1}"
10543   [(set_attr "type" "sseiadd1")])
10544
10545 (define_insn "xop_phadddq"
10546   [(set (match_operand:V2DI 0 "register_operand" "=x")
10547         (plus:V2DI
10548          (sign_extend:V2DI
10549           (vec_select:V2SI
10550            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10551            (parallel [(const_int 0)
10552                       (const_int 2)])))
10553          (sign_extend:V2DI
10554           (vec_select:V2SI
10555            (match_dup 1)
10556            (parallel [(const_int 1)
10557                       (const_int 3)])))))]
10558   "TARGET_XOP"
10559   "vphadddq\t{%1, %0|%0, %1}"
10560   [(set_attr "type" "sseiadd1")])
10561
10562 (define_insn "xop_phaddubw"
10563   [(set (match_operand:V8HI 0 "register_operand" "=x")
10564         (plus:V8HI
10565          (zero_extend:V8HI
10566           (vec_select:V8QI
10567            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10568            (parallel [(const_int 0)
10569                       (const_int 2)
10570                       (const_int 4)
10571                       (const_int 6)
10572                       (const_int 8)
10573                       (const_int 10)
10574                       (const_int 12)
10575                       (const_int 14)])))
10576          (zero_extend:V8HI
10577           (vec_select:V8QI
10578            (match_dup 1)
10579            (parallel [(const_int 1)
10580                       (const_int 3)
10581                       (const_int 5)
10582                       (const_int 7)
10583                       (const_int 9)
10584                       (const_int 11)
10585                       (const_int 13)
10586                       (const_int 15)])))))]
10587   "TARGET_XOP"
10588   "vphaddubw\t{%1, %0|%0, %1}"
10589   [(set_attr "type" "sseiadd1")])
10590
10591 (define_insn "xop_phaddubd"
10592   [(set (match_operand:V4SI 0 "register_operand" "=x")
10593         (plus:V4SI
10594          (plus:V4SI
10595           (zero_extend:V4SI
10596            (vec_select:V4QI
10597             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10598             (parallel [(const_int 0)
10599                        (const_int 4)
10600                        (const_int 8)
10601                        (const_int 12)])))
10602           (zero_extend:V4SI
10603            (vec_select:V4QI
10604             (match_dup 1)
10605             (parallel [(const_int 1)
10606                        (const_int 5)
10607                        (const_int 9)
10608                        (const_int 13)]))))
10609          (plus:V4SI
10610           (zero_extend:V4SI
10611            (vec_select:V4QI
10612             (match_dup 1)
10613             (parallel [(const_int 2)
10614                        (const_int 6)
10615                        (const_int 10)
10616                        (const_int 14)])))
10617           (zero_extend:V4SI
10618            (vec_select:V4QI
10619             (match_dup 1)
10620             (parallel [(const_int 3)
10621                        (const_int 7)
10622                        (const_int 11)
10623                        (const_int 15)]))))))]
10624   "TARGET_XOP"
10625   "vphaddubd\t{%1, %0|%0, %1}"
10626   [(set_attr "type" "sseiadd1")])
10627
10628 (define_insn "xop_phaddubq"
10629   [(set (match_operand:V2DI 0 "register_operand" "=x")
10630         (plus:V2DI
10631          (plus:V2DI
10632           (plus:V2DI
10633            (zero_extend:V2DI
10634             (vec_select:V2QI
10635              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10636              (parallel [(const_int 0)
10637                         (const_int 4)])))
10638            (sign_extend:V2DI
10639             (vec_select:V2QI
10640              (match_dup 1)
10641              (parallel [(const_int 1)
10642                         (const_int 5)]))))
10643           (plus:V2DI
10644            (zero_extend:V2DI
10645             (vec_select:V2QI
10646              (match_dup 1)
10647              (parallel [(const_int 2)
10648                         (const_int 6)])))
10649            (zero_extend:V2DI
10650             (vec_select:V2QI
10651              (match_dup 1)
10652              (parallel [(const_int 3)
10653                         (const_int 7)])))))
10654          (plus:V2DI
10655           (plus:V2DI
10656            (zero_extend:V2DI
10657             (vec_select:V2QI
10658              (match_dup 1)
10659              (parallel [(const_int 8)
10660                         (const_int 12)])))
10661            (sign_extend:V2DI
10662             (vec_select:V2QI
10663              (match_dup 1)
10664              (parallel [(const_int 9)
10665                         (const_int 13)]))))
10666           (plus:V2DI
10667            (zero_extend:V2DI
10668             (vec_select:V2QI
10669              (match_dup 1)
10670              (parallel [(const_int 10)
10671                         (const_int 14)])))
10672            (zero_extend:V2DI
10673             (vec_select:V2QI
10674              (match_dup 1)
10675              (parallel [(const_int 11)
10676                         (const_int 15)])))))))]
10677   "TARGET_XOP"
10678   "vphaddubq\t{%1, %0|%0, %1}"
10679   [(set_attr "type" "sseiadd1")])
10680
10681 (define_insn "xop_phadduwd"
10682   [(set (match_operand:V4SI 0 "register_operand" "=x")
10683         (plus:V4SI
10684          (zero_extend:V4SI
10685           (vec_select:V4HI
10686            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10687            (parallel [(const_int 0)
10688                       (const_int 2)
10689                       (const_int 4)
10690                       (const_int 6)])))
10691          (zero_extend:V4SI
10692           (vec_select:V4HI
10693            (match_dup 1)
10694            (parallel [(const_int 1)
10695                       (const_int 3)
10696                       (const_int 5)
10697                       (const_int 7)])))))]
10698   "TARGET_XOP"
10699   "vphadduwd\t{%1, %0|%0, %1}"
10700   [(set_attr "type" "sseiadd1")])
10701
10702 (define_insn "xop_phadduwq"
10703   [(set (match_operand:V2DI 0 "register_operand" "=x")
10704         (plus:V2DI
10705          (plus:V2DI
10706           (zero_extend:V2DI
10707            (vec_select:V2HI
10708             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10709             (parallel [(const_int 0)
10710                        (const_int 4)])))
10711           (zero_extend:V2DI
10712            (vec_select:V2HI
10713             (match_dup 1)
10714             (parallel [(const_int 1)
10715                        (const_int 5)]))))
10716          (plus:V2DI
10717           (zero_extend:V2DI
10718            (vec_select:V2HI
10719             (match_dup 1)
10720             (parallel [(const_int 2)
10721                        (const_int 6)])))
10722           (zero_extend:V2DI
10723            (vec_select:V2HI
10724             (match_dup 1)
10725             (parallel [(const_int 3)
10726                        (const_int 7)]))))))]
10727   "TARGET_XOP"
10728   "vphadduwq\t{%1, %0|%0, %1}"
10729   [(set_attr "type" "sseiadd1")])
10730
10731 (define_insn "xop_phaddudq"
10732   [(set (match_operand:V2DI 0 "register_operand" "=x")
10733         (plus:V2DI
10734          (zero_extend:V2DI
10735           (vec_select:V2SI
10736            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10737            (parallel [(const_int 0)
10738                       (const_int 2)])))
10739          (zero_extend:V2DI
10740           (vec_select:V2SI
10741            (match_dup 1)
10742            (parallel [(const_int 1)
10743                       (const_int 3)])))))]
10744   "TARGET_XOP"
10745   "vphaddudq\t{%1, %0|%0, %1}"
10746   [(set_attr "type" "sseiadd1")])
10747
10748 (define_insn "xop_phsubbw"
10749   [(set (match_operand:V8HI 0 "register_operand" "=x")
10750         (minus:V8HI
10751          (sign_extend:V8HI
10752           (vec_select:V8QI
10753            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
10754            (parallel [(const_int 0)
10755                       (const_int 2)
10756                       (const_int 4)
10757                       (const_int 6)
10758                       (const_int 8)
10759                       (const_int 10)
10760                       (const_int 12)
10761                       (const_int 14)])))
10762          (sign_extend:V8HI
10763           (vec_select:V8QI
10764            (match_dup 1)
10765            (parallel [(const_int 1)
10766                       (const_int 3)
10767                       (const_int 5)
10768                       (const_int 7)
10769                       (const_int 9)
10770                       (const_int 11)
10771                       (const_int 13)
10772                       (const_int 15)])))))]
10773   "TARGET_XOP"
10774   "vphsubbw\t{%1, %0|%0, %1}"
10775   [(set_attr "type" "sseiadd1")])
10776
10777 (define_insn "xop_phsubwd"
10778   [(set (match_operand:V4SI 0 "register_operand" "=x")
10779         (minus:V4SI
10780          (sign_extend:V4SI
10781           (vec_select:V4HI
10782            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10783            (parallel [(const_int 0)
10784                       (const_int 2)
10785                       (const_int 4)
10786                       (const_int 6)])))
10787          (sign_extend:V4SI
10788           (vec_select:V4HI
10789            (match_dup 1)
10790            (parallel [(const_int 1)
10791                       (const_int 3)
10792                       (const_int 5)
10793                       (const_int 7)])))))]
10794   "TARGET_XOP"
10795   "vphsubwd\t{%1, %0|%0, %1}"
10796   [(set_attr "type" "sseiadd1")])
10797
10798 (define_insn "xop_phsubdq"
10799   [(set (match_operand:V2DI 0 "register_operand" "=x")
10800         (minus:V2DI
10801          (sign_extend:V2DI
10802           (vec_select:V2SI
10803            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10804            (parallel [(const_int 0)
10805                       (const_int 2)])))
10806          (sign_extend:V2DI
10807           (vec_select:V2SI
10808            (match_dup 1)
10809            (parallel [(const_int 1)
10810                       (const_int 3)])))))]
10811   "TARGET_XOP"
10812   "vphsubdq\t{%1, %0|%0, %1}"
10813   [(set_attr "type" "sseiadd1")])
10814
10815 ;; XOP permute instructions
10816 (define_insn "xop_pperm"
10817   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
10818         (unspec:V16QI
10819           [(match_operand:V16QI 1 "register_operand" "x,x")
10820            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
10821            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
10822           UNSPEC_XOP_PERMUTE))]
10823   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
10824   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10825   [(set_attr "type" "sse4arg")
10826    (set_attr "mode" "TI")])
10827
10828 ;; XOP pack instructions that combine two vectors into a smaller vector
10829 (define_insn "xop_pperm_pack_v2di_v4si"
10830   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
10831         (vec_concat:V4SI
10832          (truncate:V2SI
10833           (match_operand:V2DI 1 "register_operand" "x,x"))
10834          (truncate:V2SI
10835           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
10836    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
10837   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
10838   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10839   [(set_attr "type" "sse4arg")
10840    (set_attr "mode" "TI")])
10841
10842 (define_insn "xop_pperm_pack_v4si_v8hi"
10843   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
10844         (vec_concat:V8HI
10845          (truncate:V4HI
10846           (match_operand:V4SI 1 "register_operand" "x,x"))
10847          (truncate:V4HI
10848           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
10849    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
10850   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
10851   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10852   [(set_attr "type" "sse4arg")
10853    (set_attr "mode" "TI")])
10854
10855 (define_insn "xop_pperm_pack_v8hi_v16qi"
10856   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
10857         (vec_concat:V16QI
10858          (truncate:V8QI
10859           (match_operand:V8HI 1 "register_operand" "x,x"))
10860          (truncate:V8QI
10861           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
10862    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
10863   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
10864   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10865   [(set_attr "type" "sse4arg")
10866    (set_attr "mode" "TI")])
10867
10868 ;; XOP packed rotate instructions
10869 (define_expand "rotl<mode>3"
10870   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
10871         (rotate:SSEMODE1248
10872          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
10873          (match_operand:SI 2 "general_operand")))]
10874   "TARGET_XOP"
10875 {
10876   /* If we were given a scalar, convert it to parallel */
10877   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
10878     {
10879       rtvec vs = rtvec_alloc (<ssescalarnum>);
10880       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
10881       rtx reg = gen_reg_rtx (<MODE>mode);
10882       rtx op2 = operands[2];
10883       int i;
10884
10885       if (GET_MODE (op2) != <ssescalarmode>mode)
10886         {
10887           op2 = gen_reg_rtx (<ssescalarmode>mode);
10888           convert_move (op2, operands[2], false);
10889         }
10890
10891       for (i = 0; i < <ssescalarnum>; i++)
10892         RTVEC_ELT (vs, i) = op2;
10893
10894       emit_insn (gen_vec_init<mode> (reg, par));
10895       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
10896       DONE;
10897     }
10898 })
10899
10900 (define_expand "rotr<mode>3"
10901   [(set (match_operand:SSEMODE1248 0 "register_operand" "")
10902         (rotatert:SSEMODE1248
10903          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "")
10904          (match_operand:SI 2 "general_operand")))]
10905   "TARGET_XOP"
10906 {
10907   /* If we were given a scalar, convert it to parallel */
10908   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
10909     {
10910       rtvec vs = rtvec_alloc (<ssescalarnum>);
10911       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
10912       rtx neg = gen_reg_rtx (<MODE>mode);
10913       rtx reg = gen_reg_rtx (<MODE>mode);
10914       rtx op2 = operands[2];
10915       int i;
10916
10917       if (GET_MODE (op2) != <ssescalarmode>mode)
10918         {
10919           op2 = gen_reg_rtx (<ssescalarmode>mode);
10920           convert_move (op2, operands[2], false);
10921         }
10922
10923       for (i = 0; i < <ssescalarnum>; i++)
10924         RTVEC_ELT (vs, i) = op2;
10925
10926       emit_insn (gen_vec_init<mode> (reg, par));
10927       emit_insn (gen_neg<mode>2 (neg, reg));
10928       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
10929       DONE;
10930     }
10931 })
10932
10933 (define_insn "xop_rotl<mode>3"
10934   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
10935         (rotate:SSEMODE1248
10936          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
10937          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
10938   "TARGET_XOP"
10939   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
10940   [(set_attr "type" "sseishft")
10941    (set_attr "length_immediate" "1")
10942    (set_attr "mode" "TI")])
10943
10944 (define_insn "xop_rotr<mode>3"
10945   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
10946         (rotatert:SSEMODE1248
10947          (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm")
10948          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
10949   "TARGET_XOP"
10950 {
10951   operands[3] = GEN_INT ((<ssescalarnum> * 8) - INTVAL (operands[2]));
10952   return \"vprot<ssevecsize>\t{%3, %1, %0|%0, %1, %3}\";
10953 }
10954   [(set_attr "type" "sseishft")
10955    (set_attr "length_immediate" "1")
10956    (set_attr "mode" "TI")])
10957
10958 (define_expand "vrotr<mode>3"
10959   [(match_operand:SSEMODE1248 0 "register_operand" "")
10960    (match_operand:SSEMODE1248 1 "register_operand" "")
10961    (match_operand:SSEMODE1248 2 "register_operand" "")]
10962   "TARGET_XOP"
10963 {
10964   rtx reg = gen_reg_rtx (<MODE>mode);
10965   emit_insn (gen_neg<mode>2 (reg, operands[2]));
10966   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
10967   DONE;
10968 })
10969
10970 (define_expand "vrotl<mode>3"
10971   [(match_operand:SSEMODE1248 0 "register_operand" "")
10972    (match_operand:SSEMODE1248 1 "register_operand" "")
10973    (match_operand:SSEMODE1248 2 "register_operand" "")]
10974   "TARGET_XOP"
10975 {
10976   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
10977   DONE;
10978 })
10979
10980 (define_insn "xop_vrotl<mode>3"
10981   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
10982         (if_then_else:SSEMODE1248
10983          (ge:SSEMODE1248
10984           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
10985           (const_int 0))
10986          (rotate:SSEMODE1248
10987           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
10988           (match_dup 2))
10989          (rotatert:SSEMODE1248
10990           (match_dup 1)
10991           (neg:SSEMODE1248 (match_dup 2)))))]
10992   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
10993   "vprot<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
10994   [(set_attr "type" "sseishft")
10995    (set_attr "prefix_data16" "0")
10996    (set_attr "prefix_extra" "2")
10997    (set_attr "mode" "TI")])
10998
10999 ;; XOP packed shift instructions.
11000 ;; FIXME: add V2DI back in
11001 (define_expand "vlshr<mode>3"
11002   [(match_operand:SSEMODE124 0 "register_operand" "")
11003    (match_operand:SSEMODE124 1 "register_operand" "")
11004    (match_operand:SSEMODE124 2 "register_operand" "")]
11005   "TARGET_XOP"
11006 {
11007   rtx neg = gen_reg_rtx (<MODE>mode);
11008   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11009   emit_insn (gen_xop_lshl<mode>3 (operands[0], operands[1], neg));
11010   DONE;
11011 })
11012
11013 (define_expand "vashr<mode>3"
11014   [(match_operand:SSEMODE124 0 "register_operand" "")
11015    (match_operand:SSEMODE124 1 "register_operand" "")
11016    (match_operand:SSEMODE124 2 "register_operand" "")]
11017   "TARGET_XOP"
11018 {
11019   rtx neg = gen_reg_rtx (<MODE>mode);
11020   emit_insn (gen_neg<mode>2 (neg, operands[2]));
11021   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], neg));
11022   DONE;
11023 })
11024
11025 (define_expand "vashl<mode>3"
11026   [(match_operand:SSEMODE124 0 "register_operand" "")
11027    (match_operand:SSEMODE124 1 "register_operand" "")
11028    (match_operand:SSEMODE124 2 "register_operand" "")]
11029   "TARGET_XOP"
11030 {
11031   emit_insn (gen_xop_ashl<mode>3 (operands[0], operands[1], operands[2]));
11032   DONE;
11033 })
11034
11035 (define_insn "xop_ashl<mode>3"
11036   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11037         (if_then_else:SSEMODE1248
11038          (ge:SSEMODE1248
11039           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11040           (const_int 0))
11041          (ashift:SSEMODE1248
11042           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11043           (match_dup 2))
11044          (ashiftrt:SSEMODE1248
11045           (match_dup 1)
11046           (neg:SSEMODE1248 (match_dup 2)))))]
11047   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11048   "vpsha<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11049   [(set_attr "type" "sseishft")
11050    (set_attr "prefix_data16" "0")
11051    (set_attr "prefix_extra" "2")
11052    (set_attr "mode" "TI")])
11053
11054 (define_insn "xop_lshl<mode>3"
11055   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x,x")
11056         (if_then_else:SSEMODE1248
11057          (ge:SSEMODE1248
11058           (match_operand:SSEMODE1248 2 "nonimmediate_operand" "x,m")
11059           (const_int 0))
11060          (ashift:SSEMODE1248
11061           (match_operand:SSEMODE1248 1 "nonimmediate_operand" "xm,x")
11062           (match_dup 2))
11063          (lshiftrt:SSEMODE1248
11064           (match_dup 1)
11065           (neg:SSEMODE1248 (match_dup 2)))))]
11066   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
11067   "vpshl<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11068   [(set_attr "type" "sseishft")
11069    (set_attr "prefix_data16" "0")
11070    (set_attr "prefix_extra" "2")
11071    (set_attr "mode" "TI")])
11072
11073 ;; SSE2 doesn't have some shift varients, so define versions for XOP
11074 (define_expand "ashlv16qi3"
11075   [(match_operand:V16QI 0 "register_operand" "")
11076    (match_operand:V16QI 1 "register_operand" "")
11077    (match_operand:SI 2 "nonmemory_operand" "")]
11078   "TARGET_XOP"
11079 {
11080   rtvec vs = rtvec_alloc (16);
11081   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11082   rtx reg = gen_reg_rtx (V16QImode);
11083   int i;
11084   for (i = 0; i < 16; i++)
11085     RTVEC_ELT (vs, i) = operands[2];
11086
11087   emit_insn (gen_vec_initv16qi (reg, par));
11088   emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11089   DONE;
11090 })
11091
11092 (define_expand "lshlv16qi3"
11093   [(match_operand:V16QI 0 "register_operand" "")
11094    (match_operand:V16QI 1 "register_operand" "")
11095    (match_operand:SI 2 "nonmemory_operand" "")]
11096   "TARGET_XOP"
11097 {
11098   rtvec vs = rtvec_alloc (16);
11099   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11100   rtx reg = gen_reg_rtx (V16QImode);
11101   int i;
11102   for (i = 0; i < 16; i++)
11103     RTVEC_ELT (vs, i) = operands[2];
11104
11105   emit_insn (gen_vec_initv16qi (reg, par));
11106   emit_insn (gen_xop_lshlv16qi3 (operands[0], operands[1], reg));
11107   DONE;
11108 })
11109
11110 (define_expand "ashrv16qi3"
11111   [(match_operand:V16QI 0 "register_operand" "")
11112    (match_operand:V16QI 1 "register_operand" "")
11113    (match_operand:SI 2 "nonmemory_operand" "")]
11114   "TARGET_XOP"
11115 {
11116   rtvec vs = rtvec_alloc (16);
11117   rtx par = gen_rtx_PARALLEL (V16QImode, vs);
11118   rtx reg = gen_reg_rtx (V16QImode);
11119   int i;
11120   rtx ele = ((CONST_INT_P (operands[2]))
11121              ? GEN_INT (- INTVAL (operands[2]))
11122              : operands[2]);
11123
11124   for (i = 0; i < 16; i++)
11125     RTVEC_ELT (vs, i) = ele;
11126
11127   emit_insn (gen_vec_initv16qi (reg, par));
11128
11129   if (!CONST_INT_P (operands[2]))
11130     {
11131       rtx neg = gen_reg_rtx (V16QImode);
11132       emit_insn (gen_negv16qi2 (neg, reg));
11133       emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], neg));
11134     }
11135   else
11136     emit_insn (gen_xop_ashlv16qi3 (operands[0], operands[1], reg));
11137
11138   DONE;
11139 })
11140
11141 (define_expand "ashrv2di3"
11142   [(match_operand:V2DI 0 "register_operand" "")
11143    (match_operand:V2DI 1 "register_operand" "")
11144    (match_operand:DI 2 "nonmemory_operand" "")]
11145   "TARGET_XOP"
11146 {
11147   rtvec vs = rtvec_alloc (2);
11148   rtx par = gen_rtx_PARALLEL (V2DImode, vs);
11149   rtx reg = gen_reg_rtx (V2DImode);
11150   rtx ele;
11151
11152   if (CONST_INT_P (operands[2]))
11153     ele = GEN_INT (- INTVAL (operands[2]));
11154   else if (GET_MODE (operands[2]) != DImode)
11155     {
11156       rtx move = gen_reg_rtx (DImode);
11157       ele = gen_reg_rtx (DImode);
11158       convert_move (move, operands[2], false);
11159       emit_insn (gen_negdi2 (ele, move));
11160     }
11161   else
11162     {
11163       ele = gen_reg_rtx (DImode);
11164       emit_insn (gen_negdi2 (ele, operands[2]));
11165     }
11166
11167   RTVEC_ELT (vs, 0) = ele;
11168   RTVEC_ELT (vs, 1) = ele;
11169   emit_insn (gen_vec_initv2di (reg, par));
11170   emit_insn (gen_xop_ashlv2di3 (operands[0], operands[1], reg));
11171   DONE;
11172 })
11173
11174 ;; XOP FRCZ support
11175 (define_insn "xop_frcz<mode>2"
11176   [(set (match_operand:FMAMODE 0 "register_operand" "=x")
11177         (unspec:FMAMODE
11178          [(match_operand:FMAMODE 1 "nonimmediate_operand" "xm")]
11179          UNSPEC_FRCZ))]
11180   "TARGET_XOP"
11181   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
11182   [(set_attr "type" "ssecvt1")
11183    (set_attr "mode" "<MODE>")])
11184
11185 ;; scalar insns
11186 (define_expand "xop_vmfrcz<mode>2"
11187   [(set (match_operand:SSEMODEF2P 0 "register_operand")
11188         (vec_merge:SSEMODEF2P
11189           (unspec:SSEMODEF2P
11190            [(match_operand:SSEMODEF2P 1 "nonimmediate_operand")]
11191            UNSPEC_FRCZ)
11192           (match_dup 3)
11193           (const_int 1)))]
11194   "TARGET_XOP"
11195 {
11196   operands[3] = CONST0_RTX (<MODE>mode);
11197 })
11198
11199 (define_insn "*xop_vmfrcz_<mode>"
11200   [(set (match_operand:SSEMODEF2P 0 "register_operand" "=x")
11201         (vec_merge:SSEMODEF2P
11202           (unspec:SSEMODEF2P
11203            [(match_operand:SSEMODEF2P 1 "nonimmediate_operand" "xm")]
11204            UNSPEC_FRCZ)
11205           (match_operand:SSEMODEF2P 2 "const0_operand")
11206           (const_int 1)))]
11207   "TARGET_XOP"
11208   "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
11209   [(set_attr "type" "ssecvt1")
11210    (set_attr "mode" "<MODE>")])
11211
11212 (define_insn "xop_maskcmp<mode>3"
11213   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11214         (match_operator:SSEMODE1248 1 "ix86_comparison_int_operator"
11215          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11216           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11217   "TARGET_XOP"
11218   "vpcom%Y1<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11219   [(set_attr "type" "sse4arg")
11220    (set_attr "prefix_data16" "0")
11221    (set_attr "prefix_rep" "0")
11222    (set_attr "prefix_extra" "2")
11223    (set_attr "length_immediate" "1")
11224    (set_attr "mode" "TI")])
11225
11226 (define_insn "xop_maskcmp_uns<mode>3"
11227   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11228         (match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11229          [(match_operand:SSEMODE1248 2 "register_operand" "x")
11230           (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")]))]
11231   "TARGET_XOP"
11232   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11233   [(set_attr "type" "ssecmp")
11234    (set_attr "prefix_data16" "0")
11235    (set_attr "prefix_rep" "0")
11236    (set_attr "prefix_extra" "2")
11237    (set_attr "length_immediate" "1")
11238    (set_attr "mode" "TI")])
11239
11240 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
11241 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
11242 ;; the exact instruction generated for the intrinsic.
11243 (define_insn "xop_maskcmp_uns2<mode>3"
11244   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11245         (unspec:SSEMODE1248
11246          [(match_operator:SSEMODE1248 1 "ix86_comparison_uns_operator"
11247           [(match_operand:SSEMODE1248 2 "register_operand" "x")
11248            (match_operand:SSEMODE1248 3 "nonimmediate_operand" "xm")])]
11249          UNSPEC_XOP_UNSIGNED_CMP))]
11250   "TARGET_XOP"
11251   "vpcom%Y1u<ssevecsize>\t{%3, %2, %0|%0, %2, %3}"
11252   [(set_attr "type" "ssecmp")
11253    (set_attr "prefix_data16" "0")
11254    (set_attr "prefix_extra" "2")
11255    (set_attr "length_immediate" "1")
11256    (set_attr "mode" "TI")])
11257
11258 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
11259 ;; being added here to be complete.
11260 (define_insn "xop_pcom_tf<mode>3"
11261   [(set (match_operand:SSEMODE1248 0 "register_operand" "=x")
11262         (unspec:SSEMODE1248
11263           [(match_operand:SSEMODE1248 1 "register_operand" "x")
11264            (match_operand:SSEMODE1248 2 "nonimmediate_operand" "xm")
11265            (match_operand:SI 3 "const_int_operand" "n")]
11266           UNSPEC_XOP_TRUEFALSE))]
11267   "TARGET_XOP"
11268 {
11269   return ((INTVAL (operands[3]) != 0)
11270           ? "vpcomtrue<ssevecsize>\t{%2, %1, %0|%0, %1, %2}"
11271           : "vpcomfalse<ssevecsize>\t{%2, %1, %0|%0, %1, %2}");
11272 }
11273   [(set_attr "type" "ssecmp")
11274    (set_attr "prefix_data16" "0")
11275    (set_attr "prefix_extra" "2")
11276    (set_attr "length_immediate" "1")
11277    (set_attr "mode" "TI")])
11278
11279 (define_insn "xop_vpermil2<mode>3"
11280   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11281         (unspec:AVXMODEF2P
11282           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11283            (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "%x")
11284            (match_operand:<avxpermvecmode> 3 "nonimmediate_operand" "xm")
11285            (match_operand:SI 4 "const_0_to_3_operand" "n")]
11286           UNSPEC_VPERMIL2))]
11287   "TARGET_XOP"
11288   "vpermil2<ssemodesuffix>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
11289   [(set_attr "type" "sse4arg")
11290    (set_attr "length_immediate" "1")
11291    (set_attr "mode" "<MODE>")])
11292
11293 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11294 (define_insn "*avx_aesenc"
11295   [(set (match_operand:V2DI 0 "register_operand" "=x")
11296         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11297                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11298                       UNSPEC_AESENC))]
11299   "TARGET_AES && TARGET_AVX"
11300   "vaesenc\t{%2, %1, %0|%0, %1, %2}"
11301   [(set_attr "type" "sselog1")
11302    (set_attr "prefix_extra" "1")
11303    (set_attr "prefix" "vex")
11304    (set_attr "mode" "TI")])
11305
11306 (define_insn "aesenc"
11307   [(set (match_operand:V2DI 0 "register_operand" "=x")
11308         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11309                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11310                       UNSPEC_AESENC))]
11311   "TARGET_AES"
11312   "aesenc\t{%2, %0|%0, %2}"
11313   [(set_attr "type" "sselog1")
11314    (set_attr "prefix_extra" "1")
11315    (set_attr "mode" "TI")])
11316
11317 (define_insn "*avx_aesenclast"
11318   [(set (match_operand:V2DI 0 "register_operand" "=x")
11319         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11320                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11321                       UNSPEC_AESENCLAST))]
11322   "TARGET_AES && TARGET_AVX"
11323   "vaesenclast\t{%2, %1, %0|%0, %1, %2}"
11324   [(set_attr "type" "sselog1")
11325    (set_attr "prefix_extra" "1")
11326    (set_attr "prefix" "vex")
11327    (set_attr "mode" "TI")])
11328
11329 (define_insn "aesenclast"
11330   [(set (match_operand:V2DI 0 "register_operand" "=x")
11331         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11332                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11333                       UNSPEC_AESENCLAST))]
11334   "TARGET_AES"
11335   "aesenclast\t{%2, %0|%0, %2}"
11336   [(set_attr "type" "sselog1")
11337    (set_attr "prefix_extra" "1")
11338    (set_attr "mode" "TI")])
11339
11340 (define_insn "*avx_aesdec"
11341   [(set (match_operand:V2DI 0 "register_operand" "=x")
11342         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11343                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11344                       UNSPEC_AESDEC))]
11345   "TARGET_AES && TARGET_AVX"
11346   "vaesdec\t{%2, %1, %0|%0, %1, %2}"
11347   [(set_attr "type" "sselog1")
11348    (set_attr "prefix_extra" "1")
11349    (set_attr "prefix" "vex")
11350    (set_attr "mode" "TI")])
11351
11352 (define_insn "aesdec"
11353   [(set (match_operand:V2DI 0 "register_operand" "=x")
11354         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11355                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11356                       UNSPEC_AESDEC))]
11357   "TARGET_AES"
11358   "aesdec\t{%2, %0|%0, %2}"
11359   [(set_attr "type" "sselog1")
11360    (set_attr "prefix_extra" "1")
11361    (set_attr "mode" "TI")])
11362
11363 (define_insn "*avx_aesdeclast"
11364   [(set (match_operand:V2DI 0 "register_operand" "=x")
11365         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11366                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11367                       UNSPEC_AESDECLAST))]
11368   "TARGET_AES && TARGET_AVX"
11369   "vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
11370   [(set_attr "type" "sselog1")
11371    (set_attr "prefix_extra" "1")
11372    (set_attr "prefix" "vex")
11373    (set_attr "mode" "TI")])
11374
11375 (define_insn "aesdeclast"
11376   [(set (match_operand:V2DI 0 "register_operand" "=x")
11377         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11378                        (match_operand:V2DI 2 "nonimmediate_operand" "xm")]
11379                       UNSPEC_AESDECLAST))]
11380   "TARGET_AES"
11381   "aesdeclast\t{%2, %0|%0, %2}"
11382   [(set_attr "type" "sselog1")
11383    (set_attr "prefix_extra" "1")
11384    (set_attr "mode" "TI")])
11385
11386 (define_insn "aesimc"
11387   [(set (match_operand:V2DI 0 "register_operand" "=x")
11388         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11389                       UNSPEC_AESIMC))]
11390   "TARGET_AES"
11391   "%vaesimc\t{%1, %0|%0, %1}"
11392   [(set_attr "type" "sselog1")
11393    (set_attr "prefix_extra" "1")
11394    (set_attr "prefix" "maybe_vex")
11395    (set_attr "mode" "TI")])
11396
11397 (define_insn "aeskeygenassist"
11398   [(set (match_operand:V2DI 0 "register_operand" "=x")
11399         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
11400                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
11401                      UNSPEC_AESKEYGENASSIST))]
11402   "TARGET_AES"
11403   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
11404   [(set_attr "type" "sselog1")
11405    (set_attr "prefix_extra" "1")
11406    (set_attr "length_immediate" "1")
11407    (set_attr "prefix" "maybe_vex")
11408    (set_attr "mode" "TI")])
11409
11410 (define_insn "*vpclmulqdq"
11411   [(set (match_operand:V2DI 0 "register_operand" "=x")
11412         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")
11413                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11414                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11415                      UNSPEC_PCLMUL))]
11416   "TARGET_PCLMUL && TARGET_AVX"
11417   "vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11418   [(set_attr "type" "sselog1")
11419    (set_attr "prefix_extra" "1")
11420    (set_attr "length_immediate" "1")
11421    (set_attr "prefix" "vex")
11422    (set_attr "mode" "TI")])
11423
11424 (define_insn "pclmulqdq"
11425   [(set (match_operand:V2DI 0 "register_operand" "=x")
11426         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11427                       (match_operand:V2DI 2 "nonimmediate_operand" "xm")
11428                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
11429                      UNSPEC_PCLMUL))]
11430   "TARGET_PCLMUL"
11431   "pclmulqdq\t{%3, %2, %0|%0, %2, %3}"
11432   [(set_attr "type" "sselog1")
11433    (set_attr "prefix_extra" "1")
11434    (set_attr "length_immediate" "1")
11435    (set_attr "mode" "TI")])
11436
11437 (define_expand "avx_vzeroall"
11438   [(match_par_dup 0 [(const_int 0)])]
11439   "TARGET_AVX"
11440 {
11441   int nregs = TARGET_64BIT ? 16 : 8;
11442   int regno;
11443
11444   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11445
11446   XVECEXP (operands[0], 0, 0)
11447     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11448                                UNSPECV_VZEROALL);
11449
11450   for (regno = 0; regno < nregs; regno++)
11451     XVECEXP (operands[0], 0, regno + 1)
11452       = gen_rtx_SET (VOIDmode,
11453                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
11454                      CONST0_RTX (V8SImode));
11455 })
11456
11457 (define_insn "*avx_vzeroall"
11458   [(match_parallel 0 "vzeroall_operation"
11459     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
11460   "TARGET_AVX"
11461   "vzeroall"
11462   [(set_attr "type" "sse")
11463    (set_attr "modrm" "0")
11464    (set_attr "memory" "none")
11465    (set_attr "prefix" "vex")
11466    (set_attr "mode" "OI")])
11467
11468 ;; vzeroupper clobbers the upper 128bits of AVX registers.
11469 (define_expand "avx_vzeroupper"
11470   [(match_par_dup 0 [(const_int 0)])]
11471   "TARGET_AVX"
11472 {
11473   int nregs = TARGET_64BIT ? 16 : 8;
11474   int regno;
11475
11476   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
11477
11478   XVECEXP (operands[0], 0, 0)
11479     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
11480                                UNSPECV_VZEROUPPER);
11481
11482   for (regno = 0; regno < nregs; regno++)
11483     XVECEXP (operands[0], 0, regno + 1)
11484       = gen_rtx_CLOBBER (VOIDmode,
11485                          gen_rtx_REG (V8SImode, SSE_REGNO (regno)));
11486 })
11487
11488 (define_insn "*avx_vzeroupper"
11489   [(match_parallel 0 "vzeroupper_operation"
11490     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)])]
11491   "TARGET_AVX"
11492   "vzeroupper"
11493   [(set_attr "type" "sse")
11494    (set_attr "modrm" "0")
11495    (set_attr "memory" "none")
11496    (set_attr "prefix" "vex")
11497    (set_attr "mode" "OI")])
11498
11499 (define_insn_and_split "vec_dup<mode>"
11500   [(set (match_operand:AVX256MODE24P 0 "register_operand" "=x,x")
11501         (vec_duplicate:AVX256MODE24P
11502           (match_operand:<avxscalarmode> 1 "nonimmediate_operand" "m,?x")))]
11503   "TARGET_AVX"
11504   "@
11505    vbroadcast<ssescalarmodesuffix>\t{%1, %0|%0, %1}
11506    #"
11507   "&& reload_completed && REG_P (operands[1])"
11508   [(set (match_dup 2) (vec_duplicate:<avxhalfvecmode> (match_dup 1)))
11509    (set (match_dup 0) (vec_concat:AVX256MODE24P (match_dup 2) (match_dup 2)))]
11510   "operands[2] = gen_rtx_REG (<avxhalfvecmode>mode, REGNO (operands[0]));"
11511   [(set_attr "type" "ssemov")
11512    (set_attr "prefix_extra" "1")
11513    (set_attr "prefix" "vex")
11514    (set_attr "mode" "V8SF")])
11515
11516 (define_insn "avx_vbroadcastf128_<mode>"
11517   [(set (match_operand:AVX256MODE 0 "register_operand" "=x,x,x")
11518         (vec_concat:AVX256MODE
11519           (match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
11520           (match_dup 1)))]
11521   "TARGET_AVX"
11522   "@
11523    vbroadcastf128\t{%1, %0|%0, %1}
11524    vinsertf128\t{$1, %1, %0, %0|%0, %0, %1, 1}
11525    vperm2f128\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
11526   [(set_attr "type" "ssemov,sselog1,sselog1")
11527    (set_attr "prefix_extra" "1")
11528    (set_attr "length_immediate" "0,1,1")
11529    (set_attr "prefix" "vex")
11530    (set_attr "mode" "V4SF,V8SF,V8SF")])
11531
11532 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
11533 ;; If it so happens that the input is in memory, use vbroadcast.
11534 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
11535 (define_insn "*avx_vperm_broadcast_v4sf"
11536   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
11537         (vec_select:V4SF
11538           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
11539           (match_parallel 2 "avx_vbroadcast_operand"
11540             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11541   "TARGET_AVX"
11542 {
11543   int elt = INTVAL (operands[3]);
11544   switch (which_alternative)
11545     {
11546     case 0:
11547     case 1:
11548       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
11549       return "vbroadcastss\t{%1, %0|%0, %1}";
11550     case 2:
11551       operands[2] = GEN_INT (elt * 0x55);
11552       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
11553     default:
11554       gcc_unreachable ();
11555     }
11556 }
11557   [(set_attr "type" "ssemov,ssemov,sselog1")
11558    (set_attr "prefix_extra" "1")
11559    (set_attr "length_immediate" "0,0,1")
11560    (set_attr "prefix" "vex")
11561    (set_attr "mode" "SF,SF,V4SF")])
11562
11563 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
11564   [(set (match_operand:AVX256MODEF2P 0 "register_operand" "=x,x,x")
11565         (vec_select:AVX256MODEF2P
11566           (match_operand:AVX256MODEF2P 1 "nonimmediate_operand" "m,o,?x")
11567           (match_parallel 2 "avx_vbroadcast_operand"
11568             [(match_operand 3 "const_int_operand" "C,n,n")])))]
11569   "TARGET_AVX"
11570   "#"
11571   "&& reload_completed"
11572   [(set (match_dup 0) (vec_duplicate:AVX256MODEF2P (match_dup 1)))]
11573 {
11574   rtx op0 = operands[0], op1 = operands[1];
11575   int elt = INTVAL (operands[3]);
11576
11577   if (REG_P (op1))
11578     {
11579       int mask;
11580
11581       /* Shuffle element we care about into all elements of the 128-bit lane.
11582          The other lane gets shuffled too, but we don't care.  */
11583       if (<MODE>mode == V4DFmode)
11584         mask = (elt & 1 ? 15 : 0);
11585       else
11586         mask = (elt & 3) * 0x55;
11587       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
11588
11589       /* Shuffle the lane we care about into both lanes of the dest.  */
11590       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
11591       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
11592       DONE;
11593     }
11594
11595   operands[1] = adjust_address_nv (op1, <avxscalarmode>mode,
11596                                    elt * GET_MODE_SIZE (<avxscalarmode>mode));
11597 })
11598
11599 (define_expand "avx_vpermil<mode>"
11600   [(set (match_operand:AVXMODEFDP 0 "register_operand" "")
11601         (vec_select:AVXMODEFDP
11602           (match_operand:AVXMODEFDP 1 "nonimmediate_operand" "")
11603           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11604   "TARGET_AVX"
11605 {
11606   int mask = INTVAL (operands[2]);
11607   rtx perm[<ssescalarnum>];
11608
11609   perm[0] = GEN_INT (mask & 1);
11610   perm[1] = GEN_INT ((mask >> 1) & 1);
11611   if (<MODE>mode == V4DFmode)
11612     {
11613       perm[2] = GEN_INT (((mask >> 2) & 1) + 2);
11614       perm[3] = GEN_INT (((mask >> 3) & 1) + 2);
11615     }
11616
11617   operands[2]
11618     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11619 })
11620
11621 (define_expand "avx_vpermil<mode>"
11622   [(set (match_operand:AVXMODEFSP 0 "register_operand" "")
11623         (vec_select:AVXMODEFSP
11624           (match_operand:AVXMODEFSP 1 "nonimmediate_operand" "")
11625           (match_operand:SI 2 "const_0_to_255_operand" "")))]
11626   "TARGET_AVX"
11627 {
11628   int mask = INTVAL (operands[2]);
11629   rtx perm[<ssescalarnum>];
11630
11631   perm[0] = GEN_INT (mask & 3);
11632   perm[1] = GEN_INT ((mask >> 2) & 3);
11633   perm[2] = GEN_INT ((mask >> 4) & 3);
11634   perm[3] = GEN_INT ((mask >> 6) & 3);
11635   if (<MODE>mode == V8SFmode)
11636     {
11637       perm[4] = GEN_INT ((mask & 3) + 4);
11638       perm[5] = GEN_INT (((mask >> 2) & 3) + 4);
11639       perm[6] = GEN_INT (((mask >> 4) & 3) + 4);
11640       perm[7] = GEN_INT (((mask >> 6) & 3) + 4);
11641     }
11642
11643   operands[2]
11644     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
11645 })
11646
11647 (define_insn "*avx_vpermilp<mode>"
11648   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11649         (vec_select:AVXMODEF2P
11650           (match_operand:AVXMODEF2P 1 "nonimmediate_operand" "xm")
11651           (match_parallel 2 "avx_vpermilp_<mode>_operand"
11652             [(match_operand 3 "const_int_operand" "")])))]
11653   "TARGET_AVX"
11654 {
11655   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
11656   operands[2] = GEN_INT (mask);
11657   return "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
11658 }
11659   [(set_attr "type" "sselog")
11660    (set_attr "prefix_extra" "1")
11661    (set_attr "length_immediate" "1")
11662    (set_attr "prefix" "vex")
11663    (set_attr "mode" "<MODE>")])
11664
11665 (define_insn "avx_vpermilvar<mode>3"
11666   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11667         (unspec:AVXMODEF2P
11668           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11669            (match_operand:<avxpermvecmode> 2 "nonimmediate_operand" "xm")]
11670           UNSPEC_VPERMIL))]
11671   "TARGET_AVX"
11672   "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11673   [(set_attr "type" "sselog")
11674    (set_attr "prefix_extra" "1")
11675    (set_attr "prefix" "vex")
11676    (set_attr "mode" "<MODE>")])
11677
11678 (define_expand "avx_vperm2f128<mode>3"
11679   [(set (match_operand:AVX256MODE2P 0 "register_operand" "")
11680         (unspec:AVX256MODE2P
11681           [(match_operand:AVX256MODE2P 1 "register_operand" "")
11682            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "")
11683            (match_operand:SI 3 "const_0_to_255_operand" "")]
11684           UNSPEC_VPERMIL2F128))]
11685   "TARGET_AVX"
11686 {
11687   int mask = INTVAL (operands[3]);
11688   if ((mask & 0x88) == 0)
11689     {
11690       rtx perm[<ssescalarnum>], t1, t2;
11691       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
11692
11693       base = (mask & 3) * nelt2;
11694       for (i = 0; i < nelt2; ++i)
11695         perm[i] = GEN_INT (base + i);
11696
11697       base = ((mask >> 4) & 3) * nelt2;
11698       for (i = 0; i < nelt2; ++i)
11699         perm[i + nelt2] = GEN_INT (base + i);
11700
11701       t2 = gen_rtx_VEC_CONCAT (<ssedoublesizemode>mode,
11702                                operands[1], operands[2]);
11703       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
11704       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
11705       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
11706       emit_insn (t2);
11707       DONE;
11708     }
11709 })
11710
11711 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
11712 ;; means that in order to represent this properly in rtl we'd have to
11713 ;; nest *another* vec_concat with a zero operand and do the select from
11714 ;; a 4x wide vector.  That doesn't seem very nice.
11715 (define_insn "*avx_vperm2f128<mode>_full"
11716   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
11717         (unspec:AVX256MODE2P
11718           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
11719            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
11720            (match_operand:SI 3 "const_0_to_255_operand" "n")]
11721           UNSPEC_VPERMIL2F128))]
11722   "TARGET_AVX"
11723   "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11724   [(set_attr "type" "sselog")
11725    (set_attr "prefix_extra" "1")
11726    (set_attr "length_immediate" "1")
11727    (set_attr "prefix" "vex")
11728    (set_attr "mode" "V8SF")])
11729
11730 (define_insn "*avx_vperm2f128<mode>_nozero"
11731   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
11732         (vec_select:AVX256MODE2P
11733           (vec_concat:<ssedoublesizemode>
11734             (match_operand:AVX256MODE2P 1 "register_operand" "x")
11735             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
11736           (match_parallel 3 "avx_vperm2f128_<mode>_operand"
11737             [(match_operand 4 "const_int_operand" "")])))]
11738   "TARGET_AVX"
11739 {
11740   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
11741   operands[3] = GEN_INT (mask);
11742   return "vperm2f128\t{%3, %2, %1, %0|%0, %1, %2, %3}";
11743 }
11744   [(set_attr "type" "sselog")
11745    (set_attr "prefix_extra" "1")
11746    (set_attr "length_immediate" "1")
11747    (set_attr "prefix" "vex")
11748    (set_attr "mode" "V8SF")])
11749
11750 (define_expand "avx_vinsertf128<mode>"
11751   [(match_operand:AVX256MODE 0 "register_operand" "")
11752    (match_operand:AVX256MODE 1 "register_operand" "")
11753    (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "")
11754    (match_operand:SI 3 "const_0_to_1_operand" "")]
11755   "TARGET_AVX"
11756 {
11757   switch (INTVAL (operands[3]))
11758     {
11759     case 0:
11760       emit_insn (gen_vec_set_lo_<mode> (operands[0], operands[1],
11761                                         operands[2]));
11762       break;
11763     case 1:
11764       emit_insn (gen_vec_set_hi_<mode> (operands[0], operands[1],
11765                                         operands[2]));
11766       break;
11767     default:
11768       gcc_unreachable ();
11769     }
11770   DONE;
11771 })
11772
11773 (define_insn "vec_set_lo_<mode>"
11774   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
11775         (vec_concat:AVX256MODE4P
11776           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
11777           (vec_select:<avxhalfvecmode>
11778             (match_operand:AVX256MODE4P 1 "register_operand" "x")
11779             (parallel [(const_int 2) (const_int 3)]))))]
11780   "TARGET_AVX"
11781   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11782   [(set_attr "type" "sselog")
11783    (set_attr "prefix_extra" "1")
11784    (set_attr "length_immediate" "1")
11785    (set_attr "prefix" "vex")
11786    (set_attr "mode" "V8SF")])
11787
11788 (define_insn "vec_set_hi_<mode>"
11789   [(set (match_operand:AVX256MODE4P 0 "register_operand" "=x")
11790         (vec_concat:AVX256MODE4P
11791           (vec_select:<avxhalfvecmode>
11792             (match_operand:AVX256MODE4P 1 "register_operand" "x")
11793             (parallel [(const_int 0) (const_int 1)]))
11794           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
11795   "TARGET_AVX"
11796   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11797   [(set_attr "type" "sselog")
11798    (set_attr "prefix_extra" "1")
11799    (set_attr "length_immediate" "1")
11800    (set_attr "prefix" "vex")
11801    (set_attr "mode" "V8SF")])
11802
11803 (define_insn "vec_set_lo_<mode>"
11804   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
11805         (vec_concat:AVX256MODE8P
11806           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")
11807           (vec_select:<avxhalfvecmode>
11808             (match_operand:AVX256MODE8P 1 "register_operand" "x")
11809             (parallel [(const_int 4) (const_int 5)
11810                        (const_int 6) (const_int 7)]))))]
11811   "TARGET_AVX"
11812   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11813   [(set_attr "type" "sselog")
11814    (set_attr "prefix_extra" "1")
11815    (set_attr "length_immediate" "1")
11816    (set_attr "prefix" "vex")
11817    (set_attr "mode" "V8SF")])
11818
11819 (define_insn "vec_set_hi_<mode>"
11820   [(set (match_operand:AVX256MODE8P 0 "register_operand" "=x")
11821         (vec_concat:AVX256MODE8P
11822           (vec_select:<avxhalfvecmode>
11823             (match_operand:AVX256MODE8P 1 "register_operand" "x")
11824             (parallel [(const_int 0) (const_int 1)
11825                        (const_int 2) (const_int 3)]))
11826           (match_operand:<avxhalfvecmode> 2 "nonimmediate_operand" "xm")))]
11827   "TARGET_AVX"
11828   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11829   [(set_attr "type" "sselog")
11830    (set_attr "prefix_extra" "1")
11831    (set_attr "length_immediate" "1")
11832    (set_attr "prefix" "vex")
11833    (set_attr "mode" "V8SF")])
11834
11835 (define_insn "vec_set_lo_v16hi"
11836   [(set (match_operand:V16HI 0 "register_operand" "=x")
11837         (vec_concat:V16HI
11838           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
11839           (vec_select:V8HI
11840             (match_operand:V16HI 1 "register_operand" "x")
11841             (parallel [(const_int 8) (const_int 9)
11842                        (const_int 10) (const_int 11)
11843                        (const_int 12) (const_int 13)
11844                        (const_int 14) (const_int 15)]))))]
11845   "TARGET_AVX"
11846   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11847   [(set_attr "type" "sselog")
11848    (set_attr "prefix_extra" "1")
11849    (set_attr "length_immediate" "1")
11850    (set_attr "prefix" "vex")
11851    (set_attr "mode" "V8SF")])
11852
11853 (define_insn "vec_set_hi_v16hi"
11854   [(set (match_operand:V16HI 0 "register_operand" "=x")
11855         (vec_concat:V16HI
11856           (vec_select:V8HI
11857             (match_operand:V16HI 1 "register_operand" "x")
11858             (parallel [(const_int 0) (const_int 1)
11859                        (const_int 2) (const_int 3)
11860                        (const_int 4) (const_int 5)
11861                        (const_int 6) (const_int 7)]))
11862           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
11863   "TARGET_AVX"
11864   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11865   [(set_attr "type" "sselog")
11866    (set_attr "prefix_extra" "1")
11867    (set_attr "length_immediate" "1")
11868    (set_attr "prefix" "vex")
11869    (set_attr "mode" "V8SF")])
11870
11871 (define_insn "vec_set_lo_v32qi"
11872   [(set (match_operand:V32QI 0 "register_operand" "=x")
11873         (vec_concat:V32QI
11874           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
11875           (vec_select:V16QI
11876             (match_operand:V32QI 1 "register_operand" "x")
11877             (parallel [(const_int 16) (const_int 17)
11878                        (const_int 18) (const_int 19)
11879                        (const_int 20) (const_int 21)
11880                        (const_int 22) (const_int 23)
11881                        (const_int 24) (const_int 25)
11882                        (const_int 26) (const_int 27)
11883                        (const_int 28) (const_int 29)
11884                        (const_int 30) (const_int 31)]))))]
11885   "TARGET_AVX"
11886   "vinsertf128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11887   [(set_attr "type" "sselog")
11888    (set_attr "prefix_extra" "1")
11889    (set_attr "length_immediate" "1")
11890    (set_attr "prefix" "vex")
11891    (set_attr "mode" "V8SF")])
11892
11893 (define_insn "vec_set_hi_v32qi"
11894   [(set (match_operand:V32QI 0 "register_operand" "=x")
11895         (vec_concat:V32QI
11896           (vec_select:V16QI
11897             (match_operand:V32QI 1 "register_operand" "x")
11898             (parallel [(const_int 0) (const_int 1)
11899                        (const_int 2) (const_int 3)
11900                        (const_int 4) (const_int 5)
11901                        (const_int 6) (const_int 7)
11902                        (const_int 8) (const_int 9)
11903                        (const_int 10) (const_int 11)
11904                        (const_int 12) (const_int 13)
11905                        (const_int 14) (const_int 15)]))
11906           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
11907   "TARGET_AVX"
11908   "vinsertf128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11909   [(set_attr "type" "sselog")
11910    (set_attr "prefix_extra" "1")
11911    (set_attr "length_immediate" "1")
11912    (set_attr "prefix" "vex")
11913    (set_attr "mode" "V8SF")])
11914
11915 (define_insn "avx_maskload<ssemodesuffix><avxmodesuffix>"
11916   [(set (match_operand:AVXMODEF2P 0 "register_operand" "=x")
11917         (unspec:AVXMODEF2P
11918           [(match_operand:AVXMODEF2P 1 "memory_operand" "m")
11919            (match_operand:AVXMODEF2P 2 "register_operand" "x")
11920            (match_dup 0)]
11921           UNSPEC_MASKLOAD))]
11922   "TARGET_AVX"
11923   "vmaskmov<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
11924   [(set_attr "type" "sselog1")
11925    (set_attr "prefix_extra" "1")
11926    (set_attr "prefix" "vex")
11927    (set_attr "mode" "<MODE>")])
11928
11929 (define_insn "avx_maskstore<ssemodesuffix><avxmodesuffix>"
11930   [(set (match_operand:AVXMODEF2P 0 "memory_operand" "=m")
11931         (unspec:AVXMODEF2P
11932           [(match_operand:AVXMODEF2P 1 "register_operand" "x")
11933            (match_operand:AVXMODEF2P 2 "register_operand" "x")
11934            (match_dup 0)]
11935           UNSPEC_MASKSTORE))]
11936   "TARGET_AVX"
11937   "vmaskmov<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11938   [(set_attr "type" "sselog1")
11939    (set_attr "prefix_extra" "1")
11940    (set_attr "prefix" "vex")
11941    (set_attr "mode" "<MODE>")])
11942
11943 (define_insn_and_split "avx_<avxmodesuffixp><avxmodesuffix>_<avxmodesuffixp>"
11944   [(set (match_operand:AVX256MODE2P 0 "nonimmediate_operand" "=x,m")
11945         (unspec:AVX256MODE2P
11946           [(match_operand:<avxhalfvecmode> 1 "nonimmediate_operand" "xm,x")]
11947           UNSPEC_CAST))]
11948   "TARGET_AVX"
11949   "#"
11950   "&& reload_completed"
11951   [(const_int 0)]
11952 {
11953   rtx op1 = operands[1];
11954   if (REG_P (op1))
11955     op1 = gen_rtx_REG (<MODE>mode, REGNO (op1));
11956   else
11957     op1 = gen_lowpart (<MODE>mode, op1);
11958   emit_move_insn (operands[0], op1);
11959   DONE;
11960 })
11961
11962 (define_expand "vec_init<mode>"
11963   [(match_operand:AVX256MODE 0 "register_operand" "")
11964    (match_operand 1 "" "")]
11965   "TARGET_AVX"
11966 {
11967   ix86_expand_vector_init (false, operands[0], operands[1]);
11968   DONE;
11969 })
11970
11971 (define_insn "*vec_concat<mode>_avx"
11972   [(set (match_operand:AVX256MODE 0 "register_operand"   "=x,x")
11973         (vec_concat:AVX256MODE
11974           (match_operand:<avxhalfvecmode> 1 "register_operand" "x,x")
11975           (match_operand:<avxhalfvecmode> 2 "vector_move_operand" "xm,C")))]
11976   "TARGET_AVX"
11977 {
11978   switch (which_alternative)
11979     {
11980     case 0:
11981       return "vinsertf128\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
11982     case 1:
11983       switch (get_attr_mode (insn))
11984         {
11985         case MODE_V8SF:
11986           return "vmovaps\t{%1, %x0|%x0, %1}";
11987         case MODE_V4DF:
11988           return "vmovapd\t{%1, %x0|%x0, %1}";
11989         default:
11990           return "vmovdqa\t{%1, %x0|%x0, %1}";
11991         }
11992     default:
11993       gcc_unreachable ();
11994     }
11995 }
11996   [(set_attr "type" "sselog,ssemov")
11997    (set_attr "prefix_extra" "1,*")
11998    (set_attr "length_immediate" "1,*")
11999    (set_attr "prefix" "vex")
12000    (set_attr "mode" "<avxvecmode>")])
12001
12002 (define_insn "vcvtph2ps"
12003   [(set (match_operand:V4SF 0 "register_operand" "=x")
12004         (vec_select:V4SF
12005           (unspec:V8SF [(match_operand:V8HI 1 "register_operand" "x")]
12006                        UNSPEC_VCVTPH2PS)
12007           (parallel [(const_int 0) (const_int 1)
12008                      (const_int 1) (const_int 2)])))]
12009   "TARGET_F16C"
12010   "vcvtph2ps\t{%1, %0|%0, %1}"
12011   [(set_attr "type" "ssecvt")
12012    (set_attr "prefix" "vex")
12013    (set_attr "mode" "V4SF")])
12014
12015 (define_insn "*vcvtph2ps_load"
12016   [(set (match_operand:V4SF 0 "register_operand" "=x")
12017         (unspec:V4SF [(match_operand:V4HI 1 "memory_operand" "m")]
12018                      UNSPEC_VCVTPH2PS))]
12019   "TARGET_F16C"
12020   "vcvtph2ps\t{%1, %0|%0, %1}"
12021   [(set_attr "type" "ssecvt")
12022    (set_attr "prefix" "vex")
12023    (set_attr "mode" "V8SF")])
12024
12025 (define_insn "vcvtph2ps256"
12026   [(set (match_operand:V8SF 0 "register_operand" "=x")
12027         (unspec:V8SF [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
12028                      UNSPEC_VCVTPH2PS))]
12029   "TARGET_F16C"
12030   "vcvtph2ps\t{%1, %0|%0, %1}"
12031   [(set_attr "type" "ssecvt")
12032    (set_attr "prefix" "vex")
12033    (set_attr "mode" "V8SF")])
12034
12035 (define_expand "vcvtps2ph"
12036   [(set (match_operand:V8HI 0 "register_operand" "")
12037         (vec_concat:V8HI
12038           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "")
12039                         (match_operand:SI 2 "immediate_operand" "")]
12040                        UNSPEC_VCVTPS2PH)
12041           (match_dup 3)))]
12042   "TARGET_F16C"
12043   "operands[3] = CONST0_RTX (V4HImode);")
12044
12045 (define_insn "*vcvtps2ph"
12046   [(set (match_operand:V8HI 0 "register_operand" "=x")
12047         (vec_concat:V8HI
12048           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
12049                         (match_operand:SI 2 "immediate_operand" "N")]
12050                        UNSPEC_VCVTPS2PH)
12051           (match_operand:V4HI 3 "const0_operand" "")))]
12052   "TARGET_F16C"
12053   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12054   [(set_attr "type" "ssecvt")
12055    (set_attr "prefix" "vex")
12056    (set_attr "mode" "V4SF")])
12057
12058 (define_insn "*vcvtps2ph_store"
12059   [(set (match_operand:V4HI 0 "memory_operand" "=m")
12060         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
12061                       (match_operand:SI 2 "immediate_operand" "N")]
12062                      UNSPEC_VCVTPS2PH))]
12063   "TARGET_F16C"
12064   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12065   [(set_attr "type" "ssecvt")
12066    (set_attr "prefix" "vex")
12067    (set_attr "mode" "V4SF")])
12068
12069 (define_insn "vcvtps2ph256"
12070   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=xm")
12071         (unspec:V8HI [(match_operand:V8SF 1 "register_operand" "x")
12072                       (match_operand:SI 2 "immediate_operand" "N")]
12073                      UNSPEC_VCVTPS2PH))]
12074   "TARGET_F16C"
12075   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
12076   [(set_attr "type" "ssecvt")
12077    (set_attr "prefix" "vex")
12078    (set_attr "mode" "V8SF")])