gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005-2014 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   ;; For AVX512F support
  88   UNSPEC_VPERMI2
  89   UNSPEC_VPERMT2
  90   UNSPEC_VPERMI2_MASK
  91   UNSPEC_UNSIGNED_FIX_NOTRUNC
  92   UNSPEC_UNSIGNED_PCMP
  93   UNSPEC_TESTM
  94   UNSPEC_TESTNM
  95   UNSPEC_SCATTER
  96   UNSPEC_RCP14
  97   UNSPEC_RSQRT14
  98   UNSPEC_FIXUPIMM
  99   UNSPEC_SCALEF
 100   UNSPEC_VTERNLOG
 101   UNSPEC_GETEXP
 102   UNSPEC_GETMANT
 103   UNSPEC_ALIGN
 104   UNSPEC_CONFLICT
 105   UNSPEC_COMPRESS
 106   UNSPEC_COMPRESS_STORE
 107   UNSPEC_EXPAND
 108   UNSPEC_MASKED_EQ
 109   UNSPEC_MASKED_GT
 110
 111   ;; For embed. rounding feature
 112   UNSPEC_EMBEDDED_ROUNDING
 113
 114   ;; For AVX512PF support
 115   UNSPEC_GATHER_PREFETCH
 116   UNSPEC_SCATTER_PREFETCH
 117
 118   ;; For AVX512ER support
 119   UNSPEC_EXP2
 120   UNSPEC_RCP28
 121   UNSPEC_RSQRT28
 122
 123   ;; For SHA support
 124   UNSPEC_SHA1MSG1
 125   UNSPEC_SHA1MSG2
 126   UNSPEC_SHA1NEXTE
 127   UNSPEC_SHA1RNDS4
 128   UNSPEC_SHA256MSG1
 129   UNSPEC_SHA256MSG2
 130   UNSPEC_SHA256RNDS2
 131 ])
 132
 133 (define_c_enum "unspecv" [
 134   UNSPECV_LDMXCSR
 135   UNSPECV_STMXCSR
 136   UNSPECV_CLFLUSH
 137   UNSPECV_MONITOR
 138   UNSPECV_MWAIT
 139   UNSPECV_VZEROALL
 140   UNSPECV_VZEROUPPER
 141 ])
 142
 143 ;; All vector modes including V?TImode, used in move patterns.
 144 (define_mode_iterator VMOVE
 145   [(V64QI "TARGET_AVX512F") (V32QI "TARGET_AVX") V16QI
 146    (V32HI "TARGET_AVX512F") (V16HI "TARGET_AVX") V8HI
 147    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX") V4SI
 148    (V8DI "TARGET_AVX512F")  (V4DI "TARGET_AVX") V2DI
 149    (V2TI "TARGET_AVX") V1TI
 150    (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
 151    (V8DF "TARGET_AVX512F")  (V4DF "TARGET_AVX") V2DF])
 152
 153 ;; All vector modes
 154 (define_mode_iterator V
 155   [(V32QI "TARGET_AVX") V16QI
 156    (V16HI "TARGET_AVX") V8HI
 157    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX") V4SI
 158    (V8DI "TARGET_AVX512F")  (V4DI "TARGET_AVX") V2DI
 159    (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
 160    (V8DF "TARGET_AVX512F")  (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 161
 162 ;; All 128bit vector modes
 163 (define_mode_iterator V_128
 164   [V16QI V8HI V4SI V2DI V4SF (V2DF "TARGET_SSE2")])
 165
 166 ;; All 256bit vector modes
 167 (define_mode_iterator V_256
 168   [V32QI V16HI V8SI V4DI V8SF V4DF])
 169
 170 ;; All 512bit vector modes
 171 (define_mode_iterator V_512 [V64QI V32HI V16SI V8DI V16SF V8DF])
 172
 173 ;; All 256bit and 512bit vector modes
 174 (define_mode_iterator V_256_512
 175   [V32QI V16HI V8SI V4DI V8SF V4DF
 176    (V64QI "TARGET_AVX512F") (V32HI "TARGET_AVX512F") (V16SI "TARGET_AVX512F")
 177    (V8DI "TARGET_AVX512F") (V16SF "TARGET_AVX512F") (V8DF "TARGET_AVX512F")])
 178
 179 ;; All vector float modes
 180 (define_mode_iterator VF
 181   [(V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
 182    (V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 183
 184 ;; 128- and 256-bit float vector modes
 185 (define_mode_iterator VF_128_256
 186   [(V8SF "TARGET_AVX") V4SF
 187    (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
 188
 189 ;; All SFmode vector float modes
 190 (define_mode_iterator VF1
 191   [(V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF])
 192
 193 ;; 128- and 256-bit SF vector modes
 194 (define_mode_iterator VF1_128_256
 195   [(V8SF "TARGET_AVX") V4SF])
 196
 197 ;; All DFmode vector float modes
 198 (define_mode_iterator VF2
 199   [(V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") V2DF])
 200
 201 ;; 128- and 256-bit DF vector modes
 202 (define_mode_iterator VF2_128_256
 203   [(V4DF "TARGET_AVX") V2DF])
 204
 205 (define_mode_iterator VF2_512_256
 206   [(V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX")])
 207
 208 ;; All 128bit vector float modes
 209 (define_mode_iterator VF_128
 210   [V4SF (V2DF "TARGET_SSE2")])
 211
 212 ;; All 256bit vector float modes
 213 (define_mode_iterator VF_256
 214   [V8SF V4DF])
 215
 216 ;; All 512bit vector float modes
 217 (define_mode_iterator VF_512
 218   [V16SF V8DF])
 219
 220 ;; All vector integer modes
 221 (define_mode_iterator VI
 222   [(V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")
 223    (V32QI "TARGET_AVX") V16QI
 224    (V16HI "TARGET_AVX") V8HI
 225    (V8SI "TARGET_AVX") V4SI
 226    (V4DI "TARGET_AVX") V2DI])
 227
 228 (define_mode_iterator VI_AVX2
 229   [(V32QI "TARGET_AVX2") V16QI
 230    (V16HI "TARGET_AVX2") V8HI
 231    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI
 232    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX2") V2DI])
 233
 234 ;; All QImode vector integer modes
 235 (define_mode_iterator VI1
 236   [(V32QI "TARGET_AVX") V16QI])
 237
 238 (define_mode_iterator VI_UNALIGNED_LOADSTORE
 239   [(V32QI "TARGET_AVX") V16QI
 240    (V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")])
 241
 242 ;; All DImode vector integer modes
 243 (define_mode_iterator VI8
 244   [(V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX") V2DI])
 245
 246 (define_mode_iterator VI1_AVX2
 247   [(V32QI "TARGET_AVX2") V16QI])
 248
 249 (define_mode_iterator VI2_AVX2
 250   [(V16HI "TARGET_AVX2") V8HI])
 251
 252 (define_mode_iterator VI2_AVX512F
 253   [(V32HI "TARGET_AVX512F") (V16HI "TARGET_AVX2") V8HI])
 254
 255 (define_mode_iterator VI4_AVX
 256   [(V8SI "TARGET_AVX") V4SI])
 257
 258 (define_mode_iterator VI4_AVX2
 259   [(V8SI "TARGET_AVX2") V4SI])
 260
 261 (define_mode_iterator VI4_AVX512F
 262   [(V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI])
 263
 264 (define_mode_iterator VI48_AVX512F
 265   [(V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI
 266    (V8DI "TARGET_AVX512F")])
 267
 268 (define_mode_iterator VI8_AVX2
 269   [(V4DI "TARGET_AVX2") V2DI])
 270
 271 (define_mode_iterator VI8_AVX2_AVX512F
 272   [(V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX2") V2DI])
 273
 274 ;; All V8D* modes
 275 (define_mode_iterator V8FI
 276   [V8DF V8DI])
 277
 278 ;; All V16S* modes
 279 (define_mode_iterator V16FI
 280   [V16SF V16SI])
 281
 282 ;; ??? We should probably use TImode instead.
 283 (define_mode_iterator VIMAX_AVX2
 284   [(V2TI "TARGET_AVX2") V1TI])
 285
 286 ;; ??? This should probably be dropped in favor of VIMAX_AVX2.
 287 (define_mode_iterator SSESCALARMODE
 288   [(V2TI "TARGET_AVX2") TI])
 289
 290 (define_mode_iterator VI12_AVX2
 291   [(V32QI "TARGET_AVX2") V16QI
 292    (V16HI "TARGET_AVX2") V8HI])
 293
 294 (define_mode_iterator VI24_AVX2
 295   [(V16HI "TARGET_AVX2") V8HI
 296    (V8SI "TARGET_AVX2") V4SI])
 297
 298 (define_mode_iterator VI124_AVX2_48_AVX512F
 299   [(V32QI "TARGET_AVX2") V16QI
 300    (V16HI "TARGET_AVX2") V8HI
 301    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI
 302    (V8DI "TARGET_AVX512F")])
 303
 304 (define_mode_iterator VI124_AVX512F
 305   [(V32QI "TARGET_AVX2") V16QI
 306    (V32HI "TARGET_AVX512F") (V16HI "TARGET_AVX2") V8HI
 307    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI])
 308
 309 (define_mode_iterator VI124_AVX2
 310   [(V32QI "TARGET_AVX2") V16QI
 311    (V16HI "TARGET_AVX2") V8HI
 312    (V8SI "TARGET_AVX2") V4SI])
 313
 314 (define_mode_iterator VI248_AVX2
 315   [(V16HI "TARGET_AVX2") V8HI
 316    (V8SI "TARGET_AVX2") V4SI
 317    (V4DI "TARGET_AVX2") V2DI])
 318
 319 (define_mode_iterator VI248_AVX2_8_AVX512F
 320   [(V16HI "TARGET_AVX2") V8HI
 321    (V8SI "TARGET_AVX2") V4SI
 322    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX2") V2DI])
 323
 324 (define_mode_iterator VI48_AVX2_48_AVX512F
 325   [(V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX2") V4SI
 326    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX2") V2DI])
 327
 328 (define_mode_iterator V48_AVX2
 329   [V4SF V2DF
 330    V8SF V4DF
 331    (V4SI "TARGET_AVX2") (V2DI "TARGET_AVX2")
 332    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")])
 333
 334 (define_mode_attr sse2_avx_avx512f
 335   [(V16QI "sse2") (V32QI "avx") (V64QI "avx512f")
 336    (V4SI  "sse2") (V8SI  "avx") (V16SI "avx512f")
 337    (V8DI "avx512f")
 338    (V16SF "avx512f") (V8SF "avx") (V4SF "avx")
 339    (V8DF "avx512f") (V4DF "avx") (V2DF "avx")])
 340
 341 (define_mode_attr sse2_avx2
 342   [(V16QI "sse2") (V32QI "avx2")
 343    (V8HI "sse2") (V16HI "avx2")
 344    (V4SI "sse2") (V8SI "avx2") (V16SI "avx512f")
 345    (V2DI "sse2") (V4DI "avx2") (V8DI "avx512f")
 346    (V1TI "sse2") (V2TI "avx2")])
 347
 348 (define_mode_attr ssse3_avx2
 349    [(V16QI "ssse3") (V32QI "avx2")
 350     (V4HI "ssse3") (V8HI "ssse3") (V16HI "avx2")
 351     (V4SI "ssse3") (V8SI "avx2")
 352     (V2DI "ssse3") (V4DI "avx2")
 353     (TI "ssse3") (V2TI "avx2")])
 354
 355 (define_mode_attr sse4_1_avx2
 356    [(V16QI "sse4_1") (V32QI "avx2")
 357     (V8HI "sse4_1") (V16HI "avx2")
 358     (V4SI "sse4_1") (V8SI "avx2") (V16SI "avx512f")
 359     (V2DI "sse4_1") (V4DI "avx2") (V8DI "avx512f")])
 360
 361 (define_mode_attr avx_avx2
 362   [(V4SF "avx") (V2DF "avx")
 363    (V8SF "avx") (V4DF "avx")
 364    (V4SI "avx2") (V2DI "avx2")
 365    (V8SI "avx2") (V4DI "avx2")])
 366
 367 (define_mode_attr vec_avx2
 368   [(V16QI "vec") (V32QI "avx2")
 369    (V8HI "vec") (V16HI "avx2")
 370    (V4SI "vec") (V8SI "avx2")
 371    (V2DI "vec") (V4DI "avx2")])
 372
 373 (define_mode_attr avx2_avx512f
 374   [(V4SI "avx2") (V8SI "avx2") (V16SI "avx512f")
 375    (V2DI "avx2") (V4DI "avx2") (V8DI "avx512f")
 376    (V8SF "avx2") (V16SF "avx512f")
 377    (V4DF "avx2") (V8DF "avx512f")])
 378
 379 (define_mode_attr shuffletype
 380   [(V16SF "f") (V16SI "i") (V8DF "f") (V8DI "i")
 381   (V8SF "f") (V8SI "i") (V4DF "f") (V4DI "i")
 382   (V4SF "f") (V4SI "i") (V2DF "f") (V2DI "i")
 383   (V32QI "i") (V16HI "u") (V16QI "i") (V8HI "i")
 384   (V64QI "i") (V1TI "i") (V2TI "i")])
 385
 386 (define_mode_attr ssequartermode
 387   [(V16SF "V4SF") (V8DF "V2DF") (V16SI "V4SI") (V8DI "V2DI")])
 388
 389 (define_mode_attr ssedoublemode
 390   [(V16SF "V32SF") (V16SI "V32SI") (V8DI "V16DI") (V8DF "V16DF")
 391    (V16HI "V16SI") (V8HI "V8SI") (V4HI "V4SI")
 392    (V32QI "V32HI") (V16QI "V16HI")])
 393
 394 (define_mode_attr ssebytemode
 395   [(V4DI "V32QI") (V2DI "V16QI")])
 396
 397 ;; All 128bit vector integer modes
 398 (define_mode_iterator VI_128 [V16QI V8HI V4SI V2DI])
 399
 400 ;; All 256bit vector integer modes
 401 (define_mode_iterator VI_256 [V32QI V16HI V8SI V4DI])
 402
 403 ;; All 512bit vector integer modes
 404 (define_mode_iterator VI_512 [V64QI V32HI V16SI V8DI])
 405
 406 ;; Various 128bit vector integer mode combinations
 407 (define_mode_iterator VI12_128 [V16QI V8HI])
 408 (define_mode_iterator VI14_128 [V16QI V4SI])
 409 (define_mode_iterator VI124_128 [V16QI V8HI V4SI])
 410 (define_mode_iterator VI128_128 [V16QI V8HI V2DI])
 411 (define_mode_iterator VI24_128 [V8HI V4SI])
 412 (define_mode_iterator VI248_128 [V8HI V4SI V2DI])
 413 (define_mode_iterator VI48_128 [V4SI V2DI])
 414
 415 ;; Various 256bit and 512 vector integer mode combinations
 416 (define_mode_iterator VI124_256_48_512
 417   [V32QI V16HI V8SI (V8DI "TARGET_AVX512F") (V16SI "TARGET_AVX512F")])
 418 (define_mode_iterator VI48_256 [V8SI V4DI])
 419 (define_mode_iterator VI48_512 [V16SI V8DI])
 420 (define_mode_iterator VI4_256_8_512 [V8SI V8DI])
 421
 422 ;; Int-float size matches
 423 (define_mode_iterator VI4F_128 [V4SI V4SF])
 424 (define_mode_iterator VI8F_128 [V2DI V2DF])
 425 (define_mode_iterator VI4F_256 [V8SI V8SF])
 426 (define_mode_iterator VI8F_256 [V4DI V4DF])
 427 (define_mode_iterator VI8F_256_512
 428   [V4DI V4DF (V8DI "TARGET_AVX512F") (V8DF "TARGET_AVX512F")])
 429 (define_mode_iterator VI48F_256_512
 430   [V8SI V8SF
 431   (V16SI "TARGET_AVX512F") (V16SF "TARGET_AVX512F")
 432   (V8DI  "TARGET_AVX512F") (V8DF  "TARGET_AVX512F")])
 433 (define_mode_iterator VI48F_512 [V16SI V16SF V8DI V8DF])
 434
 435 ;; Mapping from float mode to required SSE level
 436 (define_mode_attr sse
 437   [(SF "sse") (DF "sse2")
 438    (V4SF "sse") (V2DF "sse2")
 439    (V16SF "avx512f") (V8SF "avx")
 440    (V8DF "avx512f") (V4DF "avx")])
 441
 442 (define_mode_attr sse2
 443   [(V16QI "sse2") (V32QI "avx") (V64QI "avx512f")
 444    (V2DI "sse2") (V4DI "avx") (V8DI "avx512f")])
 445
 446 (define_mode_attr sse3
 447   [(V16QI "sse3") (V32QI "avx")])
 448
 449 (define_mode_attr sse4_1
 450   [(V4SF "sse4_1") (V2DF "sse4_1")
 451    (V8SF "avx") (V4DF "avx")
 452    (V8DF "avx512f")])
 453
 454 (define_mode_attr avxsizesuffix
 455   [(V64QI "512") (V32HI "512") (V16SI "512") (V8DI "512")
 456    (V32QI "256") (V16HI "256") (V8SI "256") (V4DI "256")
 457    (V16QI "") (V8HI "") (V4SI "") (V2DI "")
 458    (V16SF "512") (V8DF "512")
 459    (V8SF "256") (V4DF "256")
 460    (V4SF "") (V2DF "")])
 461
 462 ;; SSE instruction mode
 463 (define_mode_attr sseinsnmode
 464   [(V64QI "XI") (V32HI "XI") (V16SI "XI") (V8DI "XI")
 465    (V32QI "OI") (V16HI "OI") (V8SI "OI") (V4DI "OI") (V2TI "OI")
 466    (V16QI "TI") (V8HI "TI") (V4SI "TI") (V2DI "TI") (V1TI "TI")
 467    (V16SF "V16SF") (V8DF "V8DF")
 468    (V8SF "V8SF") (V4DF "V4DF")
 469    (V4SF "V4SF") (V2DF "V2DF")
 470    (TI "TI")])
 471
 472 ;; Mapping of vector modes to corresponding mask size
 473 (define_mode_attr avx512fmaskmode
 474   [(V16QI "HI")
 475    (V16HI "HI") (V8HI  "QI")
 476    (V16SI "HI") (V8SI  "QI") (V4SI  "QI")
 477    (V8DI  "QI") (V4DI  "QI") (V2DI  "QI")
 478    (V16SF "HI") (V8SF  "QI") (V4SF  "QI")
 479    (V8DF  "QI") (V4DF  "QI") (V2DF  "QI")])
 480
 481 ;; Mapping of vector float modes to an integer mode of the same size
 482 (define_mode_attr sseintvecmode
 483   [(V16SF "V16SI") (V8DF  "V8DI")
 484    (V8SF  "V8SI")  (V4DF  "V4DI")
 485    (V4SF  "V4SI")  (V2DF  "V2DI")
 486    (V16SI "V16SI") (V8DI  "V8DI")
 487    (V8SI  "V8SI")  (V4DI  "V4DI")
 488    (V4SI  "V4SI")  (V2DI  "V2DI")
 489    (V16HI "V16HI") (V8HI  "V8HI")
 490    (V32QI "V32QI") (V16QI "V16QI")])
 491
 492 (define_mode_attr sseintvecmodelower
 493   [(V16SF "v16si")
 494    (V8SF "v8si") (V4DF "v4di")
 495    (V4SF "v4si") (V2DF "v2di")
 496    (V8SI "v8si") (V4DI "v4di")
 497    (V4SI "v4si") (V2DI "v2di")
 498    (V16HI "v16hi") (V8HI "v8hi")
 499    (V32QI "v32qi") (V16QI "v16qi")])
 500
 501 ;; Mapping of vector modes to a vector mode of double size
 502 (define_mode_attr ssedoublevecmode
 503   [(V32QI "V64QI") (V16HI "V32HI") (V8SI "V16SI") (V4DI "V8DI")
 504    (V16QI "V32QI") (V8HI "V16HI") (V4SI "V8SI") (V2DI "V4DI")
 505    (V8SF "V16SF") (V4DF "V8DF")
 506    (V4SF "V8SF") (V2DF "V4DF")])
 507
 508 ;; Mapping of vector modes to a vector mode of half size
 509 (define_mode_attr ssehalfvecmode
 510   [(V64QI "V32QI") (V32HI "V16HI") (V16SI "V8SI") (V8DI "V4DI")
 511    (V32QI "V16QI") (V16HI  "V8HI") (V8SI  "V4SI") (V4DI "V2DI")
 512    (V16QI  "V8QI") (V8HI   "V4HI") (V4SI  "V2SI")
 513    (V16SF "V8SF") (V8DF "V4DF")
 514    (V8SF  "V4SF") (V4DF "V2DF")
 515    (V4SF  "V2SF")])
 516
 517 ;; Mapping of vector modes ti packed single mode of the same size
 518 (define_mode_attr ssePSmode
 519   [(V16SI "V16SF") (V8DF "V16SF")
 520    (V16SF "V16SF") (V8DI "V16SF")
 521    (V64QI "V16SF") (V32QI "V8SF") (V16QI "V4SF")
 522    (V32HI "V16SF") (V16HI "V8SF") (V8HI "V4SF")
 523    (V8SI "V8SF") (V4SI "V4SF")
 524    (V4DI "V8SF") (V2DI "V4SF")
 525    (V2TI "V8SF") (V1TI "V4SF")
 526    (V8SF "V8SF") (V4SF "V4SF")
 527    (V4DF "V8SF") (V2DF "V4SF")])
 528
 529 ;; Mapping of vector modes back to the scalar modes
 530 (define_mode_attr ssescalarmode
 531   [(V64QI "QI") (V32QI "QI") (V16QI "QI")
 532    (V32HI "HI") (V16HI "HI") (V8HI "HI")
 533    (V16SI "SI") (V8SI "SI")  (V4SI "SI")
 534    (V8DI "DI")  (V4DI "DI")  (V2DI "DI")
 535    (V16SF "SF") (V8SF "SF")  (V4SF "SF")
 536    (V8DF "DF")  (V4DF "DF")  (V2DF "DF")])
 537
 538 ;; Mapping of vector modes to the 128bit modes
 539 (define_mode_attr ssexmmmode
 540   [(V64QI "V16QI") (V32QI "V16QI") (V16QI "V16QI")
 541    (V32HI "V8HI")  (V16HI "V8HI") (V8HI "V8HI")
 542    (V16SI "V4SI")  (V8SI "V4SI")  (V4SI "V4SI")
 543    (V8DI "V2DI")   (V4DI "V2DI")  (V2DI "V2DI")
 544    (V16SF "V4SF")  (V8SF "V4SF")  (V4SF "V4SF")
 545    (V8DF "V2DF")   (V4DF "V2DF")  (V2DF "V2DF")])
 546
 547 ;; Pointer size override for scalar modes (Intel asm dialect)
 548 (define_mode_attr iptr
 549   [(V32QI "b") (V16HI "w") (V8SI "k") (V4DI "q")
 550    (V16QI "b") (V8HI "w") (V4SI "k") (V2DI "q")
 551    (V8SF "k") (V4DF "q")
 552    (V4SF "k") (V2DF "q")
 553    (SF "k") (DF "q")])
 554
 555 ;; Number of scalar elements in each vector type
 556 (define_mode_attr ssescalarnum
 557   [(V64QI "64") (V16SI "16") (V8DI "8")
 558    (V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4")
 559    (V16QI "16") (V8HI "8") (V4SI "4") (V2DI "2")
 560    (V16SF "16") (V8DF "8")
 561    (V8SF "8") (V4DF "4")
 562    (V4SF "4") (V2DF "2")])
 563
 564 ;; Mask of scalar elements in each vector type
 565 (define_mode_attr ssescalarnummask
 566   [(V32QI "31") (V16HI "15") (V8SI "7") (V4DI "3")
 567    (V16QI "15") (V8HI "7") (V4SI "3") (V2DI "1")
 568    (V8SF "7") (V4DF "3")
 569    (V4SF "3") (V2DF "1")])
 570
 571 (define_mode_attr ssescalarsize
 572   [(V8DI  "64") (V4DI  "64") (V2DI  "64")
 573    (V32HI "16") (V16HI "16") (V8HI "16")
 574    (V16SI "32") (V8SI "32") (V4SI "32")
 575    (V16SF "32") (V8DF "64")])
 576
 577 ;; SSE prefix for integer vector modes
 578 (define_mode_attr sseintprefix
 579   [(V2DI  "p") (V2DF  "")
 580    (V4DI  "p") (V4DF  "")
 581    (V8DI  "p") (V8DF  "")
 582    (V4SI  "p") (V4SF  "")
 583    (V8SI  "p") (V8SF  "")
 584    (V16SI "p") (V16SF "")])
 585
 586 ;; SSE scalar suffix for vector modes
 587 (define_mode_attr ssescalarmodesuffix
 588   [(SF "ss") (DF "sd")
 589    (V8SF "ss") (V4DF "sd")
 590    (V4SF "ss") (V2DF "sd")
 591    (V8SI "ss") (V4DI "sd")
 592    (V4SI "d")])
 593
 594 ;; Pack/unpack vector modes
 595 (define_mode_attr sseunpackmode
 596   [(V16QI "V8HI") (V8HI "V4SI") (V4SI "V2DI")
 597    (V32QI "V16HI") (V16HI "V8SI") (V8SI "V4DI")
 598    (V32HI "V16SI") (V64QI "V32HI") (V16SI "V8DI")])
 599
 600 (define_mode_attr ssepackmode
 601   [(V8HI "V16QI") (V4SI "V8HI") (V2DI "V4SI")
 602    (V16HI "V32QI") (V8SI "V16HI") (V4DI "V8SI")
 603    (V32HI "V64QI") (V16SI "V32HI") (V8DI "V16SI")])
 604
 605 ;; Mapping of the max integer size for xop rotate immediate constraint
 606 (define_mode_attr sserotatemax
 607   [(V16QI "7") (V8HI "15") (V4SI "31") (V2DI "63")])
 608
 609 ;; Mapping of mode to cast intrinsic name
 610 (define_mode_attr castmode [(V8SI "si") (V8SF "ps") (V4DF "pd")])
 611
 612 ;; Instruction suffix for sign and zero extensions.
 613 (define_code_attr extsuffix [(sign_extend "sx") (zero_extend "zx")])
 614
 615 ;; i128 for integer vectors and TARGET_AVX2, f128 otherwise.
 616 ;; i64x4 or f64x4 for 512bit modes.
 617 (define_mode_attr i128
 618   [(V16SF "f64x4") (V8SF "f128") (V8DF "f64x4") (V4DF "f128")
 619    (V64QI "i64x4") (V32QI "%~128") (V32HI "i64x4") (V16HI "%~128")
 620    (V16SI "i64x4") (V8SI "%~128") (V8DI "i64x4") (V4DI "%~128")])
 621
 622 ;; Mix-n-match
 623 (define_mode_iterator AVX256MODE2P [V8SI V8SF V4DF])
 624
 625 ;; Mapping of immediate bits for blend instructions
 626 (define_mode_attr blendbits
 627   [(V8SF "255") (V4SF "15") (V4DF "15") (V2DF "3")])
 628
 629 ;; Mapping suffixes for broadcast
 630 (define_mode_attr bcstscalarsuff
 631   [(V16SI "d") (V16SF "ss") (V8DI "q") (V8DF "sd")])
 632
 633 ;; Include define_subst patterns for instructions with mask
 634 (include "subst.md")
 635
 636 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
 637
 638 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 639 ;;
 640 ;; Move patterns
 641 ;;
 642 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 643
 644 ;; All of these patterns are enabled for SSE1 as well as SSE2.
 645 ;; This is essential for maintaining stable calling conventions.
 646
 647 (define_expand "mov<mode>"
 648   [(set (match_operand:VMOVE 0 "nonimmediate_operand")
 649         (match_operand:VMOVE 1 "nonimmediate_operand"))]
 650   "TARGET_SSE"
 651 {
 652   ix86_expand_vector_move (<MODE>mode, operands);
 653   DONE;
 654 })
 655
 656 (define_insn "*mov<mode>_internal"
 657   [(set (match_operand:VMOVE 0 "nonimmediate_operand"               "=v,v ,m")
 658         (match_operand:VMOVE 1 "nonimmediate_or_sse_const_operand"  "C ,vm,v"))]
 659   "TARGET_SSE
 660    && (register_operand (operands[0], <MODE>mode)
 661        || register_operand (operands[1], <MODE>mode))"
 662 {
 663   int mode = get_attr_mode (insn);
 664   switch (which_alternative)
 665     {
 666     case 0:
 667       return standard_sse_constant_opcode (insn, operands[1]);
 668     case 1:
 669     case 2:
 670       /* There is no evex-encoded vmov* for sizes smaller than 64-bytes
 671          in avx512f, so we need to use workarounds, to access sse registers
 672          16-31, which are evex-only.  */
 673       if (TARGET_AVX512F && <MODE_SIZE> < 64
 674           && ((REG_P (operands[0])
 675                && EXT_REX_SSE_REGNO_P (REGNO (operands[0])))
 676               || (REG_P (operands[1])
 677                   && EXT_REX_SSE_REGNO_P (REGNO (operands[1])))))
 678         {
 679           if (memory_operand (operands[0], <MODE>mode))
 680             {
 681               if (<MODE_SIZE> == 32)
 682                 return "vextract<shuffletype>64x4\t{$0x0, %g1, %0|%0, %g1, 0x0}";
 683               else if (<MODE_SIZE> == 16)
 684                 return "vextract<shuffletype>32x4\t{$0x0, %g1, %0|%0, %g1, 0x0}";
 685               else
 686                 gcc_unreachable ();
 687             }
 688           else if (memory_operand (operands[1], <MODE>mode))
 689             {
 690               if (<MODE_SIZE> == 32)
 691                 return "vbroadcast<shuffletype>64x4\t{%1, %g0|%g0, %1}";
 692               else if (<MODE_SIZE> == 16)
 693                 return "vbroadcast<shuffletype>32x4\t{%1, %g0|%g0, %1}";
 694               else
 695                 gcc_unreachable ();
 696             }
 697           else
 698             /* Reg -> reg move is always aligned.  Just use wider move.  */
 699             switch (mode)
 700               {
 701               case MODE_V8SF:
 702               case MODE_V4SF:
 703                 return "vmovaps\t{%g1, %g0|%g0, %g1}";
 704               case MODE_V4DF:
 705               case MODE_V2DF:
 706                 return "vmovapd\t{%g1, %g0|%g0, %g1}";
 707               case MODE_OI:
 708               case MODE_TI:
 709                 return "vmovdqa64\t{%g1, %g0|%g0, %g1}";
 710               default:
 711                 gcc_unreachable ();
 712               }
 713         }
 714       switch (mode)
 715         {
 716         case MODE_V16SF:
 717         case MODE_V8SF:
 718         case MODE_V4SF:
 719           if (TARGET_AVX
 720               && (misaligned_operand (operands[0], <MODE>mode)
 721                   || misaligned_operand (operands[1], <MODE>mode)))
 722             return "vmovups\t{%1, %0|%0, %1}";
 723           else
 724             return "%vmovaps\t{%1, %0|%0, %1}";
 725
 726         case MODE_V8DF:
 727         case MODE_V4DF:
 728         case MODE_V2DF:
 729           if (TARGET_AVX
 730               && (misaligned_operand (operands[0], <MODE>mode)
 731                   || misaligned_operand (operands[1], <MODE>mode)))
 732             return "vmovupd\t{%1, %0|%0, %1}";
 733           else
 734             return "%vmovapd\t{%1, %0|%0, %1}";
 735
 736         case MODE_OI:
 737         case MODE_TI:
 738           if (TARGET_AVX
 739               && (misaligned_operand (operands[0], <MODE>mode)
 740                   || misaligned_operand (operands[1], <MODE>mode)))
 741             return "vmovdqu\t{%1, %0|%0, %1}";
 742           else
 743             return "%vmovdqa\t{%1, %0|%0, %1}";
 744         case MODE_XI:
 745           if (misaligned_operand (operands[0], <MODE>mode)
 746               || misaligned_operand (operands[1], <MODE>mode))
 747             return "vmovdqu64\t{%1, %0|%0, %1}";
 748           else
 749             return "vmovdqa64\t{%1, %0|%0, %1}";
 750
 751         default:
 752           gcc_unreachable ();
 753         }
 754     default:
 755       gcc_unreachable ();
 756     }
 757 }
 758   [(set_attr "type" "sselog1,ssemov,ssemov")
 759    (set_attr "prefix" "maybe_vex")
 760    (set (attr "mode")
 761         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 762                  (const_string "<ssePSmode>")
 763                (and (match_test "<MODE_SIZE> == 16")
 764                     (and (eq_attr "alternative" "2")
 765                          (match_test "TARGET_SSE_TYPELESS_STORES")))
 766                  (const_string "<ssePSmode>")
 767                (match_test "TARGET_AVX")
 768                  (const_string "<sseinsnmode>")
 769                (ior (not (match_test "TARGET_SSE2"))
 770                     (match_test "optimize_function_for_size_p (cfun)"))
 771                  (const_string "V4SF")
 772                (and (eq_attr "alternative" "0")
 773                     (match_test "TARGET_SSE_LOAD0_BY_PXOR"))
 774                  (const_string "TI")
 775               ]
 776               (const_string "<sseinsnmode>")))])
 777
 778 (define_insn "avx512f_load<mode>_mask"
 779   [(set (match_operand:VI48F_512 0 "register_operand" "=v,v")
 780         (vec_merge:VI48F_512
 781           (match_operand:VI48F_512 1 "nonimmediate_operand" "v,m")
 782           (match_operand:VI48F_512 2 "vector_move_operand" "0C,0C")
 783           (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk,Yk")))]
 784   "TARGET_AVX512F"
 785 {
 786   switch (MODE_<sseinsnmode>)
 787     {
 788     case MODE_V8DF:
 789     case MODE_V16SF:
 790       if (misaligned_operand (operands[1], <MODE>mode))
 791         return "vmovu<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}";
 792       return "vmova<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}";
 793     default:
 794       if (misaligned_operand (operands[1], <MODE>mode))
 795         return "vmovdqu<ssescalarsize>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}";
 796       return "vmovdqa<ssescalarsize>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}";
 797     }
 798 }
 799   [(set_attr "type" "ssemov")
 800    (set_attr "prefix" "evex")
 801    (set_attr "memory" "none,load")
 802    (set_attr "mode" "<sseinsnmode>")])
 803
 804 (define_insn "avx512f_blendm<mode>"
 805   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
 806         (vec_merge:VI48F_512
 807           (match_operand:VI48F_512 2 "nonimmediate_operand" "vm")
 808           (match_operand:VI48F_512 1 "register_operand" "v")
 809           (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk")))]
 810   "TARGET_AVX512F"
 811   "v<sseintprefix>blendm<ssemodesuffix>\t{%2, %1, %0%{%3%}|%0%{%3%}, %1, %2}"
 812   [(set_attr "type" "ssemov")
 813    (set_attr "prefix" "evex")
 814    (set_attr "mode" "<sseinsnmode>")])
 815
 816 (define_insn "avx512f_store<mode>_mask"
 817   [(set (match_operand:VI48F_512 0 "memory_operand" "=m")
 818         (vec_merge:VI48F_512
 819           (match_operand:VI48F_512 1 "register_operand" "v")
 820           (match_dup 0)
 821           (match_operand:<avx512fmaskmode> 2 "register_operand" "Yk")))]
 822   "TARGET_AVX512F"
 823 {
 824   switch (MODE_<sseinsnmode>)
 825     {
 826     case MODE_V8DF:
 827     case MODE_V16SF:
 828       return "vmova<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}";
 829     default:
 830       return "vmovdqa<ssescalarsize>\t{%1, %0%{%2%}|%0%{%2%}, %1}";
 831     }
 832 }
 833   [(set_attr "type" "ssemov")
 834    (set_attr "prefix" "evex")
 835    (set_attr "memory" "store")
 836    (set_attr "mode" "<sseinsnmode>")])
 837
 838 (define_insn "sse2_movq128"
 839   [(set (match_operand:V2DI 0 "register_operand" "=x")
 840         (vec_concat:V2DI
 841           (vec_select:DI
 842             (match_operand:V2DI 1 "nonimmediate_operand" "xm")
 843             (parallel [(const_int 0)]))
 844           (const_int 0)))]
 845   "TARGET_SSE2"
 846   "%vmovq\t{%1, %0|%0, %q1}"
 847   [(set_attr "type" "ssemov")
 848    (set_attr "prefix" "maybe_vex")
 849    (set_attr "mode" "TI")])
 850
 851 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
 852 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
 853 ;; from memory, we'd prefer to load the memory directly into the %xmm
 854 ;; register.  To facilitate this happy circumstance, this pattern won't
 855 ;; split until after register allocation.  If the 64-bit value didn't
 856 ;; come from memory, this is the best we can do.  This is much better
 857 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
 858 ;; from there.
 859
 860 (define_insn_and_split "movdi_to_sse"
 861   [(parallel
 862     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 863           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 864      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 865   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC"
 866   "#"
 867   "&& reload_completed"
 868   [(const_int 0)]
 869 {
 870  if (register_operand (operands[1], DImode))
 871    {
 872       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 873          Assemble the 64-bit DImode value in an xmm register.  */
 874       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 875                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 876       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 877                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 878       emit_insn (gen_vec_interleave_lowv4si (operands[0], operands[0],
 879                                              operands[2]));
 880    }
 881  else if (memory_operand (operands[1], DImode))
 882    {
 883      rtx tmp = gen_reg_rtx (V2DImode);
 884      emit_insn (gen_vec_concatv2di (tmp, operands[1], const0_rtx));
 885      emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp));
 886    }
 887  else
 888    gcc_unreachable ();
 889 })
 890
 891 (define_split
 892   [(set (match_operand:V4SF 0 "register_operand")
 893         (match_operand:V4SF 1 "zero_extended_scalar_load_operand"))]
 894   "TARGET_SSE && reload_completed"
 895   [(set (match_dup 0)
 896         (vec_merge:V4SF
 897           (vec_duplicate:V4SF (match_dup 1))
 898           (match_dup 2)
 899           (const_int 1)))]
 900 {
 901   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 902   operands[2] = CONST0_RTX (V4SFmode);
 903 })
 904
 905 (define_split
 906   [(set (match_operand:V2DF 0 "register_operand")
 907         (match_operand:V2DF 1 "zero_extended_scalar_load_operand"))]
 908   "TARGET_SSE2 && reload_completed"
 909   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 910 {
 911   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 912   operands[2] = CONST0_RTX (DFmode);
 913 })
 914
 915 (define_expand "movmisalign<mode>"
 916   [(set (match_operand:VMOVE 0 "nonimmediate_operand")
 917         (match_operand:VMOVE 1 "nonimmediate_operand"))]
 918   "TARGET_SSE"
 919 {
 920   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 921   DONE;
 922 })
 923
 924 (define_expand "<sse>_loadu<ssemodesuffix><avxsizesuffix><mask_name>"
 925   [(set (match_operand:VF 0 "register_operand")
 926         (unspec:VF [(match_operand:VF 1 "nonimmediate_operand")]
 927           UNSPEC_LOADU))]
 928   "TARGET_SSE && <mask_mode512bit_condition>"
 929 {
 930   /* For AVX, normal *mov<mode>_internal pattern will handle unaligned loads
 931      just fine if misaligned_operand is true, and without the UNSPEC it can
 932      be combined with arithmetic instructions.  If misaligned_operand is
 933      false, still emit UNSPEC_LOADU insn to honor user's request for
 934      misaligned load.  */
 935   if (TARGET_AVX
 936       && misaligned_operand (operands[1], <MODE>mode))
 937     {
 938       rtx src = operands[1];
 939       if (<mask_applied>)
 940         src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
 941                                  operands[2 * <mask_applied>],
 942                                  operands[3 * <mask_applied>]);
 943       emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
 944       DONE;
 945     }
 946 })
 947
 948 (define_insn "*<sse>_loadu<ssemodesuffix><avxsizesuffix><mask_name>"
 949   [(set (match_operand:VF 0 "register_operand" "=v")
 950         (unspec:VF
 951           [(match_operand:VF 1 "nonimmediate_operand" "vm")]
 952           UNSPEC_LOADU))]
 953   "TARGET_SSE && <mask_mode512bit_condition>"
 954 {
 955   switch (get_attr_mode (insn))
 956     {
 957     case MODE_V16SF:
 958     case MODE_V8SF:
 959     case MODE_V4SF:
 960       return "%vmovups\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}";
 961     default:
 962       return "%vmovu<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}";
 963     }
 964 }
 965   [(set_attr "type" "ssemov")
 966    (set_attr "movu" "1")
 967    (set_attr "ssememalign" "8")
 968    (set_attr "prefix" "maybe_vex")
 969    (set (attr "mode")
 970         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
 971                  (const_string "<ssePSmode>")
 972                (match_test "TARGET_AVX")
 973                  (const_string "<MODE>")
 974                (match_test "optimize_function_for_size_p (cfun)")
 975                  (const_string "V4SF")
 976               ]
 977               (const_string "<MODE>")))])
 978
 979 (define_insn "<sse>_storeu<ssemodesuffix><avxsizesuffix>"
 980   [(set (match_operand:VF 0 "memory_operand" "=m")
 981         (unspec:VF
 982           [(match_operand:VF 1 "register_operand" "v")]
 983           UNSPEC_STOREU))]
 984   "TARGET_SSE"
 985 {
 986   switch (get_attr_mode (insn))
 987     {
 988     case MODE_V16SF:
 989     case MODE_V8SF:
 990     case MODE_V4SF:
 991       return "%vmovups\t{%1, %0|%0, %1}";
 992     default:
 993       return "%vmovu<ssemodesuffix>\t{%1, %0|%0, %1}";
 994     }
 995 }
 996   [(set_attr "type" "ssemov")
 997    (set_attr "movu" "1")
 998    (set_attr "ssememalign" "8")
 999    (set_attr "prefix" "maybe_vex")
1000    (set (attr "mode")
1001         (cond [(and (match_test "<MODE_SIZE> == 16")
1002                     (ior (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1003                          (match_test "TARGET_SSE_TYPELESS_STORES")))
1004                  (const_string "<ssePSmode>")
1005                (match_test "TARGET_AVX")
1006                  (const_string "<MODE>")
1007                (match_test "optimize_function_for_size_p (cfun)")
1008                  (const_string "V4SF")
1009               ]
1010               (const_string "<MODE>")))])
1011
1012 (define_insn "avx512f_storeu<ssemodesuffix>512_mask"
1013   [(set (match_operand:VF_512 0 "memory_operand" "=m")
1014         (vec_merge:VF_512
1015           (unspec:VF_512
1016             [(match_operand:VF_512 1 "register_operand" "v")]
1017             UNSPEC_STOREU)
1018           (match_dup 0)
1019           (match_operand:<avx512fmaskmode> 2 "register_operand" "Yk")))]
1020   "TARGET_AVX512F"
1021 {
1022   switch (get_attr_mode (insn))
1023     {
1024     case MODE_V16SF:
1025       return "vmovups\t{%1, %0%{%2%}|%0%{%2%}, %1}";
1026     default:
1027       return "vmovu<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}";
1028     }
1029 }
1030   [(set_attr "type" "ssemov")
1031    (set_attr "movu" "1")
1032    (set_attr "memory" "store")
1033    (set_attr "prefix" "evex")
1034    (set_attr "mode" "<sseinsnmode>")])
1035
1036 (define_expand "<sse2_avx_avx512f>_loaddqu<mode><mask_name>"
1037   [(set (match_operand:VI_UNALIGNED_LOADSTORE 0 "register_operand")
1038         (unspec:VI_UNALIGNED_LOADSTORE
1039           [(match_operand:VI_UNALIGNED_LOADSTORE 1 "nonimmediate_operand")]
1040           UNSPEC_LOADU))]
1041   "TARGET_SSE2 && <mask_mode512bit_condition>"
1042 {
1043   /* For AVX, normal *mov<mode>_internal pattern will handle unaligned loads
1044      just fine if misaligned_operand is true, and without the UNSPEC it can
1045      be combined with arithmetic instructions.  If misaligned_operand is
1046      false, still emit UNSPEC_LOADU insn to honor user's request for
1047      misaligned load.  */
1048   if (TARGET_AVX
1049       && misaligned_operand (operands[1], <MODE>mode))
1050     {
1051       rtx src = operands[1];
1052       if (<mask_applied>)
1053         src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
1054                                  operands[2 * <mask_applied>],
1055                                  operands[3 * <mask_applied>]);
1056       emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
1057       DONE;
1058     }
1059 })
1060
1061 (define_insn "*<sse2_avx_avx512f>_loaddqu<mode><mask_name>"
1062   [(set (match_operand:VI_UNALIGNED_LOADSTORE 0 "register_operand" "=v")
1063         (unspec:VI_UNALIGNED_LOADSTORE
1064           [(match_operand:VI_UNALIGNED_LOADSTORE 1 "nonimmediate_operand" "vm")]
1065           UNSPEC_LOADU))]
1066   "TARGET_SSE2 && <mask_mode512bit_condition>"
1067 {
1068   switch (get_attr_mode (insn))
1069     {
1070     case MODE_V8SF:
1071     case MODE_V4SF:
1072       return "%vmovups\t{%1, %0|%0, %1}";
1073     case MODE_XI:
1074       if (<MODE>mode == V8DImode)
1075         return "vmovdqu64\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}";
1076       else
1077         return "vmovdqu32\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}";
1078     default:
1079       return "%vmovdqu\t{%1, %0|%0, %1}";
1080     }
1081 }
1082   [(set_attr "type" "ssemov")
1083    (set_attr "movu" "1")
1084    (set_attr "ssememalign" "8")
1085    (set (attr "prefix_data16")
1086      (if_then_else
1087        (match_test "TARGET_AVX")
1088      (const_string "*")
1089      (const_string "1")))
1090    (set_attr "prefix" "maybe_vex")
1091    (set (attr "mode")
1092         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1093                  (const_string "<ssePSmode>")
1094                (match_test "TARGET_AVX")
1095                  (const_string "<sseinsnmode>")
1096                (match_test "optimize_function_for_size_p (cfun)")
1097                  (const_string "V4SF")
1098               ]
1099               (const_string "<sseinsnmode>")))])
1100
1101 (define_insn "<sse2_avx_avx512f>_storedqu<mode>"
1102   [(set (match_operand:VI_UNALIGNED_LOADSTORE 0 "memory_operand" "=m")
1103         (unspec:VI_UNALIGNED_LOADSTORE
1104           [(match_operand:VI_UNALIGNED_LOADSTORE 1 "register_operand" "v")]
1105           UNSPEC_STOREU))]
1106   "TARGET_SSE2"
1107 {
1108   switch (get_attr_mode (insn))
1109     {
1110     case MODE_V16SF:
1111     case MODE_V8SF:
1112     case MODE_V4SF:
1113       return "%vmovups\t{%1, %0|%0, %1}";
1114     case MODE_XI:
1115       if (<MODE>mode == V8DImode)
1116         return "vmovdqu64\t{%1, %0|%0, %1}";
1117       else
1118         return "vmovdqu32\t{%1, %0|%0, %1}";
1119     default:
1120       return "%vmovdqu\t{%1, %0|%0, %1}";
1121     }
1122 }
1123   [(set_attr "type" "ssemov")
1124    (set_attr "movu" "1")
1125    (set_attr "ssememalign" "8")
1126    (set (attr "prefix_data16")
1127      (if_then_else
1128        (match_test "TARGET_AVX")
1129      (const_string "*")
1130      (const_string "1")))
1131    (set_attr "prefix" "maybe_vex")
1132    (set (attr "mode")
1133         (cond [(and (match_test "<MODE_SIZE> == 16")
1134                     (ior (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
1135                          (match_test "TARGET_SSE_TYPELESS_STORES")))
1136                  (const_string "<ssePSmode>")
1137                (match_test "TARGET_AVX")
1138                  (const_string "<sseinsnmode>")
1139                (match_test "optimize_function_for_size_p (cfun)")
1140                  (const_string "V4SF")
1141               ]
1142               (const_string "<sseinsnmode>")))])
1143
1144 (define_insn "avx512f_storedqu<mode>_mask"
1145   [(set (match_operand:VI48_512 0 "memory_operand" "=m")
1146         (vec_merge:VI48_512
1147           (unspec:VI48_512
1148             [(match_operand:VI48_512 1 "register_operand" "v")]
1149             UNSPEC_STOREU)
1150           (match_dup 0)
1151           (match_operand:<avx512fmaskmode> 2 "register_operand" "Yk")))]
1152   "TARGET_AVX512F"
1153 {
1154   if (<MODE>mode == V8DImode)
1155     return "vmovdqu64\t{%1, %0%{%2%}|%0%{%2%}, %1}";
1156   else
1157     return "vmovdqu32\t{%1, %0%{%2%}|%0%{%2%}, %1}";
1158 }
1159   [(set_attr "type" "ssemov")
1160    (set_attr "movu" "1")
1161    (set_attr "memory" "store")
1162    (set_attr "prefix" "evex")
1163    (set_attr "mode" "<sseinsnmode>")])
1164
1165 (define_insn "<sse3>_lddqu<avxsizesuffix>"
1166   [(set (match_operand:VI1 0 "register_operand" "=x")
1167         (unspec:VI1 [(match_operand:VI1 1 "memory_operand" "m")]
1168                     UNSPEC_LDDQU))]
1169   "TARGET_SSE3"
1170   "%vlddqu\t{%1, %0|%0, %1}"
1171   [(set_attr "type" "ssemov")
1172    (set_attr "movu" "1")
1173    (set_attr "ssememalign" "8")
1174    (set (attr "prefix_data16")
1175      (if_then_else
1176        (match_test "TARGET_AVX")
1177      (const_string "*")
1178      (const_string "0")))
1179    (set (attr "prefix_rep")
1180      (if_then_else
1181        (match_test "TARGET_AVX")
1182      (const_string "*")
1183      (const_string "1")))
1184    (set_attr "prefix" "maybe_vex")
1185    (set_attr "mode" "<sseinsnmode>")])
1186
1187 (define_insn "sse2_movnti<mode>"
1188   [(set (match_operand:SWI48 0 "memory_operand" "=m")
1189         (unspec:SWI48 [(match_operand:SWI48 1 "register_operand" "r")]
1190                       UNSPEC_MOVNT))]
1191   "TARGET_SSE2"
1192   "movnti\t{%1, %0|%0, %1}"
1193   [(set_attr "type" "ssemov")
1194    (set_attr "prefix_data16" "0")
1195    (set_attr "mode" "<MODE>")])
1196
1197 (define_insn "<sse>_movnt<mode>"
1198   [(set (match_operand:VF 0 "memory_operand" "=m")
1199         (unspec:VF
1200           [(match_operand:VF 1 "register_operand" "v")]
1201           UNSPEC_MOVNT))]
1202   "TARGET_SSE"
1203   "%vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
1204   [(set_attr "type" "ssemov")
1205    (set_attr "prefix" "maybe_vex")
1206    (set_attr "mode" "<MODE>")])
1207
1208 (define_insn "<sse2>_movnt<mode>"
1209   [(set (match_operand:VI8 0 "memory_operand" "=m")
1210         (unspec:VI8 [(match_operand:VI8 1 "register_operand" "v")]
1211                     UNSPEC_MOVNT))]
1212   "TARGET_SSE2"
1213   "%vmovntdq\t{%1, %0|%0, %1}"
1214   [(set_attr "type" "ssecvt")
1215    (set (attr "prefix_data16")
1216      (if_then_else
1217        (match_test "TARGET_AVX")
1218      (const_string "*")
1219      (const_string "1")))
1220    (set_attr "prefix" "maybe_vex")
1221    (set_attr "mode" "<sseinsnmode>")])
1222
1223 ; Expand patterns for non-temporal stores.  At the moment, only those
1224 ; that directly map to insns are defined; it would be possible to
1225 ; define patterns for other modes that would expand to several insns.
1226
1227 ;; Modes handled by storent patterns.
1228 (define_mode_iterator STORENT_MODE
1229   [(DI "TARGET_SSE2 && TARGET_64BIT") (SI "TARGET_SSE2")
1230    (SF "TARGET_SSE4A") (DF "TARGET_SSE4A")
1231    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX") (V2DI "TARGET_SSE2")
1232    (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
1233    (V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")])
1234
1235 (define_expand "storent<mode>"
1236   [(set (match_operand:STORENT_MODE 0 "memory_operand")
1237         (unspec:STORENT_MODE
1238           [(match_operand:STORENT_MODE 1 "register_operand")]
1239           UNSPEC_MOVNT))]
1240   "TARGET_SSE")
1241
1242 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1243 ;;
1244 ;; Parallel floating point arithmetic
1245 ;;
1246 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1247
1248 (define_expand "<code><mode>2"
1249   [(set (match_operand:VF 0 "register_operand")
1250         (absneg:VF
1251           (match_operand:VF 1 "register_operand")))]
1252   "TARGET_SSE"
1253   "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
1254
1255 (define_insn_and_split "*absneg<mode>2"
1256   [(set (match_operand:VF 0 "register_operand" "=x,x,v,v")
1257         (match_operator:VF 3 "absneg_operator"
1258           [(match_operand:VF 1 "nonimmediate_operand" "0, xm, v, m")]))
1259    (use (match_operand:VF 2 "nonimmediate_operand"    "xm, 0, vm,v"))]
1260   "TARGET_SSE"
1261   "#"
1262   "&& reload_completed"
1263   [(const_int 0)]
1264 {
1265   enum rtx_code absneg_op;
1266   rtx op1, op2;
1267   rtx t;
1268
1269   if (TARGET_AVX)
1270     {
1271       if (MEM_P (operands[1]))
1272         op1 = operands[2], op2 = operands[1];
1273       else
1274         op1 = operands[1], op2 = operands[2];
1275     }
1276   else
1277     {
1278       op1 = operands[0];
1279       if (rtx_equal_p (operands[0], operands[1]))
1280         op2 = operands[2];
1281       else
1282         op2 = operands[1];
1283     }
1284
1285   absneg_op = GET_CODE (operands[3]) == NEG ? XOR : AND;
1286   t = gen_rtx_fmt_ee (absneg_op, <MODE>mode, op1, op2);
1287   t = gen_rtx_SET (VOIDmode, operands[0], t);
1288   emit_insn (t);
1289   DONE;
1290 }
1291   [(set_attr "isa" "noavx,noavx,avx,avx")])
1292
1293 (define_expand "<plusminus_insn><mode>3<mask_name><round_name>"
1294   [(set (match_operand:VF 0 "register_operand")
1295         (plusminus:VF
1296           (match_operand:VF 1 "<round_nimm_predicate>")
1297           (match_operand:VF 2 "<round_nimm_predicate>")))]
1298   "TARGET_SSE && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1299   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
1300
1301 (define_insn "*<plusminus_insn><mode>3<mask_name><round_name>"
1302   [(set (match_operand:VF 0 "register_operand" "=x,v")
1303         (plusminus:VF
1304           (match_operand:VF 1 "<round_nimm_predicate>" "<comm>0,v")
1305           (match_operand:VF 2 "<round_nimm_predicate>" "xm,<round_constraint>")))]
1306   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands) && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1307   "@
1308    <plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
1309    v<plusminus_mnemonic><ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
1310   [(set_attr "isa" "noavx,avx")
1311    (set_attr "type" "sseadd")
1312    (set_attr "prefix" "<mask_prefix3>")
1313    (set_attr "mode" "<MODE>")])
1314
1315 (define_insn "<sse>_vm<plusminus_insn><mode>3<round_name>"
1316   [(set (match_operand:VF_128 0 "register_operand" "=x,v")
1317         (vec_merge:VF_128
1318           (plusminus:VF_128
1319             (match_operand:VF_128 1 "register_operand" "0,v")
1320             (match_operand:VF_128 2 "nonimmediate_operand" "xm,<round_constraint>"))
1321           (match_dup 1)
1322           (const_int 1)))]
1323   "TARGET_SSE"
1324   "@
1325    <plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
1326    v<plusminus_mnemonic><ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %<iptr>2<round_op3>}"
1327   [(set_attr "isa" "noavx,avx")
1328    (set_attr "type" "sseadd")
1329    (set_attr "prefix" "<round_prefix>")
1330    (set_attr "mode" "<ssescalarmode>")])
1331
1332 (define_expand "mul<mode>3<mask_name><round_name>"
1333   [(set (match_operand:VF 0 "register_operand")
1334         (mult:VF
1335           (match_operand:VF 1 "<round_nimm_predicate>")
1336           (match_operand:VF 2 "<round_nimm_predicate>")))]
1337   "TARGET_SSE && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1338   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
1339
1340 (define_insn "*mul<mode>3<mask_name><round_name>"
1341   [(set (match_operand:VF 0 "register_operand" "=x,v")
1342         (mult:VF
1343           (match_operand:VF 1 "<round_nimm_predicate>" "%0,v")
1344           (match_operand:VF 2 "<round_nimm_predicate>" "xm,<round_constraint>")))]
1345   "TARGET_SSE && ix86_binary_operator_ok (MULT, <MODE>mode, operands) && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1346   "@
1347    mul<ssemodesuffix>\t{%2, %0|%0, %2}
1348    vmul<ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
1349   [(set_attr "isa" "noavx,avx")
1350    (set_attr "type" "ssemul")
1351    (set_attr "prefix" "<mask_prefix3>")
1352    (set_attr "btver2_decode" "direct,double")
1353    (set_attr "mode" "<MODE>")])
1354
1355 (define_insn "<sse>_vm<multdiv_mnemonic><mode>3<round_name>"
1356   [(set (match_operand:VF_128 0 "register_operand" "=x,v")
1357         (vec_merge:VF_128
1358           (multdiv:VF_128
1359             (match_operand:VF_128 1 "register_operand" "0,v")
1360             (match_operand:VF_128 2 "nonimmediate_operand" "xm,<round_constraint>"))
1361           (match_dup 1)
1362           (const_int 1)))]
1363   "TARGET_SSE"
1364   "@
1365    <multdiv_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
1366    v<multdiv_mnemonic><ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %<iptr>2<round_op3>}"
1367   [(set_attr "isa" "noavx,avx")
1368    (set_attr "type" "sse<multdiv_mnemonic>")
1369    (set_attr "prefix" "<round_prefix>")
1370    (set_attr "btver2_decode" "direct,double")
1371    (set_attr "mode" "<ssescalarmode>")])
1372
1373 (define_expand "div<mode>3"
1374   [(set (match_operand:VF2 0 "register_operand")
1375         (div:VF2 (match_operand:VF2 1 "register_operand")
1376                  (match_operand:VF2 2 "nonimmediate_operand")))]
1377   "TARGET_SSE2"
1378   "ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);")
1379
1380 (define_expand "div<mode>3"
1381   [(set (match_operand:VF1 0 "register_operand")
1382         (div:VF1 (match_operand:VF1 1 "register_operand")
1383                  (match_operand:VF1 2 "nonimmediate_operand")))]
1384   "TARGET_SSE"
1385 {
1386   ix86_fixup_binary_operands_no_copy (DIV, <MODE>mode, operands);
1387
1388   if (TARGET_SSE_MATH
1389       && TARGET_RECIP_VEC_DIV
1390       && !optimize_insn_for_size_p ()
1391       && flag_finite_math_only && !flag_trapping_math
1392       && flag_unsafe_math_optimizations)
1393     {
1394       ix86_emit_swdivsf (operands[0], operands[1], operands[2], <MODE>mode);
1395       DONE;
1396     }
1397 })
1398
1399 (define_insn "<sse>_div<mode>3<mask_name><round_name>"
1400   [(set (match_operand:VF 0 "register_operand" "=x,v")
1401         (div:VF
1402           (match_operand:VF 1 "register_operand" "0,v")
1403           (match_operand:VF 2 "<round_nimm_predicate>" "xm,<round_constraint>")))]
1404   "TARGET_SSE && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1405   "@
1406    div<ssemodesuffix>\t{%2, %0|%0, %2}
1407    vdiv<ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
1408   [(set_attr "isa" "noavx,avx")
1409    (set_attr "type" "ssediv")
1410    (set_attr "prefix" "<mask_prefix3>")
1411    (set_attr "mode" "<MODE>")])
1412
1413 (define_insn "<sse>_rcp<mode>2"
1414   [(set (match_operand:VF1_128_256 0 "register_operand" "=x")
1415         (unspec:VF1_128_256
1416           [(match_operand:VF1_128_256 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
1417   "TARGET_SSE"
1418   "%vrcpps\t{%1, %0|%0, %1}"
1419   [(set_attr "type" "sse")
1420    (set_attr "atom_sse_attr" "rcp")
1421    (set_attr "btver2_sse_attr" "rcp")
1422    (set_attr "prefix" "maybe_vex")
1423    (set_attr "mode" "<MODE>")])
1424
1425 (define_insn "sse_vmrcpv4sf2"
1426   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1427         (vec_merge:V4SF
1428           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
1429                        UNSPEC_RCP)
1430           (match_operand:V4SF 2 "register_operand" "0,x")
1431           (const_int 1)))]
1432   "TARGET_SSE"
1433   "@
1434    rcpss\t{%1, %0|%0, %k1}
1435    vrcpss\t{%1, %2, %0|%0, %2, %k1}"
1436   [(set_attr "isa" "noavx,avx")
1437    (set_attr "type" "sse")
1438    (set_attr "ssememalign" "32")
1439    (set_attr "atom_sse_attr" "rcp")
1440    (set_attr "btver2_sse_attr" "rcp")
1441    (set_attr "prefix" "orig,vex")
1442    (set_attr "mode" "SF")])
1443
1444 (define_insn "<mask_codefor>rcp14<mode><mask_name>"
1445   [(set (match_operand:VF_512 0 "register_operand" "=v")
1446         (unspec:VF_512
1447           [(match_operand:VF_512 1 "nonimmediate_operand" "vm")]
1448           UNSPEC_RCP14))]
1449   "TARGET_AVX512F"
1450   "vrcp14<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
1451   [(set_attr "type" "sse")
1452    (set_attr "prefix" "evex")
1453    (set_attr "mode" "<MODE>")])
1454
1455 (define_insn "srcp14<mode>"
1456   [(set (match_operand:VF_128 0 "register_operand" "=v")
1457         (vec_merge:VF_128
1458           (unspec:VF_128
1459             [(match_operand:VF_128 1 "nonimmediate_operand" "vm")]
1460             UNSPEC_RCP14)
1461           (match_operand:VF_128 2 "register_operand" "v")
1462           (const_int 1)))]
1463   "TARGET_AVX512F"
1464   "vrcp14<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}"
1465   [(set_attr "type" "sse")
1466    (set_attr "prefix" "evex")
1467    (set_attr "mode" "<MODE>")])
1468
1469 (define_expand "sqrt<mode>2"
1470   [(set (match_operand:VF2 0 "register_operand")
1471         (sqrt:VF2 (match_operand:VF2 1 "nonimmediate_operand")))]
1472   "TARGET_SSE2")
1473
1474 (define_expand "sqrt<mode>2"
1475   [(set (match_operand:VF1 0 "register_operand")
1476         (sqrt:VF1 (match_operand:VF1 1 "nonimmediate_operand")))]
1477   "TARGET_SSE"
1478 {
1479   if (TARGET_SSE_MATH
1480       && TARGET_RECIP_VEC_SQRT
1481       && !optimize_insn_for_size_p ()
1482       && flag_finite_math_only && !flag_trapping_math
1483       && flag_unsafe_math_optimizations)
1484     {
1485       ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, false);
1486       DONE;
1487     }
1488 })
1489
1490 (define_insn "<sse>_sqrt<mode>2<mask_name><round_name>"
1491   [(set (match_operand:VF 0 "register_operand" "=v")
1492         (sqrt:VF (match_operand:VF 1 "<round_nimm_predicate>" "<round_constraint>")))]
1493   "TARGET_SSE && <mask_mode512bit_condition> && <round_mode512bit_condition>"
1494   "%vsqrt<ssemodesuffix>\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
1495   [(set_attr "type" "sse")
1496    (set_attr "atom_sse_attr" "sqrt")
1497    (set_attr "btver2_sse_attr" "sqrt")
1498    (set_attr "prefix" "maybe_vex")
1499    (set_attr "mode" "<MODE>")])
1500
1501 (define_insn "<sse>_vmsqrt<mode>2<round_name>"
1502   [(set (match_operand:VF_128 0 "register_operand" "=x,v")
1503         (vec_merge:VF_128
1504           (sqrt:VF_128
1505             (match_operand:VF_128 1 "nonimmediate_operand" "xm,<round_constraint>"))
1506           (match_operand:VF_128 2 "register_operand" "0,v")
1507           (const_int 1)))]
1508   "TARGET_SSE"
1509   "@
1510    sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}
1511    vsqrt<ssescalarmodesuffix>\t{<round_op3>%1, %2, %0|%0, %2, %<iptr>1<round_op3>}"
1512   [(set_attr "isa" "noavx,avx")
1513    (set_attr "type" "sse")
1514    (set_attr "atom_sse_attr" "sqrt")
1515    (set_attr "prefix" "<round_prefix>")
1516    (set_attr "btver2_sse_attr" "sqrt")
1517    (set_attr "mode" "<ssescalarmode>")])
1518
1519 (define_expand "rsqrt<mode>2"
1520   [(set (match_operand:VF1_128_256 0 "register_operand")
1521         (unspec:VF1_128_256
1522           [(match_operand:VF1_128_256 1 "nonimmediate_operand")] UNSPEC_RSQRT))]
1523   "TARGET_SSE_MATH"
1524 {
1525   ix86_emit_swsqrtsf (operands[0], operands[1], <MODE>mode, true);
1526   DONE;
1527 })
1528
1529 (define_insn "<sse>_rsqrt<mode>2"
1530   [(set (match_operand:VF1_128_256 0 "register_operand" "=x")
1531         (unspec:VF1_128_256
1532           [(match_operand:VF1_128_256 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
1533   "TARGET_SSE"
1534   "%vrsqrtps\t{%1, %0|%0, %1}"
1535   [(set_attr "type" "sse")
1536    (set_attr "prefix" "maybe_vex")
1537    (set_attr "mode" "<MODE>")])
1538
1539 (define_insn "<mask_codefor>rsqrt14<mode><mask_name>"
1540   [(set (match_operand:VF_512 0 "register_operand" "=v")
1541         (unspec:VF_512
1542           [(match_operand:VF_512 1 "nonimmediate_operand" "vm")]
1543           UNSPEC_RSQRT14))]
1544   "TARGET_AVX512F"
1545   "vrsqrt14<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
1546   [(set_attr "type" "sse")
1547    (set_attr "prefix" "evex")
1548    (set_attr "mode" "<MODE>")])
1549
1550 (define_insn "rsqrt14<mode>"
1551   [(set (match_operand:VF_128 0 "register_operand" "=v")
1552         (vec_merge:VF_128
1553           (unspec:VF_128
1554             [(match_operand:VF_128 1 "nonimmediate_operand" "vm")]
1555             UNSPEC_RSQRT14)
1556           (match_operand:VF_128 2 "register_operand" "v")
1557           (const_int 1)))]
1558   "TARGET_AVX512F"
1559   "vrsqrt14<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}"
1560   [(set_attr "type" "sse")
1561    (set_attr "prefix" "evex")
1562    (set_attr "mode" "<MODE>")])
1563
1564 (define_insn "sse_vmrsqrtv4sf2"
1565   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1566         (vec_merge:V4SF
1567           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,xm")]
1568                        UNSPEC_RSQRT)
1569           (match_operand:V4SF 2 "register_operand" "0,x")
1570           (const_int 1)))]
1571   "TARGET_SSE"
1572   "@
1573    rsqrtss\t{%1, %0|%0, %k1}
1574    vrsqrtss\t{%1, %2, %0|%0, %2, %k1}"
1575   [(set_attr "isa" "noavx,avx")
1576    (set_attr "type" "sse")
1577    (set_attr "ssememalign" "32")
1578    (set_attr "prefix" "orig,vex")
1579    (set_attr "mode" "SF")])
1580
1581 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
1582 ;; isn't really correct, as those rtl operators aren't defined when
1583 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
1584
1585 (define_expand "<code><mode>3<mask_name><round_saeonly_name>"
1586   [(set (match_operand:VF 0 "register_operand")
1587         (smaxmin:VF
1588           (match_operand:VF 1 "<round_saeonly_nimm_predicate>")
1589           (match_operand:VF 2 "<round_saeonly_nimm_predicate>")))]
1590   "TARGET_SSE && <mask_mode512bit_condition> && <round_saeonly_mode512bit_condition>"
1591 {
1592   if (!flag_finite_math_only)
1593     operands[1] = force_reg (<MODE>mode, operands[1]);
1594   ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
1595 })
1596
1597 (define_insn "*<code><mode>3_finite<mask_name><round_saeonly_name>"
1598   [(set (match_operand:VF 0 "register_operand" "=x,v")
1599         (smaxmin:VF
1600           (match_operand:VF 1 "<round_saeonly_nimm_predicate>" "%0,v")
1601           (match_operand:VF 2 "<round_saeonly_nimm_predicate>" "xm,<round_saeonly_constraint>")))]
1602   "TARGET_SSE && flag_finite_math_only
1603    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)
1604    && <mask_mode512bit_condition> && <round_saeonly_mode512bit_condition>"
1605   "@
1606    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1607    v<maxmin_float><ssemodesuffix>\t{<round_saeonly_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_saeonly_mask_op3>}"
1608   [(set_attr "isa" "noavx,avx")
1609    (set_attr "type" "sseadd")
1610    (set_attr "btver2_sse_attr" "maxmin")
1611    (set_attr "prefix" "<mask_prefix3>")
1612    (set_attr "mode" "<MODE>")])
1613
1614 (define_insn "*<code><mode>3<mask_name><round_saeonly_name>"
1615   [(set (match_operand:VF 0 "register_operand" "=x,v")
1616         (smaxmin:VF
1617           (match_operand:VF 1 "register_operand" "0,v")
1618           (match_operand:VF 2 "<round_saeonly_nimm_predicate>" "xm,<round_saeonly_constraint>")))]
1619   "TARGET_SSE && !flag_finite_math_only
1620    && <mask_mode512bit_condition> && <round_saeonly_mode512bit_condition>"
1621   "@
1622    <maxmin_float><ssemodesuffix>\t{%2, %0|%0, %2}
1623    v<maxmin_float><ssemodesuffix>\t{<round_saeonly_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_saeonly_mask_op3>}"
1624   [(set_attr "isa" "noavx,avx")
1625    (set_attr "type" "sseadd")
1626    (set_attr "btver2_sse_attr" "maxmin")
1627    (set_attr "prefix" "<mask_prefix3>")
1628    (set_attr "mode" "<MODE>")])
1629
1630 (define_insn "<sse>_vm<code><mode>3<round_saeonly_name>"
1631   [(set (match_operand:VF_128 0 "register_operand" "=x,v")
1632         (vec_merge:VF_128
1633           (smaxmin:VF_128
1634             (match_operand:VF_128 1 "register_operand" "0,v")
1635             (match_operand:VF_128 2 "nonimmediate_operand" "xm,<round_saeonly_constraint>"))
1636          (match_dup 1)
1637          (const_int 1)))]
1638   "TARGET_SSE"
1639   "@
1640    <maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
1641    v<maxmin_float><ssescalarmodesuffix>\t{<round_saeonly_op3>%2, %1, %0|%0, %1, %<iptr>2<round_saeonly_op3>}"
1642   [(set_attr "isa" "noavx,avx")
1643    (set_attr "type" "sse")
1644    (set_attr "btver2_sse_attr" "maxmin")
1645    (set_attr "prefix" "<round_saeonly_prefix>")
1646    (set_attr "mode" "<ssescalarmode>")])
1647
1648 ;; These versions of the min/max patterns implement exactly the operations
1649 ;;   min = (op1 < op2 ? op1 : op2)
1650 ;;   max = (!(op1 < op2) ? op1 : op2)
1651 ;; Their operands are not commutative, and thus they may be used in the
1652 ;; presence of -0.0 and NaN.
1653
1654 (define_insn "*ieee_smin<mode>3"
1655   [(set (match_operand:VF 0 "register_operand" "=v,v")
1656         (unspec:VF
1657           [(match_operand:VF 1 "register_operand" "0,v")
1658            (match_operand:VF 2 "nonimmediate_operand" "vm,vm")]
1659          UNSPEC_IEEE_MIN))]
1660   "TARGET_SSE"
1661   "@
1662    min<ssemodesuffix>\t{%2, %0|%0, %2}
1663    vmin<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1664   [(set_attr "isa" "noavx,avx")
1665    (set_attr "type" "sseadd")
1666    (set_attr "prefix" "orig,vex")
1667    (set_attr "mode" "<MODE>")])
1668
1669 (define_insn "*ieee_smax<mode>3"
1670   [(set (match_operand:VF 0 "register_operand" "=v,v")
1671         (unspec:VF
1672           [(match_operand:VF 1 "register_operand" "0,v")
1673            (match_operand:VF 2 "nonimmediate_operand" "vm,vm")]
1674          UNSPEC_IEEE_MAX))]
1675   "TARGET_SSE"
1676   "@
1677    max<ssemodesuffix>\t{%2, %0|%0, %2}
1678    vmax<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
1679   [(set_attr "isa" "noavx,avx")
1680    (set_attr "type" "sseadd")
1681    (set_attr "prefix" "orig,vex")
1682    (set_attr "mode" "<MODE>")])
1683
1684 (define_insn "avx_addsubv4df3"
1685   [(set (match_operand:V4DF 0 "register_operand" "=x")
1686         (vec_merge:V4DF
1687           (plus:V4DF
1688             (match_operand:V4DF 1 "register_operand" "x")
1689             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
1690           (minus:V4DF (match_dup 1) (match_dup 2))
1691           (const_int 10)))]
1692   "TARGET_AVX"
1693   "vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1694   [(set_attr "type" "sseadd")
1695    (set_attr "prefix" "vex")
1696    (set_attr "mode" "V4DF")])
1697
1698 (define_insn "sse3_addsubv2df3"
1699   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1700         (vec_merge:V2DF
1701           (plus:V2DF
1702             (match_operand:V2DF 1 "register_operand" "0,x")
1703             (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm"))
1704           (minus:V2DF (match_dup 1) (match_dup 2))
1705           (const_int 2)))]
1706   "TARGET_SSE3"
1707   "@
1708    addsubpd\t{%2, %0|%0, %2}
1709    vaddsubpd\t{%2, %1, %0|%0, %1, %2}"
1710   [(set_attr "isa" "noavx,avx")
1711    (set_attr "type" "sseadd")
1712    (set_attr "atom_unit" "complex")
1713    (set_attr "prefix" "orig,vex")
1714    (set_attr "mode" "V2DF")])
1715
1716 (define_insn "avx_addsubv8sf3"
1717   [(set (match_operand:V8SF 0 "register_operand" "=x")
1718         (vec_merge:V8SF
1719           (plus:V8SF
1720             (match_operand:V8SF 1 "register_operand" "x")
1721             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
1722           (minus:V8SF (match_dup 1) (match_dup 2))
1723           (const_int 170)))]
1724   "TARGET_AVX"
1725   "vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1726   [(set_attr "type" "sseadd")
1727    (set_attr "prefix" "vex")
1728    (set_attr "mode" "V8SF")])
1729
1730 (define_insn "sse3_addsubv4sf3"
1731   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1732         (vec_merge:V4SF
1733           (plus:V4SF
1734             (match_operand:V4SF 1 "register_operand" "0,x")
1735             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
1736           (minus:V4SF (match_dup 1) (match_dup 2))
1737           (const_int 10)))]
1738   "TARGET_SSE3"
1739   "@
1740    addsubps\t{%2, %0|%0, %2}
1741    vaddsubps\t{%2, %1, %0|%0, %1, %2}"
1742   [(set_attr "isa" "noavx,avx")
1743    (set_attr "type" "sseadd")
1744    (set_attr "prefix" "orig,vex")
1745    (set_attr "prefix_rep" "1,*")
1746    (set_attr "mode" "V4SF")])
1747
1748 (define_insn "avx_h<plusminus_insn>v4df3"
1749   [(set (match_operand:V4DF 0 "register_operand" "=x")
1750         (vec_concat:V4DF
1751           (vec_concat:V2DF
1752             (plusminus:DF
1753               (vec_select:DF
1754                 (match_operand:V4DF 1 "register_operand" "x")
1755                 (parallel [(const_int 0)]))
1756               (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1757             (plusminus:DF
1758               (vec_select:DF
1759                 (match_operand:V4DF 2 "nonimmediate_operand" "xm")
1760                 (parallel [(const_int 0)]))
1761               (vec_select:DF (match_dup 2) (parallel [(const_int 1)]))))
1762           (vec_concat:V2DF
1763             (plusminus:DF
1764               (vec_select:DF (match_dup 1) (parallel [(const_int 2)]))
1765               (vec_select:DF (match_dup 1) (parallel [(const_int 3)])))
1766             (plusminus:DF
1767               (vec_select:DF (match_dup 2) (parallel [(const_int 2)]))
1768               (vec_select:DF (match_dup 2) (parallel [(const_int 3)]))))))]
1769   "TARGET_AVX"
1770   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
1771   [(set_attr "type" "sseadd")
1772    (set_attr "prefix" "vex")
1773    (set_attr "mode" "V4DF")])
1774
1775 (define_expand "sse3_haddv2df3"
1776   [(set (match_operand:V2DF 0 "register_operand")
1777         (vec_concat:V2DF
1778           (plus:DF
1779             (vec_select:DF
1780               (match_operand:V2DF 1 "register_operand")
1781               (parallel [(const_int 0)]))
1782             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1783           (plus:DF
1784             (vec_select:DF
1785               (match_operand:V2DF 2 "nonimmediate_operand")
1786               (parallel [(const_int 0)]))
1787             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1788   "TARGET_SSE3")
1789
1790 (define_insn "*sse3_haddv2df3"
1791   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1792         (vec_concat:V2DF
1793           (plus:DF
1794             (vec_select:DF
1795               (match_operand:V2DF 1 "register_operand" "0,x")
1796               (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))
1797             (vec_select:DF
1798               (match_dup 1)
1799               (parallel [(match_operand:SI 4 "const_0_to_1_operand")])))
1800           (plus:DF
1801             (vec_select:DF
1802               (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm")
1803               (parallel [(match_operand:SI 5 "const_0_to_1_operand")]))
1804             (vec_select:DF
1805               (match_dup 2)
1806               (parallel [(match_operand:SI 6 "const_0_to_1_operand")])))))]
1807   "TARGET_SSE3
1808    && INTVAL (operands[3]) != INTVAL (operands[4])
1809    && INTVAL (operands[5]) != INTVAL (operands[6])"
1810   "@
1811    haddpd\t{%2, %0|%0, %2}
1812    vhaddpd\t{%2, %1, %0|%0, %1, %2}"
1813   [(set_attr "isa" "noavx,avx")
1814    (set_attr "type" "sseadd")
1815    (set_attr "prefix" "orig,vex")
1816    (set_attr "mode" "V2DF")])
1817
1818 (define_insn "sse3_hsubv2df3"
1819   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
1820         (vec_concat:V2DF
1821           (minus:DF
1822             (vec_select:DF
1823               (match_operand:V2DF 1 "register_operand" "0,x")
1824               (parallel [(const_int 0)]))
1825             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1826           (minus:DF
1827             (vec_select:DF
1828               (match_operand:V2DF 2 "nonimmediate_operand" "xm,xm")
1829               (parallel [(const_int 0)]))
1830             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1831   "TARGET_SSE3"
1832   "@
1833    hsubpd\t{%2, %0|%0, %2}
1834    vhsubpd\t{%2, %1, %0|%0, %1, %2}"
1835   [(set_attr "isa" "noavx,avx")
1836    (set_attr "type" "sseadd")
1837    (set_attr "prefix" "orig,vex")
1838    (set_attr "mode" "V2DF")])
1839
1840 (define_insn "*sse3_haddv2df3_low"
1841   [(set (match_operand:DF 0 "register_operand" "=x,x")
1842         (plus:DF
1843           (vec_select:DF
1844             (match_operand:V2DF 1 "register_operand" "0,x")
1845             (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))
1846           (vec_select:DF
1847             (match_dup 1)
1848             (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))))]
1849   "TARGET_SSE3
1850    && INTVAL (operands[2]) != INTVAL (operands[3])"
1851   "@
1852    haddpd\t{%0, %0|%0, %0}
1853    vhaddpd\t{%1, %1, %0|%0, %1, %1}"
1854   [(set_attr "isa" "noavx,avx")
1855    (set_attr "type" "sseadd1")
1856    (set_attr "prefix" "orig,vex")
1857    (set_attr "mode" "V2DF")])
1858
1859 (define_insn "*sse3_hsubv2df3_low"
1860   [(set (match_operand:DF 0 "register_operand" "=x,x")
1861         (minus:DF
1862           (vec_select:DF
1863             (match_operand:V2DF 1 "register_operand" "0,x")
1864             (parallel [(const_int 0)]))
1865           (vec_select:DF
1866             (match_dup 1)
1867             (parallel [(const_int 1)]))))]
1868   "TARGET_SSE3"
1869   "@
1870    hsubpd\t{%0, %0|%0, %0}
1871    vhsubpd\t{%1, %1, %0|%0, %1, %1}"
1872   [(set_attr "isa" "noavx,avx")
1873    (set_attr "type" "sseadd1")
1874    (set_attr "prefix" "orig,vex")
1875    (set_attr "mode" "V2DF")])
1876
1877 (define_insn "avx_h<plusminus_insn>v8sf3"
1878   [(set (match_operand:V8SF 0 "register_operand" "=x")
1879         (vec_concat:V8SF
1880           (vec_concat:V4SF
1881             (vec_concat:V2SF
1882               (plusminus:SF
1883                 (vec_select:SF
1884                   (match_operand:V8SF 1 "register_operand" "x")
1885                   (parallel [(const_int 0)]))
1886                 (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1887               (plusminus:SF
1888                 (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1889                 (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1890             (vec_concat:V2SF
1891               (plusminus:SF
1892                 (vec_select:SF
1893                   (match_operand:V8SF 2 "nonimmediate_operand" "xm")
1894                   (parallel [(const_int 0)]))
1895                 (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1896               (plusminus:SF
1897                 (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1898                 (vec_select:SF (match_dup 2) (parallel [(const_int 3)])))))
1899           (vec_concat:V4SF
1900             (vec_concat:V2SF
1901               (plusminus:SF
1902                 (vec_select:SF (match_dup 1) (parallel [(const_int 4)]))
1903                 (vec_select:SF (match_dup 1) (parallel [(const_int 5)])))
1904               (plusminus:SF
1905                 (vec_select:SF (match_dup 1) (parallel [(const_int 6)]))
1906                 (vec_select:SF (match_dup 1) (parallel [(const_int 7)]))))
1907             (vec_concat:V2SF
1908               (plusminus:SF
1909                 (vec_select:SF (match_dup 2) (parallel [(const_int 4)]))
1910                 (vec_select:SF (match_dup 2) (parallel [(const_int 5)])))
1911               (plusminus:SF
1912                 (vec_select:SF (match_dup 2) (parallel [(const_int 6)]))
1913                 (vec_select:SF (match_dup 2) (parallel [(const_int 7)])))))))]
1914   "TARGET_AVX"
1915   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1916   [(set_attr "type" "sseadd")
1917    (set_attr "prefix" "vex")
1918    (set_attr "mode" "V8SF")])
1919
1920 (define_insn "sse3_h<plusminus_insn>v4sf3"
1921   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1922         (vec_concat:V4SF
1923           (vec_concat:V2SF
1924             (plusminus:SF
1925               (vec_select:SF
1926                 (match_operand:V4SF 1 "register_operand" "0,x")
1927                 (parallel [(const_int 0)]))
1928               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1929             (plusminus:SF
1930               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
1931               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
1932           (vec_concat:V2SF
1933             (plusminus:SF
1934               (vec_select:SF
1935                 (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
1936                 (parallel [(const_int 0)]))
1937               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
1938             (plusminus:SF
1939               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
1940               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
1941   "TARGET_SSE3"
1942   "@
1943    h<plusminus_mnemonic>ps\t{%2, %0|%0, %2}
1944    vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
1945   [(set_attr "isa" "noavx,avx")
1946    (set_attr "type" "sseadd")
1947    (set_attr "atom_unit" "complex")
1948    (set_attr "prefix" "orig,vex")
1949    (set_attr "prefix_rep" "1,*")
1950    (set_attr "mode" "V4SF")])
1951
1952 (define_expand "reduc_splus_v8df"
1953   [(match_operand:V8DF 0 "register_operand")
1954    (match_operand:V8DF 1 "register_operand")]
1955   "TARGET_AVX512F"
1956 {
1957   ix86_expand_reduc (gen_addv8df3, operands[0], operands[1]);
1958   DONE;
1959 })
1960
1961 (define_expand "reduc_splus_v4df"
1962   [(match_operand:V4DF 0 "register_operand")
1963    (match_operand:V4DF 1 "register_operand")]
1964   "TARGET_AVX"
1965 {
1966   rtx tmp = gen_reg_rtx (V4DFmode);
1967   rtx tmp2 = gen_reg_rtx (V4DFmode);
1968   emit_insn (gen_avx_haddv4df3 (tmp, operands[1], operands[1]));
1969   emit_insn (gen_avx_vperm2f128v4df3 (tmp2, tmp, tmp, GEN_INT (1)));
1970   emit_insn (gen_addv4df3 (operands[0], tmp, tmp2));
1971   DONE;
1972 })
1973
1974 (define_expand "reduc_splus_v2df"
1975   [(match_operand:V2DF 0 "register_operand")
1976    (match_operand:V2DF 1 "register_operand")]
1977   "TARGET_SSE3"
1978 {
1979   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1980   DONE;
1981 })
1982
1983 (define_expand "reduc_splus_v16sf"
1984   [(match_operand:V16SF 0 "register_operand")
1985    (match_operand:V16SF 1 "register_operand")]
1986   "TARGET_AVX512F"
1987 {
1988   ix86_expand_reduc (gen_addv16sf3, operands[0], operands[1]);
1989   DONE;
1990 })
1991
1992 (define_expand "reduc_splus_v8sf"
1993   [(match_operand:V8SF 0 "register_operand")
1994    (match_operand:V8SF 1 "register_operand")]
1995   "TARGET_AVX"
1996 {
1997   rtx tmp = gen_reg_rtx (V8SFmode);
1998   rtx tmp2 = gen_reg_rtx (V8SFmode);
1999   emit_insn (gen_avx_haddv8sf3 (tmp, operands[1], operands[1]));
2000   emit_insn (gen_avx_haddv8sf3 (tmp2, tmp, tmp));
2001   emit_insn (gen_avx_vperm2f128v8sf3 (tmp, tmp2, tmp2, GEN_INT (1)));
2002   emit_insn (gen_addv8sf3 (operands[0], tmp, tmp2));
2003   DONE;
2004 })
2005
2006 (define_expand "reduc_splus_v4sf"
2007   [(match_operand:V4SF 0 "register_operand")
2008    (match_operand:V4SF 1 "register_operand")]
2009   "TARGET_SSE"
2010 {
2011   if (TARGET_SSE3)
2012     {
2013       rtx tmp = gen_reg_rtx (V4SFmode);
2014       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
2015       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
2016     }
2017   else
2018     ix86_expand_reduc (gen_addv4sf3, operands[0], operands[1]);
2019   DONE;
2020 })
2021
2022 ;; Modes handled by reduc_sm{in,ax}* patterns.
2023 (define_mode_iterator REDUC_SMINMAX_MODE
2024   [(V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
2025    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
2026    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
2027    (V4SF "TARGET_SSE") (V16SI "TARGET_AVX512F")
2028    (V8DI "TARGET_AVX512F") (V16SF "TARGET_AVX512F")
2029    (V8DF "TARGET_AVX512F")])
2030
2031 (define_expand "reduc_<code>_<mode>"
2032   [(smaxmin:REDUC_SMINMAX_MODE
2033      (match_operand:REDUC_SMINMAX_MODE 0 "register_operand")
2034      (match_operand:REDUC_SMINMAX_MODE 1 "register_operand"))]
2035   ""
2036 {
2037   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
2038   DONE;
2039 })
2040
2041 (define_expand "reduc_<code>_<mode>"
2042   [(umaxmin:VI48_512
2043      (match_operand:VI48_512 0 "register_operand")
2044      (match_operand:VI48_512 1 "register_operand"))]
2045   "TARGET_AVX512F"
2046 {
2047   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
2048   DONE;
2049 })
2050
2051 (define_expand "reduc_<code>_<mode>"
2052   [(umaxmin:VI_256
2053      (match_operand:VI_256 0 "register_operand")
2054      (match_operand:VI_256 1 "register_operand"))]
2055   "TARGET_AVX2"
2056 {
2057   ix86_expand_reduc (gen_<code><mode>3, operands[0], operands[1]);
2058   DONE;
2059 })
2060
2061 (define_expand "reduc_umin_v8hi"
2062   [(umin:V8HI
2063      (match_operand:V8HI 0 "register_operand")
2064      (match_operand:V8HI 1 "register_operand"))]
2065   "TARGET_SSE4_1"
2066 {
2067   ix86_expand_reduc (gen_uminv8hi3, operands[0], operands[1]);
2068   DONE;
2069 })
2070
2071 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2072 ;;
2073 ;; Parallel floating point comparisons
2074 ;;
2075 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2076
2077 (define_insn "avx_cmp<mode>3"
2078   [(set (match_operand:VF_128_256 0 "register_operand" "=x")
2079         (unspec:VF_128_256
2080           [(match_operand:VF_128_256 1 "register_operand" "x")
2081            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm")
2082            (match_operand:SI 3 "const_0_to_31_operand" "n")]
2083           UNSPEC_PCMP))]
2084   "TARGET_AVX"
2085   "vcmp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2086   [(set_attr "type" "ssecmp")
2087    (set_attr "length_immediate" "1")
2088    (set_attr "prefix" "vex")
2089    (set_attr "mode" "<MODE>")])
2090
2091 (define_insn "avx_vmcmp<mode>3"
2092   [(set (match_operand:VF_128 0 "register_operand" "=x")
2093         (vec_merge:VF_128
2094           (unspec:VF_128
2095             [(match_operand:VF_128 1 "register_operand" "x")
2096              (match_operand:VF_128 2 "nonimmediate_operand" "xm")
2097              (match_operand:SI 3 "const_0_to_31_operand" "n")]
2098             UNSPEC_PCMP)
2099          (match_dup 1)
2100          (const_int 1)))]
2101   "TARGET_AVX"
2102   "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %3}"
2103   [(set_attr "type" "ssecmp")
2104    (set_attr "length_immediate" "1")
2105    (set_attr "prefix" "vex")
2106    (set_attr "mode" "<ssescalarmode>")])
2107
2108 (define_insn "*<sse>_maskcmp<mode>3_comm"
2109   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
2110         (match_operator:VF_128_256 3 "sse_comparison_operator"
2111           [(match_operand:VF_128_256 1 "register_operand" "%0,x")
2112            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")]))]
2113   "TARGET_SSE
2114    && GET_RTX_CLASS (GET_CODE (operands[3])) == RTX_COMM_COMPARE"
2115   "@
2116    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
2117    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2118   [(set_attr "isa" "noavx,avx")
2119    (set_attr "type" "ssecmp")
2120    (set_attr "length_immediate" "1")
2121    (set_attr "prefix" "orig,vex")
2122    (set_attr "mode" "<MODE>")])
2123
2124 (define_insn "<sse>_maskcmp<mode>3"
2125   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
2126         (match_operator:VF_128_256 3 "sse_comparison_operator"
2127           [(match_operand:VF_128_256 1 "register_operand" "0,x")
2128            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")]))]
2129   "TARGET_SSE"
2130   "@
2131    cmp%D3<ssemodesuffix>\t{%2, %0|%0, %2}
2132    vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2133   [(set_attr "isa" "noavx,avx")
2134    (set_attr "type" "ssecmp")
2135    (set_attr "length_immediate" "1")
2136    (set_attr "prefix" "orig,vex")
2137    (set_attr "mode" "<MODE>")])
2138
2139 (define_insn "<sse>_vmmaskcmp<mode>3"
2140   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
2141         (vec_merge:VF_128
2142          (match_operator:VF_128 3 "sse_comparison_operator"
2143            [(match_operand:VF_128 1 "register_operand" "0,x")
2144             (match_operand:VF_128 2 "nonimmediate_operand" "xm,xm")])
2145          (match_dup 1)
2146          (const_int 1)))]
2147   "TARGET_SSE"
2148   "@
2149    cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2}
2150    vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}"
2151   [(set_attr "isa" "noavx,avx")
2152    (set_attr "type" "ssecmp")
2153    (set_attr "length_immediate" "1,*")
2154    (set_attr "prefix" "orig,vex")
2155    (set_attr "mode" "<ssescalarmode>")])
2156
2157 (define_mode_attr cmp_imm_predicate
2158   [(V16SF "const_0_to_31_operand") (V8DF "const_0_to_31_operand")
2159   (V16SI "const_0_to_7_operand") (V8DI "const_0_to_7_operand")])
2160
2161 (define_insn "avx512f_cmp<mode>3<mask_scalar_merge_name><round_saeonly_name>"
2162   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
2163         (unspec:<avx512fmaskmode>
2164           [(match_operand:VI48F_512 1 "register_operand" "v")
2165            (match_operand:VI48F_512 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
2166            (match_operand:SI 3 "<cmp_imm_predicate>" "n")]
2167           UNSPEC_PCMP))]
2168   "TARGET_AVX512F && <round_saeonly_mode512bit_condition>"
2169   "v<sseintprefix>cmp<ssemodesuffix>\t{%3, <round_saeonly_mask_scalar_merge_op4>%2, %1, %0<mask_scalar_merge_operand4>|%0<mask_scalar_merge_operand4>, %1, %2<round_saeonly_mask_scalar_merge_op4>, %3}"
2170   [(set_attr "type" "ssecmp")
2171    (set_attr "length_immediate" "1")
2172    (set_attr "prefix" "evex")
2173    (set_attr "mode" "<sseinsnmode>")])
2174
2175 (define_insn "avx512f_ucmp<mode>3<mask_scalar_merge_name>"
2176   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
2177         (unspec:<avx512fmaskmode>
2178           [(match_operand:VI48_512 1 "register_operand" "v")
2179            (match_operand:VI48_512 2 "nonimmediate_operand" "vm")
2180            (match_operand:SI 3 "const_0_to_7_operand" "n")]
2181           UNSPEC_UNSIGNED_PCMP))]
2182   "TARGET_AVX512F"
2183   "vpcmpu<ssemodesuffix>\t{%3, %2, %1, %0<mask_scalar_merge_operand4>|%0<mask_scalar_merge_operand4>, %1, %2, %3}"
2184   [(set_attr "type" "ssecmp")
2185    (set_attr "length_immediate" "1")
2186    (set_attr "prefix" "evex")
2187    (set_attr "mode" "<sseinsnmode>")])
2188
2189 (define_insn "avx512f_vmcmp<mode>3<round_saeonly_name>"
2190   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
2191         (and:<avx512fmaskmode>
2192           (unspec:<avx512fmaskmode>
2193             [(match_operand:VF_128 1 "register_operand" "v")
2194              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
2195              (match_operand:SI 3 "const_0_to_31_operand" "n")]
2196             UNSPEC_PCMP)
2197           (const_int 1)))]
2198   "TARGET_AVX512F"
2199   "vcmp<ssescalarmodesuffix>\t{%3, <round_saeonly_op4>%2, %1, %0|%0, %1, %2<round_saeonly_op4>, %3}"
2200   [(set_attr "type" "ssecmp")
2201    (set_attr "length_immediate" "1")
2202    (set_attr "prefix" "evex")
2203    (set_attr "mode" "<ssescalarmode>")])
2204
2205 (define_insn "avx512f_vmcmp<mode>3_mask<round_saeonly_name>"
2206   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
2207         (and:<avx512fmaskmode>
2208           (unspec:<avx512fmaskmode>
2209             [(match_operand:VF_128 1 "register_operand" "v")
2210              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
2211              (match_operand:SI 3 "const_0_to_31_operand" "n")]
2212             UNSPEC_PCMP)
2213           (and:<avx512fmaskmode>
2214             (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")
2215             (const_int 1))))]
2216   "TARGET_AVX512F"
2217   "vcmp<ssescalarmodesuffix>\t{%3, <round_saeonly_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_saeonly_op5>, %3}"
2218   [(set_attr "type" "ssecmp")
2219    (set_attr "length_immediate" "1")
2220    (set_attr "prefix" "evex")
2221    (set_attr "mode" "<ssescalarmode>")])
2222
2223 (define_insn "avx512f_maskcmp<mode>3"
2224   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
2225         (match_operator:<avx512fmaskmode> 3 "sse_comparison_operator"
2226           [(match_operand:VF 1 "register_operand" "v")
2227            (match_operand:VF 2 "nonimmediate_operand" "vm")]))]
2228   "TARGET_SSE"
2229   "vcmp%D3<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
2230   [(set_attr "type" "ssecmp")
2231    (set_attr "length_immediate" "1")
2232    (set_attr "prefix" "evex")
2233    (set_attr "mode" "<sseinsnmode>")])
2234
2235 (define_insn "<sse>_comi<round_saeonly_name>"
2236   [(set (reg:CCFP FLAGS_REG)
2237         (compare:CCFP
2238           (vec_select:MODEF
2239             (match_operand:<ssevecmode> 0 "register_operand" "v")
2240             (parallel [(const_int 0)]))
2241           (vec_select:MODEF
2242             (match_operand:<ssevecmode> 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
2243             (parallel [(const_int 0)]))))]
2244   "SSE_FLOAT_MODE_P (<MODE>mode)"
2245   "%vcomi<ssemodesuffix>\t{<round_saeonly_op2>%1, %0|%0, %<iptr>1<round_saeonly_op2>}"
2246   [(set_attr "type" "ssecomi")
2247    (set_attr "prefix" "maybe_vex")
2248    (set_attr "prefix_rep" "0")
2249    (set (attr "prefix_data16")
2250         (if_then_else (eq_attr "mode" "DF")
2251                       (const_string "1")
2252                       (const_string "0")))
2253    (set_attr "mode" "<MODE>")])
2254
2255 (define_insn "<sse>_ucomi<round_saeonly_name>"
2256   [(set (reg:CCFPU FLAGS_REG)
2257         (compare:CCFPU
2258           (vec_select:MODEF
2259             (match_operand:<ssevecmode> 0 "register_operand" "v")
2260             (parallel [(const_int 0)]))
2261           (vec_select:MODEF
2262             (match_operand:<ssevecmode> 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
2263             (parallel [(const_int 0)]))))]
2264   "SSE_FLOAT_MODE_P (<MODE>mode)"
2265   "%vucomi<ssemodesuffix>\t{<round_saeonly_op2>%1, %0|%0, %<iptr>1<round_saeonly_op2>}"
2266   [(set_attr "type" "ssecomi")
2267    (set_attr "prefix" "maybe_vex")
2268    (set_attr "prefix_rep" "0")
2269    (set (attr "prefix_data16")
2270         (if_then_else (eq_attr "mode" "DF")
2271                       (const_string "1")
2272                       (const_string "0")))
2273    (set_attr "mode" "<MODE>")])
2274
2275 (define_expand "vcond<V_512:mode><VF_512:mode>"
2276   [(set (match_operand:V_512 0 "register_operand")
2277         (if_then_else:V_512
2278           (match_operator 3 ""
2279             [(match_operand:VF_512 4 "nonimmediate_operand")
2280              (match_operand:VF_512 5 "nonimmediate_operand")])
2281           (match_operand:V_512 1 "general_operand")
2282           (match_operand:V_512 2 "general_operand")))]
2283   "TARGET_AVX512F
2284    && (GET_MODE_NUNITS (<V_512:MODE>mode)
2285        == GET_MODE_NUNITS (<VF_512:MODE>mode))"
2286 {
2287   bool ok = ix86_expand_fp_vcond (operands);
2288   gcc_assert (ok);
2289   DONE;
2290 })
2291
2292 (define_expand "vcond<V_256:mode><VF_256:mode>"
2293   [(set (match_operand:V_256 0 "register_operand")
2294         (if_then_else:V_256
2295           (match_operator 3 ""
2296             [(match_operand:VF_256 4 "nonimmediate_operand")
2297              (match_operand:VF_256 5 "nonimmediate_operand")])
2298           (match_operand:V_256 1 "general_operand")
2299           (match_operand:V_256 2 "general_operand")))]
2300   "TARGET_AVX
2301    && (GET_MODE_NUNITS (<V_256:MODE>mode)
2302        == GET_MODE_NUNITS (<VF_256:MODE>mode))"
2303 {
2304   bool ok = ix86_expand_fp_vcond (operands);
2305   gcc_assert (ok);
2306   DONE;
2307 })
2308
2309 (define_expand "vcond<V_128:mode><VF_128:mode>"
2310   [(set (match_operand:V_128 0 "register_operand")
2311         (if_then_else:V_128
2312           (match_operator 3 ""
2313             [(match_operand:VF_128 4 "nonimmediate_operand")
2314              (match_operand:VF_128 5 "nonimmediate_operand")])
2315           (match_operand:V_128 1 "general_operand")
2316           (match_operand:V_128 2 "general_operand")))]
2317   "TARGET_SSE
2318    && (GET_MODE_NUNITS (<V_128:MODE>mode)
2319        == GET_MODE_NUNITS (<VF_128:MODE>mode))"
2320 {
2321   bool ok = ix86_expand_fp_vcond (operands);
2322   gcc_assert (ok);
2323   DONE;
2324 })
2325
2326 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2327 ;;
2328 ;; Parallel floating point logical operations
2329 ;;
2330 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2331
2332 (define_insn "<sse>_andnot<mode>3"
2333   [(set (match_operand:VF 0 "register_operand" "=x,v")
2334         (and:VF
2335           (not:VF
2336             (match_operand:VF 1 "register_operand" "0,v"))
2337           (match_operand:VF 2 "nonimmediate_operand" "xm,vm")))]
2338   "TARGET_SSE"
2339 {
2340   static char buf[32];
2341   const char *ops;
2342   const char *suffix;
2343
2344   switch (get_attr_mode (insn))
2345     {
2346     case MODE_V8SF:
2347     case MODE_V4SF:
2348       suffix = "ps";
2349       break;
2350     default:
2351       suffix = "<ssemodesuffix>";
2352     }
2353
2354   switch (which_alternative)
2355     {
2356     case 0:
2357       ops = "andn%s\t{%%2, %%0|%%0, %%2}";
2358       break;
2359     case 1:
2360       ops = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2361       break;
2362     default:
2363       gcc_unreachable ();
2364     }
2365
2366   /* There is no vandnp[sd].  Use vpandnq.  */
2367   if (<MODE_SIZE> == 64)
2368     {
2369       suffix = "q";
2370       ops = "vpandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2371     }
2372
2373   snprintf (buf, sizeof (buf), ops, suffix);
2374   return buf;
2375 }
2376   [(set_attr "isa" "noavx,avx")
2377    (set_attr "type" "sselog")
2378    (set_attr "prefix" "orig,maybe_evex")
2379    (set (attr "mode")
2380         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2381                  (const_string "<ssePSmode>")
2382                (match_test "TARGET_AVX")
2383                  (const_string "<MODE>")
2384                (match_test "optimize_function_for_size_p (cfun)")
2385                  (const_string "V4SF")
2386                ]
2387                (const_string "<MODE>")))])
2388
2389 (define_expand "<code><mode>3"
2390   [(set (match_operand:VF_128_256 0 "register_operand")
2391         (any_logic:VF_128_256
2392           (match_operand:VF_128_256 1 "nonimmediate_operand")
2393           (match_operand:VF_128_256 2 "nonimmediate_operand")))]
2394   "TARGET_SSE"
2395   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
2396
2397 (define_expand "<code><mode>3"
2398   [(set (match_operand:VF_512 0 "register_operand")
2399        (fpint_logic:VF_512
2400          (match_operand:VF_512 1 "nonimmediate_operand")
2401          (match_operand:VF_512 2 "nonimmediate_operand")))]
2402   "TARGET_AVX512F"
2403   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
2404
2405 (define_insn "*<code><mode>3"
2406   [(set (match_operand:VF 0 "register_operand" "=x,v")
2407         (any_logic:VF
2408           (match_operand:VF 1 "nonimmediate_operand" "%0,v")
2409           (match_operand:VF 2 "nonimmediate_operand" "xm,vm")))]
2410   "TARGET_SSE && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
2411 {
2412   static char buf[32];
2413   const char *ops;
2414   const char *suffix;
2415
2416   switch (get_attr_mode (insn))
2417     {
2418     case MODE_V8SF:
2419     case MODE_V4SF:
2420       suffix = "ps";
2421       break;
2422     default:
2423       suffix = "<ssemodesuffix>";
2424     }
2425
2426   switch (which_alternative)
2427     {
2428     case 0:
2429       ops = "<logic>%s\t{%%2, %%0|%%0, %%2}";
2430       break;
2431     case 1:
2432       ops = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2433       break;
2434     default:
2435       gcc_unreachable ();
2436     }
2437
2438   /* There is no v<logic>p[sd].  Use vp<logic>q.  */
2439   if (<MODE_SIZE> == 64)
2440     {
2441       suffix = "q";
2442       ops = "vp<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2443     }
2444
2445   snprintf (buf, sizeof (buf), ops, suffix);
2446   return buf;
2447 }
2448   [(set_attr "isa" "noavx,avx")
2449    (set_attr "type" "sselog")
2450    (set_attr "prefix" "orig,maybe_evex")
2451    (set (attr "mode")
2452         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2453                  (const_string "<ssePSmode>")
2454                (match_test "TARGET_AVX")
2455                  (const_string "<MODE>")
2456                (match_test "optimize_function_for_size_p (cfun)")
2457                  (const_string "V4SF")
2458                ]
2459                (const_string "<MODE>")))])
2460
2461 (define_expand "copysign<mode>3"
2462   [(set (match_dup 4)
2463         (and:VF
2464           (not:VF (match_dup 3))
2465           (match_operand:VF 1 "nonimmediate_operand")))
2466    (set (match_dup 5)
2467         (and:VF (match_dup 3)
2468                 (match_operand:VF 2 "nonimmediate_operand")))
2469    (set (match_operand:VF 0 "register_operand")
2470         (ior:VF (match_dup 4) (match_dup 5)))]
2471   "TARGET_SSE"
2472 {
2473   operands[3] = ix86_build_signbit_mask (<MODE>mode, 1, 0);
2474
2475   operands[4] = gen_reg_rtx (<MODE>mode);
2476   operands[5] = gen_reg_rtx (<MODE>mode);
2477 })
2478
2479 ;; Also define scalar versions.  These are used for abs, neg, and
2480 ;; conditional move.  Using subregs into vector modes causes register
2481 ;; allocation lossage.  These patterns do not allow memory operands
2482 ;; because the native instructions read the full 128-bits.
2483
2484 (define_insn "*andnot<mode>3"
2485   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
2486         (and:MODEF
2487           (not:MODEF
2488             (match_operand:MODEF 1 "register_operand" "0,x"))
2489             (match_operand:MODEF 2 "register_operand" "x,x")))]
2490   "SSE_FLOAT_MODE_P (<MODE>mode)"
2491 {
2492   static char buf[32];
2493   const char *ops;
2494   const char *suffix
2495     = (get_attr_mode (insn) == MODE_V4SF) ? "ps" : "<ssevecmodesuffix>";
2496
2497   switch (which_alternative)
2498     {
2499     case 0:
2500       ops = "andn%s\t{%%2, %%0|%%0, %%2}";
2501       break;
2502     case 1:
2503       ops = "vandn%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2504       break;
2505     default:
2506       gcc_unreachable ();
2507     }
2508
2509   snprintf (buf, sizeof (buf), ops, suffix);
2510   return buf;
2511 }
2512   [(set_attr "isa" "noavx,avx")
2513    (set_attr "type" "sselog")
2514    (set_attr "prefix" "orig,vex")
2515    (set (attr "mode")
2516         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2517                  (const_string "V4SF")
2518                (match_test "TARGET_AVX")
2519                  (const_string "<ssevecmode>")
2520                (match_test "optimize_function_for_size_p (cfun)")
2521                  (const_string "V4SF")
2522                ]
2523                (const_string "<ssevecmode>")))])
2524
2525 (define_insn "*andnottf3"
2526   [(set (match_operand:TF 0 "register_operand" "=x,x")
2527         (and:TF
2528           (not:TF (match_operand:TF 1 "register_operand" "0,x"))
2529           (match_operand:TF 2 "nonimmediate_operand" "xm,xm")))]
2530   "TARGET_SSE"
2531 {
2532   static char buf[32];
2533   const char *ops;
2534   const char *tmp
2535     = (get_attr_mode (insn) == MODE_V4SF) ? "andnps" : "pandn";
2536
2537   switch (which_alternative)
2538     {
2539     case 0:
2540       ops = "%s\t{%%2, %%0|%%0, %%2}";
2541       break;
2542     case 1:
2543       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2544       break;
2545     default:
2546       gcc_unreachable ();
2547     }
2548
2549   snprintf (buf, sizeof (buf), ops, tmp);
2550   return buf;
2551 }
2552   [(set_attr "isa" "noavx,avx")
2553    (set_attr "type" "sselog")
2554    (set (attr "prefix_data16")
2555      (if_then_else
2556        (and (eq_attr "alternative" "0")
2557             (eq_attr "mode" "TI"))
2558        (const_string "1")
2559        (const_string "*")))
2560    (set_attr "prefix" "orig,vex")
2561    (set (attr "mode")
2562         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2563                  (const_string "V4SF")
2564                (match_test "TARGET_AVX")
2565                  (const_string "TI")
2566                (ior (not (match_test "TARGET_SSE2"))
2567                     (match_test "optimize_function_for_size_p (cfun)"))
2568                  (const_string "V4SF")
2569                ]
2570                (const_string "TI")))])
2571
2572 (define_insn "*<code><mode>3"
2573   [(set (match_operand:MODEF 0 "register_operand" "=x,x")
2574         (any_logic:MODEF
2575           (match_operand:MODEF 1 "register_operand" "%0,x")
2576           (match_operand:MODEF 2 "register_operand" "x,x")))]
2577   "SSE_FLOAT_MODE_P (<MODE>mode)"
2578 {
2579   static char buf[32];
2580   const char *ops;
2581   const char *suffix
2582     = (get_attr_mode (insn) == MODE_V4SF) ? "ps" : "<ssevecmodesuffix>";
2583
2584   switch (which_alternative)
2585     {
2586     case 0:
2587       ops = "<logic>%s\t{%%2, %%0|%%0, %%2}";
2588       break;
2589     case 1:
2590       ops = "v<logic>%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2591       break;
2592     default:
2593       gcc_unreachable ();
2594     }
2595
2596   snprintf (buf, sizeof (buf), ops, suffix);
2597   return buf;
2598 }
2599   [(set_attr "isa" "noavx,avx")
2600    (set_attr "type" "sselog")
2601    (set_attr "prefix" "orig,vex")
2602    (set (attr "mode")
2603         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2604                  (const_string "V4SF")
2605                (match_test "TARGET_AVX")
2606                  (const_string "<ssevecmode>")
2607                (match_test "optimize_function_for_size_p (cfun)")
2608                  (const_string "V4SF")
2609                ]
2610                (const_string "<ssevecmode>")))])
2611
2612 (define_expand "<code>tf3"
2613   [(set (match_operand:TF 0 "register_operand")
2614         (any_logic:TF
2615           (match_operand:TF 1 "nonimmediate_operand")
2616           (match_operand:TF 2 "nonimmediate_operand")))]
2617   "TARGET_SSE"
2618   "ix86_fixup_binary_operands_no_copy (<CODE>, TFmode, operands);")
2619
2620 (define_insn "*<code>tf3"
2621   [(set (match_operand:TF 0 "register_operand" "=x,x")
2622         (any_logic:TF
2623           (match_operand:TF 1 "nonimmediate_operand" "%0,x")
2624           (match_operand:TF 2 "nonimmediate_operand" "xm,xm")))]
2625   "TARGET_SSE
2626    && ix86_binary_operator_ok (<CODE>, TFmode, operands)"
2627 {
2628   static char buf[32];
2629   const char *ops;
2630   const char *tmp
2631     = (get_attr_mode (insn) == MODE_V4SF) ? "<logic>ps" : "p<logic>";
2632
2633   switch (which_alternative)
2634     {
2635     case 0:
2636       ops = "%s\t{%%2, %%0|%%0, %%2}";
2637       break;
2638     case 1:
2639       ops = "v%s\t{%%2, %%1, %%0|%%0, %%1, %%2}";
2640       break;
2641     default:
2642       gcc_unreachable ();
2643     }
2644
2645   snprintf (buf, sizeof (buf), ops, tmp);
2646   return buf;
2647 }
2648   [(set_attr "isa" "noavx,avx")
2649    (set_attr "type" "sselog")
2650    (set (attr "prefix_data16")
2651      (if_then_else
2652        (and (eq_attr "alternative" "0")
2653             (eq_attr "mode" "TI"))
2654        (const_string "1")
2655        (const_string "*")))
2656    (set_attr "prefix" "orig,vex")
2657    (set (attr "mode")
2658         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
2659                  (const_string "V4SF")
2660                (match_test "TARGET_AVX")
2661                  (const_string "TI")
2662                (ior (not (match_test "TARGET_SSE2"))
2663                     (match_test "optimize_function_for_size_p (cfun)"))
2664                  (const_string "V4SF")
2665                ]
2666                (const_string "TI")))])
2667
2668 ;; There are no floating point xor for V16SF and V8DF in avx512f
2669 ;; but we need them for negation.  Instead we use int versions of
2670 ;; xor.  Maybe there could be a better way to do that.
2671
2672 (define_mode_attr avx512flogicsuff
2673   [(V16SF "d") (V8DF "q")])
2674
2675 (define_insn "avx512f_<logic><mode>"
2676   [(set (match_operand:VF_512 0 "register_operand" "=v")
2677         (fpint_logic:VF_512
2678           (match_operand:VF_512 1 "register_operand" "v")
2679           (match_operand:VF_512 2 "nonimmediate_operand" "vm")))]
2680   "TARGET_AVX512F"
2681   "vp<logic><avx512flogicsuff>\t{%2, %1, %0|%0, %1, %2}"
2682   [(set_attr "type" "sselog")
2683    (set_attr "prefix" "evex")])
2684
2685 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2686 ;;
2687 ;; FMA floating point multiply/accumulate instructions.  These include
2688 ;; scalar versions of the instructions as well as vector versions.
2689 ;;
2690 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2691
2692 ;; The standard names for scalar FMA are only available with SSE math enabled.
2693 ;; CPUID bit AVX512F enables evex encoded scalar and 512-bit fma.  It doesn't
2694 ;; care about FMA bit, so we enable fma for TARGET_AVX512F even when TARGET_FMA
2695 ;; and TARGET_FMA4 are both false.
2696 ;; TODO: In theory AVX512F does not automatically imply FMA, and without FMA
2697 ;; one must force the EVEX encoding of the fma insns.  Ideally we'd improve
2698 ;; GAS to allow proper prefix selection.  However, for the moment all hardware
2699 ;; that supports AVX512F also supports FMA so we can ignore this for now.
2700 (define_mode_iterator FMAMODEM
2701   [(SF "TARGET_SSE_MATH && (TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F)")
2702    (DF "TARGET_SSE_MATH && (TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F)")
2703    (V4SF "TARGET_FMA || TARGET_FMA4")
2704    (V2DF "TARGET_FMA || TARGET_FMA4")
2705    (V8SF "TARGET_FMA || TARGET_FMA4")
2706    (V4DF "TARGET_FMA || TARGET_FMA4")
2707    (V16SF "TARGET_AVX512F")
2708    (V8DF "TARGET_AVX512F")])
2709
2710 (define_expand "fma<mode>4"
2711   [(set (match_operand:FMAMODEM 0 "register_operand")
2712         (fma:FMAMODEM
2713           (match_operand:FMAMODEM 1 "nonimmediate_operand")
2714           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2715           (match_operand:FMAMODEM 3 "nonimmediate_operand")))])
2716
2717 (define_expand "fms<mode>4"
2718   [(set (match_operand:FMAMODEM 0 "register_operand")
2719         (fma:FMAMODEM
2720           (match_operand:FMAMODEM 1 "nonimmediate_operand")
2721           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2722           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))])
2723
2724 (define_expand "fnma<mode>4"
2725   [(set (match_operand:FMAMODEM 0 "register_operand")
2726         (fma:FMAMODEM
2727           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2728           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2729           (match_operand:FMAMODEM 3 "nonimmediate_operand")))])
2730
2731 (define_expand "fnms<mode>4"
2732   [(set (match_operand:FMAMODEM 0 "register_operand")
2733         (fma:FMAMODEM
2734           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2735           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2736           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))])
2737
2738 ;; The builtins for intrinsics are not constrained by SSE math enabled.
2739 (define_mode_iterator FMAMODE
2740   [(SF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2741    (DF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2742    (V4SF "TARGET_FMA || TARGET_FMA4")
2743    (V2DF "TARGET_FMA || TARGET_FMA4")
2744    (V8SF "TARGET_FMA || TARGET_FMA4")
2745    (V4DF "TARGET_FMA || TARGET_FMA4")
2746    (V16SF "TARGET_AVX512F")
2747    (V8DF "TARGET_AVX512F")])
2748
2749 (define_expand "fma4i_fmadd_<mode>"
2750   [(set (match_operand:FMAMODE 0 "register_operand")
2751         (fma:FMAMODE
2752           (match_operand:FMAMODE 1 "nonimmediate_operand")
2753           (match_operand:FMAMODE 2 "nonimmediate_operand")
2754           (match_operand:FMAMODE 3 "nonimmediate_operand")))])
2755
2756 (define_expand "avx512f_fmadd_<mode>_maskz<round_expand_name>"
2757   [(match_operand:VF_512 0 "register_operand")
2758    (match_operand:VF_512 1 "<round_expand_nimm_predicate>")
2759    (match_operand:VF_512 2 "<round_expand_nimm_predicate>")
2760    (match_operand:VF_512 3 "<round_expand_nimm_predicate>")
2761    (match_operand:<avx512fmaskmode> 4 "register_operand")]
2762   "TARGET_AVX512F"
2763 {
2764   emit_insn (gen_fma_fmadd_<mode>_maskz_1<round_expand_name> (
2765     operands[0], operands[1], operands[2], operands[3],
2766     CONST0_RTX (<MODE>mode), operands[4]<round_expand_operand>));
2767   DONE;
2768 })
2769
2770 (define_mode_iterator FMAMODE_NOVF512
2771   [(SF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2772    (DF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2773    (V4SF "TARGET_FMA || TARGET_FMA4")
2774    (V2DF "TARGET_FMA || TARGET_FMA4")
2775    (V8SF "TARGET_FMA || TARGET_FMA4")
2776    (V4DF "TARGET_FMA || TARGET_FMA4")])
2777
2778 (define_insn "<sd_mask_codefor>fma_fmadd_<mode><sd_maskz_name><round_name>"
2779   [(set (match_operand:FMAMODE_NOVF512 0 "register_operand" "=v,v,v,x,x")
2780         (fma:FMAMODE_NOVF512
2781           (match_operand:FMAMODE_NOVF512 1 "<round_nimm_predicate>" "%0,0,v,x,x")
2782           (match_operand:FMAMODE_NOVF512 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2783           (match_operand:FMAMODE_NOVF512 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")))]
2784   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2785   "@
2786    vfmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2787    vfmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2788    vfmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2789    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2790    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2791   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2792    (set_attr "type" "ssemuladd")
2793    (set_attr "mode" "<MODE>")])
2794
2795 (define_insn "<sd_mask_codefor>fma_fmadd_<mode><sd_maskz_name><round_name>"
2796   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
2797         (fma:VF_512
2798           (match_operand:VF_512 1 "<round_nimm_predicate>" "%0,0,v")
2799           (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
2800           (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>,0")))]
2801   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2802   "@
2803    vfmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2804    vfmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2805    vfmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
2806   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
2807    (set_attr "type" "ssemuladd")
2808    (set_attr "mode" "<MODE>")])
2809
2810 (define_insn "avx512f_fmadd_<mode>_mask<round_name>"
2811   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2812         (vec_merge:VF_512
2813           (fma:VF_512
2814             (match_operand:VF_512 1 "register_operand" "0,0")
2815             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2816             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))
2817           (match_dup 1)
2818           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2819   "TARGET_AVX512F"
2820   "@
2821    vfmadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2822    vfmadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2823   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2824    (set_attr "type" "ssemuladd")
2825    (set_attr "mode" "<MODE>")])
2826
2827 (define_insn "avx512f_fmadd_<mode>_mask3<round_name>"
2828   [(set (match_operand:VF_512 0 "register_operand" "=x")
2829         (vec_merge:VF_512
2830           (fma:VF_512
2831             (match_operand:VF_512 1 "register_operand" "x")
2832             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2833             (match_operand:VF_512 3 "register_operand" "0"))
2834           (match_dup 3)
2835           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2836   "TARGET_AVX512F"
2837   "vfmadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2838   [(set_attr "isa" "fma_avx512f")
2839    (set_attr "type" "ssemuladd")
2840    (set_attr "mode" "<MODE>")])
2841
2842 (define_insn "<sd_mask_codefor>fma_fmsub_<mode><sd_maskz_name><round_name>"
2843   [(set (match_operand:FMAMODE_NOVF512 0 "register_operand" "=v,v,v,x,x")
2844         (fma:FMAMODE_NOVF512
2845           (match_operand:FMAMODE_NOVF512   1 "<round_nimm_predicate>" "%0,0,v,x,x")
2846           (match_operand:FMAMODE_NOVF512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2847           (neg:FMAMODE_NOVF512
2848             (match_operand:FMAMODE_NOVF512 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))))]
2849   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2850   "@
2851    vfmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2852    vfmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2853    vfmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2854    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2855    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2856   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2857    (set_attr "type" "ssemuladd")
2858    (set_attr "mode" "<MODE>")])
2859
2860 (define_insn "<sd_mask_codefor>fma_fmsub_<mode><sd_maskz_name><round_name>"
2861   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
2862         (fma:VF_512
2863           (match_operand:VF_512   1 "<round_nimm_predicate>" "%0,0,v")
2864           (match_operand:VF_512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
2865           (neg:VF_512
2866             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>,0"))))]
2867   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2868   "@
2869    vfmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2870    vfmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2871    vfmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
2872   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
2873    (set_attr "type" "ssemuladd")
2874    (set_attr "mode" "<MODE>")])
2875
2876 (define_insn "avx512f_fmsub_<mode>_mask<round_name>"
2877   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2878         (vec_merge:VF_512
2879           (fma:VF_512
2880             (match_operand:VF_512 1 "register_operand" "0,0")
2881             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2882             (neg:VF_512
2883               (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")))
2884           (match_dup 1)
2885           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2886   "TARGET_AVX512F"
2887   "@
2888    vfmsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2889    vfmsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2890   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2891    (set_attr "type" "ssemuladd")
2892    (set_attr "mode" "<MODE>")])
2893
2894 (define_insn "avx512f_fmsub_<mode>_mask3<round_name>"
2895   [(set (match_operand:VF_512 0 "register_operand" "=v")
2896         (vec_merge:VF_512
2897           (fma:VF_512
2898             (match_operand:VF_512 1 "register_operand" "v")
2899             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2900             (neg:VF_512
2901               (match_operand:VF_512 3 "register_operand" "0")))
2902           (match_dup 3)
2903           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2904   "TARGET_AVX512F"
2905   "vfmsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2906   [(set_attr "isa" "fma_avx512f")
2907    (set_attr "type" "ssemuladd")
2908    (set_attr "mode" "<MODE>")])
2909
2910 (define_insn "<sd_mask_codefor>fma_fnmadd_<mode><sd_maskz_name><round_name>"
2911   [(set (match_operand:FMAMODE_NOVF512 0 "register_operand" "=v,v,v,x,x")
2912         (fma:FMAMODE_NOVF512
2913           (neg:FMAMODE_NOVF512
2914             (match_operand:FMAMODE_NOVF512 1 "<round_nimm_predicate>" "%0,0,v,x,x"))
2915           (match_operand:FMAMODE_NOVF512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2916           (match_operand:FMAMODE_NOVF512   3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")))]
2917   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2918   "@
2919    vfnmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2920    vfnmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2921    vfnmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2922    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2923    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2924   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2925    (set_attr "type" "ssemuladd")
2926    (set_attr "mode" "<MODE>")])
2927
2928 (define_insn "<sd_mask_codefor>fma_fnmadd_<mode><sd_maskz_name><round_name>"
2929   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
2930         (fma:VF_512
2931           (neg:VF_512
2932             (match_operand:VF_512 1 "<round_nimm_predicate>" "%0,0,v"))
2933           (match_operand:VF_512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
2934           (match_operand:VF_512   3 "<round_nimm_predicate>" "v,<round_constraint>,0")))]
2935   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2936   "@
2937    vfnmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2938    vfnmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2939    vfnmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
2940   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
2941    (set_attr "type" "ssemuladd")
2942    (set_attr "mode" "<MODE>")])
2943
2944 (define_insn "avx512f_fnmadd_<mode>_mask<round_name>"
2945   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2946         (vec_merge:VF_512
2947           (fma:VF_512
2948             (neg:VF_512
2949               (match_operand:VF_512 1 "register_operand" "0,0"))
2950             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2951             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))
2952           (match_dup 1)
2953           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2954   "TARGET_AVX512F"
2955   "@
2956    vfnmadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2957    vfnmadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2958   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2959    (set_attr "type" "ssemuladd")
2960    (set_attr "mode" "<MODE>")])
2961
2962 (define_insn "avx512f_fnmadd_<mode>_mask3<round_name>"
2963   [(set (match_operand:VF_512 0 "register_operand" "=v")
2964         (vec_merge:VF_512
2965           (fma:VF_512
2966             (neg:VF_512
2967               (match_operand:VF_512 1 "register_operand" "v"))
2968             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2969             (match_operand:VF_512 3 "register_operand" "0"))
2970           (match_dup 3)
2971           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2972   "TARGET_AVX512F"
2973   "vfnmadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2974   [(set_attr "isa" "fma_avx512f")
2975    (set_attr "type" "ssemuladd")
2976    (set_attr "mode" "<MODE>")])
2977
2978 (define_insn "<sd_mask_codefor>fma_fnmsub_<mode><sd_maskz_name><round_name>"
2979   [(set (match_operand:FMAMODE_NOVF512 0 "register_operand" "=v,v,v,x,x")
2980         (fma:FMAMODE_NOVF512
2981           (neg:FMAMODE_NOVF512
2982             (match_operand:FMAMODE_NOVF512 1 "<round_nimm_predicate>" "%0,0,v,x,x"))
2983           (match_operand:FMAMODE_NOVF512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2984           (neg:FMAMODE_NOVF512
2985             (match_operand:FMAMODE_NOVF512 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))))]
2986   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2987   "@
2988    vfnmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2989    vfnmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2990    vfnmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2991    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2992    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2993   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2994    (set_attr "type" "ssemuladd")
2995    (set_attr "mode" "<MODE>")])
2996
2997 (define_insn "<sd_mask_codefor>fma_fnmsub_<mode><sd_maskz_name><round_name>"
2998   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
2999         (fma:VF_512
3000           (neg:VF_512
3001             (match_operand:VF_512 1 "<round_nimm_predicate>" "%0,0,v"))
3002           (match_operand:VF_512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
3003           (neg:VF_512
3004             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>,0"))))]
3005   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3006   "@
3007    vfnmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3008    vfnmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3009    vfnmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
3010   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
3011    (set_attr "type" "ssemuladd")
3012    (set_attr "mode" "<MODE>")])
3013
3014 (define_insn "avx512f_fnmsub_<mode>_mask<round_name>"
3015   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
3016         (vec_merge:VF_512
3017           (fma:VF_512
3018             (neg:VF_512
3019               (match_operand:VF_512 1 "register_operand" "0,0"))
3020             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
3021             (neg:VF_512
3022               (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")))
3023           (match_dup 1)
3024           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
3025   "TARGET_AVX512F"
3026   "@
3027    vfnmsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
3028    vfnmsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
3029   [(set_attr "isa" "fma_avx512f,fma_avx512f")
3030    (set_attr "type" "ssemuladd")
3031    (set_attr "mode" "<MODE>")])
3032
3033 (define_insn "avx512f_fnmsub_<mode>_mask3<round_name>"
3034   [(set (match_operand:VF_512 0 "register_operand" "=v")
3035         (vec_merge:VF_512
3036           (fma:VF_512
3037             (neg:VF_512
3038               (match_operand:VF_512 1 "register_operand" "v"))
3039             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
3040             (neg:VF_512
3041               (match_operand:VF_512 3 "register_operand" "0")))
3042           (match_dup 3)
3043           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
3044   "TARGET_AVX512F"
3045   "vfnmsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
3046   [(set_attr "isa" "fma_avx512f")
3047    (set_attr "type" "ssemuladd")
3048    (set_attr "mode" "<MODE>")])
3049
3050 ;; FMA parallel floating point multiply addsub and subadd operations.
3051
3052 ;; It would be possible to represent these without the UNSPEC as
3053 ;;
3054 ;; (vec_merge
3055 ;;   (fma op1 op2 op3)
3056 ;;   (fma op1 op2 (neg op3))
3057 ;;   (merge-const))
3058 ;;
3059 ;; But this doesn't seem useful in practice.
3060
3061 (define_expand "fmaddsub_<mode>"
3062   [(set (match_operand:VF 0 "register_operand")
3063         (unspec:VF
3064           [(match_operand:VF 1 "nonimmediate_operand")
3065            (match_operand:VF 2 "nonimmediate_operand")
3066            (match_operand:VF 3 "nonimmediate_operand")]
3067           UNSPEC_FMADDSUB))]
3068   "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
3069
3070 (define_expand "avx512f_fmaddsub_<mode>_maskz<round_expand_name>"
3071   [(match_operand:VF_512 0 "register_operand")
3072    (match_operand:VF_512 1 "<round_expand_nimm_predicate>")
3073    (match_operand:VF_512 2 "<round_expand_nimm_predicate>")
3074    (match_operand:VF_512 3 "<round_expand_nimm_predicate>")
3075    (match_operand:<avx512fmaskmode> 4 "register_operand")]
3076   "TARGET_AVX512F"
3077 {
3078   emit_insn (gen_fma_fmaddsub_<mode>_maskz_1<round_expand_name> (
3079     operands[0], operands[1], operands[2], operands[3],
3080     CONST0_RTX (<MODE>mode), operands[4]<round_expand_operand>));
3081   DONE;
3082 })
3083
3084 (define_insn "<sd_mask_codefor>fma_fmaddsub_<mode><sd_maskz_name><round_name>"
3085   [(set (match_operand:VF_128_256 0 "register_operand" "=v,v,v,x,x")
3086         (unspec:VF_128_256
3087           [(match_operand:VF_128_256 1 "<round_nimm_predicate>" "%0,0,v,x,x")
3088            (match_operand:VF_128_256 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
3089            (match_operand:VF_128_256 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")]
3090           UNSPEC_FMADDSUB))]
3091   "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F) && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3092   "@
3093    vfmaddsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3094    vfmaddsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3095    vfmaddsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
3096    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
3097    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
3098   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
3099    (set_attr "type" "ssemuladd")
3100    (set_attr "mode" "<MODE>")])
3101
3102 (define_insn "<sd_mask_codefor>fma_fmaddsub_<mode><sd_maskz_name><round_name>"
3103   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
3104         (unspec:VF_512
3105           [(match_operand:VF_512 1 "<round_nimm_predicate>" "%0,0,v")
3106            (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
3107            (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>,0")]
3108           UNSPEC_FMADDSUB))]
3109   "TARGET_AVX512F && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3110   "@
3111    vfmaddsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3112    vfmaddsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3113    vfmaddsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
3114   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
3115    (set_attr "type" "ssemuladd")
3116    (set_attr "mode" "<MODE>")])
3117
3118 (define_insn "avx512f_fmaddsub_<mode>_mask<round_name>"
3119   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
3120         (vec_merge:VF_512
3121           (unspec:VF_512
3122             [(match_operand:VF_512 1 "register_operand" "0,0")
3123              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
3124              (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")]
3125             UNSPEC_FMADDSUB)
3126           (match_dup 1)
3127           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
3128   "TARGET_AVX512F"
3129   "@
3130    vfmaddsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
3131    vfmaddsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
3132   [(set_attr "isa" "fma_avx512f,fma_avx512f")
3133    (set_attr "type" "ssemuladd")
3134    (set_attr "mode" "<MODE>")])
3135
3136 (define_insn "avx512f_fmaddsub_<mode>_mask3<round_name>"
3137   [(set (match_operand:VF_512 0 "register_operand" "=v")
3138         (vec_merge:VF_512
3139           (unspec:VF_512
3140             [(match_operand:VF_512 1 "register_operand" "v")
3141              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
3142              (match_operand:VF_512 3 "register_operand" "0")]
3143             UNSPEC_FMADDSUB)
3144           (match_dup 3)
3145           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
3146   "TARGET_AVX512F"
3147   "vfmaddsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
3148   [(set_attr "isa" "fma_avx512f")
3149    (set_attr "type" "ssemuladd")
3150    (set_attr "mode" "<MODE>")])
3151
3152 (define_insn "<sd_mask_codefor>fma_fmsubadd_<mode><sd_maskz_name><round_name>"
3153   [(set (match_operand:VF_128_256 0 "register_operand" "=v,v,v,x,x")
3154         (unspec:VF_128_256
3155           [(match_operand:VF_128_256   1 "<round_nimm_predicate>" "%0,0,v,x,x")
3156            (match_operand:VF_128_256   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
3157            (neg:VF_128_256
3158              (match_operand:VF_128_256 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))]
3159           UNSPEC_FMADDSUB))]
3160   "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F) && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3161   "@
3162    vfmsubadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3163    vfmsubadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3164    vfmsubadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
3165    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
3166    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
3167   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
3168    (set_attr "type" "ssemuladd")
3169    (set_attr "mode" "<MODE>")])
3170
3171 (define_insn "<sd_mask_codefor>fma_fmsubadd_<mode><sd_maskz_name><round_name>"
3172   [(set (match_operand:VF_512 0 "register_operand" "=v,v,v")
3173         (unspec:VF_512
3174           [(match_operand:VF_512   1 "<round_nimm_predicate>" "%0,0,v")
3175            (match_operand:VF_512   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>")
3176            (neg:VF_512
3177              (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>,0"))]
3178           UNSPEC_FMADDSUB))]
3179   "TARGET_AVX512F && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3180   "@
3181    vfmsubadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3182    vfmsubadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3183    vfmsubadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}"
3184   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f")
3185    (set_attr "type" "ssemuladd")
3186    (set_attr "mode" "<MODE>")])
3187
3188 (define_insn "avx512f_fmsubadd_<mode>_mask<round_name>"
3189   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
3190         (vec_merge:VF_512
3191           (unspec:VF_512
3192             [(match_operand:VF_512 1 "register_operand" "0,0")
3193              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
3194              (neg:VF_512
3195                (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))]
3196             UNSPEC_FMADDSUB)
3197           (match_dup 1)
3198           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
3199   "TARGET_AVX512F"
3200   "@
3201    vfmsubadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
3202    vfmsubadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
3203   [(set_attr "isa" "fma_avx512f,fma_avx512f")
3204    (set_attr "type" "ssemuladd")
3205    (set_attr "mode" "<MODE>")])
3206
3207 (define_insn "avx512f_fmsubadd_<mode>_mask3<round_name>"
3208   [(set (match_operand:VF_512 0 "register_operand" "=v")
3209         (vec_merge:VF_512
3210           (unspec:VF_512
3211             [(match_operand:VF_512 1 "register_operand" "v")
3212              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
3213              (neg:VF_512
3214                (match_operand:VF_512 3 "register_operand" "0"))]
3215             UNSPEC_FMADDSUB)
3216           (match_dup 3)
3217           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
3218   "TARGET_AVX512F"
3219   "vfmsubadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
3220   [(set_attr "isa" "fma_avx512f")
3221    (set_attr "type" "ssemuladd")
3222    (set_attr "mode" "<MODE>")])
3223
3224 ;; FMA3 floating point scalar intrinsics. These merge result with
3225 ;; high-order elements from the destination register.
3226
3227 (define_expand "fmai_vmfmadd_<mode><round_name>"
3228   [(set (match_operand:VF_128 0 "register_operand")
3229         (vec_merge:VF_128
3230           (fma:VF_128
3231             (match_operand:VF_128 1 "<round_nimm_predicate>")
3232             (match_operand:VF_128 2 "<round_nimm_predicate>")
3233             (match_operand:VF_128 3 "<round_nimm_predicate>"))
3234           (match_dup 1)
3235           (const_int 1)))]
3236   "TARGET_FMA")
3237
3238 (define_insn "*fmai_fmadd_<mode>"
3239   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3240         (vec_merge:VF_128
3241           (fma:VF_128
3242             (match_operand:VF_128 1 "<round_nimm_predicate>" " 0, 0")
3243             (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>, v")
3244             (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>"))
3245           (match_dup 1)
3246           (const_int 1)))]
3247   "TARGET_FMA || TARGET_AVX512F"
3248   "@
3249    vfmadd132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3250    vfmadd213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3251   [(set_attr "type" "ssemuladd")
3252    (set_attr "mode" "<MODE>")])
3253
3254 (define_insn "*fmai_fmsub_<mode>"
3255   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3256         (vec_merge:VF_128
3257           (fma:VF_128
3258             (match_operand:VF_128   1 "<round_nimm_predicate>" "0,0")
3259             (match_operand:VF_128   2 "<round_nimm_predicate>" "<round_constraint>,v")
3260             (neg:VF_128
3261               (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>")))
3262           (match_dup 1)
3263           (const_int 1)))]
3264   "TARGET_FMA || TARGET_AVX512F"
3265   "@
3266    vfmsub132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3267    vfmsub213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3268   [(set_attr "type" "ssemuladd")
3269    (set_attr "mode" "<MODE>")])
3270
3271 (define_insn "*fmai_fnmadd_<mode><round_name>"
3272   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3273         (vec_merge:VF_128
3274           (fma:VF_128
3275             (neg:VF_128
3276               (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>,v"))
3277             (match_operand:VF_128   1 "<round_nimm_predicate>" "0,0")
3278             (match_operand:VF_128   3 "<round_nimm_predicate>" "v,<round_constraint>"))
3279           (match_dup 1)
3280           (const_int 1)))]
3281   "TARGET_FMA || TARGET_AVX512F"
3282   "@
3283    vfnmadd132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3284    vfnmadd213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3285   [(set_attr "type" "ssemuladd")
3286    (set_attr "mode" "<MODE>")])
3287
3288 (define_insn "*fmai_fnmsub_<mode><round_name>"
3289   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3290         (vec_merge:VF_128
3291           (fma:VF_128
3292             (neg:VF_128
3293               (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>, v"))
3294             (match_operand:VF_128   1 "<round_nimm_predicate>" " 0, 0")
3295             (neg:VF_128
3296               (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>")))
3297           (match_dup 1)
3298           (const_int 1)))]
3299   "TARGET_FMA || TARGET_AVX512F"
3300   "@
3301    vfnmsub132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3302    vfnmsub213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3303   [(set_attr "type" "ssemuladd")
3304    (set_attr "mode" "<MODE>")])
3305
3306 ;; FMA4 floating point scalar intrinsics.  These write the
3307 ;; entire destination register, with the high-order elements zeroed.
3308
3309 (define_expand "fma4i_vmfmadd_<mode>"
3310   [(set (match_operand:VF_128 0 "register_operand")
3311         (vec_merge:VF_128
3312           (fma:VF_128
3313             (match_operand:VF_128 1 "nonimmediate_operand")
3314             (match_operand:VF_128 2 "nonimmediate_operand")
3315             (match_operand:VF_128 3 "nonimmediate_operand"))
3316           (match_dup 4)
3317           (const_int 1)))]
3318   "TARGET_FMA4"
3319   "operands[4] = CONST0_RTX (<MODE>mode);")
3320
3321 (define_insn "*fma4i_vmfmadd_<mode>"
3322   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3323         (vec_merge:VF_128
3324           (fma:VF_128
3325             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
3326             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
3327             (match_operand:VF_128 3 "nonimmediate_operand" "xm,x"))
3328           (match_operand:VF_128 4 "const0_operand")
3329           (const_int 1)))]
3330   "TARGET_FMA4"
3331   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3332   [(set_attr "type" "ssemuladd")
3333    (set_attr "mode" "<MODE>")])
3334
3335 (define_insn "*fma4i_vmfmsub_<mode>"
3336   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3337         (vec_merge:VF_128
3338           (fma:VF_128
3339             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
3340             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
3341             (neg:VF_128
3342               (match_operand:VF_128 3 "nonimmediate_operand" "xm,x")))
3343           (match_operand:VF_128 4 "const0_operand")
3344           (const_int 1)))]
3345   "TARGET_FMA4"
3346   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3347   [(set_attr "type" "ssemuladd")
3348    (set_attr "mode" "<MODE>")])
3349
3350 (define_insn "*fma4i_vmfnmadd_<mode>"
3351   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3352         (vec_merge:VF_128
3353           (fma:VF_128
3354             (neg:VF_128
3355               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
3356             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
3357             (match_operand:VF_128   3 "nonimmediate_operand" "xm,x"))
3358           (match_operand:VF_128 4 "const0_operand")
3359           (const_int 1)))]
3360   "TARGET_FMA4"
3361   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3362   [(set_attr "type" "ssemuladd")
3363    (set_attr "mode" "<MODE>")])
3364
3365 (define_insn "*fma4i_vmfnmsub_<mode>"
3366   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3367         (vec_merge:VF_128
3368           (fma:VF_128
3369             (neg:VF_128
3370               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
3371             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
3372             (neg:VF_128
3373               (match_operand:VF_128   3 "nonimmediate_operand" "xm,x")))
3374           (match_operand:VF_128 4 "const0_operand")
3375           (const_int 1)))]
3376   "TARGET_FMA4"
3377   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3378   [(set_attr "type" "ssemuladd")
3379    (set_attr "mode" "<MODE>")])
3380
3381 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3382 ;;
3383 ;; Parallel single-precision floating point conversion operations
3384 ;;
3385 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3386
3387 (define_insn "sse_cvtpi2ps"
3388   [(set (match_operand:V4SF 0 "register_operand" "=x")
3389         (vec_merge:V4SF
3390           (vec_duplicate:V4SF
3391             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
3392           (match_operand:V4SF 1 "register_operand" "0")
3393           (const_int 3)))]
3394   "TARGET_SSE"
3395   "cvtpi2ps\t{%2, %0|%0, %2}"
3396   [(set_attr "type" "ssecvt")
3397    (set_attr "mode" "V4SF")])
3398
3399 (define_insn "sse_cvtps2pi"
3400   [(set (match_operand:V2SI 0 "register_operand" "=y")
3401         (vec_select:V2SI
3402           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
3403                        UNSPEC_FIX_NOTRUNC)
3404           (parallel [(const_int 0) (const_int 1)])))]
3405   "TARGET_SSE"
3406   "cvtps2pi\t{%1, %0|%0, %q1}"
3407   [(set_attr "type" "ssecvt")
3408    (set_attr "unit" "mmx")
3409    (set_attr "mode" "DI")])
3410
3411 (define_insn "sse_cvttps2pi"
3412   [(set (match_operand:V2SI 0 "register_operand" "=y")
3413         (vec_select:V2SI
3414           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
3415           (parallel [(const_int 0) (const_int 1)])))]
3416   "TARGET_SSE"
3417   "cvttps2pi\t{%1, %0|%0, %q1}"
3418   [(set_attr "type" "ssecvt")
3419    (set_attr "unit" "mmx")
3420    (set_attr "prefix_rep" "0")
3421    (set_attr "mode" "SF")])
3422
3423 (define_insn "sse_cvtsi2ss<round_name>"
3424   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
3425         (vec_merge:V4SF
3426           (vec_duplicate:V4SF
3427             (float:SF (match_operand:SI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3428           (match_operand:V4SF 1 "register_operand" "0,0,v")
3429           (const_int 1)))]
3430   "TARGET_SSE"
3431   "@
3432    cvtsi2ss\t{%2, %0|%0, %2}
3433    cvtsi2ss\t{%2, %0|%0, %2}
3434    vcvtsi2ss\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3435   [(set_attr "isa" "noavx,noavx,avx")
3436    (set_attr "type" "sseicvt")
3437    (set_attr "athlon_decode" "vector,double,*")
3438    (set_attr "amdfam10_decode" "vector,double,*")
3439    (set_attr "bdver1_decode" "double,direct,*")
3440    (set_attr "btver2_decode" "double,double,double")
3441    (set_attr "prefix" "orig,orig,maybe_evex")
3442    (set_attr "mode" "SF")])
3443
3444 (define_insn "sse_cvtsi2ssq<round_name>"
3445   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
3446         (vec_merge:V4SF
3447           (vec_duplicate:V4SF
3448             (float:SF (match_operand:DI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3449           (match_operand:V4SF 1 "register_operand" "0,0,v")
3450           (const_int 1)))]
3451   "TARGET_SSE && TARGET_64BIT"
3452   "@
3453    cvtsi2ssq\t{%2, %0|%0, %2}
3454    cvtsi2ssq\t{%2, %0|%0, %2}
3455    vcvtsi2ssq\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3456   [(set_attr "isa" "noavx,noavx,avx")
3457    (set_attr "type" "sseicvt")
3458    (set_attr "athlon_decode" "vector,double,*")
3459    (set_attr "amdfam10_decode" "vector,double,*")
3460    (set_attr "bdver1_decode" "double,direct,*")
3461    (set_attr "btver2_decode" "double,double,double")
3462    (set_attr "length_vex" "*,*,4")
3463    (set_attr "prefix_rex" "1,1,*")
3464    (set_attr "prefix" "orig,orig,maybe_evex")
3465    (set_attr "mode" "SF")])
3466
3467 (define_insn "sse_cvtss2si<round_name>"
3468   [(set (match_operand:SI 0 "register_operand" "=r,r")
3469         (unspec:SI
3470           [(vec_select:SF
3471              (match_operand:V4SF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3472              (parallel [(const_int 0)]))]
3473           UNSPEC_FIX_NOTRUNC))]
3474   "TARGET_SSE"
3475   "%vcvtss2si\t{<round_op2>%1, %0|%0, %k1<round_op2>}"
3476   [(set_attr "type" "sseicvt")
3477    (set_attr "athlon_decode" "double,vector")
3478    (set_attr "bdver1_decode" "double,double")
3479    (set_attr "prefix_rep" "1")
3480    (set_attr "prefix" "maybe_vex")
3481    (set_attr "mode" "SI")])
3482
3483 (define_insn "sse_cvtss2si_2"
3484   [(set (match_operand:SI 0 "register_operand" "=r,r")
3485         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "v,m")]
3486                    UNSPEC_FIX_NOTRUNC))]
3487   "TARGET_SSE"
3488   "%vcvtss2si\t{%1, %0|%0, %k1}"
3489   [(set_attr "type" "sseicvt")
3490    (set_attr "athlon_decode" "double,vector")
3491    (set_attr "amdfam10_decode" "double,double")
3492    (set_attr "bdver1_decode" "double,double")
3493    (set_attr "prefix_rep" "1")
3494    (set_attr "prefix" "maybe_vex")
3495    (set_attr "mode" "SI")])
3496
3497 (define_insn "sse_cvtss2siq<round_name>"
3498   [(set (match_operand:DI 0 "register_operand" "=r,r")
3499         (unspec:DI
3500           [(vec_select:SF
3501              (match_operand:V4SF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3502              (parallel [(const_int 0)]))]
3503           UNSPEC_FIX_NOTRUNC))]
3504   "TARGET_SSE && TARGET_64BIT"
3505   "%vcvtss2si{q}\t{<round_op2>%1, %0|%0, %k1<round_op2>}"
3506   [(set_attr "type" "sseicvt")
3507    (set_attr "athlon_decode" "double,vector")
3508    (set_attr "bdver1_decode" "double,double")
3509    (set_attr "prefix_rep" "1")
3510    (set_attr "prefix" "maybe_vex")
3511    (set_attr "mode" "DI")])
3512
3513 (define_insn "sse_cvtss2siq_2"
3514   [(set (match_operand:DI 0 "register_operand" "=r,r")
3515         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "v,m")]
3516                    UNSPEC_FIX_NOTRUNC))]
3517   "TARGET_SSE && TARGET_64BIT"
3518   "%vcvtss2si{q}\t{%1, %0|%0, %k1}"
3519   [(set_attr "type" "sseicvt")
3520    (set_attr "athlon_decode" "double,vector")
3521    (set_attr "amdfam10_decode" "double,double")
3522    (set_attr "bdver1_decode" "double,double")
3523    (set_attr "prefix_rep" "1")
3524    (set_attr "prefix" "maybe_vex")
3525    (set_attr "mode" "DI")])
3526
3527 (define_insn "sse_cvttss2si<round_saeonly_name>"
3528   [(set (match_operand:SI 0 "register_operand" "=r,r")
3529         (fix:SI
3530           (vec_select:SF
3531             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3532             (parallel [(const_int 0)]))))]
3533   "TARGET_SSE"
3534   "%vcvttss2si\t{<round_saeonly_op2>%1, %0|%0, %k1<round_saeonly_op2>}"
3535   [(set_attr "type" "sseicvt")
3536    (set_attr "athlon_decode" "double,vector")
3537    (set_attr "amdfam10_decode" "double,double")
3538    (set_attr "bdver1_decode" "double,double")
3539    (set_attr "prefix_rep" "1")
3540    (set_attr "prefix" "maybe_vex")
3541    (set_attr "mode" "SI")])
3542
3543 (define_insn "sse_cvttss2siq<round_saeonly_name>"
3544   [(set (match_operand:DI 0 "register_operand" "=r,r")
3545         (fix:DI
3546           (vec_select:SF
3547             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint>")
3548             (parallel [(const_int 0)]))))]
3549   "TARGET_SSE && TARGET_64BIT"
3550   "%vcvttss2si{q}\t{<round_saeonly_op2>%1, %0|%0, %k1<round_saeonly_op2>}"
3551   [(set_attr "type" "sseicvt")
3552    (set_attr "athlon_decode" "double,vector")
3553    (set_attr "amdfam10_decode" "double,double")
3554    (set_attr "bdver1_decode" "double,double")
3555    (set_attr "prefix_rep" "1")
3556    (set_attr "prefix" "maybe_vex")
3557    (set_attr "mode" "DI")])
3558
3559 (define_insn "cvtusi2<ssescalarmodesuffix>32<round_name>"
3560   [(set (match_operand:VF_128 0 "register_operand" "=v")
3561         (vec_merge:VF_128
3562           (vec_duplicate:VF_128
3563             (unsigned_float:<ssescalarmode>
3564               (match_operand:SI 2 "<round_nimm_predicate>" "<round_constraint3>")))
3565           (match_operand:VF_128 1 "register_operand" "v")
3566           (const_int 1)))]
3567   "TARGET_AVX512F && <round_modev4sf_condition>"
3568   "vcvtusi2<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3569   [(set_attr "type" "sseicvt")
3570    (set_attr "prefix" "evex")
3571    (set_attr "mode" "<ssescalarmode>")])
3572
3573 (define_insn "cvtusi2<ssescalarmodesuffix>64<round_name>"
3574   [(set (match_operand:VF_128 0 "register_operand" "=v")
3575         (vec_merge:VF_128
3576           (vec_duplicate:VF_128
3577             (unsigned_float:<ssescalarmode>
3578               (match_operand:DI 2 "<round_nimm_predicate>" "<round_constraint3>")))
3579           (match_operand:VF_128 1 "register_operand" "v")
3580           (const_int 1)))]
3581   "TARGET_AVX512F && TARGET_64BIT"
3582   "vcvtusi2<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3583   [(set_attr "type" "sseicvt")
3584    (set_attr "prefix" "evex")
3585    (set_attr "mode" "<ssescalarmode>")])
3586
3587 (define_insn "float<sseintvecmodelower><mode>2<mask_name><round_name>"
3588   [(set (match_operand:VF1 0 "register_operand" "=v")
3589         (float:VF1
3590           (match_operand:<sseintvecmode> 1 "<round_nimm_predicate>" "<round_constraint>")))]
3591   "TARGET_SSE2 && <mask_mode512bit_condition> && <round_mode512bit_condition>"
3592   "%vcvtdq2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3593   [(set_attr "type" "ssecvt")
3594    (set_attr "prefix" "maybe_vex")
3595    (set_attr "mode" "<sseinsnmode>")])
3596
3597 (define_insn "ufloatv16siv16sf2<mask_name><round_name>"
3598   [(set (match_operand:V16SF 0 "register_operand" "=v")
3599         (unsigned_float:V16SF
3600           (match_operand:V16SI 1 "<round_nimm_predicate>" "<round_constraint>")))]
3601   "TARGET_AVX512F"
3602   "vcvtudq2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3603   [(set_attr "type" "ssecvt")
3604    (set_attr "prefix" "evex")
3605    (set_attr "mode" "V16SF")])
3606
3607 (define_expand "floatuns<sseintvecmodelower><mode>2"
3608   [(match_operand:VF1 0 "register_operand")
3609    (match_operand:<sseintvecmode> 1 "register_operand")]
3610   "TARGET_SSE2 && (<MODE>mode == V4SFmode || TARGET_AVX2)"
3611 {
3612   if (<MODE>mode == V16SFmode)
3613     emit_insn (gen_ufloatv16siv16sf2 (operands[0], operands[1]));
3614   else
3615     ix86_expand_vector_convert_uns_vsivsf (operands[0], operands[1]);
3616
3617   DONE;
3618 })
3619
3620
3621 ;; For <sse2_avx_avx512f>_fix_notrunc<sf2simodelower><mode> insn pattern
3622 (define_mode_attr sf2simodelower
3623   [(V16SI "v16sf") (V8SI "v8sf") (V4SI "v4sf")])
3624
3625 (define_insn "<sse2_avx_avx512f>_fix_notrunc<sf2simodelower><mode>"
3626   [(set (match_operand:VI4_AVX 0 "register_operand" "=v")
3627         (unspec:VI4_AVX
3628           [(match_operand:<ssePSmode> 1 "nonimmediate_operand" "vm")]
3629           UNSPEC_FIX_NOTRUNC))]
3630   "TARGET_SSE2"
3631   "%vcvtps2dq\t{%1, %0|%0, %1}"
3632   [(set_attr "type" "ssecvt")
3633    (set (attr "prefix_data16")
3634      (if_then_else
3635        (match_test "TARGET_AVX")
3636      (const_string "*")
3637      (const_string "1")))
3638    (set_attr "prefix" "maybe_vex")
3639    (set_attr "mode" "<sseinsnmode>")])
3640
3641 (define_insn "<mask_codefor>avx512f_fix_notruncv16sfv16si<mask_name><round_name>"
3642   [(set (match_operand:V16SI 0 "register_operand" "=v")
3643         (unspec:V16SI
3644           [(match_operand:V16SF 1 "<round_nimm_predicate>" "<round_constraint>")]
3645           UNSPEC_FIX_NOTRUNC))]
3646   "TARGET_AVX512F"
3647   "vcvtps2dq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3648   [(set_attr "type" "ssecvt")
3649    (set_attr "prefix" "evex")
3650    (set_attr "mode" "XI")])
3651
3652 (define_insn "<mask_codefor>avx512f_ufix_notruncv16sfv16si<mask_name><round_name>"
3653   [(set (match_operand:V16SI 0 "register_operand" "=v")
3654         (unspec:V16SI
3655           [(match_operand:V16SF 1 "<round_nimm_predicate>" "<round_constraint>")]
3656           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3657   "TARGET_AVX512F"
3658   "vcvtps2udq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3659   [(set_attr "type" "ssecvt")
3660    (set_attr "prefix" "evex")
3661    (set_attr "mode" "XI")])
3662
3663 (define_insn "<fixsuffix>fix_truncv16sfv16si2<mask_name><round_saeonly_name>"
3664   [(set (match_operand:V16SI 0 "register_operand" "=v")
3665         (any_fix:V16SI
3666           (match_operand:V16SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
3667   "TARGET_AVX512F"
3668   "vcvttps2<fixsuffix>dq\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
3669   [(set_attr "type" "ssecvt")
3670    (set_attr "prefix" "evex")
3671    (set_attr "mode" "XI")])
3672
3673 (define_insn "fix_truncv8sfv8si2"
3674   [(set (match_operand:V8SI 0 "register_operand" "=x")
3675         (fix:V8SI (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
3676   "TARGET_AVX"
3677   "vcvttps2dq\t{%1, %0|%0, %1}"
3678   [(set_attr "type" "ssecvt")
3679    (set_attr "prefix" "vex")
3680    (set_attr "mode" "OI")])
3681
3682 (define_insn "fix_truncv4sfv4si2"
3683   [(set (match_operand:V4SI 0 "register_operand" "=x")
3684         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3685   "TARGET_SSE2"
3686   "%vcvttps2dq\t{%1, %0|%0, %1}"
3687   [(set_attr "type" "ssecvt")
3688    (set (attr "prefix_rep")
3689      (if_then_else
3690        (match_test "TARGET_AVX")
3691      (const_string "*")
3692      (const_string "1")))
3693    (set (attr "prefix_data16")
3694      (if_then_else
3695        (match_test "TARGET_AVX")
3696      (const_string "*")
3697      (const_string "0")))
3698    (set_attr "prefix_data16" "0")
3699    (set_attr "prefix" "maybe_vex")
3700    (set_attr "mode" "TI")])
3701
3702 (define_expand "fixuns_trunc<mode><sseintvecmodelower>2"
3703   [(match_operand:<sseintvecmode> 0 "register_operand")
3704    (match_operand:VF1 1 "register_operand")]
3705   "TARGET_SSE2"
3706 {
3707   if (<MODE>mode == V16SFmode)
3708     emit_insn (gen_ufix_truncv16sfv16si2 (operands[0],
3709                                           operands[1]));
3710   else
3711     {
3712       rtx tmp[3];
3713       tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
3714       tmp[1] = gen_reg_rtx (<sseintvecmode>mode);
3715       emit_insn (gen_fix_trunc<mode><sseintvecmodelower>2 (tmp[1], tmp[0]));
3716       emit_insn (gen_xor<sseintvecmodelower>3 (operands[0], tmp[1], tmp[2]));
3717     }
3718   DONE;
3719 })
3720
3721 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3722 ;;
3723 ;; Parallel double-precision floating point conversion operations
3724 ;;
3725 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3726
3727 (define_insn "sse2_cvtpi2pd"
3728   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
3729         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
3730   "TARGET_SSE2"
3731   "cvtpi2pd\t{%1, %0|%0, %1}"
3732   [(set_attr "type" "ssecvt")
3733    (set_attr "unit" "mmx,*")
3734    (set_attr "prefix_data16" "1,*")
3735    (set_attr "mode" "V2DF")])
3736
3737 (define_insn "sse2_cvtpd2pi"
3738   [(set (match_operand:V2SI 0 "register_operand" "=y")
3739         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
3740                      UNSPEC_FIX_NOTRUNC))]
3741   "TARGET_SSE2"
3742   "cvtpd2pi\t{%1, %0|%0, %1}"
3743   [(set_attr "type" "ssecvt")
3744    (set_attr "unit" "mmx")
3745    (set_attr "bdver1_decode" "double")
3746    (set_attr "btver2_decode" "direct")
3747    (set_attr "prefix_data16" "1")
3748    (set_attr "mode" "DI")])
3749
3750 (define_insn "sse2_cvttpd2pi"
3751   [(set (match_operand:V2SI 0 "register_operand" "=y")
3752         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
3753   "TARGET_SSE2"
3754   "cvttpd2pi\t{%1, %0|%0, %1}"
3755   [(set_attr "type" "ssecvt")
3756    (set_attr "unit" "mmx")
3757    (set_attr "bdver1_decode" "double")
3758    (set_attr "prefix_data16" "1")
3759    (set_attr "mode" "TI")])
3760
3761 (define_insn "sse2_cvtsi2sd"
3762   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
3763         (vec_merge:V2DF
3764           (vec_duplicate:V2DF
3765             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
3766           (match_operand:V2DF 1 "register_operand" "0,0,x")
3767           (const_int 1)))]
3768   "TARGET_SSE2"
3769   "@
3770    cvtsi2sd\t{%2, %0|%0, %2}
3771    cvtsi2sd\t{%2, %0|%0, %2}
3772    vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
3773   [(set_attr "isa" "noavx,noavx,avx")
3774    (set_attr "type" "sseicvt")
3775    (set_attr "athlon_decode" "double,direct,*")
3776    (set_attr "amdfam10_decode" "vector,double,*")
3777    (set_attr "bdver1_decode" "double,direct,*")
3778    (set_attr "btver2_decode" "double,double,double")
3779    (set_attr "prefix" "orig,orig,vex")
3780    (set_attr "mode" "DF")])
3781
3782 (define_insn "sse2_cvtsi2sdq<round_name>"
3783   [(set (match_operand:V2DF 0 "register_operand" "=x,x,v")
3784         (vec_merge:V2DF
3785           (vec_duplicate:V2DF
3786             (float:DF (match_operand:DI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3787           (match_operand:V2DF 1 "register_operand" "0,0,v")
3788           (const_int 1)))]
3789   "TARGET_SSE2 && TARGET_64BIT"
3790   "@
3791    cvtsi2sdq\t{%2, %0|%0, %2}
3792    cvtsi2sdq\t{%2, %0|%0, %2}
3793    vcvtsi2sdq\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3794   [(set_attr "isa" "noavx,noavx,avx")
3795    (set_attr "type" "sseicvt")
3796    (set_attr "athlon_decode" "double,direct,*")
3797    (set_attr "amdfam10_decode" "vector,double,*")
3798    (set_attr "bdver1_decode" "double,direct,*")
3799    (set_attr "length_vex" "*,*,4")
3800    (set_attr "prefix_rex" "1,1,*")
3801    (set_attr "prefix" "orig,orig,maybe_evex")
3802    (set_attr "mode" "DF")])
3803
3804 (define_insn "avx512f_vcvtss2usi<round_name>"
3805   [(set (match_operand:SI 0 "register_operand" "=r")
3806         (unspec:SI
3807           [(vec_select:SF
3808              (match_operand:V4SF 1 "<round_nimm_predicate>" "<round_constraint>")
3809              (parallel [(const_int 0)]))]
3810           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3811   "TARGET_AVX512F"
3812   "vcvtss2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3813   [(set_attr "type" "sseicvt")
3814    (set_attr "prefix" "evex")
3815    (set_attr "mode" "SI")])
3816
3817 (define_insn "avx512f_vcvtss2usiq<round_name>"
3818   [(set (match_operand:DI 0 "register_operand" "=r")
3819         (unspec:DI
3820           [(vec_select:SF
3821              (match_operand:V4SF 1 "<round_nimm_predicate>" "<round_constraint>")
3822              (parallel [(const_int 0)]))]
3823           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3824   "TARGET_AVX512F && TARGET_64BIT"
3825   "vcvtss2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3826   [(set_attr "type" "sseicvt")
3827    (set_attr "prefix" "evex")
3828    (set_attr "mode" "DI")])
3829
3830 (define_insn "avx512f_vcvttss2usi<round_saeonly_name>"
3831   [(set (match_operand:SI 0 "register_operand" "=r")
3832         (unsigned_fix:SI
3833           (vec_select:SF
3834             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3835             (parallel [(const_int 0)]))))]
3836   "TARGET_AVX512F"
3837   "vcvttss2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3838   [(set_attr "type" "sseicvt")
3839    (set_attr "prefix" "evex")
3840    (set_attr "mode" "SI")])
3841
3842 (define_insn "avx512f_vcvttss2usiq<round_saeonly_name>"
3843   [(set (match_operand:DI 0 "register_operand" "=r")
3844         (unsigned_fix:DI
3845           (vec_select:SF
3846             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3847             (parallel [(const_int 0)]))))]
3848   "TARGET_AVX512F && TARGET_64BIT"
3849   "vcvttss2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3850   [(set_attr "type" "sseicvt")
3851    (set_attr "prefix" "evex")
3852    (set_attr "mode" "DI")])
3853
3854 (define_insn "avx512f_vcvtsd2usi<round_name>"
3855   [(set (match_operand:SI 0 "register_operand" "=r")
3856         (unspec:SI
3857           [(vec_select:DF
3858              (match_operand:V2DF 1 "<round_nimm_predicate>" "<round_constraint>")
3859              (parallel [(const_int 0)]))]
3860           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3861   "TARGET_AVX512F"
3862   "vcvtsd2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3863   [(set_attr "type" "sseicvt")
3864    (set_attr "prefix" "evex")
3865    (set_attr "mode" "SI")])
3866
3867 (define_insn "avx512f_vcvtsd2usiq<round_name>"
3868   [(set (match_operand:DI 0 "register_operand" "=r")
3869         (unspec:DI
3870           [(vec_select:DF
3871              (match_operand:V2DF 1 "<round_nimm_predicate>" "<round_constraint>")
3872              (parallel [(const_int 0)]))]
3873           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3874   "TARGET_AVX512F && TARGET_64BIT"
3875   "vcvtsd2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3876   [(set_attr "type" "sseicvt")
3877    (set_attr "prefix" "evex")
3878    (set_attr "mode" "DI")])
3879
3880 (define_insn "avx512f_vcvttsd2usi<round_saeonly_name>"
3881   [(set (match_operand:SI 0 "register_operand" "=r")
3882         (unsigned_fix:SI
3883           (vec_select:DF
3884             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3885             (parallel [(const_int 0)]))))]
3886   "TARGET_AVX512F"
3887   "vcvttsd2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3888   [(set_attr "type" "sseicvt")
3889    (set_attr "prefix" "evex")
3890    (set_attr "mode" "SI")])
3891
3892 (define_insn "avx512f_vcvttsd2usiq<round_saeonly_name>"
3893   [(set (match_operand:DI 0 "register_operand" "=r")
3894         (unsigned_fix:DI
3895           (vec_select:DF
3896             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3897             (parallel [(const_int 0)]))))]
3898   "TARGET_AVX512F && TARGET_64BIT"
3899   "vcvttsd2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3900   [(set_attr "type" "sseicvt")
3901    (set_attr "prefix" "evex")
3902    (set_attr "mode" "DI")])
3903
3904 (define_insn "sse2_cvtsd2si<round_name>"
3905   [(set (match_operand:SI 0 "register_operand" "=r,r")
3906         (unspec:SI
3907           [(vec_select:DF
3908              (match_operand:V2DF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3909              (parallel [(const_int 0)]))]
3910           UNSPEC_FIX_NOTRUNC))]
3911   "TARGET_SSE2"
3912   "%vcvtsd2si\t{<round_op2>%1, %0|%0, %q1<round_op2>}"
3913   [(set_attr "type" "sseicvt")
3914    (set_attr "athlon_decode" "double,vector")
3915    (set_attr "bdver1_decode" "double,double")
3916    (set_attr "btver2_decode" "double,double")
3917    (set_attr "prefix_rep" "1")
3918    (set_attr "prefix" "maybe_vex")
3919    (set_attr "mode" "SI")])
3920
3921 (define_insn "sse2_cvtsd2si_2"
3922   [(set (match_operand:SI 0 "register_operand" "=r,r")
3923         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "v,m")]
3924                    UNSPEC_FIX_NOTRUNC))]
3925   "TARGET_SSE2"
3926   "%vcvtsd2si\t{%1, %0|%0, %q1}"
3927   [(set_attr "type" "sseicvt")
3928    (set_attr "athlon_decode" "double,vector")
3929    (set_attr "amdfam10_decode" "double,double")
3930    (set_attr "bdver1_decode" "double,double")
3931    (set_attr "prefix_rep" "1")
3932    (set_attr "prefix" "maybe_vex")
3933    (set_attr "mode" "SI")])
3934
3935 (define_insn "sse2_cvtsd2siq<round_name>"
3936   [(set (match_operand:DI 0 "register_operand" "=r,r")
3937         (unspec:DI
3938           [(vec_select:DF
3939              (match_operand:V2DF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3940              (parallel [(const_int 0)]))]
3941           UNSPEC_FIX_NOTRUNC))]
3942   "TARGET_SSE2 && TARGET_64BIT"
3943   "%vcvtsd2si{q}\t{<round_op2>%1, %0|%0, %q1<round_op2>}"
3944   [(set_attr "type" "sseicvt")
3945    (set_attr "athlon_decode" "double,vector")
3946    (set_attr "bdver1_decode" "double,double")
3947    (set_attr "prefix_rep" "1")
3948    (set_attr "prefix" "maybe_vex")
3949    (set_attr "mode" "DI")])
3950
3951 (define_insn "sse2_cvtsd2siq_2"
3952   [(set (match_operand:DI 0 "register_operand" "=r,r")
3953         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "v,m")]
3954                    UNSPEC_FIX_NOTRUNC))]
3955   "TARGET_SSE2 && TARGET_64BIT"
3956   "%vcvtsd2si{q}\t{%1, %0|%0, %q1}"
3957   [(set_attr "type" "sseicvt")
3958    (set_attr "athlon_decode" "double,vector")
3959    (set_attr "amdfam10_decode" "double,double")
3960    (set_attr "bdver1_decode" "double,double")
3961    (set_attr "prefix_rep" "1")
3962    (set_attr "prefix" "maybe_vex")
3963    (set_attr "mode" "DI")])
3964
3965 (define_insn "sse2_cvttsd2si<round_saeonly_name>"
3966   [(set (match_operand:SI 0 "register_operand" "=r,r")
3967         (fix:SI
3968           (vec_select:DF
3969             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3970             (parallel [(const_int 0)]))))]
3971   "TARGET_SSE2"
3972   "%vcvttsd2si\t{<round_saeonly_op2>%1, %0|%0, %q1<round_saeonly_op2>}"
3973   [(set_attr "type" "sseicvt")
3974    (set_attr "athlon_decode" "double,vector")
3975    (set_attr "amdfam10_decode" "double,double")
3976    (set_attr "bdver1_decode" "double,double")
3977    (set_attr "btver2_decode" "double,double")
3978    (set_attr "prefix_rep" "1")
3979    (set_attr "prefix" "maybe_vex")
3980    (set_attr "mode" "SI")])
3981
3982 (define_insn "sse2_cvttsd2siq<round_saeonly_name>"
3983   [(set (match_operand:DI 0 "register_operand" "=r,r")
3984         (fix:DI
3985           (vec_select:DF
3986             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3987             (parallel [(const_int 0)]))))]
3988   "TARGET_SSE2 && TARGET_64BIT"
3989   "%vcvttsd2si{q}\t{<round_saeonly_op2>%1, %0|%0, %q1<round_saeonly_op2>}"
3990   [(set_attr "type" "sseicvt")
3991    (set_attr "athlon_decode" "double,vector")
3992    (set_attr "amdfam10_decode" "double,double")
3993    (set_attr "bdver1_decode" "double,double")
3994    (set_attr "prefix_rep" "1")
3995    (set_attr "prefix" "maybe_vex")
3996    (set_attr "mode" "DI")])
3997
3998 ;; For float<si2dfmode><mode>2 insn pattern
3999 (define_mode_attr si2dfmode
4000   [(V8DF "V8SI") (V4DF "V4SI")])
4001 (define_mode_attr si2dfmodelower
4002   [(V8DF "v8si") (V4DF "v4si")])
4003
4004 (define_insn "float<si2dfmodelower><mode>2<mask_name>"
4005   [(set (match_operand:VF2_512_256 0 "register_operand" "=v")
4006         (float:VF2_512_256 (match_operand:<si2dfmode> 1 "nonimmediate_operand" "vm")))]
4007   "TARGET_AVX && <mask_mode512bit_condition>"
4008   "vcvtdq2pd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
4009   [(set_attr "type" "ssecvt")
4010    (set_attr "prefix" "maybe_vex")
4011    (set_attr "mode" "<MODE>")])
4012
4013 (define_insn "ufloatv8siv8df<mask_name>"
4014   [(set (match_operand:V8DF 0 "register_operand" "=v")
4015         (unsigned_float:V8DF
4016           (match_operand:V8SI 1 "nonimmediate_operand" "vm")))]
4017   "TARGET_AVX512F"
4018   "vcvtudq2pd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
4019   [(set_attr "type" "ssecvt")
4020    (set_attr "prefix" "evex")
4021    (set_attr "mode" "V8DF")])
4022
4023 (define_insn "avx512f_cvtdq2pd512_2"
4024   [(set (match_operand:V8DF 0 "register_operand" "=v")
4025         (float:V8DF
4026           (vec_select:V8SI
4027             (match_operand:V16SI 1 "nonimmediate_operand" "vm")
4028             (parallel [(const_int 0) (const_int 1)
4029                        (const_int 2) (const_int 3)
4030                        (const_int 4) (const_int 5)
4031                        (const_int 6) (const_int 7)]))))]
4032   "TARGET_AVX"
4033   "vcvtdq2pd\t{%t1, %0|%0, %t1}"
4034   [(set_attr "type" "ssecvt")
4035    (set_attr "prefix" "evex")
4036    (set_attr "mode" "V8DF")])
4037
4038 (define_insn "avx_cvtdq2pd256_2"
4039   [(set (match_operand:V4DF 0 "register_operand" "=x")
4040         (float:V4DF
4041           (vec_select:V4SI
4042             (match_operand:V8SI 1 "nonimmediate_operand" "xm")
4043             (parallel [(const_int 0) (const_int 1)
4044                        (const_int 2) (const_int 3)]))))]
4045   "TARGET_AVX"
4046   "vcvtdq2pd\t{%x1, %0|%0, %x1}"
4047   [(set_attr "type" "ssecvt")
4048    (set_attr "prefix" "vex")
4049    (set_attr "mode" "V4DF")])
4050
4051 (define_insn "sse2_cvtdq2pd"
4052   [(set (match_operand:V2DF 0 "register_operand" "=x")
4053         (float:V2DF
4054           (vec_select:V2SI
4055             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
4056             (parallel [(const_int 0) (const_int 1)]))))]
4057   "TARGET_SSE2"
4058   "%vcvtdq2pd\t{%1, %0|%0, %q1}"
4059   [(set_attr "type" "ssecvt")
4060    (set_attr "prefix" "maybe_vex")
4061    (set_attr "ssememalign" "64")
4062    (set_attr "mode" "V2DF")])
4063
4064 (define_insn "<mask_codefor>avx512f_cvtpd2dq512<mask_name><round_name>"
4065   [(set (match_operand:V8SI 0 "register_operand" "=v")
4066         (unspec:V8SI
4067           [(match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")]
4068           UNSPEC_FIX_NOTRUNC))]
4069   "TARGET_AVX512F"
4070   "vcvtpd2dq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
4071   [(set_attr "type" "ssecvt")
4072    (set_attr "prefix" "evex")
4073    (set_attr "mode" "OI")])
4074
4075 (define_insn "avx_cvtpd2dq256"
4076   [(set (match_operand:V4SI 0 "register_operand" "=x")
4077         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
4078                      UNSPEC_FIX_NOTRUNC))]
4079   "TARGET_AVX"
4080   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
4081   [(set_attr "type" "ssecvt")
4082    (set_attr "prefix" "vex")
4083    (set_attr "mode" "OI")])
4084
4085 (define_expand "avx_cvtpd2dq256_2"
4086   [(set (match_operand:V8SI 0 "register_operand")
4087         (vec_concat:V8SI
4088           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand")]
4089                        UNSPEC_FIX_NOTRUNC)
4090           (match_dup 2)))]
4091   "TARGET_AVX"
4092   "operands[2] = CONST0_RTX (V4SImode);")
4093
4094 (define_insn "*avx_cvtpd2dq256_2"
4095   [(set (match_operand:V8SI 0 "register_operand" "=x")
4096         (vec_concat:V8SI
4097           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
4098                        UNSPEC_FIX_NOTRUNC)
4099           (match_operand:V4SI 2 "const0_operand")))]
4100   "TARGET_AVX"
4101   "vcvtpd2dq{y}\t{%1, %x0|%x0, %1}"
4102   [(set_attr "type" "ssecvt")
4103    (set_attr "prefix" "vex")
4104    (set_attr "btver2_decode" "vector")
4105    (set_attr "mode" "OI")])
4106
4107 (define_expand "sse2_cvtpd2dq"
4108   [(set (match_operand:V4SI 0 "register_operand")
4109         (vec_concat:V4SI
4110           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand")]
4111                        UNSPEC_FIX_NOTRUNC)
4112           (match_dup 2)))]
4113   "TARGET_SSE2"
4114   "operands[2] = CONST0_RTX (V2SImode);")
4115
4116 (define_insn "*sse2_cvtpd2dq"
4117   [(set (match_operand:V4SI 0 "register_operand" "=x")
4118         (vec_concat:V4SI
4119           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
4120                        UNSPEC_FIX_NOTRUNC)
4121           (match_operand:V2SI 2 "const0_operand")))]
4122   "TARGET_SSE2"
4123 {
4124   if (TARGET_AVX)
4125     return "vcvtpd2dq{x}\t{%1, %0|%0, %1}";
4126   else
4127     return "cvtpd2dq\t{%1, %0|%0, %1}";
4128 }
4129   [(set_attr "type" "ssecvt")
4130    (set_attr "prefix_rep" "1")
4131    (set_attr "prefix_data16" "0")
4132    (set_attr "prefix" "maybe_vex")
4133    (set_attr "mode" "TI")
4134    (set_attr "amdfam10_decode" "double")
4135    (set_attr "athlon_decode" "vector")
4136    (set_attr "bdver1_decode" "double")])
4137
4138 (define_insn "avx512f_ufix_notruncv8dfv8si<mask_name><round_name>"
4139   [(set (match_operand:V8SI 0 "register_operand" "=v")
4140         (unspec:V8SI
4141           [(match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")]
4142           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
4143   "TARGET_AVX512F"
4144   "vcvtpd2udq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
4145   [(set_attr "type" "ssecvt")
4146    (set_attr "prefix" "evex")
4147    (set_attr "mode" "OI")])
4148
4149 (define_insn "<fixsuffix>fix_truncv8dfv8si2<mask_name><round_saeonly_name>"
4150   [(set (match_operand:V8SI 0 "register_operand" "=v")
4151         (any_fix:V8SI
4152           (match_operand:V8DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
4153   "TARGET_AVX512F"
4154   "vcvttpd2<fixsuffix>dq\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
4155   [(set_attr "type" "ssecvt")
4156    (set_attr "prefix" "evex")
4157    (set_attr "mode" "OI")])
4158
4159 (define_insn "fix_truncv4dfv4si2"
4160   [(set (match_operand:V4SI 0 "register_operand" "=x")
4161         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
4162   "TARGET_AVX"
4163   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
4164   [(set_attr "type" "ssecvt")
4165    (set_attr "prefix" "vex")
4166    (set_attr "mode" "OI")])
4167
4168 (define_expand "avx_cvttpd2dq256_2"
4169   [(set (match_operand:V8SI 0 "register_operand")
4170         (vec_concat:V8SI
4171           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand"))
4172           (match_dup 2)))]
4173   "TARGET_AVX"
4174   "operands[2] = CONST0_RTX (V4SImode);")
4175
4176 (define_insn "*avx_cvttpd2dq256_2"
4177   [(set (match_operand:V8SI 0 "register_operand" "=x")
4178         (vec_concat:V8SI
4179           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm"))
4180           (match_operand:V4SI 2 "const0_operand")))]
4181   "TARGET_AVX"
4182   "vcvttpd2dq{y}\t{%1, %x0|%x0, %1}"
4183   [(set_attr "type" "ssecvt")
4184    (set_attr "prefix" "vex")
4185    (set_attr "btver2_decode" "vector")
4186    (set_attr "mode" "OI")])
4187
4188 (define_expand "sse2_cvttpd2dq"
4189   [(set (match_operand:V4SI 0 "register_operand")
4190         (vec_concat:V4SI
4191           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand"))
4192           (match_dup 2)))]
4193   "TARGET_SSE2"
4194   "operands[2] = CONST0_RTX (V2SImode);")
4195
4196 (define_insn "*sse2_cvttpd2dq"
4197   [(set (match_operand:V4SI 0 "register_operand" "=x")
4198         (vec_concat:V4SI
4199           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
4200           (match_operand:V2SI 2 "const0_operand")))]
4201   "TARGET_SSE2"
4202 {
4203   if (TARGET_AVX)
4204     return "vcvttpd2dq{x}\t{%1, %0|%0, %1}";
4205   else
4206     return "cvttpd2dq\t{%1, %0|%0, %1}";
4207 }
4208   [(set_attr "type" "ssecvt")
4209    (set_attr "amdfam10_decode" "double")
4210    (set_attr "athlon_decode" "vector")
4211    (set_attr "bdver1_decode" "double")
4212    (set_attr "prefix" "maybe_vex")
4213    (set_attr "mode" "TI")])
4214
4215 (define_insn "sse2_cvtsd2ss<round_name>"
4216   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
4217         (vec_merge:V4SF
4218           (vec_duplicate:V4SF
4219             (float_truncate:V2SF
4220               (match_operand:V2DF 2 "nonimmediate_operand" "x,m,<round_constraint>")))
4221           (match_operand:V4SF 1 "register_operand" "0,0,v")
4222           (const_int 1)))]
4223   "TARGET_SSE2"
4224   "@
4225    cvtsd2ss\t{%2, %0|%0, %2}
4226    cvtsd2ss\t{%2, %0|%0, %q2}
4227    vcvtsd2ss\t{<round_op3>%2, %1, %0|%0, %1, %q2<round_op3>}"
4228   [(set_attr "isa" "noavx,noavx,avx")
4229    (set_attr "type" "ssecvt")
4230    (set_attr "athlon_decode" "vector,double,*")
4231    (set_attr "amdfam10_decode" "vector,double,*")
4232    (set_attr "bdver1_decode" "direct,direct,*")
4233    (set_attr "btver2_decode" "double,double,double")
4234    (set_attr "prefix" "orig,orig,<round_prefix>")
4235    (set_attr "mode" "SF")])
4236
4237 (define_insn "sse2_cvtss2sd<round_saeonly_name>"
4238   [(set (match_operand:V2DF 0 "register_operand" "=x,x,v")
4239         (vec_merge:V2DF
4240           (float_extend:V2DF
4241             (vec_select:V2SF
4242               (match_operand:V4SF 2 "nonimmediate_operand" "x,m,<round_saeonly_constraint>")
4243               (parallel [(const_int 0) (const_int 1)])))
4244           (match_operand:V2DF 1 "register_operand" "0,0,v")
4245           (const_int 1)))]
4246   "TARGET_SSE2"
4247   "@
4248    cvtss2sd\t{%2, %0|%0, %2}
4249    cvtss2sd\t{%2, %0|%0, %k2}
4250    vcvtss2sd\t{<round_saeonly_op3>%2, %1, %0|%0, %1, %k2<round_saeonly_op3>}"
4251   [(set_attr "isa" "noavx,noavx,avx")
4252    (set_attr "type" "ssecvt")
4253    (set_attr "amdfam10_decode" "vector,double,*")
4254    (set_attr "athlon_decode" "direct,direct,*")
4255    (set_attr "bdver1_decode" "direct,direct,*")
4256    (set_attr "btver2_decode" "double,double,double")
4257    (set_attr "prefix" "orig,orig,<round_saeonly_prefix>")
4258    (set_attr "mode" "DF")])
4259
4260 (define_insn "<mask_codefor>avx512f_cvtpd2ps512<mask_name><round_name>"
4261   [(set (match_operand:V8SF 0 "register_operand" "=v")
4262         (float_truncate:V8SF
4263           (match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")))]
4264   "TARGET_AVX512F"
4265   "vcvtpd2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
4266   [(set_attr "type" "ssecvt")
4267    (set_attr "prefix" "evex")
4268    (set_attr "mode" "V8SF")])
4269
4270 (define_insn "avx_cvtpd2ps256"
4271   [(set (match_operand:V4SF 0 "register_operand" "=x")
4272         (float_truncate:V4SF
4273           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
4274   "TARGET_AVX"
4275   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
4276   [(set_attr "type" "ssecvt")
4277    (set_attr "prefix" "vex")
4278    (set_attr "btver2_decode" "vector")
4279    (set_attr "mode" "V4SF")])
4280
4281 (define_expand "sse2_cvtpd2ps"
4282   [(set (match_operand:V4SF 0 "register_operand")
4283         (vec_concat:V4SF
4284           (float_truncate:V2SF
4285             (match_operand:V2DF 1 "nonimmediate_operand"))
4286           (match_dup 2)))]
4287   "TARGET_SSE2"
4288   "operands[2] = CONST0_RTX (V2SFmode);")
4289
4290 (define_insn "*sse2_cvtpd2ps"
4291   [(set (match_operand:V4SF 0 "register_operand" "=x")
4292         (vec_concat:V4SF
4293           (float_truncate:V2SF
4294             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
4295           (match_operand:V2SF 2 "const0_operand")))]
4296   "TARGET_SSE2"
4297 {
4298   if (TARGET_AVX)
4299     return "vcvtpd2ps{x}\t{%1, %0|%0, %1}";
4300   else
4301     return "cvtpd2ps\t{%1, %0|%0, %1}";
4302 }
4303   [(set_attr "type" "ssecvt")
4304    (set_attr "amdfam10_decode" "double")
4305    (set_attr "athlon_decode" "vector")
4306    (set_attr "bdver1_decode" "double")
4307    (set_attr "prefix_data16" "1")
4308    (set_attr "prefix" "maybe_vex")
4309    (set_attr "mode" "V4SF")])
4310
4311 ;; For <sse2_avx_avx512f>_cvtps2pd<avxsizesuffix> insn pattern
4312 (define_mode_attr sf2dfmode
4313   [(V8DF "V8SF") (V4DF "V4SF")])
4314
4315 (define_insn "<sse2_avx_avx512f>_cvtps2pd<avxsizesuffix><mask_name><round_saeonly_name>"
4316   [(set (match_operand:VF2_512_256 0 "register_operand" "=v")
4317         (float_extend:VF2_512_256
4318           (match_operand:<sf2dfmode> 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
4319   "TARGET_AVX && <mask_mode512bit_condition> && <round_saeonly_mode512bit_condition>"
4320   "vcvtps2pd\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
4321   [(set_attr "type" "ssecvt")
4322    (set_attr "prefix" "maybe_vex")
4323    (set_attr "mode" "<MODE>")])
4324
4325 (define_insn "*avx_cvtps2pd256_2"
4326   [(set (match_operand:V4DF 0 "register_operand" "=x")
4327         (float_extend:V4DF
4328           (vec_select:V4SF
4329             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
4330             (parallel [(const_int 0) (const_int 1)
4331                        (const_int 2) (const_int 3)]))))]
4332   "TARGET_AVX"
4333   "vcvtps2pd\t{%x1, %0|%0, %x1}"
4334   [(set_attr "type" "ssecvt")
4335    (set_attr "prefix" "vex")
4336    (set_attr "mode" "V4DF")])
4337
4338 (define_insn "vec_unpacks_lo_v16sf"
4339   [(set (match_operand:V8DF 0 "register_operand" "=v")
4340         (float_extend:V8DF
4341           (vec_select:V8SF
4342             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
4343             (parallel [(const_int 0) (const_int 1)
4344                        (const_int 2) (const_int 3)
4345                        (const_int 4) (const_int 5)
4346                        (const_int 6) (const_int 7)]))))]
4347   "TARGET_AVX512F"
4348   "vcvtps2pd\t{%t1, %0|%0, %t1}"
4349   [(set_attr "type" "ssecvt")
4350    (set_attr "prefix" "evex")
4351    (set_attr "mode" "V8DF")])
4352
4353 (define_insn "sse2_cvtps2pd"
4354   [(set (match_operand:V2DF 0 "register_operand" "=x")
4355         (float_extend:V2DF
4356           (vec_select:V2SF
4357             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
4358             (parallel [(const_int 0) (const_int 1)]))))]
4359   "TARGET_SSE2"
4360   "%vcvtps2pd\t{%1, %0|%0, %q1}"
4361   [(set_attr "type" "ssecvt")
4362    (set_attr "amdfam10_decode" "direct")
4363    (set_attr "athlon_decode" "double")
4364    (set_attr "bdver1_decode" "double")
4365    (set_attr "prefix_data16" "0")
4366    (set_attr "prefix" "maybe_vex")
4367    (set_attr "mode" "V2DF")])
4368
4369 (define_expand "vec_unpacks_hi_v4sf"
4370   [(set (match_dup 2)
4371    (vec_select:V4SF
4372      (vec_concat:V8SF
4373        (match_dup 2)
4374        (match_operand:V4SF 1 "nonimmediate_operand"))
4375      (parallel [(const_int 6) (const_int 7)
4376                 (const_int 2) (const_int 3)])))
4377   (set (match_operand:V2DF 0 "register_operand")
4378    (float_extend:V2DF
4379      (vec_select:V2SF
4380        (match_dup 2)
4381        (parallel [(const_int 0) (const_int 1)]))))]
4382   "TARGET_SSE2"
4383   "operands[2] = gen_reg_rtx (V4SFmode);")
4384
4385 (define_expand "vec_unpacks_hi_v8sf"
4386   [(set (match_dup 2)
4387         (vec_select:V4SF
4388           (match_operand:V8SF 1 "nonimmediate_operand")
4389           (parallel [(const_int 4) (const_int 5)
4390                      (const_int 6) (const_int 7)])))
4391    (set (match_operand:V4DF 0 "register_operand")
4392         (float_extend:V4DF
4393           (match_dup 2)))]
4394   "TARGET_AVX"
4395   "operands[2] = gen_reg_rtx (V4SFmode);")
4396
4397 (define_expand "vec_unpacks_hi_v16sf"
4398   [(set (match_dup 2)
4399         (vec_select:V8SF
4400           (match_operand:V16SF 1 "nonimmediate_operand")
4401           (parallel [(const_int 8) (const_int 9)
4402                      (const_int 10) (const_int 11)
4403                      (const_int 12) (const_int 13)
4404                      (const_int 14) (const_int 15)])))
4405    (set (match_operand:V8DF 0 "register_operand")
4406         (float_extend:V8DF
4407           (match_dup 2)))]
4408 "TARGET_AVX512F"
4409 "operands[2] = gen_reg_rtx (V8SFmode);")
4410
4411 (define_expand "vec_unpacks_lo_v4sf"
4412   [(set (match_operand:V2DF 0 "register_operand")
4413         (float_extend:V2DF
4414           (vec_select:V2SF
4415             (match_operand:V4SF 1 "nonimmediate_operand")
4416             (parallel [(const_int 0) (const_int 1)]))))]
4417   "TARGET_SSE2")
4418
4419 (define_expand "vec_unpacks_lo_v8sf"
4420   [(set (match_operand:V4DF 0 "register_operand")
4421         (float_extend:V4DF
4422           (vec_select:V4SF
4423             (match_operand:V8SF 1 "nonimmediate_operand")
4424             (parallel [(const_int 0) (const_int 1)
4425                        (const_int 2) (const_int 3)]))))]
4426   "TARGET_AVX")
4427
4428 (define_mode_attr sseunpackfltmode
4429   [(V8HI "V4SF") (V4SI "V2DF") (V16HI "V8SF")
4430   (V8SI "V4DF") (V32HI "V16SF") (V16SI "V8DF")])
4431
4432 (define_expand "vec_unpacks_float_hi_<mode>"
4433   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4434    (match_operand:VI2_AVX512F 1 "register_operand")]
4435   "TARGET_SSE2"
4436 {
4437   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4438
4439   emit_insn (gen_vec_unpacks_hi_<mode> (tmp, operands[1]));
4440   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4441                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4442   DONE;
4443 })
4444
4445 (define_expand "vec_unpacks_float_lo_<mode>"
4446   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4447    (match_operand:VI2_AVX512F 1 "register_operand")]
4448   "TARGET_SSE2"
4449 {
4450   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4451
4452   emit_insn (gen_vec_unpacks_lo_<mode> (tmp, operands[1]));
4453   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4454                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4455   DONE;
4456 })
4457
4458 (define_expand "vec_unpacku_float_hi_<mode>"
4459   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4460    (match_operand:VI2_AVX512F 1 "register_operand")]
4461   "TARGET_SSE2"
4462 {
4463   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4464
4465   emit_insn (gen_vec_unpacku_hi_<mode> (tmp, operands[1]));
4466   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4467                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4468   DONE;
4469 })
4470
4471 (define_expand "vec_unpacku_float_lo_<mode>"
4472   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4473    (match_operand:VI2_AVX512F 1 "register_operand")]
4474   "TARGET_SSE2"
4475 {
4476   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4477
4478   emit_insn (gen_vec_unpacku_lo_<mode> (tmp, operands[1]));
4479   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4480                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4481   DONE;
4482 })
4483
4484 (define_expand "vec_unpacks_float_hi_v4si"
4485   [(set (match_dup 2)
4486         (vec_select:V4SI
4487           (match_operand:V4SI 1 "nonimmediate_operand")
4488           (parallel [(const_int 2) (const_int 3)
4489                      (const_int 2) (const_int 3)])))
4490    (set (match_operand:V2DF 0 "register_operand")
4491         (float:V2DF
4492           (vec_select:V2SI
4493           (match_dup 2)
4494             (parallel [(const_int 0) (const_int 1)]))))]
4495   "TARGET_SSE2"
4496   "operands[2] = gen_reg_rtx (V4SImode);")
4497
4498 (define_expand "vec_unpacks_float_lo_v4si"
4499   [(set (match_operand:V2DF 0 "register_operand")
4500         (float:V2DF
4501           (vec_select:V2SI
4502             (match_operand:V4SI 1 "nonimmediate_operand")
4503             (parallel [(const_int 0) (const_int 1)]))))]
4504   "TARGET_SSE2")
4505
4506 (define_expand "vec_unpacks_float_hi_v8si"
4507   [(set (match_dup 2)
4508         (vec_select:V4SI
4509           (match_operand:V8SI 1 "nonimmediate_operand")
4510           (parallel [(const_int 4) (const_int 5)
4511                      (const_int 6) (const_int 7)])))
4512    (set (match_operand:V4DF 0 "register_operand")
4513         (float:V4DF
4514           (match_dup 2)))]
4515   "TARGET_AVX"
4516   "operands[2] = gen_reg_rtx (V4SImode);")
4517
4518 (define_expand "vec_unpacks_float_lo_v8si"
4519   [(set (match_operand:V4DF 0 "register_operand")
4520         (float:V4DF
4521           (vec_select:V4SI
4522             (match_operand:V8SI 1 "nonimmediate_operand")
4523             (parallel [(const_int 0) (const_int 1)
4524                        (const_int 2) (const_int 3)]))))]
4525   "TARGET_AVX")
4526
4527 (define_expand "vec_unpacks_float_hi_v16si"
4528   [(set (match_dup 2)
4529         (vec_select:V8SI
4530           (match_operand:V16SI 1 "nonimmediate_operand")
4531           (parallel [(const_int 8) (const_int 9)
4532                      (const_int 10) (const_int 11)
4533                      (const_int 12) (const_int 13)
4534                      (const_int 14) (const_int 15)])))
4535    (set (match_operand:V8DF 0 "register_operand")
4536         (float:V8DF
4537           (match_dup 2)))]
4538   "TARGET_AVX512F"
4539   "operands[2] = gen_reg_rtx (V8SImode);")
4540
4541 (define_expand "vec_unpacks_float_lo_v16si"
4542   [(set (match_operand:V8DF 0 "register_operand")
4543         (float:V8DF
4544           (vec_select:V8SI
4545             (match_operand:V16SI 1 "nonimmediate_operand")
4546             (parallel [(const_int 0) (const_int 1)
4547                        (const_int 2) (const_int 3)
4548                        (const_int 4) (const_int 5)
4549                        (const_int 6) (const_int 7)]))))]
4550   "TARGET_AVX512F")
4551
4552 (define_expand "vec_unpacku_float_hi_v4si"
4553   [(set (match_dup 5)
4554         (vec_select:V4SI
4555           (match_operand:V4SI 1 "nonimmediate_operand")
4556           (parallel [(const_int 2) (const_int 3)
4557                      (const_int 2) (const_int 3)])))
4558    (set (match_dup 6)
4559         (float:V2DF
4560           (vec_select:V2SI
4561           (match_dup 5)
4562             (parallel [(const_int 0) (const_int 1)]))))
4563    (set (match_dup 7)
4564         (lt:V2DF (match_dup 6) (match_dup 3)))
4565    (set (match_dup 8)
4566         (and:V2DF (match_dup 7) (match_dup 4)))
4567    (set (match_operand:V2DF 0 "register_operand")
4568         (plus:V2DF (match_dup 6) (match_dup 8)))]
4569   "TARGET_SSE2"
4570 {
4571   REAL_VALUE_TYPE TWO32r;
4572   rtx x;
4573   int i;
4574
4575   real_ldexp (&TWO32r, &dconst1, 32);
4576   x = const_double_from_real_value (TWO32r, DFmode);
4577
4578   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
4579   operands[4] = force_reg (V2DFmode,
4580                            ix86_build_const_vector (V2DFmode, 1, x));
4581
4582   operands[5] = gen_reg_rtx (V4SImode);
4583
4584   for (i = 6; i < 9; i++)
4585     operands[i] = gen_reg_rtx (V2DFmode);
4586 })
4587
4588 (define_expand "vec_unpacku_float_lo_v4si"
4589   [(set (match_dup 5)
4590         (float:V2DF
4591           (vec_select:V2SI
4592             (match_operand:V4SI 1 "nonimmediate_operand")
4593             (parallel [(const_int 0) (const_int 1)]))))
4594    (set (match_dup 6)
4595         (lt:V2DF (match_dup 5) (match_dup 3)))
4596    (set (match_dup 7)
4597         (and:V2DF (match_dup 6) (match_dup 4)))
4598    (set (match_operand:V2DF 0 "register_operand")
4599         (plus:V2DF (match_dup 5) (match_dup 7)))]
4600   "TARGET_SSE2"
4601 {
4602   REAL_VALUE_TYPE TWO32r;
4603   rtx x;
4604   int i;
4605
4606   real_ldexp (&TWO32r, &dconst1, 32);
4607   x = const_double_from_real_value (TWO32r, DFmode);
4608
4609   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
4610   operands[4] = force_reg (V2DFmode,
4611                            ix86_build_const_vector (V2DFmode, 1, x));
4612
4613   for (i = 5; i < 8; i++)
4614     operands[i] = gen_reg_rtx (V2DFmode);
4615 })
4616
4617 (define_expand "vec_unpacku_float_hi_v8si"
4618   [(match_operand:V4DF 0 "register_operand")
4619    (match_operand:V8SI 1 "register_operand")]
4620   "TARGET_AVX"
4621 {
4622   REAL_VALUE_TYPE TWO32r;
4623   rtx x, tmp[6];
4624   int i;
4625
4626   real_ldexp (&TWO32r, &dconst1, 32);
4627   x = const_double_from_real_value (TWO32r, DFmode);
4628
4629   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
4630   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
4631   tmp[5] = gen_reg_rtx (V4SImode);
4632
4633   for (i = 2; i < 5; i++)
4634     tmp[i] = gen_reg_rtx (V4DFmode);
4635   emit_insn (gen_vec_extract_hi_v8si (tmp[5], operands[1]));
4636   emit_insn (gen_floatv4siv4df2 (tmp[2], tmp[5]));
4637   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
4638                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
4639   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
4640   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
4641   DONE;
4642 })
4643
4644 (define_expand "vec_unpacku_float_hi_v16si"
4645   [(match_operand:V8DF 0 "register_operand")
4646    (match_operand:V16SI 1 "register_operand")]
4647   "TARGET_AVX512F"
4648 {
4649   REAL_VALUE_TYPE TWO32r;
4650   rtx k, x, tmp[4];
4651
4652   real_ldexp (&TWO32r, &dconst1, 32);
4653   x = const_double_from_real_value (TWO32r, DFmode);
4654
4655   tmp[0] = force_reg (V8DFmode, CONST0_RTX (V8DFmode));
4656   tmp[1] = force_reg (V8DFmode, ix86_build_const_vector (V8DFmode, 1, x));
4657   tmp[2] = gen_reg_rtx (V8DFmode);
4658   tmp[3] = gen_reg_rtx (V8SImode);
4659   k = gen_reg_rtx (QImode);
4660
4661   emit_insn (gen_vec_extract_hi_v16si (tmp[3], operands[1]));
4662   emit_insn (gen_floatv8siv8df2 (tmp[2], tmp[3]));
4663   emit_insn (gen_rtx_SET (VOIDmode, k,
4664                           gen_rtx_LT (QImode, tmp[2], tmp[0])));
4665   emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
4666   emit_move_insn (operands[0], tmp[2]);
4667   DONE;
4668 })
4669
4670 (define_expand "vec_unpacku_float_lo_v8si"
4671   [(match_operand:V4DF 0 "register_operand")
4672    (match_operand:V8SI 1 "nonimmediate_operand")]
4673   "TARGET_AVX"
4674 {
4675   REAL_VALUE_TYPE TWO32r;
4676   rtx x, tmp[5];
4677   int i;
4678
4679   real_ldexp (&TWO32r, &dconst1, 32);
4680   x = const_double_from_real_value (TWO32r, DFmode);
4681
4682   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
4683   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
4684
4685   for (i = 2; i < 5; i++)
4686     tmp[i] = gen_reg_rtx (V4DFmode);
4687   emit_insn (gen_avx_cvtdq2pd256_2 (tmp[2], operands[1]));
4688   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
4689                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
4690   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
4691   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
4692   DONE;
4693 })
4694
4695 (define_expand "vec_unpacku_float_lo_v16si"
4696   [(match_operand:V8DF 0 "register_operand")
4697    (match_operand:V16SI 1 "nonimmediate_operand")]
4698   "TARGET_AVX512F"
4699 {
4700   REAL_VALUE_TYPE TWO32r;
4701   rtx k, x, tmp[3];
4702
4703   real_ldexp (&TWO32r, &dconst1, 32);
4704   x = const_double_from_real_value (TWO32r, DFmode);
4705
4706   tmp[0] = force_reg (V8DFmode, CONST0_RTX (V8DFmode));
4707   tmp[1] = force_reg (V8DFmode, ix86_build_const_vector (V8DFmode, 1, x));
4708   tmp[2] = gen_reg_rtx (V8DFmode);
4709   k = gen_reg_rtx (QImode);
4710
4711   emit_insn (gen_avx512f_cvtdq2pd512_2 (tmp[2], operands[1]));
4712   emit_insn (gen_rtx_SET (VOIDmode, k,
4713                           gen_rtx_LT (QImode, tmp[2], tmp[0])));
4714   emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
4715   emit_move_insn (operands[0], tmp[2]);
4716   DONE;
4717 })
4718
4719 (define_expand "vec_pack_trunc_<mode>"
4720   [(set (match_dup 3)
4721         (float_truncate:<sf2dfmode>
4722           (match_operand:VF2_512_256 1 "nonimmediate_operand")))
4723    (set (match_dup 4)
4724         (float_truncate:<sf2dfmode>
4725           (match_operand:VF2_512_256 2 "nonimmediate_operand")))
4726    (set (match_operand:<ssePSmode> 0 "register_operand")
4727         (vec_concat:<ssePSmode>
4728           (match_dup 3)
4729           (match_dup 4)))]
4730   "TARGET_AVX"
4731 {
4732   operands[3] = gen_reg_rtx (<sf2dfmode>mode);
4733   operands[4] = gen_reg_rtx (<sf2dfmode>mode);
4734 })
4735
4736 (define_expand "vec_pack_trunc_v2df"
4737   [(match_operand:V4SF 0 "register_operand")
4738    (match_operand:V2DF 1 "nonimmediate_operand")
4739    (match_operand:V2DF 2 "nonimmediate_operand")]
4740   "TARGET_SSE2"
4741 {
4742   rtx tmp0, tmp1;
4743
4744   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4745     {
4746       tmp0 = gen_reg_rtx (V4DFmode);
4747       tmp1 = force_reg (V2DFmode, operands[1]);
4748
4749       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4750       emit_insn (gen_avx_cvtpd2ps256 (operands[0], tmp0));
4751     }
4752   else
4753     {
4754       tmp0 = gen_reg_rtx (V4SFmode);
4755       tmp1 = gen_reg_rtx (V4SFmode);
4756
4757       emit_insn (gen_sse2_cvtpd2ps (tmp0, operands[1]));
4758       emit_insn (gen_sse2_cvtpd2ps (tmp1, operands[2]));
4759       emit_insn (gen_sse_movlhps (operands[0], tmp0, tmp1));
4760     }
4761   DONE;
4762 })
4763
4764 (define_expand "vec_pack_sfix_trunc_v8df"
4765   [(match_operand:V16SI 0 "register_operand")
4766    (match_operand:V8DF 1 "nonimmediate_operand")
4767    (match_operand:V8DF 2 "nonimmediate_operand")]
4768   "TARGET_AVX512F"
4769 {
4770   rtx r1, r2;
4771
4772   r1 = gen_reg_rtx (V8SImode);
4773   r2 = gen_reg_rtx (V8SImode);
4774
4775   emit_insn (gen_fix_truncv8dfv8si2 (r1, operands[1]));
4776   emit_insn (gen_fix_truncv8dfv8si2 (r2, operands[2]));
4777   emit_insn (gen_avx_vec_concatv16si (operands[0], r1, r2));
4778   DONE;
4779 })
4780
4781 (define_expand "vec_pack_sfix_trunc_v4df"
4782   [(match_operand:V8SI 0 "register_operand")
4783    (match_operand:V4DF 1 "nonimmediate_operand")
4784    (match_operand:V4DF 2 "nonimmediate_operand")]
4785   "TARGET_AVX"
4786 {
4787   rtx r1, r2;
4788
4789   r1 = gen_reg_rtx (V4SImode);
4790   r2 = gen_reg_rtx (V4SImode);
4791
4792   emit_insn (gen_fix_truncv4dfv4si2 (r1, operands[1]));
4793   emit_insn (gen_fix_truncv4dfv4si2 (r2, operands[2]));
4794   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
4795   DONE;
4796 })
4797
4798 (define_expand "vec_pack_sfix_trunc_v2df"
4799   [(match_operand:V4SI 0 "register_operand")
4800    (match_operand:V2DF 1 "nonimmediate_operand")
4801    (match_operand:V2DF 2 "nonimmediate_operand")]
4802   "TARGET_SSE2"
4803 {
4804   rtx tmp0, tmp1, tmp2;
4805
4806   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4807     {
4808       tmp0 = gen_reg_rtx (V4DFmode);
4809       tmp1 = force_reg (V2DFmode, operands[1]);
4810
4811       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4812       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp0));
4813     }
4814   else
4815     {
4816       tmp0 = gen_reg_rtx (V4SImode);
4817       tmp1 = gen_reg_rtx (V4SImode);
4818       tmp2 = gen_reg_rtx (V2DImode);
4819
4820       emit_insn (gen_sse2_cvttpd2dq (tmp0, operands[1]));
4821       emit_insn (gen_sse2_cvttpd2dq (tmp1, operands[2]));
4822       emit_insn (gen_vec_interleave_lowv2di (tmp2,
4823                                              gen_lowpart (V2DImode, tmp0),
4824                                              gen_lowpart (V2DImode, tmp1)));
4825       emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp2));
4826     }
4827   DONE;
4828 })
4829
4830 (define_mode_attr ssepackfltmode
4831   [(V8DF "V16SI") (V4DF "V8SI") (V2DF "V4SI")])
4832
4833 (define_expand "vec_pack_ufix_trunc_<mode>"
4834   [(match_operand:<ssepackfltmode> 0 "register_operand")
4835    (match_operand:VF2 1 "register_operand")
4836    (match_operand:VF2 2 "register_operand")]
4837   "TARGET_SSE2"
4838 {
4839   if (<MODE>mode == V8DFmode)
4840     {
4841       rtx r1, r2;
4842
4843       r1 = gen_reg_rtx (V8SImode);
4844       r2 = gen_reg_rtx (V8SImode);
4845
4846       emit_insn (gen_ufix_truncv8dfv8si2 (r1, operands[1]));
4847       emit_insn (gen_ufix_truncv8dfv8si2 (r2, operands[2]));
4848       emit_insn (gen_avx_vec_concatv16si (operands[0], r1, r2));
4849     }
4850   else
4851     {
4852       rtx tmp[7];
4853       tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
4854       tmp[1] = ix86_expand_adjust_ufix_to_sfix_si (operands[2], &tmp[3]);
4855       tmp[4] = gen_reg_rtx (<ssepackfltmode>mode);
4856       emit_insn (gen_vec_pack_sfix_trunc_<mode> (tmp[4], tmp[0], tmp[1]));
4857       if (<ssepackfltmode>mode == V4SImode || TARGET_AVX2)
4858         {
4859           tmp[5] = gen_reg_rtx (<ssepackfltmode>mode);
4860           ix86_expand_vec_extract_even_odd (tmp[5], tmp[2], tmp[3], 0);
4861         }
4862       else
4863         {
4864           tmp[5] = gen_reg_rtx (V8SFmode);
4865           ix86_expand_vec_extract_even_odd (tmp[5], gen_lowpart (V8SFmode, tmp[2]),
4866                                             gen_lowpart (V8SFmode, tmp[3]), 0);
4867           tmp[5] = gen_lowpart (V8SImode, tmp[5]);
4868         }
4869       tmp[6] = expand_simple_binop (<ssepackfltmode>mode, XOR, tmp[4], tmp[5],
4870                                     operands[0], 0, OPTAB_DIRECT);
4871       if (tmp[6] != operands[0])
4872         emit_move_insn (operands[0], tmp[6]);
4873     }
4874
4875   DONE;
4876 })
4877
4878 (define_expand "vec_pack_sfix_v4df"
4879   [(match_operand:V8SI 0 "register_operand")
4880    (match_operand:V4DF 1 "nonimmediate_operand")
4881    (match_operand:V4DF 2 "nonimmediate_operand")]
4882   "TARGET_AVX"
4883 {
4884   rtx r1, r2;
4885
4886   r1 = gen_reg_rtx (V4SImode);
4887   r2 = gen_reg_rtx (V4SImode);
4888
4889   emit_insn (gen_avx_cvtpd2dq256 (r1, operands[1]));
4890   emit_insn (gen_avx_cvtpd2dq256 (r2, operands[2]));
4891   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
4892   DONE;
4893 })
4894
4895 (define_expand "vec_pack_sfix_v2df"
4896   [(match_operand:V4SI 0 "register_operand")
4897    (match_operand:V2DF 1 "nonimmediate_operand")
4898    (match_operand:V2DF 2 "nonimmediate_operand")]
4899   "TARGET_SSE2"
4900 {
4901   rtx tmp0, tmp1, tmp2;
4902
4903   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4904     {
4905       tmp0 = gen_reg_rtx (V4DFmode);
4906       tmp1 = force_reg (V2DFmode, operands[1]);
4907
4908       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4909       emit_insn (gen_avx_cvtpd2dq256 (operands[0], tmp0));
4910     }
4911   else
4912     {
4913       tmp0 = gen_reg_rtx (V4SImode);
4914       tmp1 = gen_reg_rtx (V4SImode);
4915       tmp2 = gen_reg_rtx (V2DImode);
4916
4917       emit_insn (gen_sse2_cvtpd2dq (tmp0, operands[1]));
4918       emit_insn (gen_sse2_cvtpd2dq (tmp1, operands[2]));
4919       emit_insn (gen_vec_interleave_lowv2di (tmp2,
4920                                              gen_lowpart (V2DImode, tmp0),
4921                                              gen_lowpart (V2DImode, tmp1)));
4922       emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp2));
4923     }
4924   DONE;
4925 })
4926
4927 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4928 ;;
4929 ;; Parallel single-precision floating point element swizzling
4930 ;;
4931 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4932
4933 (define_expand "sse_movhlps_exp"
4934   [(set (match_operand:V4SF 0 "nonimmediate_operand")
4935         (vec_select:V4SF
4936           (vec_concat:V8SF
4937             (match_operand:V4SF 1 "nonimmediate_operand")
4938             (match_operand:V4SF 2 "nonimmediate_operand"))
4939           (parallel [(const_int 6)
4940                      (const_int 7)
4941                      (const_int 2)
4942                      (const_int 3)])))]
4943   "TARGET_SSE"
4944 {
4945   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
4946
4947   emit_insn (gen_sse_movhlps (dst, operands[1], operands[2]));
4948
4949   /* Fix up the destination if needed.  */
4950   if (dst != operands[0])
4951     emit_move_insn (operands[0], dst);
4952
4953   DONE;
4954 })
4955
4956 (define_insn "sse_movhlps"
4957   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
4958         (vec_select:V4SF
4959           (vec_concat:V8SF
4960             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
4961             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,o,o,x"))
4962           (parallel [(const_int 6)
4963                      (const_int 7)
4964                      (const_int 2)
4965                      (const_int 3)])))]
4966   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4967   "@
4968    movhlps\t{%2, %0|%0, %2}
4969    vmovhlps\t{%2, %1, %0|%0, %1, %2}
4970    movlps\t{%H2, %0|%0, %H2}
4971    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
4972    %vmovhps\t{%2, %0|%q0, %2}"
4973   [(set_attr "isa" "noavx,avx,noavx,avx,*")
4974    (set_attr "type" "ssemov")
4975    (set_attr "ssememalign" "64")
4976    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
4977    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
4978
4979 (define_expand "sse_movlhps_exp"
4980   [(set (match_operand:V4SF 0 "nonimmediate_operand")
4981         (vec_select:V4SF
4982           (vec_concat:V8SF
4983             (match_operand:V4SF 1 "nonimmediate_operand")
4984             (match_operand:V4SF 2 "nonimmediate_operand"))
4985           (parallel [(const_int 0)
4986                      (const_int 1)
4987                      (const_int 4)
4988                      (const_int 5)])))]
4989   "TARGET_SSE"
4990 {
4991   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
4992
4993   emit_insn (gen_sse_movlhps (dst, operands[1], operands[2]));
4994
4995   /* Fix up the destination if needed.  */
4996   if (dst != operands[0])
4997     emit_move_insn (operands[0], dst);
4998
4999   DONE;
5000 })
5001
5002 (define_insn "sse_movlhps"
5003   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
5004         (vec_select:V4SF
5005           (vec_concat:V8SF
5006             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
5007             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,m,x"))
5008           (parallel [(const_int 0)
5009                      (const_int 1)
5010                      (const_int 4)
5011                      (const_int 5)])))]
5012   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
5013   "@
5014    movlhps\t{%2, %0|%0, %2}
5015    vmovlhps\t{%2, %1, %0|%0, %1, %2}
5016    movhps\t{%2, %0|%0, %q2}
5017    vmovhps\t{%2, %1, %0|%0, %1, %q2}
5018    %vmovlps\t{%2, %H0|%H0, %2}"
5019   [(set_attr "isa" "noavx,avx,noavx,avx,*")
5020    (set_attr "type" "ssemov")
5021    (set_attr "ssememalign" "64")
5022    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
5023    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
5024
5025 (define_insn "<mask_codefor>avx512f_unpckhps512<mask_name>"
5026   [(set (match_operand:V16SF 0 "register_operand" "=v")
5027         (vec_select:V16SF
5028           (vec_concat:V32SF
5029             (match_operand:V16SF 1 "register_operand" "v")
5030             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
5031           (parallel [(const_int 2) (const_int 18)
5032                      (const_int 3) (const_int 19)
5033                      (const_int 6) (const_int 22)
5034                      (const_int 7) (const_int 23)
5035                      (const_int 10) (const_int 26)
5036                      (const_int 11) (const_int 27)
5037                      (const_int 14) (const_int 30)
5038                      (const_int 15) (const_int 31)])))]
5039   "TARGET_AVX512F"
5040   "vunpckhps\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
5041   [(set_attr "type" "sselog")
5042    (set_attr "prefix" "evex")
5043    (set_attr "mode" "V16SF")])
5044
5045 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
5046 (define_insn "avx_unpckhps256"
5047   [(set (match_operand:V8SF 0 "register_operand" "=x")
5048         (vec_select:V8SF
5049           (vec_concat:V16SF
5050             (match_operand:V8SF 1 "register_operand" "x")
5051             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5052           (parallel [(const_int 2) (const_int 10)
5053                      (const_int 3) (const_int 11)
5054                      (const_int 6) (const_int 14)
5055                      (const_int 7) (const_int 15)])))]
5056   "TARGET_AVX"
5057   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
5058   [(set_attr "type" "sselog")
5059    (set_attr "prefix" "vex")
5060    (set_attr "mode" "V8SF")])
5061
5062 (define_expand "vec_interleave_highv8sf"
5063   [(set (match_dup 3)
5064         (vec_select:V8SF
5065           (vec_concat:V16SF
5066             (match_operand:V8SF 1 "register_operand" "x")
5067             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5068           (parallel [(const_int 0) (const_int 8)
5069                      (const_int 1) (const_int 9)
5070                      (const_int 4) (const_int 12)
5071                      (const_int 5) (const_int 13)])))
5072    (set (match_dup 4)
5073         (vec_select:V8SF
5074           (vec_concat:V16SF
5075             (match_dup 1)
5076             (match_dup 2))
5077           (parallel [(const_int 2) (const_int 10)
5078                      (const_int 3) (const_int 11)
5079                      (const_int 6) (const_int 14)
5080                      (const_int 7) (const_int 15)])))
5081    (set (match_operand:V8SF 0 "register_operand")
5082         (vec_select:V8SF
5083           (vec_concat:V16SF
5084             (match_dup 3)
5085             (match_dup 4))
5086           (parallel [(const_int 4) (const_int 5)
5087                      (const_int 6) (const_int 7)
5088                      (const_int 12) (const_int 13)
5089                      (const_int 14) (const_int 15)])))]
5090  "TARGET_AVX"
5091 {
5092   operands[3] = gen_reg_rtx (V8SFmode);
5093   operands[4] = gen_reg_rtx (V8SFmode);
5094 })
5095
5096 (define_insn "vec_interleave_highv4sf"
5097   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5098         (vec_select:V4SF
5099           (vec_concat:V8SF
5100             (match_operand:V4SF 1 "register_operand" "0,x")
5101             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
5102           (parallel [(const_int 2) (const_int 6)
5103                      (const_int 3) (const_int 7)])))]
5104   "TARGET_SSE"
5105   "@
5106    unpckhps\t{%2, %0|%0, %2}
5107    vunpckhps\t{%2, %1, %0|%0, %1, %2}"
5108   [(set_attr "isa" "noavx,avx")
5109    (set_attr "type" "sselog")
5110    (set_attr "prefix" "orig,vex")
5111    (set_attr "mode" "V4SF")])
5112
5113 (define_insn "<mask_codefor>avx512f_unpcklps512<mask_name>"
5114   [(set (match_operand:V16SF 0 "register_operand" "=v")
5115         (vec_select:V16SF
5116           (vec_concat:V32SF
5117             (match_operand:V16SF 1 "register_operand" "v")
5118             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
5119           (parallel [(const_int 0) (const_int 16)
5120                      (const_int 1) (const_int 17)
5121                      (const_int 4) (const_int 20)
5122                      (const_int 5) (const_int 21)
5123                      (const_int 8) (const_int 24)
5124                      (const_int 9) (const_int 25)
5125                      (const_int 12) (const_int 28)
5126                      (const_int 13) (const_int 29)])))]
5127   "TARGET_AVX512F"
5128   "vunpcklps\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
5129   [(set_attr "type" "sselog")
5130    (set_attr "prefix" "evex")
5131    (set_attr "mode" "V16SF")])
5132
5133 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
5134 (define_insn "avx_unpcklps256"
5135   [(set (match_operand:V8SF 0 "register_operand" "=x")
5136         (vec_select:V8SF
5137           (vec_concat:V16SF
5138             (match_operand:V8SF 1 "register_operand" "x")
5139             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5140           (parallel [(const_int 0) (const_int 8)
5141                      (const_int 1) (const_int 9)
5142                      (const_int 4) (const_int 12)
5143                      (const_int 5) (const_int 13)])))]
5144   "TARGET_AVX"
5145   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
5146   [(set_attr "type" "sselog")
5147    (set_attr "prefix" "vex")
5148    (set_attr "mode" "V8SF")])
5149
5150 (define_expand "vec_interleave_lowv8sf"
5151   [(set (match_dup 3)
5152         (vec_select:V8SF
5153           (vec_concat:V16SF
5154             (match_operand:V8SF 1 "register_operand" "x")
5155             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5156           (parallel [(const_int 0) (const_int 8)
5157                      (const_int 1) (const_int 9)
5158                      (const_int 4) (const_int 12)
5159                      (const_int 5) (const_int 13)])))
5160    (set (match_dup 4)
5161         (vec_select:V8SF
5162           (vec_concat:V16SF
5163             (match_dup 1)
5164             (match_dup 2))
5165           (parallel [(const_int 2) (const_int 10)
5166                      (const_int 3) (const_int 11)
5167                      (const_int 6) (const_int 14)
5168                      (const_int 7) (const_int 15)])))
5169    (set (match_operand:V8SF 0 "register_operand")
5170         (vec_select:V8SF
5171           (vec_concat:V16SF
5172             (match_dup 3)
5173             (match_dup 4))
5174           (parallel [(const_int 0) (const_int 1)
5175                      (const_int 2) (const_int 3)
5176                      (const_int 8) (const_int 9)
5177                      (const_int 10) (const_int 11)])))]
5178  "TARGET_AVX"
5179 {
5180   operands[3] = gen_reg_rtx (V8SFmode);
5181   operands[4] = gen_reg_rtx (V8SFmode);
5182 })
5183
5184 (define_insn "vec_interleave_lowv4sf"
5185   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5186         (vec_select:V4SF
5187           (vec_concat:V8SF
5188             (match_operand:V4SF 1 "register_operand" "0,x")
5189             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
5190           (parallel [(const_int 0) (const_int 4)
5191                      (const_int 1) (const_int 5)])))]
5192   "TARGET_SSE"
5193   "@
5194    unpcklps\t{%2, %0|%0, %2}
5195    vunpcklps\t{%2, %1, %0|%0, %1, %2}"
5196   [(set_attr "isa" "noavx,avx")
5197    (set_attr "type" "sselog")
5198    (set_attr "prefix" "orig,vex")
5199    (set_attr "mode" "V4SF")])
5200
5201 ;; These are modeled with the same vec_concat as the others so that we
5202 ;; capture users of shufps that can use the new instructions
5203 (define_insn "avx_movshdup256"
5204   [(set (match_operand:V8SF 0 "register_operand" "=x")
5205         (vec_select:V8SF
5206           (vec_concat:V16SF
5207             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
5208             (match_dup 1))
5209           (parallel [(const_int 1) (const_int 1)
5210                      (const_int 3) (const_int 3)
5211                      (const_int 5) (const_int 5)
5212                      (const_int 7) (const_int 7)])))]
5213   "TARGET_AVX"
5214   "vmovshdup\t{%1, %0|%0, %1}"
5215   [(set_attr "type" "sse")
5216    (set_attr "prefix" "vex")
5217    (set_attr "mode" "V8SF")])
5218
5219 (define_insn "sse3_movshdup"
5220   [(set (match_operand:V4SF 0 "register_operand" "=x")
5221         (vec_select:V4SF
5222           (vec_concat:V8SF
5223             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
5224             (match_dup 1))
5225           (parallel [(const_int 1)
5226                      (const_int 1)
5227                      (const_int 7)
5228                      (const_int 7)])))]
5229   "TARGET_SSE3"
5230   "%vmovshdup\t{%1, %0|%0, %1}"
5231   [(set_attr "type" "sse")
5232    (set_attr "prefix_rep" "1")
5233    (set_attr "prefix" "maybe_vex")
5234    (set_attr "mode" "V4SF")])
5235
5236 (define_insn "<mask_codefor>avx512f_movshdup512<mask_name>"
5237   [(set (match_operand:V16SF 0 "register_operand" "=v")
5238         (vec_select:V16SF
5239           (vec_concat:V32SF
5240             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
5241             (match_dup 1))
5242           (parallel [(const_int 1) (const_int 1)
5243                      (const_int 3) (const_int 3)
5244                      (const_int 5) (const_int 5)
5245                      (const_int 7) (const_int 7)
5246                      (const_int 9) (const_int 9)
5247                      (const_int 11) (const_int 11)
5248                      (const_int 13) (const_int 13)
5249                      (const_int 15) (const_int 15)])))]
5250   "TARGET_AVX512F"
5251   "vmovshdup\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
5252   [(set_attr "type" "sse")
5253    (set_attr "prefix" "evex")
5254    (set_attr "mode" "V16SF")])
5255
5256 (define_insn "avx_movsldup256"
5257   [(set (match_operand:V8SF 0 "register_operand" "=x")
5258         (vec_select:V8SF
5259           (vec_concat:V16SF
5260             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
5261             (match_dup 1))
5262           (parallel [(const_int 0) (const_int 0)
5263                      (const_int 2) (const_int 2)
5264                      (const_int 4) (const_int 4)
5265                      (const_int 6) (const_int 6)])))]
5266   "TARGET_AVX"
5267   "vmovsldup\t{%1, %0|%0, %1}"
5268   [(set_attr "type" "sse")
5269    (set_attr "prefix" "vex")
5270    (set_attr "mode" "V8SF")])
5271
5272 (define_insn "sse3_movsldup"
5273   [(set (match_operand:V4SF 0 "register_operand" "=x")
5274         (vec_select:V4SF
5275           (vec_concat:V8SF
5276             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
5277             (match_dup 1))
5278           (parallel [(const_int 0)
5279                      (const_int 0)
5280                      (const_int 6)
5281                      (const_int 6)])))]
5282   "TARGET_SSE3"
5283   "%vmovsldup\t{%1, %0|%0, %1}"
5284   [(set_attr "type" "sse")
5285    (set_attr "prefix_rep" "1")
5286    (set_attr "prefix" "maybe_vex")
5287    (set_attr "mode" "V4SF")])
5288
5289 (define_insn "<mask_codefor>avx512f_movsldup512<mask_name>"
5290   [(set (match_operand:V16SF 0 "register_operand" "=v")
5291         (vec_select:V16SF
5292           (vec_concat:V32SF
5293             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
5294             (match_dup 1))
5295           (parallel [(const_int 0) (const_int 0)
5296                      (const_int 2) (const_int 2)
5297                      (const_int 4) (const_int 4)
5298                      (const_int 6) (const_int 6)
5299                      (const_int 8) (const_int 8)
5300                      (const_int 10) (const_int 10)
5301                      (const_int 12) (const_int 12)
5302                      (const_int 14) (const_int 14)])))]
5303   "TARGET_AVX512F"
5304   "vmovsldup\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
5305   [(set_attr "type" "sse")
5306    (set_attr "prefix" "evex")
5307    (set_attr "mode" "V16SF")])
5308
5309 (define_expand "avx_shufps256"
5310   [(match_operand:V8SF 0 "register_operand")
5311    (match_operand:V8SF 1 "register_operand")
5312    (match_operand:V8SF 2 "nonimmediate_operand")
5313    (match_operand:SI 3 "const_int_operand")]
5314   "TARGET_AVX"
5315 {
5316   int mask = INTVAL (operands[3]);
5317   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
5318                                   GEN_INT ((mask >> 0) & 3),
5319                                   GEN_INT ((mask >> 2) & 3),
5320                                   GEN_INT (((mask >> 4) & 3) + 8),
5321                                   GEN_INT (((mask >> 6) & 3) + 8),
5322                                   GEN_INT (((mask >> 0) & 3) + 4),
5323                                   GEN_INT (((mask >> 2) & 3) + 4),
5324                                   GEN_INT (((mask >> 4) & 3) + 12),
5325                                   GEN_INT (((mask >> 6) & 3) + 12)));
5326   DONE;
5327 })
5328
5329 ;; One bit in mask selects 2 elements.
5330 (define_insn "avx_shufps256_1"
5331   [(set (match_operand:V8SF 0 "register_operand" "=x")
5332         (vec_select:V8SF
5333           (vec_concat:V16SF
5334             (match_operand:V8SF 1 "register_operand" "x")
5335             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5336           (parallel [(match_operand 3  "const_0_to_3_operand"  )
5337                      (match_operand 4  "const_0_to_3_operand"  )
5338                      (match_operand 5  "const_8_to_11_operand" )
5339                      (match_operand 6  "const_8_to_11_operand" )
5340                      (match_operand 7  "const_4_to_7_operand"  )
5341                      (match_operand 8  "const_4_to_7_operand"  )
5342                      (match_operand 9  "const_12_to_15_operand")
5343                      (match_operand 10 "const_12_to_15_operand")])))]
5344   "TARGET_AVX
5345    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
5346        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
5347        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
5348        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
5349 {
5350   int mask;
5351   mask = INTVAL (operands[3]);
5352   mask |= INTVAL (operands[4]) << 2;
5353   mask |= (INTVAL (operands[5]) - 8) << 4;
5354   mask |= (INTVAL (operands[6]) - 8) << 6;
5355   operands[3] = GEN_INT (mask);
5356
5357   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5358 }
5359   [(set_attr "type" "sseshuf")
5360    (set_attr "length_immediate" "1")
5361    (set_attr "prefix" "vex")
5362    (set_attr "mode" "V8SF")])
5363
5364 (define_expand "sse_shufps"
5365   [(match_operand:V4SF 0 "register_operand")
5366    (match_operand:V4SF 1 "register_operand")
5367    (match_operand:V4SF 2 "nonimmediate_operand")
5368    (match_operand:SI 3 "const_int_operand")]
5369   "TARGET_SSE"
5370 {
5371   int mask = INTVAL (operands[3]);
5372   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
5373                                GEN_INT ((mask >> 0) & 3),
5374                                GEN_INT ((mask >> 2) & 3),
5375                                GEN_INT (((mask >> 4) & 3) + 4),
5376                                GEN_INT (((mask >> 6) & 3) + 4)));
5377   DONE;
5378 })
5379
5380 (define_insn "sse_shufps_<mode>"
5381   [(set (match_operand:VI4F_128 0 "register_operand" "=x,x")
5382         (vec_select:VI4F_128
5383           (vec_concat:<ssedoublevecmode>
5384             (match_operand:VI4F_128 1 "register_operand" "0,x")
5385             (match_operand:VI4F_128 2 "nonimmediate_operand" "xm,xm"))
5386           (parallel [(match_operand 3 "const_0_to_3_operand")
5387                      (match_operand 4 "const_0_to_3_operand")
5388                      (match_operand 5 "const_4_to_7_operand")
5389                      (match_operand 6 "const_4_to_7_operand")])))]
5390   "TARGET_SSE"
5391 {
5392   int mask = 0;
5393   mask |= INTVAL (operands[3]) << 0;
5394   mask |= INTVAL (operands[4]) << 2;
5395   mask |= (INTVAL (operands[5]) - 4) << 4;
5396   mask |= (INTVAL (operands[6]) - 4) << 6;
5397   operands[3] = GEN_INT (mask);
5398
5399   switch (which_alternative)
5400     {
5401     case 0:
5402       return "shufps\t{%3, %2, %0|%0, %2, %3}";
5403     case 1:
5404       return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5405     default:
5406       gcc_unreachable ();
5407     }
5408 }
5409   [(set_attr "isa" "noavx,avx")
5410    (set_attr "type" "sseshuf")
5411    (set_attr "length_immediate" "1")
5412    (set_attr "prefix" "orig,vex")
5413    (set_attr "mode" "V4SF")])
5414
5415 (define_insn "sse_storehps"
5416   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
5417         (vec_select:V2SF
5418           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
5419           (parallel [(const_int 2) (const_int 3)])))]
5420   "TARGET_SSE"
5421   "@
5422    %vmovhps\t{%1, %0|%q0, %1}
5423    %vmovhlps\t{%1, %d0|%d0, %1}
5424    %vmovlps\t{%H1, %d0|%d0, %H1}"
5425   [(set_attr "type" "ssemov")
5426    (set_attr "ssememalign" "64")
5427    (set_attr "prefix" "maybe_vex")
5428    (set_attr "mode" "V2SF,V4SF,V2SF")])
5429
5430 (define_expand "sse_loadhps_exp"
5431   [(set (match_operand:V4SF 0 "nonimmediate_operand")
5432         (vec_concat:V4SF
5433           (vec_select:V2SF
5434             (match_operand:V4SF 1 "nonimmediate_operand")
5435             (parallel [(const_int 0) (const_int 1)]))
5436           (match_operand:V2SF 2 "nonimmediate_operand")))]
5437   "TARGET_SSE"
5438 {
5439   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
5440
5441   emit_insn (gen_sse_loadhps (dst, operands[1], operands[2]));
5442
5443   /* Fix up the destination if needed.  */
5444   if (dst != operands[0])
5445     emit_move_insn (operands[0], dst);
5446
5447   DONE;
5448 })
5449
5450 (define_insn "sse_loadhps"
5451   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
5452         (vec_concat:V4SF
5453           (vec_select:V2SF
5454             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
5455             (parallel [(const_int 0) (const_int 1)]))
5456           (match_operand:V2SF 2 "nonimmediate_operand"   " m,m,x,x,x")))]
5457   "TARGET_SSE"
5458   "@
5459    movhps\t{%2, %0|%0, %q2}
5460    vmovhps\t{%2, %1, %0|%0, %1, %q2}
5461    movlhps\t{%2, %0|%0, %2}
5462    vmovlhps\t{%2, %1, %0|%0, %1, %2}
5463    %vmovlps\t{%2, %H0|%H0, %2}"
5464   [(set_attr "isa" "noavx,avx,noavx,avx,*")
5465    (set_attr "type" "ssemov")
5466    (set_attr "ssememalign" "64")
5467    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
5468    (set_attr "mode" "V2SF,V2SF,V4SF,V4SF,V2SF")])
5469
5470 (define_insn "sse_storelps"
5471   [(set (match_operand:V2SF 0 "nonimmediate_operand"   "=m,x,x")
5472         (vec_select:V2SF
5473           (match_operand:V4SF 1 "nonimmediate_operand" " x,x,m")
5474           (parallel [(const_int 0) (const_int 1)])))]
5475   "TARGET_SSE"
5476   "@
5477    %vmovlps\t{%1, %0|%q0, %1}
5478    %vmovaps\t{%1, %0|%0, %1}
5479    %vmovlps\t{%1, %d0|%d0, %q1}"
5480   [(set_attr "type" "ssemov")
5481    (set_attr "prefix" "maybe_vex")
5482    (set_attr "mode" "V2SF,V4SF,V2SF")])
5483
5484 (define_expand "sse_loadlps_exp"
5485   [(set (match_operand:V4SF 0 "nonimmediate_operand")
5486         (vec_concat:V4SF
5487           (match_operand:V2SF 2 "nonimmediate_operand")
5488           (vec_select:V2SF
5489             (match_operand:V4SF 1 "nonimmediate_operand")
5490             (parallel [(const_int 2) (const_int 3)]))))]
5491   "TARGET_SSE"
5492 {
5493   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
5494
5495   emit_insn (gen_sse_loadlps (dst, operands[1], operands[2]));
5496
5497   /* Fix up the destination if needed.  */
5498   if (dst != operands[0])
5499     emit_move_insn (operands[0], dst);
5500
5501   DONE;
5502 })
5503
5504 (define_insn "sse_loadlps"
5505   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
5506         (vec_concat:V4SF
5507           (match_operand:V2SF 2 "nonimmediate_operand"   " 0,x,m,m,x")
5508           (vec_select:V2SF
5509             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0,x,0")
5510             (parallel [(const_int 2) (const_int 3)]))))]
5511   "TARGET_SSE"
5512   "@
5513    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
5514    vshufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
5515    movlps\t{%2, %0|%0, %q2}
5516    vmovlps\t{%2, %1, %0|%0, %1, %q2}
5517    %vmovlps\t{%2, %0|%q0, %2}"
5518   [(set_attr "isa" "noavx,avx,noavx,avx,*")
5519    (set_attr "type" "sseshuf,sseshuf,ssemov,ssemov,ssemov")
5520    (set_attr "ssememalign" "64")
5521    (set_attr "length_immediate" "1,1,*,*,*")
5522    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
5523    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
5524
5525 (define_insn "sse_movss"
5526   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
5527         (vec_merge:V4SF
5528           (match_operand:V4SF 2 "register_operand" " x,x")
5529           (match_operand:V4SF 1 "register_operand" " 0,x")
5530           (const_int 1)))]
5531   "TARGET_SSE"
5532   "@
5533    movss\t{%2, %0|%0, %2}
5534    vmovss\t{%2, %1, %0|%0, %1, %2}"
5535   [(set_attr "isa" "noavx,avx")
5536    (set_attr "type" "ssemov")
5537    (set_attr "prefix" "orig,vex")
5538    (set_attr "mode" "SF")])
5539
5540 (define_insn "avx2_vec_dup<mode>"
5541   [(set (match_operand:VF1_128_256 0 "register_operand" "=x")
5542         (vec_duplicate:VF1_128_256
5543           (vec_select:SF
5544             (match_operand:V4SF 1 "register_operand" "x")
5545             (parallel [(const_int 0)]))))]
5546   "TARGET_AVX2"
5547   "vbroadcastss\t{%1, %0|%0, %1}"
5548   [(set_attr "type" "sselog1")
5549     (set_attr "prefix" "vex")
5550     (set_attr "mode" "<MODE>")])
5551
5552 (define_insn "avx2_vec_dupv8sf_1"
5553   [(set (match_operand:V8SF 0 "register_operand" "=x")
5554         (vec_duplicate:V8SF
5555           (vec_select:SF
5556             (match_operand:V8SF 1 "register_operand" "x")
5557             (parallel [(const_int 0)]))))]
5558   "TARGET_AVX2"
5559   "vbroadcastss\t{%x1, %0|%0, %x1}"
5560   [(set_attr "type" "sselog1")
5561     (set_attr "prefix" "vex")
5562     (set_attr "mode" "V8SF")])
5563
5564 (define_insn "vec_dupv4sf"
5565   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
5566         (vec_duplicate:V4SF
5567           (match_operand:SF 1 "nonimmediate_operand" "x,m,0")))]
5568   "TARGET_SSE"
5569   "@
5570    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
5571    vbroadcastss\t{%1, %0|%0, %1}
5572    shufps\t{$0, %0, %0|%0, %0, 0}"
5573   [(set_attr "isa" "avx,avx,noavx")
5574    (set_attr "type" "sseshuf1,ssemov,sseshuf1")
5575    (set_attr "length_immediate" "1,0,1")
5576    (set_attr "prefix_extra" "0,1,*")
5577    (set_attr "prefix" "vex,vex,orig")
5578    (set_attr "mode" "V4SF")])
5579
5580 ;; Although insertps takes register source, we prefer
5581 ;; unpcklps with register source since it is shorter.
5582 (define_insn "*vec_concatv2sf_sse4_1"
5583   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,x,x,*y ,*y")
5584         (vec_concat:V2SF
5585           (match_operand:SF 1 "nonimmediate_operand" " 0,x,0,x,m, 0 , m")
5586           (match_operand:SF 2 "vector_move_operand"  " x,x,m,m,C,*ym, C")))]
5587   "TARGET_SSE4_1"
5588   "@
5589    unpcklps\t{%2, %0|%0, %2}
5590    vunpcklps\t{%2, %1, %0|%0, %1, %2}
5591    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
5592    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
5593    %vmovss\t{%1, %0|%0, %1}
5594    punpckldq\t{%2, %0|%0, %2}
5595    movd\t{%1, %0|%0, %1}"
5596   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
5597    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
5598    (set_attr "prefix_data16" "*,*,1,*,*,*,*")
5599    (set_attr "prefix_extra" "*,*,1,1,*,*,*")
5600    (set_attr "length_immediate" "*,*,1,1,*,*,*")
5601    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
5602    (set_attr "mode" "V4SF,V4SF,V4SF,V4SF,SF,DI,DI")])
5603
5604 ;; ??? In theory we can match memory for the MMX alternative, but allowing
5605 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
5606 ;; alternatives pretty much forces the MMX alternative to be chosen.
5607 (define_insn "*vec_concatv2sf_sse"
5608   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
5609         (vec_concat:V2SF
5610           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
5611           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
5612   "TARGET_SSE"
5613   "@
5614    unpcklps\t{%2, %0|%0, %2}
5615    movss\t{%1, %0|%0, %1}
5616    punpckldq\t{%2, %0|%0, %2}
5617    movd\t{%1, %0|%0, %1}"
5618   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
5619    (set_attr "mode" "V4SF,SF,DI,DI")])
5620
5621 (define_insn "*vec_concatv4sf"
5622   [(set (match_operand:V4SF 0 "register_operand"       "=x,x,x,x")
5623         (vec_concat:V4SF
5624           (match_operand:V2SF 1 "register_operand"     " 0,x,0,x")
5625           (match_operand:V2SF 2 "nonimmediate_operand" " x,x,m,m")))]
5626   "TARGET_SSE"
5627   "@
5628    movlhps\t{%2, %0|%0, %2}
5629    vmovlhps\t{%2, %1, %0|%0, %1, %2}
5630    movhps\t{%2, %0|%0, %q2}
5631    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
5632   [(set_attr "isa" "noavx,avx,noavx,avx")
5633    (set_attr "type" "ssemov")
5634    (set_attr "prefix" "orig,vex,orig,vex")
5635    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF")])
5636
5637 (define_expand "vec_init<mode>"
5638   [(match_operand:V_128 0 "register_operand")
5639    (match_operand 1)]
5640   "TARGET_SSE"
5641 {
5642   ix86_expand_vector_init (false, operands[0], operands[1]);
5643   DONE;
5644 })
5645
5646 ;; Avoid combining registers from different units in a single alternative,
5647 ;; see comment above inline_secondary_memory_needed function in i386.c
5648 (define_insn "vec_set<mode>_0"
5649   [(set (match_operand:VI4F_128 0 "nonimmediate_operand"
5650           "=x,x,x ,x,x,x,x  ,x  ,m ,m   ,m")
5651         (vec_merge:VI4F_128
5652           (vec_duplicate:VI4F_128
5653             (match_operand:<ssescalarmode> 2 "general_operand"
5654           " x,m,*r,m,x,x,*rm,*rm,!x,!*re,!*fF"))
5655           (match_operand:VI4F_128 1 "vector_move_operand"
5656           " C,C,C ,C,0,x,0  ,x  ,0 ,0   ,0")
5657           (const_int 1)))]
5658   "TARGET_SSE"
5659   "@
5660    %vinsertps\t{$0xe, %d2, %0|%0, %d2, 0xe}
5661    %vmov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
5662    %vmovd\t{%2, %0|%0, %2}
5663    movss\t{%2, %0|%0, %2}
5664    movss\t{%2, %0|%0, %2}
5665    vmovss\t{%2, %1, %0|%0, %1, %2}
5666    pinsrd\t{$0, %2, %0|%0, %2, 0}
5667    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
5668    #
5669    #
5670    #"
5671   [(set_attr "isa" "sse4,sse2,sse2,noavx,noavx,avx,sse4_noavx,avx,*,*,*")
5672    (set (attr "type")
5673      (cond [(eq_attr "alternative" "0,6,7")
5674               (const_string "sselog")
5675             (eq_attr "alternative" "9")
5676               (const_string "imov")
5677             (eq_attr "alternative" "10")
5678               (const_string "fmov")
5679            ]
5680            (const_string "ssemov")))
5681    (set_attr "prefix_extra" "*,*,*,*,*,*,1,1,*,*,*")
5682    (set_attr "length_immediate" "*,*,*,*,*,*,1,1,*,*,*")
5683    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,orig,orig,vex,orig,vex,*,*,*")
5684    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,SF,SF,TI,TI,*,*,*")])
5685
5686 ;; A subset is vec_setv4sf.
5687 (define_insn "*vec_setv4sf_sse4_1"
5688   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5689         (vec_merge:V4SF
5690           (vec_duplicate:V4SF
5691             (match_operand:SF 2 "nonimmediate_operand" "xm,xm"))
5692           (match_operand:V4SF 1 "register_operand" "0,x")
5693           (match_operand:SI 3 "const_int_operand")))]
5694   "TARGET_SSE4_1
5695    && ((unsigned) exact_log2 (INTVAL (operands[3]))
5696        < GET_MODE_NUNITS (V4SFmode))"
5697 {
5698   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
5699   switch (which_alternative)
5700     {
5701     case 0:
5702       return "insertps\t{%3, %2, %0|%0, %2, %3}";
5703     case 1:
5704       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5705     default:
5706       gcc_unreachable ();
5707     }
5708 }
5709   [(set_attr "isa" "noavx,avx")
5710    (set_attr "type" "sselog")
5711    (set_attr "prefix_data16" "1,*")
5712    (set_attr "prefix_extra" "1")
5713    (set_attr "length_immediate" "1")
5714    (set_attr "prefix" "orig,vex")
5715    (set_attr "mode" "V4SF")])
5716
5717 (define_insn "sse4_1_insertps"
5718   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5719         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
5720                       (match_operand:V4SF 1 "register_operand" "0,x")
5721                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
5722                      UNSPEC_INSERTPS))]
5723   "TARGET_SSE4_1"
5724 {
5725   if (MEM_P (operands[2]))
5726     {
5727       unsigned count_s = INTVAL (operands[3]) >> 6;
5728       if (count_s)
5729         operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
5730       operands[2] = adjust_address_nv (operands[2], SFmode, count_s * 4);
5731     }
5732   switch (which_alternative)
5733     {
5734     case 0:
5735       return "insertps\t{%3, %2, %0|%0, %2, %3}";
5736     case 1:
5737       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5738     default:
5739       gcc_unreachable ();
5740     }
5741 }
5742   [(set_attr "isa" "noavx,avx")
5743    (set_attr "type" "sselog")
5744    (set_attr "prefix_data16" "1,*")
5745    (set_attr "prefix_extra" "1")
5746    (set_attr "length_immediate" "1")
5747    (set_attr "prefix" "orig,vex")
5748    (set_attr "mode" "V4SF")])
5749
5750 (define_split
5751   [(set (match_operand:VI4F_128 0 "memory_operand")
5752         (vec_merge:VI4F_128
5753           (vec_duplicate:VI4F_128
5754             (match_operand:<ssescalarmode> 1 "nonmemory_operand"))
5755           (match_dup 0)
5756           (const_int 1)))]
5757   "TARGET_SSE && reload_completed"
5758   [(set (match_dup 0) (match_dup 1))]
5759   "operands[0] = adjust_address (operands[0], <ssescalarmode>mode, 0);")
5760
5761 (define_expand "vec_set<mode>"
5762   [(match_operand:V 0 "register_operand")
5763    (match_operand:<ssescalarmode> 1 "register_operand")
5764    (match_operand 2 "const_int_operand")]
5765   "TARGET_SSE"
5766 {
5767   ix86_expand_vector_set (false, operands[0], operands[1],
5768                           INTVAL (operands[2]));
5769   DONE;
5770 })
5771
5772 (define_insn_and_split "*vec_extractv4sf_0"
5773   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
5774         (vec_select:SF
5775           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
5776           (parallel [(const_int 0)])))]
5777   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5778   "#"
5779   "&& reload_completed"
5780   [(set (match_dup 0) (match_dup 1))]
5781 {
5782   if (REG_P (operands[1]))
5783     operands[1] = gen_rtx_REG (SFmode, REGNO (operands[1]));
5784   else
5785     operands[1] = adjust_address (operands[1], SFmode, 0);
5786 })
5787
5788 (define_insn_and_split "*sse4_1_extractps"
5789   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm,x,x")
5790         (vec_select:SF
5791           (match_operand:V4SF 1 "register_operand" "x,0,x")
5792           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n,n,n")])))]
5793   "TARGET_SSE4_1"
5794   "@
5795    %vextractps\t{%2, %1, %0|%0, %1, %2}
5796    #
5797    #"
5798   "&& reload_completed && SSE_REG_P (operands[0])"
5799   [(const_int 0)]
5800 {
5801   rtx dest = gen_rtx_REG (V4SFmode, REGNO (operands[0]));
5802   switch (INTVAL (operands[2]))
5803     {
5804     case 1:
5805     case 3:
5806       emit_insn (gen_sse_shufps_v4sf (dest, operands[1], operands[1],
5807                                       operands[2], operands[2],
5808                                       GEN_INT (INTVAL (operands[2]) + 4),
5809                                       GEN_INT (INTVAL (operands[2]) + 4)));
5810       break;
5811     case 2:
5812       emit_insn (gen_vec_interleave_highv4sf (dest, operands[1], operands[1]));
5813       break;
5814     default:
5815       /* 0 should be handled by the *vec_extractv4sf_0 pattern above.  */
5816       gcc_unreachable ();
5817     }
5818   DONE;
5819 }
5820   [(set_attr "isa" "*,noavx,avx")
5821    (set_attr "type" "sselog,*,*")
5822    (set_attr "prefix_data16" "1,*,*")
5823    (set_attr "prefix_extra" "1,*,*")
5824    (set_attr "length_immediate" "1,*,*")
5825    (set_attr "prefix" "maybe_vex,*,*")
5826    (set_attr "mode" "V4SF,*,*")])
5827
5828 (define_insn_and_split "*vec_extractv4sf_mem"
5829   [(set (match_operand:SF 0 "register_operand" "=x,*r,f")
5830         (vec_select:SF
5831           (match_operand:V4SF 1 "memory_operand" "o,o,o")
5832           (parallel [(match_operand 2 "const_0_to_3_operand" "n,n,n")])))]
5833   "TARGET_SSE"
5834   "#"
5835   "&& reload_completed"
5836   [(set (match_dup 0) (match_dup 1))]
5837 {
5838   operands[1] = adjust_address (operands[1], SFmode, INTVAL (operands[2]) * 4);
5839 })
5840
5841 (define_expand "avx512f_vextract<shuffletype>32x4_mask"
5842   [(match_operand:<ssequartermode> 0 "nonimmediate_operand")
5843    (match_operand:V16FI 1 "register_operand")
5844    (match_operand:SI 2 "const_0_to_3_operand")
5845    (match_operand:<ssequartermode> 3 "nonimmediate_operand")
5846    (match_operand:QI 4 "register_operand")]
5847   "TARGET_AVX512F"
5848 {
5849   if (MEM_P (operands[0]) && GET_CODE (operands[3]) == CONST_VECTOR)
5850     operands[0] = force_reg (<ssequartermode>mode, operands[0]);
5851   switch (INTVAL (operands[2]))
5852     {
5853     case 0:
5854       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5855           operands[1], GEN_INT (0), GEN_INT (1), GEN_INT (2),
5856           GEN_INT (3), operands[3], operands[4]));
5857       break;
5858     case 1:
5859       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5860           operands[1], GEN_INT (4), GEN_INT (5), GEN_INT (6),
5861           GEN_INT (7), operands[3], operands[4]));
5862       break;
5863     case 2:
5864       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5865           operands[1], GEN_INT (8), GEN_INT (9), GEN_INT (10),
5866           GEN_INT (11), operands[3], operands[4]));
5867       break;
5868     case 3:
5869       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5870           operands[1], GEN_INT (12), GEN_INT (13), GEN_INT (14),
5871           GEN_INT (15), operands[3], operands[4]));
5872       break;
5873     default:
5874       gcc_unreachable ();
5875     }
5876   DONE;
5877 })
5878
5879 (define_insn "avx512f_vextract<shuffletype>32x4_1_maskm"
5880   [(set (match_operand:<ssequartermode> 0 "memory_operand" "=m")
5881         (vec_merge:<ssequartermode>
5882           (vec_select:<ssequartermode>
5883             (match_operand:V16FI 1 "register_operand" "v")
5884             (parallel [(match_operand 2  "const_0_to_15_operand")
5885               (match_operand 3  "const_0_to_15_operand")
5886               (match_operand 4  "const_0_to_15_operand")
5887               (match_operand 5  "const_0_to_15_operand")]))
5888           (match_operand:<ssequartermode> 6 "memory_operand" "0")
5889           (match_operand:QI 7 "register_operand" "Yk")))]
5890   "TARGET_AVX512F && (INTVAL (operands[2]) = INTVAL (operands[3]) - 1)
5891   && (INTVAL (operands[3]) = INTVAL (operands[4]) - 1)
5892   && (INTVAL (operands[4]) = INTVAL (operands[5]) - 1)"
5893 {
5894   operands[2] = GEN_INT ((INTVAL (operands[2])) >> 2);
5895   return "vextract<shuffletype>32x4\t{%2, %1, %0%{%7%}|%0%{%7%}, %1, %2}";
5896 }
5897   [(set_attr "type" "sselog")
5898    (set_attr "prefix_extra" "1")
5899    (set_attr "length_immediate" "1")
5900    (set_attr "memory" "store")
5901    (set_attr "prefix" "evex")
5902    (set_attr "mode" "<sseinsnmode>")])
5903
5904 (define_insn "<mask_codefor>avx512f_vextract<shuffletype>32x4_1<mask_name>"
5905   [(set (match_operand:<ssequartermode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
5906         (vec_select:<ssequartermode>
5907           (match_operand:V16FI 1 "register_operand" "v")
5908           (parallel [(match_operand 2  "const_0_to_15_operand")
5909             (match_operand 3  "const_0_to_15_operand")
5910             (match_operand 4  "const_0_to_15_operand")
5911             (match_operand 5  "const_0_to_15_operand")])))]
5912   "TARGET_AVX512F && (INTVAL (operands[2]) = INTVAL (operands[3]) - 1)
5913   && (INTVAL (operands[3]) = INTVAL (operands[4]) - 1)
5914   && (INTVAL (operands[4]) = INTVAL (operands[5]) - 1)"
5915 {
5916   operands[2] = GEN_INT ((INTVAL (operands[2])) >> 2);
5917   return "vextract<shuffletype>32x4\t{%2, %1, %0<mask_operand6>|%0<mask_operand6>, %1, %2}";
5918 }
5919   [(set_attr "type" "sselog")
5920    (set_attr "prefix_extra" "1")
5921    (set_attr "length_immediate" "1")
5922    (set (attr "memory")
5923       (if_then_else (match_test "MEM_P (operands[0])")
5924         (const_string "store")
5925         (const_string "none")))
5926    (set_attr "prefix" "evex")
5927    (set_attr "mode" "<sseinsnmode>")])
5928
5929 (define_expand "avx512f_vextract<shuffletype>64x4_mask"
5930   [(match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
5931    (match_operand:V8FI 1 "register_operand")
5932    (match_operand:SI 2 "const_0_to_1_operand")
5933    (match_operand:<ssehalfvecmode> 3 "nonimmediate_operand")
5934    (match_operand:QI 4 "register_operand")]
5935   "TARGET_AVX512F"
5936 {
5937   rtx (*insn)(rtx, rtx, rtx, rtx);
5938
5939   if (MEM_P (operands[0]) && GET_CODE (operands[3]) == CONST_VECTOR)
5940     operands[0] = force_reg (<ssequartermode>mode, operands[0]);
5941
5942   switch (INTVAL (operands[2]))
5943     {
5944     case 0:
5945       insn = gen_vec_extract_lo_<mode>_mask;
5946       break;
5947     case 1:
5948       insn = gen_vec_extract_hi_<mode>_mask;
5949       break;
5950     default:
5951       gcc_unreachable ();
5952     }
5953
5954   emit_insn (insn (operands[0], operands[1], operands[3], operands[4]));
5955   DONE;
5956 })
5957
5958 (define_split
5959   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
5960         (vec_select:<ssehalfvecmode>
5961           (match_operand:V8FI 1 "nonimmediate_operand")
5962           (parallel [(const_int 0) (const_int 1)
5963             (const_int 2) (const_int 3)])))]
5964   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))
5965   && reload_completed"
5966   [(const_int 0)]
5967 {
5968   rtx op1 = operands[1];
5969   if (REG_P (op1))
5970     op1 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op1));
5971   else
5972     op1 = gen_lowpart (<ssehalfvecmode>mode, op1);
5973   emit_move_insn (operands[0], op1);
5974   DONE;
5975 })
5976
5977 (define_insn "vec_extract_lo_<mode>_maskm"
5978   [(set (match_operand:<ssehalfvecmode> 0 "memory_operand" "=m")
5979         (vec_merge:<ssehalfvecmode>
5980           (vec_select:<ssehalfvecmode>
5981             (match_operand:V8FI 1 "register_operand" "v")
5982             (parallel [(const_int 0) (const_int 1)
5983               (const_int 2) (const_int 3)]))
5984           (match_operand:<ssehalfvecmode> 2 "memory_operand" "0")
5985           (match_operand:QI 3 "register_operand" "Yk")))]
5986   "TARGET_AVX512F"
5987 "vextract<shuffletype>64x4\t{$0x0, %1, %0%{%3%}|%0%{%3%}, %1, 0x0}"
5988   [(set_attr "type" "sselog")
5989    (set_attr "prefix_extra" "1")
5990    (set_attr "length_immediate" "1")
5991    (set_attr "prefix" "evex")
5992    (set_attr "mode" "<sseinsnmode>")])
5993
5994 (define_insn "vec_extract_lo_<mode><mask_name>"
5995   [(set (match_operand:<ssehalfvecmode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
5996         (vec_select:<ssehalfvecmode>
5997           (match_operand:V8FI 1 "nonimmediate_operand" "vm")
5998           (parallel [(const_int 0) (const_int 1)
5999             (const_int 2) (const_int 3)])))]
6000   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6001 {
6002   if (<mask_applied>)
6003     return "vextract<shuffletype>64x4\t{$0x0, %1, %0<mask_operand2>|%0<mask_operand2>, %1, 0x0}";
6004   else
6005     return "#";
6006 }
6007   [(set_attr "type" "sselog")
6008    (set_attr "prefix_extra" "1")
6009    (set_attr "length_immediate" "1")
6010    (set (attr "memory")
6011       (if_then_else (match_test "MEM_P (operands[0])")
6012         (const_string "store")
6013         (const_string "none")))
6014    (set_attr "prefix" "evex")
6015    (set_attr "mode" "<sseinsnmode>")])
6016
6017 (define_insn "vec_extract_hi_<mode>_maskm"
6018   [(set (match_operand:<ssehalfvecmode> 0 "memory_operand" "=m")
6019         (vec_merge:<ssehalfvecmode>
6020           (vec_select:<ssehalfvecmode>
6021             (match_operand:V8FI 1 "register_operand" "v")
6022             (parallel [(const_int 4) (const_int 5)
6023               (const_int 6) (const_int 7)]))
6024           (match_operand:<ssehalfvecmode> 2 "memory_operand" "0")
6025           (match_operand:QI 3 "register_operand" "Yk")))]
6026   "TARGET_AVX512F"
6027   "vextract<shuffletype>64x4\t{$0x1, %1, %0%{%3%}|%0%{%3%}, %1, 0x1}"
6028   [(set_attr "type" "sselog")
6029    (set_attr "prefix_extra" "1")
6030    (set_attr "length_immediate" "1")
6031    (set_attr "memory" "store")
6032    (set_attr "prefix" "evex")
6033    (set_attr "mode" "<sseinsnmode>")])
6034
6035 (define_insn "vec_extract_hi_<mode><mask_name>"
6036   [(set (match_operand:<ssehalfvecmode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
6037         (vec_select:<ssehalfvecmode>
6038           (match_operand:V8FI 1 "register_operand" "v")
6039           (parallel [(const_int 4) (const_int 5)
6040             (const_int 6) (const_int 7)])))]
6041   "TARGET_AVX512F"
6042   "vextract<shuffletype>64x4\t{$0x1, %1, %0<mask_operand2>|%0<mask_operand2>, %1, 0x1}"
6043   [(set_attr "type" "sselog")
6044    (set_attr "prefix_extra" "1")
6045    (set_attr "length_immediate" "1")
6046    (set (attr "memory")
6047       (if_then_else (match_test "MEM_P (operands[0])")
6048         (const_string "store")
6049         (const_string "none")))
6050    (set_attr "prefix" "evex")
6051    (set_attr "mode" "<sseinsnmode>")])
6052
6053 (define_expand "avx_vextractf128<mode>"
6054   [(match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
6055    (match_operand:V_256 1 "register_operand")
6056    (match_operand:SI 2 "const_0_to_1_operand")]
6057   "TARGET_AVX"
6058 {
6059   rtx (*insn)(rtx, rtx);
6060
6061   switch (INTVAL (operands[2]))
6062     {
6063     case 0:
6064       insn = gen_vec_extract_lo_<mode>;
6065       break;
6066     case 1:
6067       insn = gen_vec_extract_hi_<mode>;
6068       break;
6069     default:
6070       gcc_unreachable ();
6071     }
6072
6073   emit_insn (insn (operands[0], operands[1]));
6074   DONE;
6075 })
6076
6077 (define_insn_and_split "vec_extract_lo_<mode>"
6078   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=v,m")
6079         (vec_select:<ssehalfvecmode>
6080           (match_operand:V16FI 1 "nonimmediate_operand" "vm,v")
6081           (parallel [(const_int 0) (const_int 1)
6082                      (const_int 2) (const_int 3)
6083                      (const_int 4) (const_int 5)
6084                      (const_int 6) (const_int 7)])))]
6085   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6086   "#"
6087   "&& reload_completed"
6088   [(const_int 0)]
6089 {
6090   rtx op1 = operands[1];
6091   if (REG_P (op1))
6092     op1 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op1));
6093   else
6094     op1 = gen_lowpart (<ssehalfvecmode>mode, op1);
6095   emit_move_insn (operands[0], op1);
6096   DONE;
6097 })
6098
6099 (define_insn "vec_extract_hi_<mode>"
6100   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=v,m")
6101         (vec_select:<ssehalfvecmode>
6102           (match_operand:V16FI 1 "nonimmediate_operand" "v,v")
6103           (parallel [(const_int 8) (const_int 9)
6104                      (const_int 10) (const_int 11)
6105                      (const_int 12) (const_int 13)
6106                      (const_int 14) (const_int 15)])))]
6107   "TARGET_AVX512F"
6108   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6109   [(set_attr "type" "sselog")
6110    (set_attr "prefix_extra" "1")
6111    (set_attr "length_immediate" "1")
6112    (set_attr "memory" "none,store")
6113    (set_attr "prefix" "evex")
6114    (set_attr "mode" "XI")])
6115
6116 (define_insn_and_split "vec_extract_lo_<mode>"
6117   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6118         (vec_select:<ssehalfvecmode>
6119           (match_operand:VI8F_256 1 "nonimmediate_operand" "xm,x")
6120           (parallel [(const_int 0) (const_int 1)])))]
6121   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6122   "#"
6123   "&& reload_completed"
6124   [(set (match_dup 0) (match_dup 1))]
6125 {
6126   if (REG_P (operands[1]))
6127     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
6128   else
6129     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
6130 })
6131
6132 (define_insn "vec_extract_hi_<mode>"
6133   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6134         (vec_select:<ssehalfvecmode>
6135           (match_operand:VI8F_256 1 "register_operand" "x,x")
6136           (parallel [(const_int 2) (const_int 3)])))]
6137   "TARGET_AVX"
6138   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
6139   [(set_attr "type" "sselog")
6140    (set_attr "prefix_extra" "1")
6141    (set_attr "length_immediate" "1")
6142    (set_attr "memory" "none,store")
6143    (set_attr "prefix" "vex")
6144    (set_attr "mode" "<sseinsnmode>")])
6145
6146 (define_insn_and_split "vec_extract_lo_<mode>"
6147   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6148         (vec_select:<ssehalfvecmode>
6149           (match_operand:VI4F_256 1 "nonimmediate_operand" "xm,x")
6150           (parallel [(const_int 0) (const_int 1)
6151                      (const_int 2) (const_int 3)])))]
6152   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6153   "#"
6154   "&& reload_completed"
6155   [(set (match_dup 0) (match_dup 1))]
6156 {
6157   if (REG_P (operands[1]))
6158     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
6159   else
6160     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
6161 })
6162
6163 (define_insn "vec_extract_hi_<mode>"
6164   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6165         (vec_select:<ssehalfvecmode>
6166           (match_operand:VI4F_256 1 "register_operand" "x,x")
6167           (parallel [(const_int 4) (const_int 5)
6168                      (const_int 6) (const_int 7)])))]
6169   "TARGET_AVX"
6170   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
6171   [(set_attr "type" "sselog")
6172    (set_attr "prefix_extra" "1")
6173    (set_attr "length_immediate" "1")
6174    (set_attr "memory" "none,store")
6175    (set_attr "prefix" "vex")
6176    (set_attr "mode" "<sseinsnmode>")])
6177
6178 (define_insn_and_split "vec_extract_lo_v32hi"
6179   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=v,m")
6180         (vec_select:V16HI
6181           (match_operand:V32HI 1 "nonimmediate_operand" "vm,v")
6182           (parallel [(const_int 0) (const_int 1)
6183                      (const_int 2) (const_int 3)
6184                      (const_int 4) (const_int 5)
6185                      (const_int 6) (const_int 7)
6186                      (const_int 8) (const_int 9)
6187                      (const_int 10) (const_int 11)
6188                      (const_int 12) (const_int 13)
6189                      (const_int 14) (const_int 15)])))]
6190   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6191   "#"
6192   "&& reload_completed"
6193   [(set (match_dup 0) (match_dup 1))]
6194 {
6195   if (REG_P (operands[1]))
6196     operands[1] = gen_rtx_REG (V16HImode, REGNO (operands[1]));
6197   else
6198     operands[1] = adjust_address (operands[1], V16HImode, 0);
6199 })
6200
6201 (define_insn "vec_extract_hi_v32hi"
6202   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=v,m")
6203         (vec_select:V16HI
6204           (match_operand:V32HI 1 "nonimmediate_operand" "v,v")
6205           (parallel [(const_int 16) (const_int 17)
6206                      (const_int 18) (const_int 19)
6207                      (const_int 20) (const_int 21)
6208                      (const_int 22) (const_int 23)
6209                      (const_int 24) (const_int 25)
6210                      (const_int 26) (const_int 27)
6211                      (const_int 28) (const_int 29)
6212                      (const_int 30) (const_int 31)])))]
6213   "TARGET_AVX512F"
6214   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6215   [(set_attr "type" "sselog")
6216    (set_attr "prefix_extra" "1")
6217    (set_attr "length_immediate" "1")
6218    (set_attr "memory" "none,store")
6219    (set_attr "prefix" "evex")
6220    (set_attr "mode" "XI")])
6221
6222 (define_insn_and_split "vec_extract_lo_v16hi"
6223   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
6224         (vec_select:V8HI
6225           (match_operand:V16HI 1 "nonimmediate_operand" "xm,x")
6226           (parallel [(const_int 0) (const_int 1)
6227                      (const_int 2) (const_int 3)
6228                      (const_int 4) (const_int 5)
6229                      (const_int 6) (const_int 7)])))]
6230   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6231   "#"
6232   "&& reload_completed"
6233   [(set (match_dup 0) (match_dup 1))]
6234 {
6235   if (REG_P (operands[1]))
6236     operands[1] = gen_rtx_REG (V8HImode, REGNO (operands[1]));
6237   else
6238     operands[1] = adjust_address (operands[1], V8HImode, 0);
6239 })
6240
6241 (define_insn "vec_extract_hi_v16hi"
6242   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
6243         (vec_select:V8HI
6244           (match_operand:V16HI 1 "register_operand" "x,x")
6245           (parallel [(const_int 8) (const_int 9)
6246                      (const_int 10) (const_int 11)
6247                      (const_int 12) (const_int 13)
6248                      (const_int 14) (const_int 15)])))]
6249   "TARGET_AVX"
6250   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
6251   [(set_attr "type" "sselog")
6252    (set_attr "prefix_extra" "1")
6253    (set_attr "length_immediate" "1")
6254    (set_attr "memory" "none,store")
6255    (set_attr "prefix" "vex")
6256    (set_attr "mode" "OI")])
6257
6258 (define_insn_and_split "vec_extract_lo_v64qi"
6259   [(set (match_operand:V32QI 0 "nonimmediate_operand" "=v,m")
6260         (vec_select:V32QI
6261           (match_operand:V64QI 1 "nonimmediate_operand" "vm,v")
6262           (parallel [(const_int 0) (const_int 1)
6263                      (const_int 2) (const_int 3)
6264                      (const_int 4) (const_int 5)
6265                      (const_int 6) (const_int 7)
6266                      (const_int 8) (const_int 9)
6267                      (const_int 10) (const_int 11)
6268                      (const_int 12) (const_int 13)
6269                      (const_int 14) (const_int 15)
6270                      (const_int 16) (const_int 17)
6271                      (const_int 18) (const_int 19)
6272                      (const_int 20) (const_int 21)
6273                      (const_int 22) (const_int 23)
6274                      (const_int 24) (const_int 25)
6275                      (const_int 26) (const_int 27)
6276                      (const_int 28) (const_int 29)
6277                      (const_int 30) (const_int 31)])))]
6278   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6279   "#"
6280   "&& reload_completed"
6281   [(set (match_dup 0) (match_dup 1))]
6282 {
6283   if (REG_P (operands[1]))
6284     operands[1] = gen_rtx_REG (V32QImode, REGNO (operands[1]));
6285   else
6286     operands[1] = adjust_address (operands[1], V32QImode, 0);
6287 })
6288
6289 (define_insn "vec_extract_hi_v64qi"
6290   [(set (match_operand:V32QI 0 "nonimmediate_operand" "=v,m")
6291         (vec_select:V32QI
6292           (match_operand:V64QI 1 "nonimmediate_operand" "v,v")
6293           (parallel [(const_int 32) (const_int 33)
6294                      (const_int 34) (const_int 35)
6295                      (const_int 36) (const_int 37)
6296                      (const_int 38) (const_int 39)
6297                      (const_int 40) (const_int 41)
6298                      (const_int 42) (const_int 43)
6299                      (const_int 44) (const_int 45)
6300                      (const_int 46) (const_int 47)
6301                      (const_int 48) (const_int 49)
6302                      (const_int 50) (const_int 51)
6303                      (const_int 52) (const_int 53)
6304                      (const_int 54) (const_int 55)
6305                      (const_int 56) (const_int 57)
6306                      (const_int 58) (const_int 59)
6307                      (const_int 60) (const_int 61)
6308                      (const_int 62) (const_int 63)])))]
6309   "TARGET_AVX512F"
6310   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6311   [(set_attr "type" "sselog")
6312    (set_attr "prefix_extra" "1")
6313    (set_attr "length_immediate" "1")
6314    (set_attr "memory" "none,store")
6315    (set_attr "prefix" "evex")
6316    (set_attr "mode" "XI")])
6317
6318 (define_insn_and_split "vec_extract_lo_v32qi"
6319   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
6320         (vec_select:V16QI
6321           (match_operand:V32QI 1 "nonimmediate_operand" "xm,x")
6322           (parallel [(const_int 0) (const_int 1)
6323                      (const_int 2) (const_int 3)
6324                      (const_int 4) (const_int 5)
6325                      (const_int 6) (const_int 7)
6326                      (const_int 8) (const_int 9)
6327                      (const_int 10) (const_int 11)
6328                      (const_int 12) (const_int 13)
6329                      (const_int 14) (const_int 15)])))]
6330   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6331   "#"
6332   "&& reload_completed"
6333   [(set (match_dup 0) (match_dup 1))]
6334 {
6335   if (REG_P (operands[1]))
6336     operands[1] = gen_rtx_REG (V16QImode, REGNO (operands[1]));
6337   else
6338     operands[1] = adjust_address (operands[1], V16QImode, 0);
6339 })
6340
6341 (define_insn "vec_extract_hi_v32qi"
6342   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
6343         (vec_select:V16QI
6344           (match_operand:V32QI 1 "register_operand" "x,x")
6345           (parallel [(const_int 16) (const_int 17)
6346                      (const_int 18) (const_int 19)
6347                      (const_int 20) (const_int 21)
6348                      (const_int 22) (const_int 23)
6349                      (const_int 24) (const_int 25)
6350                      (const_int 26) (const_int 27)
6351                      (const_int 28) (const_int 29)
6352                      (const_int 30) (const_int 31)])))]
6353   "TARGET_AVX"
6354   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
6355   [(set_attr "type" "sselog")
6356    (set_attr "prefix_extra" "1")
6357    (set_attr "length_immediate" "1")
6358    (set_attr "memory" "none,store")
6359    (set_attr "prefix" "vex")
6360    (set_attr "mode" "OI")])
6361
6362 ;; Modes handled by vec_extract patterns.
6363 (define_mode_iterator VEC_EXTRACT_MODE
6364   [(V32QI "TARGET_AVX") V16QI
6365    (V16HI "TARGET_AVX") V8HI
6366    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX") V4SI
6367    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX") V2DI
6368    (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
6369    (V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") V2DF])
6370
6371 (define_expand "vec_extract<mode>"
6372   [(match_operand:<ssescalarmode> 0 "register_operand")
6373    (match_operand:VEC_EXTRACT_MODE 1 "register_operand")
6374    (match_operand 2 "const_int_operand")]
6375   "TARGET_SSE"
6376 {
6377   ix86_expand_vector_extract (false, operands[0], operands[1],
6378                               INTVAL (operands[2]));
6379   DONE;
6380 })
6381
6382 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6383 ;;
6384 ;; Parallel double-precision floating point element swizzling
6385 ;;
6386 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6387
6388 (define_insn "<mask_codefor>avx512f_unpckhpd512<mask_name>"
6389   [(set (match_operand:V8DF 0 "register_operand" "=v")
6390         (vec_select:V8DF
6391           (vec_concat:V16DF
6392             (match_operand:V8DF 1 "nonimmediate_operand" "v")
6393             (match_operand:V8DF 2 "nonimmediate_operand" "vm"))
6394           (parallel [(const_int 1) (const_int 9)
6395                      (const_int 3) (const_int 11)
6396                      (const_int 5) (const_int 13)
6397                      (const_int 7) (const_int 15)])))]
6398   "TARGET_AVX512F"
6399   "vunpckhpd\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
6400   [(set_attr "type" "sselog")
6401    (set_attr "prefix" "evex")
6402    (set_attr "mode" "V8DF")])
6403
6404 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
6405 (define_insn "avx_unpckhpd256"
6406   [(set (match_operand:V4DF 0 "register_operand" "=x")
6407         (vec_select:V4DF
6408           (vec_concat:V8DF
6409             (match_operand:V4DF 1 "register_operand" "x")
6410             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6411           (parallel [(const_int 1) (const_int 5)
6412                      (const_int 3) (const_int 7)])))]
6413   "TARGET_AVX"
6414   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
6415   [(set_attr "type" "sselog")
6416    (set_attr "prefix" "vex")
6417    (set_attr "mode" "V4DF")])
6418
6419 (define_expand "vec_interleave_highv4df"
6420   [(set (match_dup 3)
6421         (vec_select:V4DF
6422           (vec_concat:V8DF
6423             (match_operand:V4DF 1 "register_operand" "x")
6424             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6425           (parallel [(const_int 0) (const_int 4)
6426                      (const_int 2) (const_int 6)])))
6427    (set (match_dup 4)
6428         (vec_select:V4DF
6429           (vec_concat:V8DF
6430             (match_dup 1)
6431             (match_dup 2))
6432           (parallel [(const_int 1) (const_int 5)
6433                      (const_int 3) (const_int 7)])))
6434    (set (match_operand:V4DF 0 "register_operand")
6435         (vec_select:V4DF
6436           (vec_concat:V8DF
6437             (match_dup 3)
6438             (match_dup 4))
6439           (parallel [(const_int 2) (const_int 3)
6440                      (const_int 6) (const_int 7)])))]
6441  "TARGET_AVX"
6442 {
6443   operands[3] = gen_reg_rtx (V4DFmode);
6444   operands[4] = gen_reg_rtx (V4DFmode);
6445 })
6446
6447
6448 (define_expand "vec_interleave_highv2df"
6449   [(set (match_operand:V2DF 0 "register_operand")
6450         (vec_select:V2DF
6451           (vec_concat:V4DF
6452             (match_operand:V2DF 1 "nonimmediate_operand")
6453             (match_operand:V2DF 2 "nonimmediate_operand"))
6454           (parallel [(const_int 1)
6455                      (const_int 3)])))]
6456   "TARGET_SSE2"
6457 {
6458   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
6459     operands[2] = force_reg (V2DFmode, operands[2]);
6460 })
6461
6462 (define_insn "*vec_interleave_highv2df"
6463   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,m")
6464         (vec_select:V2DF
6465           (vec_concat:V4DF
6466             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,o,o,o,x")
6467             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,0,x,0"))
6468           (parallel [(const_int 1)
6469                      (const_int 3)])))]
6470   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
6471   "@
6472    unpckhpd\t{%2, %0|%0, %2}
6473    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
6474    %vmovddup\t{%H1, %0|%0, %H1}
6475    movlpd\t{%H1, %0|%0, %H1}
6476    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
6477    %vmovhpd\t{%1, %0|%q0, %1}"
6478   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
6479    (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
6480    (set_attr "ssememalign" "64")
6481    (set_attr "prefix_data16" "*,*,*,1,*,1")
6482    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
6483    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
6484
6485 (define_expand "avx512f_movddup512<mask_name>"
6486   [(set (match_operand:V8DF 0 "register_operand")
6487         (vec_select:V8DF
6488           (vec_concat:V16DF
6489             (match_operand:V8DF 1 "nonimmediate_operand")
6490             (match_dup 1))
6491           (parallel [(const_int 0) (const_int 8)
6492                      (const_int 2) (const_int 10)
6493                      (const_int 4) (const_int 12)
6494                      (const_int 6) (const_int 14)])))]
6495   "TARGET_AVX512F")
6496
6497 (define_expand "avx512f_unpcklpd512<mask_name>"
6498   [(set (match_operand:V8DF 0 "register_operand")
6499         (vec_select:V8DF
6500           (vec_concat:V16DF
6501             (match_operand:V8DF 1 "register_operand")
6502             (match_operand:V8DF 2 "nonimmediate_operand"))
6503           (parallel [(const_int 0) (const_int 8)
6504                      (const_int 2) (const_int 10)
6505                      (const_int 4) (const_int 12)
6506                      (const_int 6) (const_int 14)])))]
6507   "TARGET_AVX512F")
6508
6509 (define_insn "*avx512f_unpcklpd512<mask_name>"
6510   [(set (match_operand:V8DF 0 "register_operand" "=v,v")
6511         (vec_select:V8DF
6512           (vec_concat:V16DF
6513             (match_operand:V8DF 1 "nonimmediate_operand" "vm, v")
6514             (match_operand:V8DF 2 "nonimmediate_operand" "1 ,vm"))
6515           (parallel [(const_int 0) (const_int 8)
6516                      (const_int 2) (const_int 10)
6517                      (const_int 4) (const_int 12)
6518                      (const_int 6) (const_int 14)])))]
6519   "TARGET_AVX512F"
6520   "@
6521    vmovddup\t{%1, %0<mask_operand3>|%0<mask_operand3>, %1}
6522    vunpcklpd\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
6523   [(set_attr "type" "sselog")
6524    (set_attr "prefix" "evex")
6525    (set_attr "mode" "V8DF")])
6526
6527 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
6528 (define_expand "avx_movddup256"
6529   [(set (match_operand:V4DF 0 "register_operand")
6530         (vec_select:V4DF
6531           (vec_concat:V8DF
6532             (match_operand:V4DF 1 "nonimmediate_operand")
6533             (match_dup 1))
6534           (parallel [(const_int 0) (const_int 4)
6535                      (const_int 2) (const_int 6)])))]
6536   "TARGET_AVX")
6537
6538 (define_expand "avx_unpcklpd256"
6539   [(set (match_operand:V4DF 0 "register_operand")
6540         (vec_select:V4DF
6541           (vec_concat:V8DF
6542             (match_operand:V4DF 1 "register_operand")
6543             (match_operand:V4DF 2 "nonimmediate_operand"))
6544           (parallel [(const_int 0) (const_int 4)
6545                      (const_int 2) (const_int 6)])))]
6546   "TARGET_AVX")
6547
6548 (define_insn "*avx_unpcklpd256"
6549   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
6550         (vec_select:V4DF
6551           (vec_concat:V8DF
6552             (match_operand:V4DF 1 "nonimmediate_operand" " x,m")
6553             (match_operand:V4DF 2 "nonimmediate_operand" "xm,1"))
6554           (parallel [(const_int 0) (const_int 4)
6555                      (const_int 2) (const_int 6)])))]
6556   "TARGET_AVX"
6557   "@
6558    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
6559    vmovddup\t{%1, %0|%0, %1}"
6560   [(set_attr "type" "sselog")
6561    (set_attr "prefix" "vex")
6562    (set_attr "mode" "V4DF")])
6563
6564 (define_expand "vec_interleave_lowv4df"
6565   [(set (match_dup 3)
6566         (vec_select:V4DF
6567           (vec_concat:V8DF
6568             (match_operand:V4DF 1 "register_operand" "x")
6569             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6570           (parallel [(const_int 0) (const_int 4)
6571                      (const_int 2) (const_int 6)])))
6572    (set (match_dup 4)
6573         (vec_select:V4DF
6574           (vec_concat:V8DF
6575             (match_dup 1)
6576             (match_dup 2))
6577           (parallel [(const_int 1) (const_int 5)
6578                      (const_int 3) (const_int 7)])))
6579    (set (match_operand:V4DF 0 "register_operand")
6580         (vec_select:V4DF
6581           (vec_concat:V8DF
6582             (match_dup 3)
6583             (match_dup 4))
6584           (parallel [(const_int 0) (const_int 1)
6585                      (const_int 4) (const_int 5)])))]
6586  "TARGET_AVX"
6587 {
6588   operands[3] = gen_reg_rtx (V4DFmode);
6589   operands[4] = gen_reg_rtx (V4DFmode);
6590 })
6591
6592 (define_expand "vec_interleave_lowv2df"
6593   [(set (match_operand:V2DF 0 "register_operand")
6594         (vec_select:V2DF
6595           (vec_concat:V4DF
6596             (match_operand:V2DF 1 "nonimmediate_operand")
6597             (match_operand:V2DF 2 "nonimmediate_operand"))
6598           (parallel [(const_int 0)
6599                      (const_int 2)])))]
6600   "TARGET_SSE2"
6601 {
6602   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
6603     operands[1] = force_reg (V2DFmode, operands[1]);
6604 })
6605
6606 (define_insn "*vec_interleave_lowv2df"
6607   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,o")
6608         (vec_select:V2DF
6609           (vec_concat:V4DF
6610             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,m,0,x,0")
6611             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,m,m,x"))
6612           (parallel [(const_int 0)
6613                      (const_int 2)])))]
6614   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
6615   "@
6616    unpcklpd\t{%2, %0|%0, %2}
6617    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
6618    %vmovddup\t{%1, %0|%0, %q1}
6619    movhpd\t{%2, %0|%0, %q2}
6620    vmovhpd\t{%2, %1, %0|%0, %1, %q2}
6621    %vmovlpd\t{%2, %H0|%H0, %2}"
6622   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
6623    (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
6624    (set_attr "ssememalign" "64")
6625    (set_attr "prefix_data16" "*,*,*,1,*,1")
6626    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
6627    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
6628
6629 (define_split
6630   [(set (match_operand:V2DF 0 "memory_operand")
6631         (vec_select:V2DF
6632           (vec_concat:V4DF
6633             (match_operand:V2DF 1 "register_operand")
6634             (match_dup 1))
6635           (parallel [(const_int 0)
6636                      (const_int 2)])))]
6637   "TARGET_SSE3 && reload_completed"
6638   [(const_int 0)]
6639 {
6640   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
6641   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
6642   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
6643   DONE;
6644 })
6645
6646 (define_split
6647   [(set (match_operand:V2DF 0 "register_operand")
6648         (vec_select:V2DF
6649           (vec_concat:V4DF
6650             (match_operand:V2DF 1 "memory_operand")
6651             (match_dup 1))
6652           (parallel [(match_operand:SI 2 "const_0_to_1_operand")
6653                      (match_operand:SI 3 "const_int_operand")])))]
6654   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
6655   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
6656 {
6657   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
6658 })
6659
6660 (define_insn "avx512f_vmscalef<mode><round_name>"
6661   [(set (match_operand:VF_128 0 "register_operand" "=v")
6662         (vec_merge:VF_128
6663           (unspec:VF_128
6664             [(match_operand:VF_128 1 "register_operand" "v")
6665              (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>")]
6666             UNSPEC_SCALEF)
6667           (match_dup 1)
6668           (const_int 1)))]
6669   "TARGET_AVX512F"
6670   "vscalef<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
6671   [(set_attr "prefix" "evex")
6672    (set_attr "mode"  "<ssescalarmode>")])
6673
6674 (define_insn "avx512f_scalef<mode><mask_name><round_name>"
6675   [(set (match_operand:VF_512 0 "register_operand" "=v")
6676         (unspec:VF_512
6677           [(match_operand:VF_512 1 "register_operand" "v")
6678            (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")]
6679           UNSPEC_SCALEF))]
6680   "TARGET_AVX512F"
6681   "vscalef<ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
6682   [(set_attr "prefix" "evex")
6683    (set_attr "mode"  "<MODE>")])
6684
6685 (define_expand "avx512f_vternlog<mode>_maskz"
6686   [(match_operand:VI48_512 0 "register_operand")
6687    (match_operand:VI48_512 1 "register_operand")
6688    (match_operand:VI48_512 2 "register_operand")
6689    (match_operand:VI48_512 3 "nonimmediate_operand")
6690    (match_operand:SI 4 "const_0_to_255_operand")
6691    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6692   "TARGET_AVX512F"
6693 {
6694   emit_insn (gen_avx512f_vternlog<mode>_maskz_1 (
6695     operands[0], operands[1], operands[2], operands[3],
6696     operands[4], CONST0_RTX (<MODE>mode), operands[5]));
6697   DONE;
6698 })
6699
6700 (define_insn "avx512f_vternlog<mode><sd_maskz_name>"
6701   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6702         (unspec:VI48_512
6703           [(match_operand:VI48_512 1 "register_operand" "0")
6704            (match_operand:VI48_512 2 "register_operand" "v")
6705            (match_operand:VI48_512 3 "nonimmediate_operand" "vm")
6706            (match_operand:SI 4 "const_0_to_255_operand")]
6707           UNSPEC_VTERNLOG))]
6708   "TARGET_AVX512F"
6709   "vpternlog<ssemodesuffix>\t{%4, %3, %2, %0<sd_mask_op5>|%0<sd_mask_op5>, %2, %3, %4}"
6710   [(set_attr "type" "sselog")
6711    (set_attr "prefix" "evex")
6712    (set_attr "mode" "<sseinsnmode>")])
6713
6714 (define_insn "avx512f_vternlog<mode>_mask"
6715   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6716         (vec_merge:VI48_512
6717           (unspec:VI48_512
6718             [(match_operand:VI48_512 1 "register_operand" "0")
6719              (match_operand:VI48_512 2 "register_operand" "v")
6720              (match_operand:VI48_512 3 "nonimmediate_operand" "vm")
6721              (match_operand:SI 4 "const_0_to_255_operand")]
6722             UNSPEC_VTERNLOG)
6723           (match_dup 1)
6724           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6725   "TARGET_AVX512F"
6726   "vpternlog<ssemodesuffix>\t{%4, %3, %2, %0%{%5%}|%0%{%5%}, %2, %3, %4}"
6727   [(set_attr "type" "sselog")
6728    (set_attr "prefix" "evex")
6729    (set_attr "mode" "<sseinsnmode>")])
6730
6731 (define_insn "avx512f_getexp<mode><mask_name><round_saeonly_name>"
6732   [(set (match_operand:VF_512 0 "register_operand" "=v")
6733         (unspec:VF_512 [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
6734                         UNSPEC_GETEXP))]
6735    "TARGET_AVX512F"
6736    "vgetexp<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}";
6737     [(set_attr "prefix" "evex")
6738      (set_attr "mode" "<MODE>")])
6739
6740 (define_insn "avx512f_sgetexp<mode><round_saeonly_name>"
6741   [(set (match_operand:VF_128 0 "register_operand" "=v")
6742         (vec_merge:VF_128
6743           (unspec:VF_128
6744             [(match_operand:VF_128 1 "register_operand" "v")
6745              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
6746             UNSPEC_GETEXP)
6747           (match_dup 1)
6748           (const_int 1)))]
6749    "TARGET_AVX512F"
6750    "vgetexp<ssescalarmodesuffix>\t{<round_saeonly_op3>%2, %1, %0|%0, %1, %2<round_saeonly_op3>}";
6751     [(set_attr "prefix" "evex")
6752      (set_attr "mode" "<ssescalarmode>")])
6753
6754 (define_insn "<mask_codefor>avx512f_align<mode><mask_name>"
6755   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6756         (unspec:VI48_512 [(match_operand:VI48_512 1 "register_operand" "v")
6757                           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")
6758                           (match_operand:SI 3 "const_0_to_255_operand")]
6759                          UNSPEC_ALIGN))]
6760   "TARGET_AVX512F"
6761   "valign<ssemodesuffix>\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
6762   [(set_attr "prefix" "evex")
6763    (set_attr "mode" "<sseinsnmode>")])
6764
6765 (define_expand "avx512f_shufps512_mask"
6766   [(match_operand:V16SF 0 "register_operand")
6767    (match_operand:V16SF 1 "register_operand")
6768    (match_operand:V16SF 2 "nonimmediate_operand")
6769    (match_operand:SI 3 "const_0_to_255_operand")
6770    (match_operand:V16SF 4 "register_operand")
6771    (match_operand:HI 5 "register_operand")]
6772   "TARGET_AVX512F"
6773 {
6774   int mask = INTVAL (operands[3]);
6775   emit_insn (gen_avx512f_shufps512_1_mask (operands[0], operands[1], operands[2],
6776                                           GEN_INT ((mask >> 0) & 3),
6777                                           GEN_INT ((mask >> 2) & 3),
6778                                           GEN_INT (((mask >> 4) & 3) + 16),
6779                                           GEN_INT (((mask >> 6) & 3) + 16),
6780                                           GEN_INT (((mask >> 0) & 3) + 4),
6781                                           GEN_INT (((mask >> 2) & 3) + 4),
6782                                           GEN_INT (((mask >> 4) & 3) + 20),
6783                                           GEN_INT (((mask >> 6) & 3) + 20),
6784                                           GEN_INT (((mask >> 0) & 3) + 8),
6785                                           GEN_INT (((mask >> 2) & 3) + 8),
6786                                           GEN_INT (((mask >> 4) & 3) + 24),
6787                                           GEN_INT (((mask >> 6) & 3) + 24),
6788                                           GEN_INT (((mask >> 0) & 3) + 12),
6789                                           GEN_INT (((mask >> 2) & 3) + 12),
6790                                           GEN_INT (((mask >> 4) & 3) + 28),
6791                                           GEN_INT (((mask >> 6) & 3) + 28),
6792                                           operands[4], operands[5]));
6793   DONE;
6794 })
6795
6796
6797 (define_expand "avx512f_fixupimm<mode>_maskz<round_saeonly_expand_name>"
6798   [(match_operand:VF_512 0 "register_operand")
6799    (match_operand:VF_512 1 "register_operand")
6800    (match_operand:VF_512 2 "register_operand")
6801    (match_operand:<sseintvecmode> 3 "<round_saeonly_expand_nimm_predicate>")
6802    (match_operand:SI 4 "const_0_to_255_operand")
6803    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6804   "TARGET_AVX512F"
6805 {
6806   emit_insn (gen_avx512f_fixupimm<mode>_maskz_1<round_saeonly_expand_name> (
6807         operands[0], operands[1], operands[2], operands[3],
6808         operands[4], CONST0_RTX (<MODE>mode), operands[5]
6809         <round_saeonly_expand_operand6>));
6810   DONE;
6811 })
6812
6813 (define_insn "avx512f_fixupimm<mode><sd_maskz_name><round_saeonly_name>"
6814   [(set (match_operand:VF_512 0 "register_operand" "=v")
6815         (unspec:VF_512
6816           [(match_operand:VF_512 1 "register_operand" "0")
6817            (match_operand:VF_512 2 "register_operand" "v")
6818            (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6819            (match_operand:SI 4 "const_0_to_255_operand")]
6820            UNSPEC_FIXUPIMM))]
6821   "TARGET_AVX512F"
6822   "vfixupimm<ssemodesuffix>\t{%4, <round_saeonly_sd_mask_op5>%3, %2, %0<sd_mask_op5>|%0<sd_mask_op5>, %2, %3<round_saeonly_sd_mask_op5>, %4}";
6823   [(set_attr "prefix" "evex")
6824    (set_attr "mode" "<MODE>")])
6825
6826 (define_insn "avx512f_fixupimm<mode>_mask<round_saeonly_name>"
6827   [(set (match_operand:VF_512 0 "register_operand" "=v")
6828         (vec_merge:VF_512
6829           (unspec:VF_512
6830             [(match_operand:VF_512 1 "register_operand" "0")
6831              (match_operand:VF_512 2 "register_operand" "v")
6832              (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6833              (match_operand:SI 4 "const_0_to_255_operand")]
6834              UNSPEC_FIXUPIMM)
6835           (match_dup 1)
6836           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6837   "TARGET_AVX512F"
6838   "vfixupimm<ssemodesuffix>\t{%4, <round_saeonly_op6>%3, %2, %0%{%5%}|%0%{%5%}, %2, %3<round_saeonly_op6>, %4}";
6839   [(set_attr "prefix" "evex")
6840    (set_attr "mode" "<MODE>")])
6841
6842 (define_expand "avx512f_sfixupimm<mode>_maskz<round_saeonly_expand_name>"
6843   [(match_operand:VF_128 0 "register_operand")
6844    (match_operand:VF_128 1 "register_operand")
6845    (match_operand:VF_128 2 "register_operand")
6846    (match_operand:<sseintvecmode> 3 "<round_saeonly_expand_nimm_predicate>")
6847    (match_operand:SI 4 "const_0_to_255_operand")
6848    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6849   "TARGET_AVX512F"
6850 {
6851   emit_insn (gen_avx512f_sfixupimm<mode>_maskz_1<round_saeonly_expand_name> (
6852         operands[0], operands[1], operands[2], operands[3],
6853         operands[4], CONST0_RTX (<MODE>mode), operands[5]
6854         <round_saeonly_expand_operand6>));
6855   DONE;
6856 })
6857
6858 (define_insn "avx512f_sfixupimm<mode><sd_maskz_name><round_saeonly_name>"
6859   [(set (match_operand:VF_128 0 "register_operand" "=v")
6860         (vec_merge:VF_128
6861           (unspec:VF_128
6862             [(match_operand:VF_128 1 "register_operand" "0")
6863              (match_operand:VF_128 2 "register_operand" "v")
6864              (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6865              (match_operand:SI 4 "const_0_to_255_operand")]
6866             UNSPEC_FIXUPIMM)
6867           (match_dup 1)
6868           (const_int 1)))]
6869    "TARGET_AVX512F"
6870    "vfixupimm<ssescalarmodesuffix>\t{%4, <round_saeonly_sd_mask_op5>%3, %2, %0<sd_mask_op5>|%0<sd_mask_op5>, %2, %3<round_saeonly_sd_mask_op5>, %4}";
6871    [(set_attr "prefix" "evex")
6872    (set_attr "mode" "<ssescalarmode>")])
6873
6874 (define_insn "avx512f_sfixupimm<mode>_mask<round_saeonly_name>"
6875   [(set (match_operand:VF_128 0 "register_operand" "=v")
6876         (vec_merge:VF_128
6877           (vec_merge:VF_128
6878             (unspec:VF_128
6879                [(match_operand:VF_128 1 "register_operand" "0")
6880                 (match_operand:VF_128 2 "register_operand" "v")
6881                 (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6882                 (match_operand:SI 4 "const_0_to_255_operand")]
6883                UNSPEC_FIXUPIMM)
6884             (match_dup 1)
6885             (const_int 1))
6886           (match_dup 1)
6887           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6888   "TARGET_AVX512F"
6889   "vfixupimm<ssescalarmodesuffix>\t{%4, <round_saeonly_op6>%3, %2, %0%{%5%}|%0%{%5%}, %2, %3<round_saeonly_op6>, %4}";
6890   [(set_attr "prefix" "evex")
6891    (set_attr "mode" "<ssescalarmode>")])
6892
6893 (define_insn "avx512f_rndscale<mode><mask_name><round_saeonly_name>"
6894   [(set (match_operand:VF_512 0 "register_operand" "=v")
6895         (unspec:VF_512
6896           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6897            (match_operand:SI 2 "const_0_to_255_operand")]
6898           UNSPEC_ROUND))]
6899   "TARGET_AVX512F"
6900   "vrndscale<ssemodesuffix>\t{%2, <round_saeonly_mask_op3>%1, %0<mask_operand3>|%0<mask_operand3>, %1<round_saeonly_mask_op3>, %2}"
6901   [(set_attr "length_immediate" "1")
6902    (set_attr "prefix" "evex")
6903    (set_attr "mode" "<MODE>")])
6904
6905 (define_insn "avx512f_rndscale<mode><round_saeonly_name>"
6906   [(set (match_operand:VF_128 0 "register_operand" "=v")
6907         (vec_merge:VF_128
6908           (unspec:VF_128
6909             [(match_operand:VF_128 1 "register_operand" "v")
6910              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6911              (match_operand:SI 3 "const_0_to_255_operand")]
6912             UNSPEC_ROUND)
6913           (match_dup 1)
6914           (const_int 1)))]
6915   "TARGET_AVX512F"
6916   "vrndscale<ssescalarmodesuffix>\t{%3, <round_saeonly_op4>%2, %1, %0|%0, %1, %2<round_saeonly_op4>, %3}"
6917   [(set_attr "length_immediate" "1")
6918    (set_attr "prefix" "evex")
6919    (set_attr "mode" "<MODE>")])
6920
6921 ;; One bit in mask selects 2 elements.
6922 (define_insn "avx512f_shufps512_1<mask_name>"
6923   [(set (match_operand:V16SF 0 "register_operand" "=v")
6924         (vec_select:V16SF
6925           (vec_concat:V32SF
6926             (match_operand:V16SF 1 "register_operand" "v")
6927             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
6928           (parallel [(match_operand 3  "const_0_to_3_operand")
6929                      (match_operand 4  "const_0_to_3_operand")
6930                      (match_operand 5  "const_16_to_19_operand")
6931                      (match_operand 6  "const_16_to_19_operand")
6932                      (match_operand 7  "const_4_to_7_operand")
6933                      (match_operand 8  "const_4_to_7_operand")
6934                      (match_operand 9  "const_20_to_23_operand")
6935                      (match_operand 10  "const_20_to_23_operand")
6936                      (match_operand 11  "const_8_to_11_operand")
6937                      (match_operand 12  "const_8_to_11_operand")
6938                      (match_operand 13  "const_24_to_27_operand")
6939                      (match_operand 14  "const_24_to_27_operand")
6940                      (match_operand 15  "const_12_to_15_operand")
6941                      (match_operand 16  "const_12_to_15_operand")
6942                      (match_operand 17  "const_28_to_31_operand")
6943                      (match_operand 18  "const_28_to_31_operand")])))]
6944   "TARGET_AVX512F
6945    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
6946        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
6947        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
6948        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4)
6949        && INTVAL (operands[3]) == (INTVAL (operands[11]) - 8)
6950        && INTVAL (operands[4]) == (INTVAL (operands[12]) - 8)
6951        && INTVAL (operands[5]) == (INTVAL (operands[13]) - 8)
6952        && INTVAL (operands[6]) == (INTVAL (operands[14]) - 8)
6953        && INTVAL (operands[3]) == (INTVAL (operands[15]) - 12)
6954        && INTVAL (operands[4]) == (INTVAL (operands[16]) - 12)
6955        && INTVAL (operands[5]) == (INTVAL (operands[17]) - 12)
6956        && INTVAL (operands[6]) == (INTVAL (operands[18]) - 12))"
6957 {
6958   int mask;
6959   mask = INTVAL (operands[3]);
6960   mask |= INTVAL (operands[4]) << 2;
6961   mask |= (INTVAL (operands[5]) - 16) << 4;
6962   mask |= (INTVAL (operands[6]) - 16) << 6;
6963   operands[3] = GEN_INT (mask);
6964
6965   return "vshufps\t{%3, %2, %1, %0<mask_operand19>|%0<mask_operand19>, %1, %2, %3}";
6966 }
6967   [(set_attr "type" "sselog")
6968    (set_attr "length_immediate" "1")
6969    (set_attr "prefix" "evex")
6970    (set_attr "mode" "V16SF")])
6971
6972 (define_expand "avx512f_shufpd512_mask"
6973   [(match_operand:V8DF 0 "register_operand")
6974    (match_operand:V8DF 1 "register_operand")
6975    (match_operand:V8DF 2 "nonimmediate_operand")
6976    (match_operand:SI 3 "const_0_to_255_operand")
6977    (match_operand:V8DF 4 "register_operand")
6978    (match_operand:QI 5 "register_operand")]
6979   "TARGET_AVX512F"
6980 {
6981   int mask = INTVAL (operands[3]);
6982   emit_insn (gen_avx512f_shufpd512_1_mask (operands[0], operands[1], operands[2],
6983                                         GEN_INT (mask & 1),
6984                                         GEN_INT (mask & 2 ? 9 : 8),
6985                                         GEN_INT (mask & 4 ? 3 : 2),
6986                                         GEN_INT (mask & 8 ? 11 : 10),
6987                                         GEN_INT (mask & 16 ? 5 : 4),
6988                                         GEN_INT (mask & 32 ? 13 : 12),
6989                                         GEN_INT (mask & 64 ? 7 : 6),
6990                                         GEN_INT (mask & 128 ? 15 : 14),
6991                                         operands[4], operands[5]));
6992   DONE;
6993 })
6994
6995 (define_insn "avx512f_shufpd512_1<mask_name>"
6996   [(set (match_operand:V8DF 0 "register_operand" "=v")
6997         (vec_select:V8DF
6998           (vec_concat:V16DF
6999             (match_operand:V8DF 1 "register_operand" "v")
7000             (match_operand:V8DF 2 "nonimmediate_operand" "vm"))
7001           (parallel [(match_operand 3 "const_0_to_1_operand")
7002                      (match_operand 4 "const_8_to_9_operand")
7003                      (match_operand 5 "const_2_to_3_operand")
7004                      (match_operand 6 "const_10_to_11_operand")
7005                      (match_operand 7 "const_4_to_5_operand")
7006                      (match_operand 8 "const_12_to_13_operand")
7007                      (match_operand 9 "const_6_to_7_operand")
7008                      (match_operand 10 "const_14_to_15_operand")])))]
7009   "TARGET_AVX512F"
7010 {
7011   int mask;
7012   mask = INTVAL (operands[3]);
7013   mask |= (INTVAL (operands[4]) - 8) << 1;
7014   mask |= (INTVAL (operands[5]) - 2) << 2;
7015   mask |= (INTVAL (operands[6]) - 10) << 3;
7016   mask |= (INTVAL (operands[7]) - 4) << 4;
7017   mask |= (INTVAL (operands[8]) - 12) << 5;
7018   mask |= (INTVAL (operands[9]) - 6) << 6;
7019   mask |= (INTVAL (operands[10]) - 14) << 7;
7020   operands[3] = GEN_INT (mask);
7021
7022   return "vshufpd\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
7023 }
7024   [(set_attr "type" "sselog")
7025    (set_attr "length_immediate" "1")
7026    (set_attr "prefix" "evex")
7027    (set_attr "mode" "V8DF")])
7028
7029 (define_expand "avx_shufpd256"
7030   [(match_operand:V4DF 0 "register_operand")
7031    (match_operand:V4DF 1 "register_operand")
7032    (match_operand:V4DF 2 "nonimmediate_operand")
7033    (match_operand:SI 3 "const_int_operand")]
7034   "TARGET_AVX"
7035 {
7036   int mask = INTVAL (operands[3]);
7037   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
7038                                    GEN_INT (mask & 1),
7039                                    GEN_INT (mask & 2 ? 5 : 4),
7040                                    GEN_INT (mask & 4 ? 3 : 2),
7041                                    GEN_INT (mask & 8 ? 7 : 6)));
7042   DONE;
7043 })
7044
7045 (define_insn "avx_shufpd256_1"
7046   [(set (match_operand:V4DF 0 "register_operand" "=x")
7047         (vec_select:V4DF
7048           (vec_concat:V8DF
7049             (match_operand:V4DF 1 "register_operand" "x")
7050             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
7051           (parallel [(match_operand 3 "const_0_to_1_operand")
7052                      (match_operand 4 "const_4_to_5_operand")
7053                      (match_operand 5 "const_2_to_3_operand")
7054                      (match_operand 6 "const_6_to_7_operand")])))]
7055   "TARGET_AVX"
7056 {
7057   int mask;
7058   mask = INTVAL (operands[3]);
7059   mask |= (INTVAL (operands[4]) - 4) << 1;
7060   mask |= (INTVAL (operands[5]) - 2) << 2;
7061   mask |= (INTVAL (operands[6]) - 6) << 3;
7062   operands[3] = GEN_INT (mask);
7063
7064   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
7065 }
7066   [(set_attr "type" "sseshuf")
7067    (set_attr "length_immediate" "1")
7068    (set_attr "prefix" "vex")
7069    (set_attr "mode" "V4DF")])
7070
7071 (define_expand "sse2_shufpd"
7072   [(match_operand:V2DF 0 "register_operand")
7073    (match_operand:V2DF 1 "register_operand")
7074    (match_operand:V2DF 2 "nonimmediate_operand")
7075    (match_operand:SI 3 "const_int_operand")]
7076   "TARGET_SSE2"
7077 {
7078   int mask = INTVAL (operands[3]);
7079   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
7080                                 GEN_INT (mask & 1),
7081                                 GEN_INT (mask & 2 ? 3 : 2)));
7082   DONE;
7083 })
7084
7085 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
7086 (define_insn "avx2_interleave_highv4di"
7087   [(set (match_operand:V4DI 0 "register_operand" "=x")
7088         (vec_select:V4DI
7089           (vec_concat:V8DI
7090             (match_operand:V4DI 1 "register_operand" "x")
7091             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
7092           (parallel [(const_int 1)
7093                      (const_int 5)
7094                      (const_int 3)
7095                      (const_int 7)])))]
7096   "TARGET_AVX2"
7097   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
7098   [(set_attr "type" "sselog")
7099    (set_attr "prefix" "vex")
7100    (set_attr "mode" "OI")])
7101
7102 (define_insn "<mask_codefor>avx512f_interleave_highv8di<mask_name>"
7103   [(set (match_operand:V8DI 0 "register_operand" "=v")
7104         (vec_select:V8DI
7105           (vec_concat:V16DI
7106             (match_operand:V8DI 1 "register_operand" "v")
7107             (match_operand:V8DI 2 "nonimmediate_operand" "vm"))
7108           (parallel [(const_int 1) (const_int 9)
7109                      (const_int 3) (const_int 11)
7110                      (const_int 5) (const_int 13)
7111                      (const_int 7) (const_int 15)])))]
7112   "TARGET_AVX512F"
7113   "vpunpckhqdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7114   [(set_attr "type" "sselog")
7115    (set_attr "prefix" "evex")
7116    (set_attr "mode" "XI")])
7117
7118 (define_insn "vec_interleave_highv2di"
7119   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7120         (vec_select:V2DI
7121           (vec_concat:V4DI
7122             (match_operand:V2DI 1 "register_operand" "0,x")
7123             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
7124           (parallel [(const_int 1)
7125                      (const_int 3)])))]
7126   "TARGET_SSE2"
7127   "@
7128    punpckhqdq\t{%2, %0|%0, %2}
7129    vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
7130   [(set_attr "isa" "noavx,avx")
7131    (set_attr "type" "sselog")
7132    (set_attr "prefix_data16" "1,*")
7133    (set_attr "prefix" "orig,vex")
7134    (set_attr "mode" "TI")])
7135
7136 (define_insn "avx2_interleave_lowv4di"
7137   [(set (match_operand:V4DI 0 "register_operand" "=x")
7138         (vec_select:V4DI
7139           (vec_concat:V8DI
7140             (match_operand:V4DI 1 "register_operand" "x")
7141             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
7142           (parallel [(const_int 0)
7143                      (const_int 4)
7144                      (const_int 2)
7145                      (const_int 6)])))]
7146   "TARGET_AVX2"
7147   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
7148   [(set_attr "type" "sselog")
7149    (set_attr "prefix" "vex")
7150    (set_attr "mode" "OI")])
7151
7152 (define_insn "<mask_codefor>avx512f_interleave_lowv8di<mask_name>"
7153   [(set (match_operand:V8DI 0 "register_operand" "=v")
7154         (vec_select:V8DI
7155           (vec_concat:V16DI
7156             (match_operand:V8DI 1 "register_operand" "v")
7157             (match_operand:V8DI 2 "nonimmediate_operand" "vm"))
7158           (parallel [(const_int 0) (const_int 8)
7159                      (const_int 2) (const_int 10)
7160                      (const_int 4) (const_int 12)
7161                      (const_int 6) (const_int 14)])))]
7162   "TARGET_AVX512F"
7163   "vpunpcklqdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7164   [(set_attr "type" "sselog")
7165    (set_attr "prefix" "evex")
7166    (set_attr "mode" "XI")])
7167
7168 (define_insn "vec_interleave_lowv2di"
7169   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7170         (vec_select:V2DI
7171           (vec_concat:V4DI
7172             (match_operand:V2DI 1 "register_operand" "0,x")
7173             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
7174           (parallel [(const_int 0)
7175                      (const_int 2)])))]
7176   "TARGET_SSE2"
7177   "@
7178    punpcklqdq\t{%2, %0|%0, %2}
7179    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
7180   [(set_attr "isa" "noavx,avx")
7181    (set_attr "type" "sselog")
7182    (set_attr "prefix_data16" "1,*")
7183    (set_attr "prefix" "orig,vex")
7184    (set_attr "mode" "TI")])
7185
7186 (define_insn "sse2_shufpd_<mode>"
7187   [(set (match_operand:VI8F_128 0 "register_operand" "=x,x")
7188         (vec_select:VI8F_128
7189           (vec_concat:<ssedoublevecmode>
7190             (match_operand:VI8F_128 1 "register_operand" "0,x")
7191             (match_operand:VI8F_128 2 "nonimmediate_operand" "xm,xm"))
7192           (parallel [(match_operand 3 "const_0_to_1_operand")
7193                      (match_operand 4 "const_2_to_3_operand")])))]
7194   "TARGET_SSE2"
7195 {
7196   int mask;
7197   mask = INTVAL (operands[3]);
7198   mask |= (INTVAL (operands[4]) - 2) << 1;
7199   operands[3] = GEN_INT (mask);
7200
7201   switch (which_alternative)
7202     {
7203     case 0:
7204       return "shufpd\t{%3, %2, %0|%0, %2, %3}";
7205     case 1:
7206       return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
7207     default:
7208       gcc_unreachable ();
7209     }
7210 }
7211   [(set_attr "isa" "noavx,avx")
7212    (set_attr "type" "sseshuf")
7213    (set_attr "length_immediate" "1")
7214    (set_attr "prefix" "orig,vex")
7215    (set_attr "mode" "V2DF")])
7216
7217 ;; Avoid combining registers from different units in a single alternative,
7218 ;; see comment above inline_secondary_memory_needed function in i386.c
7219 (define_insn "sse2_storehpd"
7220   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,x,*f,r")
7221         (vec_select:DF
7222           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,x,o,o,o")
7223           (parallel [(const_int 1)])))]
7224   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7225   "@
7226    %vmovhpd\t{%1, %0|%0, %1}
7227    unpckhpd\t%0, %0
7228    vunpckhpd\t{%d1, %0|%0, %d1}
7229    #
7230    #
7231    #"
7232   [(set_attr "isa" "*,noavx,avx,*,*,*")
7233    (set_attr "type" "ssemov,sselog1,sselog1,ssemov,fmov,imov")
7234    (set (attr "prefix_data16")
7235      (if_then_else
7236        (and (eq_attr "alternative" "0")
7237             (not (match_test "TARGET_AVX")))
7238        (const_string "1")
7239        (const_string "*")))
7240    (set_attr "prefix" "maybe_vex,orig,vex,*,*,*")
7241    (set_attr "mode" "V1DF,V1DF,V2DF,DF,DF,DF")])
7242
7243 (define_split
7244   [(set (match_operand:DF 0 "register_operand")
7245         (vec_select:DF
7246           (match_operand:V2DF 1 "memory_operand")
7247           (parallel [(const_int 1)])))]
7248   "TARGET_SSE2 && reload_completed"
7249   [(set (match_dup 0) (match_dup 1))]
7250   "operands[1] = adjust_address (operands[1], DFmode, 8);")
7251
7252 (define_insn "*vec_extractv2df_1_sse"
7253   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
7254         (vec_select:DF
7255           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
7256           (parallel [(const_int 1)])))]
7257   "!TARGET_SSE2 && TARGET_SSE
7258    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7259   "@
7260    movhps\t{%1, %0|%q0, %1}
7261    movhlps\t{%1, %0|%0, %1}
7262    movlps\t{%H1, %0|%0, %H1}"
7263   [(set_attr "type" "ssemov")
7264    (set_attr "ssememalign" "64")
7265    (set_attr "mode" "V2SF,V4SF,V2SF")])
7266
7267 ;; Avoid combining registers from different units in a single alternative,
7268 ;; see comment above inline_secondary_memory_needed function in i386.c
7269 (define_insn "sse2_storelpd"
7270   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
7271         (vec_select:DF
7272           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
7273           (parallel [(const_int 0)])))]
7274   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7275   "@
7276    %vmovlpd\t{%1, %0|%0, %1}
7277    #
7278    #
7279    #
7280    #"
7281   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
7282    (set_attr "prefix_data16" "1,*,*,*,*")
7283    (set_attr "prefix" "maybe_vex")
7284    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
7285
7286 (define_split
7287   [(set (match_operand:DF 0 "register_operand")
7288         (vec_select:DF
7289           (match_operand:V2DF 1 "nonimmediate_operand")
7290           (parallel [(const_int 0)])))]
7291   "TARGET_SSE2 && reload_completed"
7292   [(set (match_dup 0) (match_dup 1))]
7293 {
7294   if (REG_P (operands[1]))
7295     operands[1] = gen_rtx_REG (DFmode, REGNO (operands[1]));
7296   else
7297     operands[1] = adjust_address (operands[1], DFmode, 0);
7298 })
7299
7300 (define_insn "*vec_extractv2df_0_sse"
7301   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
7302         (vec_select:DF
7303           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
7304           (parallel [(const_int 0)])))]
7305   "!TARGET_SSE2 && TARGET_SSE
7306    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7307   "@
7308    movlps\t{%1, %0|%0, %1}
7309    movaps\t{%1, %0|%0, %1}
7310    movlps\t{%1, %0|%0, %q1}"
7311   [(set_attr "type" "ssemov")
7312    (set_attr "mode" "V2SF,V4SF,V2SF")])
7313
7314 (define_expand "sse2_loadhpd_exp"
7315   [(set (match_operand:V2DF 0 "nonimmediate_operand")
7316         (vec_concat:V2DF
7317           (vec_select:DF
7318             (match_operand:V2DF 1 "nonimmediate_operand")
7319             (parallel [(const_int 0)]))
7320           (match_operand:DF 2 "nonimmediate_operand")))]
7321   "TARGET_SSE2"
7322 {
7323   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
7324
7325   emit_insn (gen_sse2_loadhpd (dst, operands[1], operands[2]));
7326
7327   /* Fix up the destination if needed.  */
7328   if (dst != operands[0])
7329     emit_move_insn (operands[0], dst);
7330
7331   DONE;
7332 })
7333
7334 ;; Avoid combining registers from different units in a single alternative,
7335 ;; see comment above inline_secondary_memory_needed function in i386.c
7336 (define_insn "sse2_loadhpd"
7337   [(set (match_operand:V2DF 0 "nonimmediate_operand"
7338           "=x,x,x,x,o,o ,o")
7339         (vec_concat:V2DF
7340           (vec_select:DF
7341             (match_operand:V2DF 1 "nonimmediate_operand"
7342           " 0,x,0,x,0,0 ,0")
7343             (parallel [(const_int 0)]))
7344           (match_operand:DF 2 "nonimmediate_operand"
7345           " m,m,x,x,x,*f,r")))]
7346   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
7347   "@
7348    movhpd\t{%2, %0|%0, %2}
7349    vmovhpd\t{%2, %1, %0|%0, %1, %2}
7350    unpcklpd\t{%2, %0|%0, %2}
7351    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
7352    #
7353    #
7354    #"
7355   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
7356    (set_attr "type" "ssemov,ssemov,sselog,sselog,ssemov,fmov,imov")
7357    (set_attr "ssememalign" "64")
7358    (set_attr "prefix_data16" "1,*,*,*,*,*,*")
7359    (set_attr "prefix" "orig,vex,orig,vex,*,*,*")
7360    (set_attr "mode" "V1DF,V1DF,V2DF,V2DF,DF,DF,DF")])
7361
7362 (define_split
7363   [(set (match_operand:V2DF 0 "memory_operand")
7364         (vec_concat:V2DF
7365           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
7366           (match_operand:DF 1 "register_operand")))]
7367   "TARGET_SSE2 && reload_completed"
7368   [(set (match_dup 0) (match_dup 1))]
7369   "operands[0] = adjust_address (operands[0], DFmode, 8);")
7370
7371 (define_expand "sse2_loadlpd_exp"
7372   [(set (match_operand:V2DF 0 "nonimmediate_operand")
7373         (vec_concat:V2DF
7374           (match_operand:DF 2 "nonimmediate_operand")
7375           (vec_select:DF
7376             (match_operand:V2DF 1 "nonimmediate_operand")
7377             (parallel [(const_int 1)]))))]
7378   "TARGET_SSE2"
7379 {
7380   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
7381
7382   emit_insn (gen_sse2_loadlpd (dst, operands[1], operands[2]));
7383
7384   /* Fix up the destination if needed.  */
7385   if (dst != operands[0])
7386     emit_move_insn (operands[0], dst);
7387
7388   DONE;
7389 })
7390
7391 ;; Avoid combining registers from different units in a single alternative,
7392 ;; see comment above inline_secondary_memory_needed function in i386.c
7393 (define_insn "sse2_loadlpd"
7394   [(set (match_operand:V2DF 0 "nonimmediate_operand"
7395           "=x,x,x,x,x,x,x,x,m,m ,m")
7396         (vec_concat:V2DF
7397           (match_operand:DF 2 "nonimmediate_operand"
7398           " m,m,m,x,x,0,0,x,x,*f,r")
7399           (vec_select:DF
7400             (match_operand:V2DF 1 "vector_move_operand"
7401           " C,0,x,0,x,x,o,o,0,0 ,0")
7402             (parallel [(const_int 1)]))))]
7403   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
7404   "@
7405    %vmovsd\t{%2, %0|%0, %2}
7406    movlpd\t{%2, %0|%0, %2}
7407    vmovlpd\t{%2, %1, %0|%0, %1, %2}
7408    movsd\t{%2, %0|%0, %2}
7409    vmovsd\t{%2, %1, %0|%0, %1, %2}
7410    shufpd\t{$2, %1, %0|%0, %1, 2}
7411    movhpd\t{%H1, %0|%0, %H1}
7412    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
7413    #
7414    #
7415    #"
7416   [(set_attr "isa" "*,noavx,avx,noavx,avx,noavx,noavx,avx,*,*,*")
7417    (set (attr "type")
7418      (cond [(eq_attr "alternative" "5")
7419               (const_string "sselog")
7420             (eq_attr "alternative" "9")
7421               (const_string "fmov")
7422             (eq_attr "alternative" "10")
7423               (const_string "imov")
7424            ]
7425            (const_string "ssemov")))
7426    (set_attr "ssememalign" "64")
7427    (set_attr "prefix_data16" "*,1,*,*,*,*,1,*,*,*,*")
7428    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*,*,*")
7429    (set_attr "prefix" "maybe_vex,orig,vex,orig,vex,orig,orig,vex,*,*,*")
7430    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,DF,DF,DF")])
7431
7432 (define_split
7433   [(set (match_operand:V2DF 0 "memory_operand")
7434         (vec_concat:V2DF
7435           (match_operand:DF 1 "register_operand")
7436           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
7437   "TARGET_SSE2 && reload_completed"
7438   [(set (match_dup 0) (match_dup 1))]
7439   "operands[0] = adjust_address (operands[0], DFmode, 0);")
7440
7441 (define_insn "sse2_movsd"
7442   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,x,x,m,x,x,x,o")
7443         (vec_merge:V2DF
7444           (match_operand:V2DF 2 "nonimmediate_operand" " x,x,m,m,x,0,0,x,0")
7445           (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,0,x,0,x,o,o,x")
7446           (const_int 1)))]
7447   "TARGET_SSE2"
7448   "@
7449    movsd\t{%2, %0|%0, %2}
7450    vmovsd\t{%2, %1, %0|%0, %1, %2}
7451    movlpd\t{%2, %0|%0, %q2}
7452    vmovlpd\t{%2, %1, %0|%0, %1, %q2}
7453    %vmovlpd\t{%2, %0|%q0, %2}
7454    shufpd\t{$2, %1, %0|%0, %1, 2}
7455    movhps\t{%H1, %0|%0, %H1}
7456    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
7457    %vmovhps\t{%1, %H0|%H0, %1}"
7458   [(set_attr "isa" "noavx,avx,noavx,avx,*,noavx,noavx,avx,*")
7459    (set (attr "type")
7460      (if_then_else
7461        (eq_attr "alternative" "5")
7462        (const_string "sselog")
7463        (const_string "ssemov")))
7464    (set (attr "prefix_data16")
7465      (if_then_else
7466        (and (eq_attr "alternative" "2,4")
7467             (not (match_test "TARGET_AVX")))
7468        (const_string "1")
7469        (const_string "*")))
7470    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*")
7471    (set_attr "ssememalign" "64")
7472    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig,vex,maybe_vex")
7473    (set_attr "mode" "DF,DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,V1DF")])
7474
7475 (define_insn "vec_dupv2df"
7476   [(set (match_operand:V2DF 0 "register_operand"     "=x,x")
7477         (vec_duplicate:V2DF
7478           (match_operand:DF 1 "nonimmediate_operand" " 0,xm")))]
7479   "TARGET_SSE2"
7480   "@
7481    unpcklpd\t%0, %0
7482    %vmovddup\t{%1, %0|%0, %1}"
7483   [(set_attr "isa" "noavx,sse3")
7484    (set_attr "type" "sselog1")
7485    (set_attr "prefix" "orig,maybe_vex")
7486    (set_attr "mode" "V2DF,DF")])
7487
7488 (define_insn "*vec_concatv2df"
7489   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x,x,x,x,x,x")
7490         (vec_concat:V2DF
7491           (match_operand:DF 1 "nonimmediate_operand" " 0,x,m,0,x,m,0,0")
7492           (match_operand:DF 2 "vector_move_operand"  " x,x,1,m,m,C,x,m")))]
7493   "TARGET_SSE"
7494   "@
7495    unpcklpd\t{%2, %0|%0, %2}
7496    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
7497    %vmovddup\t{%1, %0|%0, %1}
7498    movhpd\t{%2, %0|%0, %2}
7499    vmovhpd\t{%2, %1, %0|%0, %1, %2}
7500    %vmovsd\t{%1, %0|%0, %1}
7501    movlhps\t{%2, %0|%0, %2}
7502    movhps\t{%2, %0|%0, %2}"
7503   [(set_attr "isa" "sse2_noavx,avx,sse3,sse2_noavx,avx,sse2,noavx,noavx")
7504    (set (attr "type")
7505      (if_then_else
7506        (eq_attr "alternative" "0,1,2")
7507        (const_string "sselog")
7508        (const_string "ssemov")))
7509    (set_attr "prefix_data16" "*,*,*,1,*,*,*,*")
7510    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex,orig,orig")
7511    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,DF,V4SF,V2SF")])
7512
7513 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7514 ;;
7515 ;; Parallel integer down-conversion operations
7516 ;;
7517 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7518
7519 (define_mode_iterator PMOV_DST_MODE [V16QI V16HI V8SI V8HI])
7520 (define_mode_attr pmov_src_mode
7521   [(V16QI "V16SI") (V16HI "V16SI") (V8SI "V8DI") (V8HI "V8DI")])
7522 (define_mode_attr pmov_src_lower
7523   [(V16QI "v16si") (V16HI "v16si") (V8SI "v8di") (V8HI "v8di")])
7524 (define_mode_attr pmov_suff
7525   [(V16QI "db") (V16HI "dw") (V8SI "qd") (V8HI "qw")])
7526
7527 (define_insn "*avx512f_<code><pmov_src_lower><mode>2"
7528   [(set (match_operand:PMOV_DST_MODE 0 "nonimmediate_operand" "=v,m")
7529         (any_truncate:PMOV_DST_MODE
7530           (match_operand:<pmov_src_mode> 1 "register_operand" "v,v")))]
7531   "TARGET_AVX512F"
7532   "vpmov<trunsuffix><pmov_suff>\t{%1, %0|%0, %1}"
7533   [(set_attr "type" "ssemov")
7534    (set_attr "memory" "none,store")
7535    (set_attr "prefix" "evex")
7536    (set_attr "mode" "<sseinsnmode>")])
7537
7538 (define_insn "avx512f_<code><pmov_src_lower><mode>2_mask"
7539   [(set (match_operand:PMOV_DST_MODE 0 "nonimmediate_operand" "=v,m")
7540     (vec_merge:PMOV_DST_MODE
7541       (any_truncate:PMOV_DST_MODE
7542         (match_operand:<pmov_src_mode> 1 "register_operand" "v,v"))
7543       (match_operand:PMOV_DST_MODE 2 "vector_move_operand" "0C,0")
7544       (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk,Yk")))]
7545   "TARGET_AVX512F"
7546   "vpmov<trunsuffix><pmov_suff>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
7547   [(set_attr "type" "ssemov")
7548    (set_attr "memory" "none,store")
7549    (set_attr "prefix" "evex")
7550    (set_attr "mode" "<sseinsnmode>")])
7551
7552 (define_expand "avx512f_<code><pmov_src_lower><mode>2_mask_store"
7553   [(set (match_operand:PMOV_DST_MODE 0 "memory_operand")
7554     (vec_merge:PMOV_DST_MODE
7555       (any_truncate:PMOV_DST_MODE
7556         (match_operand:<pmov_src_mode> 1 "register_operand"))
7557       (match_dup 0)
7558       (match_operand:<avx512fmaskmode> 2 "register_operand")))]
7559   "TARGET_AVX512F")
7560
7561 (define_insn "*avx512f_<code>v8div16qi2"
7562   [(set (match_operand:V16QI 0 "register_operand" "=v")
7563         (vec_concat:V16QI
7564           (any_truncate:V8QI
7565             (match_operand:V8DI 1 "register_operand" "v"))
7566           (const_vector:V8QI [(const_int 0) (const_int 0)
7567                               (const_int 0) (const_int 0)
7568                               (const_int 0) (const_int 0)
7569                               (const_int 0) (const_int 0)])))]
7570   "TARGET_AVX512F"
7571   "vpmov<trunsuffix>qb\t{%1, %0|%0, %1}"
7572   [(set_attr "type" "ssemov")
7573    (set_attr "prefix" "evex")
7574    (set_attr "mode" "TI")])
7575
7576 (define_insn "*avx512f_<code>v8div16qi2_store"
7577   [(set (match_operand:V16QI 0 "memory_operand" "=m")
7578         (vec_concat:V16QI
7579           (any_truncate:V8QI
7580             (match_operand:V8DI 1 "register_operand" "v"))
7581           (vec_select:V8QI
7582             (match_dup 0)
7583             (parallel [(const_int 8) (const_int 9)
7584                        (const_int 10) (const_int 11)
7585                        (const_int 12) (const_int 13)
7586                        (const_int 14) (const_int 15)]))))]
7587   "TARGET_AVX512F"
7588   "vpmov<trunsuffix>qb\t{%1, %0|%0, %1}"
7589   [(set_attr "type" "ssemov")
7590    (set_attr "memory" "store")
7591    (set_attr "prefix" "evex")
7592    (set_attr "mode" "TI")])
7593
7594 (define_insn "avx512f_<code>v8div16qi2_mask"
7595   [(set (match_operand:V16QI 0 "register_operand" "=v")
7596     (vec_concat:V16QI
7597       (vec_merge:V8QI
7598         (any_truncate:V8QI
7599           (match_operand:V8DI 1 "register_operand" "v"))
7600         (vec_select:V8QI
7601           (match_operand:V16QI 2 "vector_move_operand" "0C")
7602           (parallel [(const_int 0) (const_int 1)
7603                      (const_int 2) (const_int 3)
7604                      (const_int 4) (const_int 5)
7605                      (const_int 6) (const_int 7)]))
7606         (match_operand:QI 3 "register_operand" "Yk"))
7607       (const_vector:V8QI [(const_int 0) (const_int 0)
7608                           (const_int 0) (const_int 0)
7609                           (const_int 0) (const_int 0)
7610                           (const_int 0) (const_int 0)])))]
7611   "TARGET_AVX512F"
7612   "vpmov<trunsuffix>qb\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
7613   [(set_attr "type" "ssemov")
7614    (set_attr "prefix" "evex")
7615    (set_attr "mode" "TI")])
7616
7617 (define_insn "avx512f_<code>v8div16qi2_mask_store"
7618   [(set (match_operand:V16QI 0 "memory_operand" "=m")
7619     (vec_concat:V16QI
7620       (vec_merge:V8QI
7621         (any_truncate:V8QI
7622           (match_operand:V8DI 1 "register_operand" "v"))
7623         (vec_select:V8QI
7624           (match_dup 0)
7625           (parallel [(const_int 0) (const_int 1)
7626                      (const_int 2) (const_int 3)
7627                      (const_int 4) (const_int 5)
7628                      (const_int 6) (const_int 7)]))
7629         (match_operand:QI 2 "register_operand" "Yk"))
7630       (vec_select:V8QI
7631         (match_dup 0)
7632         (parallel [(const_int 8) (const_int 9)
7633                    (const_int 10) (const_int 11)
7634                    (const_int 12) (const_int 13)
7635                    (const_int 14) (const_int 15)]))))]
7636   "TARGET_AVX512F"
7637   "vpmov<trunsuffix>qb\t{%1, %0%{%2%}|%0%{%2%}, %1}"
7638   [(set_attr "type" "ssemov")
7639    (set_attr "memory" "store")
7640    (set_attr "prefix" "evex")
7641    (set_attr "mode" "TI")])
7642
7643 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7644 ;;
7645 ;; Parallel integral arithmetic
7646 ;;
7647 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7648
7649 (define_expand "neg<mode>2"
7650   [(set (match_operand:VI_AVX2 0 "register_operand")
7651         (minus:VI_AVX2
7652           (match_dup 2)
7653           (match_operand:VI_AVX2 1 "nonimmediate_operand")))]
7654   "TARGET_SSE2"
7655   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
7656
7657 (define_expand "<plusminus_insn><mode>3<mask_name>"
7658   [(set (match_operand:VI_AVX2 0 "register_operand")
7659         (plusminus:VI_AVX2
7660           (match_operand:VI_AVX2 1 "nonimmediate_operand")
7661           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
7662   "TARGET_SSE2 && <mask_mode512bit_condition>"
7663   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
7664
7665 (define_insn "*<plusminus_insn><mode>3<mask_name>"
7666   [(set (match_operand:VI_AVX2 0 "register_operand" "=x,v")
7667         (plusminus:VI_AVX2
7668           (match_operand:VI_AVX2 1 "nonimmediate_operand" "<comm>0,v")
7669           (match_operand:VI_AVX2 2 "nonimmediate_operand" "xm,vm")))]
7670   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands) && <mask_mode512bit_condition>"
7671   "@
7672    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
7673    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7674   [(set_attr "isa" "noavx,avx")
7675    (set_attr "type" "sseiadd")
7676    (set_attr "prefix_data16" "1,*")
7677    (set_attr "prefix" "<mask_prefix3>")
7678    (set_attr "mode" "<sseinsnmode>")])
7679
7680 (define_expand "<sse2_avx2>_<plusminus_insn><mode>3"
7681   [(set (match_operand:VI12_AVX2 0 "register_operand")
7682         (sat_plusminus:VI12_AVX2
7683           (match_operand:VI12_AVX2 1 "nonimmediate_operand")
7684           (match_operand:VI12_AVX2 2 "nonimmediate_operand")))]
7685   "TARGET_SSE2"
7686   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
7687
7688 (define_insn "*<sse2_avx2>_<plusminus_insn><mode>3"
7689   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,v")
7690         (sat_plusminus:VI12_AVX2
7691           (match_operand:VI12_AVX2 1 "nonimmediate_operand" "<comm>0,v")
7692           (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,vm")))]
7693   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
7694   "@
7695    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
7696    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
7697   [(set_attr "isa" "noavx,avx")
7698    (set_attr "type" "sseiadd")
7699    (set_attr "prefix_data16" "1,*")
7700    (set_attr "prefix" "orig,vex")
7701    (set_attr "mode" "TI")])
7702
7703 (define_expand "mul<mode>3"
7704   [(set (match_operand:VI1_AVX2 0 "register_operand")
7705         (mult:VI1_AVX2 (match_operand:VI1_AVX2 1 "register_operand")
7706                        (match_operand:VI1_AVX2 2 "register_operand")))]
7707   "TARGET_SSE2"
7708 {
7709   ix86_expand_vecop_qihi (MULT, operands[0], operands[1], operands[2]);
7710   DONE;
7711 })
7712
7713 (define_expand "mul<mode>3"
7714   [(set (match_operand:VI2_AVX2 0 "register_operand")
7715         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand")
7716                        (match_operand:VI2_AVX2 2 "nonimmediate_operand")))]
7717   "TARGET_SSE2"
7718   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
7719
7720 (define_insn "*mul<mode>3"
7721   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
7722         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x")
7723                        (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))]
7724   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
7725   "@
7726    pmullw\t{%2, %0|%0, %2}
7727    vpmullw\t{%2, %1, %0|%0, %1, %2}"
7728   [(set_attr "isa" "noavx,avx")
7729    (set_attr "type" "sseimul")
7730    (set_attr "prefix_data16" "1,*")
7731    (set_attr "prefix" "orig,vex")
7732    (set_attr "mode" "<sseinsnmode>")])
7733
7734 (define_expand "<s>mul<mode>3_highpart"
7735   [(set (match_operand:VI2_AVX2 0 "register_operand")
7736         (truncate:VI2_AVX2
7737           (lshiftrt:<ssedoublemode>
7738             (mult:<ssedoublemode>
7739               (any_extend:<ssedoublemode>
7740                 (match_operand:VI2_AVX2 1 "nonimmediate_operand"))
7741               (any_extend:<ssedoublemode>
7742                 (match_operand:VI2_AVX2 2 "nonimmediate_operand")))
7743             (const_int 16))))]
7744   "TARGET_SSE2"
7745   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
7746
7747 (define_insn "*<s>mul<mode>3_highpart"
7748   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
7749         (truncate:VI2_AVX2
7750           (lshiftrt:<ssedoublemode>
7751             (mult:<ssedoublemode>
7752               (any_extend:<ssedoublemode>
7753                 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
7754               (any_extend:<ssedoublemode>
7755                 (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
7756             (const_int 16))))]
7757   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
7758   "@
7759    pmulh<u>w\t{%2, %0|%0, %2}
7760    vpmulh<u>w\t{%2, %1, %0|%0, %1, %2}"
7761   [(set_attr "isa" "noavx,avx")
7762    (set_attr "type" "sseimul")
7763    (set_attr "prefix_data16" "1,*")
7764    (set_attr "prefix" "orig,vex")
7765    (set_attr "mode" "<sseinsnmode>")])
7766
7767 (define_expand "vec_widen_umult_even_v16si<mask_name>"
7768   [(set (match_operand:V8DI 0 "register_operand")
7769         (mult:V8DI
7770           (zero_extend:V8DI
7771             (vec_select:V8SI
7772               (match_operand:V16SI 1 "nonimmediate_operand")
7773               (parallel [(const_int 0) (const_int 2)
7774                          (const_int 4) (const_int 6)
7775                          (const_int 8) (const_int 10)
7776                          (const_int 12) (const_int 14)])))
7777           (zero_extend:V8DI
7778             (vec_select:V8SI
7779               (match_operand:V16SI 2 "nonimmediate_operand")
7780               (parallel [(const_int 0) (const_int 2)
7781                          (const_int 4) (const_int 6)
7782                          (const_int 8) (const_int 10)
7783                          (const_int 12) (const_int 14)])))))]
7784   "TARGET_AVX512F"
7785   "ix86_fixup_binary_operands_no_copy (MULT, V16SImode, operands);")
7786
7787 (define_insn "*vec_widen_umult_even_v16si<mask_name>"
7788   [(set (match_operand:V8DI 0 "register_operand" "=v")
7789         (mult:V8DI
7790           (zero_extend:V8DI
7791             (vec_select:V8SI
7792               (match_operand:V16SI 1 "nonimmediate_operand" "%v")
7793               (parallel [(const_int 0) (const_int 2)
7794                          (const_int 4) (const_int 6)
7795                          (const_int 8) (const_int 10)
7796                          (const_int 12) (const_int 14)])))
7797           (zero_extend:V8DI
7798             (vec_select:V8SI
7799               (match_operand:V16SI 2 "nonimmediate_operand" "vm")
7800               (parallel [(const_int 0) (const_int 2)
7801                          (const_int 4) (const_int 6)
7802                          (const_int 8) (const_int 10)
7803                          (const_int 12) (const_int 14)])))))]
7804   "TARGET_AVX512F && ix86_binary_operator_ok (MULT, V16SImode, operands)"
7805   "vpmuludq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7806   [(set_attr "isa" "avx512f")
7807    (set_attr "type" "sseimul")
7808    (set_attr "prefix_extra" "1")
7809    (set_attr "prefix" "evex")
7810    (set_attr "mode" "XI")])
7811
7812 (define_expand "vec_widen_umult_even_v8si"
7813   [(set (match_operand:V4DI 0 "register_operand")
7814         (mult:V4DI
7815           (zero_extend:V4DI
7816             (vec_select:V4SI
7817               (match_operand:V8SI 1 "nonimmediate_operand")
7818               (parallel [(const_int 0) (const_int 2)
7819                          (const_int 4) (const_int 6)])))
7820           (zero_extend:V4DI
7821             (vec_select:V4SI
7822               (match_operand:V8SI 2 "nonimmediate_operand")
7823               (parallel [(const_int 0) (const_int 2)
7824                          (const_int 4) (const_int 6)])))))]
7825   "TARGET_AVX2"
7826   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
7827
7828 (define_insn "*vec_widen_umult_even_v8si"
7829   [(set (match_operand:V4DI 0 "register_operand" "=x")
7830         (mult:V4DI
7831           (zero_extend:V4DI
7832             (vec_select:V4SI
7833               (match_operand:V8SI 1 "nonimmediate_operand" "%x")
7834               (parallel [(const_int 0) (const_int 2)
7835                          (const_int 4) (const_int 6)])))
7836           (zero_extend:V4DI
7837             (vec_select:V4SI
7838               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
7839               (parallel [(const_int 0) (const_int 2)
7840                          (const_int 4) (const_int 6)])))))]
7841   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
7842   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
7843   [(set_attr "type" "sseimul")
7844    (set_attr "prefix" "vex")
7845    (set_attr "mode" "OI")])
7846
7847 (define_expand "vec_widen_umult_even_v4si"
7848   [(set (match_operand:V2DI 0 "register_operand")
7849         (mult:V2DI
7850           (zero_extend:V2DI
7851             (vec_select:V2SI
7852               (match_operand:V4SI 1 "nonimmediate_operand")
7853               (parallel [(const_int 0) (const_int 2)])))
7854           (zero_extend:V2DI
7855             (vec_select:V2SI
7856               (match_operand:V4SI 2 "nonimmediate_operand")
7857               (parallel [(const_int 0) (const_int 2)])))))]
7858   "TARGET_SSE2"
7859   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
7860
7861 (define_insn "*vec_widen_umult_even_v4si"
7862   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7863         (mult:V2DI
7864           (zero_extend:V2DI
7865             (vec_select:V2SI
7866               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
7867               (parallel [(const_int 0) (const_int 2)])))
7868           (zero_extend:V2DI
7869             (vec_select:V2SI
7870               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
7871               (parallel [(const_int 0) (const_int 2)])))))]
7872   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
7873   "@
7874    pmuludq\t{%2, %0|%0, %2}
7875    vpmuludq\t{%2, %1, %0|%0, %1, %2}"
7876   [(set_attr "isa" "noavx,avx")
7877    (set_attr "type" "sseimul")
7878    (set_attr "prefix_data16" "1,*")
7879    (set_attr "prefix" "orig,vex")
7880    (set_attr "mode" "TI")])
7881
7882 (define_expand "vec_widen_smult_even_v16si<mask_name>"
7883   [(set (match_operand:V8DI 0 "register_operand")
7884         (mult:V8DI
7885           (sign_extend:V8DI
7886             (vec_select:V8SI
7887               (match_operand:V16SI 1 "nonimmediate_operand")
7888               (parallel [(const_int 0) (const_int 2)
7889                          (const_int 4) (const_int 6)
7890                          (const_int 8) (const_int 10)
7891                          (const_int 12) (const_int 14)])))
7892           (sign_extend:V8DI
7893             (vec_select:V8SI
7894               (match_operand:V16SI 2 "nonimmediate_operand")
7895               (parallel [(const_int 0) (const_int 2)
7896                          (const_int 4) (const_int 6)
7897                          (const_int 8) (const_int 10)
7898                          (const_int 12) (const_int 14)])))))]
7899   "TARGET_AVX512F"
7900   "ix86_fixup_binary_operands_no_copy (MULT, V16SImode, operands);")
7901
7902 (define_insn "*vec_widen_smult_even_v16si<mask_name>"
7903   [(set (match_operand:V8DI 0 "register_operand" "=v")
7904         (mult:V8DI
7905           (sign_extend:V8DI
7906             (vec_select:V8SI
7907               (match_operand:V16SI 1 "nonimmediate_operand" "%v")
7908               (parallel [(const_int 0) (const_int 2)
7909                          (const_int 4) (const_int 6)
7910                          (const_int 8) (const_int 10)
7911                          (const_int 12) (const_int 14)])))
7912           (sign_extend:V8DI
7913             (vec_select:V8SI
7914               (match_operand:V16SI 2 "nonimmediate_operand" "vm")
7915               (parallel [(const_int 0) (const_int 2)
7916                          (const_int 4) (const_int 6)
7917                          (const_int 8) (const_int 10)
7918                          (const_int 12) (const_int 14)])))))]
7919   "TARGET_AVX512F && ix86_binary_operator_ok (MULT, V16SImode, operands)"
7920   "vpmuldq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7921   [(set_attr "isa" "avx512f")
7922    (set_attr "type" "sseimul")
7923    (set_attr "prefix_extra" "1")
7924    (set_attr "prefix" "evex")
7925    (set_attr "mode" "XI")])
7926
7927 (define_expand "vec_widen_smult_even_v8si"
7928   [(set (match_operand:V4DI 0 "register_operand")
7929         (mult:V4DI
7930           (sign_extend:V4DI
7931             (vec_select:V4SI
7932               (match_operand:V8SI 1 "nonimmediate_operand")
7933               (parallel [(const_int 0) (const_int 2)
7934                          (const_int 4) (const_int 6)])))
7935           (sign_extend:V4DI
7936             (vec_select:V4SI
7937               (match_operand:V8SI 2 "nonimmediate_operand")
7938               (parallel [(const_int 0) (const_int 2)
7939                          (const_int 4) (const_int 6)])))))]
7940   "TARGET_AVX2"
7941   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
7942
7943 (define_insn "*vec_widen_smult_even_v8si"
7944   [(set (match_operand:V4DI 0 "register_operand" "=x")
7945         (mult:V4DI
7946           (sign_extend:V4DI
7947             (vec_select:V4SI
7948               (match_operand:V8SI 1 "nonimmediate_operand" "x")
7949               (parallel [(const_int 0) (const_int 2)
7950                          (const_int 4) (const_int 6)])))
7951           (sign_extend:V4DI
7952             (vec_select:V4SI
7953               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
7954               (parallel [(const_int 0) (const_int 2)
7955                          (const_int 4) (const_int 6)])))))]
7956   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
7957   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
7958   [(set_attr "type" "sseimul")
7959    (set_attr "prefix_extra" "1")
7960    (set_attr "prefix" "vex")
7961    (set_attr "mode" "OI")])
7962
7963 (define_expand "sse4_1_mulv2siv2di3"
7964   [(set (match_operand:V2DI 0 "register_operand")
7965         (mult:V2DI
7966           (sign_extend:V2DI
7967             (vec_select:V2SI
7968               (match_operand:V4SI 1 "nonimmediate_operand")
7969               (parallel [(const_int 0) (const_int 2)])))
7970           (sign_extend:V2DI
7971             (vec_select:V2SI
7972               (match_operand:V4SI 2 "nonimmediate_operand")
7973               (parallel [(const_int 0) (const_int 2)])))))]
7974   "TARGET_SSE4_1"
7975   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
7976
7977 (define_insn "*sse4_1_mulv2siv2di3"
7978   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7979         (mult:V2DI
7980           (sign_extend:V2DI
7981             (vec_select:V2SI
7982               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
7983               (parallel [(const_int 0) (const_int 2)])))
7984           (sign_extend:V2DI
7985             (vec_select:V2SI
7986               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
7987               (parallel [(const_int 0) (const_int 2)])))))]
7988   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
7989   "@
7990    pmuldq\t{%2, %0|%0, %2}
7991    vpmuldq\t{%2, %1, %0|%0, %1, %2}"
7992   [(set_attr "isa" "noavx,avx")
7993    (set_attr "type" "sseimul")
7994    (set_attr "prefix_data16" "1,*")
7995    (set_attr "prefix_extra" "1")
7996    (set_attr "prefix" "orig,vex")
7997    (set_attr "mode" "TI")])
7998
7999 (define_expand "avx2_pmaddwd"
8000   [(set (match_operand:V8SI 0 "register_operand")
8001         (plus:V8SI
8002           (mult:V8SI
8003             (sign_extend:V8SI
8004               (vec_select:V8HI
8005                 (match_operand:V16HI 1 "nonimmediate_operand")
8006                 (parallel [(const_int 0) (const_int 2)
8007                            (const_int 4) (const_int 6)
8008                            (const_int 8) (const_int 10)
8009                            (const_int 12) (const_int 14)])))
8010             (sign_extend:V8SI
8011               (vec_select:V8HI
8012                 (match_operand:V16HI 2 "nonimmediate_operand")
8013                 (parallel [(const_int 0) (const_int 2)
8014                            (const_int 4) (const_int 6)
8015                            (const_int 8) (const_int 10)
8016                            (const_int 12) (const_int 14)]))))
8017           (mult:V8SI
8018             (sign_extend:V8SI
8019               (vec_select:V8HI (match_dup 1)
8020                 (parallel [(const_int 1) (const_int 3)
8021                            (const_int 5) (const_int 7)
8022                            (const_int 9) (const_int 11)
8023                            (const_int 13) (const_int 15)])))
8024             (sign_extend:V8SI
8025               (vec_select:V8HI (match_dup 2)
8026                 (parallel [(const_int 1) (const_int 3)
8027                            (const_int 5) (const_int 7)
8028                            (const_int 9) (const_int 11)
8029                            (const_int 13) (const_int 15)]))))))]
8030   "TARGET_AVX2"
8031   "ix86_fixup_binary_operands_no_copy (MULT, V16HImode, operands);")
8032
8033 (define_insn "*avx2_pmaddwd"
8034   [(set (match_operand:V8SI 0 "register_operand" "=x")
8035         (plus:V8SI
8036           (mult:V8SI
8037             (sign_extend:V8SI
8038               (vec_select:V8HI
8039                 (match_operand:V16HI 1 "nonimmediate_operand" "%x")
8040                 (parallel [(const_int 0) (const_int 2)
8041                            (const_int 4) (const_int 6)
8042                            (const_int 8) (const_int 10)
8043                            (const_int 12) (const_int 14)])))
8044             (sign_extend:V8SI
8045               (vec_select:V8HI
8046                 (match_operand:V16HI 2 "nonimmediate_operand" "xm")
8047                 (parallel [(const_int 0) (const_int 2)
8048                            (const_int 4) (const_int 6)
8049                            (const_int 8) (const_int 10)
8050                            (const_int 12) (const_int 14)]))))
8051           (mult:V8SI
8052             (sign_extend:V8SI
8053               (vec_select:V8HI (match_dup 1)
8054                 (parallel [(const_int 1) (const_int 3)
8055                            (const_int 5) (const_int 7)
8056                            (const_int 9) (const_int 11)
8057                            (const_int 13) (const_int 15)])))
8058             (sign_extend:V8SI
8059               (vec_select:V8HI (match_dup 2)
8060                 (parallel [(const_int 1) (const_int 3)
8061                            (const_int 5) (const_int 7)
8062                            (const_int 9) (const_int 11)
8063                            (const_int 13) (const_int 15)]))))))]
8064   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V16HImode, operands)"
8065   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
8066   [(set_attr "type" "sseiadd")
8067    (set_attr "prefix" "vex")
8068    (set_attr "mode" "OI")])
8069
8070 (define_expand "sse2_pmaddwd"
8071   [(set (match_operand:V4SI 0 "register_operand")
8072         (plus:V4SI
8073           (mult:V4SI
8074             (sign_extend:V4SI
8075               (vec_select:V4HI
8076                 (match_operand:V8HI 1 "nonimmediate_operand")
8077                 (parallel [(const_int 0) (const_int 2)
8078                            (const_int 4) (const_int 6)])))
8079             (sign_extend:V4SI
8080               (vec_select:V4HI
8081                 (match_operand:V8HI 2 "nonimmediate_operand")
8082                 (parallel [(const_int 0) (const_int 2)
8083                            (const_int 4) (const_int 6)]))))
8084           (mult:V4SI
8085             (sign_extend:V4SI
8086               (vec_select:V4HI (match_dup 1)
8087                 (parallel [(const_int 1) (const_int 3)
8088                            (const_int 5) (const_int 7)])))
8089             (sign_extend:V4SI
8090               (vec_select:V4HI (match_dup 2)
8091                 (parallel [(const_int 1) (const_int 3)
8092                            (const_int 5) (const_int 7)]))))))]
8093   "TARGET_SSE2"
8094   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
8095
8096 (define_insn "*sse2_pmaddwd"
8097   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
8098         (plus:V4SI
8099           (mult:V4SI
8100             (sign_extend:V4SI
8101               (vec_select:V4HI
8102                 (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
8103                 (parallel [(const_int 0) (const_int 2)
8104                            (const_int 4) (const_int 6)])))
8105             (sign_extend:V4SI
8106               (vec_select:V4HI
8107                 (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
8108                 (parallel [(const_int 0) (const_int 2)
8109                            (const_int 4) (const_int 6)]))))
8110           (mult:V4SI
8111             (sign_extend:V4SI
8112               (vec_select:V4HI (match_dup 1)
8113                 (parallel [(const_int 1) (const_int 3)
8114                            (const_int 5) (const_int 7)])))
8115             (sign_extend:V4SI
8116               (vec_select:V4HI (match_dup 2)
8117                 (parallel [(const_int 1) (const_int 3)
8118                            (const_int 5) (const_int 7)]))))))]
8119   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8120   "@
8121    pmaddwd\t{%2, %0|%0, %2}
8122    vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
8123   [(set_attr "isa" "noavx,avx")
8124    (set_attr "type" "sseiadd")
8125    (set_attr "atom_unit" "simul")
8126    (set_attr "prefix_data16" "1,*")
8127    (set_attr "prefix" "orig,vex")
8128    (set_attr "mode" "TI")])
8129
8130 (define_expand "mul<mode>3<mask_name>"
8131   [(set (match_operand:VI4_AVX512F 0 "register_operand")
8132         (mult:VI4_AVX512F
8133           (match_operand:VI4_AVX512F 1 "general_vector_operand")
8134           (match_operand:VI4_AVX512F 2 "general_vector_operand")))]
8135   "TARGET_SSE2 && <mask_mode512bit_condition>"
8136 {
8137   if (TARGET_SSE4_1)
8138     {
8139       if (!nonimmediate_operand (operands[1], <MODE>mode))
8140         operands[1] = force_reg (<MODE>mode, operands[1]);
8141       if (!nonimmediate_operand (operands[2], <MODE>mode))
8142         operands[2] = force_reg (<MODE>mode, operands[2]);
8143       ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
8144     }
8145   else
8146     {
8147       ix86_expand_sse2_mulv4si3 (operands[0], operands[1], operands[2]);
8148       DONE;
8149     }
8150 })
8151
8152 (define_insn "*<sse4_1_avx2>_mul<mode>3<mask_name>"
8153   [(set (match_operand:VI4_AVX512F 0 "register_operand" "=x,v")
8154         (mult:VI4_AVX512F
8155           (match_operand:VI4_AVX512F 1 "nonimmediate_operand" "%0,v")
8156           (match_operand:VI4_AVX512F 2 "nonimmediate_operand" "xm,vm")))]
8157   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, <MODE>mode, operands) && <mask_mode512bit_condition>"
8158   "@
8159    pmulld\t{%2, %0|%0, %2}
8160    vpmulld\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8161   [(set_attr "isa" "noavx,avx")
8162    (set_attr "type" "sseimul")
8163    (set_attr "prefix_extra" "1")
8164    (set_attr "prefix" "<mask_prefix3>")
8165    (set_attr "btver2_decode" "vector,vector")
8166    (set_attr "mode" "<sseinsnmode>")])
8167
8168 (define_expand "mul<mode>3"
8169   [(set (match_operand:VI8_AVX2_AVX512F 0 "register_operand")
8170         (mult:VI8_AVX2_AVX512F
8171           (match_operand:VI8_AVX2_AVX512F 1 "register_operand")
8172           (match_operand:VI8_AVX2_AVX512F 2 "register_operand")))]
8173   "TARGET_SSE2"
8174 {
8175   ix86_expand_sse2_mulvxdi3 (operands[0], operands[1], operands[2]);
8176   DONE;
8177 })
8178
8179 (define_expand "vec_widen_<s>mult_hi_<mode>"
8180   [(match_operand:<sseunpackmode> 0 "register_operand")
8181    (any_extend:<sseunpackmode>
8182      (match_operand:VI124_AVX2 1 "register_operand"))
8183    (match_operand:VI124_AVX2 2 "register_operand")]
8184   "TARGET_SSE2"
8185 {
8186   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
8187                               <u_bool>, true);
8188   DONE;
8189 })
8190
8191 (define_expand "vec_widen_<s>mult_lo_<mode>"
8192   [(match_operand:<sseunpackmode> 0 "register_operand")
8193    (any_extend:<sseunpackmode>
8194      (match_operand:VI124_AVX2 1 "register_operand"))
8195    (match_operand:VI124_AVX2 2 "register_operand")]
8196   "TARGET_SSE2"
8197 {
8198   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
8199                               <u_bool>, false);
8200   DONE;
8201 })
8202
8203 ;; Most widen_<s>mult_even_<mode> can be handled directly from other
8204 ;; named patterns, but signed V4SI needs special help for plain SSE2.
8205 (define_expand "vec_widen_smult_even_v4si"
8206   [(match_operand:V2DI 0 "register_operand")
8207    (match_operand:V4SI 1 "nonimmediate_operand")
8208    (match_operand:V4SI 2 "nonimmediate_operand")]
8209   "TARGET_SSE2"
8210 {
8211   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
8212                                  false, false);
8213   DONE;
8214 })
8215
8216 (define_expand "vec_widen_<s>mult_odd_<mode>"
8217   [(match_operand:<sseunpackmode> 0 "register_operand")
8218    (any_extend:<sseunpackmode>
8219      (match_operand:VI4_AVX512F 1 "general_vector_operand"))
8220    (match_operand:VI4_AVX512F 2 "general_vector_operand")]
8221   "TARGET_SSE2"
8222 {
8223   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
8224                                  <u_bool>, true);
8225   DONE;
8226 })
8227
8228 (define_expand "sdot_prod<mode>"
8229   [(match_operand:<sseunpackmode> 0 "register_operand")
8230    (match_operand:VI2_AVX2 1 "register_operand")
8231    (match_operand:VI2_AVX2 2 "register_operand")
8232    (match_operand:<sseunpackmode> 3 "register_operand")]
8233   "TARGET_SSE2"
8234 {
8235   rtx t = gen_reg_rtx (<sseunpackmode>mode);
8236   emit_insn (gen_<sse2_avx2>_pmaddwd (t, operands[1], operands[2]));
8237   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
8238                           gen_rtx_PLUS (<sseunpackmode>mode,
8239                                         operands[3], t)));
8240   DONE;
8241 })
8242
8243 ;; Normally we use widen_mul_even/odd, but combine can't quite get it all
8244 ;; back together when madd is available.
8245 (define_expand "sdot_prodv4si"
8246   [(match_operand:V2DI 0 "register_operand")
8247    (match_operand:V4SI 1 "register_operand")
8248    (match_operand:V4SI 2 "register_operand")
8249    (match_operand:V2DI 3 "register_operand")]
8250   "TARGET_XOP"
8251 {
8252   rtx t = gen_reg_rtx (V2DImode);
8253   emit_insn (gen_xop_pmacsdqh (t, operands[1], operands[2], operands[3]));
8254   emit_insn (gen_xop_pmacsdql (operands[0], operands[1], operands[2], t));
8255   DONE;
8256 })
8257
8258 (define_insn "ashr<mode>3"
8259   [(set (match_operand:VI24_AVX2 0 "register_operand" "=x,x")
8260         (ashiftrt:VI24_AVX2
8261           (match_operand:VI24_AVX2 1 "register_operand" "0,x")
8262           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
8263   "TARGET_SSE2"
8264   "@
8265    psra<ssemodesuffix>\t{%2, %0|%0, %2}
8266    vpsra<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8267   [(set_attr "isa" "noavx,avx")
8268    (set_attr "type" "sseishft")
8269    (set (attr "length_immediate")
8270      (if_then_else (match_operand 2 "const_int_operand")
8271        (const_string "1")
8272        (const_string "0")))
8273    (set_attr "prefix_data16" "1,*")
8274    (set_attr "prefix" "orig,vex")
8275    (set_attr "mode" "<sseinsnmode>")])
8276
8277 (define_insn "ashr<mode>3<mask_name>"
8278   [(set (match_operand:VI48_512 0 "register_operand" "=v,v")
8279         (ashiftrt:VI48_512
8280           (match_operand:VI48_512 1 "nonimmediate_operand" "v,vm")
8281           (match_operand:SI 2 "nonmemory_operand" "v,N")))]
8282   "TARGET_AVX512F && <mask_mode512bit_condition>"
8283   "vpsra<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8284   [(set_attr "type" "sseishft")
8285    (set (attr "length_immediate")
8286      (if_then_else (match_operand 2 "const_int_operand")
8287        (const_string "1")
8288        (const_string "0")))
8289    (set_attr "mode" "<sseinsnmode>")])
8290
8291 (define_insn "<shift_insn><mode>3"
8292   [(set (match_operand:VI248_AVX2 0 "register_operand" "=x,x")
8293         (any_lshift:VI248_AVX2
8294           (match_operand:VI248_AVX2 1 "register_operand" "0,x")
8295           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
8296   "TARGET_SSE2"
8297   "@
8298    p<vshift><ssemodesuffix>\t{%2, %0|%0, %2}
8299    vp<vshift><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8300   [(set_attr "isa" "noavx,avx")
8301    (set_attr "type" "sseishft")
8302    (set (attr "length_immediate")
8303      (if_then_else (match_operand 2 "const_int_operand")
8304        (const_string "1")
8305        (const_string "0")))
8306    (set_attr "prefix_data16" "1,*")
8307    (set_attr "prefix" "orig,vex")
8308    (set_attr "mode" "<sseinsnmode>")])
8309
8310 (define_insn "<shift_insn><mode>3<mask_name>"
8311   [(set (match_operand:VI48_512 0 "register_operand" "=v,v")
8312         (any_lshift:VI48_512
8313           (match_operand:VI48_512 1 "nonimmediate_operand" "v,m")
8314           (match_operand:SI 2 "nonmemory_operand" "vN,N")))]
8315   "TARGET_AVX512F && <mask_mode512bit_condition>"
8316   "vp<vshift><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8317   [(set_attr "isa" "avx512f")
8318    (set_attr "type" "sseishft")
8319    (set (attr "length_immediate")
8320      (if_then_else (match_operand 2 "const_int_operand")
8321        (const_string "1")
8322        (const_string "0")))
8323    (set_attr "prefix" "evex")
8324    (set_attr "mode" "<sseinsnmode>")])
8325
8326
8327 (define_expand "vec_shl_<mode>"
8328   [(set (match_dup 3)
8329         (ashift:V1TI
8330          (match_operand:VI_128 1 "register_operand")
8331          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))
8332    (set (match_operand:VI_128 0 "register_operand") (match_dup 4))]
8333   "TARGET_SSE2"
8334 {
8335   operands[1] = gen_lowpart (V1TImode, operands[1]);
8336   operands[3] = gen_reg_rtx (V1TImode);
8337   operands[4] = gen_lowpart (<MODE>mode, operands[3]);
8338 })
8339
8340 (define_insn "<sse2_avx2>_ashl<mode>3"
8341   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
8342         (ashift:VIMAX_AVX2
8343          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
8344          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
8345   "TARGET_SSE2"
8346 {
8347   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
8348
8349   switch (which_alternative)
8350     {
8351     case 0:
8352       return "pslldq\t{%2, %0|%0, %2}";
8353     case 1:
8354       return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
8355     default:
8356       gcc_unreachable ();
8357     }
8358 }
8359   [(set_attr "isa" "noavx,avx")
8360    (set_attr "type" "sseishft")
8361    (set_attr "length_immediate" "1")
8362    (set_attr "prefix_data16" "1,*")
8363    (set_attr "prefix" "orig,vex")
8364    (set_attr "mode" "<sseinsnmode>")])
8365
8366 (define_expand "vec_shr_<mode>"
8367   [(set (match_dup 3)
8368         (lshiftrt:V1TI
8369          (match_operand:VI_128 1 "register_operand")
8370          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))
8371    (set (match_operand:VI_128 0 "register_operand") (match_dup 4))]
8372   "TARGET_SSE2"
8373 {
8374   operands[1] = gen_lowpart (V1TImode, operands[1]);
8375   operands[3] = gen_reg_rtx (V1TImode);
8376   operands[4] = gen_lowpart (<MODE>mode, operands[3]);
8377 })
8378
8379 (define_insn "<sse2_avx2>_lshr<mode>3"
8380   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
8381         (lshiftrt:VIMAX_AVX2
8382          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
8383          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
8384   "TARGET_SSE2"
8385 {
8386   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
8387
8388   switch (which_alternative)
8389     {
8390     case 0:
8391       return "psrldq\t{%2, %0|%0, %2}";
8392     case 1:
8393       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
8394     default:
8395       gcc_unreachable ();
8396     }
8397 }
8398   [(set_attr "isa" "noavx,avx")
8399    (set_attr "type" "sseishft")
8400    (set_attr "length_immediate" "1")
8401    (set_attr "atom_unit" "sishuf")
8402    (set_attr "prefix_data16" "1,*")
8403    (set_attr "prefix" "orig,vex")
8404    (set_attr "mode" "<sseinsnmode>")])
8405
8406 (define_insn "avx512f_<rotate>v<mode><mask_name>"
8407   [(set (match_operand:VI48_512 0 "register_operand" "=v")
8408         (any_rotate:VI48_512
8409           (match_operand:VI48_512 1 "register_operand" "v")
8410           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")))]
8411   "TARGET_AVX512F"
8412   "vp<rotate>v<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8413   [(set_attr "prefix" "evex")
8414    (set_attr "mode" "<sseinsnmode>")])
8415
8416 (define_insn "avx512f_<rotate><mode><mask_name>"
8417   [(set (match_operand:VI48_512 0 "register_operand" "=v")
8418         (any_rotate:VI48_512
8419           (match_operand:VI48_512 1 "nonimmediate_operand" "vm")
8420           (match_operand:SI 2 "const_0_to_255_operand")))]
8421   "TARGET_AVX512F"
8422   "vp<rotate><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8423   [(set_attr "prefix" "evex")
8424    (set_attr "mode" "<sseinsnmode>")])
8425
8426 (define_expand "<code><mode>3<mask_name><round_name>"
8427   [(set (match_operand:VI124_256_48_512 0 "register_operand")
8428         (maxmin:VI124_256_48_512
8429           (match_operand:VI124_256_48_512 1 "<round_nimm_predicate>")
8430           (match_operand:VI124_256_48_512 2 "<round_nimm_predicate>")))]
8431   "TARGET_AVX2 && <mask_mode512bit_condition> && <round_mode512bit_condition>"
8432   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
8433
8434 (define_insn "*avx2_<code><mode>3<mask_name><round_name>"
8435   [(set (match_operand:VI124_256_48_512 0 "register_operand" "=v")
8436         (maxmin:VI124_256_48_512
8437           (match_operand:VI124_256_48_512 1 "<round_nimm_predicate>" "%v")
8438           (match_operand:VI124_256_48_512 2 "<round_nimm_predicate>" "<round_constraint>")))]
8439   "TARGET_AVX2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)
8440    && <mask_mode512bit_condition> && <round_mode512bit_condition>"
8441   "vp<maxmin_int><ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
8442   [(set_attr "type" "sseiadd")
8443    (set_attr "prefix_extra" "1")
8444    (set_attr "prefix" "maybe_evex")
8445    (set_attr "mode" "OI")])
8446
8447 (define_expand "<code><mode>3"
8448   [(set (match_operand:VI8_AVX2 0 "register_operand")
8449         (maxmin:VI8_AVX2
8450           (match_operand:VI8_AVX2 1 "register_operand")
8451           (match_operand:VI8_AVX2 2 "register_operand")))]
8452   "TARGET_SSE4_2"
8453 {
8454   enum rtx_code code;
8455   rtx xops[6];
8456   bool ok;
8457
8458   xops[0] = operands[0];
8459
8460   if (<CODE> == SMAX || <CODE> == UMAX)
8461     {
8462       xops[1] = operands[1];
8463       xops[2] = operands[2];
8464     }
8465   else
8466     {
8467       xops[1] = operands[2];
8468       xops[2] = operands[1];
8469     }
8470
8471   code = (<CODE> == UMAX || <CODE> == UMIN) ? GTU : GT;
8472
8473   xops[3] = gen_rtx_fmt_ee (code, VOIDmode, operands[1], operands[2]);
8474   xops[4] = operands[1];
8475   xops[5] = operands[2];
8476
8477   ok = ix86_expand_int_vcond (xops);
8478   gcc_assert (ok);
8479   DONE;
8480 })
8481
8482 (define_expand "<code><mode>3"
8483   [(set (match_operand:VI124_128 0 "register_operand")
8484         (smaxmin:VI124_128
8485           (match_operand:VI124_128 1 "nonimmediate_operand")
8486           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8487   "TARGET_SSE2"
8488 {
8489   if (TARGET_SSE4_1 || <MODE>mode == V8HImode)
8490     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
8491   else
8492     {
8493       rtx xops[6];
8494       bool ok;
8495
8496       xops[0] = operands[0];
8497       operands[1] = force_reg (<MODE>mode, operands[1]);
8498       operands[2] = force_reg (<MODE>mode, operands[2]);
8499
8500       if (<CODE> == SMAX)
8501         {
8502           xops[1] = operands[1];
8503           xops[2] = operands[2];
8504         }
8505       else
8506         {
8507           xops[1] = operands[2];
8508           xops[2] = operands[1];
8509         }
8510
8511       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
8512       xops[4] = operands[1];
8513       xops[5] = operands[2];
8514
8515       ok = ix86_expand_int_vcond (xops);
8516       gcc_assert (ok);
8517       DONE;
8518     }
8519 })
8520
8521 (define_insn "*sse4_1_<code><mode>3"
8522   [(set (match_operand:VI14_128 0 "register_operand" "=x,x")
8523         (smaxmin:VI14_128
8524           (match_operand:VI14_128 1 "nonimmediate_operand" "%0,x")
8525           (match_operand:VI14_128 2 "nonimmediate_operand" "xm,xm")))]
8526   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
8527   "@
8528    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
8529    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8530   [(set_attr "isa" "noavx,avx")
8531    (set_attr "type" "sseiadd")
8532    (set_attr "prefix_extra" "1,*")
8533    (set_attr "prefix" "orig,vex")
8534    (set_attr "mode" "TI")])
8535
8536 (define_insn "*<code>v8hi3"
8537   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
8538         (smaxmin:V8HI
8539           (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
8540           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")))]
8541   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
8542   "@
8543    p<maxmin_int>w\t{%2, %0|%0, %2}
8544    vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
8545   [(set_attr "isa" "noavx,avx")
8546    (set_attr "type" "sseiadd")
8547    (set_attr "prefix_data16" "1,*")
8548    (set_attr "prefix_extra" "*,1")
8549    (set_attr "prefix" "orig,vex")
8550    (set_attr "mode" "TI")])
8551
8552 (define_expand "<code><mode>3"
8553   [(set (match_operand:VI124_128 0 "register_operand")
8554         (umaxmin:VI124_128
8555           (match_operand:VI124_128 1 "nonimmediate_operand")
8556           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8557   "TARGET_SSE2"
8558 {
8559   if (TARGET_SSE4_1 || <MODE>mode == V16QImode)
8560     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
8561   else if (<CODE> == UMAX && <MODE>mode == V8HImode)
8562     {
8563       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
8564       operands[1] = force_reg (<MODE>mode, operands[1]);
8565       if (rtx_equal_p (op3, op2))
8566         op3 = gen_reg_rtx (V8HImode);
8567       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
8568       emit_insn (gen_addv8hi3 (op0, op3, op2));
8569       DONE;
8570     }
8571   else
8572     {
8573       rtx xops[6];
8574       bool ok;
8575
8576       operands[1] = force_reg (<MODE>mode, operands[1]);
8577       operands[2] = force_reg (<MODE>mode, operands[2]);
8578
8579       xops[0] = operands[0];
8580
8581       if (<CODE> == UMAX)
8582         {
8583           xops[1] = operands[1];
8584           xops[2] = operands[2];
8585         }
8586       else
8587         {
8588           xops[1] = operands[2];
8589           xops[2] = operands[1];
8590         }
8591
8592       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
8593       xops[4] = operands[1];
8594       xops[5] = operands[2];
8595
8596       ok = ix86_expand_int_vcond (xops);
8597       gcc_assert (ok);
8598       DONE;
8599     }
8600 })
8601
8602 (define_insn "*sse4_1_<code><mode>3"
8603   [(set (match_operand:VI24_128 0 "register_operand" "=x,x")
8604         (umaxmin:VI24_128
8605           (match_operand:VI24_128 1 "nonimmediate_operand" "%0,x")
8606           (match_operand:VI24_128 2 "nonimmediate_operand" "xm,xm")))]
8607   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
8608   "@
8609    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
8610    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8611   [(set_attr "isa" "noavx,avx")
8612    (set_attr "type" "sseiadd")
8613    (set_attr "prefix_extra" "1,*")
8614    (set_attr "prefix" "orig,vex")
8615    (set_attr "mode" "TI")])
8616
8617 (define_insn "*<code>v16qi3"
8618   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
8619         (umaxmin:V16QI
8620           (match_operand:V16QI 1 "nonimmediate_operand" "%0,x")
8621           (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")))]
8622   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
8623   "@
8624    p<maxmin_int>b\t{%2, %0|%0, %2}
8625    vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
8626   [(set_attr "isa" "noavx,avx")
8627    (set_attr "type" "sseiadd")
8628    (set_attr "prefix_data16" "1,*")
8629    (set_attr "prefix_extra" "*,1")
8630    (set_attr "prefix" "orig,vex")
8631    (set_attr "mode" "TI")])
8632
8633 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8634 ;;
8635 ;; Parallel integral comparisons
8636 ;;
8637 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8638
8639 (define_expand "avx2_eq<mode>3"
8640   [(set (match_operand:VI_256 0 "register_operand")
8641         (eq:VI_256
8642           (match_operand:VI_256 1 "nonimmediate_operand")
8643           (match_operand:VI_256 2 "nonimmediate_operand")))]
8644   "TARGET_AVX2"
8645   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8646
8647 (define_insn "*avx2_eq<mode>3"
8648   [(set (match_operand:VI_256 0 "register_operand" "=x")
8649         (eq:VI_256
8650           (match_operand:VI_256 1 "nonimmediate_operand" "%x")
8651           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
8652   "TARGET_AVX2 && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8653   "vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8654   [(set_attr "type" "ssecmp")
8655    (set_attr "prefix_extra" "1")
8656    (set_attr "prefix" "vex")
8657    (set_attr "mode" "OI")])
8658
8659 (define_expand "avx512f_eq<mode>3<mask_scalar_merge_name>"
8660   [(set (match_operand:<avx512fmaskmode> 0 "register_operand")
8661         (unspec:<avx512fmaskmode>
8662           [(match_operand:VI48_512 1 "register_operand")
8663            (match_operand:VI48_512 2 "nonimmediate_operand")]
8664           UNSPEC_MASKED_EQ))]
8665   "TARGET_AVX512F"
8666   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8667
8668 (define_insn "avx512f_eq<mode>3<mask_scalar_merge_name>_1"
8669   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
8670         (unspec:<avx512fmaskmode>
8671           [(match_operand:VI48_512 1 "register_operand" "%v")
8672            (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
8673           UNSPEC_MASKED_EQ))]
8674   "TARGET_AVX512F && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8675   "vpcmpeq<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
8676   [(set_attr "type" "ssecmp")
8677    (set_attr "prefix_extra" "1")
8678    (set_attr "prefix" "evex")
8679    (set_attr "mode" "<sseinsnmode>")])
8680
8681 (define_insn "*sse4_1_eqv2di3"
8682   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
8683         (eq:V2DI
8684           (match_operand:V2DI 1 "nonimmediate_operand" "%0,x")
8685           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
8686   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
8687   "@
8688    pcmpeqq\t{%2, %0|%0, %2}
8689    vpcmpeqq\t{%2, %1, %0|%0, %1, %2}"
8690   [(set_attr "isa" "noavx,avx")
8691    (set_attr "type" "ssecmp")
8692    (set_attr "prefix_extra" "1")
8693    (set_attr "prefix" "orig,vex")
8694    (set_attr "mode" "TI")])
8695
8696 (define_insn "*sse2_eq<mode>3"
8697   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
8698         (eq:VI124_128
8699           (match_operand:VI124_128 1 "nonimmediate_operand" "%0,x")
8700           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
8701   "TARGET_SSE2 && !TARGET_XOP
8702    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8703   "@
8704    pcmpeq<ssemodesuffix>\t{%2, %0|%0, %2}
8705    vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8706   [(set_attr "isa" "noavx,avx")
8707    (set_attr "type" "ssecmp")
8708    (set_attr "prefix_data16" "1,*")
8709    (set_attr "prefix" "orig,vex")
8710    (set_attr "mode" "TI")])
8711
8712 (define_expand "sse2_eq<mode>3"
8713   [(set (match_operand:VI124_128 0 "register_operand")
8714         (eq:VI124_128
8715           (match_operand:VI124_128 1 "nonimmediate_operand")
8716           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8717   "TARGET_SSE2 && !TARGET_XOP "
8718   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8719
8720 (define_expand "sse4_1_eqv2di3"
8721   [(set (match_operand:V2DI 0 "register_operand")
8722         (eq:V2DI
8723           (match_operand:V2DI 1 "nonimmediate_operand")
8724           (match_operand:V2DI 2 "nonimmediate_operand")))]
8725   "TARGET_SSE4_1"
8726   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
8727
8728 (define_insn "sse4_2_gtv2di3"
8729   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
8730         (gt:V2DI
8731           (match_operand:V2DI 1 "register_operand" "0,x")
8732           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
8733   "TARGET_SSE4_2"
8734   "@
8735    pcmpgtq\t{%2, %0|%0, %2}
8736    vpcmpgtq\t{%2, %1, %0|%0, %1, %2}"
8737   [(set_attr "isa" "noavx,avx")
8738    (set_attr "type" "ssecmp")
8739    (set_attr "prefix_extra" "1")
8740    (set_attr "prefix" "orig,vex")
8741    (set_attr "mode" "TI")])
8742
8743 (define_insn "avx2_gt<mode>3"
8744   [(set (match_operand:VI_256 0 "register_operand" "=x")
8745         (gt:VI_256
8746           (match_operand:VI_256 1 "register_operand" "x")
8747           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
8748   "TARGET_AVX2"
8749   "vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8750   [(set_attr "type" "ssecmp")
8751    (set_attr "prefix_extra" "1")
8752    (set_attr "prefix" "vex")
8753    (set_attr "mode" "OI")])
8754
8755 (define_insn "avx512f_gt<mode>3<mask_scalar_merge_name>"
8756   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
8757         (unspec:<avx512fmaskmode>
8758           [(match_operand:VI48_512 1 "register_operand" "v")
8759            (match_operand:VI48_512 2 "nonimmediate_operand" "vm")] UNSPEC_MASKED_GT))]
8760   "TARGET_AVX512F"
8761   "vpcmpgt<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
8762   [(set_attr "type" "ssecmp")
8763    (set_attr "prefix_extra" "1")
8764    (set_attr "prefix" "evex")
8765    (set_attr "mode" "<sseinsnmode>")])
8766
8767 (define_insn "sse2_gt<mode>3"
8768   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
8769         (gt:VI124_128
8770           (match_operand:VI124_128 1 "register_operand" "0,x")
8771           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
8772   "TARGET_SSE2 && !TARGET_XOP"
8773   "@
8774    pcmpgt<ssemodesuffix>\t{%2, %0|%0, %2}
8775    vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8776   [(set_attr "isa" "noavx,avx")
8777    (set_attr "type" "ssecmp")
8778    (set_attr "prefix_data16" "1,*")
8779    (set_attr "prefix" "orig,vex")
8780    (set_attr "mode" "TI")])
8781
8782 (define_expand "vcond<V_512:mode><VI_512:mode>"
8783   [(set (match_operand:V_512 0 "register_operand")
8784         (if_then_else:V_512
8785           (match_operator 3 ""
8786             [(match_operand:VI_512 4 "nonimmediate_operand")
8787              (match_operand:VI_512 5 "general_operand")])
8788           (match_operand:V_512 1)
8789           (match_operand:V_512 2)))]
8790   "TARGET_AVX512F
8791    && (GET_MODE_NUNITS (<V_512:MODE>mode)
8792        == GET_MODE_NUNITS (<VI_512:MODE>mode))"
8793 {
8794   bool ok = ix86_expand_int_vcond (operands);
8795   gcc_assert (ok);
8796   DONE;
8797 })
8798
8799 (define_expand "vcond<V_256:mode><VI_256:mode>"
8800   [(set (match_operand:V_256 0 "register_operand")
8801         (if_then_else:V_256
8802           (match_operator 3 ""
8803             [(match_operand:VI_256 4 "nonimmediate_operand")
8804              (match_operand:VI_256 5 "general_operand")])
8805           (match_operand:V_256 1)
8806           (match_operand:V_256 2)))]
8807   "TARGET_AVX2
8808    && (GET_MODE_NUNITS (<V_256:MODE>mode)
8809        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
8810 {
8811   bool ok = ix86_expand_int_vcond (operands);
8812   gcc_assert (ok);
8813   DONE;
8814 })
8815
8816 (define_expand "vcond<V_128:mode><VI124_128:mode>"
8817   [(set (match_operand:V_128 0 "register_operand")
8818         (if_then_else:V_128
8819           (match_operator 3 ""
8820             [(match_operand:VI124_128 4 "nonimmediate_operand")
8821              (match_operand:VI124_128 5 "general_operand")])
8822           (match_operand:V_128 1)
8823           (match_operand:V_128 2)))]
8824   "TARGET_SSE2
8825    && (GET_MODE_NUNITS (<V_128:MODE>mode)
8826        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
8827 {
8828   bool ok = ix86_expand_int_vcond (operands);
8829   gcc_assert (ok);
8830   DONE;
8831 })
8832
8833 (define_expand "vcond<VI8F_128:mode>v2di"
8834   [(set (match_operand:VI8F_128 0 "register_operand")
8835         (if_then_else:VI8F_128
8836           (match_operator 3 ""
8837             [(match_operand:V2DI 4 "nonimmediate_operand")
8838              (match_operand:V2DI 5 "general_operand")])
8839           (match_operand:VI8F_128 1)
8840           (match_operand:VI8F_128 2)))]
8841   "TARGET_SSE4_2"
8842 {
8843   bool ok = ix86_expand_int_vcond (operands);
8844   gcc_assert (ok);
8845   DONE;
8846 })
8847
8848 (define_expand "vcondu<V_512:mode><VI_512:mode>"
8849   [(set (match_operand:V_512 0 "register_operand")
8850         (if_then_else:V_512
8851           (match_operator 3 ""
8852             [(match_operand:VI_512 4 "nonimmediate_operand")
8853              (match_operand:VI_512 5 "nonimmediate_operand")])
8854           (match_operand:V_512 1 "general_operand")
8855           (match_operand:V_512 2 "general_operand")))]
8856   "TARGET_AVX512F
8857    && (GET_MODE_NUNITS (<V_512:MODE>mode)
8858        == GET_MODE_NUNITS (<VI_512:MODE>mode))"
8859 {
8860   bool ok = ix86_expand_int_vcond (operands);
8861   gcc_assert (ok);
8862   DONE;
8863 })
8864
8865 (define_expand "vcondu<V_256:mode><VI_256:mode>"
8866   [(set (match_operand:V_256 0 "register_operand")
8867         (if_then_else:V_256
8868           (match_operator 3 ""
8869             [(match_operand:VI_256 4 "nonimmediate_operand")
8870              (match_operand:VI_256 5 "nonimmediate_operand")])
8871           (match_operand:V_256 1 "general_operand")
8872           (match_operand:V_256 2 "general_operand")))]
8873   "TARGET_AVX2
8874    && (GET_MODE_NUNITS (<V_256:MODE>mode)
8875        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
8876 {
8877   bool ok = ix86_expand_int_vcond (operands);
8878   gcc_assert (ok);
8879   DONE;
8880 })
8881
8882 (define_expand "vcondu<V_128:mode><VI124_128:mode>"
8883   [(set (match_operand:V_128 0 "register_operand")
8884         (if_then_else:V_128
8885           (match_operator 3 ""
8886             [(match_operand:VI124_128 4 "nonimmediate_operand")
8887              (match_operand:VI124_128 5 "nonimmediate_operand")])
8888           (match_operand:V_128 1 "general_operand")
8889           (match_operand:V_128 2 "general_operand")))]
8890   "TARGET_SSE2
8891    && (GET_MODE_NUNITS (<V_128:MODE>mode)
8892        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
8893 {
8894   bool ok = ix86_expand_int_vcond (operands);
8895   gcc_assert (ok);
8896   DONE;
8897 })
8898
8899 (define_expand "vcondu<VI8F_128:mode>v2di"
8900   [(set (match_operand:VI8F_128 0 "register_operand")
8901         (if_then_else:VI8F_128
8902           (match_operator 3 ""
8903             [(match_operand:V2DI 4 "nonimmediate_operand")
8904              (match_operand:V2DI 5 "nonimmediate_operand")])
8905           (match_operand:VI8F_128 1 "general_operand")
8906           (match_operand:VI8F_128 2 "general_operand")))]
8907   "TARGET_SSE4_2"
8908 {
8909   bool ok = ix86_expand_int_vcond (operands);
8910   gcc_assert (ok);
8911   DONE;
8912 })
8913
8914 (define_mode_iterator VEC_PERM_AVX2
8915   [V16QI V8HI V4SI V2DI V4SF V2DF
8916    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
8917    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
8918    (V8SF "TARGET_AVX2") (V4DF "TARGET_AVX2")
8919    (V16SF "TARGET_AVX512F") (V8DF "TARGET_AVX512F")
8920    (V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")])
8921
8922 (define_expand "vec_perm<mode>"
8923   [(match_operand:VEC_PERM_AVX2 0 "register_operand")
8924    (match_operand:VEC_PERM_AVX2 1 "register_operand")
8925    (match_operand:VEC_PERM_AVX2 2 "register_operand")
8926    (match_operand:<sseintvecmode> 3 "register_operand")]
8927   "TARGET_SSSE3 || TARGET_AVX || TARGET_XOP"
8928 {
8929   ix86_expand_vec_perm (operands);
8930   DONE;
8931 })
8932
8933 (define_mode_iterator VEC_PERM_CONST
8934   [(V4SF "TARGET_SSE") (V4SI "TARGET_SSE")
8935    (V2DF "TARGET_SSE") (V2DI "TARGET_SSE")
8936    (V16QI "TARGET_SSE2") (V8HI "TARGET_SSE2")
8937    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
8938    (V8SI "TARGET_AVX") (V4DI "TARGET_AVX")
8939    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
8940    (V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")
8941    (V16SF "TARGET_AVX512F") (V8DF "TARGET_AVX512F")])
8942
8943 (define_expand "vec_perm_const<mode>"
8944   [(match_operand:VEC_PERM_CONST 0 "register_operand")
8945    (match_operand:VEC_PERM_CONST 1 "register_operand")
8946    (match_operand:VEC_PERM_CONST 2 "register_operand")
8947    (match_operand:<sseintvecmode> 3)]
8948   ""
8949 {
8950   if (ix86_expand_vec_perm_const (operands))
8951     DONE;
8952   else
8953     FAIL;
8954 })
8955
8956 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8957 ;;
8958 ;; Parallel bitwise logical operations
8959 ;;
8960 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8961
8962 (define_expand "one_cmpl<mode>2"
8963   [(set (match_operand:VI 0 "register_operand")
8964         (xor:VI (match_operand:VI 1 "nonimmediate_operand")
8965                 (match_dup 2)))]
8966   "TARGET_SSE"
8967 {
8968   int i, n = GET_MODE_NUNITS (<MODE>mode);
8969   rtvec v = rtvec_alloc (n);
8970
8971   for (i = 0; i < n; ++i)
8972     RTVEC_ELT (v, i) = constm1_rtx;
8973
8974   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
8975 })
8976
8977 (define_expand "<sse2_avx2>_andnot<mode>3<mask_name>"
8978   [(set (match_operand:VI_AVX2 0 "register_operand")
8979         (and:VI_AVX2
8980           (not:VI_AVX2 (match_operand:VI_AVX2 1 "register_operand"))
8981           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
8982   "TARGET_SSE2 && <mask_mode512bit_condition>")
8983
8984 (define_insn "*andnot<mode>3<mask_name>"
8985   [(set (match_operand:VI 0 "register_operand" "=x,v")
8986         (and:VI
8987           (not:VI (match_operand:VI 1 "register_operand" "0,v"))
8988           (match_operand:VI 2 "nonimmediate_operand" "xm,vm")))]
8989   "TARGET_SSE && <mask_mode512bit_condition>"
8990 {
8991   static char buf[64];
8992   const char *ops;
8993   const char *tmp;
8994
8995   switch (get_attr_mode (insn))
8996     {
8997     case MODE_XI:
8998       gcc_assert (TARGET_AVX512F);
8999
9000       tmp = "pandn<ssemodesuffix>";
9001       break;
9002
9003     case MODE_OI:
9004       gcc_assert (TARGET_AVX2);
9005     case MODE_TI:
9006       gcc_assert (TARGET_SSE2);
9007
9008       tmp = "pandn";
9009       break;
9010
9011    case MODE_V16SF:
9012       gcc_assert (TARGET_AVX512F);
9013    case MODE_V8SF:
9014       gcc_assert (TARGET_AVX);
9015    case MODE_V4SF:
9016       gcc_assert (TARGET_SSE);
9017
9018       tmp = "andnps";
9019       break;
9020
9021    default:
9022       gcc_unreachable ();
9023    }
9024
9025   switch (which_alternative)
9026     {
9027     case 0:
9028       ops = "%s\t{%%2, %%0|%%0, %%2}";
9029       break;
9030     case 1:
9031       ops = "v%s\t{%%2, %%1, %%0<mask_operand3_1>|%%0<mask_operand3_1>, %%1, %%2}";
9032       break;
9033     default:
9034       gcc_unreachable ();
9035     }
9036
9037   snprintf (buf, sizeof (buf), ops, tmp);
9038   return buf;
9039 }
9040   [(set_attr "isa" "noavx,avx")
9041    (set_attr "type" "sselog")
9042    (set (attr "prefix_data16")
9043      (if_then_else
9044        (and (eq_attr "alternative" "0")
9045             (eq_attr "mode" "TI"))
9046        (const_string "1")
9047        (const_string "*")))
9048    (set_attr "prefix" "<mask_prefix3>")
9049    (set (attr "mode")
9050         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
9051                  (const_string "<ssePSmode>")
9052                (match_test "TARGET_AVX2")
9053                  (const_string "<sseinsnmode>")
9054                (match_test "TARGET_AVX")
9055                  (if_then_else
9056                    (match_test "<MODE_SIZE> > 16")
9057                    (const_string "V8SF")
9058                    (const_string "<sseinsnmode>"))
9059                (ior (not (match_test "TARGET_SSE2"))
9060                     (match_test "optimize_function_for_size_p (cfun)"))
9061                  (const_string "V4SF")
9062               ]
9063               (const_string "<sseinsnmode>")))])
9064
9065 (define_expand "<code><mode>3"
9066   [(set (match_operand:VI 0 "register_operand")
9067         (any_logic:VI
9068           (match_operand:VI 1 "nonimmediate_or_const_vector_operand")
9069           (match_operand:VI 2 "nonimmediate_or_const_vector_operand")))]
9070   "TARGET_SSE"
9071 {
9072   ix86_expand_vector_logical_operator (<CODE>, <MODE>mode, operands);
9073   DONE;
9074 })
9075
9076 (define_insn "<mask_codefor><code><mode>3<mask_name>"
9077   [(set (match_operand:VI 0 "register_operand" "=x,v")
9078         (any_logic:VI
9079           (match_operand:VI 1 "nonimmediate_operand" "%0,v")
9080           (match_operand:VI 2 "nonimmediate_operand" "xm,vm")))]
9081   "TARGET_SSE && <mask_mode512bit_condition>
9082    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
9083 {
9084   static char buf[64];
9085   const char *ops;
9086   const char *tmp;
9087
9088   switch (get_attr_mode (insn))
9089     {
9090     case MODE_XI:
9091       gcc_assert (TARGET_AVX512F);
9092
9093       tmp = "p<logic><ssemodesuffix>";
9094       break;
9095
9096     case MODE_OI:
9097       gcc_assert (TARGET_AVX2);
9098     case MODE_TI:
9099       gcc_assert (TARGET_SSE2);
9100
9101       tmp = "p<logic>";
9102       break;
9103
9104    case MODE_V16SF:
9105       gcc_assert (TARGET_AVX512F);
9106    case MODE_V8SF:
9107       gcc_assert (TARGET_AVX);
9108    case MODE_V4SF:
9109       gcc_assert (TARGET_SSE);
9110
9111       tmp = "<logic>ps";
9112       break;
9113
9114    default:
9115       gcc_unreachable ();
9116    }
9117
9118   switch (which_alternative)
9119     {
9120     case 0:
9121       ops = "%s\t{%%2, %%0|%%0, %%2}";
9122       break;
9123     case 1:
9124       ops = "v%s\t{%%2, %%1, %%0<mask_operand3_1>|%%0<mask_operand3_1>, %%1, %%2}";
9125       break;
9126     default:
9127       gcc_unreachable ();
9128     }
9129
9130   snprintf (buf, sizeof (buf), ops, tmp);
9131   return buf;
9132 }
9133   [(set_attr "isa" "noavx,avx")
9134    (set_attr "type" "sselog")
9135    (set (attr "prefix_data16")
9136      (if_then_else
9137        (and (eq_attr "alternative" "0")
9138             (eq_attr "mode" "TI"))
9139        (const_string "1")
9140        (const_string "*")))
9141    (set_attr "prefix" "<mask_prefix3>")
9142    (set (attr "mode")
9143         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
9144                  (const_string "<ssePSmode>")
9145                (match_test "TARGET_AVX2")
9146                  (const_string "<sseinsnmode>")
9147                (match_test "TARGET_AVX")
9148                  (if_then_else
9149                    (match_test "<MODE_SIZE> > 16")
9150                    (const_string "V8SF")
9151                    (const_string "<sseinsnmode>"))
9152                (ior (not (match_test "TARGET_SSE2"))
9153                     (match_test "optimize_function_for_size_p (cfun)"))
9154                  (const_string "V4SF")
9155               ]
9156               (const_string "<sseinsnmode>")))])
9157
9158 (define_insn "avx512f_testm<mode>3<mask_scalar_merge_name>"
9159   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
9160         (unspec:<avx512fmaskmode>
9161          [(match_operand:VI48_512 1 "register_operand" "v")
9162           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
9163          UNSPEC_TESTM))]
9164   "TARGET_AVX512F"
9165   "vptestm<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
9166   [(set_attr "prefix" "evex")
9167    (set_attr "mode"  "<sseinsnmode>")])
9168
9169 (define_insn "avx512f_testnm<mode>3<mask_scalar_merge_name>"
9170   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
9171         (unspec:<avx512fmaskmode>
9172          [(match_operand:VI48_512 1 "register_operand" "v")
9173           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
9174          UNSPEC_TESTNM))]
9175   "TARGET_AVX512F"
9176   "vptestnm<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
9177   [(set_attr "prefix" "evex")
9178    (set_attr "mode"  "<sseinsnmode>")])
9179
9180 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9181 ;;
9182 ;; Parallel integral element swizzling
9183 ;;
9184 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9185
9186 (define_expand "vec_pack_trunc_<mode>"
9187   [(match_operand:<ssepackmode> 0 "register_operand")
9188    (match_operand:VI248_AVX2_8_AVX512F 1 "register_operand")
9189    (match_operand:VI248_AVX2_8_AVX512F 2 "register_operand")]
9190   "TARGET_SSE2"
9191 {
9192   rtx op1 = gen_lowpart (<ssepackmode>mode, operands[1]);
9193   rtx op2 = gen_lowpart (<ssepackmode>mode, operands[2]);
9194   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
9195   DONE;
9196 })
9197
9198 (define_insn "<sse2_avx2>_packsswb"
9199   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
9200         (vec_concat:VI1_AVX2
9201           (ss_truncate:<ssehalfvecmode>
9202             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9203           (ss_truncate:<ssehalfvecmode>
9204             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9205   "TARGET_SSE2"
9206   "@
9207    packsswb\t{%2, %0|%0, %2}
9208    vpacksswb\t{%2, %1, %0|%0, %1, %2}"
9209   [(set_attr "isa" "noavx,avx")
9210    (set_attr "type" "sselog")
9211    (set_attr "prefix_data16" "1,*")
9212    (set_attr "prefix" "orig,vex")
9213    (set_attr "mode" "<sseinsnmode>")])
9214
9215 (define_insn "<sse2_avx2>_packssdw"
9216   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
9217         (vec_concat:VI2_AVX2
9218           (ss_truncate:<ssehalfvecmode>
9219             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9220           (ss_truncate:<ssehalfvecmode>
9221             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9222   "TARGET_SSE2"
9223   "@
9224    packssdw\t{%2, %0|%0, %2}
9225    vpackssdw\t{%2, %1, %0|%0, %1, %2}"
9226   [(set_attr "isa" "noavx,avx")
9227    (set_attr "type" "sselog")
9228    (set_attr "prefix_data16" "1,*")
9229    (set_attr "prefix" "orig,vex")
9230    (set_attr "mode" "<sseinsnmode>")])
9231
9232 (define_insn "<sse2_avx2>_packuswb"
9233   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
9234         (vec_concat:VI1_AVX2
9235           (us_truncate:<ssehalfvecmode>
9236             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9237           (us_truncate:<ssehalfvecmode>
9238             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9239   "TARGET_SSE2"
9240   "@
9241    packuswb\t{%2, %0|%0, %2}
9242    vpackuswb\t{%2, %1, %0|%0, %1, %2}"
9243   [(set_attr "isa" "noavx,avx")
9244    (set_attr "type" "sselog")
9245    (set_attr "prefix_data16" "1,*")
9246    (set_attr "prefix" "orig,vex")
9247    (set_attr "mode" "<sseinsnmode>")])
9248
9249 (define_insn "avx2_interleave_highv32qi"
9250   [(set (match_operand:V32QI 0 "register_operand" "=x")
9251         (vec_select:V32QI
9252           (vec_concat:V64QI
9253             (match_operand:V32QI 1 "register_operand" "x")
9254             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
9255           (parallel [(const_int 8)  (const_int 40)
9256                      (const_int 9)  (const_int 41)
9257                      (const_int 10) (const_int 42)
9258                      (const_int 11) (const_int 43)
9259                      (const_int 12) (const_int 44)
9260                      (const_int 13) (const_int 45)
9261                      (const_int 14) (const_int 46)
9262                      (const_int 15) (const_int 47)
9263                      (const_int 24) (const_int 56)
9264                      (const_int 25) (const_int 57)
9265                      (const_int 26) (const_int 58)
9266                      (const_int 27) (const_int 59)
9267                      (const_int 28) (const_int 60)
9268                      (const_int 29) (const_int 61)
9269                      (const_int 30) (const_int 62)
9270                      (const_int 31) (const_int 63)])))]
9271   "TARGET_AVX2"
9272   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
9273   [(set_attr "type" "sselog")
9274    (set_attr "prefix" "vex")
9275    (set_attr "mode" "OI")])
9276
9277 (define_insn "vec_interleave_highv16qi"
9278   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9279         (vec_select:V16QI
9280           (vec_concat:V32QI
9281             (match_operand:V16QI 1 "register_operand" "0,x")
9282             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
9283           (parallel [(const_int 8)  (const_int 24)
9284                      (const_int 9)  (const_int 25)
9285                      (const_int 10) (const_int 26)
9286                      (const_int 11) (const_int 27)
9287                      (const_int 12) (const_int 28)
9288                      (const_int 13) (const_int 29)
9289                      (const_int 14) (const_int 30)
9290                      (const_int 15) (const_int 31)])))]
9291   "TARGET_SSE2"
9292   "@
9293    punpckhbw\t{%2, %0|%0, %2}
9294    vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
9295   [(set_attr "isa" "noavx,avx")
9296    (set_attr "type" "sselog")
9297    (set_attr "prefix_data16" "1,*")
9298    (set_attr "prefix" "orig,vex")
9299    (set_attr "mode" "TI")])
9300
9301 (define_insn "avx2_interleave_lowv32qi"
9302   [(set (match_operand:V32QI 0 "register_operand" "=x")
9303         (vec_select:V32QI
9304           (vec_concat:V64QI
9305             (match_operand:V32QI 1 "register_operand" "x")
9306             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
9307           (parallel [(const_int 0) (const_int 32)
9308                      (const_int 1) (const_int 33)
9309                      (const_int 2) (const_int 34)
9310                      (const_int 3) (const_int 35)
9311                      (const_int 4) (const_int 36)
9312                      (const_int 5) (const_int 37)
9313                      (const_int 6) (const_int 38)
9314                      (const_int 7) (const_int 39)
9315                      (const_int 16) (const_int 48)
9316                      (const_int 17) (const_int 49)
9317                      (const_int 18) (const_int 50)
9318                      (const_int 19) (const_int 51)
9319                      (const_int 20) (const_int 52)
9320                      (const_int 21) (const_int 53)
9321                      (const_int 22) (const_int 54)
9322                      (const_int 23) (const_int 55)])))]
9323   "TARGET_AVX2"
9324   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
9325   [(set_attr "type" "sselog")
9326    (set_attr "prefix" "vex")
9327    (set_attr "mode" "OI")])
9328
9329 (define_insn "vec_interleave_lowv16qi"
9330   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9331         (vec_select:V16QI
9332           (vec_concat:V32QI
9333             (match_operand:V16QI 1 "register_operand" "0,x")
9334             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
9335           (parallel [(const_int 0) (const_int 16)
9336                      (const_int 1) (const_int 17)
9337                      (const_int 2) (const_int 18)
9338                      (const_int 3) (const_int 19)
9339                      (const_int 4) (const_int 20)
9340                      (const_int 5) (const_int 21)
9341                      (const_int 6) (const_int 22)
9342                      (const_int 7) (const_int 23)])))]
9343   "TARGET_SSE2"
9344   "@
9345    punpcklbw\t{%2, %0|%0, %2}
9346    vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
9347   [(set_attr "isa" "noavx,avx")
9348    (set_attr "type" "sselog")
9349    (set_attr "prefix_data16" "1,*")
9350    (set_attr "prefix" "orig,vex")
9351    (set_attr "mode" "TI")])
9352
9353 (define_insn "avx2_interleave_highv16hi"
9354   [(set (match_operand:V16HI 0 "register_operand" "=x")
9355         (vec_select:V16HI
9356           (vec_concat:V32HI
9357             (match_operand:V16HI 1 "register_operand" "x")
9358             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
9359           (parallel [(const_int 4) (const_int 20)
9360                      (const_int 5) (const_int 21)
9361                      (const_int 6) (const_int 22)
9362                      (const_int 7) (const_int 23)
9363                      (const_int 12) (const_int 28)
9364                      (const_int 13) (const_int 29)
9365                      (const_int 14) (const_int 30)
9366                      (const_int 15) (const_int 31)])))]
9367   "TARGET_AVX2"
9368   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
9369   [(set_attr "type" "sselog")
9370    (set_attr "prefix" "vex")
9371    (set_attr "mode" "OI")])
9372
9373 (define_insn "vec_interleave_highv8hi"
9374   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
9375         (vec_select:V8HI
9376           (vec_concat:V16HI
9377             (match_operand:V8HI 1 "register_operand" "0,x")
9378             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
9379           (parallel [(const_int 4) (const_int 12)
9380                      (const_int 5) (const_int 13)
9381                      (const_int 6) (const_int 14)
9382                      (const_int 7) (const_int 15)])))]
9383   "TARGET_SSE2"
9384   "@
9385    punpckhwd\t{%2, %0|%0, %2}
9386    vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
9387   [(set_attr "isa" "noavx,avx")
9388    (set_attr "type" "sselog")
9389    (set_attr "prefix_data16" "1,*")
9390    (set_attr "prefix" "orig,vex")
9391    (set_attr "mode" "TI")])
9392
9393 (define_insn "avx2_interleave_lowv16hi"
9394   [(set (match_operand:V16HI 0 "register_operand" "=x")
9395         (vec_select:V16HI
9396           (vec_concat:V32HI
9397             (match_operand:V16HI 1 "register_operand" "x")
9398             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
9399           (parallel [(const_int 0) (const_int 16)
9400                      (const_int 1) (const_int 17)
9401                      (const_int 2) (const_int 18)
9402                      (const_int 3) (const_int 19)
9403                      (const_int 8) (const_int 24)
9404                      (const_int 9) (const_int 25)
9405                      (const_int 10) (const_int 26)
9406                      (const_int 11) (const_int 27)])))]
9407   "TARGET_AVX2"
9408   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
9409   [(set_attr "type" "sselog")
9410    (set_attr "prefix" "vex")
9411    (set_attr "mode" "OI")])
9412
9413 (define_insn "vec_interleave_lowv8hi"
9414   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
9415         (vec_select:V8HI
9416           (vec_concat:V16HI
9417             (match_operand:V8HI 1 "register_operand" "0,x")
9418             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
9419           (parallel [(const_int 0) (const_int 8)
9420                      (const_int 1) (const_int 9)
9421                      (const_int 2) (const_int 10)
9422                      (const_int 3) (const_int 11)])))]
9423   "TARGET_SSE2"
9424   "@
9425    punpcklwd\t{%2, %0|%0, %2}
9426    vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
9427   [(set_attr "isa" "noavx,avx")
9428    (set_attr "type" "sselog")
9429    (set_attr "prefix_data16" "1,*")
9430    (set_attr "prefix" "orig,vex")
9431    (set_attr "mode" "TI")])
9432
9433 (define_insn "avx2_interleave_highv8si"
9434   [(set (match_operand:V8SI 0 "register_operand" "=x")
9435         (vec_select:V8SI
9436           (vec_concat:V16SI
9437             (match_operand:V8SI 1 "register_operand" "x")
9438             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
9439           (parallel [(const_int 2) (const_int 10)
9440                      (const_int 3) (const_int 11)
9441                      (const_int 6) (const_int 14)
9442                      (const_int 7) (const_int 15)])))]
9443   "TARGET_AVX2"
9444   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
9445   [(set_attr "type" "sselog")
9446    (set_attr "prefix" "vex")
9447    (set_attr "mode" "OI")])
9448
9449 (define_insn "<mask_codefor>avx512f_interleave_highv16si<mask_name>"
9450   [(set (match_operand:V16SI 0 "register_operand" "=v")
9451         (vec_select:V16SI
9452           (vec_concat:V32SI
9453             (match_operand:V16SI 1 "register_operand" "v")
9454             (match_operand:V16SI 2 "nonimmediate_operand" "vm"))
9455           (parallel [(const_int 2) (const_int 18)
9456                      (const_int 3) (const_int 19)
9457                      (const_int 6) (const_int 22)
9458                      (const_int 7) (const_int 23)
9459                      (const_int 10) (const_int 26)
9460                      (const_int 11) (const_int 27)
9461                      (const_int 14) (const_int 30)
9462                      (const_int 15) (const_int 31)])))]
9463   "TARGET_AVX512F"
9464   "vpunpckhdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
9465   [(set_attr "type" "sselog")
9466    (set_attr "prefix" "evex")
9467    (set_attr "mode" "XI")])
9468
9469
9470 (define_insn "vec_interleave_highv4si"
9471   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
9472         (vec_select:V4SI
9473           (vec_concat:V8SI
9474             (match_operand:V4SI 1 "register_operand" "0,x")
9475             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
9476           (parallel [(const_int 2) (const_int 6)
9477                      (const_int 3) (const_int 7)])))]
9478   "TARGET_SSE2"
9479   "@
9480    punpckhdq\t{%2, %0|%0, %2}
9481    vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
9482   [(set_attr "isa" "noavx,avx")
9483    (set_attr "type" "sselog")
9484    (set_attr "prefix_data16" "1,*")
9485    (set_attr "prefix" "orig,vex")
9486    (set_attr "mode" "TI")])
9487
9488 (define_insn "avx2_interleave_lowv8si"
9489   [(set (match_operand:V8SI 0 "register_operand" "=x")
9490         (vec_select:V8SI
9491           (vec_concat:V16SI
9492             (match_operand:V8SI 1 "register_operand" "x")
9493             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
9494           (parallel [(const_int 0) (const_int 8)
9495                      (const_int 1) (const_int 9)
9496                      (const_int 4) (const_int 12)
9497                      (const_int 5) (const_int 13)])))]
9498   "TARGET_AVX2"
9499   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
9500   [(set_attr "type" "sselog")
9501    (set_attr "prefix" "vex")
9502    (set_attr "mode" "OI")])
9503
9504 (define_insn "<mask_codefor>avx512f_interleave_lowv16si<mask_name>"
9505   [(set (match_operand:V16SI 0 "register_operand" "=v")
9506         (vec_select:V16SI
9507           (vec_concat:V32SI
9508             (match_operand:V16SI 1 "register_operand" "v")
9509             (match_operand:V16SI 2 "nonimmediate_operand" "vm"))
9510           (parallel [(const_int 0) (const_int 16)
9511                      (const_int 1) (const_int 17)
9512                      (const_int 4) (const_int 20)
9513                      (const_int 5) (const_int 21)
9514                      (const_int 8) (const_int 24)
9515                      (const_int 9) (const_int 25)
9516                      (const_int 12) (const_int 28)
9517                      (const_int 13) (const_int 29)])))]
9518   "TARGET_AVX512F"
9519   "vpunpckldq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
9520   [(set_attr "type" "sselog")
9521    (set_attr "prefix" "evex")
9522    (set_attr "mode" "XI")])
9523
9524 (define_insn "vec_interleave_lowv4si"
9525   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
9526         (vec_select:V4SI
9527           (vec_concat:V8SI
9528             (match_operand:V4SI 1 "register_operand" "0,x")
9529             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
9530           (parallel [(const_int 0) (const_int 4)
9531                      (const_int 1) (const_int 5)])))]
9532   "TARGET_SSE2"
9533   "@
9534    punpckldq\t{%2, %0|%0, %2}
9535    vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
9536   [(set_attr "isa" "noavx,avx")
9537    (set_attr "type" "sselog")
9538    (set_attr "prefix_data16" "1,*")
9539    (set_attr "prefix" "orig,vex")
9540    (set_attr "mode" "TI")])
9541
9542 (define_expand "vec_interleave_high<mode>"
9543   [(match_operand:VI_256 0 "register_operand" "=x")
9544    (match_operand:VI_256 1 "register_operand" "x")
9545    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
9546  "TARGET_AVX2"
9547 {
9548   rtx t1 = gen_reg_rtx (<MODE>mode);
9549   rtx t2 = gen_reg_rtx (<MODE>mode);
9550   rtx t3 = gen_reg_rtx (V4DImode);
9551   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
9552   emit_insn (gen_avx2_interleave_high<mode> (t2,  operands[1], operands[2]));
9553   emit_insn (gen_avx2_permv2ti (t3, gen_lowpart (V4DImode, t1),
9554                                 gen_lowpart (V4DImode, t2),
9555                                 GEN_INT (1 + (3 << 4))));
9556   emit_move_insn (operands[0], gen_lowpart (<MODE>mode, t3));
9557   DONE;
9558 })
9559
9560 (define_expand "vec_interleave_low<mode>"
9561   [(match_operand:VI_256 0 "register_operand" "=x")
9562    (match_operand:VI_256 1 "register_operand" "x")
9563    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
9564  "TARGET_AVX2"
9565 {
9566   rtx t1 = gen_reg_rtx (<MODE>mode);
9567   rtx t2 = gen_reg_rtx (<MODE>mode);
9568   rtx t3 = gen_reg_rtx (V4DImode);
9569   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
9570   emit_insn (gen_avx2_interleave_high<mode> (t2, operands[1], operands[2]));
9571   emit_insn (gen_avx2_permv2ti (t3, gen_lowpart (V4DImode, t1),
9572                                 gen_lowpart (V4DImode, t2),
9573                                 GEN_INT (0 + (2 << 4))));
9574   emit_move_insn (operands[0], gen_lowpart (<MODE>mode, t3));
9575   DONE;
9576 })
9577
9578 ;; Modes handled by pinsr patterns.
9579 (define_mode_iterator PINSR_MODE
9580   [(V16QI "TARGET_SSE4_1") V8HI
9581    (V4SI "TARGET_SSE4_1")
9582    (V2DI "TARGET_SSE4_1 && TARGET_64BIT")])
9583
9584 (define_mode_attr sse2p4_1
9585   [(V16QI "sse4_1") (V8HI "sse2")
9586    (V4SI "sse4_1") (V2DI "sse4_1")])
9587
9588 ;; sse4_1_pinsrd must come before sse2_loadld since it is preferred.
9589 (define_insn "<sse2p4_1>_pinsr<ssemodesuffix>"
9590   [(set (match_operand:PINSR_MODE 0 "register_operand" "=x,x,x,x")
9591         (vec_merge:PINSR_MODE
9592           (vec_duplicate:PINSR_MODE
9593             (match_operand:<ssescalarmode> 2 "nonimmediate_operand" "r,m,r,m"))
9594           (match_operand:PINSR_MODE 1 "register_operand" "0,0,x,x")
9595           (match_operand:SI 3 "const_int_operand")))]
9596   "TARGET_SSE2
9597    && ((unsigned) exact_log2 (INTVAL (operands[3]))
9598        < GET_MODE_NUNITS (<MODE>mode))"
9599 {
9600   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
9601
9602   switch (which_alternative)
9603     {
9604     case 0:
9605       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
9606         return "pinsr<ssemodesuffix>\t{%3, %k2, %0|%0, %k2, %3}";
9607       /* FALLTHRU */
9608     case 1:
9609       return "pinsr<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}";
9610     case 2:
9611       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
9612         return "vpinsr<ssemodesuffix>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
9613       /* FALLTHRU */
9614     case 3:
9615       return "vpinsr<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
9616     default:
9617       gcc_unreachable ();
9618     }
9619 }
9620   [(set_attr "isa" "noavx,noavx,avx,avx")
9621    (set_attr "type" "sselog")
9622    (set (attr "prefix_rex")
9623      (if_then_else
9624        (and (not (match_test "TARGET_AVX"))
9625             (eq (const_string "<MODE>mode") (const_string "V2DImode")))
9626        (const_string "1")
9627        (const_string "*")))
9628    (set (attr "prefix_data16")
9629      (if_then_else
9630        (and (not (match_test "TARGET_AVX"))
9631             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
9632        (const_string "1")
9633        (const_string "*")))
9634    (set (attr "prefix_extra")
9635      (if_then_else
9636        (and (not (match_test "TARGET_AVX"))
9637             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
9638        (const_string "*")
9639        (const_string "1")))
9640    (set_attr "length_immediate" "1")
9641    (set_attr "prefix" "orig,orig,vex,vex")
9642    (set_attr "mode" "TI")])
9643
9644 (define_expand "avx512f_vinsert<shuffletype>32x4_mask"
9645   [(match_operand:V16FI 0 "register_operand")
9646    (match_operand:V16FI 1 "register_operand")
9647    (match_operand:<ssequartermode> 2 "nonimmediate_operand")
9648    (match_operand:SI 3 "const_0_to_3_operand")
9649    (match_operand:V16FI 4 "register_operand")
9650    (match_operand:<avx512fmaskmode> 5 "register_operand")]
9651   "TARGET_AVX512F"
9652 {
9653   switch (INTVAL (operands[3]))
9654     {
9655     case 0:
9656       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9657           operands[1], operands[2], GEN_INT (0xFFF), operands[4],
9658           operands[5]));
9659       break;
9660     case 1:
9661       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9662           operands[1], operands[2], GEN_INT (0xF0FF), operands[4],
9663           operands[5]));
9664       break;
9665     case 2:
9666       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9667           operands[1], operands[2], GEN_INT (0xFF0F), operands[4],
9668           operands[5]));
9669       break;
9670     case 3:
9671       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9672           operands[1], operands[2], GEN_INT (0xFFF0), operands[4],
9673           operands[5]));
9674       break;
9675     default:
9676       gcc_unreachable ();
9677     }
9678   DONE;
9679
9680 })
9681
9682 (define_insn "<mask_codefor>avx512f_vinsert<shuffletype>32x4_1<mask_name>"
9683   [(set (match_operand:V16FI 0 "register_operand" "=v")
9684         (vec_merge:V16FI
9685           (match_operand:V16FI 1 "register_operand" "v")
9686           (vec_duplicate:V16FI
9687                 (match_operand:<ssequartermode> 2 "nonimmediate_operand" "vm"))
9688           (match_operand:SI 3 "const_int_operand" "n")))]
9689   "TARGET_AVX512F"
9690 {
9691   int mask;
9692   if (INTVAL (operands[3]) == 0xFFF)
9693       mask = 0;
9694   else if ( INTVAL (operands[3]) == 0xF0FF)
9695       mask = 1;
9696   else if ( INTVAL (operands[3]) == 0xFF0F)
9697       mask = 2;
9698   else if ( INTVAL (operands[3]) == 0xFFF0)
9699       mask = 3;
9700   else
9701       gcc_unreachable ();
9702
9703   operands[3] = GEN_INT (mask);
9704
9705   return "vinsert<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
9706 }
9707   [(set_attr "type" "sselog")
9708    (set_attr "length_immediate" "1")
9709    (set_attr "prefix" "evex")
9710    (set_attr "mode" "<sseinsnmode>")])
9711
9712 (define_expand "avx512f_vinsert<shuffletype>64x4_mask"
9713   [(match_operand:V8FI 0 "register_operand")
9714    (match_operand:V8FI 1 "register_operand")
9715    (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand")
9716    (match_operand:SI 3 "const_0_to_1_operand")
9717    (match_operand:V8FI 4 "register_operand")
9718    (match_operand:<avx512fmaskmode> 5 "register_operand")]
9719   "TARGET_AVX512F"
9720 {
9721   int mask = INTVAL (operands[3]);
9722   if (mask == 0)
9723     emit_insn (gen_vec_set_lo_<mode>_mask
9724       (operands[0], operands[1], operands[2],
9725        operands[4], operands[5]));
9726   else
9727     emit_insn (gen_vec_set_hi_<mode>_mask
9728       (operands[0], operands[1], operands[2],
9729        operands[4], operands[5]));
9730   DONE;
9731 })
9732
9733 (define_insn "vec_set_lo_<mode><mask_name>"
9734   [(set (match_operand:V8FI 0 "register_operand" "=v")
9735         (vec_concat:V8FI
9736           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")
9737           (vec_select:<ssehalfvecmode>
9738             (match_operand:V8FI 1 "register_operand" "v")
9739             (parallel [(const_int 4) (const_int 5)
9740               (const_int 6) (const_int 7)]))))]
9741   "TARGET_AVX512F"
9742   "vinsert<shuffletype>64x4\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x0}"
9743   [(set_attr "type" "sselog")
9744    (set_attr "length_immediate" "1")
9745    (set_attr "prefix" "evex")
9746    (set_attr "mode" "XI")])
9747
9748 (define_insn "vec_set_hi_<mode><mask_name>"
9749   [(set (match_operand:V8FI 0 "register_operand" "=v")
9750         (vec_concat:V8FI
9751           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")
9752           (vec_select:<ssehalfvecmode>
9753             (match_operand:V8FI 1 "register_operand" "v")
9754             (parallel [(const_int 0) (const_int 1)
9755               (const_int 2) (const_int 3)]))))]
9756   "TARGET_AVX512F"
9757   "vinsert<shuffletype>64x4\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x1}"
9758   [(set_attr "type" "sselog")
9759    (set_attr "length_immediate" "1")
9760    (set_attr "prefix" "evex")
9761    (set_attr "mode" "XI")])
9762
9763 (define_expand "avx512f_shuf_<shuffletype>64x2_mask"
9764   [(match_operand:V8FI 0 "register_operand")
9765    (match_operand:V8FI 1 "register_operand")
9766    (match_operand:V8FI 2 "nonimmediate_operand")
9767    (match_operand:SI 3 "const_0_to_255_operand")
9768    (match_operand:V8FI 4 "register_operand")
9769    (match_operand:QI 5 "register_operand")]
9770   "TARGET_AVX512F"
9771 {
9772   int mask = INTVAL (operands[3]);
9773   emit_insn (gen_avx512f_shuf_<shuffletype>64x2_1_mask
9774       (operands[0], operands[1], operands[2],
9775        GEN_INT (((mask >> 0) & 3) * 2),
9776        GEN_INT (((mask >> 0) & 3) * 2 + 1),
9777        GEN_INT (((mask >> 2) & 3) * 2),
9778        GEN_INT (((mask >> 2) & 3) * 2 + 1),
9779        GEN_INT (((mask >> 4) & 3) * 2 + 8),
9780        GEN_INT (((mask >> 4) & 3) * 2 + 9),
9781        GEN_INT (((mask >> 6) & 3) * 2 + 8),
9782        GEN_INT (((mask >> 6) & 3) * 2 + 9),
9783        operands[4], operands[5]));
9784   DONE;
9785 })
9786
9787 (define_insn "avx512f_shuf_<shuffletype>64x2_1<mask_name>"
9788   [(set (match_operand:V8FI 0 "register_operand" "=v")
9789         (vec_select:V8FI
9790           (vec_concat:<ssedoublemode>
9791             (match_operand:V8FI 1 "register_operand" "v")
9792             (match_operand:V8FI 2 "nonimmediate_operand" "vm"))
9793           (parallel [(match_operand 3  "const_0_to_7_operand")
9794                      (match_operand 4  "const_0_to_7_operand")
9795                      (match_operand 5  "const_0_to_7_operand")
9796                      (match_operand 6  "const_0_to_7_operand")
9797                      (match_operand 7  "const_8_to_15_operand")
9798                      (match_operand 8  "const_8_to_15_operand")
9799                      (match_operand 9  "const_8_to_15_operand")
9800                      (match_operand 10  "const_8_to_15_operand")])))]
9801   "TARGET_AVX512F
9802    && (INTVAL (operands[3]) == (INTVAL (operands[4]) - 1)
9803        && INTVAL (operands[5]) == (INTVAL (operands[6]) - 1)
9804        && INTVAL (operands[7]) == (INTVAL (operands[8]) - 1)
9805        && INTVAL (operands[9]) == (INTVAL (operands[10]) - 1))"
9806 {
9807   int mask;
9808   mask = INTVAL (operands[3]) / 2;
9809   mask |= INTVAL (operands[5]) / 2 << 2;
9810   mask |= (INTVAL (operands[7]) - 8) / 2 << 4;
9811   mask |= (INTVAL (operands[9]) - 8) / 2 << 6;
9812   operands[3] = GEN_INT (mask);
9813
9814   return "vshuf<shuffletype>64x2\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
9815 }
9816   [(set_attr "type" "sselog")
9817    (set_attr "length_immediate" "1")
9818    (set_attr "prefix" "evex")
9819    (set_attr "mode" "<sseinsnmode>")])
9820
9821 (define_expand "avx512f_shuf_<shuffletype>32x4_mask"
9822   [(match_operand:V16FI 0 "register_operand")
9823    (match_operand:V16FI 1 "register_operand")
9824    (match_operand:V16FI 2 "nonimmediate_operand")
9825    (match_operand:SI 3 "const_0_to_255_operand")
9826    (match_operand:V16FI 4 "register_operand")
9827    (match_operand:HI 5 "register_operand")]
9828   "TARGET_AVX512F"
9829 {
9830   int mask = INTVAL (operands[3]);
9831   emit_insn (gen_avx512f_shuf_<shuffletype>32x4_1_mask
9832       (operands[0], operands[1], operands[2],
9833        GEN_INT (((mask >> 0) & 3) * 4),
9834        GEN_INT (((mask >> 0) & 3) * 4 + 1),
9835        GEN_INT (((mask >> 0) & 3) * 4 + 2),
9836        GEN_INT (((mask >> 0) & 3) * 4 + 3),
9837        GEN_INT (((mask >> 2) & 3) * 4),
9838        GEN_INT (((mask >> 2) & 3) * 4 + 1),
9839        GEN_INT (((mask >> 2) & 3) * 4 + 2),
9840        GEN_INT (((mask >> 2) & 3) * 4 + 3),
9841        GEN_INT (((mask >> 4) & 3) * 4 + 16),
9842        GEN_INT (((mask >> 4) & 3) * 4 + 17),
9843        GEN_INT (((mask >> 4) & 3) * 4 + 18),
9844        GEN_INT (((mask >> 4) & 3) * 4 + 19),
9845        GEN_INT (((mask >> 6) & 3) * 4 + 16),
9846        GEN_INT (((mask >> 6) & 3) * 4 + 17),
9847        GEN_INT (((mask >> 6) & 3) * 4 + 18),
9848        GEN_INT (((mask >> 6) & 3) * 4 + 19),
9849        operands[4], operands[5]));
9850   DONE;
9851 })
9852
9853 (define_insn "avx512f_shuf_<shuffletype>32x4_1<mask_name>"
9854   [(set (match_operand:V16FI 0 "register_operand" "=v")
9855         (vec_select:V16FI
9856           (vec_concat:<ssedoublemode>
9857             (match_operand:V16FI 1 "register_operand" "v")
9858             (match_operand:V16FI 2 "nonimmediate_operand" "vm"))
9859           (parallel [(match_operand 3  "const_0_to_15_operand")
9860                      (match_operand 4  "const_0_to_15_operand")
9861                      (match_operand 5  "const_0_to_15_operand")
9862                      (match_operand 6  "const_0_to_15_operand")
9863                      (match_operand 7  "const_0_to_15_operand")
9864                      (match_operand 8  "const_0_to_15_operand")
9865                      (match_operand 9  "const_0_to_15_operand")
9866                      (match_operand 10  "const_0_to_15_operand")
9867                      (match_operand 11  "const_16_to_31_operand")
9868                      (match_operand 12  "const_16_to_31_operand")
9869                      (match_operand 13  "const_16_to_31_operand")
9870                      (match_operand 14  "const_16_to_31_operand")
9871                      (match_operand 15  "const_16_to_31_operand")
9872                      (match_operand 16  "const_16_to_31_operand")
9873                      (match_operand 17  "const_16_to_31_operand")
9874                      (match_operand 18  "const_16_to_31_operand")])))]
9875   "TARGET_AVX512F
9876    && (INTVAL (operands[3]) == (INTVAL (operands[4]) - 1)
9877        && INTVAL (operands[3]) == (INTVAL (operands[5]) - 2)
9878        && INTVAL (operands[3]) == (INTVAL (operands[6]) - 3)
9879        && INTVAL (operands[7]) == (INTVAL (operands[8]) - 1)
9880        && INTVAL (operands[7]) == (INTVAL (operands[9]) - 2)
9881        && INTVAL (operands[7]) == (INTVAL (operands[10]) - 3)
9882        && INTVAL (operands[11]) == (INTVAL (operands[12]) - 1)
9883        && INTVAL (operands[11]) == (INTVAL (operands[13]) - 2)
9884        && INTVAL (operands[11]) == (INTVAL (operands[14]) - 3)
9885        && INTVAL (operands[15]) == (INTVAL (operands[16]) - 1)
9886        && INTVAL (operands[15]) == (INTVAL (operands[17]) - 2)
9887        && INTVAL (operands[15]) == (INTVAL (operands[18]) - 3))"
9888 {
9889   int mask;
9890   mask = INTVAL (operands[3]) / 4;
9891   mask |= INTVAL (operands[7]) / 4 << 2;
9892   mask |= (INTVAL (operands[11]) - 16) / 4 << 4;
9893   mask |= (INTVAL (operands[15]) - 16) / 4 << 6;
9894   operands[3] = GEN_INT (mask);
9895
9896   return "vshuf<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand19>|%0<mask_operand19>, %1, %2, %3}";
9897 }
9898   [(set_attr "type" "sselog")
9899    (set_attr "length_immediate" "1")
9900    (set_attr "prefix" "evex")
9901    (set_attr "mode" "<sseinsnmode>")])
9902
9903 (define_expand "avx512f_pshufdv3_mask"
9904   [(match_operand:V16SI 0 "register_operand")
9905    (match_operand:V16SI 1 "nonimmediate_operand")
9906    (match_operand:SI 2 "const_0_to_255_operand")
9907    (match_operand:V16SI 3 "register_operand")
9908    (match_operand:HI 4 "register_operand")]
9909   "TARGET_AVX512F"
9910 {
9911   int mask = INTVAL (operands[2]);
9912   emit_insn (gen_avx512f_pshufd_1_mask (operands[0], operands[1],
9913                                        GEN_INT ((mask >> 0) & 3),
9914                                        GEN_INT ((mask >> 2) & 3),
9915                                        GEN_INT ((mask >> 4) & 3),
9916                                        GEN_INT ((mask >> 6) & 3),
9917                                        GEN_INT (((mask >> 0) & 3) + 4),
9918                                        GEN_INT (((mask >> 2) & 3) + 4),
9919                                        GEN_INT (((mask >> 4) & 3) + 4),
9920                                        GEN_INT (((mask >> 6) & 3) + 4),
9921                                        GEN_INT (((mask >> 0) & 3) + 8),
9922                                        GEN_INT (((mask >> 2) & 3) + 8),
9923                                        GEN_INT (((mask >> 4) & 3) + 8),
9924                                        GEN_INT (((mask >> 6) & 3) + 8),
9925                                        GEN_INT (((mask >> 0) & 3) + 12),
9926                                        GEN_INT (((mask >> 2) & 3) + 12),
9927                                        GEN_INT (((mask >> 4) & 3) + 12),
9928                                        GEN_INT (((mask >> 6) & 3) + 12),
9929                                        operands[3], operands[4]));
9930   DONE;
9931 })
9932
9933 (define_insn "avx512f_pshufd_1<mask_name>"
9934   [(set (match_operand:V16SI 0 "register_operand" "=v")
9935         (vec_select:V16SI
9936           (match_operand:V16SI 1 "nonimmediate_operand" "vm")
9937           (parallel [(match_operand 2 "const_0_to_3_operand")
9938                      (match_operand 3 "const_0_to_3_operand")
9939                      (match_operand 4 "const_0_to_3_operand")
9940                      (match_operand 5 "const_0_to_3_operand")
9941                      (match_operand 6 "const_4_to_7_operand")
9942                      (match_operand 7 "const_4_to_7_operand")
9943                      (match_operand 8 "const_4_to_7_operand")
9944                      (match_operand 9 "const_4_to_7_operand")
9945                      (match_operand 10 "const_8_to_11_operand")
9946                      (match_operand 11 "const_8_to_11_operand")
9947                      (match_operand 12 "const_8_to_11_operand")
9948                      (match_operand 13 "const_8_to_11_operand")
9949                      (match_operand 14 "const_12_to_15_operand")
9950                      (match_operand 15 "const_12_to_15_operand")
9951                      (match_operand 16 "const_12_to_15_operand")
9952                      (match_operand 17 "const_12_to_15_operand")])))]
9953   "TARGET_AVX512F
9954    && INTVAL (operands[2]) + 4 == INTVAL (operands[6])
9955    && INTVAL (operands[3]) + 4 == INTVAL (operands[7])
9956    && INTVAL (operands[4]) + 4 == INTVAL (operands[8])
9957    && INTVAL (operands[5]) + 4 == INTVAL (operands[9])
9958    && INTVAL (operands[2]) + 8 == INTVAL (operands[10])
9959    && INTVAL (operands[3]) + 8 == INTVAL (operands[11])
9960    && INTVAL (operands[4]) + 8 == INTVAL (operands[12])
9961    && INTVAL (operands[5]) + 8 == INTVAL (operands[13])
9962    && INTVAL (operands[2]) + 12 == INTVAL (operands[14])
9963    && INTVAL (operands[3]) + 12 == INTVAL (operands[15])
9964    && INTVAL (operands[4]) + 12 == INTVAL (operands[16])
9965    && INTVAL (operands[5]) + 12 == INTVAL (operands[17])"
9966 {
9967   int mask = 0;
9968   mask |= INTVAL (operands[2]) << 0;
9969   mask |= INTVAL (operands[3]) << 2;
9970   mask |= INTVAL (operands[4]) << 4;
9971   mask |= INTVAL (operands[5]) << 6;
9972   operands[2] = GEN_INT (mask);
9973
9974   return "vpshufd\t{%2, %1, %0<mask_operand18>|%0<mask_operand18>, %1, %2}";
9975 }
9976   [(set_attr "type" "sselog1")
9977    (set_attr "prefix" "evex")
9978    (set_attr "length_immediate" "1")
9979    (set_attr "mode" "XI")])
9980
9981 (define_expand "avx2_pshufdv3"
9982   [(match_operand:V8SI 0 "register_operand")
9983    (match_operand:V8SI 1 "nonimmediate_operand")
9984    (match_operand:SI 2 "const_0_to_255_operand")]
9985   "TARGET_AVX2"
9986 {
9987   int mask = INTVAL (operands[2]);
9988   emit_insn (gen_avx2_pshufd_1 (operands[0], operands[1],
9989                                 GEN_INT ((mask >> 0) & 3),
9990                                 GEN_INT ((mask >> 2) & 3),
9991                                 GEN_INT ((mask >> 4) & 3),
9992                                 GEN_INT ((mask >> 6) & 3),
9993                                 GEN_INT (((mask >> 0) & 3) + 4),
9994                                 GEN_INT (((mask >> 2) & 3) + 4),
9995                                 GEN_INT (((mask >> 4) & 3) + 4),
9996                                 GEN_INT (((mask >> 6) & 3) + 4)));
9997   DONE;
9998 })
9999
10000 (define_insn "avx2_pshufd_1"
10001   [(set (match_operand:V8SI 0 "register_operand" "=x")
10002         (vec_select:V8SI
10003           (match_operand:V8SI 1 "nonimmediate_operand" "xm")
10004           (parallel [(match_operand 2 "const_0_to_3_operand")
10005                      (match_operand 3 "const_0_to_3_operand")
10006                      (match_operand 4 "const_0_to_3_operand")
10007                      (match_operand 5 "const_0_to_3_operand")
10008                      (match_operand 6 "const_4_to_7_operand")
10009                      (match_operand 7 "const_4_to_7_operand")
10010                      (match_operand 8 "const_4_to_7_operand")
10011                      (match_operand 9 "const_4_to_7_operand")])))]
10012   "TARGET_AVX2
10013    && INTVAL (operands[2]) + 4 == INTVAL (operands[6])
10014    && INTVAL (operands[3]) + 4 == INTVAL (operands[7])
10015    && INTVAL (operands[4]) + 4 == INTVAL (operands[8])
10016    && INTVAL (operands[5]) + 4 == INTVAL (operands[9])"
10017 {
10018   int mask = 0;
10019   mask |= INTVAL (operands[2]) << 0;
10020   mask |= INTVAL (operands[3]) << 2;
10021   mask |= INTVAL (operands[4]) << 4;
10022   mask |= INTVAL (operands[5]) << 6;
10023   operands[2] = GEN_INT (mask);
10024
10025   return "vpshufd\t{%2, %1, %0|%0, %1, %2}";
10026 }
10027   [(set_attr "type" "sselog1")
10028    (set_attr "prefix" "vex")
10029    (set_attr "length_immediate" "1")
10030    (set_attr "mode" "OI")])
10031
10032 (define_expand "sse2_pshufd"
10033   [(match_operand:V4SI 0 "register_operand")
10034    (match_operand:V4SI 1 "nonimmediate_operand")
10035    (match_operand:SI 2 "const_int_operand")]
10036   "TARGET_SSE2"
10037 {
10038   int mask = INTVAL (operands[2]);
10039   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
10040                                 GEN_INT ((mask >> 0) & 3),
10041                                 GEN_INT ((mask >> 2) & 3),
10042                                 GEN_INT ((mask >> 4) & 3),
10043                                 GEN_INT ((mask >> 6) & 3)));
10044   DONE;
10045 })
10046
10047 (define_insn "sse2_pshufd_1"
10048   [(set (match_operand:V4SI 0 "register_operand" "=x")
10049         (vec_select:V4SI
10050           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
10051           (parallel [(match_operand 2 "const_0_to_3_operand")
10052                      (match_operand 3 "const_0_to_3_operand")
10053                      (match_operand 4 "const_0_to_3_operand")
10054                      (match_operand 5 "const_0_to_3_operand")])))]
10055   "TARGET_SSE2"
10056 {
10057   int mask = 0;
10058   mask |= INTVAL (operands[2]) << 0;
10059   mask |= INTVAL (operands[3]) << 2;
10060   mask |= INTVAL (operands[4]) << 4;
10061   mask |= INTVAL (operands[5]) << 6;
10062   operands[2] = GEN_INT (mask);
10063
10064   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
10065 }
10066   [(set_attr "type" "sselog1")
10067    (set_attr "prefix_data16" "1")
10068    (set_attr "prefix" "maybe_vex")
10069    (set_attr "length_immediate" "1")
10070    (set_attr "mode" "TI")])
10071
10072 (define_expand "avx2_pshuflwv3"
10073   [(match_operand:V16HI 0 "register_operand")
10074    (match_operand:V16HI 1 "nonimmediate_operand")
10075    (match_operand:SI 2 "const_0_to_255_operand")]
10076   "TARGET_AVX2"
10077 {
10078   int mask = INTVAL (operands[2]);
10079   emit_insn (gen_avx2_pshuflw_1 (operands[0], operands[1],
10080                                  GEN_INT ((mask >> 0) & 3),
10081                                  GEN_INT ((mask >> 2) & 3),
10082                                  GEN_INT ((mask >> 4) & 3),
10083                                  GEN_INT ((mask >> 6) & 3),
10084                                  GEN_INT (((mask >> 0) & 3) + 8),
10085                                  GEN_INT (((mask >> 2) & 3) + 8),
10086                                  GEN_INT (((mask >> 4) & 3) + 8),
10087                                  GEN_INT (((mask >> 6) & 3) + 8)));
10088   DONE;
10089 })
10090
10091 (define_insn "avx2_pshuflw_1"
10092   [(set (match_operand:V16HI 0 "register_operand" "=x")
10093         (vec_select:V16HI
10094           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
10095           (parallel [(match_operand 2 "const_0_to_3_operand")
10096                      (match_operand 3 "const_0_to_3_operand")
10097                      (match_operand 4 "const_0_to_3_operand")
10098                      (match_operand 5 "const_0_to_3_operand")
10099                      (const_int 4)
10100                      (const_int 5)
10101                      (const_int 6)
10102                      (const_int 7)
10103                      (match_operand 6 "const_8_to_11_operand")
10104                      (match_operand 7 "const_8_to_11_operand")
10105                      (match_operand 8 "const_8_to_11_operand")
10106                      (match_operand 9 "const_8_to_11_operand")
10107                      (const_int 12)
10108                      (const_int 13)
10109                      (const_int 14)
10110                      (const_int 15)])))]
10111   "TARGET_AVX2
10112    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
10113    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
10114    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
10115    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
10116 {
10117   int mask = 0;
10118   mask |= INTVAL (operands[2]) << 0;
10119   mask |= INTVAL (operands[3]) << 2;
10120   mask |= INTVAL (operands[4]) << 4;
10121   mask |= INTVAL (operands[5]) << 6;
10122   operands[2] = GEN_INT (mask);
10123
10124   return "vpshuflw\t{%2, %1, %0|%0, %1, %2}";
10125 }
10126   [(set_attr "type" "sselog")
10127    (set_attr "prefix" "vex")
10128    (set_attr "length_immediate" "1")
10129    (set_attr "mode" "OI")])
10130
10131 (define_expand "sse2_pshuflw"
10132   [(match_operand:V8HI 0 "register_operand")
10133    (match_operand:V8HI 1 "nonimmediate_operand")
10134    (match_operand:SI 2 "const_int_operand")]
10135   "TARGET_SSE2"
10136 {
10137   int mask = INTVAL (operands[2]);
10138   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
10139                                  GEN_INT ((mask >> 0) & 3),
10140                                  GEN_INT ((mask >> 2) & 3),
10141                                  GEN_INT ((mask >> 4) & 3),
10142                                  GEN_INT ((mask >> 6) & 3)));
10143   DONE;
10144 })
10145
10146 (define_insn "sse2_pshuflw_1"
10147   [(set (match_operand:V8HI 0 "register_operand" "=x")
10148         (vec_select:V8HI
10149           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10150           (parallel [(match_operand 2 "const_0_to_3_operand")
10151                      (match_operand 3 "const_0_to_3_operand")
10152                      (match_operand 4 "const_0_to_3_operand")
10153                      (match_operand 5 "const_0_to_3_operand")
10154                      (const_int 4)
10155                      (const_int 5)
10156                      (const_int 6)
10157                      (const_int 7)])))]
10158   "TARGET_SSE2"
10159 {
10160   int mask = 0;
10161   mask |= INTVAL (operands[2]) << 0;
10162   mask |= INTVAL (operands[3]) << 2;
10163   mask |= INTVAL (operands[4]) << 4;
10164   mask |= INTVAL (operands[5]) << 6;
10165   operands[2] = GEN_INT (mask);
10166
10167   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
10168 }
10169   [(set_attr "type" "sselog")
10170    (set_attr "prefix_data16" "0")
10171    (set_attr "prefix_rep" "1")
10172    (set_attr "prefix" "maybe_vex")
10173    (set_attr "length_immediate" "1")
10174    (set_attr "mode" "TI")])
10175
10176 (define_expand "avx2_pshufhwv3"
10177   [(match_operand:V16HI 0 "register_operand")
10178    (match_operand:V16HI 1 "nonimmediate_operand")
10179    (match_operand:SI 2 "const_0_to_255_operand")]
10180   "TARGET_AVX2"
10181 {
10182   int mask = INTVAL (operands[2]);
10183   emit_insn (gen_avx2_pshufhw_1 (operands[0], operands[1],
10184                                  GEN_INT (((mask >> 0) & 3) + 4),
10185                                  GEN_INT (((mask >> 2) & 3) + 4),
10186                                  GEN_INT (((mask >> 4) & 3) + 4),
10187                                  GEN_INT (((mask >> 6) & 3) + 4),
10188                                  GEN_INT (((mask >> 0) & 3) + 12),
10189                                  GEN_INT (((mask >> 2) & 3) + 12),
10190                                  GEN_INT (((mask >> 4) & 3) + 12),
10191                                  GEN_INT (((mask >> 6) & 3) + 12)));
10192   DONE;
10193 })
10194
10195 (define_insn "avx2_pshufhw_1"
10196   [(set (match_operand:V16HI 0 "register_operand" "=x")
10197         (vec_select:V16HI
10198           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
10199           (parallel [(const_int 0)
10200                      (const_int 1)
10201                      (const_int 2)
10202                      (const_int 3)
10203                      (match_operand 2 "const_4_to_7_operand")
10204                      (match_operand 3 "const_4_to_7_operand")
10205                      (match_operand 4 "const_4_to_7_operand")
10206                      (match_operand 5 "const_4_to_7_operand")
10207                      (const_int 8)
10208                      (const_int 9)
10209                      (const_int 10)
10210                      (const_int 11)
10211                      (match_operand 6 "const_12_to_15_operand")
10212                      (match_operand 7 "const_12_to_15_operand")
10213                      (match_operand 8 "const_12_to_15_operand")
10214                      (match_operand 9 "const_12_to_15_operand")])))]
10215   "TARGET_AVX2
10216    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
10217    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
10218    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
10219    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
10220 {
10221   int mask = 0;
10222   mask |= (INTVAL (operands[2]) - 4) << 0;
10223   mask |= (INTVAL (operands[3]) - 4) << 2;
10224   mask |= (INTVAL (operands[4]) - 4) << 4;
10225   mask |= (INTVAL (operands[5]) - 4) << 6;
10226   operands[2] = GEN_INT (mask);
10227
10228   return "vpshufhw\t{%2, %1, %0|%0, %1, %2}";
10229 }
10230   [(set_attr "type" "sselog")
10231    (set_attr "prefix" "vex")
10232    (set_attr "length_immediate" "1")
10233    (set_attr "mode" "OI")])
10234
10235 (define_expand "sse2_pshufhw"
10236   [(match_operand:V8HI 0 "register_operand")
10237    (match_operand:V8HI 1 "nonimmediate_operand")
10238    (match_operand:SI 2 "const_int_operand")]
10239   "TARGET_SSE2"
10240 {
10241   int mask = INTVAL (operands[2]);
10242   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
10243                                  GEN_INT (((mask >> 0) & 3) + 4),
10244                                  GEN_INT (((mask >> 2) & 3) + 4),
10245                                  GEN_INT (((mask >> 4) & 3) + 4),
10246                                  GEN_INT (((mask >> 6) & 3) + 4)));
10247   DONE;
10248 })
10249
10250 (define_insn "sse2_pshufhw_1"
10251   [(set (match_operand:V8HI 0 "register_operand" "=x")
10252         (vec_select:V8HI
10253           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10254           (parallel [(const_int 0)
10255                      (const_int 1)
10256                      (const_int 2)
10257                      (const_int 3)
10258                      (match_operand 2 "const_4_to_7_operand")
10259                      (match_operand 3 "const_4_to_7_operand")
10260                      (match_operand 4 "const_4_to_7_operand")
10261                      (match_operand 5 "const_4_to_7_operand")])))]
10262   "TARGET_SSE2"
10263 {
10264   int mask = 0;
10265   mask |= (INTVAL (operands[2]) - 4) << 0;
10266   mask |= (INTVAL (operands[3]) - 4) << 2;
10267   mask |= (INTVAL (operands[4]) - 4) << 4;
10268   mask |= (INTVAL (operands[5]) - 4) << 6;
10269   operands[2] = GEN_INT (mask);
10270
10271   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
10272 }
10273   [(set_attr "type" "sselog")
10274    (set_attr "prefix_rep" "1")
10275    (set_attr "prefix_data16" "0")
10276    (set_attr "prefix" "maybe_vex")
10277    (set_attr "length_immediate" "1")
10278    (set_attr "mode" "TI")])
10279
10280 (define_expand "sse2_loadd"
10281   [(set (match_operand:V4SI 0 "register_operand")
10282         (vec_merge:V4SI
10283           (vec_duplicate:V4SI
10284             (match_operand:SI 1 "nonimmediate_operand"))
10285           (match_dup 2)
10286           (const_int 1)))]
10287   "TARGET_SSE"
10288   "operands[2] = CONST0_RTX (V4SImode);")
10289
10290 (define_insn "sse2_loadld"
10291   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x,x,x")
10292         (vec_merge:V4SI
10293           (vec_duplicate:V4SI
10294             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,m,x,x"))
10295           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,C,0,x")
10296           (const_int 1)))]
10297   "TARGET_SSE"
10298   "@
10299    %vmovd\t{%2, %0|%0, %2}
10300    %vmovd\t{%2, %0|%0, %2}
10301    movss\t{%2, %0|%0, %2}
10302    movss\t{%2, %0|%0, %2}
10303    vmovss\t{%2, %1, %0|%0, %1, %2}"
10304   [(set_attr "isa" "sse2,*,noavx,noavx,avx")
10305    (set_attr "type" "ssemov")
10306    (set_attr "prefix" "maybe_vex,maybe_vex,orig,orig,vex")
10307    (set_attr "mode" "TI,TI,V4SF,SF,SF")])
10308
10309 (define_insn "*vec_extract<mode>"
10310   [(set (match_operand:<ssescalarmode> 0 "nonimmediate_operand" "=r,m")
10311         (vec_select:<ssescalarmode>
10312           (match_operand:VI12_128 1 "register_operand" "x,x")
10313           (parallel
10314             [(match_operand:SI 2 "const_0_to_<ssescalarnummask>_operand")])))]
10315   "TARGET_SSE4_1"
10316   "@
10317    %vpextr<ssemodesuffix>\t{%2, %1, %k0|%k0, %1, %2}
10318    %vpextr<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10319   [(set_attr "type" "sselog1")
10320    (set (attr "prefix_data16")
10321      (if_then_else
10322        (and (eq_attr "alternative" "0")
10323             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
10324        (const_string "1")
10325        (const_string "*")))
10326    (set (attr "prefix_extra")
10327      (if_then_else
10328        (and (eq_attr "alternative" "0")
10329             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
10330        (const_string "*")
10331        (const_string "1")))
10332    (set_attr "length_immediate" "1")
10333    (set_attr "prefix" "maybe_vex")
10334    (set_attr "mode" "TI")])
10335
10336 (define_insn "*vec_extractv8hi_sse2"
10337   [(set (match_operand:HI 0 "register_operand" "=r")
10338         (vec_select:HI
10339           (match_operand:V8HI 1 "register_operand" "x")
10340           (parallel
10341             [(match_operand:SI 2 "const_0_to_7_operand")])))]
10342   "TARGET_SSE2 && !TARGET_SSE4_1"
10343   "pextrw\t{%2, %1, %k0|%k0, %1, %2}"
10344   [(set_attr "type" "sselog1")
10345    (set_attr "prefix_data16" "1")
10346    (set_attr "length_immediate" "1")
10347    (set_attr "mode" "TI")])
10348
10349 (define_insn "*vec_extractv16qi_zext"
10350   [(set (match_operand:SWI48 0 "register_operand" "=r")
10351         (zero_extend:SWI48
10352           (vec_select:QI
10353             (match_operand:V16QI 1 "register_operand" "x")
10354             (parallel
10355               [(match_operand:SI 2 "const_0_to_15_operand")]))))]
10356   "TARGET_SSE4_1"
10357   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
10358   [(set_attr "type" "sselog1")
10359    (set_attr "prefix_extra" "1")
10360    (set_attr "length_immediate" "1")
10361    (set_attr "prefix" "maybe_vex")
10362    (set_attr "mode" "TI")])
10363
10364 (define_insn "*vec_extractv8hi_zext"
10365   [(set (match_operand:SWI48 0 "register_operand" "=r")
10366         (zero_extend:SWI48
10367           (vec_select:HI
10368             (match_operand:V8HI 1 "register_operand" "x")
10369             (parallel
10370               [(match_operand:SI 2 "const_0_to_7_operand")]))))]
10371   "TARGET_SSE2"
10372   "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
10373   [(set_attr "type" "sselog1")
10374    (set_attr "prefix_data16" "1")
10375    (set_attr "length_immediate" "1")
10376    (set_attr "prefix" "maybe_vex")
10377    (set_attr "mode" "TI")])
10378
10379 (define_insn "*vec_extract<mode>_mem"
10380   [(set (match_operand:<ssescalarmode> 0 "register_operand" "=r")
10381         (vec_select:<ssescalarmode>
10382           (match_operand:VI12_128 1 "memory_operand" "o")
10383           (parallel
10384             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
10385   "TARGET_SSE"
10386   "#")
10387
10388 (define_insn "*vec_extract<ssevecmodelower>_0"
10389   [(set (match_operand:SWI48 0 "nonimmediate_operand"          "=r ,r,x ,m")
10390         (vec_select:SWI48
10391           (match_operand:<ssevecmode> 1 "nonimmediate_operand" "mYj,x,xm,x")
10392           (parallel [(const_int 0)])))]
10393   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10394   "#"
10395   [(set_attr "isa" "*,sse4,*,*")])
10396
10397 (define_insn_and_split "*vec_extractv4si_0_zext"
10398   [(set (match_operand:DI 0 "register_operand" "=r")
10399         (zero_extend:DI
10400           (vec_select:SI
10401             (match_operand:V4SI 1 "register_operand" "x")
10402             (parallel [(const_int 0)]))))]
10403   "TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_FROM_VEC"
10404   "#"
10405   "&& reload_completed"
10406   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
10407   "operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));")
10408
10409 (define_insn "*vec_extractv2di_0_sse"
10410   [(set (match_operand:DI 0 "nonimmediate_operand"     "=x,m")
10411         (vec_select:DI
10412           (match_operand:V2DI 1 "nonimmediate_operand" "xm,x")
10413           (parallel [(const_int 0)])))]
10414   "TARGET_SSE && !TARGET_64BIT
10415    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10416   "#")
10417
10418 (define_split
10419   [(set (match_operand:SWI48x 0 "nonimmediate_operand")
10420         (vec_select:SWI48x
10421           (match_operand:<ssevecmode> 1 "register_operand")
10422           (parallel [(const_int 0)])))]
10423   "TARGET_SSE && reload_completed"
10424   [(set (match_dup 0) (match_dup 1))]
10425   "operands[1] = gen_rtx_REG (<MODE>mode, REGNO (operands[1]));")
10426
10427 (define_insn "*vec_extractv4si"
10428   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,x,x")
10429         (vec_select:SI
10430           (match_operand:V4SI 1 "register_operand" "x,0,x")
10431           (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
10432   "TARGET_SSE4_1"
10433 {
10434   switch (which_alternative)
10435     {
10436     case 0:
10437       return "%vpextrd\t{%2, %1, %0|%0, %1, %2}";
10438
10439     case 1:
10440       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
10441       return "psrldq\t{%2, %0|%0, %2}";
10442
10443     case 2:
10444       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
10445       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
10446
10447     default:
10448       gcc_unreachable ();
10449     }
10450 }
10451   [(set_attr "isa" "*,noavx,avx")
10452    (set_attr "type" "sselog1,sseishft1,sseishft1")
10453    (set_attr "prefix_extra" "1,*,*")
10454    (set_attr "length_immediate" "1")
10455    (set_attr "prefix" "maybe_vex,orig,vex")
10456    (set_attr "mode" "TI")])
10457
10458 (define_insn "*vec_extractv4si_zext"
10459   [(set (match_operand:DI 0 "register_operand" "=r")
10460         (zero_extend:DI
10461           (vec_select:SI
10462             (match_operand:V4SI 1 "register_operand" "x")
10463             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
10464   "TARGET_64BIT && TARGET_SSE4_1"
10465   "%vpextrd\t{%2, %1, %k0|%k0, %1, %2}"
10466   [(set_attr "type" "sselog1")
10467    (set_attr "prefix_extra" "1")
10468    (set_attr "length_immediate" "1")
10469    (set_attr "prefix" "maybe_vex")
10470    (set_attr "mode" "TI")])
10471
10472 (define_insn "*vec_extractv4si_mem"
10473   [(set (match_operand:SI 0 "register_operand" "=x,r")
10474         (vec_select:SI
10475           (match_operand:V4SI 1 "memory_operand" "o,o")
10476           (parallel [(match_operand 2 "const_0_to_3_operand")])))]
10477   "TARGET_SSE"
10478   "#")
10479
10480 (define_insn_and_split "*vec_extractv4si_zext_mem"
10481   [(set (match_operand:DI 0 "register_operand" "=x,r")
10482         (zero_extend:DI
10483           (vec_select:SI
10484             (match_operand:V4SI 1 "memory_operand" "o,o")
10485             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
10486   "TARGET_64BIT && TARGET_SSE"
10487   "#"
10488   "&& reload_completed"
10489   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
10490 {
10491   operands[1] = adjust_address (operands[1], SImode, INTVAL (operands[2]) * 4);
10492 })
10493
10494 (define_insn "*vec_extractv2di_1"
10495   [(set (match_operand:DI 0 "nonimmediate_operand"     "=rm,m,x,x,x,x,r")
10496         (vec_select:DI
10497           (match_operand:V2DI 1 "nonimmediate_operand"  "x ,x,0,x,x,o,o")
10498           (parallel [(const_int 1)])))]
10499   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10500   "@
10501    %vpextrq\t{$1, %1, %0|%0, %1, 1}
10502    %vmovhps\t{%1, %0|%0, %1}
10503    psrldq\t{$8, %0|%0, 8}
10504    vpsrldq\t{$8, %1, %0|%0, %1, 8}
10505    movhlps\t{%1, %0|%0, %1}
10506    #
10507    #"
10508   [(set_attr "isa" "x64_sse4,*,sse2_noavx,avx,noavx,*,x64")
10509    (set_attr "type" "sselog1,ssemov,sseishft1,sseishft1,ssemov,ssemov,imov")
10510    (set_attr "length_immediate" "1,*,1,1,*,*,*")
10511    (set_attr "prefix_rex" "1,*,*,*,*,*,*")
10512    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
10513    (set_attr "prefix" "maybe_vex,maybe_vex,orig,vex,orig,*,*")
10514    (set_attr "mode" "TI,V2SF,TI,TI,V4SF,DI,DI")])
10515
10516 (define_split
10517   [(set (match_operand:<ssescalarmode> 0 "register_operand")
10518         (vec_select:<ssescalarmode>
10519           (match_operand:VI_128 1 "memory_operand")
10520           (parallel
10521             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
10522   "TARGET_SSE && reload_completed"
10523   [(set (match_dup 0) (match_dup 1))]
10524 {
10525   int offs = INTVAL (operands[2]) * GET_MODE_SIZE (<ssescalarmode>mode);
10526
10527   operands[1] = adjust_address (operands[1], <ssescalarmode>mode, offs);
10528 })
10529
10530 (define_insn "*vec_dupv4si"
10531   [(set (match_operand:V4SI 0 "register_operand"     "=x,x,x")
10532         (vec_duplicate:V4SI
10533           (match_operand:SI 1 "nonimmediate_operand" " x,m,0")))]
10534   "TARGET_SSE"
10535   "@
10536    %vpshufd\t{$0, %1, %0|%0, %1, 0}
10537    vbroadcastss\t{%1, %0|%0, %1}
10538    shufps\t{$0, %0, %0|%0, %0, 0}"
10539   [(set_attr "isa" "sse2,avx,noavx")
10540    (set_attr "type" "sselog1,ssemov,sselog1")
10541    (set_attr "length_immediate" "1,0,1")
10542    (set_attr "prefix_extra" "0,1,*")
10543    (set_attr "prefix" "maybe_vex,vex,orig")
10544    (set_attr "mode" "TI,V4SF,V4SF")])
10545
10546 (define_insn "*vec_dupv2di"
10547   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,x,x")
10548         (vec_duplicate:V2DI
10549           (match_operand:DI 1 "nonimmediate_operand" " 0,x,m,0")))]
10550   "TARGET_SSE"
10551   "@
10552    punpcklqdq\t%0, %0
10553    vpunpcklqdq\t{%d1, %0|%0, %d1}
10554    %vmovddup\t{%1, %0|%0, %1}
10555    movlhps\t%0, %0"
10556   [(set_attr "isa" "sse2_noavx,avx,sse3,noavx")
10557    (set_attr "type" "sselog1,sselog1,sselog1,ssemov")
10558    (set_attr "prefix" "orig,vex,maybe_vex,orig")
10559    (set_attr "mode" "TI,TI,DF,V4SF")])
10560
10561 (define_insn "*vec_concatv2si_sse4_1"
10562   [(set (match_operand:V2SI 0 "register_operand"     "=x, x,x,x, x, *y,*y")
10563         (vec_concat:V2SI
10564           (match_operand:SI 1 "nonimmediate_operand" " 0, x,0,x,rm,  0,rm")
10565           (match_operand:SI 2 "vector_move_operand"  "rm,rm,x,x, C,*ym, C")))]
10566   "TARGET_SSE4_1"
10567   "@
10568    pinsrd\t{$1, %2, %0|%0, %2, 1}
10569    vpinsrd\t{$1, %2, %1, %0|%0, %1, %2, 1}
10570    punpckldq\t{%2, %0|%0, %2}
10571    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
10572    %vmovd\t{%1, %0|%0, %1}
10573    punpckldq\t{%2, %0|%0, %2}
10574    movd\t{%1, %0|%0, %1}"
10575   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
10576    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
10577    (set_attr "prefix_extra" "1,1,*,*,*,*,*")
10578    (set_attr "length_immediate" "1,1,*,*,*,*,*")
10579    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
10580    (set_attr "mode" "TI,TI,TI,TI,TI,DI,DI")])
10581
10582 ;; ??? In theory we can match memory for the MMX alternative, but allowing
10583 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
10584 ;; alternatives pretty much forces the MMX alternative to be chosen.
10585 (define_insn "*vec_concatv2si"
10586   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,x,x,*y,*y")
10587         (vec_concat:V2SI
10588           (match_operand:SI 1 "nonimmediate_operand" " 0,rm,rm,0,m, 0,*rm")
10589           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,C, x,C,*y,C")))]
10590   "TARGET_SSE && !TARGET_SSE4_1"
10591   "@
10592    punpckldq\t{%2, %0|%0, %2}
10593    movd\t{%1, %0|%0, %1}
10594    movd\t{%1, %0|%0, %1}
10595    unpcklps\t{%2, %0|%0, %2}
10596    movss\t{%1, %0|%0, %1}
10597    punpckldq\t{%2, %0|%0, %2}
10598    movd\t{%1, %0|%0, %1}"
10599   [(set_attr "isa" "sse2,sse2,sse2,*,*,*,*")
10600    (set_attr "type" "sselog,ssemov,mmxmov,sselog,ssemov,mmxcvt,mmxmov")
10601    (set_attr "mode" "TI,TI,DI,V4SF,SF,DI,DI")])
10602
10603 (define_insn "*vec_concatv4si"
10604   [(set (match_operand:V4SI 0 "register_operand"       "=x,x,x,x,x")
10605         (vec_concat:V4SI
10606           (match_operand:V2SI 1 "register_operand"     " 0,x,0,0,x")
10607           (match_operand:V2SI 2 "nonimmediate_operand" " x,x,x,m,m")))]
10608   "TARGET_SSE"
10609   "@
10610    punpcklqdq\t{%2, %0|%0, %2}
10611    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
10612    movlhps\t{%2, %0|%0, %2}
10613    movhps\t{%2, %0|%0, %q2}
10614    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
10615   [(set_attr "isa" "sse2_noavx,avx,noavx,noavx,avx")
10616    (set_attr "type" "sselog,sselog,ssemov,ssemov,ssemov")
10617    (set_attr "prefix" "orig,vex,orig,orig,vex")
10618    (set_attr "mode" "TI,TI,V4SF,V2SF,V2SF")])
10619
10620 ;; movd instead of movq is required to handle broken assemblers.
10621 (define_insn "vec_concatv2di"
10622   [(set (match_operand:V2DI 0 "register_operand"
10623           "=x,x ,Yi,x ,!x,x,x,x,x,x")
10624         (vec_concat:V2DI
10625           (match_operand:DI 1 "nonimmediate_operand"
10626           " 0,x ,r ,xm,*y,0,x,0,0,x")
10627           (match_operand:DI 2 "vector_move_operand"
10628           "rm,rm,C ,C ,C ,x,x,x,m,m")))]
10629   "TARGET_SSE"
10630   "@
10631    pinsrq\t{$1, %2, %0|%0, %2, 1}
10632    vpinsrq\t{$1, %2, %1, %0|%0, %1, %2, 1}
10633    * return HAVE_AS_IX86_INTERUNIT_MOVQ ? \"%vmovq\t{%1, %0|%0, %1}\" : \"%vmovd\t{%1, %0|%0, %1}\";
10634    %vmovq\t{%1, %0|%0, %1}
10635    movq2dq\t{%1, %0|%0, %1}
10636    punpcklqdq\t{%2, %0|%0, %2}
10637    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
10638    movlhps\t{%2, %0|%0, %2}
10639    movhps\t{%2, %0|%0, %2}
10640    vmovhps\t{%2, %1, %0|%0, %1, %2}"
10641   [(set_attr "isa" "x64_sse4_noavx,x64_avx,x64,sse2,sse2,sse2_noavx,avx,noavx,noavx,avx")
10642    (set (attr "type")
10643      (if_then_else
10644        (eq_attr "alternative" "0,1,5,6")
10645        (const_string "sselog")
10646        (const_string "ssemov")))
10647    (set_attr "prefix_rex" "1,1,1,*,*,*,*,*,*,*")
10648    (set_attr "prefix_extra" "1,1,*,*,*,*,*,*,*,*")
10649    (set_attr "length_immediate" "1,1,*,*,*,*,*,*,*,*")
10650    (set_attr "prefix" "orig,vex,maybe_vex,maybe_vex,orig,orig,vex,orig,orig,vex")
10651    (set_attr "mode" "TI,TI,TI,TI,TI,TI,TI,V4SF,V2SF,V2SF")])
10652
10653 (define_expand "vec_unpacks_lo_<mode>"
10654   [(match_operand:<sseunpackmode> 0 "register_operand")
10655    (match_operand:VI124_AVX512F 1 "register_operand")]
10656   "TARGET_SSE2"
10657   "ix86_expand_sse_unpack (operands[0], operands[1], false, false); DONE;")
10658
10659 (define_expand "vec_unpacks_hi_<mode>"
10660   [(match_operand:<sseunpackmode> 0 "register_operand")
10661    (match_operand:VI124_AVX512F 1 "register_operand")]
10662   "TARGET_SSE2"
10663   "ix86_expand_sse_unpack (operands[0], operands[1], false, true); DONE;")
10664
10665 (define_expand "vec_unpacku_lo_<mode>"
10666   [(match_operand:<sseunpackmode> 0 "register_operand")
10667    (match_operand:VI124_AVX512F 1 "register_operand")]
10668   "TARGET_SSE2"
10669   "ix86_expand_sse_unpack (operands[0], operands[1], true, false); DONE;")
10670
10671 (define_expand "vec_unpacku_hi_<mode>"
10672   [(match_operand:<sseunpackmode> 0 "register_operand")
10673    (match_operand:VI124_AVX512F 1 "register_operand")]
10674   "TARGET_SSE2"
10675   "ix86_expand_sse_unpack (operands[0], operands[1], true, true); DONE;")
10676
10677 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10678 ;;
10679 ;; Miscellaneous
10680 ;;
10681 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10682
10683 (define_expand "<sse2_avx2>_uavg<mode>3"
10684   [(set (match_operand:VI12_AVX2 0 "register_operand")
10685         (truncate:VI12_AVX2
10686           (lshiftrt:<ssedoublemode>
10687             (plus:<ssedoublemode>
10688               (plus:<ssedoublemode>
10689                 (zero_extend:<ssedoublemode>
10690                   (match_operand:VI12_AVX2 1 "nonimmediate_operand"))
10691                 (zero_extend:<ssedoublemode>
10692                   (match_operand:VI12_AVX2 2 "nonimmediate_operand")))
10693               (match_dup 3))
10694             (const_int 1))))]
10695   "TARGET_SSE2"
10696 {
10697   operands[3] = CONST1_RTX(<MODE>mode);
10698   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
10699 })
10700
10701 (define_insn "*<sse2_avx2>_uavg<mode>3"
10702   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,x")
10703         (truncate:VI12_AVX2
10704           (lshiftrt:<ssedoublemode>
10705             (plus:<ssedoublemode>
10706               (plus:<ssedoublemode>
10707                 (zero_extend:<ssedoublemode>
10708                   (match_operand:VI12_AVX2 1 "nonimmediate_operand" "%0,x"))
10709                 (zero_extend:<ssedoublemode>
10710                   (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,xm")))
10711               (match_operand:VI12_AVX2 3 "const1_operand"))
10712             (const_int 1))))]
10713   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
10714   "@
10715    pavg<ssemodesuffix>\t{%2, %0|%0, %2}
10716    vpavg<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10717   [(set_attr "isa" "noavx,avx")
10718    (set_attr "type" "sseiadd")
10719    (set_attr "prefix_data16" "1,*")
10720    (set_attr "prefix" "orig,vex")
10721    (set_attr "mode" "<sseinsnmode>")])
10722
10723 ;; The correct representation for this is absolutely enormous, and
10724 ;; surely not generally useful.
10725 (define_insn "<sse2_avx2>_psadbw"
10726   [(set (match_operand:VI8_AVX2 0 "register_operand" "=x,x")
10727         (unspec:VI8_AVX2
10728           [(match_operand:<ssebytemode> 1 "register_operand" "0,x")
10729            (match_operand:<ssebytemode> 2 "nonimmediate_operand" "xm,xm")]
10730           UNSPEC_PSADBW))]
10731   "TARGET_SSE2"
10732   "@
10733    psadbw\t{%2, %0|%0, %2}
10734    vpsadbw\t{%2, %1, %0|%0, %1, %2}"
10735   [(set_attr "isa" "noavx,avx")
10736    (set_attr "type" "sseiadd")
10737    (set_attr "atom_unit" "simul")
10738    (set_attr "prefix_data16" "1,*")
10739    (set_attr "prefix" "orig,vex")
10740    (set_attr "mode" "<sseinsnmode>")])
10741
10742 (define_insn "<sse>_movmsk<ssemodesuffix><avxsizesuffix>"
10743   [(set (match_operand:SI 0 "register_operand" "=r")
10744         (unspec:SI
10745           [(match_operand:VF_128_256 1 "register_operand" "x")]
10746           UNSPEC_MOVMSK))]
10747   "TARGET_SSE"
10748   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
10749   [(set_attr "type" "ssemov")
10750    (set_attr "prefix" "maybe_vex")
10751    (set_attr "mode" "<MODE>")])
10752
10753 (define_insn "avx2_pmovmskb"
10754   [(set (match_operand:SI 0 "register_operand" "=r")
10755         (unspec:SI [(match_operand:V32QI 1 "register_operand" "x")]
10756                    UNSPEC_MOVMSK))]
10757   "TARGET_AVX2"
10758   "vpmovmskb\t{%1, %0|%0, %1}"
10759   [(set_attr "type" "ssemov")
10760    (set_attr "prefix" "vex")
10761    (set_attr "mode" "DI")])
10762
10763 (define_insn "sse2_pmovmskb"
10764   [(set (match_operand:SI 0 "register_operand" "=r")
10765         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
10766                    UNSPEC_MOVMSK))]
10767   "TARGET_SSE2"
10768   "%vpmovmskb\t{%1, %0|%0, %1}"
10769   [(set_attr "type" "ssemov")
10770    (set_attr "prefix_data16" "1")
10771    (set_attr "prefix" "maybe_vex")
10772    (set_attr "mode" "SI")])
10773
10774 (define_expand "sse2_maskmovdqu"
10775   [(set (match_operand:V16QI 0 "memory_operand")
10776         (unspec:V16QI [(match_operand:V16QI 1 "register_operand")
10777                        (match_operand:V16QI 2 "register_operand")
10778                        (match_dup 0)]
10779                       UNSPEC_MASKMOV))]
10780   "TARGET_SSE2")
10781
10782 (define_insn "*sse2_maskmovdqu"
10783   [(set (mem:V16QI (match_operand:P 0 "register_operand" "D"))
10784         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
10785                        (match_operand:V16QI 2 "register_operand" "x")
10786                        (mem:V16QI (match_dup 0))]
10787                       UNSPEC_MASKMOV))]
10788   "TARGET_SSE2"
10789 {
10790   /* We can't use %^ here due to ASM_OUTPUT_OPCODE processing
10791      that requires %v to be at the beginning of the opcode name.  */
10792   if (Pmode != word_mode)
10793     fputs ("\taddr32", asm_out_file);
10794   return "%vmaskmovdqu\t{%2, %1|%1, %2}";
10795 }
10796   [(set_attr "type" "ssemov")
10797    (set_attr "prefix_data16" "1")
10798    (set (attr "length_address")
10799      (symbol_ref ("Pmode != word_mode")))
10800    ;; The implicit %rdi operand confuses default length_vex computation.
10801    (set (attr "length_vex")
10802      (symbol_ref ("3 + REX_SSE_REGNO_P (REGNO (operands[2]))")))
10803    (set_attr "prefix" "maybe_vex")
10804    (set_attr "mode" "TI")])
10805
10806 (define_insn "sse_ldmxcsr"
10807   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
10808                     UNSPECV_LDMXCSR)]
10809   "TARGET_SSE"
10810   "%vldmxcsr\t%0"
10811   [(set_attr "type" "sse")
10812    (set_attr "atom_sse_attr" "mxcsr")
10813    (set_attr "prefix" "maybe_vex")
10814    (set_attr "memory" "load")])
10815
10816 (define_insn "sse_stmxcsr"
10817   [(set (match_operand:SI 0 "memory_operand" "=m")
10818         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
10819   "TARGET_SSE"
10820   "%vstmxcsr\t%0"
10821   [(set_attr "type" "sse")
10822    (set_attr "atom_sse_attr" "mxcsr")
10823    (set_attr "prefix" "maybe_vex")
10824    (set_attr "memory" "store")])
10825
10826 (define_insn "sse2_clflush"
10827   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
10828                     UNSPECV_CLFLUSH)]
10829   "TARGET_SSE2"
10830   "clflush\t%a0"
10831   [(set_attr "type" "sse")
10832    (set_attr "atom_sse_attr" "fence")
10833    (set_attr "memory" "unknown")])
10834
10835
10836 (define_insn "sse3_mwait"
10837   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
10838                      (match_operand:SI 1 "register_operand" "c")]
10839                     UNSPECV_MWAIT)]
10840   "TARGET_SSE3"
10841 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
10842 ;; Since 32bit register operands are implicitly zero extended to 64bit,
10843 ;; we only need to set up 32bit registers.
10844   "mwait"
10845   [(set_attr "length" "3")])
10846
10847 (define_insn "sse3_monitor_<mode>"
10848   [(unspec_volatile [(match_operand:P 0 "register_operand" "a")
10849                      (match_operand:SI 1 "register_operand" "c")
10850                      (match_operand:SI 2 "register_operand" "d")]
10851                     UNSPECV_MONITOR)]
10852   "TARGET_SSE3"
10853 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
10854 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
10855 ;; zero extended to 64bit, we only need to set up 32bit registers.
10856   "%^monitor"
10857   [(set (attr "length")
10858      (symbol_ref ("(Pmode != word_mode) + 3")))])
10859
10860 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10861 ;;
10862 ;; SSSE3 instructions
10863 ;;
10864 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10865
10866 (define_code_iterator ssse3_plusminus [plus ss_plus minus ss_minus])
10867
10868 (define_insn "avx2_ph<plusminus_mnemonic>wv16hi3"
10869   [(set (match_operand:V16HI 0 "register_operand" "=x")
10870         (vec_concat:V16HI
10871           (vec_concat:V8HI
10872             (vec_concat:V4HI
10873               (vec_concat:V2HI
10874                 (ssse3_plusminus:HI
10875                   (vec_select:HI
10876                     (match_operand:V16HI 1 "register_operand" "x")
10877                     (parallel [(const_int 0)]))
10878                   (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
10879                 (ssse3_plusminus:HI
10880                   (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
10881                   (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
10882               (vec_concat:V2HI
10883                 (ssse3_plusminus:HI
10884                   (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
10885                   (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
10886                 (ssse3_plusminus:HI
10887                   (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
10888                   (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
10889             (vec_concat:V4HI
10890               (vec_concat:V2HI
10891                 (ssse3_plusminus:HI
10892                   (vec_select:HI (match_dup 1) (parallel [(const_int 8)]))
10893                   (vec_select:HI (match_dup 1) (parallel [(const_int 9)])))
10894                 (ssse3_plusminus:HI
10895                   (vec_select:HI (match_dup 1) (parallel [(const_int 10)]))
10896                   (vec_select:HI (match_dup 1) (parallel [(const_int 11)]))))
10897               (vec_concat:V2HI
10898                 (ssse3_plusminus:HI
10899                   (vec_select:HI (match_dup 1) (parallel [(const_int 12)]))
10900                   (vec_select:HI (match_dup 1) (parallel [(const_int 13)])))
10901                 (ssse3_plusminus:HI
10902                   (vec_select:HI (match_dup 1) (parallel [(const_int 14)]))
10903                   (vec_select:HI (match_dup 1) (parallel [(const_int 15)]))))))
10904           (vec_concat:V8HI
10905             (vec_concat:V4HI
10906               (vec_concat:V2HI
10907                 (ssse3_plusminus:HI
10908                   (vec_select:HI
10909                     (match_operand:V16HI 2 "nonimmediate_operand" "xm")
10910                     (parallel [(const_int 0)]))
10911                   (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
10912                 (ssse3_plusminus:HI
10913                   (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
10914                   (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
10915               (vec_concat:V2HI
10916                 (ssse3_plusminus:HI
10917                   (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
10918                   (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
10919                 (ssse3_plusminus:HI
10920                   (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
10921                   (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))
10922             (vec_concat:V4HI
10923               (vec_concat:V2HI
10924                 (ssse3_plusminus:HI
10925                   (vec_select:HI (match_dup 2) (parallel [(const_int 8)]))
10926                   (vec_select:HI (match_dup 2) (parallel [(const_int 9)])))
10927                 (ssse3_plusminus:HI
10928                   (vec_select:HI (match_dup 2) (parallel [(const_int 10)]))
10929                   (vec_select:HI (match_dup 2) (parallel [(const_int 11)]))))
10930               (vec_concat:V2HI
10931                 (ssse3_plusminus:HI
10932                   (vec_select:HI (match_dup 2) (parallel [(const_int 12)]))
10933                   (vec_select:HI (match_dup 2) (parallel [(const_int 13)])))
10934                 (ssse3_plusminus:HI
10935                   (vec_select:HI (match_dup 2) (parallel [(const_int 14)]))
10936                   (vec_select:HI (match_dup 2) (parallel [(const_int 15)]))))))))]
10937   "TARGET_AVX2"
10938   "vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
10939   [(set_attr "type" "sseiadd")
10940    (set_attr "prefix_extra" "1")
10941    (set_attr "prefix" "vex")
10942    (set_attr "mode" "OI")])
10943
10944 (define_insn "ssse3_ph<plusminus_mnemonic>wv8hi3"
10945   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
10946         (vec_concat:V8HI
10947           (vec_concat:V4HI
10948             (vec_concat:V2HI
10949               (ssse3_plusminus:HI
10950                 (vec_select:HI
10951                   (match_operand:V8HI 1 "register_operand" "0,x")
10952                   (parallel [(const_int 0)]))
10953                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
10954               (ssse3_plusminus:HI
10955                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
10956                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
10957             (vec_concat:V2HI
10958               (ssse3_plusminus:HI
10959                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
10960                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
10961               (ssse3_plusminus:HI
10962                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
10963                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
10964           (vec_concat:V4HI
10965             (vec_concat:V2HI
10966               (ssse3_plusminus:HI
10967                 (vec_select:HI
10968                   (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
10969                   (parallel [(const_int 0)]))
10970                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
10971               (ssse3_plusminus:HI
10972                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
10973                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
10974             (vec_concat:V2HI
10975               (ssse3_plusminus:HI
10976                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
10977                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
10978               (ssse3_plusminus:HI
10979                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
10980                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
10981   "TARGET_SSSE3"
10982   "@
10983    ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}
10984    vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
10985   [(set_attr "isa" "noavx,avx")
10986    (set_attr "type" "sseiadd")
10987    (set_attr "atom_unit" "complex")
10988    (set_attr "prefix_data16" "1,*")
10989    (set_attr "prefix_extra" "1")
10990    (set_attr "prefix" "orig,vex")
10991    (set_attr "mode" "TI")])
10992
10993 (define_insn "ssse3_ph<plusminus_mnemonic>wv4hi3"
10994   [(set (match_operand:V4HI 0 "register_operand" "=y")
10995         (vec_concat:V4HI
10996           (vec_concat:V2HI
10997             (ssse3_plusminus:HI
10998               (vec_select:HI
10999                 (match_operand:V4HI 1 "register_operand" "0")
11000                 (parallel [(const_int 0)]))
11001               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
11002             (ssse3_plusminus:HI
11003               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
11004               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
11005           (vec_concat:V2HI
11006             (ssse3_plusminus:HI
11007               (vec_select:HI
11008                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
11009                 (parallel [(const_int 0)]))
11010               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
11011             (ssse3_plusminus:HI
11012               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
11013               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
11014   "TARGET_SSSE3"
11015   "ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}"
11016   [(set_attr "type" "sseiadd")
11017    (set_attr "atom_unit" "complex")
11018    (set_attr "prefix_extra" "1")
11019    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11020    (set_attr "mode" "DI")])
11021
11022 (define_insn "avx2_ph<plusminus_mnemonic>dv8si3"
11023   [(set (match_operand:V8SI 0 "register_operand" "=x")
11024         (vec_concat:V8SI
11025           (vec_concat:V4SI
11026             (vec_concat:V2SI
11027               (plusminus:SI
11028                 (vec_select:SI
11029                   (match_operand:V8SI 1 "register_operand" "x")
11030                   (parallel [(const_int 0)]))
11031                 (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
11032               (plusminus:SI
11033                 (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
11034                 (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
11035             (vec_concat:V2SI
11036               (plusminus:SI
11037                 (vec_select:SI (match_dup 1) (parallel [(const_int 4)]))
11038                 (vec_select:SI (match_dup 1) (parallel [(const_int 5)])))
11039               (plusminus:SI
11040                 (vec_select:SI (match_dup 1) (parallel [(const_int 6)]))
11041                 (vec_select:SI (match_dup 1) (parallel [(const_int 7)])))))
11042           (vec_concat:V4SI
11043             (vec_concat:V2SI
11044               (plusminus:SI
11045                 (vec_select:SI
11046                   (match_operand:V8SI 2 "nonimmediate_operand" "xm")
11047                   (parallel [(const_int 0)]))
11048                 (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
11049               (plusminus:SI
11050                 (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
11051                 (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))
11052             (vec_concat:V2SI
11053               (plusminus:SI
11054                 (vec_select:SI (match_dup 2) (parallel [(const_int 4)]))
11055                 (vec_select:SI (match_dup 2) (parallel [(const_int 5)])))
11056               (plusminus:SI
11057                 (vec_select:SI (match_dup 2) (parallel [(const_int 6)]))
11058                 (vec_select:SI (match_dup 2) (parallel [(const_int 7)])))))))]
11059   "TARGET_AVX2"
11060   "vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
11061   [(set_attr "type" "sseiadd")
11062    (set_attr "prefix_extra" "1")
11063    (set_attr "prefix" "vex")
11064    (set_attr "mode" "OI")])
11065
11066 (define_insn "ssse3_ph<plusminus_mnemonic>dv4si3"
11067   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
11068         (vec_concat:V4SI
11069           (vec_concat:V2SI
11070             (plusminus:SI
11071               (vec_select:SI
11072                 (match_operand:V4SI 1 "register_operand" "0,x")
11073                 (parallel [(const_int 0)]))
11074               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
11075             (plusminus:SI
11076               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
11077               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
11078           (vec_concat:V2SI
11079             (plusminus:SI
11080               (vec_select:SI
11081                 (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
11082                 (parallel [(const_int 0)]))
11083               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
11084             (plusminus:SI
11085               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
11086               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
11087   "TARGET_SSSE3"
11088   "@
11089    ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}
11090    vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
11091   [(set_attr "isa" "noavx,avx")
11092    (set_attr "type" "sseiadd")
11093    (set_attr "atom_unit" "complex")
11094    (set_attr "prefix_data16" "1,*")
11095    (set_attr "prefix_extra" "1")
11096    (set_attr "prefix" "orig,vex")
11097    (set_attr "mode" "TI")])
11098
11099 (define_insn "ssse3_ph<plusminus_mnemonic>dv2si3"
11100   [(set (match_operand:V2SI 0 "register_operand" "=y")
11101         (vec_concat:V2SI
11102           (plusminus:SI
11103             (vec_select:SI
11104               (match_operand:V2SI 1 "register_operand" "0")
11105               (parallel [(const_int 0)]))
11106             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
11107           (plusminus:SI
11108             (vec_select:SI
11109               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
11110               (parallel [(const_int 0)]))
11111             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
11112   "TARGET_SSSE3"
11113   "ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}"
11114   [(set_attr "type" "sseiadd")
11115    (set_attr "atom_unit" "complex")
11116    (set_attr "prefix_extra" "1")
11117    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11118    (set_attr "mode" "DI")])
11119
11120 (define_insn "avx2_pmaddubsw256"
11121   [(set (match_operand:V16HI 0 "register_operand" "=x")
11122         (ss_plus:V16HI
11123           (mult:V16HI
11124             (zero_extend:V16HI
11125               (vec_select:V16QI
11126                 (match_operand:V32QI 1 "register_operand" "x")
11127                 (parallel [(const_int 0) (const_int 2)
11128                            (const_int 4) (const_int 6)
11129                            (const_int 8) (const_int 10)
11130                            (const_int 12) (const_int 14)
11131                            (const_int 16) (const_int 18)
11132                            (const_int 20) (const_int 22)
11133                            (const_int 24) (const_int 26)
11134                            (const_int 28) (const_int 30)])))
11135             (sign_extend:V16HI
11136               (vec_select:V16QI
11137                 (match_operand:V32QI 2 "nonimmediate_operand" "xm")
11138                 (parallel [(const_int 0) (const_int 2)
11139                            (const_int 4) (const_int 6)
11140                            (const_int 8) (const_int 10)
11141                            (const_int 12) (const_int 14)
11142                            (const_int 16) (const_int 18)
11143                            (const_int 20) (const_int 22)
11144                            (const_int 24) (const_int 26)
11145                            (const_int 28) (const_int 30)]))))
11146           (mult:V16HI
11147             (zero_extend:V16HI
11148               (vec_select:V16QI (match_dup 1)
11149                 (parallel [(const_int 1) (const_int 3)
11150                            (const_int 5) (const_int 7)
11151                            (const_int 9) (const_int 11)
11152                            (const_int 13) (const_int 15)
11153                            (const_int 17) (const_int 19)
11154                            (const_int 21) (const_int 23)
11155                            (const_int 25) (const_int 27)
11156                            (const_int 29) (const_int 31)])))
11157             (sign_extend:V16HI
11158               (vec_select:V16QI (match_dup 2)
11159                 (parallel [(const_int 1) (const_int 3)
11160                            (const_int 5) (const_int 7)
11161                            (const_int 9) (const_int 11)
11162                            (const_int 13) (const_int 15)
11163                            (const_int 17) (const_int 19)
11164                            (const_int 21) (const_int 23)
11165                            (const_int 25) (const_int 27)
11166                            (const_int 29) (const_int 31)]))))))]
11167   "TARGET_AVX2"
11168   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
11169   [(set_attr "type" "sseiadd")
11170    (set_attr "prefix_extra" "1")
11171    (set_attr "prefix" "vex")
11172    (set_attr "mode" "OI")])
11173
11174 (define_insn "ssse3_pmaddubsw128"
11175   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11176         (ss_plus:V8HI
11177           (mult:V8HI
11178             (zero_extend:V8HI
11179               (vec_select:V8QI
11180                 (match_operand:V16QI 1 "register_operand" "0,x")
11181                 (parallel [(const_int 0) (const_int 2)
11182                            (const_int 4) (const_int 6)
11183                            (const_int 8) (const_int 10)
11184                            (const_int 12) (const_int 14)])))
11185             (sign_extend:V8HI
11186               (vec_select:V8QI
11187                 (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")
11188                 (parallel [(const_int 0) (const_int 2)
11189                            (const_int 4) (const_int 6)
11190                            (const_int 8) (const_int 10)
11191                            (const_int 12) (const_int 14)]))))
11192           (mult:V8HI
11193             (zero_extend:V8HI
11194               (vec_select:V8QI (match_dup 1)
11195                 (parallel [(const_int 1) (const_int 3)
11196                            (const_int 5) (const_int 7)
11197                            (const_int 9) (const_int 11)
11198                            (const_int 13) (const_int 15)])))
11199             (sign_extend:V8HI
11200               (vec_select:V8QI (match_dup 2)
11201                 (parallel [(const_int 1) (const_int 3)
11202                            (const_int 5) (const_int 7)
11203                            (const_int 9) (const_int 11)
11204                            (const_int 13) (const_int 15)]))))))]
11205   "TARGET_SSSE3"
11206   "@
11207    pmaddubsw\t{%2, %0|%0, %2}
11208    vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
11209   [(set_attr "isa" "noavx,avx")
11210    (set_attr "type" "sseiadd")
11211    (set_attr "atom_unit" "simul")
11212    (set_attr "prefix_data16" "1,*")
11213    (set_attr "prefix_extra" "1")
11214    (set_attr "prefix" "orig,vex")
11215    (set_attr "mode" "TI")])
11216
11217 (define_insn "ssse3_pmaddubsw"
11218   [(set (match_operand:V4HI 0 "register_operand" "=y")
11219         (ss_plus:V4HI
11220           (mult:V4HI
11221             (zero_extend:V4HI
11222               (vec_select:V4QI
11223                 (match_operand:V8QI 1 "register_operand" "0")
11224                 (parallel [(const_int 0) (const_int 2)
11225                            (const_int 4) (const_int 6)])))
11226             (sign_extend:V4HI
11227               (vec_select:V4QI
11228                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
11229                 (parallel [(const_int 0) (const_int 2)
11230                            (const_int 4) (const_int 6)]))))
11231           (mult:V4HI
11232             (zero_extend:V4HI
11233               (vec_select:V4QI (match_dup 1)
11234                 (parallel [(const_int 1) (const_int 3)
11235                            (const_int 5) (const_int 7)])))
11236             (sign_extend:V4HI
11237               (vec_select:V4QI (match_dup 2)
11238                 (parallel [(const_int 1) (const_int 3)
11239                            (const_int 5) (const_int 7)]))))))]
11240   "TARGET_SSSE3"
11241   "pmaddubsw\t{%2, %0|%0, %2}"
11242   [(set_attr "type" "sseiadd")
11243    (set_attr "atom_unit" "simul")
11244    (set_attr "prefix_extra" "1")
11245    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11246    (set_attr "mode" "DI")])
11247
11248 (define_mode_iterator PMULHRSW
11249   [V4HI V8HI (V16HI "TARGET_AVX2")])
11250
11251 (define_expand "<ssse3_avx2>_pmulhrsw<mode>3"
11252   [(set (match_operand:PMULHRSW 0 "register_operand")
11253         (truncate:PMULHRSW
11254           (lshiftrt:<ssedoublemode>
11255             (plus:<ssedoublemode>
11256               (lshiftrt:<ssedoublemode>
11257                 (mult:<ssedoublemode>
11258                   (sign_extend:<ssedoublemode>
11259                     (match_operand:PMULHRSW 1 "nonimmediate_operand"))
11260                   (sign_extend:<ssedoublemode>
11261                     (match_operand:PMULHRSW 2 "nonimmediate_operand")))
11262                 (const_int 14))
11263               (match_dup 3))
11264             (const_int 1))))]
11265   "TARGET_AVX2"
11266 {
11267   operands[3] = CONST1_RTX(<MODE>mode);
11268   ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
11269 })
11270
11271 (define_insn "*<ssse3_avx2>_pmulhrsw<mode>3"
11272   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
11273         (truncate:VI2_AVX2
11274           (lshiftrt:<ssedoublemode>
11275             (plus:<ssedoublemode>
11276               (lshiftrt:<ssedoublemode>
11277                 (mult:<ssedoublemode>
11278                   (sign_extend:<ssedoublemode>
11279                     (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
11280                   (sign_extend:<ssedoublemode>
11281                     (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
11282                 (const_int 14))
11283               (match_operand:VI2_AVX2 3 "const1_operand"))
11284             (const_int 1))))]
11285   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
11286   "@
11287    pmulhrsw\t{%2, %0|%0, %2}
11288    vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
11289   [(set_attr "isa" "noavx,avx")
11290    (set_attr "type" "sseimul")
11291    (set_attr "prefix_data16" "1,*")
11292    (set_attr "prefix_extra" "1")
11293    (set_attr "prefix" "orig,vex")
11294    (set_attr "mode" "<sseinsnmode>")])
11295
11296 (define_insn "*ssse3_pmulhrswv4hi3"
11297   [(set (match_operand:V4HI 0 "register_operand" "=y")
11298         (truncate:V4HI
11299           (lshiftrt:V4SI
11300             (plus:V4SI
11301               (lshiftrt:V4SI
11302                 (mult:V4SI
11303                   (sign_extend:V4SI
11304                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
11305                   (sign_extend:V4SI
11306                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
11307                 (const_int 14))
11308               (match_operand:V4HI 3 "const1_operand"))
11309             (const_int 1))))]
11310   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
11311   "pmulhrsw\t{%2, %0|%0, %2}"
11312   [(set_attr "type" "sseimul")
11313    (set_attr "prefix_extra" "1")
11314    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11315    (set_attr "mode" "DI")])
11316
11317 (define_insn "<ssse3_avx2>_pshufb<mode>3"
11318   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11319         (unspec:VI1_AVX2
11320           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
11321            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")]
11322           UNSPEC_PSHUFB))]
11323   "TARGET_SSSE3"
11324   "@
11325    pshufb\t{%2, %0|%0, %2}
11326    vpshufb\t{%2, %1, %0|%0, %1, %2}"
11327   [(set_attr "isa" "noavx,avx")
11328    (set_attr "type" "sselog1")
11329    (set_attr "prefix_data16" "1,*")
11330    (set_attr "prefix_extra" "1")
11331    (set_attr "prefix" "orig,vex")
11332    (set_attr "btver2_decode" "vector,vector")
11333    (set_attr "mode" "<sseinsnmode>")])
11334
11335 (define_insn "ssse3_pshufbv8qi3"
11336   [(set (match_operand:V8QI 0 "register_operand" "=y")
11337         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
11338                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
11339                      UNSPEC_PSHUFB))]
11340   "TARGET_SSSE3"
11341   "pshufb\t{%2, %0|%0, %2}";
11342   [(set_attr "type" "sselog1")
11343    (set_attr "prefix_extra" "1")
11344    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11345    (set_attr "mode" "DI")])
11346
11347 (define_insn "<ssse3_avx2>_psign<mode>3"
11348   [(set (match_operand:VI124_AVX2 0 "register_operand" "=x,x")
11349         (unspec:VI124_AVX2
11350           [(match_operand:VI124_AVX2 1 "register_operand" "0,x")
11351            (match_operand:VI124_AVX2 2 "nonimmediate_operand" "xm,xm")]
11352           UNSPEC_PSIGN))]
11353   "TARGET_SSSE3"
11354   "@
11355    psign<ssemodesuffix>\t{%2, %0|%0, %2}
11356    vpsign<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11357   [(set_attr "isa" "noavx,avx")
11358    (set_attr "type" "sselog1")
11359    (set_attr "prefix_data16" "1,*")
11360    (set_attr "prefix_extra" "1")
11361    (set_attr "prefix" "orig,vex")
11362    (set_attr "mode" "<sseinsnmode>")])
11363
11364 (define_insn "ssse3_psign<mode>3"
11365   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
11366         (unspec:MMXMODEI
11367           [(match_operand:MMXMODEI 1 "register_operand" "0")
11368            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
11369           UNSPEC_PSIGN))]
11370   "TARGET_SSSE3"
11371   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
11372   [(set_attr "type" "sselog1")
11373    (set_attr "prefix_extra" "1")
11374    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11375    (set_attr "mode" "DI")])
11376
11377 (define_insn "<ssse3_avx2>_palignr<mode>"
11378   [(set (match_operand:SSESCALARMODE 0 "register_operand" "=x,x")
11379         (unspec:SSESCALARMODE
11380           [(match_operand:SSESCALARMODE 1 "register_operand" "0,x")
11381            (match_operand:SSESCALARMODE 2 "nonimmediate_operand" "xm,xm")
11382            (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n,n")]
11383           UNSPEC_PALIGNR))]
11384   "TARGET_SSSE3"
11385 {
11386   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
11387
11388   switch (which_alternative)
11389     {
11390     case 0:
11391       return "palignr\t{%3, %2, %0|%0, %2, %3}";
11392     case 1:
11393       return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
11394     default:
11395       gcc_unreachable ();
11396     }
11397 }
11398   [(set_attr "isa" "noavx,avx")
11399    (set_attr "type" "sseishft")
11400    (set_attr "atom_unit" "sishuf")
11401    (set_attr "prefix_data16" "1,*")
11402    (set_attr "prefix_extra" "1")
11403    (set_attr "length_immediate" "1")
11404    (set_attr "prefix" "orig,vex")
11405    (set_attr "mode" "<sseinsnmode>")])
11406
11407 (define_insn "ssse3_palignrdi"
11408   [(set (match_operand:DI 0 "register_operand" "=y")
11409         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
11410                     (match_operand:DI 2 "nonimmediate_operand" "ym")
11411                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
11412                    UNSPEC_PALIGNR))]
11413   "TARGET_SSSE3"
11414 {
11415   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
11416   return "palignr\t{%3, %2, %0|%0, %2, %3}";
11417 }
11418   [(set_attr "type" "sseishft")
11419    (set_attr "atom_unit" "sishuf")
11420    (set_attr "prefix_extra" "1")
11421    (set_attr "length_immediate" "1")
11422    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11423    (set_attr "mode" "DI")])
11424
11425 (define_insn "<mask_codefor>abs<mode>2<mask_name>"
11426   [(set (match_operand:VI124_AVX2_48_AVX512F 0 "register_operand" "=v")
11427         (abs:VI124_AVX2_48_AVX512F
11428           (match_operand:VI124_AVX2_48_AVX512F 1 "nonimmediate_operand" "vm")))]
11429   "TARGET_SSSE3 && <mask_mode512bit_condition>"
11430   "%vpabs<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11431   [(set_attr "type" "sselog1")
11432    (set_attr "prefix_data16" "1")
11433    (set_attr "prefix_extra" "1")
11434    (set_attr "prefix" "maybe_vex")
11435    (set_attr "mode" "<sseinsnmode>")])
11436
11437 (define_expand "abs<mode>2"
11438   [(set (match_operand:VI124_AVX2_48_AVX512F 0 "register_operand")
11439         (abs:VI124_AVX2_48_AVX512F
11440           (match_operand:VI124_AVX2_48_AVX512F 1 "nonimmediate_operand")))]
11441   "TARGET_SSE2"
11442 {
11443   if (!TARGET_SSSE3)
11444     {
11445       ix86_expand_sse2_abs (operands[0], operands[1]);
11446       DONE;
11447     }
11448 })
11449
11450 (define_insn "abs<mode>2"
11451   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
11452         (abs:MMXMODEI
11453           (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
11454   "TARGET_SSSE3"
11455   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
11456   [(set_attr "type" "sselog1")
11457    (set_attr "prefix_rep" "0")
11458    (set_attr "prefix_extra" "1")
11459    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11460    (set_attr "mode" "DI")])
11461
11462 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11463 ;;
11464 ;; AMD SSE4A instructions
11465 ;;
11466 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11467
11468 (define_insn "sse4a_movnt<mode>"
11469   [(set (match_operand:MODEF 0 "memory_operand" "=m")
11470         (unspec:MODEF
11471           [(match_operand:MODEF 1 "register_operand" "x")]
11472           UNSPEC_MOVNT))]
11473   "TARGET_SSE4A"
11474   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
11475   [(set_attr "type" "ssemov")
11476    (set_attr "mode" "<MODE>")])
11477
11478 (define_insn "sse4a_vmmovnt<mode>"
11479   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
11480         (unspec:<ssescalarmode>
11481           [(vec_select:<ssescalarmode>
11482              (match_operand:VF_128 1 "register_operand" "x")
11483              (parallel [(const_int 0)]))]
11484           UNSPEC_MOVNT))]
11485   "TARGET_SSE4A"
11486   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
11487   [(set_attr "type" "ssemov")
11488    (set_attr "mode" "<ssescalarmode>")])
11489
11490 (define_insn "sse4a_extrqi"
11491   [(set (match_operand:V2DI 0 "register_operand" "=x")
11492         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11493                       (match_operand 2 "const_0_to_255_operand")
11494                       (match_operand 3 "const_0_to_255_operand")]
11495                      UNSPEC_EXTRQI))]
11496   "TARGET_SSE4A"
11497   "extrq\t{%3, %2, %0|%0, %2, %3}"
11498   [(set_attr "type" "sse")
11499    (set_attr "prefix_data16" "1")
11500    (set_attr "length_immediate" "2")
11501    (set_attr "mode" "TI")])
11502
11503 (define_insn "sse4a_extrq"
11504   [(set (match_operand:V2DI 0 "register_operand" "=x")
11505         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11506                       (match_operand:V16QI 2 "register_operand" "x")]
11507                      UNSPEC_EXTRQ))]
11508   "TARGET_SSE4A"
11509   "extrq\t{%2, %0|%0, %2}"
11510   [(set_attr "type" "sse")
11511    (set_attr "prefix_data16" "1")
11512    (set_attr "mode" "TI")])
11513
11514 (define_insn "sse4a_insertqi"
11515   [(set (match_operand:V2DI 0 "register_operand" "=x")
11516         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11517                       (match_operand:V2DI 2 "register_operand" "x")
11518                       (match_operand 3 "const_0_to_255_operand")
11519                       (match_operand 4 "const_0_to_255_operand")]
11520                      UNSPEC_INSERTQI))]
11521   "TARGET_SSE4A"
11522   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
11523   [(set_attr "type" "sseins")
11524    (set_attr "prefix_data16" "0")
11525    (set_attr "prefix_rep" "1")
11526    (set_attr "length_immediate" "2")
11527    (set_attr "mode" "TI")])
11528
11529 (define_insn "sse4a_insertq"
11530   [(set (match_operand:V2DI 0 "register_operand" "=x")
11531         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11532                       (match_operand:V2DI 2 "register_operand" "x")]
11533                      UNSPEC_INSERTQ))]
11534   "TARGET_SSE4A"
11535   "insertq\t{%2, %0|%0, %2}"
11536   [(set_attr "type" "sseins")
11537    (set_attr "prefix_data16" "0")
11538    (set_attr "prefix_rep" "1")
11539    (set_attr "mode" "TI")])
11540
11541 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11542 ;;
11543 ;; Intel SSE4.1 instructions
11544 ;;
11545 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11546
11547 (define_insn "<sse4_1>_blend<ssemodesuffix><avxsizesuffix>"
11548   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11549         (vec_merge:VF_128_256
11550           (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11551           (match_operand:VF_128_256 1 "register_operand" "0,x")
11552           (match_operand:SI 3 "const_0_to_<blendbits>_operand")))]
11553   "TARGET_SSE4_1"
11554   "@
11555    blend<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11556    vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11557   [(set_attr "isa" "noavx,avx")
11558    (set_attr "type" "ssemov")
11559    (set_attr "length_immediate" "1")
11560    (set_attr "prefix_data16" "1,*")
11561    (set_attr "prefix_extra" "1")
11562    (set_attr "prefix" "orig,vex")
11563    (set_attr "mode" "<MODE>")])
11564
11565 (define_insn "<sse4_1>_blendv<ssemodesuffix><avxsizesuffix>"
11566   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11567         (unspec:VF_128_256
11568           [(match_operand:VF_128_256 1 "register_operand" "0,x")
11569            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11570            (match_operand:VF_128_256 3 "register_operand" "Yz,x")]
11571           UNSPEC_BLENDV))]
11572   "TARGET_SSE4_1"
11573   "@
11574    blendv<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11575    vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11576   [(set_attr "isa" "noavx,avx")
11577    (set_attr "type" "ssemov")
11578    (set_attr "length_immediate" "1")
11579    (set_attr "prefix_data16" "1,*")
11580    (set_attr "prefix_extra" "1")
11581    (set_attr "prefix" "orig,vex")
11582    (set_attr "btver2_decode" "vector,vector")
11583    (set_attr "mode" "<MODE>")])
11584
11585 (define_insn "<sse4_1>_dp<ssemodesuffix><avxsizesuffix>"
11586   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11587         (unspec:VF_128_256
11588           [(match_operand:VF_128_256 1 "nonimmediate_operand" "%0,x")
11589            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11590            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
11591           UNSPEC_DP))]
11592   "TARGET_SSE4_1"
11593   "@
11594    dp<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11595    vdp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11596   [(set_attr "isa" "noavx,avx")
11597    (set_attr "type" "ssemul")
11598    (set_attr "length_immediate" "1")
11599    (set_attr "prefix_data16" "1,*")
11600    (set_attr "prefix_extra" "1")
11601    (set_attr "prefix" "orig,vex")
11602    (set_attr "btver2_decode" "vector,vector")
11603    (set_attr "mode" "<MODE>")])
11604
11605 (define_insn "<sse4_1_avx2>_movntdqa"
11606   [(set (match_operand:VI8_AVX2_AVX512F 0 "register_operand" "=x, v")
11607         (unspec:VI8_AVX2_AVX512F [(match_operand:VI8_AVX2_AVX512F 1 "memory_operand" "m, m")]
11608                      UNSPEC_MOVNTDQA))]
11609   "TARGET_SSE4_1"
11610   "%vmovntdqa\t{%1, %0|%0, %1}"
11611   [(set_attr "type" "ssemov")
11612    (set_attr "prefix_extra" "1, *")
11613    (set_attr "prefix" "maybe_vex, evex")
11614    (set_attr "mode" "<sseinsnmode>")])
11615
11616 (define_insn "<sse4_1_avx2>_mpsadbw"
11617   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11618         (unspec:VI1_AVX2
11619           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
11620            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
11621            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
11622           UNSPEC_MPSADBW))]
11623   "TARGET_SSE4_1"
11624   "@
11625    mpsadbw\t{%3, %2, %0|%0, %2, %3}
11626    vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11627   [(set_attr "isa" "noavx,avx")
11628    (set_attr "type" "sselog1")
11629    (set_attr "length_immediate" "1")
11630    (set_attr "prefix_extra" "1")
11631    (set_attr "prefix" "orig,vex")
11632    (set_attr "btver2_decode" "vector,vector")
11633    (set_attr "mode" "<sseinsnmode>")])
11634
11635 (define_insn "avx2_packusdw"
11636   [(set (match_operand:V16HI 0 "register_operand" "=x")
11637         (vec_concat:V16HI
11638           (us_truncate:V8HI
11639             (match_operand:V8SI 1 "register_operand" "x"))
11640           (us_truncate:V8HI
11641             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))))]
11642   "TARGET_AVX2"
11643   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
11644   [(set_attr "type" "sselog")
11645    (set_attr "prefix_extra" "1")
11646    (set_attr "prefix" "vex")
11647    (set_attr "mode" "OI")])
11648
11649 (define_insn "sse4_1_packusdw"
11650   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11651         (vec_concat:V8HI
11652           (us_truncate:V4HI
11653             (match_operand:V4SI 1 "register_operand" "0,x"))
11654           (us_truncate:V4HI
11655             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))))]
11656   "TARGET_SSE4_1"
11657   "@
11658    packusdw\t{%2, %0|%0, %2}
11659    vpackusdw\t{%2, %1, %0|%0, %1, %2}"
11660   [(set_attr "isa" "noavx,avx")
11661    (set_attr "type" "sselog")
11662    (set_attr "prefix_extra" "1")
11663    (set_attr "prefix" "orig,vex")
11664    (set_attr "mode" "TI")])
11665
11666 (define_insn "<sse4_1_avx2>_pblendvb"
11667   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11668         (unspec:VI1_AVX2
11669           [(match_operand:VI1_AVX2 1 "register_operand"  "0,x")
11670            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
11671            (match_operand:VI1_AVX2 3 "register_operand" "Yz,x")]
11672           UNSPEC_BLENDV))]
11673   "TARGET_SSE4_1"
11674   "@
11675    pblendvb\t{%3, %2, %0|%0, %2, %3}
11676    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11677   [(set_attr "isa" "noavx,avx")
11678    (set_attr "type" "ssemov")
11679    (set_attr "prefix_extra" "1")
11680    (set_attr "length_immediate" "*,1")
11681    (set_attr "prefix" "orig,vex")
11682    (set_attr "btver2_decode" "vector,vector")
11683    (set_attr "mode" "<sseinsnmode>")])
11684
11685 (define_insn "sse4_1_pblendw"
11686   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11687         (vec_merge:V8HI
11688           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
11689           (match_operand:V8HI 1 "register_operand" "0,x")
11690           (match_operand:SI 3 "const_0_to_255_operand" "n,n")))]
11691   "TARGET_SSE4_1"
11692   "@
11693    pblendw\t{%3, %2, %0|%0, %2, %3}
11694    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11695   [(set_attr "isa" "noavx,avx")
11696    (set_attr "type" "ssemov")
11697    (set_attr "prefix_extra" "1")
11698    (set_attr "length_immediate" "1")
11699    (set_attr "prefix" "orig,vex")
11700    (set_attr "mode" "TI")])
11701
11702 ;; The builtin uses an 8-bit immediate.  Expand that.
11703 (define_expand "avx2_pblendw"
11704   [(set (match_operand:V16HI 0 "register_operand")
11705         (vec_merge:V16HI
11706           (match_operand:V16HI 2 "nonimmediate_operand")
11707           (match_operand:V16HI 1 "register_operand")
11708           (match_operand:SI 3 "const_0_to_255_operand")))]
11709   "TARGET_AVX2"
11710 {
11711   HOST_WIDE_INT val = INTVAL (operands[3]) & 0xff;
11712   operands[3] = GEN_INT (val << 8 | val);
11713 })
11714
11715 (define_insn "*avx2_pblendw"
11716   [(set (match_operand:V16HI 0 "register_operand" "=x")
11717         (vec_merge:V16HI
11718           (match_operand:V16HI 2 "nonimmediate_operand" "xm")
11719           (match_operand:V16HI 1 "register_operand" "x")
11720           (match_operand:SI 3 "avx2_pblendw_operand" "n")))]
11721   "TARGET_AVX2"
11722 {
11723   operands[3] = GEN_INT (INTVAL (operands[3]) & 0xff);
11724   return "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
11725 }
11726   [(set_attr "type" "ssemov")
11727    (set_attr "prefix_extra" "1")
11728    (set_attr "length_immediate" "1")
11729    (set_attr "prefix" "vex")
11730    (set_attr "mode" "OI")])
11731
11732 (define_insn "avx2_pblendd<mode>"
11733   [(set (match_operand:VI4_AVX2 0 "register_operand" "=x")
11734         (vec_merge:VI4_AVX2
11735           (match_operand:VI4_AVX2 2 "nonimmediate_operand" "xm")
11736           (match_operand:VI4_AVX2 1 "register_operand" "x")
11737           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
11738   "TARGET_AVX2"
11739   "vpblendd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11740   [(set_attr "type" "ssemov")
11741    (set_attr "prefix_extra" "1")
11742    (set_attr "length_immediate" "1")
11743    (set_attr "prefix" "vex")
11744    (set_attr "mode" "<sseinsnmode>")])
11745
11746 (define_insn "sse4_1_phminposuw"
11747   [(set (match_operand:V8HI 0 "register_operand" "=x")
11748         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
11749                      UNSPEC_PHMINPOSUW))]
11750   "TARGET_SSE4_1"
11751   "%vphminposuw\t{%1, %0|%0, %1}"
11752   [(set_attr "type" "sselog1")
11753    (set_attr "prefix_extra" "1")
11754    (set_attr "prefix" "maybe_vex")
11755    (set_attr "mode" "TI")])
11756
11757 (define_insn "avx2_<code>v16qiv16hi2"
11758   [(set (match_operand:V16HI 0 "register_operand" "=x")
11759         (any_extend:V16HI
11760           (match_operand:V16QI 1 "nonimmediate_operand" "xm")))]
11761   "TARGET_AVX2"
11762   "vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
11763   [(set_attr "type" "ssemov")
11764    (set_attr "prefix_extra" "1")
11765    (set_attr "prefix" "vex")
11766    (set_attr "mode" "OI")])
11767
11768 (define_insn "sse4_1_<code>v8qiv8hi2"
11769   [(set (match_operand:V8HI 0 "register_operand" "=x")
11770         (any_extend:V8HI
11771           (vec_select:V8QI
11772             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11773             (parallel [(const_int 0) (const_int 1)
11774                        (const_int 2) (const_int 3)
11775                        (const_int 4) (const_int 5)
11776                        (const_int 6) (const_int 7)]))))]
11777   "TARGET_SSE4_1"
11778   "%vpmov<extsuffix>bw\t{%1, %0|%0, %q1}"
11779   [(set_attr "type" "ssemov")
11780    (set_attr "ssememalign" "64")
11781    (set_attr "prefix_extra" "1")
11782    (set_attr "prefix" "maybe_vex")
11783    (set_attr "mode" "TI")])
11784
11785 (define_insn "<mask_codefor>avx512f_<code>v16qiv16si2<mask_name>"
11786   [(set (match_operand:V16SI 0 "register_operand" "=v")
11787         (any_extend:V16SI
11788           (match_operand:V16QI 1 "nonimmediate_operand" "vm")))]
11789   "TARGET_AVX512F"
11790   "vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %q1}"
11791   [(set_attr "type" "ssemov")
11792    (set_attr "prefix" "evex")
11793    (set_attr "mode" "XI")])
11794
11795 (define_insn "avx2_<code>v8qiv8si2"
11796   [(set (match_operand:V8SI 0 "register_operand" "=x")
11797         (any_extend:V8SI
11798           (vec_select:V8QI
11799             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11800             (parallel [(const_int 0) (const_int 1)
11801                        (const_int 2) (const_int 3)
11802                        (const_int 4) (const_int 5)
11803                        (const_int 6) (const_int 7)]))))]
11804   "TARGET_AVX2"
11805   "vpmov<extsuffix>bd\t{%1, %0|%0, %q1}"
11806   [(set_attr "type" "ssemov")
11807    (set_attr "prefix_extra" "1")
11808    (set_attr "prefix" "vex")
11809    (set_attr "mode" "OI")])
11810
11811 (define_insn "sse4_1_<code>v4qiv4si2"
11812   [(set (match_operand:V4SI 0 "register_operand" "=x")
11813         (any_extend:V4SI
11814           (vec_select:V4QI
11815             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11816             (parallel [(const_int 0) (const_int 1)
11817                        (const_int 2) (const_int 3)]))))]
11818   "TARGET_SSE4_1"
11819   "%vpmov<extsuffix>bd\t{%1, %0|%0, %k1}"
11820   [(set_attr "type" "ssemov")
11821    (set_attr "ssememalign" "32")
11822    (set_attr "prefix_extra" "1")
11823    (set_attr "prefix" "maybe_vex")
11824    (set_attr "mode" "TI")])
11825
11826 (define_insn "avx512f_<code>v16hiv16si2<mask_name>"
11827   [(set (match_operand:V16SI 0 "register_operand" "=v")
11828         (any_extend:V16SI
11829           (match_operand:V16HI 1 "nonimmediate_operand" "vm")))]
11830   "TARGET_AVX512F"
11831   "vpmov<extsuffix>wd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11832   [(set_attr "type" "ssemov")
11833    (set_attr "prefix" "evex")
11834    (set_attr "mode" "XI")])
11835
11836 (define_insn "avx2_<code>v8hiv8si2"
11837   [(set (match_operand:V8SI 0 "register_operand" "=x")
11838         (any_extend:V8SI
11839             (match_operand:V8HI 1 "nonimmediate_operand" "xm")))]
11840   "TARGET_AVX2"
11841   "vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
11842   [(set_attr "type" "ssemov")
11843    (set_attr "prefix_extra" "1")
11844    (set_attr "prefix" "vex")
11845    (set_attr "mode" "OI")])
11846
11847 (define_insn "sse4_1_<code>v4hiv4si2"
11848   [(set (match_operand:V4SI 0 "register_operand" "=x")
11849         (any_extend:V4SI
11850           (vec_select:V4HI
11851             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11852             (parallel [(const_int 0) (const_int 1)
11853                        (const_int 2) (const_int 3)]))))]
11854   "TARGET_SSE4_1"
11855   "%vpmov<extsuffix>wd\t{%1, %0|%0, %q1}"
11856   [(set_attr "type" "ssemov")
11857    (set_attr "ssememalign" "64")
11858    (set_attr "prefix_extra" "1")
11859    (set_attr "prefix" "maybe_vex")
11860    (set_attr "mode" "TI")])
11861
11862 (define_insn "avx512f_<code>v8qiv8di2<mask_name>"
11863   [(set (match_operand:V8DI 0 "register_operand" "=v")
11864         (any_extend:V8DI
11865           (vec_select:V8QI
11866             (match_operand:V16QI 1 "nonimmediate_operand" "vm")
11867             (parallel [(const_int 0) (const_int 1)
11868                        (const_int 2) (const_int 3)
11869                        (const_int 4) (const_int 5)
11870                        (const_int 6) (const_int 7)]))))]
11871   "TARGET_AVX512F"
11872   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %k1}"
11873   [(set_attr "type" "ssemov")
11874    (set_attr "prefix" "evex")
11875    (set_attr "mode" "XI")])
11876
11877 (define_insn "avx2_<code>v4qiv4di2"
11878   [(set (match_operand:V4DI 0 "register_operand" "=x")
11879         (any_extend:V4DI
11880           (vec_select:V4QI
11881             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11882             (parallel [(const_int 0) (const_int 1)
11883                        (const_int 2) (const_int 3)]))))]
11884   "TARGET_AVX2"
11885   "vpmov<extsuffix>bq\t{%1, %0|%0, %k1}"
11886   [(set_attr "type" "ssemov")
11887    (set_attr "prefix_extra" "1")
11888    (set_attr "prefix" "vex")
11889    (set_attr "mode" "OI")])
11890
11891 (define_insn "sse4_1_<code>v2qiv2di2"
11892   [(set (match_operand:V2DI 0 "register_operand" "=x")
11893         (any_extend:V2DI
11894           (vec_select:V2QI
11895             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11896             (parallel [(const_int 0) (const_int 1)]))))]
11897   "TARGET_SSE4_1"
11898   "%vpmov<extsuffix>bq\t{%1, %0|%0, %w1}"
11899   [(set_attr "type" "ssemov")
11900    (set_attr "ssememalign" "16")
11901    (set_attr "prefix_extra" "1")
11902    (set_attr "prefix" "maybe_vex")
11903    (set_attr "mode" "TI")])
11904
11905 (define_insn "avx512f_<code>v8hiv8di2<mask_name>"
11906   [(set (match_operand:V8DI 0 "register_operand" "=v")
11907         (any_extend:V8DI
11908           (match_operand:V8HI 1 "nonimmediate_operand" "vm")))]
11909   "TARGET_AVX512F"
11910   "vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %q1}"
11911   [(set_attr "type" "ssemov")
11912    (set_attr "prefix" "evex")
11913    (set_attr "mode" "XI")])
11914
11915 (define_insn "avx2_<code>v4hiv4di2"
11916   [(set (match_operand:V4DI 0 "register_operand" "=x")
11917         (any_extend:V4DI
11918           (vec_select:V4HI
11919             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11920             (parallel [(const_int 0) (const_int 1)
11921                        (const_int 2) (const_int 3)]))))]
11922   "TARGET_AVX2"
11923   "vpmov<extsuffix>wq\t{%1, %0|%0, %q1}"
11924   [(set_attr "type" "ssemov")
11925    (set_attr "prefix_extra" "1")
11926    (set_attr "prefix" "vex")
11927    (set_attr "mode" "OI")])
11928
11929 (define_insn "sse4_1_<code>v2hiv2di2"
11930   [(set (match_operand:V2DI 0 "register_operand" "=x")
11931         (any_extend:V2DI
11932           (vec_select:V2HI
11933             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11934             (parallel [(const_int 0) (const_int 1)]))))]
11935   "TARGET_SSE4_1"
11936   "%vpmov<extsuffix>wq\t{%1, %0|%0, %k1}"
11937   [(set_attr "type" "ssemov")
11938    (set_attr "ssememalign" "32")
11939    (set_attr "prefix_extra" "1")
11940    (set_attr "prefix" "maybe_vex")
11941    (set_attr "mode" "TI")])
11942
11943 (define_insn "avx512f_<code>v8siv8di2<mask_name>"
11944   [(set (match_operand:V8DI 0 "register_operand" "=v")
11945         (any_extend:V8DI
11946           (match_operand:V8SI 1 "nonimmediate_operand" "vm")))]
11947   "TARGET_AVX512F"
11948   "vpmov<extsuffix>dq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11949   [(set_attr "type" "ssemov")
11950    (set_attr "prefix" "evex")
11951    (set_attr "mode" "XI")])
11952
11953 (define_insn "avx2_<code>v4siv4di2"
11954   [(set (match_operand:V4DI 0 "register_operand" "=x")
11955         (any_extend:V4DI
11956             (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
11957   "TARGET_AVX2"
11958   "vpmov<extsuffix>dq\t{%1, %0|%0, %1}"
11959   [(set_attr "type" "ssemov")
11960    (set_attr "prefix_extra" "1")
11961    (set_attr "mode" "OI")])
11962
11963 (define_insn "sse4_1_<code>v2siv2di2"
11964   [(set (match_operand:V2DI 0 "register_operand" "=x")
11965         (any_extend:V2DI
11966           (vec_select:V2SI
11967             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11968             (parallel [(const_int 0) (const_int 1)]))))]
11969   "TARGET_SSE4_1"
11970   "%vpmov<extsuffix>dq\t{%1, %0|%0, %q1}"
11971   [(set_attr "type" "ssemov")
11972    (set_attr "ssememalign" "64")
11973    (set_attr "prefix_extra" "1")
11974    (set_attr "prefix" "maybe_vex")
11975    (set_attr "mode" "TI")])
11976
11977 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
11978 ;; setting FLAGS_REG. But it is not a really compare instruction.
11979 (define_insn "avx_vtest<ssemodesuffix><avxsizesuffix>"
11980   [(set (reg:CC FLAGS_REG)
11981         (unspec:CC [(match_operand:VF_128_256 0 "register_operand" "x")
11982                     (match_operand:VF_128_256 1 "nonimmediate_operand" "xm")]
11983                    UNSPEC_VTESTP))]
11984   "TARGET_AVX"
11985   "vtest<ssemodesuffix>\t{%1, %0|%0, %1}"
11986   [(set_attr "type" "ssecomi")
11987    (set_attr "prefix_extra" "1")
11988    (set_attr "prefix" "vex")
11989    (set_attr "mode" "<MODE>")])
11990
11991 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
11992 ;; But it is not a really compare instruction.
11993 (define_insn "avx_ptest256"
11994   [(set (reg:CC FLAGS_REG)
11995         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
11996                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
11997                    UNSPEC_PTEST))]
11998   "TARGET_AVX"
11999   "vptest\t{%1, %0|%0, %1}"
12000   [(set_attr "type" "ssecomi")
12001    (set_attr "prefix_extra" "1")
12002    (set_attr "prefix" "vex")
12003    (set_attr "btver2_decode" "vector")
12004    (set_attr "mode" "OI")])
12005
12006 (define_insn "sse4_1_ptest"
12007   [(set (reg:CC FLAGS_REG)
12008         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
12009                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
12010                    UNSPEC_PTEST))]
12011   "TARGET_SSE4_1"
12012   "%vptest\t{%1, %0|%0, %1}"
12013   [(set_attr "type" "ssecomi")
12014    (set_attr "prefix_extra" "1")
12015    (set_attr "prefix" "maybe_vex")
12016    (set_attr "mode" "TI")])
12017
12018 (define_insn "<sse4_1>_round<ssemodesuffix><avxsizesuffix>"
12019   [(set (match_operand:VF_128_256 0 "register_operand" "=x")
12020         (unspec:VF_128_256
12021           [(match_operand:VF_128_256 1 "nonimmediate_operand" "xm")
12022            (match_operand:SI 2 "const_0_to_15_operand" "n")]
12023           UNSPEC_ROUND))]
12024   "TARGET_ROUND"
12025   "%vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
12026   [(set_attr "type" "ssecvt")
12027    (set (attr "prefix_data16")
12028      (if_then_else
12029        (match_test "TARGET_AVX")
12030      (const_string "*")
12031      (const_string "1")))
12032    (set_attr "prefix_extra" "1")
12033    (set_attr "length_immediate" "1")
12034    (set_attr "prefix" "maybe_vex")
12035    (set_attr "mode" "<MODE>")])
12036
12037 (define_expand "<sse4_1>_round<ssemodesuffix>_sfix<avxsizesuffix>"
12038   [(match_operand:<sseintvecmode> 0 "register_operand")
12039    (match_operand:VF1_128_256 1 "nonimmediate_operand")
12040    (match_operand:SI 2 "const_0_to_15_operand")]
12041   "TARGET_ROUND"
12042 {
12043   rtx tmp = gen_reg_rtx (<MODE>mode);
12044
12045   emit_insn
12046     (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp, operands[1],
12047                                                        operands[2]));
12048   emit_insn
12049     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
12050   DONE;
12051 })
12052
12053 (define_expand "avx512f_roundpd512"
12054   [(match_operand:V8DF 0 "register_operand")
12055    (match_operand:V8DF 1 "nonimmediate_operand")
12056    (match_operand:SI 2 "const_0_to_15_operand")]
12057   "TARGET_AVX512F"
12058 {
12059   emit_insn (gen_avx512f_rndscalev8df (operands[0], operands[1], operands[2]));
12060   DONE;
12061 })
12062
12063 (define_expand "<sse4_1>_round<ssemodesuffix>_vec_pack_sfix<avxsizesuffix>"
12064   [(match_operand:<ssepackfltmode> 0 "register_operand")
12065    (match_operand:VF2 1 "nonimmediate_operand")
12066    (match_operand:VF2 2 "nonimmediate_operand")
12067    (match_operand:SI 3 "const_0_to_15_operand")]
12068   "TARGET_ROUND"
12069 {
12070   rtx tmp0, tmp1;
12071
12072   if (<MODE>mode == V2DFmode
12073       && TARGET_AVX && !TARGET_PREFER_AVX128)
12074     {
12075       rtx tmp2 = gen_reg_rtx (V4DFmode);
12076
12077       tmp0 = gen_reg_rtx (V4DFmode);
12078       tmp1 = force_reg (V2DFmode, operands[1]);
12079
12080       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
12081       emit_insn (gen_avx_roundpd256 (tmp2, tmp0, operands[3]));
12082       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
12083     }
12084   else
12085     {
12086       tmp0 = gen_reg_rtx (<MODE>mode);
12087       tmp1 = gen_reg_rtx (<MODE>mode);
12088
12089       emit_insn
12090        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp0, operands[1],
12091                                                           operands[3]));
12092       emit_insn
12093        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp1, operands[2],
12094                                                           operands[3]));
12095       emit_insn
12096        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
12097     }
12098   DONE;
12099 })
12100
12101 (define_insn "sse4_1_round<ssescalarmodesuffix>"
12102   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
12103         (vec_merge:VF_128
12104           (unspec:VF_128
12105             [(match_operand:VF_128 2 "register_operand" "x,x")
12106              (match_operand:SI 3 "const_0_to_15_operand" "n,n")]
12107             UNSPEC_ROUND)
12108           (match_operand:VF_128 1 "register_operand" "0,x")
12109           (const_int 1)))]
12110   "TARGET_ROUND"
12111   "@
12112    round<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
12113    vround<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12114   [(set_attr "isa" "noavx,avx")
12115    (set_attr "type" "ssecvt")
12116    (set_attr "length_immediate" "1")
12117    (set_attr "prefix_data16" "1,*")
12118    (set_attr "prefix_extra" "1")
12119    (set_attr "prefix" "orig,vex")
12120    (set_attr "mode" "<MODE>")])
12121
12122 (define_expand "round<mode>2"
12123   [(set (match_dup 4)
12124         (plus:VF
12125           (match_operand:VF 1 "register_operand")
12126           (match_dup 3)))
12127    (set (match_operand:VF 0 "register_operand")
12128         (unspec:VF
12129           [(match_dup 4) (match_dup 5)]
12130           UNSPEC_ROUND))]
12131   "TARGET_ROUND && !flag_trapping_math"
12132 {
12133   enum machine_mode scalar_mode;
12134   const struct real_format *fmt;
12135   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
12136   rtx half, vec_half;
12137
12138   scalar_mode = GET_MODE_INNER (<MODE>mode);
12139
12140   /* load nextafter (0.5, 0.0) */
12141   fmt = REAL_MODE_FORMAT (scalar_mode);
12142   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, scalar_mode);
12143   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
12144   half = const_double_from_real_value (pred_half, scalar_mode);
12145
12146   vec_half = ix86_build_const_vector (<MODE>mode, true, half);
12147   vec_half = force_reg (<MODE>mode, vec_half);
12148
12149   operands[3] = gen_reg_rtx (<MODE>mode);
12150   emit_insn (gen_copysign<mode>3 (operands[3], vec_half, operands[1]));
12151
12152   operands[4] = gen_reg_rtx (<MODE>mode);
12153   operands[5] = GEN_INT (ROUND_TRUNC);
12154 })
12155
12156 (define_expand "round<mode>2_sfix"
12157   [(match_operand:<sseintvecmode> 0 "register_operand")
12158    (match_operand:VF1_128_256 1 "register_operand")]
12159   "TARGET_ROUND && !flag_trapping_math"
12160 {
12161   rtx tmp = gen_reg_rtx (<MODE>mode);
12162
12163   emit_insn (gen_round<mode>2 (tmp, operands[1]));
12164
12165   emit_insn
12166     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
12167   DONE;
12168 })
12169
12170 (define_expand "round<mode>2_vec_pack_sfix"
12171   [(match_operand:<ssepackfltmode> 0 "register_operand")
12172    (match_operand:VF2 1 "register_operand")
12173    (match_operand:VF2 2 "register_operand")]
12174   "TARGET_ROUND && !flag_trapping_math"
12175 {
12176   rtx tmp0, tmp1;
12177
12178   if (<MODE>mode == V2DFmode
12179       && TARGET_AVX && !TARGET_PREFER_AVX128)
12180     {
12181       rtx tmp2 = gen_reg_rtx (V4DFmode);
12182
12183       tmp0 = gen_reg_rtx (V4DFmode);
12184       tmp1 = force_reg (V2DFmode, operands[1]);
12185
12186       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
12187       emit_insn (gen_roundv4df2 (tmp2, tmp0));
12188       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
12189     }
12190   else
12191     {
12192       tmp0 = gen_reg_rtx (<MODE>mode);
12193       tmp1 = gen_reg_rtx (<MODE>mode);
12194
12195       emit_insn (gen_round<mode>2 (tmp0, operands[1]));
12196       emit_insn (gen_round<mode>2 (tmp1, operands[2]));
12197
12198       emit_insn
12199        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
12200     }
12201   DONE;
12202 })
12203
12204 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12205 ;;
12206 ;; Intel SSE4.2 string/text processing instructions
12207 ;;
12208 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12209
12210 (define_insn_and_split "sse4_2_pcmpestr"
12211   [(set (match_operand:SI 0 "register_operand" "=c,c")
12212         (unspec:SI
12213           [(match_operand:V16QI 2 "register_operand" "x,x")
12214            (match_operand:SI 3 "register_operand" "a,a")
12215            (match_operand:V16QI 4 "nonimmediate_operand" "x,m")
12216            (match_operand:SI 5 "register_operand" "d,d")
12217            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
12218           UNSPEC_PCMPESTR))
12219    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
12220         (unspec:V16QI
12221           [(match_dup 2)
12222            (match_dup 3)
12223            (match_dup 4)
12224            (match_dup 5)
12225            (match_dup 6)]
12226           UNSPEC_PCMPESTR))
12227    (set (reg:CC FLAGS_REG)
12228         (unspec:CC
12229           [(match_dup 2)
12230            (match_dup 3)
12231            (match_dup 4)
12232            (match_dup 5)
12233            (match_dup 6)]
12234           UNSPEC_PCMPESTR))]
12235   "TARGET_SSE4_2
12236    && can_create_pseudo_p ()"
12237   "#"
12238   "&& 1"
12239   [(const_int 0)]
12240 {
12241   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12242   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12243   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12244
12245   if (ecx)
12246     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
12247                                      operands[3], operands[4],
12248                                      operands[5], operands[6]));
12249   if (xmm0)
12250     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
12251                                      operands[3], operands[4],
12252                                      operands[5], operands[6]));
12253   if (flags && !(ecx || xmm0))
12254     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
12255                                            operands[2], operands[3],
12256                                            operands[4], operands[5],
12257                                            operands[6]));
12258   if (!(flags || ecx || xmm0))
12259     emit_note (NOTE_INSN_DELETED);
12260
12261   DONE;
12262 }
12263   [(set_attr "type" "sselog")
12264    (set_attr "prefix_data16" "1")
12265    (set_attr "prefix_extra" "1")
12266    (set_attr "ssememalign" "8")
12267    (set_attr "length_immediate" "1")
12268    (set_attr "memory" "none,load")
12269    (set_attr "mode" "TI")])
12270
12271 (define_insn_and_split "*sse4_2_pcmpestr_unaligned"
12272   [(set (match_operand:SI 0 "register_operand" "=c")
12273         (unspec:SI
12274           [(match_operand:V16QI 2 "register_operand" "x")
12275            (match_operand:SI 3 "register_operand" "a")
12276            (unspec:V16QI
12277              [(match_operand:V16QI 4 "memory_operand" "m")]
12278              UNSPEC_LOADU)
12279            (match_operand:SI 5 "register_operand" "d")
12280            (match_operand:SI 6 "const_0_to_255_operand" "n")]
12281           UNSPEC_PCMPESTR))
12282    (set (match_operand:V16QI 1 "register_operand" "=Yz")
12283         (unspec:V16QI
12284           [(match_dup 2)
12285            (match_dup 3)
12286            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
12287            (match_dup 5)
12288            (match_dup 6)]
12289           UNSPEC_PCMPESTR))
12290    (set (reg:CC FLAGS_REG)
12291         (unspec:CC
12292           [(match_dup 2)
12293            (match_dup 3)
12294            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
12295            (match_dup 5)
12296            (match_dup 6)]
12297           UNSPEC_PCMPESTR))]
12298   "TARGET_SSE4_2
12299    && can_create_pseudo_p ()"
12300   "#"
12301   "&& 1"
12302   [(const_int 0)]
12303 {
12304   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12305   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12306   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12307
12308   if (ecx)
12309     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
12310                                      operands[3], operands[4],
12311                                      operands[5], operands[6]));
12312   if (xmm0)
12313     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
12314                                      operands[3], operands[4],
12315                                      operands[5], operands[6]));
12316   if (flags && !(ecx || xmm0))
12317     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
12318                                            operands[2], operands[3],
12319                                            operands[4], operands[5],
12320                                            operands[6]));
12321   if (!(flags || ecx || xmm0))
12322     emit_note (NOTE_INSN_DELETED);
12323
12324   DONE;
12325 }
12326   [(set_attr "type" "sselog")
12327    (set_attr "prefix_data16" "1")
12328    (set_attr "prefix_extra" "1")
12329    (set_attr "ssememalign" "8")
12330    (set_attr "length_immediate" "1")
12331    (set_attr "memory" "load")
12332    (set_attr "mode" "TI")])
12333
12334 (define_insn "sse4_2_pcmpestri"
12335   [(set (match_operand:SI 0 "register_operand" "=c,c")
12336         (unspec:SI
12337           [(match_operand:V16QI 1 "register_operand" "x,x")
12338            (match_operand:SI 2 "register_operand" "a,a")
12339            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12340            (match_operand:SI 4 "register_operand" "d,d")
12341            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
12342           UNSPEC_PCMPESTR))
12343    (set (reg:CC FLAGS_REG)
12344         (unspec:CC
12345           [(match_dup 1)
12346            (match_dup 2)
12347            (match_dup 3)
12348            (match_dup 4)
12349            (match_dup 5)]
12350           UNSPEC_PCMPESTR))]
12351   "TARGET_SSE4_2"
12352   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
12353   [(set_attr "type" "sselog")
12354    (set_attr "prefix_data16" "1")
12355    (set_attr "prefix_extra" "1")
12356    (set_attr "prefix" "maybe_vex")
12357    (set_attr "ssememalign" "8")
12358    (set_attr "length_immediate" "1")
12359    (set_attr "btver2_decode" "vector")
12360    (set_attr "memory" "none,load")
12361    (set_attr "mode" "TI")])
12362
12363 (define_insn "sse4_2_pcmpestrm"
12364   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
12365         (unspec:V16QI
12366           [(match_operand:V16QI 1 "register_operand" "x,x")
12367            (match_operand:SI 2 "register_operand" "a,a")
12368            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12369            (match_operand:SI 4 "register_operand" "d,d")
12370            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
12371           UNSPEC_PCMPESTR))
12372    (set (reg:CC FLAGS_REG)
12373         (unspec:CC
12374           [(match_dup 1)
12375            (match_dup 2)
12376            (match_dup 3)
12377            (match_dup 4)
12378            (match_dup 5)]
12379           UNSPEC_PCMPESTR))]
12380   "TARGET_SSE4_2"
12381   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
12382   [(set_attr "type" "sselog")
12383    (set_attr "prefix_data16" "1")
12384    (set_attr "prefix_extra" "1")
12385    (set_attr "ssememalign" "8")
12386    (set_attr "length_immediate" "1")
12387    (set_attr "prefix" "maybe_vex")
12388    (set_attr "btver2_decode" "vector")
12389    (set_attr "memory" "none,load")
12390    (set_attr "mode" "TI")])
12391
12392 (define_insn "sse4_2_pcmpestr_cconly"
12393   [(set (reg:CC FLAGS_REG)
12394         (unspec:CC
12395           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
12396            (match_operand:SI 3 "register_operand" "a,a,a,a")
12397            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
12398            (match_operand:SI 5 "register_operand" "d,d,d,d")
12399            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
12400           UNSPEC_PCMPESTR))
12401    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
12402    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
12403   "TARGET_SSE4_2"
12404   "@
12405    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
12406    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
12407    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
12408    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
12409   [(set_attr "type" "sselog")
12410    (set_attr "prefix_data16" "1")
12411    (set_attr "prefix_extra" "1")
12412    (set_attr "ssememalign" "8")
12413    (set_attr "length_immediate" "1")
12414    (set_attr "memory" "none,load,none,load")
12415    (set_attr "btver2_decode" "vector,vector,vector,vector")
12416    (set_attr "prefix" "maybe_vex")
12417    (set_attr "mode" "TI")])
12418
12419 (define_insn_and_split "sse4_2_pcmpistr"
12420   [(set (match_operand:SI 0 "register_operand" "=c,c")
12421         (unspec:SI
12422           [(match_operand:V16QI 2 "register_operand" "x,x")
12423            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12424            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
12425           UNSPEC_PCMPISTR))
12426    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
12427         (unspec:V16QI
12428           [(match_dup 2)
12429            (match_dup 3)
12430            (match_dup 4)]
12431           UNSPEC_PCMPISTR))
12432    (set (reg:CC FLAGS_REG)
12433         (unspec:CC
12434           [(match_dup 2)
12435            (match_dup 3)
12436            (match_dup 4)]
12437           UNSPEC_PCMPISTR))]
12438   "TARGET_SSE4_2
12439    && can_create_pseudo_p ()"
12440   "#"
12441   "&& 1"
12442   [(const_int 0)]
12443 {
12444   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12445   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12446   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12447
12448   if (ecx)
12449     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
12450                                      operands[3], operands[4]));
12451   if (xmm0)
12452     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
12453                                      operands[3], operands[4]));
12454   if (flags && !(ecx || xmm0))
12455     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
12456                                            operands[2], operands[3],
12457                                            operands[4]));
12458   if (!(flags || ecx || xmm0))
12459     emit_note (NOTE_INSN_DELETED);
12460
12461   DONE;
12462 }
12463   [(set_attr "type" "sselog")
12464    (set_attr "prefix_data16" "1")
12465    (set_attr "prefix_extra" "1")
12466    (set_attr "ssememalign" "8")
12467    (set_attr "length_immediate" "1")
12468    (set_attr "memory" "none,load")
12469    (set_attr "mode" "TI")])
12470
12471 (define_insn_and_split "*sse4_2_pcmpistr_unaligned"
12472   [(set (match_operand:SI 0 "register_operand" "=c")
12473         (unspec:SI
12474           [(match_operand:V16QI 2 "register_operand" "x")
12475            (unspec:V16QI
12476              [(match_operand:V16QI 3 "memory_operand" "m")]
12477              UNSPEC_LOADU)
12478            (match_operand:SI 4 "const_0_to_255_operand" "n")]
12479           UNSPEC_PCMPISTR))
12480    (set (match_operand:V16QI 1 "register_operand" "=Yz")
12481         (unspec:V16QI
12482           [(match_dup 2)
12483            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
12484            (match_dup 4)]
12485           UNSPEC_PCMPISTR))
12486    (set (reg:CC FLAGS_REG)
12487         (unspec:CC
12488           [(match_dup 2)
12489            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
12490            (match_dup 4)]
12491           UNSPEC_PCMPISTR))]
12492   "TARGET_SSE4_2
12493    && can_create_pseudo_p ()"
12494   "#"
12495   "&& 1"
12496   [(const_int 0)]
12497 {
12498   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12499   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12500   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12501
12502   if (ecx)
12503     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
12504                                      operands[3], operands[4]));
12505   if (xmm0)
12506     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
12507                                      operands[3], operands[4]));
12508   if (flags && !(ecx || xmm0))
12509     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
12510                                            operands[2], operands[3],
12511                                            operands[4]));
12512   if (!(flags || ecx || xmm0))
12513     emit_note (NOTE_INSN_DELETED);
12514
12515   DONE;
12516 }
12517   [(set_attr "type" "sselog")
12518    (set_attr "prefix_data16" "1")
12519    (set_attr "prefix_extra" "1")
12520    (set_attr "ssememalign" "8")
12521    (set_attr "length_immediate" "1")
12522    (set_attr "memory" "load")
12523    (set_attr "mode" "TI")])
12524
12525 (define_insn "sse4_2_pcmpistri"
12526   [(set (match_operand:SI 0 "register_operand" "=c,c")
12527         (unspec:SI
12528           [(match_operand:V16QI 1 "register_operand" "x,x")
12529            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
12530            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
12531           UNSPEC_PCMPISTR))
12532    (set (reg:CC FLAGS_REG)
12533         (unspec:CC
12534           [(match_dup 1)
12535            (match_dup 2)
12536            (match_dup 3)]
12537           UNSPEC_PCMPISTR))]
12538   "TARGET_SSE4_2"
12539   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
12540   [(set_attr "type" "sselog")
12541    (set_attr "prefix_data16" "1")
12542    (set_attr "prefix_extra" "1")
12543    (set_attr "ssememalign" "8")
12544    (set_attr "length_immediate" "1")
12545    (set_attr "prefix" "maybe_vex")
12546    (set_attr "memory" "none,load")
12547    (set_attr "btver2_decode" "vector")
12548    (set_attr "mode" "TI")])
12549
12550 (define_insn "sse4_2_pcmpistrm"
12551   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
12552         (unspec:V16QI
12553           [(match_operand:V16QI 1 "register_operand" "x,x")
12554            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
12555            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
12556           UNSPEC_PCMPISTR))
12557    (set (reg:CC FLAGS_REG)
12558         (unspec:CC
12559           [(match_dup 1)
12560            (match_dup 2)
12561            (match_dup 3)]
12562           UNSPEC_PCMPISTR))]
12563   "TARGET_SSE4_2"
12564   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
12565   [(set_attr "type" "sselog")
12566    (set_attr "prefix_data16" "1")
12567    (set_attr "prefix_extra" "1")
12568    (set_attr "ssememalign" "8")
12569    (set_attr "length_immediate" "1")
12570    (set_attr "prefix" "maybe_vex")
12571    (set_attr "memory" "none,load")
12572    (set_attr "btver2_decode" "vector")
12573    (set_attr "mode" "TI")])
12574
12575 (define_insn "sse4_2_pcmpistr_cconly"
12576   [(set (reg:CC FLAGS_REG)
12577         (unspec:CC
12578           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
12579            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
12580            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
12581           UNSPEC_PCMPISTR))
12582    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
12583    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
12584   "TARGET_SSE4_2"
12585   "@
12586    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
12587    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
12588    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
12589    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
12590   [(set_attr "type" "sselog")
12591    (set_attr "prefix_data16" "1")
12592    (set_attr "prefix_extra" "1")
12593    (set_attr "ssememalign" "8")
12594    (set_attr "length_immediate" "1")
12595    (set_attr "memory" "none,load,none,load")
12596    (set_attr "prefix" "maybe_vex")
12597    (set_attr "btver2_decode" "vector,vector,vector,vector")
12598    (set_attr "mode" "TI")])
12599
12600 ;; Packed float variants
12601 (define_mode_attr GATHER_SCATTER_SF_MEM_MODE
12602                       [(V8DI "V8SF") (V16SI "V16SF")])
12603
12604 (define_expand "avx512pf_gatherpf<mode>sf"
12605   [(unspec
12606      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12607       (mem:<GATHER_SCATTER_SF_MEM_MODE>
12608         (match_par_dup 5
12609           [(match_operand 2 "vsib_address_operand")
12610            (match_operand:VI48_512 1 "register_operand")
12611            (match_operand:SI 3 "const1248_operand")]))
12612       (match_operand:SI 4 "const_2_to_3_operand")]
12613      UNSPEC_GATHER_PREFETCH)]
12614   "TARGET_AVX512PF"
12615 {
12616   operands[5]
12617     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12618                                         operands[3]), UNSPEC_VSIBADDR);
12619 })
12620
12621 (define_insn "*avx512pf_gatherpf<mode>sf_mask"
12622   [(unspec
12623      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12624       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 5 "vsib_mem_operator"
12625         [(unspec:P
12626            [(match_operand:P 2 "vsib_address_operand" "Tv")
12627             (match_operand:VI48_512 1 "register_operand" "v")
12628             (match_operand:SI 3 "const1248_operand" "n")]
12629            UNSPEC_VSIBADDR)])
12630       (match_operand:SI 4 "const_2_to_3_operand" "n")]
12631      UNSPEC_GATHER_PREFETCH)]
12632   "TARGET_AVX512PF"
12633 {
12634   switch (INTVAL (operands[4]))
12635     {
12636     case 3:
12637       return "vgatherpf0<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12638     case 2:
12639       return "vgatherpf1<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12640     default:
12641       gcc_unreachable ();
12642     }
12643 }
12644   [(set_attr "type" "sse")
12645    (set_attr "prefix" "evex")
12646    (set_attr "mode" "XI")])
12647
12648 (define_insn "*avx512pf_gatherpf<mode>sf"
12649   [(unspec
12650      [(const_int -1)
12651       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 4 "vsib_mem_operator"
12652         [(unspec:P
12653            [(match_operand:P 1 "vsib_address_operand" "Tv")
12654             (match_operand:VI48_512 0 "register_operand" "v")
12655             (match_operand:SI 2 "const1248_operand" "n")]
12656            UNSPEC_VSIBADDR)])
12657       (match_operand:SI 3 "const_2_to_3_operand" "n")]
12658      UNSPEC_GATHER_PREFETCH)]
12659   "TARGET_AVX512PF"
12660 {
12661   switch (INTVAL (operands[3]))
12662     {
12663     case 3:
12664       return "vgatherpf0<ssemodesuffix>ps\t{%4|%4}";
12665     case 2:
12666       return "vgatherpf1<ssemodesuffix>ps\t{%4|%4}";
12667     default:
12668       gcc_unreachable ();
12669     }
12670 }
12671   [(set_attr "type" "sse")
12672    (set_attr "prefix" "evex")
12673    (set_attr "mode" "XI")])
12674
12675 ;; Packed double variants
12676 (define_expand "avx512pf_gatherpf<mode>df"
12677   [(unspec
12678      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12679       (mem:V8DF
12680         (match_par_dup 5
12681           [(match_operand 2 "vsib_address_operand")
12682            (match_operand:VI4_256_8_512 1 "register_operand")
12683            (match_operand:SI 3 "const1248_operand")]))
12684       (match_operand:SI 4 "const_2_to_3_operand")]
12685      UNSPEC_GATHER_PREFETCH)]
12686   "TARGET_AVX512PF"
12687 {
12688   operands[5]
12689     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12690                                         operands[3]), UNSPEC_VSIBADDR);
12691 })
12692
12693 (define_insn "*avx512pf_gatherpf<mode>df_mask"
12694   [(unspec
12695      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12696       (match_operator:V8DF 5 "vsib_mem_operator"
12697         [(unspec:P
12698            [(match_operand:P 2 "vsib_address_operand" "Tv")
12699             (match_operand:VI4_256_8_512 1 "register_operand" "v")
12700             (match_operand:SI 3 "const1248_operand" "n")]
12701            UNSPEC_VSIBADDR)])
12702       (match_operand:SI 4 "const_2_to_3_operand" "n")]
12703      UNSPEC_GATHER_PREFETCH)]
12704   "TARGET_AVX512PF"
12705 {
12706   switch (INTVAL (operands[4]))
12707     {
12708     case 3:
12709       return "vgatherpf0<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12710     case 2:
12711       return "vgatherpf1<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12712     default:
12713       gcc_unreachable ();
12714     }
12715 }
12716   [(set_attr "type" "sse")
12717    (set_attr "prefix" "evex")
12718    (set_attr "mode" "XI")])
12719
12720 (define_insn "*avx512pf_gatherpf<mode>df"
12721   [(unspec
12722      [(const_int -1)
12723       (match_operator:V8DF 4 "vsib_mem_operator"
12724         [(unspec:P
12725            [(match_operand:P 1 "vsib_address_operand" "Tv")
12726             (match_operand:VI4_256_8_512 0 "register_operand" "v")
12727             (match_operand:SI 2 "const1248_operand" "n")]
12728            UNSPEC_VSIBADDR)])
12729       (match_operand:SI 3 "const_2_to_3_operand" "n")]
12730      UNSPEC_GATHER_PREFETCH)]
12731   "TARGET_AVX512PF"
12732 {
12733   switch (INTVAL (operands[3]))
12734     {
12735     case 3:
12736       return "vgatherpf0<ssemodesuffix>pd\t{%4|%4}";
12737     case 2:
12738       return "vgatherpf1<ssemodesuffix>pd\t{%4|%4}";
12739     default:
12740       gcc_unreachable ();
12741     }
12742 }
12743   [(set_attr "type" "sse")
12744    (set_attr "prefix" "evex")
12745    (set_attr "mode" "XI")])
12746
12747 ;; Packed float variants
12748 (define_expand "avx512pf_scatterpf<mode>sf"
12749   [(unspec
12750      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12751       (mem:<GATHER_SCATTER_SF_MEM_MODE>
12752         (match_par_dup 5
12753           [(match_operand 2 "vsib_address_operand")
12754            (match_operand:VI48_512 1 "register_operand")
12755            (match_operand:SI 3 "const1248_operand")]))
12756       (match_operand:SI 4 "const2367_operand")]
12757      UNSPEC_SCATTER_PREFETCH)]
12758   "TARGET_AVX512PF"
12759 {
12760   operands[5]
12761     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12762                                         operands[3]), UNSPEC_VSIBADDR);
12763 })
12764
12765 (define_insn "*avx512pf_scatterpf<mode>sf_mask"
12766   [(unspec
12767      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12768       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 5 "vsib_mem_operator"
12769         [(unspec:P
12770            [(match_operand:P 2 "vsib_address_operand" "Tv")
12771             (match_operand:VI48_512 1 "register_operand" "v")
12772             (match_operand:SI 3 "const1248_operand" "n")]
12773            UNSPEC_VSIBADDR)])
12774       (match_operand:SI 4 "const2367_operand" "n")]
12775      UNSPEC_SCATTER_PREFETCH)]
12776   "TARGET_AVX512PF"
12777 {
12778   switch (INTVAL (operands[4]))
12779     {
12780     case 3:
12781     case 7:
12782       return "vscatterpf0<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12783     case 2:
12784     case 6:
12785       return "vscatterpf1<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12786     default:
12787       gcc_unreachable ();
12788     }
12789 }
12790   [(set_attr "type" "sse")
12791    (set_attr "prefix" "evex")
12792    (set_attr "mode" "XI")])
12793
12794 (define_insn "*avx512pf_scatterpf<mode>sf"
12795   [(unspec
12796      [(const_int -1)
12797       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 4 "vsib_mem_operator"
12798         [(unspec:P
12799            [(match_operand:P 1 "vsib_address_operand" "Tv")
12800             (match_operand:VI48_512 0 "register_operand" "v")
12801             (match_operand:SI 2 "const1248_operand" "n")]
12802            UNSPEC_VSIBADDR)])
12803       (match_operand:SI 3 "const2367_operand" "n")]
12804      UNSPEC_SCATTER_PREFETCH)]
12805   "TARGET_AVX512PF"
12806 {
12807   switch (INTVAL (operands[3]))
12808     {
12809     case 3:
12810     case 7:
12811       return "vscatterpf0<ssemodesuffix>ps\t{%4|%4}";
12812     case 2:
12813     case 6:
12814       return "vscatterpf1<ssemodesuffix>ps\t{%4|%4}";
12815     default:
12816       gcc_unreachable ();
12817     }
12818 }
12819   [(set_attr "type" "sse")
12820    (set_attr "prefix" "evex")
12821    (set_attr "mode" "XI")])
12822
12823 ;; Packed double variants
12824 (define_expand "avx512pf_scatterpf<mode>df"
12825   [(unspec
12826      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12827       (mem:V8DF
12828         (match_par_dup 5
12829           [(match_operand 2 "vsib_address_operand")
12830            (match_operand:VI4_256_8_512 1 "register_operand")
12831            (match_operand:SI 3 "const1248_operand")]))
12832       (match_operand:SI 4 "const2367_operand")]
12833      UNSPEC_SCATTER_PREFETCH)]
12834   "TARGET_AVX512PF"
12835 {
12836   operands[5]
12837     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12838                                         operands[3]), UNSPEC_VSIBADDR);
12839 })
12840
12841 (define_insn "*avx512pf_scatterpf<mode>df_mask"
12842   [(unspec
12843      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12844       (match_operator:V8DF 5 "vsib_mem_operator"
12845         [(unspec:P
12846            [(match_operand:P 2 "vsib_address_operand" "Tv")
12847             (match_operand:VI4_256_8_512 1 "register_operand" "v")
12848             (match_operand:SI 3 "const1248_operand" "n")]
12849            UNSPEC_VSIBADDR)])
12850       (match_operand:SI 4 "const2367_operand" "n")]
12851      UNSPEC_SCATTER_PREFETCH)]
12852   "TARGET_AVX512PF"
12853 {
12854   switch (INTVAL (operands[4]))
12855     {
12856     case 3:
12857     case 7:
12858       return "vscatterpf0<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12859     case 2:
12860     case 6:
12861       return "vscatterpf1<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12862     default:
12863       gcc_unreachable ();
12864     }
12865 }
12866   [(set_attr "type" "sse")
12867    (set_attr "prefix" "evex")
12868    (set_attr "mode" "XI")])
12869
12870 (define_insn "*avx512pf_scatterpf<mode>df"
12871   [(unspec
12872      [(const_int -1)
12873       (match_operator:V8DF 4 "vsib_mem_operator"
12874         [(unspec:P
12875            [(match_operand:P 1 "vsib_address_operand" "Tv")
12876             (match_operand:VI4_256_8_512 0 "register_operand" "v")
12877             (match_operand:SI 2 "const1248_operand" "n")]
12878            UNSPEC_VSIBADDR)])
12879       (match_operand:SI 3 "const2367_operand" "n")]
12880      UNSPEC_SCATTER_PREFETCH)]
12881   "TARGET_AVX512PF"
12882 {
12883   switch (INTVAL (operands[3]))
12884     {
12885     case 3:
12886     case 7:
12887       return "vscatterpf0<ssemodesuffix>pd\t{%4|%4}";
12888     case 2:
12889     case 6:
12890       return "vscatterpf1<ssemodesuffix>pd\t{%4|%4}";
12891     default:
12892       gcc_unreachable ();
12893     }
12894 }
12895   [(set_attr "type" "sse")
12896    (set_attr "prefix" "evex")
12897    (set_attr "mode" "XI")])
12898
12899 (define_insn "avx512er_exp2<mode><mask_name><round_saeonly_name>"
12900   [(set (match_operand:VF_512 0 "register_operand" "=v")
12901         (unspec:VF_512
12902           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12903           UNSPEC_EXP2))]
12904   "TARGET_AVX512ER"
12905   "vexp2<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12906   [(set_attr "prefix" "evex")
12907    (set_attr "type" "sse")
12908    (set_attr "mode" "<MODE>")])
12909
12910 (define_insn "<mask_codefor>avx512er_rcp28<mode><mask_name><round_saeonly_name>"
12911   [(set (match_operand:VF_512 0 "register_operand" "=v")
12912         (unspec:VF_512
12913           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12914           UNSPEC_RCP28))]
12915   "TARGET_AVX512ER"
12916   "vrcp28<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12917   [(set_attr "prefix" "evex")
12918    (set_attr "type" "sse")
12919    (set_attr "mode" "<MODE>")])
12920
12921 (define_insn "avx512er_vmrcp28<mode><round_saeonly_name>"
12922   [(set (match_operand:VF_128 0 "register_operand" "=v")
12923         (vec_merge:VF_128
12924           (unspec:VF_128
12925             [(match_operand:VF_128 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12926             UNSPEC_RCP28)
12927           (match_operand:VF_128 2 "register_operand" "v")
12928           (const_int 1)))]
12929   "TARGET_AVX512ER"
12930   "vrcp28<ssescalarmodesuffix>\t{<round_saeonly_op3>%1, %2, %0|%0, %2, %1<round_saeonly_op3>}"
12931   [(set_attr "length_immediate" "1")
12932    (set_attr "prefix" "evex")
12933    (set_attr "type" "sse")
12934    (set_attr "mode" "<MODE>")])
12935
12936 (define_insn "<mask_codefor>avx512er_rsqrt28<mode><mask_name><round_saeonly_name>"
12937   [(set (match_operand:VF_512 0 "register_operand" "=v")
12938         (unspec:VF_512
12939           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12940           UNSPEC_RSQRT28))]
12941   "TARGET_AVX512ER"
12942   "vrsqrt28<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12943   [(set_attr "prefix" "evex")
12944    (set_attr "type" "sse")
12945    (set_attr "mode" "<MODE>")])
12946
12947 (define_insn "avx512er_vmrsqrt28<mode><round_saeonly_name>"
12948   [(set (match_operand:VF_128 0 "register_operand" "=v")
12949         (vec_merge:VF_128
12950           (unspec:VF_128
12951             [(match_operand:VF_128 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12952             UNSPEC_RSQRT28)
12953           (match_operand:VF_128 2 "register_operand" "v")
12954           (const_int 1)))]
12955   "TARGET_AVX512ER"
12956   "vrsqrt28<ssescalarmodesuffix>\t{<round_saeonly_op3>%1, %2, %0|%0, %2, %1<round_saeonly_op3>}"
12957   [(set_attr "length_immediate" "1")
12958    (set_attr "type" "sse")
12959    (set_attr "prefix" "evex")
12960    (set_attr "mode" "<MODE>")])
12961
12962 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12963 ;;
12964 ;; XOP instructions
12965 ;;
12966 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12967
12968 (define_code_iterator xop_plus [plus ss_plus])
12969
12970 (define_code_attr macs [(plus "macs") (ss_plus "macss")])
12971 (define_code_attr madcs [(plus "madcs") (ss_plus "madcss")])
12972
12973 ;; XOP parallel integer multiply/add instructions.
12974
12975 (define_insn "xop_p<macs><ssemodesuffix><ssemodesuffix>"
12976   [(set (match_operand:VI24_128 0 "register_operand" "=x")
12977         (xop_plus:VI24_128
12978          (mult:VI24_128
12979           (match_operand:VI24_128 1 "nonimmediate_operand" "%x")
12980           (match_operand:VI24_128 2 "nonimmediate_operand" "xm"))
12981          (match_operand:VI24_128 3 "register_operand" "x")))]
12982   "TARGET_XOP"
12983   "vp<macs><ssemodesuffix><ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12984   [(set_attr "type" "ssemuladd")
12985    (set_attr "mode" "TI")])
12986
12987 (define_insn "xop_p<macs>dql"
12988   [(set (match_operand:V2DI 0 "register_operand" "=x")
12989         (xop_plus:V2DI
12990          (mult:V2DI
12991           (sign_extend:V2DI
12992            (vec_select:V2SI
12993             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
12994             (parallel [(const_int 0) (const_int 2)])))
12995           (sign_extend:V2DI
12996            (vec_select:V2SI
12997             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
12998             (parallel [(const_int 0) (const_int 2)]))))
12999          (match_operand:V2DI 3 "register_operand" "x")))]
13000   "TARGET_XOP"
13001   "vp<macs>dql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13002   [(set_attr "type" "ssemuladd")
13003    (set_attr "mode" "TI")])
13004
13005 (define_insn "xop_p<macs>dqh"
13006   [(set (match_operand:V2DI 0 "register_operand" "=x")
13007         (xop_plus:V2DI
13008          (mult:V2DI
13009           (sign_extend:V2DI
13010            (vec_select:V2SI
13011             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
13012             (parallel [(const_int 1) (const_int 3)])))
13013           (sign_extend:V2DI
13014            (vec_select:V2SI
13015             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
13016             (parallel [(const_int 1) (const_int 3)]))))
13017          (match_operand:V2DI 3 "register_operand" "x")))]
13018   "TARGET_XOP"
13019   "vp<macs>dqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13020   [(set_attr "type" "ssemuladd")
13021    (set_attr "mode" "TI")])
13022
13023 ;; XOP parallel integer multiply/add instructions for the intrinisics
13024 (define_insn "xop_p<macs>wd"
13025   [(set (match_operand:V4SI 0 "register_operand" "=x")
13026         (xop_plus:V4SI
13027          (mult:V4SI
13028           (sign_extend:V4SI
13029            (vec_select:V4HI
13030             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
13031             (parallel [(const_int 1) (const_int 3)
13032                        (const_int 5) (const_int 7)])))
13033           (sign_extend:V4SI
13034            (vec_select:V4HI
13035             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
13036             (parallel [(const_int 1) (const_int 3)
13037                        (const_int 5) (const_int 7)]))))
13038          (match_operand:V4SI 3 "register_operand" "x")))]
13039   "TARGET_XOP"
13040   "vp<macs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13041   [(set_attr "type" "ssemuladd")
13042    (set_attr "mode" "TI")])
13043
13044 (define_insn "xop_p<madcs>wd"
13045   [(set (match_operand:V4SI 0 "register_operand" "=x")
13046         (xop_plus:V4SI
13047          (plus:V4SI
13048           (mult:V4SI
13049            (sign_extend:V4SI
13050             (vec_select:V4HI
13051              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
13052              (parallel [(const_int 0) (const_int 2)
13053                         (const_int 4) (const_int 6)])))
13054            (sign_extend:V4SI
13055             (vec_select:V4HI
13056              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
13057              (parallel [(const_int 0) (const_int 2)
13058                         (const_int 4) (const_int 6)]))))
13059           (mult:V4SI
13060            (sign_extend:V4SI
13061             (vec_select:V4HI
13062              (match_dup 1)
13063              (parallel [(const_int 1) (const_int 3)
13064                         (const_int 5) (const_int 7)])))
13065            (sign_extend:V4SI
13066             (vec_select:V4HI
13067              (match_dup 2)
13068              (parallel [(const_int 1) (const_int 3)
13069                         (const_int 5) (const_int 7)])))))
13070          (match_operand:V4SI 3 "register_operand" "x")))]
13071   "TARGET_XOP"
13072   "vp<madcs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13073   [(set_attr "type" "ssemuladd")
13074    (set_attr "mode" "TI")])
13075
13076 ;; XOP parallel XMM conditional moves
13077 (define_insn "xop_pcmov_<mode><avxsizesuffix>"
13078   [(set (match_operand:V 0 "register_operand" "=x,x")
13079         (if_then_else:V
13080           (match_operand:V 3 "nonimmediate_operand" "x,m")
13081           (match_operand:V 1 "register_operand" "x,x")
13082           (match_operand:V 2 "nonimmediate_operand" "xm,x")))]
13083   "TARGET_XOP"
13084   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13085   [(set_attr "type" "sse4arg")])
13086
13087 ;; XOP horizontal add/subtract instructions
13088 (define_insn "xop_phadd<u>bw"
13089   [(set (match_operand:V8HI 0 "register_operand" "=x")
13090         (plus:V8HI
13091          (any_extend:V8HI
13092           (vec_select:V8QI
13093            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13094            (parallel [(const_int 0) (const_int 2)
13095                       (const_int 4) (const_int 6)
13096                       (const_int 8) (const_int 10)
13097                       (const_int 12) (const_int 14)])))
13098          (any_extend:V8HI
13099           (vec_select:V8QI
13100            (match_dup 1)
13101            (parallel [(const_int 1) (const_int 3)
13102                       (const_int 5) (const_int 7)
13103                       (const_int 9) (const_int 11)
13104                       (const_int 13) (const_int 15)])))))]
13105   "TARGET_XOP"
13106   "vphadd<u>bw\t{%1, %0|%0, %1}"
13107   [(set_attr "type" "sseiadd1")])
13108
13109 (define_insn "xop_phadd<u>bd"
13110   [(set (match_operand:V4SI 0 "register_operand" "=x")
13111         (plus:V4SI
13112          (plus:V4SI
13113           (any_extend:V4SI
13114            (vec_select:V4QI
13115             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13116             (parallel [(const_int 0) (const_int 4)
13117                        (const_int 8) (const_int 12)])))
13118           (any_extend:V4SI
13119            (vec_select:V4QI
13120             (match_dup 1)
13121             (parallel [(const_int 1) (const_int 5)
13122                        (const_int 9) (const_int 13)]))))
13123          (plus:V4SI
13124           (any_extend:V4SI
13125            (vec_select:V4QI
13126             (match_dup 1)
13127             (parallel [(const_int 2) (const_int 6)
13128                        (const_int 10) (const_int 14)])))
13129           (any_extend:V4SI
13130            (vec_select:V4QI
13131             (match_dup 1)
13132             (parallel [(const_int 3) (const_int 7)
13133                        (const_int 11) (const_int 15)]))))))]
13134   "TARGET_XOP"
13135   "vphadd<u>bd\t{%1, %0|%0, %1}"
13136   [(set_attr "type" "sseiadd1")])
13137
13138 (define_insn "xop_phadd<u>bq"
13139   [(set (match_operand:V2DI 0 "register_operand" "=x")
13140         (plus:V2DI
13141          (plus:V2DI
13142           (plus:V2DI
13143            (any_extend:V2DI
13144             (vec_select:V2QI
13145              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13146              (parallel [(const_int 0) (const_int 8)])))
13147            (any_extend:V2DI
13148             (vec_select:V2QI
13149              (match_dup 1)
13150              (parallel [(const_int 1) (const_int 9)]))))
13151           (plus:V2DI
13152            (any_extend:V2DI
13153             (vec_select:V2QI
13154              (match_dup 1)
13155              (parallel [(const_int 2) (const_int 10)])))
13156            (any_extend:V2DI
13157             (vec_select:V2QI
13158              (match_dup 1)
13159              (parallel [(const_int 3) (const_int 11)])))))
13160          (plus:V2DI
13161           (plus:V2DI
13162            (any_extend:V2DI
13163             (vec_select:V2QI
13164              (match_dup 1)
13165              (parallel [(const_int 4) (const_int 12)])))
13166            (any_extend:V2DI
13167             (vec_select:V2QI
13168              (match_dup 1)
13169              (parallel [(const_int 5) (const_int 13)]))))
13170           (plus:V2DI
13171            (any_extend:V2DI
13172             (vec_select:V2QI
13173              (match_dup 1)
13174              (parallel [(const_int 6) (const_int 14)])))
13175            (any_extend:V2DI
13176             (vec_select:V2QI
13177              (match_dup 1)
13178              (parallel [(const_int 7) (const_int 15)])))))))]
13179   "TARGET_XOP"
13180   "vphadd<u>bq\t{%1, %0|%0, %1}"
13181   [(set_attr "type" "sseiadd1")])
13182
13183 (define_insn "xop_phadd<u>wd"
13184   [(set (match_operand:V4SI 0 "register_operand" "=x")
13185         (plus:V4SI
13186          (any_extend:V4SI
13187           (vec_select:V4HI
13188            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13189            (parallel [(const_int 0) (const_int 2)
13190                       (const_int 4) (const_int 6)])))
13191          (any_extend:V4SI
13192           (vec_select:V4HI
13193            (match_dup 1)
13194            (parallel [(const_int 1) (const_int 3)
13195                       (const_int 5) (const_int 7)])))))]
13196   "TARGET_XOP"
13197   "vphadd<u>wd\t{%1, %0|%0, %1}"
13198   [(set_attr "type" "sseiadd1")])
13199
13200 (define_insn "xop_phadd<u>wq"
13201   [(set (match_operand:V2DI 0 "register_operand" "=x")
13202         (plus:V2DI
13203          (plus:V2DI
13204           (any_extend:V2DI
13205            (vec_select:V2HI
13206             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13207             (parallel [(const_int 0) (const_int 4)])))
13208           (any_extend:V2DI
13209            (vec_select:V2HI
13210             (match_dup 1)
13211             (parallel [(const_int 1) (const_int 5)]))))
13212          (plus:V2DI
13213           (any_extend:V2DI
13214            (vec_select:V2HI
13215             (match_dup 1)
13216             (parallel [(const_int 2) (const_int 6)])))
13217           (any_extend:V2DI
13218            (vec_select:V2HI
13219             (match_dup 1)
13220             (parallel [(const_int 3) (const_int 7)]))))))]
13221   "TARGET_XOP"
13222   "vphadd<u>wq\t{%1, %0|%0, %1}"
13223   [(set_attr "type" "sseiadd1")])
13224
13225 (define_insn "xop_phadd<u>dq"
13226   [(set (match_operand:V2DI 0 "register_operand" "=x")
13227         (plus:V2DI
13228          (any_extend:V2DI
13229           (vec_select:V2SI
13230            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
13231            (parallel [(const_int 0) (const_int 2)])))
13232          (any_extend:V2DI
13233           (vec_select:V2SI
13234            (match_dup 1)
13235            (parallel [(const_int 1) (const_int 3)])))))]
13236   "TARGET_XOP"
13237   "vphadd<u>dq\t{%1, %0|%0, %1}"
13238   [(set_attr "type" "sseiadd1")])
13239
13240 (define_insn "xop_phsubbw"
13241   [(set (match_operand:V8HI 0 "register_operand" "=x")
13242         (minus:V8HI
13243          (sign_extend:V8HI
13244           (vec_select:V8QI
13245            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13246            (parallel [(const_int 0) (const_int 2)
13247                       (const_int 4) (const_int 6)
13248                       (const_int 8) (const_int 10)
13249                       (const_int 12) (const_int 14)])))
13250          (sign_extend:V8HI
13251           (vec_select:V8QI
13252            (match_dup 1)
13253            (parallel [(const_int 1) (const_int 3)
13254                       (const_int 5) (const_int 7)
13255                       (const_int 9) (const_int 11)
13256                       (const_int 13) (const_int 15)])))))]
13257   "TARGET_XOP"
13258   "vphsubbw\t{%1, %0|%0, %1}"
13259   [(set_attr "type" "sseiadd1")])
13260
13261 (define_insn "xop_phsubwd"
13262   [(set (match_operand:V4SI 0 "register_operand" "=x")
13263         (minus:V4SI
13264          (sign_extend:V4SI
13265           (vec_select:V4HI
13266            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13267            (parallel [(const_int 0) (const_int 2)
13268                       (const_int 4) (const_int 6)])))
13269          (sign_extend:V4SI
13270           (vec_select:V4HI
13271            (match_dup 1)
13272            (parallel [(const_int 1) (const_int 3)
13273                       (const_int 5) (const_int 7)])))))]
13274   "TARGET_XOP"
13275   "vphsubwd\t{%1, %0|%0, %1}"
13276   [(set_attr "type" "sseiadd1")])
13277
13278 (define_insn "xop_phsubdq"
13279   [(set (match_operand:V2DI 0 "register_operand" "=x")
13280         (minus:V2DI
13281          (sign_extend:V2DI
13282           (vec_select:V2SI
13283            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
13284            (parallel [(const_int 0) (const_int 2)])))
13285          (sign_extend:V2DI
13286           (vec_select:V2SI
13287            (match_dup 1)
13288            (parallel [(const_int 1) (const_int 3)])))))]
13289   "TARGET_XOP"
13290   "vphsubdq\t{%1, %0|%0, %1}"
13291   [(set_attr "type" "sseiadd1")])
13292
13293 ;; XOP permute instructions
13294 (define_insn "xop_pperm"
13295   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
13296         (unspec:V16QI
13297           [(match_operand:V16QI 1 "register_operand" "x,x")
13298            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
13299            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
13300           UNSPEC_XOP_PERMUTE))]
13301   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13302   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13303   [(set_attr "type" "sse4arg")
13304    (set_attr "mode" "TI")])
13305
13306 ;; XOP pack instructions that combine two vectors into a smaller vector
13307 (define_insn "xop_pperm_pack_v2di_v4si"
13308   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
13309         (vec_concat:V4SI
13310          (truncate:V2SI
13311           (match_operand:V2DI 1 "register_operand" "x,x"))
13312          (truncate:V2SI
13313           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
13314    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13315   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13316   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13317   [(set_attr "type" "sse4arg")
13318    (set_attr "mode" "TI")])
13319
13320 (define_insn "xop_pperm_pack_v4si_v8hi"
13321   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
13322         (vec_concat:V8HI
13323          (truncate:V4HI
13324           (match_operand:V4SI 1 "register_operand" "x,x"))
13325          (truncate:V4HI
13326           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
13327    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13328   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13329   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13330   [(set_attr "type" "sse4arg")
13331    (set_attr "mode" "TI")])
13332
13333 (define_insn "xop_pperm_pack_v8hi_v16qi"
13334   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
13335         (vec_concat:V16QI
13336          (truncate:V8QI
13337           (match_operand:V8HI 1 "register_operand" "x,x"))
13338          (truncate:V8QI
13339           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
13340    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13341   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13342   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13343   [(set_attr "type" "sse4arg")
13344    (set_attr "mode" "TI")])
13345
13346 ;; XOP packed rotate instructions
13347 (define_expand "rotl<mode>3"
13348   [(set (match_operand:VI_128 0 "register_operand")
13349         (rotate:VI_128
13350          (match_operand:VI_128 1 "nonimmediate_operand")
13351          (match_operand:SI 2 "general_operand")))]
13352   "TARGET_XOP"
13353 {
13354   /* If we were given a scalar, convert it to parallel */
13355   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
13356     {
13357       rtvec vs = rtvec_alloc (<ssescalarnum>);
13358       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
13359       rtx reg = gen_reg_rtx (<MODE>mode);
13360       rtx op2 = operands[2];
13361       int i;
13362
13363       if (GET_MODE (op2) != <ssescalarmode>mode)
13364         {
13365           op2 = gen_reg_rtx (<ssescalarmode>mode);
13366           convert_move (op2, operands[2], false);
13367         }
13368
13369       for (i = 0; i < <ssescalarnum>; i++)
13370         RTVEC_ELT (vs, i) = op2;
13371
13372       emit_insn (gen_vec_init<mode> (reg, par));
13373       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
13374       DONE;
13375     }
13376 })
13377
13378 (define_expand "rotr<mode>3"
13379   [(set (match_operand:VI_128 0 "register_operand")
13380         (rotatert:VI_128
13381          (match_operand:VI_128 1 "nonimmediate_operand")
13382          (match_operand:SI 2 "general_operand")))]
13383   "TARGET_XOP"
13384 {
13385   /* If we were given a scalar, convert it to parallel */
13386   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
13387     {
13388       rtvec vs = rtvec_alloc (<ssescalarnum>);
13389       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
13390       rtx neg = gen_reg_rtx (<MODE>mode);
13391       rtx reg = gen_reg_rtx (<MODE>mode);
13392       rtx op2 = operands[2];
13393       int i;
13394
13395       if (GET_MODE (op2) != <ssescalarmode>mode)
13396         {
13397           op2 = gen_reg_rtx (<ssescalarmode>mode);
13398           convert_move (op2, operands[2], false);
13399         }
13400
13401       for (i = 0; i < <ssescalarnum>; i++)
13402         RTVEC_ELT (vs, i) = op2;
13403
13404       emit_insn (gen_vec_init<mode> (reg, par));
13405       emit_insn (gen_neg<mode>2 (neg, reg));
13406       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
13407       DONE;
13408     }
13409 })
13410
13411 (define_insn "xop_rotl<mode>3"
13412   [(set (match_operand:VI_128 0 "register_operand" "=x")
13413         (rotate:VI_128
13414          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
13415          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
13416   "TARGET_XOP"
13417   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13418   [(set_attr "type" "sseishft")
13419    (set_attr "length_immediate" "1")
13420    (set_attr "mode" "TI")])
13421
13422 (define_insn "xop_rotr<mode>3"
13423   [(set (match_operand:VI_128 0 "register_operand" "=x")
13424         (rotatert:VI_128
13425          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
13426          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
13427   "TARGET_XOP"
13428 {
13429   operands[3]
13430     = GEN_INT (GET_MODE_BITSIZE (<ssescalarmode>mode) - INTVAL (operands[2]));
13431   return \"vprot<ssemodesuffix>\t{%3, %1, %0|%0, %1, %3}\";
13432 }
13433   [(set_attr "type" "sseishft")
13434    (set_attr "length_immediate" "1")
13435    (set_attr "mode" "TI")])
13436
13437 (define_expand "vrotr<mode>3"
13438   [(match_operand:VI_128 0 "register_operand")
13439    (match_operand:VI_128 1 "register_operand")
13440    (match_operand:VI_128 2 "register_operand")]
13441   "TARGET_XOP"
13442 {
13443   rtx reg = gen_reg_rtx (<MODE>mode);
13444   emit_insn (gen_neg<mode>2 (reg, operands[2]));
13445   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
13446   DONE;
13447 })
13448
13449 (define_expand "vrotl<mode>3"
13450   [(match_operand:VI_128 0 "register_operand")
13451    (match_operand:VI_128 1 "register_operand")
13452    (match_operand:VI_128 2 "register_operand")]
13453   "TARGET_XOP"
13454 {
13455   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
13456   DONE;
13457 })
13458
13459 (define_insn "xop_vrotl<mode>3"
13460   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13461         (if_then_else:VI_128
13462          (ge:VI_128
13463           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13464           (const_int 0))
13465          (rotate:VI_128
13466           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13467           (match_dup 2))
13468          (rotatert:VI_128
13469           (match_dup 1)
13470           (neg:VI_128 (match_dup 2)))))]
13471   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13472   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13473   [(set_attr "type" "sseishft")
13474    (set_attr "prefix_data16" "0")
13475    (set_attr "prefix_extra" "2")
13476    (set_attr "mode" "TI")])
13477
13478 ;; XOP packed shift instructions.
13479 (define_expand "vlshr<mode>3"
13480   [(set (match_operand:VI12_128 0 "register_operand")
13481         (lshiftrt:VI12_128
13482           (match_operand:VI12_128 1 "register_operand")
13483           (match_operand:VI12_128 2 "nonimmediate_operand")))]
13484   "TARGET_XOP"
13485 {
13486   rtx neg = gen_reg_rtx (<MODE>mode);
13487   emit_insn (gen_neg<mode>2 (neg, operands[2]));
13488   emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
13489   DONE;
13490 })
13491
13492 (define_expand "vlshr<mode>3"
13493   [(set (match_operand:VI48_128 0 "register_operand")
13494         (lshiftrt:VI48_128
13495           (match_operand:VI48_128 1 "register_operand")
13496           (match_operand:VI48_128 2 "nonimmediate_operand")))]
13497   "TARGET_AVX2 || TARGET_XOP"
13498 {
13499   if (!TARGET_AVX2)
13500     {
13501       rtx neg = gen_reg_rtx (<MODE>mode);
13502       emit_insn (gen_neg<mode>2 (neg, operands[2]));
13503       emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
13504       DONE;
13505     }
13506 })
13507
13508 (define_expand "vlshr<mode>3"
13509   [(set (match_operand:VI48_512 0 "register_operand")
13510         (lshiftrt:VI48_512
13511           (match_operand:VI48_512 1 "register_operand")
13512           (match_operand:VI48_512 2 "nonimmediate_operand")))]
13513   "TARGET_AVX512F")
13514
13515 (define_expand "vlshr<mode>3"
13516   [(set (match_operand:VI48_256 0 "register_operand")
13517         (lshiftrt:VI48_256
13518           (match_operand:VI48_256 1 "register_operand")
13519           (match_operand:VI48_256 2 "nonimmediate_operand")))]
13520   "TARGET_AVX2")
13521
13522 (define_expand "vashr<mode>3"
13523   [(set (match_operand:VI128_128 0 "register_operand")
13524         (ashiftrt:VI128_128
13525           (match_operand:VI128_128 1 "register_operand")
13526           (match_operand:VI128_128 2 "nonimmediate_operand")))]
13527   "TARGET_XOP"
13528 {
13529   rtx neg = gen_reg_rtx (<MODE>mode);
13530   emit_insn (gen_neg<mode>2 (neg, operands[2]));
13531   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], neg));
13532   DONE;
13533 })
13534
13535 (define_expand "vashrv4si3"
13536   [(set (match_operand:V4SI 0 "register_operand")
13537         (ashiftrt:V4SI (match_operand:V4SI 1 "register_operand")
13538                        (match_operand:V4SI 2 "nonimmediate_operand")))]
13539   "TARGET_AVX2 || TARGET_XOP"
13540 {
13541   if (!TARGET_AVX2)
13542     {
13543       rtx neg = gen_reg_rtx (V4SImode);
13544       emit_insn (gen_negv4si2 (neg, operands[2]));
13545       emit_insn (gen_xop_shav4si3 (operands[0], operands[1], neg));
13546       DONE;
13547     }
13548 })
13549
13550 (define_expand "vashrv16si3"
13551   [(set (match_operand:V16SI 0 "register_operand")
13552         (ashiftrt:V16SI (match_operand:V16SI 1 "register_operand")
13553                         (match_operand:V16SI 2 "nonimmediate_operand")))]
13554   "TARGET_AVX512F")
13555
13556 (define_expand "vashrv8si3"
13557   [(set (match_operand:V8SI 0 "register_operand")
13558         (ashiftrt:V8SI (match_operand:V8SI 1 "register_operand")
13559                        (match_operand:V8SI 2 "nonimmediate_operand")))]
13560   "TARGET_AVX2")
13561
13562 (define_expand "vashl<mode>3"
13563   [(set (match_operand:VI12_128 0 "register_operand")
13564         (ashift:VI12_128
13565           (match_operand:VI12_128 1 "register_operand")
13566           (match_operand:VI12_128 2 "nonimmediate_operand")))]
13567   "TARGET_XOP"
13568 {
13569   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
13570   DONE;
13571 })
13572
13573 (define_expand "vashl<mode>3"
13574   [(set (match_operand:VI48_128 0 "register_operand")
13575         (ashift:VI48_128
13576           (match_operand:VI48_128 1 "register_operand")
13577           (match_operand:VI48_128 2 "nonimmediate_operand")))]
13578   "TARGET_AVX2 || TARGET_XOP"
13579 {
13580   if (!TARGET_AVX2)
13581     {
13582       operands[2] = force_reg (<MODE>mode, operands[2]);
13583       emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
13584       DONE;
13585     }
13586 })
13587
13588 (define_expand "vashl<mode>3"
13589   [(set (match_operand:VI48_512 0 "register_operand")
13590         (ashift:VI48_512
13591           (match_operand:VI48_512 1 "register_operand")
13592           (match_operand:VI48_512 2 "nonimmediate_operand")))]
13593   "TARGET_AVX512F")
13594
13595 (define_expand "vashl<mode>3"
13596   [(set (match_operand:VI48_256 0 "register_operand")
13597         (ashift:VI48_256
13598           (match_operand:VI48_256 1 "register_operand")
13599           (match_operand:VI48_256 2 "nonimmediate_operand")))]
13600   "TARGET_AVX2")
13601
13602 (define_insn "xop_sha<mode>3"
13603   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13604         (if_then_else:VI_128
13605          (ge:VI_128
13606           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13607           (const_int 0))
13608          (ashift:VI_128
13609           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13610           (match_dup 2))
13611          (ashiftrt:VI_128
13612           (match_dup 1)
13613           (neg:VI_128 (match_dup 2)))))]
13614   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13615   "vpsha<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13616   [(set_attr "type" "sseishft")
13617    (set_attr "prefix_data16" "0")
13618    (set_attr "prefix_extra" "2")
13619    (set_attr "mode" "TI")])
13620
13621 (define_insn "xop_shl<mode>3"
13622   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13623         (if_then_else:VI_128
13624          (ge:VI_128
13625           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13626           (const_int 0))
13627          (ashift:VI_128
13628           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13629           (match_dup 2))
13630          (lshiftrt:VI_128
13631           (match_dup 1)
13632           (neg:VI_128 (match_dup 2)))))]
13633   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13634   "vpshl<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13635   [(set_attr "type" "sseishft")
13636    (set_attr "prefix_data16" "0")
13637    (set_attr "prefix_extra" "2")
13638    (set_attr "mode" "TI")])
13639
13640 (define_expand "<shift_insn><mode>3"
13641   [(set (match_operand:VI1_AVX2 0 "register_operand")
13642         (any_shift:VI1_AVX2
13643           (match_operand:VI1_AVX2 1 "register_operand")
13644           (match_operand:SI 2 "nonmemory_operand")))]
13645   "TARGET_SSE2"
13646 {
13647   if (TARGET_XOP && <MODE>mode == V16QImode)
13648     {
13649       bool negate = false;
13650       rtx (*gen) (rtx, rtx, rtx);
13651       rtx tmp, par;
13652       int i;
13653
13654       if (<CODE> != ASHIFT)
13655         {
13656           if (CONST_INT_P (operands[2]))
13657             operands[2] = GEN_INT (-INTVAL (operands[2]));
13658           else
13659             negate = true;
13660         }
13661       par = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
13662       for (i = 0; i < 16; i++)
13663         XVECEXP (par, 0, i) = operands[2];
13664
13665       tmp = gen_reg_rtx (V16QImode);
13666       emit_insn (gen_vec_initv16qi (tmp, par));
13667
13668       if (negate)
13669         emit_insn (gen_negv16qi2 (tmp, tmp));
13670
13671       gen = (<CODE> == LSHIFTRT ? gen_xop_shlv16qi3 : gen_xop_shav16qi3);
13672       emit_insn (gen (operands[0], operands[1], tmp));
13673     }
13674   else
13675     ix86_expand_vecop_qihi (<CODE>, operands[0], operands[1], operands[2]);
13676   DONE;
13677 })
13678
13679 (define_expand "ashrv2di3"
13680   [(set (match_operand:V2DI 0 "register_operand")
13681         (ashiftrt:V2DI
13682           (match_operand:V2DI 1 "register_operand")
13683           (match_operand:DI 2 "nonmemory_operand")))]
13684   "TARGET_XOP"
13685 {
13686   rtx reg = gen_reg_rtx (V2DImode);
13687   rtx par;
13688   bool negate = false;
13689   int i;
13690
13691   if (CONST_INT_P (operands[2]))
13692     operands[2] = GEN_INT (-INTVAL (operands[2]));
13693   else
13694     negate = true;
13695
13696   par = gen_rtx_PARALLEL (V2DImode, rtvec_alloc (2));
13697   for (i = 0; i < 2; i++)
13698     XVECEXP (par, 0, i) = operands[2];
13699
13700   emit_insn (gen_vec_initv2di (reg, par));
13701
13702   if (negate)
13703     emit_insn (gen_negv2di2 (reg, reg));
13704
13705   emit_insn (gen_xop_shav2di3 (operands[0], operands[1], reg));
13706   DONE;
13707 })
13708
13709 ;; XOP FRCZ support
13710 (define_insn "xop_frcz<mode>2"
13711   [(set (match_operand:FMAMODE 0 "register_operand" "=x")
13712         (unspec:FMAMODE
13713          [(match_operand:FMAMODE 1 "nonimmediate_operand" "xm")]
13714          UNSPEC_FRCZ))]
13715   "TARGET_XOP"
13716   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
13717   [(set_attr "type" "ssecvt1")
13718    (set_attr "mode" "<MODE>")])
13719
13720 (define_expand "xop_vmfrcz<mode>2"
13721   [(set (match_operand:VF_128 0 "register_operand")
13722         (vec_merge:VF_128
13723           (unspec:VF_128
13724            [(match_operand:VF_128 1 "nonimmediate_operand")]
13725            UNSPEC_FRCZ)
13726           (match_dup 2)
13727           (const_int 1)))]
13728   "TARGET_XOP"
13729   "operands[2] = CONST0_RTX (<MODE>mode);")
13730
13731 (define_insn "*xop_vmfrcz<mode>2"
13732   [(set (match_operand:VF_128 0 "register_operand" "=x")
13733         (vec_merge:VF_128
13734           (unspec:VF_128
13735            [(match_operand:VF_128 1 "nonimmediate_operand" "xm")]
13736            UNSPEC_FRCZ)
13737           (match_operand:VF_128 2 "const0_operand")
13738           (const_int 1)))]
13739   "TARGET_XOP"
13740   "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}"
13741   [(set_attr "type" "ssecvt1")
13742    (set_attr "mode" "<MODE>")])
13743
13744 (define_insn "xop_maskcmp<mode>3"
13745   [(set (match_operand:VI_128 0 "register_operand" "=x")
13746         (match_operator:VI_128 1 "ix86_comparison_int_operator"
13747          [(match_operand:VI_128 2 "register_operand" "x")
13748           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
13749   "TARGET_XOP"
13750   "vpcom%Y1<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13751   [(set_attr "type" "sse4arg")
13752    (set_attr "prefix_data16" "0")
13753    (set_attr "prefix_rep" "0")
13754    (set_attr "prefix_extra" "2")
13755    (set_attr "length_immediate" "1")
13756    (set_attr "mode" "TI")])
13757
13758 (define_insn "xop_maskcmp_uns<mode>3"
13759   [(set (match_operand:VI_128 0 "register_operand" "=x")
13760         (match_operator:VI_128 1 "ix86_comparison_uns_operator"
13761          [(match_operand:VI_128 2 "register_operand" "x")
13762           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
13763   "TARGET_XOP"
13764   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13765   [(set_attr "type" "ssecmp")
13766    (set_attr "prefix_data16" "0")
13767    (set_attr "prefix_rep" "0")
13768    (set_attr "prefix_extra" "2")
13769    (set_attr "length_immediate" "1")
13770    (set_attr "mode" "TI")])
13771
13772 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
13773 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
13774 ;; the exact instruction generated for the intrinsic.
13775 (define_insn "xop_maskcmp_uns2<mode>3"
13776   [(set (match_operand:VI_128 0 "register_operand" "=x")
13777         (unspec:VI_128
13778          [(match_operator:VI_128 1 "ix86_comparison_uns_operator"
13779           [(match_operand:VI_128 2 "register_operand" "x")
13780            (match_operand:VI_128 3 "nonimmediate_operand" "xm")])]
13781          UNSPEC_XOP_UNSIGNED_CMP))]
13782   "TARGET_XOP"
13783   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13784   [(set_attr "type" "ssecmp")
13785    (set_attr "prefix_data16" "0")
13786    (set_attr "prefix_extra" "2")
13787    (set_attr "length_immediate" "1")
13788    (set_attr "mode" "TI")])
13789
13790 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
13791 ;; being added here to be complete.
13792 (define_insn "xop_pcom_tf<mode>3"
13793   [(set (match_operand:VI_128 0 "register_operand" "=x")
13794         (unspec:VI_128
13795           [(match_operand:VI_128 1 "register_operand" "x")
13796            (match_operand:VI_128 2 "nonimmediate_operand" "xm")
13797            (match_operand:SI 3 "const_int_operand" "n")]
13798           UNSPEC_XOP_TRUEFALSE))]
13799   "TARGET_XOP"
13800 {
13801   return ((INTVAL (operands[3]) != 0)
13802           ? "vpcomtrue<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13803           : "vpcomfalse<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}");
13804 }
13805   [(set_attr "type" "ssecmp")
13806    (set_attr "prefix_data16" "0")
13807    (set_attr "prefix_extra" "2")
13808    (set_attr "length_immediate" "1")
13809    (set_attr "mode" "TI")])
13810
13811 (define_insn "xop_vpermil2<mode>3"
13812   [(set (match_operand:VF_128_256 0 "register_operand" "=x")
13813         (unspec:VF_128_256
13814           [(match_operand:VF_128_256 1 "register_operand" "x")
13815            (match_operand:VF_128_256 2 "nonimmediate_operand" "%x")
13816            (match_operand:<sseintvecmode> 3 "nonimmediate_operand" "xm")
13817            (match_operand:SI 4 "const_0_to_3_operand" "n")]
13818           UNSPEC_VPERMIL2))]
13819   "TARGET_XOP"
13820   "vpermil2<ssemodesuffix>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
13821   [(set_attr "type" "sse4arg")
13822    (set_attr "length_immediate" "1")
13823    (set_attr "mode" "<MODE>")])
13824
13825 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13826
13827 (define_insn "aesenc"
13828   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13829         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13830                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13831                       UNSPEC_AESENC))]
13832   "TARGET_AES"
13833   "@
13834    aesenc\t{%2, %0|%0, %2}
13835    vaesenc\t{%2, %1, %0|%0, %1, %2}"
13836   [(set_attr "isa" "noavx,avx")
13837    (set_attr "type" "sselog1")
13838    (set_attr "prefix_extra" "1")
13839    (set_attr "prefix" "orig,vex")
13840    (set_attr "btver2_decode" "double,double")
13841    (set_attr "mode" "TI")])
13842
13843 (define_insn "aesenclast"
13844   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13845         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13846                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13847                       UNSPEC_AESENCLAST))]
13848   "TARGET_AES"
13849   "@
13850    aesenclast\t{%2, %0|%0, %2}
13851    vaesenclast\t{%2, %1, %0|%0, %1, %2}"
13852   [(set_attr "isa" "noavx,avx")
13853    (set_attr "type" "sselog1")
13854    (set_attr "prefix_extra" "1")
13855    (set_attr "prefix" "orig,vex")
13856    (set_attr "btver2_decode" "double,double")
13857    (set_attr "mode" "TI")])
13858
13859 (define_insn "aesdec"
13860   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13861         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13862                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13863                       UNSPEC_AESDEC))]
13864   "TARGET_AES"
13865   "@
13866    aesdec\t{%2, %0|%0, %2}
13867    vaesdec\t{%2, %1, %0|%0, %1, %2}"
13868   [(set_attr "isa" "noavx,avx")
13869    (set_attr "type" "sselog1")
13870    (set_attr "prefix_extra" "1")
13871    (set_attr "prefix" "orig,vex")
13872    (set_attr "btver2_decode" "double,double")
13873    (set_attr "mode" "TI")])
13874
13875 (define_insn "aesdeclast"
13876   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13877         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13878                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13879                       UNSPEC_AESDECLAST))]
13880   "TARGET_AES"
13881   "@
13882    aesdeclast\t{%2, %0|%0, %2}
13883    vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
13884   [(set_attr "isa" "noavx,avx")
13885    (set_attr "type" "sselog1")
13886    (set_attr "prefix_extra" "1")
13887    (set_attr "prefix" "orig,vex")
13888    (set_attr "btver2_decode" "double,double")
13889    (set_attr "mode" "TI")])
13890
13891 (define_insn "aesimc"
13892   [(set (match_operand:V2DI 0 "register_operand" "=x")
13893         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
13894                       UNSPEC_AESIMC))]
13895   "TARGET_AES"
13896   "%vaesimc\t{%1, %0|%0, %1}"
13897   [(set_attr "type" "sselog1")
13898    (set_attr "prefix_extra" "1")
13899    (set_attr "prefix" "maybe_vex")
13900    (set_attr "mode" "TI")])
13901
13902 (define_insn "aeskeygenassist"
13903   [(set (match_operand:V2DI 0 "register_operand" "=x")
13904         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
13905                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
13906                      UNSPEC_AESKEYGENASSIST))]
13907   "TARGET_AES"
13908   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
13909   [(set_attr "type" "sselog1")
13910    (set_attr "prefix_extra" "1")
13911    (set_attr "length_immediate" "1")
13912    (set_attr "prefix" "maybe_vex")
13913    (set_attr "mode" "TI")])
13914
13915 (define_insn "pclmulqdq"
13916   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13917         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13918                       (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")
13919                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
13920                      UNSPEC_PCLMUL))]
13921   "TARGET_PCLMUL"
13922   "@
13923    pclmulqdq\t{%3, %2, %0|%0, %2, %3}
13924    vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13925   [(set_attr "isa" "noavx,avx")
13926    (set_attr "type" "sselog1")
13927    (set_attr "prefix_extra" "1")
13928    (set_attr "length_immediate" "1")
13929    (set_attr "prefix" "orig,vex")
13930    (set_attr "mode" "TI")])
13931
13932 (define_expand "avx_vzeroall"
13933   [(match_par_dup 0 [(const_int 0)])]
13934   "TARGET_AVX"
13935 {
13936   int nregs = TARGET_64BIT ? 16 : 8;
13937   int regno;
13938
13939   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
13940
13941   XVECEXP (operands[0], 0, 0)
13942     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
13943                                UNSPECV_VZEROALL);
13944
13945   for (regno = 0; regno < nregs; regno++)
13946     XVECEXP (operands[0], 0, regno + 1)
13947       = gen_rtx_SET (VOIDmode,
13948                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
13949                      CONST0_RTX (V8SImode));
13950 })
13951
13952 (define_insn "*avx_vzeroall"
13953   [(match_parallel 0 "vzeroall_operation"
13954     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
13955   "TARGET_AVX"
13956   "vzeroall"
13957   [(set_attr "type" "sse")
13958    (set_attr "modrm" "0")
13959    (set_attr "memory" "none")
13960    (set_attr "prefix" "vex")
13961    (set_attr "btver2_decode" "vector")
13962    (set_attr "mode" "OI")])
13963
13964 ;; Clear the upper 128bits of AVX registers, equivalent to a NOP
13965 ;; if the upper 128bits are unused.
13966 (define_insn "avx_vzeroupper"
13967   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)]
13968   "TARGET_AVX"
13969   "vzeroupper"
13970   [(set_attr "type" "sse")
13971    (set_attr "modrm" "0")
13972    (set_attr "memory" "none")
13973    (set_attr "prefix" "vex")
13974    (set_attr "btver2_decode" "vector")
13975    (set_attr "mode" "OI")])
13976
13977 (define_insn "avx2_pbroadcast<mode>"
13978   [(set (match_operand:VI 0 "register_operand" "=x")
13979         (vec_duplicate:VI
13980           (vec_select:<ssescalarmode>
13981             (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "xm")
13982             (parallel [(const_int 0)]))))]
13983   "TARGET_AVX2"
13984   "vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}"
13985   [(set_attr "type" "ssemov")
13986    (set_attr "prefix_extra" "1")
13987    (set_attr "prefix" "vex")
13988    (set_attr "mode" "<sseinsnmode>")])
13989
13990 (define_insn "avx2_pbroadcast<mode>_1"
13991   [(set (match_operand:VI_256 0 "register_operand" "=x,x")
13992         (vec_duplicate:VI_256
13993           (vec_select:<ssescalarmode>
13994             (match_operand:VI_256 1 "nonimmediate_operand" "m,x")
13995             (parallel [(const_int 0)]))))]
13996   "TARGET_AVX2"
13997   "@
13998    vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}
13999    vpbroadcast<ssemodesuffix>\t{%x1, %0|%0, %x1}"
14000   [(set_attr "type" "ssemov")
14001    (set_attr "prefix_extra" "1")
14002    (set_attr "prefix" "vex")
14003    (set_attr "mode" "<sseinsnmode>")])
14004
14005 (define_insn "<avx2_avx512f>_permvar<mode><mask_name>"
14006   [(set (match_operand:VI48F_256_512 0 "register_operand" "=v")
14007         (unspec:VI48F_256_512
14008           [(match_operand:VI48F_256_512 1 "nonimmediate_operand" "vm")
14009            (match_operand:<sseintvecmode> 2 "register_operand" "v")]
14010           UNSPEC_VPERMVAR))]
14011   "TARGET_AVX2 && <mask_mode512bit_condition>"
14012   "vperm<ssemodesuffix>\t{%1, %2, %0<mask_operand3>|%0<mask_operand3>, %2, %1}"
14013   [(set_attr "type" "sselog")
14014    (set_attr "prefix" "<mask_prefix2>")
14015    (set_attr "mode" "<sseinsnmode>")])
14016
14017 (define_expand "<avx2_avx512f>_perm<mode>"
14018   [(match_operand:VI8F_256_512 0 "register_operand")
14019    (match_operand:VI8F_256_512 1 "nonimmediate_operand")
14020    (match_operand:SI 2 "const_0_to_255_operand")]
14021   "TARGET_AVX2"
14022 {
14023   int mask = INTVAL (operands[2]);
14024   emit_insn (gen_<avx2_avx512f>_perm<mode>_1 (operands[0], operands[1],
14025                                               GEN_INT ((mask >> 0) & 3),
14026                                               GEN_INT ((mask >> 2) & 3),
14027                                               GEN_INT ((mask >> 4) & 3),
14028                                               GEN_INT ((mask >> 6) & 3)));
14029   DONE;
14030 })
14031
14032 (define_expand "avx512f_perm<mode>_mask"
14033   [(match_operand:V8FI 0 "register_operand")
14034    (match_operand:V8FI 1 "nonimmediate_operand")
14035    (match_operand:SI 2 "const_0_to_255_operand")
14036    (match_operand:V8FI 3 "vector_move_operand")
14037    (match_operand:<avx512fmaskmode> 4 "register_operand")]
14038   "TARGET_AVX512F"
14039 {
14040   int mask = INTVAL (operands[2]);
14041   emit_insn (gen_<avx2_avx512f>_perm<mode>_1_mask (operands[0], operands[1],
14042                                                    GEN_INT ((mask >> 0) & 3),
14043                                                    GEN_INT ((mask >> 2) & 3),
14044                                                    GEN_INT ((mask >> 4) & 3),
14045                                                    GEN_INT ((mask >> 6) & 3),
14046                                                    operands[3], operands[4]));
14047   DONE;
14048 })
14049
14050 (define_insn "<avx2_avx512f>_perm<mode>_1<mask_name>"
14051   [(set (match_operand:VI8F_256_512 0 "register_operand" "=v")
14052         (vec_select:VI8F_256_512
14053           (match_operand:VI8F_256_512 1 "nonimmediate_operand" "vm")
14054           (parallel [(match_operand 2 "const_0_to_3_operand")
14055                      (match_operand 3 "const_0_to_3_operand")
14056                      (match_operand 4 "const_0_to_3_operand")
14057                      (match_operand 5 "const_0_to_3_operand")])))]
14058   "TARGET_AVX2 && <mask_mode512bit_condition>"
14059 {
14060   int mask = 0;
14061   mask |= INTVAL (operands[2]) << 0;
14062   mask |= INTVAL (operands[3]) << 2;
14063   mask |= INTVAL (operands[4]) << 4;
14064   mask |= INTVAL (operands[5]) << 6;
14065   operands[2] = GEN_INT (mask);
14066   return "vperm<ssemodesuffix>\t{%2, %1, %0<mask_operand6>|%0<mask_operand6>, %1, %2}";
14067 }
14068   [(set_attr "type" "sselog")
14069    (set_attr "prefix" "<mask_prefix2>")
14070    (set_attr "mode" "<sseinsnmode>")])
14071
14072 (define_insn "avx2_permv2ti"
14073   [(set (match_operand:V4DI 0 "register_operand" "=x")
14074         (unspec:V4DI
14075           [(match_operand:V4DI 1 "register_operand" "x")
14076            (match_operand:V4DI 2 "nonimmediate_operand" "xm")
14077            (match_operand:SI 3 "const_0_to_255_operand" "n")]
14078           UNSPEC_VPERMTI))]
14079   "TARGET_AVX2"
14080   "vperm2i128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
14081   [(set_attr "type" "sselog")
14082    (set_attr "prefix" "vex")
14083    (set_attr "mode" "OI")])
14084
14085 (define_insn "avx2_vec_dupv4df"
14086   [(set (match_operand:V4DF 0 "register_operand" "=x")
14087         (vec_duplicate:V4DF
14088           (vec_select:DF
14089             (match_operand:V2DF 1 "register_operand" "x")
14090             (parallel [(const_int 0)]))))]
14091   "TARGET_AVX2"
14092   "vbroadcastsd\t{%1, %0|%0, %1}"
14093   [(set_attr "type" "sselog1")
14094    (set_attr "prefix" "vex")
14095    (set_attr "mode" "V4DF")])
14096
14097 ;; Modes handled by AVX vec_dup patterns.
14098 (define_mode_iterator AVX_VEC_DUP_MODE
14099   [V8SI V8SF V4DI V4DF])
14100
14101 (define_insn "vec_dup<mode>"
14102   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand" "=x,x,x")
14103         (vec_duplicate:AVX_VEC_DUP_MODE
14104           (match_operand:<ssescalarmode> 1 "nonimmediate_operand" "m,x,?x")))]
14105   "TARGET_AVX"
14106   "@
14107    vbroadcast<ssescalarmodesuffix>\t{%1, %0|%0, %1}
14108    vbroadcast<ssescalarmodesuffix>\t{%x1, %0|%0, %x1}
14109    #"
14110   [(set_attr "type" "ssemov")
14111    (set_attr "prefix_extra" "1")
14112    (set_attr "prefix" "vex")
14113    (set_attr "isa" "*,avx2,noavx2")
14114    (set_attr "mode" "V8SF")])
14115
14116 (define_insn "<mask_codefor>avx512f_vec_dup<mode><mask_name>"
14117   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14118         (vec_duplicate:VI48F_512
14119           (vec_select:<ssescalarmode>
14120             (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "vm")
14121             (parallel [(const_int 0)]))))]
14122   "TARGET_AVX512F"
14123   "v<sseintprefix>broadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14124   [(set_attr "type" "ssemov")
14125    (set_attr "prefix" "evex")
14126    (set_attr "mode" "<sseinsnmode>")])
14127
14128 (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
14129   [(set (match_operand:V16FI 0 "register_operand" "=v,v")
14130         (vec_duplicate:V16FI
14131           (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "v,m")))]
14132   "TARGET_AVX512F"
14133   "@
14134    vshuf<shuffletype>32x4\t{$0x0, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x0}
14135    vbroadcast<shuffletype>32x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14136   [(set_attr "type" "ssemov")
14137    (set_attr "prefix" "evex")
14138    (set_attr "mode" "<sseinsnmode>")])
14139
14140 (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
14141   [(set (match_operand:V8FI 0 "register_operand" "=v,v")
14142         (vec_duplicate:V8FI
14143           (match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "v,m")))]
14144   "TARGET_AVX512F"
14145   "@
14146    vshuf<shuffletype>64x2\t{$0x44, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x44}
14147    vbroadcast<shuffletype>64x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14148   [(set_attr "type" "ssemov")
14149    (set_attr "prefix" "evex")
14150    (set_attr "mode" "<sseinsnmode>")])
14151
14152 (define_insn "<mask_codefor>avx512f_vec_dup_gpr<mode><mask_name>"
14153   [(set (match_operand:VI48_512 0 "register_operand" "=v")
14154         (vec_duplicate:VI48_512
14155           (match_operand:<ssescalarmode> 1 "register_operand" "r")))]
14156   "TARGET_AVX512F && (<MODE>mode != V8DImode || TARGET_64BIT)"
14157   "vpbroadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14158   [(set_attr "type" "ssemov")
14159    (set_attr "prefix" "evex")
14160    (set_attr "mode" "<sseinsnmode>")])
14161
14162 (define_insn "<mask_codefor>avx512f_vec_dup_mem<mode><mask_name>"
14163   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14164         (vec_duplicate:VI48F_512
14165           (match_operand:<ssescalarmode> 1 "nonimmediate_operand" "vm")))]
14166   "TARGET_AVX512F"
14167   "v<sseintprefix>broadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14168   [(set_attr "type" "ssemov")
14169    (set_attr "prefix" "evex")
14170    (set_attr "mode" "<sseinsnmode>")])
14171
14172 (define_insn "avx2_vbroadcasti128_<mode>"
14173   [(set (match_operand:VI_256 0 "register_operand" "=x")
14174         (vec_concat:VI_256
14175           (match_operand:<ssehalfvecmode> 1 "memory_operand" "m")
14176           (match_dup 1)))]
14177   "TARGET_AVX2"
14178   "vbroadcasti128\t{%1, %0|%0, %1}"
14179   [(set_attr "type" "ssemov")
14180    (set_attr "prefix_extra" "1")
14181    (set_attr "prefix" "vex")
14182    (set_attr "mode" "OI")])
14183
14184 (define_split
14185   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand")
14186         (vec_duplicate:AVX_VEC_DUP_MODE
14187           (match_operand:<ssescalarmode> 1 "register_operand")))]
14188   "TARGET_AVX && !TARGET_AVX2 && reload_completed"
14189   [(set (match_dup 2)
14190         (vec_duplicate:<ssehalfvecmode> (match_dup 1)))
14191    (set (match_dup 0)
14192         (vec_concat:AVX_VEC_DUP_MODE (match_dup 2) (match_dup 2)))]
14193   "operands[2] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[0]));")
14194
14195 (define_insn "avx_vbroadcastf128_<mode>"
14196   [(set (match_operand:V_256 0 "register_operand" "=x,x,x")
14197         (vec_concat:V_256
14198           (match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
14199           (match_dup 1)))]
14200   "TARGET_AVX"
14201   "@
14202    vbroadcast<i128>\t{%1, %0|%0, %1}
14203    vinsert<i128>\t{$1, %1, %0, %0|%0, %0, %1, 1}
14204    vperm2<i128>\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
14205   [(set_attr "type" "ssemov,sselog1,sselog1")
14206    (set_attr "prefix_extra" "1")
14207    (set_attr "length_immediate" "0,1,1")
14208    (set_attr "prefix" "vex")
14209    (set_attr "mode" "<sseinsnmode>")])
14210
14211 (define_insn "avx512cd_maskb_vec_dupv8di"
14212   [(set (match_operand:V8DI 0 "register_operand" "=v")
14213         (vec_duplicate:V8DI
14214           (zero_extend:DI
14215             (match_operand:QI 1 "register_operand" "Yk"))))]
14216   "TARGET_AVX512CD"
14217   "vpbroadcastmb2q\t{%1, %0|%0, %1}"
14218   [(set_attr "type" "mskmov")
14219    (set_attr "prefix" "evex")
14220    (set_attr "mode" "XI")])
14221
14222 (define_insn "avx512cd_maskw_vec_dupv16si"
14223   [(set (match_operand:V16SI 0 "register_operand" "=v")
14224         (vec_duplicate:V16SI
14225           (zero_extend:SI
14226             (match_operand:HI 1 "register_operand" "Yk"))))]
14227   "TARGET_AVX512CD"
14228   "vpbroadcastmw2d\t{%1, %0|%0, %1}"
14229   [(set_attr "type" "mskmov")
14230    (set_attr "prefix" "evex")
14231    (set_attr "mode" "XI")])
14232
14233 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
14234 ;; If it so happens that the input is in memory, use vbroadcast.
14235 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
14236 (define_insn "*avx_vperm_broadcast_v4sf"
14237   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
14238         (vec_select:V4SF
14239           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
14240           (match_parallel 2 "avx_vbroadcast_operand"
14241             [(match_operand 3 "const_int_operand" "C,n,n")])))]
14242   "TARGET_AVX"
14243 {
14244   int elt = INTVAL (operands[3]);
14245   switch (which_alternative)
14246     {
14247     case 0:
14248     case 1:
14249       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
14250       return "vbroadcastss\t{%1, %0|%0, %k1}";
14251     case 2:
14252       operands[2] = GEN_INT (elt * 0x55);
14253       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
14254     default:
14255       gcc_unreachable ();
14256     }
14257 }
14258   [(set_attr "type" "ssemov,ssemov,sselog1")
14259    (set_attr "prefix_extra" "1")
14260    (set_attr "length_immediate" "0,0,1")
14261    (set_attr "prefix" "vex")
14262    (set_attr "mode" "SF,SF,V4SF")])
14263
14264 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
14265   [(set (match_operand:VF_256 0 "register_operand" "=x,x,x")
14266         (vec_select:VF_256
14267           (match_operand:VF_256 1 "nonimmediate_operand" "m,o,?x")
14268           (match_parallel 2 "avx_vbroadcast_operand"
14269             [(match_operand 3 "const_int_operand" "C,n,n")])))]
14270   "TARGET_AVX"
14271   "#"
14272   "&& reload_completed && (<MODE>mode != V4DFmode || !TARGET_AVX2)"
14273   [(set (match_dup 0) (vec_duplicate:VF_256 (match_dup 1)))]
14274 {
14275   rtx op0 = operands[0], op1 = operands[1];
14276   int elt = INTVAL (operands[3]);
14277
14278   if (REG_P (op1))
14279     {
14280       int mask;
14281
14282       if (TARGET_AVX2 && elt == 0)
14283         {
14284           emit_insn (gen_vec_dup<mode> (op0, gen_lowpart (<ssescalarmode>mode,
14285                                                           op1)));
14286           DONE;
14287         }
14288
14289       /* Shuffle element we care about into all elements of the 128-bit lane.
14290          The other lane gets shuffled too, but we don't care.  */
14291       if (<MODE>mode == V4DFmode)
14292         mask = (elt & 1 ? 15 : 0);
14293       else
14294         mask = (elt & 3) * 0x55;
14295       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
14296
14297       /* Shuffle the lane we care about into both lanes of the dest.  */
14298       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
14299       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
14300       DONE;
14301     }
14302
14303   operands[1] = adjust_address (op1, <ssescalarmode>mode,
14304                                 elt * GET_MODE_SIZE (<ssescalarmode>mode));
14305 })
14306
14307 (define_expand "<sse2_avx_avx512f>_vpermil<mode><mask_name>"
14308   [(set (match_operand:VF2 0 "register_operand")
14309         (vec_select:VF2
14310           (match_operand:VF2 1 "nonimmediate_operand")
14311           (match_operand:SI 2 "const_0_to_255_operand")))]
14312   "TARGET_AVX && <mask_mode512bit_condition>"
14313 {
14314   int mask = INTVAL (operands[2]);
14315   rtx perm[<ssescalarnum>];
14316
14317   int i;
14318   for (i = 0; i < <ssescalarnum>; i = i + 2)
14319     {
14320       perm[i]     = GEN_INT (((mask >> i)       & 1) + i);
14321       perm[i + 1] = GEN_INT (((mask >> (i + 1)) & 1) + i);
14322     }
14323
14324   operands[2]
14325     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
14326 })
14327
14328 (define_expand "<sse2_avx_avx512f>_vpermil<mode><mask_name>"
14329   [(set (match_operand:VF1 0 "register_operand")
14330         (vec_select:VF1
14331           (match_operand:VF1 1 "nonimmediate_operand")
14332           (match_operand:SI 2 "const_0_to_255_operand")))]
14333   "TARGET_AVX && <mask_mode512bit_condition>"
14334 {
14335   int mask = INTVAL (operands[2]);
14336   rtx perm[<ssescalarnum>];
14337
14338   int i;
14339   for (i = 0; i < <ssescalarnum>; i = i + 4)
14340     {
14341       perm[i]     = GEN_INT (((mask >> 0) & 3) + i);
14342       perm[i + 1] = GEN_INT (((mask >> 2) & 3) + i);
14343       perm[i + 2] = GEN_INT (((mask >> 4) & 3) + i);
14344       perm[i + 3] = GEN_INT (((mask >> 6) & 3) + i);
14345     }
14346
14347   operands[2]
14348     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
14349 })
14350
14351 (define_insn "*<sse2_avx_avx512f>_vpermilp<mode><mask_name>"
14352   [(set (match_operand:VF 0 "register_operand" "=v")
14353         (vec_select:VF
14354           (match_operand:VF 1 "nonimmediate_operand" "vm")
14355           (match_parallel 2 ""
14356             [(match_operand 3 "const_int_operand")])))]
14357   "TARGET_AVX && <mask_mode512bit_condition>
14358    && avx_vpermilp_parallel (operands[2], <MODE>mode)"
14359 {
14360   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
14361   operands[2] = GEN_INT (mask);
14362   return "vpermil<ssemodesuffix>\t{%2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2}";
14363 }
14364   [(set_attr "type" "sselog")
14365    (set_attr "prefix_extra" "1")
14366    (set_attr "length_immediate" "1")
14367    (set_attr "prefix" "<mask_prefix>")
14368    (set_attr "mode" "<sseinsnmode>")])
14369
14370 (define_insn "<sse2_avx_avx512f>_vpermilvar<mode>3<mask_name>"
14371   [(set (match_operand:VF 0 "register_operand" "=v")
14372         (unspec:VF
14373           [(match_operand:VF 1 "register_operand" "v")
14374            (match_operand:<sseintvecmode> 2 "nonimmediate_operand" "vm")]
14375           UNSPEC_VPERMIL))]
14376   "TARGET_AVX && <mask_mode512bit_condition>"
14377   "vpermil<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14378   [(set_attr "type" "sselog")
14379    (set_attr "prefix_extra" "1")
14380    (set_attr "btver2_decode" "vector")
14381    (set_attr "prefix" "<mask_prefix>")
14382    (set_attr "mode" "<sseinsnmode>")])
14383
14384 (define_expand "avx512f_vpermi2var<mode>3_maskz"
14385   [(match_operand:VI48F_512 0 "register_operand" "=v")
14386    (match_operand:VI48F_512 1 "register_operand" "v")
14387    (match_operand:<sseintvecmode> 2 "register_operand" "0")
14388    (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")
14389    (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")]
14390   "TARGET_AVX512F"
14391 {
14392   emit_insn (gen_avx512f_vpermi2var<mode>3_maskz_1 (
14393         operands[0], operands[1], operands[2], operands[3],
14394         CONST0_RTX (<MODE>mode), operands[4]));
14395   DONE;
14396 })
14397
14398 (define_insn "avx512f_vpermi2var<mode>3<sd_maskz_name>"
14399   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14400         (unspec:VI48F_512
14401           [(match_operand:VI48F_512 1 "register_operand" "v")
14402            (match_operand:<sseintvecmode> 2 "register_operand" "0")
14403            (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14404           UNSPEC_VPERMI2))]
14405   "TARGET_AVX512F"
14406   "vpermi2<ssemodesuffix>\t{%3, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %3}"
14407   [(set_attr "type" "sselog")
14408    (set_attr "prefix" "evex")
14409    (set_attr "mode" "<sseinsnmode>")])
14410
14411 (define_insn "avx512f_vpermi2var<mode>3_mask"
14412   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14413         (vec_merge:VI48F_512
14414           (unspec:VI48F_512
14415             [(match_operand:VI48F_512 1 "register_operand" "v")
14416             (match_operand:<sseintvecmode> 2 "register_operand" "0")
14417             (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14418             UNSPEC_VPERMI2_MASK)
14419           (match_dup 0)
14420           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
14421   "TARGET_AVX512F"
14422   "vpermi2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
14423   [(set_attr "type" "sselog")
14424    (set_attr "prefix" "evex")
14425    (set_attr "mode" "<sseinsnmode>")])
14426
14427 (define_expand "avx512f_vpermt2var<mode>3_maskz"
14428   [(match_operand:VI48F_512 0 "register_operand" "=v")
14429    (match_operand:<sseintvecmode> 1 "register_operand" "v")
14430    (match_operand:VI48F_512 2 "register_operand" "0")
14431    (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")
14432    (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")]
14433   "TARGET_AVX512F"
14434 {
14435   emit_insn (gen_avx512f_vpermt2var<mode>3_maskz_1 (
14436         operands[0], operands[1], operands[2], operands[3],
14437         CONST0_RTX (<MODE>mode), operands[4]));
14438   DONE;
14439 })
14440
14441 (define_insn "avx512f_vpermt2var<mode>3<sd_maskz_name>"
14442   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14443         (unspec:VI48F_512
14444           [(match_operand:<sseintvecmode> 1 "register_operand" "v")
14445            (match_operand:VI48F_512 2 "register_operand" "0")
14446            (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14447           UNSPEC_VPERMT2))]
14448   "TARGET_AVX512F"
14449   "vpermt2<ssemodesuffix>\t{%3, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %3}"
14450   [(set_attr "type" "sselog")
14451    (set_attr "prefix" "evex")
14452    (set_attr "mode" "<sseinsnmode>")])
14453
14454 (define_insn "avx512f_vpermt2var<mode>3_mask"
14455   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14456         (vec_merge:VI48F_512
14457           (unspec:VI48F_512
14458             [(match_operand:<sseintvecmode> 1 "register_operand" "v")
14459             (match_operand:VI48F_512 2 "register_operand" "0")
14460             (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14461             UNSPEC_VPERMT2)
14462           (match_dup 2)
14463           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
14464   "TARGET_AVX512F"
14465   "vpermt2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
14466   [(set_attr "type" "sselog")
14467    (set_attr "prefix" "evex")
14468    (set_attr "mode" "<sseinsnmode>")])
14469
14470 (define_expand "avx_vperm2f128<mode>3"
14471   [(set (match_operand:AVX256MODE2P 0 "register_operand")
14472         (unspec:AVX256MODE2P
14473           [(match_operand:AVX256MODE2P 1 "register_operand")
14474            (match_operand:AVX256MODE2P 2 "nonimmediate_operand")
14475            (match_operand:SI 3 "const_0_to_255_operand")]
14476           UNSPEC_VPERMIL2F128))]
14477   "TARGET_AVX"
14478 {
14479   int mask = INTVAL (operands[3]);
14480   if ((mask & 0x88) == 0)
14481     {
14482       rtx perm[<ssescalarnum>], t1, t2;
14483       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
14484
14485       base = (mask & 3) * nelt2;
14486       for (i = 0; i < nelt2; ++i)
14487         perm[i] = GEN_INT (base + i);
14488
14489       base = ((mask >> 4) & 3) * nelt2;
14490       for (i = 0; i < nelt2; ++i)
14491         perm[i + nelt2] = GEN_INT (base + i);
14492
14493       t2 = gen_rtx_VEC_CONCAT (<ssedoublevecmode>mode,
14494                                operands[1], operands[2]);
14495       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
14496       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
14497       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
14498       emit_insn (t2);
14499       DONE;
14500     }
14501 })
14502
14503 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
14504 ;; means that in order to represent this properly in rtl we'd have to
14505 ;; nest *another* vec_concat with a zero operand and do the select from
14506 ;; a 4x wide vector.  That doesn't seem very nice.
14507 (define_insn "*avx_vperm2f128<mode>_full"
14508   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
14509         (unspec:AVX256MODE2P
14510           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
14511            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
14512            (match_operand:SI 3 "const_0_to_255_operand" "n")]
14513           UNSPEC_VPERMIL2F128))]
14514   "TARGET_AVX"
14515   "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
14516   [(set_attr "type" "sselog")
14517    (set_attr "prefix_extra" "1")
14518    (set_attr "length_immediate" "1")
14519    (set_attr "prefix" "vex")
14520    (set_attr "mode" "<sseinsnmode>")])
14521
14522 (define_insn "*avx_vperm2f128<mode>_nozero"
14523   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
14524         (vec_select:AVX256MODE2P
14525           (vec_concat:<ssedoublevecmode>
14526             (match_operand:AVX256MODE2P 1 "register_operand" "x")
14527             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
14528           (match_parallel 3 ""
14529             [(match_operand 4 "const_int_operand")])))]
14530   "TARGET_AVX
14531    && avx_vperm2f128_parallel (operands[3], <MODE>mode)"
14532 {
14533   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
14534   if (mask == 0x12)
14535     return "vinsert<i128>\t{$0, %x2, %1, %0|%0, %1, %x2, 0}";
14536   if (mask == 0x20)
14537     return "vinsert<i128>\t{$1, %x2, %1, %0|%0, %1, %x2, 1}";
14538   operands[3] = GEN_INT (mask);
14539   return "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
14540 }
14541   [(set_attr "type" "sselog")
14542    (set_attr "prefix_extra" "1")
14543    (set_attr "length_immediate" "1")
14544    (set_attr "prefix" "vex")
14545    (set_attr "mode" "<sseinsnmode>")])
14546
14547 (define_expand "avx_vinsertf128<mode>"
14548   [(match_operand:V_256 0 "register_operand")
14549    (match_operand:V_256 1 "register_operand")
14550    (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand")
14551    (match_operand:SI 3 "const_0_to_1_operand")]
14552   "TARGET_AVX"
14553 {
14554   rtx (*insn)(rtx, rtx, rtx);
14555
14556   switch (INTVAL (operands[3]))
14557     {
14558     case 0:
14559       insn = gen_vec_set_lo_<mode>;
14560       break;
14561     case 1:
14562       insn = gen_vec_set_hi_<mode>;
14563       break;
14564     default:
14565       gcc_unreachable ();
14566     }
14567
14568   emit_insn (insn (operands[0], operands[1], operands[2]));
14569   DONE;
14570 })
14571
14572 (define_insn "avx2_vec_set_lo_v4di"
14573   [(set (match_operand:V4DI 0 "register_operand" "=x")
14574         (vec_concat:V4DI
14575           (match_operand:V2DI 2 "nonimmediate_operand" "xm")
14576           (vec_select:V2DI
14577             (match_operand:V4DI 1 "register_operand" "x")
14578             (parallel [(const_int 2) (const_int 3)]))))]
14579   "TARGET_AVX2"
14580   "vinserti128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14581   [(set_attr "type" "sselog")
14582    (set_attr "prefix_extra" "1")
14583    (set_attr "length_immediate" "1")
14584    (set_attr "prefix" "vex")
14585    (set_attr "mode" "OI")])
14586
14587 (define_insn "avx2_vec_set_hi_v4di"
14588   [(set (match_operand:V4DI 0 "register_operand" "=x")
14589         (vec_concat:V4DI
14590           (vec_select:V2DI
14591             (match_operand:V4DI 1 "register_operand" "x")
14592             (parallel [(const_int 0) (const_int 1)]))
14593           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
14594   "TARGET_AVX2"
14595   "vinserti128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14596   [(set_attr "type" "sselog")
14597    (set_attr "prefix_extra" "1")
14598    (set_attr "length_immediate" "1")
14599    (set_attr "prefix" "vex")
14600    (set_attr "mode" "OI")])
14601
14602 (define_insn "vec_set_lo_<mode>"
14603   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
14604         (vec_concat:VI8F_256
14605           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
14606           (vec_select:<ssehalfvecmode>
14607             (match_operand:VI8F_256 1 "register_operand" "x")
14608             (parallel [(const_int 2) (const_int 3)]))))]
14609   "TARGET_AVX"
14610   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14611   [(set_attr "type" "sselog")
14612    (set_attr "prefix_extra" "1")
14613    (set_attr "length_immediate" "1")
14614    (set_attr "prefix" "vex")
14615    (set_attr "mode" "<sseinsnmode>")])
14616
14617 (define_insn "vec_set_hi_<mode>"
14618   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
14619         (vec_concat:VI8F_256
14620           (vec_select:<ssehalfvecmode>
14621             (match_operand:VI8F_256 1 "register_operand" "x")
14622             (parallel [(const_int 0) (const_int 1)]))
14623           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
14624   "TARGET_AVX"
14625   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14626   [(set_attr "type" "sselog")
14627    (set_attr "prefix_extra" "1")
14628    (set_attr "length_immediate" "1")
14629    (set_attr "prefix" "vex")
14630    (set_attr "mode" "<sseinsnmode>")])
14631
14632 (define_insn "vec_set_lo_<mode>"
14633   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
14634         (vec_concat:VI4F_256
14635           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
14636           (vec_select:<ssehalfvecmode>
14637             (match_operand:VI4F_256 1 "register_operand" "x")
14638             (parallel [(const_int 4) (const_int 5)
14639                        (const_int 6) (const_int 7)]))))]
14640   "TARGET_AVX"
14641   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14642   [(set_attr "type" "sselog")
14643    (set_attr "prefix_extra" "1")
14644    (set_attr "length_immediate" "1")
14645    (set_attr "prefix" "vex")
14646    (set_attr "mode" "<sseinsnmode>")])
14647
14648 (define_insn "vec_set_hi_<mode>"
14649   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
14650         (vec_concat:VI4F_256
14651           (vec_select:<ssehalfvecmode>
14652             (match_operand:VI4F_256 1 "register_operand" "x")
14653             (parallel [(const_int 0) (const_int 1)
14654                        (const_int 2) (const_int 3)]))
14655           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
14656   "TARGET_AVX"
14657   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14658   [(set_attr "type" "sselog")
14659    (set_attr "prefix_extra" "1")
14660    (set_attr "length_immediate" "1")
14661    (set_attr "prefix" "vex")
14662    (set_attr "mode" "<sseinsnmode>")])
14663
14664 (define_insn "vec_set_lo_v16hi"
14665   [(set (match_operand:V16HI 0 "register_operand" "=x")
14666         (vec_concat:V16HI
14667           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
14668           (vec_select:V8HI
14669             (match_operand:V16HI 1 "register_operand" "x")
14670             (parallel [(const_int 8) (const_int 9)
14671                        (const_int 10) (const_int 11)
14672                        (const_int 12) (const_int 13)
14673                        (const_int 14) (const_int 15)]))))]
14674   "TARGET_AVX"
14675   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14676   [(set_attr "type" "sselog")
14677    (set_attr "prefix_extra" "1")
14678    (set_attr "length_immediate" "1")
14679    (set_attr "prefix" "vex")
14680    (set_attr "mode" "OI")])
14681
14682 (define_insn "vec_set_hi_v16hi"
14683   [(set (match_operand:V16HI 0 "register_operand" "=x")
14684         (vec_concat:V16HI
14685           (vec_select:V8HI
14686             (match_operand:V16HI 1 "register_operand" "x")
14687             (parallel [(const_int 0) (const_int 1)
14688                        (const_int 2) (const_int 3)
14689                        (const_int 4) (const_int 5)
14690                        (const_int 6) (const_int 7)]))
14691           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
14692   "TARGET_AVX"
14693   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14694   [(set_attr "type" "sselog")
14695    (set_attr "prefix_extra" "1")
14696    (set_attr "length_immediate" "1")
14697    (set_attr "prefix" "vex")
14698    (set_attr "mode" "OI")])
14699
14700 (define_insn "vec_set_lo_v32qi"
14701   [(set (match_operand:V32QI 0 "register_operand" "=x")
14702         (vec_concat:V32QI
14703           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
14704           (vec_select:V16QI
14705             (match_operand:V32QI 1 "register_operand" "x")
14706             (parallel [(const_int 16) (const_int 17)
14707                        (const_int 18) (const_int 19)
14708                        (const_int 20) (const_int 21)
14709                        (const_int 22) (const_int 23)
14710                        (const_int 24) (const_int 25)
14711                        (const_int 26) (const_int 27)
14712                        (const_int 28) (const_int 29)
14713                        (const_int 30) (const_int 31)]))))]
14714   "TARGET_AVX"
14715   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14716   [(set_attr "type" "sselog")
14717    (set_attr "prefix_extra" "1")
14718    (set_attr "length_immediate" "1")
14719    (set_attr "prefix" "vex")
14720    (set_attr "mode" "OI")])
14721
14722 (define_insn "vec_set_hi_v32qi"
14723   [(set (match_operand:V32QI 0 "register_operand" "=x")
14724         (vec_concat:V32QI
14725           (vec_select:V16QI
14726             (match_operand:V32QI 1 "register_operand" "x")
14727             (parallel [(const_int 0) (const_int 1)
14728                        (const_int 2) (const_int 3)
14729                        (const_int 4) (const_int 5)
14730                        (const_int 6) (const_int 7)
14731                        (const_int 8) (const_int 9)
14732                        (const_int 10) (const_int 11)
14733                        (const_int 12) (const_int 13)
14734                        (const_int 14) (const_int 15)]))
14735           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
14736   "TARGET_AVX"
14737   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14738   [(set_attr "type" "sselog")
14739    (set_attr "prefix_extra" "1")
14740    (set_attr "length_immediate" "1")
14741    (set_attr "prefix" "vex")
14742    (set_attr "mode" "OI")])
14743
14744 (define_insn "<avx_avx2>_maskload<ssemodesuffix><avxsizesuffix>"
14745   [(set (match_operand:V48_AVX2 0 "register_operand" "=x")
14746         (unspec:V48_AVX2
14747           [(match_operand:<sseintvecmode> 2 "register_operand" "x")
14748            (match_operand:V48_AVX2 1 "memory_operand" "m")]
14749           UNSPEC_MASKMOV))]
14750   "TARGET_AVX"
14751   "v<sseintprefix>maskmov<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
14752   [(set_attr "type" "sselog1")
14753    (set_attr "prefix_extra" "1")
14754    (set_attr "prefix" "vex")
14755    (set_attr "btver2_decode" "vector")
14756    (set_attr "mode" "<sseinsnmode>")])
14757
14758 (define_insn "<avx_avx2>_maskstore<ssemodesuffix><avxsizesuffix>"
14759   [(set (match_operand:V48_AVX2 0 "memory_operand" "+m")
14760         (unspec:V48_AVX2
14761           [(match_operand:<sseintvecmode> 1 "register_operand" "x")
14762            (match_operand:V48_AVX2 2 "register_operand" "x")
14763            (match_dup 0)]
14764           UNSPEC_MASKMOV))]
14765   "TARGET_AVX"
14766   "v<sseintprefix>maskmov<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
14767   [(set_attr "type" "sselog1")
14768    (set_attr "prefix_extra" "1")
14769    (set_attr "prefix" "vex")
14770    (set_attr "btver2_decode" "vector")
14771    (set_attr "mode" "<sseinsnmode>")])
14772
14773 (define_expand "maskload<mode>"
14774   [(set (match_operand:V48_AVX2 0 "register_operand")
14775         (unspec:V48_AVX2
14776           [(match_operand:<sseintvecmode> 2 "register_operand")
14777            (match_operand:V48_AVX2 1 "memory_operand")]
14778           UNSPEC_MASKMOV))]
14779   "TARGET_AVX")
14780
14781 (define_expand "maskstore<mode>"
14782   [(set (match_operand:V48_AVX2 0 "memory_operand")
14783         (unspec:V48_AVX2
14784           [(match_operand:<sseintvecmode> 2 "register_operand")
14785            (match_operand:V48_AVX2 1 "register_operand")
14786            (match_dup 0)]
14787           UNSPEC_MASKMOV))]
14788   "TARGET_AVX")
14789
14790 (define_insn_and_split "avx_<castmode><avxsizesuffix>_<castmode>"
14791   [(set (match_operand:AVX256MODE2P 0 "nonimmediate_operand" "=x,m")
14792         (unspec:AVX256MODE2P
14793           [(match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "xm,x")]
14794           UNSPEC_CAST))]
14795   "TARGET_AVX"
14796   "#"
14797   "&& reload_completed"
14798   [(const_int 0)]
14799 {
14800   rtx op0 = operands[0];
14801   rtx op1 = operands[1];
14802   if (REG_P (op0))
14803     op0 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op0));
14804   else
14805     op1 = gen_rtx_REG (<MODE>mode, REGNO (op1));
14806   emit_move_insn (op0, op1);
14807   DONE;
14808 })
14809
14810 (define_expand "vec_init<mode>"
14811   [(match_operand:V_256 0 "register_operand")
14812    (match_operand 1)]
14813   "TARGET_AVX"
14814 {
14815   ix86_expand_vector_init (false, operands[0], operands[1]);
14816   DONE;
14817 })
14818
14819 (define_expand "vec_init<mode>"
14820   [(match_operand:VI48F_512 0 "register_operand")
14821    (match_operand 1)]
14822   "TARGET_AVX512F"
14823 {
14824   ix86_expand_vector_init (false, operands[0], operands[1]);
14825   DONE;
14826 })
14827
14828 (define_expand "avx2_extracti128"
14829   [(match_operand:V2DI 0 "nonimmediate_operand")
14830    (match_operand:V4DI 1 "register_operand")
14831    (match_operand:SI 2 "const_0_to_1_operand")]
14832   "TARGET_AVX2"
14833 {
14834   rtx (*insn)(rtx, rtx);
14835
14836   switch (INTVAL (operands[2]))
14837     {
14838     case 0:
14839       insn = gen_vec_extract_lo_v4di;
14840       break;
14841     case 1:
14842       insn = gen_vec_extract_hi_v4di;
14843       break;
14844     default:
14845       gcc_unreachable ();
14846     }
14847
14848   emit_insn (insn (operands[0], operands[1]));
14849   DONE;
14850 })
14851
14852 (define_expand "avx2_inserti128"
14853   [(match_operand:V4DI 0 "register_operand")
14854    (match_operand:V4DI 1 "register_operand")
14855    (match_operand:V2DI 2 "nonimmediate_operand")
14856    (match_operand:SI 3 "const_0_to_1_operand")]
14857   "TARGET_AVX2"
14858 {
14859   rtx (*insn)(rtx, rtx, rtx);
14860
14861   switch (INTVAL (operands[3]))
14862     {
14863     case 0:
14864       insn = gen_avx2_vec_set_lo_v4di;
14865       break;
14866     case 1:
14867       insn = gen_avx2_vec_set_hi_v4di;
14868       break;
14869     default:
14870       gcc_unreachable ();
14871     }
14872
14873   emit_insn (insn (operands[0], operands[1], operands[2]));
14874   DONE;
14875 })
14876
14877 (define_insn "<avx2_avx512f>_ashrv<mode><mask_name>"
14878   [(set (match_operand:VI48_AVX512F 0 "register_operand" "=v")
14879         (ashiftrt:VI48_AVX512F
14880           (match_operand:VI48_AVX512F 1 "register_operand" "v")
14881           (match_operand:VI48_AVX512F 2 "nonimmediate_operand" "vm")))]
14882   "TARGET_AVX2 && <mask_mode512bit_condition>"
14883   "vpsrav<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14884   [(set_attr "type" "sseishft")
14885    (set_attr "prefix" "maybe_evex")
14886    (set_attr "mode" "<sseinsnmode>")])
14887
14888 (define_insn "<avx2_avx512f>_<shift_insn>v<mode><mask_name>"
14889   [(set (match_operand:VI48_AVX2_48_AVX512F 0 "register_operand" "=v")
14890         (any_lshift:VI48_AVX2_48_AVX512F
14891           (match_operand:VI48_AVX2_48_AVX512F 1 "register_operand" "v")
14892           (match_operand:VI48_AVX2_48_AVX512F 2 "nonimmediate_operand" "vm")))]
14893   "TARGET_AVX2 && <mask_mode512bit_condition>"
14894   "vp<vshift>v<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14895   [(set_attr "type" "sseishft")
14896    (set_attr "prefix" "maybe_evex")
14897    (set_attr "mode" "<sseinsnmode>")])
14898
14899 ;; For avx_vec_concat<mode> insn pattern
14900 (define_mode_attr concat_tg_mode
14901   [(V32QI "t") (V16HI "t") (V8SI "t") (V4DI "t") (V8SF "t") (V4DF "t")
14902    (V64QI "g") (V32HI "g") (V16SI "g") (V8DI "g") (V16SF "g") (V8DF "g")])
14903
14904 (define_insn "avx_vec_concat<mode>"
14905   [(set (match_operand:V_256_512 0 "register_operand" "=x,x")
14906         (vec_concat:V_256_512
14907           (match_operand:<ssehalfvecmode> 1 "register_operand" "x,x")
14908           (match_operand:<ssehalfvecmode> 2 "vector_move_operand" "xm,C")))]
14909   "TARGET_AVX"
14910 {
14911   switch (which_alternative)
14912     {
14913     case 0:
14914       return "vinsert<i128>\t{$0x1, %2, %<concat_tg_mode>1, %0|%0, %<concat_tg_mode>1, %2, 0x1}";
14915     case 1:
14916       switch (get_attr_mode (insn))
14917         {
14918         case MODE_V16SF:
14919           return "vmovaps\t{%1, %t0|%t0, %1}";
14920         case MODE_V8DF:
14921           return "vmovapd\t{%1, %t0|%t0, %1}";
14922         case MODE_V8SF:
14923           return "vmovaps\t{%1, %x0|%x0, %1}";
14924         case MODE_V4DF:
14925           return "vmovapd\t{%1, %x0|%x0, %1}";
14926         case MODE_XI:
14927           return "vmovdqa\t{%1, %t0|%t0, %1}";
14928         case MODE_OI:
14929           return "vmovdqa\t{%1, %x0|%x0, %1}";
14930         default:
14931           gcc_unreachable ();
14932         }
14933     default:
14934       gcc_unreachable ();
14935     }
14936 }
14937   [(set_attr "type" "sselog,ssemov")
14938    (set_attr "prefix_extra" "1,*")
14939    (set_attr "length_immediate" "1,*")
14940    (set_attr "prefix" "maybe_evex")
14941    (set_attr "mode" "<sseinsnmode>")])
14942
14943 (define_insn "vcvtph2ps"
14944   [(set (match_operand:V4SF 0 "register_operand" "=x")
14945         (vec_select:V4SF
14946           (unspec:V8SF [(match_operand:V8HI 1 "register_operand" "x")]
14947                        UNSPEC_VCVTPH2PS)
14948           (parallel [(const_int 0) (const_int 1)
14949                      (const_int 2) (const_int 3)])))]
14950   "TARGET_F16C"
14951   "vcvtph2ps\t{%1, %0|%0, %1}"
14952   [(set_attr "type" "ssecvt")
14953    (set_attr "prefix" "vex")
14954    (set_attr "mode" "V4SF")])
14955
14956 (define_insn "*vcvtph2ps_load"
14957   [(set (match_operand:V4SF 0 "register_operand" "=x")
14958         (unspec:V4SF [(match_operand:V4HI 1 "memory_operand" "m")]
14959                      UNSPEC_VCVTPH2PS))]
14960   "TARGET_F16C"
14961   "vcvtph2ps\t{%1, %0|%0, %1}"
14962   [(set_attr "type" "ssecvt")
14963    (set_attr "prefix" "vex")
14964    (set_attr "mode" "V8SF")])
14965
14966 (define_insn "vcvtph2ps256"
14967   [(set (match_operand:V8SF 0 "register_operand" "=x")
14968         (unspec:V8SF [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
14969                      UNSPEC_VCVTPH2PS))]
14970   "TARGET_F16C"
14971   "vcvtph2ps\t{%1, %0|%0, %1}"
14972   [(set_attr "type" "ssecvt")
14973    (set_attr "prefix" "vex")
14974    (set_attr "btver2_decode" "double")
14975    (set_attr "mode" "V8SF")])
14976
14977 (define_insn "<mask_codefor>avx512f_vcvtph2ps512<mask_name><round_saeonly_name>"
14978   [(set (match_operand:V16SF 0 "register_operand" "=v")
14979         (unspec:V16SF
14980           [(match_operand:V16HI 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
14981           UNSPEC_VCVTPH2PS))]
14982   "TARGET_AVX512F"
14983   "vcvtph2ps\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
14984   [(set_attr "type" "ssecvt")
14985    (set_attr "prefix" "evex")
14986    (set_attr "mode" "V16SF")])
14987
14988 (define_expand "vcvtps2ph"
14989   [(set (match_operand:V8HI 0 "register_operand")
14990         (vec_concat:V8HI
14991           (unspec:V4HI [(match_operand:V4SF 1 "register_operand")
14992                         (match_operand:SI 2 "const_0_to_255_operand")]
14993                        UNSPEC_VCVTPS2PH)
14994           (match_dup 3)))]
14995   "TARGET_F16C"
14996   "operands[3] = CONST0_RTX (V4HImode);")
14997
14998 (define_insn "*vcvtps2ph"
14999   [(set (match_operand:V8HI 0 "register_operand" "=x")
15000         (vec_concat:V8HI
15001           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
15002                         (match_operand:SI 2 "const_0_to_255_operand" "N")]
15003                        UNSPEC_VCVTPS2PH)
15004           (match_operand:V4HI 3 "const0_operand")))]
15005   "TARGET_F16C"
15006   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
15007   [(set_attr "type" "ssecvt")
15008    (set_attr "prefix" "vex")
15009    (set_attr "mode" "V4SF")])
15010
15011 (define_insn "*vcvtps2ph_store"
15012   [(set (match_operand:V4HI 0 "memory_operand" "=m")
15013         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
15014                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
15015                      UNSPEC_VCVTPS2PH))]
15016   "TARGET_F16C"
15017   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
15018   [(set_attr "type" "ssecvt")
15019    (set_attr "prefix" "vex")
15020    (set_attr "mode" "V4SF")])
15021
15022 (define_insn "vcvtps2ph256"
15023   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=xm")
15024         (unspec:V8HI [(match_operand:V8SF 1 "register_operand" "x")
15025                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
15026                      UNSPEC_VCVTPS2PH))]
15027   "TARGET_F16C"
15028   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
15029   [(set_attr "type" "ssecvt")
15030    (set_attr "prefix" "vex")
15031    (set_attr "btver2_decode" "vector")
15032    (set_attr "mode" "V8SF")])
15033
15034 (define_insn "<mask_codefor>avx512f_vcvtps2ph512<mask_name>"
15035   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=vm")
15036         (unspec:V16HI
15037           [(match_operand:V16SF 1 "register_operand" "v")
15038            (match_operand:SI 2 "const_0_to_255_operand" "N")]
15039           UNSPEC_VCVTPS2PH))]
15040   "TARGET_AVX512F"
15041   "vcvtps2ph\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
15042   [(set_attr "type" "ssecvt")
15043    (set_attr "prefix" "evex")
15044    (set_attr "mode" "V16SF")])
15045
15046 ;; For gather* insn patterns
15047 (define_mode_iterator VEC_GATHER_MODE
15048                       [V2DI V2DF V4DI V4DF V4SI V4SF V8SI V8SF])
15049 (define_mode_attr VEC_GATHER_IDXSI
15050                       [(V2DI "V4SI") (V4DI "V4SI") (V8DI "V8SI")
15051                        (V2DF "V4SI") (V4DF "V4SI") (V8DF "V8SI")
15052                        (V4SI "V4SI") (V8SI "V8SI") (V16SI "V16SI")
15053                        (V4SF "V4SI") (V8SF "V8SI") (V16SF "V16SI")])
15054
15055 (define_mode_attr VEC_GATHER_IDXDI
15056                       [(V2DI "V2DI") (V4DI "V4DI") (V8DI "V8DI")
15057                        (V2DF "V2DI") (V4DF "V4DI") (V8DF "V8DI")
15058                        (V4SI "V2DI") (V8SI "V4DI") (V16SI "V8DI")
15059                        (V4SF "V2DI") (V8SF "V4DI") (V16SF "V8DI")])
15060
15061 (define_mode_attr VEC_GATHER_SRCDI
15062                       [(V2DI "V2DI") (V4DI "V4DI") (V8DI "V8DI")
15063                        (V2DF "V2DF") (V4DF "V4DF") (V8DF "V8DF")
15064                        (V4SI "V4SI") (V8SI "V4SI") (V16SI "V8SI")
15065                        (V4SF "V4SF") (V8SF "V4SF") (V16SF "V8SF")])
15066
15067 (define_expand "avx2_gathersi<mode>"
15068   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
15069                    (unspec:VEC_GATHER_MODE
15070                      [(match_operand:VEC_GATHER_MODE 1 "register_operand")
15071                       (mem:<ssescalarmode>
15072                         (match_par_dup 7
15073                           [(match_operand 2 "vsib_address_operand")
15074                            (match_operand:<VEC_GATHER_IDXSI>
15075                               3 "register_operand")
15076                            (match_operand:SI 5 "const1248_operand ")]))
15077                       (mem:BLK (scratch))
15078                       (match_operand:VEC_GATHER_MODE 4 "register_operand")]
15079                      UNSPEC_GATHER))
15080               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
15081   "TARGET_AVX2"
15082 {
15083   operands[7]
15084     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15085                                         operands[5]), UNSPEC_VSIBADDR);
15086 })
15087
15088 (define_insn "*avx2_gathersi<mode>"
15089   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15090         (unspec:VEC_GATHER_MODE
15091           [(match_operand:VEC_GATHER_MODE 2 "register_operand" "0")
15092            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
15093              [(unspec:P
15094                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15095                  (match_operand:<VEC_GATHER_IDXSI> 4 "register_operand" "x")
15096                  (match_operand:SI 6 "const1248_operand" "n")]
15097                 UNSPEC_VSIBADDR)])
15098            (mem:BLK (scratch))
15099            (match_operand:VEC_GATHER_MODE 5 "register_operand" "1")]
15100           UNSPEC_GATHER))
15101    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15102   "TARGET_AVX2"
15103   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %7, %0|%0, %7, %1}"
15104   [(set_attr "type" "ssemov")
15105    (set_attr "prefix" "vex")
15106    (set_attr "mode" "<sseinsnmode>")])
15107
15108 (define_insn "*avx2_gathersi<mode>_2"
15109   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15110         (unspec:VEC_GATHER_MODE
15111           [(pc)
15112            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15113              [(unspec:P
15114                 [(match_operand:P 2 "vsib_address_operand" "Tv")
15115                  (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand" "x")
15116                  (match_operand:SI 5 "const1248_operand" "n")]
15117                 UNSPEC_VSIBADDR)])
15118            (mem:BLK (scratch))
15119            (match_operand:VEC_GATHER_MODE 4 "register_operand" "1")]
15120           UNSPEC_GATHER))
15121    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15122   "TARGET_AVX2"
15123   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %6, %0|%0, %6, %1}"
15124   [(set_attr "type" "ssemov")
15125    (set_attr "prefix" "vex")
15126    (set_attr "mode" "<sseinsnmode>")])
15127
15128 (define_expand "avx2_gatherdi<mode>"
15129   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
15130                    (unspec:VEC_GATHER_MODE
15131                      [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand")
15132                       (mem:<ssescalarmode>
15133                         (match_par_dup 7
15134                           [(match_operand 2 "vsib_address_operand")
15135                            (match_operand:<VEC_GATHER_IDXDI>
15136                               3 "register_operand")
15137                            (match_operand:SI 5 "const1248_operand ")]))
15138                       (mem:BLK (scratch))
15139                       (match_operand:<VEC_GATHER_SRCDI>
15140                         4 "register_operand")]
15141                      UNSPEC_GATHER))
15142               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
15143   "TARGET_AVX2"
15144 {
15145   operands[7]
15146     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15147                                         operands[5]), UNSPEC_VSIBADDR);
15148 })
15149
15150 (define_insn "*avx2_gatherdi<mode>"
15151   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15152         (unspec:VEC_GATHER_MODE
15153           [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
15154            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
15155              [(unspec:P
15156                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15157                  (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
15158                  (match_operand:SI 6 "const1248_operand" "n")]
15159                 UNSPEC_VSIBADDR)])
15160            (mem:BLK (scratch))
15161            (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
15162           UNSPEC_GATHER))
15163    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15164   "TARGET_AVX2"
15165   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %2|%2, %7, %5}"
15166   [(set_attr "type" "ssemov")
15167    (set_attr "prefix" "vex")
15168    (set_attr "mode" "<sseinsnmode>")])
15169
15170 (define_insn "*avx2_gatherdi<mode>_2"
15171   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15172         (unspec:VEC_GATHER_MODE
15173           [(pc)
15174            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15175              [(unspec:P
15176                 [(match_operand:P 2 "vsib_address_operand" "Tv")
15177                  (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
15178                  (match_operand:SI 5 "const1248_operand" "n")]
15179                 UNSPEC_VSIBADDR)])
15180            (mem:BLK (scratch))
15181            (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
15182           UNSPEC_GATHER))
15183    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15184   "TARGET_AVX2"
15185 {
15186   if (<MODE>mode != <VEC_GATHER_SRCDI>mode)
15187     return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %x0|%x0, %6, %4}";
15188   return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}";
15189 }
15190   [(set_attr "type" "ssemov")
15191    (set_attr "prefix" "vex")
15192    (set_attr "mode" "<sseinsnmode>")])
15193
15194 (define_insn "*avx2_gatherdi<mode>_3"
15195   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
15196         (vec_select:<VEC_GATHER_SRCDI>
15197           (unspec:VI4F_256
15198             [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
15199              (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
15200                [(unspec:P
15201                   [(match_operand:P 3 "vsib_address_operand" "Tv")
15202                    (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
15203                    (match_operand:SI 6 "const1248_operand" "n")]
15204                   UNSPEC_VSIBADDR)])
15205              (mem:BLK (scratch))
15206              (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
15207              UNSPEC_GATHER)
15208           (parallel [(const_int 0) (const_int 1)
15209                      (const_int 2) (const_int 3)])))
15210    (clobber (match_scratch:VI4F_256 1 "=&x"))]
15211   "TARGET_AVX2"
15212   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %0|%0, %7, %5}"
15213   [(set_attr "type" "ssemov")
15214    (set_attr "prefix" "vex")
15215    (set_attr "mode" "<sseinsnmode>")])
15216
15217 (define_insn "*avx2_gatherdi<mode>_4"
15218   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
15219         (vec_select:<VEC_GATHER_SRCDI>
15220           (unspec:VI4F_256
15221             [(pc)
15222              (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15223                [(unspec:P
15224                   [(match_operand:P 2 "vsib_address_operand" "Tv")
15225                    (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
15226                    (match_operand:SI 5 "const1248_operand" "n")]
15227                   UNSPEC_VSIBADDR)])
15228              (mem:BLK (scratch))
15229              (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
15230             UNSPEC_GATHER)
15231           (parallel [(const_int 0) (const_int 1)
15232                      (const_int 2) (const_int 3)])))
15233    (clobber (match_scratch:VI4F_256 1 "=&x"))]
15234   "TARGET_AVX2"
15235   "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}"
15236   [(set_attr "type" "ssemov")
15237    (set_attr "prefix" "vex")
15238    (set_attr "mode" "<sseinsnmode>")])
15239
15240 (define_expand "avx512f_gathersi<mode>"
15241   [(parallel [(set (match_operand:VI48F_512 0 "register_operand")
15242                    (unspec:VI48F_512
15243                      [(match_operand:VI48F_512 1 "register_operand")
15244                       (match_operand:<avx512fmaskmode> 4 "register_operand")
15245                       (mem:<ssescalarmode>
15246                         (match_par_dup 6
15247                           [(match_operand 2 "vsib_address_operand")
15248                            (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand")
15249                            (match_operand:SI 5 "const1248_operand")]))]
15250                      UNSPEC_GATHER))
15251               (clobber (match_scratch:<avx512fmaskmode> 7))])]
15252   "TARGET_AVX512F"
15253 {
15254   operands[6]
15255     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15256                                         operands[5]), UNSPEC_VSIBADDR);
15257 })
15258
15259 (define_insn "*avx512f_gathersi<mode>"
15260   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15261         (unspec:VI48F_512
15262           [(match_operand:VI48F_512 1 "register_operand" "0")
15263            (match_operand:<avx512fmaskmode> 7 "register_operand" "2")
15264            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15265              [(unspec:P
15266                 [(match_operand:P 4 "vsib_address_operand" "Tv")
15267                  (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand" "v")
15268                  (match_operand:SI 5 "const1248_operand" "n")]
15269                 UNSPEC_VSIBADDR)])]
15270           UNSPEC_GATHER))
15271    (clobber (match_scratch:<avx512fmaskmode> 2 "=&Yk"))]
15272   "TARGET_AVX512F"
15273   "v<sseintprefix>gatherd<ssemodesuffix>\t{%6, %0%{%2%}|%0%{%2%}, %g6}"
15274   [(set_attr "type" "ssemov")
15275    (set_attr "prefix" "evex")
15276    (set_attr "mode" "<sseinsnmode>")])
15277
15278 (define_insn "*avx512f_gathersi<mode>_2"
15279   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15280         (unspec:VI48F_512
15281           [(pc)
15282            (match_operand:<avx512fmaskmode> 6 "register_operand" "1")
15283            (match_operator:<ssescalarmode> 5 "vsib_mem_operator"
15284              [(unspec:P
15285                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15286                  (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand" "v")
15287                  (match_operand:SI 4 "const1248_operand" "n")]
15288                 UNSPEC_VSIBADDR)])]
15289           UNSPEC_GATHER))
15290    (clobber (match_scratch:<avx512fmaskmode> 1 "=&Yk"))]
15291   "TARGET_AVX512F"
15292   "v<sseintprefix>gatherd<ssemodesuffix>\t{%5, %0%{%1%}|%0%{%1%}, %g5}"
15293   [(set_attr "type" "ssemov")
15294    (set_attr "prefix" "evex")
15295    (set_attr "mode" "<sseinsnmode>")])
15296
15297
15298 (define_expand "avx512f_gatherdi<mode>"
15299   [(parallel [(set (match_operand:VI48F_512 0 "register_operand")
15300                    (unspec:VI48F_512
15301                      [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand")
15302                       (match_operand:QI 4 "register_operand")
15303                       (mem:<ssescalarmode>
15304                         (match_par_dup 6
15305                           [(match_operand 2 "vsib_address_operand")
15306                            (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand")
15307                            (match_operand:SI 5 "const1248_operand")]))]
15308                      UNSPEC_GATHER))
15309               (clobber (match_scratch:QI 7))])]
15310   "TARGET_AVX512F"
15311 {
15312   operands[6]
15313     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15314                                         operands[5]), UNSPEC_VSIBADDR);
15315 })
15316
15317 (define_insn "*avx512f_gatherdi<mode>"
15318   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15319         (unspec:VI48F_512
15320           [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand" "0")
15321            (match_operand:QI 7 "register_operand" "2")
15322            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15323              [(unspec:P
15324                 [(match_operand:P 4 "vsib_address_operand" "Tv")
15325                  (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "v")
15326                  (match_operand:SI 5 "const1248_operand" "n")]
15327                 UNSPEC_VSIBADDR)])]
15328           UNSPEC_GATHER))
15329    (clobber (match_scratch:QI 2 "=&Yk"))]
15330   "TARGET_AVX512F"
15331   "v<sseintprefix>gatherq<ssemodesuffix>\t{%6, %1%{%2%}|%1%{%2%}, %g6}"
15332   [(set_attr "type" "ssemov")
15333    (set_attr "prefix" "evex")
15334    (set_attr "mode" "<sseinsnmode>")])
15335
15336 (define_insn "*avx512f_gatherdi<mode>_2"
15337   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15338         (unspec:VI48F_512
15339           [(pc)
15340            (match_operand:QI 6 "register_operand" "1")
15341            (match_operator:<ssescalarmode> 5 "vsib_mem_operator"
15342              [(unspec:P
15343                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15344                  (match_operand:<VEC_GATHER_IDXDI> 2 "register_operand" "v")
15345                  (match_operand:SI 4 "const1248_operand" "n")]
15346                 UNSPEC_VSIBADDR)])]
15347           UNSPEC_GATHER))
15348    (clobber (match_scratch:QI 1 "=&Yk"))]
15349   "TARGET_AVX512F"
15350 {
15351   if (<MODE>mode != <VEC_GATHER_SRCDI>mode)
15352     return "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %t0%{%1%}|%t0%{%1%}, %g5}";
15353   return "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %0%{%1%}|%0%{%1%}, %g5}";
15354 }
15355   [(set_attr "type" "ssemov")
15356    (set_attr "prefix" "evex")
15357    (set_attr "mode" "<sseinsnmode>")])
15358
15359 (define_expand "avx512f_scattersi<mode>"
15360   [(parallel [(set (mem:VI48F_512
15361                      (match_par_dup 5
15362                        [(match_operand 0 "vsib_address_operand")
15363                         (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand")
15364                         (match_operand:SI 4 "const1248_operand")]))
15365                    (unspec:VI48F_512
15366                      [(match_operand:<avx512fmaskmode> 1 "register_operand")
15367                       (match_operand:VI48F_512 3 "register_operand")]
15368                      UNSPEC_SCATTER))
15369               (clobber (match_scratch:<avx512fmaskmode> 6))])]
15370   "TARGET_AVX512F"
15371 {
15372   operands[5]
15373     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[0], operands[2],
15374                                         operands[4]), UNSPEC_VSIBADDR);
15375 })
15376
15377 (define_insn "*avx512f_scattersi<mode>"
15378   [(set (match_operator:VI48F_512 5 "vsib_mem_operator"
15379           [(unspec:P
15380              [(match_operand:P 0 "vsib_address_operand" "Tv")
15381               (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand" "v")
15382               (match_operand:SI 4 "const1248_operand" "n")]
15383              UNSPEC_VSIBADDR)])
15384         (unspec:VI48F_512
15385           [(match_operand:<avx512fmaskmode> 6 "register_operand" "1")
15386            (match_operand:VI48F_512 3 "register_operand" "v")]
15387           UNSPEC_SCATTER))
15388    (clobber (match_scratch:<avx512fmaskmode> 1 "=&Yk"))]
15389   "TARGET_AVX512F"
15390   "v<sseintprefix>scatterd<ssemodesuffix>\t{%3, %5%{%1%}|%5%{%1%}, %3}"
15391   [(set_attr "type" "ssemov")
15392    (set_attr "prefix" "evex")
15393    (set_attr "mode" "<sseinsnmode>")])
15394
15395 (define_expand "avx512f_scatterdi<mode>"
15396   [(parallel [(set (mem:VI48F_512
15397                      (match_par_dup 5
15398                        [(match_operand 0 "vsib_address_operand")
15399                         (match_operand:V8DI 2 "register_operand")
15400                         (match_operand:SI 4 "const1248_operand")]))
15401                    (unspec:VI48F_512
15402                      [(match_operand:QI 1 "register_operand")
15403                       (match_operand:<VEC_GATHER_SRCDI> 3 "register_operand")]
15404                      UNSPEC_SCATTER))
15405               (clobber (match_scratch:QI 6))])]
15406   "TARGET_AVX512F"
15407 {
15408   operands[5]
15409     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[0], operands[2],
15410                                         operands[4]), UNSPEC_VSIBADDR);
15411 })
15412
15413 (define_insn "*avx512f_scatterdi<mode>"
15414   [(set (match_operator:VI48F_512 5 "vsib_mem_operator"
15415           [(unspec:P
15416              [(match_operand:P 0 "vsib_address_operand" "Tv")
15417               (match_operand:V8DI 2 "register_operand" "v")
15418               (match_operand:SI 4 "const1248_operand" "n")]
15419              UNSPEC_VSIBADDR)])
15420         (unspec:VI48F_512
15421           [(match_operand:QI 6 "register_operand" "1")
15422            (match_operand:<VEC_GATHER_SRCDI> 3 "register_operand" "v")]
15423           UNSPEC_SCATTER))
15424    (clobber (match_scratch:QI 1 "=&Yk"))]
15425   "TARGET_AVX512F"
15426   "v<sseintprefix>scatterq<ssemodesuffix>\t{%3, %5%{%1%}|%5%{%1%}, %3}"
15427   [(set_attr "type" "ssemov")
15428    (set_attr "prefix" "evex")
15429    (set_attr "mode" "<sseinsnmode>")])
15430
15431 (define_insn "avx512f_compress<mode>_mask"
15432   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
15433         (unspec:VI48F_512
15434           [(match_operand:VI48F_512 1 "register_operand" "v")
15435            (match_operand:VI48F_512 2 "vector_move_operand" "0C")
15436            (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk")]
15437           UNSPEC_COMPRESS))]
15438   "TARGET_AVX512F"
15439   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
15440   [(set_attr "type" "ssemov")
15441    (set_attr "prefix" "evex")
15442    (set_attr "mode" "<sseinsnmode>")])
15443
15444 (define_insn "avx512f_compressstore<mode>_mask"
15445   [(set (match_operand:VI48F_512 0 "memory_operand" "=m")
15446         (unspec:VI48F_512
15447           [(match_operand:VI48F_512 1 "register_operand" "x")
15448            (match_dup 0)
15449            (match_operand:<avx512fmaskmode> 2 "register_operand" "Yk")]
15450           UNSPEC_COMPRESS_STORE))]
15451   "TARGET_AVX512F"
15452   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}"
15453   [(set_attr "type" "ssemov")
15454    (set_attr "prefix" "evex")
15455    (set_attr "memory" "store")
15456    (set_attr "mode" "<sseinsnmode>")])
15457
15458 (define_expand "avx512f_expand<mode>_maskz"
15459   [(set (match_operand:VI48F_512 0 "register_operand")
15460         (unspec:VI48F_512
15461           [(match_operand:VI48F_512 1 "nonimmediate_operand")
15462            (match_operand:VI48F_512 2 "vector_move_operand")
15463            (match_operand:<avx512fmaskmode> 3 "register_operand")]
15464           UNSPEC_EXPAND))]
15465   "TARGET_AVX512F"
15466   "operands[2] = CONST0_RTX (<MODE>mode);")
15467
15468 (define_insn "avx512f_expand<mode>_mask"
15469   [(set (match_operand:VI48F_512 0 "register_operand" "=v,v")
15470         (unspec:VI48F_512
15471           [(match_operand:VI48F_512 1 "nonimmediate_operand" "v,m")
15472            (match_operand:VI48F_512 2 "vector_move_operand" "0C,0C")
15473            (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk,Yk")]
15474           UNSPEC_EXPAND))]
15475   "TARGET_AVX512F"
15476   "v<sseintprefix>expand<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
15477   [(set_attr "type" "ssemov")
15478    (set_attr "prefix" "evex")
15479    (set_attr "memory" "none,load")
15480    (set_attr "mode" "<sseinsnmode>")])
15481
15482 (define_insn "avx512f_getmant<mode><mask_name><round_saeonly_name>"
15483   [(set (match_operand:VF_512 0 "register_operand" "=v")
15484         (unspec:VF_512
15485           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
15486            (match_operand:SI 2 "const_0_to_15_operand")]
15487           UNSPEC_GETMANT))]
15488   "TARGET_AVX512F"
15489   "vgetmant<ssemodesuffix>\t{%2, <round_saeonly_mask_op3>%1, %0<mask_operand3>|%0<mask_operand3>, %1<round_saeonly_mask_op3>, %2}";
15490   [(set_attr "prefix" "evex")
15491    (set_attr "mode" "<MODE>")])
15492
15493 (define_insn "avx512f_getmant<mode><round_saeonly_name>"
15494   [(set (match_operand:VF_128 0 "register_operand" "=v")
15495         (vec_merge:VF_128
15496           (unspec:VF_128
15497             [(match_operand:VF_128 1 "register_operand" "v")
15498              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
15499              (match_operand:SI 3 "const_0_to_15_operand")]
15500             UNSPEC_GETMANT)
15501           (match_dup 1)
15502           (const_int 1)))]
15503    "TARGET_AVX512F"
15504    "vgetmant<ssescalarmodesuffix>\t{%3, <round_saeonly_op4>%2, %1, %0|%0, %1, %2<round_saeonly_op4>, %3}";
15505    [(set_attr "prefix" "evex")
15506    (set_attr "mode" "<ssescalarmode>")])
15507
15508 (define_insn "clz<mode>2<mask_name>"
15509   [(set (match_operand:VI48_512 0 "register_operand" "=v")
15510         (clz:VI48_512
15511           (match_operand:VI48_512 1 "nonimmediate_operand" "vm")))]
15512   "TARGET_AVX512CD"
15513   "vplzcnt<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
15514   [(set_attr "type" "sse")
15515    (set_attr "prefix" "evex")
15516    (set_attr "mode" "<sseinsnmode>")])
15517
15518 (define_insn "<mask_codefor>conflict<mode><mask_name>"
15519   [(set (match_operand:VI48_512 0 "register_operand" "=v")
15520         (unspec:VI48_512
15521           [(match_operand:VI48_512 1 "nonimmediate_operand" "vm")]
15522           UNSPEC_CONFLICT))]
15523   "TARGET_AVX512CD"
15524   "vpconflict<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
15525   [(set_attr "type" "sse")
15526    (set_attr "prefix" "evex")
15527    (set_attr "mode" "<sseinsnmode>")])
15528
15529 (define_insn "sha1msg1"
15530   [(set (match_operand:V4SI 0 "register_operand" "=x")
15531         (unspec:V4SI
15532           [(match_operand:V4SI 1 "register_operand" "0")
15533            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15534           UNSPEC_SHA1MSG1))]
15535   "TARGET_SHA"
15536   "sha1msg1\t{%2, %0|%0, %2}"
15537   [(set_attr "type" "sselog1")
15538    (set_attr "mode" "TI")])
15539
15540 (define_insn "sha1msg2"
15541   [(set (match_operand:V4SI 0 "register_operand" "=x")
15542         (unspec:V4SI
15543           [(match_operand:V4SI 1 "register_operand" "0")
15544            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15545           UNSPEC_SHA1MSG2))]
15546   "TARGET_SHA"
15547   "sha1msg2\t{%2, %0|%0, %2}"
15548   [(set_attr "type" "sselog1")
15549    (set_attr "mode" "TI")])
15550
15551 (define_insn "sha1nexte"
15552   [(set (match_operand:V4SI 0 "register_operand" "=x")
15553         (unspec:V4SI
15554           [(match_operand:V4SI 1 "register_operand" "0")
15555            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15556           UNSPEC_SHA1NEXTE))]
15557   "TARGET_SHA"
15558   "sha1nexte\t{%2, %0|%0, %2}"
15559   [(set_attr "type" "sselog1")
15560    (set_attr "mode" "TI")])
15561
15562 (define_insn "sha1rnds4"
15563   [(set (match_operand:V4SI 0 "register_operand" "=x")
15564         (unspec:V4SI
15565           [(match_operand:V4SI 1 "register_operand" "0")
15566            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
15567            (match_operand:SI 3 "const_0_to_3_operand" "n")]
15568           UNSPEC_SHA1RNDS4))]
15569   "TARGET_SHA"
15570   "sha1rnds4\t{%3, %2, %0|%0, %2, %3}"
15571   [(set_attr "type" "sselog1")
15572    (set_attr "length_immediate" "1")
15573    (set_attr "mode" "TI")])
15574
15575 (define_insn "sha256msg1"
15576   [(set (match_operand:V4SI 0 "register_operand" "=x")
15577         (unspec:V4SI
15578           [(match_operand:V4SI 1 "register_operand" "0")
15579            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15580           UNSPEC_SHA256MSG1))]
15581   "TARGET_SHA"
15582   "sha256msg1\t{%2, %0|%0, %2}"
15583   [(set_attr "type" "sselog1")
15584    (set_attr "mode" "TI")])
15585
15586 (define_insn "sha256msg2"
15587   [(set (match_operand:V4SI 0 "register_operand" "=x")
15588         (unspec:V4SI
15589           [(match_operand:V4SI 1 "register_operand" "0")
15590            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15591           UNSPEC_SHA256MSG2))]
15592   "TARGET_SHA"
15593   "sha256msg2\t{%2, %0|%0, %2}"
15594   [(set_attr "type" "sselog1")
15595    (set_attr "mode" "TI")])
15596
15597 (define_insn "sha256rnds2"
15598   [(set (match_operand:V4SI 0 "register_operand" "=x")
15599         (unspec:V4SI
15600           [(match_operand:V4SI 1 "register_operand" "0")
15601            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
15602            (match_operand:V4SI 3 "register_operand" "Yz")]
15603           UNSPEC_SHA256RNDS2))]
15604   "TARGET_SHA"
15605   "sha256rnds2\t{%3, %2, %0|%0, %2, %3}"
15606   [(set_attr "type" "sselog1")
15607    (set_attr "length_immediate" "1")
15608    (set_attr "mode" "TI")])