gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005-2013 Free Software Foundation, Inc.
   3 ;;
   4 ;; This file is part of GCC.
   5 ;;
   6 ;; GCC is free software; you can redistribute it and/or modify
   7 ;; it under the terms of the GNU General Public License as published by
   8 ;; the Free Software Foundation; either version 3, or (at your option)
   9 ;; any later version.
  10 ;;
  11 ;; GCC is distributed in the hope that it will be useful,
  12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;; GNU General Public License for more details.
  15 ;;
  16 ;; You should have received a copy of the GNU General Public License
  17 ;; along with GCC; see the file COPYING3.  If not see
  18 ;; <http://www.gnu.org/licenses/>.
  19
  20 (define_c_enum "unspec" [
  21   ;; SSE
  22   UNSPEC_MOVNT
  23   UNSPEC_LOADU
  24   UNSPEC_STOREU
  25
  26   ;; SSE3
  27   UNSPEC_LDDQU
  28
  29   ;; SSSE3
  30   UNSPEC_PSHUFB
  31   UNSPEC_PSIGN
  32   UNSPEC_PALIGNR
  33
  34   ;; For SSE4A support
  35   UNSPEC_EXTRQI
  36   UNSPEC_EXTRQ
  37   UNSPEC_INSERTQI
  38   UNSPEC_INSERTQ
  39
  40   ;; For SSE4.1 support
  41   UNSPEC_BLENDV
  42   UNSPEC_INSERTPS
  43   UNSPEC_DP
  44   UNSPEC_MOVNTDQA
  45   UNSPEC_MPSADBW
  46   UNSPEC_PHMINPOSUW
  47   UNSPEC_PTEST
  48
  49   ;; For SSE4.2 support
  50   UNSPEC_PCMPESTR
  51   UNSPEC_PCMPISTR
  52
  53   ;; For FMA4 support
  54   UNSPEC_FMADDSUB
  55   UNSPEC_XOP_UNSIGNED_CMP
  56   UNSPEC_XOP_TRUEFALSE
  57   UNSPEC_XOP_PERMUTE
  58   UNSPEC_FRCZ
  59
  60   ;; For AES support
  61   UNSPEC_AESENC
  62   UNSPEC_AESENCLAST
  63   UNSPEC_AESDEC
  64   UNSPEC_AESDECLAST
  65   UNSPEC_AESIMC
  66   UNSPEC_AESKEYGENASSIST
  67
  68   ;; For PCLMUL support
  69   UNSPEC_PCLMUL
  70
  71   ;; For AVX support
  72   UNSPEC_PCMP
  73   UNSPEC_VPERMIL
  74   UNSPEC_VPERMIL2
  75   UNSPEC_VPERMIL2F128
  76   UNSPEC_CAST
  77   UNSPEC_VTESTP
  78   UNSPEC_VCVTPH2PS
  79   UNSPEC_VCVTPS2PH
  80
  81   ;; For AVX2 support
  82   UNSPEC_VPERMVAR
  83   UNSPEC_VPERMTI
  84   UNSPEC_GATHER
  85   UNSPEC_VSIBADDR
  86 ])
  87
  88 (define_c_enum "unspecv" [
  89   UNSPECV_LDMXCSR
  90   UNSPECV_STMXCSR
  91   UNSPECV_CLFLUSH
  92   UNSPECV_MONITOR
  93   UNSPECV_MWAIT
  94   UNSPECV_VZEROALL
  95   UNSPECV_VZEROUPPER
  96 ])
  97
  98 ;; All vector modes including V?TImode, used in move patterns.
  99 (define_mode_iterator V16
 100   [(V32QI "TARGET_AVX") V16QI
 101    (V16HI "TARGET_AVX") V8HI
 102    (V8SI "TARGET_AVX") V4SI
 103    (V4DI "TARGET_AVX") V2DI
 104    (V2TI "TARGET_AVX") V1TI
 105    (V8SF "TARGET_AVX") V4SF
 106    (V4DF "TARGET_AVX") V2DF])
 107
 108 ;; All vector modes
 109 (define_mode_iterator V
 110   [(V32QI "TARGET_AVX") V16QI
 111    (V16HI "TARGET_AVX") V8HI
 112    (V8SI "TARGET_AVX") V4SI
 113    (V4DI "TARGET_AVX") V2DI
 114    (V8SF "TARGET_AVX") V4SF
 115    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 116
 117 ;; All 128bit vector modes
 118 (define_mode_iterator V_128
 119   [V16QI V8HI V4SI V2DI V4SF (V2DF "TARGET_SSE2")])
 120
 121 ;; All 256bit vector modes
 122 (define_mode_iterator V_256
 123   [V32QI V16HI V8SI V4DI V8SF V4DF])
 124
 125 ;; All vector float modes
 126 (define_mode_iterator VF
 127   [(V8SF "TARGET_AVX") V4SF
 128    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 129
 130 ;; All SFmode vector float modes
 131 (define_mode_iterator VF1
 132   [(V8SF "TARGET_AVX") V4SF])
 133
 134 ;; All DFmode vector float modes
 135 (define_mode_iterator VF2
 136   [(V4DF "TARGET_AVX") V2DF])
 137
 138 ;; All 128bit vector float modes
 139 (define_mode_iterator VF_128
 140   [V4SF (V2DF "TARGET_SSE2")])
 141
 142 ;; All 256bit vector float modes
 143 (define_mode_iterator VF_256
 144   [V8SF V4DF])
 145
 146 ;; All vector integer modes
 147 (define_mode_iterator VI
 148   [(V32QI "TARGET_AVX") V16QI
 149    (V16HI "TARGET_AVX") V8HI
 150    (V8SI "TARGET_AVX") V4SI
 151    (V4DI "TARGET_AVX") V2DI])
 152
 153 (define_mode_iterator VI_AVX2
 154   [(V32QI "TARGET_AVX2") V16QI
 155    (V16HI "TARGET_AVX2") V8HI
 156    (V8SI "TARGET_AVX2") V4SI
 157    (V4DI "TARGET_AVX2") V2DI])
 158
 159 ;; All QImode vector integer modes
 160 (define_mode_iterator VI1
 161   [(V32QI "TARGET_AVX") V16QI])
 162
 163 ;; All DImode vector integer modes
 164 (define_mode_iterator VI8
 165   [(V4DI "TARGET_AVX") V2DI])
 166
 167 (define_mode_iterator VI1_AVX2
 168   [(V32QI "TARGET_AVX2") V16QI])
 169
 170 (define_mode_iterator VI2_AVX2
 171   [(V16HI "TARGET_AVX2") V8HI])
 172
 173 (define_mode_iterator VI4_AVX2
 174   [(V8SI "TARGET_AVX2") V4SI])
 175
 176 (define_mode_iterator VI8_AVX2
 177   [(V4DI "TARGET_AVX2") V2DI])
 178
 179 ;; ??? We should probably use TImode instead.
 180 (define_mode_iterator VIMAX_AVX2
 181   [(V2TI "TARGET_AVX2") V1TI])
 182
 183 ;; ??? This should probably be dropped in favor of VIMAX_AVX2.
 184 (define_mode_iterator SSESCALARMODE
 185   [(V2TI "TARGET_AVX2") TI])
 186
 187 (define_mode_iterator VI12_AVX2
 188   [(V32QI "TARGET_AVX2") V16QI
 189    (V16HI "TARGET_AVX2") V8HI])
 190
 191 (define_mode_iterator VI24_AVX2
 192   [(V16HI "TARGET_AVX2") V8HI
 193    (V8SI "TARGET_AVX2") V4SI])
 194
 195 (define_mode_iterator VI124_AVX2
 196   [(V32QI "TARGET_AVX2") V16QI
 197    (V16HI "TARGET_AVX2") V8HI
 198    (V8SI "TARGET_AVX2") V4SI])
 199
 200 (define_mode_iterator VI248_AVX2
 201   [(V16HI "TARGET_AVX2") V8HI
 202    (V8SI "TARGET_AVX2") V4SI
 203    (V4DI "TARGET_AVX2") V2DI])
 204
 205 (define_mode_iterator VI48_AVX2
 206   [(V8SI "TARGET_AVX2") V4SI
 207    (V4DI "TARGET_AVX2") V2DI])
 208
 209 (define_mode_iterator V48_AVX2
 210   [V4SF V2DF
 211    V8SF V4DF
 212    (V4SI "TARGET_AVX2") (V2DI "TARGET_AVX2")
 213    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")])
 214
 215 (define_mode_attr sse2_avx2
 216   [(V16QI "sse2") (V32QI "avx2")
 217    (V8HI "sse2") (V16HI "avx2")
 218    (V4SI "sse2") (V8SI "avx2")
 219    (V2DI "sse2") (V4DI "avx2")
 220    (V1TI "sse2") (V2TI "avx2")])
 221
 222 (define_mode_attr ssse3_avx2
 223    [(V16QI "ssse3") (V32QI "avx2")
 224     (V4HI "ssse3") (V8HI "ssse3") (V16HI "avx2")
 225     (V4SI "ssse3") (V8SI "avx2")
 226     (V2DI "ssse3") (V4DI "avx2")
 227     (TI "ssse3") (V2TI "avx2")])
 228
 229 (define_mode_attr sse4_1_avx2
 230    [(V16QI "sse4_1") (V32QI "avx2")
 231     (V8HI "sse4_1") (V16HI "avx2")
 232     (V4SI "sse4_1") (V8SI "avx2")
 233     (V2DI "sse4_1") (V4DI "avx2")])
 234
 235 (define_mode_attr avx_avx2
 236   [(V4SF "avx") (V2DF "avx")
 237    (V8SF "avx") (V4DF "avx")
 238    (V4SI "avx2") (V2DI "avx2")
 239    (V8SI "avx2") (V4DI "avx2")])
 240
 241 (define_mode_attr vec_avx2
 242   [(V16QI "vec") (V32QI "avx2")
 243    (V8HI "vec") (V16HI "avx2")
 244    (V4SI "vec") (V8SI "avx2")
 245    (V2DI "vec") (V4DI "avx2")])
 246
 247 (define_mode_attr ssedoublemode
 248   [(V16HI "V16SI") (V8HI "V8SI") (V4HI "V4SI")
 249    (V32QI "V32HI") (V16QI "V16HI")])
 250
 251 (define_mode_attr ssebytemode
 252   [(V4DI "V32QI") (V2DI "V16QI")])
 253
 254 ;; All 128bit vector integer modes
 255 (define_mode_iterator VI_128 [V16QI V8HI V4SI V2DI])
 256
 257 ;; All 256bit vector integer modes
 258 (define_mode_iterator VI_256 [V32QI V16HI V8SI V4DI])
 259
 260 ;; Random 128bit vector integer mode combinations
 261 (define_mode_iterator VI12_128 [V16QI V8HI])
 262 (define_mode_iterator VI14_128 [V16QI V4SI])
 263 (define_mode_iterator VI124_128 [V16QI V8HI V4SI])
 264 (define_mode_iterator VI128_128 [V16QI V8HI V2DI])
 265 (define_mode_iterator VI24_128 [V8HI V4SI])
 266 (define_mode_iterator VI248_128 [V8HI V4SI V2DI])
 267 (define_mode_iterator VI48_128 [V4SI V2DI])
 268
 269 ;; Random 256bit vector integer mode combinations
 270 (define_mode_iterator VI124_256 [V32QI V16HI V8SI])
 271 (define_mode_iterator VI48_256 [V8SI V4DI])
 272
 273 ;; Int-float size matches
 274 (define_mode_iterator VI4F_128 [V4SI V4SF])
 275 (define_mode_iterator VI8F_128 [V2DI V2DF])
 276 (define_mode_iterator VI4F_256 [V8SI V8SF])
 277 (define_mode_iterator VI8F_256 [V4DI V4DF])
 278
 279 ;; Mapping from float mode to required SSE level
 280 (define_mode_attr sse
 281   [(SF "sse") (DF "sse2")
 282    (V4SF "sse") (V2DF "sse2")
 283    (V8SF "avx") (V4DF "avx")])
 284
 285 (define_mode_attr sse2
 286   [(V16QI "sse2") (V32QI "avx")
 287    (V2DI "sse2") (V4DI "avx")])
 288
 289 (define_mode_attr sse3
 290   [(V16QI "sse3") (V32QI "avx")])
 291
 292 (define_mode_attr sse4_1
 293   [(V4SF "sse4_1") (V2DF "sse4_1")
 294    (V8SF "avx") (V4DF "avx")])
 295
 296 (define_mode_attr avxsizesuffix
 297   [(V32QI "256") (V16HI "256") (V8SI "256") (V4DI "256")
 298    (V16QI "") (V8HI "") (V4SI "") (V2DI "")
 299    (V8SF "256") (V4DF "256")
 300    (V4SF "") (V2DF "")])
 301
 302 ;; SSE instruction mode
 303 (define_mode_attr sseinsnmode
 304   [(V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI") (V2TI "OI")
 305    (V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
 306    (V8SF "V8SF") (V4DF "V4DF")
 307    (V4SF "V4SF") (V2DF "V2DF")
 308    (TI "TI")])
 309
 310 ;; Mapping of vector float modes to an integer mode of the same size
 311 (define_mode_attr sseintvecmode
 312   [(V8SF "V8SI") (V4DF "V4DI")
 313    (V4SF "V4SI") (V2DF "V2DI")
 314    (V8SI "V8SI") (V4DI "V4DI")
 315    (V4SI "V4SI") (V2DI "V2DI")
 316    (V16HI "V16HI") (V8HI "V8HI")
 317    (V32QI "V32QI") (V16QI "V16QI")])
 318
 319 (define_mode_attr sseintvecmodelower
 320   [(V8SF "v8si") (V4DF "v4di")
 321    (V4SF "v4si") (V2DF "v2di")
 322    (V8SI "v8si") (V4DI "v4di")
 323    (V4SI "v4si") (V2DI "v2di")
 324    (V16HI "v16hi") (V8HI "v8hi")
 325    (V32QI "v32qi") (V16QI "v16qi")])
 326
 327 ;; Mapping of vector modes to a vector mode of double size
 328 (define_mode_attr ssedoublevecmode
 329   [(V32QI "V64QI") (V16HI "V32HI") (V8SI "V16SI") (V4DI "V8DI")
 330    (V16QI "V32QI") (V8HI "V16HI") (V4SI "V8SI") (V2DI "V4DI")
 331    (V8SF "V16SF") (V4DF "V8DF")
 332    (V4SF "V8SF") (V2DF "V4DF")])
 333
 334 ;; Mapping of vector modes to a vector mode of half size
 335 (define_mode_attr ssehalfvecmode
 336   [(V32QI "V16QI") (V16HI "V8HI") (V8SI "V4SI") (V4DI "V2DI")
 337    (V16QI  "V8QI") (V8HI  "V4HI") (V4SI "V2SI")
 338    (V8SF "V4SF") (V4DF "V2DF")
 339    (V4SF "V2SF")])
 340
 341 ;; Mapping of vector modes ti packed single mode of the same size
 342 (define_mode_attr ssePSmode
 343   [(V32QI "V8SF") (V16QI "V4SF")
 344    (V16HI "V8SF") (V8HI "V4SF")
 345    (V8SI "V8SF") (V4SI "V4SF")
 346    (V4DI "V8SF") (V2DI "V4SF")
 347    (V2TI "V8SF") (V1TI "V4SF")
 348    (V8SF "V8SF") (V4SF "V4SF")
 349    (V4DF "V8SF") (V2DF "V4SF")])
 350
 351 ;; Mapping of vector modes back to the scalar modes
 352 (define_mode_attr ssescalarmode
 353   [(V32QI "QI") (V16HI "HI") (V8SI "SI") (V4DI "DI")
 354    (V16QI "QI") (V8HI "HI") (V4SI "SI") (V2DI "DI")
 355    (V8SF "SF") (V4DF "DF")
 356    (V4SF "SF") (V2DF "DF")])
 357
 358 ;; Pointer size override for scalar modes (Intel asm dialect)
 359 (define_mode_attr iptr
 360   [(V32QI "b") (V16HI "w") (V8SI "k") (V4DI "q")
 361    (V16QI "b") (V8HI "w") (V4SI "k") (V2DI "q")
 362    (V8SF "k") (V4DF "q")
 363    (V4SF "k") (V2DF "q")
 364    (SF "k") (DF "q")])
 365
 366 ;; Number of scalar elements in each vector type
 367 (define_mode_attr ssescalarnum
 368   [(V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")
 369    (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
 370    (V8SF "8") (V4DF "4")
 371    (V4SF "4") (V2DF "2")])
 372
 373 ;; Mask of scalar elements in each vector type
 374 (define_mode_attr ssescalarnummask
 375   [(V32QI "31") (V16HI "15") (V8SI "7") (V4DI "3")
 376    (V16QI "15") (V8HI "7") (V4SI "3") (V2DI "1")
 377    (V8SF "7") (V4DF "3")
 378    (V4SF "3") (V2DF "1")])
 379
 380 ;; SSE prefix for integer vector modes
 381 (define_mode_attr sseintprefix
 382   [(V2DI "p") (V2DF "")
 383    (V4DI "p") (V4DF "")
 384    (V4SI "p") (V4SF "")
 385    (V8SI "p") (V8SF "")])
 386
 387 ;; SSE scalar suffix for vector modes
 388 (define_mode_attr ssescalarmodesuffix
 389   [(SF "ss") (DF "sd")
 390    (V8SF "ss") (V4DF "sd")
 391    (V4SF "ss") (V2DF "sd")
 392    (V8SI "ss") (V4DI "sd")
 393    (V4SI "d")])
 394
 395 ;; Pack/unpack vector modes
 396 (define_mode_attr sseunpackmode
 397   [(V16QI "V8HI") (V8HI "V4SI") (V4SI "V2DI")
 398    (V32QI "V16HI") (V16HI "V8SI") (V8SI "V4DI")])
 399
 400 (define_mode_attr ssepackmode
 401   [(V8HI "V16QI") (V4SI "V8HI") (V2DI "V4SI")
 402    (V16HI "V32QI") (V8SI "V16HI") (V4DI "V8SI")])
 403
 404 ;; Mapping of the max integer size for xop rotate immediate constraint
 405 (define_mode_attr sserotatemax
 406   [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
 407
 408 ;; Mapping of mode to cast intrinsic name
 409 (define_mode_attr castmode [(V8SI "si") (V8SF "ps") (V4DF "pd")])
 410
 411 ;; Instruction suffix for sign and zero extensions.
 412 (define_code_attr extsuffix [(sign_extend "sx") (zero_extend "zx")])
 413
 414 ;; i128 for integer vectors and TARGET_AVX2, f128 otherwise.
 415 (define_mode_attr i128
 416   [(V8SF "f128") (V4DF "f128") (V32QI "%~128") (V16HI "%~128")
 417    (V8SI "%~128") (V4DI "%~128")])
 418
 419 ;; Mix-n-match
 420 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
 421
 422 ;; Mapping of immediate bits for blend instructions
 423 (define_mode_attr blendbits
 424   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 425
 426 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 427
 428 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 429 ;;
 430 ;; Move patterns
 431 ;;
 432 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 433
 434 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 435 ;; This is essential for maintaining stable calling conventions.
 436
 437 (define_expand "mov<mode>"
 438   [(set (match_operand:V16 0 "nonimmediate_operand")
 439         (match_operand:V16 1 "nonimmediate_operand"))]
 440   "TARGET_SSE"
 441 {
 442   ix86_expand_vector_move (<MODE>mode, operands);
 443   DONE;
 444 })
 445
 446 (define_insn "*mov<mode>_internal"
 447   [(set (match_operand:V16 0 "nonimmediate_operand"               "=x,x ,m")
 448         (match_operand:V16 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
 449   "TARGET_SSE
 450    && (register_operand (operands[0], <MODE>mode)
 451        || register_operand (operands[1], <MODE>mode))"
 452 {
 453   switch (which_alternative)
 454     {
 455     case 0:
 456       return standard_sse_constant_opcode (insn, operands[1]);
 457     case 1:
 458     case 2:
 459       switch (get_attr_mode (insn))
 460         {
 461         case MODE_V8SF:
 462         case MODE_V4SF:
 463           if (TARGET_AVX
 464               && (misaligned_operand (operands[0], <MODE>mode)
 465                   || misaligned_operand (operands[1], <MODE>mode)))
 466             return "vmovups\t{%1, %0|%0, %1}";
 467           else
 468             return "%vmovaps\t{%1, %0|%0, %1}";
 469
 470         case MODE_V4DF:
 471         case MODE_V2DF:
 472           if (TARGET_AVX
 473               && (misaligned_operand (operands[0], <MODE>mode)
 474                   || misaligned_operand (operands[1], <MODE>mode)))
 475             return "vmovupd\t{%1, %0|%0, %1}";
 476           else
 477             return "%vmovapd\t{%1, %0|%0, %1}";
 478
 479         case MODE_OI:
 480         case MODE_TI:
 481           if (TARGET_AVX
 482               && (misaligned_operand (operands[0], <MODE>mode)
 483                   || misaligned_operand (operands[1], <MODE>mode)))
 484             return "vmovdqu\t{%1, %0|%0, %1}";
 485           else
 486             return "%vmovdqa\t{%1, %0|%0, %1}";
 487
 488         default:
 489           gcc_unreachable ();
 490         }
 491     default:
 492       gcc_unreachable ();
 493     }
 494 }
 495   [(set_attr "type" "sselog1,ssemov,ssemov")
 496    (set_attr "prefix" "maybe_vex")
 497    (set (attr "mode")
 498         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 499                  (const_string "<ssePSmode>")
 500                (and (eq_attr "alternative" "2")
 501                     (match_test "TARGET_SSE_TYPELESS_STORES"))
 502                  (const_string "<ssePSmode>")
 503                (match_test "TARGET_AVX")
 504                  (const_string "<sseinsnmode>")
 505                (ior (not (match_test "TARGET_SSE2"))
 506                     (match_test "optimize_function_for_size_p (cfun)"))
 507                  (const_string "V4SF")
 508                (and (eq_attr "alternative" "0")
 509                     (match_test "TARGET_SSE_LOAD0_BY_PXOR"))
 510                  (const_string "TI")
 511               ]
 512               (const_string "<sseinsnmode>")))])
 513
 514 (define_insn "sse2_movq128"
 515   [(set (match_operand:V2DI 0 "register_operand" "=x")
 516         (vec_concat:V2DI
 517           (vec_select:DI
 518             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 519             (parallel [(const_int 0)]))
 520           (const_int 0)))]
 521   "TARGET_SSE2"
 522   "%vmovq\t{%1, %0|%0, %q1}"
 523   [(set_attr "type" "ssemov")
 524    (set_attr "prefix" "maybe_vex")
 525    (set_attr "mode" "TI")])
 526
 527 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 528 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 529 ;; from memory, we'd prefer to load the memory directly into the %xmm
 530 ;; register.  To facilitate this happy circumstance, this pattern won't
 531 ;; split until after register allocation.  If the 64-bit value didn't
 532 ;; come from memory, this is the best we can do.  This is much better
 533 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 534 ;; from there.
 535
 536 (define_insn_and_split "movdi_to_sse"
 537   [(parallel
 538     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 539           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 540      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 541   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC"
 542   "#"
 543   "&& reload_completed"
 544   [(const_int 0)]
 545 {
 546  if (register_operand (operands[1], DImode))
 547    {
 548       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 549          Assemble the 64-bit DImode value in an xmm register.  */
 550       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 551                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 552       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 553                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 554       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
 555                                              operands[2]));
 556     }
 557  else if (memory_operand (operands[1], DImode))
 558    emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]),
 559                                   operands[1], const0_rtx));
 560  else
 561    gcc_unreachable ();
 562 })
 563
 564 (define_split
 565   [(set (match_operand:V4SF 0 "register_operand")
 566         (match_operand:V4SF 1 "zero_extended_scalar_load_operand"))]
 567   "TARGET_SSE && reload_completed"
 568   [(set (match_dup 0)
 569         (vec_merge:V4SF
 570           (vec_duplicate:V4SF (match_dup 1))
 571           (match_dup 2)
 572           (const_int 1)))]
 573 {
 574   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 575   operands[2] = CONST0_RTX (V4SFmode);
 576 })
 577
 578 (define_split
 579   [(set (match_operand:V2DF 0 "register_operand")
 580         (match_operand:V2DF 1 "zero_extended_scalar_load_operand"))]
 581   "TARGET_SSE2 && reload_completed"
 582   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 583 {
 584   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 585   operands[2] = CONST0_RTX (DFmode);
 586 })
 587
 588 (define_expand "push<mode>1"
 589   [(match_operand:V16 0 "register_operand")]
 590   "TARGET_SSE"
 591 {
 592   ix86_expand_push (<MODE>mode, operands[0]);
 593   DONE;
 594 })
 595
 596 (define_expand "movmisalign<mode>"
 597   [(set (match_operand:V16 0 "nonimmediate_operand")
 598         (match_operand:V16 1 "nonimmediate_operand"))]
 599   "TARGET_SSE"
 600 {
 601   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 602   DONE;
 603 })
 604
 605 (define_insn "<sse>_loadu<ssemodesuffix><avxsizesuffix>"
 606   [(set (match_operand:VF 0 "register_operand" "=x")
 607         (unspec:VF
 608           [(match_operand:VF 1 "memory_operand" "m")]
 609           UNSPEC_LOADU))]
 610   "TARGET_SSE"
 611 {
 612   switch (get_attr_mode (insn))
 613     {
 614     case MODE_V8SF:
 615     case MODE_V4SF:
 616       return "%vmovups\t{%1, %0|%0, %1}";
 617     default:
 618       return "%vmovu<ssemodesuffix>\t{%1, %0|%0, %1}";
 619     }
 620 }
 621   [(set_attr "type" "ssemov")
 622    (set_attr "movu" "1")
 623    (set_attr "prefix" "maybe_vex")
 624    (set (attr "mode")
 625         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 626                  (const_string "<ssePSmode>")
 627                (match_test "TARGET_AVX")
 628                  (const_string "<MODE>")
 629                (match_test "optimize_function_for_size_p (cfun)")
 630                  (const_string "V4SF")
 631               ]
 632               (const_string "<MODE>")))])
 633
 634 (define_insn "<sse>_storeu<ssemodesuffix><avxsizesuffix>"
 635   [(set (match_operand:VF 0 "memory_operand" "=m")
 636         (unspec:VF
 637           [(match_operand:VF 1 "register_operand" "x")]
 638           UNSPEC_STOREU))]
 639   "TARGET_SSE"
 640 {
 641   switch (get_attr_mode (insn))
 642     {
 643     case MODE_V8SF:
 644     case MODE_V4SF:
 645       return "%vmovups\t{%1, %0|%0, %1}";
 646     default:
 647       return "%vmovu<ssemodesuffix>\t{%1, %0|%0, %1}";
 648     }
 649 }
 650   [(set_attr "type" "ssemov")
 651    (set_attr "movu" "1")
 652    (set_attr "prefix" "maybe_vex")
 653    (set (attr "mode")
 654         (cond [(ior (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 655                     (match_test "TARGET_SSE_TYPELESS_STORES"))
 656                  (const_string "<ssePSmode>")
 657                (match_test "TARGET_AVX")
 658                  (const_string "<MODE>")
 659                (match_test "optimize_function_for_size_p (cfun)")
 660                  (const_string "V4SF")
 661               ]
 662               (const_string "<MODE>")))])
 663
 664 (define_insn "<sse2>_loaddqu<avxsizesuffix>"
 665   [(set (match_operand:VI1 0 "register_operand" "=x")
 666         (unspec:VI1 [(match_operand:VI1 1 "memory_operand" "m")]
 667                     UNSPEC_LOADU))]
 668   "TARGET_SSE2"
 669 {
 670   switch (get_attr_mode (insn))
 671     {
 672     case MODE_V8SF:
 673     case MODE_V4SF:
 674       return "%vmovups\t{%1, %0|%0, %1}";
 675     default:
 676       return "%vmovdqu\t{%1, %0|%0, %1}";
 677     }
 678 }
 679   [(set_attr "type" "ssemov")
 680    (set_attr "movu" "1")
 681    (set (attr "prefix_data16")
 682      (if_then_else
 683        (match_test "TARGET_AVX")
 684      (const_string "*")
 685      (const_string "1")))
 686    (set_attr "prefix" "maybe_vex")
 687    (set (attr "mode")
 688         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 689                  (const_string "<ssePSmode>")
 690                (match_test "TARGET_AVX")
 691                  (const_string "<sseinsnmode>")
 692                (match_test "optimize_function_for_size_p (cfun)")
 693                  (const_string "V4SF")
 694               ]
 695               (const_string "<sseinsnmode>")))])
 696
 697 (define_insn "<sse2>_storedqu<avxsizesuffix>"
 698   [(set (match_operand:VI1 0 "memory_operand" "=m")
 699         (unspec:VI1 [(match_operand:VI1 1 "register_operand" "x")]
 700                     UNSPEC_STOREU))]
 701   "TARGET_SSE2"
 702 {
 703   switch (get_attr_mode (insn))
 704     {
 705     case MODE_V8SF:
 706     case MODE_V4SF:
 707       return "%vmovups\t{%1, %0|%0, %1}";
 708     default:
 709       return "%vmovdqu\t{%1, %0|%0, %1}";
 710     }
 711 }
 712   [(set_attr "type" "ssemov")
 713    (set_attr "movu" "1")
 714    (set (attr "prefix_data16")
 715      (if_then_else
 716        (match_test "TARGET_AVX")
 717      (const_string "*")
 718      (const_string "1")))
 719    (set_attr "prefix" "maybe_vex")
 720    (set (attr "mode")
 721         (cond [(ior (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 722                     (match_test "TARGET_SSE_TYPELESS_STORES"))
 723                  (const_string "<ssePSmode>")
 724                (match_test "TARGET_AVX")
 725                  (const_string "<sseinsnmode>")
 726                (match_test "optimize_function_for_size_p (cfun)")
 727                  (const_string "V4SF")
 728               ]
 729               (const_string "<sseinsnmode>")))])
 730
 731 (define_insn "<sse3>_lddqu<avxsizesuffix>"
 732   [(set (match_operand:VI1 0 "register_operand" "=x")
 733         (unspec:VI1 [(match_operand:VI1 1 "memory_operand" "m")]
 734                     UNSPEC_LDDQU))]
 735   "TARGET_SSE3"
 736   "%vlddqu\t{%1, %0|%0, %1}"
 737   [(set_attr "type" "ssemov")
 738    (set_attr "movu" "1")
 739    (set (attr "prefix_data16")
 740      (if_then_else
 741        (match_test "TARGET_AVX")
 742      (const_string "*")
 743      (const_string "0")))
 744    (set (attr "prefix_rep")
 745      (if_then_else
 746        (match_test "TARGET_AVX")
 747      (const_string "*")
 748      (const_string "1")))
 749    (set_attr "prefix" "maybe_vex")
 750    (set_attr "mode" "<sseinsnmode>")])
 751
 752 (define_insn "sse2_movnti<mode>"
 753   [(set (match_operand:SWI48 0 "memory_operand" "=m")
 754         (unspec:SWI48 [(match_operand:SWI48 1 "register_operand" "r")]
 755                       UNSPEC_MOVNT))]
 756   "TARGET_SSE2"
 757   "movnti\t{%1, %0|%0, %1}"
 758   [(set_attr "type" "ssemov")
 759    (set_attr "prefix_data16" "0")
 760    (set_attr "mode" "<MODE>")])
 761
 762 (define_insn "<sse>_movnt<mode>"
 763   [(set (match_operand:VF 0 "memory_operand" "=m")
 764         (unspec:VF [(match_operand:VF 1 "register_operand" "x")]
 765                    UNSPEC_MOVNT))]
 766   "TARGET_SSE"
 767   "%vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
 768   [(set_attr "type" "ssemov")
 769    (set_attr "prefix" "maybe_vex")
 770    (set_attr "mode" "<MODE>")])
 771
 772 (define_insn "<sse2>_movnt<mode>"
 773   [(set (match_operand:VI8 0 "memory_operand" "=m")
 774         (unspec:VI8 [(match_operand:VI8 1 "register_operand" "x")]
 775                     UNSPEC_MOVNT))]
 776   "TARGET_SSE2"
 777   "%vmovntdq\t{%1, %0|%0, %1}"
 778   [(set_attr "type" "ssecvt")
 779    (set (attr "prefix_data16")
 780      (if_then_else
 781        (match_test "TARGET_AVX")
 782      (const_string "*")
 783      (const_string "1")))
 784    (set_attr "prefix" "maybe_vex")
 785    (set_attr "mode" "<sseinsnmode>")])
 786
 787 ; Expand patterns for non-temporal stores.  At the moment, only those
 788 ; that directly map to insns are defined; it would be possible to
 789 ; define patterns for other modes that would expand to several insns.
 790
 791 ;; Modes handled by storent patterns.
 792 (define_mode_iterator STORENT_MODE
 793   [(DI "TARGET_SSE2 && TARGET_64BIT") (SI "TARGET_SSE2")
 794    (SF "TARGET_SSE4A") (DF "TARGET_SSE4A")
 795    (V4DI "TARGET_AVX") (V2DI "TARGET_SSE2")
 796    (V8SF "TARGET_AVX") V4SF
 797    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 798
 799 (define_expand "storent<mode>"
 800   [(set (match_operand:STORENT_MODE 0 "memory_operand")
 801         (unspec:STORENT_MODE
 802           [(match_operand:STORENT_MODE 1 "register_operand")]
 803           UNSPEC_MOVNT))]
 804   "TARGET_SSE")
 805
 806 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 807 ;;
 808 ;; Parallel floating point arithmetic
 809 ;;
 810 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 811
 812 (define_expand "<code><mode>2"
 813   [(set (match_operand:VF 0 "register_operand")
 814         (absneg:VF
 815           (match_operand:VF 1 "register_operand")))]
 816   "TARGET_SSE"
 817   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
 818
 819 (define_insn_and_split "*absneg<mode>2"
 820   [(set (match_operand:VF 0 "register_operand" "=x,x,x,x")
 821         (match_operator:VF 3 "absneg_operator"
 822           [(match_operand:VF 1 "nonimmediate_operand" "0, xm,x, m")]))
 823    (use (match_operand:VF 2 "nonimmediate_operand"    "xm,0, xm,x"))]
 824   "TARGET_SSE"
 825   "#"
 826   "&& reload_completed"
 827   [(const_int 0)]
 828 {
 829   enum rtx_code absneg_op;
 830   rtx op1, op2;
 831   rtx t;
 832
 833   if (TARGET_AVX)
 834     {
 835       if (MEM_P (operands[1]))
 836         op1 = operands[2], op2 = operands[1];
 837       else
 838         op1 = operands[1], op2 = operands[2];
 839     }
 840   else
 841     {
 842       op1 = operands[0];
 843       if (rtx_equal_p (operands[0], operands[1]))
 844         op2 = operands[2];
 845       else
 846         op2 = operands[1];
 847     }
 848
 849   absneg_op = GET_CODE (operands[3]) == NEG ? XOR : AND;
 850   t = gen_rtx_fmt_ee (absneg_op, <MODE>mode, op1, op2);
 851   t = gen_rtx_SET (VOIDmode, operands[0], t);
 852   emit_insn (t);
 853   DONE;
 854 }
 855   [(set_attr "isa" "noavx,noavx,avx,avx")])
 856
 857 (define_expand "<plusminus_insn><mode>3"
 858   [(set (match_operand:VF 0 "register_operand")
 859         (plusminus:VF
 860           (match_operand:VF 1 "nonimmediate_operand")
 861           (match_operand:VF 2 "nonimmediate_operand")))]
 862   "TARGET_SSE"
 863   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
 864
 865 (define_insn "*<plusminus_insn><mode>3"
 866   [(set (match_operand:VF 0 "register_operand" "=x,x")
 867         (plusminus:VF
 868           (match_operand:VF 1 "nonimmediate_operand" "<comm>0,x")
 869           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
 870   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
 871   "@
 872    <plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
 873    v<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 874   [(set_attr "isa" "noavx,avx")
 875    (set_attr "type" "sseadd")
 876    (set_attr "prefix" "orig,vex")
 877    (set_attr "mode" "<MODE>")])
 878
 879 (define_insn "<sse>_vm<plusminus_insn><mode>3"
 880   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
 881         (vec_merge:VF_128
 882           (plusminus:VF_128
 883             (match_operand:VF_128 1 "register_operand" "0,x")
 884             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
 885           (match_dup 1)
 886           (const_int 1)))]
 887   "TARGET_SSE"
 888   "@
 889    <plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
 890    v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
 891   [(set_attr "isa" "noavx,avx")
 892    (set_attr "type" "sseadd")
 893    (set_attr "prefix" "orig,vex")
 894    (set_attr "mode" "<ssescalarmode>")])
 895
 896 (define_expand "mul<mode>3"
 897   [(set (match_operand:VF 0 "register_operand")
 898         (mult:VF
 899           (match_operand:VF 1 "nonimmediate_operand")
 900           (match_operand:VF 2 "nonimmediate_operand")))]
 901   "TARGET_SSE"
 902   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
 903
 904 (define_insn "*mul<mode>3"
 905   [(set (match_operand:VF 0 "register_operand" "=x,x")
 906         (mult:VF
 907           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
 908           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
 909   "TARGET_SSE && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
 910   "@
 911    mul<ssemodesuffix>\t{%2, %0|%0, %2}
 912    vmul<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 913   [(set_attr "isa" "noavx,avx")
 914    (set_attr "type" "ssemul")
 915    (set_attr "prefix" "orig,vex")
 916    (set_attr "btver2_decode" "direct,double")
 917    (set_attr "mode" "<MODE>")])
 918
 919 (define_insn "<sse>_vmmul<mode>3"
 920   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
 921         (vec_merge:VF_128
 922           (mult:VF_128
 923             (match_operand:VF_128 1 "register_operand" "0,x")
 924             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
 925           (match_dup 1)
 926           (const_int 1)))]
 927   "TARGET_SSE"
 928   "@
 929    mul<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
 930    vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
 931   [(set_attr "isa" "noavx,avx")
 932    (set_attr "type" "ssemul")
 933    (set_attr "prefix" "orig,vex")
 934    (set_attr "mode" "<ssescalarmode>")])
 935
 936 (define_expand "div<mode>3"
 937   [(set (match_operand:VF2 0 "register_operand")
 938         (div:VF2 (match_operand:VF2 1 "register_operand")
 939                  (match_operand:VF2 2 "nonimmediate_operand")))]
 940   "TARGET_SSE2"
 941   "ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);")
 942
 943 (define_expand "div<mode>3"
 944   [(set (match_operand:VF1 0 "register_operand")
 945         (div:VF1 (match_operand:VF1 1 "register_operand")
 946                  (match_operand:VF1 2 "nonimmediate_operand")))]
 947   "TARGET_SSE"
 948 {
 949   ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);
 950
 951   if (TARGET_SSE_MATH
 952       && TARGET_RECIP_VEC_DIV
 953       && !optimize_insn_for_size_p ()
 954       && flag_finite_math_only && !flag_trapping_math
 955       && flag_unsafe_math_optimizations)
 956     {
 957       ix86_emit_swdivsf (operands[0], operands[1], operands[2], <MODE>mode);
 958       DONE;
 959     }
 960 })
 961
 962 (define_insn "<sse>_div<mode>3"
 963   [(set (match_operand:VF 0 "register_operand" "=x,x")
 964         (div:VF
 965           (match_operand:VF 1 "register_operand" "0,x")
 966           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
 967   "TARGET_SSE"
 968   "@
 969    div<ssemodesuffix>\t{%2, %0|%0, %2}
 970    vdiv<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
 971   [(set_attr "isa" "noavx,avx")
 972    (set_attr "type" "ssediv")
 973    (set_attr "prefix" "orig,vex")
 974    (set_attr "mode" "<MODE>")])
 975
 976 (define_insn "<sse>_vmdiv<mode>3"
 977   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
 978         (vec_merge:VF_128
 979           (div:VF_128
 980             (match_operand:VF_128 1 "register_operand" "0,x")
 981             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
 982           (match_dup 1)
 983           (const_int 1)))]
 984   "TARGET_SSE"
 985   "@
 986    div<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
 987    vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
 988   [(set_attr "isa" "noavx,avx")
 989    (set_attr "type" "ssediv")
 990    (set_attr "prefix" "orig,vex")
 991    (set_attr "btver2_decode" "direct,double")
 992    (set_attr "mode" "<ssescalarmode>")])
 993
 994 (define_insn "<sse>_rcp<mode>2"
 995   [(set (match_operand:VF1 0 "register_operand" "=x")
 996         (unspec:VF1
 997           [(match_operand:VF1 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 998   "TARGET_SSE"
 999   "%vrcpps\t{%1, %0|%0, %1}"
1000   [(set_attr "type" "sse")
1001    (set_attr "atom_sse_attr" "rcp")
1002    (set_attr "btver2_sse_attr" "rcp")
1003    (set_attr "prefix" "maybe_vex")
1004    (set_attr "mode" "<MODE>")])
1005
1006 (define_insn "sse_vmrcpv4sf2"
1007   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1008         (vec_merge:V4SF
1009           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
1010                        UNSPEC_RCP)
1011           (match_operand:V4SF 2 "register_operand" "0,x")
1012           (const_int 1)))]
1013   "TARGET_SSE"
1014   "@
1015    rcpss\t{%1, %0|%0, %k1}
1016    vrcpss\t{%1, %2, %0|%0, %2, %k1}"
1017   [(set_attr "isa" "noavx,avx")
1018    (set_attr "type" "sse")
1019    (set_attr "atom_sse_attr" "rcp")
1020    (set_attr "btver2_sse_attr" "rcp")
1021    (set_attr "prefix" "orig,vex")
1022    (set_attr "mode" "SF")])
1023
1024 (define_expand "sqrt<mode>2"
1025   [(set (match_operand:VF2 0 "register_operand")
1026         (sqrt:VF2 (match_operand:VF2 1 "nonimmediate_operand")))]
1027   "TARGET_SSE2")
1028
1029 (define_expand "sqrt<mode>2"
1030   [(set (match_operand:VF1 0 "register_operand")
1031         (sqrt:VF1 (match_operand:VF1 1 "nonimmediate_operand")))]
1032   "TARGET_SSE"
1033 {
1034   if (TARGET_SSE_MATH
1035       && TARGET_RECIP_VEC_SQRT
1036       && !optimize_insn_for_size_p ()
1037       && flag_finite_math_only && !flag_trapping_math
1038       && flag_unsafe_math_optimizations)
1039     {
1040       ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, false);
1041       DONE;
1042     }
1043 })
1044
1045 (define_insn "<sse>_sqrt<mode>2"
1046   [(set (match_operand:VF 0 "register_operand" "=x")
1047         (sqrt:VF (match_operand:VF 1 "nonimmediate_operand" "xm")))]
1048   "TARGET_SSE"
1049   "%vsqrt<ssemodesuffix>\t{%1, %0|%0, %1}"
1050   [(set_attr "type" "sse")
1051    (set_attr "atom_sse_attr" "sqrt")
1052    (set_attr "btver2_sse_attr" "sqrt")
1053    (set_attr "prefix" "maybe_vex")
1054    (set_attr "mode" "<MODE>")])
1055
1056 (define_insn "<sse>_vmsqrt<mode>2"
1057   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1058         (vec_merge:VF_128
1059           (sqrt:VF_128
1060             (match_operand:VF_128 1 "nonimmediate_operand" "xm,xm"))
1061           (match_operand:VF_128 2 "register_operand" "0,x")
1062           (const_int 1)))]
1063   "TARGET_SSE"
1064   "@
1065    sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}
1066    vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %<iptr>1}"
1067   [(set_attr "isa" "noavx,avx")
1068    (set_attr "type" "sse")
1069    (set_attr "atom_sse_attr" "sqrt")
1070    (set_attr "btver2_sse_attr" "sqrt")
1071    (set_attr "prefix" "orig,vex")
1072    (set_attr "mode" "<ssescalarmode>")])
1073
1074 (define_expand "rsqrt<mode>2"
1075   [(set (match_operand:VF1 0 "register_operand")
1076         (unspec:VF1
1077           [(match_operand:VF1 1 "nonimmediate_operand")] UNSPEC_RSQRT))]
1078   "TARGET_SSE_MATH"
1079 {
1080   ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, true);
1081   DONE;
1082 })
1083
1084 (define_insn "<sse>_rsqrt<mode>2"
1085   [(set (match_operand:VF1 0 "register_operand" "=x")
1086         (unspec:VF1
1087           [(match_operand:VF1 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
1088   "TARGET_SSE"
1089   "%vrsqrtps\t{%1, %0|%0, %1}"
1090   [(set_attr "type" "sse")
1091    (set_attr "prefix" "maybe_vex")
1092    (set_attr "mode" "<MODE>")])
1093
1094 (define_insn "sse_vmrsqrtv4sf2"
1095   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1096         (vec_merge:V4SF
1097           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
1098                        UNSPEC_RSQRT)
1099           (match_operand:V4SF 2 "register_operand" "0,x")
1100           (const_int 1)))]
1101   "TARGET_SSE"
1102   "@
1103    rsqrtss\t{%1, %0|%0, %k1}
1104    vrsqrtss\t{%1, %2, %0|%0, %2, %k1}"
1105   [(set_attr "isa" "noavx,avx")
1106    (set_attr "type" "sse")
1107    (set_attr "prefix" "orig,vex")
1108    (set_attr "mode" "SF")])
1109
1110 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
1111 ;; isn't really correct, as those rtl operators aren't defined when
1112 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
1113
1114 (define_expand "<code><mode>3"
1115   [(set (match_operand:VF 0 "register_operand")
1116         (smaxmin:VF
1117           (match_operand:VF 1 "nonimmediate_operand")
1118           (match_operand:VF 2 "nonimmediate_operand")))]
1119   "TARGET_SSE"
1120 {
1121   if (!flag_finite_math_only)
1122     operands[1] = force_reg (<MODE>mode, operands[1]);
1123   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1124 })
1125
1126 (define_insn "*<code><mode>3_finite"
1127   [(set (match_operand:VF 0 "register_operand" "=x,x")
1128         (smaxmin:VF
1129           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
1130           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1131   "TARGET_SSE && flag_finite_math_only
1132    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1133   "@
1134    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1135    v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1136   [(set_attr "isa" "noavx,avx")
1137    (set_attr "type" "sseadd")
1138    (set_attr "btver2_sse_attr" "maxmin")
1139    (set_attr "prefix" "orig,vex")
1140    (set_attr "mode" "<MODE>")])
1141
1142 (define_insn "*<code><mode>3"
1143   [(set (match_operand:VF 0 "register_operand" "=x,x")
1144         (smaxmin:VF
1145           (match_operand:VF 1 "register_operand" "0,x")
1146           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1147   "TARGET_SSE && !flag_finite_math_only"
1148   "@
1149    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1150    v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1151   [(set_attr "isa" "noavx,avx")
1152    (set_attr "type" "sseadd")
1153    (set_attr "btver2_sse_attr" "maxmin")
1154    (set_attr "prefix" "orig,vex")
1155    (set_attr "mode" "<MODE>")])
1156
1157 (define_insn "<sse>_vm<code><mode>3"
1158   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1159         (vec_merge:VF_128
1160           (smaxmin:VF_128
1161             (match_operand:VF_128 1 "register_operand" "0,x")
1162             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm"))
1163          (match_dup 1)
1164          (const_int 1)))]
1165   "TARGET_SSE"
1166   "@
1167    <maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
1168    v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
1169   [(set_attr "isa" "noavx,avx")
1170    (set_attr "type" "sse")
1171    (set_attr "btver2_sse_attr" "maxmin")
1172    (set_attr "prefix" "orig,vex")
1173    (set_attr "mode" "<ssescalarmode>")])
1174
1175 ;; These versions of the min/max patterns implement exactly the operations
1176 ;;   min = (op1 < op2 ? op1 : op2)
1177 ;;   max = (!(op1 < op2) ? op1 : op2)
1178 ;; Their operands are not commutative, and thus they may be used in the
1179 ;; presence of -0.0 and NaN.
1180
1181 (define_insn "*ieee_smin<mode>3"
1182   [(set (match_operand:VF 0 "register_operand" "=x,x")
1183         (unspec:VF
1184           [(match_operand:VF 1 "register_operand" "0,x")
1185            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]
1186          UNSPEC_IEEE_MIN))]
1187   "TARGET_SSE"
1188   "@
1189    min<ssemodesuffix>\t{%2, %0|%0, %2}
1190    vmin<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1191   [(set_attr "isa" "noavx,avx")
1192    (set_attr "type" "sseadd")
1193    (set_attr "prefix" "orig,vex")
1194    (set_attr "mode" "<MODE>")])
1195
1196 (define_insn "*ieee_smax<mode>3"
1197   [(set (match_operand:VF 0 "register_operand" "=x,x")
1198         (unspec:VF
1199           [(match_operand:VF 1 "register_operand" "0,x")
1200            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]
1201          UNSPEC_IEEE_MAX))]
1202   "TARGET_SSE"
1203   "@
1204    max<ssemodesuffix>\t{%2, %0|%0, %2}
1205    vmax<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1206   [(set_attr "isa" "noavx,avx")
1207    (set_attr "type" "sseadd")
1208    (set_attr "prefix" "orig,vex")
1209    (set_attr "mode" "<MODE>")])
1210
1211 (define_insn "avx_addsubv4df3"
1212   [(set (match_operand:V4DF 0 "register_operand" "=x")
1213         (vec_merge:V4DF
1214           (plus:V4DF
1215             (match_operand:V4DF 1 "register_operand" "x")
1216             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1217           (minus:V4DF (match_dup 1) (match_dup 2))
1218           (const_int 10)))]
1219   "TARGET_AVX"
1220   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1221   [(set_attr "type" "sseadd")
1222    (set_attr "prefix" "vex")
1223    (set_attr "mode" "V4DF")])
1224
1225 (define_insn "sse3_addsubv2df3"
1226   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1227         (vec_merge:V2DF
1228           (plus:V2DF
1229             (match_operand:V2DF 1 "register_operand" "0,x")
1230             (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm"))
1231           (minus:V2DF (match_dup 1) (match_dup 2))
1232           (const_int 2)))]
1233   "TARGET_SSE3"
1234   "@
1235    addsubpd\t{%2, %0|%0, %2}
1236    vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1237   [(set_attr "isa" "noavx,avx")
1238    (set_attr "type" "sseadd")
1239    (set_attr "atom_unit" "complex")
1240    (set_attr "prefix" "orig,vex")
1241    (set_attr "mode" "V2DF")])
1242
1243 (define_insn "avx_addsubv8sf3"
1244   [(set (match_operand:V8SF 0 "register_operand" "=x")
1245         (vec_merge:V8SF
1246           (plus:V8SF
1247             (match_operand:V8SF 1 "register_operand" "x")
1248             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1249           (minus:V8SF (match_dup 1) (match_dup 2))
1250           (const_int 170)))]
1251   "TARGET_AVX"
1252   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1253   [(set_attr "type" "sseadd")
1254    (set_attr "prefix" "vex")
1255    (set_attr "mode" "V8SF")])
1256
1257 (define_insn "sse3_addsubv4sf3"
1258   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1259         (vec_merge:V4SF
1260           (plus:V4SF
1261             (match_operand:V4SF 1 "register_operand" "0,x")
1262             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
1263           (minus:V4SF (match_dup 1) (match_dup 2))
1264           (const_int 10)))]
1265   "TARGET_SSE3"
1266   "@
1267    addsubps\t{%2, %0|%0, %2}
1268    vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1269   [(set_attr "isa" "noavx,avx")
1270    (set_attr "type" "sseadd")
1271    (set_attr "prefix" "orig,vex")
1272    (set_attr "prefix_rep" "1,*")
1273    (set_attr "mode" "V4SF")])
1274
1275 (define_insn "avx_h<plusminus_insn>v4df3"
1276   [(set (match_operand:V4DF 0 "register_operand" "=x")
1277         (vec_concat:V4DF
1278           (vec_concat:V2DF
1279             (plusminus:DF
1280               (vec_select:DF
1281                 (match_operand:V4DF 1 "register_operand" "x")
1282                 (parallel [(const_int 0)]))
1283               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1284             (plusminus:DF
1285               (vec_select:DF
1286                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1287                 (parallel [(const_int 0)]))
1288               (vec_select:DF (match_dup 2) (parallel [(const_int 1)]))))
1289           (vec_concat:V2DF
1290             (plusminus:DF
1291               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1292               (vec_select:DF (match_dup 1) (parallel [(const_int 3)])))
1293             (plusminus:DF
1294               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1295               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1296   "TARGET_AVX"
1297   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1298   [(set_attr "type" "sseadd")
1299    (set_attr "prefix" "vex")
1300    (set_attr "mode" "V4DF")])
1301
1302 (define_expand "sse3_haddv2df3"
1303   [(set (match_operand:V2DF 0 "register_operand")
1304         (vec_concat:V2DF
1305           (plus:DF
1306             (vec_select:DF
1307               (match_operand:V2DF 1 "register_operand")
1308               (parallel [(const_int 0)]))
1309             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1310           (plus:DF
1311             (vec_select:DF
1312               (match_operand:V2DF 2 "nonimmediate_operand")
1313               (parallel [(const_int 0)]))
1314             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1315   "TARGET_SSE3")
1316
1317 (define_insn "*sse3_haddv2df3"
1318   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1319         (vec_concat:V2DF
1320           (plus:DF
1321             (vec_select:DF
1322               (match_operand:V2DF 1 "register_operand" "0,x")
1323               (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))
1324             (vec_select:DF
1325               (match_dup 1)
1326               (parallel [(match_operand:SI 4 "const_0_to_1_operand")])))
1327           (plus:DF
1328             (vec_select:DF
1329               (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm")
1330               (parallel [(match_operand:SI 5 "const_0_to_1_operand")]))
1331             (vec_select:DF
1332               (match_dup 2)
1333               (parallel [(match_operand:SI 6 "const_0_to_1_operand")])))))]
1334   "TARGET_SSE3
1335    && INTVAL (operands[3]) != INTVAL (operands[4])
1336    && INTVAL (operands[5]) != INTVAL (operands[6])"
1337   "@
1338    haddpd\t{%2, %0|%0, %2}
1339    vhaddpd\t{%2, %1, %0|%0, %1, %2}"
1340   [(set_attr "isa" "noavx,avx")
1341    (set_attr "type" "sseadd")
1342    (set_attr "prefix" "orig,vex")
1343    (set_attr "mode" "V2DF")])
1344
1345 (define_insn "sse3_hsubv2df3"
1346   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1347         (vec_concat:V2DF
1348           (minus:DF
1349             (vec_select:DF
1350               (match_operand:V2DF 1 "register_operand" "0,x")
1351               (parallel [(const_int 0)]))
1352             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1353           (minus:DF
1354             (vec_select:DF
1355               (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm")
1356               (parallel [(const_int 0)]))
1357             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1358   "TARGET_SSE3"
1359   "@
1360    hsubpd\t{%2, %0|%0, %2}
1361    vhsubpd\t{%2, %1, %0|%0, %1, %2}"
1362   [(set_attr "isa" "noavx,avx")
1363    (set_attr "type" "sseadd")
1364    (set_attr "prefix" "orig,vex")
1365    (set_attr "mode" "V2DF")])
1366
1367 (define_insn "*sse3_haddv2df3_low"
1368   [(set (match_operand:DF 0 "register_operand" "=x,x")
1369         (plus:DF
1370           (vec_select:DF
1371             (match_operand:V2DF 1 "register_operand" "0,x")
1372             (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))
1373           (vec_select:DF
1374             (match_dup 1)
1375             (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))))]
1376   "TARGET_SSE3
1377    && INTVAL (operands[2]) != INTVAL (operands[3])"
1378   "@
1379    haddpd\t{%0, %0|%0, %0}
1380    vhaddpd\t{%1, %1, %0|%0, %1, %1}"
1381   [(set_attr "isa" "noavx,avx")
1382    (set_attr "type" "sseadd1")
1383    (set_attr "prefix" "orig,vex")
1384    (set_attr "mode" "V2DF")])
1385
1386 (define_insn "*sse3_hsubv2df3_low"
1387   [(set (match_operand:DF 0 "register_operand" "=x,x")
1388         (minus:DF
1389           (vec_select:DF
1390             (match_operand:V2DF 1 "register_operand" "0,x")
1391             (parallel [(const_int 0)]))
1392           (vec_select:DF
1393             (match_dup 1)
1394             (parallel [(const_int 1)]))))]
1395   "TARGET_SSE3"
1396   "@
1397    hsubpd\t{%0, %0|%0, %0}
1398    vhsubpd\t{%1, %1, %0|%0, %1, %1}"
1399   [(set_attr "isa" "noavx,avx")
1400    (set_attr "type" "sseadd1")
1401    (set_attr "prefix" "orig,vex")
1402    (set_attr "mode" "V2DF")])
1403
1404 (define_insn "avx_h<plusminus_insn>v8sf3"
1405   [(set (match_operand:V8SF 0 "register_operand" "=x")
1406         (vec_concat:V8SF
1407           (vec_concat:V4SF
1408             (vec_concat:V2SF
1409               (plusminus:SF
1410                 (vec_select:SF
1411                   (match_operand:V8SF 1 "register_operand" "x")
1412                   (parallel [(const_int 0)]))
1413                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1414               (plusminus:SF
1415                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1416                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1417             (vec_concat:V2SF
1418               (plusminus:SF
1419                 (vec_select:SF
1420                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1421                   (parallel [(const_int 0)]))
1422                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1423               (plusminus:SF
1424                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1425                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1426           (vec_concat:V4SF
1427             (vec_concat:V2SF
1428               (plusminus:SF
1429                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1430                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1431               (plusminus:SF
1432                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1433                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1434             (vec_concat:V2SF
1435               (plusminus:SF
1436                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1437                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1438               (plusminus:SF
1439                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1440                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1441   "TARGET_AVX"
1442   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1443   [(set_attr "type" "sseadd")
1444    (set_attr "prefix" "vex")
1445    (set_attr "mode" "V8SF")])
1446
1447 (define_insn "sse3_h<plusminus_insn>v4sf3"
1448   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1449         (vec_concat:V4SF
1450           (vec_concat:V2SF
1451             (plusminus:SF
1452               (vec_select:SF
1453                 (match_operand:V4SF 1 "register_operand" "0,x")
1454                 (parallel [(const_int 0)]))
1455               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1456             (plusminus:SF
1457               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1458               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1459           (vec_concat:V2SF
1460             (plusminus:SF
1461               (vec_select:SF
1462                 (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
1463                 (parallel [(const_int 0)]))
1464               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1465             (plusminus:SF
1466               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1467               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1468   "TARGET_SSE3"
1469   "@
1470    h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}
1471    vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1472   [(set_attr "isa" "noavx,avx")
1473    (set_attr "type" "sseadd")
1474    (set_attr "atom_unit" "complex")
1475    (set_attr "prefix" "orig,vex")
1476    (set_attr "prefix_rep" "1,*")
1477    (set_attr "mode" "V4SF")])
1478
1479 (define_expand "reduc_splus_v4df"
1480   [(match_operand:V4DF 0 "register_operand")
1481    (match_operand:V4DF 1 "register_operand")]
1482   "TARGET_AVX"
1483 {
1484   rtx tmp = gen_reg_rtx (V4DFmode);
1485   rtx tmp2 = gen_reg_rtx (V4DFmode);
1486   emit_insn (gen_avx_haddv4df3 (tmp, operands[1], operands[1]));
1487   emit_insn (gen_avx_vperm2f128v4df3 (tmp2, tmp, tmp, GEN_INT (1)));
1488   emit_insn (gen_addv4df3 (operands[0], tmp, tmp2));
1489   DONE;
1490 })
1491
1492 (define_expand "reduc_splus_v2df"
1493   [(match_operand:V2DF 0 "register_operand")
1494    (match_operand:V2DF 1 "register_operand")]
1495   "TARGET_SSE3"
1496 {
1497   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1498   DONE;
1499 })
1500
1501 (define_expand "reduc_splus_v8sf"
1502   [(match_operand:V8SF 0 "register_operand")
1503    (match_operand:V8SF 1 "register_operand")]
1504   "TARGET_AVX"
1505 {
1506   rtx tmp = gen_reg_rtx (V8SFmode);
1507   rtx tmp2 = gen_reg_rtx (V8SFmode);
1508   emit_insn (gen_avx_haddv8sf3 (tmp, operands[1], operands[1]));
1509   emit_insn (gen_avx_haddv8sf3 (tmp2, tmp, tmp));
1510   emit_insn (gen_avx_vperm2f128v8sf3 (tmp, tmp2, tmp2, GEN_INT (1)));
1511   emit_insn (gen_addv8sf3 (operands[0], tmp, tmp2));
1512   DONE;
1513 })
1514
1515 (define_expand "reduc_splus_v4sf"
1516   [(match_operand:V4SF 0 "register_operand")
1517    (match_operand:V4SF 1 "register_operand")]
1518   "TARGET_SSE"
1519 {
1520   if (TARGET_SSE3)
1521     {
1522       rtx tmp = gen_reg_rtx (V4SFmode);
1523       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
1524       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
1525     }
1526   else
1527     ix86_expand_reduc (gen_addv4sf3, operands[0], operands[1]);
1528   DONE;
1529 })
1530
1531 ;; Modes handled by reduc_sm{in,ax}* patterns.
1532 (define_mode_iterator REDUC_SMINMAX_MODE
1533   [(V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
1534    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
1535    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
1536    (V4SF "TARGET_SSE")])
1537
1538 (define_expand "reduc_<code>_<mode>"
1539   [(smaxmin:REDUC_SMINMAX_MODE
1540      (match_operand:REDUC_SMINMAX_MODE 0 "register_operand")
1541      (match_operand:REDUC_SMINMAX_MODE 1 "register_operand"))]
1542   ""
1543 {
1544   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
1545   DONE;
1546 })
1547
1548 (define_expand "reduc_<code>_<mode>"
1549   [(umaxmin:VI_256
1550      (match_operand:VI_256 0 "register_operand")
1551      (match_operand:VI_256 1 "register_operand"))]
1552   "TARGET_AVX2"
1553 {
1554   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
1555   DONE;
1556 })
1557
1558 (define_expand "reduc_umin_v8hi"
1559   [(umin:V8HI
1560      (match_operand:V8HI 0 "register_operand")
1561      (match_operand:V8HI 1 "register_operand"))]
1562   "TARGET_SSE4_1"
1563 {
1564   ix86_expand_reduc (gen_uminv8hi3, operands[0], operands[1]);
1565   DONE;
1566 })
1567
1568 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1569 ;;
1570 ;; Parallel floating point comparisons
1571 ;;
1572 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1573
1574 (define_insn "avx_cmp<mode>3"
1575   [(set (match_operand:VF 0 "register_operand" "=x")
1576         (unspec:VF
1577           [(match_operand:VF 1 "register_operand" "x")
1578            (match_operand:VF 2 "nonimmediate_operand" "xm")
1579            (match_operand:SI 3 "const_0_to_31_operand" "n")]
1580           UNSPEC_PCMP))]
1581   "TARGET_AVX"
1582   "vcmp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1583   [(set_attr "type" "ssecmp")
1584    (set_attr "length_immediate" "1")
1585    (set_attr "prefix" "vex")
1586    (set_attr "mode" "<MODE>")])
1587
1588 (define_insn "avx_vmcmp<mode>3"
1589   [(set (match_operand:VF_128 0 "register_operand" "=x")
1590         (vec_merge:VF_128
1591           (unspec:VF_128
1592             [(match_operand:VF_128 1 "register_operand" "x")
1593              (match_operand:VF_128 2 "nonimmediate_operand" "xm")
1594              (match_operand:SI 3 "const_0_to_31_operand" "n")]
1595             UNSPEC_PCMP)
1596          (match_dup 1)
1597          (const_int 1)))]
1598   "TARGET_AVX"
1599   "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %3}"
1600   [(set_attr "type" "ssecmp")
1601    (set_attr "length_immediate" "1")
1602    (set_attr "prefix" "vex")
1603    (set_attr "mode" "<ssescalarmode>")])
1604
1605 (define_insn "*<sse>_maskcmp<mode>3_comm"
1606   [(set (match_operand:VF 0 "register_operand" "=x,x")
1607         (match_operator:VF 3 "sse_comparison_operator"
1608           [(match_operand:VF 1 "register_operand" "%0,x")
1609            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]))]
1610   "TARGET_SSE
1611    && GET_RTX_CLASS (GET_CODE (operands[3])) == RTX_COMM_COMPARE"
1612   "@
1613    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
1614    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1615   [(set_attr "isa" "noavx,avx")
1616    (set_attr "type" "ssecmp")
1617    (set_attr "length_immediate" "1")
1618    (set_attr "prefix" "orig,vex")
1619    (set_attr "mode" "<MODE>")])
1620
1621 (define_insn "<sse>_maskcmp<mode>3"
1622   [(set (match_operand:VF 0 "register_operand" "=x,x")
1623         (match_operator:VF 3 "sse_comparison_operator"
1624           [(match_operand:VF 1 "register_operand" "0,x")
1625            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")]))]
1626   "TARGET_SSE"
1627   "@
1628    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
1629    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1630   [(set_attr "isa" "noavx,avx")
1631    (set_attr "type" "ssecmp")
1632    (set_attr "length_immediate" "1")
1633    (set_attr "prefix" "orig,vex")
1634    (set_attr "mode" "<MODE>")])
1635
1636 (define_insn "<sse>_vmmaskcmp<mode>3"
1637   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
1638         (vec_merge:VF_128
1639          (match_operator:VF_128 3 "sse_comparison_operator"
1640            [(match_operand:VF_128 1 "register_operand" "0,x")
1641             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm")])
1642          (match_dup 1)
1643          (const_int 1)))]
1644   "TARGET_SSE"
1645   "@
1646    cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
1647    vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
1648   [(set_attr "isa" "noavx,avx")
1649    (set_attr "type" "ssecmp")
1650    (set_attr "length_immediate" "1,*")
1651    (set_attr "prefix" "orig,vex")
1652    (set_attr "mode" "<ssescalarmode>")])
1653
1654 (define_insn "<sse>_comi"
1655   [(set (reg:CCFP FLAGS_REG)
1656         (compare:CCFP
1657           (vec_select:MODEF
1658             (match_operand:<ssevecmode> 0 "register_operand" "x")
1659             (parallel [(const_int 0)]))
1660           (vec_select:MODEF
1661             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1662             (parallel [(const_int 0)]))))]
1663   "SSE_FLOAT_MODE_P (<MODE>mode)"
1664   "%vcomi<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}"
1665   [(set_attr "type" "ssecomi")
1666    (set_attr "prefix" "maybe_vex")
1667    (set_attr "prefix_rep" "0")
1668    (set (attr "prefix_data16")
1669         (if_then_else (eq_attr "mode" "DF")
1670                       (const_string "1")
1671                       (const_string "0")))
1672    (set_attr "mode" "<MODE>")])
1673
1674 (define_insn "<sse>_ucomi"
1675   [(set (reg:CCFPU FLAGS_REG)
1676         (compare:CCFPU
1677           (vec_select:MODEF
1678             (match_operand:<ssevecmode> 0 "register_operand" "x")
1679             (parallel [(const_int 0)]))
1680           (vec_select:MODEF
1681             (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm")
1682             (parallel [(const_int 0)]))))]
1683   "SSE_FLOAT_MODE_P (<MODE>mode)"
1684   "%vucomi<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}"
1685   [(set_attr "type" "ssecomi")
1686    (set_attr "prefix" "maybe_vex")
1687    (set_attr "prefix_rep" "0")
1688    (set (attr "prefix_data16")
1689         (if_then_else (eq_attr "mode" "DF")
1690                       (const_string "1")
1691                       (const_string "0")))
1692    (set_attr "mode" "<MODE>")])
1693
1694 (define_expand "vcond<V_256:mode><VF_256:mode>"
1695   [(set (match_operand:V_256 0 "register_operand")
1696         (if_then_else:V_256
1697           (match_operator 3 ""
1698             [(match_operand:VF_256 4 "nonimmediate_operand")
1699              (match_operand:VF_256 5 "nonimmediate_operand")])
1700           (match_operand:V_256 1 "general_operand")
1701           (match_operand:V_256 2 "general_operand")))]
1702   "TARGET_AVX
1703    && (GET_MODE_NUNITS (<V_256:MODE>mode)
1704        == GET_MODE_NUNITS (<VF_256:MODE>mode))"
1705 {
1706   bool ok = ix86_expand_fp_vcond (operands);
1707   gcc_assert (ok);
1708   DONE;
1709 })
1710
1711 (define_expand "vcond<V_128:mode><VF_128:mode>"
1712   [(set (match_operand:V_128 0 "register_operand")
1713         (if_then_else:V_128
1714           (match_operator 3 ""
1715             [(match_operand:VF_128 4 "nonimmediate_operand")
1716              (match_operand:VF_128 5 "nonimmediate_operand")])
1717           (match_operand:V_128 1 "general_operand")
1718           (match_operand:V_128 2 "general_operand")))]
1719   "TARGET_SSE
1720    && (GET_MODE_NUNITS (<V_128:MODE>mode)
1721        == GET_MODE_NUNITS (<VF_128:MODE>mode))"
1722 {
1723   bool ok = ix86_expand_fp_vcond (operands);
1724   gcc_assert (ok);
1725   DONE;
1726 })
1727
1728 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1729 ;;
1730 ;; Parallel floating point logical operations
1731 ;;
1732 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1733
1734 (define_insn "<sse>_andnot<mode>3"
1735   [(set (match_operand:VF 0 "register_operand" "=x,x")
1736         (and:VF
1737           (not:VF
1738             (match_operand:VF 1 "register_operand" "0,x"))
1739           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1740   "TARGET_SSE"
1741 {
1742   static char buf[32];
1743   const char *ops;
1744   const char *suffix;
1745
1746   switch (get_attr_mode (insn))
1747     {
1748     case MODE_V8SF:
1749     case MODE_V4SF:
1750       suffix = "ps";
1751       break;
1752     default:
1753       suffix = "<ssemodesuffix>";
1754     }
1755
1756   switch (which_alternative)
1757     {
1758     case 0:
1759       ops = "andn%s\t{%%2, %%0|%%0, %%2}";
1760       break;
1761     case 1:
1762       ops = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1763       break;
1764     default:
1765       gcc_unreachable ();
1766     }
1767
1768   snprintf (buf, sizeof (buf), ops, suffix);
1769   return buf;
1770 }
1771   [(set_attr "isa" "noavx,avx")
1772    (set_attr "type" "sselog")
1773    (set_attr "prefix" "orig,vex")
1774    (set (attr "mode")
1775         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1776                  (const_string "<ssePSmode>")
1777                (match_test "TARGET_AVX")
1778                  (const_string "<MODE>")
1779                (match_test "optimize_function_for_size_p (cfun)")
1780                  (const_string "V4SF")
1781                ]
1782                (const_string "<MODE>")))])
1783
1784 (define_expand "<code><mode>3"
1785   [(set (match_operand:VF 0 "register_operand")
1786         (any_logic:VF
1787           (match_operand:VF 1 "nonimmediate_operand")
1788           (match_operand:VF 2 "nonimmediate_operand")))]
1789   "TARGET_SSE"
1790   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1791
1792 (define_insn "*<code><mode>3"
1793   [(set (match_operand:VF 0 "register_operand" "=x,x")
1794         (any_logic:VF
1795           (match_operand:VF 1 "nonimmediate_operand" "%0,x")
1796           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")))]
1797   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
1798 {
1799   static char buf[32];
1800   const char *ops;
1801   const char *suffix;
1802
1803   switch (get_attr_mode (insn))
1804     {
1805     case MODE_V8SF:
1806     case MODE_V4SF:
1807       suffix = "ps";
1808       break;
1809     default:
1810       suffix = "<ssemodesuffix>";
1811     }
1812
1813   switch (which_alternative)
1814     {
1815     case 0:
1816       ops = "<logic>%s\t{%%2, %%0|%%0, %%2}";
1817       break;
1818     case 1:
1819       ops = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1820       break;
1821     default:
1822       gcc_unreachable ();
1823     }
1824
1825   snprintf (buf, sizeof (buf), ops, suffix);
1826   return buf;
1827 }
1828   [(set_attr "isa" "noavx,avx")
1829    (set_attr "type" "sselog")
1830    (set_attr "prefix" "orig,vex")
1831    (set (attr "mode")
1832         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1833                  (const_string "<ssePSmode>")
1834                (match_test "TARGET_AVX")
1835                  (const_string "<MODE>")
1836                (match_test "optimize_function_for_size_p (cfun)")
1837                  (const_string "V4SF")
1838                ]
1839                (const_string "<MODE>")))])
1840
1841 (define_expand "copysign<mode>3"
1842   [(set (match_dup 4)
1843         (and:VF
1844           (not:VF (match_dup 3))
1845           (match_operand:VF 1 "nonimmediate_operand")))
1846    (set (match_dup 5)
1847         (and:VF (match_dup 3)
1848                 (match_operand:VF 2 "nonimmediate_operand")))
1849    (set (match_operand:VF 0 "register_operand")
1850         (ior:VF (match_dup 4) (match_dup 5)))]
1851   "TARGET_SSE"
1852 {
1853   operands[3] = ix86_build_signbit_mask (<MODE>mode, 1, 0);
1854
1855   operands[4] = gen_reg_rtx (<MODE>mode);
1856   operands[5] = gen_reg_rtx (<MODE>mode);
1857 })
1858
1859 ;; Also define scalar versions.  These are used for abs, neg, and
1860 ;; conditional move.  Using subregs into vector modes causes register
1861 ;; allocation lossage.  These patterns do not allow memory operands
1862 ;; because the native instructions read the full 128-bits.
1863
1864 (define_insn "*andnot<mode>3"
1865   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
1866         (and:MODEF
1867           (not:MODEF
1868             (match_operand:MODEF 1 "register_operand" "0,x"))
1869             (match_operand:MODEF 2 "register_operand" "x,x")))]
1870   "SSE_FLOAT_MODE_P (<MODE>mode)"
1871 {
1872   static char buf[32];
1873   const char *ops;
1874   const char *suffix
1875     = (get_attr_mode (insn) == MODE_V4SF) ? "ps" : "<ssevecmodesuffix>";
1876
1877   switch (which_alternative)
1878     {
1879     case 0:
1880       ops = "andn%s\t{%%2, %%0|%%0, %%2}";
1881       break;
1882     case 1:
1883       ops = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1884       break;
1885     default:
1886       gcc_unreachable ();
1887     }
1888
1889   snprintf (buf, sizeof (buf), ops, suffix);
1890   return buf;
1891 }
1892   [(set_attr "isa" "noavx,avx")
1893    (set_attr "type" "sselog")
1894    (set_attr "prefix" "orig,vex")
1895    (set (attr "mode")
1896         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1897                  (const_string "V4SF")
1898                (match_test "TARGET_AVX")
1899                  (const_string "<ssevecmode>")
1900                (match_test "optimize_function_for_size_p (cfun)")
1901                  (const_string "V4SF")
1902                ]
1903                (const_string "<ssevecmode>")))])
1904
1905 (define_insn "*andnottf3"
1906   [(set (match_operand:TF 0 "register_operand" "=x,x")
1907         (and:TF
1908           (not:TF (match_operand:TF 1 "register_operand" "0,x"))
1909           (match_operand:TF 2 "nonimmediate_operand" "xm,xm")))]
1910   "TARGET_SSE"
1911 {
1912   static char buf[32];
1913   const char *ops;
1914   const char *tmp
1915     = (get_attr_mode (insn) == MODE_V4SF) ? "andnps" : "pandn";
1916
1917   switch (which_alternative)
1918     {
1919     case 0:
1920       ops = "%s\t{%%2, %%0|%%0, %%2}";
1921       break;
1922     case 1:
1923       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1924       break;
1925     default:
1926       gcc_unreachable ();
1927     }
1928
1929   snprintf (buf, sizeof (buf), ops, tmp);
1930   return buf;
1931 }
1932   [(set_attr "isa" "noavx,avx")
1933    (set_attr "type" "sselog")
1934    (set (attr "prefix_data16")
1935      (if_then_else
1936        (and (eq_attr "alternative" "0")
1937             (eq_attr "mode" "TI"))
1938        (const_string "1")
1939        (const_string "*")))
1940    (set_attr "prefix" "orig,vex")
1941    (set (attr "mode")
1942         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1943                  (const_string "V4SF")
1944                (match_test "TARGET_AVX")
1945                  (const_string "TI")
1946                (ior (not (match_test "TARGET_SSE2"))
1947                     (match_test "optimize_function_for_size_p (cfun)"))
1948                  (const_string "V4SF")
1949                ]
1950                (const_string "TI")))])
1951
1952 (define_insn "*<code><mode>3"
1953   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
1954         (any_logic:MODEF
1955           (match_operand:MODEF 1 "register_operand" "%0,x")
1956           (match_operand:MODEF 2 "register_operand" "x,x")))]
1957   "SSE_FLOAT_MODE_P (<MODE>mode)"
1958 {
1959   static char buf[32];
1960   const char *ops;
1961   const char *suffix
1962     = (get_attr_mode (insn) == MODE_V4SF) ? "ps" : "<ssevecmodesuffix>";
1963
1964   switch (which_alternative)
1965     {
1966     case 0:
1967       ops = "<logic>%s\t{%%2, %%0|%%0, %%2}";
1968       break;
1969     case 1:
1970       ops = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
1971       break;
1972     default:
1973       gcc_unreachable ();
1974     }
1975
1976   snprintf (buf, sizeof (buf), ops, suffix);
1977   return buf;
1978 }
1979   [(set_attr "isa" "noavx,avx")
1980    (set_attr "type" "sselog")
1981    (set_attr "prefix" "orig,vex")
1982    (set (attr "mode")
1983         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1984                  (const_string "V4SF")
1985                (match_test "TARGET_AVX")
1986                  (const_string "<ssevecmode>")
1987                (match_test "optimize_function_for_size_p (cfun)")
1988                  (const_string "V4SF")
1989                ]
1990                (const_string "<ssevecmode>")))])
1991
1992 (define_expand "<code>tf3"
1993   [(set (match_operand:TF 0 "register_operand")
1994         (any_logic:TF
1995           (match_operand:TF 1 "nonimmediate_operand")
1996           (match_operand:TF 2 "nonimmediate_operand")))]
1997   "TARGET_SSE"
1998   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
1999
2000 (define_insn "*<code>tf3"
2001   [(set (match_operand:TF 0 "register_operand" "=x,x")
2002         (any_logic:TF
2003           (match_operand:TF 1 "nonimmediate_operand" "%0,x")
2004           (match_operand:TF 2 "nonimmediate_operand" "xm,xm")))]
2005   "TARGET_SSE
2006    && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
2007 {
2008   static char buf[32];
2009   const char *ops;
2010   const char *tmp
2011     = (get_attr_mode (insn) == MODE_V4SF) ? "<logic>ps" : "p<logic>";
2012
2013   switch (which_alternative)
2014     {
2015     case 0:
2016       ops = "%s\t{%%2, %%0|%%0, %%2}";
2017       break;
2018     case 1:
2019       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2020       break;
2021     default:
2022       gcc_unreachable ();
2023     }
2024
2025   snprintf (buf, sizeof (buf), ops, tmp);
2026   return buf;
2027 }
2028   [(set_attr "isa" "noavx,avx")
2029    (set_attr "type" "sselog")
2030    (set (attr "prefix_data16")
2031      (if_then_else
2032        (and (eq_attr "alternative" "0")
2033             (eq_attr "mode" "TI"))
2034        (const_string "1")
2035        (const_string "*")))
2036    (set_attr "prefix" "orig,vex")
2037    (set (attr "mode")
2038         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2039                  (const_string "V4SF")
2040                (match_test "TARGET_AVX")
2041                  (const_string "TI")
2042                (ior (not (match_test "TARGET_SSE2"))
2043                     (match_test "optimize_function_for_size_p (cfun)"))
2044                  (const_string "V4SF")
2045                ]
2046                (const_string "TI")))])
2047
2048 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2049 ;;
2050 ;; FMA floating point multiply/accumulate instructions.  These include
2051 ;; scalar versions of the instructions as well as vector versions.
2052 ;;
2053 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2054
2055 ;; The standard names for scalar FMA are only available with SSE math enabled.
2056 (define_mode_iterator FMAMODEM [(SF "TARGET_SSE_MATH")
2057                                 (DF "TARGET_SSE_MATH")
2058                                 V4SF V2DF V8SF V4DF])
2059
2060 (define_expand "fma<mode>4"
2061   [(set (match_operand:FMAMODEM 0 "register_operand")
2062         (fma:FMAMODEM
2063           (match_operand:FMAMODEM 1 "nonimmediate_operand")
2064           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2065           (match_operand:FMAMODEM 3 "nonimmediate_operand")))]
2066   "TARGET_FMA || TARGET_FMA4")
2067
2068 (define_expand "fms<mode>4"
2069   [(set (match_operand:FMAMODEM 0 "register_operand")
2070         (fma:FMAMODEM
2071           (match_operand:FMAMODEM 1 "nonimmediate_operand")
2072           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2073           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))]
2074   "TARGET_FMA || TARGET_FMA4")
2075
2076 (define_expand "fnma<mode>4"
2077   [(set (match_operand:FMAMODEM 0 "register_operand")
2078         (fma:FMAMODEM
2079           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2080           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2081           (match_operand:FMAMODEM 3 "nonimmediate_operand")))]
2082   "TARGET_FMA || TARGET_FMA4")
2083
2084 (define_expand "fnms<mode>4"
2085   [(set (match_operand:FMAMODEM 0 "register_operand")
2086         (fma:FMAMODEM
2087           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2088           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2089           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))]
2090   "TARGET_FMA || TARGET_FMA4")
2091
2092 ;; The builtins for intrinsics are not constrained by SSE math enabled.
2093 (define_mode_iterator FMAMODE [SF DF V4SF V2DF V8SF V4DF])
2094
2095 (define_expand "fma4i_fmadd_<mode>"
2096   [(set (match_operand:FMAMODE 0 "register_operand")
2097         (fma:FMAMODE
2098           (match_operand:FMAMODE 1 "nonimmediate_operand")
2099           (match_operand:FMAMODE 2 "nonimmediate_operand")
2100           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
2101   "TARGET_FMA || TARGET_FMA4")
2102
2103 (define_insn "*fma_fmadd_<mode>"
2104   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x,x,x")
2105         (fma:FMAMODE
2106           (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x, x,x")
2107           (match_operand:FMAMODE 2 "nonimmediate_operand" "xm, x,xm,x,m")
2108           (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0,xm,x")))]
2109   "TARGET_FMA || TARGET_FMA4"
2110   "@
2111    vfmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2112    vfmadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2113    vfmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2114    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2115    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2116   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2117    (set_attr "type" "ssemuladd")
2118    (set_attr "mode" "<MODE>")])
2119
2120 (define_insn "*fma_fmsub_<mode>"
2121   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x,x,x")
2122         (fma:FMAMODE
2123           (match_operand:FMAMODE   1 "nonimmediate_operand" "%0, 0,x, x,x")
2124           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm,x,m")
2125           (neg:FMAMODE
2126             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0,xm,x"))))]
2127   "TARGET_FMA || TARGET_FMA4"
2128   "@
2129    vfmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2130    vfmsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2131    vfmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2132    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2133    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2134   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2135    (set_attr "type" "ssemuladd")
2136    (set_attr "mode" "<MODE>")])
2137
2138 (define_insn "*fma_fnmadd_<mode>"
2139   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x,x,x")
2140         (fma:FMAMODE
2141           (neg:FMAMODE
2142             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x, x,x"))
2143           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm,x,m")
2144           (match_operand:FMAMODE   3 "nonimmediate_operand" " x,xm,0,xm,x")))]
2145   "TARGET_FMA || TARGET_FMA4"
2146   "@
2147    vfnmadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2148    vfnmadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2149    vfnmadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2150    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2151    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2152   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2153    (set_attr "type" "ssemuladd")
2154    (set_attr "mode" "<MODE>")])
2155
2156 (define_insn "*fma_fnmsub_<mode>"
2157   [(set (match_operand:FMAMODE 0 "register_operand" "=x,x,x,x,x")
2158         (fma:FMAMODE
2159           (neg:FMAMODE
2160             (match_operand:FMAMODE 1 "nonimmediate_operand" "%0, 0,x, x,x"))
2161           (match_operand:FMAMODE   2 "nonimmediate_operand" "xm, x,xm,x,m")
2162           (neg:FMAMODE
2163             (match_operand:FMAMODE 3 "nonimmediate_operand" " x,xm,0,xm,x"))))]
2164   "TARGET_FMA || TARGET_FMA4"
2165   "@
2166    vfnmsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2167    vfnmsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2168    vfnmsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2169    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2170    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2171   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2172    (set_attr "type" "ssemuladd")
2173    (set_attr "mode" "<MODE>")])
2174
2175 ;; FMA parallel floating point multiply addsub and subadd operations.
2176
2177 ;; It would be possible to represent these without the UNSPEC as
2178 ;;
2179 ;; (vec_merge
2180 ;;   (fma op1 op2 op3)
2181 ;;   (fma op1 op2 (neg op3))
2182 ;;   (merge-const))
2183 ;;
2184 ;; But this doesn't seem useful in practice.
2185
2186 (define_expand "fmaddsub_<mode>"
2187   [(set (match_operand:VF 0 "register_operand")
2188         (unspec:VF
2189           [(match_operand:VF 1 "nonimmediate_operand")
2190            (match_operand:VF 2 "nonimmediate_operand")
2191            (match_operand:VF 3 "nonimmediate_operand")]
2192           UNSPEC_FMADDSUB))]
2193   "TARGET_FMA || TARGET_FMA4")
2194
2195 (define_insn "*fma_fmaddsub_<mode>"
2196   [(set (match_operand:VF 0 "register_operand" "=x,x,x,x,x")
2197         (unspec:VF
2198           [(match_operand:VF 1 "nonimmediate_operand" "%0, 0,x, x,x")
2199            (match_operand:VF 2 "nonimmediate_operand" "xm, x,xm,x,m")
2200            (match_operand:VF 3 "nonimmediate_operand" " x,xm,0,xm,x")]
2201           UNSPEC_FMADDSUB))]
2202   "TARGET_FMA || TARGET_FMA4"
2203   "@
2204    vfmaddsub132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2205    vfmaddsub213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2206    vfmaddsub231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2207    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2208    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2209   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2210    (set_attr "type" "ssemuladd")
2211    (set_attr "mode" "<MODE>")])
2212
2213 (define_insn "*fma_fmsubadd_<mode>"
2214   [(set (match_operand:VF 0 "register_operand" "=x,x,x,x,x")
2215         (unspec:VF
2216           [(match_operand:VF   1 "nonimmediate_operand" "%0, 0,x, x,x")
2217            (match_operand:VF   2 "nonimmediate_operand" "xm, x,xm,x,m")
2218            (neg:VF
2219              (match_operand:VF 3 "nonimmediate_operand" " x,xm,0,xm,x"))]
2220           UNSPEC_FMADDSUB))]
2221   "TARGET_FMA || TARGET_FMA4"
2222   "@
2223    vfmsubadd132<ssemodesuffix>\t{%2, %3, %0|%0, %3, %2}
2224    vfmsubadd213<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
2225    vfmsubadd231<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}
2226    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2227    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2228   [(set_attr "isa" "fma,fma,fma,fma4,fma4")
2229    (set_attr "type" "ssemuladd")
2230    (set_attr "mode" "<MODE>")])
2231
2232 ;; FMA3 floating point scalar intrinsics. These merge result with
2233 ;; high-order elements from the destination register.
2234
2235 (define_expand "fmai_vmfmadd_<mode>"
2236   [(set (match_operand:VF_128 0 "register_operand")
2237         (vec_merge:VF_128
2238           (fma:VF_128
2239             (match_operand:VF_128 1 "nonimmediate_operand")
2240             (match_operand:VF_128 2 "nonimmediate_operand")
2241             (match_operand:VF_128 3 "nonimmediate_operand"))
2242           (match_dup 1)
2243           (const_int 1)))]
2244   "TARGET_FMA")
2245
2246 (define_insn "*fmai_fmadd_<mode>"
2247   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2248         (vec_merge:VF_128
2249           (fma:VF_128
2250             (match_operand:VF_128 1 "nonimmediate_operand" " 0, 0")
2251             (match_operand:VF_128 2 "nonimmediate_operand" "xm, x")
2252             (match_operand:VF_128 3 "nonimmediate_operand" " x,xm"))
2253           (match_dup 1)
2254           (const_int 1)))]
2255   "TARGET_FMA"
2256   "@
2257    vfmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2}
2258    vfmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}"
2259   [(set_attr "type" "ssemuladd")
2260    (set_attr "mode" "<MODE>")])
2261
2262 (define_insn "*fmai_fmsub_<mode>"
2263   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2264         (vec_merge:VF_128
2265           (fma:VF_128
2266             (match_operand:VF_128   1 "nonimmediate_operand" " 0, 0")
2267             (match_operand:VF_128   2 "nonimmediate_operand" "xm, x")
2268             (neg:VF_128
2269               (match_operand:VF_128 3 "nonimmediate_operand" " x,xm")))
2270           (match_dup 1)
2271           (const_int 1)))]
2272   "TARGET_FMA"
2273   "@
2274    vfmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2}
2275    vfmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}"
2276   [(set_attr "type" "ssemuladd")
2277    (set_attr "mode" "<MODE>")])
2278
2279 (define_insn "*fmai_fnmadd_<mode>"
2280   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2281         (vec_merge:VF_128
2282           (fma:VF_128
2283             (neg:VF_128
2284               (match_operand:VF_128 2 "nonimmediate_operand" "xm, x"))
2285             (match_operand:VF_128   1 "nonimmediate_operand" " 0, 0")
2286             (match_operand:VF_128   3 "nonimmediate_operand" " x,xm"))
2287           (match_dup 1)
2288           (const_int 1)))]
2289   "TARGET_FMA"
2290   "@
2291    vfnmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2}
2292    vfnmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}"
2293   [(set_attr "type" "ssemuladd")
2294    (set_attr "mode" "<MODE>")])
2295
2296 (define_insn "*fmai_fnmsub_<mode>"
2297   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2298         (vec_merge:VF_128
2299           (fma:VF_128
2300             (neg:VF_128
2301               (match_operand:VF_128 2 "nonimmediate_operand" "xm, x"))
2302             (match_operand:VF_128   1 "nonimmediate_operand" " 0, 0")
2303             (neg:VF_128
2304               (match_operand:VF_128 3 "nonimmediate_operand" " x,xm")))
2305           (match_dup 1)
2306           (const_int 1)))]
2307   "TARGET_FMA"
2308   "@
2309    vfnmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2}
2310    vfnmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}"
2311   [(set_attr "type" "ssemuladd")
2312    (set_attr "mode" "<MODE>")])
2313
2314 ;; FMA4 floating point scalar intrinsics.  These write the
2315 ;; entire destination register, with the high-order elements zeroed.
2316
2317 (define_expand "fma4i_vmfmadd_<mode>"
2318   [(set (match_operand:VF_128 0 "register_operand")
2319         (vec_merge:VF_128
2320           (fma:VF_128
2321             (match_operand:VF_128 1 "nonimmediate_operand")
2322             (match_operand:VF_128 2 "nonimmediate_operand")
2323             (match_operand:VF_128 3 "nonimmediate_operand"))
2324           (match_dup 4)
2325           (const_int 1)))]
2326   "TARGET_FMA4"
2327   "operands[4] = CONST0_RTX (<MODE>mode);")
2328
2329 (define_insn "*fma4i_vmfmadd_<mode>"
2330   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2331         (vec_merge:VF_128
2332           (fma:VF_128
2333             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
2334             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
2335             (match_operand:VF_128 3 "nonimmediate_operand" "xm,x"))
2336           (match_operand:VF_128 4 "const0_operand")
2337           (const_int 1)))]
2338   "TARGET_FMA4"
2339   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
2340   [(set_attr "type" "ssemuladd")
2341    (set_attr "mode" "<MODE>")])
2342
2343 (define_insn "*fma4i_vmfmsub_<mode>"
2344   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2345         (vec_merge:VF_128
2346           (fma:VF_128
2347             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
2348             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
2349             (neg:VF_128
2350               (match_operand:VF_128 3 "nonimmediate_operand" "xm,x")))
2351           (match_operand:VF_128 4 "const0_operand")
2352           (const_int 1)))]
2353   "TARGET_FMA4"
2354   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
2355   [(set_attr "type" "ssemuladd")
2356    (set_attr "mode" "<MODE>")])
2357
2358 (define_insn "*fma4i_vmfnmadd_<mode>"
2359   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2360         (vec_merge:VF_128
2361           (fma:VF_128
2362             (neg:VF_128
2363               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
2364             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
2365             (match_operand:VF_128   3 "nonimmediate_operand" "xm,x"))
2366           (match_operand:VF_128 4 "const0_operand")
2367           (const_int 1)))]
2368   "TARGET_FMA4"
2369   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
2370   [(set_attr "type" "ssemuladd")
2371    (set_attr "mode" "<MODE>")])
2372
2373 (define_insn "*fma4i_vmfnmsub_<mode>"
2374   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2375         (vec_merge:VF_128
2376           (fma:VF_128
2377             (neg:VF_128
2378               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
2379             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
2380             (neg:VF_128
2381               (match_operand:VF_128   3 "nonimmediate_operand" "xm,x")))
2382           (match_operand:VF_128 4 "const0_operand")
2383           (const_int 1)))]
2384   "TARGET_FMA4"
2385   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
2386   [(set_attr "type" "ssemuladd")
2387    (set_attr "mode" "<MODE>")])
2388
2389 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2390 ;;
2391 ;; Parallel single-precision floating point conversion operations
2392 ;;
2393 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2394
2395 (define_insn "sse_cvtpi2ps"
2396   [(set (match_operand:V4SF 0 "register_operand" "=x")
2397         (vec_merge:V4SF
2398           (vec_duplicate:V4SF
2399             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
2400           (match_operand:V4SF 1 "register_operand" "0")
2401           (const_int 3)))]
2402   "TARGET_SSE"
2403   "cvtpi2ps\t{%2, %0|%0, %2}"
2404   [(set_attr "type" "ssecvt")
2405    (set_attr "mode" "V4SF")])
2406
2407 (define_insn "sse_cvtps2pi"
2408   [(set (match_operand:V2SI 0 "register_operand" "=y")
2409         (vec_select:V2SI
2410           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2411                        UNSPEC_FIX_NOTRUNC)
2412           (parallel [(const_int 0) (const_int 1)])))]
2413   "TARGET_SSE"
2414   "cvtps2pi\t{%1, %0|%0, %q1}"
2415   [(set_attr "type" "ssecvt")
2416    (set_attr "unit" "mmx")
2417    (set_attr "mode" "DI")])
2418
2419 (define_insn "sse_cvttps2pi"
2420   [(set (match_operand:V2SI 0 "register_operand" "=y")
2421         (vec_select:V2SI
2422           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
2423           (parallel [(const_int 0) (const_int 1)])))]
2424   "TARGET_SSE"
2425   "cvttps2pi\t{%1, %0|%0, %q1}"
2426   [(set_attr "type" "ssecvt")
2427    (set_attr "unit" "mmx")
2428    (set_attr "prefix_rep" "0")
2429    (set_attr "mode" "SF")])
2430
2431 (define_insn "sse_cvtsi2ss"
2432   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2433         (vec_merge:V4SF
2434           (vec_duplicate:V4SF
2435             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
2436           (match_operand:V4SF 1 "register_operand" "0,0,x")
2437           (const_int 1)))]
2438   "TARGET_SSE"
2439   "@
2440    cvtsi2ss\t{%2, %0|%0, %2}
2441    cvtsi2ss\t{%2, %0|%0, %2}
2442    vcvtsi2ss\t{%2, %1, %0|%0, %1, %2}"
2443   [(set_attr "isa" "noavx,noavx,avx")
2444    (set_attr "type" "sseicvt")
2445    (set_attr "athlon_decode" "vector,double,*")
2446    (set_attr "amdfam10_decode" "vector,double,*")
2447    (set_attr "bdver1_decode" "double,direct,*")
2448    (set_attr "btver2_decode" "double,double,double")
2449    (set_attr "prefix" "orig,orig,vex")
2450    (set_attr "mode" "SF")])
2451
2452 (define_insn "sse_cvtsi2ssq"
2453   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2454         (vec_merge:V4SF
2455           (vec_duplicate:V4SF
2456             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,m,rm")))
2457           (match_operand:V4SF 1 "register_operand" "0,0,x")
2458           (const_int 1)))]
2459   "TARGET_SSE && TARGET_64BIT"
2460   "@
2461    cvtsi2ssq\t{%2, %0|%0, %2}
2462    cvtsi2ssq\t{%2, %0|%0, %2}
2463    vcvtsi2ssq\t{%2, %1, %0|%0, %1, %2}"
2464   [(set_attr "isa" "noavx,noavx,avx")
2465    (set_attr "type" "sseicvt")
2466    (set_attr "athlon_decode" "vector,double,*")
2467    (set_attr "amdfam10_decode" "vector,double,*")
2468    (set_attr "bdver1_decode" "double,direct,*")
2469    (set_attr "btver2_decode" "double,double,double")
2470    (set_attr "length_vex" "*,*,4")
2471    (set_attr "prefix_rex" "1,1,*")
2472    (set_attr "prefix" "orig,orig,vex")
2473    (set_attr "mode" "SF")])
2474
2475 (define_insn "sse_cvtss2si"
2476   [(set (match_operand:SI 0 "register_operand" "=r,r")
2477         (unspec:SI
2478           [(vec_select:SF
2479              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2480              (parallel [(const_int 0)]))]
2481           UNSPEC_FIX_NOTRUNC))]
2482   "TARGET_SSE"
2483   "%vcvtss2si\t{%1, %0|%0, %k1}"
2484   [(set_attr "type" "sseicvt")
2485    (set_attr "athlon_decode" "double,vector")
2486    (set_attr "bdver1_decode" "double,double")
2487    (set_attr "prefix_rep" "1")
2488    (set_attr "prefix" "maybe_vex")
2489    (set_attr "mode" "SI")])
2490
2491 (define_insn "sse_cvtss2si_2"
2492   [(set (match_operand:SI 0 "register_operand" "=r,r")
2493         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2494                    UNSPEC_FIX_NOTRUNC))]
2495   "TARGET_SSE"
2496   "%vcvtss2si\t{%1, %0|%0, %k1}"
2497   [(set_attr "type" "sseicvt")
2498    (set_attr "athlon_decode" "double,vector")
2499    (set_attr "amdfam10_decode" "double,double")
2500    (set_attr "bdver1_decode" "double,double")
2501    (set_attr "prefix_rep" "1")
2502    (set_attr "prefix" "maybe_vex")
2503    (set_attr "mode" "SI")])
2504
2505 (define_insn "sse_cvtss2siq"
2506   [(set (match_operand:DI 0 "register_operand" "=r,r")
2507         (unspec:DI
2508           [(vec_select:SF
2509              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2510              (parallel [(const_int 0)]))]
2511           UNSPEC_FIX_NOTRUNC))]
2512   "TARGET_SSE && TARGET_64BIT"
2513   "%vcvtss2si{q}\t{%1, %0|%0, %k1}"
2514   [(set_attr "type" "sseicvt")
2515    (set_attr "athlon_decode" "double,vector")
2516    (set_attr "bdver1_decode" "double,double")
2517    (set_attr "prefix_rep" "1")
2518    (set_attr "prefix" "maybe_vex")
2519    (set_attr "mode" "DI")])
2520
2521 (define_insn "sse_cvtss2siq_2"
2522   [(set (match_operand:DI 0 "register_operand" "=r,r")
2523         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
2524                    UNSPEC_FIX_NOTRUNC))]
2525   "TARGET_SSE && TARGET_64BIT"
2526   "%vcvtss2si{q}\t{%1, %0|%0, %k1}"
2527   [(set_attr "type" "sseicvt")
2528    (set_attr "athlon_decode" "double,vector")
2529    (set_attr "amdfam10_decode" "double,double")
2530    (set_attr "bdver1_decode" "double,double")
2531    (set_attr "prefix_rep" "1")
2532    (set_attr "prefix" "maybe_vex")
2533    (set_attr "mode" "DI")])
2534
2535 (define_insn "sse_cvttss2si"
2536   [(set (match_operand:SI 0 "register_operand" "=r,r")
2537         (fix:SI
2538           (vec_select:SF
2539             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2540             (parallel [(const_int 0)]))))]
2541   "TARGET_SSE"
2542   "%vcvttss2si\t{%1, %0|%0, %k1}"
2543   [(set_attr "type" "sseicvt")
2544    (set_attr "athlon_decode" "double,vector")
2545    (set_attr "amdfam10_decode" "double,double")
2546    (set_attr "bdver1_decode" "double,double")
2547    (set_attr "prefix_rep" "1")
2548    (set_attr "prefix" "maybe_vex")
2549    (set_attr "mode" "SI")])
2550
2551 (define_insn "sse_cvttss2siq"
2552   [(set (match_operand:DI 0 "register_operand" "=r,r")
2553         (fix:DI
2554           (vec_select:SF
2555             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
2556             (parallel [(const_int 0)]))))]
2557   "TARGET_SSE && TARGET_64BIT"
2558   "%vcvttss2si{q}\t{%1, %0|%0, %k1}"
2559   [(set_attr "type" "sseicvt")
2560    (set_attr "athlon_decode" "double,vector")
2561    (set_attr "amdfam10_decode" "double,double")
2562    (set_attr "bdver1_decode" "double,double")
2563    (set_attr "prefix_rep" "1")
2564    (set_attr "prefix" "maybe_vex")
2565    (set_attr "mode" "DI")])
2566
2567 (define_insn "float<sseintvecmodelower><mode>2"
2568   [(set (match_operand:VF1 0 "register_operand" "=x")
2569         (float:VF1
2570           (match_operand:<sseintvecmode> 1 "nonimmediate_operand" "xm")))]
2571   "TARGET_SSE2"
2572   "%vcvtdq2ps\t{%1, %0|%0, %1}"
2573   [(set_attr "type" "ssecvt")
2574    (set_attr "prefix" "maybe_vex")
2575    (set_attr "mode" "<sseinsnmode>")])
2576
2577 (define_expand "floatuns<sseintvecmodelower><mode>2"
2578   [(match_operand:VF1 0 "register_operand")
2579    (match_operand:<sseintvecmode> 1 "register_operand")]
2580   "TARGET_SSE2 && (<MODE>mode == V4SFmode || TARGET_AVX2)"
2581 {
2582   ix86_expand_vector_convert_uns_vsivsf (operands[0], operands[1]);
2583   DONE;
2584 })
2585
2586 (define_insn "avx_cvtps2dq256"
2587   [(set (match_operand:V8SI 0 "register_operand" "=x")
2588         (unspec:V8SI [(match_operand:V8SF 1 "nonimmediate_operand" "xm")]
2589                      UNSPEC_FIX_NOTRUNC))]
2590   "TARGET_AVX"
2591   "vcvtps2dq\t{%1, %0|%0, %1}"
2592   [(set_attr "type" "ssecvt")
2593    (set_attr "prefix" "vex")
2594    (set_attr "mode" "OI")])
2595
2596 (define_insn "sse2_cvtps2dq"
2597   [(set (match_operand:V4SI 0 "register_operand" "=x")
2598         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
2599                      UNSPEC_FIX_NOTRUNC))]
2600   "TARGET_SSE2"
2601   "%vcvtps2dq\t{%1, %0|%0, %1}"
2602   [(set_attr "type" "ssecvt")
2603    (set (attr "prefix_data16")
2604      (if_then_else
2605        (match_test "TARGET_AVX")
2606      (const_string "*")
2607      (const_string "1")))
2608    (set_attr "prefix" "maybe_vex")
2609    (set_attr "mode" "TI")])
2610
2611 (define_insn "fix_truncv8sfv8si2"
2612   [(set (match_operand:V8SI 0 "register_operand" "=x")
2613         (fix:V8SI (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
2614   "TARGET_AVX"
2615   "vcvttps2dq\t{%1, %0|%0, %1}"
2616   [(set_attr "type" "ssecvt")
2617    (set_attr "prefix" "vex")
2618    (set_attr "mode" "OI")])
2619
2620 (define_insn "fix_truncv4sfv4si2"
2621   [(set (match_operand:V4SI 0 "register_operand" "=x")
2622         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
2623   "TARGET_SSE2"
2624   "%vcvttps2dq\t{%1, %0|%0, %1}"
2625   [(set_attr "type" "ssecvt")
2626    (set (attr "prefix_rep")
2627      (if_then_else
2628        (match_test "TARGET_AVX")
2629      (const_string "*")
2630      (const_string "1")))
2631    (set (attr "prefix_data16")
2632      (if_then_else
2633        (match_test "TARGET_AVX")
2634      (const_string "*")
2635      (const_string "0")))
2636    (set_attr "prefix_data16" "0")
2637    (set_attr "prefix" "maybe_vex")
2638    (set_attr "mode" "TI")])
2639
2640 (define_expand "fixuns_trunc<mode><sseintvecmodelower>2"
2641   [(match_operand:<sseintvecmode> 0 "register_operand")
2642    (match_operand:VF1 1 "register_operand")]
2643   "TARGET_SSE2"
2644 {
2645   rtx tmp[3];
2646   tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
2647   tmp[1] = gen_reg_rtx (<sseintvecmode>mode);
2648   emit_insn (gen_fix_trunc<mode><sseintvecmodelower>2 (tmp[1], tmp[0]));
2649   emit_insn (gen_xor<sseintvecmodelower>3 (operands[0], tmp[1], tmp[2]));
2650   DONE;
2651 })
2652
2653 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2654 ;;
2655 ;; Parallel double-precision floating point conversion operations
2656 ;;
2657 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2658
2659 (define_insn "sse2_cvtpi2pd"
2660   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2661         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2662   "TARGET_SSE2"
2663   "cvtpi2pd\t{%1, %0|%0, %1}"
2664   [(set_attr "type" "ssecvt")
2665    (set_attr "unit" "mmx,*")
2666    (set_attr "prefix_data16" "1,*")
2667    (set_attr "mode" "V2DF")])
2668
2669 (define_insn "sse2_cvtpd2pi"
2670   [(set (match_operand:V2SI 0 "register_operand" "=y")
2671         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2672                      UNSPEC_FIX_NOTRUNC))]
2673   "TARGET_SSE2"
2674   "cvtpd2pi\t{%1, %0|%0, %1}"
2675   [(set_attr "type" "ssecvt")
2676    (set_attr "unit" "mmx")
2677    (set_attr "bdver1_decode" "double")
2678    (set_attr "btver2_decode" "direct")
2679    (set_attr "prefix_data16" "1")
2680    (set_attr "mode" "DI")])
2681
2682 (define_insn "sse2_cvttpd2pi"
2683   [(set (match_operand:V2SI 0 "register_operand" "=y")
2684         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2685   "TARGET_SSE2"
2686   "cvttpd2pi\t{%1, %0|%0, %1}"
2687   [(set_attr "type" "ssecvt")
2688    (set_attr "unit" "mmx")
2689    (set_attr "bdver1_decode" "double")
2690    (set_attr "prefix_data16" "1")
2691    (set_attr "mode" "TI")])
2692
2693 (define_insn "sse2_cvtsi2sd"
2694   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
2695         (vec_merge:V2DF
2696           (vec_duplicate:V2DF
2697             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
2698           (match_operand:V2DF 1 "register_operand" "0,0,x")
2699           (const_int 1)))]
2700   "TARGET_SSE2"
2701   "@
2702    cvtsi2sd\t{%2, %0|%0, %2}
2703    cvtsi2sd\t{%2, %0|%0, %2}
2704    vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
2705   [(set_attr "isa" "noavx,noavx,avx")
2706    (set_attr "type" "sseicvt")
2707    (set_attr "athlon_decode" "double,direct,*")
2708    (set_attr "amdfam10_decode" "vector,double,*")
2709    (set_attr "bdver1_decode" "double,direct,*")
2710    (set_attr "btver2_decode" "double,double,double")
2711    (set_attr "prefix" "orig,orig,vex")
2712    (set_attr "mode" "DF")])
2713
2714 (define_insn "sse2_cvtsi2sdq"
2715   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
2716         (vec_merge:V2DF
2717           (vec_duplicate:V2DF
2718             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m,rm")))
2719           (match_operand:V2DF 1 "register_operand" "0,0,x")
2720           (const_int 1)))]
2721   "TARGET_SSE2 && TARGET_64BIT"
2722   "@
2723    cvtsi2sdq\t{%2, %0|%0, %2}
2724    cvtsi2sdq\t{%2, %0|%0, %2}
2725    vcvtsi2sdq\t{%2, %1, %0|%0, %1, %2}"
2726   [(set_attr "isa" "noavx,noavx,avx")
2727    (set_attr "type" "sseicvt")
2728    (set_attr "athlon_decode" "double,direct,*")
2729    (set_attr "amdfam10_decode" "vector,double,*")
2730    (set_attr "bdver1_decode" "double,direct,*")
2731    (set_attr "length_vex" "*,*,4")
2732    (set_attr "prefix_rex" "1,1,*")
2733    (set_attr "prefix" "orig,orig,vex")
2734    (set_attr "mode" "DF")])
2735
2736 (define_insn "sse2_cvtsd2si"
2737   [(set (match_operand:SI 0 "register_operand" "=r,r")
2738         (unspec:SI
2739           [(vec_select:DF
2740              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2741              (parallel [(const_int 0)]))]
2742           UNSPEC_FIX_NOTRUNC))]
2743   "TARGET_SSE2"
2744   "%vcvtsd2si\t{%1, %0|%0, %q1}"
2745   [(set_attr "type" "sseicvt")
2746    (set_attr "athlon_decode" "double,vector")
2747    (set_attr "bdver1_decode" "double,double")
2748    (set_attr "btver2_decode" "double,double")
2749    (set_attr "prefix_rep" "1")
2750    (set_attr "prefix" "maybe_vex")
2751    (set_attr "mode" "SI")])
2752
2753 (define_insn "sse2_cvtsd2si_2"
2754   [(set (match_operand:SI 0 "register_operand" "=r,r")
2755         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2756                    UNSPEC_FIX_NOTRUNC))]
2757   "TARGET_SSE2"
2758   "%vcvtsd2si\t{%1, %0|%0, %q1}"
2759   [(set_attr "type" "sseicvt")
2760    (set_attr "athlon_decode" "double,vector")
2761    (set_attr "amdfam10_decode" "double,double")
2762    (set_attr "bdver1_decode" "double,double")
2763    (set_attr "prefix_rep" "1")
2764    (set_attr "prefix" "maybe_vex")
2765    (set_attr "mode" "SI")])
2766
2767 (define_insn "sse2_cvtsd2siq"
2768   [(set (match_operand:DI 0 "register_operand" "=r,r")
2769         (unspec:DI
2770           [(vec_select:DF
2771              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2772              (parallel [(const_int 0)]))]
2773           UNSPEC_FIX_NOTRUNC))]
2774   "TARGET_SSE2 && TARGET_64BIT"
2775   "%vcvtsd2si{q}\t{%1, %0|%0, %q1}"
2776   [(set_attr "type" "sseicvt")
2777    (set_attr "athlon_decode" "double,vector")
2778    (set_attr "bdver1_decode" "double,double")
2779    (set_attr "prefix_rep" "1")
2780    (set_attr "prefix" "maybe_vex")
2781    (set_attr "mode" "DI")])
2782
2783 (define_insn "sse2_cvtsd2siq_2"
2784   [(set (match_operand:DI 0 "register_operand" "=r,r")
2785         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2786                    UNSPEC_FIX_NOTRUNC))]
2787   "TARGET_SSE2 && TARGET_64BIT"
2788   "%vcvtsd2si{q}\t{%1, %0|%0, %q1}"
2789   [(set_attr "type" "sseicvt")
2790    (set_attr "athlon_decode" "double,vector")
2791    (set_attr "amdfam10_decode" "double,double")
2792    (set_attr "bdver1_decode" "double,double")
2793    (set_attr "prefix_rep" "1")
2794    (set_attr "prefix" "maybe_vex")
2795    (set_attr "mode" "DI")])
2796
2797 (define_insn "sse2_cvttsd2si"
2798   [(set (match_operand:SI 0 "register_operand" "=r,r")
2799         (fix:SI
2800           (vec_select:DF
2801             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2802             (parallel [(const_int 0)]))))]
2803   "TARGET_SSE2"
2804   "%vcvttsd2si\t{%1, %0|%0, %q1}"
2805   [(set_attr "type" "sseicvt")
2806    (set_attr "athlon_decode" "double,vector")
2807    (set_attr "amdfam10_decode" "double,double")
2808    (set_attr "bdver1_decode" "double,double")
2809    (set_attr "btver2_decode" "double,double")
2810    (set_attr "prefix_rep" "1")
2811    (set_attr "prefix" "maybe_vex")
2812    (set_attr "mode" "SI")])
2813
2814 (define_insn "sse2_cvttsd2siq"
2815   [(set (match_operand:DI 0 "register_operand" "=r,r")
2816         (fix:DI
2817           (vec_select:DF
2818             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2819             (parallel [(const_int 0)]))))]
2820   "TARGET_SSE2 && TARGET_64BIT"
2821   "%vcvttsd2si{q}\t{%1, %0|%0, %q1}"
2822   [(set_attr "type" "sseicvt")
2823    (set_attr "athlon_decode" "double,vector")
2824    (set_attr "amdfam10_decode" "double,double")
2825    (set_attr "bdver1_decode" "double,double")
2826    (set_attr "prefix_rep" "1")
2827    (set_attr "prefix" "maybe_vex")
2828    (set_attr "mode" "DI")])
2829
2830 (define_insn "floatv4siv4df2"
2831   [(set (match_operand:V4DF 0 "register_operand" "=x")
2832         (float:V4DF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
2833   "TARGET_AVX"
2834   "vcvtdq2pd\t{%1, %0|%0, %1}"
2835   [(set_attr "type" "ssecvt")
2836    (set_attr "prefix" "vex")
2837    (set_attr "mode" "V4DF")])
2838
2839 (define_insn "avx_cvtdq2pd256_2"
2840   [(set (match_operand:V4DF 0 "register_operand" "=x")
2841         (float:V4DF
2842           (vec_select:V4SI
2843             (match_operand:V8SI 1 "nonimmediate_operand" "xm")
2844             (parallel [(const_int 0) (const_int 1)
2845                        (const_int 2) (const_int 3)]))))]
2846   "TARGET_AVX"
2847   "vcvtdq2pd\t{%x1, %0|%0, %x1}"
2848   [(set_attr "type" "ssecvt")
2849    (set_attr "prefix" "vex")
2850    (set_attr "mode" "V4DF")])
2851
2852 (define_insn "sse2_cvtdq2pd"
2853   [(set (match_operand:V2DF 0 "register_operand" "=x")
2854         (float:V2DF
2855           (vec_select:V2SI
2856             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2857             (parallel [(const_int 0) (const_int 1)]))))]
2858   "TARGET_SSE2"
2859   "%vcvtdq2pd\t{%1, %0|%0, %q1}"
2860   [(set_attr "type" "ssecvt")
2861    (set_attr "prefix" "maybe_vex")
2862    (set_attr "mode" "V2DF")])
2863
2864 (define_insn "avx_cvtpd2dq256"
2865   [(set (match_operand:V4SI 0 "register_operand" "=x")
2866         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2867                      UNSPEC_FIX_NOTRUNC))]
2868   "TARGET_AVX"
2869   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
2870   [(set_attr "type" "ssecvt")
2871    (set_attr "prefix" "vex")
2872    (set_attr "mode" "OI")])
2873
2874 (define_expand "avx_cvtpd2dq256_2"
2875   [(set (match_operand:V8SI 0 "register_operand")
2876         (vec_concat:V8SI
2877           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand")]
2878                        UNSPEC_FIX_NOTRUNC)
2879           (match_dup 2)))]
2880   "TARGET_AVX"
2881   "operands[2] = CONST0_RTX (V4SImode);")
2882
2883 (define_insn "*avx_cvtpd2dq256_2"
2884   [(set (match_operand:V8SI 0 "register_operand" "=x")
2885         (vec_concat:V8SI
2886           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
2887                        UNSPEC_FIX_NOTRUNC)
2888           (match_operand:V4SI 2 "const0_operand")))]
2889   "TARGET_AVX"
2890   "vcvtpd2dq{y}\t{%1, %x0|%x0, %1}"
2891   [(set_attr "type" "ssecvt")
2892    (set_attr "prefix" "vex")
2893    (set_attr "btver2_decode" "vector")
2894    (set_attr "mode" "OI")])
2895
2896 (define_expand "sse2_cvtpd2dq"
2897   [(set (match_operand:V4SI 0 "register_operand")
2898         (vec_concat:V4SI
2899           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand")]
2900                        UNSPEC_FIX_NOTRUNC)
2901           (match_dup 2)))]
2902   "TARGET_SSE2"
2903   "operands[2] = CONST0_RTX (V2SImode);")
2904
2905 (define_insn "*sse2_cvtpd2dq"
2906   [(set (match_operand:V4SI 0 "register_operand" "=x")
2907         (vec_concat:V4SI
2908           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2909                        UNSPEC_FIX_NOTRUNC)
2910           (match_operand:V2SI 2 "const0_operand")))]
2911   "TARGET_SSE2"
2912 {
2913   if (TARGET_AVX)
2914     return "vcvtpd2dq{x}\t{%1, %0|%0, %1}";
2915   else
2916     return "cvtpd2dq\t{%1, %0|%0, %1}";
2917 }
2918   [(set_attr "type" "ssecvt")
2919    (set_attr "prefix_rep" "1")
2920    (set_attr "prefix_data16" "0")
2921    (set_attr "prefix" "maybe_vex")
2922    (set_attr "mode" "TI")
2923    (set_attr "amdfam10_decode" "double")
2924    (set_attr "athlon_decode" "vector")
2925    (set_attr "bdver1_decode" "double")])
2926
2927 (define_insn "fix_truncv4dfv4si2"
2928   [(set (match_operand:V4SI 0 "register_operand" "=x")
2929         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
2930   "TARGET_AVX"
2931   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
2932   [(set_attr "type" "ssecvt")
2933    (set_attr "prefix" "vex")
2934    (set_attr "mode" "OI")])
2935
2936 (define_expand "avx_cvttpd2dq256_2"
2937   [(set (match_operand:V8SI 0 "register_operand")
2938         (vec_concat:V8SI
2939           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand"))
2940           (match_dup 2)))]
2941   "TARGET_AVX"
2942   "operands[2] = CONST0_RTX (V4SImode);")
2943
2944 (define_insn "*avx_cvttpd2dq256_2"
2945   [(set (match_operand:V8SI 0 "register_operand" "=x")
2946         (vec_concat:V8SI
2947           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm"))
2948           (match_operand:V4SI 2 "const0_operand")))]
2949   "TARGET_AVX"
2950   "vcvttpd2dq{y}\t{%1, %x0|%x0, %1}"
2951   [(set_attr "type" "ssecvt")
2952    (set_attr "prefix" "vex")
2953    (set_attr "btver2_decode" "vector")
2954    (set_attr "mode" "OI")])
2955
2956 (define_expand "sse2_cvttpd2dq"
2957   [(set (match_operand:V4SI 0 "register_operand")
2958         (vec_concat:V4SI
2959           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand"))
2960           (match_dup 2)))]
2961   "TARGET_SSE2"
2962   "operands[2] = CONST0_RTX (V2SImode);")
2963
2964 (define_insn "*sse2_cvttpd2dq"
2965   [(set (match_operand:V4SI 0 "register_operand" "=x")
2966         (vec_concat:V4SI
2967           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2968           (match_operand:V2SI 2 "const0_operand")))]
2969   "TARGET_SSE2"
2970 {
2971   if (TARGET_AVX)
2972     return "vcvttpd2dq{x}\t{%1, %0|%0, %1}";
2973   else
2974     return "cvttpd2dq\t{%1, %0|%0, %1}";
2975 }
2976   [(set_attr "type" "ssecvt")
2977    (set_attr "amdfam10_decode" "double")
2978    (set_attr "athlon_decode" "vector")
2979    (set_attr "bdver1_decode" "double")
2980    (set_attr "prefix" "maybe_vex")
2981    (set_attr "mode" "TI")])
2982
2983 (define_insn "sse2_cvtsd2ss"
2984   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
2985         (vec_merge:V4SF
2986           (vec_duplicate:V4SF
2987             (float_truncate:V2SF
2988               (match_operand:V2DF 2 "nonimmediate_operand" "x,m,xm")))
2989           (match_operand:V4SF 1 "register_operand" "0,0,x")
2990           (const_int 1)))]
2991   "TARGET_SSE2"
2992   "@
2993    cvtsd2ss\t{%2, %0|%0, %2}
2994    cvtsd2ss\t{%2, %0|%0, %q2}
2995    vcvtsd2ss\t{%2, %1, %0|%0, %1, %q2}"
2996   [(set_attr "isa" "noavx,noavx,avx")
2997    (set_attr "type" "ssecvt")
2998    (set_attr "athlon_decode" "vector,double,*")
2999    (set_attr "amdfam10_decode" "vector,double,*")
3000    (set_attr "bdver1_decode" "direct,direct,*")
3001    (set_attr "btver2_decode" "double,double,double")
3002    (set_attr "prefix" "orig,orig,vex")
3003    (set_attr "mode" "SF")])
3004
3005 (define_insn "sse2_cvtss2sd"
3006   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
3007         (vec_merge:V2DF
3008           (float_extend:V2DF
3009             (vec_select:V2SF
3010               (match_operand:V4SF 2 "nonimmediate_operand" "x,m,xm")
3011               (parallel [(const_int 0) (const_int 1)])))
3012           (match_operand:V2DF 1 "register_operand" "0,0,x")
3013           (const_int 1)))]
3014   "TARGET_SSE2"
3015   "@
3016    cvtss2sd\t{%2, %0|%0, %2}
3017    cvtss2sd\t{%2, %0|%0, %k2}
3018    vcvtss2sd\t{%2, %1, %0|%0, %1, %k2}"
3019   [(set_attr "isa" "noavx,noavx,avx")
3020    (set_attr "type" "ssecvt")
3021    (set_attr "amdfam10_decode" "vector,double,*")
3022    (set_attr "athlon_decode" "direct,direct,*")
3023    (set_attr "bdver1_decode" "direct,direct,*")
3024    (set_attr "btver2_decode" "double,double,double")
3025    (set_attr "prefix" "orig,orig,vex")
3026    (set_attr "mode" "DF")])
3027
3028 (define_insn "avx_cvtpd2ps256"
3029   [(set (match_operand:V4SF 0 "register_operand" "=x")
3030         (float_truncate:V4SF
3031           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
3032   "TARGET_AVX"
3033   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
3034   [(set_attr "type" "ssecvt")
3035    (set_attr "prefix" "vex")
3036    (set_attr "btver2_decode" "vector")
3037    (set_attr "mode" "V4SF")])
3038
3039 (define_expand "sse2_cvtpd2ps"
3040   [(set (match_operand:V4SF 0 "register_operand")
3041         (vec_concat:V4SF
3042           (float_truncate:V2SF
3043             (match_operand:V2DF 1 "nonimmediate_operand"))
3044           (match_dup 2)))]
3045   "TARGET_SSE2"
3046   "operands[2] = CONST0_RTX (V2SFmode);")
3047
3048 (define_insn "*sse2_cvtpd2ps"
3049   [(set (match_operand:V4SF 0 "register_operand" "=x")
3050         (vec_concat:V4SF
3051           (float_truncate:V2SF
3052             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
3053           (match_operand:V2SF 2 "const0_operand")))]
3054   "TARGET_SSE2"
3055 {
3056   if (TARGET_AVX)
3057     return "vcvtpd2ps{x}\t{%1, %0|%0, %1}";
3058   else
3059     return "cvtpd2ps\t{%1, %0|%0, %1}";
3060 }
3061   [(set_attr "type" "ssecvt")
3062    (set_attr "amdfam10_decode" "double")
3063    (set_attr "athlon_decode" "vector")
3064    (set_attr "bdver1_decode" "double")
3065    (set_attr "prefix_data16" "1")
3066    (set_attr "prefix" "maybe_vex")
3067    (set_attr "mode" "V4SF")])
3068
3069 (define_insn "avx_cvtps2pd256"
3070   [(set (match_operand:V4DF 0 "register_operand" "=x")
3071         (float_extend:V4DF
3072           (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3073   "TARGET_AVX"
3074   "vcvtps2pd\t{%1, %0|%0, %1}"
3075   [(set_attr "type" "ssecvt")
3076    (set_attr "prefix" "vex")
3077    (set_attr "mode" "V4DF")])
3078
3079 (define_insn "*avx_cvtps2pd256_2"
3080   [(set (match_operand:V4DF 0 "register_operand" "=x")
3081         (float_extend:V4DF
3082           (vec_select:V4SF
3083             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3084             (parallel [(const_int 0) (const_int 1)
3085                        (const_int 2) (const_int 3)]))))]
3086   "TARGET_AVX"
3087   "vcvtps2pd\t{%x1, %0|%0, %x1}"
3088   [(set_attr "type" "ssecvt")
3089    (set_attr "prefix" "vex")
3090    (set_attr "mode" "V4DF")])
3091
3092 (define_insn "sse2_cvtps2pd"
3093   [(set (match_operand:V2DF 0 "register_operand" "=x")
3094         (float_extend:V2DF
3095           (vec_select:V2SF
3096             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3097             (parallel [(const_int 0) (const_int 1)]))))]
3098   "TARGET_SSE2"
3099   "%vcvtps2pd\t{%1, %0|%0, %q1}"
3100   [(set_attr "type" "ssecvt")
3101    (set_attr "amdfam10_decode" "direct")
3102    (set_attr "athlon_decode" "double")
3103    (set_attr "bdver1_decode" "double")
3104    (set_attr "prefix_data16" "0")
3105    (set_attr "prefix" "maybe_vex")
3106    (set_attr "mode" "V2DF")])
3107
3108 (define_expand "vec_unpacks_hi_v4sf"
3109   [(set (match_dup 2)
3110    (vec_select:V4SF
3111      (vec_concat:V8SF
3112        (match_dup 2)
3113        (match_operand:V4SF 1 "nonimmediate_operand"))
3114      (parallel [(const_int 6) (const_int 7)
3115                 (const_int 2) (const_int 3)])))
3116   (set (match_operand:V2DF 0 "register_operand")
3117    (float_extend:V2DF
3118      (vec_select:V2SF
3119        (match_dup 2)
3120        (parallel [(const_int 0) (const_int 1)]))))]
3121   "TARGET_SSE2"
3122   "operands[2] = gen_reg_rtx (V4SFmode);")
3123
3124 (define_expand "vec_unpacks_hi_v8sf"
3125   [(set (match_dup 2)
3126         (vec_select:V4SF
3127           (match_operand:V8SF 1 "nonimmediate_operand")
3128           (parallel [(const_int 4) (const_int 5)
3129                      (const_int 6) (const_int 7)])))
3130    (set (match_operand:V4DF 0 "register_operand")
3131         (float_extend:V4DF
3132           (match_dup 2)))]
3133   "TARGET_AVX"
3134   "operands[2] = gen_reg_rtx (V4SFmode);")
3135
3136 (define_expand "vec_unpacks_lo_v4sf"
3137   [(set (match_operand:V2DF 0 "register_operand")
3138         (float_extend:V2DF
3139           (vec_select:V2SF
3140             (match_operand:V4SF 1 "nonimmediate_operand")
3141             (parallel [(const_int 0) (const_int 1)]))))]
3142   "TARGET_SSE2")
3143
3144 (define_expand "vec_unpacks_lo_v8sf"
3145   [(set (match_operand:V4DF 0 "register_operand")
3146         (float_extend:V4DF
3147           (vec_select:V4SF
3148             (match_operand:V8SF 1 "nonimmediate_operand")
3149             (parallel [(const_int 0) (const_int 1)
3150                        (const_int 2) (const_int 3)]))))]
3151   "TARGET_AVX")
3152
3153 (define_mode_attr sseunpackfltmode
3154   [(V8HI "V4SF") (V4SI "V2DF") (V16HI "V8SF") (V8SI "V4DF")])
3155
3156 (define_expand "vec_unpacks_float_hi_<mode>"
3157   [(match_operand:<sseunpackfltmode> 0 "register_operand")
3158    (match_operand:VI2_AVX2 1 "register_operand")]
3159   "TARGET_SSE2"
3160 {
3161   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
3162
3163   emit_insn (gen_vec_unpacks_hi_<mode> (tmp, operands[1]));
3164   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3165                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
3166   DONE;
3167 })
3168
3169 (define_expand "vec_unpacks_float_lo_<mode>"
3170   [(match_operand:<sseunpackfltmode> 0 "register_operand")
3171    (match_operand:VI2_AVX2 1 "register_operand")]
3172   "TARGET_SSE2"
3173 {
3174   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
3175
3176   emit_insn (gen_vec_unpacks_lo_<mode> (tmp, operands[1]));
3177   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3178                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
3179   DONE;
3180 })
3181
3182 (define_expand "vec_unpacku_float_hi_<mode>"
3183   [(match_operand:<sseunpackfltmode> 0 "register_operand")
3184    (match_operand:VI2_AVX2 1 "register_operand")]
3185   "TARGET_SSE2"
3186 {
3187   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
3188
3189   emit_insn (gen_vec_unpacku_hi_<mode> (tmp, operands[1]));
3190   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3191                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
3192   DONE;
3193 })
3194
3195 (define_expand "vec_unpacku_float_lo_<mode>"
3196   [(match_operand:<sseunpackfltmode> 0 "register_operand")
3197    (match_operand:VI2_AVX2 1 "register_operand")]
3198   "TARGET_SSE2"
3199 {
3200   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
3201
3202   emit_insn (gen_vec_unpacku_lo_<mode> (tmp, operands[1]));
3203   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3204                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
3205   DONE;
3206 })
3207
3208 (define_expand "vec_unpacks_float_hi_v4si"
3209   [(set (match_dup 2)
3210         (vec_select:V4SI
3211           (match_operand:V4SI 1 "nonimmediate_operand")
3212           (parallel [(const_int 2) (const_int 3)
3213                      (const_int 2) (const_int 3)])))
3214    (set (match_operand:V2DF 0 "register_operand")
3215         (float:V2DF
3216           (vec_select:V2SI
3217           (match_dup 2)
3218             (parallel [(const_int 0) (const_int 1)]))))]
3219   "TARGET_SSE2"
3220   "operands[2] = gen_reg_rtx (V4SImode);")
3221
3222 (define_expand "vec_unpacks_float_lo_v4si"
3223   [(set (match_operand:V2DF 0 "register_operand")
3224         (float:V2DF
3225           (vec_select:V2SI
3226             (match_operand:V4SI 1 "nonimmediate_operand")
3227             (parallel [(const_int 0) (const_int 1)]))))]
3228   "TARGET_SSE2")
3229
3230 (define_expand "vec_unpacks_float_hi_v8si"
3231   [(set (match_dup 2)
3232         (vec_select:V4SI
3233           (match_operand:V8SI 1 "nonimmediate_operand")
3234           (parallel [(const_int 4) (const_int 5)
3235                      (const_int 6) (const_int 7)])))
3236    (set (match_operand:V4DF 0 "register_operand")
3237         (float:V4DF
3238           (match_dup 2)))]
3239   "TARGET_AVX"
3240   "operands[2] = gen_reg_rtx (V4SImode);")
3241
3242 (define_expand "vec_unpacks_float_lo_v8si"
3243   [(set (match_operand:V4DF 0 "register_operand")
3244         (float:V4DF
3245           (vec_select:V4SI
3246             (match_operand:V8SI 1 "nonimmediate_operand")
3247             (parallel [(const_int 0) (const_int 1)
3248                        (const_int 2) (const_int 3)]))))]
3249   "TARGET_AVX")
3250
3251 (define_expand "vec_unpacku_float_hi_v4si"
3252   [(set (match_dup 5)
3253         (vec_select:V4SI
3254           (match_operand:V4SI 1 "nonimmediate_operand")
3255           (parallel [(const_int 2) (const_int 3)
3256                      (const_int 2) (const_int 3)])))
3257    (set (match_dup 6)
3258         (float:V2DF
3259           (vec_select:V2SI
3260           (match_dup 5)
3261             (parallel [(const_int 0) (const_int 1)]))))
3262    (set (match_dup 7)
3263         (lt:V2DF (match_dup 6) (match_dup 3)))
3264    (set (match_dup 8)
3265         (and:V2DF (match_dup 7) (match_dup 4)))
3266    (set (match_operand:V2DF 0 "register_operand")
3267         (plus:V2DF (match_dup 6) (match_dup 8)))]
3268   "TARGET_SSE2"
3269 {
3270   REAL_VALUE_TYPE TWO32r;
3271   rtx x;
3272   int i;
3273
3274   real_ldexp (&TWO32r, &dconst1, 32);
3275   x = const_double_from_real_value (TWO32r, DFmode);
3276
3277   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3278   operands[4] = force_reg (V2DFmode,
3279                            ix86_build_const_vector (V2DFmode, 1, x));
3280
3281   operands[5] = gen_reg_rtx (V4SImode);
3282
3283   for (i = 6; i < 9; i++)
3284     operands[i] = gen_reg_rtx (V2DFmode);
3285 })
3286
3287 (define_expand "vec_unpacku_float_lo_v4si"
3288   [(set (match_dup 5)
3289         (float:V2DF
3290           (vec_select:V2SI
3291             (match_operand:V4SI 1 "nonimmediate_operand")
3292             (parallel [(const_int 0) (const_int 1)]))))
3293    (set (match_dup 6)
3294         (lt:V2DF (match_dup 5) (match_dup 3)))
3295    (set (match_dup 7)
3296         (and:V2DF (match_dup 6) (match_dup 4)))
3297    (set (match_operand:V2DF 0 "register_operand")
3298         (plus:V2DF (match_dup 5) (match_dup 7)))]
3299   "TARGET_SSE2"
3300 {
3301   REAL_VALUE_TYPE TWO32r;
3302   rtx x;
3303   int i;
3304
3305   real_ldexp (&TWO32r, &dconst1, 32);
3306   x = const_double_from_real_value (TWO32r, DFmode);
3307
3308   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
3309   operands[4] = force_reg (V2DFmode,
3310                            ix86_build_const_vector (V2DFmode, 1, x));
3311
3312   for (i = 5; i < 8; i++)
3313     operands[i] = gen_reg_rtx (V2DFmode);
3314 })
3315
3316 (define_expand "vec_unpacku_float_hi_v8si"
3317   [(match_operand:V4DF 0 "register_operand")
3318    (match_operand:V8SI 1 "register_operand")]
3319   "TARGET_AVX"
3320 {
3321   REAL_VALUE_TYPE TWO32r;
3322   rtx x, tmp[6];
3323   int i;
3324
3325   real_ldexp (&TWO32r, &dconst1, 32);
3326   x = const_double_from_real_value (TWO32r, DFmode);
3327
3328   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
3329   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
3330   tmp[5] = gen_reg_rtx (V4SImode);
3331
3332   for (i = 2; i < 5; i++)
3333     tmp[i] = gen_reg_rtx (V4DFmode);
3334   emit_insn (gen_vec_extract_hi_v8si (tmp[5], operands[1]));
3335   emit_insn (gen_floatv4siv4df2 (tmp[2], tmp[5]));
3336   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
3337                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
3338   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
3339   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
3340   DONE;
3341 })
3342
3343 (define_expand "vec_unpacku_float_lo_v8si"
3344   [(match_operand:V4DF 0 "register_operand")
3345    (match_operand:V8SI 1 "nonimmediate_operand")]
3346   "TARGET_AVX"
3347 {
3348   REAL_VALUE_TYPE TWO32r;
3349   rtx x, tmp[5];
3350   int i;
3351
3352   real_ldexp (&TWO32r, &dconst1, 32);
3353   x = const_double_from_real_value (TWO32r, DFmode);
3354
3355   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
3356   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
3357
3358   for (i = 2; i < 5; i++)
3359     tmp[i] = gen_reg_rtx (V4DFmode);
3360   emit_insn (gen_avx_cvtdq2pd256_2 (tmp[2], operands[1]));
3361   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
3362                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
3363   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
3364   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
3365   DONE;
3366 })
3367
3368 (define_expand "vec_pack_trunc_v4df"
3369   [(set (match_dup 3)
3370         (float_truncate:V4SF
3371           (match_operand:V4DF 1 "nonimmediate_operand")))
3372    (set (match_dup 4)
3373         (float_truncate:V4SF
3374           (match_operand:V4DF 2 "nonimmediate_operand")))
3375    (set (match_operand:V8SF 0 "register_operand")
3376         (vec_concat:V8SF
3377           (match_dup 3)
3378           (match_dup 4)))]
3379   "TARGET_AVX"
3380 {
3381   operands[3] = gen_reg_rtx (V4SFmode);
3382   operands[4] = gen_reg_rtx (V4SFmode);
3383 })
3384
3385 (define_expand "vec_pack_trunc_v2df"
3386   [(match_operand:V4SF 0 "register_operand")
3387    (match_operand:V2DF 1 "nonimmediate_operand")
3388    (match_operand:V2DF 2 "nonimmediate_operand")]
3389   "TARGET_SSE2"
3390 {
3391   rtx tmp0, tmp1;
3392
3393   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3394     {
3395       tmp0 = gen_reg_rtx (V4DFmode);
3396       tmp1 = force_reg (V2DFmode, operands[1]);
3397
3398       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3399       emit_insn (gen_avx_cvtpd2ps256 (operands[0], tmp0));
3400     }
3401   else
3402     {
3403       tmp0 = gen_reg_rtx (V4SFmode);
3404       tmp1 = gen_reg_rtx (V4SFmode);
3405
3406       emit_insn (gen_sse2_cvtpd2ps (tmp0, operands[1]));
3407       emit_insn (gen_sse2_cvtpd2ps (tmp1, operands[2]));
3408       emit_insn (gen_sse_movlhps (operands[0], tmp0, tmp1));
3409     }
3410   DONE;
3411 })
3412
3413 (define_expand "vec_pack_sfix_trunc_v4df"
3414   [(match_operand:V8SI 0 "register_operand")
3415    (match_operand:V4DF 1 "nonimmediate_operand")
3416    (match_operand:V4DF 2 "nonimmediate_operand")]
3417   "TARGET_AVX"
3418 {
3419   rtx r1, r2;
3420
3421   r1 = gen_reg_rtx (V4SImode);
3422   r2 = gen_reg_rtx (V4SImode);
3423
3424   emit_insn (gen_fix_truncv4dfv4si2 (r1, operands[1]));
3425   emit_insn (gen_fix_truncv4dfv4si2 (r2, operands[2]));
3426   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
3427   DONE;
3428 })
3429
3430 (define_expand "vec_pack_sfix_trunc_v2df"
3431   [(match_operand:V4SI 0 "register_operand")
3432    (match_operand:V2DF 1 "nonimmediate_operand")
3433    (match_operand:V2DF 2 "nonimmediate_operand")]
3434   "TARGET_SSE2"
3435 {
3436   rtx tmp0, tmp1;
3437
3438   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3439     {
3440       tmp0 = gen_reg_rtx (V4DFmode);
3441       tmp1 = force_reg (V2DFmode, operands[1]);
3442
3443       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3444       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp0));
3445     }
3446   else
3447     {
3448       tmp0 = gen_reg_rtx (V4SImode);
3449       tmp1 = gen_reg_rtx (V4SImode);
3450
3451       emit_insn (gen_sse2_cvttpd2dq (tmp0, operands[1]));
3452       emit_insn (gen_sse2_cvttpd2dq (tmp1, operands[2]));
3453       emit_insn
3454        (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3455                                     gen_lowpart (V2DImode, tmp0),
3456                                     gen_lowpart (V2DImode, tmp1)));
3457     }
3458   DONE;
3459 })
3460
3461 (define_mode_attr ssepackfltmode
3462   [(V4DF "V8SI") (V2DF "V4SI")])
3463
3464 (define_expand "vec_pack_ufix_trunc_<mode>"
3465   [(match_operand:<ssepackfltmode> 0 "register_operand")
3466    (match_operand:VF2 1 "register_operand")
3467    (match_operand:VF2 2 "register_operand")]
3468   "TARGET_SSE2"
3469 {
3470   rtx tmp[7];
3471   tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
3472   tmp[1] = ix86_expand_adjust_ufix_to_sfix_si (operands[2], &tmp[3]);
3473   tmp[4] = gen_reg_rtx (<ssepackfltmode>mode);
3474   emit_insn (gen_vec_pack_sfix_trunc_<mode> (tmp[4], tmp[0], tmp[1]));
3475   if (<ssepackfltmode>mode == V4SImode || TARGET_AVX2)
3476     {
3477       tmp[5] = gen_reg_rtx (<ssepackfltmode>mode);
3478       ix86_expand_vec_extract_even_odd (tmp[5], tmp[2], tmp[3], 0);
3479     }
3480   else
3481     {
3482       tmp[5] = gen_reg_rtx (V8SFmode);
3483       ix86_expand_vec_extract_even_odd (tmp[5], gen_lowpart (V8SFmode, tmp[2]),
3484                                         gen_lowpart (V8SFmode, tmp[3]), 0);
3485       tmp[5] = gen_lowpart (V8SImode, tmp[5]);
3486     }
3487   tmp[6] = expand_simple_binop (<ssepackfltmode>mode, XOR, tmp[4], tmp[5],
3488                                 operands[0], 0, OPTAB_DIRECT);
3489   if (tmp[6] != operands[0])
3490     emit_move_insn (operands[0], tmp[6]);
3491   DONE;
3492 })
3493
3494 (define_expand "vec_pack_sfix_v4df"
3495   [(match_operand:V8SI 0 "register_operand")
3496    (match_operand:V4DF 1 "nonimmediate_operand")
3497    (match_operand:V4DF 2 "nonimmediate_operand")]
3498   "TARGET_AVX"
3499 {
3500   rtx r1, r2;
3501
3502   r1 = gen_reg_rtx (V4SImode);
3503   r2 = gen_reg_rtx (V4SImode);
3504
3505   emit_insn (gen_avx_cvtpd2dq256 (r1, operands[1]));
3506   emit_insn (gen_avx_cvtpd2dq256 (r2, operands[2]));
3507   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
3508   DONE;
3509 })
3510
3511 (define_expand "vec_pack_sfix_v2df"
3512   [(match_operand:V4SI 0 "register_operand")
3513    (match_operand:V2DF 1 "nonimmediate_operand")
3514    (match_operand:V2DF 2 "nonimmediate_operand")]
3515   "TARGET_SSE2"
3516 {
3517   rtx tmp0, tmp1;
3518
3519   if (TARGET_AVX && !TARGET_PREFER_AVX128)
3520     {
3521       tmp0 = gen_reg_rtx (V4DFmode);
3522       tmp1 = force_reg (V2DFmode, operands[1]);
3523
3524       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
3525       emit_insn (gen_avx_cvtpd2dq256 (operands[0], tmp0));
3526     }
3527   else
3528     {
3529       tmp0 = gen_reg_rtx (V4SImode);
3530       tmp1 = gen_reg_rtx (V4SImode);
3531
3532       emit_insn (gen_sse2_cvtpd2dq (tmp0, operands[1]));
3533       emit_insn (gen_sse2_cvtpd2dq (tmp1, operands[2]));
3534       emit_insn
3535        (gen_vec_interleave_lowv2di (gen_lowpart (V2DImode, operands[0]),
3536                                     gen_lowpart (V2DImode, tmp0),
3537                                     gen_lowpart (V2DImode, tmp1)));
3538     }
3539   DONE;
3540 })
3541
3542 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3543 ;;
3544 ;; Parallel single-precision floating point element swizzling
3545 ;;
3546 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3547
3548 (define_expand "sse_movhlps_exp"
3549   [(set (match_operand:V4SF 0 "nonimmediate_operand")
3550         (vec_select:V4SF
3551           (vec_concat:V8SF
3552             (match_operand:V4SF 1 "nonimmediate_operand")
3553             (match_operand:V4SF 2 "nonimmediate_operand"))
3554           (parallel [(const_int 6)
3555                      (const_int 7)
3556                      (const_int 2)
3557                      (const_int 3)])))]
3558   "TARGET_SSE"
3559 {
3560   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
3561
3562   emit_insn (gen_sse_movhlps (dst, operands[1], operands[2]));
3563
3564   /* Fix up the destination if needed.  */
3565   if (dst != operands[0])
3566     emit_move_insn (operands[0], dst);
3567
3568   DONE;
3569 })
3570
3571 (define_insn "sse_movhlps"
3572   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
3573         (vec_select:V4SF
3574           (vec_concat:V8SF
3575             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
3576             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,o,o,x"))
3577           (parallel [(const_int 6)
3578                      (const_int 7)
3579                      (const_int 2)
3580                      (const_int 3)])))]
3581   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
3582   "@
3583    movhlps\t{%2, %0|%0, %2}
3584    vmovhlps\t{%2, %1, %0|%0, %1, %2}
3585    movlps\t{%H2, %0|%0, %H2}
3586    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
3587    %vmovhps\t{%2, %0|%q0, %2}"
3588   [(set_attr "isa" "noavx,avx,noavx,avx,*")
3589    (set_attr "type" "ssemov")
3590    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
3591    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
3592
3593 (define_expand "sse_movlhps_exp"
3594   [(set (match_operand:V4SF 0 "nonimmediate_operand")
3595         (vec_select:V4SF
3596           (vec_concat:V8SF
3597             (match_operand:V4SF 1 "nonimmediate_operand")
3598             (match_operand:V4SF 2 "nonimmediate_operand"))
3599           (parallel [(const_int 0)
3600                      (const_int 1)
3601                      (const_int 4)
3602                      (const_int 5)])))]
3603   "TARGET_SSE"
3604 {
3605   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
3606
3607   emit_insn (gen_sse_movlhps (dst, operands[1], operands[2]));
3608
3609   /* Fix up the destination if needed.  */
3610   if (dst != operands[0])
3611     emit_move_insn (operands[0], dst);
3612
3613   DONE;
3614 })
3615
3616 (define_insn "sse_movlhps"
3617   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
3618         (vec_select:V4SF
3619           (vec_concat:V8SF
3620             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
3621             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,m,x"))
3622           (parallel [(const_int 0)
3623                      (const_int 1)
3624                      (const_int 4)
3625                      (const_int 5)])))]
3626   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
3627   "@
3628    movlhps\t{%2, %0|%0, %2}
3629    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3630    movhps\t{%2, %0|%0, %q2}
3631    vmovhps\t{%2, %1, %0|%0, %1, %q2}
3632    %vmovlps\t{%2, %H0|%H0, %2}"
3633   [(set_attr "isa" "noavx,avx,noavx,avx,*")
3634    (set_attr "type" "ssemov")
3635    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
3636    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
3637
3638 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3639 (define_insn "avx_unpckhps256"
3640   [(set (match_operand:V8SF 0 "register_operand" "=x")
3641         (vec_select:V8SF
3642           (vec_concat:V16SF
3643             (match_operand:V8SF 1 "register_operand" "x")
3644             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3645           (parallel [(const_int 2) (const_int 10)
3646                      (const_int 3) (const_int 11)
3647                      (const_int 6) (const_int 14)
3648                      (const_int 7) (const_int 15)])))]
3649   "TARGET_AVX"
3650   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3651   [(set_attr "type" "sselog")
3652    (set_attr "prefix" "vex")
3653    (set_attr "mode" "V8SF")])
3654
3655 (define_expand "vec_interleave_highv8sf"
3656   [(set (match_dup 3)
3657         (vec_select:V8SF
3658           (vec_concat:V16SF
3659             (match_operand:V8SF 1 "register_operand" "x")
3660             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3661           (parallel [(const_int 0) (const_int 8)
3662                      (const_int 1) (const_int 9)
3663                      (const_int 4) (const_int 12)
3664                      (const_int 5) (const_int 13)])))
3665    (set (match_dup 4)
3666         (vec_select:V8SF
3667           (vec_concat:V16SF
3668             (match_dup 1)
3669             (match_dup 2))
3670           (parallel [(const_int 2) (const_int 10)
3671                      (const_int 3) (const_int 11)
3672                      (const_int 6) (const_int 14)
3673                      (const_int 7) (const_int 15)])))
3674    (set (match_operand:V8SF 0 "register_operand")
3675         (vec_select:V8SF
3676           (vec_concat:V16SF
3677             (match_dup 3)
3678             (match_dup 4))
3679           (parallel [(const_int 4) (const_int 5)
3680                      (const_int 6) (const_int 7)
3681                      (const_int 12) (const_int 13)
3682                      (const_int 14) (const_int 15)])))]
3683  "TARGET_AVX"
3684 {
3685   operands[3] = gen_reg_rtx (V8SFmode);
3686   operands[4] = gen_reg_rtx (V8SFmode);
3687 })
3688
3689 (define_insn "vec_interleave_highv4sf"
3690   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3691         (vec_select:V4SF
3692           (vec_concat:V8SF
3693             (match_operand:V4SF 1 "register_operand" "0,x")
3694             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
3695           (parallel [(const_int 2) (const_int 6)
3696                      (const_int 3) (const_int 7)])))]
3697   "TARGET_SSE"
3698   "@
3699    unpckhps\t{%2, %0|%0, %2}
3700    vunpckhps\t{%2, %1, %0|%0, %1, %2}"
3701   [(set_attr "isa" "noavx,avx")
3702    (set_attr "type" "sselog")
3703    (set_attr "prefix" "orig,vex")
3704    (set_attr "mode" "V4SF")])
3705
3706 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
3707 (define_insn "avx_unpcklps256"
3708   [(set (match_operand:V8SF 0 "register_operand" "=x")
3709         (vec_select:V8SF
3710           (vec_concat:V16SF
3711             (match_operand:V8SF 1 "register_operand" "x")
3712             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3713           (parallel [(const_int 0) (const_int 8)
3714                      (const_int 1) (const_int 9)
3715                      (const_int 4) (const_int 12)
3716                      (const_int 5) (const_int 13)])))]
3717   "TARGET_AVX"
3718   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3719   [(set_attr "type" "sselog")
3720    (set_attr "prefix" "vex")
3721    (set_attr "mode" "V8SF")])
3722
3723 (define_expand "vec_interleave_lowv8sf"
3724   [(set (match_dup 3)
3725         (vec_select:V8SF
3726           (vec_concat:V16SF
3727             (match_operand:V8SF 1 "register_operand" "x")
3728             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3729           (parallel [(const_int 0) (const_int 8)
3730                      (const_int 1) (const_int 9)
3731                      (const_int 4) (const_int 12)
3732                      (const_int 5) (const_int 13)])))
3733    (set (match_dup 4)
3734         (vec_select:V8SF
3735           (vec_concat:V16SF
3736             (match_dup 1)
3737             (match_dup 2))
3738           (parallel [(const_int 2) (const_int 10)
3739                      (const_int 3) (const_int 11)
3740                      (const_int 6) (const_int 14)
3741                      (const_int 7) (const_int 15)])))
3742    (set (match_operand:V8SF 0 "register_operand")
3743         (vec_select:V8SF
3744           (vec_concat:V16SF
3745             (match_dup 3)
3746             (match_dup 4))
3747           (parallel [(const_int 0) (const_int 1)
3748                      (const_int 2) (const_int 3)
3749                      (const_int 8) (const_int 9)
3750                      (const_int 10) (const_int 11)])))]
3751  "TARGET_AVX"
3752 {
3753   operands[3] = gen_reg_rtx (V8SFmode);
3754   operands[4] = gen_reg_rtx (V8SFmode);
3755 })
3756
3757 (define_insn "vec_interleave_lowv4sf"
3758   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
3759         (vec_select:V4SF
3760           (vec_concat:V8SF
3761             (match_operand:V4SF 1 "register_operand" "0,x")
3762             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
3763           (parallel [(const_int 0) (const_int 4)
3764                      (const_int 1) (const_int 5)])))]
3765   "TARGET_SSE"
3766   "@
3767    unpcklps\t{%2, %0|%0, %2}
3768    vunpcklps\t{%2, %1, %0|%0, %1, %2}"
3769   [(set_attr "isa" "noavx,avx")
3770    (set_attr "type" "sselog")
3771    (set_attr "prefix" "orig,vex")
3772    (set_attr "mode" "V4SF")])
3773
3774 ;; These are modeled with the same vec_concat as the others so that we
3775 ;; capture users of shufps that can use the new instructions
3776 (define_insn "avx_movshdup256"
3777   [(set (match_operand:V8SF 0 "register_operand" "=x")
3778         (vec_select:V8SF
3779           (vec_concat:V16SF
3780             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3781             (match_dup 1))
3782           (parallel [(const_int 1) (const_int 1)
3783                      (const_int 3) (const_int 3)
3784                      (const_int 5) (const_int 5)
3785                      (const_int 7) (const_int 7)])))]
3786   "TARGET_AVX"
3787   "vmovshdup\t{%1, %0|%0, %1}"
3788   [(set_attr "type" "sse")
3789    (set_attr "prefix" "vex")
3790    (set_attr "mode" "V8SF")])
3791
3792 (define_insn "sse3_movshdup"
3793   [(set (match_operand:V4SF 0 "register_operand" "=x")
3794         (vec_select:V4SF
3795           (vec_concat:V8SF
3796             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3797             (match_dup 1))
3798           (parallel [(const_int 1)
3799                      (const_int 1)
3800                      (const_int 7)
3801                      (const_int 7)])))]
3802   "TARGET_SSE3"
3803   "%vmovshdup\t{%1, %0|%0, %1}"
3804   [(set_attr "type" "sse")
3805    (set_attr "prefix_rep" "1")
3806    (set_attr "prefix" "maybe_vex")
3807    (set_attr "mode" "V4SF")])
3808
3809 (define_insn "avx_movsldup256"
3810   [(set (match_operand:V8SF 0 "register_operand" "=x")
3811         (vec_select:V8SF
3812           (vec_concat:V16SF
3813             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
3814             (match_dup 1))
3815           (parallel [(const_int 0) (const_int 0)
3816                      (const_int 2) (const_int 2)
3817                      (const_int 4) (const_int 4)
3818                      (const_int 6) (const_int 6)])))]
3819   "TARGET_AVX"
3820   "vmovsldup\t{%1, %0|%0, %1}"
3821   [(set_attr "type" "sse")
3822    (set_attr "prefix" "vex")
3823    (set_attr "mode" "V8SF")])
3824
3825 (define_insn "sse3_movsldup"
3826   [(set (match_operand:V4SF 0 "register_operand" "=x")
3827         (vec_select:V4SF
3828           (vec_concat:V8SF
3829             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
3830             (match_dup 1))
3831           (parallel [(const_int 0)
3832                      (const_int 0)
3833                      (const_int 6)
3834                      (const_int 6)])))]
3835   "TARGET_SSE3"
3836   "%vmovsldup\t{%1, %0|%0, %1}"
3837   [(set_attr "type" "sse")
3838    (set_attr "prefix_rep" "1")
3839    (set_attr "prefix" "maybe_vex")
3840    (set_attr "mode" "V4SF")])
3841
3842 (define_expand "avx_shufps256"
3843   [(match_operand:V8SF 0 "register_operand")
3844    (match_operand:V8SF 1 "register_operand")
3845    (match_operand:V8SF 2 "nonimmediate_operand")
3846    (match_operand:SI 3 "const_int_operand")]
3847   "TARGET_AVX"
3848 {
3849   int mask = INTVAL (operands[3]);
3850   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
3851                                   GEN_INT ((mask >> 0) & 3),
3852                                   GEN_INT ((mask >> 2) & 3),
3853                                   GEN_INT (((mask >> 4) & 3) + 8),
3854                                   GEN_INT (((mask >> 6) & 3) + 8),
3855                                   GEN_INT (((mask >> 0) & 3) + 4),
3856                                   GEN_INT (((mask >> 2) & 3) + 4),
3857                                   GEN_INT (((mask >> 4) & 3) + 12),
3858                                   GEN_INT (((mask >> 6) & 3) + 12)));
3859   DONE;
3860 })
3861
3862 ;; One bit in mask selects 2 elements.
3863 (define_insn "avx_shufps256_1"
3864   [(set (match_operand:V8SF 0 "register_operand" "=x")
3865         (vec_select:V8SF
3866           (vec_concat:V16SF
3867             (match_operand:V8SF 1 "register_operand" "x")
3868             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
3869           (parallel [(match_operand 3  "const_0_to_3_operand"  )
3870                      (match_operand 4  "const_0_to_3_operand"  )
3871                      (match_operand 5  "const_8_to_11_operand" )
3872                      (match_operand 6  "const_8_to_11_operand" )
3873                      (match_operand 7  "const_4_to_7_operand"  )
3874                      (match_operand 8  "const_4_to_7_operand"  )
3875                      (match_operand 9  "const_12_to_15_operand")
3876                      (match_operand 10 "const_12_to_15_operand")])))]
3877   "TARGET_AVX
3878    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
3879        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
3880        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
3881        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
3882 {
3883   int mask;
3884   mask = INTVAL (operands[3]);
3885   mask |= INTVAL (operands[4]) << 2;
3886   mask |= (INTVAL (operands[5]) - 8) << 4;
3887   mask |= (INTVAL (operands[6]) - 8) << 6;
3888   operands[3] = GEN_INT (mask);
3889
3890   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3891 }
3892   [(set_attr "type" "sseshuf")
3893    (set_attr "length_immediate" "1")
3894    (set_attr "prefix" "vex")
3895    (set_attr "mode" "V8SF")])
3896
3897 (define_expand "sse_shufps"
3898   [(match_operand:V4SF 0 "register_operand")
3899    (match_operand:V4SF 1 "register_operand")
3900    (match_operand:V4SF 2 "nonimmediate_operand")
3901    (match_operand:SI 3 "const_int_operand")]
3902   "TARGET_SSE"
3903 {
3904   int mask = INTVAL (operands[3]);
3905   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
3906                                GEN_INT ((mask >> 0) & 3),
3907                                GEN_INT ((mask >> 2) & 3),
3908                                GEN_INT (((mask >> 4) & 3) + 4),
3909                                GEN_INT (((mask >> 6) & 3) + 4)));
3910   DONE;
3911 })
3912
3913 (define_insn "sse_shufps_<mode>"
3914   [(set (match_operand:VI4F_128 0 "register_operand" "=x,x")
3915         (vec_select:VI4F_128
3916           (vec_concat:<ssedoublevecmode>
3917             (match_operand:VI4F_128 1 "register_operand" "0,x")
3918             (match_operand:VI4F_128 2 "nonimmediate_operand" "xm,xm"))
3919           (parallel [(match_operand 3 "const_0_to_3_operand")
3920                      (match_operand 4 "const_0_to_3_operand")
3921                      (match_operand 5 "const_4_to_7_operand")
3922                      (match_operand 6 "const_4_to_7_operand")])))]
3923   "TARGET_SSE"
3924 {
3925   int mask = 0;
3926   mask |= INTVAL (operands[3]) << 0;
3927   mask |= INTVAL (operands[4]) << 2;
3928   mask |= (INTVAL (operands[5]) - 4) << 4;
3929   mask |= (INTVAL (operands[6]) - 4) << 6;
3930   operands[3] = GEN_INT (mask);
3931
3932   switch (which_alternative)
3933     {
3934     case 0:
3935       return "shufps\t{%3, %2, %0|%0, %2, %3}";
3936     case 1:
3937       return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
3938     default:
3939       gcc_unreachable ();
3940     }
3941 }
3942   [(set_attr "isa" "noavx,avx")
3943    (set_attr "type" "sseshuf")
3944    (set_attr "length_immediate" "1")
3945    (set_attr "prefix" "orig,vex")
3946    (set_attr "mode" "V4SF")])
3947
3948 (define_insn "sse_storehps"
3949   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
3950         (vec_select:V2SF
3951           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
3952           (parallel [(const_int 2) (const_int 3)])))]
3953   "TARGET_SSE"
3954   "@
3955    %vmovhps\t{%1, %0|%q0, %1}
3956    %vmovhlps\t{%1, %d0|%d0, %1}
3957    %vmovlps\t{%H1, %d0|%d0, %H1}"
3958   [(set_attr "type" "ssemov")
3959    (set_attr "prefix" "maybe_vex")
3960    (set_attr "mode" "V2SF,V4SF,V2SF")])
3961
3962 (define_expand "sse_loadhps_exp"
3963   [(set (match_operand:V4SF 0 "nonimmediate_operand")
3964         (vec_concat:V4SF
3965           (vec_select:V2SF
3966             (match_operand:V4SF 1 "nonimmediate_operand")
3967             (parallel [(const_int 0) (const_int 1)]))
3968           (match_operand:V2SF 2 "nonimmediate_operand")))]
3969   "TARGET_SSE"
3970 {
3971   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
3972
3973   emit_insn (gen_sse_loadhps (dst, operands[1], operands[2]));
3974
3975   /* Fix up the destination if needed.  */
3976   if (dst != operands[0])
3977     emit_move_insn (operands[0], dst);
3978
3979   DONE;
3980 })
3981
3982 (define_insn "sse_loadhps"
3983   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
3984         (vec_concat:V4SF
3985           (vec_select:V2SF
3986             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
3987             (parallel [(const_int 0) (const_int 1)]))
3988           (match_operand:V2SF 2 "nonimmediate_operand"   " m,m,x,x,x")))]
3989   "TARGET_SSE"
3990   "@
3991    movhps\t{%2, %0|%0, %q2}
3992    vmovhps\t{%2, %1, %0|%0, %1, %q2}
3993    movlhps\t{%2, %0|%0, %2}
3994    vmovlhps\t{%2, %1, %0|%0, %1, %2}
3995    %vmovlps\t{%2, %H0|%H0, %2}"
3996   [(set_attr "isa" "noavx,avx,noavx,avx,*")
3997    (set_attr "type" "ssemov")
3998    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
3999    (set_attr "mode" "V2SF,V2SF,V4SF,V4SF,V2SF")])
4000
4001 (define_insn "sse_storelps"
4002   [(set (match_operand:V2SF 0 "nonimmediate_operand"   "=m,x,x")
4003         (vec_select:V2SF
4004           (match_operand:V4SF 1 "nonimmediate_operand" " x,x,m")
4005           (parallel [(const_int 0) (const_int 1)])))]
4006   "TARGET_SSE"
4007   "@
4008    %vmovlps\t{%1, %0|%q0, %1}
4009    %vmovaps\t{%1, %0|%0, %1}
4010    %vmovlps\t{%1, %d0|%d0, %q1}"
4011   [(set_attr "type" "ssemov")
4012    (set_attr "prefix" "maybe_vex")
4013    (set_attr "mode" "V2SF,V4SF,V2SF")])
4014
4015 (define_expand "sse_loadlps_exp"
4016   [(set (match_operand:V4SF 0 "nonimmediate_operand")
4017         (vec_concat:V4SF
4018           (match_operand:V2SF 2 "nonimmediate_operand")
4019           (vec_select:V2SF
4020             (match_operand:V4SF 1 "nonimmediate_operand")
4021             (parallel [(const_int 2) (const_int 3)]))))]
4022   "TARGET_SSE"
4023 {
4024   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
4025
4026   emit_insn (gen_sse_loadlps (dst, operands[1], operands[2]));
4027
4028   /* Fix up the destination if needed.  */
4029   if (dst != operands[0])
4030     emit_move_insn (operands[0], dst);
4031
4032   DONE;
4033 })
4034
4035 (define_insn "sse_loadlps"
4036   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
4037         (vec_concat:V4SF
4038           (match_operand:V2SF 2 "nonimmediate_operand"   " 0,x,m,m,x")
4039           (vec_select:V2SF
4040             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0,x,0")
4041             (parallel [(const_int 2) (const_int 3)]))))]
4042   "TARGET_SSE"
4043   "@
4044    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
4045    vshufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
4046    movlps\t{%2, %0|%0, %q2}
4047    vmovlps\t{%2, %1, %0|%0, %1, %q2}
4048    %vmovlps\t{%2, %0|%q0, %2}"
4049   [(set_attr "isa" "noavx,avx,noavx,avx,*")
4050    (set_attr "type" "sseshuf,sseshuf,ssemov,ssemov,ssemov")
4051    (set_attr "length_immediate" "1,1,*,*,*")
4052    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
4053    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
4054
4055 (define_insn "sse_movss"
4056   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
4057         (vec_merge:V4SF
4058           (match_operand:V4SF 2 "register_operand" " x,x")
4059           (match_operand:V4SF 1 "register_operand" " 0,x")
4060           (const_int 1)))]
4061   "TARGET_SSE"
4062   "@
4063    movss\t{%2, %0|%0, %2}
4064    vmovss\t{%2, %1, %0|%0, %1, %2}"
4065   [(set_attr "isa" "noavx,avx")
4066    (set_attr "type" "ssemov")
4067    (set_attr "prefix" "orig,vex")
4068    (set_attr "mode" "SF")])
4069
4070 (define_insn "avx2_vec_dup<mode>"
4071   [(set (match_operand:VF1 0 "register_operand" "=x")
4072         (vec_duplicate:VF1
4073           (vec_select:SF
4074             (match_operand:V4SF 1 "register_operand" "x")
4075             (parallel [(const_int 0)]))))]
4076   "TARGET_AVX2"
4077   "vbroadcastss\t{%1, %0|%0, %1}"
4078   [(set_attr "type" "sselog1")
4079     (set_attr "prefix" "vex")
4080     (set_attr "mode" "<MODE>")])
4081
4082 (define_insn "avx2_vec_dupv8sf_1"
4083   [(set (match_operand:V8SF 0 "register_operand" "=x")
4084         (vec_duplicate:V8SF
4085           (vec_select:SF
4086             (match_operand:V8SF 1 "register_operand" "x")
4087             (parallel [(const_int 0)]))))]
4088   "TARGET_AVX2"
4089   "vbroadcastss\t{%x1, %0|%0, %x1}"
4090   [(set_attr "type" "sselog1")
4091     (set_attr "prefix" "vex")
4092     (set_attr "mode" "V8SF")])
4093
4094 (define_insn "vec_dupv4sf"
4095   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
4096         (vec_duplicate:V4SF
4097           (match_operand:SF 1 "nonimmediate_operand" "x,m,0")))]
4098   "TARGET_SSE"
4099   "@
4100    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
4101    vbroadcastss\t{%1, %0|%0, %1}
4102    shufps\t{$0, %0, %0|%0, %0, 0}"
4103   [(set_attr "isa" "avx,avx,noavx")
4104    (set_attr "type" "sseshuf1,ssemov,sseshuf1")
4105    (set_attr "length_immediate" "1,0,1")
4106    (set_attr "prefix_extra" "0,1,*")
4107    (set_attr "prefix" "vex,vex,orig")
4108    (set_attr "mode" "V4SF")])
4109
4110 ;; Although insertps takes register source, we prefer
4111 ;; unpcklps with register source since it is shorter.
4112 (define_insn "*vec_concatv2sf_sse4_1"
4113   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,x,x,*y ,*y")
4114         (vec_concat:V2SF
4115           (match_operand:SF 1 "nonimmediate_operand" " 0,x,0,x,m, 0 , m")
4116           (match_operand:SF 2 "vector_move_operand"  " x,x,m,m,C,*ym, C")))]
4117   "TARGET_SSE4_1"
4118   "@
4119    unpcklps\t{%2, %0|%0, %2}
4120    vunpcklps\t{%2, %1, %0|%0, %1, %2}
4121    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
4122    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
4123    %vmovss\t{%1, %0|%0, %1}
4124    punpckldq\t{%2, %0|%0, %2}
4125    movd\t{%1, %0|%0, %1}"
4126   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
4127    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
4128    (set_attr "prefix_data16" "*,*,1,*,*,*,*")
4129    (set_attr "prefix_extra" "*,*,1,1,*,*,*")
4130    (set_attr "length_immediate" "*,*,1,1,*,*,*")
4131    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
4132    (set_attr "mode" "V4SF,V4SF,V4SF,V4SF,SF,DI,DI")])
4133
4134 ;; ??? In theory we can match memory for the MMX alternative, but allowing
4135 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
4136 ;; alternatives pretty much forces the MMX alternative to be chosen.
4137 (define_insn "*vec_concatv2sf_sse"
4138   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
4139         (vec_concat:V2SF
4140           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
4141           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
4142   "TARGET_SSE"
4143   "@
4144    unpcklps\t{%2, %0|%0, %2}
4145    movss\t{%1, %0|%0, %1}
4146    punpckldq\t{%2, %0|%0, %2}
4147    movd\t{%1, %0|%0, %1}"
4148   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
4149    (set_attr "mode" "V4SF,SF,DI,DI")])
4150
4151 (define_insn "*vec_concatv4sf"
4152   [(set (match_operand:V4SF 0 "register_operand"       "=x,x,x,x")
4153         (vec_concat:V4SF
4154           (match_operand:V2SF 1 "register_operand"     " 0,x,0,x")
4155           (match_operand:V2SF 2 "nonimmediate_operand" " x,x,m,m")))]
4156   "TARGET_SSE"
4157   "@
4158    movlhps\t{%2, %0|%0, %2}
4159    vmovlhps\t{%2, %1, %0|%0, %1, %2}
4160    movhps\t{%2, %0|%0, %q2}
4161    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
4162   [(set_attr "isa" "noavx,avx,noavx,avx")
4163    (set_attr "type" "ssemov")
4164    (set_attr "prefix" "orig,vex,orig,vex")
4165    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF")])
4166
4167 (define_expand "vec_init<mode>"
4168   [(match_operand:V_128 0 "register_operand")
4169    (match_operand 1)]
4170   "TARGET_SSE"
4171 {
4172   ix86_expand_vector_init (false, operands[0], operands[1]);
4173   DONE;
4174 })
4175
4176 ;; Avoid combining registers from different units in a single alternative,
4177 ;; see comment above inline_secondary_memory_needed function in i386.c
4178 (define_insn "vec_set<mode>_0"
4179   [(set (match_operand:VI4F_128 0 "nonimmediate_operand"
4180           "=x,x,x ,x,x,x,x  ,x  ,m ,m   ,m")
4181         (vec_merge:VI4F_128
4182           (vec_duplicate:VI4F_128
4183             (match_operand:<ssescalarmode> 2 "general_operand"
4184           " x,m,*r,m,x,x,*rm,*rm,!x,!*re,!*fF"))
4185           (match_operand:VI4F_128 1 "vector_move_operand"
4186           " C,C,C ,C,0,x,0  ,x  ,0 ,0   ,0")
4187           (const_int 1)))]
4188   "TARGET_SSE"
4189   "@
4190    %vinsertps\t{$0xe, %d2, %0|%0, %d2, 0xe}
4191    %vmov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
4192    %vmovd\t{%2, %0|%0, %2}
4193    movss\t{%2, %0|%0, %2}
4194    movss\t{%2, %0|%0, %2}
4195    vmovss\t{%2, %1, %0|%0, %1, %2}
4196    pinsrd\t{$0, %2, %0|%0, %2, 0}
4197    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
4198    #
4199    #
4200    #"
4201   [(set_attr "isa" "sse4,sse2,sse2,noavx,noavx,avx,sse4_noavx,avx,*,*,*")
4202    (set (attr "type")
4203      (cond [(eq_attr "alternative" "0,6,7")
4204               (const_string "sselog")
4205             (eq_attr "alternative" "9")
4206               (const_string "imov")
4207             (eq_attr "alternative" "10")
4208               (const_string "fmov")
4209            ]
4210            (const_string "ssemov")))
4211    (set_attr "prefix_extra" "*,*,*,*,*,*,1,1,*,*,*")
4212    (set_attr "length_immediate" "*,*,*,*,*,*,1,1,*,*,*")
4213    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,orig,orig,vex,orig,vex,*,*,*")
4214    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,SF,SF,TI,TI,*,*,*")])
4215
4216 ;; A subset is vec_setv4sf.
4217 (define_insn "*vec_setv4sf_sse4_1"
4218   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
4219         (vec_merge:V4SF
4220           (vec_duplicate:V4SF
4221             (match_operand:SF 2 "nonimmediate_operand" "xm,xm"))
4222           (match_operand:V4SF 1 "register_operand" "0,x")
4223           (match_operand:SI 3 "const_int_operand")))]
4224   "TARGET_SSE4_1
4225    && ((unsigned) exact_log2 (INTVAL (operands[3]))
4226        < GET_MODE_NUNITS (V4SFmode))"
4227 {
4228   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
4229   switch (which_alternative)
4230     {
4231     case 0:
4232       return "insertps\t{%3, %2, %0|%0, %2, %3}";
4233     case 1:
4234       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4235     default:
4236       gcc_unreachable ();
4237     }
4238 }
4239   [(set_attr "isa" "noavx,avx")
4240    (set_attr "type" "sselog")
4241    (set_attr "prefix_data16" "1,*")
4242    (set_attr "prefix_extra" "1")
4243    (set_attr "length_immediate" "1")
4244    (set_attr "prefix" "orig,vex")
4245    (set_attr "mode" "V4SF")])
4246
4247 (define_insn "sse4_1_insertps"
4248   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
4249         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
4250                       (match_operand:V4SF 1 "register_operand" "0,x")
4251                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
4252                      UNSPEC_INSERTPS))]
4253   "TARGET_SSE4_1"
4254 {
4255   if (MEM_P (operands[2]))
4256     {
4257       unsigned count_s = INTVAL (operands[3]) >> 6;
4258       if (count_s)
4259         operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
4260       operands[2] = adjust_address_nv (operands[2], SFmode, count_s * 4);
4261     }
4262   switch (which_alternative)
4263     {
4264     case 0:
4265       return "insertps\t{%3, %2, %0|%0, %2, %3}";
4266     case 1:
4267       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4268     default:
4269       gcc_unreachable ();
4270     }
4271 }
4272   [(set_attr "isa" "noavx,avx")
4273    (set_attr "type" "sselog")
4274    (set_attr "prefix_data16" "1,*")
4275    (set_attr "prefix_extra" "1")
4276    (set_attr "length_immediate" "1")
4277    (set_attr "prefix" "orig,vex")
4278    (set_attr "mode" "V4SF")])
4279
4280 (define_split
4281   [(set (match_operand:VI4F_128 0 "memory_operand")
4282         (vec_merge:VI4F_128
4283           (vec_duplicate:VI4F_128
4284             (match_operand:<ssescalarmode> 1 "nonmemory_operand"))
4285           (match_dup 0)
4286           (const_int 1)))]
4287   "TARGET_SSE && reload_completed"
4288   [(set (match_dup 0) (match_dup 1))]
4289   "operands[0] = adjust_address (operands[0], <ssescalarmode>mode, 0);")
4290
4291 (define_expand "vec_set<mode>"
4292   [(match_operand:V 0 "register_operand")
4293    (match_operand:<ssescalarmode> 1 "register_operand")
4294    (match_operand 2 "const_int_operand")]
4295   "TARGET_SSE"
4296 {
4297   ix86_expand_vector_set (false, operands[0], operands[1],
4298                           INTVAL (operands[2]));
4299   DONE;
4300 })
4301
4302 (define_insn_and_split "*vec_extractv4sf_0"
4303   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
4304         (vec_select:SF
4305           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
4306           (parallel [(const_int 0)])))]
4307   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4308   "#"
4309   "&& reload_completed"
4310   [(set (match_dup 0) (match_dup 1))]
4311 {
4312   if (REG_P (operands[1]))
4313     operands[1] = gen_rtx_REG (SFmode, REGNO (operands[1]));
4314   else
4315     operands[1] = adjust_address (operands[1], SFmode, 0);
4316 })
4317
4318 (define_insn_and_split "*sse4_1_extractps"
4319   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm,x,x")
4320         (vec_select:SF
4321           (match_operand:V4SF 1 "register_operand" "x,0,x")
4322           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n,n,n")])))]
4323   "TARGET_SSE4_1"
4324   "@
4325    %vextractps\t{%2, %1, %0|%0, %1, %2}
4326    #
4327    #"
4328   "&& reload_completed && SSE_REG_P (operands[0])"
4329   [(const_int 0)]
4330 {
4331   rtx dest = gen_rtx_REG (V4SFmode, REGNO (operands[0]));
4332   switch (INTVAL (operands[2]))
4333     {
4334     case 1:
4335     case 3:
4336       emit_insn (gen_sse_shufps_v4sf (dest, operands[1], operands[1],
4337                                       operands[2], operands[2],
4338                                       GEN_INT (INTVAL (operands[2]) + 4),
4339                                       GEN_INT (INTVAL (operands[2]) + 4)));
4340       break;
4341     case 2:
4342       emit_insn (gen_vec_interleave_highv4sf (dest, operands[1], operands[1]));
4343       break;
4344     default:
4345       /* 0 should be handled by the *vec_extractv4sf_0 pattern above.  */
4346       gcc_unreachable ();
4347     }
4348   DONE;
4349 }
4350   [(set_attr "isa" "*,noavx,avx")
4351    (set_attr "type" "sselog,*,*")
4352    (set_attr "prefix_data16" "1,*,*")
4353    (set_attr "prefix_extra" "1,*,*")
4354    (set_attr "length_immediate" "1,*,*")
4355    (set_attr "prefix" "maybe_vex,*,*")
4356    (set_attr "mode" "V4SF,*,*")])
4357
4358 (define_insn_and_split "*vec_extractv4sf_mem"
4359   [(set (match_operand:SF 0 "register_operand" "=x,*r,f")
4360         (vec_select:SF
4361           (match_operand:V4SF 1 "memory_operand" "o,o,o")
4362           (parallel [(match_operand 2 "const_0_to_3_operand" "n,n,n")])))]
4363   "TARGET_SSE"
4364   "#"
4365   "&& reload_completed"
4366   [(set (match_dup 0) (match_dup 1))]
4367 {
4368   operands[1] = adjust_address (operands[1], SFmode, INTVAL (operands[2]) * 4);
4369 })
4370
4371 (define_expand "avx_vextractf128<mode>"
4372   [(match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
4373    (match_operand:V_256 1 "register_operand")
4374    (match_operand:SI 2 "const_0_to_1_operand")]
4375   "TARGET_AVX"
4376 {
4377   rtx (*insn)(rtx, rtx);
4378
4379   switch (INTVAL (operands[2]))
4380     {
4381     case 0:
4382       insn = gen_vec_extract_lo_<mode>;
4383       break;
4384     case 1:
4385       insn = gen_vec_extract_hi_<mode>;
4386       break;
4387     default:
4388       gcc_unreachable ();
4389     }
4390
4391   emit_insn (insn (operands[0], operands[1]));
4392   DONE;
4393 })
4394
4395 (define_insn_and_split "vec_extract_lo_<mode>"
4396   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
4397         (vec_select:<ssehalfvecmode>
4398           (match_operand:VI8F_256 1 "nonimmediate_operand" "xm,x")
4399           (parallel [(const_int 0) (const_int 1)])))]
4400   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4401   "#"
4402   "&& reload_completed"
4403   [(set (match_dup 0) (match_dup 1))]
4404 {
4405   if (REG_P (operands[1]))
4406     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
4407   else
4408     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
4409 })
4410
4411 (define_insn "vec_extract_hi_<mode>"
4412   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
4413         (vec_select:<ssehalfvecmode>
4414           (match_operand:VI8F_256 1 "register_operand" "x,x")
4415           (parallel [(const_int 2) (const_int 3)])))]
4416   "TARGET_AVX"
4417   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
4418   [(set_attr "type" "sselog")
4419    (set_attr "prefix_extra" "1")
4420    (set_attr "length_immediate" "1")
4421    (set_attr "memory" "none,store")
4422    (set_attr "prefix" "vex")
4423    (set_attr "mode" "<sseinsnmode>")])
4424
4425 (define_insn_and_split "vec_extract_lo_<mode>"
4426   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
4427         (vec_select:<ssehalfvecmode>
4428           (match_operand:VI4F_256 1 "nonimmediate_operand" "xm,x")
4429           (parallel [(const_int 0) (const_int 1)
4430                      (const_int 2) (const_int 3)])))]
4431   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4432   "#"
4433   "&& reload_completed"
4434   [(set (match_dup 0) (match_dup 1))]
4435 {
4436   if (REG_P (operands[1]))
4437     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
4438   else
4439     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
4440 })
4441
4442 (define_insn "vec_extract_hi_<mode>"
4443   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
4444         (vec_select:<ssehalfvecmode>
4445           (match_operand:VI4F_256 1 "register_operand" "x,x")
4446           (parallel [(const_int 4) (const_int 5)
4447                      (const_int 6) (const_int 7)])))]
4448   "TARGET_AVX"
4449   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
4450   [(set_attr "type" "sselog")
4451    (set_attr "prefix_extra" "1")
4452    (set_attr "length_immediate" "1")
4453    (set_attr "memory" "none,store")
4454    (set_attr "prefix" "vex")
4455    (set_attr "mode" "<sseinsnmode>")])
4456
4457 (define_insn_and_split "vec_extract_lo_v16hi"
4458   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4459         (vec_select:V8HI
4460           (match_operand:V16HI 1 "nonimmediate_operand" "xm,x")
4461           (parallel [(const_int 0) (const_int 1)
4462                      (const_int 2) (const_int 3)
4463                      (const_int 4) (const_int 5)
4464                      (const_int 6) (const_int 7)])))]
4465   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4466   "#"
4467   "&& reload_completed"
4468   [(set (match_dup 0) (match_dup 1))]
4469 {
4470   if (REG_P (operands[1]))
4471     operands[1] = gen_rtx_REG (V8HImode, REGNO (operands[1]));
4472   else
4473     operands[1] = adjust_address (operands[1], V8HImode, 0);
4474 })
4475
4476 (define_insn "vec_extract_hi_v16hi"
4477   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
4478         (vec_select:V8HI
4479           (match_operand:V16HI 1 "register_operand" "x,x")
4480           (parallel [(const_int 8) (const_int 9)
4481                      (const_int 10) (const_int 11)
4482                      (const_int 12) (const_int 13)
4483                      (const_int 14) (const_int 15)])))]
4484   "TARGET_AVX"
4485   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
4486   [(set_attr "type" "sselog")
4487    (set_attr "prefix_extra" "1")
4488    (set_attr "length_immediate" "1")
4489    (set_attr "memory" "none,store")
4490    (set_attr "prefix" "vex")
4491    (set_attr "mode" "OI")])
4492
4493 (define_insn_and_split "vec_extract_lo_v32qi"
4494   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4495         (vec_select:V16QI
4496           (match_operand:V32QI 1 "nonimmediate_operand" "xm,x")
4497           (parallel [(const_int 0) (const_int 1)
4498                      (const_int 2) (const_int 3)
4499                      (const_int 4) (const_int 5)
4500                      (const_int 6) (const_int 7)
4501                      (const_int 8) (const_int 9)
4502                      (const_int 10) (const_int 11)
4503                      (const_int 12) (const_int 13)
4504                      (const_int 14) (const_int 15)])))]
4505   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4506   "#"
4507   "&& reload_completed"
4508   [(set (match_dup 0) (match_dup 1))]
4509 {
4510   if (REG_P (operands[1]))
4511     operands[1] = gen_rtx_REG (V16QImode, REGNO (operands[1]));
4512   else
4513     operands[1] = adjust_address (operands[1], V16QImode, 0);
4514 })
4515
4516 (define_insn "vec_extract_hi_v32qi"
4517   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
4518         (vec_select:V16QI
4519           (match_operand:V32QI 1 "register_operand" "x,x")
4520           (parallel [(const_int 16) (const_int 17)
4521                      (const_int 18) (const_int 19)
4522                      (const_int 20) (const_int 21)
4523                      (const_int 22) (const_int 23)
4524                      (const_int 24) (const_int 25)
4525                      (const_int 26) (const_int 27)
4526                      (const_int 28) (const_int 29)
4527                      (const_int 30) (const_int 31)])))]
4528   "TARGET_AVX"
4529   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
4530   [(set_attr "type" "sselog")
4531    (set_attr "prefix_extra" "1")
4532    (set_attr "length_immediate" "1")
4533    (set_attr "memory" "none,store")
4534    (set_attr "prefix" "vex")
4535    (set_attr "mode" "OI")])
4536
4537 ;; Modes handled by vec_extract patterns.
4538 (define_mode_iterator VEC_EXTRACT_MODE
4539   [(V32QI "TARGET_AVX") V16QI
4540    (V16HI "TARGET_AVX") V8HI
4541    (V8SI "TARGET_AVX") V4SI
4542    (V4DI "TARGET_AVX") V2DI
4543    (V8SF "TARGET_AVX") V4SF
4544    (V4DF "TARGET_AVX") V2DF])
4545
4546 (define_expand "vec_extract<mode>"
4547   [(match_operand:<ssescalarmode> 0 "register_operand")
4548    (match_operand:VEC_EXTRACT_MODE 1 "register_operand")
4549    (match_operand 2 "const_int_operand")]
4550   "TARGET_SSE"
4551 {
4552   ix86_expand_vector_extract (false, operands[0], operands[1],
4553                               INTVAL (operands[2]));
4554   DONE;
4555 })
4556
4557 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4558 ;;
4559 ;; Parallel double-precision floating point element swizzling
4560 ;;
4561 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4562
4563 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4564 (define_insn "avx_unpckhpd256"
4565   [(set (match_operand:V4DF 0 "register_operand" "=x")
4566         (vec_select:V4DF
4567           (vec_concat:V8DF
4568             (match_operand:V4DF 1 "register_operand" "x")
4569             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4570           (parallel [(const_int 1) (const_int 5)
4571                      (const_int 3) (const_int 7)])))]
4572   "TARGET_AVX"
4573   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
4574   [(set_attr "type" "sselog")
4575    (set_attr "prefix" "vex")
4576    (set_attr "mode" "V4DF")])
4577
4578 (define_expand "vec_interleave_highv4df"
4579   [(set (match_dup 3)
4580         (vec_select:V4DF
4581           (vec_concat:V8DF
4582             (match_operand:V4DF 1 "register_operand" "x")
4583             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4584           (parallel [(const_int 0) (const_int 4)
4585                      (const_int 2) (const_int 6)])))
4586    (set (match_dup 4)
4587         (vec_select:V4DF
4588           (vec_concat:V8DF
4589             (match_dup 1)
4590             (match_dup 2))
4591           (parallel [(const_int 1) (const_int 5)
4592                      (const_int 3) (const_int 7)])))
4593    (set (match_operand:V4DF 0 "register_operand")
4594         (vec_select:V4DF
4595           (vec_concat:V8DF
4596             (match_dup 3)
4597             (match_dup 4))
4598           (parallel [(const_int 2) (const_int 3)
4599                      (const_int 6) (const_int 7)])))]
4600  "TARGET_AVX"
4601 {
4602   operands[3] = gen_reg_rtx (V4DFmode);
4603   operands[4] = gen_reg_rtx (V4DFmode);
4604 })
4605
4606
4607 (define_expand "vec_interleave_highv2df"
4608   [(set (match_operand:V2DF 0 "register_operand")
4609         (vec_select:V2DF
4610           (vec_concat:V4DF
4611             (match_operand:V2DF 1 "nonimmediate_operand")
4612             (match_operand:V2DF 2 "nonimmediate_operand"))
4613           (parallel [(const_int 1)
4614                      (const_int 3)])))]
4615   "TARGET_SSE2"
4616 {
4617   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
4618     operands[2] = force_reg (V2DFmode, operands[2]);
4619 })
4620
4621 (define_insn "*vec_interleave_highv2df"
4622   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,m")
4623         (vec_select:V2DF
4624           (vec_concat:V4DF
4625             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,o,o,o,x")
4626             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,0,x,0"))
4627           (parallel [(const_int 1)
4628                      (const_int 3)])))]
4629   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
4630   "@
4631    unpckhpd\t{%2, %0|%0, %2}
4632    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
4633    %vmovddup\t{%H1, %0|%0, %H1}
4634    movlpd\t{%H1, %0|%0, %H1}
4635    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
4636    %vmovhpd\t{%1, %0|%q0, %1}"
4637   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
4638   (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
4639    (set_attr "prefix_data16" "*,*,*,1,*,1")
4640    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
4641    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
4642
4643 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4644 (define_expand "avx_movddup256"
4645   [(set (match_operand:V4DF 0 "register_operand")
4646         (vec_select:V4DF
4647           (vec_concat:V8DF
4648             (match_operand:V4DF 1 "nonimmediate_operand")
4649             (match_dup 1))
4650           (parallel [(const_int 0) (const_int 4)
4651                      (const_int 2) (const_int 6)])))]
4652   "TARGET_AVX")
4653
4654 (define_expand "avx_unpcklpd256"
4655   [(set (match_operand:V4DF 0 "register_operand")
4656         (vec_select:V4DF
4657           (vec_concat:V8DF
4658             (match_operand:V4DF 1 "register_operand")
4659             (match_operand:V4DF 2 "nonimmediate_operand"))
4660           (parallel [(const_int 0) (const_int 4)
4661                      (const_int 2) (const_int 6)])))]
4662   "TARGET_AVX")
4663
4664 (define_insn "*avx_unpcklpd256"
4665   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
4666         (vec_select:V4DF
4667           (vec_concat:V8DF
4668             (match_operand:V4DF 1 "nonimmediate_operand" " x,m")
4669             (match_operand:V4DF 2 "nonimmediate_operand" "xm,1"))
4670           (parallel [(const_int 0) (const_int 4)
4671                      (const_int 2) (const_int 6)])))]
4672   "TARGET_AVX"
4673   "@
4674    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4675    vmovddup\t{%1, %0|%0, %1}"
4676   [(set_attr "type" "sselog")
4677    (set_attr "prefix" "vex")
4678    (set_attr "mode" "V4DF")])
4679
4680 (define_expand "vec_interleave_lowv4df"
4681   [(set (match_dup 3)
4682         (vec_select:V4DF
4683           (vec_concat:V8DF
4684             (match_operand:V4DF 1 "register_operand" "x")
4685             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4686           (parallel [(const_int 0) (const_int 4)
4687                      (const_int 2) (const_int 6)])))
4688    (set (match_dup 4)
4689         (vec_select:V4DF
4690           (vec_concat:V8DF
4691             (match_dup 1)
4692             (match_dup 2))
4693           (parallel [(const_int 1) (const_int 5)
4694                      (const_int 3) (const_int 7)])))
4695    (set (match_operand:V4DF 0 "register_operand")
4696         (vec_select:V4DF
4697           (vec_concat:V8DF
4698             (match_dup 3)
4699             (match_dup 4))
4700           (parallel [(const_int 0) (const_int 1)
4701                      (const_int 4) (const_int 5)])))]
4702  "TARGET_AVX"
4703 {
4704   operands[3] = gen_reg_rtx (V4DFmode);
4705   operands[4] = gen_reg_rtx (V4DFmode);
4706 })
4707
4708 (define_expand "vec_interleave_lowv2df"
4709   [(set (match_operand:V2DF 0 "register_operand")
4710         (vec_select:V2DF
4711           (vec_concat:V4DF
4712             (match_operand:V2DF 1 "nonimmediate_operand")
4713             (match_operand:V2DF 2 "nonimmediate_operand"))
4714           (parallel [(const_int 0)
4715                      (const_int 2)])))]
4716   "TARGET_SSE2"
4717 {
4718   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
4719     operands[1] = force_reg (V2DFmode, operands[1]);
4720 })
4721
4722 (define_insn "*vec_interleave_lowv2df"
4723   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,o")
4724         (vec_select:V2DF
4725           (vec_concat:V4DF
4726             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,m,0,x,0")
4727             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,m,m,x"))
4728           (parallel [(const_int 0)
4729                      (const_int 2)])))]
4730   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
4731   "@
4732    unpcklpd\t{%2, %0|%0, %2}
4733    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
4734    %vmovddup\t{%1, %0|%0, %q1}
4735    movhpd\t{%2, %0|%0, %q2}
4736    vmovhpd\t{%2, %1, %0|%0, %1, %q2}
4737    %vmovlpd\t{%2, %H0|%H0, %2}"
4738   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
4739    (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
4740    (set_attr "prefix_data16" "*,*,*,1,*,1")
4741    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
4742    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
4743
4744 (define_split
4745   [(set (match_operand:V2DF 0 "memory_operand")
4746         (vec_select:V2DF
4747           (vec_concat:V4DF
4748             (match_operand:V2DF 1 "register_operand")
4749             (match_dup 1))
4750           (parallel [(const_int 0)
4751                      (const_int 2)])))]
4752   "TARGET_SSE3 && reload_completed"
4753   [(const_int 0)]
4754 {
4755   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
4756   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
4757   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
4758   DONE;
4759 })
4760
4761 (define_split
4762   [(set (match_operand:V2DF 0 "register_operand")
4763         (vec_select:V2DF
4764           (vec_concat:V4DF
4765             (match_operand:V2DF 1 "memory_operand")
4766             (match_dup 1))
4767           (parallel [(match_operand:SI 2 "const_0_to_1_operand")
4768                      (match_operand:SI 3 "const_int_operand")])))]
4769   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
4770   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
4771 {
4772   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
4773 })
4774
4775 (define_expand "avx_shufpd256"
4776   [(match_operand:V4DF 0 "register_operand")
4777    (match_operand:V4DF 1 "register_operand")
4778    (match_operand:V4DF 2 "nonimmediate_operand")
4779    (match_operand:SI 3 "const_int_operand")]
4780   "TARGET_AVX"
4781 {
4782   int mask = INTVAL (operands[3]);
4783   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
4784                                    GEN_INT (mask & 1),
4785                                    GEN_INT (mask & 2 ? 5 : 4),
4786                                    GEN_INT (mask & 4 ? 3 : 2),
4787                                    GEN_INT (mask & 8 ? 7 : 6)));
4788   DONE;
4789 })
4790
4791 (define_insn "avx_shufpd256_1"
4792   [(set (match_operand:V4DF 0 "register_operand" "=x")
4793         (vec_select:V4DF
4794           (vec_concat:V8DF
4795             (match_operand:V4DF 1 "register_operand" "x")
4796             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
4797           (parallel [(match_operand 3 "const_0_to_1_operand")
4798                      (match_operand 4 "const_4_to_5_operand")
4799                      (match_operand 5 "const_2_to_3_operand")
4800                      (match_operand 6 "const_6_to_7_operand")])))]
4801   "TARGET_AVX"
4802 {
4803   int mask;
4804   mask = INTVAL (operands[3]);
4805   mask |= (INTVAL (operands[4]) - 4) << 1;
4806   mask |= (INTVAL (operands[5]) - 2) << 2;
4807   mask |= (INTVAL (operands[6]) - 6) << 3;
4808   operands[3] = GEN_INT (mask);
4809
4810   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4811 }
4812   [(set_attr "type" "sseshuf")
4813    (set_attr "length_immediate" "1")
4814    (set_attr "prefix" "vex")
4815    (set_attr "mode" "V4DF")])
4816
4817 (define_expand "sse2_shufpd"
4818   [(match_operand:V2DF 0 "register_operand")
4819    (match_operand:V2DF 1 "register_operand")
4820    (match_operand:V2DF 2 "nonimmediate_operand")
4821    (match_operand:SI 3 "const_int_operand")]
4822   "TARGET_SSE2"
4823 {
4824   int mask = INTVAL (operands[3]);
4825   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
4826                                 GEN_INT (mask & 1),
4827                                 GEN_INT (mask & 2 ? 3 : 2)));
4828   DONE;
4829 })
4830
4831 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
4832 (define_insn "avx2_interleave_highv4di"
4833   [(set (match_operand:V4DI 0 "register_operand" "=x")
4834         (vec_select:V4DI
4835           (vec_concat:V8DI
4836             (match_operand:V4DI 1 "register_operand" "x")
4837             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
4838           (parallel [(const_int 1)
4839                      (const_int 5)
4840                      (const_int 3)
4841                      (const_int 7)])))]
4842   "TARGET_AVX2"
4843   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4844   [(set_attr "type" "sselog")
4845    (set_attr "prefix" "vex")
4846    (set_attr "mode" "OI")])
4847
4848 (define_insn "vec_interleave_highv2di"
4849   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
4850         (vec_select:V2DI
4851           (vec_concat:V4DI
4852             (match_operand:V2DI 1 "register_operand" "0,x")
4853             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
4854           (parallel [(const_int 1)
4855                      (const_int 3)])))]
4856   "TARGET_SSE2"
4857   "@
4858    punpckhqdq\t{%2, %0|%0, %2}
4859    vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
4860   [(set_attr "isa" "noavx,avx")
4861    (set_attr "type" "sselog")
4862    (set_attr "prefix_data16" "1,*")
4863    (set_attr "prefix" "orig,vex")
4864    (set_attr "mode" "TI")])
4865
4866 (define_insn "avx2_interleave_lowv4di"
4867   [(set (match_operand:V4DI 0 "register_operand" "=x")
4868         (vec_select:V4DI
4869           (vec_concat:V8DI
4870             (match_operand:V4DI 1 "register_operand" "x")
4871             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
4872           (parallel [(const_int 0)
4873                      (const_int 4)
4874                      (const_int 2)
4875                      (const_int 6)])))]
4876   "TARGET_AVX2"
4877   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4878   [(set_attr "type" "sselog")
4879    (set_attr "prefix" "vex")
4880    (set_attr "mode" "OI")])
4881
4882 (define_insn "vec_interleave_lowv2di"
4883   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
4884         (vec_select:V2DI
4885           (vec_concat:V4DI
4886             (match_operand:V2DI 1 "register_operand" "0,x")
4887             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
4888           (parallel [(const_int 0)
4889                      (const_int 2)])))]
4890   "TARGET_SSE2"
4891   "@
4892    punpcklqdq\t{%2, %0|%0, %2}
4893    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
4894   [(set_attr "isa" "noavx,avx")
4895    (set_attr "type" "sselog")
4896    (set_attr "prefix_data16" "1,*")
4897    (set_attr "prefix" "orig,vex")
4898    (set_attr "mode" "TI")])
4899
4900 (define_insn "sse2_shufpd_<mode>"
4901   [(set (match_operand:VI8F_128 0 "register_operand" "=x,x")
4902         (vec_select:VI8F_128
4903           (vec_concat:<ssedoublevecmode>
4904             (match_operand:VI8F_128 1 "register_operand" "0,x")
4905             (match_operand:VI8F_128 2 "nonimmediate_operand" "xm,xm"))
4906           (parallel [(match_operand 3 "const_0_to_1_operand")
4907                      (match_operand 4 "const_2_to_3_operand")])))]
4908   "TARGET_SSE2"
4909 {
4910   int mask;
4911   mask = INTVAL (operands[3]);
4912   mask |= (INTVAL (operands[4]) - 2) << 1;
4913   operands[3] = GEN_INT (mask);
4914
4915   switch (which_alternative)
4916     {
4917     case 0:
4918       return "shufpd\t{%3, %2, %0|%0, %2, %3}";
4919     case 1:
4920       return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4921     default:
4922       gcc_unreachable ();
4923     }
4924 }
4925   [(set_attr "isa" "noavx,avx")
4926    (set_attr "type" "sseshuf")
4927    (set_attr "length_immediate" "1")
4928    (set_attr "prefix" "orig,vex")
4929    (set_attr "mode" "V2DF")])
4930
4931 ;; Avoid combining registers from different units in a single alternative,
4932 ;; see comment above inline_secondary_memory_needed function in i386.c
4933 (define_insn "sse2_storehpd"
4934   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,x,*f,r")
4935         (vec_select:DF
4936           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,x,o,o,o")
4937           (parallel [(const_int 1)])))]
4938   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4939   "@
4940    %vmovhpd\t{%1, %0|%0, %1}
4941    unpckhpd\t%0, %0
4942    vunpckhpd\t{%d1, %0|%0, %d1}
4943    #
4944    #
4945    #"
4946   [(set_attr "isa" "*,noavx,avx,*,*,*")
4947    (set_attr "type" "ssemov,sselog1,sselog1,ssemov,fmov,imov")
4948    (set (attr "prefix_data16")
4949      (if_then_else
4950        (and (eq_attr "alternative" "0")
4951             (not (match_test "TARGET_AVX")))
4952        (const_string "1")
4953        (const_string "*")))
4954    (set_attr "prefix" "maybe_vex,orig,vex,*,*,*")
4955    (set_attr "mode" "V1DF,V1DF,V2DF,DF,DF,DF")])
4956
4957 (define_split
4958   [(set (match_operand:DF 0 "register_operand")
4959         (vec_select:DF
4960           (match_operand:V2DF 1 "memory_operand")
4961           (parallel [(const_int 1)])))]
4962   "TARGET_SSE2 && reload_completed"
4963   [(set (match_dup 0) (match_dup 1))]
4964   "operands[1] = adjust_address (operands[1], DFmode, 8);")
4965
4966 (define_insn "*vec_extractv2df_1_sse"
4967   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
4968         (vec_select:DF
4969           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
4970           (parallel [(const_int 1)])))]
4971   "!TARGET_SSE2 && TARGET_SSE
4972    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4973   "@
4974    movhps\t{%1, %0|%q0, %1}
4975    movhlps\t{%1, %0|%0, %1}
4976    movlps\t{%H1, %0|%0, %H1}"
4977   [(set_attr "type" "ssemov")
4978    (set_attr "mode" "V2SF,V4SF,V2SF")])
4979
4980 ;; Avoid combining registers from different units in a single alternative,
4981 ;; see comment above inline_secondary_memory_needed function in i386.c
4982 (define_insn "sse2_storelpd"
4983   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
4984         (vec_select:DF
4985           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
4986           (parallel [(const_int 0)])))]
4987   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4988   "@
4989    %vmovlpd\t{%1, %0|%0, %1}
4990    #
4991    #
4992    #
4993    #"
4994   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
4995    (set_attr "prefix_data16" "1,*,*,*,*")
4996    (set_attr "prefix" "maybe_vex")
4997    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
4998
4999 (define_split
5000   [(set (match_operand:DF 0 "register_operand")
5001         (vec_select:DF
5002           (match_operand:V2DF 1 "nonimmediate_operand")
5003           (parallel [(const_int 0)])))]
5004   "TARGET_SSE2 && reload_completed"
5005   [(set (match_dup 0) (match_dup 1))]
5006 {
5007   if (REG_P (operands[1]))
5008     operands[1] = gen_rtx_REG (DFmode, REGNO (operands[1]));
5009   else
5010     operands[1] = adjust_address (operands[1], DFmode, 0);
5011 })
5012
5013 (define_insn "*vec_extractv2df_0_sse"
5014   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
5015         (vec_select:DF
5016           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
5017           (parallel [(const_int 0)])))]
5018   "!TARGET_SSE2 && TARGET_SSE
5019    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5020   "@
5021    movlps\t{%1, %0|%0, %1}
5022    movaps\t{%1, %0|%0, %1}
5023    movlps\t{%1, %0|%0, %q1}"
5024   [(set_attr "type" "ssemov")
5025    (set_attr "mode" "V2SF,V4SF,V2SF")])
5026
5027 (define_expand "sse2_loadhpd_exp"
5028   [(set (match_operand:V2DF 0 "nonimmediate_operand")
5029         (vec_concat:V2DF
5030           (vec_select:DF
5031             (match_operand:V2DF 1 "nonimmediate_operand")
5032             (parallel [(const_int 0)]))
5033           (match_operand:DF 2 "nonimmediate_operand")))]
5034   "TARGET_SSE2"
5035 {
5036   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
5037
5038   emit_insn (gen_sse2_loadhpd (dst, operands[1], operands[2]));
5039
5040   /* Fix up the destination if needed.  */
5041   if (dst != operands[0])
5042     emit_move_insn (operands[0], dst);
5043
5044   DONE;
5045 })
5046
5047 ;; Avoid combining registers from different units in a single alternative,
5048 ;; see comment above inline_secondary_memory_needed function in i386.c
5049 (define_insn "sse2_loadhpd"
5050   [(set (match_operand:V2DF 0 "nonimmediate_operand"
5051           "=x,x,x,x,o,o ,o")
5052         (vec_concat:V2DF
5053           (vec_select:DF
5054             (match_operand:V2DF 1 "nonimmediate_operand"
5055           " 0,x,0,x,0,0 ,0")
5056             (parallel [(const_int 0)]))
5057           (match_operand:DF 2 "nonimmediate_operand"
5058           " m,m,x,x,x,*f,r")))]
5059   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
5060   "@
5061    movhpd\t{%2, %0|%0, %2}
5062    vmovhpd\t{%2, %1, %0|%0, %1, %2}
5063    unpcklpd\t{%2, %0|%0, %2}
5064    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
5065    #
5066    #
5067    #"
5068   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
5069    (set_attr "type" "ssemov,ssemov,sselog,sselog,ssemov,fmov,imov")
5070    (set_attr "prefix_data16" "1,*,*,*,*,*,*")
5071    (set_attr "prefix" "orig,vex,orig,vex,*,*,*")
5072    (set_attr "mode" "V1DF,V1DF,V2DF,V2DF,DF,DF,DF")])
5073
5074 (define_split
5075   [(set (match_operand:V2DF 0 "memory_operand")
5076         (vec_concat:V2DF
5077           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
5078           (match_operand:DF 1 "register_operand")))]
5079   "TARGET_SSE2 && reload_completed"
5080   [(set (match_dup 0) (match_dup 1))]
5081   "operands[0] = adjust_address (operands[0], DFmode, 8);")
5082
5083 (define_expand "sse2_loadlpd_exp"
5084   [(set (match_operand:V2DF 0 "nonimmediate_operand")
5085         (vec_concat:V2DF
5086           (match_operand:DF 2 "nonimmediate_operand")
5087           (vec_select:DF
5088             (match_operand:V2DF 1 "nonimmediate_operand")
5089             (parallel [(const_int 1)]))))]
5090   "TARGET_SSE2"
5091 {
5092   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
5093
5094   emit_insn (gen_sse2_loadlpd (dst, operands[1], operands[2]));
5095
5096   /* Fix up the destination if needed.  */
5097   if (dst != operands[0])
5098     emit_move_insn (operands[0], dst);
5099
5100   DONE;
5101 })
5102
5103 ;; Avoid combining registers from different units in a single alternative,
5104 ;; see comment above inline_secondary_memory_needed function in i386.c
5105 (define_insn "sse2_loadlpd"
5106   [(set (match_operand:V2DF 0 "nonimmediate_operand"
5107           "=x,x,x,x,x,x,x,x,m,m ,m")
5108         (vec_concat:V2DF
5109           (match_operand:DF 2 "nonimmediate_operand"
5110           " m,m,m,x,x,0,0,x,x,*f,r")
5111           (vec_select:DF
5112             (match_operand:V2DF 1 "vector_move_operand"
5113           " C,0,x,0,x,x,o,o,0,0 ,0")
5114             (parallel [(const_int 1)]))))]
5115   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
5116   "@
5117    %vmovsd\t{%2, %0|%0, %2}
5118    movlpd\t{%2, %0|%0, %2}
5119    vmovlpd\t{%2, %1, %0|%0, %1, %2}
5120    movsd\t{%2, %0|%0, %2}
5121    vmovsd\t{%2, %1, %0|%0, %1, %2}
5122    shufpd\t{$2, %1, %0|%0, %1, 2}
5123    movhpd\t{%H1, %0|%0, %H1}
5124    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
5125    #
5126    #
5127    #"
5128   [(set_attr "isa" "*,noavx,avx,noavx,avx,noavx,noavx,avx,*,*,*")
5129    (set (attr "type")
5130      (cond [(eq_attr "alternative" "5")
5131               (const_string "sselog")
5132             (eq_attr "alternative" "9")
5133               (const_string "fmov")
5134             (eq_attr "alternative" "10")
5135               (const_string "imov")
5136            ]
5137            (const_string "ssemov")))
5138    (set_attr "prefix_data16" "*,1,*,*,*,*,1,*,*,*,*")
5139    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*,*,*")
5140    (set_attr "prefix" "maybe_vex,orig,vex,orig,vex,orig,orig,vex,*,*,*")
5141    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,DF,DF,DF")])
5142
5143 (define_split
5144   [(set (match_operand:V2DF 0 "memory_operand")
5145         (vec_concat:V2DF
5146           (match_operand:DF 1 "register_operand")
5147           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
5148   "TARGET_SSE2 && reload_completed"
5149   [(set (match_dup 0) (match_dup 1))]
5150   "operands[0] = adjust_address (operands[0], DFmode, 0);")
5151
5152 (define_insn "sse2_movsd"
5153   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,x,x,m,x,x,x,o")
5154         (vec_merge:V2DF
5155           (match_operand:V2DF 2 "nonimmediate_operand" " x,x,m,m,x,0,0,x,0")
5156           (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,0,x,0,x,o,o,x")
5157           (const_int 1)))]
5158   "TARGET_SSE2"
5159   "@
5160    movsd\t{%2, %0|%0, %2}
5161    vmovsd\t{%2, %1, %0|%0, %1, %2}
5162    movlpd\t{%2, %0|%0, %q2}
5163    vmovlpd\t{%2, %1, %0|%0, %1, %q2}
5164    %vmovlpd\t{%2, %0|%q0, %2}
5165    shufpd\t{$2, %1, %0|%0, %1, 2}
5166    movhps\t{%H1, %0|%0, %H1}
5167    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
5168    %vmovhps\t{%1, %H0|%H0, %1}"
5169   [(set_attr "isa" "noavx,avx,noavx,avx,*,noavx,noavx,avx,*")
5170    (set (attr "type")
5171      (if_then_else
5172        (eq_attr "alternative" "5")
5173        (const_string "sselog")
5174        (const_string "ssemov")))
5175    (set (attr "prefix_data16")
5176      (if_then_else
5177        (and (eq_attr "alternative" "2,4")
5178             (not (match_test "TARGET_AVX")))
5179        (const_string "1")
5180        (const_string "*")))
5181    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*")
5182    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig,vex,maybe_vex")
5183    (set_attr "mode" "DF,DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,V1DF")])
5184
5185 (define_insn "vec_dupv2df"
5186   [(set (match_operand:V2DF 0 "register_operand"     "=x,x")
5187         (vec_duplicate:V2DF
5188           (match_operand:DF 1 "nonimmediate_operand" " 0,xm")))]
5189   "TARGET_SSE2"
5190   "@
5191    unpcklpd\t%0, %0
5192    %vmovddup\t{%1, %0|%0, %1}"
5193   [(set_attr "isa" "noavx,sse3")
5194    (set_attr "type" "sselog1")
5195    (set_attr "prefix" "orig,maybe_vex")
5196    (set_attr "mode" "V2DF,DF")])
5197
5198 (define_insn "*vec_concatv2df"
5199   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x,x,x,x,x,x")
5200         (vec_concat:V2DF
5201           (match_operand:DF 1 "nonimmediate_operand" " 0,x,m,0,x,m,0,0")
5202           (match_operand:DF 2 "vector_move_operand"  " x,x,1,m,m,C,x,m")))]
5203   "TARGET_SSE"
5204   "@
5205    unpcklpd\t{%2, %0|%0, %2}
5206    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
5207    %vmovddup\t{%1, %0|%0, %1}
5208    movhpd\t{%2, %0|%0, %2}
5209    vmovhpd\t{%2, %1, %0|%0, %1, %2}
5210    %vmovsd\t{%1, %0|%0, %1}
5211    movlhps\t{%2, %0|%0, %2}
5212    movhps\t{%2, %0|%0, %2}"
5213   [(set_attr "isa" "sse2_noavx,avx,sse3,sse2_noavx,avx,sse2,noavx,noavx")
5214    (set (attr "type")
5215      (if_then_else
5216        (eq_attr "alternative" "0,1,2")
5217        (const_string "sselog")
5218        (const_string "ssemov")))
5219    (set_attr "prefix_data16" "*,*,*,1,*,*,*,*")
5220    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex,orig,orig")
5221    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,DF,V4SF,V2SF")])
5222
5223 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5224 ;;
5225 ;; Parallel integral arithmetic
5226 ;;
5227 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5228
5229 (define_expand "neg<mode>2"
5230   [(set (match_operand:VI_AVX2 0 "register_operand")
5231         (minus:VI_AVX2
5232           (match_dup 2)
5233           (match_operand:VI_AVX2 1 "nonimmediate_operand")))]
5234   "TARGET_SSE2"
5235   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
5236
5237 (define_expand "<plusminus_insn><mode>3"
5238   [(set (match_operand:VI_AVX2 0 "register_operand")
5239         (plusminus:VI_AVX2
5240           (match_operand:VI_AVX2 1 "nonimmediate_operand")
5241           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
5242   "TARGET_SSE2"
5243   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5244
5245 (define_insn "*<plusminus_insn><mode>3"
5246   [(set (match_operand:VI_AVX2 0 "register_operand" "=x,x")
5247         (plusminus:VI_AVX2
5248           (match_operand:VI_AVX2 1 "nonimmediate_operand" "<comm>0,x")
5249           (match_operand:VI_AVX2 2 "nonimmediate_operand" "xm,xm")))]
5250   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5251   "@
5252    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
5253    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5254   [(set_attr "isa" "noavx,avx")
5255    (set_attr "type" "sseiadd")
5256    (set_attr "prefix_data16" "1,*")
5257    (set_attr "prefix" "orig,vex")
5258    (set_attr "mode" "<sseinsnmode>")])
5259
5260 (define_expand "<sse2_avx2>_<plusminus_insn><mode>3"
5261   [(set (match_operand:VI12_AVX2 0 "register_operand")
5262         (sat_plusminus:VI12_AVX2
5263           (match_operand:VI12_AVX2 1 "nonimmediate_operand")
5264           (match_operand:VI12_AVX2 2 "nonimmediate_operand")))]
5265   "TARGET_SSE2"
5266   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5267
5268 (define_insn "*<sse2_avx2>_<plusminus_insn><mode>3"
5269   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,x")
5270         (sat_plusminus:VI12_AVX2
5271           (match_operand:VI12_AVX2 1 "nonimmediate_operand" "<comm>0,x")
5272           (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,xm")))]
5273   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5274   "@
5275    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
5276    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5277   [(set_attr "isa" "noavx,avx")
5278    (set_attr "type" "sseiadd")
5279    (set_attr "prefix_data16" "1,*")
5280    (set_attr "prefix" "orig,vex")
5281    (set_attr "mode" "TI")])
5282
5283 (define_expand "mul<mode>3"
5284   [(set (match_operand:VI1_AVX2 0 "register_operand")
5285         (mult:VI1_AVX2 (match_operand:VI1_AVX2 1 "register_operand")
5286                        (match_operand:VI1_AVX2 2 "register_operand")))]
5287   "TARGET_SSE2"
5288 {
5289   ix86_expand_vecop_qihi (MULT, operands[0], operands[1], operands[2]);
5290   DONE;
5291 })
5292
5293 (define_expand "mul<mode>3"
5294   [(set (match_operand:VI2_AVX2 0 "register_operand")
5295         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand")
5296                        (match_operand:VI2_AVX2 2 "nonimmediate_operand")))]
5297   "TARGET_SSE2"
5298   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
5299
5300 (define_insn "*mul<mode>3"
5301   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
5302         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x")
5303                        (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))]
5304   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
5305   "@
5306    pmullw\t{%2, %0|%0, %2}
5307    vpmullw\t{%2, %1, %0|%0, %1, %2}"
5308   [(set_attr "isa" "noavx,avx")
5309    (set_attr "type" "sseimul")
5310    (set_attr "prefix_data16" "1,*")
5311    (set_attr "prefix" "orig,vex")
5312    (set_attr "mode" "<sseinsnmode>")])
5313
5314 (define_expand "<s>mul<mode>3_highpart"
5315   [(set (match_operand:VI2_AVX2 0 "register_operand")
5316         (truncate:VI2_AVX2
5317           (lshiftrt:<ssedoublemode>
5318             (mult:<ssedoublemode>
5319               (any_extend:<ssedoublemode>
5320                 (match_operand:VI2_AVX2 1 "nonimmediate_operand"))
5321               (any_extend:<ssedoublemode>
5322                 (match_operand:VI2_AVX2 2 "nonimmediate_operand")))
5323             (const_int 16))))]
5324   "TARGET_SSE2"
5325   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
5326
5327 (define_insn "*<s>mul<mode>3_highpart"
5328   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
5329         (truncate:VI2_AVX2
5330           (lshiftrt:<ssedoublemode>
5331             (mult:<ssedoublemode>
5332               (any_extend:<ssedoublemode>
5333                 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
5334               (any_extend:<ssedoublemode>
5335                 (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
5336             (const_int 16))))]
5337   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
5338   "@
5339    pmulh<u>w\t{%2, %0|%0, %2}
5340    vpmulh<u>w\t{%2, %1, %0|%0, %1, %2}"
5341   [(set_attr "isa" "noavx,avx")
5342    (set_attr "type" "sseimul")
5343    (set_attr "prefix_data16" "1,*")
5344    (set_attr "prefix" "orig,vex")
5345    (set_attr "mode" "<sseinsnmode>")])
5346
5347 (define_expand "vec_widen_umult_even_v8si"
5348   [(set (match_operand:V4DI 0 "register_operand")
5349         (mult:V4DI
5350           (zero_extend:V4DI
5351             (vec_select:V4SI
5352               (match_operand:V8SI 1 "nonimmediate_operand")
5353               (parallel [(const_int 0) (const_int 2)
5354                          (const_int 4) (const_int 6)])))
5355           (zero_extend:V4DI
5356             (vec_select:V4SI
5357               (match_operand:V8SI 2 "nonimmediate_operand")
5358               (parallel [(const_int 0) (const_int 2)
5359                          (const_int 4) (const_int 6)])))))]
5360   "TARGET_AVX2"
5361   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
5362
5363 (define_insn "*vec_widen_umult_even_v8si"
5364   [(set (match_operand:V4DI 0 "register_operand" "=x")
5365         (mult:V4DI
5366           (zero_extend:V4DI
5367             (vec_select:V4SI
5368               (match_operand:V8SI 1 "nonimmediate_operand" "%x")
5369               (parallel [(const_int 0) (const_int 2)
5370                          (const_int 4) (const_int 6)])))
5371           (zero_extend:V4DI
5372             (vec_select:V4SI
5373               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
5374               (parallel [(const_int 0) (const_int 2)
5375                          (const_int 4) (const_int 6)])))))]
5376   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
5377   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5378   [(set_attr "type" "sseimul")
5379    (set_attr "prefix" "vex")
5380    (set_attr "mode" "OI")])
5381
5382 (define_expand "vec_widen_umult_even_v4si"
5383   [(set (match_operand:V2DI 0 "register_operand")
5384         (mult:V2DI
5385           (zero_extend:V2DI
5386             (vec_select:V2SI
5387               (match_operand:V4SI 1 "nonimmediate_operand")
5388               (parallel [(const_int 0) (const_int 2)])))
5389           (zero_extend:V2DI
5390             (vec_select:V2SI
5391               (match_operand:V4SI 2 "nonimmediate_operand")
5392               (parallel [(const_int 0) (const_int 2)])))))]
5393   "TARGET_SSE2"
5394   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5395
5396 (define_insn "*vec_widen_umult_even_v4si"
5397   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
5398         (mult:V2DI
5399           (zero_extend:V2DI
5400             (vec_select:V2SI
5401               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
5402               (parallel [(const_int 0) (const_int 2)])))
5403           (zero_extend:V2DI
5404             (vec_select:V2SI
5405               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
5406               (parallel [(const_int 0) (const_int 2)])))))]
5407   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5408   "@
5409    pmuludq\t{%2, %0|%0, %2}
5410    vpmuludq\t{%2, %1, %0|%0, %1, %2}"
5411   [(set_attr "isa" "noavx,avx")
5412    (set_attr "type" "sseimul")
5413    (set_attr "prefix_data16" "1,*")
5414    (set_attr "prefix" "orig,vex")
5415    (set_attr "mode" "TI")])
5416
5417 (define_expand "vec_widen_smult_even_v8si"
5418   [(set (match_operand:V4DI 0 "register_operand")
5419         (mult:V4DI
5420           (sign_extend:V4DI
5421             (vec_select:V4SI
5422               (match_operand:V8SI 1 "nonimmediate_operand")
5423               (parallel [(const_int 0) (const_int 2)
5424                          (const_int 4) (const_int 6)])))
5425           (sign_extend:V4DI
5426             (vec_select:V4SI
5427               (match_operand:V8SI 2 "nonimmediate_operand")
5428               (parallel [(const_int 0) (const_int 2)
5429                          (const_int 4) (const_int 6)])))))]
5430   "TARGET_AVX2"
5431   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
5432
5433 (define_insn "*vec_widen_smult_even_v8si"
5434   [(set (match_operand:V4DI 0 "register_operand" "=x")
5435         (mult:V4DI
5436           (sign_extend:V4DI
5437             (vec_select:V4SI
5438               (match_operand:V8SI 1 "nonimmediate_operand" "x")
5439               (parallel [(const_int 0) (const_int 2)
5440                          (const_int 4) (const_int 6)])))
5441           (sign_extend:V4DI
5442             (vec_select:V4SI
5443               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
5444               (parallel [(const_int 0) (const_int 2)
5445                          (const_int 4) (const_int 6)])))))]
5446   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
5447   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5448   [(set_attr "isa" "avx")
5449    (set_attr "type" "sseimul")
5450    (set_attr "prefix_extra" "1")
5451    (set_attr "prefix" "vex")
5452    (set_attr "mode" "OI")])
5453
5454 (define_expand "sse4_1_mulv2siv2di3"
5455   [(set (match_operand:V2DI 0 "register_operand")
5456         (mult:V2DI
5457           (sign_extend:V2DI
5458             (vec_select:V2SI
5459               (match_operand:V4SI 1 "nonimmediate_operand")
5460               (parallel [(const_int 0) (const_int 2)])))
5461           (sign_extend:V2DI
5462             (vec_select:V2SI
5463               (match_operand:V4SI 2 "nonimmediate_operand")
5464               (parallel [(const_int 0) (const_int 2)])))))]
5465   "TARGET_SSE4_1"
5466   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
5467
5468 (define_insn "*sse4_1_mulv2siv2di3"
5469   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
5470         (mult:V2DI
5471           (sign_extend:V2DI
5472             (vec_select:V2SI
5473               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
5474               (parallel [(const_int 0) (const_int 2)])))
5475           (sign_extend:V2DI
5476             (vec_select:V2SI
5477               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
5478               (parallel [(const_int 0) (const_int 2)])))))]
5479   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
5480   "@
5481    pmuldq\t{%2, %0|%0, %2}
5482    vpmuldq\t{%2, %1, %0|%0, %1, %2}"
5483   [(set_attr "isa" "noavx,avx")
5484    (set_attr "type" "sseimul")
5485    (set_attr "prefix_data16" "1,*")
5486    (set_attr "prefix_extra" "1")
5487    (set_attr "prefix" "orig,vex")
5488    (set_attr "mode" "TI")])
5489
5490 (define_expand "avx2_pmaddwd"
5491   [(set (match_operand:V8SI 0 "register_operand")
5492         (plus:V8SI
5493           (mult:V8SI
5494             (sign_extend:V8SI
5495               (vec_select:V8HI
5496                 (match_operand:V16HI 1 "nonimmediate_operand")
5497                 (parallel [(const_int 0) (const_int 2)
5498                            (const_int 4) (const_int 6)
5499                            (const_int 8) (const_int 10)
5500                            (const_int 12) (const_int 14)])))
5501             (sign_extend:V8SI
5502               (vec_select:V8HI
5503                 (match_operand:V16HI 2 "nonimmediate_operand")
5504                 (parallel [(const_int 0) (const_int 2)
5505                            (const_int 4) (const_int 6)
5506                            (const_int 8) (const_int 10)
5507                            (const_int 12) (const_int 14)]))))
5508           (mult:V8SI
5509             (sign_extend:V8SI
5510               (vec_select:V8HI (match_dup 1)
5511                 (parallel [(const_int 1) (const_int 3)
5512                            (const_int 5) (const_int 7)
5513                            (const_int 9) (const_int 11)
5514                            (const_int 13) (const_int 15)])))
5515             (sign_extend:V8SI
5516               (vec_select:V8HI (match_dup 2)
5517                 (parallel [(const_int 1) (const_int 3)
5518                            (const_int 5) (const_int 7)
5519                            (const_int 9) (const_int 11)
5520                            (const_int 13) (const_int 15)]))))))]
5521   "TARGET_AVX2"
5522   "ix86_fixup_binary_operands_no_copy (MULT, V16HImode, operands);")
5523
5524 (define_insn "*avx2_pmaddwd"
5525   [(set (match_operand:V8SI 0 "register_operand" "=x")
5526         (plus:V8SI
5527           (mult:V8SI
5528             (sign_extend:V8SI
5529               (vec_select:V8HI
5530                 (match_operand:V16HI 1 "nonimmediate_operand" "%x")
5531                 (parallel [(const_int 0) (const_int 2)
5532                            (const_int 4) (const_int 6)
5533                            (const_int 8) (const_int 10)
5534                            (const_int 12) (const_int 14)])))
5535             (sign_extend:V8SI
5536               (vec_select:V8HI
5537                 (match_operand:V16HI 2 "nonimmediate_operand" "xm")
5538                 (parallel [(const_int 0) (const_int 2)
5539                            (const_int 4) (const_int 6)
5540                            (const_int 8) (const_int 10)
5541                            (const_int 12) (const_int 14)]))))
5542           (mult:V8SI
5543             (sign_extend:V8SI
5544               (vec_select:V8HI (match_dup 1)
5545                 (parallel [(const_int 1) (const_int 3)
5546                            (const_int 5) (const_int 7)
5547                            (const_int 9) (const_int 11)
5548                            (const_int 13) (const_int 15)])))
5549             (sign_extend:V8SI
5550               (vec_select:V8HI (match_dup 2)
5551                 (parallel [(const_int 1) (const_int 3)
5552                            (const_int 5) (const_int 7)
5553                            (const_int 9) (const_int 11)
5554                            (const_int 13) (const_int 15)]))))))]
5555   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V16HImode, operands)"
5556   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5557   [(set_attr "type" "sseiadd")
5558    (set_attr "prefix" "vex")
5559    (set_attr "mode" "OI")])
5560
5561 (define_expand "sse2_pmaddwd"
5562   [(set (match_operand:V4SI 0 "register_operand")
5563         (plus:V4SI
5564           (mult:V4SI
5565             (sign_extend:V4SI
5566               (vec_select:V4HI
5567                 (match_operand:V8HI 1 "nonimmediate_operand")
5568                 (parallel [(const_int 0) (const_int 2)
5569                            (const_int 4) (const_int 6)])))
5570             (sign_extend:V4SI
5571               (vec_select:V4HI
5572                 (match_operand:V8HI 2 "nonimmediate_operand")
5573                 (parallel [(const_int 0) (const_int 2)
5574                            (const_int 4) (const_int 6)]))))
5575           (mult:V4SI
5576             (sign_extend:V4SI
5577               (vec_select:V4HI (match_dup 1)
5578                 (parallel [(const_int 1) (const_int 3)
5579                            (const_int 5) (const_int 7)])))
5580             (sign_extend:V4SI
5581               (vec_select:V4HI (match_dup 2)
5582                 (parallel [(const_int 1) (const_int 3)
5583                            (const_int 5) (const_int 7)]))))))]
5584   "TARGET_SSE2"
5585   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
5586
5587 (define_insn "*sse2_pmaddwd"
5588   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
5589         (plus:V4SI
5590           (mult:V4SI
5591             (sign_extend:V4SI
5592               (vec_select:V4HI
5593                 (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
5594                 (parallel [(const_int 0) (const_int 2)
5595                            (const_int 4) (const_int 6)])))
5596             (sign_extend:V4SI
5597               (vec_select:V4HI
5598                 (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
5599                 (parallel [(const_int 0) (const_int 2)
5600                            (const_int 4) (const_int 6)]))))
5601           (mult:V4SI
5602             (sign_extend:V4SI
5603               (vec_select:V4HI (match_dup 1)
5604                 (parallel [(const_int 1) (const_int 3)
5605                            (const_int 5) (const_int 7)])))
5606             (sign_extend:V4SI
5607               (vec_select:V4HI (match_dup 2)
5608                 (parallel [(const_int 1) (const_int 3)
5609                            (const_int 5) (const_int 7)]))))))]
5610   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5611   "@
5612    pmaddwd\t{%2, %0|%0, %2}
5613    vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
5614   [(set_attr "isa" "noavx,avx")
5615    (set_attr "type" "sseiadd")
5616    (set_attr "atom_unit" "simul")
5617    (set_attr "prefix_data16" "1,*")
5618    (set_attr "prefix" "orig,vex")
5619    (set_attr "mode" "TI")])
5620
5621 (define_expand "mul<mode>3"
5622   [(set (match_operand:VI4_AVX2 0 "register_operand")
5623         (mult:VI4_AVX2
5624           (match_operand:VI4_AVX2 1 "general_vector_operand")
5625           (match_operand:VI4_AVX2 2 "general_vector_operand")))]
5626   "TARGET_SSE2"
5627 {
5628   if (TARGET_SSE4_1)
5629     {
5630       if (!nonimmediate_operand (operands[1], <MODE>mode))
5631         operands[1] = force_reg (<MODE>mode, operands[1]);
5632       if (!nonimmediate_operand (operands[2], <MODE>mode))
5633         operands[2] = force_reg (<MODE>mode, operands[2]);
5634       ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
5635     }
5636   else
5637     {
5638       ix86_expand_sse2_mulv4si3 (operands[0], operands[1], operands[2]);
5639       DONE;
5640     }
5641 })
5642
5643 (define_insn "*<sse4_1_avx2>_mul<mode>3"
5644   [(set (match_operand:VI4_AVX2 0 "register_operand" "=x,x")
5645         (mult:VI4_AVX2
5646           (match_operand:VI4_AVX2 1 "nonimmediate_operand" "%0,x")
5647           (match_operand:VI4_AVX2 2 "nonimmediate_operand" "xm,xm")))]
5648   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
5649   "@
5650    pmulld\t{%2, %0|%0, %2}
5651    vpmulld\t{%2, %1, %0|%0, %1, %2}"
5652   [(set_attr "isa" "noavx,avx")
5653    (set_attr "type" "sseimul")
5654    (set_attr "prefix_extra" "1")
5655    (set_attr "prefix" "orig,vex")
5656    (set_attr "btver2_decode" "vector,vector")
5657    (set_attr "mode" "<sseinsnmode>")])
5658
5659 (define_expand "mul<mode>3"
5660   [(set (match_operand:VI8_AVX2 0 "register_operand")
5661         (mult:VI8_AVX2 (match_operand:VI8_AVX2 1 "register_operand")
5662                        (match_operand:VI8_AVX2 2 "register_operand")))]
5663   "TARGET_SSE2"
5664 {
5665   ix86_expand_sse2_mulvxdi3 (operands[0], operands[1], operands[2]);
5666   DONE;
5667 })
5668
5669 (define_expand "vec_widen_<s>mult_hi_<mode>"
5670   [(match_operand:<sseunpackmode> 0 "register_operand")
5671    (any_extend:<sseunpackmode>
5672      (match_operand:VI124_AVX2 1 "register_operand"))
5673    (match_operand:VI124_AVX2 2 "register_operand")]
5674   "TARGET_SSE2"
5675 {
5676   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
5677                               <u_bool>, true);
5678   DONE;
5679 })
5680
5681 (define_expand "vec_widen_<s>mult_lo_<mode>"
5682   [(match_operand:<sseunpackmode> 0 "register_operand")
5683    (any_extend:<sseunpackmode>
5684      (match_operand:VI124_AVX2 1 "register_operand"))
5685    (match_operand:VI124_AVX2 2 "register_operand")]
5686   "TARGET_SSE2"
5687 {
5688   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
5689                               <u_bool>, false);
5690   DONE;
5691 })
5692
5693 ;; Most widen_<s>mult_even_<mode> can be handled directly from other
5694 ;; named patterns, but signed V4SI needs special help for plain SSE2.
5695 (define_expand "vec_widen_smult_even_v4si"
5696   [(match_operand:V2DI 0 "register_operand")
5697    (match_operand:V4SI 1 "nonimmediate_operand")
5698    (match_operand:V4SI 2 "nonimmediate_operand")]
5699   "TARGET_SSE2"
5700 {
5701   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
5702                                  false, false);
5703   DONE;
5704 })
5705
5706 (define_expand "vec_widen_<s>mult_odd_<mode>"
5707   [(match_operand:<sseunpackmode> 0 "register_operand")
5708    (any_extend:<sseunpackmode>
5709      (match_operand:VI4_AVX2 1 "general_vector_operand"))
5710    (match_operand:VI4_AVX2 2 "general_vector_operand")]
5711   "TARGET_SSE2"
5712 {
5713   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
5714                                  <u_bool>, true);
5715   DONE;
5716 })
5717
5718 (define_expand "sdot_prod<mode>"
5719   [(match_operand:<sseunpackmode> 0 "register_operand")
5720    (match_operand:VI2_AVX2 1 "register_operand")
5721    (match_operand:VI2_AVX2 2 "register_operand")
5722    (match_operand:<sseunpackmode> 3 "register_operand")]
5723   "TARGET_SSE2"
5724 {
5725   rtx t = gen_reg_rtx (<sseunpackmode>mode);
5726   emit_insn (gen_<sse2_avx2>_pmaddwd (t, operands[1], operands[2]));
5727   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
5728                           gen_rtx_PLUS (<sseunpackmode>mode,
5729                                         operands[3], t)));
5730   DONE;
5731 })
5732
5733 ;; Normally we use widen_mul_even/odd, but combine can't quite get it all
5734 ;; back together when madd is available.
5735 (define_expand "sdot_prodv4si"
5736   [(match_operand:V2DI 0 "register_operand")
5737    (match_operand:V4SI 1 "register_operand")
5738    (match_operand:V4SI 2 "register_operand")
5739    (match_operand:V2DI 3 "register_operand")]
5740   "TARGET_XOP"
5741 {
5742   rtx t = gen_reg_rtx (V2DImode);
5743   emit_insn (gen_xop_pmacsdqh (t, operands[1], operands[2], operands[3]));
5744   emit_insn (gen_xop_pmacsdql (operands[0], operands[1], operands[2], t));
5745   DONE;
5746 })
5747
5748 (define_insn "ashr<mode>3"
5749   [(set (match_operand:VI24_AVX2 0 "register_operand" "=x,x")
5750         (ashiftrt:VI24_AVX2
5751           (match_operand:VI24_AVX2 1 "register_operand" "0,x")
5752           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
5753   "TARGET_SSE2"
5754   "@
5755    psra<ssemodesuffix>\t{%2, %0|%0, %2}
5756    vpsra<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5757   [(set_attr "isa" "noavx,avx")
5758    (set_attr "type" "sseishft")
5759    (set (attr "length_immediate")
5760      (if_then_else (match_operand 2 "const_int_operand")
5761        (const_string "1")
5762        (const_string "0")))
5763    (set_attr "prefix_data16" "1,*")
5764    (set_attr "prefix" "orig,vex")
5765    (set_attr "mode" "<sseinsnmode>")])
5766
5767 (define_insn "<shift_insn><mode>3"
5768   [(set (match_operand:VI248_AVX2 0 "register_operand" "=x,x")
5769         (any_lshift:VI248_AVX2
5770           (match_operand:VI248_AVX2 1 "register_operand" "0,x")
5771           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
5772   "TARGET_SSE2"
5773   "@
5774    p<vshift><ssemodesuffix>\t{%2, %0|%0, %2}
5775    vp<vshift><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5776   [(set_attr "isa" "noavx,avx")
5777    (set_attr "type" "sseishft")
5778    (set (attr "length_immediate")
5779      (if_then_else (match_operand 2 "const_int_operand")
5780        (const_string "1")
5781        (const_string "0")))
5782    (set_attr "prefix_data16" "1,*")
5783    (set_attr "prefix" "orig,vex")
5784    (set_attr "mode" "<sseinsnmode>")])
5785
5786 (define_expand "vec_shl_<mode>"
5787   [(set (match_operand:VI_128 0 "register_operand")
5788         (ashift:V1TI
5789          (match_operand:VI_128 1 "register_operand")
5790          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))]
5791   "TARGET_SSE2"
5792 {
5793   operands[0] = gen_lowpart (V1TImode, operands[0]);
5794   operands[1] = gen_lowpart (V1TImode, operands[1]);
5795 })
5796
5797 (define_insn "<sse2_avx2>_ashl<mode>3"
5798   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
5799         (ashift:VIMAX_AVX2
5800          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
5801          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
5802   "TARGET_SSE2"
5803 {
5804   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5805
5806   switch (which_alternative)
5807     {
5808     case 0:
5809       return "pslldq\t{%2, %0|%0, %2}";
5810     case 1:
5811       return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
5812     default:
5813       gcc_unreachable ();
5814     }
5815 }
5816   [(set_attr "isa" "noavx,avx")
5817    (set_attr "type" "sseishft")
5818    (set_attr "length_immediate" "1")
5819    (set_attr "prefix_data16" "1,*")
5820    (set_attr "prefix" "orig,vex")
5821    (set_attr "mode" "<sseinsnmode>")])
5822
5823 (define_expand "vec_shr_<mode>"
5824   [(set (match_operand:VI_128 0 "register_operand")
5825         (lshiftrt:V1TI
5826          (match_operand:VI_128 1 "register_operand")
5827          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))]
5828   "TARGET_SSE2"
5829 {
5830   operands[0] = gen_lowpart (V1TImode, operands[0]);
5831   operands[1] = gen_lowpart (V1TImode, operands[1]);
5832 })
5833
5834 (define_insn "<sse2_avx2>_lshr<mode>3"
5835   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
5836         (lshiftrt:VIMAX_AVX2
5837          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
5838          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
5839   "TARGET_SSE2"
5840 {
5841   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
5842
5843   switch (which_alternative)
5844     {
5845     case 0:
5846       return "psrldq\t{%2, %0|%0, %2}";
5847     case 1:
5848       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5849     default:
5850       gcc_unreachable ();
5851     }
5852 }
5853   [(set_attr "isa" "noavx,avx")
5854    (set_attr "type" "sseishft")
5855    (set_attr "length_immediate" "1")
5856    (set_attr "atom_unit" "sishuf")
5857    (set_attr "prefix_data16" "1,*")
5858    (set_attr "prefix" "orig,vex")
5859    (set_attr "mode" "<sseinsnmode>")])
5860
5861
5862 (define_expand "<code><mode>3"
5863   [(set (match_operand:VI124_256 0 "register_operand")
5864         (maxmin:VI124_256
5865           (match_operand:VI124_256 1 "nonimmediate_operand")
5866           (match_operand:VI124_256 2 "nonimmediate_operand")))]
5867   "TARGET_AVX2"
5868   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
5869
5870 (define_insn "*avx2_<code><mode>3"
5871   [(set (match_operand:VI124_256 0 "register_operand" "=x")
5872         (maxmin:VI124_256
5873           (match_operand:VI124_256 1 "nonimmediate_operand" "%x")
5874           (match_operand:VI124_256 2 "nonimmediate_operand" "xm")))]
5875   "TARGET_AVX2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5876   "vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5877   [(set_attr "type" "sseiadd")
5878    (set_attr "prefix_extra" "1")
5879    (set_attr "prefix" "vex")
5880    (set_attr "mode" "OI")])
5881
5882 (define_expand "<code><mode>3"
5883   [(set (match_operand:VI8_AVX2 0 "register_operand")
5884         (maxmin:VI8_AVX2
5885           (match_operand:VI8_AVX2 1 "register_operand")
5886           (match_operand:VI8_AVX2 2 "register_operand")))]
5887   "TARGET_SSE4_2"
5888 {
5889   enum rtx_code code;
5890   rtx xops[6];
5891   bool ok;
5892
5893   xops[0] = operands[0];
5894
5895   if (<CODE> == SMAX || <CODE> == UMAX)
5896     {
5897       xops[1] = operands[1];
5898       xops[2] = operands[2];
5899     }
5900   else
5901     {
5902       xops[1] = operands[2];
5903       xops[2] = operands[1];
5904     }
5905
5906   code = (<CODE> == UMAX || <CODE> == UMIN) ? GTU : GT;
5907
5908   xops[3] = gen_rtx_fmt_ee (code, VOIDmode, operands[1], operands[2]);
5909   xops[4] = operands[1];
5910   xops[5] = operands[2];
5911
5912   ok = ix86_expand_int_vcond (xops);
5913   gcc_assert (ok);
5914   DONE;
5915 })
5916
5917 (define_expand "<code><mode>3"
5918   [(set (match_operand:VI124_128 0 "register_operand")
5919         (smaxmin:VI124_128
5920           (match_operand:VI124_128 1 "nonimmediate_operand")
5921           (match_operand:VI124_128 2 "nonimmediate_operand")))]
5922   "TARGET_SSE2"
5923 {
5924   if (TARGET_SSE4_1 || <MODE>mode == V8HImode)
5925     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
5926   else
5927     {
5928       rtx xops[6];
5929       bool ok;
5930
5931       xops[0] = operands[0];
5932       operands[1] = force_reg (<MODE>mode, operands[1]);
5933       operands[2] = force_reg (<MODE>mode, operands[2]);
5934
5935       if (<CODE> == SMAX)
5936         {
5937           xops[1] = operands[1];
5938           xops[2] = operands[2];
5939         }
5940       else
5941         {
5942           xops[1] = operands[2];
5943           xops[2] = operands[1];
5944         }
5945
5946       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
5947       xops[4] = operands[1];
5948       xops[5] = operands[2];
5949
5950       ok = ix86_expand_int_vcond (xops);
5951       gcc_assert (ok);
5952       DONE;
5953     }
5954 })
5955
5956 (define_insn "*sse4_1_<code><mode>3"
5957   [(set (match_operand:VI14_128 0 "register_operand" "=x,x")
5958         (smaxmin:VI14_128
5959           (match_operand:VI14_128 1 "nonimmediate_operand" "%0,x")
5960           (match_operand:VI14_128 2 "nonimmediate_operand" "xm,xm")))]
5961   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
5962   "@
5963    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
5964    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
5965   [(set_attr "isa" "noavx,avx")
5966    (set_attr "type" "sseiadd")
5967    (set_attr "prefix_extra" "1,*")
5968    (set_attr "prefix" "orig,vex")
5969    (set_attr "mode" "TI")])
5970
5971 (define_insn "*<code>v8hi3"
5972   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
5973         (smaxmin:V8HI
5974           (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
5975           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")))]
5976   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
5977   "@
5978    p<maxmin_int>w\t{%2, %0|%0, %2}
5979    vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
5980   [(set_attr "isa" "noavx,avx")
5981    (set_attr "type" "sseiadd")
5982    (set_attr "prefix_data16" "1,*")
5983    (set_attr "prefix_extra" "*,1")
5984    (set_attr "prefix" "orig,vex")
5985    (set_attr "mode" "TI")])
5986
5987 (define_expand "<code><mode>3"
5988   [(set (match_operand:VI124_128 0 "register_operand")
5989         (umaxmin:VI124_128
5990           (match_operand:VI124_128 1 "nonimmediate_operand")
5991           (match_operand:VI124_128 2 "nonimmediate_operand")))]
5992   "TARGET_SSE2"
5993 {
5994   if (TARGET_SSE4_1 || <MODE>mode == V16QImode)
5995     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
5996   else if (<CODE> == UMAX && <MODE>mode == V8HImode)
5997     {
5998       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
5999       operands[1] = force_reg (<MODE>mode, operands[1]);
6000       if (rtx_equal_p (op3, op2))
6001         op3 = gen_reg_rtx (V8HImode);
6002       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
6003       emit_insn (gen_addv8hi3 (op0, op3, op2));
6004       DONE;
6005     }
6006   else
6007     {
6008       rtx xops[6];
6009       bool ok;
6010
6011       operands[1] = force_reg (<MODE>mode, operands[1]);
6012       operands[2] = force_reg (<MODE>mode, operands[2]);
6013
6014       xops[0] = operands[0];
6015
6016       if (<CODE> == UMAX)
6017         {
6018           xops[1] = operands[1];
6019           xops[2] = operands[2];
6020         }
6021       else
6022         {
6023           xops[1] = operands[2];
6024           xops[2] = operands[1];
6025         }
6026
6027       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
6028       xops[4] = operands[1];
6029       xops[5] = operands[2];
6030
6031       ok = ix86_expand_int_vcond (xops);
6032       gcc_assert (ok);
6033       DONE;
6034     }
6035 })
6036
6037 (define_insn "*sse4_1_<code><mode>3"
6038   [(set (match_operand:VI24_128 0 "register_operand" "=x,x")
6039         (umaxmin:VI24_128
6040           (match_operand:VI24_128 1 "nonimmediate_operand" "%0,x")
6041           (match_operand:VI24_128 2 "nonimmediate_operand" "xm,xm")))]
6042   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6043   "@
6044    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
6045    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
6046   [(set_attr "isa" "noavx,avx")
6047    (set_attr "type" "sseiadd")
6048    (set_attr "prefix_extra" "1,*")
6049    (set_attr "prefix" "orig,vex")
6050    (set_attr "mode" "TI")])
6051
6052 (define_insn "*<code>v16qi3"
6053   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
6054         (umaxmin:V16QI
6055           (match_operand:V16QI 1 "nonimmediate_operand" "%0,x")
6056           (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")))]
6057   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
6058   "@
6059    p<maxmin_int>b\t{%2, %0|%0, %2}
6060    vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
6061   [(set_attr "isa" "noavx,avx")
6062    (set_attr "type" "sseiadd")
6063    (set_attr "prefix_data16" "1,*")
6064    (set_attr "prefix_extra" "*,1")
6065    (set_attr "prefix" "orig,vex")
6066    (set_attr "mode" "TI")])
6067
6068 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6069 ;;
6070 ;; Parallel integral comparisons
6071 ;;
6072 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6073
6074 (define_expand "avx2_eq<mode>3"
6075   [(set (match_operand:VI_256 0 "register_operand")
6076         (eq:VI_256
6077           (match_operand:VI_256 1 "nonimmediate_operand")
6078           (match_operand:VI_256 2 "nonimmediate_operand")))]
6079   "TARGET_AVX2"
6080   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
6081
6082 (define_insn "*avx2_eq<mode>3"
6083   [(set (match_operand:VI_256 0 "register_operand" "=x")
6084         (eq:VI_256
6085           (match_operand:VI_256 1 "nonimmediate_operand" "%x")
6086           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
6087   "TARGET_AVX2 && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6088   "vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
6089   [(set_attr "type" "ssecmp")
6090    (set_attr "prefix_extra" "1")
6091    (set_attr "prefix" "vex")
6092    (set_attr "mode" "OI")])
6093
6094 (define_insn "*sse4_1_eqv2di3"
6095   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
6096         (eq:V2DI
6097           (match_operand:V2DI 1 "nonimmediate_operand" "%0,x")
6098           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
6099   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
6100   "@
6101    pcmpeqq\t{%2, %0|%0, %2}
6102    vpcmpeqq\t{%2, %1, %0|%0, %1, %2}"
6103   [(set_attr "isa" "noavx,avx")
6104    (set_attr "type" "ssecmp")
6105    (set_attr "prefix_extra" "1")
6106    (set_attr "prefix" "orig,vex")
6107    (set_attr "mode" "TI")])
6108
6109 (define_insn "*sse2_eq<mode>3"
6110   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
6111         (eq:VI124_128
6112           (match_operand:VI124_128 1 "nonimmediate_operand" "%0,x")
6113           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
6114   "TARGET_SSE2 && !TARGET_XOP
6115    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
6116   "@
6117    pcmpeq<ssemodesuffix>\t{%2, %0|%0, %2}
6118    vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
6119   [(set_attr "isa" "noavx,avx")
6120    (set_attr "type" "ssecmp")
6121    (set_attr "prefix_data16" "1,*")
6122    (set_attr "prefix" "orig,vex")
6123    (set_attr "mode" "TI")])
6124
6125 (define_expand "sse2_eq<mode>3"
6126   [(set (match_operand:VI124_128 0 "register_operand")
6127         (eq:VI124_128
6128           (match_operand:VI124_128 1 "nonimmediate_operand")
6129           (match_operand:VI124_128 2 "nonimmediate_operand")))]
6130   "TARGET_SSE2 && !TARGET_XOP "
6131   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
6132
6133 (define_expand "sse4_1_eqv2di3"
6134   [(set (match_operand:V2DI 0 "register_operand")
6135         (eq:V2DI
6136           (match_operand:V2DI 1 "nonimmediate_operand")
6137           (match_operand:V2DI 2 "nonimmediate_operand")))]
6138   "TARGET_SSE4_1"
6139   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
6140
6141 (define_insn "sse4_2_gtv2di3"
6142   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
6143         (gt:V2DI
6144           (match_operand:V2DI 1 "register_operand" "0,x")
6145           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
6146   "TARGET_SSE4_2"
6147   "@
6148    pcmpgtq\t{%2, %0|%0, %2}
6149    vpcmpgtq\t{%2, %1, %0|%0, %1, %2}"
6150   [(set_attr "isa" "noavx,avx")
6151    (set_attr "type" "ssecmp")
6152    (set_attr "prefix_extra" "1")
6153    (set_attr "prefix" "orig,vex")
6154    (set_attr "mode" "TI")])
6155
6156 (define_insn "avx2_gt<mode>3"
6157   [(set (match_operand:VI_256 0 "register_operand" "=x")
6158         (gt:VI_256
6159           (match_operand:VI_256 1 "register_operand" "x")
6160           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
6161   "TARGET_AVX2"
6162   "vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
6163   [(set_attr "type" "ssecmp")
6164    (set_attr "prefix_extra" "1")
6165    (set_attr "prefix" "vex")
6166    (set_attr "mode" "OI")])
6167
6168 (define_insn "sse2_gt<mode>3"
6169   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
6170         (gt:VI124_128
6171           (match_operand:VI124_128 1 "register_operand" "0,x")
6172           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
6173   "TARGET_SSE2 && !TARGET_XOP"
6174   "@
6175    pcmpgt<ssemodesuffix>\t{%2, %0|%0, %2}
6176    vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
6177   [(set_attr "isa" "noavx,avx")
6178    (set_attr "type" "ssecmp")
6179    (set_attr "prefix_data16" "1,*")
6180    (set_attr "prefix" "orig,vex")
6181    (set_attr "mode" "TI")])
6182
6183 (define_expand "vcond<V_256:mode><VI_256:mode>"
6184   [(set (match_operand:V_256 0 "register_operand")
6185         (if_then_else:V_256
6186           (match_operator 3 ""
6187             [(match_operand:VI_256 4 "nonimmediate_operand")
6188              (match_operand:VI_256 5 "general_operand")])
6189           (match_operand:V_256 1)
6190           (match_operand:V_256 2)))]
6191   "TARGET_AVX2
6192    && (GET_MODE_NUNITS (<V_256:MODE>mode)
6193        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
6194 {
6195   bool ok = ix86_expand_int_vcond (operands);
6196   gcc_assert (ok);
6197   DONE;
6198 })
6199
6200 (define_expand "vcond<V_128:mode><VI124_128:mode>"
6201   [(set (match_operand:V_128 0 "register_operand")
6202         (if_then_else:V_128
6203           (match_operator 3 ""
6204             [(match_operand:VI124_128 4 "nonimmediate_operand")
6205              (match_operand:VI124_128 5 "general_operand")])
6206           (match_operand:V_128 1)
6207           (match_operand:V_128 2)))]
6208   "TARGET_SSE2
6209    && (GET_MODE_NUNITS (<V_128:MODE>mode)
6210        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
6211 {
6212   bool ok = ix86_expand_int_vcond (operands);
6213   gcc_assert (ok);
6214   DONE;
6215 })
6216
6217 (define_expand "vcond<VI8F_128:mode>v2di"
6218   [(set (match_operand:VI8F_128 0 "register_operand")
6219         (if_then_else:VI8F_128
6220           (match_operator 3 ""
6221             [(match_operand:V2DI 4 "nonimmediate_operand")
6222              (match_operand:V2DI 5 "general_operand")])
6223           (match_operand:VI8F_128 1)
6224           (match_operand:VI8F_128 2)))]
6225   "TARGET_SSE4_2"
6226 {
6227   bool ok = ix86_expand_int_vcond (operands);
6228   gcc_assert (ok);
6229   DONE;
6230 })
6231
6232 (define_expand "vcondu<V_256:mode><VI_256:mode>"
6233   [(set (match_operand:V_256 0 "register_operand")
6234         (if_then_else:V_256
6235           (match_operator 3 ""
6236             [(match_operand:VI_256 4 "nonimmediate_operand")
6237              (match_operand:VI_256 5 "nonimmediate_operand")])
6238           (match_operand:V_256 1 "general_operand")
6239           (match_operand:V_256 2 "general_operand")))]
6240   "TARGET_AVX2
6241    && (GET_MODE_NUNITS (<V_256:MODE>mode)
6242        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
6243 {
6244   bool ok = ix86_expand_int_vcond (operands);
6245   gcc_assert (ok);
6246   DONE;
6247 })
6248
6249 (define_expand "vcondu<V_128:mode><VI124_128:mode>"
6250   [(set (match_operand:V_128 0 "register_operand")
6251         (if_then_else:V_128
6252           (match_operator 3 ""
6253             [(match_operand:VI124_128 4 "nonimmediate_operand")
6254              (match_operand:VI124_128 5 "nonimmediate_operand")])
6255           (match_operand:V_128 1 "general_operand")
6256           (match_operand:V_128 2 "general_operand")))]
6257   "TARGET_SSE2
6258    && (GET_MODE_NUNITS (<V_128:MODE>mode)
6259        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
6260 {
6261   bool ok = ix86_expand_int_vcond (operands);
6262   gcc_assert (ok);
6263   DONE;
6264 })
6265
6266 (define_expand "vcondu<VI8F_128:mode>v2di"
6267   [(set (match_operand:VI8F_128 0 "register_operand")
6268         (if_then_else:VI8F_128
6269           (match_operator 3 ""
6270             [(match_operand:V2DI 4 "nonimmediate_operand")
6271              (match_operand:V2DI 5 "nonimmediate_operand")])
6272           (match_operand:VI8F_128 1 "general_operand")
6273           (match_operand:VI8F_128 2 "general_operand")))]
6274   "TARGET_SSE4_2"
6275 {
6276   bool ok = ix86_expand_int_vcond (operands);
6277   gcc_assert (ok);
6278   DONE;
6279 })
6280
6281 (define_mode_iterator VEC_PERM_AVX2
6282   [V16QI V8HI V4SI V2DI V4SF V2DF
6283    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
6284    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
6285    (V8SF "TARGET_AVX2") (V4DF "TARGET_AVX2")])
6286
6287 (define_expand "vec_perm<mode>"
6288   [(match_operand:VEC_PERM_AVX2 0 "register_operand")
6289    (match_operand:VEC_PERM_AVX2 1 "register_operand")
6290    (match_operand:VEC_PERM_AVX2 2 "register_operand")
6291    (match_operand:<sseintvecmode> 3 "register_operand")]
6292   "TARGET_SSSE3 || TARGET_AVX || TARGET_XOP"
6293 {
6294   ix86_expand_vec_perm (operands);
6295   DONE;
6296 })
6297
6298 (define_mode_iterator VEC_PERM_CONST
6299   [(V4SF "TARGET_SSE") (V4SI "TARGET_SSE")
6300    (V2DF "TARGET_SSE") (V2DI "TARGET_SSE")
6301    (V16QI "TARGET_SSE2") (V8HI "TARGET_SSE2")
6302    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
6303    (V8SI "TARGET_AVX") (V4DI "TARGET_AVX")
6304    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")])
6305
6306 (define_expand "vec_perm_const<mode>"
6307   [(match_operand:VEC_PERM_CONST 0 "register_operand")
6308    (match_operand:VEC_PERM_CONST 1 "register_operand")
6309    (match_operand:VEC_PERM_CONST 2 "register_operand")
6310    (match_operand:<sseintvecmode> 3)]
6311   ""
6312 {
6313   if (ix86_expand_vec_perm_const (operands))
6314     DONE;
6315   else
6316     FAIL;
6317 })
6318
6319 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6320 ;;
6321 ;; Parallel bitwise logical operations
6322 ;;
6323 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6324
6325 (define_expand "one_cmpl<mode>2"
6326   [(set (match_operand:VI 0 "register_operand")
6327         (xor:VI (match_operand:VI 1 "nonimmediate_operand")
6328                 (match_dup 2)))]
6329   "TARGET_SSE"
6330 {
6331   int i, n = GET_MODE_NUNITS (<MODE>mode);
6332   rtvec v = rtvec_alloc (n);
6333
6334   for (i = 0; i < n; ++i)
6335     RTVEC_ELT (v, i) = constm1_rtx;
6336
6337   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
6338 })
6339
6340 (define_expand "<sse2_avx2>_andnot<mode>3"
6341   [(set (match_operand:VI_AVX2 0 "register_operand")
6342         (and:VI_AVX2
6343           (not:VI_AVX2 (match_operand:VI_AVX2 1 "register_operand"))
6344           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
6345   "TARGET_SSE2")
6346
6347 (define_insn "*andnot<mode>3"
6348   [(set (match_operand:VI 0 "register_operand" "=x,x")
6349         (and:VI
6350           (not:VI (match_operand:VI 1 "register_operand" "0,x"))
6351           (match_operand:VI 2 "nonimmediate_operand" "xm,xm")))]
6352   "TARGET_SSE"
6353 {
6354   static char buf[32];
6355   const char *ops;
6356   const char *tmp;
6357
6358   switch (get_attr_mode (insn))
6359     {
6360     case MODE_OI:
6361       gcc_assert (TARGET_AVX2);
6362     case MODE_TI:
6363       gcc_assert (TARGET_SSE2);
6364
6365       tmp = "pandn";
6366       break;
6367
6368    case MODE_V8SF:
6369       gcc_assert (TARGET_AVX);
6370    case MODE_V4SF:
6371       gcc_assert (TARGET_SSE);
6372
6373       tmp = "andnps";
6374       break;
6375
6376    default:
6377       gcc_unreachable ();
6378    }
6379
6380   switch (which_alternative)
6381     {
6382     case 0:
6383       ops = "%s\t{%%2, %%0|%%0, %%2}";
6384       break;
6385     case 1:
6386       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
6387       break;
6388     default:
6389       gcc_unreachable ();
6390     }
6391
6392   snprintf (buf, sizeof (buf), ops, tmp);
6393   return buf;
6394 }
6395   [(set_attr "isa" "noavx,avx")
6396    (set_attr "type" "sselog")
6397    (set (attr "prefix_data16")
6398      (if_then_else
6399        (and (eq_attr "alternative" "0")
6400             (eq_attr "mode" "TI"))
6401        (const_string "1")
6402        (const_string "*")))
6403    (set_attr "prefix" "orig,vex")
6404    (set (attr "mode")
6405         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
6406                  (const_string "<ssePSmode>")
6407                (match_test "TARGET_AVX2")
6408                  (const_string "<sseinsnmode>")
6409                (match_test "TARGET_AVX")
6410                  (if_then_else
6411                    (match_test "GET_MODE_SIZE (<MODE>mode) > 16")
6412                    (const_string "V8SF")
6413                    (const_string "<sseinsnmode>"))
6414                (ior (not (match_test "TARGET_SSE2"))
6415                     (match_test "optimize_function_for_size_p (cfun)"))
6416                  (const_string "V4SF")
6417               ]
6418               (const_string "<sseinsnmode>")))])
6419
6420 (define_expand "<code><mode>3"
6421   [(set (match_operand:VI 0 "register_operand")
6422         (any_logic:VI
6423           (match_operand:VI 1 "nonimmediate_or_const_vector_operand")
6424           (match_operand:VI 2 "nonimmediate_or_const_vector_operand")))]
6425   "TARGET_SSE"
6426 {
6427   ix86_expand_vector_logical_operator (<CODE>, <MODE>mode, operands);
6428   DONE;
6429 })
6430
6431 (define_insn "*<code><mode>3"
6432   [(set (match_operand:VI 0 "register_operand" "=x,x")
6433         (any_logic:VI
6434           (match_operand:VI 1 "nonimmediate_operand" "%0,x")
6435           (match_operand:VI 2 "nonimmediate_operand" "xm,xm")))]
6436   "TARGET_SSE
6437    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
6438 {
6439   static char buf[32];
6440   const char *ops;
6441   const char *tmp;
6442
6443   switch (get_attr_mode (insn))
6444     {
6445     case MODE_OI:
6446       gcc_assert (TARGET_AVX2);
6447     case MODE_TI:
6448       gcc_assert (TARGET_SSE2);
6449
6450       tmp = "p<logic>";
6451       break;
6452
6453    case MODE_V8SF:
6454       gcc_assert (TARGET_AVX);
6455    case MODE_V4SF:
6456       gcc_assert (TARGET_SSE);
6457
6458       tmp = "<logic>ps";
6459       break;
6460
6461    default:
6462       gcc_unreachable ();
6463    }
6464
6465   switch (which_alternative)
6466     {
6467     case 0:
6468       ops = "%s\t{%%2, %%0|%%0, %%2}";
6469       break;
6470     case 1:
6471       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
6472       break;
6473     default:
6474       gcc_unreachable ();
6475     }
6476
6477   snprintf (buf, sizeof (buf), ops, tmp);
6478   return buf;
6479 }
6480   [(set_attr "isa" "noavx,avx")
6481    (set_attr "type" "sselog")
6482    (set (attr "prefix_data16")
6483      (if_then_else
6484        (and (eq_attr "alternative" "0")
6485             (eq_attr "mode" "TI"))
6486        (const_string "1")
6487        (const_string "*")))
6488    (set_attr "prefix" "orig,vex")
6489    (set (attr "mode")
6490         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
6491                  (const_string "<ssePSmode>")
6492                (match_test "TARGET_AVX2")
6493                  (const_string "<sseinsnmode>")
6494                (match_test "TARGET_AVX")
6495                  (if_then_else
6496                    (match_test "GET_MODE_SIZE (<MODE>mode) > 16")
6497                    (const_string "V8SF")
6498                    (const_string "<sseinsnmode>"))
6499                (ior (not (match_test "TARGET_SSE2"))
6500                     (match_test "optimize_function_for_size_p (cfun)"))
6501                  (const_string "V4SF")
6502               ]
6503               (const_string "<sseinsnmode>")))])
6504
6505 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6506 ;;
6507 ;; Parallel integral element swizzling
6508 ;;
6509 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6510
6511 (define_expand "vec_pack_trunc_<mode>"
6512   [(match_operand:<ssepackmode> 0 "register_operand")
6513    (match_operand:VI248_AVX2 1 "register_operand")
6514    (match_operand:VI248_AVX2 2 "register_operand")]
6515   "TARGET_SSE2"
6516 {
6517   rtx op1 = gen_lowpart (<ssepackmode>mode, operands[1]);
6518   rtx op2 = gen_lowpart (<ssepackmode>mode, operands[2]);
6519   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
6520   DONE;
6521 })
6522
6523 (define_insn "<sse2_avx2>_packsswb"
6524   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
6525         (vec_concat:VI1_AVX2
6526           (ss_truncate:<ssehalfvecmode>
6527             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
6528           (ss_truncate:<ssehalfvecmode>
6529             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
6530   "TARGET_SSE2"
6531   "@
6532    packsswb\t{%2, %0|%0, %2}
6533    vpacksswb\t{%2, %1, %0|%0, %1, %2}"
6534   [(set_attr "isa" "noavx,avx")
6535    (set_attr "type" "sselog")
6536    (set_attr "prefix_data16" "1,*")
6537    (set_attr "prefix" "orig,vex")
6538    (set_attr "mode" "<sseinsnmode>")])
6539
6540 (define_insn "<sse2_avx2>_packssdw"
6541   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
6542         (vec_concat:VI2_AVX2
6543           (ss_truncate:<ssehalfvecmode>
6544             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
6545           (ss_truncate:<ssehalfvecmode>
6546             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
6547   "TARGET_SSE2"
6548   "@
6549    packssdw\t{%2, %0|%0, %2}
6550    vpackssdw\t{%2, %1, %0|%0, %1, %2}"
6551   [(set_attr "isa" "noavx,avx")
6552    (set_attr "type" "sselog")
6553    (set_attr "prefix_data16" "1,*")
6554    (set_attr "prefix" "orig,vex")
6555    (set_attr "mode" "<sseinsnmode>")])
6556
6557 (define_insn "<sse2_avx2>_packuswb"
6558   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
6559         (vec_concat:VI1_AVX2
6560           (us_truncate:<ssehalfvecmode>
6561             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
6562           (us_truncate:<ssehalfvecmode>
6563             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
6564   "TARGET_SSE2"
6565   "@
6566    packuswb\t{%2, %0|%0, %2}
6567    vpackuswb\t{%2, %1, %0|%0, %1, %2}"
6568   [(set_attr "isa" "noavx,avx")
6569    (set_attr "type" "sselog")
6570    (set_attr "prefix_data16" "1,*")
6571    (set_attr "prefix" "orig,vex")
6572    (set_attr "mode" "<sseinsnmode>")])
6573
6574 (define_insn "avx2_interleave_highv32qi"
6575   [(set (match_operand:V32QI 0 "register_operand" "=x")
6576         (vec_select:V32QI
6577           (vec_concat:V64QI
6578             (match_operand:V32QI 1 "register_operand" "x")
6579             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
6580           (parallel [(const_int 8)  (const_int 40)
6581                      (const_int 9)  (const_int 41)
6582                      (const_int 10) (const_int 42)
6583                      (const_int 11) (const_int 43)
6584                      (const_int 12) (const_int 44)
6585                      (const_int 13) (const_int 45)
6586                      (const_int 14) (const_int 46)
6587                      (const_int 15) (const_int 47)
6588                      (const_int 24) (const_int 56)
6589                      (const_int 25) (const_int 57)
6590                      (const_int 26) (const_int 58)
6591                      (const_int 27) (const_int 59)
6592                      (const_int 28) (const_int 60)
6593                      (const_int 29) (const_int 61)
6594                      (const_int 30) (const_int 62)
6595                      (const_int 31) (const_int 63)])))]
6596   "TARGET_AVX2"
6597   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6598   [(set_attr "type" "sselog")
6599    (set_attr "prefix" "vex")
6600    (set_attr "mode" "OI")])
6601
6602 (define_insn "vec_interleave_highv16qi"
6603   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
6604         (vec_select:V16QI
6605           (vec_concat:V32QI
6606             (match_operand:V16QI 1 "register_operand" "0,x")
6607             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
6608           (parallel [(const_int 8)  (const_int 24)
6609                      (const_int 9)  (const_int 25)
6610                      (const_int 10) (const_int 26)
6611                      (const_int 11) (const_int 27)
6612                      (const_int 12) (const_int 28)
6613                      (const_int 13) (const_int 29)
6614                      (const_int 14) (const_int 30)
6615                      (const_int 15) (const_int 31)])))]
6616   "TARGET_SSE2"
6617   "@
6618    punpckhbw\t{%2, %0|%0, %2}
6619    vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
6620   [(set_attr "isa" "noavx,avx")
6621    (set_attr "type" "sselog")
6622    (set_attr "prefix_data16" "1,*")
6623    (set_attr "prefix" "orig,vex")
6624    (set_attr "mode" "TI")])
6625
6626 (define_insn "avx2_interleave_lowv32qi"
6627   [(set (match_operand:V32QI 0 "register_operand" "=x")
6628         (vec_select:V32QI
6629           (vec_concat:V64QI
6630             (match_operand:V32QI 1 "register_operand" "x")
6631             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
6632           (parallel [(const_int 0) (const_int 32)
6633                      (const_int 1) (const_int 33)
6634                      (const_int 2) (const_int 34)
6635                      (const_int 3) (const_int 35)
6636                      (const_int 4) (const_int 36)
6637                      (const_int 5) (const_int 37)
6638                      (const_int 6) (const_int 38)
6639                      (const_int 7) (const_int 39)
6640                      (const_int 16) (const_int 48)
6641                      (const_int 17) (const_int 49)
6642                      (const_int 18) (const_int 50)
6643                      (const_int 19) (const_int 51)
6644                      (const_int 20) (const_int 52)
6645                      (const_int 21) (const_int 53)
6646                      (const_int 22) (const_int 54)
6647                      (const_int 23) (const_int 55)])))]
6648   "TARGET_AVX2"
6649   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6650   [(set_attr "type" "sselog")
6651    (set_attr "prefix" "vex")
6652    (set_attr "mode" "OI")])
6653
6654 (define_insn "vec_interleave_lowv16qi"
6655   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
6656         (vec_select:V16QI
6657           (vec_concat:V32QI
6658             (match_operand:V16QI 1 "register_operand" "0,x")
6659             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
6660           (parallel [(const_int 0) (const_int 16)
6661                      (const_int 1) (const_int 17)
6662                      (const_int 2) (const_int 18)
6663                      (const_int 3) (const_int 19)
6664                      (const_int 4) (const_int 20)
6665                      (const_int 5) (const_int 21)
6666                      (const_int 6) (const_int 22)
6667                      (const_int 7) (const_int 23)])))]
6668   "TARGET_SSE2"
6669   "@
6670    punpcklbw\t{%2, %0|%0, %2}
6671    vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
6672   [(set_attr "isa" "noavx,avx")
6673    (set_attr "type" "sselog")
6674    (set_attr "prefix_data16" "1,*")
6675    (set_attr "prefix" "orig,vex")
6676    (set_attr "mode" "TI")])
6677
6678 (define_insn "avx2_interleave_highv16hi"
6679   [(set (match_operand:V16HI 0 "register_operand" "=x")
6680         (vec_select:V16HI
6681           (vec_concat:V32HI
6682             (match_operand:V16HI 1 "register_operand" "x")
6683             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
6684           (parallel [(const_int 4) (const_int 20)
6685                      (const_int 5) (const_int 21)
6686                      (const_int 6) (const_int 22)
6687                      (const_int 7) (const_int 23)
6688                      (const_int 12) (const_int 28)
6689                      (const_int 13) (const_int 29)
6690                      (const_int 14) (const_int 30)
6691                      (const_int 15) (const_int 31)])))]
6692   "TARGET_AVX2"
6693   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6694   [(set_attr "type" "sselog")
6695    (set_attr "prefix" "vex")
6696    (set_attr "mode" "OI")])
6697
6698 (define_insn "vec_interleave_highv8hi"
6699   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
6700         (vec_select:V8HI
6701           (vec_concat:V16HI
6702             (match_operand:V8HI 1 "register_operand" "0,x")
6703             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
6704           (parallel [(const_int 4) (const_int 12)
6705                      (const_int 5) (const_int 13)
6706                      (const_int 6) (const_int 14)
6707                      (const_int 7) (const_int 15)])))]
6708   "TARGET_SSE2"
6709   "@
6710    punpckhwd\t{%2, %0|%0, %2}
6711    vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
6712   [(set_attr "isa" "noavx,avx")
6713    (set_attr "type" "sselog")
6714    (set_attr "prefix_data16" "1,*")
6715    (set_attr "prefix" "orig,vex")
6716    (set_attr "mode" "TI")])
6717
6718 (define_insn "avx2_interleave_lowv16hi"
6719   [(set (match_operand:V16HI 0 "register_operand" "=x")
6720         (vec_select:V16HI
6721           (vec_concat:V32HI
6722             (match_operand:V16HI 1 "register_operand" "x")
6723             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
6724           (parallel [(const_int 0) (const_int 16)
6725                      (const_int 1) (const_int 17)
6726                      (const_int 2) (const_int 18)
6727                      (const_int 3) (const_int 19)
6728                      (const_int 8) (const_int 24)
6729                      (const_int 9) (const_int 25)
6730                      (const_int 10) (const_int 26)
6731                      (const_int 11) (const_int 27)])))]
6732   "TARGET_AVX2"
6733   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6734   [(set_attr "type" "sselog")
6735    (set_attr "prefix" "vex")
6736    (set_attr "mode" "OI")])
6737
6738 (define_insn "vec_interleave_lowv8hi"
6739   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
6740         (vec_select:V8HI
6741           (vec_concat:V16HI
6742             (match_operand:V8HI 1 "register_operand" "0,x")
6743             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
6744           (parallel [(const_int 0) (const_int 8)
6745                      (const_int 1) (const_int 9)
6746                      (const_int 2) (const_int 10)
6747                      (const_int 3) (const_int 11)])))]
6748   "TARGET_SSE2"
6749   "@
6750    punpcklwd\t{%2, %0|%0, %2}
6751    vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
6752   [(set_attr "isa" "noavx,avx")
6753    (set_attr "type" "sselog")
6754    (set_attr "prefix_data16" "1,*")
6755    (set_attr "prefix" "orig,vex")
6756    (set_attr "mode" "TI")])
6757
6758 (define_insn "avx2_interleave_highv8si"
6759   [(set (match_operand:V8SI 0 "register_operand" "=x")
6760         (vec_select:V8SI
6761           (vec_concat:V16SI
6762             (match_operand:V8SI 1 "register_operand" "x")
6763             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
6764           (parallel [(const_int 2) (const_int 10)
6765                      (const_int 3) (const_int 11)
6766                      (const_int 6) (const_int 14)
6767                      (const_int 7) (const_int 15)])))]
6768   "TARGET_AVX2"
6769   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6770   [(set_attr "type" "sselog")
6771    (set_attr "prefix" "vex")
6772    (set_attr "mode" "OI")])
6773
6774 (define_insn "vec_interleave_highv4si"
6775   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
6776         (vec_select:V4SI
6777           (vec_concat:V8SI
6778             (match_operand:V4SI 1 "register_operand" "0,x")
6779             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
6780           (parallel [(const_int 2) (const_int 6)
6781                      (const_int 3) (const_int 7)])))]
6782   "TARGET_SSE2"
6783   "@
6784    punpckhdq\t{%2, %0|%0, %2}
6785    vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
6786   [(set_attr "isa" "noavx,avx")
6787    (set_attr "type" "sselog")
6788    (set_attr "prefix_data16" "1,*")
6789    (set_attr "prefix" "orig,vex")
6790    (set_attr "mode" "TI")])
6791
6792 (define_insn "avx2_interleave_lowv8si"
6793   [(set (match_operand:V8SI 0 "register_operand" "=x")
6794         (vec_select:V8SI
6795           (vec_concat:V16SI
6796             (match_operand:V8SI 1 "register_operand" "x")
6797             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
6798           (parallel [(const_int 0) (const_int 8)
6799                      (const_int 1) (const_int 9)
6800                      (const_int 4) (const_int 12)
6801                      (const_int 5) (const_int 13)])))]
6802   "TARGET_AVX2"
6803   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6804   [(set_attr "type" "sselog")
6805    (set_attr "prefix" "vex")
6806    (set_attr "mode" "OI")])
6807
6808 (define_insn "vec_interleave_lowv4si"
6809   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
6810         (vec_select:V4SI
6811           (vec_concat:V8SI
6812             (match_operand:V4SI 1 "register_operand" "0,x")
6813             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
6814           (parallel [(const_int 0) (const_int 4)
6815                      (const_int 1) (const_int 5)])))]
6816   "TARGET_SSE2"
6817   "@
6818    punpckldq\t{%2, %0|%0, %2}
6819    vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
6820   [(set_attr "isa" "noavx,avx")
6821    (set_attr "type" "sselog")
6822    (set_attr "prefix_data16" "1,*")
6823    (set_attr "prefix" "orig,vex")
6824    (set_attr "mode" "TI")])
6825
6826 (define_expand "vec_interleave_high<mode>"
6827   [(match_operand:VI_256 0 "register_operand" "=x")
6828    (match_operand:VI_256 1 "register_operand" "x")
6829    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
6830  "TARGET_AVX2"
6831 {
6832   rtx t1 = gen_reg_rtx (<MODE>mode);
6833   rtx t2 = gen_reg_rtx (<MODE>mode);
6834   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
6835   emit_insn (gen_avx2_interleave_high<mode> (t2,  operands[1], operands[2]));
6836   emit_insn (gen_avx2_permv2ti
6837              (gen_lowpart (V4DImode, operands[0]),
6838               gen_lowpart (V4DImode, t1),
6839               gen_lowpart (V4DImode, t2), GEN_INT (1 + (3 << 4))));
6840   DONE;
6841 })
6842
6843 (define_expand "vec_interleave_low<mode>"
6844   [(match_operand:VI_256 0 "register_operand" "=x")
6845    (match_operand:VI_256 1 "register_operand" "x")
6846    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
6847  "TARGET_AVX2"
6848 {
6849   rtx t1 = gen_reg_rtx (<MODE>mode);
6850   rtx t2 = gen_reg_rtx (<MODE>mode);
6851   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
6852   emit_insn (gen_avx2_interleave_high<mode> (t2, operands[1], operands[2]));
6853   emit_insn (gen_avx2_permv2ti
6854              (gen_lowpart (V4DImode, operands[0]),
6855               gen_lowpart (V4DImode, t1),
6856               gen_lowpart (V4DImode, t2), GEN_INT (0 + (2 << 4))));
6857   DONE;
6858 })
6859
6860 ;; Modes handled by pinsr patterns.
6861 (define_mode_iterator PINSR_MODE
6862   [(V16QI "TARGET_SSE4_1") V8HI
6863    (V4SI "TARGET_SSE4_1")
6864    (V2DI "TARGET_SSE4_1 && TARGET_64BIT")])
6865
6866 (define_mode_attr sse2p4_1
6867   [(V16QI "sse4_1") (V8HI "sse2")
6868    (V4SI "sse4_1") (V2DI "sse4_1")])
6869
6870 ;; sse4_1_pinsrd must come before sse2_loadld since it is preferred.
6871 (define_insn "<sse2p4_1>_pinsr<ssemodesuffix>"
6872   [(set (match_operand:PINSR_MODE 0 "register_operand" "=x,x,x,x")
6873         (vec_merge:PINSR_MODE
6874           (vec_duplicate:PINSR_MODE
6875             (match_operand:<ssescalarmode> 2 "nonimmediate_operand" "r,m,r,m"))
6876           (match_operand:PINSR_MODE 1 "register_operand" "0,0,x,x")
6877           (match_operand:SI 3 "const_int_operand")))]
6878   "TARGET_SSE2
6879    && ((unsigned) exact_log2 (INTVAL (operands[3]))
6880        < GET_MODE_NUNITS (<MODE>mode))"
6881 {
6882   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
6883
6884   switch (which_alternative)
6885     {
6886     case 0:
6887       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
6888         return "pinsr<ssemodesuffix>\t{%3, %k2, %0|%0, %k2, %3}";
6889       /* FALLTHRU */
6890     case 1:
6891       return "pinsr<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}";
6892     case 2:
6893       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
6894         return "vpinsr<ssemodesuffix>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
6895       /* FALLTHRU */
6896     case 3:
6897       return "vpinsr<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6898     default:
6899       gcc_unreachable ();
6900     }
6901 }
6902   [(set_attr "isa" "noavx,noavx,avx,avx")
6903    (set_attr "type" "sselog")
6904    (set (attr "prefix_rex")
6905      (if_then_else
6906        (and (not (match_test "TARGET_AVX"))
6907             (eq (const_string "<MODE>mode") (const_string "V2DImode")))
6908        (const_string "1")
6909        (const_string "*")))
6910    (set (attr "prefix_data16")
6911      (if_then_else
6912        (and (not (match_test "TARGET_AVX"))
6913             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
6914        (const_string "1")
6915        (const_string "*")))
6916    (set (attr "prefix_extra")
6917      (if_then_else
6918        (and (not (match_test "TARGET_AVX"))
6919             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
6920        (const_string "*")
6921        (const_string "1")))
6922    (set_attr "length_immediate" "1")
6923    (set_attr "prefix" "orig,orig,vex,vex")
6924    (set_attr "mode" "TI")])
6925
6926 (define_expand "avx2_pshufdv3"
6927   [(match_operand:V8SI 0 "register_operand")
6928    (match_operand:V8SI 1 "nonimmediate_operand")
6929    (match_operand:SI 2 "const_0_to_255_operand")]
6930   "TARGET_AVX2"
6931 {
6932   int mask = INTVAL (operands[2]);
6933   emit_insn (gen_avx2_pshufd_1 (operands[0], operands[1],
6934                                 GEN_INT ((mask >> 0) & 3),
6935                                 GEN_INT ((mask >> 2) & 3),
6936                                 GEN_INT ((mask >> 4) & 3),
6937                                 GEN_INT ((mask >> 6) & 3),
6938                                 GEN_INT (((mask >> 0) & 3) + 4),
6939                                 GEN_INT (((mask >> 2) & 3) + 4),
6940                                 GEN_INT (((mask >> 4) & 3) + 4),
6941                                 GEN_INT (((mask >> 6) & 3) + 4)));
6942   DONE;
6943 })
6944
6945 (define_insn "avx2_pshufd_1"
6946   [(set (match_operand:V8SI 0 "register_operand" "=x")
6947         (vec_select:V8SI
6948           (match_operand:V8SI 1 "nonimmediate_operand" "xm")
6949           (parallel [(match_operand 2 "const_0_to_3_operand")
6950                      (match_operand 3 "const_0_to_3_operand")
6951                      (match_operand 4 "const_0_to_3_operand")
6952                      (match_operand 5 "const_0_to_3_operand")
6953                      (match_operand 6 "const_4_to_7_operand")
6954                      (match_operand 7 "const_4_to_7_operand")
6955                      (match_operand 8 "const_4_to_7_operand")
6956                      (match_operand 9 "const_4_to_7_operand")])))]
6957   "TARGET_AVX2
6958    && INTVAL (operands[2]) + 4 == INTVAL (operands[6])
6959    && INTVAL (operands[3]) + 4 == INTVAL (operands[7])
6960    && INTVAL (operands[4]) + 4 == INTVAL (operands[8])
6961    && INTVAL (operands[5]) + 4 == INTVAL (operands[9])"
6962 {
6963   int mask = 0;
6964   mask |= INTVAL (operands[2]) << 0;
6965   mask |= INTVAL (operands[3]) << 2;
6966   mask |= INTVAL (operands[4]) << 4;
6967   mask |= INTVAL (operands[5]) << 6;
6968   operands[2] = GEN_INT (mask);
6969
6970   return "vpshufd\t{%2, %1, %0|%0, %1, %2}";
6971 }
6972   [(set_attr "type" "sselog1")
6973    (set_attr "prefix" "vex")
6974    (set_attr "length_immediate" "1")
6975    (set_attr "mode" "OI")])
6976
6977 (define_expand "sse2_pshufd"
6978   [(match_operand:V4SI 0 "register_operand")
6979    (match_operand:V4SI 1 "nonimmediate_operand")
6980    (match_operand:SI 2 "const_int_operand")]
6981   "TARGET_SSE2"
6982 {
6983   int mask = INTVAL (operands[2]);
6984   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
6985                                 GEN_INT ((mask >> 0) & 3),
6986                                 GEN_INT ((mask >> 2) & 3),
6987                                 GEN_INT ((mask >> 4) & 3),
6988                                 GEN_INT ((mask >> 6) & 3)));
6989   DONE;
6990 })
6991
6992 (define_insn "sse2_pshufd_1"
6993   [(set (match_operand:V4SI 0 "register_operand" "=x")
6994         (vec_select:V4SI
6995           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
6996           (parallel [(match_operand 2 "const_0_to_3_operand")
6997                      (match_operand 3 "const_0_to_3_operand")
6998                      (match_operand 4 "const_0_to_3_operand")
6999                      (match_operand 5 "const_0_to_3_operand")])))]
7000   "TARGET_SSE2"
7001 {
7002   int mask = 0;
7003   mask |= INTVAL (operands[2]) << 0;
7004   mask |= INTVAL (operands[3]) << 2;
7005   mask |= INTVAL (operands[4]) << 4;
7006   mask |= INTVAL (operands[5]) << 6;
7007   operands[2] = GEN_INT (mask);
7008
7009   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
7010 }
7011   [(set_attr "type" "sselog1")
7012    (set_attr "prefix_data16" "1")
7013    (set_attr "prefix" "maybe_vex")
7014    (set_attr "length_immediate" "1")
7015    (set_attr "mode" "TI")])
7016
7017 (define_expand "avx2_pshuflwv3"
7018   [(match_operand:V16HI 0 "register_operand")
7019    (match_operand:V16HI 1 "nonimmediate_operand")
7020    (match_operand:SI 2 "const_0_to_255_operand")]
7021   "TARGET_AVX2"
7022 {
7023   int mask = INTVAL (operands[2]);
7024   emit_insn (gen_avx2_pshuflw_1 (operands[0], operands[1],
7025                                  GEN_INT ((mask >> 0) & 3),
7026                                  GEN_INT ((mask >> 2) & 3),
7027                                  GEN_INT ((mask >> 4) & 3),
7028                                  GEN_INT ((mask >> 6) & 3),
7029                                  GEN_INT (((mask >> 0) & 3) + 8),
7030                                  GEN_INT (((mask >> 2) & 3) + 8),
7031                                  GEN_INT (((mask >> 4) & 3) + 8),
7032                                  GEN_INT (((mask >> 6) & 3) + 8)));
7033   DONE;
7034 })
7035
7036 (define_insn "avx2_pshuflw_1"
7037   [(set (match_operand:V16HI 0 "register_operand" "=x")
7038         (vec_select:V16HI
7039           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
7040           (parallel [(match_operand 2 "const_0_to_3_operand")
7041                      (match_operand 3 "const_0_to_3_operand")
7042                      (match_operand 4 "const_0_to_3_operand")
7043                      (match_operand 5 "const_0_to_3_operand")
7044                      (const_int 4)
7045                      (const_int 5)
7046                      (const_int 6)
7047                      (const_int 7)
7048                      (match_operand 6 "const_8_to_11_operand")
7049                      (match_operand 7 "const_8_to_11_operand")
7050                      (match_operand 8 "const_8_to_11_operand")
7051                      (match_operand 9 "const_8_to_11_operand")
7052                      (const_int 12)
7053                      (const_int 13)
7054                      (const_int 14)
7055                      (const_int 15)])))]
7056   "TARGET_AVX2
7057    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
7058    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
7059    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
7060    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
7061 {
7062   int mask = 0;
7063   mask |= INTVAL (operands[2]) << 0;
7064   mask |= INTVAL (operands[3]) << 2;
7065   mask |= INTVAL (operands[4]) << 4;
7066   mask |= INTVAL (operands[5]) << 6;
7067   operands[2] = GEN_INT (mask);
7068
7069   return "vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7070 }
7071   [(set_attr "type" "sselog")
7072    (set_attr "prefix" "vex")
7073    (set_attr "length_immediate" "1")
7074    (set_attr "mode" "OI")])
7075
7076 (define_expand "sse2_pshuflw"
7077   [(match_operand:V8HI 0 "register_operand")
7078    (match_operand:V8HI 1 "nonimmediate_operand")
7079    (match_operand:SI 2 "const_int_operand")]
7080   "TARGET_SSE2"
7081 {
7082   int mask = INTVAL (operands[2]);
7083   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
7084                                  GEN_INT ((mask >> 0) & 3),
7085                                  GEN_INT ((mask >> 2) & 3),
7086                                  GEN_INT ((mask >> 4) & 3),
7087                                  GEN_INT ((mask >> 6) & 3)));
7088   DONE;
7089 })
7090
7091 (define_insn "sse2_pshuflw_1"
7092   [(set (match_operand:V8HI 0 "register_operand" "=x")
7093         (vec_select:V8HI
7094           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7095           (parallel [(match_operand 2 "const_0_to_3_operand")
7096                      (match_operand 3 "const_0_to_3_operand")
7097                      (match_operand 4 "const_0_to_3_operand")
7098                      (match_operand 5 "const_0_to_3_operand")
7099                      (const_int 4)
7100                      (const_int 5)
7101                      (const_int 6)
7102                      (const_int 7)])))]
7103   "TARGET_SSE2"
7104 {
7105   int mask = 0;
7106   mask |= INTVAL (operands[2]) << 0;
7107   mask |= INTVAL (operands[3]) << 2;
7108   mask |= INTVAL (operands[4]) << 4;
7109   mask |= INTVAL (operands[5]) << 6;
7110   operands[2] = GEN_INT (mask);
7111
7112   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
7113 }
7114   [(set_attr "type" "sselog")
7115    (set_attr "prefix_data16" "0")
7116    (set_attr "prefix_rep" "1")
7117    (set_attr "prefix" "maybe_vex")
7118    (set_attr "length_immediate" "1")
7119    (set_attr "mode" "TI")])
7120
7121 (define_expand "avx2_pshufhwv3"
7122   [(match_operand:V16HI 0 "register_operand")
7123    (match_operand:V16HI 1 "nonimmediate_operand")
7124    (match_operand:SI 2 "const_0_to_255_operand")]
7125   "TARGET_AVX2"
7126 {
7127   int mask = INTVAL (operands[2]);
7128   emit_insn (gen_avx2_pshufhw_1 (operands[0], operands[1],
7129                                  GEN_INT (((mask >> 0) & 3) + 4),
7130                                  GEN_INT (((mask >> 2) & 3) + 4),
7131                                  GEN_INT (((mask >> 4) & 3) + 4),
7132                                  GEN_INT (((mask >> 6) & 3) + 4),
7133                                  GEN_INT (((mask >> 0) & 3) + 12),
7134                                  GEN_INT (((mask >> 2) & 3) + 12),
7135                                  GEN_INT (((mask >> 4) & 3) + 12),
7136                                  GEN_INT (((mask >> 6) & 3) + 12)));
7137   DONE;
7138 })
7139
7140 (define_insn "avx2_pshufhw_1"
7141   [(set (match_operand:V16HI 0 "register_operand" "=x")
7142         (vec_select:V16HI
7143           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
7144           (parallel [(const_int 0)
7145                      (const_int 1)
7146                      (const_int 2)
7147                      (const_int 3)
7148                      (match_operand 2 "const_4_to_7_operand")
7149                      (match_operand 3 "const_4_to_7_operand")
7150                      (match_operand 4 "const_4_to_7_operand")
7151                      (match_operand 5 "const_4_to_7_operand")
7152                      (const_int 8)
7153                      (const_int 9)
7154                      (const_int 10)
7155                      (const_int 11)
7156                      (match_operand 6 "const_12_to_15_operand")
7157                      (match_operand 7 "const_12_to_15_operand")
7158                      (match_operand 8 "const_12_to_15_operand")
7159                      (match_operand 9 "const_12_to_15_operand")])))]
7160   "TARGET_AVX2
7161    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
7162    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
7163    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
7164    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
7165 {
7166   int mask = 0;
7167   mask |= (INTVAL (operands[2]) - 4) << 0;
7168   mask |= (INTVAL (operands[3]) - 4) << 2;
7169   mask |= (INTVAL (operands[4]) - 4) << 4;
7170   mask |= (INTVAL (operands[5]) - 4) << 6;
7171   operands[2] = GEN_INT (mask);
7172
7173   return "vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7174 }
7175   [(set_attr "type" "sselog")
7176    (set_attr "prefix" "vex")
7177    (set_attr "length_immediate" "1")
7178    (set_attr "mode" "OI")])
7179
7180 (define_expand "sse2_pshufhw"
7181   [(match_operand:V8HI 0 "register_operand")
7182    (match_operand:V8HI 1 "nonimmediate_operand")
7183    (match_operand:SI 2 "const_int_operand")]
7184   "TARGET_SSE2"
7185 {
7186   int mask = INTVAL (operands[2]);
7187   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
7188                                  GEN_INT (((mask >> 0) & 3) + 4),
7189                                  GEN_INT (((mask >> 2) & 3) + 4),
7190                                  GEN_INT (((mask >> 4) & 3) + 4),
7191                                  GEN_INT (((mask >> 6) & 3) + 4)));
7192   DONE;
7193 })
7194
7195 (define_insn "sse2_pshufhw_1"
7196   [(set (match_operand:V8HI 0 "register_operand" "=x")
7197         (vec_select:V8HI
7198           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
7199           (parallel [(const_int 0)
7200                      (const_int 1)
7201                      (const_int 2)
7202                      (const_int 3)
7203                      (match_operand 2 "const_4_to_7_operand")
7204                      (match_operand 3 "const_4_to_7_operand")
7205                      (match_operand 4 "const_4_to_7_operand")
7206                      (match_operand 5 "const_4_to_7_operand")])))]
7207   "TARGET_SSE2"
7208 {
7209   int mask = 0;
7210   mask |= (INTVAL (operands[2]) - 4) << 0;
7211   mask |= (INTVAL (operands[3]) - 4) << 2;
7212   mask |= (INTVAL (operands[4]) - 4) << 4;
7213   mask |= (INTVAL (operands[5]) - 4) << 6;
7214   operands[2] = GEN_INT (mask);
7215
7216   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
7217 }
7218   [(set_attr "type" "sselog")
7219    (set_attr "prefix_rep" "1")
7220    (set_attr "prefix_data16" "0")
7221    (set_attr "prefix" "maybe_vex")
7222    (set_attr "length_immediate" "1")
7223    (set_attr "mode" "TI")])
7224
7225 (define_expand "sse2_loadd"
7226   [(set (match_operand:V4SI 0 "register_operand")
7227         (vec_merge:V4SI
7228           (vec_duplicate:V4SI
7229             (match_operand:SI 1 "nonimmediate_operand"))
7230           (match_dup 2)
7231           (const_int 1)))]
7232   "TARGET_SSE"
7233   "operands[2] = CONST0_RTX (V4SImode);")
7234
7235 (define_insn "sse2_loadld"
7236   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x,x,x")
7237         (vec_merge:V4SI
7238           (vec_duplicate:V4SI
7239             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,m,x,x"))
7240           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,C,0,x")
7241           (const_int 1)))]
7242   "TARGET_SSE"
7243   "@
7244    %vmovd\t{%2, %0|%0, %2}
7245    %vmovd\t{%2, %0|%0, %2}
7246    movss\t{%2, %0|%0, %2}
7247    movss\t{%2, %0|%0, %2}
7248    vmovss\t{%2, %1, %0|%0, %1, %2}"
7249   [(set_attr "isa" "sse2,*,noavx,noavx,avx")
7250    (set_attr "type" "ssemov")
7251    (set_attr "prefix" "maybe_vex,maybe_vex,orig,orig,vex")
7252    (set_attr "mode" "TI,TI,V4SF,SF,SF")])
7253
7254 (define_insn "*vec_extract<mode>"
7255   [(set (match_operand:<ssescalarmode> 0 "nonimmediate_operand" "=r,m")
7256         (vec_select:<ssescalarmode>
7257           (match_operand:VI12_128 1 "register_operand" "x,x")
7258           (parallel
7259             [(match_operand:SI 2 "const_0_to_<ssescalarnummask>_operand")])))]
7260   "TARGET_SSE4_1"
7261   "@
7262    %vpextr<ssemodesuffix>\t{%2, %1, %k0|%k0, %1, %2}
7263    %vpextr<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
7264   [(set_attr "type" "sselog1")
7265    (set (attr "prefix_data16")
7266      (if_then_else
7267        (and (eq_attr "alternative" "0")
7268             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
7269        (const_string "1")
7270        (const_string "*")))
7271    (set (attr "prefix_extra")
7272      (if_then_else
7273        (and (eq_attr "alternative" "0")
7274             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
7275        (const_string "*")
7276        (const_string "1")))
7277    (set_attr "length_immediate" "1")
7278    (set_attr "prefix" "maybe_vex")
7279    (set_attr "mode" "TI")])
7280
7281 (define_insn "*vec_extractv8hi_sse2"
7282   [(set (match_operand:HI 0 "register_operand" "=r")
7283         (vec_select:HI
7284           (match_operand:V8HI 1 "register_operand" "x")
7285           (parallel
7286             [(match_operand:SI 2 "const_0_to_7_operand")])))]
7287   "TARGET_SSE2 && !TARGET_SSE4_1"
7288   "pextrw\t{%2, %1, %k0|%k0, %1, %2}"
7289   [(set_attr "type" "sselog1")
7290    (set_attr "prefix_data16" "1")
7291    (set_attr "length_immediate" "1")
7292    (set_attr "mode" "TI")])
7293
7294 (define_insn "*vec_extractv16qi_zext"
7295   [(set (match_operand:SWI48 0 "register_operand" "=r")
7296         (zero_extend:SWI48
7297           (vec_select:QI
7298             (match_operand:V16QI 1 "register_operand" "x")
7299             (parallel
7300               [(match_operand:SI 2 "const_0_to_15_operand")]))))]
7301   "TARGET_SSE4_1"
7302   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
7303   [(set_attr "type" "sselog1")
7304    (set_attr "prefix_extra" "1")
7305    (set_attr "length_immediate" "1")
7306    (set_attr "prefix" "maybe_vex")
7307    (set_attr "mode" "TI")])
7308
7309 (define_insn "*vec_extractv8hi_zext"
7310   [(set (match_operand:SWI48 0 "register_operand" "=r")
7311         (zero_extend:SWI48
7312           (vec_select:HI
7313             (match_operand:V8HI 1 "register_operand" "x")
7314             (parallel
7315               [(match_operand:SI 2 "const_0_to_7_operand")]))))]
7316   "TARGET_SSE2"
7317   "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
7318   [(set_attr "type" "sselog1")
7319    (set_attr "prefix_data16" "1")
7320    (set_attr "length_immediate" "1")
7321    (set_attr "prefix" "maybe_vex")
7322    (set_attr "mode" "TI")])
7323
7324 (define_insn "*vec_extract<mode>_mem"
7325   [(set (match_operand:<ssescalarmode> 0 "register_operand" "=r")
7326         (vec_select:<ssescalarmode>
7327           (match_operand:VI12_128 1 "memory_operand" "o")
7328           (parallel
7329             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
7330   "TARGET_SSE"
7331   "#")
7332
7333 (define_insn "*vec_extract<ssevecmodelower>_0"
7334   [(set (match_operand:SWI48 0 "nonimmediate_operand"          "=r ,r,x ,m")
7335         (vec_select:SWI48
7336           (match_operand:<ssevecmode> 1 "nonimmediate_operand" "mYj,x,xm,x")
7337           (parallel [(const_int 0)])))]
7338   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7339   "#"
7340   [(set_attr "isa" "*,sse4,*,*")])
7341
7342 (define_insn_and_split "*vec_extractv4si_0_zext"
7343   [(set (match_operand:DI 0 "register_operand" "=r")
7344         (zero_extend:DI
7345           (vec_select:SI
7346             (match_operand:V4SI 1 "register_operand" "x")
7347             (parallel [(const_int 0)]))))]
7348   "TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_FROM_VEC"
7349   "#"
7350   "&& reload_completed"
7351   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
7352   "operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));")
7353
7354 (define_insn "*vec_extractv2di_0_sse"
7355   [(set (match_operand:DI 0 "nonimmediate_operand"     "=x,m")
7356         (vec_select:DI
7357           (match_operand:V2DI 1 "nonimmediate_operand" "xm,x")
7358           (parallel [(const_int 0)])))]
7359   "TARGET_SSE && !TARGET_64BIT
7360    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7361   "#")
7362
7363 (define_split
7364   [(set (match_operand:SWI48x 0 "nonimmediate_operand")
7365         (vec_select:SWI48x
7366           (match_operand:<ssevecmode> 1 "register_operand")
7367           (parallel [(const_int 0)])))]
7368   "TARGET_SSE && reload_completed"
7369   [(set (match_dup 0) (match_dup 1))]
7370   "operands[1] = gen_rtx_REG (<MODE>mode, REGNO (operands[1]));")
7371
7372 (define_insn "*vec_extractv4si"
7373   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,x,x")
7374         (vec_select:SI
7375           (match_operand:V4SI 1 "register_operand" "x,0,x")
7376           (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
7377   "TARGET_SSE4_1"
7378 {
7379   switch (which_alternative)
7380     {
7381     case 0:
7382       return "%vpextrd\t{%2, %1, %0|%0, %1, %2}";
7383
7384     case 1:
7385       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
7386       return "psrldq\t{%2, %0|%0, %2}";
7387
7388     case 2:
7389       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
7390       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
7391
7392     default:
7393       gcc_unreachable ();
7394     }
7395 }
7396   [(set_attr "isa" "*,noavx,avx")
7397    (set_attr "type" "sselog1,sseishft1,sseishft1")
7398    (set_attr "prefix_extra" "1,*,*")
7399    (set_attr "length_immediate" "1")
7400    (set_attr "prefix" "maybe_vex,orig,vex")
7401    (set_attr "mode" "TI")])
7402
7403 (define_insn "*vec_extractv4si_zext"
7404   [(set (match_operand:DI 0 "register_operand" "=r")
7405         (zero_extend:DI
7406           (vec_select:SI
7407             (match_operand:V4SI 1 "register_operand" "x")
7408             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
7409   "TARGET_64BIT && TARGET_SSE4_1"
7410   "%vpextrd\t{%2, %1, %k0|%k0, %1, %2}"
7411   [(set_attr "type" "sselog1")
7412    (set_attr "prefix_extra" "1")
7413    (set_attr "length_immediate" "1")
7414    (set_attr "prefix" "maybe_vex")
7415    (set_attr "mode" "TI")])
7416
7417 (define_insn "*vec_extractv4si_mem"
7418   [(set (match_operand:SI 0 "register_operand" "=x,r")
7419         (vec_select:SI
7420           (match_operand:V4SI 1 "memory_operand" "o,o")
7421           (parallel [(match_operand 2 "const_0_to_3_operand")])))]
7422   "TARGET_SSE"
7423   "#")
7424
7425 (define_insn_and_split "*vec_extractv4si_zext_mem"
7426   [(set (match_operand:DI 0 "register_operand" "=x,r")
7427         (zero_extend:DI
7428           (vec_select:SI
7429             (match_operand:V4SI 1 "memory_operand" "o,o")
7430             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
7431   "TARGET_64BIT && TARGET_SSE"
7432   "#"
7433   "&& reload_completed"
7434   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
7435 {
7436   operands[1] = adjust_address (operands[1], SImode, INTVAL (operands[2]) * 4);
7437 })
7438
7439 (define_insn "*vec_extractv2di_1"
7440   [(set (match_operand:DI 0 "nonimmediate_operand"     "=rm,m,x,x,x,x,r")
7441         (vec_select:DI
7442           (match_operand:V2DI 1 "nonimmediate_operand"  "x ,x,0,x,x,o,o")
7443           (parallel [(const_int 1)])))]
7444   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7445   "@
7446    %vpextrq\t{$1, %1, %0|%0, %1, 1}
7447    %vmovhps\t{%1, %0|%0, %1}
7448    psrldq\t{$8, %0|%0, 8}
7449    vpsrldq\t{$8, %1, %0|%0, %1, 8}
7450    movhlps\t{%1, %0|%0, %1}
7451    #
7452    #"
7453   [(set_attr "isa" "x64_sse4,*,sse2_noavx,avx,noavx,*,x64")
7454    (set_attr "type" "sselog1,ssemov,sseishft1,sseishft1,ssemov,ssemov,imov")
7455    (set_attr "length_immediate" "1,*,1,1,*,*,*")
7456    (set_attr "prefix_rex" "1,*,*,*,*,*,*")
7457    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
7458    (set_attr "prefix" "maybe_vex,maybe_vex,orig,vex,orig,*,*")
7459    (set_attr "mode" "TI,V2SF,TI,TI,V4SF,DI,DI")])
7460
7461 (define_split
7462   [(set (match_operand:<ssescalarmode> 0 "register_operand")
7463         (vec_select:<ssescalarmode>
7464           (match_operand:VI_128 1 "memory_operand")
7465           (parallel
7466             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
7467   "TARGET_SSE && reload_completed"
7468   [(set (match_dup 0) (match_dup 1))]
7469 {
7470   int offs = INTVAL (operands[2]) * GET_MODE_SIZE (<ssescalarmode>mode);
7471
7472   operands[1] = adjust_address (operands[1], <ssescalarmode>mode, offs);
7473 })
7474
7475 (define_insn "*vec_dupv4si"
7476   [(set (match_operand:V4SI 0 "register_operand"     "=x,x,x")
7477         (vec_duplicate:V4SI
7478           (match_operand:SI 1 "nonimmediate_operand" " x,m,0")))]
7479   "TARGET_SSE"
7480   "@
7481    %vpshufd\t{$0, %1, %0|%0, %1, 0}
7482    vbroadcastss\t{%1, %0|%0, %1}
7483    shufps\t{$0, %0, %0|%0, %0, 0}"
7484   [(set_attr "isa" "sse2,avx,noavx")
7485    (set_attr "type" "sselog1,ssemov,sselog1")
7486    (set_attr "length_immediate" "1,0,1")
7487    (set_attr "prefix_extra" "0,1,*")
7488    (set_attr "prefix" "maybe_vex,vex,orig")
7489    (set_attr "mode" "TI,V4SF,V4SF")])
7490
7491 (define_insn "*vec_dupv2di"
7492   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,x,x")
7493         (vec_duplicate:V2DI
7494           (match_operand:DI 1 "nonimmediate_operand" " 0,x,m,0")))]
7495   "TARGET_SSE"
7496   "@
7497    punpcklqdq\t%0, %0
7498    vpunpcklqdq\t{%d1, %0|%0, %d1}
7499    %vmovddup\t{%1, %0|%0, %1}
7500    movlhps\t%0, %0"
7501   [(set_attr "isa" "sse2_noavx,avx,sse3,noavx")
7502    (set_attr "type" "sselog1,sselog1,sselog1,ssemov")
7503    (set_attr "prefix" "orig,vex,maybe_vex,orig")
7504    (set_attr "mode" "TI,TI,DF,V4SF")])
7505
7506 (define_insn "*vec_concatv2si_sse4_1"
7507   [(set (match_operand:V2SI 0 "register_operand"     "=x, x,x,x, x, *y,*y")
7508         (vec_concat:V2SI
7509           (match_operand:SI 1 "nonimmediate_operand" " 0, x,0,x,rm,  0,rm")
7510           (match_operand:SI 2 "vector_move_operand"  "rm,rm,x,x, C,*ym, C")))]
7511   "TARGET_SSE4_1"
7512   "@
7513    pinsrd\t{$1, %2, %0|%0, %2, 1}
7514    vpinsrd\t{$1, %2, %1, %0|%0, %1, %2, 1}
7515    punpckldq\t{%2, %0|%0, %2}
7516    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
7517    %vmovd\t{%1, %0|%0, %1}
7518    punpckldq\t{%2, %0|%0, %2}
7519    movd\t{%1, %0|%0, %1}"
7520   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
7521    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
7522    (set_attr "prefix_extra" "1,1,*,*,*,*,*")
7523    (set_attr "length_immediate" "1,1,*,*,*,*,*")
7524    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
7525    (set_attr "mode" "TI,TI,TI,TI,TI,DI,DI")])
7526
7527 ;; ??? In theory we can match memory for the MMX alternative, but allowing
7528 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
7529 ;; alternatives pretty much forces the MMX alternative to be chosen.
7530 (define_insn "*vec_concatv2si"
7531   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,x,x,*y,*y")
7532         (vec_concat:V2SI
7533           (match_operand:SI 1 "nonimmediate_operand" " 0,rm,rm,0,m, 0,*rm")
7534           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,C, x,C,*y,C")))]
7535   "TARGET_SSE && !TARGET_SSE4_1"
7536   "@
7537    punpckldq\t{%2, %0|%0, %2}
7538    movd\t{%1, %0|%0, %1}
7539    movd\t{%1, %0|%0, %1}
7540    unpcklps\t{%2, %0|%0, %2}
7541    movss\t{%1, %0|%0, %1}
7542    punpckldq\t{%2, %0|%0, %2}
7543    movd\t{%1, %0|%0, %1}"
7544   [(set_attr "isa" "sse2,sse2,sse2,*,*,*,*")
7545    (set_attr "type" "sselog,ssemov,mmxmov,sselog,ssemov,mmxcvt,mmxmov")
7546    (set_attr "mode" "TI,TI,DI,V4SF,SF,DI,DI")])
7547
7548 (define_insn "*vec_concatv4si"
7549   [(set (match_operand:V4SI 0 "register_operand"       "=x,x,x,x,x")
7550         (vec_concat:V4SI
7551           (match_operand:V2SI 1 "register_operand"     " 0,x,0,0,x")
7552           (match_operand:V2SI 2 "nonimmediate_operand" " x,x,x,m,m")))]
7553   "TARGET_SSE"
7554   "@
7555    punpcklqdq\t{%2, %0|%0, %2}
7556    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7557    movlhps\t{%2, %0|%0, %2}
7558    movhps\t{%2, %0|%0, %q2}
7559    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
7560   [(set_attr "isa" "sse2_noavx,avx,noavx,noavx,avx")
7561    (set_attr "type" "sselog,sselog,ssemov,ssemov,ssemov")
7562    (set_attr "prefix" "orig,vex,orig,orig,vex")
7563    (set_attr "mode" "TI,TI,V4SF,V2SF,V2SF")])
7564
7565 ;; movd instead of movq is required to handle broken assemblers.
7566 (define_insn "vec_concatv2di"
7567   [(set (match_operand:V2DI 0 "register_operand"
7568           "=x,x ,Yi,x ,!x,x,x,x,x,x")
7569         (vec_concat:V2DI
7570           (match_operand:DI 1 "nonimmediate_operand"
7571           " 0,x ,r ,xm,*y,0,x,0,0,x")
7572           (match_operand:DI 2 "vector_move_operand"
7573           "rm,rm,C ,C ,C ,x,x,x,m,m")))]
7574   "TARGET_SSE"
7575   "@
7576    pinsrq\t{$1, %2, %0|%0, %2, 1}
7577    vpinsrq\t{$1, %2, %1, %0|%0, %1, %2, 1}
7578    %vmovd\t{%1, %0|%0, %1}
7579    %vmovq\t{%1, %0|%0, %1}
7580    movq2dq\t{%1, %0|%0, %1}
7581    punpcklqdq\t{%2, %0|%0, %2}
7582    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
7583    movlhps\t{%2, %0|%0, %2}
7584    movhps\t{%2, %0|%0, %2}
7585    vmovhps\t{%2, %1, %0|%0, %1, %2}"
7586   [(set_attr "isa" "x64_sse4_noavx,x64_avx,x64,sse2,sse2,sse2_noavx,avx,noavx,noavx,avx")
7587    (set (attr "type")
7588      (if_then_else
7589        (eq_attr "alternative" "0,1,5,6")
7590        (const_string "sselog")
7591        (const_string "ssemov")))
7592    (set_attr "prefix_rex" "1,1,1,*,*,*,*,*,*,*")
7593    (set_attr "prefix_extra" "1,1,*,*,*,*,*,*,*,*")
7594    (set_attr "length_immediate" "1,1,*,*,*,*,*,*,*,*")
7595    (set_attr "prefix" "orig,vex,maybe_vex,maybe_vex,orig,orig,vex,orig,orig,vex")
7596    (set_attr "mode" "TI,TI,TI,TI,TI,TI,TI,V4SF,V2SF,V2SF")])
7597
7598 (define_expand "vec_unpacks_lo_<mode>"
7599   [(match_operand:<sseunpackmode> 0 "register_operand")
7600    (match_operand:VI124_AVX2 1 "register_operand")]
7601   "TARGET_SSE2"
7602   "ix86_expand_sse_unpack (operands[0], operands[1], false, false); DONE;")
7603
7604 (define_expand "vec_unpacks_hi_<mode>"
7605   [(match_operand:<sseunpackmode> 0 "register_operand")
7606    (match_operand:VI124_AVX2 1 "register_operand")]
7607   "TARGET_SSE2"
7608   "ix86_expand_sse_unpack (operands[0], operands[1], false, true); DONE;")
7609
7610 (define_expand "vec_unpacku_lo_<mode>"
7611   [(match_operand:<sseunpackmode> 0 "register_operand")
7612    (match_operand:VI124_AVX2 1 "register_operand")]
7613   "TARGET_SSE2"
7614   "ix86_expand_sse_unpack (operands[0], operands[1], true, false); DONE;")
7615
7616 (define_expand "vec_unpacku_hi_<mode>"
7617   [(match_operand:<sseunpackmode> 0 "register_operand")
7618    (match_operand:VI124_AVX2 1 "register_operand")]
7619   "TARGET_SSE2"
7620   "ix86_expand_sse_unpack (operands[0], operands[1], true, true); DONE;")
7621
7622 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7623 ;;
7624 ;; Miscellaneous
7625 ;;
7626 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7627
7628 (define_expand "<sse2_avx2>_uavg<mode>3"
7629   [(set (match_operand:VI12_AVX2 0 "register_operand")
7630         (truncate:VI12_AVX2
7631           (lshiftrt:<ssedoublemode>
7632             (plus:<ssedoublemode>
7633               (plus:<ssedoublemode>
7634                 (zero_extend:<ssedoublemode>
7635                   (match_operand:VI12_AVX2 1 "nonimmediate_operand"))
7636                 (zero_extend:<ssedoublemode>
7637                   (match_operand:VI12_AVX2 2 "nonimmediate_operand")))
7638               (match_dup 3))
7639             (const_int 1))))]
7640   "TARGET_SSE2"
7641 {
7642   operands[3] = CONST1_RTX(<MODE>mode);
7643   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
7644 })
7645
7646 (define_insn "*<sse2_avx2>_uavg<mode>3"
7647   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,x")
7648         (truncate:VI12_AVX2
7649           (lshiftrt:<ssedoublemode>
7650             (plus:<ssedoublemode>
7651               (plus:<ssedoublemode>
7652                 (zero_extend:<ssedoublemode>
7653                   (match_operand:VI12_AVX2 1 "nonimmediate_operand" "%0,x"))
7654                 (zero_extend:<ssedoublemode>
7655                   (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,xm")))
7656               (match_operand:VI12_AVX2 3 "const1_operand"))
7657             (const_int 1))))]
7658   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
7659   "@
7660    pavg<ssemodesuffix>\t{%2, %0|%0, %2}
7661    vpavg<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
7662   [(set_attr "isa" "noavx,avx")
7663    (set_attr "type" "sseiadd")
7664    (set_attr "prefix_data16" "1,*")
7665    (set_attr "prefix" "orig,vex")
7666    (set_attr "mode" "<sseinsnmode>")])
7667
7668 ;; The correct representation for this is absolutely enormous, and
7669 ;; surely not generally useful.
7670 (define_insn "<sse2_avx2>_psadbw"
7671   [(set (match_operand:VI8_AVX2 0 "register_operand" "=x,x")
7672         (unspec:VI8_AVX2
7673           [(match_operand:<ssebytemode> 1 "register_operand" "0,x")
7674            (match_operand:<ssebytemode> 2 "nonimmediate_operand" "xm,xm")]
7675           UNSPEC_PSADBW))]
7676   "TARGET_SSE2"
7677   "@
7678    psadbw\t{%2, %0|%0, %2}
7679    vpsadbw\t{%2, %1, %0|%0, %1, %2}"
7680   [(set_attr "isa" "noavx,avx")
7681    (set_attr "type" "sseiadd")
7682    (set_attr "atom_unit" "simul")
7683    (set_attr "prefix_data16" "1,*")
7684    (set_attr "prefix" "orig,vex")
7685    (set_attr "mode" "<sseinsnmode>")])
7686
7687 (define_insn "<sse>_movmsk<ssemodesuffix><avxsizesuffix>"
7688   [(set (match_operand:SI 0 "register_operand" "=r")
7689         (unspec:SI
7690           [(match_operand:VF 1 "register_operand" "x")]
7691           UNSPEC_MOVMSK))]
7692   "TARGET_SSE"
7693   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
7694   [(set_attr "type" "ssemov")
7695    (set_attr "prefix" "maybe_vex")
7696    (set_attr "mode" "<MODE>")])
7697
7698 (define_insn "avx2_pmovmskb"
7699   [(set (match_operand:SI 0 "register_operand" "=r")
7700         (unspec:SI [(match_operand:V32QI 1 "register_operand" "x")]
7701                    UNSPEC_MOVMSK))]
7702   "TARGET_AVX2"
7703   "vpmovmskb\t{%1, %0|%0, %1}"
7704   [(set_attr "type" "ssemov")
7705    (set_attr "prefix" "vex")
7706    (set_attr "mode" "DI")])
7707
7708 (define_insn "sse2_pmovmskb"
7709   [(set (match_operand:SI 0 "register_operand" "=r")
7710         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
7711                    UNSPEC_MOVMSK))]
7712   "TARGET_SSE2"
7713   "%vpmovmskb\t{%1, %0|%0, %1}"
7714   [(set_attr "type" "ssemov")
7715    (set_attr "prefix_data16" "1")
7716    (set_attr "prefix" "maybe_vex")
7717    (set_attr "mode" "SI")])
7718
7719 (define_expand "sse2_maskmovdqu"
7720   [(set (match_operand:V16QI 0 "memory_operand")
7721         (unspec:V16QI [(match_operand:V16QI 1 "register_operand")
7722                        (match_operand:V16QI 2 "register_operand")
7723                        (match_dup 0)]
7724                       UNSPEC_MASKMOV))]
7725   "TARGET_SSE2")
7726
7727 (define_insn "*sse2_maskmovdqu"
7728   [(set (mem:V16QI (match_operand:P 0 "register_operand" "D"))
7729         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
7730                        (match_operand:V16QI 2 "register_operand" "x")
7731                        (mem:V16QI (match_dup 0))]
7732                       UNSPEC_MASKMOV))]
7733   "TARGET_SSE2"
7734   "%vmaskmovdqu\t{%2, %1|%1, %2}"
7735   [(set_attr "type" "ssemov")
7736    (set_attr "prefix_data16" "1")
7737    ;; The implicit %rdi operand confuses default length_vex computation.
7738    (set (attr "length_vex")
7739      (symbol_ref ("3 + REX_SSE_REGNO_P (REGNO (operands[2]))")))
7740    (set_attr "prefix" "maybe_vex")
7741    (set_attr "mode" "TI")])
7742
7743 (define_insn "sse_ldmxcsr"
7744   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
7745                     UNSPECV_LDMXCSR)]
7746   "TARGET_SSE"
7747   "%vldmxcsr\t%0"
7748   [(set_attr "type" "sse")
7749    (set_attr "atom_sse_attr" "mxcsr")
7750    (set_attr "prefix" "maybe_vex")
7751    (set_attr "memory" "load")])
7752
7753 (define_insn "sse_stmxcsr"
7754   [(set (match_operand:SI 0 "memory_operand" "=m")
7755         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
7756   "TARGET_SSE"
7757   "%vstmxcsr\t%0"
7758   [(set_attr "type" "sse")
7759    (set_attr "atom_sse_attr" "mxcsr")
7760    (set_attr "prefix" "maybe_vex")
7761    (set_attr "memory" "store")])
7762
7763 (define_insn "sse2_clflush"
7764   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
7765                     UNSPECV_CLFLUSH)]
7766   "TARGET_SSE2"
7767   "clflush\t%a0"
7768   [(set_attr "type" "sse")
7769    (set_attr "atom_sse_attr" "fence")
7770    (set_attr "memory" "unknown")])
7771
7772
7773 (define_insn "sse3_mwait"
7774   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
7775                      (match_operand:SI 1 "register_operand" "c")]
7776                     UNSPECV_MWAIT)]
7777   "TARGET_SSE3"
7778 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
7779 ;; Since 32bit register operands are implicitly zero extended to 64bit,
7780 ;; we only need to set up 32bit registers.
7781   "mwait"
7782   [(set_attr "length" "3")])
7783
7784 (define_insn "sse3_monitor"
7785   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
7786                      (match_operand:SI 1 "register_operand" "c")
7787                      (match_operand:SI 2 "register_operand" "d")]
7788                     UNSPECV_MONITOR)]
7789   "TARGET_SSE3 && !TARGET_64BIT"
7790   "monitor\t%0, %1, %2"
7791   [(set_attr "length" "3")])
7792
7793 (define_insn "sse3_monitor64_<mode>"
7794   [(unspec_volatile [(match_operand:P 0 "register_operand" "a")
7795                      (match_operand:SI 1 "register_operand" "c")
7796                      (match_operand:SI 2 "register_operand" "d")]
7797                     UNSPECV_MONITOR)]
7798   "TARGET_SSE3 && TARGET_64BIT"
7799 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
7800 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
7801 ;; zero extended to 64bit, we only need to set up 32bit registers.
7802   "monitor"
7803   [(set_attr "length" "3")])
7804
7805 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7806 ;;
7807 ;; SSSE3 instructions
7808 ;;
7809 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7810
7811 (define_code_iterator ssse3_plusminus [plus ss_plus minus ss_minus])
7812
7813 (define_insn "avx2_ph<plusminus_mnemonic>wv16hi3"
7814   [(set (match_operand:V16HI 0 "register_operand" "=x")
7815         (vec_concat:V16HI
7816           (vec_concat:V8HI
7817             (vec_concat:V4HI
7818               (vec_concat:V2HI
7819                 (ssse3_plusminus:HI
7820                   (vec_select:HI
7821                     (match_operand:V16HI 1 "register_operand" "x")
7822                     (parallel [(const_int 0)]))
7823                   (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7824                 (ssse3_plusminus:HI
7825                   (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7826                   (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7827               (vec_concat:V2HI
7828                 (ssse3_plusminus:HI
7829                   (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
7830                   (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
7831                 (ssse3_plusminus:HI
7832                   (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
7833                   (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
7834             (vec_concat:V4HI
7835               (vec_concat:V2HI
7836                 (ssse3_plusminus:HI
7837                   (vec_select:HI (match_dup 1) (parallel [(const_int 8)]))
7838                   (vec_select:HI (match_dup 1) (parallel [(const_int 9)])))
7839                 (ssse3_plusminus:HI
7840                   (vec_select:HI (match_dup 1) (parallel [(const_int 10)]))
7841                   (vec_select:HI (match_dup 1) (parallel [(const_int 11)]))))
7842               (vec_concat:V2HI
7843                 (ssse3_plusminus:HI
7844                   (vec_select:HI (match_dup 1) (parallel [(const_int 12)]))
7845                   (vec_select:HI (match_dup 1) (parallel [(const_int 13)])))
7846                 (ssse3_plusminus:HI
7847                   (vec_select:HI (match_dup 1) (parallel [(const_int 14)]))
7848                   (vec_select:HI (match_dup 1) (parallel [(const_int 15)]))))))
7849           (vec_concat:V8HI
7850             (vec_concat:V4HI
7851               (vec_concat:V2HI
7852                 (ssse3_plusminus:HI
7853                   (vec_select:HI
7854                     (match_operand:V16HI 2 "nonimmediate_operand" "xm")
7855                     (parallel [(const_int 0)]))
7856                   (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7857                 (ssse3_plusminus:HI
7858                   (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7859                   (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
7860               (vec_concat:V2HI
7861                 (ssse3_plusminus:HI
7862                   (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
7863                   (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
7864                 (ssse3_plusminus:HI
7865                   (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
7866                   (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))
7867             (vec_concat:V4HI
7868               (vec_concat:V2HI
7869                 (ssse3_plusminus:HI
7870                   (vec_select:HI (match_dup 2) (parallel [(const_int 8)]))
7871                   (vec_select:HI (match_dup 2) (parallel [(const_int 9)])))
7872                 (ssse3_plusminus:HI
7873                   (vec_select:HI (match_dup 2) (parallel [(const_int 10)]))
7874                   (vec_select:HI (match_dup 2) (parallel [(const_int 11)]))))
7875               (vec_concat:V2HI
7876                 (ssse3_plusminus:HI
7877                   (vec_select:HI (match_dup 2) (parallel [(const_int 12)]))
7878                   (vec_select:HI (match_dup 2) (parallel [(const_int 13)])))
7879                 (ssse3_plusminus:HI
7880                   (vec_select:HI (match_dup 2) (parallel [(const_int 14)]))
7881                   (vec_select:HI (match_dup 2) (parallel [(const_int 15)]))))))))]
7882   "TARGET_AVX2"
7883   "vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
7884   [(set_attr "type" "sseiadd")
7885    (set_attr "prefix_extra" "1")
7886    (set_attr "prefix" "vex")
7887    (set_attr "mode" "OI")])
7888
7889 (define_insn "ssse3_ph<plusminus_mnemonic>wv8hi3"
7890   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
7891         (vec_concat:V8HI
7892           (vec_concat:V4HI
7893             (vec_concat:V2HI
7894               (ssse3_plusminus:HI
7895                 (vec_select:HI
7896                   (match_operand:V8HI 1 "register_operand" "0,x")
7897                   (parallel [(const_int 0)]))
7898                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7899               (ssse3_plusminus:HI
7900                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7901                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7902             (vec_concat:V2HI
7903               (ssse3_plusminus:HI
7904                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
7905                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
7906               (ssse3_plusminus:HI
7907                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
7908                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
7909           (vec_concat:V4HI
7910             (vec_concat:V2HI
7911               (ssse3_plusminus:HI
7912                 (vec_select:HI
7913                   (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
7914                   (parallel [(const_int 0)]))
7915                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7916               (ssse3_plusminus:HI
7917                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7918                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
7919             (vec_concat:V2HI
7920               (ssse3_plusminus:HI
7921                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
7922                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
7923               (ssse3_plusminus:HI
7924                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
7925                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
7926   "TARGET_SSSE3"
7927   "@
7928    ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}
7929    vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
7930   [(set_attr "isa" "noavx,avx")
7931    (set_attr "type" "sseiadd")
7932    (set_attr "atom_unit" "complex")
7933    (set_attr "prefix_data16" "1,*")
7934    (set_attr "prefix_extra" "1")
7935    (set_attr "prefix" "orig,vex")
7936    (set_attr "mode" "TI")])
7937
7938 (define_insn "ssse3_ph<plusminus_mnemonic>wv4hi3"
7939   [(set (match_operand:V4HI 0 "register_operand" "=y")
7940         (vec_concat:V4HI
7941           (vec_concat:V2HI
7942             (ssse3_plusminus:HI
7943               (vec_select:HI
7944                 (match_operand:V4HI 1 "register_operand" "0")
7945                 (parallel [(const_int 0)]))
7946               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
7947             (ssse3_plusminus:HI
7948               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
7949               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
7950           (vec_concat:V2HI
7951             (ssse3_plusminus:HI
7952               (vec_select:HI
7953                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
7954                 (parallel [(const_int 0)]))
7955               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
7956             (ssse3_plusminus:HI
7957               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
7958               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
7959   "TARGET_SSSE3"
7960   "ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}"
7961   [(set_attr "type" "sseiadd")
7962    (set_attr "atom_unit" "complex")
7963    (set_attr "prefix_extra" "1")
7964    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
7965    (set_attr "mode" "DI")])
7966
7967 (define_insn "avx2_ph<plusminus_mnemonic>dv8si3"
7968   [(set (match_operand:V8SI 0 "register_operand" "=x")
7969         (vec_concat:V8SI
7970           (vec_concat:V4SI
7971             (vec_concat:V2SI
7972               (plusminus:SI
7973                 (vec_select:SI
7974                   (match_operand:V8SI 1 "register_operand" "x")
7975                   (parallel [(const_int 0)]))
7976                 (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
7977               (plusminus:SI
7978                 (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
7979                 (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
7980             (vec_concat:V2SI
7981               (plusminus:SI
7982                 (vec_select:SI (match_dup 1) (parallel [(const_int 4)]))
7983                 (vec_select:SI (match_dup 1) (parallel [(const_int 5)])))
7984               (plusminus:SI
7985                 (vec_select:SI (match_dup 1) (parallel [(const_int 6)]))
7986                 (vec_select:SI (match_dup 1) (parallel [(const_int 7)])))))
7987           (vec_concat:V4SI
7988             (vec_concat:V2SI
7989               (plusminus:SI
7990                 (vec_select:SI
7991                   (match_operand:V8SI 2 "nonimmediate_operand" "xm")
7992                   (parallel [(const_int 0)]))
7993                 (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
7994               (plusminus:SI
7995                 (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
7996                 (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))
7997             (vec_concat:V2SI
7998               (plusminus:SI
7999                 (vec_select:SI (match_dup 2) (parallel [(const_int 4)]))
8000                 (vec_select:SI (match_dup 2) (parallel [(const_int 5)])))
8001               (plusminus:SI
8002                 (vec_select:SI (match_dup 2) (parallel [(const_int 6)]))
8003                 (vec_select:SI (match_dup 2) (parallel [(const_int 7)])))))))]
8004   "TARGET_AVX2"
8005   "vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
8006   [(set_attr "type" "sseiadd")
8007    (set_attr "prefix_extra" "1")
8008    (set_attr "prefix" "vex")
8009    (set_attr "mode" "OI")])
8010
8011 (define_insn "ssse3_ph<plusminus_mnemonic>dv4si3"
8012   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
8013         (vec_concat:V4SI
8014           (vec_concat:V2SI
8015             (plusminus:SI
8016               (vec_select:SI
8017                 (match_operand:V4SI 1 "register_operand" "0,x")
8018                 (parallel [(const_int 0)]))
8019               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8020             (plusminus:SI
8021               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
8022               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
8023           (vec_concat:V2SI
8024             (plusminus:SI
8025               (vec_select:SI
8026                 (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
8027                 (parallel [(const_int 0)]))
8028               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
8029             (plusminus:SI
8030               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
8031               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
8032   "TARGET_SSSE3"
8033   "@
8034    ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}
8035    vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
8036   [(set_attr "isa" "noavx,avx")
8037    (set_attr "type" "sseiadd")
8038    (set_attr "atom_unit" "complex")
8039    (set_attr "prefix_data16" "1,*")
8040    (set_attr "prefix_extra" "1")
8041    (set_attr "prefix" "orig,vex")
8042    (set_attr "mode" "TI")])
8043
8044 (define_insn "ssse3_ph<plusminus_mnemonic>dv2si3"
8045   [(set (match_operand:V2SI 0 "register_operand" "=y")
8046         (vec_concat:V2SI
8047           (plusminus:SI
8048             (vec_select:SI
8049               (match_operand:V2SI 1 "register_operand" "0")
8050               (parallel [(const_int 0)]))
8051             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
8052           (plusminus:SI
8053             (vec_select:SI
8054               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
8055               (parallel [(const_int 0)]))
8056             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
8057   "TARGET_SSSE3"
8058   "ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}"
8059   [(set_attr "type" "sseiadd")
8060    (set_attr "atom_unit" "complex")
8061    (set_attr "prefix_extra" "1")
8062    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8063    (set_attr "mode" "DI")])
8064
8065 (define_insn "avx2_pmaddubsw256"
8066   [(set (match_operand:V16HI 0 "register_operand" "=x")
8067         (ss_plus:V16HI
8068           (mult:V16HI
8069             (zero_extend:V16HI
8070               (vec_select:V16QI
8071                 (match_operand:V32QI 1 "register_operand" "x")
8072                 (parallel [(const_int 0) (const_int 2)
8073                            (const_int 4) (const_int 6)
8074                            (const_int 8) (const_int 10)
8075                            (const_int 12) (const_int 14)
8076                            (const_int 16) (const_int 18)
8077                            (const_int 20) (const_int 22)
8078                            (const_int 24) (const_int 26)
8079                            (const_int 28) (const_int 30)])))
8080             (sign_extend:V16HI
8081               (vec_select:V16QI
8082                 (match_operand:V32QI 2 "nonimmediate_operand" "xm")
8083                 (parallel [(const_int 0) (const_int 2)
8084                            (const_int 4) (const_int 6)
8085                            (const_int 8) (const_int 10)
8086                            (const_int 12) (const_int 14)
8087                            (const_int 16) (const_int 18)
8088                            (const_int 20) (const_int 22)
8089                            (const_int 24) (const_int 26)
8090                            (const_int 28) (const_int 30)]))))
8091           (mult:V16HI
8092             (zero_extend:V16HI
8093               (vec_select:V16QI (match_dup 1)
8094                 (parallel [(const_int 1) (const_int 3)
8095                            (const_int 5) (const_int 7)
8096                            (const_int 9) (const_int 11)
8097                            (const_int 13) (const_int 15)
8098                            (const_int 17) (const_int 19)
8099                            (const_int 21) (const_int 23)
8100                            (const_int 25) (const_int 27)
8101                            (const_int 29) (const_int 31)])))
8102             (sign_extend:V16HI
8103               (vec_select:V16QI (match_dup 2)
8104                 (parallel [(const_int 1) (const_int 3)
8105                            (const_int 5) (const_int 7)
8106                            (const_int 9) (const_int 11)
8107                            (const_int 13) (const_int 15)
8108                            (const_int 17) (const_int 19)
8109                            (const_int 21) (const_int 23)
8110                            (const_int 25) (const_int 27)
8111                            (const_int 29) (const_int 31)]))))))]
8112   "TARGET_AVX2"
8113   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8114   [(set_attr "type" "sseiadd")
8115    (set_attr "prefix_extra" "1")
8116    (set_attr "prefix" "vex")
8117    (set_attr "mode" "OI")])
8118
8119 (define_insn "ssse3_pmaddubsw128"
8120   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
8121         (ss_plus:V8HI
8122           (mult:V8HI
8123             (zero_extend:V8HI
8124               (vec_select:V8QI
8125                 (match_operand:V16QI 1 "register_operand" "0,x")
8126                 (parallel [(const_int 0) (const_int 2)
8127                            (const_int 4) (const_int 6)
8128                            (const_int 8) (const_int 10)
8129                            (const_int 12) (const_int 14)])))
8130             (sign_extend:V8HI
8131               (vec_select:V8QI
8132                 (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")
8133                 (parallel [(const_int 0) (const_int 2)
8134                            (const_int 4) (const_int 6)
8135                            (const_int 8) (const_int 10)
8136                            (const_int 12) (const_int 14)]))))
8137           (mult:V8HI
8138             (zero_extend:V8HI
8139               (vec_select:V8QI (match_dup 1)
8140                 (parallel [(const_int 1) (const_int 3)
8141                            (const_int 5) (const_int 7)
8142                            (const_int 9) (const_int 11)
8143                            (const_int 13) (const_int 15)])))
8144             (sign_extend:V8HI
8145               (vec_select:V8QI (match_dup 2)
8146                 (parallel [(const_int 1) (const_int 3)
8147                            (const_int 5) (const_int 7)
8148                            (const_int 9) (const_int 11)
8149                            (const_int 13) (const_int 15)]))))))]
8150   "TARGET_SSSE3"
8151   "@
8152    pmaddubsw\t{%2, %0|%0, %2}
8153    vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
8154   [(set_attr "isa" "noavx,avx")
8155    (set_attr "type" "sseiadd")
8156    (set_attr "atom_unit" "simul")
8157    (set_attr "prefix_data16" "1,*")
8158    (set_attr "prefix_extra" "1")
8159    (set_attr "prefix" "orig,vex")
8160    (set_attr "mode" "TI")])
8161
8162 (define_insn "ssse3_pmaddubsw"
8163   [(set (match_operand:V4HI 0 "register_operand" "=y")
8164         (ss_plus:V4HI
8165           (mult:V4HI
8166             (zero_extend:V4HI
8167               (vec_select:V4QI
8168                 (match_operand:V8QI 1 "register_operand" "0")
8169                 (parallel [(const_int 0) (const_int 2)
8170                            (const_int 4) (const_int 6)])))
8171             (sign_extend:V4HI
8172               (vec_select:V4QI
8173                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
8174                 (parallel [(const_int 0) (const_int 2)
8175                            (const_int 4) (const_int 6)]))))
8176           (mult:V4HI
8177             (zero_extend:V4HI
8178               (vec_select:V4QI (match_dup 1)
8179                 (parallel [(const_int 1) (const_int 3)
8180                            (const_int 5) (const_int 7)])))
8181             (sign_extend:V4HI
8182               (vec_select:V4QI (match_dup 2)
8183                 (parallel [(const_int 1) (const_int 3)
8184                            (const_int 5) (const_int 7)]))))))]
8185   "TARGET_SSSE3"
8186   "pmaddubsw\t{%2, %0|%0, %2}"
8187   [(set_attr "type" "sseiadd")
8188    (set_attr "atom_unit" "simul")
8189    (set_attr "prefix_extra" "1")
8190    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8191    (set_attr "mode" "DI")])
8192
8193 (define_mode_iterator PMULHRSW
8194   [V4HI V8HI (V16HI "TARGET_AVX2")])
8195
8196 (define_expand "<ssse3_avx2>_pmulhrsw<mode>3"
8197   [(set (match_operand:PMULHRSW 0 "register_operand")
8198         (truncate:PMULHRSW
8199           (lshiftrt:<ssedoublemode>
8200             (plus:<ssedoublemode>
8201               (lshiftrt:<ssedoublemode>
8202                 (mult:<ssedoublemode>
8203                   (sign_extend:<ssedoublemode>
8204                     (match_operand:PMULHRSW 1 "nonimmediate_operand"))
8205                   (sign_extend:<ssedoublemode>
8206                     (match_operand:PMULHRSW 2 "nonimmediate_operand")))
8207                 (const_int 14))
8208               (match_dup 3))
8209             (const_int 1))))]
8210   "TARGET_AVX2"
8211 {
8212   operands[3] = CONST1_RTX(<MODE>mode);
8213   ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
8214 })
8215
8216 (define_insn "*<ssse3_avx2>_pmulhrsw<mode>3"
8217   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
8218         (truncate:VI2_AVX2
8219           (lshiftrt:<ssedoublemode>
8220             (plus:<ssedoublemode>
8221               (lshiftrt:<ssedoublemode>
8222                 (mult:<ssedoublemode>
8223                   (sign_extend:<ssedoublemode>
8224                     (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
8225                   (sign_extend:<ssedoublemode>
8226                     (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
8227                 (const_int 14))
8228               (match_operand:VI2_AVX2 3 "const1_operand"))
8229             (const_int 1))))]
8230   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
8231   "@
8232    pmulhrsw\t{%2, %0|%0, %2}
8233    vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
8234   [(set_attr "isa" "noavx,avx")
8235    (set_attr "type" "sseimul")
8236    (set_attr "prefix_data16" "1,*")
8237    (set_attr "prefix_extra" "1")
8238    (set_attr "prefix" "orig,vex")
8239    (set_attr "mode" "<sseinsnmode>")])
8240
8241 (define_insn "*ssse3_pmulhrswv4hi3"
8242   [(set (match_operand:V4HI 0 "register_operand" "=y")
8243         (truncate:V4HI
8244           (lshiftrt:V4SI
8245             (plus:V4SI
8246               (lshiftrt:V4SI
8247                 (mult:V4SI
8248                   (sign_extend:V4SI
8249                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
8250                   (sign_extend:V4SI
8251                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
8252                 (const_int 14))
8253               (match_operand:V4HI 3 "const1_operand"))
8254             (const_int 1))))]
8255   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
8256   "pmulhrsw\t{%2, %0|%0, %2}"
8257   [(set_attr "type" "sseimul")
8258    (set_attr "prefix_extra" "1")
8259    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8260    (set_attr "mode" "DI")])
8261
8262 (define_insn "<ssse3_avx2>_pshufb<mode>3"
8263   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
8264         (unspec:VI1_AVX2
8265           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
8266            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")]
8267           UNSPEC_PSHUFB))]
8268   "TARGET_SSSE3"
8269   "@
8270    pshufb\t{%2, %0|%0, %2}
8271    vpshufb\t{%2, %1, %0|%0, %1, %2}"
8272   [(set_attr "isa" "noavx,avx")
8273    (set_attr "type" "sselog1")
8274    (set_attr "prefix_data16" "1,*")
8275    (set_attr "prefix_extra" "1")
8276    (set_attr "prefix" "orig,vex")
8277    (set_attr "btver2_decode" "vector,vector")
8278    (set_attr "mode" "<sseinsnmode>")])
8279
8280 (define_insn "ssse3_pshufbv8qi3"
8281   [(set (match_operand:V8QI 0 "register_operand" "=y")
8282         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
8283                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
8284                      UNSPEC_PSHUFB))]
8285   "TARGET_SSSE3"
8286   "pshufb\t{%2, %0|%0, %2}";
8287   [(set_attr "type" "sselog1")
8288    (set_attr "prefix_extra" "1")
8289    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8290    (set_attr "mode" "DI")])
8291
8292 (define_insn "<ssse3_avx2>_psign<mode>3"
8293   [(set (match_operand:VI124_AVX2 0 "register_operand" "=x,x")
8294         (unspec:VI124_AVX2
8295           [(match_operand:VI124_AVX2 1 "register_operand" "0,x")
8296            (match_operand:VI124_AVX2 2 "nonimmediate_operand" "xm,xm")]
8297           UNSPEC_PSIGN))]
8298   "TARGET_SSSE3"
8299   "@
8300    psign<ssemodesuffix>\t{%2, %0|%0, %2}
8301    vpsign<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8302   [(set_attr "isa" "noavx,avx")
8303    (set_attr "type" "sselog1")
8304    (set_attr "prefix_data16" "1,*")
8305    (set_attr "prefix_extra" "1")
8306    (set_attr "prefix" "orig,vex")
8307    (set_attr "mode" "<sseinsnmode>")])
8308
8309 (define_insn "ssse3_psign<mode>3"
8310   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
8311         (unspec:MMXMODEI
8312           [(match_operand:MMXMODEI 1 "register_operand" "0")
8313            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
8314           UNSPEC_PSIGN))]
8315   "TARGET_SSSE3"
8316   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
8317   [(set_attr "type" "sselog1")
8318    (set_attr "prefix_extra" "1")
8319    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8320    (set_attr "mode" "DI")])
8321
8322 (define_insn "<ssse3_avx2>_palignr<mode>"
8323   [(set (match_operand:SSESCALARMODE 0 "register_operand" "=x,x")
8324         (unspec:SSESCALARMODE
8325           [(match_operand:SSESCALARMODE 1 "register_operand" "0,x")
8326            (match_operand:SSESCALARMODE 2 "nonimmediate_operand" "xm,xm")
8327            (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n,n")]
8328           UNSPEC_PALIGNR))]
8329   "TARGET_SSSE3"
8330 {
8331   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8332
8333   switch (which_alternative)
8334     {
8335     case 0:
8336       return "palignr\t{%3, %2, %0|%0, %2, %3}";
8337     case 1:
8338       return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
8339     default:
8340       gcc_unreachable ();
8341     }
8342 }
8343   [(set_attr "isa" "noavx,avx")
8344    (set_attr "type" "sseishft")
8345    (set_attr "atom_unit" "sishuf")
8346    (set_attr "prefix_data16" "1,*")
8347    (set_attr "prefix_extra" "1")
8348    (set_attr "length_immediate" "1")
8349    (set_attr "prefix" "orig,vex")
8350    (set_attr "mode" "<sseinsnmode>")])
8351
8352 (define_insn "ssse3_palignrdi"
8353   [(set (match_operand:DI 0 "register_operand" "=y")
8354         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
8355                     (match_operand:DI 2 "nonimmediate_operand" "ym")
8356                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
8357                    UNSPEC_PALIGNR))]
8358   "TARGET_SSSE3"
8359 {
8360   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
8361   return "palignr\t{%3, %2, %0|%0, %2, %3}";
8362 }
8363   [(set_attr "type" "sseishft")
8364    (set_attr "atom_unit" "sishuf")
8365    (set_attr "prefix_extra" "1")
8366    (set_attr "length_immediate" "1")
8367    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8368    (set_attr "mode" "DI")])
8369
8370 (define_insn "abs<mode>2"
8371   [(set (match_operand:VI124_AVX2 0 "register_operand" "=x")
8372         (abs:VI124_AVX2
8373           (match_operand:VI124_AVX2 1 "nonimmediate_operand" "xm")))]
8374   "TARGET_SSSE3"
8375   "%vpabs<ssemodesuffix>\t{%1, %0|%0, %1}"
8376   [(set_attr "type" "sselog1")
8377    (set_attr "prefix_data16" "1")
8378    (set_attr "prefix_extra" "1")
8379    (set_attr "prefix" "maybe_vex")
8380    (set_attr "mode" "<sseinsnmode>")])
8381
8382 (define_insn "abs<mode>2"
8383   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
8384         (abs:MMXMODEI
8385           (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
8386   "TARGET_SSSE3"
8387   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
8388   [(set_attr "type" "sselog1")
8389    (set_attr "prefix_rep" "0")
8390    (set_attr "prefix_extra" "1")
8391    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
8392    (set_attr "mode" "DI")])
8393
8394 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8395 ;;
8396 ;; AMD SSE4A instructions
8397 ;;
8398 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8399
8400 (define_insn "sse4a_movnt<mode>"
8401   [(set (match_operand:MODEF 0 "memory_operand" "=m")
8402         (unspec:MODEF
8403           [(match_operand:MODEF 1 "register_operand" "x")]
8404           UNSPEC_MOVNT))]
8405   "TARGET_SSE4A"
8406   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
8407   [(set_attr "type" "ssemov")
8408    (set_attr "mode" "<MODE>")])
8409
8410 (define_insn "sse4a_vmmovnt<mode>"
8411   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
8412         (unspec:<ssescalarmode>
8413           [(vec_select:<ssescalarmode>
8414              (match_operand:VF_128 1 "register_operand" "x")
8415              (parallel [(const_int 0)]))]
8416           UNSPEC_MOVNT))]
8417   "TARGET_SSE4A"
8418   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
8419   [(set_attr "type" "ssemov")
8420    (set_attr "mode" "<ssescalarmode>")])
8421
8422 (define_insn "sse4a_extrqi"
8423   [(set (match_operand:V2DI 0 "register_operand" "=x")
8424         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8425                       (match_operand 2 "const_0_to_255_operand")
8426                       (match_operand 3 "const_0_to_255_operand")]
8427                      UNSPEC_EXTRQI))]
8428   "TARGET_SSE4A"
8429   "extrq\t{%3, %2, %0|%0, %2, %3}"
8430   [(set_attr "type" "sse")
8431    (set_attr "prefix_data16" "1")
8432    (set_attr "length_immediate" "2")
8433    (set_attr "mode" "TI")])
8434
8435 (define_insn "sse4a_extrq"
8436   [(set (match_operand:V2DI 0 "register_operand" "=x")
8437         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8438                       (match_operand:V16QI 2 "register_operand" "x")]
8439                      UNSPEC_EXTRQ))]
8440   "TARGET_SSE4A"
8441   "extrq\t{%2, %0|%0, %2}"
8442   [(set_attr "type" "sse")
8443    (set_attr "prefix_data16" "1")
8444    (set_attr "mode" "TI")])
8445
8446 (define_insn "sse4a_insertqi"
8447   [(set (match_operand:V2DI 0 "register_operand" "=x")
8448         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8449                       (match_operand:V2DI 2 "register_operand" "x")
8450                       (match_operand 3 "const_0_to_255_operand")
8451                       (match_operand 4 "const_0_to_255_operand")]
8452                      UNSPEC_INSERTQI))]
8453   "TARGET_SSE4A"
8454   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
8455   [(set_attr "type" "sseins")
8456    (set_attr "prefix_data16" "0")
8457    (set_attr "prefix_rep" "1")
8458    (set_attr "length_immediate" "2")
8459    (set_attr "mode" "TI")])
8460
8461 (define_insn "sse4a_insertq"
8462   [(set (match_operand:V2DI 0 "register_operand" "=x")
8463         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
8464                       (match_operand:V2DI 2 "register_operand" "x")]
8465                      UNSPEC_INSERTQ))]
8466   "TARGET_SSE4A"
8467   "insertq\t{%2, %0|%0, %2}"
8468   [(set_attr "type" "sseins")
8469    (set_attr "prefix_data16" "0")
8470    (set_attr "prefix_rep" "1")
8471    (set_attr "mode" "TI")])
8472
8473 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8474 ;;
8475 ;; Intel SSE4.1 instructions
8476 ;;
8477 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8478
8479 (define_insn "<sse4_1>_blend<ssemodesuffix><avxsizesuffix>"
8480   [(set (match_operand:VF 0 "register_operand" "=x,x")
8481         (vec_merge:VF
8482           (match_operand:VF 2 "nonimmediate_operand" "xm,xm")
8483           (match_operand:VF 1 "register_operand" "0,x")
8484           (match_operand:SI 3 "const_0_to_<blendbits>_operand")))]
8485   "TARGET_SSE4_1"
8486   "@
8487    blend<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
8488    vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8489   [(set_attr "isa" "noavx,avx")
8490    (set_attr "type" "ssemov")
8491    (set_attr "length_immediate" "1")
8492    (set_attr "prefix_data16" "1,*")
8493    (set_attr "prefix_extra" "1")
8494    (set_attr "prefix" "orig,vex")
8495    (set_attr "mode" "<MODE>")])
8496
8497 (define_insn "<sse4_1>_blendv<ssemodesuffix><avxsizesuffix>"
8498   [(set (match_operand:VF 0 "register_operand" "=x,x")
8499         (unspec:VF
8500           [(match_operand:VF 1 "register_operand" "0,x")
8501            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")
8502            (match_operand:VF 3 "register_operand" "Yz,x")]
8503           UNSPEC_BLENDV))]
8504   "TARGET_SSE4_1"
8505   "@
8506    blendv<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
8507    vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8508   [(set_attr "isa" "noavx,avx")
8509    (set_attr "type" "ssemov")
8510    (set_attr "length_immediate" "1")
8511    (set_attr "prefix_data16" "1,*")
8512    (set_attr "prefix_extra" "1")
8513    (set_attr "prefix" "orig,vex")
8514    (set_attr "btver2_decode" "vector,vector")
8515    (set_attr "mode" "<MODE>")])
8516
8517 (define_insn "<sse4_1>_dp<ssemodesuffix><avxsizesuffix>"
8518   [(set (match_operand:VF 0 "register_operand" "=x,x")
8519         (unspec:VF
8520           [(match_operand:VF 1 "nonimmediate_operand" "%0,x")
8521            (match_operand:VF 2 "nonimmediate_operand" "xm,xm")
8522            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
8523           UNSPEC_DP))]
8524   "TARGET_SSE4_1"
8525   "@
8526    dp<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
8527    vdp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8528   [(set_attr "isa" "noavx,avx")
8529    (set_attr "type" "ssemul")
8530    (set_attr "length_immediate" "1")
8531    (set_attr "prefix_data16" "1,*")
8532    (set_attr "prefix_extra" "1")
8533    (set_attr "prefix" "orig,vex")
8534    (set_attr "btver2_decode" "vector,vector")
8535    (set_attr "mode" "<MODE>")])
8536
8537 (define_insn "<sse4_1_avx2>_movntdqa"
8538   [(set (match_operand:VI8_AVX2 0 "register_operand" "=x")
8539         (unspec:VI8_AVX2 [(match_operand:VI8_AVX2 1 "memory_operand" "m")]
8540                      UNSPEC_MOVNTDQA))]
8541   "TARGET_SSE4_1"
8542   "%vmovntdqa\t{%1, %0|%0, %1}"
8543   [(set_attr "type" "ssemov")
8544    (set_attr "prefix_extra" "1")
8545    (set_attr "prefix" "maybe_vex")
8546    (set_attr "mode" "<sseinsnmode>")])
8547
8548 (define_insn "<sse4_1_avx2>_mpsadbw"
8549   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
8550         (unspec:VI1_AVX2
8551           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
8552            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
8553            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
8554           UNSPEC_MPSADBW))]
8555   "TARGET_SSE4_1"
8556   "@
8557    mpsadbw\t{%3, %2, %0|%0, %2, %3}
8558    vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8559   [(set_attr "isa" "noavx,avx")
8560    (set_attr "type" "sselog1")
8561    (set_attr "length_immediate" "1")
8562    (set_attr "prefix_extra" "1")
8563    (set_attr "prefix" "orig,vex")
8564    (set_attr "btver2_decode" "vector,vector")
8565    (set_attr "mode" "<sseinsnmode>")])
8566
8567 (define_insn "avx2_packusdw"
8568   [(set (match_operand:V16HI 0 "register_operand" "=x")
8569         (vec_concat:V16HI
8570           (us_truncate:V8HI
8571             (match_operand:V8SI 1 "register_operand" "x"))
8572           (us_truncate:V8HI
8573             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))))]
8574   "TARGET_AVX2"
8575   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
8576   [(set_attr "type" "sselog")
8577    (set_attr "prefix_extra" "1")
8578    (set_attr "prefix" "vex")
8579    (set_attr "mode" "OI")])
8580
8581 (define_insn "sse4_1_packusdw"
8582   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
8583         (vec_concat:V8HI
8584           (us_truncate:V4HI
8585             (match_operand:V4SI 1 "register_operand" "0,x"))
8586           (us_truncate:V4HI
8587             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))))]
8588   "TARGET_SSE4_1"
8589   "@
8590    packusdw\t{%2, %0|%0, %2}
8591    vpackusdw\t{%2, %1, %0|%0, %1, %2}"
8592   [(set_attr "isa" "noavx,avx")
8593    (set_attr "type" "sselog")
8594    (set_attr "prefix_extra" "1")
8595    (set_attr "prefix" "orig,vex")
8596    (set_attr "mode" "TI")])
8597
8598 (define_insn "<sse4_1_avx2>_pblendvb"
8599   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
8600         (unspec:VI1_AVX2
8601           [(match_operand:VI1_AVX2 1 "register_operand"  "0,x")
8602            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
8603            (match_operand:VI1_AVX2 3 "register_operand" "Yz,x")]
8604           UNSPEC_BLENDV))]
8605   "TARGET_SSE4_1"
8606   "@
8607    pblendvb\t{%3, %2, %0|%0, %2, %3}
8608    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8609   [(set_attr "isa" "noavx,avx")
8610    (set_attr "type" "ssemov")
8611    (set_attr "prefix_extra" "1")
8612    (set_attr "length_immediate" "*,1")
8613    (set_attr "prefix" "orig,vex")
8614    (set_attr "btver2_decode" "vector,vector")
8615    (set_attr "mode" "<sseinsnmode>")])
8616
8617 (define_insn "sse4_1_pblendw"
8618   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
8619         (vec_merge:V8HI
8620           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
8621           (match_operand:V8HI 1 "register_operand" "0,x")
8622           (match_operand:SI 3 "const_0_to_255_operand" "n,n")))]
8623   "TARGET_SSE4_1"
8624   "@
8625    pblendw\t{%3, %2, %0|%0, %2, %3}
8626    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8627   [(set_attr "isa" "noavx,avx")
8628    (set_attr "type" "ssemov")
8629    (set_attr "prefix_extra" "1")
8630    (set_attr "length_immediate" "1")
8631    (set_attr "prefix" "orig,vex")
8632    (set_attr "mode" "TI")])
8633
8634 ;; The builtin uses an 8-bit immediate.  Expand that.
8635 (define_expand "avx2_pblendw"
8636   [(set (match_operand:V16HI 0 "register_operand")
8637         (vec_merge:V16HI
8638           (match_operand:V16HI 2 "nonimmediate_operand")
8639           (match_operand:V16HI 1 "register_operand")
8640           (match_operand:SI 3 "const_0_to_255_operand")))]
8641   "TARGET_AVX2"
8642 {
8643   HOST_WIDE_INT val = INTVAL (operands[3]) & 0xff;
8644   operands[3] = GEN_INT (val << 8 | val);
8645 })
8646
8647 (define_insn "*avx2_pblendw"
8648   [(set (match_operand:V16HI 0 "register_operand" "=x")
8649         (vec_merge:V16HI
8650           (match_operand:V16HI 2 "nonimmediate_operand" "xm")
8651           (match_operand:V16HI 1 "register_operand" "x")
8652           (match_operand:SI 3 "avx2_pblendw_operand" "n")))]
8653   "TARGET_AVX2"
8654 {
8655   operands[3] = GEN_INT (INTVAL (operands[3]) & 0xff);
8656   return "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
8657 }
8658   [(set_attr "type" "ssemov")
8659    (set_attr "prefix_extra" "1")
8660    (set_attr "length_immediate" "1")
8661    (set_attr "prefix" "vex")
8662    (set_attr "mode" "OI")])
8663
8664 (define_insn "avx2_pblendd<mode>"
8665   [(set (match_operand:VI4_AVX2 0 "register_operand" "=x")
8666         (vec_merge:VI4_AVX2
8667           (match_operand:VI4_AVX2 2 "nonimmediate_operand" "xm")
8668           (match_operand:VI4_AVX2 1 "register_operand" "x")
8669           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
8670   "TARGET_AVX2"
8671   "vpblendd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8672   [(set_attr "type" "ssemov")
8673    (set_attr "prefix_extra" "1")
8674    (set_attr "length_immediate" "1")
8675    (set_attr "prefix" "vex")
8676    (set_attr "mode" "<sseinsnmode>")])
8677
8678 (define_insn "sse4_1_phminposuw"
8679   [(set (match_operand:V8HI 0 "register_operand" "=x")
8680         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
8681                      UNSPEC_PHMINPOSUW))]
8682   "TARGET_SSE4_1"
8683   "%vphminposuw\t{%1, %0|%0, %1}"
8684   [(set_attr "type" "sselog1")
8685    (set_attr "prefix_extra" "1")
8686    (set_attr "prefix" "maybe_vex")
8687    (set_attr "mode" "TI")])
8688
8689 (define_insn "avx2_<code>v16qiv16hi2"
8690   [(set (match_operand:V16HI 0 "register_operand" "=x")
8691         (any_extend:V16HI
8692           (match_operand:V16QI 1 "nonimmediate_operand" "xm")))]
8693   "TARGET_AVX2"
8694   "vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
8695   [(set_attr "type" "ssemov")
8696    (set_attr "prefix_extra" "1")
8697    (set_attr "prefix" "vex")
8698    (set_attr "mode" "OI")])
8699
8700 (define_insn "sse4_1_<code>v8qiv8hi2"
8701   [(set (match_operand:V8HI 0 "register_operand" "=x")
8702         (any_extend:V8HI
8703           (vec_select:V8QI
8704             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
8705             (parallel [(const_int 0) (const_int 1)
8706                        (const_int 2) (const_int 3)
8707                        (const_int 4) (const_int 5)
8708                        (const_int 6) (const_int 7)]))))]
8709   "TARGET_SSE4_1"
8710   "%vpmov<extsuffix>bw\t{%1, %0|%0, %q1}"
8711   [(set_attr "type" "ssemov")
8712    (set_attr "prefix_extra" "1")
8713    (set_attr "prefix" "maybe_vex")
8714    (set_attr "mode" "TI")])
8715
8716 (define_insn "avx2_<code>v8qiv8si2"
8717   [(set (match_operand:V8SI 0 "register_operand" "=x")
8718         (any_extend:V8SI
8719           (vec_select:V8QI
8720             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
8721             (parallel [(const_int 0) (const_int 1)
8722                        (const_int 2) (const_int 3)
8723                        (const_int 4) (const_int 5)
8724                        (const_int 6) (const_int 7)]))))]
8725   "TARGET_AVX2"
8726   "vpmov<extsuffix>bd\t{%1, %0|%0, %q1}"
8727   [(set_attr "type" "ssemov")
8728    (set_attr "prefix_extra" "1")
8729    (set_attr "prefix" "vex")
8730    (set_attr "mode" "OI")])
8731
8732 (define_insn "sse4_1_<code>v4qiv4si2"
8733   [(set (match_operand:V4SI 0 "register_operand" "=x")
8734         (any_extend:V4SI
8735           (vec_select:V4QI
8736             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
8737             (parallel [(const_int 0) (const_int 1)
8738                        (const_int 2) (const_int 3)]))))]
8739   "TARGET_SSE4_1"
8740   "%vpmov<extsuffix>bd\t{%1, %0|%0, %k1}"
8741   [(set_attr "type" "ssemov")
8742    (set_attr "prefix_extra" "1")
8743    (set_attr "prefix" "maybe_vex")
8744    (set_attr "mode" "TI")])
8745
8746 (define_insn "avx2_<code>v8hiv8si2"
8747   [(set (match_operand:V8SI 0 "register_operand" "=x")
8748         (any_extend:V8SI
8749             (match_operand:V8HI 1 "nonimmediate_operand" "xm")))]
8750   "TARGET_AVX2"
8751   "vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
8752   [(set_attr "type" "ssemov")
8753    (set_attr "prefix_extra" "1")
8754    (set_attr "prefix" "vex")
8755    (set_attr "mode" "OI")])
8756
8757 (define_insn "sse4_1_<code>v4hiv4si2"
8758   [(set (match_operand:V4SI 0 "register_operand" "=x")
8759         (any_extend:V4SI
8760           (vec_select:V4HI
8761             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
8762             (parallel [(const_int 0) (const_int 1)
8763                        (const_int 2) (const_int 3)]))))]
8764   "TARGET_SSE4_1"
8765   "%vpmov<extsuffix>wd\t{%1, %0|%0, %q1}"
8766   [(set_attr "type" "ssemov")
8767    (set_attr "prefix_extra" "1")
8768    (set_attr "prefix" "maybe_vex")
8769    (set_attr "mode" "TI")])
8770
8771 (define_insn "avx2_<code>v4qiv4di2"
8772   [(set (match_operand:V4DI 0 "register_operand" "=x")
8773         (any_extend:V4DI
8774           (vec_select:V4QI
8775             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
8776             (parallel [(const_int 0) (const_int 1)
8777                        (const_int 2) (const_int 3)]))))]
8778   "TARGET_AVX2"
8779   "vpmov<extsuffix>bq\t{%1, %0|%0, %k1}"
8780   [(set_attr "type" "ssemov")
8781    (set_attr "prefix_extra" "1")
8782    (set_attr "prefix" "vex")
8783    (set_attr "mode" "OI")])
8784
8785 (define_insn "sse4_1_<code>v2qiv2di2"
8786   [(set (match_operand:V2DI 0 "register_operand" "=x")
8787         (any_extend:V2DI
8788           (vec_select:V2QI
8789             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
8790             (parallel [(const_int 0) (const_int 1)]))))]
8791   "TARGET_SSE4_1"
8792   "%vpmov<extsuffix>bq\t{%1, %0|%0, %w1}"
8793   [(set_attr "type" "ssemov")
8794    (set_attr "prefix_extra" "1")
8795    (set_attr "prefix" "maybe_vex")
8796    (set_attr "mode" "TI")])
8797
8798 (define_insn "avx2_<code>v4hiv4di2"
8799   [(set (match_operand:V4DI 0 "register_operand" "=x")
8800         (any_extend:V4DI
8801           (vec_select:V4HI
8802             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
8803             (parallel [(const_int 0) (const_int 1)
8804                        (const_int 2) (const_int 3)]))))]
8805   "TARGET_AVX2"
8806   "vpmov<extsuffix>wq\t{%1, %0|%0, %q1}"
8807   [(set_attr "type" "ssemov")
8808    (set_attr "prefix_extra" "1")
8809    (set_attr "prefix" "vex")
8810    (set_attr "mode" "OI")])
8811
8812 (define_insn "sse4_1_<code>v2hiv2di2"
8813   [(set (match_operand:V2DI 0 "register_operand" "=x")
8814         (any_extend:V2DI
8815           (vec_select:V2HI
8816             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
8817             (parallel [(const_int 0) (const_int 1)]))))]
8818   "TARGET_SSE4_1"
8819   "%vpmov<extsuffix>wq\t{%1, %0|%0, %k1}"
8820   [(set_attr "type" "ssemov")
8821    (set_attr "prefix_extra" "1")
8822    (set_attr "prefix" "maybe_vex")
8823    (set_attr "mode" "TI")])
8824
8825 (define_insn "avx2_<code>v4siv4di2"
8826   [(set (match_operand:V4DI 0 "register_operand" "=x")
8827         (any_extend:V4DI
8828             (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
8829   "TARGET_AVX2"
8830   "vpmov<extsuffix>dq\t{%1, %0|%0, %1}"
8831   [(set_attr "type" "ssemov")
8832    (set_attr "prefix_extra" "1")
8833    (set_attr "mode" "OI")])
8834
8835 (define_insn "sse4_1_<code>v2siv2di2"
8836   [(set (match_operand:V2DI 0 "register_operand" "=x")
8837         (any_extend:V2DI
8838           (vec_select:V2SI
8839             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
8840             (parallel [(const_int 0) (const_int 1)]))))]
8841   "TARGET_SSE4_1"
8842   "%vpmov<extsuffix>dq\t{%1, %0|%0, %q1}"
8843   [(set_attr "type" "ssemov")
8844    (set_attr "prefix_extra" "1")
8845    (set_attr "prefix" "maybe_vex")
8846    (set_attr "mode" "TI")])
8847
8848 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
8849 ;; setting FLAGS_REG. But it is not a really compare instruction.
8850 (define_insn "avx_vtest<ssemodesuffix><avxsizesuffix>"
8851   [(set (reg:CC FLAGS_REG)
8852         (unspec:CC [(match_operand:VF 0 "register_operand" "x")
8853                     (match_operand:VF 1 "nonimmediate_operand" "xm")]
8854                    UNSPEC_VTESTP))]
8855   "TARGET_AVX"
8856   "vtest<ssemodesuffix>\t{%1, %0|%0, %1}"
8857   [(set_attr "type" "ssecomi")
8858    (set_attr "prefix_extra" "1")
8859    (set_attr "prefix" "vex")
8860    (set_attr "mode" "<MODE>")])
8861
8862 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
8863 ;; But it is not a really compare instruction.
8864 (define_insn "avx_ptest256"
8865   [(set (reg:CC FLAGS_REG)
8866         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
8867                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
8868                    UNSPEC_PTEST))]
8869   "TARGET_AVX"
8870   "vptest\t{%1, %0|%0, %1}"
8871   [(set_attr "type" "ssecomi")
8872    (set_attr "prefix_extra" "1")
8873    (set_attr "prefix" "vex")
8874    (set_attr "btver2_decode" "vector")
8875    (set_attr "mode" "OI")])
8876
8877 (define_insn "sse4_1_ptest"
8878   [(set (reg:CC FLAGS_REG)
8879         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
8880                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
8881                    UNSPEC_PTEST))]
8882   "TARGET_SSE4_1"
8883   "%vptest\t{%1, %0|%0, %1}"
8884   [(set_attr "type" "ssecomi")
8885    (set_attr "prefix_extra" "1")
8886    (set_attr "prefix" "maybe_vex")
8887    (set_attr "mode" "TI")])
8888
8889 (define_insn "<sse4_1>_round<ssemodesuffix><avxsizesuffix>"
8890   [(set (match_operand:VF 0 "register_operand" "=x")
8891         (unspec:VF
8892           [(match_operand:VF 1 "nonimmediate_operand" "xm")
8893            (match_operand:SI 2 "const_0_to_15_operand" "n")]
8894           UNSPEC_ROUND))]
8895   "TARGET_ROUND"
8896   "%vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8897   [(set_attr "type" "ssecvt")
8898    (set (attr "prefix_data16")
8899      (if_then_else
8900        (match_test "TARGET_AVX")
8901      (const_string "*")
8902      (const_string "1")))
8903    (set_attr "prefix_extra" "1")
8904    (set_attr "length_immediate" "1")
8905    (set_attr "prefix" "maybe_vex")
8906    (set_attr "mode" "<MODE>")])
8907
8908 (define_expand "<sse4_1>_round<ssemodesuffix>_sfix<avxsizesuffix>"
8909   [(match_operand:<sseintvecmode> 0 "register_operand")
8910    (match_operand:VF1 1 "nonimmediate_operand")
8911    (match_operand:SI 2 "const_0_to_15_operand")]
8912   "TARGET_ROUND"
8913 {
8914   rtx tmp = gen_reg_rtx (<MODE>mode);
8915
8916   emit_insn
8917     (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp, operands[1],
8918                                                        operands[2]));
8919   emit_insn
8920     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
8921   DONE;
8922 })
8923
8924 (define_expand "<sse4_1>_round<ssemodesuffix>_vec_pack_sfix<avxsizesuffix>"
8925   [(match_operand:<ssepackfltmode> 0 "register_operand")
8926    (match_operand:VF2 1 "nonimmediate_operand")
8927    (match_operand:VF2 2 "nonimmediate_operand")
8928    (match_operand:SI 3 "const_0_to_15_operand")]
8929   "TARGET_ROUND"
8930 {
8931   rtx tmp0, tmp1;
8932
8933   if (<MODE>mode == V2DFmode
8934       && TARGET_AVX && !TARGET_PREFER_AVX128)
8935     {
8936       rtx tmp2 = gen_reg_rtx (V4DFmode);
8937
8938       tmp0 = gen_reg_rtx (V4DFmode);
8939       tmp1 = force_reg (V2DFmode, operands[1]);
8940
8941       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
8942       emit_insn (gen_avx_roundpd256 (tmp2, tmp0, operands[3]));
8943       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
8944     }
8945   else
8946     {
8947       tmp0 = gen_reg_rtx (<MODE>mode);
8948       tmp1 = gen_reg_rtx (<MODE>mode);
8949
8950       emit_insn
8951        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp0, operands[1],
8952                                                           operands[3]));
8953       emit_insn
8954        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp1, operands[2],
8955                                                           operands[3]));
8956       emit_insn
8957        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
8958     }
8959   DONE;
8960 })
8961
8962 (define_insn "sse4_1_round<ssescalarmodesuffix>"
8963   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
8964         (vec_merge:VF_128
8965           (unspec:VF_128
8966             [(match_operand:VF_128 2 "register_operand" "x,x")
8967              (match_operand:SI 3 "const_0_to_15_operand" "n,n")]
8968             UNSPEC_ROUND)
8969           (match_operand:VF_128 1 "register_operand" "0,x")
8970           (const_int 1)))]
8971   "TARGET_ROUND"
8972   "@
8973    round<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
8974    vround<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
8975   [(set_attr "isa" "noavx,avx")
8976    (set_attr "type" "ssecvt")
8977    (set_attr "length_immediate" "1")
8978    (set_attr "prefix_data16" "1,*")
8979    (set_attr "prefix_extra" "1")
8980    (set_attr "prefix" "orig,vex")
8981    (set_attr "mode" "<MODE>")])
8982
8983 (define_expand "round<mode>2"
8984   [(set (match_dup 4)
8985         (plus:VF
8986           (match_operand:VF 1 "register_operand")
8987           (match_dup 3)))
8988    (set (match_operand:VF 0 "register_operand")
8989         (unspec:VF
8990           [(match_dup 4) (match_dup 5)]
8991           UNSPEC_ROUND))]
8992   "TARGET_ROUND && !flag_trapping_math"
8993 {
8994   enum machine_mode scalar_mode;
8995   const struct real_format *fmt;
8996   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
8997   rtx half, vec_half;
8998
8999   scalar_mode = GET_MODE_INNER (<MODE>mode);
9000
9001   /* load nextafter (0.5, 0.0) */
9002   fmt = REAL_MODE_FORMAT (scalar_mode);
9003   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, scalar_mode);
9004   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
9005   half = const_double_from_real_value (pred_half, scalar_mode);
9006
9007   vec_half = ix86_build_const_vector (<MODE>mode, true, half);
9008   vec_half = force_reg (<MODE>mode, vec_half);
9009
9010   operands[3] = gen_reg_rtx (<MODE>mode);
9011   emit_insn (gen_copysign<mode>3 (operands[3], vec_half, operands[1]));
9012
9013   operands[4] = gen_reg_rtx (<MODE>mode);
9014   operands[5] = GEN_INT (ROUND_TRUNC);
9015 })
9016
9017 (define_expand "round<mode>2_sfix"
9018   [(match_operand:<sseintvecmode> 0 "register_operand")
9019    (match_operand:VF1 1 "register_operand")]
9020   "TARGET_ROUND && !flag_trapping_math"
9021 {
9022   rtx tmp = gen_reg_rtx (<MODE>mode);
9023
9024   emit_insn (gen_round<mode>2 (tmp, operands[1]));
9025
9026   emit_insn
9027     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
9028   DONE;
9029 })
9030
9031 (define_expand "round<mode>2_vec_pack_sfix"
9032   [(match_operand:<ssepackfltmode> 0 "register_operand")
9033    (match_operand:VF2 1 "register_operand")
9034    (match_operand:VF2 2 "register_operand")]
9035   "TARGET_ROUND && !flag_trapping_math"
9036 {
9037   rtx tmp0, tmp1;
9038
9039   if (<MODE>mode == V2DFmode
9040       && TARGET_AVX && !TARGET_PREFER_AVX128)
9041     {
9042       rtx tmp2 = gen_reg_rtx (V4DFmode);
9043
9044       tmp0 = gen_reg_rtx (V4DFmode);
9045       tmp1 = force_reg (V2DFmode, operands[1]);
9046
9047       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
9048       emit_insn (gen_roundv4df2 (tmp2, tmp0));
9049       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
9050     }
9051   else
9052     {
9053       tmp0 = gen_reg_rtx (<MODE>mode);
9054       tmp1 = gen_reg_rtx (<MODE>mode);
9055
9056       emit_insn (gen_round<mode>2 (tmp0, operands[1]));
9057       emit_insn (gen_round<mode>2 (tmp1, operands[2]));
9058
9059       emit_insn
9060        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
9061     }
9062   DONE;
9063 })
9064
9065 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9066 ;;
9067 ;; Intel SSE4.2 string/text processing instructions
9068 ;;
9069 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9070
9071 (define_insn_and_split "sse4_2_pcmpestr"
9072   [(set (match_operand:SI 0 "register_operand" "=c,c")
9073         (unspec:SI
9074           [(match_operand:V16QI 2 "register_operand" "x,x")
9075            (match_operand:SI 3 "register_operand" "a,a")
9076            (match_operand:V16QI 4 "nonimmediate_operand" "x,m")
9077            (match_operand:SI 5 "register_operand" "d,d")
9078            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
9079           UNSPEC_PCMPESTR))
9080    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9081         (unspec:V16QI
9082           [(match_dup 2)
9083            (match_dup 3)
9084            (match_dup 4)
9085            (match_dup 5)
9086            (match_dup 6)]
9087           UNSPEC_PCMPESTR))
9088    (set (reg:CC FLAGS_REG)
9089         (unspec:CC
9090           [(match_dup 2)
9091            (match_dup 3)
9092            (match_dup 4)
9093            (match_dup 5)
9094            (match_dup 6)]
9095           UNSPEC_PCMPESTR))]
9096   "TARGET_SSE4_2
9097    && can_create_pseudo_p ()"
9098   "#"
9099   "&& 1"
9100   [(const_int 0)]
9101 {
9102   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9103   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9104   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9105
9106   if (ecx)
9107     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
9108                                      operands[3], operands[4],
9109                                      operands[5], operands[6]));
9110   if (xmm0)
9111     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
9112                                      operands[3], operands[4],
9113                                      operands[5], operands[6]));
9114   if (flags && !(ecx || xmm0))
9115     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
9116                                            operands[2], operands[3],
9117                                            operands[4], operands[5],
9118                                            operands[6]));
9119   if (!(flags || ecx || xmm0))
9120     emit_note (NOTE_INSN_DELETED);
9121
9122   DONE;
9123 }
9124   [(set_attr "type" "sselog")
9125    (set_attr "prefix_data16" "1")
9126    (set_attr "prefix_extra" "1")
9127    (set_attr "length_immediate" "1")
9128    (set_attr "memory" "none,load")
9129    (set_attr "mode" "TI")])
9130
9131 (define_insn_and_split "*sse4_2_pcmpestr_unaligned"
9132   [(set (match_operand:SI 0 "register_operand" "=c")
9133         (unspec:SI
9134           [(match_operand:V16QI 2 "register_operand" "x")
9135            (match_operand:SI 3 "register_operand" "a")
9136            (unspec:V16QI
9137              [(match_operand:V16QI 4 "memory_operand" "m")]
9138              UNSPEC_LOADU)
9139            (match_operand:SI 5 "register_operand" "d")
9140            (match_operand:SI 6 "const_0_to_255_operand" "n")]
9141           UNSPEC_PCMPESTR))
9142    (set (match_operand:V16QI 1 "register_operand" "=Yz")
9143         (unspec:V16QI
9144           [(match_dup 2)
9145            (match_dup 3)
9146            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
9147            (match_dup 5)
9148            (match_dup 6)]
9149           UNSPEC_PCMPESTR))
9150    (set (reg:CC FLAGS_REG)
9151         (unspec:CC
9152           [(match_dup 2)
9153            (match_dup 3)
9154            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
9155            (match_dup 5)
9156            (match_dup 6)]
9157           UNSPEC_PCMPESTR))]
9158   "TARGET_SSE4_2
9159    && can_create_pseudo_p ()"
9160   "#"
9161   "&& 1"
9162   [(const_int 0)]
9163 {
9164   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9165   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9166   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9167
9168   if (ecx)
9169     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
9170                                      operands[3], operands[4],
9171                                      operands[5], operands[6]));
9172   if (xmm0)
9173     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
9174                                      operands[3], operands[4],
9175                                      operands[5], operands[6]));
9176   if (flags && !(ecx || xmm0))
9177     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
9178                                            operands[2], operands[3],
9179                                            operands[4], operands[5],
9180                                            operands[6]));
9181   if (!(flags || ecx || xmm0))
9182     emit_note (NOTE_INSN_DELETED);
9183
9184   DONE;
9185 }
9186   [(set_attr "type" "sselog")
9187    (set_attr "prefix_data16" "1")
9188    (set_attr "prefix_extra" "1")
9189    (set_attr "length_immediate" "1")
9190    (set_attr "memory" "load")
9191    (set_attr "mode" "TI")])
9192
9193 (define_insn "sse4_2_pcmpestri"
9194   [(set (match_operand:SI 0 "register_operand" "=c,c")
9195         (unspec:SI
9196           [(match_operand:V16QI 1 "register_operand" "x,x")
9197            (match_operand:SI 2 "register_operand" "a,a")
9198            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9199            (match_operand:SI 4 "register_operand" "d,d")
9200            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9201           UNSPEC_PCMPESTR))
9202    (set (reg:CC FLAGS_REG)
9203         (unspec:CC
9204           [(match_dup 1)
9205            (match_dup 2)
9206            (match_dup 3)
9207            (match_dup 4)
9208            (match_dup 5)]
9209           UNSPEC_PCMPESTR))]
9210   "TARGET_SSE4_2"
9211   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
9212   [(set_attr "type" "sselog")
9213    (set_attr "prefix_data16" "1")
9214    (set_attr "prefix_extra" "1")
9215    (set_attr "prefix" "maybe_vex")
9216    (set_attr "length_immediate" "1")
9217    (set_attr "btver2_decode" "vector")
9218    (set_attr "memory" "none,load")
9219    (set_attr "mode" "TI")])
9220
9221 (define_insn "sse4_2_pcmpestrm"
9222   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9223         (unspec:V16QI
9224           [(match_operand:V16QI 1 "register_operand" "x,x")
9225            (match_operand:SI 2 "register_operand" "a,a")
9226            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9227            (match_operand:SI 4 "register_operand" "d,d")
9228            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
9229           UNSPEC_PCMPESTR))
9230    (set (reg:CC FLAGS_REG)
9231         (unspec:CC
9232           [(match_dup 1)
9233            (match_dup 2)
9234            (match_dup 3)
9235            (match_dup 4)
9236            (match_dup 5)]
9237           UNSPEC_PCMPESTR))]
9238   "TARGET_SSE4_2"
9239   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
9240   [(set_attr "type" "sselog")
9241    (set_attr "prefix_data16" "1")
9242    (set_attr "prefix_extra" "1")
9243    (set_attr "length_immediate" "1")
9244    (set_attr "prefix" "maybe_vex")
9245    (set_attr "btver2_decode" "vector")
9246    (set_attr "memory" "none,load")
9247    (set_attr "mode" "TI")])
9248
9249 (define_insn "sse4_2_pcmpestr_cconly"
9250   [(set (reg:CC FLAGS_REG)
9251         (unspec:CC
9252           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9253            (match_operand:SI 3 "register_operand" "a,a,a,a")
9254            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
9255            (match_operand:SI 5 "register_operand" "d,d,d,d")
9256            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
9257           UNSPEC_PCMPESTR))
9258    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9259    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9260   "TARGET_SSE4_2"
9261   "@
9262    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9263    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
9264    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
9265    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
9266   [(set_attr "type" "sselog")
9267    (set_attr "prefix_data16" "1")
9268    (set_attr "prefix_extra" "1")
9269    (set_attr "length_immediate" "1")
9270    (set_attr "memory" "none,load,none,load")
9271    (set_attr "btver2_decode" "vector,vector,vector,vector")
9272    (set_attr "prefix" "maybe_vex")
9273    (set_attr "mode" "TI")])
9274
9275 (define_insn_and_split "sse4_2_pcmpistr"
9276   [(set (match_operand:SI 0 "register_operand" "=c,c")
9277         (unspec:SI
9278           [(match_operand:V16QI 2 "register_operand" "x,x")
9279            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
9280            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
9281           UNSPEC_PCMPISTR))
9282    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
9283         (unspec:V16QI
9284           [(match_dup 2)
9285            (match_dup 3)
9286            (match_dup 4)]
9287           UNSPEC_PCMPISTR))
9288    (set (reg:CC FLAGS_REG)
9289         (unspec:CC
9290           [(match_dup 2)
9291            (match_dup 3)
9292            (match_dup 4)]
9293           UNSPEC_PCMPISTR))]
9294   "TARGET_SSE4_2
9295    && can_create_pseudo_p ()"
9296   "#"
9297   "&& 1"
9298   [(const_int 0)]
9299 {
9300   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9301   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9302   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9303
9304   if (ecx)
9305     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
9306                                      operands[3], operands[4]));
9307   if (xmm0)
9308     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
9309                                      operands[3], operands[4]));
9310   if (flags && !(ecx || xmm0))
9311     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
9312                                            operands[2], operands[3],
9313                                            operands[4]));
9314   if (!(flags || ecx || xmm0))
9315     emit_note (NOTE_INSN_DELETED);
9316
9317   DONE;
9318 }
9319   [(set_attr "type" "sselog")
9320    (set_attr "prefix_data16" "1")
9321    (set_attr "prefix_extra" "1")
9322    (set_attr "length_immediate" "1")
9323    (set_attr "memory" "none,load")
9324    (set_attr "mode" "TI")])
9325
9326 (define_insn_and_split "*sse4_2_pcmpistr_unaligned"
9327   [(set (match_operand:SI 0 "register_operand" "=c")
9328         (unspec:SI
9329           [(match_operand:V16QI 2 "register_operand" "x")
9330            (unspec:V16QI
9331              [(match_operand:V16QI 3 "memory_operand" "m")]
9332              UNSPEC_LOADU)
9333            (match_operand:SI 4 "const_0_to_255_operand" "n")]
9334           UNSPEC_PCMPISTR))
9335    (set (match_operand:V16QI 1 "register_operand" "=Yz")
9336         (unspec:V16QI
9337           [(match_dup 2)
9338            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
9339            (match_dup 4)]
9340           UNSPEC_PCMPISTR))
9341    (set (reg:CC FLAGS_REG)
9342         (unspec:CC
9343           [(match_dup 2)
9344            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
9345            (match_dup 4)]
9346           UNSPEC_PCMPISTR))]
9347   "TARGET_SSE4_2
9348    && can_create_pseudo_p ()"
9349   "#"
9350   "&& 1"
9351   [(const_int 0)]
9352 {
9353   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
9354   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
9355   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
9356
9357   if (ecx)
9358     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
9359                                      operands[3], operands[4]));
9360   if (xmm0)
9361     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
9362                                      operands[3], operands[4]));
9363   if (flags && !(ecx || xmm0))
9364     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
9365                                            operands[2], operands[3],
9366                                            operands[4]));
9367   if (!(flags || ecx || xmm0))
9368     emit_note (NOTE_INSN_DELETED);
9369
9370   DONE;
9371 }
9372   [(set_attr "type" "sselog")
9373    (set_attr "prefix_data16" "1")
9374    (set_attr "prefix_extra" "1")
9375    (set_attr "length_immediate" "1")
9376    (set_attr "memory" "load")
9377    (set_attr "mode" "TI")])
9378
9379 (define_insn "sse4_2_pcmpistri"
9380   [(set (match_operand:SI 0 "register_operand" "=c,c")
9381         (unspec:SI
9382           [(match_operand:V16QI 1 "register_operand" "x,x")
9383            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9384            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9385           UNSPEC_PCMPISTR))
9386    (set (reg:CC FLAGS_REG)
9387         (unspec:CC
9388           [(match_dup 1)
9389            (match_dup 2)
9390            (match_dup 3)]
9391           UNSPEC_PCMPISTR))]
9392   "TARGET_SSE4_2"
9393   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
9394   [(set_attr "type" "sselog")
9395    (set_attr "prefix_data16" "1")
9396    (set_attr "prefix_extra" "1")
9397    (set_attr "length_immediate" "1")
9398    (set_attr "prefix" "maybe_vex")
9399    (set_attr "memory" "none,load")
9400    (set_attr "btver2_decode" "vector")
9401    (set_attr "mode" "TI")])
9402
9403 (define_insn "sse4_2_pcmpistrm"
9404   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
9405         (unspec:V16QI
9406           [(match_operand:V16QI 1 "register_operand" "x,x")
9407            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9408            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
9409           UNSPEC_PCMPISTR))
9410    (set (reg:CC FLAGS_REG)
9411         (unspec:CC
9412           [(match_dup 1)
9413            (match_dup 2)
9414            (match_dup 3)]
9415           UNSPEC_PCMPISTR))]
9416   "TARGET_SSE4_2"
9417   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
9418   [(set_attr "type" "sselog")
9419    (set_attr "prefix_data16" "1")
9420    (set_attr "prefix_extra" "1")
9421    (set_attr "length_immediate" "1")
9422    (set_attr "prefix" "maybe_vex")
9423    (set_attr "memory" "none,load")
9424    (set_attr "btver2_decode" "vector")
9425    (set_attr "mode" "TI")])
9426
9427 (define_insn "sse4_2_pcmpistr_cconly"
9428   [(set (reg:CC FLAGS_REG)
9429         (unspec:CC
9430           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
9431            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
9432            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
9433           UNSPEC_PCMPISTR))
9434    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
9435    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
9436   "TARGET_SSE4_2"
9437   "@
9438    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9439    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
9440    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
9441    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
9442   [(set_attr "type" "sselog")
9443    (set_attr "prefix_data16" "1")
9444    (set_attr "prefix_extra" "1")
9445    (set_attr "length_immediate" "1")
9446    (set_attr "memory" "none,load,none,load")
9447    (set_attr "prefix" "maybe_vex")
9448    (set_attr "btver2_decode" "vector,vector,vector,vector")
9449    (set_attr "mode" "TI")])
9450
9451 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9452 ;;
9453 ;; XOP instructions
9454 ;;
9455 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9456
9457 (define_code_iterator xop_plus [plus ss_plus])
9458
9459 (define_code_attr macs [(plus "macs") (ss_plus "macss")])
9460 (define_code_attr madcs [(plus "madcs") (ss_plus "madcss")])
9461
9462 ;; XOP parallel integer multiply/add instructions.
9463
9464 (define_insn "xop_p<macs><ssemodesuffix><ssemodesuffix>"
9465   [(set (match_operand:VI24_128 0 "register_operand" "=x")
9466         (xop_plus:VI24_128
9467          (mult:VI24_128
9468           (match_operand:VI24_128 1 "nonimmediate_operand" "%x")
9469           (match_operand:VI24_128 2 "nonimmediate_operand" "xm"))
9470          (match_operand:VI24_128 3 "register_operand" "x")))]
9471   "TARGET_XOP"
9472   "vp<macs><ssemodesuffix><ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9473   [(set_attr "type" "ssemuladd")
9474    (set_attr "mode" "TI")])
9475
9476 (define_insn "xop_p<macs>dql"
9477   [(set (match_operand:V2DI 0 "register_operand" "=x")
9478         (xop_plus:V2DI
9479          (mult:V2DI
9480           (sign_extend:V2DI
9481            (vec_select:V2SI
9482             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
9483             (parallel [(const_int 0) (const_int 2)])))
9484           (sign_extend:V2DI
9485            (vec_select:V2SI
9486             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
9487             (parallel [(const_int 0) (const_int 2)]))))
9488          (match_operand:V2DI 3 "register_operand" "x")))]
9489   "TARGET_XOP"
9490   "vp<macs>dql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9491   [(set_attr "type" "ssemuladd")
9492    (set_attr "mode" "TI")])
9493
9494 (define_insn "xop_p<macs>dqh"
9495   [(set (match_operand:V2DI 0 "register_operand" "=x")
9496         (xop_plus:V2DI
9497          (mult:V2DI
9498           (sign_extend:V2DI
9499            (vec_select:V2SI
9500             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
9501             (parallel [(const_int 1) (const_int 3)])))
9502           (sign_extend:V2DI
9503            (vec_select:V2SI
9504             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
9505             (parallel [(const_int 1) (const_int 3)]))))
9506          (match_operand:V2DI 3 "register_operand" "x")))]
9507   "TARGET_XOP"
9508   "vp<macs>dqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9509   [(set_attr "type" "ssemuladd")
9510    (set_attr "mode" "TI")])
9511
9512 ;; XOP parallel integer multiply/add instructions for the intrinisics
9513 (define_insn "xop_p<macs>wd"
9514   [(set (match_operand:V4SI 0 "register_operand" "=x")
9515         (xop_plus:V4SI
9516          (mult:V4SI
9517           (sign_extend:V4SI
9518            (vec_select:V4HI
9519             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
9520             (parallel [(const_int 1) (const_int 3)
9521                        (const_int 5) (const_int 7)])))
9522           (sign_extend:V4SI
9523            (vec_select:V4HI
9524             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9525             (parallel [(const_int 1) (const_int 3)
9526                        (const_int 5) (const_int 7)]))))
9527          (match_operand:V4SI 3 "register_operand" "x")))]
9528   "TARGET_XOP"
9529   "vp<macs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9530   [(set_attr "type" "ssemuladd")
9531    (set_attr "mode" "TI")])
9532
9533 (define_insn "xop_p<madcs>wd"
9534   [(set (match_operand:V4SI 0 "register_operand" "=x")
9535         (xop_plus:V4SI
9536          (plus:V4SI
9537           (mult:V4SI
9538            (sign_extend:V4SI
9539             (vec_select:V4HI
9540              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
9541              (parallel [(const_int 0) (const_int 2)
9542                         (const_int 4) (const_int 6)])))
9543            (sign_extend:V4SI
9544             (vec_select:V4HI
9545              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
9546              (parallel [(const_int 0) (const_int 2)
9547                         (const_int 4) (const_int 6)]))))
9548           (mult:V4SI
9549            (sign_extend:V4SI
9550             (vec_select:V4HI
9551              (match_dup 1)
9552              (parallel [(const_int 1) (const_int 3)
9553                         (const_int 5) (const_int 7)])))
9554            (sign_extend:V4SI
9555             (vec_select:V4HI
9556              (match_dup 2)
9557              (parallel [(const_int 1) (const_int 3)
9558                         (const_int 5) (const_int 7)])))))
9559          (match_operand:V4SI 3 "register_operand" "x")))]
9560   "TARGET_XOP"
9561   "vp<madcs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9562   [(set_attr "type" "ssemuladd")
9563    (set_attr "mode" "TI")])
9564
9565 ;; XOP parallel XMM conditional moves
9566 (define_insn "xop_pcmov_<mode><avxsizesuffix>"
9567   [(set (match_operand:V 0 "register_operand" "=x,x")
9568         (if_then_else:V
9569           (match_operand:V 3 "nonimmediate_operand" "x,m")
9570           (match_operand:V 1 "register_operand" "x,x")
9571           (match_operand:V 2 "nonimmediate_operand" "xm,x")))]
9572   "TARGET_XOP"
9573   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9574   [(set_attr "type" "sse4arg")])
9575
9576 ;; XOP horizontal add/subtract instructions
9577 (define_insn "xop_phadd<u>bw"
9578   [(set (match_operand:V8HI 0 "register_operand" "=x")
9579         (plus:V8HI
9580          (any_extend:V8HI
9581           (vec_select:V8QI
9582            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9583            (parallel [(const_int 0) (const_int 2)
9584                       (const_int 4) (const_int 6)
9585                       (const_int 8) (const_int 10)
9586                       (const_int 12) (const_int 14)])))
9587          (any_extend:V8HI
9588           (vec_select:V8QI
9589            (match_dup 1)
9590            (parallel [(const_int 1) (const_int 3)
9591                       (const_int 5) (const_int 7)
9592                       (const_int 9) (const_int 11)
9593                       (const_int 13) (const_int 15)])))))]
9594   "TARGET_XOP"
9595   "vphadd<u>bw\t{%1, %0|%0, %1}"
9596   [(set_attr "type" "sseiadd1")])
9597
9598 (define_insn "xop_phadd<u>bd"
9599   [(set (match_operand:V4SI 0 "register_operand" "=x")
9600         (plus:V4SI
9601          (plus:V4SI
9602           (any_extend:V4SI
9603            (vec_select:V4QI
9604             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9605             (parallel [(const_int 0) (const_int 4)
9606                        (const_int 8) (const_int 12)])))
9607           (any_extend:V4SI
9608            (vec_select:V4QI
9609             (match_dup 1)
9610             (parallel [(const_int 1) (const_int 5)
9611                        (const_int 9) (const_int 13)]))))
9612          (plus:V4SI
9613           (any_extend:V4SI
9614            (vec_select:V4QI
9615             (match_dup 1)
9616             (parallel [(const_int 2) (const_int 6)
9617                        (const_int 10) (const_int 14)])))
9618           (any_extend:V4SI
9619            (vec_select:V4QI
9620             (match_dup 1)
9621             (parallel [(const_int 3) (const_int 7)
9622                        (const_int 11) (const_int 15)]))))))]
9623   "TARGET_XOP"
9624   "vphadd<u>bd\t{%1, %0|%0, %1}"
9625   [(set_attr "type" "sseiadd1")])
9626
9627 (define_insn "xop_phadd<u>bq"
9628   [(set (match_operand:V2DI 0 "register_operand" "=x")
9629         (plus:V2DI
9630          (plus:V2DI
9631           (plus:V2DI
9632            (any_extend:V2DI
9633             (vec_select:V2QI
9634              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9635              (parallel [(const_int 0) (const_int 8)])))
9636            (any_extend:V2DI
9637             (vec_select:V2QI
9638              (match_dup 1)
9639              (parallel [(const_int 1) (const_int 9)]))))
9640           (plus:V2DI
9641            (any_extend:V2DI
9642             (vec_select:V2QI
9643              (match_dup 1)
9644              (parallel [(const_int 2) (const_int 10)])))
9645            (any_extend:V2DI
9646             (vec_select:V2QI
9647              (match_dup 1)
9648              (parallel [(const_int 3) (const_int 11)])))))
9649          (plus:V2DI
9650           (plus:V2DI
9651            (any_extend:V2DI
9652             (vec_select:V2QI
9653              (match_dup 1)
9654              (parallel [(const_int 4) (const_int 12)])))
9655            (any_extend:V2DI
9656             (vec_select:V2QI
9657              (match_dup 1)
9658              (parallel [(const_int 5) (const_int 13)]))))
9659           (plus:V2DI
9660            (any_extend:V2DI
9661             (vec_select:V2QI
9662              (match_dup 1)
9663              (parallel [(const_int 6) (const_int 14)])))
9664            (any_extend:V2DI
9665             (vec_select:V2QI
9666              (match_dup 1)
9667              (parallel [(const_int 7) (const_int 15)])))))))]
9668   "TARGET_XOP"
9669   "vphadd<u>bq\t{%1, %0|%0, %1}"
9670   [(set_attr "type" "sseiadd1")])
9671
9672 (define_insn "xop_phadd<u>wd"
9673   [(set (match_operand:V4SI 0 "register_operand" "=x")
9674         (plus:V4SI
9675          (any_extend:V4SI
9676           (vec_select:V4HI
9677            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
9678            (parallel [(const_int 0) (const_int 2)
9679                       (const_int 4) (const_int 6)])))
9680          (any_extend:V4SI
9681           (vec_select:V4HI
9682            (match_dup 1)
9683            (parallel [(const_int 1) (const_int 3)
9684                       (const_int 5) (const_int 7)])))))]
9685   "TARGET_XOP"
9686   "vphadd<u>wd\t{%1, %0|%0, %1}"
9687   [(set_attr "type" "sseiadd1")])
9688
9689 (define_insn "xop_phadd<u>wq"
9690   [(set (match_operand:V2DI 0 "register_operand" "=x")
9691         (plus:V2DI
9692          (plus:V2DI
9693           (any_extend:V2DI
9694            (vec_select:V2HI
9695             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
9696             (parallel [(const_int 0) (const_int 4)])))
9697           (any_extend:V2DI
9698            (vec_select:V2HI
9699             (match_dup 1)
9700             (parallel [(const_int 1) (const_int 5)]))))
9701          (plus:V2DI
9702           (any_extend:V2DI
9703            (vec_select:V2HI
9704             (match_dup 1)
9705             (parallel [(const_int 2) (const_int 6)])))
9706           (any_extend:V2DI
9707            (vec_select:V2HI
9708             (match_dup 1)
9709             (parallel [(const_int 3) (const_int 7)]))))))]
9710   "TARGET_XOP"
9711   "vphadd<u>wq\t{%1, %0|%0, %1}"
9712   [(set_attr "type" "sseiadd1")])
9713
9714 (define_insn "xop_phadd<u>dq"
9715   [(set (match_operand:V2DI 0 "register_operand" "=x")
9716         (plus:V2DI
9717          (any_extend:V2DI
9718           (vec_select:V2SI
9719            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
9720            (parallel [(const_int 0) (const_int 2)])))
9721          (any_extend:V2DI
9722           (vec_select:V2SI
9723            (match_dup 1)
9724            (parallel [(const_int 1) (const_int 3)])))))]
9725   "TARGET_XOP"
9726   "vphadd<u>dq\t{%1, %0|%0, %1}"
9727   [(set_attr "type" "sseiadd1")])
9728
9729 (define_insn "xop_phsubbw"
9730   [(set (match_operand:V8HI 0 "register_operand" "=x")
9731         (minus:V8HI
9732          (sign_extend:V8HI
9733           (vec_select:V8QI
9734            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
9735            (parallel [(const_int 0) (const_int 2)
9736                       (const_int 4) (const_int 6)
9737                       (const_int 8) (const_int 10)
9738                       (const_int 12) (const_int 14)])))
9739          (sign_extend:V8HI
9740           (vec_select:V8QI
9741            (match_dup 1)
9742            (parallel [(const_int 1) (const_int 3)
9743                       (const_int 5) (const_int 7)
9744                       (const_int 9) (const_int 11)
9745                       (const_int 13) (const_int 15)])))))]
9746   "TARGET_XOP"
9747   "vphsubbw\t{%1, %0|%0, %1}"
9748   [(set_attr "type" "sseiadd1")])
9749
9750 (define_insn "xop_phsubwd"
9751   [(set (match_operand:V4SI 0 "register_operand" "=x")
9752         (minus:V4SI
9753          (sign_extend:V4SI
9754           (vec_select:V4HI
9755            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
9756            (parallel [(const_int 0) (const_int 2)
9757                       (const_int 4) (const_int 6)])))
9758          (sign_extend:V4SI
9759           (vec_select:V4HI
9760            (match_dup 1)
9761            (parallel [(const_int 1) (const_int 3)
9762                       (const_int 5) (const_int 7)])))))]
9763   "TARGET_XOP"
9764   "vphsubwd\t{%1, %0|%0, %1}"
9765   [(set_attr "type" "sseiadd1")])
9766
9767 (define_insn "xop_phsubdq"
9768   [(set (match_operand:V2DI 0 "register_operand" "=x")
9769         (minus:V2DI
9770          (sign_extend:V2DI
9771           (vec_select:V2SI
9772            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
9773            (parallel [(const_int 0) (const_int 2)])))
9774          (sign_extend:V2DI
9775           (vec_select:V2SI
9776            (match_dup 1)
9777            (parallel [(const_int 1) (const_int 3)])))))]
9778   "TARGET_XOP"
9779   "vphsubdq\t{%1, %0|%0, %1}"
9780   [(set_attr "type" "sseiadd1")])
9781
9782 ;; XOP permute instructions
9783 (define_insn "xop_pperm"
9784   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9785         (unspec:V16QI
9786           [(match_operand:V16QI 1 "register_operand" "x,x")
9787            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
9788            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
9789           UNSPEC_XOP_PERMUTE))]
9790   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
9791   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9792   [(set_attr "type" "sse4arg")
9793    (set_attr "mode" "TI")])
9794
9795 ;; XOP pack instructions that combine two vectors into a smaller vector
9796 (define_insn "xop_pperm_pack_v2di_v4si"
9797   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
9798         (vec_concat:V4SI
9799          (truncate:V2SI
9800           (match_operand:V2DI 1 "register_operand" "x,x"))
9801          (truncate:V2SI
9802           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
9803    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
9804   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
9805   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9806   [(set_attr "type" "sse4arg")
9807    (set_attr "mode" "TI")])
9808
9809 (define_insn "xop_pperm_pack_v4si_v8hi"
9810   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
9811         (vec_concat:V8HI
9812          (truncate:V4HI
9813           (match_operand:V4SI 1 "register_operand" "x,x"))
9814          (truncate:V4HI
9815           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
9816    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
9817   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
9818   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9819   [(set_attr "type" "sse4arg")
9820    (set_attr "mode" "TI")])
9821
9822 (define_insn "xop_pperm_pack_v8hi_v16qi"
9823   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9824         (vec_concat:V16QI
9825          (truncate:V8QI
9826           (match_operand:V8HI 1 "register_operand" "x,x"))
9827          (truncate:V8QI
9828           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
9829    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
9830   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
9831   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
9832   [(set_attr "type" "sse4arg")
9833    (set_attr "mode" "TI")])
9834
9835 ;; XOP packed rotate instructions
9836 (define_expand "rotl<mode>3"
9837   [(set (match_operand:VI_128 0 "register_operand")
9838         (rotate:VI_128
9839          (match_operand:VI_128 1 "nonimmediate_operand")
9840          (match_operand:SI 2 "general_operand")))]
9841   "TARGET_XOP"
9842 {
9843   /* If we were given a scalar, convert it to parallel */
9844   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
9845     {
9846       rtvec vs = rtvec_alloc (<ssescalarnum>);
9847       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
9848       rtx reg = gen_reg_rtx (<MODE>mode);
9849       rtx op2 = operands[2];
9850       int i;
9851
9852       if (GET_MODE (op2) != <ssescalarmode>mode)
9853         {
9854           op2 = gen_reg_rtx (<ssescalarmode>mode);
9855           convert_move (op2, operands[2], false);
9856         }
9857
9858       for (i = 0; i < <ssescalarnum>; i++)
9859         RTVEC_ELT (vs, i) = op2;
9860
9861       emit_insn (gen_vec_init<mode> (reg, par));
9862       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
9863       DONE;
9864     }
9865 })
9866
9867 (define_expand "rotr<mode>3"
9868   [(set (match_operand:VI_128 0 "register_operand")
9869         (rotatert:VI_128
9870          (match_operand:VI_128 1 "nonimmediate_operand")
9871          (match_operand:SI 2 "general_operand")))]
9872   "TARGET_XOP"
9873 {
9874   /* If we were given a scalar, convert it to parallel */
9875   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
9876     {
9877       rtvec vs = rtvec_alloc (<ssescalarnum>);
9878       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
9879       rtx neg = gen_reg_rtx (<MODE>mode);
9880       rtx reg = gen_reg_rtx (<MODE>mode);
9881       rtx op2 = operands[2];
9882       int i;
9883
9884       if (GET_MODE (op2) != <ssescalarmode>mode)
9885         {
9886           op2 = gen_reg_rtx (<ssescalarmode>mode);
9887           convert_move (op2, operands[2], false);
9888         }
9889
9890       for (i = 0; i < <ssescalarnum>; i++)
9891         RTVEC_ELT (vs, i) = op2;
9892
9893       emit_insn (gen_vec_init<mode> (reg, par));
9894       emit_insn (gen_neg<mode>2 (neg, reg));
9895       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
9896       DONE;
9897     }
9898 })
9899
9900 (define_insn "xop_rotl<mode>3"
9901   [(set (match_operand:VI_128 0 "register_operand" "=x")
9902         (rotate:VI_128
9903          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
9904          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
9905   "TARGET_XOP"
9906   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
9907   [(set_attr "type" "sseishft")
9908    (set_attr "length_immediate" "1")
9909    (set_attr "mode" "TI")])
9910
9911 (define_insn "xop_rotr<mode>3"
9912   [(set (match_operand:VI_128 0 "register_operand" "=x")
9913         (rotatert:VI_128
9914          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
9915          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
9916   "TARGET_XOP"
9917 {
9918   operands[3]
9919     = GEN_INT (GET_MODE_BITSIZE (<ssescalarmode>mode) - INTVAL (operands[2]));
9920   return \"vprot<ssemodesuffix>\t{%3, %1, %0|%0, %1, %3}\";
9921 }
9922   [(set_attr "type" "sseishft")
9923    (set_attr "length_immediate" "1")
9924    (set_attr "mode" "TI")])
9925
9926 (define_expand "vrotr<mode>3"
9927   [(match_operand:VI_128 0 "register_operand")
9928    (match_operand:VI_128 1 "register_operand")
9929    (match_operand:VI_128 2 "register_operand")]
9930   "TARGET_XOP"
9931 {
9932   rtx reg = gen_reg_rtx (<MODE>mode);
9933   emit_insn (gen_neg<mode>2 (reg, operands[2]));
9934   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
9935   DONE;
9936 })
9937
9938 (define_expand "vrotl<mode>3"
9939   [(match_operand:VI_128 0 "register_operand")
9940    (match_operand:VI_128 1 "register_operand")
9941    (match_operand:VI_128 2 "register_operand")]
9942   "TARGET_XOP"
9943 {
9944   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
9945   DONE;
9946 })
9947
9948 (define_insn "xop_vrotl<mode>3"
9949   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
9950         (if_then_else:VI_128
9951          (ge:VI_128
9952           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
9953           (const_int 0))
9954          (rotate:VI_128
9955           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
9956           (match_dup 2))
9957          (rotatert:VI_128
9958           (match_dup 1)
9959           (neg:VI_128 (match_dup 2)))))]
9960   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
9961   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
9962   [(set_attr "type" "sseishft")
9963    (set_attr "prefix_data16" "0")
9964    (set_attr "prefix_extra" "2")
9965    (set_attr "mode" "TI")])
9966
9967 ;; XOP packed shift instructions.
9968 (define_expand "vlshr<mode>3"
9969   [(set (match_operand:VI12_128 0 "register_operand")
9970         (lshiftrt:VI12_128
9971           (match_operand:VI12_128 1 "register_operand")
9972           (match_operand:VI12_128 2 "nonimmediate_operand")))]
9973   "TARGET_XOP"
9974 {
9975   rtx neg = gen_reg_rtx (<MODE>mode);
9976   emit_insn (gen_neg<mode>2 (neg, operands[2]));
9977   emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
9978   DONE;
9979 })
9980
9981 (define_expand "vlshr<mode>3"
9982   [(set (match_operand:VI48_128 0 "register_operand")
9983         (lshiftrt:VI48_128
9984           (match_operand:VI48_128 1 "register_operand")
9985           (match_operand:VI48_128 2 "nonimmediate_operand")))]
9986   "TARGET_AVX2 || TARGET_XOP"
9987 {
9988   if (!TARGET_AVX2)
9989     {
9990       rtx neg = gen_reg_rtx (<MODE>mode);
9991       emit_insn (gen_neg<mode>2 (neg, operands[2]));
9992       emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
9993       DONE;
9994     }
9995 })
9996
9997 (define_expand "vlshr<mode>3"
9998   [(set (match_operand:VI48_256 0 "register_operand")
9999         (lshiftrt:VI48_256
10000           (match_operand:VI48_256 1 "register_operand")
10001           (match_operand:VI48_256 2 "nonimmediate_operand")))]
10002   "TARGET_AVX2")
10003
10004 (define_expand "vashr<mode>3"
10005   [(set (match_operand:VI128_128 0 "register_operand")
10006         (ashiftrt:VI128_128
10007           (match_operand:VI128_128 1 "register_operand")
10008           (match_operand:VI128_128 2 "nonimmediate_operand")))]
10009   "TARGET_XOP"
10010 {
10011   rtx neg = gen_reg_rtx (<MODE>mode);
10012   emit_insn (gen_neg<mode>2 (neg, operands[2]));
10013   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], neg));
10014   DONE;
10015 })
10016
10017 (define_expand "vashrv4si3"
10018   [(set (match_operand:V4SI 0 "register_operand")
10019         (ashiftrt:V4SI (match_operand:V4SI 1 "register_operand")
10020                        (match_operand:V4SI 2 "nonimmediate_operand")))]
10021   "TARGET_AVX2 || TARGET_XOP"
10022 {
10023   if (!TARGET_AVX2)
10024     {
10025       rtx neg = gen_reg_rtx (V4SImode);
10026       emit_insn (gen_negv4si2 (neg, operands[2]));
10027       emit_insn (gen_xop_shav4si3 (operands[0], operands[1], neg));
10028       DONE;
10029     }
10030 })
10031
10032 (define_expand "vashrv8si3"
10033   [(set (match_operand:V8SI 0 "register_operand")
10034         (ashiftrt:V8SI (match_operand:V8SI 1 "register_operand")
10035                        (match_operand:V8SI 2 "nonimmediate_operand")))]
10036   "TARGET_AVX2")
10037
10038 (define_expand "vashl<mode>3"
10039   [(set (match_operand:VI12_128 0 "register_operand")
10040         (ashift:VI12_128
10041           (match_operand:VI12_128 1 "register_operand")
10042           (match_operand:VI12_128 2 "nonimmediate_operand")))]
10043   "TARGET_XOP"
10044 {
10045   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
10046   DONE;
10047 })
10048
10049 (define_expand "vashl<mode>3"
10050   [(set (match_operand:VI48_128 0 "register_operand")
10051         (ashift:VI48_128
10052           (match_operand:VI48_128 1 "register_operand")
10053           (match_operand:VI48_128 2 "nonimmediate_operand")))]
10054   "TARGET_AVX2 || TARGET_XOP"
10055 {
10056   if (!TARGET_AVX2)
10057     {
10058       operands[2] = force_reg (<MODE>mode, operands[2]);
10059       emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
10060       DONE;
10061     }
10062 })
10063
10064 (define_expand "vashl<mode>3"
10065   [(set (match_operand:VI48_256 0 "register_operand")
10066         (ashift:VI48_256
10067           (match_operand:VI48_256 1 "register_operand")
10068           (match_operand:VI48_256 2 "nonimmediate_operand")))]
10069   "TARGET_AVX2")
10070
10071 (define_insn "xop_sha<mode>3"
10072   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
10073         (if_then_else:VI_128
10074          (ge:VI_128
10075           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
10076           (const_int 0))
10077          (ashift:VI_128
10078           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
10079           (match_dup 2))
10080          (ashiftrt:VI_128
10081           (match_dup 1)
10082           (neg:VI_128 (match_dup 2)))))]
10083   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
10084   "vpsha<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10085   [(set_attr "type" "sseishft")
10086    (set_attr "prefix_data16" "0")
10087    (set_attr "prefix_extra" "2")
10088    (set_attr "mode" "TI")])
10089
10090 (define_insn "xop_shl<mode>3"
10091   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
10092         (if_then_else:VI_128
10093          (ge:VI_128
10094           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
10095           (const_int 0))
10096          (ashift:VI_128
10097           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
10098           (match_dup 2))
10099          (lshiftrt:VI_128
10100           (match_dup 1)
10101           (neg:VI_128 (match_dup 2)))))]
10102   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
10103   "vpshl<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10104   [(set_attr "type" "sseishft")
10105    (set_attr "prefix_data16" "0")
10106    (set_attr "prefix_extra" "2")
10107    (set_attr "mode" "TI")])
10108
10109 (define_expand "<shift_insn><mode>3"
10110   [(set (match_operand:VI1_AVX2 0 "register_operand")
10111         (any_shift:VI1_AVX2
10112           (match_operand:VI1_AVX2 1 "register_operand")
10113           (match_operand:SI 2 "nonmemory_operand")))]
10114   "TARGET_SSE2"
10115 {
10116   if (TARGET_XOP && <MODE>mode == V16QImode)
10117     {
10118       bool negate = false;
10119       rtx (*gen) (rtx, rtx, rtx);
10120       rtx tmp, par;
10121       int i;
10122
10123       if (<CODE> != ASHIFT)
10124         {
10125           if (CONST_INT_P (operands[2]))
10126             operands[2] = GEN_INT (-INTVAL (operands[2]));
10127           else
10128             negate = true;
10129         }
10130       par = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
10131       for (i = 0; i < 16; i++)
10132         XVECEXP (par, 0, i) = operands[2];
10133
10134       tmp = gen_reg_rtx (V16QImode);
10135       emit_insn (gen_vec_initv16qi (tmp, par));
10136
10137       if (negate)
10138         emit_insn (gen_negv16qi2 (tmp, tmp));
10139
10140       gen = (<CODE> == LSHIFTRT ? gen_xop_shlv16qi3 : gen_xop_shav16qi3);
10141       emit_insn (gen (operands[0], operands[1], tmp));
10142     }
10143   else
10144     ix86_expand_vecop_qihi (<CODE>, operands[0], operands[1], operands[2]);
10145   DONE;
10146 })
10147
10148 (define_expand "ashrv2di3"
10149   [(set (match_operand:V2DI 0 "register_operand")
10150         (ashiftrt:V2DI
10151           (match_operand:V2DI 1 "register_operand")
10152           (match_operand:DI 2 "nonmemory_operand")))]
10153   "TARGET_XOP"
10154 {
10155   rtx reg = gen_reg_rtx (V2DImode);
10156   rtx par;
10157   bool negate = false;
10158   int i;
10159
10160   if (CONST_INT_P (operands[2]))
10161     operands[2] = GEN_INT (-INTVAL (operands[2]));
10162   else
10163     negate = true;
10164
10165   par = gen_rtx_PARALLEL (V2DImode, rtvec_alloc (2));
10166   for (i = 0; i < 2; i++)
10167     XVECEXP (par, 0, i) = operands[2];
10168
10169   emit_insn (gen_vec_initv2di (reg, par));
10170
10171   if (negate)
10172     emit_insn (gen_negv2di2 (reg, reg));
10173
10174   emit_insn (gen_xop_shav2di3 (operands[0], operands[1], reg));
10175   DONE;
10176 })
10177
10178 ;; XOP FRCZ support
10179 (define_insn "xop_frcz<mode>2"
10180   [(set (match_operand:FMAMODE 0 "register_operand" "=x")
10181         (unspec:FMAMODE
10182          [(match_operand:FMAMODE 1 "nonimmediate_operand" "xm")]
10183          UNSPEC_FRCZ))]
10184   "TARGET_XOP"
10185   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
10186   [(set_attr "type" "ssecvt1")
10187    (set_attr "mode" "<MODE>")])
10188
10189 ;; scalar insns
10190 (define_expand "xop_vmfrcz<mode>2"
10191   [(set (match_operand:VF_128 0 "register_operand")
10192         (vec_merge:VF_128
10193           (unspec:VF_128
10194            [(match_operand:VF_128 1 "nonimmediate_operand")]
10195            UNSPEC_FRCZ)
10196           (match_dup 3)
10197           (const_int 1)))]
10198   "TARGET_XOP"
10199 {
10200   operands[3] = CONST0_RTX (<MODE>mode);
10201 })
10202
10203 (define_insn "*xop_vmfrcz_<mode>"
10204   [(set (match_operand:VF_128 0 "register_operand" "=x")
10205         (vec_merge:VF_128
10206           (unspec:VF_128
10207            [(match_operand:VF_128 1 "nonimmediate_operand" "xm")]
10208            UNSPEC_FRCZ)
10209           (match_operand:VF_128 2 "const0_operand")
10210           (const_int 1)))]
10211   "TARGET_XOP"
10212   "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}"
10213   [(set_attr "type" "ssecvt1")
10214    (set_attr "mode" "<MODE>")])
10215
10216 (define_insn "xop_maskcmp<mode>3"
10217   [(set (match_operand:VI_128 0 "register_operand" "=x")
10218         (match_operator:VI_128 1 "ix86_comparison_int_operator"
10219          [(match_operand:VI_128 2 "register_operand" "x")
10220           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
10221   "TARGET_XOP"
10222   "vpcom%Y1<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
10223   [(set_attr "type" "sse4arg")
10224    (set_attr "prefix_data16" "0")
10225    (set_attr "prefix_rep" "0")
10226    (set_attr "prefix_extra" "2")
10227    (set_attr "length_immediate" "1")
10228    (set_attr "mode" "TI")])
10229
10230 (define_insn "xop_maskcmp_uns<mode>3"
10231   [(set (match_operand:VI_128 0 "register_operand" "=x")
10232         (match_operator:VI_128 1 "ix86_comparison_uns_operator"
10233          [(match_operand:VI_128 2 "register_operand" "x")
10234           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
10235   "TARGET_XOP"
10236   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
10237   [(set_attr "type" "ssecmp")
10238    (set_attr "prefix_data16" "0")
10239    (set_attr "prefix_rep" "0")
10240    (set_attr "prefix_extra" "2")
10241    (set_attr "length_immediate" "1")
10242    (set_attr "mode" "TI")])
10243
10244 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
10245 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
10246 ;; the exact instruction generated for the intrinsic.
10247 (define_insn "xop_maskcmp_uns2<mode>3"
10248   [(set (match_operand:VI_128 0 "register_operand" "=x")
10249         (unspec:VI_128
10250          [(match_operator:VI_128 1 "ix86_comparison_uns_operator"
10251           [(match_operand:VI_128 2 "register_operand" "x")
10252            (match_operand:VI_128 3 "nonimmediate_operand" "xm")])]
10253          UNSPEC_XOP_UNSIGNED_CMP))]
10254   "TARGET_XOP"
10255   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
10256   [(set_attr "type" "ssecmp")
10257    (set_attr "prefix_data16" "0")
10258    (set_attr "prefix_extra" "2")
10259    (set_attr "length_immediate" "1")
10260    (set_attr "mode" "TI")])
10261
10262 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
10263 ;; being added here to be complete.
10264 (define_insn "xop_pcom_tf<mode>3"
10265   [(set (match_operand:VI_128 0 "register_operand" "=x")
10266         (unspec:VI_128
10267           [(match_operand:VI_128 1 "register_operand" "x")
10268            (match_operand:VI_128 2 "nonimmediate_operand" "xm")
10269            (match_operand:SI 3 "const_int_operand" "n")]
10270           UNSPEC_XOP_TRUEFALSE))]
10271   "TARGET_XOP"
10272 {
10273   return ((INTVAL (operands[3]) != 0)
10274           ? "vpcomtrue<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10275           : "vpcomfalse<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}");
10276 }
10277   [(set_attr "type" "ssecmp")
10278    (set_attr "prefix_data16" "0")
10279    (set_attr "prefix_extra" "2")
10280    (set_attr "length_immediate" "1")
10281    (set_attr "mode" "TI")])
10282
10283 (define_insn "xop_vpermil2<mode>3"
10284   [(set (match_operand:VF 0 "register_operand" "=x")
10285         (unspec:VF
10286           [(match_operand:VF 1 "register_operand" "x")
10287            (match_operand:VF 2 "nonimmediate_operand" "%x")
10288            (match_operand:<sseintvecmode> 3 "nonimmediate_operand" "xm")
10289            (match_operand:SI 4 "const_0_to_3_operand" "n")]
10290           UNSPEC_VPERMIL2))]
10291   "TARGET_XOP"
10292   "vpermil2<ssemodesuffix>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
10293   [(set_attr "type" "sse4arg")
10294    (set_attr "length_immediate" "1")
10295    (set_attr "mode" "<MODE>")])
10296
10297 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10298
10299 (define_insn "aesenc"
10300   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10301         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
10302                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
10303                       UNSPEC_AESENC))]
10304   "TARGET_AES"
10305   "@
10306    aesenc\t{%2, %0|%0, %2}
10307    vaesenc\t{%2, %1, %0|%0, %1, %2}"
10308   [(set_attr "isa" "noavx,avx")
10309    (set_attr "type" "sselog1")
10310    (set_attr "prefix_extra" "1")
10311    (set_attr "prefix" "orig,vex")
10312    (set_attr "btver2_decode" "double,double")
10313    (set_attr "mode" "TI")])
10314
10315 (define_insn "aesenclast"
10316   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10317         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
10318                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
10319                       UNSPEC_AESENCLAST))]
10320   "TARGET_AES"
10321   "@
10322    aesenclast\t{%2, %0|%0, %2}
10323    vaesenclast\t{%2, %1, %0|%0, %1, %2}"
10324   [(set_attr "isa" "noavx,avx")
10325    (set_attr "type" "sselog1")
10326    (set_attr "prefix_extra" "1")
10327    (set_attr "prefix" "orig,vex")
10328    (set_attr "btver2_decode" "double,double")
10329    (set_attr "mode" "TI")])
10330
10331 (define_insn "aesdec"
10332   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10333         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
10334                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
10335                       UNSPEC_AESDEC))]
10336   "TARGET_AES"
10337   "@
10338    aesdec\t{%2, %0|%0, %2}
10339    vaesdec\t{%2, %1, %0|%0, %1, %2}"
10340   [(set_attr "isa" "noavx,avx")
10341    (set_attr "type" "sselog1")
10342    (set_attr "prefix_extra" "1")
10343    (set_attr "prefix" "orig,vex")
10344    (set_attr "btver2_decode" "double,double")
10345    (set_attr "mode" "TI")])
10346
10347 (define_insn "aesdeclast"
10348   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10349         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
10350                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
10351                       UNSPEC_AESDECLAST))]
10352   "TARGET_AES"
10353   "@
10354    aesdeclast\t{%2, %0|%0, %2}
10355    vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
10356   [(set_attr "isa" "noavx,avx")
10357    (set_attr "type" "sselog1")
10358    (set_attr "prefix_extra" "1")
10359    (set_attr "prefix" "orig,vex")
10360    (set_attr "btver2_decode" "double,double")
10361    (set_attr "mode" "TI")])
10362
10363 (define_insn "aesimc"
10364   [(set (match_operand:V2DI 0 "register_operand" "=x")
10365         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
10366                       UNSPEC_AESIMC))]
10367   "TARGET_AES"
10368   "%vaesimc\t{%1, %0|%0, %1}"
10369   [(set_attr "type" "sselog1")
10370    (set_attr "prefix_extra" "1")
10371    (set_attr "prefix" "maybe_vex")
10372    (set_attr "mode" "TI")])
10373
10374 (define_insn "aeskeygenassist"
10375   [(set (match_operand:V2DI 0 "register_operand" "=x")
10376         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
10377                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
10378                      UNSPEC_AESKEYGENASSIST))]
10379   "TARGET_AES"
10380   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
10381   [(set_attr "type" "sselog1")
10382    (set_attr "prefix_extra" "1")
10383    (set_attr "length_immediate" "1")
10384    (set_attr "prefix" "maybe_vex")
10385    (set_attr "mode" "TI")])
10386
10387 (define_insn "pclmulqdq"
10388   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
10389         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
10390                       (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")
10391                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
10392                      UNSPEC_PCLMUL))]
10393   "TARGET_PCLMUL"
10394   "@
10395    pclmulqdq\t{%3, %2, %0|%0, %2, %3}
10396    vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10397   [(set_attr "isa" "noavx,avx")
10398    (set_attr "type" "sselog1")
10399    (set_attr "prefix_extra" "1")
10400    (set_attr "length_immediate" "1")
10401    (set_attr "prefix" "orig,vex")
10402    (set_attr "mode" "TI")])
10403
10404 (define_expand "avx_vzeroall"
10405   [(match_par_dup 0 [(const_int 0)])]
10406   "TARGET_AVX"
10407 {
10408   int nregs = TARGET_64BIT ? 16 : 8;
10409   int regno;
10410
10411   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
10412
10413   XVECEXP (operands[0], 0, 0)
10414     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
10415                                UNSPECV_VZEROALL);
10416
10417   for (regno = 0; regno < nregs; regno++)
10418     XVECEXP (operands[0], 0, regno + 1)
10419       = gen_rtx_SET (VOIDmode,
10420                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
10421                      CONST0_RTX (V8SImode));
10422 })
10423
10424 (define_insn "*avx_vzeroall"
10425   [(match_parallel 0 "vzeroall_operation"
10426     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
10427   "TARGET_AVX"
10428   "vzeroall"
10429   [(set_attr "type" "sse")
10430    (set_attr "modrm" "0")
10431    (set_attr "memory" "none")
10432    (set_attr "prefix" "vex")
10433    (set_attr "btver2_decode" "vector")
10434    (set_attr "mode" "OI")])
10435
10436 ;; Clear the upper 128bits of AVX registers, equivalent to a NOP
10437 ;; if the upper 128bits are unused.
10438 (define_insn "avx_vzeroupper"
10439   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)]
10440   "TARGET_AVX"
10441   "vzeroupper"
10442   [(set_attr "type" "sse")
10443    (set_attr "modrm" "0")
10444    (set_attr "memory" "none")
10445    (set_attr "prefix" "vex")
10446    (set_attr "btver2_decode" "vector")
10447    (set_attr "mode" "OI")])
10448
10449 (define_mode_attr AVXTOSSEMODE
10450   [(V4DI "V2DI") (V2DI "V2DI")
10451    (V8SI "V4SI") (V4SI "V4SI")
10452    (V16HI "V8HI") (V8HI "V8HI")
10453    (V32QI "V16QI") (V16QI "V16QI")])
10454
10455 (define_insn "avx2_pbroadcast<mode>"
10456   [(set (match_operand:VI 0 "register_operand" "=x")
10457         (vec_duplicate:VI
10458           (vec_select:<ssescalarmode>
10459             (match_operand:<AVXTOSSEMODE> 1 "nonimmediate_operand" "xm")
10460             (parallel [(const_int 0)]))))]
10461   "TARGET_AVX2"
10462   "vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}"
10463   [(set_attr "type" "ssemov")
10464    (set_attr "prefix_extra" "1")
10465    (set_attr "prefix" "vex")
10466    (set_attr "mode" "<sseinsnmode>")])
10467
10468 (define_insn "avx2_pbroadcast<mode>_1"
10469   [(set (match_operand:VI_256 0 "register_operand" "=x,x")
10470         (vec_duplicate:VI_256
10471           (vec_select:<ssescalarmode>
10472             (match_operand:VI_256 1 "nonimmediate_operand" "m,x")
10473             (parallel [(const_int 0)]))))]
10474   "TARGET_AVX2"
10475   "@
10476    vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}
10477    vpbroadcast<ssemodesuffix>\t{%x1, %0|%0, %x1}"
10478   [(set_attr "type" "ssemov")
10479    (set_attr "prefix_extra" "1")
10480    (set_attr "prefix" "vex")
10481    (set_attr "mode" "<sseinsnmode>")])
10482
10483 (define_insn "avx2_permvar<mode>"
10484   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
10485         (unspec:VI4F_256
10486           [(match_operand:VI4F_256 1 "nonimmediate_operand" "xm")
10487            (match_operand:V8SI 2 "register_operand" "x")]
10488           UNSPEC_VPERMVAR))]
10489   "TARGET_AVX2"
10490   "vperm<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
10491   [(set_attr "type" "sselog")
10492    (set_attr "prefix" "vex")
10493    (set_attr "mode" "OI")])
10494
10495 (define_expand "avx2_perm<mode>"
10496   [(match_operand:VI8F_256 0 "register_operand")
10497    (match_operand:VI8F_256 1 "nonimmediate_operand")
10498    (match_operand:SI 2 "const_0_to_255_operand")]
10499   "TARGET_AVX2"
10500 {
10501   int mask = INTVAL (operands[2]);
10502   emit_insn (gen_avx2_perm<mode>_1 (operands[0], operands[1],
10503                                     GEN_INT ((mask >> 0) & 3),
10504                                     GEN_INT ((mask >> 2) & 3),
10505                                     GEN_INT ((mask >> 4) & 3),
10506                                     GEN_INT ((mask >> 6) & 3)));
10507   DONE;
10508 })
10509
10510 (define_insn "avx2_perm<mode>_1"
10511   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
10512         (vec_select:VI8F_256
10513           (match_operand:VI8F_256 1 "nonimmediate_operand" "xm")
10514           (parallel [(match_operand 2 "const_0_to_3_operand")
10515                      (match_operand 3 "const_0_to_3_operand")
10516                      (match_operand 4 "const_0_to_3_operand")
10517                      (match_operand 5 "const_0_to_3_operand")])))]
10518   "TARGET_AVX2"
10519 {
10520   int mask = 0;
10521   mask |= INTVAL (operands[2]) << 0;
10522   mask |= INTVAL (operands[3]) << 2;
10523   mask |= INTVAL (operands[4]) << 4;
10524   mask |= INTVAL (operands[5]) << 6;
10525   operands[2] = GEN_INT (mask);
10526   return "vperm<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
10527 }
10528   [(set_attr "type" "sselog")
10529    (set_attr "prefix" "vex")
10530    (set_attr "mode" "<sseinsnmode>")])
10531
10532 (define_insn "avx2_permv2ti"
10533   [(set (match_operand:V4DI 0 "register_operand" "=x")
10534         (unspec:V4DI
10535           [(match_operand:V4DI 1 "register_operand" "x")
10536            (match_operand:V4DI 2 "nonimmediate_operand" "xm")
10537            (match_operand:SI 3 "const_0_to_255_operand" "n")]
10538           UNSPEC_VPERMTI))]
10539   "TARGET_AVX2"
10540   "vperm2i128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10541   [(set_attr "type" "sselog")
10542    (set_attr "prefix" "vex")
10543    (set_attr "mode" "OI")])
10544
10545 (define_insn "avx2_vec_dupv4df"
10546   [(set (match_operand:V4DF 0 "register_operand" "=x")
10547         (vec_duplicate:V4DF
10548           (vec_select:DF
10549             (match_operand:V2DF 1 "register_operand" "x")
10550             (parallel [(const_int 0)]))))]
10551   "TARGET_AVX2"
10552   "vbroadcastsd\t{%1, %0|%0, %1}"
10553   [(set_attr "type" "sselog1")
10554    (set_attr "prefix" "vex")
10555    (set_attr "mode" "V4DF")])
10556
10557 ;; Modes handled by AVX vec_dup patterns.
10558 (define_mode_iterator AVX_VEC_DUP_MODE
10559   [V8SI V8SF V4DI V4DF])
10560
10561 (define_insn "vec_dup<mode>"
10562   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand" "=x,x,x")
10563         (vec_duplicate:AVX_VEC_DUP_MODE
10564           (match_operand:<ssescalarmode> 1 "nonimmediate_operand" "m,x,?x")))]
10565   "TARGET_AVX"
10566   "@
10567    vbroadcast<ssescalarmodesuffix>\t{%1, %0|%0, %1}
10568    vbroadcast<ssescalarmodesuffix>\t{%x1, %0|%0, %x1}
10569    #"
10570   [(set_attr "type" "ssemov")
10571    (set_attr "prefix_extra" "1")
10572    (set_attr "prefix" "vex")
10573    (set_attr "isa" "*,avx2,noavx2")
10574    (set_attr "mode" "V8SF")])
10575
10576 (define_insn "avx2_vbroadcasti128_<mode>"
10577   [(set (match_operand:VI_256 0 "register_operand" "=x")
10578         (vec_concat:VI_256
10579           (match_operand:<ssehalfvecmode> 1 "memory_operand" "m")
10580           (match_dup 1)))]
10581   "TARGET_AVX2"
10582   "vbroadcasti128\t{%1, %0|%0, %1}"
10583   [(set_attr "type" "ssemov")
10584    (set_attr "prefix_extra" "1")
10585    (set_attr "prefix" "vex")
10586    (set_attr "mode" "OI")])
10587
10588 (define_split
10589   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand")
10590         (vec_duplicate:AVX_VEC_DUP_MODE
10591           (match_operand:<ssescalarmode> 1 "register_operand")))]
10592   "TARGET_AVX && !TARGET_AVX2 && reload_completed"
10593   [(set (match_dup 2)
10594         (vec_duplicate:<ssehalfvecmode> (match_dup 1)))
10595    (set (match_dup 0)
10596         (vec_concat:AVX_VEC_DUP_MODE (match_dup 2) (match_dup 2)))]
10597   "operands[2] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[0]));")
10598
10599 (define_insn "avx_vbroadcastf128_<mode>"
10600   [(set (match_operand:V_256 0 "register_operand" "=x,x,x")
10601         (vec_concat:V_256
10602           (match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
10603           (match_dup 1)))]
10604   "TARGET_AVX"
10605   "@
10606    vbroadcast<i128>\t{%1, %0|%0, %1}
10607    vinsert<i128>\t{$1, %1, %0, %0|%0, %0, %1, 1}
10608    vperm2<i128>\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
10609   [(set_attr "type" "ssemov,sselog1,sselog1")
10610    (set_attr "prefix_extra" "1")
10611    (set_attr "length_immediate" "0,1,1")
10612    (set_attr "prefix" "vex")
10613    (set_attr "mode" "<sseinsnmode>")])
10614
10615 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
10616 ;; If it so happens that the input is in memory, use vbroadcast.
10617 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
10618 (define_insn "*avx_vperm_broadcast_v4sf"
10619   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
10620         (vec_select:V4SF
10621           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
10622           (match_parallel 2 "avx_vbroadcast_operand"
10623             [(match_operand 3 "const_int_operand" "C,n,n")])))]
10624   "TARGET_AVX"
10625 {
10626   int elt = INTVAL (operands[3]);
10627   switch (which_alternative)
10628     {
10629     case 0:
10630     case 1:
10631       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
10632       return "vbroadcastss\t{%1, %0|%0, %k1}";
10633     case 2:
10634       operands[2] = GEN_INT (elt * 0x55);
10635       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
10636     default:
10637       gcc_unreachable ();
10638     }
10639 }
10640   [(set_attr "type" "ssemov,ssemov,sselog1")
10641    (set_attr "prefix_extra" "1")
10642    (set_attr "length_immediate" "0,0,1")
10643    (set_attr "prefix" "vex")
10644    (set_attr "mode" "SF,SF,V4SF")])
10645
10646 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
10647   [(set (match_operand:VF_256 0 "register_operand" "=x,x,x")
10648         (vec_select:VF_256
10649           (match_operand:VF_256 1 "nonimmediate_operand" "m,o,?x")
10650           (match_parallel 2 "avx_vbroadcast_operand"
10651             [(match_operand 3 "const_int_operand" "C,n,n")])))]
10652   "TARGET_AVX"
10653   "#"
10654   "&& reload_completed && (<MODE>mode != V4DFmode || !TARGET_AVX2)"
10655   [(set (match_dup 0) (vec_duplicate:VF_256 (match_dup 1)))]
10656 {
10657   rtx op0 = operands[0], op1 = operands[1];
10658   int elt = INTVAL (operands[3]);
10659
10660   if (REG_P (op1))
10661     {
10662       int mask;
10663
10664       if (TARGET_AVX2 && elt == 0)
10665         {
10666           emit_insn (gen_vec_dup<mode> (op0, gen_lowpart (<ssescalarmode>mode,
10667                                                           op1)));
10668           DONE;
10669         }
10670
10671       /* Shuffle element we care about into all elements of the 128-bit lane.
10672          The other lane gets shuffled too, but we don't care.  */
10673       if (<MODE>mode == V4DFmode)
10674         mask = (elt & 1 ? 15 : 0);
10675       else
10676         mask = (elt & 3) * 0x55;
10677       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
10678
10679       /* Shuffle the lane we care about into both lanes of the dest.  */
10680       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
10681       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
10682       DONE;
10683     }
10684
10685   operands[1] = adjust_address (op1, <ssescalarmode>mode,
10686                                 elt * GET_MODE_SIZE (<ssescalarmode>mode));
10687 })
10688
10689 (define_expand "avx_vpermil<mode>"
10690   [(set (match_operand:VF2 0 "register_operand")
10691         (vec_select:VF2
10692           (match_operand:VF2 1 "nonimmediate_operand")
10693           (match_operand:SI 2 "const_0_to_255_operand")))]
10694   "TARGET_AVX"
10695 {
10696   int mask = INTVAL (operands[2]);
10697   rtx perm[<ssescalarnum>];
10698
10699   perm[0] = GEN_INT (mask & 1);
10700   perm[1] = GEN_INT ((mask >> 1) & 1);
10701   if (<MODE>mode == V4DFmode)
10702     {
10703       perm[2] = GEN_INT (((mask >> 2) & 1) + 2);
10704       perm[3] = GEN_INT (((mask >> 3) & 1) + 2);
10705     }
10706
10707   operands[2]
10708     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
10709 })
10710
10711 (define_expand "avx_vpermil<mode>"
10712   [(set (match_operand:VF1 0 "register_operand")
10713         (vec_select:VF1
10714           (match_operand:VF1 1 "nonimmediate_operand")
10715           (match_operand:SI 2 "const_0_to_255_operand")))]
10716   "TARGET_AVX"
10717 {
10718   int mask = INTVAL (operands[2]);
10719   rtx perm[<ssescalarnum>];
10720
10721   perm[0] = GEN_INT (mask & 3);
10722   perm[1] = GEN_INT ((mask >> 2) & 3);
10723   perm[2] = GEN_INT ((mask >> 4) & 3);
10724   perm[3] = GEN_INT ((mask >> 6) & 3);
10725   if (<MODE>mode == V8SFmode)
10726     {
10727       perm[4] = GEN_INT ((mask & 3) + 4);
10728       perm[5] = GEN_INT (((mask >> 2) & 3) + 4);
10729       perm[6] = GEN_INT (((mask >> 4) & 3) + 4);
10730       perm[7] = GEN_INT (((mask >> 6) & 3) + 4);
10731     }
10732
10733   operands[2]
10734     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
10735 })
10736
10737 (define_insn "*avx_vpermilp<mode>"
10738   [(set (match_operand:VF 0 "register_operand" "=x")
10739         (vec_select:VF
10740           (match_operand:VF 1 "nonimmediate_operand" "xm")
10741           (match_parallel 2 ""
10742             [(match_operand 3 "const_int_operand")])))]
10743   "TARGET_AVX
10744    && avx_vpermilp_parallel (operands[2], <MODE>mode)"
10745 {
10746   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
10747   operands[2] = GEN_INT (mask);
10748   return "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}";
10749 }
10750   [(set_attr "type" "sselog")
10751    (set_attr "prefix_extra" "1")
10752    (set_attr "length_immediate" "1")
10753    (set_attr "prefix" "vex")
10754    (set_attr "mode" "<MODE>")])
10755
10756 (define_insn "avx_vpermilvar<mode>3"
10757   [(set (match_operand:VF 0 "register_operand" "=x")
10758         (unspec:VF
10759           [(match_operand:VF 1 "register_operand" "x")
10760            (match_operand:<sseintvecmode> 2 "nonimmediate_operand" "xm")]
10761           UNSPEC_VPERMIL))]
10762   "TARGET_AVX"
10763   "vpermil<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10764   [(set_attr "type" "sselog")
10765    (set_attr "prefix_extra" "1")
10766    (set_attr "prefix" "vex")
10767    (set_attr "btver2_decode" "vector")
10768    (set_attr "mode" "<MODE>")])
10769
10770 (define_expand "avx_vperm2f128<mode>3"
10771   [(set (match_operand:AVX256MODE2P 0 "register_operand")
10772         (unspec:AVX256MODE2P
10773           [(match_operand:AVX256MODE2P 1 "register_operand")
10774            (match_operand:AVX256MODE2P 2 "nonimmediate_operand")
10775            (match_operand:SI 3 "const_0_to_255_operand")]
10776           UNSPEC_VPERMIL2F128))]
10777   "TARGET_AVX"
10778 {
10779   int mask = INTVAL (operands[3]);
10780   if ((mask & 0x88) == 0)
10781     {
10782       rtx perm[<ssescalarnum>], t1, t2;
10783       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
10784
10785       base = (mask & 3) * nelt2;
10786       for (i = 0; i < nelt2; ++i)
10787         perm[i] = GEN_INT (base + i);
10788
10789       base = ((mask >> 4) & 3) * nelt2;
10790       for (i = 0; i < nelt2; ++i)
10791         perm[i + nelt2] = GEN_INT (base + i);
10792
10793       t2 = gen_rtx_VEC_CONCAT (<ssedoublevecmode>mode,
10794                                operands[1], operands[2]);
10795       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
10796       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
10797       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
10798       emit_insn (t2);
10799       DONE;
10800     }
10801 })
10802
10803 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
10804 ;; means that in order to represent this properly in rtl we'd have to
10805 ;; nest *another* vec_concat with a zero operand and do the select from
10806 ;; a 4x wide vector.  That doesn't seem very nice.
10807 (define_insn "*avx_vperm2f128<mode>_full"
10808   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
10809         (unspec:AVX256MODE2P
10810           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
10811            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
10812            (match_operand:SI 3 "const_0_to_255_operand" "n")]
10813           UNSPEC_VPERMIL2F128))]
10814   "TARGET_AVX"
10815   "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
10816   [(set_attr "type" "sselog")
10817    (set_attr "prefix_extra" "1")
10818    (set_attr "length_immediate" "1")
10819    (set_attr "prefix" "vex")
10820    (set_attr "mode" "<sseinsnmode>")])
10821
10822 (define_insn "*avx_vperm2f128<mode>_nozero"
10823   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
10824         (vec_select:AVX256MODE2P
10825           (vec_concat:<ssedoublevecmode>
10826             (match_operand:AVX256MODE2P 1 "register_operand" "x")
10827             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
10828           (match_parallel 3 ""
10829             [(match_operand 4 "const_int_operand")])))]
10830   "TARGET_AVX
10831    && avx_vperm2f128_parallel (operands[3], <MODE>mode)"
10832 {
10833   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
10834   if (mask == 0x12)
10835     return "vinsert<i128>\t{$0, %x2, %1, %0|%0, %1, %x2, 0}";
10836   if (mask == 0x20)
10837     return "vinsert<i128>\t{$1, %x2, %1, %0|%0, %1, %x2, 1}";
10838   operands[3] = GEN_INT (mask);
10839   return "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
10840 }
10841   [(set_attr "type" "sselog")
10842    (set_attr "prefix_extra" "1")
10843    (set_attr "length_immediate" "1")
10844    (set_attr "prefix" "vex")
10845    (set_attr "mode" "<sseinsnmode>")])
10846
10847 (define_expand "avx_vinsertf128<mode>"
10848   [(match_operand:V_256 0 "register_operand")
10849    (match_operand:V_256 1 "register_operand")
10850    (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand")
10851    (match_operand:SI 3 "const_0_to_1_operand")]
10852   "TARGET_AVX"
10853 {
10854   rtx (*insn)(rtx, rtx, rtx);
10855
10856   switch (INTVAL (operands[3]))
10857     {
10858     case 0:
10859       insn = gen_vec_set_lo_<mode>;
10860       break;
10861     case 1:
10862       insn = gen_vec_set_hi_<mode>;
10863       break;
10864     default:
10865       gcc_unreachable ();
10866     }
10867
10868   emit_insn (insn (operands[0], operands[1], operands[2]));
10869   DONE;
10870 })
10871
10872 (define_insn "avx2_vec_set_lo_v4di"
10873   [(set (match_operand:V4DI 0 "register_operand" "=x")
10874         (vec_concat:V4DI
10875           (match_operand:V2DI 2 "nonimmediate_operand" "xm")
10876           (vec_select:V2DI
10877             (match_operand:V4DI 1 "register_operand" "x")
10878             (parallel [(const_int 2) (const_int 3)]))))]
10879   "TARGET_AVX2"
10880   "vinserti128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
10881   [(set_attr "type" "sselog")
10882    (set_attr "prefix_extra" "1")
10883    (set_attr "length_immediate" "1")
10884    (set_attr "prefix" "vex")
10885    (set_attr "mode" "OI")])
10886
10887 (define_insn "avx2_vec_set_hi_v4di"
10888   [(set (match_operand:V4DI 0 "register_operand" "=x")
10889         (vec_concat:V4DI
10890           (vec_select:V2DI
10891             (match_operand:V4DI 1 "register_operand" "x")
10892             (parallel [(const_int 0) (const_int 1)]))
10893           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
10894   "TARGET_AVX2"
10895   "vinserti128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
10896   [(set_attr "type" "sselog")
10897    (set_attr "prefix_extra" "1")
10898    (set_attr "length_immediate" "1")
10899    (set_attr "prefix" "vex")
10900    (set_attr "mode" "OI")])
10901
10902 (define_insn "vec_set_lo_<mode>"
10903   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
10904         (vec_concat:VI8F_256
10905           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
10906           (vec_select:<ssehalfvecmode>
10907             (match_operand:VI8F_256 1 "register_operand" "x")
10908             (parallel [(const_int 2) (const_int 3)]))))]
10909   "TARGET_AVX"
10910   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
10911   [(set_attr "type" "sselog")
10912    (set_attr "prefix_extra" "1")
10913    (set_attr "length_immediate" "1")
10914    (set_attr "prefix" "vex")
10915    (set_attr "mode" "<sseinsnmode>")])
10916
10917 (define_insn "vec_set_hi_<mode>"
10918   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
10919         (vec_concat:VI8F_256
10920           (vec_select:<ssehalfvecmode>
10921             (match_operand:VI8F_256 1 "register_operand" "x")
10922             (parallel [(const_int 0) (const_int 1)]))
10923           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
10924   "TARGET_AVX"
10925   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
10926   [(set_attr "type" "sselog")
10927    (set_attr "prefix_extra" "1")
10928    (set_attr "length_immediate" "1")
10929    (set_attr "prefix" "vex")
10930    (set_attr "mode" "<sseinsnmode>")])
10931
10932 (define_insn "vec_set_lo_<mode>"
10933   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
10934         (vec_concat:VI4F_256
10935           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
10936           (vec_select:<ssehalfvecmode>
10937             (match_operand:VI4F_256 1 "register_operand" "x")
10938             (parallel [(const_int 4) (const_int 5)
10939                        (const_int 6) (const_int 7)]))))]
10940   "TARGET_AVX"
10941   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
10942   [(set_attr "type" "sselog")
10943    (set_attr "prefix_extra" "1")
10944    (set_attr "length_immediate" "1")
10945    (set_attr "prefix" "vex")
10946    (set_attr "mode" "<sseinsnmode>")])
10947
10948 (define_insn "vec_set_hi_<mode>"
10949   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
10950         (vec_concat:VI4F_256
10951           (vec_select:<ssehalfvecmode>
10952             (match_operand:VI4F_256 1 "register_operand" "x")
10953             (parallel [(const_int 0) (const_int 1)
10954                        (const_int 2) (const_int 3)]))
10955           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
10956   "TARGET_AVX"
10957   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
10958   [(set_attr "type" "sselog")
10959    (set_attr "prefix_extra" "1")
10960    (set_attr "length_immediate" "1")
10961    (set_attr "prefix" "vex")
10962    (set_attr "mode" "<sseinsnmode>")])
10963
10964 (define_insn "vec_set_lo_v16hi"
10965   [(set (match_operand:V16HI 0 "register_operand" "=x")
10966         (vec_concat:V16HI
10967           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
10968           (vec_select:V8HI
10969             (match_operand:V16HI 1 "register_operand" "x")
10970             (parallel [(const_int 8) (const_int 9)
10971                        (const_int 10) (const_int 11)
10972                        (const_int 12) (const_int 13)
10973                        (const_int 14) (const_int 15)]))))]
10974   "TARGET_AVX"
10975   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
10976   [(set_attr "type" "sselog")
10977    (set_attr "prefix_extra" "1")
10978    (set_attr "length_immediate" "1")
10979    (set_attr "prefix" "vex")
10980    (set_attr "mode" "OI")])
10981
10982 (define_insn "vec_set_hi_v16hi"
10983   [(set (match_operand:V16HI 0 "register_operand" "=x")
10984         (vec_concat:V16HI
10985           (vec_select:V8HI
10986             (match_operand:V16HI 1 "register_operand" "x")
10987             (parallel [(const_int 0) (const_int 1)
10988                        (const_int 2) (const_int 3)
10989                        (const_int 4) (const_int 5)
10990                        (const_int 6) (const_int 7)]))
10991           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
10992   "TARGET_AVX"
10993   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
10994   [(set_attr "type" "sselog")
10995    (set_attr "prefix_extra" "1")
10996    (set_attr "length_immediate" "1")
10997    (set_attr "prefix" "vex")
10998    (set_attr "mode" "OI")])
10999
11000 (define_insn "vec_set_lo_v32qi"
11001   [(set (match_operand:V32QI 0 "register_operand" "=x")
11002         (vec_concat:V32QI
11003           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
11004           (vec_select:V16QI
11005             (match_operand:V32QI 1 "register_operand" "x")
11006             (parallel [(const_int 16) (const_int 17)
11007                        (const_int 18) (const_int 19)
11008                        (const_int 20) (const_int 21)
11009                        (const_int 22) (const_int 23)
11010                        (const_int 24) (const_int 25)
11011                        (const_int 26) (const_int 27)
11012                        (const_int 28) (const_int 29)
11013                        (const_int 30) (const_int 31)]))))]
11014   "TARGET_AVX"
11015   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
11016   [(set_attr "type" "sselog")
11017    (set_attr "prefix_extra" "1")
11018    (set_attr "length_immediate" "1")
11019    (set_attr "prefix" "vex")
11020    (set_attr "mode" "OI")])
11021
11022 (define_insn "vec_set_hi_v32qi"
11023   [(set (match_operand:V32QI 0 "register_operand" "=x")
11024         (vec_concat:V32QI
11025           (vec_select:V16QI
11026             (match_operand:V32QI 1 "register_operand" "x")
11027             (parallel [(const_int 0) (const_int 1)
11028                        (const_int 2) (const_int 3)
11029                        (const_int 4) (const_int 5)
11030                        (const_int 6) (const_int 7)
11031                        (const_int 8) (const_int 9)
11032                        (const_int 10) (const_int 11)
11033                        (const_int 12) (const_int 13)
11034                        (const_int 14) (const_int 15)]))
11035           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
11036   "TARGET_AVX"
11037   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
11038   [(set_attr "type" "sselog")
11039    (set_attr "prefix_extra" "1")
11040    (set_attr "length_immediate" "1")
11041    (set_attr "prefix" "vex")
11042    (set_attr "mode" "OI")])
11043
11044 (define_insn "<avx_avx2>_maskload<ssemodesuffix><avxsizesuffix>"
11045   [(set (match_operand:V48_AVX2 0 "register_operand" "=x")
11046         (unspec:V48_AVX2
11047           [(match_operand:<sseintvecmode> 2 "register_operand" "x")
11048            (match_operand:V48_AVX2 1 "memory_operand" "m")]
11049           UNSPEC_MASKMOV))]
11050   "TARGET_AVX"
11051   "v<sseintprefix>maskmov<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
11052   [(set_attr "type" "sselog1")
11053    (set_attr "prefix_extra" "1")
11054    (set_attr "prefix" "vex")
11055    (set_attr "btver2_decode" "vector")
11056    (set_attr "mode" "<sseinsnmode>")])
11057
11058 (define_insn "<avx_avx2>_maskstore<ssemodesuffix><avxsizesuffix>"
11059   [(set (match_operand:V48_AVX2 0 "memory_operand" "+m")
11060         (unspec:V48_AVX2
11061           [(match_operand:<sseintvecmode> 1 "register_operand" "x")
11062            (match_operand:V48_AVX2 2 "register_operand" "x")
11063            (match_dup 0)]
11064           UNSPEC_MASKMOV))]
11065   "TARGET_AVX"
11066   "v<sseintprefix>maskmov<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11067   [(set_attr "type" "sselog1")
11068    (set_attr "prefix_extra" "1")
11069    (set_attr "prefix" "vex")
11070    (set_attr "btver2_decode" "vector")
11071    (set_attr "mode" "<sseinsnmode>")])
11072
11073 (define_insn_and_split "avx_<castmode><avxsizesuffix>_<castmode>"
11074   [(set (match_operand:AVX256MODE2P 0 "nonimmediate_operand" "=x,m")
11075         (unspec:AVX256MODE2P
11076           [(match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "xm,x")]
11077           UNSPEC_CAST))]
11078   "TARGET_AVX"
11079   "#"
11080   "&& reload_completed"
11081   [(const_int 0)]
11082 {
11083   rtx op0 = operands[0];
11084   rtx op1 = operands[1];
11085   if (REG_P (op0))
11086     op0 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op0));
11087   else
11088     op1 = gen_rtx_REG (<MODE>mode, REGNO (op1));
11089   emit_move_insn (op0, op1);
11090   DONE;
11091 })
11092
11093 (define_expand "vec_init<mode>"
11094   [(match_operand:V_256 0 "register_operand")
11095    (match_operand 1)]
11096   "TARGET_AVX"
11097 {
11098   ix86_expand_vector_init (false, operands[0], operands[1]);
11099   DONE;
11100 })
11101
11102 (define_expand "avx2_extracti128"
11103   [(match_operand:V2DI 0 "nonimmediate_operand")
11104    (match_operand:V4DI 1 "register_operand")
11105    (match_operand:SI 2 "const_0_to_1_operand")]
11106   "TARGET_AVX2"
11107 {
11108   rtx (*insn)(rtx, rtx);
11109
11110   switch (INTVAL (operands[2]))
11111     {
11112     case 0:
11113       insn = gen_vec_extract_lo_v4di;
11114       break;
11115     case 1:
11116       insn = gen_vec_extract_hi_v4di;
11117       break;
11118     default:
11119       gcc_unreachable ();
11120     }
11121
11122   emit_insn (insn (operands[0], operands[1]));
11123   DONE;
11124 })
11125
11126 (define_expand "avx2_inserti128"
11127   [(match_operand:V4DI 0 "register_operand")
11128    (match_operand:V4DI 1 "register_operand")
11129    (match_operand:V2DI 2 "nonimmediate_operand")
11130    (match_operand:SI 3 "const_0_to_1_operand")]
11131   "TARGET_AVX2"
11132 {
11133   rtx (*insn)(rtx, rtx, rtx);
11134
11135   switch (INTVAL (operands[3]))
11136     {
11137     case 0:
11138       insn = gen_avx2_vec_set_lo_v4di;
11139       break;
11140     case 1:
11141       insn = gen_avx2_vec_set_hi_v4di;
11142       break;
11143     default:
11144       gcc_unreachable ();
11145     }
11146
11147   emit_insn (insn (operands[0], operands[1], operands[2]));
11148   DONE;
11149 })
11150
11151 (define_insn "avx2_ashrv<mode>"
11152   [(set (match_operand:VI4_AVX2 0 "register_operand" "=x")
11153         (ashiftrt:VI4_AVX2
11154           (match_operand:VI4_AVX2 1 "register_operand" "x")
11155           (match_operand:VI4_AVX2 2 "nonimmediate_operand" "xm")))]
11156   "TARGET_AVX2"
11157   "vpsravd\t{%2, %1, %0|%0, %1, %2}"
11158   [(set_attr "type" "sseishft")
11159    (set_attr "prefix" "vex")
11160    (set_attr "mode" "<sseinsnmode>")])
11161
11162 (define_insn "avx2_<shift_insn>v<mode>"
11163   [(set (match_operand:VI48_AVX2 0 "register_operand" "=x")
11164         (any_lshift:VI48_AVX2
11165           (match_operand:VI48_AVX2 1 "register_operand" "x")
11166           (match_operand:VI48_AVX2 2 "nonimmediate_operand" "xm")))]
11167   "TARGET_AVX2"
11168   "vp<vshift>v<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11169   [(set_attr "type" "sseishft")
11170    (set_attr "prefix" "vex")
11171    (set_attr "mode" "<sseinsnmode>")])
11172
11173 (define_insn "avx_vec_concat<mode>"
11174   [(set (match_operand:V_256 0 "register_operand" "=x,x")
11175         (vec_concat:V_256
11176           (match_operand:<ssehalfvecmode> 1 "register_operand" "x,x")
11177           (match_operand:<ssehalfvecmode> 2 "vector_move_operand" "xm,C")))]
11178   "TARGET_AVX"
11179 {
11180   switch (which_alternative)
11181     {
11182     case 0:
11183       return "vinsert<i128>\t{$0x1, %2, %t1, %0|%0, %t1, %2, 0x1}";
11184     case 1:
11185       switch (get_attr_mode (insn))
11186         {
11187         case MODE_V8SF:
11188           return "vmovaps\t{%1, %x0|%x0, %1}";
11189         case MODE_V4DF:
11190           return "vmovapd\t{%1, %x0|%x0, %1}";
11191         default:
11192           return "vmovdqa\t{%1, %x0|%x0, %1}";
11193         }
11194     default:
11195       gcc_unreachable ();
11196     }
11197 }
11198   [(set_attr "type" "sselog,ssemov")
11199    (set_attr "prefix_extra" "1,*")
11200    (set_attr "length_immediate" "1,*")
11201    (set_attr "prefix" "vex")
11202    (set_attr "mode" "<sseinsnmode>")])
11203
11204 (define_insn "vcvtph2ps"
11205   [(set (match_operand:V4SF 0 "register_operand" "=x")
11206         (vec_select:V4SF
11207           (unspec:V8SF [(match_operand:V8HI 1 "register_operand" "x")]
11208                        UNSPEC_VCVTPH2PS)
11209           (parallel [(const_int 0) (const_int 1)
11210                      (const_int 2) (const_int 3)])))]
11211   "TARGET_F16C"
11212   "vcvtph2ps\t{%1, %0|%0, %1}"
11213   [(set_attr "type" "ssecvt")
11214    (set_attr "prefix" "vex")
11215    (set_attr "mode" "V4SF")])
11216
11217 (define_insn "*vcvtph2ps_load"
11218   [(set (match_operand:V4SF 0 "register_operand" "=x")
11219         (unspec:V4SF [(match_operand:V4HI 1 "memory_operand" "m")]
11220                      UNSPEC_VCVTPH2PS))]
11221   "TARGET_F16C"
11222   "vcvtph2ps\t{%1, %0|%0, %1}"
11223   [(set_attr "type" "ssecvt")
11224    (set_attr "prefix" "vex")
11225    (set_attr "mode" "V8SF")])
11226
11227 (define_insn "vcvtph2ps256"
11228   [(set (match_operand:V8SF 0 "register_operand" "=x")
11229         (unspec:V8SF [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
11230                      UNSPEC_VCVTPH2PS))]
11231   "TARGET_F16C"
11232   "vcvtph2ps\t{%1, %0|%0, %1}"
11233   [(set_attr "type" "ssecvt")
11234    (set_attr "prefix" "vex")
11235    (set_attr "btver2_decode" "double")
11236    (set_attr "mode" "V8SF")])
11237
11238 (define_expand "vcvtps2ph"
11239   [(set (match_operand:V8HI 0 "register_operand")
11240         (vec_concat:V8HI
11241           (unspec:V4HI [(match_operand:V4SF 1 "register_operand")
11242                         (match_operand:SI 2 "const_0_to_255_operand")]
11243                        UNSPEC_VCVTPS2PH)
11244           (match_dup 3)))]
11245   "TARGET_F16C"
11246   "operands[3] = CONST0_RTX (V4HImode);")
11247
11248 (define_insn "*vcvtps2ph"
11249   [(set (match_operand:V8HI 0 "register_operand" "=x")
11250         (vec_concat:V8HI
11251           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
11252                         (match_operand:SI 2 "const_0_to_255_operand" "N")]
11253                        UNSPEC_VCVTPS2PH)
11254           (match_operand:V4HI 3 "const0_operand")))]
11255   "TARGET_F16C"
11256   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
11257   [(set_attr "type" "ssecvt")
11258    (set_attr "prefix" "vex")
11259    (set_attr "mode" "V4SF")])
11260
11261 (define_insn "*vcvtps2ph_store"
11262   [(set (match_operand:V4HI 0 "memory_operand" "=m")
11263         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
11264                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
11265                      UNSPEC_VCVTPS2PH))]
11266   "TARGET_F16C"
11267   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
11268   [(set_attr "type" "ssecvt")
11269    (set_attr "prefix" "vex")
11270    (set_attr "mode" "V4SF")])
11271
11272 (define_insn "vcvtps2ph256"
11273   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=xm")
11274         (unspec:V8HI [(match_operand:V8SF 1 "register_operand" "x")
11275                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
11276                      UNSPEC_VCVTPS2PH))]
11277   "TARGET_F16C"
11278   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
11279   [(set_attr "type" "ssecvt")
11280    (set_attr "prefix" "vex")
11281    (set_attr "btver2_decode" "vector")
11282    (set_attr "mode" "V8SF")])
11283
11284 ;; For gather* insn patterns
11285 (define_mode_iterator VEC_GATHER_MODE
11286                       [V2DI V2DF V4DI V4DF V4SI V4SF V8SI V8SF])
11287 (define_mode_attr VEC_GATHER_IDXSI
11288                       [(V2DI "V4SI") (V2DF "V4SI")
11289                        (V4DI "V4SI") (V4DF "V4SI")
11290                        (V4SI "V4SI") (V4SF "V4SI")
11291                        (V8SI "V8SI") (V8SF "V8SI")])
11292 (define_mode_attr VEC_GATHER_IDXDI
11293                       [(V2DI "V2DI") (V2DF "V2DI")
11294                        (V4DI "V4DI") (V4DF "V4DI")
11295                        (V4SI "V2DI") (V4SF "V2DI")
11296                        (V8SI "V4DI") (V8SF "V4DI")])
11297 (define_mode_attr VEC_GATHER_SRCDI
11298                       [(V2DI "V2DI") (V2DF "V2DF")
11299                        (V4DI "V4DI") (V4DF "V4DF")
11300                        (V4SI "V4SI") (V4SF "V4SF")
11301                        (V8SI "V4SI") (V8SF "V4SF")])
11302
11303 (define_expand "avx2_gathersi<mode>"
11304   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
11305                    (unspec:VEC_GATHER_MODE
11306                      [(match_operand:VEC_GATHER_MODE 1 "register_operand")
11307                       (mem:<ssescalarmode>
11308                         (match_par_dup 7
11309                           [(match_operand 2 "vsib_address_operand")
11310                            (match_operand:<VEC_GATHER_IDXSI>
11311                               3 "register_operand")
11312                            (match_operand:SI 5 "const1248_operand ")]))
11313                       (mem:BLK (scratch))
11314                       (match_operand:VEC_GATHER_MODE 4 "register_operand")]
11315                      UNSPEC_GATHER))
11316               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
11317   "TARGET_AVX2"
11318 {
11319   operands[7]
11320     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
11321                                         operands[5]), UNSPEC_VSIBADDR);
11322 })
11323
11324 (define_insn "*avx2_gathersi<mode>"
11325   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
11326         (unspec:VEC_GATHER_MODE
11327           [(match_operand:VEC_GATHER_MODE 2 "register_operand" "0")
11328            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
11329              [(unspec:P
11330                 [(match_operand:P 3 "vsib_address_operand" "p")
11331                  (match_operand:<VEC_GATHER_IDXSI> 4 "register_operand" "x")
11332                  (match_operand:SI 6 "const1248_operand" "n")]
11333                 UNSPEC_VSIBADDR)])
11334            (mem:BLK (scratch))
11335            (match_operand:VEC_GATHER_MODE 5 "register_operand" "1")]
11336           UNSPEC_GATHER))
11337    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
11338   "TARGET_AVX2"
11339   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %7, %0|%0, %7, %1}"
11340   [(set_attr "type" "ssemov")
11341    (set_attr "prefix" "vex")
11342    (set_attr "mode" "<sseinsnmode>")])
11343
11344 (define_insn "*avx2_gathersi<mode>_2"
11345   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
11346         (unspec:VEC_GATHER_MODE
11347           [(pc)
11348            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
11349              [(unspec:P
11350                 [(match_operand:P 2 "vsib_address_operand" "p")
11351                  (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand" "x")
11352                  (match_operand:SI 5 "const1248_operand" "n")]
11353                 UNSPEC_VSIBADDR)])
11354            (mem:BLK (scratch))
11355            (match_operand:VEC_GATHER_MODE 4 "register_operand" "1")]
11356           UNSPEC_GATHER))
11357    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
11358   "TARGET_AVX2"
11359   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %6, %0|%0, %6, %1}"
11360   [(set_attr "type" "ssemov")
11361    (set_attr "prefix" "vex")
11362    (set_attr "mode" "<sseinsnmode>")])
11363
11364 (define_expand "avx2_gatherdi<mode>"
11365   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
11366                    (unspec:VEC_GATHER_MODE
11367                      [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand")
11368                       (mem:<ssescalarmode>
11369                         (match_par_dup 7
11370                           [(match_operand 2 "vsib_address_operand")
11371                            (match_operand:<VEC_GATHER_IDXDI>
11372                               3 "register_operand")
11373                            (match_operand:SI 5 "const1248_operand ")]))
11374                       (mem:BLK (scratch))
11375                       (match_operand:<VEC_GATHER_SRCDI>
11376                         4 "register_operand")]
11377                      UNSPEC_GATHER))
11378               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
11379   "TARGET_AVX2"
11380 {
11381   operands[7]
11382     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
11383                                         operands[5]), UNSPEC_VSIBADDR);
11384 })
11385
11386 (define_insn "*avx2_gatherdi<mode>"
11387   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
11388         (unspec:VEC_GATHER_MODE
11389           [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
11390            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
11391              [(unspec:P
11392                 [(match_operand:P 3 "vsib_address_operand" "p")
11393                  (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
11394                  (match_operand:SI 6 "const1248_operand" "n")]
11395                 UNSPEC_VSIBADDR)])
11396            (mem:BLK (scratch))
11397            (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
11398           UNSPEC_GATHER))
11399    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
11400   "TARGET_AVX2"
11401   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %2|%2, %7, %5}"
11402   [(set_attr "type" "ssemov")
11403    (set_attr "prefix" "vex")
11404    (set_attr "mode" "<sseinsnmode>")])
11405
11406 (define_insn "*avx2_gatherdi<mode>_2"
11407   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
11408         (unspec:VEC_GATHER_MODE
11409           [(pc)
11410            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
11411              [(unspec:P
11412                 [(match_operand:P 2 "vsib_address_operand" "p")
11413                  (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
11414                  (match_operand:SI 5 "const1248_operand" "n")]
11415                 UNSPEC_VSIBADDR)])
11416            (mem:BLK (scratch))
11417            (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
11418           UNSPEC_GATHER))
11419    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
11420   "TARGET_AVX2"
11421 {
11422   if (<MODE>mode != <VEC_GATHER_SRCDI>mode)
11423     return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %x0|%x0, %6, %4}";
11424   return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}";
11425 }
11426   [(set_attr "type" "ssemov")
11427    (set_attr "prefix" "vex")
11428    (set_attr "mode" "<sseinsnmode>")])
11429
11430 (define_insn "*avx2_gatherdi<mode>_3"
11431   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
11432         (vec_select:<VEC_GATHER_SRCDI>
11433           (unspec:VI4F_256
11434             [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
11435              (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
11436                [(unspec:P
11437                   [(match_operand:P 3 "vsib_address_operand" "p")
11438                    (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
11439                    (match_operand:SI 6 "const1248_operand" "n")]
11440                   UNSPEC_VSIBADDR)])
11441              (mem:BLK (scratch))
11442              (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
11443              UNSPEC_GATHER)
11444           (parallel [(const_int 0) (const_int 1)
11445                      (const_int 2) (const_int 3)])))
11446    (clobber (match_scratch:VI4F_256 1 "=&x"))]
11447   "TARGET_AVX2"
11448   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %0|%0, %7, %5}"
11449   [(set_attr "type" "ssemov")
11450    (set_attr "prefix" "vex")
11451    (set_attr "mode" "<sseinsnmode>")])
11452
11453 (define_insn "*avx2_gatherdi<mode>_4"
11454   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
11455         (vec_select:<VEC_GATHER_SRCDI>
11456           (unspec:VI4F_256
11457             [(pc)
11458              (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
11459                [(unspec:P
11460                   [(match_operand:P 2 "vsib_address_operand" "p")
11461                    (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
11462                    (match_operand:SI 5 "const1248_operand" "n")]
11463                   UNSPEC_VSIBADDR)])
11464              (mem:BLK (scratch))
11465              (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
11466             UNSPEC_GATHER)
11467           (parallel [(const_int 0) (const_int 1)
11468                      (const_int 2) (const_int 3)])))
11469    (clobber (match_scratch:VI4F_256 1 "=&x"))]
11470   "TARGET_AVX2"
11471   "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}"
11472   [(set_attr "type" "ssemov")
11473    (set_attr "prefix" "vex")
11474    (set_attr "mode" "<sseinsnmode>")])