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
2718 (define_expand "fms<mode>4"
2719   [(set (match_operand:FMAMODEM 0 "register_operand")
2720         (fma:FMAMODEM
2721           (match_operand:FMAMODEM 1 "nonimmediate_operand")
2722           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2723           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))]
2724   "")
2725
2726 (define_expand "fnma<mode>4"
2727   [(set (match_operand:FMAMODEM 0 "register_operand")
2728         (fma:FMAMODEM
2729           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2730           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2731           (match_operand:FMAMODEM 3 "nonimmediate_operand")))]
2732   "")
2733
2734 (define_expand "fnms<mode>4"
2735   [(set (match_operand:FMAMODEM 0 "register_operand")
2736         (fma:FMAMODEM
2737           (neg:FMAMODEM (match_operand:FMAMODEM 1 "nonimmediate_operand"))
2738           (match_operand:FMAMODEM 2 "nonimmediate_operand")
2739           (neg:FMAMODEM (match_operand:FMAMODEM 3 "nonimmediate_operand"))))]
2740   "")
2741
2742 ;; The builtins for intrinsics are not constrained by SSE math enabled.
2743 (define_mode_iterator FMAMODE [(SF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2744                                (DF "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
2745                                (V4SF "TARGET_FMA || TARGET_FMA4")
2746                                (V2DF "TARGET_FMA || TARGET_FMA4")
2747                                (V8SF "TARGET_FMA || TARGET_FMA4")
2748                                (V4DF "TARGET_FMA || TARGET_FMA4")
2749                                (V16SF "TARGET_AVX512F")
2750                                (V8DF "TARGET_AVX512F")])
2751
2752 (define_expand "fma4i_fmadd_<mode>"
2753   [(set (match_operand:FMAMODE 0 "register_operand")
2754         (fma:FMAMODE
2755           (match_operand:FMAMODE 1 "nonimmediate_operand")
2756           (match_operand:FMAMODE 2 "nonimmediate_operand")
2757           (match_operand:FMAMODE 3 "nonimmediate_operand")))]
2758   "")
2759
2760 (define_expand "avx512f_fmadd_<mode>_maskz<round_expand_name>"
2761   [(match_operand:VF_512 0 "register_operand")
2762    (match_operand:VF_512 1 "<round_expand_nimm_predicate>")
2763    (match_operand:VF_512 2 "<round_expand_nimm_predicate>")
2764    (match_operand:VF_512 3 "<round_expand_nimm_predicate>")
2765    (match_operand:<avx512fmaskmode> 4 "register_operand")]
2766   "TARGET_AVX512F"
2767 {
2768   emit_insn (gen_fma_fmadd_<mode>_maskz_1<round_expand_name> (
2769     operands[0], operands[1], operands[2], operands[3],
2770     CONST0_RTX (<MODE>mode), operands[4]<round_expand_operand>));
2771   DONE;
2772 })
2773
2774 (define_insn "<sd_mask_codefor>fma_fmadd_<mode><sd_maskz_name><round_name>"
2775   [(set (match_operand:FMAMODE 0 "register_operand" "=v,v,v,x,x")
2776         (fma:FMAMODE
2777           (match_operand:FMAMODE 1 "<round_nimm_predicate>" "%0,0,v,x,x")
2778           (match_operand:FMAMODE 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2779           (match_operand:FMAMODE 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")))]
2780   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2781   "@
2782    vfmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2783    vfmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2784    vfmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2785    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2786    vfmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2787   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2788    (set_attr "type" "ssemuladd")
2789    (set_attr "mode" "<MODE>")])
2790
2791 (define_insn "avx512f_fmadd_<mode>_mask<round_name>"
2792   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2793         (vec_merge:VF_512
2794           (fma:VF_512
2795             (match_operand:VF_512 1 "register_operand" "0,0")
2796             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2797             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))
2798           (match_dup 1)
2799           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2800   "TARGET_AVX512F"
2801   "@
2802    vfmadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2803    vfmadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2804   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2805    (set_attr "type" "ssemuladd")
2806    (set_attr "mode" "<MODE>")])
2807
2808 (define_insn "avx512f_fmadd_<mode>_mask3<round_name>"
2809   [(set (match_operand:VF_512 0 "register_operand" "=x")
2810         (vec_merge:VF_512
2811           (fma:VF_512
2812             (match_operand:VF_512 1 "register_operand" "x")
2813             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2814             (match_operand:VF_512 3 "register_operand" "0"))
2815           (match_dup 3)
2816           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2817   "TARGET_AVX512F"
2818   "vfmadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2819   [(set_attr "isa" "fma_avx512f")
2820    (set_attr "type" "ssemuladd")
2821    (set_attr "mode" "<MODE>")])
2822
2823 (define_insn "<sd_mask_codefor>fma_fmsub_<mode><sd_maskz_name><round_name>"
2824   [(set (match_operand:FMAMODE 0 "register_operand" "=v,v,v,x,x")
2825         (fma:FMAMODE
2826           (match_operand:FMAMODE   1 "<round_nimm_predicate>" "%0, 0, v, x,x")
2827           (match_operand:FMAMODE   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2828           (neg:FMAMODE
2829             (match_operand:FMAMODE 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))))]
2830   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2831   "@
2832    vfmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2833    vfmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2834    vfmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2835    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2836    vfmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2837   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2838    (set_attr "type" "ssemuladd")
2839    (set_attr "mode" "<MODE>")])
2840
2841 (define_insn "avx512f_fmsub_<mode>_mask<round_name>"
2842   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2843         (vec_merge:VF_512
2844           (fma:VF_512
2845             (match_operand:VF_512 1 "register_operand" "0,0")
2846             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2847             (neg:VF_512
2848               (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")))
2849           (match_dup 1)
2850           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2851   "TARGET_AVX512F"
2852   "@
2853    vfmsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2854    vfmsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2855   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2856    (set_attr "type" "ssemuladd")
2857    (set_attr "mode" "<MODE>")])
2858
2859 (define_insn "avx512f_fmsub_<mode>_mask3<round_name>"
2860   [(set (match_operand:VF_512 0 "register_operand" "=v")
2861         (vec_merge:VF_512
2862           (fma:VF_512
2863             (match_operand:VF_512 1 "register_operand" "v")
2864             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2865             (neg:VF_512
2866               (match_operand:VF_512 3 "register_operand" "0")))
2867           (match_dup 3)
2868           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2869   "TARGET_AVX512F"
2870   "vfmsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2871   [(set_attr "isa" "fma_avx512f")
2872    (set_attr "type" "ssemuladd")
2873    (set_attr "mode" "<MODE>")])
2874
2875 (define_insn "<sd_mask_codefor>fma_fnmadd_<mode><sd_maskz_name><round_name>"
2876   [(set (match_operand:FMAMODE 0 "register_operand" "=v,v,v,x,x")
2877         (fma:FMAMODE
2878           (neg:FMAMODE
2879             (match_operand:FMAMODE 1 "<round_nimm_predicate>" "%0,0,v,x,x"))
2880           (match_operand:FMAMODE   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2881           (match_operand:FMAMODE   3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")))]
2882   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2883   "@
2884    vfnmadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2885    vfnmadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2886    vfnmadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2887    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2888    vfnmadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2889   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2890    (set_attr "type" "ssemuladd")
2891    (set_attr "mode" "<MODE>")])
2892
2893 (define_insn "avx512f_fnmadd_<mode>_mask<round_name>"
2894   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2895         (vec_merge:VF_512
2896           (fma:VF_512
2897             (neg:VF_512
2898               (match_operand:VF_512 1 "register_operand" "0,0"))
2899             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2900             (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))
2901           (match_dup 1)
2902           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2903   "TARGET_AVX512F"
2904   "@
2905    vfnmadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2906    vfnmadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2907   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2908    (set_attr "type" "ssemuladd")
2909    (set_attr "mode" "<MODE>")])
2910
2911 (define_insn "avx512f_fnmadd_<mode>_mask3<round_name>"
2912   [(set (match_operand:VF_512 0 "register_operand" "=v")
2913         (vec_merge:VF_512
2914           (fma:VF_512
2915             (neg:VF_512
2916               (match_operand:VF_512 1 "register_operand" "v"))
2917             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2918             (match_operand:VF_512 3 "register_operand" "0"))
2919           (match_dup 3)
2920           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2921   "TARGET_AVX512F"
2922   "vfnmadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2923   [(set_attr "isa" "fma_avx512f")
2924    (set_attr "type" "ssemuladd")
2925    (set_attr "mode" "<MODE>")])
2926
2927 (define_insn "<sd_mask_codefor>fma_fnmsub_<mode><sd_maskz_name><round_name>"
2928   [(set (match_operand:FMAMODE 0 "register_operand" "=v,v,v,x,x")
2929         (fma:FMAMODE
2930           (neg:FMAMODE
2931             (match_operand:FMAMODE 1 "<round_nimm_predicate>" "%0,0,v,x,x"))
2932           (match_operand:FMAMODE   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
2933           (neg:FMAMODE
2934             (match_operand:FMAMODE 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))))]
2935   "<sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
2936   "@
2937    vfnmsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
2938    vfnmsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
2939    vfnmsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
2940    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
2941    vfnmsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
2942   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
2943    (set_attr "type" "ssemuladd")
2944    (set_attr "mode" "<MODE>")])
2945
2946 (define_insn "avx512f_fnmsub_<mode>_mask<round_name>"
2947   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
2948         (vec_merge:VF_512
2949           (fma:VF_512
2950             (neg:VF_512
2951               (match_operand:VF_512 1 "register_operand" "0,0"))
2952             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
2953             (neg:VF_512
2954               (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")))
2955           (match_dup 1)
2956           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
2957   "TARGET_AVX512F"
2958   "@
2959    vfnmsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
2960    vfnmsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
2961   [(set_attr "isa" "fma_avx512f,fma_avx512f")
2962    (set_attr "type" "ssemuladd")
2963    (set_attr "mode" "<MODE>")])
2964
2965 (define_insn "avx512f_fnmsub_<mode>_mask3<round_name>"
2966   [(set (match_operand:VF_512 0 "register_operand" "=v")
2967         (vec_merge:VF_512
2968           (fma:VF_512
2969             (neg:VF_512
2970               (match_operand:VF_512 1 "register_operand" "v"))
2971             (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
2972             (neg:VF_512
2973               (match_operand:VF_512 3 "register_operand" "0")))
2974           (match_dup 3)
2975           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
2976   "TARGET_AVX512F"
2977   "vfnmsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
2978   [(set_attr "isa" "fma_avx512f")
2979    (set_attr "type" "ssemuladd")
2980    (set_attr "mode" "<MODE>")])
2981
2982 ;; FMA parallel floating point multiply addsub and subadd operations.
2983
2984 ;; It would be possible to represent these without the UNSPEC as
2985 ;;
2986 ;; (vec_merge
2987 ;;   (fma op1 op2 op3)
2988 ;;   (fma op1 op2 (neg op3))
2989 ;;   (merge-const))
2990 ;;
2991 ;; But this doesn't seem useful in practice.
2992
2993 (define_expand "fmaddsub_<mode>"
2994   [(set (match_operand:VF 0 "register_operand")
2995         (unspec:VF
2996           [(match_operand:VF 1 "nonimmediate_operand")
2997            (match_operand:VF 2 "nonimmediate_operand")
2998            (match_operand:VF 3 "nonimmediate_operand")]
2999           UNSPEC_FMADDSUB))]
3000   "TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F")
3001
3002 (define_expand "avx512f_fmaddsub_<mode>_maskz<round_expand_name>"
3003   [(match_operand:VF_512 0 "register_operand")
3004    (match_operand:VF_512 1 "<round_expand_nimm_predicate>")
3005    (match_operand:VF_512 2 "<round_expand_nimm_predicate>")
3006    (match_operand:VF_512 3 "<round_expand_nimm_predicate>")
3007    (match_operand:<avx512fmaskmode> 4 "register_operand")]
3008   "TARGET_AVX512F"
3009 {
3010   emit_insn (gen_fma_fmaddsub_<mode>_maskz_1<round_expand_name> (
3011     operands[0], operands[1], operands[2], operands[3],
3012     CONST0_RTX (<MODE>mode), operands[4]<round_expand_operand>));
3013   DONE;
3014 })
3015
3016 (define_insn "<sd_mask_codefor>fma_fmaddsub_<mode><sd_maskz_name><round_name>"
3017   [(set (match_operand:VF 0 "register_operand" "=v,v,v,x,x")
3018         (unspec:VF
3019           [(match_operand:VF 1 "<round_nimm_predicate>" "%0,0,v,x,x")
3020            (match_operand:VF 2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
3021            (match_operand:VF 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x")]
3022           UNSPEC_FMADDSUB))]
3023   "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F) && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3024   "@
3025    vfmaddsub132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3026    vfmaddsub213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3027    vfmaddsub231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
3028    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
3029    vfmaddsub<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
3030   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
3031    (set_attr "type" "ssemuladd")
3032    (set_attr "mode" "<MODE>")])
3033
3034 (define_insn "avx512f_fmaddsub_<mode>_mask<round_name>"
3035   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
3036         (vec_merge:VF_512
3037           (unspec:VF_512
3038             [(match_operand:VF_512 1 "register_operand" "0,0")
3039              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
3040              (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>")]
3041             UNSPEC_FMADDSUB)
3042           (match_dup 1)
3043           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
3044   "TARGET_AVX512F"
3045   "@
3046    vfmaddsub132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
3047    vfmaddsub213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
3048   [(set_attr "isa" "fma_avx512f,fma_avx512f")
3049    (set_attr "type" "ssemuladd")
3050    (set_attr "mode" "<MODE>")])
3051
3052 (define_insn "avx512f_fmaddsub_<mode>_mask3<round_name>"
3053   [(set (match_operand:VF_512 0 "register_operand" "=v")
3054         (vec_merge:VF_512
3055           (unspec:VF_512
3056             [(match_operand:VF_512 1 "register_operand" "v")
3057              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
3058              (match_operand:VF_512 3 "register_operand" "0")]
3059             UNSPEC_FMADDSUB)
3060           (match_dup 3)
3061           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
3062   "TARGET_AVX512F"
3063   "vfmaddsub231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
3064   [(set_attr "isa" "fma_avx512f")
3065    (set_attr "type" "ssemuladd")
3066    (set_attr "mode" "<MODE>")])
3067
3068 (define_insn "<sd_mask_codefor>fma_fmsubadd_<mode><sd_maskz_name><round_name>"
3069   [(set (match_operand:VF 0 "register_operand" "=v,v,v,x,x")
3070         (unspec:VF
3071           [(match_operand:VF   1 "<round_nimm_predicate>" "%0,0,v,x,x")
3072            (match_operand:VF   2 "<round_nimm_predicate>" "<round_constraint>,v,<round_constraint>,x,m")
3073            (neg:VF
3074              (match_operand:VF 3 "<round_nimm_predicate>" "v,<round_constraint>,0,xm,x"))]
3075           UNSPEC_FMADDSUB))]
3076   "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512F) && <sd_mask_mode512bit_condition> && <round_mode512bit_condition>"
3077   "@
3078    vfmsubadd132<ssemodesuffix>\t{<round_sd_mask_op4>%2, %3, %0<sd_mask_op4>|%0<sd_mask_op4>, %3, %2<round_sd_mask_op4>}
3079    vfmsubadd213<ssemodesuffix>\t{<round_sd_mask_op4>%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3<round_sd_mask_op4>}
3080    vfmsubadd231<ssemodesuffix>\t{<round_sd_mask_op4>%2, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %2<round_sd_mask_op4>}
3081    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}
3082    vfmsubadd<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
3083   [(set_attr "isa" "fma_avx512f,fma_avx512f,fma_avx512f,fma4,fma4")
3084    (set_attr "type" "ssemuladd")
3085    (set_attr "mode" "<MODE>")])
3086
3087 (define_insn "avx512f_fmsubadd_<mode>_mask<round_name>"
3088   [(set (match_operand:VF_512 0 "register_operand" "=v,v")
3089         (vec_merge:VF_512
3090           (unspec:VF_512
3091             [(match_operand:VF_512 1 "register_operand" "0,0")
3092              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>,v")
3093              (neg:VF_512
3094                (match_operand:VF_512 3 "<round_nimm_predicate>" "v,<round_constraint>"))]
3095             UNSPEC_FMADDSUB)
3096           (match_dup 1)
3097           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk,Yk")))]
3098   "TARGET_AVX512F"
3099   "@
3100    vfmsubadd132<ssemodesuffix>\t{<round_op5>%2, %3, %0%{%4%}|%0%{%4%}, %3, %2<round_op5>}
3101    vfmsubadd213<ssemodesuffix>\t{<round_op5>%3, %2, %0%{%4%}|%0%{%4%}, %2, %3<round_op5>}"
3102   [(set_attr "isa" "fma_avx512f,fma_avx512f")
3103    (set_attr "type" "ssemuladd")
3104    (set_attr "mode" "<MODE>")])
3105
3106 (define_insn "avx512f_fmsubadd_<mode>_mask3<round_name>"
3107   [(set (match_operand:VF_512 0 "register_operand" "=v")
3108         (vec_merge:VF_512
3109           (unspec:VF_512
3110             [(match_operand:VF_512 1 "register_operand" "v")
3111              (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")
3112              (neg:VF_512
3113                (match_operand:VF_512 3 "register_operand" "0"))]
3114             UNSPEC_FMADDSUB)
3115           (match_dup 3)
3116           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
3117   "TARGET_AVX512F"
3118   "vfmsubadd231<ssemodesuffix>\t{<round_op5>%2, %1, %0%{%4%}|%0%{%4%}, %1, %2<round_op5>}"
3119   [(set_attr "isa" "fma_avx512f")
3120    (set_attr "type" "ssemuladd")
3121    (set_attr "mode" "<MODE>")])
3122
3123 ;; FMA3 floating point scalar intrinsics. These merge result with
3124 ;; high-order elements from the destination register.
3125
3126 (define_expand "fmai_vmfmadd_<mode><round_name>"
3127   [(set (match_operand:VF_128 0 "register_operand")
3128         (vec_merge:VF_128
3129           (fma:VF_128
3130             (match_operand:VF_128 1 "<round_nimm_predicate>")
3131             (match_operand:VF_128 2 "<round_nimm_predicate>")
3132             (match_operand:VF_128 3 "<round_nimm_predicate>"))
3133           (match_dup 1)
3134           (const_int 1)))]
3135   "TARGET_FMA")
3136
3137 (define_insn "*fmai_fmadd_<mode>"
3138   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3139         (vec_merge:VF_128
3140           (fma:VF_128
3141             (match_operand:VF_128 1 "<round_nimm_predicate>" " 0, 0")
3142             (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>, v")
3143             (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>"))
3144           (match_dup 1)
3145           (const_int 1)))]
3146   "TARGET_FMA || TARGET_AVX512F"
3147   "@
3148    vfmadd132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3149    vfmadd213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3150   [(set_attr "type" "ssemuladd")
3151    (set_attr "mode" "<MODE>")])
3152
3153 (define_insn "*fmai_fmsub_<mode>"
3154   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3155         (vec_merge:VF_128
3156           (fma:VF_128
3157             (match_operand:VF_128   1 "<round_nimm_predicate>" "0,0")
3158             (match_operand:VF_128   2 "<round_nimm_predicate>" "<round_constraint>,v")
3159             (neg:VF_128
3160               (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>")))
3161           (match_dup 1)
3162           (const_int 1)))]
3163   "TARGET_FMA || TARGET_AVX512F"
3164   "@
3165    vfmsub132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3166    vfmsub213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3167   [(set_attr "type" "ssemuladd")
3168    (set_attr "mode" "<MODE>")])
3169
3170 (define_insn "*fmai_fnmadd_<mode><round_name>"
3171   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3172         (vec_merge:VF_128
3173           (fma:VF_128
3174             (neg:VF_128
3175               (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>,v"))
3176             (match_operand:VF_128   1 "<round_nimm_predicate>" "0,0")
3177             (match_operand:VF_128   3 "<round_nimm_predicate>" "v,<round_constraint>"))
3178           (match_dup 1)
3179           (const_int 1)))]
3180   "TARGET_FMA || TARGET_AVX512F"
3181   "@
3182    vfnmadd132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3183    vfnmadd213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3184   [(set_attr "type" "ssemuladd")
3185    (set_attr "mode" "<MODE>")])
3186
3187 (define_insn "*fmai_fnmsub_<mode><round_name>"
3188   [(set (match_operand:VF_128 0 "register_operand" "=v,v")
3189         (vec_merge:VF_128
3190           (fma:VF_128
3191             (neg:VF_128
3192               (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>, v"))
3193             (match_operand:VF_128   1 "<round_nimm_predicate>" " 0, 0")
3194             (neg:VF_128
3195               (match_operand:VF_128 3 "<round_nimm_predicate>" " v,<round_constraint>")))
3196           (match_dup 1)
3197           (const_int 1)))]
3198   "TARGET_FMA || TARGET_AVX512F"
3199   "@
3200    vfnmsub132<ssescalarmodesuffix>\t{<round_op4>%2, %3, %0|%0, %<iptr>3, %<iptr>2<round_op4>}
3201    vfnmsub213<ssescalarmodesuffix>\t{<round_op4>%3, %2, %0|%0, %<iptr>2, %<iptr>3<round_op4>}"
3202   [(set_attr "type" "ssemuladd")
3203    (set_attr "mode" "<MODE>")])
3204
3205 ;; FMA4 floating point scalar intrinsics.  These write the
3206 ;; entire destination register, with the high-order elements zeroed.
3207
3208 (define_expand "fma4i_vmfmadd_<mode>"
3209   [(set (match_operand:VF_128 0 "register_operand")
3210         (vec_merge:VF_128
3211           (fma:VF_128
3212             (match_operand:VF_128 1 "nonimmediate_operand")
3213             (match_operand:VF_128 2 "nonimmediate_operand")
3214             (match_operand:VF_128 3 "nonimmediate_operand"))
3215           (match_dup 4)
3216           (const_int 1)))]
3217   "TARGET_FMA4"
3218   "operands[4] = CONST0_RTX (<MODE>mode);")
3219
3220 (define_insn "*fma4i_vmfmadd_<mode>"
3221   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3222         (vec_merge:VF_128
3223           (fma:VF_128
3224             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
3225             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
3226             (match_operand:VF_128 3 "nonimmediate_operand" "xm,x"))
3227           (match_operand:VF_128 4 "const0_operand")
3228           (const_int 1)))]
3229   "TARGET_FMA4"
3230   "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3231   [(set_attr "type" "ssemuladd")
3232    (set_attr "mode" "<MODE>")])
3233
3234 (define_insn "*fma4i_vmfmsub_<mode>"
3235   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3236         (vec_merge:VF_128
3237           (fma:VF_128
3238             (match_operand:VF_128 1 "nonimmediate_operand" "%x,x")
3239             (match_operand:VF_128 2 "nonimmediate_operand" " x,m")
3240             (neg:VF_128
3241               (match_operand:VF_128 3 "nonimmediate_operand" "xm,x")))
3242           (match_operand:VF_128 4 "const0_operand")
3243           (const_int 1)))]
3244   "TARGET_FMA4"
3245   "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3246   [(set_attr "type" "ssemuladd")
3247    (set_attr "mode" "<MODE>")])
3248
3249 (define_insn "*fma4i_vmfnmadd_<mode>"
3250   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3251         (vec_merge:VF_128
3252           (fma:VF_128
3253             (neg:VF_128
3254               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
3255             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
3256             (match_operand:VF_128   3 "nonimmediate_operand" "xm,x"))
3257           (match_operand:VF_128 4 "const0_operand")
3258           (const_int 1)))]
3259   "TARGET_FMA4"
3260   "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3261   [(set_attr "type" "ssemuladd")
3262    (set_attr "mode" "<MODE>")])
3263
3264 (define_insn "*fma4i_vmfnmsub_<mode>"
3265   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
3266         (vec_merge:VF_128
3267           (fma:VF_128
3268             (neg:VF_128
3269               (match_operand:VF_128 1 "nonimmediate_operand" "%x,x"))
3270             (match_operand:VF_128   2 "nonimmediate_operand" " x,m")
3271             (neg:VF_128
3272               (match_operand:VF_128   3 "nonimmediate_operand" "xm,x")))
3273           (match_operand:VF_128 4 "const0_operand")
3274           (const_int 1)))]
3275   "TARGET_FMA4"
3276   "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}"
3277   [(set_attr "type" "ssemuladd")
3278    (set_attr "mode" "<MODE>")])
3279
3280 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3281 ;;
3282 ;; Parallel single-precision floating point conversion operations
3283 ;;
3284 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3285
3286 (define_insn "sse_cvtpi2ps"
3287   [(set (match_operand:V4SF 0 "register_operand" "=x")
3288         (vec_merge:V4SF
3289           (vec_duplicate:V4SF
3290             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
3291           (match_operand:V4SF 1 "register_operand" "0")
3292           (const_int 3)))]
3293   "TARGET_SSE"
3294   "cvtpi2ps\t{%2, %0|%0, %2}"
3295   [(set_attr "type" "ssecvt")
3296    (set_attr "mode" "V4SF")])
3297
3298 (define_insn "sse_cvtps2pi"
3299   [(set (match_operand:V2SI 0 "register_operand" "=y")
3300         (vec_select:V2SI
3301           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
3302                        UNSPEC_FIX_NOTRUNC)
3303           (parallel [(const_int 0) (const_int 1)])))]
3304   "TARGET_SSE"
3305   "cvtps2pi\t{%1, %0|%0, %q1}"
3306   [(set_attr "type" "ssecvt")
3307    (set_attr "unit" "mmx")
3308    (set_attr "mode" "DI")])
3309
3310 (define_insn "sse_cvttps2pi"
3311   [(set (match_operand:V2SI 0 "register_operand" "=y")
3312         (vec_select:V2SI
3313           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
3314           (parallel [(const_int 0) (const_int 1)])))]
3315   "TARGET_SSE"
3316   "cvttps2pi\t{%1, %0|%0, %q1}"
3317   [(set_attr "type" "ssecvt")
3318    (set_attr "unit" "mmx")
3319    (set_attr "prefix_rep" "0")
3320    (set_attr "mode" "SF")])
3321
3322 (define_insn "sse_cvtsi2ss<round_name>"
3323   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
3324         (vec_merge:V4SF
3325           (vec_duplicate:V4SF
3326             (float:SF (match_operand:SI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3327           (match_operand:V4SF 1 "register_operand" "0,0,v")
3328           (const_int 1)))]
3329   "TARGET_SSE"
3330   "@
3331    cvtsi2ss\t{%2, %0|%0, %2}
3332    cvtsi2ss\t{%2, %0|%0, %2}
3333    vcvtsi2ss\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3334   [(set_attr "isa" "noavx,noavx,avx")
3335    (set_attr "type" "sseicvt")
3336    (set_attr "athlon_decode" "vector,double,*")
3337    (set_attr "amdfam10_decode" "vector,double,*")
3338    (set_attr "bdver1_decode" "double,direct,*")
3339    (set_attr "btver2_decode" "double,double,double")
3340    (set_attr "prefix" "orig,orig,maybe_evex")
3341    (set_attr "mode" "SF")])
3342
3343 (define_insn "sse_cvtsi2ssq<round_name>"
3344   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
3345         (vec_merge:V4SF
3346           (vec_duplicate:V4SF
3347             (float:SF (match_operand:DI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3348           (match_operand:V4SF 1 "register_operand" "0,0,v")
3349           (const_int 1)))]
3350   "TARGET_SSE && TARGET_64BIT"
3351   "@
3352    cvtsi2ssq\t{%2, %0|%0, %2}
3353    cvtsi2ssq\t{%2, %0|%0, %2}
3354    vcvtsi2ssq\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3355   [(set_attr "isa" "noavx,noavx,avx")
3356    (set_attr "type" "sseicvt")
3357    (set_attr "athlon_decode" "vector,double,*")
3358    (set_attr "amdfam10_decode" "vector,double,*")
3359    (set_attr "bdver1_decode" "double,direct,*")
3360    (set_attr "btver2_decode" "double,double,double")
3361    (set_attr "length_vex" "*,*,4")
3362    (set_attr "prefix_rex" "1,1,*")
3363    (set_attr "prefix" "orig,orig,maybe_evex")
3364    (set_attr "mode" "SF")])
3365
3366 (define_insn "sse_cvtss2si<round_name>"
3367   [(set (match_operand:SI 0 "register_operand" "=r,r")
3368         (unspec:SI
3369           [(vec_select:SF
3370              (match_operand:V4SF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3371              (parallel [(const_int 0)]))]
3372           UNSPEC_FIX_NOTRUNC))]
3373   "TARGET_SSE"
3374   "%vcvtss2si\t{<round_op2>%1, %0|%0, %k1<round_op2>}"
3375   [(set_attr "type" "sseicvt")
3376    (set_attr "athlon_decode" "double,vector")
3377    (set_attr "bdver1_decode" "double,double")
3378    (set_attr "prefix_rep" "1")
3379    (set_attr "prefix" "maybe_vex")
3380    (set_attr "mode" "SI")])
3381
3382 (define_insn "sse_cvtss2si_2"
3383   [(set (match_operand:SI 0 "register_operand" "=r,r")
3384         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "v,m")]
3385                    UNSPEC_FIX_NOTRUNC))]
3386   "TARGET_SSE"
3387   "%vcvtss2si\t{%1, %0|%0, %k1}"
3388   [(set_attr "type" "sseicvt")
3389    (set_attr "athlon_decode" "double,vector")
3390    (set_attr "amdfam10_decode" "double,double")
3391    (set_attr "bdver1_decode" "double,double")
3392    (set_attr "prefix_rep" "1")
3393    (set_attr "prefix" "maybe_vex")
3394    (set_attr "mode" "SI")])
3395
3396 (define_insn "sse_cvtss2siq<round_name>"
3397   [(set (match_operand:DI 0 "register_operand" "=r,r")
3398         (unspec:DI
3399           [(vec_select:SF
3400              (match_operand:V4SF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3401              (parallel [(const_int 0)]))]
3402           UNSPEC_FIX_NOTRUNC))]
3403   "TARGET_SSE && TARGET_64BIT"
3404   "%vcvtss2si{q}\t{<round_op2>%1, %0|%0, %k1<round_op2>}"
3405   [(set_attr "type" "sseicvt")
3406    (set_attr "athlon_decode" "double,vector")
3407    (set_attr "bdver1_decode" "double,double")
3408    (set_attr "prefix_rep" "1")
3409    (set_attr "prefix" "maybe_vex")
3410    (set_attr "mode" "DI")])
3411
3412 (define_insn "sse_cvtss2siq_2"
3413   [(set (match_operand:DI 0 "register_operand" "=r,r")
3414         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "v,m")]
3415                    UNSPEC_FIX_NOTRUNC))]
3416   "TARGET_SSE && TARGET_64BIT"
3417   "%vcvtss2si{q}\t{%1, %0|%0, %k1}"
3418   [(set_attr "type" "sseicvt")
3419    (set_attr "athlon_decode" "double,vector")
3420    (set_attr "amdfam10_decode" "double,double")
3421    (set_attr "bdver1_decode" "double,double")
3422    (set_attr "prefix_rep" "1")
3423    (set_attr "prefix" "maybe_vex")
3424    (set_attr "mode" "DI")])
3425
3426 (define_insn "sse_cvttss2si<round_saeonly_name>"
3427   [(set (match_operand:SI 0 "register_operand" "=r,r")
3428         (fix:SI
3429           (vec_select:SF
3430             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3431             (parallel [(const_int 0)]))))]
3432   "TARGET_SSE"
3433   "%vcvttss2si\t{<round_saeonly_op2>%1, %0|%0, %k1<round_saeonly_op2>}"
3434   [(set_attr "type" "sseicvt")
3435    (set_attr "athlon_decode" "double,vector")
3436    (set_attr "amdfam10_decode" "double,double")
3437    (set_attr "bdver1_decode" "double,double")
3438    (set_attr "prefix_rep" "1")
3439    (set_attr "prefix" "maybe_vex")
3440    (set_attr "mode" "SI")])
3441
3442 (define_insn "sse_cvttss2siq<round_saeonly_name>"
3443   [(set (match_operand:DI 0 "register_operand" "=r,r")
3444         (fix:DI
3445           (vec_select:SF
3446             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint>")
3447             (parallel [(const_int 0)]))))]
3448   "TARGET_SSE && TARGET_64BIT"
3449   "%vcvttss2si{q}\t{<round_saeonly_op2>%1, %0|%0, %k1<round_saeonly_op2>}"
3450   [(set_attr "type" "sseicvt")
3451    (set_attr "athlon_decode" "double,vector")
3452    (set_attr "amdfam10_decode" "double,double")
3453    (set_attr "bdver1_decode" "double,double")
3454    (set_attr "prefix_rep" "1")
3455    (set_attr "prefix" "maybe_vex")
3456    (set_attr "mode" "DI")])
3457
3458 (define_insn "cvtusi2<ssescalarmodesuffix>32<round_name>"
3459   [(set (match_operand:VF_128 0 "register_operand" "=v")
3460         (vec_merge:VF_128
3461           (vec_duplicate:VF_128
3462             (unsigned_float:<ssescalarmode>
3463               (match_operand:SI 2 "<round_nimm_predicate>" "<round_constraint3>")))
3464           (match_operand:VF_128 1 "register_operand" "v")
3465           (const_int 1)))]
3466   "TARGET_AVX512F && <round_modev4sf_condition>"
3467   "vcvtusi2<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3468   [(set_attr "type" "sseicvt")
3469    (set_attr "prefix" "evex")
3470    (set_attr "mode" "<ssescalarmode>")])
3471
3472 (define_insn "cvtusi2<ssescalarmodesuffix>64<round_name>"
3473   [(set (match_operand:VF_128 0 "register_operand" "=v")
3474         (vec_merge:VF_128
3475           (vec_duplicate:VF_128
3476             (unsigned_float:<ssescalarmode>
3477               (match_operand:DI 2 "<round_nimm_predicate>" "<round_constraint3>")))
3478           (match_operand:VF_128 1 "register_operand" "v")
3479           (const_int 1)))]
3480   "TARGET_AVX512F && TARGET_64BIT"
3481   "vcvtusi2<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3482   [(set_attr "type" "sseicvt")
3483    (set_attr "prefix" "evex")
3484    (set_attr "mode" "<ssescalarmode>")])
3485
3486 (define_insn "float<sseintvecmodelower><mode>2<mask_name><round_name>"
3487   [(set (match_operand:VF1 0 "register_operand" "=v")
3488         (float:VF1
3489           (match_operand:<sseintvecmode> 1 "<round_nimm_predicate>" "<round_constraint>")))]
3490   "TARGET_SSE2 && <mask_mode512bit_condition> && <round_mode512bit_condition>"
3491   "%vcvtdq2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3492   [(set_attr "type" "ssecvt")
3493    (set_attr "prefix" "maybe_vex")
3494    (set_attr "mode" "<sseinsnmode>")])
3495
3496 (define_insn "ufloatv16siv16sf2<mask_name><round_name>"
3497   [(set (match_operand:V16SF 0 "register_operand" "=v")
3498         (unsigned_float:V16SF
3499           (match_operand:V16SI 1 "<round_nimm_predicate>" "<round_constraint>")))]
3500   "TARGET_AVX512F"
3501   "vcvtudq2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3502   [(set_attr "type" "ssecvt")
3503    (set_attr "prefix" "evex")
3504    (set_attr "mode" "V16SF")])
3505
3506 (define_expand "floatuns<sseintvecmodelower><mode>2"
3507   [(match_operand:VF1 0 "register_operand")
3508    (match_operand:<sseintvecmode> 1 "register_operand")]
3509   "TARGET_SSE2 && (<MODE>mode == V4SFmode || TARGET_AVX2)"
3510 {
3511   if (<MODE>mode == V16SFmode)
3512     emit_insn (gen_ufloatv16siv16sf2 (operands[0], operands[1]));
3513   else
3514     ix86_expand_vector_convert_uns_vsivsf (operands[0], operands[1]);
3515
3516   DONE;
3517 })
3518
3519
3520 ;; For <sse2_avx_avx512f>_fix_notrunc<sf2simodelower><mode> insn pattern
3521 (define_mode_attr sf2simodelower
3522   [(V16SI "v16sf") (V8SI "v8sf") (V4SI "v4sf")])
3523
3524 (define_insn "<sse2_avx_avx512f>_fix_notrunc<sf2simodelower><mode>"
3525   [(set (match_operand:VI4_AVX 0 "register_operand" "=v")
3526         (unspec:VI4_AVX
3527           [(match_operand:<ssePSmode> 1 "nonimmediate_operand" "vm")]
3528           UNSPEC_FIX_NOTRUNC))]
3529   "TARGET_SSE2"
3530   "%vcvtps2dq\t{%1, %0|%0, %1}"
3531   [(set_attr "type" "ssecvt")
3532    (set (attr "prefix_data16")
3533      (if_then_else
3534        (match_test "TARGET_AVX")
3535      (const_string "*")
3536      (const_string "1")))
3537    (set_attr "prefix" "maybe_vex")
3538    (set_attr "mode" "<sseinsnmode>")])
3539
3540 (define_insn "<mask_codefor>avx512f_fix_notruncv16sfv16si<mask_name><round_name>"
3541   [(set (match_operand:V16SI 0 "register_operand" "=v")
3542         (unspec:V16SI
3543           [(match_operand:V16SF 1 "<round_nimm_predicate>" "<round_constraint>")]
3544           UNSPEC_FIX_NOTRUNC))]
3545   "TARGET_AVX512F"
3546   "vcvtps2dq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3547   [(set_attr "type" "ssecvt")
3548    (set_attr "prefix" "evex")
3549    (set_attr "mode" "XI")])
3550
3551 (define_insn "<mask_codefor>avx512f_ufix_notruncv16sfv16si<mask_name><round_name>"
3552   [(set (match_operand:V16SI 0 "register_operand" "=v")
3553         (unspec:V16SI
3554           [(match_operand:V16SF 1 "<round_nimm_predicate>" "<round_constraint>")]
3555           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3556   "TARGET_AVX512F"
3557   "vcvtps2udq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3558   [(set_attr "type" "ssecvt")
3559    (set_attr "prefix" "evex")
3560    (set_attr "mode" "XI")])
3561
3562 (define_insn "<fixsuffix>fix_truncv16sfv16si2<mask_name><round_saeonly_name>"
3563   [(set (match_operand:V16SI 0 "register_operand" "=v")
3564         (any_fix:V16SI
3565           (match_operand:V16SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
3566   "TARGET_AVX512F"
3567   "vcvttps2<fixsuffix>dq\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
3568   [(set_attr "type" "ssecvt")
3569    (set_attr "prefix" "evex")
3570    (set_attr "mode" "XI")])
3571
3572 (define_insn "fix_truncv8sfv8si2"
3573   [(set (match_operand:V8SI 0 "register_operand" "=x")
3574         (fix:V8SI (match_operand:V8SF 1 "nonimmediate_operand" "xm")))]
3575   "TARGET_AVX"
3576   "vcvttps2dq\t{%1, %0|%0, %1}"
3577   [(set_attr "type" "ssecvt")
3578    (set_attr "prefix" "vex")
3579    (set_attr "mode" "OI")])
3580
3581 (define_insn "fix_truncv4sfv4si2"
3582   [(set (match_operand:V4SI 0 "register_operand" "=x")
3583         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
3584   "TARGET_SSE2"
3585   "%vcvttps2dq\t{%1, %0|%0, %1}"
3586   [(set_attr "type" "ssecvt")
3587    (set (attr "prefix_rep")
3588      (if_then_else
3589        (match_test "TARGET_AVX")
3590      (const_string "*")
3591      (const_string "1")))
3592    (set (attr "prefix_data16")
3593      (if_then_else
3594        (match_test "TARGET_AVX")
3595      (const_string "*")
3596      (const_string "0")))
3597    (set_attr "prefix_data16" "0")
3598    (set_attr "prefix" "maybe_vex")
3599    (set_attr "mode" "TI")])
3600
3601 (define_expand "fixuns_trunc<mode><sseintvecmodelower>2"
3602   [(match_operand:<sseintvecmode> 0 "register_operand")
3603    (match_operand:VF1 1 "register_operand")]
3604   "TARGET_SSE2"
3605 {
3606   if (<MODE>mode == V16SFmode)
3607     emit_insn (gen_ufix_truncv16sfv16si2 (operands[0],
3608                                           operands[1]));
3609   else
3610     {
3611       rtx tmp[3];
3612       tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
3613       tmp[1] = gen_reg_rtx (<sseintvecmode>mode);
3614       emit_insn (gen_fix_trunc<mode><sseintvecmodelower>2 (tmp[1], tmp[0]));
3615       emit_insn (gen_xor<sseintvecmodelower>3 (operands[0], tmp[1], tmp[2]));
3616     }
3617   DONE;
3618 })
3619
3620 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3621 ;;
3622 ;; Parallel double-precision floating point conversion operations
3623 ;;
3624 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3625
3626 (define_insn "sse2_cvtpi2pd"
3627   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
3628         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
3629   "TARGET_SSE2"
3630   "cvtpi2pd\t{%1, %0|%0, %1}"
3631   [(set_attr "type" "ssecvt")
3632    (set_attr "unit" "mmx,*")
3633    (set_attr "prefix_data16" "1,*")
3634    (set_attr "mode" "V2DF")])
3635
3636 (define_insn "sse2_cvtpd2pi"
3637   [(set (match_operand:V2SI 0 "register_operand" "=y")
3638         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
3639                      UNSPEC_FIX_NOTRUNC))]
3640   "TARGET_SSE2"
3641   "cvtpd2pi\t{%1, %0|%0, %1}"
3642   [(set_attr "type" "ssecvt")
3643    (set_attr "unit" "mmx")
3644    (set_attr "bdver1_decode" "double")
3645    (set_attr "btver2_decode" "direct")
3646    (set_attr "prefix_data16" "1")
3647    (set_attr "mode" "DI")])
3648
3649 (define_insn "sse2_cvttpd2pi"
3650   [(set (match_operand:V2SI 0 "register_operand" "=y")
3651         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
3652   "TARGET_SSE2"
3653   "cvttpd2pi\t{%1, %0|%0, %1}"
3654   [(set_attr "type" "ssecvt")
3655    (set_attr "unit" "mmx")
3656    (set_attr "bdver1_decode" "double")
3657    (set_attr "prefix_data16" "1")
3658    (set_attr "mode" "TI")])
3659
3660 (define_insn "sse2_cvtsi2sd"
3661   [(set (match_operand:V2DF 0 "register_operand" "=x,x,x")
3662         (vec_merge:V2DF
3663           (vec_duplicate:V2DF
3664             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m,rm")))
3665           (match_operand:V2DF 1 "register_operand" "0,0,x")
3666           (const_int 1)))]
3667   "TARGET_SSE2"
3668   "@
3669    cvtsi2sd\t{%2, %0|%0, %2}
3670    cvtsi2sd\t{%2, %0|%0, %2}
3671    vcvtsi2sd\t{%2, %1, %0|%0, %1, %2}"
3672   [(set_attr "isa" "noavx,noavx,avx")
3673    (set_attr "type" "sseicvt")
3674    (set_attr "athlon_decode" "double,direct,*")
3675    (set_attr "amdfam10_decode" "vector,double,*")
3676    (set_attr "bdver1_decode" "double,direct,*")
3677    (set_attr "btver2_decode" "double,double,double")
3678    (set_attr "prefix" "orig,orig,vex")
3679    (set_attr "mode" "DF")])
3680
3681 (define_insn "sse2_cvtsi2sdq<round_name>"
3682   [(set (match_operand:V2DF 0 "register_operand" "=x,x,v")
3683         (vec_merge:V2DF
3684           (vec_duplicate:V2DF
3685             (float:DF (match_operand:DI 2 "<round_nimm_predicate>" "r,m,<round_constraint3>")))
3686           (match_operand:V2DF 1 "register_operand" "0,0,v")
3687           (const_int 1)))]
3688   "TARGET_SSE2 && TARGET_64BIT"
3689   "@
3690    cvtsi2sdq\t{%2, %0|%0, %2}
3691    cvtsi2sdq\t{%2, %0|%0, %2}
3692    vcvtsi2sdq\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
3693   [(set_attr "isa" "noavx,noavx,avx")
3694    (set_attr "type" "sseicvt")
3695    (set_attr "athlon_decode" "double,direct,*")
3696    (set_attr "amdfam10_decode" "vector,double,*")
3697    (set_attr "bdver1_decode" "double,direct,*")
3698    (set_attr "length_vex" "*,*,4")
3699    (set_attr "prefix_rex" "1,1,*")
3700    (set_attr "prefix" "orig,orig,maybe_evex")
3701    (set_attr "mode" "DF")])
3702
3703 (define_insn "avx512f_vcvtss2usi<round_name>"
3704   [(set (match_operand:SI 0 "register_operand" "=r")
3705         (unspec:SI
3706           [(vec_select:SF
3707              (match_operand:V4SF 1 "<round_nimm_predicate>" "<round_constraint>")
3708              (parallel [(const_int 0)]))]
3709           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3710   "TARGET_AVX512F"
3711   "vcvtss2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3712   [(set_attr "type" "sseicvt")
3713    (set_attr "prefix" "evex")
3714    (set_attr "mode" "SI")])
3715
3716 (define_insn "avx512f_vcvtss2usiq<round_name>"
3717   [(set (match_operand:DI 0 "register_operand" "=r")
3718         (unspec:DI
3719           [(vec_select:SF
3720              (match_operand:V4SF 1 "<round_nimm_predicate>" "<round_constraint>")
3721              (parallel [(const_int 0)]))]
3722           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3723   "TARGET_AVX512F && TARGET_64BIT"
3724   "vcvtss2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3725   [(set_attr "type" "sseicvt")
3726    (set_attr "prefix" "evex")
3727    (set_attr "mode" "DI")])
3728
3729 (define_insn "avx512f_vcvttss2usi<round_saeonly_name>"
3730   [(set (match_operand:SI 0 "register_operand" "=r")
3731         (unsigned_fix:SI
3732           (vec_select:SF
3733             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3734             (parallel [(const_int 0)]))))]
3735   "TARGET_AVX512F"
3736   "vcvttss2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3737   [(set_attr "type" "sseicvt")
3738    (set_attr "prefix" "evex")
3739    (set_attr "mode" "SI")])
3740
3741 (define_insn "avx512f_vcvttss2usiq<round_saeonly_name>"
3742   [(set (match_operand:DI 0 "register_operand" "=r")
3743         (unsigned_fix:DI
3744           (vec_select:SF
3745             (match_operand:V4SF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3746             (parallel [(const_int 0)]))))]
3747   "TARGET_AVX512F && TARGET_64BIT"
3748   "vcvttss2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3749   [(set_attr "type" "sseicvt")
3750    (set_attr "prefix" "evex")
3751    (set_attr "mode" "DI")])
3752
3753 (define_insn "avx512f_vcvtsd2usi<round_name>"
3754   [(set (match_operand:SI 0 "register_operand" "=r")
3755         (unspec:SI
3756           [(vec_select:DF
3757              (match_operand:V2DF 1 "<round_nimm_predicate>" "<round_constraint>")
3758              (parallel [(const_int 0)]))]
3759           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3760   "TARGET_AVX512F"
3761   "vcvtsd2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3762   [(set_attr "type" "sseicvt")
3763    (set_attr "prefix" "evex")
3764    (set_attr "mode" "SI")])
3765
3766 (define_insn "avx512f_vcvtsd2usiq<round_name>"
3767   [(set (match_operand:DI 0 "register_operand" "=r")
3768         (unspec:DI
3769           [(vec_select:DF
3770              (match_operand:V2DF 1 "<round_nimm_predicate>" "<round_constraint>")
3771              (parallel [(const_int 0)]))]
3772           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
3773   "TARGET_AVX512F && TARGET_64BIT"
3774   "vcvtsd2usi\t{<round_op2>%1, %0|%0, %1<round_op2>}"
3775   [(set_attr "type" "sseicvt")
3776    (set_attr "prefix" "evex")
3777    (set_attr "mode" "DI")])
3778
3779 (define_insn "avx512f_vcvttsd2usi<round_saeonly_name>"
3780   [(set (match_operand:SI 0 "register_operand" "=r")
3781         (unsigned_fix:SI
3782           (vec_select:DF
3783             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3784             (parallel [(const_int 0)]))))]
3785   "TARGET_AVX512F"
3786   "vcvttsd2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3787   [(set_attr "type" "sseicvt")
3788    (set_attr "prefix" "evex")
3789    (set_attr "mode" "SI")])
3790
3791 (define_insn "avx512f_vcvttsd2usiq<round_saeonly_name>"
3792   [(set (match_operand:DI 0 "register_operand" "=r")
3793         (unsigned_fix:DI
3794           (vec_select:DF
3795             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
3796             (parallel [(const_int 0)]))))]
3797   "TARGET_AVX512F && TARGET_64BIT"
3798   "vcvttsd2usi\t{<round_saeonly_op2>%1, %0|%0, %1<round_saeonly_op2>}"
3799   [(set_attr "type" "sseicvt")
3800    (set_attr "prefix" "evex")
3801    (set_attr "mode" "DI")])
3802
3803 (define_insn "sse2_cvtsd2si<round_name>"
3804   [(set (match_operand:SI 0 "register_operand" "=r,r")
3805         (unspec:SI
3806           [(vec_select:DF
3807              (match_operand:V2DF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3808              (parallel [(const_int 0)]))]
3809           UNSPEC_FIX_NOTRUNC))]
3810   "TARGET_SSE2"
3811   "%vcvtsd2si\t{<round_op2>%1, %0|%0, %q1<round_op2>}"
3812   [(set_attr "type" "sseicvt")
3813    (set_attr "athlon_decode" "double,vector")
3814    (set_attr "bdver1_decode" "double,double")
3815    (set_attr "btver2_decode" "double,double")
3816    (set_attr "prefix_rep" "1")
3817    (set_attr "prefix" "maybe_vex")
3818    (set_attr "mode" "SI")])
3819
3820 (define_insn "sse2_cvtsd2si_2"
3821   [(set (match_operand:SI 0 "register_operand" "=r,r")
3822         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "v,m")]
3823                    UNSPEC_FIX_NOTRUNC))]
3824   "TARGET_SSE2"
3825   "%vcvtsd2si\t{%1, %0|%0, %q1}"
3826   [(set_attr "type" "sseicvt")
3827    (set_attr "athlon_decode" "double,vector")
3828    (set_attr "amdfam10_decode" "double,double")
3829    (set_attr "bdver1_decode" "double,double")
3830    (set_attr "prefix_rep" "1")
3831    (set_attr "prefix" "maybe_vex")
3832    (set_attr "mode" "SI")])
3833
3834 (define_insn "sse2_cvtsd2siq<round_name>"
3835   [(set (match_operand:DI 0 "register_operand" "=r,r")
3836         (unspec:DI
3837           [(vec_select:DF
3838              (match_operand:V2DF 1 "<round_nimm_predicate>" "v,<round_constraint2>")
3839              (parallel [(const_int 0)]))]
3840           UNSPEC_FIX_NOTRUNC))]
3841   "TARGET_SSE2 && TARGET_64BIT"
3842   "%vcvtsd2si{q}\t{<round_op2>%1, %0|%0, %q1<round_op2>}"
3843   [(set_attr "type" "sseicvt")
3844    (set_attr "athlon_decode" "double,vector")
3845    (set_attr "bdver1_decode" "double,double")
3846    (set_attr "prefix_rep" "1")
3847    (set_attr "prefix" "maybe_vex")
3848    (set_attr "mode" "DI")])
3849
3850 (define_insn "sse2_cvtsd2siq_2"
3851   [(set (match_operand:DI 0 "register_operand" "=r,r")
3852         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "v,m")]
3853                    UNSPEC_FIX_NOTRUNC))]
3854   "TARGET_SSE2 && TARGET_64BIT"
3855   "%vcvtsd2si{q}\t{%1, %0|%0, %q1}"
3856   [(set_attr "type" "sseicvt")
3857    (set_attr "athlon_decode" "double,vector")
3858    (set_attr "amdfam10_decode" "double,double")
3859    (set_attr "bdver1_decode" "double,double")
3860    (set_attr "prefix_rep" "1")
3861    (set_attr "prefix" "maybe_vex")
3862    (set_attr "mode" "DI")])
3863
3864 (define_insn "sse2_cvttsd2si<round_saeonly_name>"
3865   [(set (match_operand:SI 0 "register_operand" "=r,r")
3866         (fix:SI
3867           (vec_select:DF
3868             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3869             (parallel [(const_int 0)]))))]
3870   "TARGET_SSE2"
3871   "%vcvttsd2si\t{<round_saeonly_op2>%1, %0|%0, %q1<round_saeonly_op2>}"
3872   [(set_attr "type" "sseicvt")
3873    (set_attr "athlon_decode" "double,vector")
3874    (set_attr "amdfam10_decode" "double,double")
3875    (set_attr "bdver1_decode" "double,double")
3876    (set_attr "btver2_decode" "double,double")
3877    (set_attr "prefix_rep" "1")
3878    (set_attr "prefix" "maybe_vex")
3879    (set_attr "mode" "SI")])
3880
3881 (define_insn "sse2_cvttsd2siq<round_saeonly_name>"
3882   [(set (match_operand:DI 0 "register_operand" "=r,r")
3883         (fix:DI
3884           (vec_select:DF
3885             (match_operand:V2DF 1 "<round_saeonly_nimm_predicate>" "v,<round_saeonly_constraint2>")
3886             (parallel [(const_int 0)]))))]
3887   "TARGET_SSE2 && TARGET_64BIT"
3888   "%vcvttsd2si{q}\t{<round_saeonly_op2>%1, %0|%0, %q1<round_saeonly_op2>}"
3889   [(set_attr "type" "sseicvt")
3890    (set_attr "athlon_decode" "double,vector")
3891    (set_attr "amdfam10_decode" "double,double")
3892    (set_attr "bdver1_decode" "double,double")
3893    (set_attr "prefix_rep" "1")
3894    (set_attr "prefix" "maybe_vex")
3895    (set_attr "mode" "DI")])
3896
3897 ;; For float<si2dfmode><mode>2 insn pattern
3898 (define_mode_attr si2dfmode
3899   [(V8DF "V8SI") (V4DF "V4SI")])
3900 (define_mode_attr si2dfmodelower
3901   [(V8DF "v8si") (V4DF "v4si")])
3902
3903 (define_insn "float<si2dfmodelower><mode>2<mask_name>"
3904   [(set (match_operand:VF2_512_256 0 "register_operand" "=v")
3905         (float:VF2_512_256 (match_operand:<si2dfmode> 1 "nonimmediate_operand" "vm")))]
3906   "TARGET_AVX && <mask_mode512bit_condition>"
3907   "vcvtdq2pd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
3908   [(set_attr "type" "ssecvt")
3909    (set_attr "prefix" "maybe_vex")
3910    (set_attr "mode" "<MODE>")])
3911
3912 (define_insn "ufloatv8siv8df<mask_name>"
3913   [(set (match_operand:V8DF 0 "register_operand" "=v")
3914         (unsigned_float:V8DF
3915           (match_operand:V8SI 1 "nonimmediate_operand" "vm")))]
3916   "TARGET_AVX512F"
3917   "vcvtudq2pd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
3918   [(set_attr "type" "ssecvt")
3919    (set_attr "prefix" "evex")
3920    (set_attr "mode" "V8DF")])
3921
3922 (define_insn "avx512f_cvtdq2pd512_2"
3923   [(set (match_operand:V8DF 0 "register_operand" "=v")
3924         (float:V8DF
3925           (vec_select:V8SI
3926             (match_operand:V16SI 1 "nonimmediate_operand" "vm")
3927             (parallel [(const_int 0) (const_int 1)
3928                        (const_int 2) (const_int 3)
3929                        (const_int 4) (const_int 5)
3930                        (const_int 6) (const_int 7)]))))]
3931   "TARGET_AVX"
3932   "vcvtdq2pd\t{%t1, %0|%0, %t1}"
3933   [(set_attr "type" "ssecvt")
3934    (set_attr "prefix" "evex")
3935    (set_attr "mode" "V8DF")])
3936
3937 (define_insn "avx_cvtdq2pd256_2"
3938   [(set (match_operand:V4DF 0 "register_operand" "=x")
3939         (float:V4DF
3940           (vec_select:V4SI
3941             (match_operand:V8SI 1 "nonimmediate_operand" "xm")
3942             (parallel [(const_int 0) (const_int 1)
3943                        (const_int 2) (const_int 3)]))))]
3944   "TARGET_AVX"
3945   "vcvtdq2pd\t{%x1, %0|%0, %x1}"
3946   [(set_attr "type" "ssecvt")
3947    (set_attr "prefix" "vex")
3948    (set_attr "mode" "V4DF")])
3949
3950 (define_insn "sse2_cvtdq2pd"
3951   [(set (match_operand:V2DF 0 "register_operand" "=x")
3952         (float:V2DF
3953           (vec_select:V2SI
3954             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
3955             (parallel [(const_int 0) (const_int 1)]))))]
3956   "TARGET_SSE2"
3957   "%vcvtdq2pd\t{%1, %0|%0, %q1}"
3958   [(set_attr "type" "ssecvt")
3959    (set_attr "prefix" "maybe_vex")
3960    (set_attr "ssememalign" "64")
3961    (set_attr "mode" "V2DF")])
3962
3963 (define_insn "<mask_codefor>avx512f_cvtpd2dq512<mask_name><round_name>"
3964   [(set (match_operand:V8SI 0 "register_operand" "=v")
3965         (unspec:V8SI
3966           [(match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")]
3967           UNSPEC_FIX_NOTRUNC))]
3968   "TARGET_AVX512F"
3969   "vcvtpd2dq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
3970   [(set_attr "type" "ssecvt")
3971    (set_attr "prefix" "evex")
3972    (set_attr "mode" "OI")])
3973
3974 (define_insn "avx_cvtpd2dq256"
3975   [(set (match_operand:V4SI 0 "register_operand" "=x")
3976         (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
3977                      UNSPEC_FIX_NOTRUNC))]
3978   "TARGET_AVX"
3979   "vcvtpd2dq{y}\t{%1, %0|%0, %1}"
3980   [(set_attr "type" "ssecvt")
3981    (set_attr "prefix" "vex")
3982    (set_attr "mode" "OI")])
3983
3984 (define_expand "avx_cvtpd2dq256_2"
3985   [(set (match_operand:V8SI 0 "register_operand")
3986         (vec_concat:V8SI
3987           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand")]
3988                        UNSPEC_FIX_NOTRUNC)
3989           (match_dup 2)))]
3990   "TARGET_AVX"
3991   "operands[2] = CONST0_RTX (V4SImode);")
3992
3993 (define_insn "*avx_cvtpd2dq256_2"
3994   [(set (match_operand:V8SI 0 "register_operand" "=x")
3995         (vec_concat:V8SI
3996           (unspec:V4SI [(match_operand:V4DF 1 "nonimmediate_operand" "xm")]
3997                        UNSPEC_FIX_NOTRUNC)
3998           (match_operand:V4SI 2 "const0_operand")))]
3999   "TARGET_AVX"
4000   "vcvtpd2dq{y}\t{%1, %x0|%x0, %1}"
4001   [(set_attr "type" "ssecvt")
4002    (set_attr "prefix" "vex")
4003    (set_attr "btver2_decode" "vector")
4004    (set_attr "mode" "OI")])
4005
4006 (define_expand "sse2_cvtpd2dq"
4007   [(set (match_operand:V4SI 0 "register_operand")
4008         (vec_concat:V4SI
4009           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand")]
4010                        UNSPEC_FIX_NOTRUNC)
4011           (match_dup 2)))]
4012   "TARGET_SSE2"
4013   "operands[2] = CONST0_RTX (V2SImode);")
4014
4015 (define_insn "*sse2_cvtpd2dq"
4016   [(set (match_operand:V4SI 0 "register_operand" "=x")
4017         (vec_concat:V4SI
4018           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
4019                        UNSPEC_FIX_NOTRUNC)
4020           (match_operand:V2SI 2 "const0_operand")))]
4021   "TARGET_SSE2"
4022 {
4023   if (TARGET_AVX)
4024     return "vcvtpd2dq{x}\t{%1, %0|%0, %1}";
4025   else
4026     return "cvtpd2dq\t{%1, %0|%0, %1}";
4027 }
4028   [(set_attr "type" "ssecvt")
4029    (set_attr "prefix_rep" "1")
4030    (set_attr "prefix_data16" "0")
4031    (set_attr "prefix" "maybe_vex")
4032    (set_attr "mode" "TI")
4033    (set_attr "amdfam10_decode" "double")
4034    (set_attr "athlon_decode" "vector")
4035    (set_attr "bdver1_decode" "double")])
4036
4037 (define_insn "avx512f_ufix_notruncv8dfv8si<mask_name><round_name>"
4038   [(set (match_operand:V8SI 0 "register_operand" "=v")
4039         (unspec:V8SI
4040           [(match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")]
4041           UNSPEC_UNSIGNED_FIX_NOTRUNC))]
4042   "TARGET_AVX512F"
4043   "vcvtpd2udq\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
4044   [(set_attr "type" "ssecvt")
4045    (set_attr "prefix" "evex")
4046    (set_attr "mode" "OI")])
4047
4048 (define_insn "<fixsuffix>fix_truncv8dfv8si2<mask_name><round_saeonly_name>"
4049   [(set (match_operand:V8SI 0 "register_operand" "=v")
4050         (any_fix:V8SI
4051           (match_operand:V8DF 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
4052   "TARGET_AVX512F"
4053   "vcvttpd2<fixsuffix>dq\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
4054   [(set_attr "type" "ssecvt")
4055    (set_attr "prefix" "evex")
4056    (set_attr "mode" "OI")])
4057
4058 (define_insn "fix_truncv4dfv4si2"
4059   [(set (match_operand:V4SI 0 "register_operand" "=x")
4060         (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
4061   "TARGET_AVX"
4062   "vcvttpd2dq{y}\t{%1, %0|%0, %1}"
4063   [(set_attr "type" "ssecvt")
4064    (set_attr "prefix" "vex")
4065    (set_attr "mode" "OI")])
4066
4067 (define_expand "avx_cvttpd2dq256_2"
4068   [(set (match_operand:V8SI 0 "register_operand")
4069         (vec_concat:V8SI
4070           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand"))
4071           (match_dup 2)))]
4072   "TARGET_AVX"
4073   "operands[2] = CONST0_RTX (V4SImode);")
4074
4075 (define_insn "*avx_cvttpd2dq256_2"
4076   [(set (match_operand:V8SI 0 "register_operand" "=x")
4077         (vec_concat:V8SI
4078           (fix:V4SI (match_operand:V4DF 1 "nonimmediate_operand" "xm"))
4079           (match_operand:V4SI 2 "const0_operand")))]
4080   "TARGET_AVX"
4081   "vcvttpd2dq{y}\t{%1, %x0|%x0, %1}"
4082   [(set_attr "type" "ssecvt")
4083    (set_attr "prefix" "vex")
4084    (set_attr "btver2_decode" "vector")
4085    (set_attr "mode" "OI")])
4086
4087 (define_expand "sse2_cvttpd2dq"
4088   [(set (match_operand:V4SI 0 "register_operand")
4089         (vec_concat:V4SI
4090           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand"))
4091           (match_dup 2)))]
4092   "TARGET_SSE2"
4093   "operands[2] = CONST0_RTX (V2SImode);")
4094
4095 (define_insn "*sse2_cvttpd2dq"
4096   [(set (match_operand:V4SI 0 "register_operand" "=x")
4097         (vec_concat:V4SI
4098           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
4099           (match_operand:V2SI 2 "const0_operand")))]
4100   "TARGET_SSE2"
4101 {
4102   if (TARGET_AVX)
4103     return "vcvttpd2dq{x}\t{%1, %0|%0, %1}";
4104   else
4105     return "cvttpd2dq\t{%1, %0|%0, %1}";
4106 }
4107   [(set_attr "type" "ssecvt")
4108    (set_attr "amdfam10_decode" "double")
4109    (set_attr "athlon_decode" "vector")
4110    (set_attr "bdver1_decode" "double")
4111    (set_attr "prefix" "maybe_vex")
4112    (set_attr "mode" "TI")])
4113
4114 (define_insn "sse2_cvtsd2ss<round_name>"
4115   [(set (match_operand:V4SF 0 "register_operand" "=x,x,v")
4116         (vec_merge:V4SF
4117           (vec_duplicate:V4SF
4118             (float_truncate:V2SF
4119               (match_operand:V2DF 2 "nonimmediate_operand" "x,m,<round_constraint>")))
4120           (match_operand:V4SF 1 "register_operand" "0,0,v")
4121           (const_int 1)))]
4122   "TARGET_SSE2"
4123   "@
4124    cvtsd2ss\t{%2, %0|%0, %2}
4125    cvtsd2ss\t{%2, %0|%0, %q2}
4126    vcvtsd2ss\t{<round_op3>%2, %1, %0|%0, %1, %q2<round_op3>}"
4127   [(set_attr "isa" "noavx,noavx,avx")
4128    (set_attr "type" "ssecvt")
4129    (set_attr "athlon_decode" "vector,double,*")
4130    (set_attr "amdfam10_decode" "vector,double,*")
4131    (set_attr "bdver1_decode" "direct,direct,*")
4132    (set_attr "btver2_decode" "double,double,double")
4133    (set_attr "prefix" "orig,orig,<round_prefix>")
4134    (set_attr "mode" "SF")])
4135
4136 (define_insn "sse2_cvtss2sd<round_saeonly_name>"
4137   [(set (match_operand:V2DF 0 "register_operand" "=x,x,v")
4138         (vec_merge:V2DF
4139           (float_extend:V2DF
4140             (vec_select:V2SF
4141               (match_operand:V4SF 2 "nonimmediate_operand" "x,m,<round_saeonly_constraint>")
4142               (parallel [(const_int 0) (const_int 1)])))
4143           (match_operand:V2DF 1 "register_operand" "0,0,v")
4144           (const_int 1)))]
4145   "TARGET_SSE2"
4146   "@
4147    cvtss2sd\t{%2, %0|%0, %2}
4148    cvtss2sd\t{%2, %0|%0, %k2}
4149    vcvtss2sd\t{<round_saeonly_op3>%2, %1, %0|%0, %1, %k2<round_saeonly_op3>}"
4150   [(set_attr "isa" "noavx,noavx,avx")
4151    (set_attr "type" "ssecvt")
4152    (set_attr "amdfam10_decode" "vector,double,*")
4153    (set_attr "athlon_decode" "direct,direct,*")
4154    (set_attr "bdver1_decode" "direct,direct,*")
4155    (set_attr "btver2_decode" "double,double,double")
4156    (set_attr "prefix" "orig,orig,<round_saeonly_prefix>")
4157    (set_attr "mode" "DF")])
4158
4159 (define_insn "<mask_codefor>avx512f_cvtpd2ps512<mask_name><round_name>"
4160   [(set (match_operand:V8SF 0 "register_operand" "=v")
4161         (float_truncate:V8SF
4162           (match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")))]
4163   "TARGET_AVX512F"
4164   "vcvtpd2ps\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
4165   [(set_attr "type" "ssecvt")
4166    (set_attr "prefix" "evex")
4167    (set_attr "mode" "V8SF")])
4168
4169 (define_insn "avx_cvtpd2ps256"
4170   [(set (match_operand:V4SF 0 "register_operand" "=x")
4171         (float_truncate:V4SF
4172           (match_operand:V4DF 1 "nonimmediate_operand" "xm")))]
4173   "TARGET_AVX"
4174   "vcvtpd2ps{y}\t{%1, %0|%0, %1}"
4175   [(set_attr "type" "ssecvt")
4176    (set_attr "prefix" "vex")
4177    (set_attr "btver2_decode" "vector")
4178    (set_attr "mode" "V4SF")])
4179
4180 (define_expand "sse2_cvtpd2ps"
4181   [(set (match_operand:V4SF 0 "register_operand")
4182         (vec_concat:V4SF
4183           (float_truncate:V2SF
4184             (match_operand:V2DF 1 "nonimmediate_operand"))
4185           (match_dup 2)))]
4186   "TARGET_SSE2"
4187   "operands[2] = CONST0_RTX (V2SFmode);")
4188
4189 (define_insn "*sse2_cvtpd2ps"
4190   [(set (match_operand:V4SF 0 "register_operand" "=x")
4191         (vec_concat:V4SF
4192           (float_truncate:V2SF
4193             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
4194           (match_operand:V2SF 2 "const0_operand")))]
4195   "TARGET_SSE2"
4196 {
4197   if (TARGET_AVX)
4198     return "vcvtpd2ps{x}\t{%1, %0|%0, %1}";
4199   else
4200     return "cvtpd2ps\t{%1, %0|%0, %1}";
4201 }
4202   [(set_attr "type" "ssecvt")
4203    (set_attr "amdfam10_decode" "double")
4204    (set_attr "athlon_decode" "vector")
4205    (set_attr "bdver1_decode" "double")
4206    (set_attr "prefix_data16" "1")
4207    (set_attr "prefix" "maybe_vex")
4208    (set_attr "mode" "V4SF")])
4209
4210 ;; For <sse2_avx_avx512f>_cvtps2pd<avxsizesuffix> insn pattern
4211 (define_mode_attr sf2dfmode
4212   [(V8DF "V8SF") (V4DF "V4SF")])
4213
4214 (define_insn "<sse2_avx_avx512f>_cvtps2pd<avxsizesuffix><mask_name><round_saeonly_name>"
4215   [(set (match_operand:VF2_512_256 0 "register_operand" "=v")
4216         (float_extend:VF2_512_256
4217           (match_operand:<sf2dfmode> 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")))]
4218   "TARGET_AVX && <mask_mode512bit_condition> && <round_saeonly_mode512bit_condition>"
4219   "vcvtps2pd\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
4220   [(set_attr "type" "ssecvt")
4221    (set_attr "prefix" "maybe_vex")
4222    (set_attr "mode" "<MODE>")])
4223
4224 (define_insn "*avx_cvtps2pd256_2"
4225   [(set (match_operand:V4DF 0 "register_operand" "=x")
4226         (float_extend:V4DF
4227           (vec_select:V4SF
4228             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
4229             (parallel [(const_int 0) (const_int 1)
4230                        (const_int 2) (const_int 3)]))))]
4231   "TARGET_AVX"
4232   "vcvtps2pd\t{%x1, %0|%0, %x1}"
4233   [(set_attr "type" "ssecvt")
4234    (set_attr "prefix" "vex")
4235    (set_attr "mode" "V4DF")])
4236
4237 (define_insn "vec_unpacks_lo_v16sf"
4238   [(set (match_operand:V8DF 0 "register_operand" "=v")
4239         (float_extend:V8DF
4240           (vec_select:V8SF
4241             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
4242             (parallel [(const_int 0) (const_int 1)
4243                        (const_int 2) (const_int 3)
4244                        (const_int 4) (const_int 5)
4245                        (const_int 6) (const_int 7)]))))]
4246   "TARGET_AVX512F"
4247   "vcvtps2pd\t{%t1, %0|%0, %t1}"
4248   [(set_attr "type" "ssecvt")
4249    (set_attr "prefix" "evex")
4250    (set_attr "mode" "V8DF")])
4251
4252 (define_insn "sse2_cvtps2pd"
4253   [(set (match_operand:V2DF 0 "register_operand" "=x")
4254         (float_extend:V2DF
4255           (vec_select:V2SF
4256             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
4257             (parallel [(const_int 0) (const_int 1)]))))]
4258   "TARGET_SSE2"
4259   "%vcvtps2pd\t{%1, %0|%0, %q1}"
4260   [(set_attr "type" "ssecvt")
4261    (set_attr "amdfam10_decode" "direct")
4262    (set_attr "athlon_decode" "double")
4263    (set_attr "bdver1_decode" "double")
4264    (set_attr "prefix_data16" "0")
4265    (set_attr "prefix" "maybe_vex")
4266    (set_attr "mode" "V2DF")])
4267
4268 (define_expand "vec_unpacks_hi_v4sf"
4269   [(set (match_dup 2)
4270    (vec_select:V4SF
4271      (vec_concat:V8SF
4272        (match_dup 2)
4273        (match_operand:V4SF 1 "nonimmediate_operand"))
4274      (parallel [(const_int 6) (const_int 7)
4275                 (const_int 2) (const_int 3)])))
4276   (set (match_operand:V2DF 0 "register_operand")
4277    (float_extend:V2DF
4278      (vec_select:V2SF
4279        (match_dup 2)
4280        (parallel [(const_int 0) (const_int 1)]))))]
4281   "TARGET_SSE2"
4282   "operands[2] = gen_reg_rtx (V4SFmode);")
4283
4284 (define_expand "vec_unpacks_hi_v8sf"
4285   [(set (match_dup 2)
4286         (vec_select:V4SF
4287           (match_operand:V8SF 1 "nonimmediate_operand")
4288           (parallel [(const_int 4) (const_int 5)
4289                      (const_int 6) (const_int 7)])))
4290    (set (match_operand:V4DF 0 "register_operand")
4291         (float_extend:V4DF
4292           (match_dup 2)))]
4293   "TARGET_AVX"
4294   "operands[2] = gen_reg_rtx (V4SFmode);")
4295
4296 (define_expand "vec_unpacks_hi_v16sf"
4297   [(set (match_dup 2)
4298         (vec_select:V8SF
4299           (match_operand:V16SF 1 "nonimmediate_operand")
4300           (parallel [(const_int 8) (const_int 9)
4301                      (const_int 10) (const_int 11)
4302                      (const_int 12) (const_int 13)
4303                      (const_int 14) (const_int 15)])))
4304    (set (match_operand:V8DF 0 "register_operand")
4305         (float_extend:V8DF
4306           (match_dup 2)))]
4307 "TARGET_AVX512F"
4308 "operands[2] = gen_reg_rtx (V8SFmode);")
4309
4310 (define_expand "vec_unpacks_lo_v4sf"
4311   [(set (match_operand:V2DF 0 "register_operand")
4312         (float_extend:V2DF
4313           (vec_select:V2SF
4314             (match_operand:V4SF 1 "nonimmediate_operand")
4315             (parallel [(const_int 0) (const_int 1)]))))]
4316   "TARGET_SSE2")
4317
4318 (define_expand "vec_unpacks_lo_v8sf"
4319   [(set (match_operand:V4DF 0 "register_operand")
4320         (float_extend:V4DF
4321           (vec_select:V4SF
4322             (match_operand:V8SF 1 "nonimmediate_operand")
4323             (parallel [(const_int 0) (const_int 1)
4324                        (const_int 2) (const_int 3)]))))]
4325   "TARGET_AVX")
4326
4327 (define_mode_attr sseunpackfltmode
4328   [(V8HI "V4SF") (V4SI "V2DF") (V16HI "V8SF")
4329   (V8SI "V4DF") (V32HI "V16SF") (V16SI "V8DF")])
4330
4331 (define_expand "vec_unpacks_float_hi_<mode>"
4332   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4333    (match_operand:VI2_AVX512F 1 "register_operand")]
4334   "TARGET_SSE2"
4335 {
4336   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4337
4338   emit_insn (gen_vec_unpacks_hi_<mode> (tmp, operands[1]));
4339   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4340                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4341   DONE;
4342 })
4343
4344 (define_expand "vec_unpacks_float_lo_<mode>"
4345   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4346    (match_operand:VI2_AVX512F 1 "register_operand")]
4347   "TARGET_SSE2"
4348 {
4349   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4350
4351   emit_insn (gen_vec_unpacks_lo_<mode> (tmp, operands[1]));
4352   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4353                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4354   DONE;
4355 })
4356
4357 (define_expand "vec_unpacku_float_hi_<mode>"
4358   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4359    (match_operand:VI2_AVX512F 1 "register_operand")]
4360   "TARGET_SSE2"
4361 {
4362   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4363
4364   emit_insn (gen_vec_unpacku_hi_<mode> (tmp, operands[1]));
4365   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4366                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4367   DONE;
4368 })
4369
4370 (define_expand "vec_unpacku_float_lo_<mode>"
4371   [(match_operand:<sseunpackfltmode> 0 "register_operand")
4372    (match_operand:VI2_AVX512F 1 "register_operand")]
4373   "TARGET_SSE2"
4374 {
4375   rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
4376
4377   emit_insn (gen_vec_unpacku_lo_<mode> (tmp, operands[1]));
4378   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
4379                           gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
4380   DONE;
4381 })
4382
4383 (define_expand "vec_unpacks_float_hi_v4si"
4384   [(set (match_dup 2)
4385         (vec_select:V4SI
4386           (match_operand:V4SI 1 "nonimmediate_operand")
4387           (parallel [(const_int 2) (const_int 3)
4388                      (const_int 2) (const_int 3)])))
4389    (set (match_operand:V2DF 0 "register_operand")
4390         (float:V2DF
4391           (vec_select:V2SI
4392           (match_dup 2)
4393             (parallel [(const_int 0) (const_int 1)]))))]
4394   "TARGET_SSE2"
4395   "operands[2] = gen_reg_rtx (V4SImode);")
4396
4397 (define_expand "vec_unpacks_float_lo_v4si"
4398   [(set (match_operand:V2DF 0 "register_operand")
4399         (float:V2DF
4400           (vec_select:V2SI
4401             (match_operand:V4SI 1 "nonimmediate_operand")
4402             (parallel [(const_int 0) (const_int 1)]))))]
4403   "TARGET_SSE2")
4404
4405 (define_expand "vec_unpacks_float_hi_v8si"
4406   [(set (match_dup 2)
4407         (vec_select:V4SI
4408           (match_operand:V8SI 1 "nonimmediate_operand")
4409           (parallel [(const_int 4) (const_int 5)
4410                      (const_int 6) (const_int 7)])))
4411    (set (match_operand:V4DF 0 "register_operand")
4412         (float:V4DF
4413           (match_dup 2)))]
4414   "TARGET_AVX"
4415   "operands[2] = gen_reg_rtx (V4SImode);")
4416
4417 (define_expand "vec_unpacks_float_lo_v8si"
4418   [(set (match_operand:V4DF 0 "register_operand")
4419         (float:V4DF
4420           (vec_select:V4SI
4421             (match_operand:V8SI 1 "nonimmediate_operand")
4422             (parallel [(const_int 0) (const_int 1)
4423                        (const_int 2) (const_int 3)]))))]
4424   "TARGET_AVX")
4425
4426 (define_expand "vec_unpacks_float_hi_v16si"
4427   [(set (match_dup 2)
4428         (vec_select:V8SI
4429           (match_operand:V16SI 1 "nonimmediate_operand")
4430           (parallel [(const_int 8) (const_int 9)
4431                      (const_int 10) (const_int 11)
4432                      (const_int 12) (const_int 13)
4433                      (const_int 14) (const_int 15)])))
4434    (set (match_operand:V8DF 0 "register_operand")
4435         (float:V8DF
4436           (match_dup 2)))]
4437   "TARGET_AVX512F"
4438   "operands[2] = gen_reg_rtx (V8SImode);")
4439
4440 (define_expand "vec_unpacks_float_lo_v16si"
4441   [(set (match_operand:V8DF 0 "register_operand")
4442         (float:V8DF
4443           (vec_select:V8SI
4444             (match_operand:V16SI 1 "nonimmediate_operand")
4445             (parallel [(const_int 0) (const_int 1)
4446                        (const_int 2) (const_int 3)
4447                        (const_int 4) (const_int 5)
4448                        (const_int 6) (const_int 7)]))))]
4449   "TARGET_AVX512F")
4450
4451 (define_expand "vec_unpacku_float_hi_v4si"
4452   [(set (match_dup 5)
4453         (vec_select:V4SI
4454           (match_operand:V4SI 1 "nonimmediate_operand")
4455           (parallel [(const_int 2) (const_int 3)
4456                      (const_int 2) (const_int 3)])))
4457    (set (match_dup 6)
4458         (float:V2DF
4459           (vec_select:V2SI
4460           (match_dup 5)
4461             (parallel [(const_int 0) (const_int 1)]))))
4462    (set (match_dup 7)
4463         (lt:V2DF (match_dup 6) (match_dup 3)))
4464    (set (match_dup 8)
4465         (and:V2DF (match_dup 7) (match_dup 4)))
4466    (set (match_operand:V2DF 0 "register_operand")
4467         (plus:V2DF (match_dup 6) (match_dup 8)))]
4468   "TARGET_SSE2"
4469 {
4470   REAL_VALUE_TYPE TWO32r;
4471   rtx x;
4472   int i;
4473
4474   real_ldexp (&TWO32r, &dconst1, 32);
4475   x = const_double_from_real_value (TWO32r, DFmode);
4476
4477   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
4478   operands[4] = force_reg (V2DFmode,
4479                            ix86_build_const_vector (V2DFmode, 1, x));
4480
4481   operands[5] = gen_reg_rtx (V4SImode);
4482
4483   for (i = 6; i < 9; i++)
4484     operands[i] = gen_reg_rtx (V2DFmode);
4485 })
4486
4487 (define_expand "vec_unpacku_float_lo_v4si"
4488   [(set (match_dup 5)
4489         (float:V2DF
4490           (vec_select:V2SI
4491             (match_operand:V4SI 1 "nonimmediate_operand")
4492             (parallel [(const_int 0) (const_int 1)]))))
4493    (set (match_dup 6)
4494         (lt:V2DF (match_dup 5) (match_dup 3)))
4495    (set (match_dup 7)
4496         (and:V2DF (match_dup 6) (match_dup 4)))
4497    (set (match_operand:V2DF 0 "register_operand")
4498         (plus:V2DF (match_dup 5) (match_dup 7)))]
4499   "TARGET_SSE2"
4500 {
4501   REAL_VALUE_TYPE TWO32r;
4502   rtx x;
4503   int i;
4504
4505   real_ldexp (&TWO32r, &dconst1, 32);
4506   x = const_double_from_real_value (TWO32r, DFmode);
4507
4508   operands[3] = force_reg (V2DFmode, CONST0_RTX (V2DFmode));
4509   operands[4] = force_reg (V2DFmode,
4510                            ix86_build_const_vector (V2DFmode, 1, x));
4511
4512   for (i = 5; i < 8; i++)
4513     operands[i] = gen_reg_rtx (V2DFmode);
4514 })
4515
4516 (define_expand "vec_unpacku_float_hi_v8si"
4517   [(match_operand:V4DF 0 "register_operand")
4518    (match_operand:V8SI 1 "register_operand")]
4519   "TARGET_AVX"
4520 {
4521   REAL_VALUE_TYPE TWO32r;
4522   rtx x, tmp[6];
4523   int i;
4524
4525   real_ldexp (&TWO32r, &dconst1, 32);
4526   x = const_double_from_real_value (TWO32r, DFmode);
4527
4528   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
4529   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
4530   tmp[5] = gen_reg_rtx (V4SImode);
4531
4532   for (i = 2; i < 5; i++)
4533     tmp[i] = gen_reg_rtx (V4DFmode);
4534   emit_insn (gen_vec_extract_hi_v8si (tmp[5], operands[1]));
4535   emit_insn (gen_floatv4siv4df2 (tmp[2], tmp[5]));
4536   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
4537                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
4538   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
4539   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
4540   DONE;
4541 })
4542
4543 (define_expand "vec_unpacku_float_hi_v16si"
4544   [(match_operand:V8DF 0 "register_operand")
4545    (match_operand:V16SI 1 "register_operand")]
4546   "TARGET_AVX512F"
4547 {
4548   REAL_VALUE_TYPE TWO32r;
4549   rtx k, x, tmp[4];
4550
4551   real_ldexp (&TWO32r, &dconst1, 32);
4552   x = const_double_from_real_value (TWO32r, DFmode);
4553
4554   tmp[0] = force_reg (V8DFmode, CONST0_RTX (V8DFmode));
4555   tmp[1] = force_reg (V8DFmode, ix86_build_const_vector (V8DFmode, 1, x));
4556   tmp[2] = gen_reg_rtx (V8DFmode);
4557   tmp[3] = gen_reg_rtx (V8SImode);
4558   k = gen_reg_rtx (QImode);
4559
4560   emit_insn (gen_vec_extract_hi_v16si (tmp[3], operands[1]));
4561   emit_insn (gen_floatv8siv8df2 (tmp[2], tmp[3]));
4562   emit_insn (gen_rtx_SET (VOIDmode, k,
4563                           gen_rtx_LT (QImode, tmp[2], tmp[0])));
4564   emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
4565   emit_move_insn (operands[0], tmp[2]);
4566   DONE;
4567 })
4568
4569 (define_expand "vec_unpacku_float_lo_v8si"
4570   [(match_operand:V4DF 0 "register_operand")
4571    (match_operand:V8SI 1 "nonimmediate_operand")]
4572   "TARGET_AVX"
4573 {
4574   REAL_VALUE_TYPE TWO32r;
4575   rtx x, tmp[5];
4576   int i;
4577
4578   real_ldexp (&TWO32r, &dconst1, 32);
4579   x = const_double_from_real_value (TWO32r, DFmode);
4580
4581   tmp[0] = force_reg (V4DFmode, CONST0_RTX (V4DFmode));
4582   tmp[1] = force_reg (V4DFmode, ix86_build_const_vector (V4DFmode, 1, x));
4583
4584   for (i = 2; i < 5; i++)
4585     tmp[i] = gen_reg_rtx (V4DFmode);
4586   emit_insn (gen_avx_cvtdq2pd256_2 (tmp[2], operands[1]));
4587   emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
4588                           gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
4589   emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
4590   emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
4591   DONE;
4592 })
4593
4594 (define_expand "vec_unpacku_float_lo_v16si"
4595   [(match_operand:V8DF 0 "register_operand")
4596    (match_operand:V16SI 1 "nonimmediate_operand")]
4597   "TARGET_AVX512F"
4598 {
4599   REAL_VALUE_TYPE TWO32r;
4600   rtx k, x, tmp[3];
4601
4602   real_ldexp (&TWO32r, &dconst1, 32);
4603   x = const_double_from_real_value (TWO32r, DFmode);
4604
4605   tmp[0] = force_reg (V8DFmode, CONST0_RTX (V8DFmode));
4606   tmp[1] = force_reg (V8DFmode, ix86_build_const_vector (V8DFmode, 1, x));
4607   tmp[2] = gen_reg_rtx (V8DFmode);
4608   k = gen_reg_rtx (QImode);
4609
4610   emit_insn (gen_avx512f_cvtdq2pd512_2 (tmp[2], operands[1]));
4611   emit_insn (gen_rtx_SET (VOIDmode, k,
4612                           gen_rtx_LT (QImode, tmp[2], tmp[0])));
4613   emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
4614   emit_move_insn (operands[0], tmp[2]);
4615   DONE;
4616 })
4617
4618 (define_expand "vec_pack_trunc_<mode>"
4619   [(set (match_dup 3)
4620         (float_truncate:<sf2dfmode>
4621           (match_operand:VF2_512_256 1 "nonimmediate_operand")))
4622    (set (match_dup 4)
4623         (float_truncate:<sf2dfmode>
4624           (match_operand:VF2_512_256 2 "nonimmediate_operand")))
4625    (set (match_operand:<ssePSmode> 0 "register_operand")
4626         (vec_concat:<ssePSmode>
4627           (match_dup 3)
4628           (match_dup 4)))]
4629   "TARGET_AVX"
4630 {
4631   operands[3] = gen_reg_rtx (<sf2dfmode>mode);
4632   operands[4] = gen_reg_rtx (<sf2dfmode>mode);
4633 })
4634
4635 (define_expand "vec_pack_trunc_v2df"
4636   [(match_operand:V4SF 0 "register_operand")
4637    (match_operand:V2DF 1 "nonimmediate_operand")
4638    (match_operand:V2DF 2 "nonimmediate_operand")]
4639   "TARGET_SSE2"
4640 {
4641   rtx tmp0, tmp1;
4642
4643   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4644     {
4645       tmp0 = gen_reg_rtx (V4DFmode);
4646       tmp1 = force_reg (V2DFmode, operands[1]);
4647
4648       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4649       emit_insn (gen_avx_cvtpd2ps256 (operands[0], tmp0));
4650     }
4651   else
4652     {
4653       tmp0 = gen_reg_rtx (V4SFmode);
4654       tmp1 = gen_reg_rtx (V4SFmode);
4655
4656       emit_insn (gen_sse2_cvtpd2ps (tmp0, operands[1]));
4657       emit_insn (gen_sse2_cvtpd2ps (tmp1, operands[2]));
4658       emit_insn (gen_sse_movlhps (operands[0], tmp0, tmp1));
4659     }
4660   DONE;
4661 })
4662
4663 (define_expand "vec_pack_sfix_trunc_v8df"
4664   [(match_operand:V16SI 0 "register_operand")
4665    (match_operand:V8DF 1 "nonimmediate_operand")
4666    (match_operand:V8DF 2 "nonimmediate_operand")]
4667   "TARGET_AVX512F"
4668 {
4669   rtx r1, r2;
4670
4671   r1 = gen_reg_rtx (V8SImode);
4672   r2 = gen_reg_rtx (V8SImode);
4673
4674   emit_insn (gen_fix_truncv8dfv8si2 (r1, operands[1]));
4675   emit_insn (gen_fix_truncv8dfv8si2 (r2, operands[2]));
4676   emit_insn (gen_avx_vec_concatv16si (operands[0], r1, r2));
4677   DONE;
4678 })
4679
4680 (define_expand "vec_pack_sfix_trunc_v4df"
4681   [(match_operand:V8SI 0 "register_operand")
4682    (match_operand:V4DF 1 "nonimmediate_operand")
4683    (match_operand:V4DF 2 "nonimmediate_operand")]
4684   "TARGET_AVX"
4685 {
4686   rtx r1, r2;
4687
4688   r1 = gen_reg_rtx (V4SImode);
4689   r2 = gen_reg_rtx (V4SImode);
4690
4691   emit_insn (gen_fix_truncv4dfv4si2 (r1, operands[1]));
4692   emit_insn (gen_fix_truncv4dfv4si2 (r2, operands[2]));
4693   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
4694   DONE;
4695 })
4696
4697 (define_expand "vec_pack_sfix_trunc_v2df"
4698   [(match_operand:V4SI 0 "register_operand")
4699    (match_operand:V2DF 1 "nonimmediate_operand")
4700    (match_operand:V2DF 2 "nonimmediate_operand")]
4701   "TARGET_SSE2"
4702 {
4703   rtx tmp0, tmp1, tmp2;
4704
4705   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4706     {
4707       tmp0 = gen_reg_rtx (V4DFmode);
4708       tmp1 = force_reg (V2DFmode, operands[1]);
4709
4710       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4711       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp0));
4712     }
4713   else
4714     {
4715       tmp0 = gen_reg_rtx (V4SImode);
4716       tmp1 = gen_reg_rtx (V4SImode);
4717       tmp2 = gen_reg_rtx (V2DImode);
4718
4719       emit_insn (gen_sse2_cvttpd2dq (tmp0, operands[1]));
4720       emit_insn (gen_sse2_cvttpd2dq (tmp1, operands[2]));
4721       emit_insn (gen_vec_interleave_lowv2di (tmp2,
4722                                              gen_lowpart (V2DImode, tmp0),
4723                                              gen_lowpart (V2DImode, tmp1)));
4724       emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp2));
4725     }
4726   DONE;
4727 })
4728
4729 (define_mode_attr ssepackfltmode
4730   [(V8DF "V16SI") (V4DF "V8SI") (V2DF "V4SI")])
4731
4732 (define_expand "vec_pack_ufix_trunc_<mode>"
4733   [(match_operand:<ssepackfltmode> 0 "register_operand")
4734    (match_operand:VF2 1 "register_operand")
4735    (match_operand:VF2 2 "register_operand")]
4736   "TARGET_SSE2"
4737 {
4738   if (<MODE>mode == V8DFmode)
4739     {
4740       rtx r1, r2;
4741
4742       r1 = gen_reg_rtx (V8SImode);
4743       r2 = gen_reg_rtx (V8SImode);
4744
4745       emit_insn (gen_ufix_truncv8dfv8si2 (r1, operands[1]));
4746       emit_insn (gen_ufix_truncv8dfv8si2 (r2, operands[2]));
4747       emit_insn (gen_avx_vec_concatv16si (operands[0], r1, r2));
4748     }
4749   else
4750     {
4751       rtx tmp[7];
4752       tmp[0] = ix86_expand_adjust_ufix_to_sfix_si (operands[1], &tmp[2]);
4753       tmp[1] = ix86_expand_adjust_ufix_to_sfix_si (operands[2], &tmp[3]);
4754       tmp[4] = gen_reg_rtx (<ssepackfltmode>mode);
4755       emit_insn (gen_vec_pack_sfix_trunc_<mode> (tmp[4], tmp[0], tmp[1]));
4756       if (<ssepackfltmode>mode == V4SImode || TARGET_AVX2)
4757         {
4758           tmp[5] = gen_reg_rtx (<ssepackfltmode>mode);
4759           ix86_expand_vec_extract_even_odd (tmp[5], tmp[2], tmp[3], 0);
4760         }
4761       else
4762         {
4763           tmp[5] = gen_reg_rtx (V8SFmode);
4764           ix86_expand_vec_extract_even_odd (tmp[5], gen_lowpart (V8SFmode, tmp[2]),
4765                                             gen_lowpart (V8SFmode, tmp[3]), 0);
4766           tmp[5] = gen_lowpart (V8SImode, tmp[5]);
4767         }
4768       tmp[6] = expand_simple_binop (<ssepackfltmode>mode, XOR, tmp[4], tmp[5],
4769                                     operands[0], 0, OPTAB_DIRECT);
4770       if (tmp[6] != operands[0])
4771         emit_move_insn (operands[0], tmp[6]);
4772     }
4773
4774   DONE;
4775 })
4776
4777 (define_expand "vec_pack_sfix_v4df"
4778   [(match_operand:V8SI 0 "register_operand")
4779    (match_operand:V4DF 1 "nonimmediate_operand")
4780    (match_operand:V4DF 2 "nonimmediate_operand")]
4781   "TARGET_AVX"
4782 {
4783   rtx r1, r2;
4784
4785   r1 = gen_reg_rtx (V4SImode);
4786   r2 = gen_reg_rtx (V4SImode);
4787
4788   emit_insn (gen_avx_cvtpd2dq256 (r1, operands[1]));
4789   emit_insn (gen_avx_cvtpd2dq256 (r2, operands[2]));
4790   emit_insn (gen_avx_vec_concatv8si (operands[0], r1, r2));
4791   DONE;
4792 })
4793
4794 (define_expand "vec_pack_sfix_v2df"
4795   [(match_operand:V4SI 0 "register_operand")
4796    (match_operand:V2DF 1 "nonimmediate_operand")
4797    (match_operand:V2DF 2 "nonimmediate_operand")]
4798   "TARGET_SSE2"
4799 {
4800   rtx tmp0, tmp1, tmp2;
4801
4802   if (TARGET_AVX && !TARGET_PREFER_AVX128)
4803     {
4804       tmp0 = gen_reg_rtx (V4DFmode);
4805       tmp1 = force_reg (V2DFmode, operands[1]);
4806
4807       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
4808       emit_insn (gen_avx_cvtpd2dq256 (operands[0], tmp0));
4809     }
4810   else
4811     {
4812       tmp0 = gen_reg_rtx (V4SImode);
4813       tmp1 = gen_reg_rtx (V4SImode);
4814       tmp2 = gen_reg_rtx (V2DImode);
4815
4816       emit_insn (gen_sse2_cvtpd2dq (tmp0, operands[1]));
4817       emit_insn (gen_sse2_cvtpd2dq (tmp1, operands[2]));
4818       emit_insn (gen_vec_interleave_lowv2di (tmp2,
4819                                              gen_lowpart (V2DImode, tmp0),
4820                                              gen_lowpart (V2DImode, tmp1)));
4821       emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp2));
4822     }
4823   DONE;
4824 })
4825
4826 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4827 ;;
4828 ;; Parallel single-precision floating point element swizzling
4829 ;;
4830 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4831
4832 (define_expand "sse_movhlps_exp"
4833   [(set (match_operand:V4SF 0 "nonimmediate_operand")
4834         (vec_select:V4SF
4835           (vec_concat:V8SF
4836             (match_operand:V4SF 1 "nonimmediate_operand")
4837             (match_operand:V4SF 2 "nonimmediate_operand"))
4838           (parallel [(const_int 6)
4839                      (const_int 7)
4840                      (const_int 2)
4841                      (const_int 3)])))]
4842   "TARGET_SSE"
4843 {
4844   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
4845
4846   emit_insn (gen_sse_movhlps (dst, operands[1], operands[2]));
4847
4848   /* Fix up the destination if needed.  */
4849   if (dst != operands[0])
4850     emit_move_insn (operands[0], dst);
4851
4852   DONE;
4853 })
4854
4855 (define_insn "sse_movhlps"
4856   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
4857         (vec_select:V4SF
4858           (vec_concat:V8SF
4859             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
4860             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,o,o,x"))
4861           (parallel [(const_int 6)
4862                      (const_int 7)
4863                      (const_int 2)
4864                      (const_int 3)])))]
4865   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
4866   "@
4867    movhlps\t{%2, %0|%0, %2}
4868    vmovhlps\t{%2, %1, %0|%0, %1, %2}
4869    movlps\t{%H2, %0|%0, %H2}
4870    vmovlps\t{%H2, %1, %0|%0, %1, %H2}
4871    %vmovhps\t{%2, %0|%q0, %2}"
4872   [(set_attr "isa" "noavx,avx,noavx,avx,*")
4873    (set_attr "type" "ssemov")
4874    (set_attr "ssememalign" "64")
4875    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
4876    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
4877
4878 (define_expand "sse_movlhps_exp"
4879   [(set (match_operand:V4SF 0 "nonimmediate_operand")
4880         (vec_select:V4SF
4881           (vec_concat:V8SF
4882             (match_operand:V4SF 1 "nonimmediate_operand")
4883             (match_operand:V4SF 2 "nonimmediate_operand"))
4884           (parallel [(const_int 0)
4885                      (const_int 1)
4886                      (const_int 4)
4887                      (const_int 5)])))]
4888   "TARGET_SSE"
4889 {
4890   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
4891
4892   emit_insn (gen_sse_movlhps (dst, operands[1], operands[2]));
4893
4894   /* Fix up the destination if needed.  */
4895   if (dst != operands[0])
4896     emit_move_insn (operands[0], dst);
4897
4898   DONE;
4899 })
4900
4901 (define_insn "sse_movlhps"
4902   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
4903         (vec_select:V4SF
4904           (vec_concat:V8SF
4905             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
4906             (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,m,x"))
4907           (parallel [(const_int 0)
4908                      (const_int 1)
4909                      (const_int 4)
4910                      (const_int 5)])))]
4911   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
4912   "@
4913    movlhps\t{%2, %0|%0, %2}
4914    vmovlhps\t{%2, %1, %0|%0, %1, %2}
4915    movhps\t{%2, %0|%0, %q2}
4916    vmovhps\t{%2, %1, %0|%0, %1, %q2}
4917    %vmovlps\t{%2, %H0|%H0, %2}"
4918   [(set_attr "isa" "noavx,avx,noavx,avx,*")
4919    (set_attr "type" "ssemov")
4920    (set_attr "ssememalign" "64")
4921    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
4922    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
4923
4924 (define_insn "<mask_codefor>avx512f_unpckhps512<mask_name>"
4925   [(set (match_operand:V16SF 0 "register_operand" "=v")
4926         (vec_select:V16SF
4927           (vec_concat:V32SF
4928             (match_operand:V16SF 1 "register_operand" "v")
4929             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
4930           (parallel [(const_int 2) (const_int 18)
4931                      (const_int 3) (const_int 19)
4932                      (const_int 6) (const_int 22)
4933                      (const_int 7) (const_int 23)
4934                      (const_int 10) (const_int 26)
4935                      (const_int 11) (const_int 27)
4936                      (const_int 14) (const_int 30)
4937                      (const_int 15) (const_int 31)])))]
4938   "TARGET_AVX512F"
4939   "vunpckhps\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
4940   [(set_attr "type" "sselog")
4941    (set_attr "prefix" "evex")
4942    (set_attr "mode" "V16SF")])
4943
4944 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
4945 (define_insn "avx_unpckhps256"
4946   [(set (match_operand:V8SF 0 "register_operand" "=x")
4947         (vec_select:V8SF
4948           (vec_concat:V16SF
4949             (match_operand:V8SF 1 "register_operand" "x")
4950             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
4951           (parallel [(const_int 2) (const_int 10)
4952                      (const_int 3) (const_int 11)
4953                      (const_int 6) (const_int 14)
4954                      (const_int 7) (const_int 15)])))]
4955   "TARGET_AVX"
4956   "vunpckhps\t{%2, %1, %0|%0, %1, %2}"
4957   [(set_attr "type" "sselog")
4958    (set_attr "prefix" "vex")
4959    (set_attr "mode" "V8SF")])
4960
4961 (define_expand "vec_interleave_highv8sf"
4962   [(set (match_dup 3)
4963         (vec_select:V8SF
4964           (vec_concat:V16SF
4965             (match_operand:V8SF 1 "register_operand" "x")
4966             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
4967           (parallel [(const_int 0) (const_int 8)
4968                      (const_int 1) (const_int 9)
4969                      (const_int 4) (const_int 12)
4970                      (const_int 5) (const_int 13)])))
4971    (set (match_dup 4)
4972         (vec_select:V8SF
4973           (vec_concat:V16SF
4974             (match_dup 1)
4975             (match_dup 2))
4976           (parallel [(const_int 2) (const_int 10)
4977                      (const_int 3) (const_int 11)
4978                      (const_int 6) (const_int 14)
4979                      (const_int 7) (const_int 15)])))
4980    (set (match_operand:V8SF 0 "register_operand")
4981         (vec_select:V8SF
4982           (vec_concat:V16SF
4983             (match_dup 3)
4984             (match_dup 4))
4985           (parallel [(const_int 4) (const_int 5)
4986                      (const_int 6) (const_int 7)
4987                      (const_int 12) (const_int 13)
4988                      (const_int 14) (const_int 15)])))]
4989  "TARGET_AVX"
4990 {
4991   operands[3] = gen_reg_rtx (V8SFmode);
4992   operands[4] = gen_reg_rtx (V8SFmode);
4993 })
4994
4995 (define_insn "vec_interleave_highv4sf"
4996   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
4997         (vec_select:V4SF
4998           (vec_concat:V8SF
4999             (match_operand:V4SF 1 "register_operand" "0,x")
5000             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
5001           (parallel [(const_int 2) (const_int 6)
5002                      (const_int 3) (const_int 7)])))]
5003   "TARGET_SSE"
5004   "@
5005    unpckhps\t{%2, %0|%0, %2}
5006    vunpckhps\t{%2, %1, %0|%0, %1, %2}"
5007   [(set_attr "isa" "noavx,avx")
5008    (set_attr "type" "sselog")
5009    (set_attr "prefix" "orig,vex")
5010    (set_attr "mode" "V4SF")])
5011
5012 (define_insn "<mask_codefor>avx512f_unpcklps512<mask_name>"
5013   [(set (match_operand:V16SF 0 "register_operand" "=v")
5014         (vec_select:V16SF
5015           (vec_concat:V32SF
5016             (match_operand:V16SF 1 "register_operand" "v")
5017             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
5018           (parallel [(const_int 0) (const_int 16)
5019                      (const_int 1) (const_int 17)
5020                      (const_int 4) (const_int 20)
5021                      (const_int 5) (const_int 21)
5022                      (const_int 8) (const_int 24)
5023                      (const_int 9) (const_int 25)
5024                      (const_int 12) (const_int 28)
5025                      (const_int 13) (const_int 29)])))]
5026   "TARGET_AVX512F"
5027   "vunpcklps\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
5028   [(set_attr "type" "sselog")
5029    (set_attr "prefix" "evex")
5030    (set_attr "mode" "V16SF")])
5031
5032 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
5033 (define_insn "avx_unpcklps256"
5034   [(set (match_operand:V8SF 0 "register_operand" "=x")
5035         (vec_select:V8SF
5036           (vec_concat:V16SF
5037             (match_operand:V8SF 1 "register_operand" "x")
5038             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5039           (parallel [(const_int 0) (const_int 8)
5040                      (const_int 1) (const_int 9)
5041                      (const_int 4) (const_int 12)
5042                      (const_int 5) (const_int 13)])))]
5043   "TARGET_AVX"
5044   "vunpcklps\t{%2, %1, %0|%0, %1, %2}"
5045   [(set_attr "type" "sselog")
5046    (set_attr "prefix" "vex")
5047    (set_attr "mode" "V8SF")])
5048
5049 (define_expand "vec_interleave_lowv8sf"
5050   [(set (match_dup 3)
5051         (vec_select:V8SF
5052           (vec_concat:V16SF
5053             (match_operand:V8SF 1 "register_operand" "x")
5054             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5055           (parallel [(const_int 0) (const_int 8)
5056                      (const_int 1) (const_int 9)
5057                      (const_int 4) (const_int 12)
5058                      (const_int 5) (const_int 13)])))
5059    (set (match_dup 4)
5060         (vec_select:V8SF
5061           (vec_concat:V16SF
5062             (match_dup 1)
5063             (match_dup 2))
5064           (parallel [(const_int 2) (const_int 10)
5065                      (const_int 3) (const_int 11)
5066                      (const_int 6) (const_int 14)
5067                      (const_int 7) (const_int 15)])))
5068    (set (match_operand:V8SF 0 "register_operand")
5069         (vec_select:V8SF
5070           (vec_concat:V16SF
5071             (match_dup 3)
5072             (match_dup 4))
5073           (parallel [(const_int 0) (const_int 1)
5074                      (const_int 2) (const_int 3)
5075                      (const_int 8) (const_int 9)
5076                      (const_int 10) (const_int 11)])))]
5077  "TARGET_AVX"
5078 {
5079   operands[3] = gen_reg_rtx (V8SFmode);
5080   operands[4] = gen_reg_rtx (V8SFmode);
5081 })
5082
5083 (define_insn "vec_interleave_lowv4sf"
5084   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5085         (vec_select:V4SF
5086           (vec_concat:V8SF
5087             (match_operand:V4SF 1 "register_operand" "0,x")
5088             (match_operand:V4SF 2 "nonimmediate_operand" "xm,xm"))
5089           (parallel [(const_int 0) (const_int 4)
5090                      (const_int 1) (const_int 5)])))]
5091   "TARGET_SSE"
5092   "@
5093    unpcklps\t{%2, %0|%0, %2}
5094    vunpcklps\t{%2, %1, %0|%0, %1, %2}"
5095   [(set_attr "isa" "noavx,avx")
5096    (set_attr "type" "sselog")
5097    (set_attr "prefix" "orig,vex")
5098    (set_attr "mode" "V4SF")])
5099
5100 ;; These are modeled with the same vec_concat as the others so that we
5101 ;; capture users of shufps that can use the new instructions
5102 (define_insn "avx_movshdup256"
5103   [(set (match_operand:V8SF 0 "register_operand" "=x")
5104         (vec_select:V8SF
5105           (vec_concat:V16SF
5106             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
5107             (match_dup 1))
5108           (parallel [(const_int 1) (const_int 1)
5109                      (const_int 3) (const_int 3)
5110                      (const_int 5) (const_int 5)
5111                      (const_int 7) (const_int 7)])))]
5112   "TARGET_AVX"
5113   "vmovshdup\t{%1, %0|%0, %1}"
5114   [(set_attr "type" "sse")
5115    (set_attr "prefix" "vex")
5116    (set_attr "mode" "V8SF")])
5117
5118 (define_insn "sse3_movshdup"
5119   [(set (match_operand:V4SF 0 "register_operand" "=x")
5120         (vec_select:V4SF
5121           (vec_concat:V8SF
5122             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
5123             (match_dup 1))
5124           (parallel [(const_int 1)
5125                      (const_int 1)
5126                      (const_int 7)
5127                      (const_int 7)])))]
5128   "TARGET_SSE3"
5129   "%vmovshdup\t{%1, %0|%0, %1}"
5130   [(set_attr "type" "sse")
5131    (set_attr "prefix_rep" "1")
5132    (set_attr "prefix" "maybe_vex")
5133    (set_attr "mode" "V4SF")])
5134
5135 (define_insn "<mask_codefor>avx512f_movshdup512<mask_name>"
5136   [(set (match_operand:V16SF 0 "register_operand" "=v")
5137         (vec_select:V16SF
5138           (vec_concat:V32SF
5139             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
5140             (match_dup 1))
5141           (parallel [(const_int 1) (const_int 1)
5142                      (const_int 3) (const_int 3)
5143                      (const_int 5) (const_int 5)
5144                      (const_int 7) (const_int 7)
5145                      (const_int 9) (const_int 9)
5146                      (const_int 11) (const_int 11)
5147                      (const_int 13) (const_int 13)
5148                      (const_int 15) (const_int 15)])))]
5149   "TARGET_AVX512F"
5150   "vmovshdup\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
5151   [(set_attr "type" "sse")
5152    (set_attr "prefix" "evex")
5153    (set_attr "mode" "V16SF")])
5154
5155 (define_insn "avx_movsldup256"
5156   [(set (match_operand:V8SF 0 "register_operand" "=x")
5157         (vec_select:V8SF
5158           (vec_concat:V16SF
5159             (match_operand:V8SF 1 "nonimmediate_operand" "xm")
5160             (match_dup 1))
5161           (parallel [(const_int 0) (const_int 0)
5162                      (const_int 2) (const_int 2)
5163                      (const_int 4) (const_int 4)
5164                      (const_int 6) (const_int 6)])))]
5165   "TARGET_AVX"
5166   "vmovsldup\t{%1, %0|%0, %1}"
5167   [(set_attr "type" "sse")
5168    (set_attr "prefix" "vex")
5169    (set_attr "mode" "V8SF")])
5170
5171 (define_insn "sse3_movsldup"
5172   [(set (match_operand:V4SF 0 "register_operand" "=x")
5173         (vec_select:V4SF
5174           (vec_concat:V8SF
5175             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
5176             (match_dup 1))
5177           (parallel [(const_int 0)
5178                      (const_int 0)
5179                      (const_int 6)
5180                      (const_int 6)])))]
5181   "TARGET_SSE3"
5182   "%vmovsldup\t{%1, %0|%0, %1}"
5183   [(set_attr "type" "sse")
5184    (set_attr "prefix_rep" "1")
5185    (set_attr "prefix" "maybe_vex")
5186    (set_attr "mode" "V4SF")])
5187
5188 (define_insn "<mask_codefor>avx512f_movsldup512<mask_name>"
5189   [(set (match_operand:V16SF 0 "register_operand" "=v")
5190         (vec_select:V16SF
5191           (vec_concat:V32SF
5192             (match_operand:V16SF 1 "nonimmediate_operand" "vm")
5193             (match_dup 1))
5194           (parallel [(const_int 0) (const_int 0)
5195                      (const_int 2) (const_int 2)
5196                      (const_int 4) (const_int 4)
5197                      (const_int 6) (const_int 6)
5198                      (const_int 8) (const_int 8)
5199                      (const_int 10) (const_int 10)
5200                      (const_int 12) (const_int 12)
5201                      (const_int 14) (const_int 14)])))]
5202   "TARGET_AVX512F"
5203   "vmovsldup\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
5204   [(set_attr "type" "sse")
5205    (set_attr "prefix" "evex")
5206    (set_attr "mode" "V16SF")])
5207
5208 (define_expand "avx_shufps256"
5209   [(match_operand:V8SF 0 "register_operand")
5210    (match_operand:V8SF 1 "register_operand")
5211    (match_operand:V8SF 2 "nonimmediate_operand")
5212    (match_operand:SI 3 "const_int_operand")]
5213   "TARGET_AVX"
5214 {
5215   int mask = INTVAL (operands[3]);
5216   emit_insn (gen_avx_shufps256_1 (operands[0], operands[1], operands[2],
5217                                   GEN_INT ((mask >> 0) & 3),
5218                                   GEN_INT ((mask >> 2) & 3),
5219                                   GEN_INT (((mask >> 4) & 3) + 8),
5220                                   GEN_INT (((mask >> 6) & 3) + 8),
5221                                   GEN_INT (((mask >> 0) & 3) + 4),
5222                                   GEN_INT (((mask >> 2) & 3) + 4),
5223                                   GEN_INT (((mask >> 4) & 3) + 12),
5224                                   GEN_INT (((mask >> 6) & 3) + 12)));
5225   DONE;
5226 })
5227
5228 ;; One bit in mask selects 2 elements.
5229 (define_insn "avx_shufps256_1"
5230   [(set (match_operand:V8SF 0 "register_operand" "=x")
5231         (vec_select:V8SF
5232           (vec_concat:V16SF
5233             (match_operand:V8SF 1 "register_operand" "x")
5234             (match_operand:V8SF 2 "nonimmediate_operand" "xm"))
5235           (parallel [(match_operand 3  "const_0_to_3_operand"  )
5236                      (match_operand 4  "const_0_to_3_operand"  )
5237                      (match_operand 5  "const_8_to_11_operand" )
5238                      (match_operand 6  "const_8_to_11_operand" )
5239                      (match_operand 7  "const_4_to_7_operand"  )
5240                      (match_operand 8  "const_4_to_7_operand"  )
5241                      (match_operand 9  "const_12_to_15_operand")
5242                      (match_operand 10 "const_12_to_15_operand")])))]
5243   "TARGET_AVX
5244    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
5245        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
5246        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
5247        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4))"
5248 {
5249   int mask;
5250   mask = INTVAL (operands[3]);
5251   mask |= INTVAL (operands[4]) << 2;
5252   mask |= (INTVAL (operands[5]) - 8) << 4;
5253   mask |= (INTVAL (operands[6]) - 8) << 6;
5254   operands[3] = GEN_INT (mask);
5255
5256   return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5257 }
5258   [(set_attr "type" "sseshuf")
5259    (set_attr "length_immediate" "1")
5260    (set_attr "prefix" "vex")
5261    (set_attr "mode" "V8SF")])
5262
5263 (define_expand "sse_shufps"
5264   [(match_operand:V4SF 0 "register_operand")
5265    (match_operand:V4SF 1 "register_operand")
5266    (match_operand:V4SF 2 "nonimmediate_operand")
5267    (match_operand:SI 3 "const_int_operand")]
5268   "TARGET_SSE"
5269 {
5270   int mask = INTVAL (operands[3]);
5271   emit_insn (gen_sse_shufps_v4sf (operands[0], operands[1], operands[2],
5272                                GEN_INT ((mask >> 0) & 3),
5273                                GEN_INT ((mask >> 2) & 3),
5274                                GEN_INT (((mask >> 4) & 3) + 4),
5275                                GEN_INT (((mask >> 6) & 3) + 4)));
5276   DONE;
5277 })
5278
5279 (define_insn "sse_shufps_<mode>"
5280   [(set (match_operand:VI4F_128 0 "register_operand" "=x,x")
5281         (vec_select:VI4F_128
5282           (vec_concat:<ssedoublevecmode>
5283             (match_operand:VI4F_128 1 "register_operand" "0,x")
5284             (match_operand:VI4F_128 2 "nonimmediate_operand" "xm,xm"))
5285           (parallel [(match_operand 3 "const_0_to_3_operand")
5286                      (match_operand 4 "const_0_to_3_operand")
5287                      (match_operand 5 "const_4_to_7_operand")
5288                      (match_operand 6 "const_4_to_7_operand")])))]
5289   "TARGET_SSE"
5290 {
5291   int mask = 0;
5292   mask |= INTVAL (operands[3]) << 0;
5293   mask |= INTVAL (operands[4]) << 2;
5294   mask |= (INTVAL (operands[5]) - 4) << 4;
5295   mask |= (INTVAL (operands[6]) - 4) << 6;
5296   operands[3] = GEN_INT (mask);
5297
5298   switch (which_alternative)
5299     {
5300     case 0:
5301       return "shufps\t{%3, %2, %0|%0, %2, %3}";
5302     case 1:
5303       return "vshufps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5304     default:
5305       gcc_unreachable ();
5306     }
5307 }
5308   [(set_attr "isa" "noavx,avx")
5309    (set_attr "type" "sseshuf")
5310    (set_attr "length_immediate" "1")
5311    (set_attr "prefix" "orig,vex")
5312    (set_attr "mode" "V4SF")])
5313
5314 (define_insn "sse_storehps"
5315   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
5316         (vec_select:V2SF
5317           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
5318           (parallel [(const_int 2) (const_int 3)])))]
5319   "TARGET_SSE"
5320   "@
5321    %vmovhps\t{%1, %0|%q0, %1}
5322    %vmovhlps\t{%1, %d0|%d0, %1}
5323    %vmovlps\t{%H1, %d0|%d0, %H1}"
5324   [(set_attr "type" "ssemov")
5325    (set_attr "ssememalign" "64")
5326    (set_attr "prefix" "maybe_vex")
5327    (set_attr "mode" "V2SF,V4SF,V2SF")])
5328
5329 (define_expand "sse_loadhps_exp"
5330   [(set (match_operand:V4SF 0 "nonimmediate_operand")
5331         (vec_concat:V4SF
5332           (vec_select:V2SF
5333             (match_operand:V4SF 1 "nonimmediate_operand")
5334             (parallel [(const_int 0) (const_int 1)]))
5335           (match_operand:V2SF 2 "nonimmediate_operand")))]
5336   "TARGET_SSE"
5337 {
5338   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
5339
5340   emit_insn (gen_sse_loadhps (dst, operands[1], operands[2]));
5341
5342   /* Fix up the destination if needed.  */
5343   if (dst != operands[0])
5344     emit_move_insn (operands[0], dst);
5345
5346   DONE;
5347 })
5348
5349 (define_insn "sse_loadhps"
5350   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,o")
5351         (vec_concat:V4SF
5352           (vec_select:V2SF
5353             (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0")
5354             (parallel [(const_int 0) (const_int 1)]))
5355           (match_operand:V2SF 2 "nonimmediate_operand"   " m,m,x,x,x")))]
5356   "TARGET_SSE"
5357   "@
5358    movhps\t{%2, %0|%0, %q2}
5359    vmovhps\t{%2, %1, %0|%0, %1, %q2}
5360    movlhps\t{%2, %0|%0, %2}
5361    vmovlhps\t{%2, %1, %0|%0, %1, %2}
5362    %vmovlps\t{%2, %H0|%H0, %2}"
5363   [(set_attr "isa" "noavx,avx,noavx,avx,*")
5364    (set_attr "type" "ssemov")
5365    (set_attr "ssememalign" "64")
5366    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
5367    (set_attr "mode" "V2SF,V2SF,V4SF,V4SF,V2SF")])
5368
5369 (define_insn "sse_storelps"
5370   [(set (match_operand:V2SF 0 "nonimmediate_operand"   "=m,x,x")
5371         (vec_select:V2SF
5372           (match_operand:V4SF 1 "nonimmediate_operand" " x,x,m")
5373           (parallel [(const_int 0) (const_int 1)])))]
5374   "TARGET_SSE"
5375   "@
5376    %vmovlps\t{%1, %0|%q0, %1}
5377    %vmovaps\t{%1, %0|%0, %1}
5378    %vmovlps\t{%1, %d0|%d0, %q1}"
5379   [(set_attr "type" "ssemov")
5380    (set_attr "prefix" "maybe_vex")
5381    (set_attr "mode" "V2SF,V4SF,V2SF")])
5382
5383 (define_expand "sse_loadlps_exp"
5384   [(set (match_operand:V4SF 0 "nonimmediate_operand")
5385         (vec_concat:V4SF
5386           (match_operand:V2SF 2 "nonimmediate_operand")
5387           (vec_select:V2SF
5388             (match_operand:V4SF 1 "nonimmediate_operand")
5389             (parallel [(const_int 2) (const_int 3)]))))]
5390   "TARGET_SSE"
5391 {
5392   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V4SFmode, operands);
5393
5394   emit_insn (gen_sse_loadlps (dst, operands[1], operands[2]));
5395
5396   /* Fix up the destination if needed.  */
5397   if (dst != operands[0])
5398     emit_move_insn (operands[0], dst);
5399
5400   DONE;
5401 })
5402
5403 (define_insn "sse_loadlps"
5404   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,x,x,m")
5405         (vec_concat:V4SF
5406           (match_operand:V2SF 2 "nonimmediate_operand"   " 0,x,m,m,x")
5407           (vec_select:V2SF
5408             (match_operand:V4SF 1 "nonimmediate_operand" " x,x,0,x,0")
5409             (parallel [(const_int 2) (const_int 3)]))))]
5410   "TARGET_SSE"
5411   "@
5412    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
5413    vshufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4}
5414    movlps\t{%2, %0|%0, %q2}
5415    vmovlps\t{%2, %1, %0|%0, %1, %q2}
5416    %vmovlps\t{%2, %0|%q0, %2}"
5417   [(set_attr "isa" "noavx,avx,noavx,avx,*")
5418    (set_attr "type" "sseshuf,sseshuf,ssemov,ssemov,ssemov")
5419    (set_attr "ssememalign" "64")
5420    (set_attr "length_immediate" "1,1,*,*,*")
5421    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex")
5422    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF,V2SF")])
5423
5424 (define_insn "sse_movss"
5425   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
5426         (vec_merge:V4SF
5427           (match_operand:V4SF 2 "register_operand" " x,x")
5428           (match_operand:V4SF 1 "register_operand" " 0,x")
5429           (const_int 1)))]
5430   "TARGET_SSE"
5431   "@
5432    movss\t{%2, %0|%0, %2}
5433    vmovss\t{%2, %1, %0|%0, %1, %2}"
5434   [(set_attr "isa" "noavx,avx")
5435    (set_attr "type" "ssemov")
5436    (set_attr "prefix" "orig,vex")
5437    (set_attr "mode" "SF")])
5438
5439 (define_insn "avx2_vec_dup<mode>"
5440   [(set (match_operand:VF1_128_256 0 "register_operand" "=x")
5441         (vec_duplicate:VF1_128_256
5442           (vec_select:SF
5443             (match_operand:V4SF 1 "register_operand" "x")
5444             (parallel [(const_int 0)]))))]
5445   "TARGET_AVX2"
5446   "vbroadcastss\t{%1, %0|%0, %1}"
5447   [(set_attr "type" "sselog1")
5448     (set_attr "prefix" "vex")
5449     (set_attr "mode" "<MODE>")])
5450
5451 (define_insn "avx2_vec_dupv8sf_1"
5452   [(set (match_operand:V8SF 0 "register_operand" "=x")
5453         (vec_duplicate:V8SF
5454           (vec_select:SF
5455             (match_operand:V8SF 1 "register_operand" "x")
5456             (parallel [(const_int 0)]))))]
5457   "TARGET_AVX2"
5458   "vbroadcastss\t{%x1, %0|%0, %x1}"
5459   [(set_attr "type" "sselog1")
5460     (set_attr "prefix" "vex")
5461     (set_attr "mode" "V8SF")])
5462
5463 (define_insn "vec_dupv4sf"
5464   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
5465         (vec_duplicate:V4SF
5466           (match_operand:SF 1 "nonimmediate_operand" "x,m,0")))]
5467   "TARGET_SSE"
5468   "@
5469    vshufps\t{$0, %1, %1, %0|%0, %1, %1, 0}
5470    vbroadcastss\t{%1, %0|%0, %1}
5471    shufps\t{$0, %0, %0|%0, %0, 0}"
5472   [(set_attr "isa" "avx,avx,noavx")
5473    (set_attr "type" "sseshuf1,ssemov,sseshuf1")
5474    (set_attr "length_immediate" "1,0,1")
5475    (set_attr "prefix_extra" "0,1,*")
5476    (set_attr "prefix" "vex,vex,orig")
5477    (set_attr "mode" "V4SF")])
5478
5479 ;; Although insertps takes register source, we prefer
5480 ;; unpcklps with register source since it is shorter.
5481 (define_insn "*vec_concatv2sf_sse4_1"
5482   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,x,x,x,*y ,*y")
5483         (vec_concat:V2SF
5484           (match_operand:SF 1 "nonimmediate_operand" " 0,x,0,x,m, 0 , m")
5485           (match_operand:SF 2 "vector_move_operand"  " x,x,m,m,C,*ym, C")))]
5486   "TARGET_SSE4_1"
5487   "@
5488    unpcklps\t{%2, %0|%0, %2}
5489    vunpcklps\t{%2, %1, %0|%0, %1, %2}
5490    insertps\t{$0x10, %2, %0|%0, %2, 0x10}
5491    vinsertps\t{$0x10, %2, %1, %0|%0, %1, %2, 0x10}
5492    %vmovss\t{%1, %0|%0, %1}
5493    punpckldq\t{%2, %0|%0, %2}
5494    movd\t{%1, %0|%0, %1}"
5495   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
5496    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
5497    (set_attr "prefix_data16" "*,*,1,*,*,*,*")
5498    (set_attr "prefix_extra" "*,*,1,1,*,*,*")
5499    (set_attr "length_immediate" "*,*,1,1,*,*,*")
5500    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
5501    (set_attr "mode" "V4SF,V4SF,V4SF,V4SF,SF,DI,DI")])
5502
5503 ;; ??? In theory we can match memory for the MMX alternative, but allowing
5504 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
5505 ;; alternatives pretty much forces the MMX alternative to be chosen.
5506 (define_insn "*vec_concatv2sf_sse"
5507   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
5508         (vec_concat:V2SF
5509           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
5510           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
5511   "TARGET_SSE"
5512   "@
5513    unpcklps\t{%2, %0|%0, %2}
5514    movss\t{%1, %0|%0, %1}
5515    punpckldq\t{%2, %0|%0, %2}
5516    movd\t{%1, %0|%0, %1}"
5517   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
5518    (set_attr "mode" "V4SF,SF,DI,DI")])
5519
5520 (define_insn "*vec_concatv4sf"
5521   [(set (match_operand:V4SF 0 "register_operand"       "=x,x,x,x")
5522         (vec_concat:V4SF
5523           (match_operand:V2SF 1 "register_operand"     " 0,x,0,x")
5524           (match_operand:V2SF 2 "nonimmediate_operand" " x,x,m,m")))]
5525   "TARGET_SSE"
5526   "@
5527    movlhps\t{%2, %0|%0, %2}
5528    vmovlhps\t{%2, %1, %0|%0, %1, %2}
5529    movhps\t{%2, %0|%0, %q2}
5530    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
5531   [(set_attr "isa" "noavx,avx,noavx,avx")
5532    (set_attr "type" "ssemov")
5533    (set_attr "prefix" "orig,vex,orig,vex")
5534    (set_attr "mode" "V4SF,V4SF,V2SF,V2SF")])
5535
5536 (define_expand "vec_init<mode>"
5537   [(match_operand:V_128 0 "register_operand")
5538    (match_operand 1)]
5539   "TARGET_SSE"
5540 {
5541   ix86_expand_vector_init (false, operands[0], operands[1]);
5542   DONE;
5543 })
5544
5545 ;; Avoid combining registers from different units in a single alternative,
5546 ;; see comment above inline_secondary_memory_needed function in i386.c
5547 (define_insn "vec_set<mode>_0"
5548   [(set (match_operand:VI4F_128 0 "nonimmediate_operand"
5549           "=x,x,x ,x,x,x,x  ,x  ,m ,m   ,m")
5550         (vec_merge:VI4F_128
5551           (vec_duplicate:VI4F_128
5552             (match_operand:<ssescalarmode> 2 "general_operand"
5553           " x,m,*r,m,x,x,*rm,*rm,!x,!*re,!*fF"))
5554           (match_operand:VI4F_128 1 "vector_move_operand"
5555           " C,C,C ,C,0,x,0  ,x  ,0 ,0   ,0")
5556           (const_int 1)))]
5557   "TARGET_SSE"
5558   "@
5559    %vinsertps\t{$0xe, %d2, %0|%0, %d2, 0xe}
5560    %vmov<ssescalarmodesuffix>\t{%2, %0|%0, %2}
5561    %vmovd\t{%2, %0|%0, %2}
5562    movss\t{%2, %0|%0, %2}
5563    movss\t{%2, %0|%0, %2}
5564    vmovss\t{%2, %1, %0|%0, %1, %2}
5565    pinsrd\t{$0, %2, %0|%0, %2, 0}
5566    vpinsrd\t{$0, %2, %1, %0|%0, %1, %2, 0}
5567    #
5568    #
5569    #"
5570   [(set_attr "isa" "sse4,sse2,sse2,noavx,noavx,avx,sse4_noavx,avx,*,*,*")
5571    (set (attr "type")
5572      (cond [(eq_attr "alternative" "0,6,7")
5573               (const_string "sselog")
5574             (eq_attr "alternative" "9")
5575               (const_string "imov")
5576             (eq_attr "alternative" "10")
5577               (const_string "fmov")
5578            ]
5579            (const_string "ssemov")))
5580    (set_attr "prefix_extra" "*,*,*,*,*,*,1,1,*,*,*")
5581    (set_attr "length_immediate" "*,*,*,*,*,*,1,1,*,*,*")
5582    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,orig,orig,vex,orig,vex,*,*,*")
5583    (set_attr "mode" "SF,<ssescalarmode>,SI,SF,SF,SF,TI,TI,*,*,*")])
5584
5585 ;; A subset is vec_setv4sf.
5586 (define_insn "*vec_setv4sf_sse4_1"
5587   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5588         (vec_merge:V4SF
5589           (vec_duplicate:V4SF
5590             (match_operand:SF 2 "nonimmediate_operand" "xm,xm"))
5591           (match_operand:V4SF 1 "register_operand" "0,x")
5592           (match_operand:SI 3 "const_int_operand")))]
5593   "TARGET_SSE4_1
5594    && ((unsigned) exact_log2 (INTVAL (operands[3]))
5595        < GET_MODE_NUNITS (V4SFmode))"
5596 {
5597   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
5598   switch (which_alternative)
5599     {
5600     case 0:
5601       return "insertps\t{%3, %2, %0|%0, %2, %3}";
5602     case 1:
5603       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5604     default:
5605       gcc_unreachable ();
5606     }
5607 }
5608   [(set_attr "isa" "noavx,avx")
5609    (set_attr "type" "sselog")
5610    (set_attr "prefix_data16" "1,*")
5611    (set_attr "prefix_extra" "1")
5612    (set_attr "length_immediate" "1")
5613    (set_attr "prefix" "orig,vex")
5614    (set_attr "mode" "V4SF")])
5615
5616 (define_insn "sse4_1_insertps"
5617   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
5618         (unspec:V4SF [(match_operand:V4SF 2 "nonimmediate_operand" "xm,xm")
5619                       (match_operand:V4SF 1 "register_operand" "0,x")
5620                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
5621                      UNSPEC_INSERTPS))]
5622   "TARGET_SSE4_1"
5623 {
5624   if (MEM_P (operands[2]))
5625     {
5626       unsigned count_s = INTVAL (operands[3]) >> 6;
5627       if (count_s)
5628         operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
5629       operands[2] = adjust_address_nv (operands[2], SFmode, count_s * 4);
5630     }
5631   switch (which_alternative)
5632     {
5633     case 0:
5634       return "insertps\t{%3, %2, %0|%0, %2, %3}";
5635     case 1:
5636       return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5637     default:
5638       gcc_unreachable ();
5639     }
5640 }
5641   [(set_attr "isa" "noavx,avx")
5642    (set_attr "type" "sselog")
5643    (set_attr "prefix_data16" "1,*")
5644    (set_attr "prefix_extra" "1")
5645    (set_attr "length_immediate" "1")
5646    (set_attr "prefix" "orig,vex")
5647    (set_attr "mode" "V4SF")])
5648
5649 (define_split
5650   [(set (match_operand:VI4F_128 0 "memory_operand")
5651         (vec_merge:VI4F_128
5652           (vec_duplicate:VI4F_128
5653             (match_operand:<ssescalarmode> 1 "nonmemory_operand"))
5654           (match_dup 0)
5655           (const_int 1)))]
5656   "TARGET_SSE && reload_completed"
5657   [(set (match_dup 0) (match_dup 1))]
5658   "operands[0] = adjust_address (operands[0], <ssescalarmode>mode, 0);")
5659
5660 (define_expand "vec_set<mode>"
5661   [(match_operand:V 0 "register_operand")
5662    (match_operand:<ssescalarmode> 1 "register_operand")
5663    (match_operand 2 "const_int_operand")]
5664   "TARGET_SSE"
5665 {
5666   ix86_expand_vector_set (false, operands[0], operands[1],
5667                           INTVAL (operands[2]));
5668   DONE;
5669 })
5670
5671 (define_insn_and_split "*vec_extractv4sf_0"
5672   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,f,r")
5673         (vec_select:SF
5674           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m,m")
5675           (parallel [(const_int 0)])))]
5676   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5677   "#"
5678   "&& reload_completed"
5679   [(set (match_dup 0) (match_dup 1))]
5680 {
5681   if (REG_P (operands[1]))
5682     operands[1] = gen_rtx_REG (SFmode, REGNO (operands[1]));
5683   else
5684     operands[1] = adjust_address (operands[1], SFmode, 0);
5685 })
5686
5687 (define_insn_and_split "*sse4_1_extractps"
5688   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm,x,x")
5689         (vec_select:SF
5690           (match_operand:V4SF 1 "register_operand" "x,0,x")
5691           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n,n,n")])))]
5692   "TARGET_SSE4_1"
5693   "@
5694    %vextractps\t{%2, %1, %0|%0, %1, %2}
5695    #
5696    #"
5697   "&& reload_completed && SSE_REG_P (operands[0])"
5698   [(const_int 0)]
5699 {
5700   rtx dest = gen_rtx_REG (V4SFmode, REGNO (operands[0]));
5701   switch (INTVAL (operands[2]))
5702     {
5703     case 1:
5704     case 3:
5705       emit_insn (gen_sse_shufps_v4sf (dest, operands[1], operands[1],
5706                                       operands[2], operands[2],
5707                                       GEN_INT (INTVAL (operands[2]) + 4),
5708                                       GEN_INT (INTVAL (operands[2]) + 4)));
5709       break;
5710     case 2:
5711       emit_insn (gen_vec_interleave_highv4sf (dest, operands[1], operands[1]));
5712       break;
5713     default:
5714       /* 0 should be handled by the *vec_extractv4sf_0 pattern above.  */
5715       gcc_unreachable ();
5716     }
5717   DONE;
5718 }
5719   [(set_attr "isa" "*,noavx,avx")
5720    (set_attr "type" "sselog,*,*")
5721    (set_attr "prefix_data16" "1,*,*")
5722    (set_attr "prefix_extra" "1,*,*")
5723    (set_attr "length_immediate" "1,*,*")
5724    (set_attr "prefix" "maybe_vex,*,*")
5725    (set_attr "mode" "V4SF,*,*")])
5726
5727 (define_insn_and_split "*vec_extractv4sf_mem"
5728   [(set (match_operand:SF 0 "register_operand" "=x,*r,f")
5729         (vec_select:SF
5730           (match_operand:V4SF 1 "memory_operand" "o,o,o")
5731           (parallel [(match_operand 2 "const_0_to_3_operand" "n,n,n")])))]
5732   "TARGET_SSE"
5733   "#"
5734   "&& reload_completed"
5735   [(set (match_dup 0) (match_dup 1))]
5736 {
5737   operands[1] = adjust_address (operands[1], SFmode, INTVAL (operands[2]) * 4);
5738 })
5739
5740 (define_expand "avx512f_vextract<shuffletype>32x4_mask"
5741   [(match_operand:<ssequartermode> 0 "nonimmediate_operand")
5742    (match_operand:V16FI 1 "register_operand")
5743    (match_operand:SI 2 "const_0_to_3_operand")
5744    (match_operand:<ssequartermode> 3 "nonimmediate_operand")
5745    (match_operand:QI 4 "register_operand")]
5746   "TARGET_AVX512F"
5747 {
5748   if (MEM_P (operands[0]) && GET_CODE (operands[3]) == CONST_VECTOR)
5749     operands[0] = force_reg (<ssequartermode>mode, operands[0]);
5750   switch (INTVAL (operands[2]))
5751     {
5752     case 0:
5753       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5754           operands[1], GEN_INT (0), GEN_INT (1), GEN_INT (2),
5755           GEN_INT (3), operands[3], operands[4]));
5756       break;
5757     case 1:
5758       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5759           operands[1], GEN_INT (4), GEN_INT (5), GEN_INT (6),
5760           GEN_INT (7), operands[3], operands[4]));
5761       break;
5762     case 2:
5763       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5764           operands[1], GEN_INT (8), GEN_INT (9), GEN_INT (10),
5765           GEN_INT (11), operands[3], operands[4]));
5766       break;
5767     case 3:
5768       emit_insn (gen_avx512f_vextract<shuffletype>32x4_1_mask (operands[0],
5769           operands[1], GEN_INT (12), GEN_INT (13), GEN_INT (14),
5770           GEN_INT (15), operands[3], operands[4]));
5771       break;
5772     default:
5773       gcc_unreachable ();
5774     }
5775   DONE;
5776 })
5777
5778 (define_insn "avx512f_vextract<shuffletype>32x4_1_maskm"
5779   [(set (match_operand:<ssequartermode> 0 "memory_operand" "=m")
5780         (vec_merge:<ssequartermode>
5781           (vec_select:<ssequartermode>
5782             (match_operand:V16FI 1 "register_operand" "v")
5783             (parallel [(match_operand 2  "const_0_to_15_operand")
5784               (match_operand 3  "const_0_to_15_operand")
5785               (match_operand 4  "const_0_to_15_operand")
5786               (match_operand 5  "const_0_to_15_operand")]))
5787           (match_operand:<ssequartermode> 6 "memory_operand" "0")
5788           (match_operand:QI 7 "register_operand" "Yk")))]
5789   "TARGET_AVX512F && (INTVAL (operands[2]) = INTVAL (operands[3]) - 1)
5790   && (INTVAL (operands[3]) = INTVAL (operands[4]) - 1)
5791   && (INTVAL (operands[4]) = INTVAL (operands[5]) - 1)"
5792 {
5793   operands[2] = GEN_INT ((INTVAL (operands[2])) >> 2);
5794   return "vextract<shuffletype>32x4\t{%2, %1, %0%{%7%}|%0%{%7%}, %1, %2}";
5795 }
5796   [(set_attr "type" "sselog")
5797    (set_attr "prefix_extra" "1")
5798    (set_attr "length_immediate" "1")
5799    (set_attr "memory" "store")
5800    (set_attr "prefix" "evex")
5801    (set_attr "mode" "<sseinsnmode>")])
5802
5803 (define_insn "<mask_codefor>avx512f_vextract<shuffletype>32x4_1<mask_name>"
5804   [(set (match_operand:<ssequartermode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
5805         (vec_select:<ssequartermode>
5806           (match_operand:V16FI 1 "register_operand" "v")
5807           (parallel [(match_operand 2  "const_0_to_15_operand")
5808             (match_operand 3  "const_0_to_15_operand")
5809             (match_operand 4  "const_0_to_15_operand")
5810             (match_operand 5  "const_0_to_15_operand")])))]
5811   "TARGET_AVX512F && (INTVAL (operands[2]) = INTVAL (operands[3]) - 1)
5812   && (INTVAL (operands[3]) = INTVAL (operands[4]) - 1)
5813   && (INTVAL (operands[4]) = INTVAL (operands[5]) - 1)"
5814 {
5815   operands[2] = GEN_INT ((INTVAL (operands[2])) >> 2);
5816   return "vextract<shuffletype>32x4\t{%2, %1, %0<mask_operand6>|%0<mask_operand6>, %1, %2}";
5817 }
5818   [(set_attr "type" "sselog")
5819    (set_attr "prefix_extra" "1")
5820    (set_attr "length_immediate" "1")
5821    (set (attr "memory")
5822       (if_then_else (match_test "MEM_P (operands[0])")
5823         (const_string "store")
5824         (const_string "none")))
5825    (set_attr "prefix" "evex")
5826    (set_attr "mode" "<sseinsnmode>")])
5827
5828 (define_expand "avx512f_vextract<shuffletype>64x4_mask"
5829   [(match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
5830    (match_operand:V8FI 1 "register_operand")
5831    (match_operand:SI 2 "const_0_to_1_operand")
5832    (match_operand:<ssehalfvecmode> 3 "nonimmediate_operand")
5833    (match_operand:QI 4 "register_operand")]
5834   "TARGET_AVX512F"
5835 {
5836   rtx (*insn)(rtx, rtx, rtx, rtx);
5837
5838   if (MEM_P (operands[0]) && GET_CODE (operands[3]) == CONST_VECTOR)
5839     operands[0] = force_reg (<ssequartermode>mode, operands[0]);
5840
5841   switch (INTVAL (operands[2]))
5842     {
5843     case 0:
5844       insn = gen_vec_extract_lo_<mode>_mask;
5845       break;
5846     case 1:
5847       insn = gen_vec_extract_hi_<mode>_mask;
5848       break;
5849     default:
5850       gcc_unreachable ();
5851     }
5852
5853   emit_insn (insn (operands[0], operands[1], operands[3], operands[4]));
5854   DONE;
5855 })
5856
5857 (define_split
5858   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
5859         (vec_select:<ssehalfvecmode>
5860           (match_operand:V8FI 1 "nonimmediate_operand")
5861           (parallel [(const_int 0) (const_int 1)
5862             (const_int 2) (const_int 3)])))]
5863   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))
5864   && reload_completed"
5865   [(const_int 0)]
5866 {
5867   rtx op1 = operands[1];
5868   if (REG_P (op1))
5869     op1 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op1));
5870   else
5871     op1 = gen_lowpart (<ssehalfvecmode>mode, op1);
5872   emit_move_insn (operands[0], op1);
5873   DONE;
5874 })
5875
5876 (define_insn "vec_extract_lo_<mode>_maskm"
5877   [(set (match_operand:<ssehalfvecmode> 0 "memory_operand" "=m")
5878         (vec_merge:<ssehalfvecmode>
5879           (vec_select:<ssehalfvecmode>
5880             (match_operand:V8FI 1 "register_operand" "v")
5881             (parallel [(const_int 0) (const_int 1)
5882               (const_int 2) (const_int 3)]))
5883           (match_operand:<ssehalfvecmode> 2 "memory_operand" "0")
5884           (match_operand:QI 3 "register_operand" "Yk")))]
5885   "TARGET_AVX512F"
5886 "vextract<shuffletype>64x4\t{$0x0, %1, %0%{%3%}|%0%{%3%}, %1, 0x0}"
5887   [(set_attr "type" "sselog")
5888    (set_attr "prefix_extra" "1")
5889    (set_attr "length_immediate" "1")
5890    (set_attr "prefix" "evex")
5891    (set_attr "mode" "<sseinsnmode>")])
5892
5893 (define_insn "vec_extract_lo_<mode><mask_name>"
5894   [(set (match_operand:<ssehalfvecmode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
5895         (vec_select:<ssehalfvecmode>
5896           (match_operand:V8FI 1 "nonimmediate_operand" "vm")
5897           (parallel [(const_int 0) (const_int 1)
5898             (const_int 2) (const_int 3)])))]
5899   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5900 {
5901   if (<mask_applied>)
5902     return "vextract<shuffletype>64x4\t{$0x0, %1, %0<mask_operand2>|%0<mask_operand2>, %1, 0x0}";
5903   else
5904     return "#";
5905 }
5906   [(set_attr "type" "sselog")
5907    (set_attr "prefix_extra" "1")
5908    (set_attr "length_immediate" "1")
5909    (set (attr "memory")
5910       (if_then_else (match_test "MEM_P (operands[0])")
5911         (const_string "store")
5912         (const_string "none")))
5913    (set_attr "prefix" "evex")
5914    (set_attr "mode" "<sseinsnmode>")])
5915
5916 (define_insn "vec_extract_hi_<mode>_maskm"
5917   [(set (match_operand:<ssehalfvecmode> 0 "memory_operand" "=m")
5918         (vec_merge:<ssehalfvecmode>
5919           (vec_select:<ssehalfvecmode>
5920             (match_operand:V8FI 1 "register_operand" "v")
5921             (parallel [(const_int 4) (const_int 5)
5922               (const_int 6) (const_int 7)]))
5923           (match_operand:<ssehalfvecmode> 2 "memory_operand" "0")
5924           (match_operand:QI 3 "register_operand" "Yk")))]
5925   "TARGET_AVX512F"
5926   "vextract<shuffletype>64x4\t{$0x1, %1, %0%{%3%}|%0%{%3%}, %1, 0x1}"
5927   [(set_attr "type" "sselog")
5928    (set_attr "prefix_extra" "1")
5929    (set_attr "length_immediate" "1")
5930    (set_attr "memory" "store")
5931    (set_attr "prefix" "evex")
5932    (set_attr "mode" "<sseinsnmode>")])
5933
5934 (define_insn "vec_extract_hi_<mode><mask_name>"
5935   [(set (match_operand:<ssehalfvecmode> 0 "<store_mask_predicate>" "=<store_mask_constraint>")
5936         (vec_select:<ssehalfvecmode>
5937           (match_operand:V8FI 1 "register_operand" "v")
5938           (parallel [(const_int 4) (const_int 5)
5939             (const_int 6) (const_int 7)])))]
5940   "TARGET_AVX512F"
5941   "vextract<shuffletype>64x4\t{$0x1, %1, %0<mask_operand2>|%0<mask_operand2>, %1, 0x1}"
5942   [(set_attr "type" "sselog")
5943    (set_attr "prefix_extra" "1")
5944    (set_attr "length_immediate" "1")
5945    (set (attr "memory")
5946       (if_then_else (match_test "MEM_P (operands[0])")
5947         (const_string "store")
5948         (const_string "none")))
5949    (set_attr "prefix" "evex")
5950    (set_attr "mode" "<sseinsnmode>")])
5951
5952 (define_expand "avx_vextractf128<mode>"
5953   [(match_operand:<ssehalfvecmode> 0 "nonimmediate_operand")
5954    (match_operand:V_256 1 "register_operand")
5955    (match_operand:SI 2 "const_0_to_1_operand")]
5956   "TARGET_AVX"
5957 {
5958   rtx (*insn)(rtx, rtx);
5959
5960   switch (INTVAL (operands[2]))
5961     {
5962     case 0:
5963       insn = gen_vec_extract_lo_<mode>;
5964       break;
5965     case 1:
5966       insn = gen_vec_extract_hi_<mode>;
5967       break;
5968     default:
5969       gcc_unreachable ();
5970     }
5971
5972   emit_insn (insn (operands[0], operands[1]));
5973   DONE;
5974 })
5975
5976 (define_insn_and_split "vec_extract_lo_<mode>"
5977   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=v,m")
5978         (vec_select:<ssehalfvecmode>
5979           (match_operand:V16FI 1 "nonimmediate_operand" "vm,v")
5980           (parallel [(const_int 0) (const_int 1)
5981                      (const_int 2) (const_int 3)
5982                      (const_int 4) (const_int 5)
5983                      (const_int 6) (const_int 7)])))]
5984   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5985   "#"
5986   "&& reload_completed"
5987   [(const_int 0)]
5988 {
5989   rtx op1 = operands[1];
5990   if (REG_P (op1))
5991     op1 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op1));
5992   else
5993     op1 = gen_lowpart (<ssehalfvecmode>mode, op1);
5994   emit_move_insn (operands[0], op1);
5995   DONE;
5996 })
5997
5998 (define_insn "vec_extract_hi_<mode>"
5999   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=v,m")
6000         (vec_select:<ssehalfvecmode>
6001           (match_operand:V16FI 1 "nonimmediate_operand" "v,v")
6002           (parallel [(const_int 8) (const_int 9)
6003                      (const_int 10) (const_int 11)
6004                      (const_int 12) (const_int 13)
6005                      (const_int 14) (const_int 15)])))]
6006   "TARGET_AVX512F"
6007   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6008   [(set_attr "type" "sselog")
6009    (set_attr "prefix_extra" "1")
6010    (set_attr "length_immediate" "1")
6011    (set_attr "memory" "none,store")
6012    (set_attr "prefix" "evex")
6013    (set_attr "mode" "XI")])
6014
6015 (define_insn_and_split "vec_extract_lo_<mode>"
6016   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6017         (vec_select:<ssehalfvecmode>
6018           (match_operand:VI8F_256 1 "nonimmediate_operand" "xm,x")
6019           (parallel [(const_int 0) (const_int 1)])))]
6020   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6021   "#"
6022   "&& reload_completed"
6023   [(set (match_dup 0) (match_dup 1))]
6024 {
6025   if (REG_P (operands[1]))
6026     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
6027   else
6028     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
6029 })
6030
6031 (define_insn "vec_extract_hi_<mode>"
6032   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6033         (vec_select:<ssehalfvecmode>
6034           (match_operand:VI8F_256 1 "register_operand" "x,x")
6035           (parallel [(const_int 2) (const_int 3)])))]
6036   "TARGET_AVX"
6037   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
6038   [(set_attr "type" "sselog")
6039    (set_attr "prefix_extra" "1")
6040    (set_attr "length_immediate" "1")
6041    (set_attr "memory" "none,store")
6042    (set_attr "prefix" "vex")
6043    (set_attr "mode" "<sseinsnmode>")])
6044
6045 (define_insn_and_split "vec_extract_lo_<mode>"
6046   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6047         (vec_select:<ssehalfvecmode>
6048           (match_operand:VI4F_256 1 "nonimmediate_operand" "xm,x")
6049           (parallel [(const_int 0) (const_int 1)
6050                      (const_int 2) (const_int 3)])))]
6051   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6052   "#"
6053   "&& reload_completed"
6054   [(set (match_dup 0) (match_dup 1))]
6055 {
6056   if (REG_P (operands[1]))
6057     operands[1] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[1]));
6058   else
6059     operands[1] = adjust_address (operands[1], <ssehalfvecmode>mode, 0);
6060 })
6061
6062 (define_insn "vec_extract_hi_<mode>"
6063   [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=x,m")
6064         (vec_select:<ssehalfvecmode>
6065           (match_operand:VI4F_256 1 "register_operand" "x,x")
6066           (parallel [(const_int 4) (const_int 5)
6067                      (const_int 6) (const_int 7)])))]
6068   "TARGET_AVX"
6069   "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}"
6070   [(set_attr "type" "sselog")
6071    (set_attr "prefix_extra" "1")
6072    (set_attr "length_immediate" "1")
6073    (set_attr "memory" "none,store")
6074    (set_attr "prefix" "vex")
6075    (set_attr "mode" "<sseinsnmode>")])
6076
6077 (define_insn_and_split "vec_extract_lo_v32hi"
6078   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=v,m")
6079         (vec_select:V16HI
6080           (match_operand:V32HI 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                      (const_int 8) (const_int 9)
6086                      (const_int 10) (const_int 11)
6087                      (const_int 12) (const_int 13)
6088                      (const_int 14) (const_int 15)])))]
6089   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6090   "#"
6091   "&& reload_completed"
6092   [(set (match_dup 0) (match_dup 1))]
6093 {
6094   if (REG_P (operands[1]))
6095     operands[1] = gen_rtx_REG (V16HImode, REGNO (operands[1]));
6096   else
6097     operands[1] = adjust_address (operands[1], V16HImode, 0);
6098 })
6099
6100 (define_insn "vec_extract_hi_v32hi"
6101   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=v,m")
6102         (vec_select:V16HI
6103           (match_operand:V32HI 1 "nonimmediate_operand" "v,v")
6104           (parallel [(const_int 16) (const_int 17)
6105                      (const_int 18) (const_int 19)
6106                      (const_int 20) (const_int 21)
6107                      (const_int 22) (const_int 23)
6108                      (const_int 24) (const_int 25)
6109                      (const_int 26) (const_int 27)
6110                      (const_int 28) (const_int 29)
6111                      (const_int 30) (const_int 31)])))]
6112   "TARGET_AVX512F"
6113   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6114   [(set_attr "type" "sselog")
6115    (set_attr "prefix_extra" "1")
6116    (set_attr "length_immediate" "1")
6117    (set_attr "memory" "none,store")
6118    (set_attr "prefix" "evex")
6119    (set_attr "mode" "XI")])
6120
6121 (define_insn_and_split "vec_extract_lo_v16hi"
6122   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
6123         (vec_select:V8HI
6124           (match_operand:V16HI 1 "nonimmediate_operand" "xm,x")
6125           (parallel [(const_int 0) (const_int 1)
6126                      (const_int 2) (const_int 3)
6127                      (const_int 4) (const_int 5)
6128                      (const_int 6) (const_int 7)])))]
6129   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6130   "#"
6131   "&& reload_completed"
6132   [(set (match_dup 0) (match_dup 1))]
6133 {
6134   if (REG_P (operands[1]))
6135     operands[1] = gen_rtx_REG (V8HImode, REGNO (operands[1]));
6136   else
6137     operands[1] = adjust_address (operands[1], V8HImode, 0);
6138 })
6139
6140 (define_insn "vec_extract_hi_v16hi"
6141   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=x,m")
6142         (vec_select:V8HI
6143           (match_operand:V16HI 1 "register_operand" "x,x")
6144           (parallel [(const_int 8) (const_int 9)
6145                      (const_int 10) (const_int 11)
6146                      (const_int 12) (const_int 13)
6147                      (const_int 14) (const_int 15)])))]
6148   "TARGET_AVX"
6149   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
6150   [(set_attr "type" "sselog")
6151    (set_attr "prefix_extra" "1")
6152    (set_attr "length_immediate" "1")
6153    (set_attr "memory" "none,store")
6154    (set_attr "prefix" "vex")
6155    (set_attr "mode" "OI")])
6156
6157 (define_insn_and_split "vec_extract_lo_v64qi"
6158   [(set (match_operand:V32QI 0 "nonimmediate_operand" "=v,m")
6159         (vec_select:V32QI
6160           (match_operand:V64QI 1 "nonimmediate_operand" "vm,v")
6161           (parallel [(const_int 0) (const_int 1)
6162                      (const_int 2) (const_int 3)
6163                      (const_int 4) (const_int 5)
6164                      (const_int 6) (const_int 7)
6165                      (const_int 8) (const_int 9)
6166                      (const_int 10) (const_int 11)
6167                      (const_int 12) (const_int 13)
6168                      (const_int 14) (const_int 15)
6169                      (const_int 16) (const_int 17)
6170                      (const_int 18) (const_int 19)
6171                      (const_int 20) (const_int 21)
6172                      (const_int 22) (const_int 23)
6173                      (const_int 24) (const_int 25)
6174                      (const_int 26) (const_int 27)
6175                      (const_int 28) (const_int 29)
6176                      (const_int 30) (const_int 31)])))]
6177   "TARGET_AVX512F && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6178   "#"
6179   "&& reload_completed"
6180   [(set (match_dup 0) (match_dup 1))]
6181 {
6182   if (REG_P (operands[1]))
6183     operands[1] = gen_rtx_REG (V32QImode, REGNO (operands[1]));
6184   else
6185     operands[1] = adjust_address (operands[1], V32QImode, 0);
6186 })
6187
6188 (define_insn "vec_extract_hi_v64qi"
6189   [(set (match_operand:V32QI 0 "nonimmediate_operand" "=v,m")
6190         (vec_select:V32QI
6191           (match_operand:V64QI 1 "nonimmediate_operand" "v,v")
6192           (parallel [(const_int 32) (const_int 33)
6193                      (const_int 34) (const_int 35)
6194                      (const_int 36) (const_int 37)
6195                      (const_int 38) (const_int 39)
6196                      (const_int 40) (const_int 41)
6197                      (const_int 42) (const_int 43)
6198                      (const_int 44) (const_int 45)
6199                      (const_int 46) (const_int 47)
6200                      (const_int 48) (const_int 49)
6201                      (const_int 50) (const_int 51)
6202                      (const_int 52) (const_int 53)
6203                      (const_int 54) (const_int 55)
6204                      (const_int 56) (const_int 57)
6205                      (const_int 58) (const_int 59)
6206                      (const_int 60) (const_int 61)
6207                      (const_int 62) (const_int 63)])))]
6208   "TARGET_AVX512F"
6209   "vextracti64x4\t{$0x1, %1, %0|%0, %1, 0x1}"
6210   [(set_attr "type" "sselog")
6211    (set_attr "prefix_extra" "1")
6212    (set_attr "length_immediate" "1")
6213    (set_attr "memory" "none,store")
6214    (set_attr "prefix" "evex")
6215    (set_attr "mode" "XI")])
6216
6217 (define_insn_and_split "vec_extract_lo_v32qi"
6218   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
6219         (vec_select:V16QI
6220           (match_operand:V32QI 1 "nonimmediate_operand" "xm,x")
6221           (parallel [(const_int 0) (const_int 1)
6222                      (const_int 2) (const_int 3)
6223                      (const_int 4) (const_int 5)
6224                      (const_int 6) (const_int 7)
6225                      (const_int 8) (const_int 9)
6226                      (const_int 10) (const_int 11)
6227                      (const_int 12) (const_int 13)
6228                      (const_int 14) (const_int 15)])))]
6229   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
6230   "#"
6231   "&& reload_completed"
6232   [(set (match_dup 0) (match_dup 1))]
6233 {
6234   if (REG_P (operands[1]))
6235     operands[1] = gen_rtx_REG (V16QImode, REGNO (operands[1]));
6236   else
6237     operands[1] = adjust_address (operands[1], V16QImode, 0);
6238 })
6239
6240 (define_insn "vec_extract_hi_v32qi"
6241   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
6242         (vec_select:V16QI
6243           (match_operand:V32QI 1 "register_operand" "x,x")
6244           (parallel [(const_int 16) (const_int 17)
6245                      (const_int 18) (const_int 19)
6246                      (const_int 20) (const_int 21)
6247                      (const_int 22) (const_int 23)
6248                      (const_int 24) (const_int 25)
6249                      (const_int 26) (const_int 27)
6250                      (const_int 28) (const_int 29)
6251                      (const_int 30) (const_int 31)])))]
6252   "TARGET_AVX"
6253   "vextract%~128\t{$0x1, %1, %0|%0, %1, 0x1}"
6254   [(set_attr "type" "sselog")
6255    (set_attr "prefix_extra" "1")
6256    (set_attr "length_immediate" "1")
6257    (set_attr "memory" "none,store")
6258    (set_attr "prefix" "vex")
6259    (set_attr "mode" "OI")])
6260
6261 ;; Modes handled by vec_extract patterns.
6262 (define_mode_iterator VEC_EXTRACT_MODE
6263   [(V32QI "TARGET_AVX") V16QI
6264    (V16HI "TARGET_AVX") V8HI
6265    (V16SI "TARGET_AVX512F") (V8SI "TARGET_AVX") V4SI
6266    (V8DI "TARGET_AVX512F") (V4DI "TARGET_AVX") V2DI
6267    (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF
6268    (V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") V2DF])
6269
6270 (define_expand "vec_extract<mode>"
6271   [(match_operand:<ssescalarmode> 0 "register_operand")
6272    (match_operand:VEC_EXTRACT_MODE 1 "register_operand")
6273    (match_operand 2 "const_int_operand")]
6274   "TARGET_SSE"
6275 {
6276   ix86_expand_vector_extract (false, operands[0], operands[1],
6277                               INTVAL (operands[2]));
6278   DONE;
6279 })
6280
6281 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6282 ;;
6283 ;; Parallel double-precision floating point element swizzling
6284 ;;
6285 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6286
6287 (define_insn "<mask_codefor>avx512f_unpckhpd512<mask_name>"
6288   [(set (match_operand:V8DF 0 "register_operand" "=v")
6289         (vec_select:V8DF
6290           (vec_concat:V16DF
6291             (match_operand:V8DF 1 "nonimmediate_operand" "v")
6292             (match_operand:V8DF 2 "nonimmediate_operand" "vm"))
6293           (parallel [(const_int 1) (const_int 9)
6294                      (const_int 3) (const_int 11)
6295                      (const_int 5) (const_int 13)
6296                      (const_int 7) (const_int 15)])))]
6297   "TARGET_AVX512F"
6298   "vunpckhpd\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
6299   [(set_attr "type" "sselog")
6300    (set_attr "prefix" "evex")
6301    (set_attr "mode" "V8DF")])
6302
6303 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
6304 (define_insn "avx_unpckhpd256"
6305   [(set (match_operand:V4DF 0 "register_operand" "=x")
6306         (vec_select:V4DF
6307           (vec_concat:V8DF
6308             (match_operand:V4DF 1 "register_operand" "x")
6309             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6310           (parallel [(const_int 1) (const_int 5)
6311                      (const_int 3) (const_int 7)])))]
6312   "TARGET_AVX"
6313   "vunpckhpd\t{%2, %1, %0|%0, %1, %2}"
6314   [(set_attr "type" "sselog")
6315    (set_attr "prefix" "vex")
6316    (set_attr "mode" "V4DF")])
6317
6318 (define_expand "vec_interleave_highv4df"
6319   [(set (match_dup 3)
6320         (vec_select:V4DF
6321           (vec_concat:V8DF
6322             (match_operand:V4DF 1 "register_operand" "x")
6323             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6324           (parallel [(const_int 0) (const_int 4)
6325                      (const_int 2) (const_int 6)])))
6326    (set (match_dup 4)
6327         (vec_select:V4DF
6328           (vec_concat:V8DF
6329             (match_dup 1)
6330             (match_dup 2))
6331           (parallel [(const_int 1) (const_int 5)
6332                      (const_int 3) (const_int 7)])))
6333    (set (match_operand:V4DF 0 "register_operand")
6334         (vec_select:V4DF
6335           (vec_concat:V8DF
6336             (match_dup 3)
6337             (match_dup 4))
6338           (parallel [(const_int 2) (const_int 3)
6339                      (const_int 6) (const_int 7)])))]
6340  "TARGET_AVX"
6341 {
6342   operands[3] = gen_reg_rtx (V4DFmode);
6343   operands[4] = gen_reg_rtx (V4DFmode);
6344 })
6345
6346
6347 (define_expand "vec_interleave_highv2df"
6348   [(set (match_operand:V2DF 0 "register_operand")
6349         (vec_select:V2DF
6350           (vec_concat:V4DF
6351             (match_operand:V2DF 1 "nonimmediate_operand")
6352             (match_operand:V2DF 2 "nonimmediate_operand"))
6353           (parallel [(const_int 1)
6354                      (const_int 3)])))]
6355   "TARGET_SSE2"
6356 {
6357   if (!ix86_vec_interleave_v2df_operator_ok (operands, 1))
6358     operands[2] = force_reg (V2DFmode, operands[2]);
6359 })
6360
6361 (define_insn "*vec_interleave_highv2df"
6362   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,m")
6363         (vec_select:V2DF
6364           (vec_concat:V4DF
6365             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,o,o,o,x")
6366             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,0,x,0"))
6367           (parallel [(const_int 1)
6368                      (const_int 3)])))]
6369   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 1)"
6370   "@
6371    unpckhpd\t{%2, %0|%0, %2}
6372    vunpckhpd\t{%2, %1, %0|%0, %1, %2}
6373    %vmovddup\t{%H1, %0|%0, %H1}
6374    movlpd\t{%H1, %0|%0, %H1}
6375    vmovlpd\t{%H1, %2, %0|%0, %2, %H1}
6376    %vmovhpd\t{%1, %0|%q0, %1}"
6377   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
6378    (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
6379    (set_attr "ssememalign" "64")
6380    (set_attr "prefix_data16" "*,*,*,1,*,1")
6381    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
6382    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
6383
6384 (define_expand "avx512f_movddup512<mask_name>"
6385   [(set (match_operand:V8DF 0 "register_operand")
6386         (vec_select:V8DF
6387           (vec_concat:V16DF
6388             (match_operand:V8DF 1 "nonimmediate_operand")
6389             (match_dup 1))
6390           (parallel [(const_int 0) (const_int 8)
6391                      (const_int 2) (const_int 10)
6392                      (const_int 4) (const_int 12)
6393                      (const_int 6) (const_int 14)])))]
6394   "TARGET_AVX512F")
6395
6396 (define_expand "avx512f_unpcklpd512<mask_name>"
6397   [(set (match_operand:V8DF 0 "register_operand")
6398         (vec_select:V8DF
6399           (vec_concat:V16DF
6400             (match_operand:V8DF 1 "register_operand")
6401             (match_operand:V8DF 2 "nonimmediate_operand"))
6402           (parallel [(const_int 0) (const_int 8)
6403                      (const_int 2) (const_int 10)
6404                      (const_int 4) (const_int 12)
6405                      (const_int 6) (const_int 14)])))]
6406   "TARGET_AVX512F")
6407
6408 (define_insn "*avx512f_unpcklpd512<mask_name>"
6409   [(set (match_operand:V8DF 0 "register_operand" "=v,v")
6410         (vec_select:V8DF
6411           (vec_concat:V16DF
6412             (match_operand:V8DF 1 "nonimmediate_operand" "vm, v")
6413             (match_operand:V8DF 2 "nonimmediate_operand" "1 ,vm"))
6414           (parallel [(const_int 0) (const_int 8)
6415                      (const_int 2) (const_int 10)
6416                      (const_int 4) (const_int 12)
6417                      (const_int 6) (const_int 14)])))]
6418   "TARGET_AVX512F"
6419   "@
6420    vmovddup\t{%1, %0<mask_operand3>|%0<mask_operand3>, %1}
6421    vunpcklpd\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
6422   [(set_attr "type" "sselog")
6423    (set_attr "prefix" "evex")
6424    (set_attr "mode" "V8DF")])
6425
6426 ;; Recall that the 256-bit unpck insns only shuffle within their lanes.
6427 (define_expand "avx_movddup256"
6428   [(set (match_operand:V4DF 0 "register_operand")
6429         (vec_select:V4DF
6430           (vec_concat:V8DF
6431             (match_operand:V4DF 1 "nonimmediate_operand")
6432             (match_dup 1))
6433           (parallel [(const_int 0) (const_int 4)
6434                      (const_int 2) (const_int 6)])))]
6435   "TARGET_AVX")
6436
6437 (define_expand "avx_unpcklpd256"
6438   [(set (match_operand:V4DF 0 "register_operand")
6439         (vec_select:V4DF
6440           (vec_concat:V8DF
6441             (match_operand:V4DF 1 "register_operand")
6442             (match_operand:V4DF 2 "nonimmediate_operand"))
6443           (parallel [(const_int 0) (const_int 4)
6444                      (const_int 2) (const_int 6)])))]
6445   "TARGET_AVX")
6446
6447 (define_insn "*avx_unpcklpd256"
6448   [(set (match_operand:V4DF 0 "register_operand"         "=x,x")
6449         (vec_select:V4DF
6450           (vec_concat:V8DF
6451             (match_operand:V4DF 1 "nonimmediate_operand" " x,m")
6452             (match_operand:V4DF 2 "nonimmediate_operand" "xm,1"))
6453           (parallel [(const_int 0) (const_int 4)
6454                      (const_int 2) (const_int 6)])))]
6455   "TARGET_AVX"
6456   "@
6457    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
6458    vmovddup\t{%1, %0|%0, %1}"
6459   [(set_attr "type" "sselog")
6460    (set_attr "prefix" "vex")
6461    (set_attr "mode" "V4DF")])
6462
6463 (define_expand "vec_interleave_lowv4df"
6464   [(set (match_dup 3)
6465         (vec_select:V4DF
6466           (vec_concat:V8DF
6467             (match_operand:V4DF 1 "register_operand" "x")
6468             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6469           (parallel [(const_int 0) (const_int 4)
6470                      (const_int 2) (const_int 6)])))
6471    (set (match_dup 4)
6472         (vec_select:V4DF
6473           (vec_concat:V8DF
6474             (match_dup 1)
6475             (match_dup 2))
6476           (parallel [(const_int 1) (const_int 5)
6477                      (const_int 3) (const_int 7)])))
6478    (set (match_operand:V4DF 0 "register_operand")
6479         (vec_select:V4DF
6480           (vec_concat:V8DF
6481             (match_dup 3)
6482             (match_dup 4))
6483           (parallel [(const_int 0) (const_int 1)
6484                      (const_int 4) (const_int 5)])))]
6485  "TARGET_AVX"
6486 {
6487   operands[3] = gen_reg_rtx (V4DFmode);
6488   operands[4] = gen_reg_rtx (V4DFmode);
6489 })
6490
6491 (define_expand "vec_interleave_lowv2df"
6492   [(set (match_operand:V2DF 0 "register_operand")
6493         (vec_select:V2DF
6494           (vec_concat:V4DF
6495             (match_operand:V2DF 1 "nonimmediate_operand")
6496             (match_operand:V2DF 2 "nonimmediate_operand"))
6497           (parallel [(const_int 0)
6498                      (const_int 2)])))]
6499   "TARGET_SSE2"
6500 {
6501   if (!ix86_vec_interleave_v2df_operator_ok (operands, 0))
6502     operands[1] = force_reg (V2DFmode, operands[1]);
6503 })
6504
6505 (define_insn "*vec_interleave_lowv2df"
6506   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,x,x,o")
6507         (vec_select:V2DF
6508           (vec_concat:V4DF
6509             (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,m,0,x,0")
6510             (match_operand:V2DF 2 "nonimmediate_operand" " x,x,1,m,m,x"))
6511           (parallel [(const_int 0)
6512                      (const_int 2)])))]
6513   "TARGET_SSE2 && ix86_vec_interleave_v2df_operator_ok (operands, 0)"
6514   "@
6515    unpcklpd\t{%2, %0|%0, %2}
6516    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
6517    %vmovddup\t{%1, %0|%0, %q1}
6518    movhpd\t{%2, %0|%0, %q2}
6519    vmovhpd\t{%2, %1, %0|%0, %1, %q2}
6520    %vmovlpd\t{%2, %H0|%H0, %2}"
6521   [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*")
6522    (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov")
6523    (set_attr "ssememalign" "64")
6524    (set_attr "prefix_data16" "*,*,*,1,*,1")
6525    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex")
6526    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,V1DF")])
6527
6528 (define_split
6529   [(set (match_operand:V2DF 0 "memory_operand")
6530         (vec_select:V2DF
6531           (vec_concat:V4DF
6532             (match_operand:V2DF 1 "register_operand")
6533             (match_dup 1))
6534           (parallel [(const_int 0)
6535                      (const_int 2)])))]
6536   "TARGET_SSE3 && reload_completed"
6537   [(const_int 0)]
6538 {
6539   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
6540   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
6541   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
6542   DONE;
6543 })
6544
6545 (define_split
6546   [(set (match_operand:V2DF 0 "register_operand")
6547         (vec_select:V2DF
6548           (vec_concat:V4DF
6549             (match_operand:V2DF 1 "memory_operand")
6550             (match_dup 1))
6551           (parallel [(match_operand:SI 2 "const_0_to_1_operand")
6552                      (match_operand:SI 3 "const_int_operand")])))]
6553   "TARGET_SSE3 && INTVAL (operands[2]) + 2 == INTVAL (operands[3])"
6554   [(set (match_dup 0) (vec_duplicate:V2DF (match_dup 1)))]
6555 {
6556   operands[1] = adjust_address (operands[1], DFmode, INTVAL (operands[2]) * 8);
6557 })
6558
6559 (define_insn "avx512f_vmscalef<mode><round_name>"
6560   [(set (match_operand:VF_128 0 "register_operand" "=v")
6561         (vec_merge:VF_128
6562           (unspec:VF_128
6563             [(match_operand:VF_128 1 "register_operand" "v")
6564              (match_operand:VF_128 2 "<round_nimm_predicate>" "<round_constraint>")]
6565             UNSPEC_SCALEF)
6566           (match_dup 1)
6567           (const_int 1)))]
6568   "TARGET_AVX512F"
6569   "vscalef<ssescalarmodesuffix>\t{<round_op3>%2, %1, %0|%0, %1, %2<round_op3>}"
6570   [(set_attr "prefix" "evex")
6571    (set_attr "mode"  "<ssescalarmode>")])
6572
6573 (define_insn "avx512f_scalef<mode><mask_name><round_name>"
6574   [(set (match_operand:VF_512 0 "register_operand" "=v")
6575         (unspec:VF_512
6576           [(match_operand:VF_512 1 "register_operand" "v")
6577            (match_operand:VF_512 2 "<round_nimm_predicate>" "<round_constraint>")]
6578           UNSPEC_SCALEF))]
6579   "TARGET_AVX512F"
6580   "vscalef<ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
6581   [(set_attr "prefix" "evex")
6582    (set_attr "mode"  "<MODE>")])
6583
6584 (define_expand "avx512f_vternlog<mode>_maskz"
6585   [(match_operand:VI48_512 0 "register_operand")
6586    (match_operand:VI48_512 1 "register_operand")
6587    (match_operand:VI48_512 2 "register_operand")
6588    (match_operand:VI48_512 3 "nonimmediate_operand")
6589    (match_operand:SI 4 "const_0_to_255_operand")
6590    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6591   "TARGET_AVX512F"
6592 {
6593   emit_insn (gen_avx512f_vternlog<mode>_maskz_1 (
6594     operands[0], operands[1], operands[2], operands[3],
6595     operands[4], CONST0_RTX (<MODE>mode), operands[5]));
6596   DONE;
6597 })
6598
6599 (define_insn "avx512f_vternlog<mode><sd_maskz_name>"
6600   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6601         (unspec:VI48_512
6602           [(match_operand:VI48_512 1 "register_operand" "0")
6603            (match_operand:VI48_512 2 "register_operand" "v")
6604            (match_operand:VI48_512 3 "nonimmediate_operand" "vm")
6605            (match_operand:SI 4 "const_0_to_255_operand")]
6606           UNSPEC_VTERNLOG))]
6607   "TARGET_AVX512F"
6608   "vpternlog<ssemodesuffix>\t{%4, %3, %2, %0<sd_mask_op5>|%0<sd_mask_op5>, %2, %3, %4}"
6609   [(set_attr "type" "sselog")
6610    (set_attr "prefix" "evex")
6611    (set_attr "mode" "<sseinsnmode>")])
6612
6613 (define_insn "avx512f_vternlog<mode>_mask"
6614   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6615         (vec_merge:VI48_512
6616           (unspec:VI48_512
6617             [(match_operand:VI48_512 1 "register_operand" "0")
6618              (match_operand:VI48_512 2 "register_operand" "v")
6619              (match_operand:VI48_512 3 "nonimmediate_operand" "vm")
6620              (match_operand:SI 4 "const_0_to_255_operand")]
6621             UNSPEC_VTERNLOG)
6622           (match_dup 1)
6623           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6624   "TARGET_AVX512F"
6625   "vpternlog<ssemodesuffix>\t{%4, %3, %2, %0%{%5%}|%0%{%5%}, %2, %3, %4}"
6626   [(set_attr "type" "sselog")
6627    (set_attr "prefix" "evex")
6628    (set_attr "mode" "<sseinsnmode>")])
6629
6630 (define_insn "avx512f_getexp<mode><mask_name><round_saeonly_name>"
6631   [(set (match_operand:VF_512 0 "register_operand" "=v")
6632         (unspec:VF_512 [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
6633                         UNSPEC_GETEXP))]
6634    "TARGET_AVX512F"
6635    "vgetexp<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}";
6636     [(set_attr "prefix" "evex")
6637      (set_attr "mode" "<MODE>")])
6638
6639 (define_insn "avx512f_sgetexp<mode><round_saeonly_name>"
6640   [(set (match_operand:VF_128 0 "register_operand" "=v")
6641         (vec_merge:VF_128
6642           (unspec:VF_128
6643             [(match_operand:VF_128 1 "register_operand" "v")
6644              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
6645             UNSPEC_GETEXP)
6646           (match_dup 1)
6647           (const_int 1)))]
6648    "TARGET_AVX512F"
6649    "vgetexp<ssescalarmodesuffix>\t{<round_saeonly_op3>%2, %1, %0|%0, %1, %2<round_saeonly_op3>}";
6650     [(set_attr "prefix" "evex")
6651      (set_attr "mode" "<ssescalarmode>")])
6652
6653 (define_insn "<mask_codefor>avx512f_align<mode><mask_name>"
6654   [(set (match_operand:VI48_512 0 "register_operand" "=v")
6655         (unspec:VI48_512 [(match_operand:VI48_512 1 "register_operand" "v")
6656                           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")
6657                           (match_operand:SI 3 "const_0_to_255_operand")]
6658                          UNSPEC_ALIGN))]
6659   "TARGET_AVX512F"
6660   "valign<ssemodesuffix>\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
6661   [(set_attr "prefix" "evex")
6662    (set_attr "mode" "<sseinsnmode>")])
6663
6664 (define_expand "avx512f_shufps512_mask"
6665   [(match_operand:V16SF 0 "register_operand")
6666    (match_operand:V16SF 1 "register_operand")
6667    (match_operand:V16SF 2 "nonimmediate_operand")
6668    (match_operand:SI 3 "const_0_to_255_operand")
6669    (match_operand:V16SF 4 "register_operand")
6670    (match_operand:HI 5 "register_operand")]
6671   "TARGET_AVX512F"
6672 {
6673   int mask = INTVAL (operands[3]);
6674   emit_insn (gen_avx512f_shufps512_1_mask (operands[0], operands[1], operands[2],
6675                                           GEN_INT ((mask >> 0) & 3),
6676                                           GEN_INT ((mask >> 2) & 3),
6677                                           GEN_INT (((mask >> 4) & 3) + 16),
6678                                           GEN_INT (((mask >> 6) & 3) + 16),
6679                                           GEN_INT (((mask >> 0) & 3) + 4),
6680                                           GEN_INT (((mask >> 2) & 3) + 4),
6681                                           GEN_INT (((mask >> 4) & 3) + 20),
6682                                           GEN_INT (((mask >> 6) & 3) + 20),
6683                                           GEN_INT (((mask >> 0) & 3) + 8),
6684                                           GEN_INT (((mask >> 2) & 3) + 8),
6685                                           GEN_INT (((mask >> 4) & 3) + 24),
6686                                           GEN_INT (((mask >> 6) & 3) + 24),
6687                                           GEN_INT (((mask >> 0) & 3) + 12),
6688                                           GEN_INT (((mask >> 2) & 3) + 12),
6689                                           GEN_INT (((mask >> 4) & 3) + 28),
6690                                           GEN_INT (((mask >> 6) & 3) + 28),
6691                                           operands[4], operands[5]));
6692   DONE;
6693 })
6694
6695
6696 (define_expand "avx512f_fixupimm<mode>_maskz<round_saeonly_expand_name>"
6697   [(match_operand:VF_512 0 "register_operand")
6698    (match_operand:VF_512 1 "register_operand")
6699    (match_operand:VF_512 2 "register_operand")
6700    (match_operand:<sseintvecmode> 3 "<round_saeonly_expand_nimm_predicate>")
6701    (match_operand:SI 4 "const_0_to_255_operand")
6702    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6703   "TARGET_AVX512F"
6704 {
6705   emit_insn (gen_avx512f_fixupimm<mode>_maskz_1<round_saeonly_expand_name> (
6706         operands[0], operands[1], operands[2], operands[3],
6707         operands[4], CONST0_RTX (<MODE>mode), operands[5]
6708         <round_saeonly_expand_operand6>));
6709   DONE;
6710 })
6711
6712 (define_insn "avx512f_fixupimm<mode><sd_maskz_name><round_saeonly_name>"
6713   [(set (match_operand:VF_512 0 "register_operand" "=v")
6714         (unspec:VF_512
6715           [(match_operand:VF_512 1 "register_operand" "0")
6716            (match_operand:VF_512 2 "register_operand" "v")
6717            (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6718            (match_operand:SI 4 "const_0_to_255_operand")]
6719            UNSPEC_FIXUPIMM))]
6720   "TARGET_AVX512F"
6721   "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}";
6722   [(set_attr "prefix" "evex")
6723    (set_attr "mode" "<MODE>")])
6724
6725 (define_insn "avx512f_fixupimm<mode>_mask<round_saeonly_name>"
6726   [(set (match_operand:VF_512 0 "register_operand" "=v")
6727         (vec_merge:VF_512
6728           (unspec:VF_512
6729             [(match_operand:VF_512 1 "register_operand" "0")
6730              (match_operand:VF_512 2 "register_operand" "v")
6731              (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6732              (match_operand:SI 4 "const_0_to_255_operand")]
6733              UNSPEC_FIXUPIMM)
6734           (match_dup 1)
6735           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6736   "TARGET_AVX512F"
6737   "vfixupimm<ssemodesuffix>\t{%4, <round_saeonly_op6>%3, %2, %0%{%5%}|%0%{%5%}, %2, %3<round_saeonly_op6>, %4}";
6738   [(set_attr "prefix" "evex")
6739    (set_attr "mode" "<MODE>")])
6740
6741 (define_expand "avx512f_sfixupimm<mode>_maskz<round_saeonly_expand_name>"
6742   [(match_operand:VF_128 0 "register_operand")
6743    (match_operand:VF_128 1 "register_operand")
6744    (match_operand:VF_128 2 "register_operand")
6745    (match_operand:<sseintvecmode> 3 "<round_saeonly_expand_nimm_predicate>")
6746    (match_operand:SI 4 "const_0_to_255_operand")
6747    (match_operand:<avx512fmaskmode> 5 "register_operand")]
6748   "TARGET_AVX512F"
6749 {
6750   emit_insn (gen_avx512f_sfixupimm<mode>_maskz_1<round_saeonly_expand_name> (
6751         operands[0], operands[1], operands[2], operands[3],
6752         operands[4], CONST0_RTX (<MODE>mode), operands[5]
6753         <round_saeonly_expand_operand6>));
6754   DONE;
6755 })
6756
6757 (define_insn "avx512f_sfixupimm<mode><sd_maskz_name><round_saeonly_name>"
6758   [(set (match_operand:VF_128 0 "register_operand" "=v")
6759         (vec_merge:VF_128
6760           (unspec:VF_128
6761             [(match_operand:VF_128 1 "register_operand" "0")
6762              (match_operand:VF_128 2 "register_operand" "v")
6763              (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6764              (match_operand:SI 4 "const_0_to_255_operand")]
6765             UNSPEC_FIXUPIMM)
6766           (match_dup 1)
6767           (const_int 1)))]
6768    "TARGET_AVX512F"
6769    "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}";
6770    [(set_attr "prefix" "evex")
6771    (set_attr "mode" "<ssescalarmode>")])
6772
6773 (define_insn "avx512f_sfixupimm<mode>_mask<round_saeonly_name>"
6774   [(set (match_operand:VF_128 0 "register_operand" "=v")
6775         (vec_merge:VF_128
6776           (vec_merge:VF_128
6777             (unspec:VF_128
6778                [(match_operand:VF_128 1 "register_operand" "0")
6779                 (match_operand:VF_128 2 "register_operand" "v")
6780                 (match_operand:<sseintvecmode> 3 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6781                 (match_operand:SI 4 "const_0_to_255_operand")]
6782                UNSPEC_FIXUPIMM)
6783             (match_dup 1)
6784             (const_int 1))
6785           (match_dup 1)
6786           (match_operand:<avx512fmaskmode> 5 "register_operand" "Yk")))]
6787   "TARGET_AVX512F"
6788   "vfixupimm<ssescalarmodesuffix>\t{%4, <round_saeonly_op6>%3, %2, %0%{%5%}|%0%{%5%}, %2, %3<round_saeonly_op6>, %4}";
6789   [(set_attr "prefix" "evex")
6790    (set_attr "mode" "<ssescalarmode>")])
6791
6792 (define_insn "avx512f_rndscale<mode><mask_name><round_saeonly_name>"
6793   [(set (match_operand:VF_512 0 "register_operand" "=v")
6794         (unspec:VF_512
6795           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6796            (match_operand:SI 2 "const_0_to_255_operand")]
6797           UNSPEC_ROUND))]
6798   "TARGET_AVX512F"
6799   "vrndscale<ssemodesuffix>\t{%2, <round_saeonly_mask_op3>%1, %0<mask_operand3>|%0<mask_operand3>, %1<round_saeonly_mask_op3>, %2}"
6800   [(set_attr "length_immediate" "1")
6801    (set_attr "prefix" "evex")
6802    (set_attr "mode" "<MODE>")])
6803
6804 (define_insn "avx512f_rndscale<mode><round_saeonly_name>"
6805   [(set (match_operand:VF_128 0 "register_operand" "=v")
6806         (vec_merge:VF_128
6807           (unspec:VF_128
6808             [(match_operand:VF_128 1 "register_operand" "v")
6809              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
6810              (match_operand:SI 3 "const_0_to_255_operand")]
6811             UNSPEC_ROUND)
6812           (match_dup 1)
6813           (const_int 1)))]
6814   "TARGET_AVX512F"
6815   "vrndscale<ssescalarmodesuffix>\t{%3, <round_saeonly_op4>%2, %1, %0|%0, %1, %2<round_saeonly_op4>, %3}"
6816   [(set_attr "length_immediate" "1")
6817    (set_attr "prefix" "evex")
6818    (set_attr "mode" "<MODE>")])
6819
6820 ;; One bit in mask selects 2 elements.
6821 (define_insn "avx512f_shufps512_1<mask_name>"
6822   [(set (match_operand:V16SF 0 "register_operand" "=v")
6823         (vec_select:V16SF
6824           (vec_concat:V32SF
6825             (match_operand:V16SF 1 "register_operand" "v")
6826             (match_operand:V16SF 2 "nonimmediate_operand" "vm"))
6827           (parallel [(match_operand 3  "const_0_to_3_operand")
6828                      (match_operand 4  "const_0_to_3_operand")
6829                      (match_operand 5  "const_16_to_19_operand")
6830                      (match_operand 6  "const_16_to_19_operand")
6831                      (match_operand 7  "const_4_to_7_operand")
6832                      (match_operand 8  "const_4_to_7_operand")
6833                      (match_operand 9  "const_20_to_23_operand")
6834                      (match_operand 10  "const_20_to_23_operand")
6835                      (match_operand 11  "const_8_to_11_operand")
6836                      (match_operand 12  "const_8_to_11_operand")
6837                      (match_operand 13  "const_24_to_27_operand")
6838                      (match_operand 14  "const_24_to_27_operand")
6839                      (match_operand 15  "const_12_to_15_operand")
6840                      (match_operand 16  "const_12_to_15_operand")
6841                      (match_operand 17  "const_28_to_31_operand")
6842                      (match_operand 18  "const_28_to_31_operand")])))]
6843   "TARGET_AVX512F
6844    && (INTVAL (operands[3]) == (INTVAL (operands[7]) - 4)
6845        && INTVAL (operands[4]) == (INTVAL (operands[8]) - 4)
6846        && INTVAL (operands[5]) == (INTVAL (operands[9]) - 4)
6847        && INTVAL (operands[6]) == (INTVAL (operands[10]) - 4)
6848        && INTVAL (operands[3]) == (INTVAL (operands[11]) - 8)
6849        && INTVAL (operands[4]) == (INTVAL (operands[12]) - 8)
6850        && INTVAL (operands[5]) == (INTVAL (operands[13]) - 8)
6851        && INTVAL (operands[6]) == (INTVAL (operands[14]) - 8)
6852        && INTVAL (operands[3]) == (INTVAL (operands[15]) - 12)
6853        && INTVAL (operands[4]) == (INTVAL (operands[16]) - 12)
6854        && INTVAL (operands[5]) == (INTVAL (operands[17]) - 12)
6855        && INTVAL (operands[6]) == (INTVAL (operands[18]) - 12))"
6856 {
6857   int mask;
6858   mask = INTVAL (operands[3]);
6859   mask |= INTVAL (operands[4]) << 2;
6860   mask |= (INTVAL (operands[5]) - 16) << 4;
6861   mask |= (INTVAL (operands[6]) - 16) << 6;
6862   operands[3] = GEN_INT (mask);
6863
6864   return "vshufps\t{%3, %2, %1, %0<mask_operand19>|%0<mask_operand19>, %1, %2, %3}";
6865 }
6866   [(set_attr "type" "sselog")
6867    (set_attr "length_immediate" "1")
6868    (set_attr "prefix" "evex")
6869    (set_attr "mode" "V16SF")])
6870
6871 (define_expand "avx512f_shufpd512_mask"
6872   [(match_operand:V8DF 0 "register_operand")
6873    (match_operand:V8DF 1 "register_operand")
6874    (match_operand:V8DF 2 "nonimmediate_operand")
6875    (match_operand:SI 3 "const_0_to_255_operand")
6876    (match_operand:V8DF 4 "register_operand")
6877    (match_operand:QI 5 "register_operand")]
6878   "TARGET_AVX512F"
6879 {
6880   int mask = INTVAL (operands[3]);
6881   emit_insn (gen_avx512f_shufpd512_1_mask (operands[0], operands[1], operands[2],
6882                                         GEN_INT (mask & 1),
6883                                         GEN_INT (mask & 2 ? 9 : 8),
6884                                         GEN_INT (mask & 4 ? 3 : 2),
6885                                         GEN_INT (mask & 8 ? 11 : 10),
6886                                         GEN_INT (mask & 16 ? 5 : 4),
6887                                         GEN_INT (mask & 32 ? 13 : 12),
6888                                         GEN_INT (mask & 64 ? 7 : 6),
6889                                         GEN_INT (mask & 128 ? 15 : 14),
6890                                         operands[4], operands[5]));
6891   DONE;
6892 })
6893
6894 (define_insn "avx512f_shufpd512_1<mask_name>"
6895   [(set (match_operand:V8DF 0 "register_operand" "=v")
6896         (vec_select:V8DF
6897           (vec_concat:V16DF
6898             (match_operand:V8DF 1 "register_operand" "v")
6899             (match_operand:V8DF 2 "nonimmediate_operand" "vm"))
6900           (parallel [(match_operand 3 "const_0_to_1_operand")
6901                      (match_operand 4 "const_8_to_9_operand")
6902                      (match_operand 5 "const_2_to_3_operand")
6903                      (match_operand 6 "const_10_to_11_operand")
6904                      (match_operand 7 "const_4_to_5_operand")
6905                      (match_operand 8 "const_12_to_13_operand")
6906                      (match_operand 9 "const_6_to_7_operand")
6907                      (match_operand 10 "const_14_to_15_operand")])))]
6908   "TARGET_AVX512F"
6909 {
6910   int mask;
6911   mask = INTVAL (operands[3]);
6912   mask |= (INTVAL (operands[4]) - 8) << 1;
6913   mask |= (INTVAL (operands[5]) - 2) << 2;
6914   mask |= (INTVAL (operands[6]) - 10) << 3;
6915   mask |= (INTVAL (operands[7]) - 4) << 4;
6916   mask |= (INTVAL (operands[8]) - 12) << 5;
6917   mask |= (INTVAL (operands[9]) - 6) << 6;
6918   mask |= (INTVAL (operands[10]) - 14) << 7;
6919   operands[3] = GEN_INT (mask);
6920
6921   return "vshufpd\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
6922 }
6923   [(set_attr "type" "sselog")
6924    (set_attr "length_immediate" "1")
6925    (set_attr "prefix" "evex")
6926    (set_attr "mode" "V8DF")])
6927
6928 (define_expand "avx_shufpd256"
6929   [(match_operand:V4DF 0 "register_operand")
6930    (match_operand:V4DF 1 "register_operand")
6931    (match_operand:V4DF 2 "nonimmediate_operand")
6932    (match_operand:SI 3 "const_int_operand")]
6933   "TARGET_AVX"
6934 {
6935   int mask = INTVAL (operands[3]);
6936   emit_insn (gen_avx_shufpd256_1 (operands[0], operands[1], operands[2],
6937                                    GEN_INT (mask & 1),
6938                                    GEN_INT (mask & 2 ? 5 : 4),
6939                                    GEN_INT (mask & 4 ? 3 : 2),
6940                                    GEN_INT (mask & 8 ? 7 : 6)));
6941   DONE;
6942 })
6943
6944 (define_insn "avx_shufpd256_1"
6945   [(set (match_operand:V4DF 0 "register_operand" "=x")
6946         (vec_select:V4DF
6947           (vec_concat:V8DF
6948             (match_operand:V4DF 1 "register_operand" "x")
6949             (match_operand:V4DF 2 "nonimmediate_operand" "xm"))
6950           (parallel [(match_operand 3 "const_0_to_1_operand")
6951                      (match_operand 4 "const_4_to_5_operand")
6952                      (match_operand 5 "const_2_to_3_operand")
6953                      (match_operand 6 "const_6_to_7_operand")])))]
6954   "TARGET_AVX"
6955 {
6956   int mask;
6957   mask = INTVAL (operands[3]);
6958   mask |= (INTVAL (operands[4]) - 4) << 1;
6959   mask |= (INTVAL (operands[5]) - 2) << 2;
6960   mask |= (INTVAL (operands[6]) - 6) << 3;
6961   operands[3] = GEN_INT (mask);
6962
6963   return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
6964 }
6965   [(set_attr "type" "sseshuf")
6966    (set_attr "length_immediate" "1")
6967    (set_attr "prefix" "vex")
6968    (set_attr "mode" "V4DF")])
6969
6970 (define_expand "sse2_shufpd"
6971   [(match_operand:V2DF 0 "register_operand")
6972    (match_operand:V2DF 1 "register_operand")
6973    (match_operand:V2DF 2 "nonimmediate_operand")
6974    (match_operand:SI 3 "const_int_operand")]
6975   "TARGET_SSE2"
6976 {
6977   int mask = INTVAL (operands[3]);
6978   emit_insn (gen_sse2_shufpd_v2df (operands[0], operands[1], operands[2],
6979                                 GEN_INT (mask & 1),
6980                                 GEN_INT (mask & 2 ? 3 : 2)));
6981   DONE;
6982 })
6983
6984 ;; punpcklqdq and punpckhqdq are shorter than shufpd.
6985 (define_insn "avx2_interleave_highv4di"
6986   [(set (match_operand:V4DI 0 "register_operand" "=x")
6987         (vec_select:V4DI
6988           (vec_concat:V8DI
6989             (match_operand:V4DI 1 "register_operand" "x")
6990             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
6991           (parallel [(const_int 1)
6992                      (const_int 5)
6993                      (const_int 3)
6994                      (const_int 7)])))]
6995   "TARGET_AVX2"
6996   "vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
6997   [(set_attr "type" "sselog")
6998    (set_attr "prefix" "vex")
6999    (set_attr "mode" "OI")])
7000
7001 (define_insn "<mask_codefor>avx512f_interleave_highv8di<mask_name>"
7002   [(set (match_operand:V8DI 0 "register_operand" "=v")
7003         (vec_select:V8DI
7004           (vec_concat:V16DI
7005             (match_operand:V8DI 1 "register_operand" "v")
7006             (match_operand:V8DI 2 "nonimmediate_operand" "vm"))
7007           (parallel [(const_int 1) (const_int 9)
7008                      (const_int 3) (const_int 11)
7009                      (const_int 5) (const_int 13)
7010                      (const_int 7) (const_int 15)])))]
7011   "TARGET_AVX512F"
7012   "vpunpckhqdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7013   [(set_attr "type" "sselog")
7014    (set_attr "prefix" "evex")
7015    (set_attr "mode" "XI")])
7016
7017 (define_insn "vec_interleave_highv2di"
7018   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7019         (vec_select:V2DI
7020           (vec_concat:V4DI
7021             (match_operand:V2DI 1 "register_operand" "0,x")
7022             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
7023           (parallel [(const_int 1)
7024                      (const_int 3)])))]
7025   "TARGET_SSE2"
7026   "@
7027    punpckhqdq\t{%2, %0|%0, %2}
7028    vpunpckhqdq\t{%2, %1, %0|%0, %1, %2}"
7029   [(set_attr "isa" "noavx,avx")
7030    (set_attr "type" "sselog")
7031    (set_attr "prefix_data16" "1,*")
7032    (set_attr "prefix" "orig,vex")
7033    (set_attr "mode" "TI")])
7034
7035 (define_insn "avx2_interleave_lowv4di"
7036   [(set (match_operand:V4DI 0 "register_operand" "=x")
7037         (vec_select:V4DI
7038           (vec_concat:V8DI
7039             (match_operand:V4DI 1 "register_operand" "x")
7040             (match_operand:V4DI 2 "nonimmediate_operand" "xm"))
7041           (parallel [(const_int 0)
7042                      (const_int 4)
7043                      (const_int 2)
7044                      (const_int 6)])))]
7045   "TARGET_AVX2"
7046   "vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
7047   [(set_attr "type" "sselog")
7048    (set_attr "prefix" "vex")
7049    (set_attr "mode" "OI")])
7050
7051 (define_insn "<mask_codefor>avx512f_interleave_lowv8di<mask_name>"
7052   [(set (match_operand:V8DI 0 "register_operand" "=v")
7053         (vec_select:V8DI
7054           (vec_concat:V16DI
7055             (match_operand:V8DI 1 "register_operand" "v")
7056             (match_operand:V8DI 2 "nonimmediate_operand" "vm"))
7057           (parallel [(const_int 0) (const_int 8)
7058                      (const_int 2) (const_int 10)
7059                      (const_int 4) (const_int 12)
7060                      (const_int 6) (const_int 14)])))]
7061   "TARGET_AVX512F"
7062   "vpunpcklqdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7063   [(set_attr "type" "sselog")
7064    (set_attr "prefix" "evex")
7065    (set_attr "mode" "XI")])
7066
7067 (define_insn "vec_interleave_lowv2di"
7068   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7069         (vec_select:V2DI
7070           (vec_concat:V4DI
7071             (match_operand:V2DI 1 "register_operand" "0,x")
7072             (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm"))
7073           (parallel [(const_int 0)
7074                      (const_int 2)])))]
7075   "TARGET_SSE2"
7076   "@
7077    punpcklqdq\t{%2, %0|%0, %2}
7078    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}"
7079   [(set_attr "isa" "noavx,avx")
7080    (set_attr "type" "sselog")
7081    (set_attr "prefix_data16" "1,*")
7082    (set_attr "prefix" "orig,vex")
7083    (set_attr "mode" "TI")])
7084
7085 (define_insn "sse2_shufpd_<mode>"
7086   [(set (match_operand:VI8F_128 0 "register_operand" "=x,x")
7087         (vec_select:VI8F_128
7088           (vec_concat:<ssedoublevecmode>
7089             (match_operand:VI8F_128 1 "register_operand" "0,x")
7090             (match_operand:VI8F_128 2 "nonimmediate_operand" "xm,xm"))
7091           (parallel [(match_operand 3 "const_0_to_1_operand")
7092                      (match_operand 4 "const_2_to_3_operand")])))]
7093   "TARGET_SSE2"
7094 {
7095   int mask;
7096   mask = INTVAL (operands[3]);
7097   mask |= (INTVAL (operands[4]) - 2) << 1;
7098   operands[3] = GEN_INT (mask);
7099
7100   switch (which_alternative)
7101     {
7102     case 0:
7103       return "shufpd\t{%3, %2, %0|%0, %2, %3}";
7104     case 1:
7105       return "vshufpd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
7106     default:
7107       gcc_unreachable ();
7108     }
7109 }
7110   [(set_attr "isa" "noavx,avx")
7111    (set_attr "type" "sseshuf")
7112    (set_attr "length_immediate" "1")
7113    (set_attr "prefix" "orig,vex")
7114    (set_attr "mode" "V2DF")])
7115
7116 ;; Avoid combining registers from different units in a single alternative,
7117 ;; see comment above inline_secondary_memory_needed function in i386.c
7118 (define_insn "sse2_storehpd"
7119   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,x,*f,r")
7120         (vec_select:DF
7121           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,x,o,o,o")
7122           (parallel [(const_int 1)])))]
7123   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7124   "@
7125    %vmovhpd\t{%1, %0|%0, %1}
7126    unpckhpd\t%0, %0
7127    vunpckhpd\t{%d1, %0|%0, %d1}
7128    #
7129    #
7130    #"
7131   [(set_attr "isa" "*,noavx,avx,*,*,*")
7132    (set_attr "type" "ssemov,sselog1,sselog1,ssemov,fmov,imov")
7133    (set (attr "prefix_data16")
7134      (if_then_else
7135        (and (eq_attr "alternative" "0")
7136             (not (match_test "TARGET_AVX")))
7137        (const_string "1")
7138        (const_string "*")))
7139    (set_attr "prefix" "maybe_vex,orig,vex,*,*,*")
7140    (set_attr "mode" "V1DF,V1DF,V2DF,DF,DF,DF")])
7141
7142 (define_split
7143   [(set (match_operand:DF 0 "register_operand")
7144         (vec_select:DF
7145           (match_operand:V2DF 1 "memory_operand")
7146           (parallel [(const_int 1)])))]
7147   "TARGET_SSE2 && reload_completed"
7148   [(set (match_dup 0) (match_dup 1))]
7149   "operands[1] = adjust_address (operands[1], DFmode, 8);")
7150
7151 (define_insn "*vec_extractv2df_1_sse"
7152   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
7153         (vec_select:DF
7154           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
7155           (parallel [(const_int 1)])))]
7156   "!TARGET_SSE2 && TARGET_SSE
7157    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7158   "@
7159    movhps\t{%1, %0|%q0, %1}
7160    movhlps\t{%1, %0|%0, %1}
7161    movlps\t{%H1, %0|%0, %H1}"
7162   [(set_attr "type" "ssemov")
7163    (set_attr "ssememalign" "64")
7164    (set_attr "mode" "V2SF,V4SF,V2SF")])
7165
7166 ;; Avoid combining registers from different units in a single alternative,
7167 ;; see comment above inline_secondary_memory_needed function in i386.c
7168 (define_insn "sse2_storelpd"
7169   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x,*f,r")
7170         (vec_select:DF
7171           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m,m,m")
7172           (parallel [(const_int 0)])))]
7173   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7174   "@
7175    %vmovlpd\t{%1, %0|%0, %1}
7176    #
7177    #
7178    #
7179    #"
7180   [(set_attr "type" "ssemov,ssemov,ssemov,fmov,imov")
7181    (set_attr "prefix_data16" "1,*,*,*,*")
7182    (set_attr "prefix" "maybe_vex")
7183    (set_attr "mode" "V1DF,DF,DF,DF,DF")])
7184
7185 (define_split
7186   [(set (match_operand:DF 0 "register_operand")
7187         (vec_select:DF
7188           (match_operand:V2DF 1 "nonimmediate_operand")
7189           (parallel [(const_int 0)])))]
7190   "TARGET_SSE2 && reload_completed"
7191   [(set (match_dup 0) (match_dup 1))]
7192 {
7193   if (REG_P (operands[1]))
7194     operands[1] = gen_rtx_REG (DFmode, REGNO (operands[1]));
7195   else
7196     operands[1] = adjust_address (operands[1], DFmode, 0);
7197 })
7198
7199 (define_insn "*vec_extractv2df_0_sse"
7200   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
7201         (vec_select:DF
7202           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
7203           (parallel [(const_int 0)])))]
7204   "!TARGET_SSE2 && TARGET_SSE
7205    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
7206   "@
7207    movlps\t{%1, %0|%0, %1}
7208    movaps\t{%1, %0|%0, %1}
7209    movlps\t{%1, %0|%0, %q1}"
7210   [(set_attr "type" "ssemov")
7211    (set_attr "mode" "V2SF,V4SF,V2SF")])
7212
7213 (define_expand "sse2_loadhpd_exp"
7214   [(set (match_operand:V2DF 0 "nonimmediate_operand")
7215         (vec_concat:V2DF
7216           (vec_select:DF
7217             (match_operand:V2DF 1 "nonimmediate_operand")
7218             (parallel [(const_int 0)]))
7219           (match_operand:DF 2 "nonimmediate_operand")))]
7220   "TARGET_SSE2"
7221 {
7222   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
7223
7224   emit_insn (gen_sse2_loadhpd (dst, operands[1], operands[2]));
7225
7226   /* Fix up the destination if needed.  */
7227   if (dst != operands[0])
7228     emit_move_insn (operands[0], dst);
7229
7230   DONE;
7231 })
7232
7233 ;; Avoid combining registers from different units in a single alternative,
7234 ;; see comment above inline_secondary_memory_needed function in i386.c
7235 (define_insn "sse2_loadhpd"
7236   [(set (match_operand:V2DF 0 "nonimmediate_operand"
7237           "=x,x,x,x,o,o ,o")
7238         (vec_concat:V2DF
7239           (vec_select:DF
7240             (match_operand:V2DF 1 "nonimmediate_operand"
7241           " 0,x,0,x,0,0 ,0")
7242             (parallel [(const_int 0)]))
7243           (match_operand:DF 2 "nonimmediate_operand"
7244           " m,m,x,x,x,*f,r")))]
7245   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
7246   "@
7247    movhpd\t{%2, %0|%0, %2}
7248    vmovhpd\t{%2, %1, %0|%0, %1, %2}
7249    unpcklpd\t{%2, %0|%0, %2}
7250    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
7251    #
7252    #
7253    #"
7254   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
7255    (set_attr "type" "ssemov,ssemov,sselog,sselog,ssemov,fmov,imov")
7256    (set_attr "ssememalign" "64")
7257    (set_attr "prefix_data16" "1,*,*,*,*,*,*")
7258    (set_attr "prefix" "orig,vex,orig,vex,*,*,*")
7259    (set_attr "mode" "V1DF,V1DF,V2DF,V2DF,DF,DF,DF")])
7260
7261 (define_split
7262   [(set (match_operand:V2DF 0 "memory_operand")
7263         (vec_concat:V2DF
7264           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
7265           (match_operand:DF 1 "register_operand")))]
7266   "TARGET_SSE2 && reload_completed"
7267   [(set (match_dup 0) (match_dup 1))]
7268   "operands[0] = adjust_address (operands[0], DFmode, 8);")
7269
7270 (define_expand "sse2_loadlpd_exp"
7271   [(set (match_operand:V2DF 0 "nonimmediate_operand")
7272         (vec_concat:V2DF
7273           (match_operand:DF 2 "nonimmediate_operand")
7274           (vec_select:DF
7275             (match_operand:V2DF 1 "nonimmediate_operand")
7276             (parallel [(const_int 1)]))))]
7277   "TARGET_SSE2"
7278 {
7279   rtx dst = ix86_fixup_binary_operands (UNKNOWN, V2DFmode, operands);
7280
7281   emit_insn (gen_sse2_loadlpd (dst, operands[1], operands[2]));
7282
7283   /* Fix up the destination if needed.  */
7284   if (dst != operands[0])
7285     emit_move_insn (operands[0], dst);
7286
7287   DONE;
7288 })
7289
7290 ;; Avoid combining registers from different units in a single alternative,
7291 ;; see comment above inline_secondary_memory_needed function in i386.c
7292 (define_insn "sse2_loadlpd"
7293   [(set (match_operand:V2DF 0 "nonimmediate_operand"
7294           "=x,x,x,x,x,x,x,x,m,m ,m")
7295         (vec_concat:V2DF
7296           (match_operand:DF 2 "nonimmediate_operand"
7297           " m,m,m,x,x,0,0,x,x,*f,r")
7298           (vec_select:DF
7299             (match_operand:V2DF 1 "vector_move_operand"
7300           " C,0,x,0,x,x,o,o,0,0 ,0")
7301             (parallel [(const_int 1)]))))]
7302   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
7303   "@
7304    %vmovsd\t{%2, %0|%0, %2}
7305    movlpd\t{%2, %0|%0, %2}
7306    vmovlpd\t{%2, %1, %0|%0, %1, %2}
7307    movsd\t{%2, %0|%0, %2}
7308    vmovsd\t{%2, %1, %0|%0, %1, %2}
7309    shufpd\t{$2, %1, %0|%0, %1, 2}
7310    movhpd\t{%H1, %0|%0, %H1}
7311    vmovhpd\t{%H1, %2, %0|%0, %2, %H1}
7312    #
7313    #
7314    #"
7315   [(set_attr "isa" "*,noavx,avx,noavx,avx,noavx,noavx,avx,*,*,*")
7316    (set (attr "type")
7317      (cond [(eq_attr "alternative" "5")
7318               (const_string "sselog")
7319             (eq_attr "alternative" "9")
7320               (const_string "fmov")
7321             (eq_attr "alternative" "10")
7322               (const_string "imov")
7323            ]
7324            (const_string "ssemov")))
7325    (set_attr "ssememalign" "64")
7326    (set_attr "prefix_data16" "*,1,*,*,*,*,1,*,*,*,*")
7327    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*,*,*")
7328    (set_attr "prefix" "maybe_vex,orig,vex,orig,vex,orig,orig,vex,*,*,*")
7329    (set_attr "mode" "DF,V1DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,DF,DF,DF")])
7330
7331 (define_split
7332   [(set (match_operand:V2DF 0 "memory_operand")
7333         (vec_concat:V2DF
7334           (match_operand:DF 1 "register_operand")
7335           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
7336   "TARGET_SSE2 && reload_completed"
7337   [(set (match_dup 0) (match_dup 1))]
7338   "operands[0] = adjust_address (operands[0], DFmode, 0);")
7339
7340 (define_insn "sse2_movsd"
7341   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,x,x,m,x,x,x,o")
7342         (vec_merge:V2DF
7343           (match_operand:V2DF 2 "nonimmediate_operand" " x,x,m,m,x,0,0,x,0")
7344           (match_operand:V2DF 1 "nonimmediate_operand" " 0,x,0,x,0,x,o,o,x")
7345           (const_int 1)))]
7346   "TARGET_SSE2"
7347   "@
7348    movsd\t{%2, %0|%0, %2}
7349    vmovsd\t{%2, %1, %0|%0, %1, %2}
7350    movlpd\t{%2, %0|%0, %q2}
7351    vmovlpd\t{%2, %1, %0|%0, %1, %q2}
7352    %vmovlpd\t{%2, %0|%q0, %2}
7353    shufpd\t{$2, %1, %0|%0, %1, 2}
7354    movhps\t{%H1, %0|%0, %H1}
7355    vmovhps\t{%H1, %2, %0|%0, %2, %H1}
7356    %vmovhps\t{%1, %H0|%H0, %1}"
7357   [(set_attr "isa" "noavx,avx,noavx,avx,*,noavx,noavx,avx,*")
7358    (set (attr "type")
7359      (if_then_else
7360        (eq_attr "alternative" "5")
7361        (const_string "sselog")
7362        (const_string "ssemov")))
7363    (set (attr "prefix_data16")
7364      (if_then_else
7365        (and (eq_attr "alternative" "2,4")
7366             (not (match_test "TARGET_AVX")))
7367        (const_string "1")
7368        (const_string "*")))
7369    (set_attr "length_immediate" "*,*,*,*,*,1,*,*,*")
7370    (set_attr "ssememalign" "64")
7371    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig,vex,maybe_vex")
7372    (set_attr "mode" "DF,DF,V1DF,V1DF,V1DF,V2DF,V1DF,V1DF,V1DF")])
7373
7374 (define_insn "vec_dupv2df"
7375   [(set (match_operand:V2DF 0 "register_operand"     "=x,x")
7376         (vec_duplicate:V2DF
7377           (match_operand:DF 1 "nonimmediate_operand" " 0,xm")))]
7378   "TARGET_SSE2"
7379   "@
7380    unpcklpd\t%0, %0
7381    %vmovddup\t{%1, %0|%0, %1}"
7382   [(set_attr "isa" "noavx,sse3")
7383    (set_attr "type" "sselog1")
7384    (set_attr "prefix" "orig,maybe_vex")
7385    (set_attr "mode" "V2DF,DF")])
7386
7387 (define_insn "*vec_concatv2df"
7388   [(set (match_operand:V2DF 0 "register_operand"     "=x,x,x,x,x,x,x,x")
7389         (vec_concat:V2DF
7390           (match_operand:DF 1 "nonimmediate_operand" " 0,x,m,0,x,m,0,0")
7391           (match_operand:DF 2 "vector_move_operand"  " x,x,1,m,m,C,x,m")))]
7392   "TARGET_SSE"
7393   "@
7394    unpcklpd\t{%2, %0|%0, %2}
7395    vunpcklpd\t{%2, %1, %0|%0, %1, %2}
7396    %vmovddup\t{%1, %0|%0, %1}
7397    movhpd\t{%2, %0|%0, %2}
7398    vmovhpd\t{%2, %1, %0|%0, %1, %2}
7399    %vmovsd\t{%1, %0|%0, %1}
7400    movlhps\t{%2, %0|%0, %2}
7401    movhps\t{%2, %0|%0, %2}"
7402   [(set_attr "isa" "sse2_noavx,avx,sse3,sse2_noavx,avx,sse2,noavx,noavx")
7403    (set (attr "type")
7404      (if_then_else
7405        (eq_attr "alternative" "0,1,2")
7406        (const_string "sselog")
7407        (const_string "ssemov")))
7408    (set_attr "prefix_data16" "*,*,*,1,*,*,*,*")
7409    (set_attr "prefix" "orig,vex,maybe_vex,orig,vex,maybe_vex,orig,orig")
7410    (set_attr "mode" "V2DF,V2DF,DF,V1DF,V1DF,DF,V4SF,V2SF")])
7411
7412 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7413 ;;
7414 ;; Parallel integer down-conversion operations
7415 ;;
7416 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7417
7418 (define_mode_iterator PMOV_DST_MODE [V16QI V16HI V8SI V8HI])
7419 (define_mode_attr pmov_src_mode
7420   [(V16QI "V16SI") (V16HI "V16SI") (V8SI "V8DI") (V8HI "V8DI")])
7421 (define_mode_attr pmov_src_lower
7422   [(V16QI "v16si") (V16HI "v16si") (V8SI "v8di") (V8HI "v8di")])
7423 (define_mode_attr pmov_suff
7424   [(V16QI "db") (V16HI "dw") (V8SI "qd") (V8HI "qw")])
7425
7426 (define_insn "*avx512f_<code><pmov_src_lower><mode>2"
7427   [(set (match_operand:PMOV_DST_MODE 0 "nonimmediate_operand" "=v,m")
7428         (any_truncate:PMOV_DST_MODE
7429           (match_operand:<pmov_src_mode> 1 "register_operand" "v,v")))]
7430   "TARGET_AVX512F"
7431   "vpmov<trunsuffix><pmov_suff>\t{%1, %0|%0, %1}"
7432   [(set_attr "type" "ssemov")
7433    (set_attr "memory" "none,store")
7434    (set_attr "prefix" "evex")
7435    (set_attr "mode" "<sseinsnmode>")])
7436
7437 (define_insn "avx512f_<code><pmov_src_lower><mode>2_mask"
7438   [(set (match_operand:PMOV_DST_MODE 0 "nonimmediate_operand" "=v,m")
7439     (vec_merge:PMOV_DST_MODE
7440       (any_truncate:PMOV_DST_MODE
7441         (match_operand:<pmov_src_mode> 1 "register_operand" "v,v"))
7442       (match_operand:PMOV_DST_MODE 2 "vector_move_operand" "0C,0")
7443       (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk,Yk")))]
7444   "TARGET_AVX512F"
7445   "vpmov<trunsuffix><pmov_suff>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
7446   [(set_attr "type" "ssemov")
7447    (set_attr "memory" "none,store")
7448    (set_attr "prefix" "evex")
7449    (set_attr "mode" "<sseinsnmode>")])
7450
7451 (define_expand "avx512f_<code><pmov_src_lower><mode>2_mask_store"
7452   [(set (match_operand:PMOV_DST_MODE 0 "memory_operand")
7453     (vec_merge:PMOV_DST_MODE
7454       (any_truncate:PMOV_DST_MODE
7455         (match_operand:<pmov_src_mode> 1 "register_operand"))
7456       (match_dup 0)
7457       (match_operand:<avx512fmaskmode> 2 "register_operand")))]
7458   "TARGET_AVX512F")
7459
7460 (define_insn "*avx512f_<code>v8div16qi2"
7461   [(set (match_operand:V16QI 0 "register_operand" "=v")
7462         (vec_concat:V16QI
7463           (any_truncate:V8QI
7464             (match_operand:V8DI 1 "register_operand" "v"))
7465           (const_vector:V8QI [(const_int 0) (const_int 0)
7466                               (const_int 0) (const_int 0)
7467                               (const_int 0) (const_int 0)
7468                               (const_int 0) (const_int 0)])))]
7469   "TARGET_AVX512F"
7470   "vpmov<trunsuffix>qb\t{%1, %0|%0, %1}"
7471   [(set_attr "type" "ssemov")
7472    (set_attr "prefix" "evex")
7473    (set_attr "mode" "TI")])
7474
7475 (define_insn "*avx512f_<code>v8div16qi2_store"
7476   [(set (match_operand:V16QI 0 "memory_operand" "=m")
7477         (vec_concat:V16QI
7478           (any_truncate:V8QI
7479             (match_operand:V8DI 1 "register_operand" "v"))
7480           (vec_select:V8QI
7481             (match_dup 0)
7482             (parallel [(const_int 8) (const_int 9)
7483                        (const_int 10) (const_int 11)
7484                        (const_int 12) (const_int 13)
7485                        (const_int 14) (const_int 15)]))))]
7486   "TARGET_AVX512F"
7487   "vpmov<trunsuffix>qb\t{%1, %0|%0, %1}"
7488   [(set_attr "type" "ssemov")
7489    (set_attr "memory" "store")
7490    (set_attr "prefix" "evex")
7491    (set_attr "mode" "TI")])
7492
7493 (define_insn "avx512f_<code>v8div16qi2_mask"
7494   [(set (match_operand:V16QI 0 "register_operand" "=v")
7495     (vec_concat:V16QI
7496       (vec_merge:V8QI
7497         (any_truncate:V8QI
7498           (match_operand:V8DI 1 "register_operand" "v"))
7499         (vec_select:V8QI
7500           (match_operand:V16QI 2 "vector_move_operand" "0C")
7501           (parallel [(const_int 0) (const_int 1)
7502                      (const_int 2) (const_int 3)
7503                      (const_int 4) (const_int 5)
7504                      (const_int 6) (const_int 7)]))
7505         (match_operand:QI 3 "register_operand" "Yk"))
7506       (const_vector:V8QI [(const_int 0) (const_int 0)
7507                           (const_int 0) (const_int 0)
7508                           (const_int 0) (const_int 0)
7509                           (const_int 0) (const_int 0)])))]
7510   "TARGET_AVX512F"
7511   "vpmov<trunsuffix>qb\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
7512   [(set_attr "type" "ssemov")
7513    (set_attr "prefix" "evex")
7514    (set_attr "mode" "TI")])
7515
7516 (define_insn "avx512f_<code>v8div16qi2_mask_store"
7517   [(set (match_operand:V16QI 0 "memory_operand" "=m")
7518     (vec_concat:V16QI
7519       (vec_merge:V8QI
7520         (any_truncate:V8QI
7521           (match_operand:V8DI 1 "register_operand" "v"))
7522         (vec_select:V8QI
7523           (match_dup 0)
7524           (parallel [(const_int 0) (const_int 1)
7525                      (const_int 2) (const_int 3)
7526                      (const_int 4) (const_int 5)
7527                      (const_int 6) (const_int 7)]))
7528         (match_operand:QI 2 "register_operand" "Yk"))
7529       (vec_select:V8QI
7530         (match_dup 0)
7531         (parallel [(const_int 8) (const_int 9)
7532                    (const_int 10) (const_int 11)
7533                    (const_int 12) (const_int 13)
7534                    (const_int 14) (const_int 15)]))))]
7535   "TARGET_AVX512F"
7536   "vpmov<trunsuffix>qb\t{%1, %0%{%2%}|%0%{%2%}, %1}"
7537   [(set_attr "type" "ssemov")
7538    (set_attr "memory" "store")
7539    (set_attr "prefix" "evex")
7540    (set_attr "mode" "TI")])
7541
7542 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7543 ;;
7544 ;; Parallel integral arithmetic
7545 ;;
7546 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7547
7548 (define_expand "neg<mode>2"
7549   [(set (match_operand:VI_AVX2 0 "register_operand")
7550         (minus:VI_AVX2
7551           (match_dup 2)
7552           (match_operand:VI_AVX2 1 "nonimmediate_operand")))]
7553   "TARGET_SSE2"
7554   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
7555
7556 (define_expand "<plusminus_insn><mode>3<mask_name>"
7557   [(set (match_operand:VI_AVX2 0 "register_operand")
7558         (plusminus:VI_AVX2
7559           (match_operand:VI_AVX2 1 "nonimmediate_operand")
7560           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
7561   "TARGET_SSE2 && <mask_mode512bit_condition>"
7562   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
7563
7564 (define_insn "*<plusminus_insn><mode>3<mask_name>"
7565   [(set (match_operand:VI_AVX2 0 "register_operand" "=x,v")
7566         (plusminus:VI_AVX2
7567           (match_operand:VI_AVX2 1 "nonimmediate_operand" "<comm>0,v")
7568           (match_operand:VI_AVX2 2 "nonimmediate_operand" "xm,vm")))]
7569   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands) && <mask_mode512bit_condition>"
7570   "@
7571    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
7572    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7573   [(set_attr "isa" "noavx,avx")
7574    (set_attr "type" "sseiadd")
7575    (set_attr "prefix_data16" "1,*")
7576    (set_attr "prefix" "<mask_prefix3>")
7577    (set_attr "mode" "<sseinsnmode>")])
7578
7579 (define_expand "<sse2_avx2>_<plusminus_insn><mode>3"
7580   [(set (match_operand:VI12_AVX2 0 "register_operand")
7581         (sat_plusminus:VI12_AVX2
7582           (match_operand:VI12_AVX2 1 "nonimmediate_operand")
7583           (match_operand:VI12_AVX2 2 "nonimmediate_operand")))]
7584   "TARGET_SSE2"
7585   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
7586
7587 (define_insn "*<sse2_avx2>_<plusminus_insn><mode>3"
7588   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,v")
7589         (sat_plusminus:VI12_AVX2
7590           (match_operand:VI12_AVX2 1 "nonimmediate_operand" "<comm>0,v")
7591           (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,vm")))]
7592   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
7593   "@
7594    p<plusminus_mnemonic><ssemodesuffix>\t{%2, %0|%0, %2}
7595    vp<plusminus_mnemonic><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
7596   [(set_attr "isa" "noavx,avx")
7597    (set_attr "type" "sseiadd")
7598    (set_attr "prefix_data16" "1,*")
7599    (set_attr "prefix" "orig,vex")
7600    (set_attr "mode" "TI")])
7601
7602 (define_expand "mul<mode>3"
7603   [(set (match_operand:VI1_AVX2 0 "register_operand")
7604         (mult:VI1_AVX2 (match_operand:VI1_AVX2 1 "register_operand")
7605                        (match_operand:VI1_AVX2 2 "register_operand")))]
7606   "TARGET_SSE2"
7607 {
7608   ix86_expand_vecop_qihi (MULT, operands[0], operands[1], operands[2]);
7609   DONE;
7610 })
7611
7612 (define_expand "mul<mode>3"
7613   [(set (match_operand:VI2_AVX2 0 "register_operand")
7614         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand")
7615                        (match_operand:VI2_AVX2 2 "nonimmediate_operand")))]
7616   "TARGET_SSE2"
7617   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
7618
7619 (define_insn "*mul<mode>3"
7620   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
7621         (mult:VI2_AVX2 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x")
7622                        (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))]
7623   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
7624   "@
7625    pmullw\t{%2, %0|%0, %2}
7626    vpmullw\t{%2, %1, %0|%0, %1, %2}"
7627   [(set_attr "isa" "noavx,avx")
7628    (set_attr "type" "sseimul")
7629    (set_attr "prefix_data16" "1,*")
7630    (set_attr "prefix" "orig,vex")
7631    (set_attr "mode" "<sseinsnmode>")])
7632
7633 (define_expand "<s>mul<mode>3_highpart"
7634   [(set (match_operand:VI2_AVX2 0 "register_operand")
7635         (truncate:VI2_AVX2
7636           (lshiftrt:<ssedoublemode>
7637             (mult:<ssedoublemode>
7638               (any_extend:<ssedoublemode>
7639                 (match_operand:VI2_AVX2 1 "nonimmediate_operand"))
7640               (any_extend:<ssedoublemode>
7641                 (match_operand:VI2_AVX2 2 "nonimmediate_operand")))
7642             (const_int 16))))]
7643   "TARGET_SSE2"
7644   "ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);")
7645
7646 (define_insn "*<s>mul<mode>3_highpart"
7647   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
7648         (truncate:VI2_AVX2
7649           (lshiftrt:<ssedoublemode>
7650             (mult:<ssedoublemode>
7651               (any_extend:<ssedoublemode>
7652                 (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
7653               (any_extend:<ssedoublemode>
7654                 (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
7655             (const_int 16))))]
7656   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
7657   "@
7658    pmulh<u>w\t{%2, %0|%0, %2}
7659    vpmulh<u>w\t{%2, %1, %0|%0, %1, %2}"
7660   [(set_attr "isa" "noavx,avx")
7661    (set_attr "type" "sseimul")
7662    (set_attr "prefix_data16" "1,*")
7663    (set_attr "prefix" "orig,vex")
7664    (set_attr "mode" "<sseinsnmode>")])
7665
7666 (define_expand "vec_widen_umult_even_v16si<mask_name>"
7667   [(set (match_operand:V8DI 0 "register_operand")
7668         (mult:V8DI
7669           (zero_extend:V8DI
7670             (vec_select:V8SI
7671               (match_operand:V16SI 1 "nonimmediate_operand")
7672               (parallel [(const_int 0) (const_int 2)
7673                          (const_int 4) (const_int 6)
7674                          (const_int 8) (const_int 10)
7675                          (const_int 12) (const_int 14)])))
7676           (zero_extend:V8DI
7677             (vec_select:V8SI
7678               (match_operand:V16SI 2 "nonimmediate_operand")
7679               (parallel [(const_int 0) (const_int 2)
7680                          (const_int 4) (const_int 6)
7681                          (const_int 8) (const_int 10)
7682                          (const_int 12) (const_int 14)])))))]
7683   "TARGET_AVX512F"
7684   "ix86_fixup_binary_operands_no_copy (MULT, V16SImode, operands);")
7685
7686 (define_insn "*vec_widen_umult_even_v16si<mask_name>"
7687   [(set (match_operand:V8DI 0 "register_operand" "=v")
7688         (mult:V8DI
7689           (zero_extend:V8DI
7690             (vec_select:V8SI
7691               (match_operand:V16SI 1 "nonimmediate_operand" "%v")
7692               (parallel [(const_int 0) (const_int 2)
7693                          (const_int 4) (const_int 6)
7694                          (const_int 8) (const_int 10)
7695                          (const_int 12) (const_int 14)])))
7696           (zero_extend:V8DI
7697             (vec_select:V8SI
7698               (match_operand:V16SI 2 "nonimmediate_operand" "vm")
7699               (parallel [(const_int 0) (const_int 2)
7700                          (const_int 4) (const_int 6)
7701                          (const_int 8) (const_int 10)
7702                          (const_int 12) (const_int 14)])))))]
7703   "TARGET_AVX512F && ix86_binary_operator_ok (MULT, V16SImode, operands)"
7704   "vpmuludq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7705   [(set_attr "isa" "avx512f")
7706    (set_attr "type" "sseimul")
7707    (set_attr "prefix_extra" "1")
7708    (set_attr "prefix" "evex")
7709    (set_attr "mode" "XI")])
7710
7711 (define_expand "vec_widen_umult_even_v8si"
7712   [(set (match_operand:V4DI 0 "register_operand")
7713         (mult:V4DI
7714           (zero_extend:V4DI
7715             (vec_select:V4SI
7716               (match_operand:V8SI 1 "nonimmediate_operand")
7717               (parallel [(const_int 0) (const_int 2)
7718                          (const_int 4) (const_int 6)])))
7719           (zero_extend:V4DI
7720             (vec_select:V4SI
7721               (match_operand:V8SI 2 "nonimmediate_operand")
7722               (parallel [(const_int 0) (const_int 2)
7723                          (const_int 4) (const_int 6)])))))]
7724   "TARGET_AVX2"
7725   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
7726
7727 (define_insn "*vec_widen_umult_even_v8si"
7728   [(set (match_operand:V4DI 0 "register_operand" "=x")
7729         (mult:V4DI
7730           (zero_extend:V4DI
7731             (vec_select:V4SI
7732               (match_operand:V8SI 1 "nonimmediate_operand" "%x")
7733               (parallel [(const_int 0) (const_int 2)
7734                          (const_int 4) (const_int 6)])))
7735           (zero_extend:V4DI
7736             (vec_select:V4SI
7737               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
7738               (parallel [(const_int 0) (const_int 2)
7739                          (const_int 4) (const_int 6)])))))]
7740   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
7741   "vpmuludq\t{%2, %1, %0|%0, %1, %2}"
7742   [(set_attr "type" "sseimul")
7743    (set_attr "prefix" "vex")
7744    (set_attr "mode" "OI")])
7745
7746 (define_expand "vec_widen_umult_even_v4si"
7747   [(set (match_operand:V2DI 0 "register_operand")
7748         (mult:V2DI
7749           (zero_extend:V2DI
7750             (vec_select:V2SI
7751               (match_operand:V4SI 1 "nonimmediate_operand")
7752               (parallel [(const_int 0) (const_int 2)])))
7753           (zero_extend:V2DI
7754             (vec_select:V2SI
7755               (match_operand:V4SI 2 "nonimmediate_operand")
7756               (parallel [(const_int 0) (const_int 2)])))))]
7757   "TARGET_SSE2"
7758   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
7759
7760 (define_insn "*vec_widen_umult_even_v4si"
7761   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7762         (mult:V2DI
7763           (zero_extend:V2DI
7764             (vec_select:V2SI
7765               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
7766               (parallel [(const_int 0) (const_int 2)])))
7767           (zero_extend:V2DI
7768             (vec_select:V2SI
7769               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
7770               (parallel [(const_int 0) (const_int 2)])))))]
7771   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
7772   "@
7773    pmuludq\t{%2, %0|%0, %2}
7774    vpmuludq\t{%2, %1, %0|%0, %1, %2}"
7775   [(set_attr "isa" "noavx,avx")
7776    (set_attr "type" "sseimul")
7777    (set_attr "prefix_data16" "1,*")
7778    (set_attr "prefix" "orig,vex")
7779    (set_attr "mode" "TI")])
7780
7781 (define_expand "vec_widen_smult_even_v16si<mask_name>"
7782   [(set (match_operand:V8DI 0 "register_operand")
7783         (mult:V8DI
7784           (sign_extend:V8DI
7785             (vec_select:V8SI
7786               (match_operand:V16SI 1 "nonimmediate_operand")
7787               (parallel [(const_int 0) (const_int 2)
7788                          (const_int 4) (const_int 6)
7789                          (const_int 8) (const_int 10)
7790                          (const_int 12) (const_int 14)])))
7791           (sign_extend:V8DI
7792             (vec_select:V8SI
7793               (match_operand:V16SI 2 "nonimmediate_operand")
7794               (parallel [(const_int 0) (const_int 2)
7795                          (const_int 4) (const_int 6)
7796                          (const_int 8) (const_int 10)
7797                          (const_int 12) (const_int 14)])))))]
7798   "TARGET_AVX512F"
7799   "ix86_fixup_binary_operands_no_copy (MULT, V16SImode, operands);")
7800
7801 (define_insn "*vec_widen_smult_even_v16si<mask_name>"
7802   [(set (match_operand:V8DI 0 "register_operand" "=v")
7803         (mult:V8DI
7804           (sign_extend:V8DI
7805             (vec_select:V8SI
7806               (match_operand:V16SI 1 "nonimmediate_operand" "%v")
7807               (parallel [(const_int 0) (const_int 2)
7808                          (const_int 4) (const_int 6)
7809                          (const_int 8) (const_int 10)
7810                          (const_int 12) (const_int 14)])))
7811           (sign_extend:V8DI
7812             (vec_select:V8SI
7813               (match_operand:V16SI 2 "nonimmediate_operand" "vm")
7814               (parallel [(const_int 0) (const_int 2)
7815                          (const_int 4) (const_int 6)
7816                          (const_int 8) (const_int 10)
7817                          (const_int 12) (const_int 14)])))))]
7818   "TARGET_AVX512F && ix86_binary_operator_ok (MULT, V16SImode, operands)"
7819   "vpmuldq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
7820   [(set_attr "isa" "avx512f")
7821    (set_attr "type" "sseimul")
7822    (set_attr "prefix_extra" "1")
7823    (set_attr "prefix" "evex")
7824    (set_attr "mode" "XI")])
7825
7826 (define_expand "vec_widen_smult_even_v8si"
7827   [(set (match_operand:V4DI 0 "register_operand")
7828         (mult:V4DI
7829           (sign_extend:V4DI
7830             (vec_select:V4SI
7831               (match_operand:V8SI 1 "nonimmediate_operand")
7832               (parallel [(const_int 0) (const_int 2)
7833                          (const_int 4) (const_int 6)])))
7834           (sign_extend:V4DI
7835             (vec_select:V4SI
7836               (match_operand:V8SI 2 "nonimmediate_operand")
7837               (parallel [(const_int 0) (const_int 2)
7838                          (const_int 4) (const_int 6)])))))]
7839   "TARGET_AVX2"
7840   "ix86_fixup_binary_operands_no_copy (MULT, V8SImode, operands);")
7841
7842 (define_insn "*vec_widen_smult_even_v8si"
7843   [(set (match_operand:V4DI 0 "register_operand" "=x")
7844         (mult:V4DI
7845           (sign_extend:V4DI
7846             (vec_select:V4SI
7847               (match_operand:V8SI 1 "nonimmediate_operand" "x")
7848               (parallel [(const_int 0) (const_int 2)
7849                          (const_int 4) (const_int 6)])))
7850           (sign_extend:V4DI
7851             (vec_select:V4SI
7852               (match_operand:V8SI 2 "nonimmediate_operand" "xm")
7853               (parallel [(const_int 0) (const_int 2)
7854                          (const_int 4) (const_int 6)])))))]
7855   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V8SImode, operands)"
7856   "vpmuldq\t{%2, %1, %0|%0, %1, %2}"
7857   [(set_attr "type" "sseimul")
7858    (set_attr "prefix_extra" "1")
7859    (set_attr "prefix" "vex")
7860    (set_attr "mode" "OI")])
7861
7862 (define_expand "sse4_1_mulv2siv2di3"
7863   [(set (match_operand:V2DI 0 "register_operand")
7864         (mult:V2DI
7865           (sign_extend:V2DI
7866             (vec_select:V2SI
7867               (match_operand:V4SI 1 "nonimmediate_operand")
7868               (parallel [(const_int 0) (const_int 2)])))
7869           (sign_extend:V2DI
7870             (vec_select:V2SI
7871               (match_operand:V4SI 2 "nonimmediate_operand")
7872               (parallel [(const_int 0) (const_int 2)])))))]
7873   "TARGET_SSE4_1"
7874   "ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);")
7875
7876 (define_insn "*sse4_1_mulv2siv2di3"
7877   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
7878         (mult:V2DI
7879           (sign_extend:V2DI
7880             (vec_select:V2SI
7881               (match_operand:V4SI 1 "nonimmediate_operand" "%0,x")
7882               (parallel [(const_int 0) (const_int 2)])))
7883           (sign_extend:V2DI
7884             (vec_select:V2SI
7885               (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
7886               (parallel [(const_int 0) (const_int 2)])))))]
7887   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
7888   "@
7889    pmuldq\t{%2, %0|%0, %2}
7890    vpmuldq\t{%2, %1, %0|%0, %1, %2}"
7891   [(set_attr "isa" "noavx,avx")
7892    (set_attr "type" "sseimul")
7893    (set_attr "prefix_data16" "1,*")
7894    (set_attr "prefix_extra" "1")
7895    (set_attr "prefix" "orig,vex")
7896    (set_attr "mode" "TI")])
7897
7898 (define_expand "avx2_pmaddwd"
7899   [(set (match_operand:V8SI 0 "register_operand")
7900         (plus:V8SI
7901           (mult:V8SI
7902             (sign_extend:V8SI
7903               (vec_select:V8HI
7904                 (match_operand:V16HI 1 "nonimmediate_operand")
7905                 (parallel [(const_int 0) (const_int 2)
7906                            (const_int 4) (const_int 6)
7907                            (const_int 8) (const_int 10)
7908                            (const_int 12) (const_int 14)])))
7909             (sign_extend:V8SI
7910               (vec_select:V8HI
7911                 (match_operand:V16HI 2 "nonimmediate_operand")
7912                 (parallel [(const_int 0) (const_int 2)
7913                            (const_int 4) (const_int 6)
7914                            (const_int 8) (const_int 10)
7915                            (const_int 12) (const_int 14)]))))
7916           (mult:V8SI
7917             (sign_extend:V8SI
7918               (vec_select:V8HI (match_dup 1)
7919                 (parallel [(const_int 1) (const_int 3)
7920                            (const_int 5) (const_int 7)
7921                            (const_int 9) (const_int 11)
7922                            (const_int 13) (const_int 15)])))
7923             (sign_extend:V8SI
7924               (vec_select:V8HI (match_dup 2)
7925                 (parallel [(const_int 1) (const_int 3)
7926                            (const_int 5) (const_int 7)
7927                            (const_int 9) (const_int 11)
7928                            (const_int 13) (const_int 15)]))))))]
7929   "TARGET_AVX2"
7930   "ix86_fixup_binary_operands_no_copy (MULT, V16HImode, operands);")
7931
7932 (define_insn "*avx2_pmaddwd"
7933   [(set (match_operand:V8SI 0 "register_operand" "=x")
7934         (plus:V8SI
7935           (mult:V8SI
7936             (sign_extend:V8SI
7937               (vec_select:V8HI
7938                 (match_operand:V16HI 1 "nonimmediate_operand" "%x")
7939                 (parallel [(const_int 0) (const_int 2)
7940                            (const_int 4) (const_int 6)
7941                            (const_int 8) (const_int 10)
7942                            (const_int 12) (const_int 14)])))
7943             (sign_extend:V8SI
7944               (vec_select:V8HI
7945                 (match_operand:V16HI 2 "nonimmediate_operand" "xm")
7946                 (parallel [(const_int 0) (const_int 2)
7947                            (const_int 4) (const_int 6)
7948                            (const_int 8) (const_int 10)
7949                            (const_int 12) (const_int 14)]))))
7950           (mult:V8SI
7951             (sign_extend:V8SI
7952               (vec_select:V8HI (match_dup 1)
7953                 (parallel [(const_int 1) (const_int 3)
7954                            (const_int 5) (const_int 7)
7955                            (const_int 9) (const_int 11)
7956                            (const_int 13) (const_int 15)])))
7957             (sign_extend:V8SI
7958               (vec_select:V8HI (match_dup 2)
7959                 (parallel [(const_int 1) (const_int 3)
7960                            (const_int 5) (const_int 7)
7961                            (const_int 9) (const_int 11)
7962                            (const_int 13) (const_int 15)]))))))]
7963   "TARGET_AVX2 && ix86_binary_operator_ok (MULT, V16HImode, operands)"
7964   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
7965   [(set_attr "type" "sseiadd")
7966    (set_attr "prefix" "vex")
7967    (set_attr "mode" "OI")])
7968
7969 (define_expand "sse2_pmaddwd"
7970   [(set (match_operand:V4SI 0 "register_operand")
7971         (plus:V4SI
7972           (mult:V4SI
7973             (sign_extend:V4SI
7974               (vec_select:V4HI
7975                 (match_operand:V8HI 1 "nonimmediate_operand")
7976                 (parallel [(const_int 0) (const_int 2)
7977                            (const_int 4) (const_int 6)])))
7978             (sign_extend:V4SI
7979               (vec_select:V4HI
7980                 (match_operand:V8HI 2 "nonimmediate_operand")
7981                 (parallel [(const_int 0) (const_int 2)
7982                            (const_int 4) (const_int 6)]))))
7983           (mult:V4SI
7984             (sign_extend:V4SI
7985               (vec_select:V4HI (match_dup 1)
7986                 (parallel [(const_int 1) (const_int 3)
7987                            (const_int 5) (const_int 7)])))
7988             (sign_extend:V4SI
7989               (vec_select:V4HI (match_dup 2)
7990                 (parallel [(const_int 1) (const_int 3)
7991                            (const_int 5) (const_int 7)]))))))]
7992   "TARGET_SSE2"
7993   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
7994
7995 (define_insn "*sse2_pmaddwd"
7996   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
7997         (plus:V4SI
7998           (mult:V4SI
7999             (sign_extend:V4SI
8000               (vec_select:V4HI
8001                 (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
8002                 (parallel [(const_int 0) (const_int 2)
8003                            (const_int 4) (const_int 6)])))
8004             (sign_extend:V4SI
8005               (vec_select:V4HI
8006                 (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
8007                 (parallel [(const_int 0) (const_int 2)
8008                            (const_int 4) (const_int 6)]))))
8009           (mult:V4SI
8010             (sign_extend:V4SI
8011               (vec_select:V4HI (match_dup 1)
8012                 (parallel [(const_int 1) (const_int 3)
8013                            (const_int 5) (const_int 7)])))
8014             (sign_extend:V4SI
8015               (vec_select:V4HI (match_dup 2)
8016                 (parallel [(const_int 1) (const_int 3)
8017                            (const_int 5) (const_int 7)]))))))]
8018   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
8019   "@
8020    pmaddwd\t{%2, %0|%0, %2}
8021    vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
8022   [(set_attr "isa" "noavx,avx")
8023    (set_attr "type" "sseiadd")
8024    (set_attr "atom_unit" "simul")
8025    (set_attr "prefix_data16" "1,*")
8026    (set_attr "prefix" "orig,vex")
8027    (set_attr "mode" "TI")])
8028
8029 (define_expand "mul<mode>3<mask_name>"
8030   [(set (match_operand:VI4_AVX512F 0 "register_operand")
8031         (mult:VI4_AVX512F
8032           (match_operand:VI4_AVX512F 1 "general_vector_operand")
8033           (match_operand:VI4_AVX512F 2 "general_vector_operand")))]
8034   "TARGET_SSE2 && <mask_mode512bit_condition>"
8035 {
8036   if (TARGET_SSE4_1)
8037     {
8038       if (!nonimmediate_operand (operands[1], <MODE>mode))
8039         operands[1] = force_reg (<MODE>mode, operands[1]);
8040       if (!nonimmediate_operand (operands[2], <MODE>mode))
8041         operands[2] = force_reg (<MODE>mode, operands[2]);
8042       ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
8043     }
8044   else
8045     {
8046       ix86_expand_sse2_mulv4si3 (operands[0], operands[1], operands[2]);
8047       DONE;
8048     }
8049 })
8050
8051 (define_insn "*<sse4_1_avx2>_mul<mode>3<mask_name>"
8052   [(set (match_operand:VI4_AVX512F 0 "register_operand" "=x,v")
8053         (mult:VI4_AVX512F
8054           (match_operand:VI4_AVX512F 1 "nonimmediate_operand" "%0,v")
8055           (match_operand:VI4_AVX512F 2 "nonimmediate_operand" "xm,vm")))]
8056   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, <MODE>mode, operands) && <mask_mode512bit_condition>"
8057   "@
8058    pmulld\t{%2, %0|%0, %2}
8059    vpmulld\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8060   [(set_attr "isa" "noavx,avx")
8061    (set_attr "type" "sseimul")
8062    (set_attr "prefix_extra" "1")
8063    (set_attr "prefix" "<mask_prefix3>")
8064    (set_attr "btver2_decode" "vector,vector")
8065    (set_attr "mode" "<sseinsnmode>")])
8066
8067 (define_expand "mul<mode>3"
8068   [(set (match_operand:VI8_AVX2_AVX512F 0 "register_operand")
8069         (mult:VI8_AVX2_AVX512F
8070           (match_operand:VI8_AVX2_AVX512F 1 "register_operand")
8071           (match_operand:VI8_AVX2_AVX512F 2 "register_operand")))]
8072   "TARGET_SSE2"
8073 {
8074   ix86_expand_sse2_mulvxdi3 (operands[0], operands[1], operands[2]);
8075   DONE;
8076 })
8077
8078 (define_expand "vec_widen_<s>mult_hi_<mode>"
8079   [(match_operand:<sseunpackmode> 0 "register_operand")
8080    (any_extend:<sseunpackmode>
8081      (match_operand:VI124_AVX2 1 "register_operand"))
8082    (match_operand:VI124_AVX2 2 "register_operand")]
8083   "TARGET_SSE2"
8084 {
8085   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
8086                               <u_bool>, true);
8087   DONE;
8088 })
8089
8090 (define_expand "vec_widen_<s>mult_lo_<mode>"
8091   [(match_operand:<sseunpackmode> 0 "register_operand")
8092    (any_extend:<sseunpackmode>
8093      (match_operand:VI124_AVX2 1 "register_operand"))
8094    (match_operand:VI124_AVX2 2 "register_operand")]
8095   "TARGET_SSE2"
8096 {
8097   ix86_expand_mul_widen_hilo (operands[0], operands[1], operands[2],
8098                               <u_bool>, false);
8099   DONE;
8100 })
8101
8102 ;; Most widen_<s>mult_even_<mode> can be handled directly from other
8103 ;; named patterns, but signed V4SI needs special help for plain SSE2.
8104 (define_expand "vec_widen_smult_even_v4si"
8105   [(match_operand:V2DI 0 "register_operand")
8106    (match_operand:V4SI 1 "nonimmediate_operand")
8107    (match_operand:V4SI 2 "nonimmediate_operand")]
8108   "TARGET_SSE2"
8109 {
8110   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
8111                                  false, false);
8112   DONE;
8113 })
8114
8115 (define_expand "vec_widen_<s>mult_odd_<mode>"
8116   [(match_operand:<sseunpackmode> 0 "register_operand")
8117    (any_extend:<sseunpackmode>
8118      (match_operand:VI4_AVX512F 1 "general_vector_operand"))
8119    (match_operand:VI4_AVX512F 2 "general_vector_operand")]
8120   "TARGET_SSE2"
8121 {
8122   ix86_expand_mul_widen_evenodd (operands[0], operands[1], operands[2],
8123                                  <u_bool>, true);
8124   DONE;
8125 })
8126
8127 (define_expand "sdot_prod<mode>"
8128   [(match_operand:<sseunpackmode> 0 "register_operand")
8129    (match_operand:VI2_AVX2 1 "register_operand")
8130    (match_operand:VI2_AVX2 2 "register_operand")
8131    (match_operand:<sseunpackmode> 3 "register_operand")]
8132   "TARGET_SSE2"
8133 {
8134   rtx t = gen_reg_rtx (<sseunpackmode>mode);
8135   emit_insn (gen_<sse2_avx2>_pmaddwd (t, operands[1], operands[2]));
8136   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
8137                           gen_rtx_PLUS (<sseunpackmode>mode,
8138                                         operands[3], t)));
8139   DONE;
8140 })
8141
8142 ;; Normally we use widen_mul_even/odd, but combine can't quite get it all
8143 ;; back together when madd is available.
8144 (define_expand "sdot_prodv4si"
8145   [(match_operand:V2DI 0 "register_operand")
8146    (match_operand:V4SI 1 "register_operand")
8147    (match_operand:V4SI 2 "register_operand")
8148    (match_operand:V2DI 3 "register_operand")]
8149   "TARGET_XOP"
8150 {
8151   rtx t = gen_reg_rtx (V2DImode);
8152   emit_insn (gen_xop_pmacsdqh (t, operands[1], operands[2], operands[3]));
8153   emit_insn (gen_xop_pmacsdql (operands[0], operands[1], operands[2], t));
8154   DONE;
8155 })
8156
8157 (define_insn "ashr<mode>3"
8158   [(set (match_operand:VI24_AVX2 0 "register_operand" "=x,x")
8159         (ashiftrt:VI24_AVX2
8160           (match_operand:VI24_AVX2 1 "register_operand" "0,x")
8161           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
8162   "TARGET_SSE2"
8163   "@
8164    psra<ssemodesuffix>\t{%2, %0|%0, %2}
8165    vpsra<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8166   [(set_attr "isa" "noavx,avx")
8167    (set_attr "type" "sseishft")
8168    (set (attr "length_immediate")
8169      (if_then_else (match_operand 2 "const_int_operand")
8170        (const_string "1")
8171        (const_string "0")))
8172    (set_attr "prefix_data16" "1,*")
8173    (set_attr "prefix" "orig,vex")
8174    (set_attr "mode" "<sseinsnmode>")])
8175
8176 (define_insn "ashr<mode>3<mask_name>"
8177   [(set (match_operand:VI48_512 0 "register_operand" "=v,v")
8178         (ashiftrt:VI48_512
8179           (match_operand:VI48_512 1 "nonimmediate_operand" "v,vm")
8180           (match_operand:SI 2 "nonmemory_operand" "v,N")))]
8181   "TARGET_AVX512F && <mask_mode512bit_condition>"
8182   "vpsra<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8183   [(set_attr "type" "sseishft")
8184    (set (attr "length_immediate")
8185      (if_then_else (match_operand 2 "const_int_operand")
8186        (const_string "1")
8187        (const_string "0")))
8188    (set_attr "mode" "<sseinsnmode>")])
8189
8190 (define_insn "<shift_insn><mode>3"
8191   [(set (match_operand:VI248_AVX2 0 "register_operand" "=x,x")
8192         (any_lshift:VI248_AVX2
8193           (match_operand:VI248_AVX2 1 "register_operand" "0,x")
8194           (match_operand:SI 2 "nonmemory_operand" "xN,xN")))]
8195   "TARGET_SSE2"
8196   "@
8197    p<vshift><ssemodesuffix>\t{%2, %0|%0, %2}
8198    vp<vshift><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8199   [(set_attr "isa" "noavx,avx")
8200    (set_attr "type" "sseishft")
8201    (set (attr "length_immediate")
8202      (if_then_else (match_operand 2 "const_int_operand")
8203        (const_string "1")
8204        (const_string "0")))
8205    (set_attr "prefix_data16" "1,*")
8206    (set_attr "prefix" "orig,vex")
8207    (set_attr "mode" "<sseinsnmode>")])
8208
8209 (define_insn "<shift_insn><mode>3<mask_name>"
8210   [(set (match_operand:VI48_512 0 "register_operand" "=v,v")
8211         (any_lshift:VI48_512
8212           (match_operand:VI48_512 1 "nonimmediate_operand" "v,m")
8213           (match_operand:SI 2 "nonmemory_operand" "vN,N")))]
8214   "TARGET_AVX512F && <mask_mode512bit_condition>"
8215   "vp<vshift><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8216   [(set_attr "isa" "avx512f")
8217    (set_attr "type" "sseishft")
8218    (set (attr "length_immediate")
8219      (if_then_else (match_operand 2 "const_int_operand")
8220        (const_string "1")
8221        (const_string "0")))
8222    (set_attr "prefix" "evex")
8223    (set_attr "mode" "<sseinsnmode>")])
8224
8225
8226 (define_expand "vec_shl_<mode>"
8227   [(set (match_dup 3)
8228         (ashift:V1TI
8229          (match_operand:VI_128 1 "register_operand")
8230          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))
8231    (set (match_operand:VI_128 0 "register_operand") (match_dup 4))]
8232   "TARGET_SSE2"
8233 {
8234   operands[1] = gen_lowpart (V1TImode, operands[1]);
8235   operands[3] = gen_reg_rtx (V1TImode);
8236   operands[4] = gen_lowpart (<MODE>mode, operands[3]);
8237 })
8238
8239 (define_insn "<sse2_avx2>_ashl<mode>3"
8240   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
8241         (ashift:VIMAX_AVX2
8242          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
8243          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
8244   "TARGET_SSE2"
8245 {
8246   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
8247
8248   switch (which_alternative)
8249     {
8250     case 0:
8251       return "pslldq\t{%2, %0|%0, %2}";
8252     case 1:
8253       return "vpslldq\t{%2, %1, %0|%0, %1, %2}";
8254     default:
8255       gcc_unreachable ();
8256     }
8257 }
8258   [(set_attr "isa" "noavx,avx")
8259    (set_attr "type" "sseishft")
8260    (set_attr "length_immediate" "1")
8261    (set_attr "prefix_data16" "1,*")
8262    (set_attr "prefix" "orig,vex")
8263    (set_attr "mode" "<sseinsnmode>")])
8264
8265 (define_expand "vec_shr_<mode>"
8266   [(set (match_dup 3)
8267         (lshiftrt:V1TI
8268          (match_operand:VI_128 1 "register_operand")
8269          (match_operand:SI 2 "const_0_to_255_mul_8_operand")))
8270    (set (match_operand:VI_128 0 "register_operand") (match_dup 4))]
8271   "TARGET_SSE2"
8272 {
8273   operands[1] = gen_lowpart (V1TImode, operands[1]);
8274   operands[3] = gen_reg_rtx (V1TImode);
8275   operands[4] = gen_lowpart (<MODE>mode, operands[3]);
8276 })
8277
8278 (define_insn "<sse2_avx2>_lshr<mode>3"
8279   [(set (match_operand:VIMAX_AVX2 0 "register_operand" "=x,x")
8280         (lshiftrt:VIMAX_AVX2
8281          (match_operand:VIMAX_AVX2 1 "register_operand" "0,x")
8282          (match_operand:SI 2 "const_0_to_255_mul_8_operand" "n,n")))]
8283   "TARGET_SSE2"
8284 {
8285   operands[2] = GEN_INT (INTVAL (operands[2]) / 8);
8286
8287   switch (which_alternative)
8288     {
8289     case 0:
8290       return "psrldq\t{%2, %0|%0, %2}";
8291     case 1:
8292       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
8293     default:
8294       gcc_unreachable ();
8295     }
8296 }
8297   [(set_attr "isa" "noavx,avx")
8298    (set_attr "type" "sseishft")
8299    (set_attr "length_immediate" "1")
8300    (set_attr "atom_unit" "sishuf")
8301    (set_attr "prefix_data16" "1,*")
8302    (set_attr "prefix" "orig,vex")
8303    (set_attr "mode" "<sseinsnmode>")])
8304
8305 (define_insn "avx512f_<rotate>v<mode><mask_name>"
8306   [(set (match_operand:VI48_512 0 "register_operand" "=v")
8307         (any_rotate:VI48_512
8308           (match_operand:VI48_512 1 "register_operand" "v")
8309           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")))]
8310   "TARGET_AVX512F"
8311   "vp<rotate>v<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8312   [(set_attr "prefix" "evex")
8313    (set_attr "mode" "<sseinsnmode>")])
8314
8315 (define_insn "avx512f_<rotate><mode><mask_name>"
8316   [(set (match_operand:VI48_512 0 "register_operand" "=v")
8317         (any_rotate:VI48_512
8318           (match_operand:VI48_512 1 "nonimmediate_operand" "vm")
8319           (match_operand:SI 2 "const_0_to_255_operand")))]
8320   "TARGET_AVX512F"
8321   "vp<rotate><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
8322   [(set_attr "prefix" "evex")
8323    (set_attr "mode" "<sseinsnmode>")])
8324
8325 (define_expand "<code><mode>3<mask_name><round_name>"
8326   [(set (match_operand:VI124_256_48_512 0 "register_operand")
8327         (maxmin:VI124_256_48_512
8328           (match_operand:VI124_256_48_512 1 "<round_nimm_predicate>")
8329           (match_operand:VI124_256_48_512 2 "<round_nimm_predicate>")))]
8330   "TARGET_AVX2 && <mask_mode512bit_condition> && <round_mode512bit_condition>"
8331   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
8332
8333 (define_insn "*avx2_<code><mode>3<mask_name><round_name>"
8334   [(set (match_operand:VI124_256_48_512 0 "register_operand" "=v")
8335         (maxmin:VI124_256_48_512
8336           (match_operand:VI124_256_48_512 1 "<round_nimm_predicate>" "%v")
8337           (match_operand:VI124_256_48_512 2 "<round_nimm_predicate>" "<round_constraint>")))]
8338   "TARGET_AVX2 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)
8339    && <mask_mode512bit_condition> && <round_mode512bit_condition>"
8340   "vp<maxmin_int><ssemodesuffix>\t{<round_mask_op3>%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2<round_mask_op3>}"
8341   [(set_attr "type" "sseiadd")
8342    (set_attr "prefix_extra" "1")
8343    (set_attr "prefix" "maybe_evex")
8344    (set_attr "mode" "OI")])
8345
8346 (define_expand "<code><mode>3"
8347   [(set (match_operand:VI8_AVX2 0 "register_operand")
8348         (maxmin:VI8_AVX2
8349           (match_operand:VI8_AVX2 1 "register_operand")
8350           (match_operand:VI8_AVX2 2 "register_operand")))]
8351   "TARGET_SSE4_2"
8352 {
8353   enum rtx_code code;
8354   rtx xops[6];
8355   bool ok;
8356
8357   xops[0] = operands[0];
8358
8359   if (<CODE> == SMAX || <CODE> == UMAX)
8360     {
8361       xops[1] = operands[1];
8362       xops[2] = operands[2];
8363     }
8364   else
8365     {
8366       xops[1] = operands[2];
8367       xops[2] = operands[1];
8368     }
8369
8370   code = (<CODE> == UMAX || <CODE> == UMIN) ? GTU : GT;
8371
8372   xops[3] = gen_rtx_fmt_ee (code, VOIDmode, operands[1], operands[2]);
8373   xops[4] = operands[1];
8374   xops[5] = operands[2];
8375
8376   ok = ix86_expand_int_vcond (xops);
8377   gcc_assert (ok);
8378   DONE;
8379 })
8380
8381 (define_expand "<code><mode>3"
8382   [(set (match_operand:VI124_128 0 "register_operand")
8383         (smaxmin:VI124_128
8384           (match_operand:VI124_128 1 "nonimmediate_operand")
8385           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8386   "TARGET_SSE2"
8387 {
8388   if (TARGET_SSE4_1 || <MODE>mode == V8HImode)
8389     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
8390   else
8391     {
8392       rtx xops[6];
8393       bool ok;
8394
8395       xops[0] = operands[0];
8396       operands[1] = force_reg (<MODE>mode, operands[1]);
8397       operands[2] = force_reg (<MODE>mode, operands[2]);
8398
8399       if (<CODE> == SMAX)
8400         {
8401           xops[1] = operands[1];
8402           xops[2] = operands[2];
8403         }
8404       else
8405         {
8406           xops[1] = operands[2];
8407           xops[2] = operands[1];
8408         }
8409
8410       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
8411       xops[4] = operands[1];
8412       xops[5] = operands[2];
8413
8414       ok = ix86_expand_int_vcond (xops);
8415       gcc_assert (ok);
8416       DONE;
8417     }
8418 })
8419
8420 (define_insn "*sse4_1_<code><mode>3"
8421   [(set (match_operand:VI14_128 0 "register_operand" "=x,x")
8422         (smaxmin:VI14_128
8423           (match_operand:VI14_128 1 "nonimmediate_operand" "%0,x")
8424           (match_operand:VI14_128 2 "nonimmediate_operand" "xm,xm")))]
8425   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
8426   "@
8427    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
8428    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8429   [(set_attr "isa" "noavx,avx")
8430    (set_attr "type" "sseiadd")
8431    (set_attr "prefix_extra" "1,*")
8432    (set_attr "prefix" "orig,vex")
8433    (set_attr "mode" "TI")])
8434
8435 (define_insn "*<code>v8hi3"
8436   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
8437         (smaxmin:V8HI
8438           (match_operand:V8HI 1 "nonimmediate_operand" "%0,x")
8439           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")))]
8440   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V8HImode, operands)"
8441   "@
8442    p<maxmin_int>w\t{%2, %0|%0, %2}
8443    vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
8444   [(set_attr "isa" "noavx,avx")
8445    (set_attr "type" "sseiadd")
8446    (set_attr "prefix_data16" "1,*")
8447    (set_attr "prefix_extra" "*,1")
8448    (set_attr "prefix" "orig,vex")
8449    (set_attr "mode" "TI")])
8450
8451 (define_expand "<code><mode>3"
8452   [(set (match_operand:VI124_128 0 "register_operand")
8453         (umaxmin:VI124_128
8454           (match_operand:VI124_128 1 "nonimmediate_operand")
8455           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8456   "TARGET_SSE2"
8457 {
8458   if (TARGET_SSE4_1 || <MODE>mode == V16QImode)
8459     ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);
8460   else if (<CODE> == UMAX && <MODE>mode == V8HImode)
8461     {
8462       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
8463       operands[1] = force_reg (<MODE>mode, operands[1]);
8464       if (rtx_equal_p (op3, op2))
8465         op3 = gen_reg_rtx (V8HImode);
8466       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
8467       emit_insn (gen_addv8hi3 (op0, op3, op2));
8468       DONE;
8469     }
8470   else
8471     {
8472       rtx xops[6];
8473       bool ok;
8474
8475       operands[1] = force_reg (<MODE>mode, operands[1]);
8476       operands[2] = force_reg (<MODE>mode, operands[2]);
8477
8478       xops[0] = operands[0];
8479
8480       if (<CODE> == UMAX)
8481         {
8482           xops[1] = operands[1];
8483           xops[2] = operands[2];
8484         }
8485       else
8486         {
8487           xops[1] = operands[2];
8488           xops[2] = operands[1];
8489         }
8490
8491       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
8492       xops[4] = operands[1];
8493       xops[5] = operands[2];
8494
8495       ok = ix86_expand_int_vcond (xops);
8496       gcc_assert (ok);
8497       DONE;
8498     }
8499 })
8500
8501 (define_insn "*sse4_1_<code><mode>3"
8502   [(set (match_operand:VI24_128 0 "register_operand" "=x,x")
8503         (umaxmin:VI24_128
8504           (match_operand:VI24_128 1 "nonimmediate_operand" "%0,x")
8505           (match_operand:VI24_128 2 "nonimmediate_operand" "xm,xm")))]
8506   "TARGET_SSE4_1 && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
8507   "@
8508    p<maxmin_int><ssemodesuffix>\t{%2, %0|%0, %2}
8509    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8510   [(set_attr "isa" "noavx,avx")
8511    (set_attr "type" "sseiadd")
8512    (set_attr "prefix_extra" "1,*")
8513    (set_attr "prefix" "orig,vex")
8514    (set_attr "mode" "TI")])
8515
8516 (define_insn "*<code>v16qi3"
8517   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
8518         (umaxmin:V16QI
8519           (match_operand:V16QI 1 "nonimmediate_operand" "%0,x")
8520           (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")))]
8521   "TARGET_SSE2 && ix86_binary_operator_ok (<CODE>, V16QImode, operands)"
8522   "@
8523    p<maxmin_int>b\t{%2, %0|%0, %2}
8524    vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
8525   [(set_attr "isa" "noavx,avx")
8526    (set_attr "type" "sseiadd")
8527    (set_attr "prefix_data16" "1,*")
8528    (set_attr "prefix_extra" "*,1")
8529    (set_attr "prefix" "orig,vex")
8530    (set_attr "mode" "TI")])
8531
8532 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8533 ;;
8534 ;; Parallel integral comparisons
8535 ;;
8536 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8537
8538 (define_expand "avx2_eq<mode>3"
8539   [(set (match_operand:VI_256 0 "register_operand")
8540         (eq:VI_256
8541           (match_operand:VI_256 1 "nonimmediate_operand")
8542           (match_operand:VI_256 2 "nonimmediate_operand")))]
8543   "TARGET_AVX2"
8544   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8545
8546 (define_insn "*avx2_eq<mode>3"
8547   [(set (match_operand:VI_256 0 "register_operand" "=x")
8548         (eq:VI_256
8549           (match_operand:VI_256 1 "nonimmediate_operand" "%x")
8550           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
8551   "TARGET_AVX2 && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8552   "vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8553   [(set_attr "type" "ssecmp")
8554    (set_attr "prefix_extra" "1")
8555    (set_attr "prefix" "vex")
8556    (set_attr "mode" "OI")])
8557
8558 (define_expand "avx512f_eq<mode>3<mask_scalar_merge_name>"
8559   [(set (match_operand:<avx512fmaskmode> 0 "register_operand")
8560         (unspec:<avx512fmaskmode>
8561           [(match_operand:VI48_512 1 "register_operand")
8562            (match_operand:VI48_512 2 "nonimmediate_operand")]
8563           UNSPEC_MASKED_EQ))]
8564   "TARGET_AVX512F"
8565   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8566
8567 (define_insn "avx512f_eq<mode>3<mask_scalar_merge_name>_1"
8568   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
8569         (unspec:<avx512fmaskmode>
8570           [(match_operand:VI48_512 1 "register_operand" "%v")
8571            (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
8572           UNSPEC_MASKED_EQ))]
8573   "TARGET_AVX512F && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8574   "vpcmpeq<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
8575   [(set_attr "type" "ssecmp")
8576    (set_attr "prefix_extra" "1")
8577    (set_attr "prefix" "evex")
8578    (set_attr "mode" "<sseinsnmode>")])
8579
8580 (define_insn "*sse4_1_eqv2di3"
8581   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
8582         (eq:V2DI
8583           (match_operand:V2DI 1 "nonimmediate_operand" "%0,x")
8584           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
8585   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
8586   "@
8587    pcmpeqq\t{%2, %0|%0, %2}
8588    vpcmpeqq\t{%2, %1, %0|%0, %1, %2}"
8589   [(set_attr "isa" "noavx,avx")
8590    (set_attr "type" "ssecmp")
8591    (set_attr "prefix_extra" "1")
8592    (set_attr "prefix" "orig,vex")
8593    (set_attr "mode" "TI")])
8594
8595 (define_insn "*sse2_eq<mode>3"
8596   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
8597         (eq:VI124_128
8598           (match_operand:VI124_128 1 "nonimmediate_operand" "%0,x")
8599           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
8600   "TARGET_SSE2 && !TARGET_XOP
8601    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
8602   "@
8603    pcmpeq<ssemodesuffix>\t{%2, %0|%0, %2}
8604    vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8605   [(set_attr "isa" "noavx,avx")
8606    (set_attr "type" "ssecmp")
8607    (set_attr "prefix_data16" "1,*")
8608    (set_attr "prefix" "orig,vex")
8609    (set_attr "mode" "TI")])
8610
8611 (define_expand "sse2_eq<mode>3"
8612   [(set (match_operand:VI124_128 0 "register_operand")
8613         (eq:VI124_128
8614           (match_operand:VI124_128 1 "nonimmediate_operand")
8615           (match_operand:VI124_128 2 "nonimmediate_operand")))]
8616   "TARGET_SSE2 && !TARGET_XOP "
8617   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
8618
8619 (define_expand "sse4_1_eqv2di3"
8620   [(set (match_operand:V2DI 0 "register_operand")
8621         (eq:V2DI
8622           (match_operand:V2DI 1 "nonimmediate_operand")
8623           (match_operand:V2DI 2 "nonimmediate_operand")))]
8624   "TARGET_SSE4_1"
8625   "ix86_fixup_binary_operands_no_copy (EQ, V2DImode, operands);")
8626
8627 (define_insn "sse4_2_gtv2di3"
8628   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
8629         (gt:V2DI
8630           (match_operand:V2DI 1 "register_operand" "0,x")
8631           (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")))]
8632   "TARGET_SSE4_2"
8633   "@
8634    pcmpgtq\t{%2, %0|%0, %2}
8635    vpcmpgtq\t{%2, %1, %0|%0, %1, %2}"
8636   [(set_attr "isa" "noavx,avx")
8637    (set_attr "type" "ssecmp")
8638    (set_attr "prefix_extra" "1")
8639    (set_attr "prefix" "orig,vex")
8640    (set_attr "mode" "TI")])
8641
8642 (define_insn "avx2_gt<mode>3"
8643   [(set (match_operand:VI_256 0 "register_operand" "=x")
8644         (gt:VI_256
8645           (match_operand:VI_256 1 "register_operand" "x")
8646           (match_operand:VI_256 2 "nonimmediate_operand" "xm")))]
8647   "TARGET_AVX2"
8648   "vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8649   [(set_attr "type" "ssecmp")
8650    (set_attr "prefix_extra" "1")
8651    (set_attr "prefix" "vex")
8652    (set_attr "mode" "OI")])
8653
8654 (define_insn "avx512f_gt<mode>3<mask_scalar_merge_name>"
8655   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
8656         (unspec:<avx512fmaskmode>
8657           [(match_operand:VI48_512 1 "register_operand" "v")
8658            (match_operand:VI48_512 2 "nonimmediate_operand" "vm")] UNSPEC_MASKED_GT))]
8659   "TARGET_AVX512F"
8660   "vpcmpgt<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
8661   [(set_attr "type" "ssecmp")
8662    (set_attr "prefix_extra" "1")
8663    (set_attr "prefix" "evex")
8664    (set_attr "mode" "<sseinsnmode>")])
8665
8666 (define_insn "sse2_gt<mode>3"
8667   [(set (match_operand:VI124_128 0 "register_operand" "=x,x")
8668         (gt:VI124_128
8669           (match_operand:VI124_128 1 "register_operand" "0,x")
8670           (match_operand:VI124_128 2 "nonimmediate_operand" "xm,xm")))]
8671   "TARGET_SSE2 && !TARGET_XOP"
8672   "@
8673    pcmpgt<ssemodesuffix>\t{%2, %0|%0, %2}
8674    vpcmpgt<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
8675   [(set_attr "isa" "noavx,avx")
8676    (set_attr "type" "ssecmp")
8677    (set_attr "prefix_data16" "1,*")
8678    (set_attr "prefix" "orig,vex")
8679    (set_attr "mode" "TI")])
8680
8681 (define_expand "vcond<V_512:mode><VI_512:mode>"
8682   [(set (match_operand:V_512 0 "register_operand")
8683         (if_then_else:V_512
8684           (match_operator 3 ""
8685             [(match_operand:VI_512 4 "nonimmediate_operand")
8686              (match_operand:VI_512 5 "general_operand")])
8687           (match_operand:V_512 1)
8688           (match_operand:V_512 2)))]
8689   "TARGET_AVX512F
8690    && (GET_MODE_NUNITS (<V_512:MODE>mode)
8691        == GET_MODE_NUNITS (<VI_512:MODE>mode))"
8692 {
8693   bool ok = ix86_expand_int_vcond (operands);
8694   gcc_assert (ok);
8695   DONE;
8696 })
8697
8698 (define_expand "vcond<V_256:mode><VI_256:mode>"
8699   [(set (match_operand:V_256 0 "register_operand")
8700         (if_then_else:V_256
8701           (match_operator 3 ""
8702             [(match_operand:VI_256 4 "nonimmediate_operand")
8703              (match_operand:VI_256 5 "general_operand")])
8704           (match_operand:V_256 1)
8705           (match_operand:V_256 2)))]
8706   "TARGET_AVX2
8707    && (GET_MODE_NUNITS (<V_256:MODE>mode)
8708        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
8709 {
8710   bool ok = ix86_expand_int_vcond (operands);
8711   gcc_assert (ok);
8712   DONE;
8713 })
8714
8715 (define_expand "vcond<V_128:mode><VI124_128:mode>"
8716   [(set (match_operand:V_128 0 "register_operand")
8717         (if_then_else:V_128
8718           (match_operator 3 ""
8719             [(match_operand:VI124_128 4 "nonimmediate_operand")
8720              (match_operand:VI124_128 5 "general_operand")])
8721           (match_operand:V_128 1)
8722           (match_operand:V_128 2)))]
8723   "TARGET_SSE2
8724    && (GET_MODE_NUNITS (<V_128:MODE>mode)
8725        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
8726 {
8727   bool ok = ix86_expand_int_vcond (operands);
8728   gcc_assert (ok);
8729   DONE;
8730 })
8731
8732 (define_expand "vcond<VI8F_128:mode>v2di"
8733   [(set (match_operand:VI8F_128 0 "register_operand")
8734         (if_then_else:VI8F_128
8735           (match_operator 3 ""
8736             [(match_operand:V2DI 4 "nonimmediate_operand")
8737              (match_operand:V2DI 5 "general_operand")])
8738           (match_operand:VI8F_128 1)
8739           (match_operand:VI8F_128 2)))]
8740   "TARGET_SSE4_2"
8741 {
8742   bool ok = ix86_expand_int_vcond (operands);
8743   gcc_assert (ok);
8744   DONE;
8745 })
8746
8747 (define_expand "vcondu<V_512:mode><VI_512:mode>"
8748   [(set (match_operand:V_512 0 "register_operand")
8749         (if_then_else:V_512
8750           (match_operator 3 ""
8751             [(match_operand:VI_512 4 "nonimmediate_operand")
8752              (match_operand:VI_512 5 "nonimmediate_operand")])
8753           (match_operand:V_512 1 "general_operand")
8754           (match_operand:V_512 2 "general_operand")))]
8755   "TARGET_AVX512F
8756    && (GET_MODE_NUNITS (<V_512:MODE>mode)
8757        == GET_MODE_NUNITS (<VI_512:MODE>mode))"
8758 {
8759   bool ok = ix86_expand_int_vcond (operands);
8760   gcc_assert (ok);
8761   DONE;
8762 })
8763
8764 (define_expand "vcondu<V_256:mode><VI_256:mode>"
8765   [(set (match_operand:V_256 0 "register_operand")
8766         (if_then_else:V_256
8767           (match_operator 3 ""
8768             [(match_operand:VI_256 4 "nonimmediate_operand")
8769              (match_operand:VI_256 5 "nonimmediate_operand")])
8770           (match_operand:V_256 1 "general_operand")
8771           (match_operand:V_256 2 "general_operand")))]
8772   "TARGET_AVX2
8773    && (GET_MODE_NUNITS (<V_256:MODE>mode)
8774        == GET_MODE_NUNITS (<VI_256:MODE>mode))"
8775 {
8776   bool ok = ix86_expand_int_vcond (operands);
8777   gcc_assert (ok);
8778   DONE;
8779 })
8780
8781 (define_expand "vcondu<V_128:mode><VI124_128:mode>"
8782   [(set (match_operand:V_128 0 "register_operand")
8783         (if_then_else:V_128
8784           (match_operator 3 ""
8785             [(match_operand:VI124_128 4 "nonimmediate_operand")
8786              (match_operand:VI124_128 5 "nonimmediate_operand")])
8787           (match_operand:V_128 1 "general_operand")
8788           (match_operand:V_128 2 "general_operand")))]
8789   "TARGET_SSE2
8790    && (GET_MODE_NUNITS (<V_128:MODE>mode)
8791        == GET_MODE_NUNITS (<VI124_128:MODE>mode))"
8792 {
8793   bool ok = ix86_expand_int_vcond (operands);
8794   gcc_assert (ok);
8795   DONE;
8796 })
8797
8798 (define_expand "vcondu<VI8F_128:mode>v2di"
8799   [(set (match_operand:VI8F_128 0 "register_operand")
8800         (if_then_else:VI8F_128
8801           (match_operator 3 ""
8802             [(match_operand:V2DI 4 "nonimmediate_operand")
8803              (match_operand:V2DI 5 "nonimmediate_operand")])
8804           (match_operand:VI8F_128 1 "general_operand")
8805           (match_operand:VI8F_128 2 "general_operand")))]
8806   "TARGET_SSE4_2"
8807 {
8808   bool ok = ix86_expand_int_vcond (operands);
8809   gcc_assert (ok);
8810   DONE;
8811 })
8812
8813 (define_mode_iterator VEC_PERM_AVX2
8814   [V16QI V8HI V4SI V2DI V4SF V2DF
8815    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
8816    (V8SI "TARGET_AVX2") (V4DI "TARGET_AVX2")
8817    (V8SF "TARGET_AVX2") (V4DF "TARGET_AVX2")
8818    (V16SF "TARGET_AVX512F") (V8DF "TARGET_AVX512F")
8819    (V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")])
8820
8821 (define_expand "vec_perm<mode>"
8822   [(match_operand:VEC_PERM_AVX2 0 "register_operand")
8823    (match_operand:VEC_PERM_AVX2 1 "register_operand")
8824    (match_operand:VEC_PERM_AVX2 2 "register_operand")
8825    (match_operand:<sseintvecmode> 3 "register_operand")]
8826   "TARGET_SSSE3 || TARGET_AVX || TARGET_XOP"
8827 {
8828   ix86_expand_vec_perm (operands);
8829   DONE;
8830 })
8831
8832 (define_mode_iterator VEC_PERM_CONST
8833   [(V4SF "TARGET_SSE") (V4SI "TARGET_SSE")
8834    (V2DF "TARGET_SSE") (V2DI "TARGET_SSE")
8835    (V16QI "TARGET_SSE2") (V8HI "TARGET_SSE2")
8836    (V8SF "TARGET_AVX") (V4DF "TARGET_AVX")
8837    (V8SI "TARGET_AVX") (V4DI "TARGET_AVX")
8838    (V32QI "TARGET_AVX2") (V16HI "TARGET_AVX2")
8839    (V16SI "TARGET_AVX512F") (V8DI "TARGET_AVX512F")
8840    (V16SF "TARGET_AVX512F") (V8DF "TARGET_AVX512F")])
8841
8842 (define_expand "vec_perm_const<mode>"
8843   [(match_operand:VEC_PERM_CONST 0 "register_operand")
8844    (match_operand:VEC_PERM_CONST 1 "register_operand")
8845    (match_operand:VEC_PERM_CONST 2 "register_operand")
8846    (match_operand:<sseintvecmode> 3)]
8847   ""
8848 {
8849   if (ix86_expand_vec_perm_const (operands))
8850     DONE;
8851   else
8852     FAIL;
8853 })
8854
8855 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8856 ;;
8857 ;; Parallel bitwise logical operations
8858 ;;
8859 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8860
8861 (define_expand "one_cmpl<mode>2"
8862   [(set (match_operand:VI 0 "register_operand")
8863         (xor:VI (match_operand:VI 1 "nonimmediate_operand")
8864                 (match_dup 2)))]
8865   "TARGET_SSE"
8866 {
8867   int i, n = GET_MODE_NUNITS (<MODE>mode);
8868   rtvec v = rtvec_alloc (n);
8869
8870   for (i = 0; i < n; ++i)
8871     RTVEC_ELT (v, i) = constm1_rtx;
8872
8873   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
8874 })
8875
8876 (define_expand "<sse2_avx2>_andnot<mode>3<mask_name>"
8877   [(set (match_operand:VI_AVX2 0 "register_operand")
8878         (and:VI_AVX2
8879           (not:VI_AVX2 (match_operand:VI_AVX2 1 "register_operand"))
8880           (match_operand:VI_AVX2 2 "nonimmediate_operand")))]
8881   "TARGET_SSE2 && <mask_mode512bit_condition>")
8882
8883 (define_insn "*andnot<mode>3<mask_name>"
8884   [(set (match_operand:VI 0 "register_operand" "=x,v")
8885         (and:VI
8886           (not:VI (match_operand:VI 1 "register_operand" "0,v"))
8887           (match_operand:VI 2 "nonimmediate_operand" "xm,vm")))]
8888   "TARGET_SSE && <mask_mode512bit_condition>"
8889 {
8890   static char buf[64];
8891   const char *ops;
8892   const char *tmp;
8893
8894   switch (get_attr_mode (insn))
8895     {
8896     case MODE_XI:
8897       gcc_assert (TARGET_AVX512F);
8898
8899       tmp = "pandn<ssemodesuffix>";
8900       break;
8901
8902     case MODE_OI:
8903       gcc_assert (TARGET_AVX2);
8904     case MODE_TI:
8905       gcc_assert (TARGET_SSE2);
8906
8907       tmp = "pandn";
8908       break;
8909
8910    case MODE_V16SF:
8911       gcc_assert (TARGET_AVX512F);
8912    case MODE_V8SF:
8913       gcc_assert (TARGET_AVX);
8914    case MODE_V4SF:
8915       gcc_assert (TARGET_SSE);
8916
8917       tmp = "andnps";
8918       break;
8919
8920    default:
8921       gcc_unreachable ();
8922    }
8923
8924   switch (which_alternative)
8925     {
8926     case 0:
8927       ops = "%s\t{%%2, %%0|%%0, %%2}";
8928       break;
8929     case 1:
8930       ops = "v%s\t{%%2, %%1, %%0<mask_operand3_1>|%%0<mask_operand3_1>, %%1, %%2}";
8931       break;
8932     default:
8933       gcc_unreachable ();
8934     }
8935
8936   snprintf (buf, sizeof (buf), ops, tmp);
8937   return buf;
8938 }
8939   [(set_attr "isa" "noavx,avx")
8940    (set_attr "type" "sselog")
8941    (set (attr "prefix_data16")
8942      (if_then_else
8943        (and (eq_attr "alternative" "0")
8944             (eq_attr "mode" "TI"))
8945        (const_string "1")
8946        (const_string "*")))
8947    (set_attr "prefix" "<mask_prefix3>")
8948    (set (attr "mode")
8949         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
8950                  (const_string "<ssePSmode>")
8951                (match_test "TARGET_AVX2")
8952                  (const_string "<sseinsnmode>")
8953                (match_test "TARGET_AVX")
8954                  (if_then_else
8955                    (match_test "<MODE_SIZE> > 16")
8956                    (const_string "V8SF")
8957                    (const_string "<sseinsnmode>"))
8958                (ior (not (match_test "TARGET_SSE2"))
8959                     (match_test "optimize_function_for_size_p (cfun)"))
8960                  (const_string "V4SF")
8961               ]
8962               (const_string "<sseinsnmode>")))])
8963
8964 (define_expand "<code><mode>3"
8965   [(set (match_operand:VI 0 "register_operand")
8966         (any_logic:VI
8967           (match_operand:VI 1 "nonimmediate_or_const_vector_operand")
8968           (match_operand:VI 2 "nonimmediate_or_const_vector_operand")))]
8969   "TARGET_SSE"
8970 {
8971   ix86_expand_vector_logical_operator (<CODE>, <MODE>mode, operands);
8972   DONE;
8973 })
8974
8975 (define_insn "<mask_codefor><code><mode>3<mask_name>"
8976   [(set (match_operand:VI 0 "register_operand" "=x,v")
8977         (any_logic:VI
8978           (match_operand:VI 1 "nonimmediate_operand" "%0,v")
8979           (match_operand:VI 2 "nonimmediate_operand" "xm,vm")))]
8980   "TARGET_SSE && <mask_mode512bit_condition>
8981    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
8982 {
8983   static char buf[64];
8984   const char *ops;
8985   const char *tmp;
8986
8987   switch (get_attr_mode (insn))
8988     {
8989     case MODE_XI:
8990       gcc_assert (TARGET_AVX512F);
8991
8992       tmp = "p<logic><ssemodesuffix>";
8993       break;
8994
8995     case MODE_OI:
8996       gcc_assert (TARGET_AVX2);
8997     case MODE_TI:
8998       gcc_assert (TARGET_SSE2);
8999
9000       tmp = "p<logic>";
9001       break;
9002
9003    case MODE_V16SF:
9004       gcc_assert (TARGET_AVX512F);
9005    case MODE_V8SF:
9006       gcc_assert (TARGET_AVX);
9007    case MODE_V4SF:
9008       gcc_assert (TARGET_SSE);
9009
9010       tmp = "<logic>ps";
9011       break;
9012
9013    default:
9014       gcc_unreachable ();
9015    }
9016
9017   switch (which_alternative)
9018     {
9019     case 0:
9020       ops = "%s\t{%%2, %%0|%%0, %%2}";
9021       break;
9022     case 1:
9023       ops = "v%s\t{%%2, %%1, %%0<mask_operand3_1>|%%0<mask_operand3_1>, %%1, %%2}";
9024       break;
9025     default:
9026       gcc_unreachable ();
9027     }
9028
9029   snprintf (buf, sizeof (buf), ops, tmp);
9030   return buf;
9031 }
9032   [(set_attr "isa" "noavx,avx")
9033    (set_attr "type" "sselog")
9034    (set (attr "prefix_data16")
9035      (if_then_else
9036        (and (eq_attr "alternative" "0")
9037             (eq_attr "mode" "TI"))
9038        (const_string "1")
9039        (const_string "*")))
9040    (set_attr "prefix" "<mask_prefix3>")
9041    (set (attr "mode")
9042         (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
9043                  (const_string "<ssePSmode>")
9044                (match_test "TARGET_AVX2")
9045                  (const_string "<sseinsnmode>")
9046                (match_test "TARGET_AVX")
9047                  (if_then_else
9048                    (match_test "<MODE_SIZE> > 16")
9049                    (const_string "V8SF")
9050                    (const_string "<sseinsnmode>"))
9051                (ior (not (match_test "TARGET_SSE2"))
9052                     (match_test "optimize_function_for_size_p (cfun)"))
9053                  (const_string "V4SF")
9054               ]
9055               (const_string "<sseinsnmode>")))])
9056
9057 (define_insn "avx512f_testm<mode>3<mask_scalar_merge_name>"
9058   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
9059         (unspec:<avx512fmaskmode>
9060          [(match_operand:VI48_512 1 "register_operand" "v")
9061           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
9062          UNSPEC_TESTM))]
9063   "TARGET_AVX512F"
9064   "vptestm<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
9065   [(set_attr "prefix" "evex")
9066    (set_attr "mode"  "<sseinsnmode>")])
9067
9068 (define_insn "avx512f_testnm<mode>3<mask_scalar_merge_name>"
9069   [(set (match_operand:<avx512fmaskmode> 0 "register_operand" "=Yk")
9070         (unspec:<avx512fmaskmode>
9071          [(match_operand:VI48_512 1 "register_operand" "v")
9072           (match_operand:VI48_512 2 "nonimmediate_operand" "vm")]
9073          UNSPEC_TESTNM))]
9074   "TARGET_AVX512F"
9075   "vptestnm<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}"
9076   [(set_attr "prefix" "evex")
9077    (set_attr "mode"  "<sseinsnmode>")])
9078
9079 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9080 ;;
9081 ;; Parallel integral element swizzling
9082 ;;
9083 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9084
9085 (define_expand "vec_pack_trunc_<mode>"
9086   [(match_operand:<ssepackmode> 0 "register_operand")
9087    (match_operand:VI248_AVX2_8_AVX512F 1 "register_operand")
9088    (match_operand:VI248_AVX2_8_AVX512F 2 "register_operand")]
9089   "TARGET_SSE2"
9090 {
9091   rtx op1 = gen_lowpart (<ssepackmode>mode, operands[1]);
9092   rtx op2 = gen_lowpart (<ssepackmode>mode, operands[2]);
9093   ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
9094   DONE;
9095 })
9096
9097 (define_insn "<sse2_avx2>_packsswb"
9098   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
9099         (vec_concat:VI1_AVX2
9100           (ss_truncate:<ssehalfvecmode>
9101             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9102           (ss_truncate:<ssehalfvecmode>
9103             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9104   "TARGET_SSE2"
9105   "@
9106    packsswb\t{%2, %0|%0, %2}
9107    vpacksswb\t{%2, %1, %0|%0, %1, %2}"
9108   [(set_attr "isa" "noavx,avx")
9109    (set_attr "type" "sselog")
9110    (set_attr "prefix_data16" "1,*")
9111    (set_attr "prefix" "orig,vex")
9112    (set_attr "mode" "<sseinsnmode>")])
9113
9114 (define_insn "<sse2_avx2>_packssdw"
9115   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
9116         (vec_concat:VI2_AVX2
9117           (ss_truncate:<ssehalfvecmode>
9118             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9119           (ss_truncate:<ssehalfvecmode>
9120             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9121   "TARGET_SSE2"
9122   "@
9123    packssdw\t{%2, %0|%0, %2}
9124    vpackssdw\t{%2, %1, %0|%0, %1, %2}"
9125   [(set_attr "isa" "noavx,avx")
9126    (set_attr "type" "sselog")
9127    (set_attr "prefix_data16" "1,*")
9128    (set_attr "prefix" "orig,vex")
9129    (set_attr "mode" "<sseinsnmode>")])
9130
9131 (define_insn "<sse2_avx2>_packuswb"
9132   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
9133         (vec_concat:VI1_AVX2
9134           (us_truncate:<ssehalfvecmode>
9135             (match_operand:<sseunpackmode> 1 "register_operand" "0,x"))
9136           (us_truncate:<ssehalfvecmode>
9137             (match_operand:<sseunpackmode> 2 "nonimmediate_operand" "xm,xm"))))]
9138   "TARGET_SSE2"
9139   "@
9140    packuswb\t{%2, %0|%0, %2}
9141    vpackuswb\t{%2, %1, %0|%0, %1, %2}"
9142   [(set_attr "isa" "noavx,avx")
9143    (set_attr "type" "sselog")
9144    (set_attr "prefix_data16" "1,*")
9145    (set_attr "prefix" "orig,vex")
9146    (set_attr "mode" "<sseinsnmode>")])
9147
9148 (define_insn "avx2_interleave_highv32qi"
9149   [(set (match_operand:V32QI 0 "register_operand" "=x")
9150         (vec_select:V32QI
9151           (vec_concat:V64QI
9152             (match_operand:V32QI 1 "register_operand" "x")
9153             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
9154           (parallel [(const_int 8)  (const_int 40)
9155                      (const_int 9)  (const_int 41)
9156                      (const_int 10) (const_int 42)
9157                      (const_int 11) (const_int 43)
9158                      (const_int 12) (const_int 44)
9159                      (const_int 13) (const_int 45)
9160                      (const_int 14) (const_int 46)
9161                      (const_int 15) (const_int 47)
9162                      (const_int 24) (const_int 56)
9163                      (const_int 25) (const_int 57)
9164                      (const_int 26) (const_int 58)
9165                      (const_int 27) (const_int 59)
9166                      (const_int 28) (const_int 60)
9167                      (const_int 29) (const_int 61)
9168                      (const_int 30) (const_int 62)
9169                      (const_int 31) (const_int 63)])))]
9170   "TARGET_AVX2"
9171   "vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
9172   [(set_attr "type" "sselog")
9173    (set_attr "prefix" "vex")
9174    (set_attr "mode" "OI")])
9175
9176 (define_insn "vec_interleave_highv16qi"
9177   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9178         (vec_select:V16QI
9179           (vec_concat:V32QI
9180             (match_operand:V16QI 1 "register_operand" "0,x")
9181             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
9182           (parallel [(const_int 8)  (const_int 24)
9183                      (const_int 9)  (const_int 25)
9184                      (const_int 10) (const_int 26)
9185                      (const_int 11) (const_int 27)
9186                      (const_int 12) (const_int 28)
9187                      (const_int 13) (const_int 29)
9188                      (const_int 14) (const_int 30)
9189                      (const_int 15) (const_int 31)])))]
9190   "TARGET_SSE2"
9191   "@
9192    punpckhbw\t{%2, %0|%0, %2}
9193    vpunpckhbw\t{%2, %1, %0|%0, %1, %2}"
9194   [(set_attr "isa" "noavx,avx")
9195    (set_attr "type" "sselog")
9196    (set_attr "prefix_data16" "1,*")
9197    (set_attr "prefix" "orig,vex")
9198    (set_attr "mode" "TI")])
9199
9200 (define_insn "avx2_interleave_lowv32qi"
9201   [(set (match_operand:V32QI 0 "register_operand" "=x")
9202         (vec_select:V32QI
9203           (vec_concat:V64QI
9204             (match_operand:V32QI 1 "register_operand" "x")
9205             (match_operand:V32QI 2 "nonimmediate_operand" "xm"))
9206           (parallel [(const_int 0) (const_int 32)
9207                      (const_int 1) (const_int 33)
9208                      (const_int 2) (const_int 34)
9209                      (const_int 3) (const_int 35)
9210                      (const_int 4) (const_int 36)
9211                      (const_int 5) (const_int 37)
9212                      (const_int 6) (const_int 38)
9213                      (const_int 7) (const_int 39)
9214                      (const_int 16) (const_int 48)
9215                      (const_int 17) (const_int 49)
9216                      (const_int 18) (const_int 50)
9217                      (const_int 19) (const_int 51)
9218                      (const_int 20) (const_int 52)
9219                      (const_int 21) (const_int 53)
9220                      (const_int 22) (const_int 54)
9221                      (const_int 23) (const_int 55)])))]
9222   "TARGET_AVX2"
9223   "vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
9224   [(set_attr "type" "sselog")
9225    (set_attr "prefix" "vex")
9226    (set_attr "mode" "OI")])
9227
9228 (define_insn "vec_interleave_lowv16qi"
9229   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
9230         (vec_select:V16QI
9231           (vec_concat:V32QI
9232             (match_operand:V16QI 1 "register_operand" "0,x")
9233             (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm"))
9234           (parallel [(const_int 0) (const_int 16)
9235                      (const_int 1) (const_int 17)
9236                      (const_int 2) (const_int 18)
9237                      (const_int 3) (const_int 19)
9238                      (const_int 4) (const_int 20)
9239                      (const_int 5) (const_int 21)
9240                      (const_int 6) (const_int 22)
9241                      (const_int 7) (const_int 23)])))]
9242   "TARGET_SSE2"
9243   "@
9244    punpcklbw\t{%2, %0|%0, %2}
9245    vpunpcklbw\t{%2, %1, %0|%0, %1, %2}"
9246   [(set_attr "isa" "noavx,avx")
9247    (set_attr "type" "sselog")
9248    (set_attr "prefix_data16" "1,*")
9249    (set_attr "prefix" "orig,vex")
9250    (set_attr "mode" "TI")])
9251
9252 (define_insn "avx2_interleave_highv16hi"
9253   [(set (match_operand:V16HI 0 "register_operand" "=x")
9254         (vec_select:V16HI
9255           (vec_concat:V32HI
9256             (match_operand:V16HI 1 "register_operand" "x")
9257             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
9258           (parallel [(const_int 4) (const_int 20)
9259                      (const_int 5) (const_int 21)
9260                      (const_int 6) (const_int 22)
9261                      (const_int 7) (const_int 23)
9262                      (const_int 12) (const_int 28)
9263                      (const_int 13) (const_int 29)
9264                      (const_int 14) (const_int 30)
9265                      (const_int 15) (const_int 31)])))]
9266   "TARGET_AVX2"
9267   "vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
9268   [(set_attr "type" "sselog")
9269    (set_attr "prefix" "vex")
9270    (set_attr "mode" "OI")])
9271
9272 (define_insn "vec_interleave_highv8hi"
9273   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
9274         (vec_select:V8HI
9275           (vec_concat:V16HI
9276             (match_operand:V8HI 1 "register_operand" "0,x")
9277             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
9278           (parallel [(const_int 4) (const_int 12)
9279                      (const_int 5) (const_int 13)
9280                      (const_int 6) (const_int 14)
9281                      (const_int 7) (const_int 15)])))]
9282   "TARGET_SSE2"
9283   "@
9284    punpckhwd\t{%2, %0|%0, %2}
9285    vpunpckhwd\t{%2, %1, %0|%0, %1, %2}"
9286   [(set_attr "isa" "noavx,avx")
9287    (set_attr "type" "sselog")
9288    (set_attr "prefix_data16" "1,*")
9289    (set_attr "prefix" "orig,vex")
9290    (set_attr "mode" "TI")])
9291
9292 (define_insn "avx2_interleave_lowv16hi"
9293   [(set (match_operand:V16HI 0 "register_operand" "=x")
9294         (vec_select:V16HI
9295           (vec_concat:V32HI
9296             (match_operand:V16HI 1 "register_operand" "x")
9297             (match_operand:V16HI 2 "nonimmediate_operand" "xm"))
9298           (parallel [(const_int 0) (const_int 16)
9299                      (const_int 1) (const_int 17)
9300                      (const_int 2) (const_int 18)
9301                      (const_int 3) (const_int 19)
9302                      (const_int 8) (const_int 24)
9303                      (const_int 9) (const_int 25)
9304                      (const_int 10) (const_int 26)
9305                      (const_int 11) (const_int 27)])))]
9306   "TARGET_AVX2"
9307   "vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
9308   [(set_attr "type" "sselog")
9309    (set_attr "prefix" "vex")
9310    (set_attr "mode" "OI")])
9311
9312 (define_insn "vec_interleave_lowv8hi"
9313   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
9314         (vec_select:V8HI
9315           (vec_concat:V16HI
9316             (match_operand:V8HI 1 "register_operand" "0,x")
9317             (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm"))
9318           (parallel [(const_int 0) (const_int 8)
9319                      (const_int 1) (const_int 9)
9320                      (const_int 2) (const_int 10)
9321                      (const_int 3) (const_int 11)])))]
9322   "TARGET_SSE2"
9323   "@
9324    punpcklwd\t{%2, %0|%0, %2}
9325    vpunpcklwd\t{%2, %1, %0|%0, %1, %2}"
9326   [(set_attr "isa" "noavx,avx")
9327    (set_attr "type" "sselog")
9328    (set_attr "prefix_data16" "1,*")
9329    (set_attr "prefix" "orig,vex")
9330    (set_attr "mode" "TI")])
9331
9332 (define_insn "avx2_interleave_highv8si"
9333   [(set (match_operand:V8SI 0 "register_operand" "=x")
9334         (vec_select:V8SI
9335           (vec_concat:V16SI
9336             (match_operand:V8SI 1 "register_operand" "x")
9337             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
9338           (parallel [(const_int 2) (const_int 10)
9339                      (const_int 3) (const_int 11)
9340                      (const_int 6) (const_int 14)
9341                      (const_int 7) (const_int 15)])))]
9342   "TARGET_AVX2"
9343   "vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
9344   [(set_attr "type" "sselog")
9345    (set_attr "prefix" "vex")
9346    (set_attr "mode" "OI")])
9347
9348 (define_insn "<mask_codefor>avx512f_interleave_highv16si<mask_name>"
9349   [(set (match_operand:V16SI 0 "register_operand" "=v")
9350         (vec_select:V16SI
9351           (vec_concat:V32SI
9352             (match_operand:V16SI 1 "register_operand" "v")
9353             (match_operand:V16SI 2 "nonimmediate_operand" "vm"))
9354           (parallel [(const_int 2) (const_int 18)
9355                      (const_int 3) (const_int 19)
9356                      (const_int 6) (const_int 22)
9357                      (const_int 7) (const_int 23)
9358                      (const_int 10) (const_int 26)
9359                      (const_int 11) (const_int 27)
9360                      (const_int 14) (const_int 30)
9361                      (const_int 15) (const_int 31)])))]
9362   "TARGET_AVX512F"
9363   "vpunpckhdq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
9364   [(set_attr "type" "sselog")
9365    (set_attr "prefix" "evex")
9366    (set_attr "mode" "XI")])
9367
9368
9369 (define_insn "vec_interleave_highv4si"
9370   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
9371         (vec_select:V4SI
9372           (vec_concat:V8SI
9373             (match_operand:V4SI 1 "register_operand" "0,x")
9374             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
9375           (parallel [(const_int 2) (const_int 6)
9376                      (const_int 3) (const_int 7)])))]
9377   "TARGET_SSE2"
9378   "@
9379    punpckhdq\t{%2, %0|%0, %2}
9380    vpunpckhdq\t{%2, %1, %0|%0, %1, %2}"
9381   [(set_attr "isa" "noavx,avx")
9382    (set_attr "type" "sselog")
9383    (set_attr "prefix_data16" "1,*")
9384    (set_attr "prefix" "orig,vex")
9385    (set_attr "mode" "TI")])
9386
9387 (define_insn "avx2_interleave_lowv8si"
9388   [(set (match_operand:V8SI 0 "register_operand" "=x")
9389         (vec_select:V8SI
9390           (vec_concat:V16SI
9391             (match_operand:V8SI 1 "register_operand" "x")
9392             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))
9393           (parallel [(const_int 0) (const_int 8)
9394                      (const_int 1) (const_int 9)
9395                      (const_int 4) (const_int 12)
9396                      (const_int 5) (const_int 13)])))]
9397   "TARGET_AVX2"
9398   "vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
9399   [(set_attr "type" "sselog")
9400    (set_attr "prefix" "vex")
9401    (set_attr "mode" "OI")])
9402
9403 (define_insn "<mask_codefor>avx512f_interleave_lowv16si<mask_name>"
9404   [(set (match_operand:V16SI 0 "register_operand" "=v")
9405         (vec_select:V16SI
9406           (vec_concat:V32SI
9407             (match_operand:V16SI 1 "register_operand" "v")
9408             (match_operand:V16SI 2 "nonimmediate_operand" "vm"))
9409           (parallel [(const_int 0) (const_int 16)
9410                      (const_int 1) (const_int 17)
9411                      (const_int 4) (const_int 20)
9412                      (const_int 5) (const_int 21)
9413                      (const_int 8) (const_int 24)
9414                      (const_int 9) (const_int 25)
9415                      (const_int 12) (const_int 28)
9416                      (const_int 13) (const_int 29)])))]
9417   "TARGET_AVX512F"
9418   "vpunpckldq\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
9419   [(set_attr "type" "sselog")
9420    (set_attr "prefix" "evex")
9421    (set_attr "mode" "XI")])
9422
9423 (define_insn "vec_interleave_lowv4si"
9424   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
9425         (vec_select:V4SI
9426           (vec_concat:V8SI
9427             (match_operand:V4SI 1 "register_operand" "0,x")
9428             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))
9429           (parallel [(const_int 0) (const_int 4)
9430                      (const_int 1) (const_int 5)])))]
9431   "TARGET_SSE2"
9432   "@
9433    punpckldq\t{%2, %0|%0, %2}
9434    vpunpckldq\t{%2, %1, %0|%0, %1, %2}"
9435   [(set_attr "isa" "noavx,avx")
9436    (set_attr "type" "sselog")
9437    (set_attr "prefix_data16" "1,*")
9438    (set_attr "prefix" "orig,vex")
9439    (set_attr "mode" "TI")])
9440
9441 (define_expand "vec_interleave_high<mode>"
9442   [(match_operand:VI_256 0 "register_operand" "=x")
9443    (match_operand:VI_256 1 "register_operand" "x")
9444    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
9445  "TARGET_AVX2"
9446 {
9447   rtx t1 = gen_reg_rtx (<MODE>mode);
9448   rtx t2 = gen_reg_rtx (<MODE>mode);
9449   rtx t3 = gen_reg_rtx (V4DImode);
9450   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
9451   emit_insn (gen_avx2_interleave_high<mode> (t2,  operands[1], operands[2]));
9452   emit_insn (gen_avx2_permv2ti (t3, gen_lowpart (V4DImode, t1),
9453                                 gen_lowpart (V4DImode, t2),
9454                                 GEN_INT (1 + (3 << 4))));
9455   emit_move_insn (operands[0], gen_lowpart (<MODE>mode, t3));
9456   DONE;
9457 })
9458
9459 (define_expand "vec_interleave_low<mode>"
9460   [(match_operand:VI_256 0 "register_operand" "=x")
9461    (match_operand:VI_256 1 "register_operand" "x")
9462    (match_operand:VI_256 2 "nonimmediate_operand" "xm")]
9463  "TARGET_AVX2"
9464 {
9465   rtx t1 = gen_reg_rtx (<MODE>mode);
9466   rtx t2 = gen_reg_rtx (<MODE>mode);
9467   rtx t3 = gen_reg_rtx (V4DImode);
9468   emit_insn (gen_avx2_interleave_low<mode> (t1, operands[1], operands[2]));
9469   emit_insn (gen_avx2_interleave_high<mode> (t2, operands[1], operands[2]));
9470   emit_insn (gen_avx2_permv2ti (t3, gen_lowpart (V4DImode, t1),
9471                                 gen_lowpart (V4DImode, t2),
9472                                 GEN_INT (0 + (2 << 4))));
9473   emit_move_insn (operands[0], gen_lowpart (<MODE>mode, t3));
9474   DONE;
9475 })
9476
9477 ;; Modes handled by pinsr patterns.
9478 (define_mode_iterator PINSR_MODE
9479   [(V16QI "TARGET_SSE4_1") V8HI
9480    (V4SI "TARGET_SSE4_1")
9481    (V2DI "TARGET_SSE4_1 && TARGET_64BIT")])
9482
9483 (define_mode_attr sse2p4_1
9484   [(V16QI "sse4_1") (V8HI "sse2")
9485    (V4SI "sse4_1") (V2DI "sse4_1")])
9486
9487 ;; sse4_1_pinsrd must come before sse2_loadld since it is preferred.
9488 (define_insn "<sse2p4_1>_pinsr<ssemodesuffix>"
9489   [(set (match_operand:PINSR_MODE 0 "register_operand" "=x,x,x,x")
9490         (vec_merge:PINSR_MODE
9491           (vec_duplicate:PINSR_MODE
9492             (match_operand:<ssescalarmode> 2 "nonimmediate_operand" "r,m,r,m"))
9493           (match_operand:PINSR_MODE 1 "register_operand" "0,0,x,x")
9494           (match_operand:SI 3 "const_int_operand")))]
9495   "TARGET_SSE2
9496    && ((unsigned) exact_log2 (INTVAL (operands[3]))
9497        < GET_MODE_NUNITS (<MODE>mode))"
9498 {
9499   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
9500
9501   switch (which_alternative)
9502     {
9503     case 0:
9504       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
9505         return "pinsr<ssemodesuffix>\t{%3, %k2, %0|%0, %k2, %3}";
9506       /* FALLTHRU */
9507     case 1:
9508       return "pinsr<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}";
9509     case 2:
9510       if (GET_MODE_SIZE (<ssescalarmode>mode) < GET_MODE_SIZE (SImode))
9511         return "vpinsr<ssemodesuffix>\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
9512       /* FALLTHRU */
9513     case 3:
9514       return "vpinsr<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
9515     default:
9516       gcc_unreachable ();
9517     }
9518 }
9519   [(set_attr "isa" "noavx,noavx,avx,avx")
9520    (set_attr "type" "sselog")
9521    (set (attr "prefix_rex")
9522      (if_then_else
9523        (and (not (match_test "TARGET_AVX"))
9524             (eq (const_string "<MODE>mode") (const_string "V2DImode")))
9525        (const_string "1")
9526        (const_string "*")))
9527    (set (attr "prefix_data16")
9528      (if_then_else
9529        (and (not (match_test "TARGET_AVX"))
9530             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
9531        (const_string "1")
9532        (const_string "*")))
9533    (set (attr "prefix_extra")
9534      (if_then_else
9535        (and (not (match_test "TARGET_AVX"))
9536             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
9537        (const_string "*")
9538        (const_string "1")))
9539    (set_attr "length_immediate" "1")
9540    (set_attr "prefix" "orig,orig,vex,vex")
9541    (set_attr "mode" "TI")])
9542
9543 (define_expand "avx512f_vinsert<shuffletype>32x4_mask"
9544   [(match_operand:V16FI 0 "register_operand")
9545    (match_operand:V16FI 1 "register_operand")
9546    (match_operand:<ssequartermode> 2 "nonimmediate_operand")
9547    (match_operand:SI 3 "const_0_to_3_operand")
9548    (match_operand:V16FI 4 "register_operand")
9549    (match_operand:<avx512fmaskmode> 5 "register_operand")]
9550   "TARGET_AVX512F"
9551 {
9552   switch (INTVAL (operands[3]))
9553     {
9554     case 0:
9555       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9556           operands[1], operands[2], GEN_INT (0xFFF), operands[4],
9557           operands[5]));
9558       break;
9559     case 1:
9560       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9561           operands[1], operands[2], GEN_INT (0xF0FF), operands[4],
9562           operands[5]));
9563       break;
9564     case 2:
9565       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9566           operands[1], operands[2], GEN_INT (0xFF0F), operands[4],
9567           operands[5]));
9568       break;
9569     case 3:
9570       emit_insn (gen_avx512f_vinsert<shuffletype>32x4_1_mask (operands[0],
9571           operands[1], operands[2], GEN_INT (0xFFF0), operands[4],
9572           operands[5]));
9573       break;
9574     default:
9575       gcc_unreachable ();
9576     }
9577   DONE;
9578
9579 })
9580
9581 (define_insn "<mask_codefor>avx512f_vinsert<shuffletype>32x4_1<mask_name>"
9582   [(set (match_operand:V16FI 0 "register_operand" "=v")
9583         (vec_merge:V16FI
9584           (match_operand:V16FI 1 "register_operand" "v")
9585           (vec_duplicate:V16FI
9586                 (match_operand:<ssequartermode> 2 "nonimmediate_operand" "vm"))
9587           (match_operand:SI 3 "const_int_operand" "n")))]
9588   "TARGET_AVX512F"
9589 {
9590   int mask;
9591   if (INTVAL (operands[3]) == 0xFFF)
9592       mask = 0;
9593   else if ( INTVAL (operands[3]) == 0xF0FF)
9594       mask = 1;
9595   else if ( INTVAL (operands[3]) == 0xFF0F)
9596       mask = 2;
9597   else if ( INTVAL (operands[3]) == 0xFFF0)
9598       mask = 3;
9599   else
9600       gcc_unreachable ();
9601
9602   operands[3] = GEN_INT (mask);
9603
9604   return "vinsert<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
9605 }
9606   [(set_attr "type" "sselog")
9607    (set_attr "length_immediate" "1")
9608    (set_attr "prefix" "evex")
9609    (set_attr "mode" "<sseinsnmode>")])
9610
9611 (define_expand "avx512f_vinsert<shuffletype>64x4_mask"
9612   [(match_operand:V8FI 0 "register_operand")
9613    (match_operand:V8FI 1 "register_operand")
9614    (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand")
9615    (match_operand:SI 3 "const_0_to_1_operand")
9616    (match_operand:V8FI 4 "register_operand")
9617    (match_operand:<avx512fmaskmode> 5 "register_operand")]
9618   "TARGET_AVX512F"
9619 {
9620   int mask = INTVAL (operands[3]);
9621   if (mask == 0)
9622     emit_insn (gen_vec_set_lo_<mode>_mask
9623       (operands[0], operands[1], operands[2],
9624        operands[4], operands[5]));
9625   else
9626     emit_insn (gen_vec_set_hi_<mode>_mask
9627       (operands[0], operands[1], operands[2],
9628        operands[4], operands[5]));
9629   DONE;
9630 })
9631
9632 (define_insn "vec_set_lo_<mode><mask_name>"
9633   [(set (match_operand:V8FI 0 "register_operand" "=v")
9634         (vec_concat:V8FI
9635           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")
9636           (vec_select:<ssehalfvecmode>
9637             (match_operand:V8FI 1 "register_operand" "v")
9638             (parallel [(const_int 4) (const_int 5)
9639               (const_int 6) (const_int 7)]))))]
9640   "TARGET_AVX512F"
9641   "vinsert<shuffletype>64x4\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x0}"
9642   [(set_attr "type" "sselog")
9643    (set_attr "length_immediate" "1")
9644    (set_attr "prefix" "evex")
9645    (set_attr "mode" "XI")])
9646
9647 (define_insn "vec_set_hi_<mode><mask_name>"
9648   [(set (match_operand:V8FI 0 "register_operand" "=v")
9649         (vec_concat:V8FI
9650           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")
9651           (vec_select:<ssehalfvecmode>
9652             (match_operand:V8FI 1 "register_operand" "v")
9653             (parallel [(const_int 0) (const_int 1)
9654               (const_int 2) (const_int 3)]))))]
9655   "TARGET_AVX512F"
9656   "vinsert<shuffletype>64x4\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x1}"
9657   [(set_attr "type" "sselog")
9658    (set_attr "length_immediate" "1")
9659    (set_attr "prefix" "evex")
9660    (set_attr "mode" "XI")])
9661
9662 (define_expand "avx512f_shuf_<shuffletype>64x2_mask"
9663   [(match_operand:V8FI 0 "register_operand")
9664    (match_operand:V8FI 1 "register_operand")
9665    (match_operand:V8FI 2 "nonimmediate_operand")
9666    (match_operand:SI 3 "const_0_to_255_operand")
9667    (match_operand:V8FI 4 "register_operand")
9668    (match_operand:QI 5 "register_operand")]
9669   "TARGET_AVX512F"
9670 {
9671   int mask = INTVAL (operands[3]);
9672   emit_insn (gen_avx512f_shuf_<shuffletype>64x2_1_mask
9673       (operands[0], operands[1], operands[2],
9674        GEN_INT (((mask >> 0) & 3) * 2),
9675        GEN_INT (((mask >> 0) & 3) * 2 + 1),
9676        GEN_INT (((mask >> 2) & 3) * 2),
9677        GEN_INT (((mask >> 2) & 3) * 2 + 1),
9678        GEN_INT (((mask >> 4) & 3) * 2 + 8),
9679        GEN_INT (((mask >> 4) & 3) * 2 + 9),
9680        GEN_INT (((mask >> 6) & 3) * 2 + 8),
9681        GEN_INT (((mask >> 6) & 3) * 2 + 9),
9682        operands[4], operands[5]));
9683   DONE;
9684 })
9685
9686 (define_insn "avx512f_shuf_<shuffletype>64x2_1<mask_name>"
9687   [(set (match_operand:V8FI 0 "register_operand" "=v")
9688         (vec_select:V8FI
9689           (vec_concat:<ssedoublemode>
9690             (match_operand:V8FI 1 "register_operand" "v")
9691             (match_operand:V8FI 2 "nonimmediate_operand" "vm"))
9692           (parallel [(match_operand 3  "const_0_to_7_operand")
9693                      (match_operand 4  "const_0_to_7_operand")
9694                      (match_operand 5  "const_0_to_7_operand")
9695                      (match_operand 6  "const_0_to_7_operand")
9696                      (match_operand 7  "const_8_to_15_operand")
9697                      (match_operand 8  "const_8_to_15_operand")
9698                      (match_operand 9  "const_8_to_15_operand")
9699                      (match_operand 10  "const_8_to_15_operand")])))]
9700   "TARGET_AVX512F
9701    && (INTVAL (operands[3]) == (INTVAL (operands[4]) - 1)
9702        && INTVAL (operands[5]) == (INTVAL (operands[6]) - 1)
9703        && INTVAL (operands[7]) == (INTVAL (operands[8]) - 1)
9704        && INTVAL (operands[9]) == (INTVAL (operands[10]) - 1))"
9705 {
9706   int mask;
9707   mask = INTVAL (operands[3]) / 2;
9708   mask |= INTVAL (operands[5]) / 2 << 2;
9709   mask |= (INTVAL (operands[7]) - 8) / 2 << 4;
9710   mask |= (INTVAL (operands[9]) - 8) / 2 << 6;
9711   operands[3] = GEN_INT (mask);
9712
9713   return "vshuf<shuffletype>64x2\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
9714 }
9715   [(set_attr "type" "sselog")
9716    (set_attr "length_immediate" "1")
9717    (set_attr "prefix" "evex")
9718    (set_attr "mode" "<sseinsnmode>")])
9719
9720 (define_expand "avx512f_shuf_<shuffletype>32x4_mask"
9721   [(match_operand:V16FI 0 "register_operand")
9722    (match_operand:V16FI 1 "register_operand")
9723    (match_operand:V16FI 2 "nonimmediate_operand")
9724    (match_operand:SI 3 "const_0_to_255_operand")
9725    (match_operand:V16FI 4 "register_operand")
9726    (match_operand:HI 5 "register_operand")]
9727   "TARGET_AVX512F"
9728 {
9729   int mask = INTVAL (operands[3]);
9730   emit_insn (gen_avx512f_shuf_<shuffletype>32x4_1_mask
9731       (operands[0], operands[1], operands[2],
9732        GEN_INT (((mask >> 0) & 3) * 4),
9733        GEN_INT (((mask >> 0) & 3) * 4 + 1),
9734        GEN_INT (((mask >> 0) & 3) * 4 + 2),
9735        GEN_INT (((mask >> 0) & 3) * 4 + 3),
9736        GEN_INT (((mask >> 2) & 3) * 4),
9737        GEN_INT (((mask >> 2) & 3) * 4 + 1),
9738        GEN_INT (((mask >> 2) & 3) * 4 + 2),
9739        GEN_INT (((mask >> 2) & 3) * 4 + 3),
9740        GEN_INT (((mask >> 4) & 3) * 4 + 16),
9741        GEN_INT (((mask >> 4) & 3) * 4 + 17),
9742        GEN_INT (((mask >> 4) & 3) * 4 + 18),
9743        GEN_INT (((mask >> 4) & 3) * 4 + 19),
9744        GEN_INT (((mask >> 6) & 3) * 4 + 16),
9745        GEN_INT (((mask >> 6) & 3) * 4 + 17),
9746        GEN_INT (((mask >> 6) & 3) * 4 + 18),
9747        GEN_INT (((mask >> 6) & 3) * 4 + 19),
9748        operands[4], operands[5]));
9749   DONE;
9750 })
9751
9752 (define_insn "avx512f_shuf_<shuffletype>32x4_1<mask_name>"
9753   [(set (match_operand:V16FI 0 "register_operand" "=v")
9754         (vec_select:V16FI
9755           (vec_concat:<ssedoublemode>
9756             (match_operand:V16FI 1 "register_operand" "v")
9757             (match_operand:V16FI 2 "nonimmediate_operand" "vm"))
9758           (parallel [(match_operand 3  "const_0_to_15_operand")
9759                      (match_operand 4  "const_0_to_15_operand")
9760                      (match_operand 5  "const_0_to_15_operand")
9761                      (match_operand 6  "const_0_to_15_operand")
9762                      (match_operand 7  "const_0_to_15_operand")
9763                      (match_operand 8  "const_0_to_15_operand")
9764                      (match_operand 9  "const_0_to_15_operand")
9765                      (match_operand 10  "const_0_to_15_operand")
9766                      (match_operand 11  "const_16_to_31_operand")
9767                      (match_operand 12  "const_16_to_31_operand")
9768                      (match_operand 13  "const_16_to_31_operand")
9769                      (match_operand 14  "const_16_to_31_operand")
9770                      (match_operand 15  "const_16_to_31_operand")
9771                      (match_operand 16  "const_16_to_31_operand")
9772                      (match_operand 17  "const_16_to_31_operand")
9773                      (match_operand 18  "const_16_to_31_operand")])))]
9774   "TARGET_AVX512F
9775    && (INTVAL (operands[3]) == (INTVAL (operands[4]) - 1)
9776        && INTVAL (operands[3]) == (INTVAL (operands[5]) - 2)
9777        && INTVAL (operands[3]) == (INTVAL (operands[6]) - 3)
9778        && INTVAL (operands[7]) == (INTVAL (operands[8]) - 1)
9779        && INTVAL (operands[7]) == (INTVAL (operands[9]) - 2)
9780        && INTVAL (operands[7]) == (INTVAL (operands[10]) - 3)
9781        && INTVAL (operands[11]) == (INTVAL (operands[12]) - 1)
9782        && INTVAL (operands[11]) == (INTVAL (operands[13]) - 2)
9783        && INTVAL (operands[11]) == (INTVAL (operands[14]) - 3)
9784        && INTVAL (operands[15]) == (INTVAL (operands[16]) - 1)
9785        && INTVAL (operands[15]) == (INTVAL (operands[17]) - 2)
9786        && INTVAL (operands[15]) == (INTVAL (operands[18]) - 3))"
9787 {
9788   int mask;
9789   mask = INTVAL (operands[3]) / 4;
9790   mask |= INTVAL (operands[7]) / 4 << 2;
9791   mask |= (INTVAL (operands[11]) - 16) / 4 << 4;
9792   mask |= (INTVAL (operands[15]) - 16) / 4 << 6;
9793   operands[3] = GEN_INT (mask);
9794
9795   return "vshuf<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand19>|%0<mask_operand19>, %1, %2, %3}";
9796 }
9797   [(set_attr "type" "sselog")
9798    (set_attr "length_immediate" "1")
9799    (set_attr "prefix" "evex")
9800    (set_attr "mode" "<sseinsnmode>")])
9801
9802 (define_expand "avx512f_pshufdv3_mask"
9803   [(match_operand:V16SI 0 "register_operand")
9804    (match_operand:V16SI 1 "nonimmediate_operand")
9805    (match_operand:SI 2 "const_0_to_255_operand")
9806    (match_operand:V16SI 3 "register_operand")
9807    (match_operand:HI 4 "register_operand")]
9808   "TARGET_AVX512F"
9809 {
9810   int mask = INTVAL (operands[2]);
9811   emit_insn (gen_avx512f_pshufd_1_mask (operands[0], operands[1],
9812                                        GEN_INT ((mask >> 0) & 3),
9813                                        GEN_INT ((mask >> 2) & 3),
9814                                        GEN_INT ((mask >> 4) & 3),
9815                                        GEN_INT ((mask >> 6) & 3),
9816                                        GEN_INT (((mask >> 0) & 3) + 4),
9817                                        GEN_INT (((mask >> 2) & 3) + 4),
9818                                        GEN_INT (((mask >> 4) & 3) + 4),
9819                                        GEN_INT (((mask >> 6) & 3) + 4),
9820                                        GEN_INT (((mask >> 0) & 3) + 8),
9821                                        GEN_INT (((mask >> 2) & 3) + 8),
9822                                        GEN_INT (((mask >> 4) & 3) + 8),
9823                                        GEN_INT (((mask >> 6) & 3) + 8),
9824                                        GEN_INT (((mask >> 0) & 3) + 12),
9825                                        GEN_INT (((mask >> 2) & 3) + 12),
9826                                        GEN_INT (((mask >> 4) & 3) + 12),
9827                                        GEN_INT (((mask >> 6) & 3) + 12),
9828                                        operands[3], operands[4]));
9829   DONE;
9830 })
9831
9832 (define_insn "avx512f_pshufd_1<mask_name>"
9833   [(set (match_operand:V16SI 0 "register_operand" "=v")
9834         (vec_select:V16SI
9835           (match_operand:V16SI 1 "nonimmediate_operand" "vm")
9836           (parallel [(match_operand 2 "const_0_to_3_operand")
9837                      (match_operand 3 "const_0_to_3_operand")
9838                      (match_operand 4 "const_0_to_3_operand")
9839                      (match_operand 5 "const_0_to_3_operand")
9840                      (match_operand 6 "const_4_to_7_operand")
9841                      (match_operand 7 "const_4_to_7_operand")
9842                      (match_operand 8 "const_4_to_7_operand")
9843                      (match_operand 9 "const_4_to_7_operand")
9844                      (match_operand 10 "const_8_to_11_operand")
9845                      (match_operand 11 "const_8_to_11_operand")
9846                      (match_operand 12 "const_8_to_11_operand")
9847                      (match_operand 13 "const_8_to_11_operand")
9848                      (match_operand 14 "const_12_to_15_operand")
9849                      (match_operand 15 "const_12_to_15_operand")
9850                      (match_operand 16 "const_12_to_15_operand")
9851                      (match_operand 17 "const_12_to_15_operand")])))]
9852   "TARGET_AVX512F
9853    && INTVAL (operands[2]) + 4 == INTVAL (operands[6])
9854    && INTVAL (operands[3]) + 4 == INTVAL (operands[7])
9855    && INTVAL (operands[4]) + 4 == INTVAL (operands[8])
9856    && INTVAL (operands[5]) + 4 == INTVAL (operands[9])
9857    && INTVAL (operands[2]) + 8 == INTVAL (operands[10])
9858    && INTVAL (operands[3]) + 8 == INTVAL (operands[11])
9859    && INTVAL (operands[4]) + 8 == INTVAL (operands[12])
9860    && INTVAL (operands[5]) + 8 == INTVAL (operands[13])
9861    && INTVAL (operands[2]) + 12 == INTVAL (operands[14])
9862    && INTVAL (operands[3]) + 12 == INTVAL (operands[15])
9863    && INTVAL (operands[4]) + 12 == INTVAL (operands[16])
9864    && INTVAL (operands[5]) + 12 == INTVAL (operands[17])"
9865 {
9866   int mask = 0;
9867   mask |= INTVAL (operands[2]) << 0;
9868   mask |= INTVAL (operands[3]) << 2;
9869   mask |= INTVAL (operands[4]) << 4;
9870   mask |= INTVAL (operands[5]) << 6;
9871   operands[2] = GEN_INT (mask);
9872
9873   return "vpshufd\t{%2, %1, %0<mask_operand18>|%0<mask_operand18>, %1, %2}";
9874 }
9875   [(set_attr "type" "sselog1")
9876    (set_attr "prefix" "evex")
9877    (set_attr "length_immediate" "1")
9878    (set_attr "mode" "XI")])
9879
9880 (define_expand "avx2_pshufdv3"
9881   [(match_operand:V8SI 0 "register_operand")
9882    (match_operand:V8SI 1 "nonimmediate_operand")
9883    (match_operand:SI 2 "const_0_to_255_operand")]
9884   "TARGET_AVX2"
9885 {
9886   int mask = INTVAL (operands[2]);
9887   emit_insn (gen_avx2_pshufd_1 (operands[0], operands[1],
9888                                 GEN_INT ((mask >> 0) & 3),
9889                                 GEN_INT ((mask >> 2) & 3),
9890                                 GEN_INT ((mask >> 4) & 3),
9891                                 GEN_INT ((mask >> 6) & 3),
9892                                 GEN_INT (((mask >> 0) & 3) + 4),
9893                                 GEN_INT (((mask >> 2) & 3) + 4),
9894                                 GEN_INT (((mask >> 4) & 3) + 4),
9895                                 GEN_INT (((mask >> 6) & 3) + 4)));
9896   DONE;
9897 })
9898
9899 (define_insn "avx2_pshufd_1"
9900   [(set (match_operand:V8SI 0 "register_operand" "=x")
9901         (vec_select:V8SI
9902           (match_operand:V8SI 1 "nonimmediate_operand" "xm")
9903           (parallel [(match_operand 2 "const_0_to_3_operand")
9904                      (match_operand 3 "const_0_to_3_operand")
9905                      (match_operand 4 "const_0_to_3_operand")
9906                      (match_operand 5 "const_0_to_3_operand")
9907                      (match_operand 6 "const_4_to_7_operand")
9908                      (match_operand 7 "const_4_to_7_operand")
9909                      (match_operand 8 "const_4_to_7_operand")
9910                      (match_operand 9 "const_4_to_7_operand")])))]
9911   "TARGET_AVX2
9912    && INTVAL (operands[2]) + 4 == INTVAL (operands[6])
9913    && INTVAL (operands[3]) + 4 == INTVAL (operands[7])
9914    && INTVAL (operands[4]) + 4 == INTVAL (operands[8])
9915    && INTVAL (operands[5]) + 4 == INTVAL (operands[9])"
9916 {
9917   int mask = 0;
9918   mask |= INTVAL (operands[2]) << 0;
9919   mask |= INTVAL (operands[3]) << 2;
9920   mask |= INTVAL (operands[4]) << 4;
9921   mask |= INTVAL (operands[5]) << 6;
9922   operands[2] = GEN_INT (mask);
9923
9924   return "vpshufd\t{%2, %1, %0|%0, %1, %2}";
9925 }
9926   [(set_attr "type" "sselog1")
9927    (set_attr "prefix" "vex")
9928    (set_attr "length_immediate" "1")
9929    (set_attr "mode" "OI")])
9930
9931 (define_expand "sse2_pshufd"
9932   [(match_operand:V4SI 0 "register_operand")
9933    (match_operand:V4SI 1 "nonimmediate_operand")
9934    (match_operand:SI 2 "const_int_operand")]
9935   "TARGET_SSE2"
9936 {
9937   int mask = INTVAL (operands[2]);
9938   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
9939                                 GEN_INT ((mask >> 0) & 3),
9940                                 GEN_INT ((mask >> 2) & 3),
9941                                 GEN_INT ((mask >> 4) & 3),
9942                                 GEN_INT ((mask >> 6) & 3)));
9943   DONE;
9944 })
9945
9946 (define_insn "sse2_pshufd_1"
9947   [(set (match_operand:V4SI 0 "register_operand" "=x")
9948         (vec_select:V4SI
9949           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
9950           (parallel [(match_operand 2 "const_0_to_3_operand")
9951                      (match_operand 3 "const_0_to_3_operand")
9952                      (match_operand 4 "const_0_to_3_operand")
9953                      (match_operand 5 "const_0_to_3_operand")])))]
9954   "TARGET_SSE2"
9955 {
9956   int mask = 0;
9957   mask |= INTVAL (operands[2]) << 0;
9958   mask |= INTVAL (operands[3]) << 2;
9959   mask |= INTVAL (operands[4]) << 4;
9960   mask |= INTVAL (operands[5]) << 6;
9961   operands[2] = GEN_INT (mask);
9962
9963   return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
9964 }
9965   [(set_attr "type" "sselog1")
9966    (set_attr "prefix_data16" "1")
9967    (set_attr "prefix" "maybe_vex")
9968    (set_attr "length_immediate" "1")
9969    (set_attr "mode" "TI")])
9970
9971 (define_expand "avx2_pshuflwv3"
9972   [(match_operand:V16HI 0 "register_operand")
9973    (match_operand:V16HI 1 "nonimmediate_operand")
9974    (match_operand:SI 2 "const_0_to_255_operand")]
9975   "TARGET_AVX2"
9976 {
9977   int mask = INTVAL (operands[2]);
9978   emit_insn (gen_avx2_pshuflw_1 (operands[0], operands[1],
9979                                  GEN_INT ((mask >> 0) & 3),
9980                                  GEN_INT ((mask >> 2) & 3),
9981                                  GEN_INT ((mask >> 4) & 3),
9982                                  GEN_INT ((mask >> 6) & 3),
9983                                  GEN_INT (((mask >> 0) & 3) + 8),
9984                                  GEN_INT (((mask >> 2) & 3) + 8),
9985                                  GEN_INT (((mask >> 4) & 3) + 8),
9986                                  GEN_INT (((mask >> 6) & 3) + 8)));
9987   DONE;
9988 })
9989
9990 (define_insn "avx2_pshuflw_1"
9991   [(set (match_operand:V16HI 0 "register_operand" "=x")
9992         (vec_select:V16HI
9993           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
9994           (parallel [(match_operand 2 "const_0_to_3_operand")
9995                      (match_operand 3 "const_0_to_3_operand")
9996                      (match_operand 4 "const_0_to_3_operand")
9997                      (match_operand 5 "const_0_to_3_operand")
9998                      (const_int 4)
9999                      (const_int 5)
10000                      (const_int 6)
10001                      (const_int 7)
10002                      (match_operand 6 "const_8_to_11_operand")
10003                      (match_operand 7 "const_8_to_11_operand")
10004                      (match_operand 8 "const_8_to_11_operand")
10005                      (match_operand 9 "const_8_to_11_operand")
10006                      (const_int 12)
10007                      (const_int 13)
10008                      (const_int 14)
10009                      (const_int 15)])))]
10010   "TARGET_AVX2
10011    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
10012    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
10013    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
10014    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
10015 {
10016   int mask = 0;
10017   mask |= INTVAL (operands[2]) << 0;
10018   mask |= INTVAL (operands[3]) << 2;
10019   mask |= INTVAL (operands[4]) << 4;
10020   mask |= INTVAL (operands[5]) << 6;
10021   operands[2] = GEN_INT (mask);
10022
10023   return "vpshuflw\t{%2, %1, %0|%0, %1, %2}";
10024 }
10025   [(set_attr "type" "sselog")
10026    (set_attr "prefix" "vex")
10027    (set_attr "length_immediate" "1")
10028    (set_attr "mode" "OI")])
10029
10030 (define_expand "sse2_pshuflw"
10031   [(match_operand:V8HI 0 "register_operand")
10032    (match_operand:V8HI 1 "nonimmediate_operand")
10033    (match_operand:SI 2 "const_int_operand")]
10034   "TARGET_SSE2"
10035 {
10036   int mask = INTVAL (operands[2]);
10037   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
10038                                  GEN_INT ((mask >> 0) & 3),
10039                                  GEN_INT ((mask >> 2) & 3),
10040                                  GEN_INT ((mask >> 4) & 3),
10041                                  GEN_INT ((mask >> 6) & 3)));
10042   DONE;
10043 })
10044
10045 (define_insn "sse2_pshuflw_1"
10046   [(set (match_operand:V8HI 0 "register_operand" "=x")
10047         (vec_select:V8HI
10048           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10049           (parallel [(match_operand 2 "const_0_to_3_operand")
10050                      (match_operand 3 "const_0_to_3_operand")
10051                      (match_operand 4 "const_0_to_3_operand")
10052                      (match_operand 5 "const_0_to_3_operand")
10053                      (const_int 4)
10054                      (const_int 5)
10055                      (const_int 6)
10056                      (const_int 7)])))]
10057   "TARGET_SSE2"
10058 {
10059   int mask = 0;
10060   mask |= INTVAL (operands[2]) << 0;
10061   mask |= INTVAL (operands[3]) << 2;
10062   mask |= INTVAL (operands[4]) << 4;
10063   mask |= INTVAL (operands[5]) << 6;
10064   operands[2] = GEN_INT (mask);
10065
10066   return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
10067 }
10068   [(set_attr "type" "sselog")
10069    (set_attr "prefix_data16" "0")
10070    (set_attr "prefix_rep" "1")
10071    (set_attr "prefix" "maybe_vex")
10072    (set_attr "length_immediate" "1")
10073    (set_attr "mode" "TI")])
10074
10075 (define_expand "avx2_pshufhwv3"
10076   [(match_operand:V16HI 0 "register_operand")
10077    (match_operand:V16HI 1 "nonimmediate_operand")
10078    (match_operand:SI 2 "const_0_to_255_operand")]
10079   "TARGET_AVX2"
10080 {
10081   int mask = INTVAL (operands[2]);
10082   emit_insn (gen_avx2_pshufhw_1 (operands[0], operands[1],
10083                                  GEN_INT (((mask >> 0) & 3) + 4),
10084                                  GEN_INT (((mask >> 2) & 3) + 4),
10085                                  GEN_INT (((mask >> 4) & 3) + 4),
10086                                  GEN_INT (((mask >> 6) & 3) + 4),
10087                                  GEN_INT (((mask >> 0) & 3) + 12),
10088                                  GEN_INT (((mask >> 2) & 3) + 12),
10089                                  GEN_INT (((mask >> 4) & 3) + 12),
10090                                  GEN_INT (((mask >> 6) & 3) + 12)));
10091   DONE;
10092 })
10093
10094 (define_insn "avx2_pshufhw_1"
10095   [(set (match_operand:V16HI 0 "register_operand" "=x")
10096         (vec_select:V16HI
10097           (match_operand:V16HI 1 "nonimmediate_operand" "xm")
10098           (parallel [(const_int 0)
10099                      (const_int 1)
10100                      (const_int 2)
10101                      (const_int 3)
10102                      (match_operand 2 "const_4_to_7_operand")
10103                      (match_operand 3 "const_4_to_7_operand")
10104                      (match_operand 4 "const_4_to_7_operand")
10105                      (match_operand 5 "const_4_to_7_operand")
10106                      (const_int 8)
10107                      (const_int 9)
10108                      (const_int 10)
10109                      (const_int 11)
10110                      (match_operand 6 "const_12_to_15_operand")
10111                      (match_operand 7 "const_12_to_15_operand")
10112                      (match_operand 8 "const_12_to_15_operand")
10113                      (match_operand 9 "const_12_to_15_operand")])))]
10114   "TARGET_AVX2
10115    && INTVAL (operands[2]) + 8 == INTVAL (operands[6])
10116    && INTVAL (operands[3]) + 8 == INTVAL (operands[7])
10117    && INTVAL (operands[4]) + 8 == INTVAL (operands[8])
10118    && INTVAL (operands[5]) + 8 == INTVAL (operands[9])"
10119 {
10120   int mask = 0;
10121   mask |= (INTVAL (operands[2]) - 4) << 0;
10122   mask |= (INTVAL (operands[3]) - 4) << 2;
10123   mask |= (INTVAL (operands[4]) - 4) << 4;
10124   mask |= (INTVAL (operands[5]) - 4) << 6;
10125   operands[2] = GEN_INT (mask);
10126
10127   return "vpshufhw\t{%2, %1, %0|%0, %1, %2}";
10128 }
10129   [(set_attr "type" "sselog")
10130    (set_attr "prefix" "vex")
10131    (set_attr "length_immediate" "1")
10132    (set_attr "mode" "OI")])
10133
10134 (define_expand "sse2_pshufhw"
10135   [(match_operand:V8HI 0 "register_operand")
10136    (match_operand:V8HI 1 "nonimmediate_operand")
10137    (match_operand:SI 2 "const_int_operand")]
10138   "TARGET_SSE2"
10139 {
10140   int mask = INTVAL (operands[2]);
10141   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
10142                                  GEN_INT (((mask >> 0) & 3) + 4),
10143                                  GEN_INT (((mask >> 2) & 3) + 4),
10144                                  GEN_INT (((mask >> 4) & 3) + 4),
10145                                  GEN_INT (((mask >> 6) & 3) + 4)));
10146   DONE;
10147 })
10148
10149 (define_insn "sse2_pshufhw_1"
10150   [(set (match_operand:V8HI 0 "register_operand" "=x")
10151         (vec_select:V8HI
10152           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
10153           (parallel [(const_int 0)
10154                      (const_int 1)
10155                      (const_int 2)
10156                      (const_int 3)
10157                      (match_operand 2 "const_4_to_7_operand")
10158                      (match_operand 3 "const_4_to_7_operand")
10159                      (match_operand 4 "const_4_to_7_operand")
10160                      (match_operand 5 "const_4_to_7_operand")])))]
10161   "TARGET_SSE2"
10162 {
10163   int mask = 0;
10164   mask |= (INTVAL (operands[2]) - 4) << 0;
10165   mask |= (INTVAL (operands[3]) - 4) << 2;
10166   mask |= (INTVAL (operands[4]) - 4) << 4;
10167   mask |= (INTVAL (operands[5]) - 4) << 6;
10168   operands[2] = GEN_INT (mask);
10169
10170   return "%vpshufhw\t{%2, %1, %0|%0, %1, %2}";
10171 }
10172   [(set_attr "type" "sselog")
10173    (set_attr "prefix_rep" "1")
10174    (set_attr "prefix_data16" "0")
10175    (set_attr "prefix" "maybe_vex")
10176    (set_attr "length_immediate" "1")
10177    (set_attr "mode" "TI")])
10178
10179 (define_expand "sse2_loadd"
10180   [(set (match_operand:V4SI 0 "register_operand")
10181         (vec_merge:V4SI
10182           (vec_duplicate:V4SI
10183             (match_operand:SI 1 "nonimmediate_operand"))
10184           (match_dup 2)
10185           (const_int 1)))]
10186   "TARGET_SSE"
10187   "operands[2] = CONST0_RTX (V4SImode);")
10188
10189 (define_insn "sse2_loadld"
10190   [(set (match_operand:V4SI 0 "register_operand"       "=x,Yi,x,x,x")
10191         (vec_merge:V4SI
10192           (vec_duplicate:V4SI
10193             (match_operand:SI 2 "nonimmediate_operand" "m ,r ,m,x,x"))
10194           (match_operand:V4SI 1 "reg_or_0_operand"     "C ,C ,C,0,x")
10195           (const_int 1)))]
10196   "TARGET_SSE"
10197   "@
10198    %vmovd\t{%2, %0|%0, %2}
10199    %vmovd\t{%2, %0|%0, %2}
10200    movss\t{%2, %0|%0, %2}
10201    movss\t{%2, %0|%0, %2}
10202    vmovss\t{%2, %1, %0|%0, %1, %2}"
10203   [(set_attr "isa" "sse2,*,noavx,noavx,avx")
10204    (set_attr "type" "ssemov")
10205    (set_attr "prefix" "maybe_vex,maybe_vex,orig,orig,vex")
10206    (set_attr "mode" "TI,TI,V4SF,SF,SF")])
10207
10208 (define_insn "*vec_extract<mode>"
10209   [(set (match_operand:<ssescalarmode> 0 "nonimmediate_operand" "=r,m")
10210         (vec_select:<ssescalarmode>
10211           (match_operand:VI12_128 1 "register_operand" "x,x")
10212           (parallel
10213             [(match_operand:SI 2 "const_0_to_<ssescalarnummask>_operand")])))]
10214   "TARGET_SSE4_1"
10215   "@
10216    %vpextr<ssemodesuffix>\t{%2, %1, %k0|%k0, %1, %2}
10217    %vpextr<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10218   [(set_attr "type" "sselog1")
10219    (set (attr "prefix_data16")
10220      (if_then_else
10221        (and (eq_attr "alternative" "0")
10222             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
10223        (const_string "1")
10224        (const_string "*")))
10225    (set (attr "prefix_extra")
10226      (if_then_else
10227        (and (eq_attr "alternative" "0")
10228             (eq (const_string "<MODE>mode") (const_string "V8HImode")))
10229        (const_string "*")
10230        (const_string "1")))
10231    (set_attr "length_immediate" "1")
10232    (set_attr "prefix" "maybe_vex")
10233    (set_attr "mode" "TI")])
10234
10235 (define_insn "*vec_extractv8hi_sse2"
10236   [(set (match_operand:HI 0 "register_operand" "=r")
10237         (vec_select:HI
10238           (match_operand:V8HI 1 "register_operand" "x")
10239           (parallel
10240             [(match_operand:SI 2 "const_0_to_7_operand")])))]
10241   "TARGET_SSE2 && !TARGET_SSE4_1"
10242   "pextrw\t{%2, %1, %k0|%k0, %1, %2}"
10243   [(set_attr "type" "sselog1")
10244    (set_attr "prefix_data16" "1")
10245    (set_attr "length_immediate" "1")
10246    (set_attr "mode" "TI")])
10247
10248 (define_insn "*vec_extractv16qi_zext"
10249   [(set (match_operand:SWI48 0 "register_operand" "=r")
10250         (zero_extend:SWI48
10251           (vec_select:QI
10252             (match_operand:V16QI 1 "register_operand" "x")
10253             (parallel
10254               [(match_operand:SI 2 "const_0_to_15_operand")]))))]
10255   "TARGET_SSE4_1"
10256   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
10257   [(set_attr "type" "sselog1")
10258    (set_attr "prefix_extra" "1")
10259    (set_attr "length_immediate" "1")
10260    (set_attr "prefix" "maybe_vex")
10261    (set_attr "mode" "TI")])
10262
10263 (define_insn "*vec_extractv8hi_zext"
10264   [(set (match_operand:SWI48 0 "register_operand" "=r")
10265         (zero_extend:SWI48
10266           (vec_select:HI
10267             (match_operand:V8HI 1 "register_operand" "x")
10268             (parallel
10269               [(match_operand:SI 2 "const_0_to_7_operand")]))))]
10270   "TARGET_SSE2"
10271   "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
10272   [(set_attr "type" "sselog1")
10273    (set_attr "prefix_data16" "1")
10274    (set_attr "length_immediate" "1")
10275    (set_attr "prefix" "maybe_vex")
10276    (set_attr "mode" "TI")])
10277
10278 (define_insn "*vec_extract<mode>_mem"
10279   [(set (match_operand:<ssescalarmode> 0 "register_operand" "=r")
10280         (vec_select:<ssescalarmode>
10281           (match_operand:VI12_128 1 "memory_operand" "o")
10282           (parallel
10283             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
10284   "TARGET_SSE"
10285   "#")
10286
10287 (define_insn "*vec_extract<ssevecmodelower>_0"
10288   [(set (match_operand:SWI48 0 "nonimmediate_operand"          "=r ,r,x ,m")
10289         (vec_select:SWI48
10290           (match_operand:<ssevecmode> 1 "nonimmediate_operand" "mYj,x,xm,x")
10291           (parallel [(const_int 0)])))]
10292   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10293   "#"
10294   [(set_attr "isa" "*,sse4,*,*")])
10295
10296 (define_insn_and_split "*vec_extractv4si_0_zext"
10297   [(set (match_operand:DI 0 "register_operand" "=r")
10298         (zero_extend:DI
10299           (vec_select:SI
10300             (match_operand:V4SI 1 "register_operand" "x")
10301             (parallel [(const_int 0)]))))]
10302   "TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_FROM_VEC"
10303   "#"
10304   "&& reload_completed"
10305   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
10306   "operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));")
10307
10308 (define_insn "*vec_extractv2di_0_sse"
10309   [(set (match_operand:DI 0 "nonimmediate_operand"     "=x,m")
10310         (vec_select:DI
10311           (match_operand:V2DI 1 "nonimmediate_operand" "xm,x")
10312           (parallel [(const_int 0)])))]
10313   "TARGET_SSE && !TARGET_64BIT
10314    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10315   "#")
10316
10317 (define_split
10318   [(set (match_operand:SWI48x 0 "nonimmediate_operand")
10319         (vec_select:SWI48x
10320           (match_operand:<ssevecmode> 1 "register_operand")
10321           (parallel [(const_int 0)])))]
10322   "TARGET_SSE && reload_completed"
10323   [(set (match_dup 0) (match_dup 1))]
10324   "operands[1] = gen_rtx_REG (<MODE>mode, REGNO (operands[1]));")
10325
10326 (define_insn "*vec_extractv4si"
10327   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,x,x")
10328         (vec_select:SI
10329           (match_operand:V4SI 1 "register_operand" "x,0,x")
10330           (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
10331   "TARGET_SSE4_1"
10332 {
10333   switch (which_alternative)
10334     {
10335     case 0:
10336       return "%vpextrd\t{%2, %1, %0|%0, %1, %2}";
10337
10338     case 1:
10339       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
10340       return "psrldq\t{%2, %0|%0, %2}";
10341
10342     case 2:
10343       operands [2] = GEN_INT (INTVAL (operands[2]) * 4);
10344       return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
10345
10346     default:
10347       gcc_unreachable ();
10348     }
10349 }
10350   [(set_attr "isa" "*,noavx,avx")
10351    (set_attr "type" "sselog1,sseishft1,sseishft1")
10352    (set_attr "prefix_extra" "1,*,*")
10353    (set_attr "length_immediate" "1")
10354    (set_attr "prefix" "maybe_vex,orig,vex")
10355    (set_attr "mode" "TI")])
10356
10357 (define_insn "*vec_extractv4si_zext"
10358   [(set (match_operand:DI 0 "register_operand" "=r")
10359         (zero_extend:DI
10360           (vec_select:SI
10361             (match_operand:V4SI 1 "register_operand" "x")
10362             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
10363   "TARGET_64BIT && TARGET_SSE4_1"
10364   "%vpextrd\t{%2, %1, %k0|%k0, %1, %2}"
10365   [(set_attr "type" "sselog1")
10366    (set_attr "prefix_extra" "1")
10367    (set_attr "length_immediate" "1")
10368    (set_attr "prefix" "maybe_vex")
10369    (set_attr "mode" "TI")])
10370
10371 (define_insn "*vec_extractv4si_mem"
10372   [(set (match_operand:SI 0 "register_operand" "=x,r")
10373         (vec_select:SI
10374           (match_operand:V4SI 1 "memory_operand" "o,o")
10375           (parallel [(match_operand 2 "const_0_to_3_operand")])))]
10376   "TARGET_SSE"
10377   "#")
10378
10379 (define_insn_and_split "*vec_extractv4si_zext_mem"
10380   [(set (match_operand:DI 0 "register_operand" "=x,r")
10381         (zero_extend:DI
10382           (vec_select:SI
10383             (match_operand:V4SI 1 "memory_operand" "o,o")
10384             (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
10385   "TARGET_64BIT && TARGET_SSE"
10386   "#"
10387   "&& reload_completed"
10388   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
10389 {
10390   operands[1] = adjust_address (operands[1], SImode, INTVAL (operands[2]) * 4);
10391 })
10392
10393 (define_insn "*vec_extractv2di_1"
10394   [(set (match_operand:DI 0 "nonimmediate_operand"     "=rm,m,x,x,x,x,r")
10395         (vec_select:DI
10396           (match_operand:V2DI 1 "nonimmediate_operand"  "x ,x,0,x,x,o,o")
10397           (parallel [(const_int 1)])))]
10398   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
10399   "@
10400    %vpextrq\t{$1, %1, %0|%0, %1, 1}
10401    %vmovhps\t{%1, %0|%0, %1}
10402    psrldq\t{$8, %0|%0, 8}
10403    vpsrldq\t{$8, %1, %0|%0, %1, 8}
10404    movhlps\t{%1, %0|%0, %1}
10405    #
10406    #"
10407   [(set_attr "isa" "x64_sse4,*,sse2_noavx,avx,noavx,*,x64")
10408    (set_attr "type" "sselog1,ssemov,sseishft1,sseishft1,ssemov,ssemov,imov")
10409    (set_attr "length_immediate" "1,*,1,1,*,*,*")
10410    (set_attr "prefix_rex" "1,*,*,*,*,*,*")
10411    (set_attr "prefix_extra" "1,*,*,*,*,*,*")
10412    (set_attr "prefix" "maybe_vex,maybe_vex,orig,vex,orig,*,*")
10413    (set_attr "mode" "TI,V2SF,TI,TI,V4SF,DI,DI")])
10414
10415 (define_split
10416   [(set (match_operand:<ssescalarmode> 0 "register_operand")
10417         (vec_select:<ssescalarmode>
10418           (match_operand:VI_128 1 "memory_operand")
10419           (parallel
10420             [(match_operand 2 "const_0_to_<ssescalarnummask>_operand")])))]
10421   "TARGET_SSE && reload_completed"
10422   [(set (match_dup 0) (match_dup 1))]
10423 {
10424   int offs = INTVAL (operands[2]) * GET_MODE_SIZE (<ssescalarmode>mode);
10425
10426   operands[1] = adjust_address (operands[1], <ssescalarmode>mode, offs);
10427 })
10428
10429 (define_insn "*vec_dupv4si"
10430   [(set (match_operand:V4SI 0 "register_operand"     "=x,x,x")
10431         (vec_duplicate:V4SI
10432           (match_operand:SI 1 "nonimmediate_operand" " x,m,0")))]
10433   "TARGET_SSE"
10434   "@
10435    %vpshufd\t{$0, %1, %0|%0, %1, 0}
10436    vbroadcastss\t{%1, %0|%0, %1}
10437    shufps\t{$0, %0, %0|%0, %0, 0}"
10438   [(set_attr "isa" "sse2,avx,noavx")
10439    (set_attr "type" "sselog1,ssemov,sselog1")
10440    (set_attr "length_immediate" "1,0,1")
10441    (set_attr "prefix_extra" "0,1,*")
10442    (set_attr "prefix" "maybe_vex,vex,orig")
10443    (set_attr "mode" "TI,V4SF,V4SF")])
10444
10445 (define_insn "*vec_dupv2di"
10446   [(set (match_operand:V2DI 0 "register_operand"     "=x,x,x,x")
10447         (vec_duplicate:V2DI
10448           (match_operand:DI 1 "nonimmediate_operand" " 0,x,m,0")))]
10449   "TARGET_SSE"
10450   "@
10451    punpcklqdq\t%0, %0
10452    vpunpcklqdq\t{%d1, %0|%0, %d1}
10453    %vmovddup\t{%1, %0|%0, %1}
10454    movlhps\t%0, %0"
10455   [(set_attr "isa" "sse2_noavx,avx,sse3,noavx")
10456    (set_attr "type" "sselog1,sselog1,sselog1,ssemov")
10457    (set_attr "prefix" "orig,vex,maybe_vex,orig")
10458    (set_attr "mode" "TI,TI,DF,V4SF")])
10459
10460 (define_insn "*vec_concatv2si_sse4_1"
10461   [(set (match_operand:V2SI 0 "register_operand"     "=x, x,x,x, x, *y,*y")
10462         (vec_concat:V2SI
10463           (match_operand:SI 1 "nonimmediate_operand" " 0, x,0,x,rm,  0,rm")
10464           (match_operand:SI 2 "vector_move_operand"  "rm,rm,x,x, C,*ym, C")))]
10465   "TARGET_SSE4_1"
10466   "@
10467    pinsrd\t{$1, %2, %0|%0, %2, 1}
10468    vpinsrd\t{$1, %2, %1, %0|%0, %1, %2, 1}
10469    punpckldq\t{%2, %0|%0, %2}
10470    vpunpckldq\t{%2, %1, %0|%0, %1, %2}
10471    %vmovd\t{%1, %0|%0, %1}
10472    punpckldq\t{%2, %0|%0, %2}
10473    movd\t{%1, %0|%0, %1}"
10474   [(set_attr "isa" "noavx,avx,noavx,avx,*,*,*")
10475    (set_attr "type" "sselog,sselog,sselog,sselog,ssemov,mmxcvt,mmxmov")
10476    (set_attr "prefix_extra" "1,1,*,*,*,*,*")
10477    (set_attr "length_immediate" "1,1,*,*,*,*,*")
10478    (set_attr "prefix" "orig,vex,orig,vex,maybe_vex,orig,orig")
10479    (set_attr "mode" "TI,TI,TI,TI,TI,DI,DI")])
10480
10481 ;; ??? In theory we can match memory for the MMX alternative, but allowing
10482 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
10483 ;; alternatives pretty much forces the MMX alternative to be chosen.
10484 (define_insn "*vec_concatv2si"
10485   [(set (match_operand:V2SI 0 "register_operand"     "=x,x ,*y,x,x,*y,*y")
10486         (vec_concat:V2SI
10487           (match_operand:SI 1 "nonimmediate_operand" " 0,rm,rm,0,m, 0,*rm")
10488           (match_operand:SI 2 "reg_or_0_operand"     " x,C ,C, x,C,*y,C")))]
10489   "TARGET_SSE && !TARGET_SSE4_1"
10490   "@
10491    punpckldq\t{%2, %0|%0, %2}
10492    movd\t{%1, %0|%0, %1}
10493    movd\t{%1, %0|%0, %1}
10494    unpcklps\t{%2, %0|%0, %2}
10495    movss\t{%1, %0|%0, %1}
10496    punpckldq\t{%2, %0|%0, %2}
10497    movd\t{%1, %0|%0, %1}"
10498   [(set_attr "isa" "sse2,sse2,sse2,*,*,*,*")
10499    (set_attr "type" "sselog,ssemov,mmxmov,sselog,ssemov,mmxcvt,mmxmov")
10500    (set_attr "mode" "TI,TI,DI,V4SF,SF,DI,DI")])
10501
10502 (define_insn "*vec_concatv4si"
10503   [(set (match_operand:V4SI 0 "register_operand"       "=x,x,x,x,x")
10504         (vec_concat:V4SI
10505           (match_operand:V2SI 1 "register_operand"     " 0,x,0,0,x")
10506           (match_operand:V2SI 2 "nonimmediate_operand" " x,x,x,m,m")))]
10507   "TARGET_SSE"
10508   "@
10509    punpcklqdq\t{%2, %0|%0, %2}
10510    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
10511    movlhps\t{%2, %0|%0, %2}
10512    movhps\t{%2, %0|%0, %q2}
10513    vmovhps\t{%2, %1, %0|%0, %1, %q2}"
10514   [(set_attr "isa" "sse2_noavx,avx,noavx,noavx,avx")
10515    (set_attr "type" "sselog,sselog,ssemov,ssemov,ssemov")
10516    (set_attr "prefix" "orig,vex,orig,orig,vex")
10517    (set_attr "mode" "TI,TI,V4SF,V2SF,V2SF")])
10518
10519 ;; movd instead of movq is required to handle broken assemblers.
10520 (define_insn "vec_concatv2di"
10521   [(set (match_operand:V2DI 0 "register_operand"
10522           "=x,x ,Yi,x ,!x,x,x,x,x,x")
10523         (vec_concat:V2DI
10524           (match_operand:DI 1 "nonimmediate_operand"
10525           " 0,x ,r ,xm,*y,0,x,0,0,x")
10526           (match_operand:DI 2 "vector_move_operand"
10527           "rm,rm,C ,C ,C ,x,x,x,m,m")))]
10528   "TARGET_SSE"
10529   "@
10530    pinsrq\t{$1, %2, %0|%0, %2, 1}
10531    vpinsrq\t{$1, %2, %1, %0|%0, %1, %2, 1}
10532    * return HAVE_AS_IX86_INTERUNIT_MOVQ ? \"%vmovq\t{%1, %0|%0, %1}\" : \"%vmovd\t{%1, %0|%0, %1}\";
10533    %vmovq\t{%1, %0|%0, %1}
10534    movq2dq\t{%1, %0|%0, %1}
10535    punpcklqdq\t{%2, %0|%0, %2}
10536    vpunpcklqdq\t{%2, %1, %0|%0, %1, %2}
10537    movlhps\t{%2, %0|%0, %2}
10538    movhps\t{%2, %0|%0, %2}
10539    vmovhps\t{%2, %1, %0|%0, %1, %2}"
10540   [(set_attr "isa" "x64_sse4_noavx,x64_avx,x64,sse2,sse2,sse2_noavx,avx,noavx,noavx,avx")
10541    (set (attr "type")
10542      (if_then_else
10543        (eq_attr "alternative" "0,1,5,6")
10544        (const_string "sselog")
10545        (const_string "ssemov")))
10546    (set_attr "prefix_rex" "1,1,1,*,*,*,*,*,*,*")
10547    (set_attr "prefix_extra" "1,1,*,*,*,*,*,*,*,*")
10548    (set_attr "length_immediate" "1,1,*,*,*,*,*,*,*,*")
10549    (set_attr "prefix" "orig,vex,maybe_vex,maybe_vex,orig,orig,vex,orig,orig,vex")
10550    (set_attr "mode" "TI,TI,TI,TI,TI,TI,TI,V4SF,V2SF,V2SF")])
10551
10552 (define_expand "vec_unpacks_lo_<mode>"
10553   [(match_operand:<sseunpackmode> 0 "register_operand")
10554    (match_operand:VI124_AVX512F 1 "register_operand")]
10555   "TARGET_SSE2"
10556   "ix86_expand_sse_unpack (operands[0], operands[1], false, false); DONE;")
10557
10558 (define_expand "vec_unpacks_hi_<mode>"
10559   [(match_operand:<sseunpackmode> 0 "register_operand")
10560    (match_operand:VI124_AVX512F 1 "register_operand")]
10561   "TARGET_SSE2"
10562   "ix86_expand_sse_unpack (operands[0], operands[1], false, true); DONE;")
10563
10564 (define_expand "vec_unpacku_lo_<mode>"
10565   [(match_operand:<sseunpackmode> 0 "register_operand")
10566    (match_operand:VI124_AVX512F 1 "register_operand")]
10567   "TARGET_SSE2"
10568   "ix86_expand_sse_unpack (operands[0], operands[1], true, false); DONE;")
10569
10570 (define_expand "vec_unpacku_hi_<mode>"
10571   [(match_operand:<sseunpackmode> 0 "register_operand")
10572    (match_operand:VI124_AVX512F 1 "register_operand")]
10573   "TARGET_SSE2"
10574   "ix86_expand_sse_unpack (operands[0], operands[1], true, true); DONE;")
10575
10576 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10577 ;;
10578 ;; Miscellaneous
10579 ;;
10580 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10581
10582 (define_expand "<sse2_avx2>_uavg<mode>3"
10583   [(set (match_operand:VI12_AVX2 0 "register_operand")
10584         (truncate:VI12_AVX2
10585           (lshiftrt:<ssedoublemode>
10586             (plus:<ssedoublemode>
10587               (plus:<ssedoublemode>
10588                 (zero_extend:<ssedoublemode>
10589                   (match_operand:VI12_AVX2 1 "nonimmediate_operand"))
10590                 (zero_extend:<ssedoublemode>
10591                   (match_operand:VI12_AVX2 2 "nonimmediate_operand")))
10592               (match_dup 3))
10593             (const_int 1))))]
10594   "TARGET_SSE2"
10595 {
10596   operands[3] = CONST1_RTX(<MODE>mode);
10597   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
10598 })
10599
10600 (define_insn "*<sse2_avx2>_uavg<mode>3"
10601   [(set (match_operand:VI12_AVX2 0 "register_operand" "=x,x")
10602         (truncate:VI12_AVX2
10603           (lshiftrt:<ssedoublemode>
10604             (plus:<ssedoublemode>
10605               (plus:<ssedoublemode>
10606                 (zero_extend:<ssedoublemode>
10607                   (match_operand:VI12_AVX2 1 "nonimmediate_operand" "%0,x"))
10608                 (zero_extend:<ssedoublemode>
10609                   (match_operand:VI12_AVX2 2 "nonimmediate_operand" "xm,xm")))
10610               (match_operand:VI12_AVX2 3 "const1_operand"))
10611             (const_int 1))))]
10612   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
10613   "@
10614    pavg<ssemodesuffix>\t{%2, %0|%0, %2}
10615    vpavg<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
10616   [(set_attr "isa" "noavx,avx")
10617    (set_attr "type" "sseiadd")
10618    (set_attr "prefix_data16" "1,*")
10619    (set_attr "prefix" "orig,vex")
10620    (set_attr "mode" "<sseinsnmode>")])
10621
10622 ;; The correct representation for this is absolutely enormous, and
10623 ;; surely not generally useful.
10624 (define_insn "<sse2_avx2>_psadbw"
10625   [(set (match_operand:VI8_AVX2 0 "register_operand" "=x,x")
10626         (unspec:VI8_AVX2
10627           [(match_operand:<ssebytemode> 1 "register_operand" "0,x")
10628            (match_operand:<ssebytemode> 2 "nonimmediate_operand" "xm,xm")]
10629           UNSPEC_PSADBW))]
10630   "TARGET_SSE2"
10631   "@
10632    psadbw\t{%2, %0|%0, %2}
10633    vpsadbw\t{%2, %1, %0|%0, %1, %2}"
10634   [(set_attr "isa" "noavx,avx")
10635    (set_attr "type" "sseiadd")
10636    (set_attr "atom_unit" "simul")
10637    (set_attr "prefix_data16" "1,*")
10638    (set_attr "prefix" "orig,vex")
10639    (set_attr "mode" "<sseinsnmode>")])
10640
10641 (define_insn "<sse>_movmsk<ssemodesuffix><avxsizesuffix>"
10642   [(set (match_operand:SI 0 "register_operand" "=r")
10643         (unspec:SI
10644           [(match_operand:VF_128_256 1 "register_operand" "x")]
10645           UNSPEC_MOVMSK))]
10646   "TARGET_SSE"
10647   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
10648   [(set_attr "type" "ssemov")
10649    (set_attr "prefix" "maybe_vex")
10650    (set_attr "mode" "<MODE>")])
10651
10652 (define_insn "avx2_pmovmskb"
10653   [(set (match_operand:SI 0 "register_operand" "=r")
10654         (unspec:SI [(match_operand:V32QI 1 "register_operand" "x")]
10655                    UNSPEC_MOVMSK))]
10656   "TARGET_AVX2"
10657   "vpmovmskb\t{%1, %0|%0, %1}"
10658   [(set_attr "type" "ssemov")
10659    (set_attr "prefix" "vex")
10660    (set_attr "mode" "DI")])
10661
10662 (define_insn "sse2_pmovmskb"
10663   [(set (match_operand:SI 0 "register_operand" "=r")
10664         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
10665                    UNSPEC_MOVMSK))]
10666   "TARGET_SSE2"
10667   "%vpmovmskb\t{%1, %0|%0, %1}"
10668   [(set_attr "type" "ssemov")
10669    (set_attr "prefix_data16" "1")
10670    (set_attr "prefix" "maybe_vex")
10671    (set_attr "mode" "SI")])
10672
10673 (define_expand "sse2_maskmovdqu"
10674   [(set (match_operand:V16QI 0 "memory_operand")
10675         (unspec:V16QI [(match_operand:V16QI 1 "register_operand")
10676                        (match_operand:V16QI 2 "register_operand")
10677                        (match_dup 0)]
10678                       UNSPEC_MASKMOV))]
10679   "TARGET_SSE2")
10680
10681 (define_insn "*sse2_maskmovdqu"
10682   [(set (mem:V16QI (match_operand:P 0 "register_operand" "D"))
10683         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
10684                        (match_operand:V16QI 2 "register_operand" "x")
10685                        (mem:V16QI (match_dup 0))]
10686                       UNSPEC_MASKMOV))]
10687   "TARGET_SSE2"
10688 {
10689   /* We can't use %^ here due to ASM_OUTPUT_OPCODE processing
10690      that requires %v to be at the beginning of the opcode name.  */
10691   if (Pmode != word_mode)
10692     fputs ("\taddr32", asm_out_file);
10693   return "%vmaskmovdqu\t{%2, %1|%1, %2}";
10694 }
10695   [(set_attr "type" "ssemov")
10696    (set_attr "prefix_data16" "1")
10697    (set (attr "length_address")
10698      (symbol_ref ("Pmode != word_mode")))
10699    ;; The implicit %rdi operand confuses default length_vex computation.
10700    (set (attr "length_vex")
10701      (symbol_ref ("3 + REX_SSE_REGNO_P (REGNO (operands[2]))")))
10702    (set_attr "prefix" "maybe_vex")
10703    (set_attr "mode" "TI")])
10704
10705 (define_insn "sse_ldmxcsr"
10706   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
10707                     UNSPECV_LDMXCSR)]
10708   "TARGET_SSE"
10709   "%vldmxcsr\t%0"
10710   [(set_attr "type" "sse")
10711    (set_attr "atom_sse_attr" "mxcsr")
10712    (set_attr "prefix" "maybe_vex")
10713    (set_attr "memory" "load")])
10714
10715 (define_insn "sse_stmxcsr"
10716   [(set (match_operand:SI 0 "memory_operand" "=m")
10717         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
10718   "TARGET_SSE"
10719   "%vstmxcsr\t%0"
10720   [(set_attr "type" "sse")
10721    (set_attr "atom_sse_attr" "mxcsr")
10722    (set_attr "prefix" "maybe_vex")
10723    (set_attr "memory" "store")])
10724
10725 (define_insn "sse2_clflush"
10726   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
10727                     UNSPECV_CLFLUSH)]
10728   "TARGET_SSE2"
10729   "clflush\t%a0"
10730   [(set_attr "type" "sse")
10731    (set_attr "atom_sse_attr" "fence")
10732    (set_attr "memory" "unknown")])
10733
10734
10735 (define_insn "sse3_mwait"
10736   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
10737                      (match_operand:SI 1 "register_operand" "c")]
10738                     UNSPECV_MWAIT)]
10739   "TARGET_SSE3"
10740 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
10741 ;; Since 32bit register operands are implicitly zero extended to 64bit,
10742 ;; we only need to set up 32bit registers.
10743   "mwait"
10744   [(set_attr "length" "3")])
10745
10746 (define_insn "sse3_monitor_<mode>"
10747   [(unspec_volatile [(match_operand:P 0 "register_operand" "a")
10748                      (match_operand:SI 1 "register_operand" "c")
10749                      (match_operand:SI 2 "register_operand" "d")]
10750                     UNSPECV_MONITOR)]
10751   "TARGET_SSE3"
10752 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
10753 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
10754 ;; zero extended to 64bit, we only need to set up 32bit registers.
10755   "%^monitor"
10756   [(set (attr "length")
10757      (symbol_ref ("(Pmode != word_mode) + 3")))])
10758
10759 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10760 ;;
10761 ;; SSSE3 instructions
10762 ;;
10763 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
10764
10765 (define_code_iterator ssse3_plusminus [plus ss_plus minus ss_minus])
10766
10767 (define_insn "avx2_ph<plusminus_mnemonic>wv16hi3"
10768   [(set (match_operand:V16HI 0 "register_operand" "=x")
10769         (vec_concat:V16HI
10770           (vec_concat:V8HI
10771             (vec_concat:V4HI
10772               (vec_concat:V2HI
10773                 (ssse3_plusminus:HI
10774                   (vec_select:HI
10775                     (match_operand:V16HI 1 "register_operand" "x")
10776                     (parallel [(const_int 0)]))
10777                   (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
10778                 (ssse3_plusminus:HI
10779                   (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
10780                   (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
10781               (vec_concat:V2HI
10782                 (ssse3_plusminus:HI
10783                   (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
10784                   (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
10785                 (ssse3_plusminus:HI
10786                   (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
10787                   (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
10788             (vec_concat:V4HI
10789               (vec_concat:V2HI
10790                 (ssse3_plusminus:HI
10791                   (vec_select:HI (match_dup 1) (parallel [(const_int 8)]))
10792                   (vec_select:HI (match_dup 1) (parallel [(const_int 9)])))
10793                 (ssse3_plusminus:HI
10794                   (vec_select:HI (match_dup 1) (parallel [(const_int 10)]))
10795                   (vec_select:HI (match_dup 1) (parallel [(const_int 11)]))))
10796               (vec_concat:V2HI
10797                 (ssse3_plusminus:HI
10798                   (vec_select:HI (match_dup 1) (parallel [(const_int 12)]))
10799                   (vec_select:HI (match_dup 1) (parallel [(const_int 13)])))
10800                 (ssse3_plusminus:HI
10801                   (vec_select:HI (match_dup 1) (parallel [(const_int 14)]))
10802                   (vec_select:HI (match_dup 1) (parallel [(const_int 15)]))))))
10803           (vec_concat:V8HI
10804             (vec_concat:V4HI
10805               (vec_concat:V2HI
10806                 (ssse3_plusminus:HI
10807                   (vec_select:HI
10808                     (match_operand:V16HI 2 "nonimmediate_operand" "xm")
10809                     (parallel [(const_int 0)]))
10810                   (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
10811                 (ssse3_plusminus:HI
10812                   (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
10813                   (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
10814               (vec_concat:V2HI
10815                 (ssse3_plusminus:HI
10816                   (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
10817                   (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
10818                 (ssse3_plusminus:HI
10819                   (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
10820                   (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))
10821             (vec_concat:V4HI
10822               (vec_concat:V2HI
10823                 (ssse3_plusminus:HI
10824                   (vec_select:HI (match_dup 2) (parallel [(const_int 8)]))
10825                   (vec_select:HI (match_dup 2) (parallel [(const_int 9)])))
10826                 (ssse3_plusminus:HI
10827                   (vec_select:HI (match_dup 2) (parallel [(const_int 10)]))
10828                   (vec_select:HI (match_dup 2) (parallel [(const_int 11)]))))
10829               (vec_concat:V2HI
10830                 (ssse3_plusminus:HI
10831                   (vec_select:HI (match_dup 2) (parallel [(const_int 12)]))
10832                   (vec_select:HI (match_dup 2) (parallel [(const_int 13)])))
10833                 (ssse3_plusminus:HI
10834                   (vec_select:HI (match_dup 2) (parallel [(const_int 14)]))
10835                   (vec_select:HI (match_dup 2) (parallel [(const_int 15)]))))))))]
10836   "TARGET_AVX2"
10837   "vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
10838   [(set_attr "type" "sseiadd")
10839    (set_attr "prefix_extra" "1")
10840    (set_attr "prefix" "vex")
10841    (set_attr "mode" "OI")])
10842
10843 (define_insn "ssse3_ph<plusminus_mnemonic>wv8hi3"
10844   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
10845         (vec_concat:V8HI
10846           (vec_concat:V4HI
10847             (vec_concat:V2HI
10848               (ssse3_plusminus:HI
10849                 (vec_select:HI
10850                   (match_operand:V8HI 1 "register_operand" "0,x")
10851                   (parallel [(const_int 0)]))
10852                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
10853               (ssse3_plusminus:HI
10854                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
10855                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
10856             (vec_concat:V2HI
10857               (ssse3_plusminus:HI
10858                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
10859                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
10860               (ssse3_plusminus:HI
10861                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
10862                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
10863           (vec_concat:V4HI
10864             (vec_concat:V2HI
10865               (ssse3_plusminus:HI
10866                 (vec_select:HI
10867                   (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
10868                   (parallel [(const_int 0)]))
10869                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
10870               (ssse3_plusminus:HI
10871                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
10872                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
10873             (vec_concat:V2HI
10874               (ssse3_plusminus:HI
10875                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
10876                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
10877               (ssse3_plusminus:HI
10878                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
10879                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
10880   "TARGET_SSSE3"
10881   "@
10882    ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}
10883    vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
10884   [(set_attr "isa" "noavx,avx")
10885    (set_attr "type" "sseiadd")
10886    (set_attr "atom_unit" "complex")
10887    (set_attr "prefix_data16" "1,*")
10888    (set_attr "prefix_extra" "1")
10889    (set_attr "prefix" "orig,vex")
10890    (set_attr "mode" "TI")])
10891
10892 (define_insn "ssse3_ph<plusminus_mnemonic>wv4hi3"
10893   [(set (match_operand:V4HI 0 "register_operand" "=y")
10894         (vec_concat:V4HI
10895           (vec_concat:V2HI
10896             (ssse3_plusminus:HI
10897               (vec_select:HI
10898                 (match_operand:V4HI 1 "register_operand" "0")
10899                 (parallel [(const_int 0)]))
10900               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
10901             (ssse3_plusminus:HI
10902               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
10903               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
10904           (vec_concat:V2HI
10905             (ssse3_plusminus:HI
10906               (vec_select:HI
10907                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
10908                 (parallel [(const_int 0)]))
10909               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
10910             (ssse3_plusminus:HI
10911               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
10912               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
10913   "TARGET_SSSE3"
10914   "ph<plusminus_mnemonic>w\t{%2, %0|%0, %2}"
10915   [(set_attr "type" "sseiadd")
10916    (set_attr "atom_unit" "complex")
10917    (set_attr "prefix_extra" "1")
10918    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
10919    (set_attr "mode" "DI")])
10920
10921 (define_insn "avx2_ph<plusminus_mnemonic>dv8si3"
10922   [(set (match_operand:V8SI 0 "register_operand" "=x")
10923         (vec_concat:V8SI
10924           (vec_concat:V4SI
10925             (vec_concat:V2SI
10926               (plusminus:SI
10927                 (vec_select:SI
10928                   (match_operand:V8SI 1 "register_operand" "x")
10929                   (parallel [(const_int 0)]))
10930                 (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
10931               (plusminus:SI
10932                 (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
10933                 (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
10934             (vec_concat:V2SI
10935               (plusminus:SI
10936                 (vec_select:SI (match_dup 1) (parallel [(const_int 4)]))
10937                 (vec_select:SI (match_dup 1) (parallel [(const_int 5)])))
10938               (plusminus:SI
10939                 (vec_select:SI (match_dup 1) (parallel [(const_int 6)]))
10940                 (vec_select:SI (match_dup 1) (parallel [(const_int 7)])))))
10941           (vec_concat:V4SI
10942             (vec_concat:V2SI
10943               (plusminus:SI
10944                 (vec_select:SI
10945                   (match_operand:V8SI 2 "nonimmediate_operand" "xm")
10946                   (parallel [(const_int 0)]))
10947                 (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
10948               (plusminus:SI
10949                 (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
10950                 (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))
10951             (vec_concat:V2SI
10952               (plusminus:SI
10953                 (vec_select:SI (match_dup 2) (parallel [(const_int 4)]))
10954                 (vec_select:SI (match_dup 2) (parallel [(const_int 5)])))
10955               (plusminus:SI
10956                 (vec_select:SI (match_dup 2) (parallel [(const_int 6)]))
10957                 (vec_select:SI (match_dup 2) (parallel [(const_int 7)])))))))]
10958   "TARGET_AVX2"
10959   "vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
10960   [(set_attr "type" "sseiadd")
10961    (set_attr "prefix_extra" "1")
10962    (set_attr "prefix" "vex")
10963    (set_attr "mode" "OI")])
10964
10965 (define_insn "ssse3_ph<plusminus_mnemonic>dv4si3"
10966   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
10967         (vec_concat:V4SI
10968           (vec_concat:V2SI
10969             (plusminus:SI
10970               (vec_select:SI
10971                 (match_operand:V4SI 1 "register_operand" "0,x")
10972                 (parallel [(const_int 0)]))
10973               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
10974             (plusminus:SI
10975               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
10976               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
10977           (vec_concat:V2SI
10978             (plusminus:SI
10979               (vec_select:SI
10980                 (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm")
10981                 (parallel [(const_int 0)]))
10982               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
10983             (plusminus:SI
10984               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
10985               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
10986   "TARGET_SSSE3"
10987   "@
10988    ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}
10989    vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
10990   [(set_attr "isa" "noavx,avx")
10991    (set_attr "type" "sseiadd")
10992    (set_attr "atom_unit" "complex")
10993    (set_attr "prefix_data16" "1,*")
10994    (set_attr "prefix_extra" "1")
10995    (set_attr "prefix" "orig,vex")
10996    (set_attr "mode" "TI")])
10997
10998 (define_insn "ssse3_ph<plusminus_mnemonic>dv2si3"
10999   [(set (match_operand:V2SI 0 "register_operand" "=y")
11000         (vec_concat:V2SI
11001           (plusminus:SI
11002             (vec_select:SI
11003               (match_operand:V2SI 1 "register_operand" "0")
11004               (parallel [(const_int 0)]))
11005             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
11006           (plusminus:SI
11007             (vec_select:SI
11008               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
11009               (parallel [(const_int 0)]))
11010             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
11011   "TARGET_SSSE3"
11012   "ph<plusminus_mnemonic>d\t{%2, %0|%0, %2}"
11013   [(set_attr "type" "sseiadd")
11014    (set_attr "atom_unit" "complex")
11015    (set_attr "prefix_extra" "1")
11016    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11017    (set_attr "mode" "DI")])
11018
11019 (define_insn "avx2_pmaddubsw256"
11020   [(set (match_operand:V16HI 0 "register_operand" "=x")
11021         (ss_plus:V16HI
11022           (mult:V16HI
11023             (zero_extend:V16HI
11024               (vec_select:V16QI
11025                 (match_operand:V32QI 1 "register_operand" "x")
11026                 (parallel [(const_int 0) (const_int 2)
11027                            (const_int 4) (const_int 6)
11028                            (const_int 8) (const_int 10)
11029                            (const_int 12) (const_int 14)
11030                            (const_int 16) (const_int 18)
11031                            (const_int 20) (const_int 22)
11032                            (const_int 24) (const_int 26)
11033                            (const_int 28) (const_int 30)])))
11034             (sign_extend:V16HI
11035               (vec_select:V16QI
11036                 (match_operand:V32QI 2 "nonimmediate_operand" "xm")
11037                 (parallel [(const_int 0) (const_int 2)
11038                            (const_int 4) (const_int 6)
11039                            (const_int 8) (const_int 10)
11040                            (const_int 12) (const_int 14)
11041                            (const_int 16) (const_int 18)
11042                            (const_int 20) (const_int 22)
11043                            (const_int 24) (const_int 26)
11044                            (const_int 28) (const_int 30)]))))
11045           (mult:V16HI
11046             (zero_extend:V16HI
11047               (vec_select:V16QI (match_dup 1)
11048                 (parallel [(const_int 1) (const_int 3)
11049                            (const_int 5) (const_int 7)
11050                            (const_int 9) (const_int 11)
11051                            (const_int 13) (const_int 15)
11052                            (const_int 17) (const_int 19)
11053                            (const_int 21) (const_int 23)
11054                            (const_int 25) (const_int 27)
11055                            (const_int 29) (const_int 31)])))
11056             (sign_extend:V16HI
11057               (vec_select:V16QI (match_dup 2)
11058                 (parallel [(const_int 1) (const_int 3)
11059                            (const_int 5) (const_int 7)
11060                            (const_int 9) (const_int 11)
11061                            (const_int 13) (const_int 15)
11062                            (const_int 17) (const_int 19)
11063                            (const_int 21) (const_int 23)
11064                            (const_int 25) (const_int 27)
11065                            (const_int 29) (const_int 31)]))))))]
11066   "TARGET_AVX2"
11067   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
11068   [(set_attr "type" "sseiadd")
11069    (set_attr "prefix_extra" "1")
11070    (set_attr "prefix" "vex")
11071    (set_attr "mode" "OI")])
11072
11073 (define_insn "ssse3_pmaddubsw128"
11074   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11075         (ss_plus:V8HI
11076           (mult:V8HI
11077             (zero_extend:V8HI
11078               (vec_select:V8QI
11079                 (match_operand:V16QI 1 "register_operand" "0,x")
11080                 (parallel [(const_int 0) (const_int 2)
11081                            (const_int 4) (const_int 6)
11082                            (const_int 8) (const_int 10)
11083                            (const_int 12) (const_int 14)])))
11084             (sign_extend:V8HI
11085               (vec_select:V8QI
11086                 (match_operand:V16QI 2 "nonimmediate_operand" "xm,xm")
11087                 (parallel [(const_int 0) (const_int 2)
11088                            (const_int 4) (const_int 6)
11089                            (const_int 8) (const_int 10)
11090                            (const_int 12) (const_int 14)]))))
11091           (mult:V8HI
11092             (zero_extend:V8HI
11093               (vec_select:V8QI (match_dup 1)
11094                 (parallel [(const_int 1) (const_int 3)
11095                            (const_int 5) (const_int 7)
11096                            (const_int 9) (const_int 11)
11097                            (const_int 13) (const_int 15)])))
11098             (sign_extend:V8HI
11099               (vec_select:V8QI (match_dup 2)
11100                 (parallel [(const_int 1) (const_int 3)
11101                            (const_int 5) (const_int 7)
11102                            (const_int 9) (const_int 11)
11103                            (const_int 13) (const_int 15)]))))))]
11104   "TARGET_SSSE3"
11105   "@
11106    pmaddubsw\t{%2, %0|%0, %2}
11107    vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
11108   [(set_attr "isa" "noavx,avx")
11109    (set_attr "type" "sseiadd")
11110    (set_attr "atom_unit" "simul")
11111    (set_attr "prefix_data16" "1,*")
11112    (set_attr "prefix_extra" "1")
11113    (set_attr "prefix" "orig,vex")
11114    (set_attr "mode" "TI")])
11115
11116 (define_insn "ssse3_pmaddubsw"
11117   [(set (match_operand:V4HI 0 "register_operand" "=y")
11118         (ss_plus:V4HI
11119           (mult:V4HI
11120             (zero_extend:V4HI
11121               (vec_select:V4QI
11122                 (match_operand:V8QI 1 "register_operand" "0")
11123                 (parallel [(const_int 0) (const_int 2)
11124                            (const_int 4) (const_int 6)])))
11125             (sign_extend:V4HI
11126               (vec_select:V4QI
11127                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
11128                 (parallel [(const_int 0) (const_int 2)
11129                            (const_int 4) (const_int 6)]))))
11130           (mult:V4HI
11131             (zero_extend:V4HI
11132               (vec_select:V4QI (match_dup 1)
11133                 (parallel [(const_int 1) (const_int 3)
11134                            (const_int 5) (const_int 7)])))
11135             (sign_extend:V4HI
11136               (vec_select:V4QI (match_dup 2)
11137                 (parallel [(const_int 1) (const_int 3)
11138                            (const_int 5) (const_int 7)]))))))]
11139   "TARGET_SSSE3"
11140   "pmaddubsw\t{%2, %0|%0, %2}"
11141   [(set_attr "type" "sseiadd")
11142    (set_attr "atom_unit" "simul")
11143    (set_attr "prefix_extra" "1")
11144    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11145    (set_attr "mode" "DI")])
11146
11147 (define_mode_iterator PMULHRSW
11148   [V4HI V8HI (V16HI "TARGET_AVX2")])
11149
11150 (define_expand "<ssse3_avx2>_pmulhrsw<mode>3"
11151   [(set (match_operand:PMULHRSW 0 "register_operand")
11152         (truncate:PMULHRSW
11153           (lshiftrt:<ssedoublemode>
11154             (plus:<ssedoublemode>
11155               (lshiftrt:<ssedoublemode>
11156                 (mult:<ssedoublemode>
11157                   (sign_extend:<ssedoublemode>
11158                     (match_operand:PMULHRSW 1 "nonimmediate_operand"))
11159                   (sign_extend:<ssedoublemode>
11160                     (match_operand:PMULHRSW 2 "nonimmediate_operand")))
11161                 (const_int 14))
11162               (match_dup 3))
11163             (const_int 1))))]
11164   "TARGET_AVX2"
11165 {
11166   operands[3] = CONST1_RTX(<MODE>mode);
11167   ix86_fixup_binary_operands_no_copy (MULT, <MODE>mode, operands);
11168 })
11169
11170 (define_insn "*<ssse3_avx2>_pmulhrsw<mode>3"
11171   [(set (match_operand:VI2_AVX2 0 "register_operand" "=x,x")
11172         (truncate:VI2_AVX2
11173           (lshiftrt:<ssedoublemode>
11174             (plus:<ssedoublemode>
11175               (lshiftrt:<ssedoublemode>
11176                 (mult:<ssedoublemode>
11177                   (sign_extend:<ssedoublemode>
11178                     (match_operand:VI2_AVX2 1 "nonimmediate_operand" "%0,x"))
11179                   (sign_extend:<ssedoublemode>
11180                     (match_operand:VI2_AVX2 2 "nonimmediate_operand" "xm,xm")))
11181                 (const_int 14))
11182               (match_operand:VI2_AVX2 3 "const1_operand"))
11183             (const_int 1))))]
11184   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, <MODE>mode, operands)"
11185   "@
11186    pmulhrsw\t{%2, %0|%0, %2}
11187    vpmulhrsw\t{%2, %1, %0|%0, %1, %2}"
11188   [(set_attr "isa" "noavx,avx")
11189    (set_attr "type" "sseimul")
11190    (set_attr "prefix_data16" "1,*")
11191    (set_attr "prefix_extra" "1")
11192    (set_attr "prefix" "orig,vex")
11193    (set_attr "mode" "<sseinsnmode>")])
11194
11195 (define_insn "*ssse3_pmulhrswv4hi3"
11196   [(set (match_operand:V4HI 0 "register_operand" "=y")
11197         (truncate:V4HI
11198           (lshiftrt:V4SI
11199             (plus:V4SI
11200               (lshiftrt:V4SI
11201                 (mult:V4SI
11202                   (sign_extend:V4SI
11203                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
11204                   (sign_extend:V4SI
11205                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
11206                 (const_int 14))
11207               (match_operand:V4HI 3 "const1_operand"))
11208             (const_int 1))))]
11209   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
11210   "pmulhrsw\t{%2, %0|%0, %2}"
11211   [(set_attr "type" "sseimul")
11212    (set_attr "prefix_extra" "1")
11213    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11214    (set_attr "mode" "DI")])
11215
11216 (define_insn "<ssse3_avx2>_pshufb<mode>3"
11217   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11218         (unspec:VI1_AVX2
11219           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
11220            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")]
11221           UNSPEC_PSHUFB))]
11222   "TARGET_SSSE3"
11223   "@
11224    pshufb\t{%2, %0|%0, %2}
11225    vpshufb\t{%2, %1, %0|%0, %1, %2}"
11226   [(set_attr "isa" "noavx,avx")
11227    (set_attr "type" "sselog1")
11228    (set_attr "prefix_data16" "1,*")
11229    (set_attr "prefix_extra" "1")
11230    (set_attr "prefix" "orig,vex")
11231    (set_attr "btver2_decode" "vector,vector")
11232    (set_attr "mode" "<sseinsnmode>")])
11233
11234 (define_insn "ssse3_pshufbv8qi3"
11235   [(set (match_operand:V8QI 0 "register_operand" "=y")
11236         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
11237                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
11238                      UNSPEC_PSHUFB))]
11239   "TARGET_SSSE3"
11240   "pshufb\t{%2, %0|%0, %2}";
11241   [(set_attr "type" "sselog1")
11242    (set_attr "prefix_extra" "1")
11243    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11244    (set_attr "mode" "DI")])
11245
11246 (define_insn "<ssse3_avx2>_psign<mode>3"
11247   [(set (match_operand:VI124_AVX2 0 "register_operand" "=x,x")
11248         (unspec:VI124_AVX2
11249           [(match_operand:VI124_AVX2 1 "register_operand" "0,x")
11250            (match_operand:VI124_AVX2 2 "nonimmediate_operand" "xm,xm")]
11251           UNSPEC_PSIGN))]
11252   "TARGET_SSSE3"
11253   "@
11254    psign<ssemodesuffix>\t{%2, %0|%0, %2}
11255    vpsign<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11256   [(set_attr "isa" "noavx,avx")
11257    (set_attr "type" "sselog1")
11258    (set_attr "prefix_data16" "1,*")
11259    (set_attr "prefix_extra" "1")
11260    (set_attr "prefix" "orig,vex")
11261    (set_attr "mode" "<sseinsnmode>")])
11262
11263 (define_insn "ssse3_psign<mode>3"
11264   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
11265         (unspec:MMXMODEI
11266           [(match_operand:MMXMODEI 1 "register_operand" "0")
11267            (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
11268           UNSPEC_PSIGN))]
11269   "TARGET_SSSE3"
11270   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
11271   [(set_attr "type" "sselog1")
11272    (set_attr "prefix_extra" "1")
11273    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11274    (set_attr "mode" "DI")])
11275
11276 (define_insn "<ssse3_avx2>_palignr<mode>"
11277   [(set (match_operand:SSESCALARMODE 0 "register_operand" "=x,x")
11278         (unspec:SSESCALARMODE
11279           [(match_operand:SSESCALARMODE 1 "register_operand" "0,x")
11280            (match_operand:SSESCALARMODE 2 "nonimmediate_operand" "xm,xm")
11281            (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n,n")]
11282           UNSPEC_PALIGNR))]
11283   "TARGET_SSSE3"
11284 {
11285   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
11286
11287   switch (which_alternative)
11288     {
11289     case 0:
11290       return "palignr\t{%3, %2, %0|%0, %2, %3}";
11291     case 1:
11292       return "vpalignr\t{%3, %2, %1, %0|%0, %1, %2, %3}";
11293     default:
11294       gcc_unreachable ();
11295     }
11296 }
11297   [(set_attr "isa" "noavx,avx")
11298    (set_attr "type" "sseishft")
11299    (set_attr "atom_unit" "sishuf")
11300    (set_attr "prefix_data16" "1,*")
11301    (set_attr "prefix_extra" "1")
11302    (set_attr "length_immediate" "1")
11303    (set_attr "prefix" "orig,vex")
11304    (set_attr "mode" "<sseinsnmode>")])
11305
11306 (define_insn "ssse3_palignrdi"
11307   [(set (match_operand:DI 0 "register_operand" "=y")
11308         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
11309                     (match_operand:DI 2 "nonimmediate_operand" "ym")
11310                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
11311                    UNSPEC_PALIGNR))]
11312   "TARGET_SSSE3"
11313 {
11314   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
11315   return "palignr\t{%3, %2, %0|%0, %2, %3}";
11316 }
11317   [(set_attr "type" "sseishft")
11318    (set_attr "atom_unit" "sishuf")
11319    (set_attr "prefix_extra" "1")
11320    (set_attr "length_immediate" "1")
11321    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11322    (set_attr "mode" "DI")])
11323
11324 (define_insn "<mask_codefor>abs<mode>2<mask_name>"
11325   [(set (match_operand:VI124_AVX2_48_AVX512F 0 "register_operand" "=v")
11326         (abs:VI124_AVX2_48_AVX512F
11327           (match_operand:VI124_AVX2_48_AVX512F 1 "nonimmediate_operand" "vm")))]
11328   "TARGET_SSSE3 && <mask_mode512bit_condition>"
11329   "%vpabs<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11330   [(set_attr "type" "sselog1")
11331    (set_attr "prefix_data16" "1")
11332    (set_attr "prefix_extra" "1")
11333    (set_attr "prefix" "maybe_vex")
11334    (set_attr "mode" "<sseinsnmode>")])
11335
11336 (define_expand "abs<mode>2"
11337   [(set (match_operand:VI124_AVX2_48_AVX512F 0 "register_operand")
11338         (abs:VI124_AVX2_48_AVX512F
11339           (match_operand:VI124_AVX2_48_AVX512F 1 "nonimmediate_operand")))]
11340   "TARGET_SSE2"
11341 {
11342   if (!TARGET_SSSE3)
11343     {
11344       ix86_expand_sse2_abs (operands[0], operands[1]);
11345       DONE;
11346     }
11347 })
11348
11349 (define_insn "abs<mode>2"
11350   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
11351         (abs:MMXMODEI
11352           (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
11353   "TARGET_SSSE3"
11354   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
11355   [(set_attr "type" "sselog1")
11356    (set_attr "prefix_rep" "0")
11357    (set_attr "prefix_extra" "1")
11358    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
11359    (set_attr "mode" "DI")])
11360
11361 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11362 ;;
11363 ;; AMD SSE4A instructions
11364 ;;
11365 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11366
11367 (define_insn "sse4a_movnt<mode>"
11368   [(set (match_operand:MODEF 0 "memory_operand" "=m")
11369         (unspec:MODEF
11370           [(match_operand:MODEF 1 "register_operand" "x")]
11371           UNSPEC_MOVNT))]
11372   "TARGET_SSE4A"
11373   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
11374   [(set_attr "type" "ssemov")
11375    (set_attr "mode" "<MODE>")])
11376
11377 (define_insn "sse4a_vmmovnt<mode>"
11378   [(set (match_operand:<ssescalarmode> 0 "memory_operand" "=m")
11379         (unspec:<ssescalarmode>
11380           [(vec_select:<ssescalarmode>
11381              (match_operand:VF_128 1 "register_operand" "x")
11382              (parallel [(const_int 0)]))]
11383           UNSPEC_MOVNT))]
11384   "TARGET_SSE4A"
11385   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
11386   [(set_attr "type" "ssemov")
11387    (set_attr "mode" "<ssescalarmode>")])
11388
11389 (define_insn "sse4a_extrqi"
11390   [(set (match_operand:V2DI 0 "register_operand" "=x")
11391         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11392                       (match_operand 2 "const_0_to_255_operand")
11393                       (match_operand 3 "const_0_to_255_operand")]
11394                      UNSPEC_EXTRQI))]
11395   "TARGET_SSE4A"
11396   "extrq\t{%3, %2, %0|%0, %2, %3}"
11397   [(set_attr "type" "sse")
11398    (set_attr "prefix_data16" "1")
11399    (set_attr "length_immediate" "2")
11400    (set_attr "mode" "TI")])
11401
11402 (define_insn "sse4a_extrq"
11403   [(set (match_operand:V2DI 0 "register_operand" "=x")
11404         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11405                       (match_operand:V16QI 2 "register_operand" "x")]
11406                      UNSPEC_EXTRQ))]
11407   "TARGET_SSE4A"
11408   "extrq\t{%2, %0|%0, %2}"
11409   [(set_attr "type" "sse")
11410    (set_attr "prefix_data16" "1")
11411    (set_attr "mode" "TI")])
11412
11413 (define_insn "sse4a_insertqi"
11414   [(set (match_operand:V2DI 0 "register_operand" "=x")
11415         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11416                       (match_operand:V2DI 2 "register_operand" "x")
11417                       (match_operand 3 "const_0_to_255_operand")
11418                       (match_operand 4 "const_0_to_255_operand")]
11419                      UNSPEC_INSERTQI))]
11420   "TARGET_SSE4A"
11421   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
11422   [(set_attr "type" "sseins")
11423    (set_attr "prefix_data16" "0")
11424    (set_attr "prefix_rep" "1")
11425    (set_attr "length_immediate" "2")
11426    (set_attr "mode" "TI")])
11427
11428 (define_insn "sse4a_insertq"
11429   [(set (match_operand:V2DI 0 "register_operand" "=x")
11430         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
11431                       (match_operand:V2DI 2 "register_operand" "x")]
11432                      UNSPEC_INSERTQ))]
11433   "TARGET_SSE4A"
11434   "insertq\t{%2, %0|%0, %2}"
11435   [(set_attr "type" "sseins")
11436    (set_attr "prefix_data16" "0")
11437    (set_attr "prefix_rep" "1")
11438    (set_attr "mode" "TI")])
11439
11440 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11441 ;;
11442 ;; Intel SSE4.1 instructions
11443 ;;
11444 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11445
11446 (define_insn "<sse4_1>_blend<ssemodesuffix><avxsizesuffix>"
11447   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11448         (vec_merge:VF_128_256
11449           (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11450           (match_operand:VF_128_256 1 "register_operand" "0,x")
11451           (match_operand:SI 3 "const_0_to_<blendbits>_operand")))]
11452   "TARGET_SSE4_1"
11453   "@
11454    blend<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11455    vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11456   [(set_attr "isa" "noavx,avx")
11457    (set_attr "type" "ssemov")
11458    (set_attr "length_immediate" "1")
11459    (set_attr "prefix_data16" "1,*")
11460    (set_attr "prefix_extra" "1")
11461    (set_attr "prefix" "orig,vex")
11462    (set_attr "mode" "<MODE>")])
11463
11464 (define_insn "<sse4_1>_blendv<ssemodesuffix><avxsizesuffix>"
11465   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11466         (unspec:VF_128_256
11467           [(match_operand:VF_128_256 1 "register_operand" "0,x")
11468            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11469            (match_operand:VF_128_256 3 "register_operand" "Yz,x")]
11470           UNSPEC_BLENDV))]
11471   "TARGET_SSE4_1"
11472   "@
11473    blendv<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11474    vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11475   [(set_attr "isa" "noavx,avx")
11476    (set_attr "type" "ssemov")
11477    (set_attr "length_immediate" "1")
11478    (set_attr "prefix_data16" "1,*")
11479    (set_attr "prefix_extra" "1")
11480    (set_attr "prefix" "orig,vex")
11481    (set_attr "btver2_decode" "vector,vector")
11482    (set_attr "mode" "<MODE>")])
11483
11484 (define_insn "<sse4_1>_dp<ssemodesuffix><avxsizesuffix>"
11485   [(set (match_operand:VF_128_256 0 "register_operand" "=x,x")
11486         (unspec:VF_128_256
11487           [(match_operand:VF_128_256 1 "nonimmediate_operand" "%0,x")
11488            (match_operand:VF_128_256 2 "nonimmediate_operand" "xm,xm")
11489            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
11490           UNSPEC_DP))]
11491   "TARGET_SSE4_1"
11492   "@
11493    dp<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}
11494    vdp<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11495   [(set_attr "isa" "noavx,avx")
11496    (set_attr "type" "ssemul")
11497    (set_attr "length_immediate" "1")
11498    (set_attr "prefix_data16" "1,*")
11499    (set_attr "prefix_extra" "1")
11500    (set_attr "prefix" "orig,vex")
11501    (set_attr "btver2_decode" "vector,vector")
11502    (set_attr "mode" "<MODE>")])
11503
11504 (define_insn "<sse4_1_avx2>_movntdqa"
11505   [(set (match_operand:VI8_AVX2_AVX512F 0 "register_operand" "=x, v")
11506         (unspec:VI8_AVX2_AVX512F [(match_operand:VI8_AVX2_AVX512F 1 "memory_operand" "m, m")]
11507                      UNSPEC_MOVNTDQA))]
11508   "TARGET_SSE4_1"
11509   "%vmovntdqa\t{%1, %0|%0, %1}"
11510   [(set_attr "type" "ssemov")
11511    (set_attr "prefix_extra" "1, *")
11512    (set_attr "prefix" "maybe_vex, evex")
11513    (set_attr "mode" "<sseinsnmode>")])
11514
11515 (define_insn "<sse4_1_avx2>_mpsadbw"
11516   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11517         (unspec:VI1_AVX2
11518           [(match_operand:VI1_AVX2 1 "register_operand" "0,x")
11519            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
11520            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
11521           UNSPEC_MPSADBW))]
11522   "TARGET_SSE4_1"
11523   "@
11524    mpsadbw\t{%3, %2, %0|%0, %2, %3}
11525    vmpsadbw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11526   [(set_attr "isa" "noavx,avx")
11527    (set_attr "type" "sselog1")
11528    (set_attr "length_immediate" "1")
11529    (set_attr "prefix_extra" "1")
11530    (set_attr "prefix" "orig,vex")
11531    (set_attr "btver2_decode" "vector,vector")
11532    (set_attr "mode" "<sseinsnmode>")])
11533
11534 (define_insn "avx2_packusdw"
11535   [(set (match_operand:V16HI 0 "register_operand" "=x")
11536         (vec_concat:V16HI
11537           (us_truncate:V8HI
11538             (match_operand:V8SI 1 "register_operand" "x"))
11539           (us_truncate:V8HI
11540             (match_operand:V8SI 2 "nonimmediate_operand" "xm"))))]
11541   "TARGET_AVX2"
11542   "vpackusdw\t{%2, %1, %0|%0, %1, %2}"
11543   [(set_attr "type" "sselog")
11544    (set_attr "prefix_extra" "1")
11545    (set_attr "prefix" "vex")
11546    (set_attr "mode" "OI")])
11547
11548 (define_insn "sse4_1_packusdw"
11549   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11550         (vec_concat:V8HI
11551           (us_truncate:V4HI
11552             (match_operand:V4SI 1 "register_operand" "0,x"))
11553           (us_truncate:V4HI
11554             (match_operand:V4SI 2 "nonimmediate_operand" "xm,xm"))))]
11555   "TARGET_SSE4_1"
11556   "@
11557    packusdw\t{%2, %0|%0, %2}
11558    vpackusdw\t{%2, %1, %0|%0, %1, %2}"
11559   [(set_attr "isa" "noavx,avx")
11560    (set_attr "type" "sselog")
11561    (set_attr "prefix_extra" "1")
11562    (set_attr "prefix" "orig,vex")
11563    (set_attr "mode" "TI")])
11564
11565 (define_insn "<sse4_1_avx2>_pblendvb"
11566   [(set (match_operand:VI1_AVX2 0 "register_operand" "=x,x")
11567         (unspec:VI1_AVX2
11568           [(match_operand:VI1_AVX2 1 "register_operand"  "0,x")
11569            (match_operand:VI1_AVX2 2 "nonimmediate_operand" "xm,xm")
11570            (match_operand:VI1_AVX2 3 "register_operand" "Yz,x")]
11571           UNSPEC_BLENDV))]
11572   "TARGET_SSE4_1"
11573   "@
11574    pblendvb\t{%3, %2, %0|%0, %2, %3}
11575    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11576   [(set_attr "isa" "noavx,avx")
11577    (set_attr "type" "ssemov")
11578    (set_attr "prefix_extra" "1")
11579    (set_attr "length_immediate" "*,1")
11580    (set_attr "prefix" "orig,vex")
11581    (set_attr "btver2_decode" "vector,vector")
11582    (set_attr "mode" "<sseinsnmode>")])
11583
11584 (define_insn "sse4_1_pblendw"
11585   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
11586         (vec_merge:V8HI
11587           (match_operand:V8HI 2 "nonimmediate_operand" "xm,xm")
11588           (match_operand:V8HI 1 "register_operand" "0,x")
11589           (match_operand:SI 3 "const_0_to_255_operand" "n,n")))]
11590   "TARGET_SSE4_1"
11591   "@
11592    pblendw\t{%3, %2, %0|%0, %2, %3}
11593    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11594   [(set_attr "isa" "noavx,avx")
11595    (set_attr "type" "ssemov")
11596    (set_attr "prefix_extra" "1")
11597    (set_attr "length_immediate" "1")
11598    (set_attr "prefix" "orig,vex")
11599    (set_attr "mode" "TI")])
11600
11601 ;; The builtin uses an 8-bit immediate.  Expand that.
11602 (define_expand "avx2_pblendw"
11603   [(set (match_operand:V16HI 0 "register_operand")
11604         (vec_merge:V16HI
11605           (match_operand:V16HI 2 "nonimmediate_operand")
11606           (match_operand:V16HI 1 "register_operand")
11607           (match_operand:SI 3 "const_0_to_255_operand")))]
11608   "TARGET_AVX2"
11609 {
11610   HOST_WIDE_INT val = INTVAL (operands[3]) & 0xff;
11611   operands[3] = GEN_INT (val << 8 | val);
11612 })
11613
11614 (define_insn "*avx2_pblendw"
11615   [(set (match_operand:V16HI 0 "register_operand" "=x")
11616         (vec_merge:V16HI
11617           (match_operand:V16HI 2 "nonimmediate_operand" "xm")
11618           (match_operand:V16HI 1 "register_operand" "x")
11619           (match_operand:SI 3 "avx2_pblendw_operand" "n")))]
11620   "TARGET_AVX2"
11621 {
11622   operands[3] = GEN_INT (INTVAL (operands[3]) & 0xff);
11623   return "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
11624 }
11625   [(set_attr "type" "ssemov")
11626    (set_attr "prefix_extra" "1")
11627    (set_attr "length_immediate" "1")
11628    (set_attr "prefix" "vex")
11629    (set_attr "mode" "OI")])
11630
11631 (define_insn "avx2_pblendd<mode>"
11632   [(set (match_operand:VI4_AVX2 0 "register_operand" "=x")
11633         (vec_merge:VI4_AVX2
11634           (match_operand:VI4_AVX2 2 "nonimmediate_operand" "xm")
11635           (match_operand:VI4_AVX2 1 "register_operand" "x")
11636           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
11637   "TARGET_AVX2"
11638   "vpblendd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
11639   [(set_attr "type" "ssemov")
11640    (set_attr "prefix_extra" "1")
11641    (set_attr "length_immediate" "1")
11642    (set_attr "prefix" "vex")
11643    (set_attr "mode" "<sseinsnmode>")])
11644
11645 (define_insn "sse4_1_phminposuw"
11646   [(set (match_operand:V8HI 0 "register_operand" "=x")
11647         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
11648                      UNSPEC_PHMINPOSUW))]
11649   "TARGET_SSE4_1"
11650   "%vphminposuw\t{%1, %0|%0, %1}"
11651   [(set_attr "type" "sselog1")
11652    (set_attr "prefix_extra" "1")
11653    (set_attr "prefix" "maybe_vex")
11654    (set_attr "mode" "TI")])
11655
11656 (define_insn "avx2_<code>v16qiv16hi2"
11657   [(set (match_operand:V16HI 0 "register_operand" "=x")
11658         (any_extend:V16HI
11659           (match_operand:V16QI 1 "nonimmediate_operand" "xm")))]
11660   "TARGET_AVX2"
11661   "vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
11662   [(set_attr "type" "ssemov")
11663    (set_attr "prefix_extra" "1")
11664    (set_attr "prefix" "vex")
11665    (set_attr "mode" "OI")])
11666
11667 (define_insn "sse4_1_<code>v8qiv8hi2"
11668   [(set (match_operand:V8HI 0 "register_operand" "=x")
11669         (any_extend:V8HI
11670           (vec_select:V8QI
11671             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11672             (parallel [(const_int 0) (const_int 1)
11673                        (const_int 2) (const_int 3)
11674                        (const_int 4) (const_int 5)
11675                        (const_int 6) (const_int 7)]))))]
11676   "TARGET_SSE4_1"
11677   "%vpmov<extsuffix>bw\t{%1, %0|%0, %q1}"
11678   [(set_attr "type" "ssemov")
11679    (set_attr "ssememalign" "64")
11680    (set_attr "prefix_extra" "1")
11681    (set_attr "prefix" "maybe_vex")
11682    (set_attr "mode" "TI")])
11683
11684 (define_insn "<mask_codefor>avx512f_<code>v16qiv16si2<mask_name>"
11685   [(set (match_operand:V16SI 0 "register_operand" "=v")
11686         (any_extend:V16SI
11687           (match_operand:V16QI 1 "nonimmediate_operand" "vm")))]
11688   "TARGET_AVX512F"
11689   "vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %q1}"
11690   [(set_attr "type" "ssemov")
11691    (set_attr "prefix" "evex")
11692    (set_attr "mode" "XI")])
11693
11694 (define_insn "avx2_<code>v8qiv8si2"
11695   [(set (match_operand:V8SI 0 "register_operand" "=x")
11696         (any_extend:V8SI
11697           (vec_select:V8QI
11698             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11699             (parallel [(const_int 0) (const_int 1)
11700                        (const_int 2) (const_int 3)
11701                        (const_int 4) (const_int 5)
11702                        (const_int 6) (const_int 7)]))))]
11703   "TARGET_AVX2"
11704   "vpmov<extsuffix>bd\t{%1, %0|%0, %q1}"
11705   [(set_attr "type" "ssemov")
11706    (set_attr "prefix_extra" "1")
11707    (set_attr "prefix" "vex")
11708    (set_attr "mode" "OI")])
11709
11710 (define_insn "sse4_1_<code>v4qiv4si2"
11711   [(set (match_operand:V4SI 0 "register_operand" "=x")
11712         (any_extend:V4SI
11713           (vec_select:V4QI
11714             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11715             (parallel [(const_int 0) (const_int 1)
11716                        (const_int 2) (const_int 3)]))))]
11717   "TARGET_SSE4_1"
11718   "%vpmov<extsuffix>bd\t{%1, %0|%0, %k1}"
11719   [(set_attr "type" "ssemov")
11720    (set_attr "ssememalign" "32")
11721    (set_attr "prefix_extra" "1")
11722    (set_attr "prefix" "maybe_vex")
11723    (set_attr "mode" "TI")])
11724
11725 (define_insn "avx512f_<code>v16hiv16si2<mask_name>"
11726   [(set (match_operand:V16SI 0 "register_operand" "=v")
11727         (any_extend:V16SI
11728           (match_operand:V16HI 1 "nonimmediate_operand" "vm")))]
11729   "TARGET_AVX512F"
11730   "vpmov<extsuffix>wd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11731   [(set_attr "type" "ssemov")
11732    (set_attr "prefix" "evex")
11733    (set_attr "mode" "XI")])
11734
11735 (define_insn "avx2_<code>v8hiv8si2"
11736   [(set (match_operand:V8SI 0 "register_operand" "=x")
11737         (any_extend:V8SI
11738             (match_operand:V8HI 1 "nonimmediate_operand" "xm")))]
11739   "TARGET_AVX2"
11740   "vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
11741   [(set_attr "type" "ssemov")
11742    (set_attr "prefix_extra" "1")
11743    (set_attr "prefix" "vex")
11744    (set_attr "mode" "OI")])
11745
11746 (define_insn "sse4_1_<code>v4hiv4si2"
11747   [(set (match_operand:V4SI 0 "register_operand" "=x")
11748         (any_extend:V4SI
11749           (vec_select:V4HI
11750             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11751             (parallel [(const_int 0) (const_int 1)
11752                        (const_int 2) (const_int 3)]))))]
11753   "TARGET_SSE4_1"
11754   "%vpmov<extsuffix>wd\t{%1, %0|%0, %q1}"
11755   [(set_attr "type" "ssemov")
11756    (set_attr "ssememalign" "64")
11757    (set_attr "prefix_extra" "1")
11758    (set_attr "prefix" "maybe_vex")
11759    (set_attr "mode" "TI")])
11760
11761 (define_insn "avx512f_<code>v8qiv8di2<mask_name>"
11762   [(set (match_operand:V8DI 0 "register_operand" "=v")
11763         (any_extend:V8DI
11764           (vec_select:V8QI
11765             (match_operand:V16QI 1 "nonimmediate_operand" "vm")
11766             (parallel [(const_int 0) (const_int 1)
11767                        (const_int 2) (const_int 3)
11768                        (const_int 4) (const_int 5)
11769                        (const_int 6) (const_int 7)]))))]
11770   "TARGET_AVX512F"
11771   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %k1}"
11772   [(set_attr "type" "ssemov")
11773    (set_attr "prefix" "evex")
11774    (set_attr "mode" "XI")])
11775
11776 (define_insn "avx2_<code>v4qiv4di2"
11777   [(set (match_operand:V4DI 0 "register_operand" "=x")
11778         (any_extend:V4DI
11779           (vec_select:V4QI
11780             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11781             (parallel [(const_int 0) (const_int 1)
11782                        (const_int 2) (const_int 3)]))))]
11783   "TARGET_AVX2"
11784   "vpmov<extsuffix>bq\t{%1, %0|%0, %k1}"
11785   [(set_attr "type" "ssemov")
11786    (set_attr "prefix_extra" "1")
11787    (set_attr "prefix" "vex")
11788    (set_attr "mode" "OI")])
11789
11790 (define_insn "sse4_1_<code>v2qiv2di2"
11791   [(set (match_operand:V2DI 0 "register_operand" "=x")
11792         (any_extend:V2DI
11793           (vec_select:V2QI
11794             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
11795             (parallel [(const_int 0) (const_int 1)]))))]
11796   "TARGET_SSE4_1"
11797   "%vpmov<extsuffix>bq\t{%1, %0|%0, %w1}"
11798   [(set_attr "type" "ssemov")
11799    (set_attr "ssememalign" "16")
11800    (set_attr "prefix_extra" "1")
11801    (set_attr "prefix" "maybe_vex")
11802    (set_attr "mode" "TI")])
11803
11804 (define_insn "avx512f_<code>v8hiv8di2<mask_name>"
11805   [(set (match_operand:V8DI 0 "register_operand" "=v")
11806         (any_extend:V8DI
11807           (match_operand:V8HI 1 "nonimmediate_operand" "vm")))]
11808   "TARGET_AVX512F"
11809   "vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %q1}"
11810   [(set_attr "type" "ssemov")
11811    (set_attr "prefix" "evex")
11812    (set_attr "mode" "XI")])
11813
11814 (define_insn "avx2_<code>v4hiv4di2"
11815   [(set (match_operand:V4DI 0 "register_operand" "=x")
11816         (any_extend:V4DI
11817           (vec_select:V4HI
11818             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11819             (parallel [(const_int 0) (const_int 1)
11820                        (const_int 2) (const_int 3)]))))]
11821   "TARGET_AVX2"
11822   "vpmov<extsuffix>wq\t{%1, %0|%0, %q1}"
11823   [(set_attr "type" "ssemov")
11824    (set_attr "prefix_extra" "1")
11825    (set_attr "prefix" "vex")
11826    (set_attr "mode" "OI")])
11827
11828 (define_insn "sse4_1_<code>v2hiv2di2"
11829   [(set (match_operand:V2DI 0 "register_operand" "=x")
11830         (any_extend:V2DI
11831           (vec_select:V2HI
11832             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
11833             (parallel [(const_int 0) (const_int 1)]))))]
11834   "TARGET_SSE4_1"
11835   "%vpmov<extsuffix>wq\t{%1, %0|%0, %k1}"
11836   [(set_attr "type" "ssemov")
11837    (set_attr "ssememalign" "32")
11838    (set_attr "prefix_extra" "1")
11839    (set_attr "prefix" "maybe_vex")
11840    (set_attr "mode" "TI")])
11841
11842 (define_insn "avx512f_<code>v8siv8di2<mask_name>"
11843   [(set (match_operand:V8DI 0 "register_operand" "=v")
11844         (any_extend:V8DI
11845           (match_operand:V8SI 1 "nonimmediate_operand" "vm")))]
11846   "TARGET_AVX512F"
11847   "vpmov<extsuffix>dq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
11848   [(set_attr "type" "ssemov")
11849    (set_attr "prefix" "evex")
11850    (set_attr "mode" "XI")])
11851
11852 (define_insn "avx2_<code>v4siv4di2"
11853   [(set (match_operand:V4DI 0 "register_operand" "=x")
11854         (any_extend:V4DI
11855             (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
11856   "TARGET_AVX2"
11857   "vpmov<extsuffix>dq\t{%1, %0|%0, %1}"
11858   [(set_attr "type" "ssemov")
11859    (set_attr "prefix_extra" "1")
11860    (set_attr "mode" "OI")])
11861
11862 (define_insn "sse4_1_<code>v2siv2di2"
11863   [(set (match_operand:V2DI 0 "register_operand" "=x")
11864         (any_extend:V2DI
11865           (vec_select:V2SI
11866             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
11867             (parallel [(const_int 0) (const_int 1)]))))]
11868   "TARGET_SSE4_1"
11869   "%vpmov<extsuffix>dq\t{%1, %0|%0, %q1}"
11870   [(set_attr "type" "ssemov")
11871    (set_attr "ssememalign" "64")
11872    (set_attr "prefix_extra" "1")
11873    (set_attr "prefix" "maybe_vex")
11874    (set_attr "mode" "TI")])
11875
11876 ;; ptestps/ptestpd are very similar to comiss and ucomiss when
11877 ;; setting FLAGS_REG. But it is not a really compare instruction.
11878 (define_insn "avx_vtest<ssemodesuffix><avxsizesuffix>"
11879   [(set (reg:CC FLAGS_REG)
11880         (unspec:CC [(match_operand:VF_128_256 0 "register_operand" "x")
11881                     (match_operand:VF_128_256 1 "nonimmediate_operand" "xm")]
11882                    UNSPEC_VTESTP))]
11883   "TARGET_AVX"
11884   "vtest<ssemodesuffix>\t{%1, %0|%0, %1}"
11885   [(set_attr "type" "ssecomi")
11886    (set_attr "prefix_extra" "1")
11887    (set_attr "prefix" "vex")
11888    (set_attr "mode" "<MODE>")])
11889
11890 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
11891 ;; But it is not a really compare instruction.
11892 (define_insn "avx_ptest256"
11893   [(set (reg:CC FLAGS_REG)
11894         (unspec:CC [(match_operand:V4DI 0 "register_operand" "x")
11895                     (match_operand:V4DI 1 "nonimmediate_operand" "xm")]
11896                    UNSPEC_PTEST))]
11897   "TARGET_AVX"
11898   "vptest\t{%1, %0|%0, %1}"
11899   [(set_attr "type" "ssecomi")
11900    (set_attr "prefix_extra" "1")
11901    (set_attr "prefix" "vex")
11902    (set_attr "btver2_decode" "vector")
11903    (set_attr "mode" "OI")])
11904
11905 (define_insn "sse4_1_ptest"
11906   [(set (reg:CC FLAGS_REG)
11907         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
11908                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
11909                    UNSPEC_PTEST))]
11910   "TARGET_SSE4_1"
11911   "%vptest\t{%1, %0|%0, %1}"
11912   [(set_attr "type" "ssecomi")
11913    (set_attr "prefix_extra" "1")
11914    (set_attr "prefix" "maybe_vex")
11915    (set_attr "mode" "TI")])
11916
11917 (define_insn "<sse4_1>_round<ssemodesuffix><avxsizesuffix>"
11918   [(set (match_operand:VF_128_256 0 "register_operand" "=x")
11919         (unspec:VF_128_256
11920           [(match_operand:VF_128_256 1 "nonimmediate_operand" "xm")
11921            (match_operand:SI 2 "const_0_to_15_operand" "n")]
11922           UNSPEC_ROUND))]
11923   "TARGET_ROUND"
11924   "%vround<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
11925   [(set_attr "type" "ssecvt")
11926    (set (attr "prefix_data16")
11927      (if_then_else
11928        (match_test "TARGET_AVX")
11929      (const_string "*")
11930      (const_string "1")))
11931    (set_attr "prefix_extra" "1")
11932    (set_attr "length_immediate" "1")
11933    (set_attr "prefix" "maybe_vex")
11934    (set_attr "mode" "<MODE>")])
11935
11936 (define_expand "<sse4_1>_round<ssemodesuffix>_sfix<avxsizesuffix>"
11937   [(match_operand:<sseintvecmode> 0 "register_operand")
11938    (match_operand:VF1_128_256 1 "nonimmediate_operand")
11939    (match_operand:SI 2 "const_0_to_15_operand")]
11940   "TARGET_ROUND"
11941 {
11942   rtx tmp = gen_reg_rtx (<MODE>mode);
11943
11944   emit_insn
11945     (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp, operands[1],
11946                                                        operands[2]));
11947   emit_insn
11948     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
11949   DONE;
11950 })
11951
11952 (define_expand "avx512f_roundpd512"
11953   [(match_operand:V8DF 0 "register_operand")
11954    (match_operand:V8DF 1 "nonimmediate_operand")
11955    (match_operand:SI 2 "const_0_to_15_operand")]
11956   "TARGET_AVX512F"
11957 {
11958   emit_insn (gen_avx512f_rndscalev8df (operands[0], operands[1], operands[2]));
11959   DONE;
11960 })
11961
11962 (define_expand "<sse4_1>_round<ssemodesuffix>_vec_pack_sfix<avxsizesuffix>"
11963   [(match_operand:<ssepackfltmode> 0 "register_operand")
11964    (match_operand:VF2 1 "nonimmediate_operand")
11965    (match_operand:VF2 2 "nonimmediate_operand")
11966    (match_operand:SI 3 "const_0_to_15_operand")]
11967   "TARGET_ROUND"
11968 {
11969   rtx tmp0, tmp1;
11970
11971   if (<MODE>mode == V2DFmode
11972       && TARGET_AVX && !TARGET_PREFER_AVX128)
11973     {
11974       rtx tmp2 = gen_reg_rtx (V4DFmode);
11975
11976       tmp0 = gen_reg_rtx (V4DFmode);
11977       tmp1 = force_reg (V2DFmode, operands[1]);
11978
11979       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
11980       emit_insn (gen_avx_roundpd256 (tmp2, tmp0, operands[3]));
11981       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
11982     }
11983   else
11984     {
11985       tmp0 = gen_reg_rtx (<MODE>mode);
11986       tmp1 = gen_reg_rtx (<MODE>mode);
11987
11988       emit_insn
11989        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp0, operands[1],
11990                                                           operands[3]));
11991       emit_insn
11992        (gen_<sse4_1>_round<ssemodesuffix><avxsizesuffix> (tmp1, operands[2],
11993                                                           operands[3]));
11994       emit_insn
11995        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
11996     }
11997   DONE;
11998 })
11999
12000 (define_insn "sse4_1_round<ssescalarmodesuffix>"
12001   [(set (match_operand:VF_128 0 "register_operand" "=x,x")
12002         (vec_merge:VF_128
12003           (unspec:VF_128
12004             [(match_operand:VF_128 2 "register_operand" "x,x")
12005              (match_operand:SI 3 "const_0_to_15_operand" "n,n")]
12006             UNSPEC_ROUND)
12007           (match_operand:VF_128 1 "register_operand" "0,x")
12008           (const_int 1)))]
12009   "TARGET_ROUND"
12010   "@
12011    round<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}
12012    vround<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12013   [(set_attr "isa" "noavx,avx")
12014    (set_attr "type" "ssecvt")
12015    (set_attr "length_immediate" "1")
12016    (set_attr "prefix_data16" "1,*")
12017    (set_attr "prefix_extra" "1")
12018    (set_attr "prefix" "orig,vex")
12019    (set_attr "mode" "<MODE>")])
12020
12021 (define_expand "round<mode>2"
12022   [(set (match_dup 4)
12023         (plus:VF
12024           (match_operand:VF 1 "register_operand")
12025           (match_dup 3)))
12026    (set (match_operand:VF 0 "register_operand")
12027         (unspec:VF
12028           [(match_dup 4) (match_dup 5)]
12029           UNSPEC_ROUND))]
12030   "TARGET_ROUND && !flag_trapping_math"
12031 {
12032   enum machine_mode scalar_mode;
12033   const struct real_format *fmt;
12034   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
12035   rtx half, vec_half;
12036
12037   scalar_mode = GET_MODE_INNER (<MODE>mode);
12038
12039   /* load nextafter (0.5, 0.0) */
12040   fmt = REAL_MODE_FORMAT (scalar_mode);
12041   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, scalar_mode);
12042   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
12043   half = const_double_from_real_value (pred_half, scalar_mode);
12044
12045   vec_half = ix86_build_const_vector (<MODE>mode, true, half);
12046   vec_half = force_reg (<MODE>mode, vec_half);
12047
12048   operands[3] = gen_reg_rtx (<MODE>mode);
12049   emit_insn (gen_copysign<mode>3 (operands[3], vec_half, operands[1]));
12050
12051   operands[4] = gen_reg_rtx (<MODE>mode);
12052   operands[5] = GEN_INT (ROUND_TRUNC);
12053 })
12054
12055 (define_expand "round<mode>2_sfix"
12056   [(match_operand:<sseintvecmode> 0 "register_operand")
12057    (match_operand:VF1_128_256 1 "register_operand")]
12058   "TARGET_ROUND && !flag_trapping_math"
12059 {
12060   rtx tmp = gen_reg_rtx (<MODE>mode);
12061
12062   emit_insn (gen_round<mode>2 (tmp, operands[1]));
12063
12064   emit_insn
12065     (gen_fix_trunc<mode><sseintvecmodelower>2 (operands[0], tmp));
12066   DONE;
12067 })
12068
12069 (define_expand "round<mode>2_vec_pack_sfix"
12070   [(match_operand:<ssepackfltmode> 0 "register_operand")
12071    (match_operand:VF2 1 "register_operand")
12072    (match_operand:VF2 2 "register_operand")]
12073   "TARGET_ROUND && !flag_trapping_math"
12074 {
12075   rtx tmp0, tmp1;
12076
12077   if (<MODE>mode == V2DFmode
12078       && TARGET_AVX && !TARGET_PREFER_AVX128)
12079     {
12080       rtx tmp2 = gen_reg_rtx (V4DFmode);
12081
12082       tmp0 = gen_reg_rtx (V4DFmode);
12083       tmp1 = force_reg (V2DFmode, operands[1]);
12084
12085       emit_insn (gen_avx_vec_concatv4df (tmp0, tmp1, operands[2]));
12086       emit_insn (gen_roundv4df2 (tmp2, tmp0));
12087       emit_insn (gen_fix_truncv4dfv4si2 (operands[0], tmp2));
12088     }
12089   else
12090     {
12091       tmp0 = gen_reg_rtx (<MODE>mode);
12092       tmp1 = gen_reg_rtx (<MODE>mode);
12093
12094       emit_insn (gen_round<mode>2 (tmp0, operands[1]));
12095       emit_insn (gen_round<mode>2 (tmp1, operands[2]));
12096
12097       emit_insn
12098        (gen_vec_pack_sfix_trunc_<mode> (operands[0], tmp0, tmp1));
12099     }
12100   DONE;
12101 })
12102
12103 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12104 ;;
12105 ;; Intel SSE4.2 string/text processing instructions
12106 ;;
12107 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12108
12109 (define_insn_and_split "sse4_2_pcmpestr"
12110   [(set (match_operand:SI 0 "register_operand" "=c,c")
12111         (unspec:SI
12112           [(match_operand:V16QI 2 "register_operand" "x,x")
12113            (match_operand:SI 3 "register_operand" "a,a")
12114            (match_operand:V16QI 4 "nonimmediate_operand" "x,m")
12115            (match_operand:SI 5 "register_operand" "d,d")
12116            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
12117           UNSPEC_PCMPESTR))
12118    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
12119         (unspec:V16QI
12120           [(match_dup 2)
12121            (match_dup 3)
12122            (match_dup 4)
12123            (match_dup 5)
12124            (match_dup 6)]
12125           UNSPEC_PCMPESTR))
12126    (set (reg:CC FLAGS_REG)
12127         (unspec:CC
12128           [(match_dup 2)
12129            (match_dup 3)
12130            (match_dup 4)
12131            (match_dup 5)
12132            (match_dup 6)]
12133           UNSPEC_PCMPESTR))]
12134   "TARGET_SSE4_2
12135    && can_create_pseudo_p ()"
12136   "#"
12137   "&& 1"
12138   [(const_int 0)]
12139 {
12140   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12141   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12142   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12143
12144   if (ecx)
12145     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
12146                                      operands[3], operands[4],
12147                                      operands[5], operands[6]));
12148   if (xmm0)
12149     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
12150                                      operands[3], operands[4],
12151                                      operands[5], operands[6]));
12152   if (flags && !(ecx || xmm0))
12153     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
12154                                            operands[2], operands[3],
12155                                            operands[4], operands[5],
12156                                            operands[6]));
12157   if (!(flags || ecx || xmm0))
12158     emit_note (NOTE_INSN_DELETED);
12159
12160   DONE;
12161 }
12162   [(set_attr "type" "sselog")
12163    (set_attr "prefix_data16" "1")
12164    (set_attr "prefix_extra" "1")
12165    (set_attr "ssememalign" "8")
12166    (set_attr "length_immediate" "1")
12167    (set_attr "memory" "none,load")
12168    (set_attr "mode" "TI")])
12169
12170 (define_insn_and_split "*sse4_2_pcmpestr_unaligned"
12171   [(set (match_operand:SI 0 "register_operand" "=c")
12172         (unspec:SI
12173           [(match_operand:V16QI 2 "register_operand" "x")
12174            (match_operand:SI 3 "register_operand" "a")
12175            (unspec:V16QI
12176              [(match_operand:V16QI 4 "memory_operand" "m")]
12177              UNSPEC_LOADU)
12178            (match_operand:SI 5 "register_operand" "d")
12179            (match_operand:SI 6 "const_0_to_255_operand" "n")]
12180           UNSPEC_PCMPESTR))
12181    (set (match_operand:V16QI 1 "register_operand" "=Yz")
12182         (unspec:V16QI
12183           [(match_dup 2)
12184            (match_dup 3)
12185            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
12186            (match_dup 5)
12187            (match_dup 6)]
12188           UNSPEC_PCMPESTR))
12189    (set (reg:CC FLAGS_REG)
12190         (unspec:CC
12191           [(match_dup 2)
12192            (match_dup 3)
12193            (unspec:V16QI [(match_dup 4)] UNSPEC_LOADU)
12194            (match_dup 5)
12195            (match_dup 6)]
12196           UNSPEC_PCMPESTR))]
12197   "TARGET_SSE4_2
12198    && can_create_pseudo_p ()"
12199   "#"
12200   "&& 1"
12201   [(const_int 0)]
12202 {
12203   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12204   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12205   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12206
12207   if (ecx)
12208     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
12209                                      operands[3], operands[4],
12210                                      operands[5], operands[6]));
12211   if (xmm0)
12212     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
12213                                      operands[3], operands[4],
12214                                      operands[5], operands[6]));
12215   if (flags && !(ecx || xmm0))
12216     emit_insn (gen_sse4_2_pcmpestr_cconly (NULL, NULL,
12217                                            operands[2], operands[3],
12218                                            operands[4], operands[5],
12219                                            operands[6]));
12220   if (!(flags || ecx || xmm0))
12221     emit_note (NOTE_INSN_DELETED);
12222
12223   DONE;
12224 }
12225   [(set_attr "type" "sselog")
12226    (set_attr "prefix_data16" "1")
12227    (set_attr "prefix_extra" "1")
12228    (set_attr "ssememalign" "8")
12229    (set_attr "length_immediate" "1")
12230    (set_attr "memory" "load")
12231    (set_attr "mode" "TI")])
12232
12233 (define_insn "sse4_2_pcmpestri"
12234   [(set (match_operand:SI 0 "register_operand" "=c,c")
12235         (unspec:SI
12236           [(match_operand:V16QI 1 "register_operand" "x,x")
12237            (match_operand:SI 2 "register_operand" "a,a")
12238            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12239            (match_operand:SI 4 "register_operand" "d,d")
12240            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
12241           UNSPEC_PCMPESTR))
12242    (set (reg:CC FLAGS_REG)
12243         (unspec:CC
12244           [(match_dup 1)
12245            (match_dup 2)
12246            (match_dup 3)
12247            (match_dup 4)
12248            (match_dup 5)]
12249           UNSPEC_PCMPESTR))]
12250   "TARGET_SSE4_2"
12251   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
12252   [(set_attr "type" "sselog")
12253    (set_attr "prefix_data16" "1")
12254    (set_attr "prefix_extra" "1")
12255    (set_attr "prefix" "maybe_vex")
12256    (set_attr "ssememalign" "8")
12257    (set_attr "length_immediate" "1")
12258    (set_attr "btver2_decode" "vector")
12259    (set_attr "memory" "none,load")
12260    (set_attr "mode" "TI")])
12261
12262 (define_insn "sse4_2_pcmpestrm"
12263   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
12264         (unspec:V16QI
12265           [(match_operand:V16QI 1 "register_operand" "x,x")
12266            (match_operand:SI 2 "register_operand" "a,a")
12267            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12268            (match_operand:SI 4 "register_operand" "d,d")
12269            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
12270           UNSPEC_PCMPESTR))
12271    (set (reg:CC FLAGS_REG)
12272         (unspec:CC
12273           [(match_dup 1)
12274            (match_dup 2)
12275            (match_dup 3)
12276            (match_dup 4)
12277            (match_dup 5)]
12278           UNSPEC_PCMPESTR))]
12279   "TARGET_SSE4_2"
12280   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
12281   [(set_attr "type" "sselog")
12282    (set_attr "prefix_data16" "1")
12283    (set_attr "prefix_extra" "1")
12284    (set_attr "ssememalign" "8")
12285    (set_attr "length_immediate" "1")
12286    (set_attr "prefix" "maybe_vex")
12287    (set_attr "btver2_decode" "vector")
12288    (set_attr "memory" "none,load")
12289    (set_attr "mode" "TI")])
12290
12291 (define_insn "sse4_2_pcmpestr_cconly"
12292   [(set (reg:CC FLAGS_REG)
12293         (unspec:CC
12294           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
12295            (match_operand:SI 3 "register_operand" "a,a,a,a")
12296            (match_operand:V16QI 4 "nonimmediate_operand" "x,m,x,m")
12297            (match_operand:SI 5 "register_operand" "d,d,d,d")
12298            (match_operand:SI 6 "const_0_to_255_operand" "n,n,n,n")]
12299           UNSPEC_PCMPESTR))
12300    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
12301    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
12302   "TARGET_SSE4_2"
12303   "@
12304    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
12305    %vpcmpestrm\t{%6, %4, %2|%2, %4, %6}
12306    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
12307    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
12308   [(set_attr "type" "sselog")
12309    (set_attr "prefix_data16" "1")
12310    (set_attr "prefix_extra" "1")
12311    (set_attr "ssememalign" "8")
12312    (set_attr "length_immediate" "1")
12313    (set_attr "memory" "none,load,none,load")
12314    (set_attr "btver2_decode" "vector,vector,vector,vector")
12315    (set_attr "prefix" "maybe_vex")
12316    (set_attr "mode" "TI")])
12317
12318 (define_insn_and_split "sse4_2_pcmpistr"
12319   [(set (match_operand:SI 0 "register_operand" "=c,c")
12320         (unspec:SI
12321           [(match_operand:V16QI 2 "register_operand" "x,x")
12322            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
12323            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
12324           UNSPEC_PCMPISTR))
12325    (set (match_operand:V16QI 1 "register_operand" "=Yz,Yz")
12326         (unspec:V16QI
12327           [(match_dup 2)
12328            (match_dup 3)
12329            (match_dup 4)]
12330           UNSPEC_PCMPISTR))
12331    (set (reg:CC FLAGS_REG)
12332         (unspec:CC
12333           [(match_dup 2)
12334            (match_dup 3)
12335            (match_dup 4)]
12336           UNSPEC_PCMPISTR))]
12337   "TARGET_SSE4_2
12338    && can_create_pseudo_p ()"
12339   "#"
12340   "&& 1"
12341   [(const_int 0)]
12342 {
12343   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12344   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12345   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12346
12347   if (ecx)
12348     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
12349                                      operands[3], operands[4]));
12350   if (xmm0)
12351     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
12352                                      operands[3], operands[4]));
12353   if (flags && !(ecx || xmm0))
12354     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
12355                                            operands[2], operands[3],
12356                                            operands[4]));
12357   if (!(flags || ecx || xmm0))
12358     emit_note (NOTE_INSN_DELETED);
12359
12360   DONE;
12361 }
12362   [(set_attr "type" "sselog")
12363    (set_attr "prefix_data16" "1")
12364    (set_attr "prefix_extra" "1")
12365    (set_attr "ssememalign" "8")
12366    (set_attr "length_immediate" "1")
12367    (set_attr "memory" "none,load")
12368    (set_attr "mode" "TI")])
12369
12370 (define_insn_and_split "*sse4_2_pcmpistr_unaligned"
12371   [(set (match_operand:SI 0 "register_operand" "=c")
12372         (unspec:SI
12373           [(match_operand:V16QI 2 "register_operand" "x")
12374            (unspec:V16QI
12375              [(match_operand:V16QI 3 "memory_operand" "m")]
12376              UNSPEC_LOADU)
12377            (match_operand:SI 4 "const_0_to_255_operand" "n")]
12378           UNSPEC_PCMPISTR))
12379    (set (match_operand:V16QI 1 "register_operand" "=Yz")
12380         (unspec:V16QI
12381           [(match_dup 2)
12382            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
12383            (match_dup 4)]
12384           UNSPEC_PCMPISTR))
12385    (set (reg:CC FLAGS_REG)
12386         (unspec:CC
12387           [(match_dup 2)
12388            (unspec:V16QI [(match_dup 3)] UNSPEC_LOADU)
12389            (match_dup 4)]
12390           UNSPEC_PCMPISTR))]
12391   "TARGET_SSE4_2
12392    && can_create_pseudo_p ()"
12393   "#"
12394   "&& 1"
12395   [(const_int 0)]
12396 {
12397   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
12398   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
12399   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
12400
12401   if (ecx)
12402     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
12403                                      operands[3], operands[4]));
12404   if (xmm0)
12405     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
12406                                      operands[3], operands[4]));
12407   if (flags && !(ecx || xmm0))
12408     emit_insn (gen_sse4_2_pcmpistr_cconly (NULL, NULL,
12409                                            operands[2], operands[3],
12410                                            operands[4]));
12411   if (!(flags || ecx || xmm0))
12412     emit_note (NOTE_INSN_DELETED);
12413
12414   DONE;
12415 }
12416   [(set_attr "type" "sselog")
12417    (set_attr "prefix_data16" "1")
12418    (set_attr "prefix_extra" "1")
12419    (set_attr "ssememalign" "8")
12420    (set_attr "length_immediate" "1")
12421    (set_attr "memory" "load")
12422    (set_attr "mode" "TI")])
12423
12424 (define_insn "sse4_2_pcmpistri"
12425   [(set (match_operand:SI 0 "register_operand" "=c,c")
12426         (unspec:SI
12427           [(match_operand:V16QI 1 "register_operand" "x,x")
12428            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
12429            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
12430           UNSPEC_PCMPISTR))
12431    (set (reg:CC FLAGS_REG)
12432         (unspec:CC
12433           [(match_dup 1)
12434            (match_dup 2)
12435            (match_dup 3)]
12436           UNSPEC_PCMPISTR))]
12437   "TARGET_SSE4_2"
12438   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
12439   [(set_attr "type" "sselog")
12440    (set_attr "prefix_data16" "1")
12441    (set_attr "prefix_extra" "1")
12442    (set_attr "ssememalign" "8")
12443    (set_attr "length_immediate" "1")
12444    (set_attr "prefix" "maybe_vex")
12445    (set_attr "memory" "none,load")
12446    (set_attr "btver2_decode" "vector")
12447    (set_attr "mode" "TI")])
12448
12449 (define_insn "sse4_2_pcmpistrm"
12450   [(set (match_operand:V16QI 0 "register_operand" "=Yz,Yz")
12451         (unspec:V16QI
12452           [(match_operand:V16QI 1 "register_operand" "x,x")
12453            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
12454            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
12455           UNSPEC_PCMPISTR))
12456    (set (reg:CC FLAGS_REG)
12457         (unspec:CC
12458           [(match_dup 1)
12459            (match_dup 2)
12460            (match_dup 3)]
12461           UNSPEC_PCMPISTR))]
12462   "TARGET_SSE4_2"
12463   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
12464   [(set_attr "type" "sselog")
12465    (set_attr "prefix_data16" "1")
12466    (set_attr "prefix_extra" "1")
12467    (set_attr "ssememalign" "8")
12468    (set_attr "length_immediate" "1")
12469    (set_attr "prefix" "maybe_vex")
12470    (set_attr "memory" "none,load")
12471    (set_attr "btver2_decode" "vector")
12472    (set_attr "mode" "TI")])
12473
12474 (define_insn "sse4_2_pcmpistr_cconly"
12475   [(set (reg:CC FLAGS_REG)
12476         (unspec:CC
12477           [(match_operand:V16QI 2 "register_operand" "x,x,x,x")
12478            (match_operand:V16QI 3 "nonimmediate_operand" "x,m,x,m")
12479            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
12480           UNSPEC_PCMPISTR))
12481    (clobber (match_scratch:V16QI 0 "=Yz,Yz,X,X"))
12482    (clobber (match_scratch:SI    1 "= X, X,c,c"))]
12483   "TARGET_SSE4_2"
12484   "@
12485    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
12486    %vpcmpistrm\t{%4, %3, %2|%2, %3, %4}
12487    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
12488    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
12489   [(set_attr "type" "sselog")
12490    (set_attr "prefix_data16" "1")
12491    (set_attr "prefix_extra" "1")
12492    (set_attr "ssememalign" "8")
12493    (set_attr "length_immediate" "1")
12494    (set_attr "memory" "none,load,none,load")
12495    (set_attr "prefix" "maybe_vex")
12496    (set_attr "btver2_decode" "vector,vector,vector,vector")
12497    (set_attr "mode" "TI")])
12498
12499 ;; Packed float variants
12500 (define_mode_attr GATHER_SCATTER_SF_MEM_MODE
12501                       [(V8DI "V8SF") (V16SI "V16SF")])
12502
12503 (define_expand "avx512pf_gatherpf<mode>sf"
12504   [(unspec
12505      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12506       (mem:<GATHER_SCATTER_SF_MEM_MODE>
12507         (match_par_dup 5
12508           [(match_operand 2 "vsib_address_operand")
12509            (match_operand:VI48_512 1 "register_operand")
12510            (match_operand:SI 3 "const1248_operand")]))
12511       (match_operand:SI 4 "const_2_to_3_operand")]
12512      UNSPEC_GATHER_PREFETCH)]
12513   "TARGET_AVX512PF"
12514 {
12515   operands[5]
12516     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12517                                         operands[3]), UNSPEC_VSIBADDR);
12518 })
12519
12520 (define_insn "*avx512pf_gatherpf<mode>sf_mask"
12521   [(unspec
12522      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12523       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 5 "vsib_mem_operator"
12524         [(unspec:P
12525            [(match_operand:P 2 "vsib_address_operand" "Tv")
12526             (match_operand:VI48_512 1 "register_operand" "v")
12527             (match_operand:SI 3 "const1248_operand" "n")]
12528            UNSPEC_VSIBADDR)])
12529       (match_operand:SI 4 "const_2_to_3_operand" "n")]
12530      UNSPEC_GATHER_PREFETCH)]
12531   "TARGET_AVX512PF"
12532 {
12533   switch (INTVAL (operands[4]))
12534     {
12535     case 3:
12536       return "vgatherpf0<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12537     case 2:
12538       return "vgatherpf1<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12539     default:
12540       gcc_unreachable ();
12541     }
12542 }
12543   [(set_attr "type" "sse")
12544    (set_attr "prefix" "evex")
12545    (set_attr "mode" "XI")])
12546
12547 (define_insn "*avx512pf_gatherpf<mode>sf"
12548   [(unspec
12549      [(const_int -1)
12550       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 4 "vsib_mem_operator"
12551         [(unspec:P
12552            [(match_operand:P 1 "vsib_address_operand" "Tv")
12553             (match_operand:VI48_512 0 "register_operand" "v")
12554             (match_operand:SI 2 "const1248_operand" "n")]
12555            UNSPEC_VSIBADDR)])
12556       (match_operand:SI 3 "const_2_to_3_operand" "n")]
12557      UNSPEC_GATHER_PREFETCH)]
12558   "TARGET_AVX512PF"
12559 {
12560   switch (INTVAL (operands[3]))
12561     {
12562     case 3:
12563       return "vgatherpf0<ssemodesuffix>ps\t{%4|%4}";
12564     case 2:
12565       return "vgatherpf1<ssemodesuffix>ps\t{%4|%4}";
12566     default:
12567       gcc_unreachable ();
12568     }
12569 }
12570   [(set_attr "type" "sse")
12571    (set_attr "prefix" "evex")
12572    (set_attr "mode" "XI")])
12573
12574 ;; Packed double variants
12575 (define_expand "avx512pf_gatherpf<mode>df"
12576   [(unspec
12577      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12578       (mem:V8DF
12579         (match_par_dup 5
12580           [(match_operand 2 "vsib_address_operand")
12581            (match_operand:VI4_256_8_512 1 "register_operand")
12582            (match_operand:SI 3 "const1248_operand")]))
12583       (match_operand:SI 4 "const_2_to_3_operand")]
12584      UNSPEC_GATHER_PREFETCH)]
12585   "TARGET_AVX512PF"
12586 {
12587   operands[5]
12588     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12589                                         operands[3]), UNSPEC_VSIBADDR);
12590 })
12591
12592 (define_insn "*avx512pf_gatherpf<mode>df_mask"
12593   [(unspec
12594      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12595       (match_operator:V8DF 5 "vsib_mem_operator"
12596         [(unspec:P
12597            [(match_operand:P 2 "vsib_address_operand" "Tv")
12598             (match_operand:VI4_256_8_512 1 "register_operand" "v")
12599             (match_operand:SI 3 "const1248_operand" "n")]
12600            UNSPEC_VSIBADDR)])
12601       (match_operand:SI 4 "const_2_to_3_operand" "n")]
12602      UNSPEC_GATHER_PREFETCH)]
12603   "TARGET_AVX512PF"
12604 {
12605   switch (INTVAL (operands[4]))
12606     {
12607     case 3:
12608       return "vgatherpf0<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12609     case 2:
12610       return "vgatherpf1<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12611     default:
12612       gcc_unreachable ();
12613     }
12614 }
12615   [(set_attr "type" "sse")
12616    (set_attr "prefix" "evex")
12617    (set_attr "mode" "XI")])
12618
12619 (define_insn "*avx512pf_gatherpf<mode>df"
12620   [(unspec
12621      [(const_int -1)
12622       (match_operator:V8DF 4 "vsib_mem_operator"
12623         [(unspec:P
12624            [(match_operand:P 1 "vsib_address_operand" "Tv")
12625             (match_operand:VI4_256_8_512 0 "register_operand" "v")
12626             (match_operand:SI 2 "const1248_operand" "n")]
12627            UNSPEC_VSIBADDR)])
12628       (match_operand:SI 3 "const_2_to_3_operand" "n")]
12629      UNSPEC_GATHER_PREFETCH)]
12630   "TARGET_AVX512PF"
12631 {
12632   switch (INTVAL (operands[3]))
12633     {
12634     case 3:
12635       return "vgatherpf0<ssemodesuffix>pd\t{%4|%4}";
12636     case 2:
12637       return "vgatherpf1<ssemodesuffix>pd\t{%4|%4}";
12638     default:
12639       gcc_unreachable ();
12640     }
12641 }
12642   [(set_attr "type" "sse")
12643    (set_attr "prefix" "evex")
12644    (set_attr "mode" "XI")])
12645
12646 ;; Packed float variants
12647 (define_expand "avx512pf_scatterpf<mode>sf"
12648   [(unspec
12649      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12650       (mem:<GATHER_SCATTER_SF_MEM_MODE>
12651         (match_par_dup 5
12652           [(match_operand 2 "vsib_address_operand")
12653            (match_operand:VI48_512 1 "register_operand")
12654            (match_operand:SI 3 "const1248_operand")]))
12655       (match_operand:SI 4 "const2367_operand")]
12656      UNSPEC_SCATTER_PREFETCH)]
12657   "TARGET_AVX512PF"
12658 {
12659   operands[5]
12660     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12661                                         operands[3]), UNSPEC_VSIBADDR);
12662 })
12663
12664 (define_insn "*avx512pf_scatterpf<mode>sf_mask"
12665   [(unspec
12666      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12667       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 5 "vsib_mem_operator"
12668         [(unspec:P
12669            [(match_operand:P 2 "vsib_address_operand" "Tv")
12670             (match_operand:VI48_512 1 "register_operand" "v")
12671             (match_operand:SI 3 "const1248_operand" "n")]
12672            UNSPEC_VSIBADDR)])
12673       (match_operand:SI 4 "const2367_operand" "n")]
12674      UNSPEC_SCATTER_PREFETCH)]
12675   "TARGET_AVX512PF"
12676 {
12677   switch (INTVAL (operands[4]))
12678     {
12679     case 3:
12680     case 7:
12681       return "vscatterpf0<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12682     case 2:
12683     case 6:
12684       return "vscatterpf1<ssemodesuffix>ps\t{%5%{%0%}|%5%{%0%}}";
12685     default:
12686       gcc_unreachable ();
12687     }
12688 }
12689   [(set_attr "type" "sse")
12690    (set_attr "prefix" "evex")
12691    (set_attr "mode" "XI")])
12692
12693 (define_insn "*avx512pf_scatterpf<mode>sf"
12694   [(unspec
12695      [(const_int -1)
12696       (match_operator:<GATHER_SCATTER_SF_MEM_MODE> 4 "vsib_mem_operator"
12697         [(unspec:P
12698            [(match_operand:P 1 "vsib_address_operand" "Tv")
12699             (match_operand:VI48_512 0 "register_operand" "v")
12700             (match_operand:SI 2 "const1248_operand" "n")]
12701            UNSPEC_VSIBADDR)])
12702       (match_operand:SI 3 "const2367_operand" "n")]
12703      UNSPEC_SCATTER_PREFETCH)]
12704   "TARGET_AVX512PF"
12705 {
12706   switch (INTVAL (operands[3]))
12707     {
12708     case 3:
12709     case 7:
12710       return "vscatterpf0<ssemodesuffix>ps\t{%4|%4}";
12711     case 2:
12712     case 6:
12713       return "vscatterpf1<ssemodesuffix>ps\t{%4|%4}";
12714     default:
12715       gcc_unreachable ();
12716     }
12717 }
12718   [(set_attr "type" "sse")
12719    (set_attr "prefix" "evex")
12720    (set_attr "mode" "XI")])
12721
12722 ;; Packed double variants
12723 (define_expand "avx512pf_scatterpf<mode>df"
12724   [(unspec
12725      [(match_operand:<avx512fmaskmode> 0 "register_or_constm1_operand")
12726       (mem:V8DF
12727         (match_par_dup 5
12728           [(match_operand 2 "vsib_address_operand")
12729            (match_operand:VI4_256_8_512 1 "register_operand")
12730            (match_operand:SI 3 "const1248_operand")]))
12731       (match_operand:SI 4 "const2367_operand")]
12732      UNSPEC_SCATTER_PREFETCH)]
12733   "TARGET_AVX512PF"
12734 {
12735   operands[5]
12736     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[1],
12737                                         operands[3]), UNSPEC_VSIBADDR);
12738 })
12739
12740 (define_insn "*avx512pf_scatterpf<mode>df_mask"
12741   [(unspec
12742      [(match_operand:<avx512fmaskmode> 0 "register_operand" "Yk")
12743       (match_operator:V8DF 5 "vsib_mem_operator"
12744         [(unspec:P
12745            [(match_operand:P 2 "vsib_address_operand" "Tv")
12746             (match_operand:VI4_256_8_512 1 "register_operand" "v")
12747             (match_operand:SI 3 "const1248_operand" "n")]
12748            UNSPEC_VSIBADDR)])
12749       (match_operand:SI 4 "const2367_operand" "n")]
12750      UNSPEC_SCATTER_PREFETCH)]
12751   "TARGET_AVX512PF"
12752 {
12753   switch (INTVAL (operands[4]))
12754     {
12755     case 3:
12756     case 7:
12757       return "vscatterpf0<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12758     case 2:
12759     case 6:
12760       return "vscatterpf1<ssemodesuffix>pd\t{%5%{%0%}|%5%{%0%}}";
12761     default:
12762       gcc_unreachable ();
12763     }
12764 }
12765   [(set_attr "type" "sse")
12766    (set_attr "prefix" "evex")
12767    (set_attr "mode" "XI")])
12768
12769 (define_insn "*avx512pf_scatterpf<mode>df"
12770   [(unspec
12771      [(const_int -1)
12772       (match_operator:V8DF 4 "vsib_mem_operator"
12773         [(unspec:P
12774            [(match_operand:P 1 "vsib_address_operand" "Tv")
12775             (match_operand:VI4_256_8_512 0 "register_operand" "v")
12776             (match_operand:SI 2 "const1248_operand" "n")]
12777            UNSPEC_VSIBADDR)])
12778       (match_operand:SI 3 "const2367_operand" "n")]
12779      UNSPEC_SCATTER_PREFETCH)]
12780   "TARGET_AVX512PF"
12781 {
12782   switch (INTVAL (operands[3]))
12783     {
12784     case 3:
12785     case 7:
12786       return "vscatterpf0<ssemodesuffix>pd\t{%4|%4}";
12787     case 2:
12788     case 6:
12789       return "vscatterpf1<ssemodesuffix>pd\t{%4|%4}";
12790     default:
12791       gcc_unreachable ();
12792     }
12793 }
12794   [(set_attr "type" "sse")
12795    (set_attr "prefix" "evex")
12796    (set_attr "mode" "XI")])
12797
12798 (define_insn "avx512er_exp2<mode><mask_name><round_saeonly_name>"
12799   [(set (match_operand:VF_512 0 "register_operand" "=v")
12800         (unspec:VF_512
12801           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12802           UNSPEC_EXP2))]
12803   "TARGET_AVX512ER"
12804   "vexp2<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12805   [(set_attr "prefix" "evex")
12806    (set_attr "type" "sse")
12807    (set_attr "mode" "<MODE>")])
12808
12809 (define_insn "<mask_codefor>avx512er_rcp28<mode><mask_name><round_saeonly_name>"
12810   [(set (match_operand:VF_512 0 "register_operand" "=v")
12811         (unspec:VF_512
12812           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12813           UNSPEC_RCP28))]
12814   "TARGET_AVX512ER"
12815   "vrcp28<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12816   [(set_attr "prefix" "evex")
12817    (set_attr "type" "sse")
12818    (set_attr "mode" "<MODE>")])
12819
12820 (define_insn "avx512er_vmrcp28<mode><round_saeonly_name>"
12821   [(set (match_operand:VF_128 0 "register_operand" "=v")
12822         (vec_merge:VF_128
12823           (unspec:VF_128
12824             [(match_operand:VF_128 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12825             UNSPEC_RCP28)
12826           (match_operand:VF_128 2 "register_operand" "v")
12827           (const_int 1)))]
12828   "TARGET_AVX512ER"
12829   "vrcp28<ssescalarmodesuffix>\t{<round_saeonly_op3>%1, %2, %0|%0, %2, %1<round_saeonly_op3>}"
12830   [(set_attr "length_immediate" "1")
12831    (set_attr "prefix" "evex")
12832    (set_attr "type" "sse")
12833    (set_attr "mode" "<MODE>")])
12834
12835 (define_insn "<mask_codefor>avx512er_rsqrt28<mode><mask_name><round_saeonly_name>"
12836   [(set (match_operand:VF_512 0 "register_operand" "=v")
12837         (unspec:VF_512
12838           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12839           UNSPEC_RSQRT28))]
12840   "TARGET_AVX512ER"
12841   "vrsqrt28<ssemodesuffix>\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
12842   [(set_attr "prefix" "evex")
12843    (set_attr "type" "sse")
12844    (set_attr "mode" "<MODE>")])
12845
12846 (define_insn "avx512er_vmrsqrt28<mode><round_saeonly_name>"
12847   [(set (match_operand:VF_128 0 "register_operand" "=v")
12848         (vec_merge:VF_128
12849           (unspec:VF_128
12850             [(match_operand:VF_128 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
12851             UNSPEC_RSQRT28)
12852           (match_operand:VF_128 2 "register_operand" "v")
12853           (const_int 1)))]
12854   "TARGET_AVX512ER"
12855   "vrsqrt28<ssescalarmodesuffix>\t{<round_saeonly_op3>%1, %2, %0|%0, %2, %1<round_saeonly_op3>}"
12856   [(set_attr "length_immediate" "1")
12857    (set_attr "type" "sse")
12858    (set_attr "prefix" "evex")
12859    (set_attr "mode" "<MODE>")])
12860
12861 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12862 ;;
12863 ;; XOP instructions
12864 ;;
12865 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12866
12867 (define_code_iterator xop_plus [plus ss_plus])
12868
12869 (define_code_attr macs [(plus "macs") (ss_plus "macss")])
12870 (define_code_attr madcs [(plus "madcs") (ss_plus "madcss")])
12871
12872 ;; XOP parallel integer multiply/add instructions.
12873
12874 (define_insn "xop_p<macs><ssemodesuffix><ssemodesuffix>"
12875   [(set (match_operand:VI24_128 0 "register_operand" "=x")
12876         (xop_plus:VI24_128
12877          (mult:VI24_128
12878           (match_operand:VI24_128 1 "nonimmediate_operand" "%x")
12879           (match_operand:VI24_128 2 "nonimmediate_operand" "xm"))
12880          (match_operand:VI24_128 3 "register_operand" "x")))]
12881   "TARGET_XOP"
12882   "vp<macs><ssemodesuffix><ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12883   [(set_attr "type" "ssemuladd")
12884    (set_attr "mode" "TI")])
12885
12886 (define_insn "xop_p<macs>dql"
12887   [(set (match_operand:V2DI 0 "register_operand" "=x")
12888         (xop_plus:V2DI
12889          (mult:V2DI
12890           (sign_extend:V2DI
12891            (vec_select:V2SI
12892             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
12893             (parallel [(const_int 0) (const_int 2)])))
12894           (sign_extend:V2DI
12895            (vec_select:V2SI
12896             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
12897             (parallel [(const_int 0) (const_int 2)]))))
12898          (match_operand:V2DI 3 "register_operand" "x")))]
12899   "TARGET_XOP"
12900   "vp<macs>dql\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12901   [(set_attr "type" "ssemuladd")
12902    (set_attr "mode" "TI")])
12903
12904 (define_insn "xop_p<macs>dqh"
12905   [(set (match_operand:V2DI 0 "register_operand" "=x")
12906         (xop_plus:V2DI
12907          (mult:V2DI
12908           (sign_extend:V2DI
12909            (vec_select:V2SI
12910             (match_operand:V4SI 1 "nonimmediate_operand" "%x")
12911             (parallel [(const_int 1) (const_int 3)])))
12912           (sign_extend:V2DI
12913            (vec_select:V2SI
12914             (match_operand:V4SI 2 "nonimmediate_operand" "xm")
12915             (parallel [(const_int 1) (const_int 3)]))))
12916          (match_operand:V2DI 3 "register_operand" "x")))]
12917   "TARGET_XOP"
12918   "vp<macs>dqh\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12919   [(set_attr "type" "ssemuladd")
12920    (set_attr "mode" "TI")])
12921
12922 ;; XOP parallel integer multiply/add instructions for the intrinisics
12923 (define_insn "xop_p<macs>wd"
12924   [(set (match_operand:V4SI 0 "register_operand" "=x")
12925         (xop_plus:V4SI
12926          (mult:V4SI
12927           (sign_extend:V4SI
12928            (vec_select:V4HI
12929             (match_operand:V8HI 1 "nonimmediate_operand" "%x")
12930             (parallel [(const_int 1) (const_int 3)
12931                        (const_int 5) (const_int 7)])))
12932           (sign_extend:V4SI
12933            (vec_select:V4HI
12934             (match_operand:V8HI 2 "nonimmediate_operand" "xm")
12935             (parallel [(const_int 1) (const_int 3)
12936                        (const_int 5) (const_int 7)]))))
12937          (match_operand:V4SI 3 "register_operand" "x")))]
12938   "TARGET_XOP"
12939   "vp<macs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12940   [(set_attr "type" "ssemuladd")
12941    (set_attr "mode" "TI")])
12942
12943 (define_insn "xop_p<madcs>wd"
12944   [(set (match_operand:V4SI 0 "register_operand" "=x")
12945         (xop_plus:V4SI
12946          (plus:V4SI
12947           (mult:V4SI
12948            (sign_extend:V4SI
12949             (vec_select:V4HI
12950              (match_operand:V8HI 1 "nonimmediate_operand" "%x")
12951              (parallel [(const_int 0) (const_int 2)
12952                         (const_int 4) (const_int 6)])))
12953            (sign_extend:V4SI
12954             (vec_select:V4HI
12955              (match_operand:V8HI 2 "nonimmediate_operand" "xm")
12956              (parallel [(const_int 0) (const_int 2)
12957                         (const_int 4) (const_int 6)]))))
12958           (mult:V4SI
12959            (sign_extend:V4SI
12960             (vec_select:V4HI
12961              (match_dup 1)
12962              (parallel [(const_int 1) (const_int 3)
12963                         (const_int 5) (const_int 7)])))
12964            (sign_extend:V4SI
12965             (vec_select:V4HI
12966              (match_dup 2)
12967              (parallel [(const_int 1) (const_int 3)
12968                         (const_int 5) (const_int 7)])))))
12969          (match_operand:V4SI 3 "register_operand" "x")))]
12970   "TARGET_XOP"
12971   "vp<madcs>wd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12972   [(set_attr "type" "ssemuladd")
12973    (set_attr "mode" "TI")])
12974
12975 ;; XOP parallel XMM conditional moves
12976 (define_insn "xop_pcmov_<mode><avxsizesuffix>"
12977   [(set (match_operand:V 0 "register_operand" "=x,x")
12978         (if_then_else:V
12979           (match_operand:V 3 "nonimmediate_operand" "x,m")
12980           (match_operand:V 1 "register_operand" "x,x")
12981           (match_operand:V 2 "nonimmediate_operand" "xm,x")))]
12982   "TARGET_XOP"
12983   "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
12984   [(set_attr "type" "sse4arg")])
12985
12986 ;; XOP horizontal add/subtract instructions
12987 (define_insn "xop_phadd<u>bw"
12988   [(set (match_operand:V8HI 0 "register_operand" "=x")
12989         (plus:V8HI
12990          (any_extend:V8HI
12991           (vec_select:V8QI
12992            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
12993            (parallel [(const_int 0) (const_int 2)
12994                       (const_int 4) (const_int 6)
12995                       (const_int 8) (const_int 10)
12996                       (const_int 12) (const_int 14)])))
12997          (any_extend:V8HI
12998           (vec_select:V8QI
12999            (match_dup 1)
13000            (parallel [(const_int 1) (const_int 3)
13001                       (const_int 5) (const_int 7)
13002                       (const_int 9) (const_int 11)
13003                       (const_int 13) (const_int 15)])))))]
13004   "TARGET_XOP"
13005   "vphadd<u>bw\t{%1, %0|%0, %1}"
13006   [(set_attr "type" "sseiadd1")])
13007
13008 (define_insn "xop_phadd<u>bd"
13009   [(set (match_operand:V4SI 0 "register_operand" "=x")
13010         (plus:V4SI
13011          (plus:V4SI
13012           (any_extend:V4SI
13013            (vec_select:V4QI
13014             (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13015             (parallel [(const_int 0) (const_int 4)
13016                        (const_int 8) (const_int 12)])))
13017           (any_extend:V4SI
13018            (vec_select:V4QI
13019             (match_dup 1)
13020             (parallel [(const_int 1) (const_int 5)
13021                        (const_int 9) (const_int 13)]))))
13022          (plus:V4SI
13023           (any_extend:V4SI
13024            (vec_select:V4QI
13025             (match_dup 1)
13026             (parallel [(const_int 2) (const_int 6)
13027                        (const_int 10) (const_int 14)])))
13028           (any_extend:V4SI
13029            (vec_select:V4QI
13030             (match_dup 1)
13031             (parallel [(const_int 3) (const_int 7)
13032                        (const_int 11) (const_int 15)]))))))]
13033   "TARGET_XOP"
13034   "vphadd<u>bd\t{%1, %0|%0, %1}"
13035   [(set_attr "type" "sseiadd1")])
13036
13037 (define_insn "xop_phadd<u>bq"
13038   [(set (match_operand:V2DI 0 "register_operand" "=x")
13039         (plus:V2DI
13040          (plus:V2DI
13041           (plus:V2DI
13042            (any_extend:V2DI
13043             (vec_select:V2QI
13044              (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13045              (parallel [(const_int 0) (const_int 8)])))
13046            (any_extend:V2DI
13047             (vec_select:V2QI
13048              (match_dup 1)
13049              (parallel [(const_int 1) (const_int 9)]))))
13050           (plus:V2DI
13051            (any_extend:V2DI
13052             (vec_select:V2QI
13053              (match_dup 1)
13054              (parallel [(const_int 2) (const_int 10)])))
13055            (any_extend:V2DI
13056             (vec_select:V2QI
13057              (match_dup 1)
13058              (parallel [(const_int 3) (const_int 11)])))))
13059          (plus:V2DI
13060           (plus:V2DI
13061            (any_extend:V2DI
13062             (vec_select:V2QI
13063              (match_dup 1)
13064              (parallel [(const_int 4) (const_int 12)])))
13065            (any_extend:V2DI
13066             (vec_select:V2QI
13067              (match_dup 1)
13068              (parallel [(const_int 5) (const_int 13)]))))
13069           (plus:V2DI
13070            (any_extend:V2DI
13071             (vec_select:V2QI
13072              (match_dup 1)
13073              (parallel [(const_int 6) (const_int 14)])))
13074            (any_extend:V2DI
13075             (vec_select:V2QI
13076              (match_dup 1)
13077              (parallel [(const_int 7) (const_int 15)])))))))]
13078   "TARGET_XOP"
13079   "vphadd<u>bq\t{%1, %0|%0, %1}"
13080   [(set_attr "type" "sseiadd1")])
13081
13082 (define_insn "xop_phadd<u>wd"
13083   [(set (match_operand:V4SI 0 "register_operand" "=x")
13084         (plus:V4SI
13085          (any_extend:V4SI
13086           (vec_select:V4HI
13087            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13088            (parallel [(const_int 0) (const_int 2)
13089                       (const_int 4) (const_int 6)])))
13090          (any_extend:V4SI
13091           (vec_select:V4HI
13092            (match_dup 1)
13093            (parallel [(const_int 1) (const_int 3)
13094                       (const_int 5) (const_int 7)])))))]
13095   "TARGET_XOP"
13096   "vphadd<u>wd\t{%1, %0|%0, %1}"
13097   [(set_attr "type" "sseiadd1")])
13098
13099 (define_insn "xop_phadd<u>wq"
13100   [(set (match_operand:V2DI 0 "register_operand" "=x")
13101         (plus:V2DI
13102          (plus:V2DI
13103           (any_extend:V2DI
13104            (vec_select:V2HI
13105             (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13106             (parallel [(const_int 0) (const_int 4)])))
13107           (any_extend:V2DI
13108            (vec_select:V2HI
13109             (match_dup 1)
13110             (parallel [(const_int 1) (const_int 5)]))))
13111          (plus:V2DI
13112           (any_extend:V2DI
13113            (vec_select:V2HI
13114             (match_dup 1)
13115             (parallel [(const_int 2) (const_int 6)])))
13116           (any_extend:V2DI
13117            (vec_select:V2HI
13118             (match_dup 1)
13119             (parallel [(const_int 3) (const_int 7)]))))))]
13120   "TARGET_XOP"
13121   "vphadd<u>wq\t{%1, %0|%0, %1}"
13122   [(set_attr "type" "sseiadd1")])
13123
13124 (define_insn "xop_phadd<u>dq"
13125   [(set (match_operand:V2DI 0 "register_operand" "=x")
13126         (plus:V2DI
13127          (any_extend:V2DI
13128           (vec_select:V2SI
13129            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
13130            (parallel [(const_int 0) (const_int 2)])))
13131          (any_extend:V2DI
13132           (vec_select:V2SI
13133            (match_dup 1)
13134            (parallel [(const_int 1) (const_int 3)])))))]
13135   "TARGET_XOP"
13136   "vphadd<u>dq\t{%1, %0|%0, %1}"
13137   [(set_attr "type" "sseiadd1")])
13138
13139 (define_insn "xop_phsubbw"
13140   [(set (match_operand:V8HI 0 "register_operand" "=x")
13141         (minus:V8HI
13142          (sign_extend:V8HI
13143           (vec_select:V8QI
13144            (match_operand:V16QI 1 "nonimmediate_operand" "xm")
13145            (parallel [(const_int 0) (const_int 2)
13146                       (const_int 4) (const_int 6)
13147                       (const_int 8) (const_int 10)
13148                       (const_int 12) (const_int 14)])))
13149          (sign_extend:V8HI
13150           (vec_select:V8QI
13151            (match_dup 1)
13152            (parallel [(const_int 1) (const_int 3)
13153                       (const_int 5) (const_int 7)
13154                       (const_int 9) (const_int 11)
13155                       (const_int 13) (const_int 15)])))))]
13156   "TARGET_XOP"
13157   "vphsubbw\t{%1, %0|%0, %1}"
13158   [(set_attr "type" "sseiadd1")])
13159
13160 (define_insn "xop_phsubwd"
13161   [(set (match_operand:V4SI 0 "register_operand" "=x")
13162         (minus:V4SI
13163          (sign_extend:V4SI
13164           (vec_select:V4HI
13165            (match_operand:V8HI 1 "nonimmediate_operand" "xm")
13166            (parallel [(const_int 0) (const_int 2)
13167                       (const_int 4) (const_int 6)])))
13168          (sign_extend:V4SI
13169           (vec_select:V4HI
13170            (match_dup 1)
13171            (parallel [(const_int 1) (const_int 3)
13172                       (const_int 5) (const_int 7)])))))]
13173   "TARGET_XOP"
13174   "vphsubwd\t{%1, %0|%0, %1}"
13175   [(set_attr "type" "sseiadd1")])
13176
13177 (define_insn "xop_phsubdq"
13178   [(set (match_operand:V2DI 0 "register_operand" "=x")
13179         (minus:V2DI
13180          (sign_extend:V2DI
13181           (vec_select:V2SI
13182            (match_operand:V4SI 1 "nonimmediate_operand" "xm")
13183            (parallel [(const_int 0) (const_int 2)])))
13184          (sign_extend:V2DI
13185           (vec_select:V2SI
13186            (match_dup 1)
13187            (parallel [(const_int 1) (const_int 3)])))))]
13188   "TARGET_XOP"
13189   "vphsubdq\t{%1, %0|%0, %1}"
13190   [(set_attr "type" "sseiadd1")])
13191
13192 ;; XOP permute instructions
13193 (define_insn "xop_pperm"
13194   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
13195         (unspec:V16QI
13196           [(match_operand:V16QI 1 "register_operand" "x,x")
13197            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
13198            (match_operand:V16QI 3 "nonimmediate_operand" "xm,x")]
13199           UNSPEC_XOP_PERMUTE))]
13200   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13201   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13202   [(set_attr "type" "sse4arg")
13203    (set_attr "mode" "TI")])
13204
13205 ;; XOP pack instructions that combine two vectors into a smaller vector
13206 (define_insn "xop_pperm_pack_v2di_v4si"
13207   [(set (match_operand:V4SI 0 "register_operand" "=x,x")
13208         (vec_concat:V4SI
13209          (truncate:V2SI
13210           (match_operand:V2DI 1 "register_operand" "x,x"))
13211          (truncate:V2SI
13212           (match_operand:V2DI 2 "nonimmediate_operand" "x,m"))))
13213    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13214   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13215   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13216   [(set_attr "type" "sse4arg")
13217    (set_attr "mode" "TI")])
13218
13219 (define_insn "xop_pperm_pack_v4si_v8hi"
13220   [(set (match_operand:V8HI 0 "register_operand" "=x,x")
13221         (vec_concat:V8HI
13222          (truncate:V4HI
13223           (match_operand:V4SI 1 "register_operand" "x,x"))
13224          (truncate:V4HI
13225           (match_operand:V4SI 2 "nonimmediate_operand" "x,m"))))
13226    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13227   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13228   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13229   [(set_attr "type" "sse4arg")
13230    (set_attr "mode" "TI")])
13231
13232 (define_insn "xop_pperm_pack_v8hi_v16qi"
13233   [(set (match_operand:V16QI 0 "register_operand" "=x,x")
13234         (vec_concat:V16QI
13235          (truncate:V8QI
13236           (match_operand:V8HI 1 "register_operand" "x,x"))
13237          (truncate:V8QI
13238           (match_operand:V8HI 2 "nonimmediate_operand" "x,m"))))
13239    (use (match_operand:V16QI 3 "nonimmediate_operand" "xm,x"))]
13240   "TARGET_XOP && !(MEM_P (operands[2]) && MEM_P (operands[3]))"
13241   "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13242   [(set_attr "type" "sse4arg")
13243    (set_attr "mode" "TI")])
13244
13245 ;; XOP packed rotate instructions
13246 (define_expand "rotl<mode>3"
13247   [(set (match_operand:VI_128 0 "register_operand")
13248         (rotate:VI_128
13249          (match_operand:VI_128 1 "nonimmediate_operand")
13250          (match_operand:SI 2 "general_operand")))]
13251   "TARGET_XOP"
13252 {
13253   /* If we were given a scalar, convert it to parallel */
13254   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
13255     {
13256       rtvec vs = rtvec_alloc (<ssescalarnum>);
13257       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
13258       rtx reg = gen_reg_rtx (<MODE>mode);
13259       rtx op2 = operands[2];
13260       int i;
13261
13262       if (GET_MODE (op2) != <ssescalarmode>mode)
13263         {
13264           op2 = gen_reg_rtx (<ssescalarmode>mode);
13265           convert_move (op2, operands[2], false);
13266         }
13267
13268       for (i = 0; i < <ssescalarnum>; i++)
13269         RTVEC_ELT (vs, i) = op2;
13270
13271       emit_insn (gen_vec_init<mode> (reg, par));
13272       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
13273       DONE;
13274     }
13275 })
13276
13277 (define_expand "rotr<mode>3"
13278   [(set (match_operand:VI_128 0 "register_operand")
13279         (rotatert:VI_128
13280          (match_operand:VI_128 1 "nonimmediate_operand")
13281          (match_operand:SI 2 "general_operand")))]
13282   "TARGET_XOP"
13283 {
13284   /* If we were given a scalar, convert it to parallel */
13285   if (! const_0_to_<sserotatemax>_operand (operands[2], SImode))
13286     {
13287       rtvec vs = rtvec_alloc (<ssescalarnum>);
13288       rtx par = gen_rtx_PARALLEL (<MODE>mode, vs);
13289       rtx neg = gen_reg_rtx (<MODE>mode);
13290       rtx reg = gen_reg_rtx (<MODE>mode);
13291       rtx op2 = operands[2];
13292       int i;
13293
13294       if (GET_MODE (op2) != <ssescalarmode>mode)
13295         {
13296           op2 = gen_reg_rtx (<ssescalarmode>mode);
13297           convert_move (op2, operands[2], false);
13298         }
13299
13300       for (i = 0; i < <ssescalarnum>; i++)
13301         RTVEC_ELT (vs, i) = op2;
13302
13303       emit_insn (gen_vec_init<mode> (reg, par));
13304       emit_insn (gen_neg<mode>2 (neg, reg));
13305       emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], neg));
13306       DONE;
13307     }
13308 })
13309
13310 (define_insn "xop_rotl<mode>3"
13311   [(set (match_operand:VI_128 0 "register_operand" "=x")
13312         (rotate:VI_128
13313          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
13314          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
13315   "TARGET_XOP"
13316   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13317   [(set_attr "type" "sseishft")
13318    (set_attr "length_immediate" "1")
13319    (set_attr "mode" "TI")])
13320
13321 (define_insn "xop_rotr<mode>3"
13322   [(set (match_operand:VI_128 0 "register_operand" "=x")
13323         (rotatert:VI_128
13324          (match_operand:VI_128 1 "nonimmediate_operand" "xm")
13325          (match_operand:SI 2 "const_0_to_<sserotatemax>_operand" "n")))]
13326   "TARGET_XOP"
13327 {
13328   operands[3]
13329     = GEN_INT (GET_MODE_BITSIZE (<ssescalarmode>mode) - INTVAL (operands[2]));
13330   return \"vprot<ssemodesuffix>\t{%3, %1, %0|%0, %1, %3}\";
13331 }
13332   [(set_attr "type" "sseishft")
13333    (set_attr "length_immediate" "1")
13334    (set_attr "mode" "TI")])
13335
13336 (define_expand "vrotr<mode>3"
13337   [(match_operand:VI_128 0 "register_operand")
13338    (match_operand:VI_128 1 "register_operand")
13339    (match_operand:VI_128 2 "register_operand")]
13340   "TARGET_XOP"
13341 {
13342   rtx reg = gen_reg_rtx (<MODE>mode);
13343   emit_insn (gen_neg<mode>2 (reg, operands[2]));
13344   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], reg));
13345   DONE;
13346 })
13347
13348 (define_expand "vrotl<mode>3"
13349   [(match_operand:VI_128 0 "register_operand")
13350    (match_operand:VI_128 1 "register_operand")
13351    (match_operand:VI_128 2 "register_operand")]
13352   "TARGET_XOP"
13353 {
13354   emit_insn (gen_xop_vrotl<mode>3 (operands[0], operands[1], operands[2]));
13355   DONE;
13356 })
13357
13358 (define_insn "xop_vrotl<mode>3"
13359   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13360         (if_then_else:VI_128
13361          (ge:VI_128
13362           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13363           (const_int 0))
13364          (rotate:VI_128
13365           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13366           (match_dup 2))
13367          (rotatert:VI_128
13368           (match_dup 1)
13369           (neg:VI_128 (match_dup 2)))))]
13370   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13371   "vprot<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13372   [(set_attr "type" "sseishft")
13373    (set_attr "prefix_data16" "0")
13374    (set_attr "prefix_extra" "2")
13375    (set_attr "mode" "TI")])
13376
13377 ;; XOP packed shift instructions.
13378 (define_expand "vlshr<mode>3"
13379   [(set (match_operand:VI12_128 0 "register_operand")
13380         (lshiftrt:VI12_128
13381           (match_operand:VI12_128 1 "register_operand")
13382           (match_operand:VI12_128 2 "nonimmediate_operand")))]
13383   "TARGET_XOP"
13384 {
13385   rtx neg = gen_reg_rtx (<MODE>mode);
13386   emit_insn (gen_neg<mode>2 (neg, operands[2]));
13387   emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
13388   DONE;
13389 })
13390
13391 (define_expand "vlshr<mode>3"
13392   [(set (match_operand:VI48_128 0 "register_operand")
13393         (lshiftrt:VI48_128
13394           (match_operand:VI48_128 1 "register_operand")
13395           (match_operand:VI48_128 2 "nonimmediate_operand")))]
13396   "TARGET_AVX2 || TARGET_XOP"
13397 {
13398   if (!TARGET_AVX2)
13399     {
13400       rtx neg = gen_reg_rtx (<MODE>mode);
13401       emit_insn (gen_neg<mode>2 (neg, operands[2]));
13402       emit_insn (gen_xop_shl<mode>3 (operands[0], operands[1], neg));
13403       DONE;
13404     }
13405 })
13406
13407 (define_expand "vlshr<mode>3"
13408   [(set (match_operand:VI48_512 0 "register_operand")
13409         (lshiftrt:VI48_512
13410           (match_operand:VI48_512 1 "register_operand")
13411           (match_operand:VI48_512 2 "nonimmediate_operand")))]
13412   "TARGET_AVX512F")
13413
13414 (define_expand "vlshr<mode>3"
13415   [(set (match_operand:VI48_256 0 "register_operand")
13416         (lshiftrt:VI48_256
13417           (match_operand:VI48_256 1 "register_operand")
13418           (match_operand:VI48_256 2 "nonimmediate_operand")))]
13419   "TARGET_AVX2")
13420
13421 (define_expand "vashr<mode>3"
13422   [(set (match_operand:VI128_128 0 "register_operand")
13423         (ashiftrt:VI128_128
13424           (match_operand:VI128_128 1 "register_operand")
13425           (match_operand:VI128_128 2 "nonimmediate_operand")))]
13426   "TARGET_XOP"
13427 {
13428   rtx neg = gen_reg_rtx (<MODE>mode);
13429   emit_insn (gen_neg<mode>2 (neg, operands[2]));
13430   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], neg));
13431   DONE;
13432 })
13433
13434 (define_expand "vashrv4si3"
13435   [(set (match_operand:V4SI 0 "register_operand")
13436         (ashiftrt:V4SI (match_operand:V4SI 1 "register_operand")
13437                        (match_operand:V4SI 2 "nonimmediate_operand")))]
13438   "TARGET_AVX2 || TARGET_XOP"
13439 {
13440   if (!TARGET_AVX2)
13441     {
13442       rtx neg = gen_reg_rtx (V4SImode);
13443       emit_insn (gen_negv4si2 (neg, operands[2]));
13444       emit_insn (gen_xop_shav4si3 (operands[0], operands[1], neg));
13445       DONE;
13446     }
13447 })
13448
13449 (define_expand "vashrv16si3"
13450   [(set (match_operand:V16SI 0 "register_operand")
13451         (ashiftrt:V16SI (match_operand:V16SI 1 "register_operand")
13452                         (match_operand:V16SI 2 "nonimmediate_operand")))]
13453   "TARGET_AVX512F")
13454
13455 (define_expand "vashrv8si3"
13456   [(set (match_operand:V8SI 0 "register_operand")
13457         (ashiftrt:V8SI (match_operand:V8SI 1 "register_operand")
13458                        (match_operand:V8SI 2 "nonimmediate_operand")))]
13459   "TARGET_AVX2")
13460
13461 (define_expand "vashl<mode>3"
13462   [(set (match_operand:VI12_128 0 "register_operand")
13463         (ashift:VI12_128
13464           (match_operand:VI12_128 1 "register_operand")
13465           (match_operand:VI12_128 2 "nonimmediate_operand")))]
13466   "TARGET_XOP"
13467 {
13468   emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
13469   DONE;
13470 })
13471
13472 (define_expand "vashl<mode>3"
13473   [(set (match_operand:VI48_128 0 "register_operand")
13474         (ashift:VI48_128
13475           (match_operand:VI48_128 1 "register_operand")
13476           (match_operand:VI48_128 2 "nonimmediate_operand")))]
13477   "TARGET_AVX2 || TARGET_XOP"
13478 {
13479   if (!TARGET_AVX2)
13480     {
13481       operands[2] = force_reg (<MODE>mode, operands[2]);
13482       emit_insn (gen_xop_sha<mode>3 (operands[0], operands[1], operands[2]));
13483       DONE;
13484     }
13485 })
13486
13487 (define_expand "vashl<mode>3"
13488   [(set (match_operand:VI48_512 0 "register_operand")
13489         (ashift:VI48_512
13490           (match_operand:VI48_512 1 "register_operand")
13491           (match_operand:VI48_512 2 "nonimmediate_operand")))]
13492   "TARGET_AVX512F")
13493
13494 (define_expand "vashl<mode>3"
13495   [(set (match_operand:VI48_256 0 "register_operand")
13496         (ashift:VI48_256
13497           (match_operand:VI48_256 1 "register_operand")
13498           (match_operand:VI48_256 2 "nonimmediate_operand")))]
13499   "TARGET_AVX2")
13500
13501 (define_insn "xop_sha<mode>3"
13502   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13503         (if_then_else:VI_128
13504          (ge:VI_128
13505           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13506           (const_int 0))
13507          (ashift:VI_128
13508           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13509           (match_dup 2))
13510          (ashiftrt:VI_128
13511           (match_dup 1)
13512           (neg:VI_128 (match_dup 2)))))]
13513   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13514   "vpsha<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13515   [(set_attr "type" "sseishft")
13516    (set_attr "prefix_data16" "0")
13517    (set_attr "prefix_extra" "2")
13518    (set_attr "mode" "TI")])
13519
13520 (define_insn "xop_shl<mode>3"
13521   [(set (match_operand:VI_128 0 "register_operand" "=x,x")
13522         (if_then_else:VI_128
13523          (ge:VI_128
13524           (match_operand:VI_128 2 "nonimmediate_operand" "x,m")
13525           (const_int 0))
13526          (ashift:VI_128
13527           (match_operand:VI_128 1 "nonimmediate_operand" "xm,x")
13528           (match_dup 2))
13529          (lshiftrt:VI_128
13530           (match_dup 1)
13531           (neg:VI_128 (match_dup 2)))))]
13532   "TARGET_XOP && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
13533   "vpshl<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13534   [(set_attr "type" "sseishft")
13535    (set_attr "prefix_data16" "0")
13536    (set_attr "prefix_extra" "2")
13537    (set_attr "mode" "TI")])
13538
13539 (define_expand "<shift_insn><mode>3"
13540   [(set (match_operand:VI1_AVX2 0 "register_operand")
13541         (any_shift:VI1_AVX2
13542           (match_operand:VI1_AVX2 1 "register_operand")
13543           (match_operand:SI 2 "nonmemory_operand")))]
13544   "TARGET_SSE2"
13545 {
13546   if (TARGET_XOP && <MODE>mode == V16QImode)
13547     {
13548       bool negate = false;
13549       rtx (*gen) (rtx, rtx, rtx);
13550       rtx tmp, par;
13551       int i;
13552
13553       if (<CODE> != ASHIFT)
13554         {
13555           if (CONST_INT_P (operands[2]))
13556             operands[2] = GEN_INT (-INTVAL (operands[2]));
13557           else
13558             negate = true;
13559         }
13560       par = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
13561       for (i = 0; i < 16; i++)
13562         XVECEXP (par, 0, i) = operands[2];
13563
13564       tmp = gen_reg_rtx (V16QImode);
13565       emit_insn (gen_vec_initv16qi (tmp, par));
13566
13567       if (negate)
13568         emit_insn (gen_negv16qi2 (tmp, tmp));
13569
13570       gen = (<CODE> == LSHIFTRT ? gen_xop_shlv16qi3 : gen_xop_shav16qi3);
13571       emit_insn (gen (operands[0], operands[1], tmp));
13572     }
13573   else
13574     ix86_expand_vecop_qihi (<CODE>, operands[0], operands[1], operands[2]);
13575   DONE;
13576 })
13577
13578 (define_expand "ashrv2di3"
13579   [(set (match_operand:V2DI 0 "register_operand")
13580         (ashiftrt:V2DI
13581           (match_operand:V2DI 1 "register_operand")
13582           (match_operand:DI 2 "nonmemory_operand")))]
13583   "TARGET_XOP"
13584 {
13585   rtx reg = gen_reg_rtx (V2DImode);
13586   rtx par;
13587   bool negate = false;
13588   int i;
13589
13590   if (CONST_INT_P (operands[2]))
13591     operands[2] = GEN_INT (-INTVAL (operands[2]));
13592   else
13593     negate = true;
13594
13595   par = gen_rtx_PARALLEL (V2DImode, rtvec_alloc (2));
13596   for (i = 0; i < 2; i++)
13597     XVECEXP (par, 0, i) = operands[2];
13598
13599   emit_insn (gen_vec_initv2di (reg, par));
13600
13601   if (negate)
13602     emit_insn (gen_negv2di2 (reg, reg));
13603
13604   emit_insn (gen_xop_shav2di3 (operands[0], operands[1], reg));
13605   DONE;
13606 })
13607
13608 ;; XOP FRCZ support
13609 (define_insn "xop_frcz<mode>2"
13610   [(set (match_operand:FMAMODE 0 "register_operand" "=x")
13611         (unspec:FMAMODE
13612          [(match_operand:FMAMODE 1 "nonimmediate_operand" "xm")]
13613          UNSPEC_FRCZ))]
13614   "TARGET_XOP"
13615   "vfrcz<ssemodesuffix>\t{%1, %0|%0, %1}"
13616   [(set_attr "type" "ssecvt1")
13617    (set_attr "mode" "<MODE>")])
13618
13619 (define_expand "xop_vmfrcz<mode>2"
13620   [(set (match_operand:VF_128 0 "register_operand")
13621         (vec_merge:VF_128
13622           (unspec:VF_128
13623            [(match_operand:VF_128 1 "nonimmediate_operand")]
13624            UNSPEC_FRCZ)
13625           (match_dup 2)
13626           (const_int 1)))]
13627   "TARGET_XOP"
13628   "operands[2] = CONST0_RTX (<MODE>mode);")
13629
13630 (define_insn "*xop_vmfrcz<mode>2"
13631   [(set (match_operand:VF_128 0 "register_operand" "=x")
13632         (vec_merge:VF_128
13633           (unspec:VF_128
13634            [(match_operand:VF_128 1 "nonimmediate_operand" "xm")]
13635            UNSPEC_FRCZ)
13636           (match_operand:VF_128 2 "const0_operand")
13637           (const_int 1)))]
13638   "TARGET_XOP"
13639   "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}"
13640   [(set_attr "type" "ssecvt1")
13641    (set_attr "mode" "<MODE>")])
13642
13643 (define_insn "xop_maskcmp<mode>3"
13644   [(set (match_operand:VI_128 0 "register_operand" "=x")
13645         (match_operator:VI_128 1 "ix86_comparison_int_operator"
13646          [(match_operand:VI_128 2 "register_operand" "x")
13647           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
13648   "TARGET_XOP"
13649   "vpcom%Y1<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13650   [(set_attr "type" "sse4arg")
13651    (set_attr "prefix_data16" "0")
13652    (set_attr "prefix_rep" "0")
13653    (set_attr "prefix_extra" "2")
13654    (set_attr "length_immediate" "1")
13655    (set_attr "mode" "TI")])
13656
13657 (define_insn "xop_maskcmp_uns<mode>3"
13658   [(set (match_operand:VI_128 0 "register_operand" "=x")
13659         (match_operator:VI_128 1 "ix86_comparison_uns_operator"
13660          [(match_operand:VI_128 2 "register_operand" "x")
13661           (match_operand:VI_128 3 "nonimmediate_operand" "xm")]))]
13662   "TARGET_XOP"
13663   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13664   [(set_attr "type" "ssecmp")
13665    (set_attr "prefix_data16" "0")
13666    (set_attr "prefix_rep" "0")
13667    (set_attr "prefix_extra" "2")
13668    (set_attr "length_immediate" "1")
13669    (set_attr "mode" "TI")])
13670
13671 ;; Version of pcom*u* that is called from the intrinsics that allows pcomequ*
13672 ;; and pcomneu* not to be converted to the signed ones in case somebody needs
13673 ;; the exact instruction generated for the intrinsic.
13674 (define_insn "xop_maskcmp_uns2<mode>3"
13675   [(set (match_operand:VI_128 0 "register_operand" "=x")
13676         (unspec:VI_128
13677          [(match_operator:VI_128 1 "ix86_comparison_uns_operator"
13678           [(match_operand:VI_128 2 "register_operand" "x")
13679            (match_operand:VI_128 3 "nonimmediate_operand" "xm")])]
13680          UNSPEC_XOP_UNSIGNED_CMP))]
13681   "TARGET_XOP"
13682   "vpcom%Y1u<ssemodesuffix>\t{%3, %2, %0|%0, %2, %3}"
13683   [(set_attr "type" "ssecmp")
13684    (set_attr "prefix_data16" "0")
13685    (set_attr "prefix_extra" "2")
13686    (set_attr "length_immediate" "1")
13687    (set_attr "mode" "TI")])
13688
13689 ;; Pcomtrue and pcomfalse support.  These are useless instructions, but are
13690 ;; being added here to be complete.
13691 (define_insn "xop_pcom_tf<mode>3"
13692   [(set (match_operand:VI_128 0 "register_operand" "=x")
13693         (unspec:VI_128
13694           [(match_operand:VI_128 1 "register_operand" "x")
13695            (match_operand:VI_128 2 "nonimmediate_operand" "xm")
13696            (match_operand:SI 3 "const_int_operand" "n")]
13697           UNSPEC_XOP_TRUEFALSE))]
13698   "TARGET_XOP"
13699 {
13700   return ((INTVAL (operands[3]) != 0)
13701           ? "vpcomtrue<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
13702           : "vpcomfalse<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}");
13703 }
13704   [(set_attr "type" "ssecmp")
13705    (set_attr "prefix_data16" "0")
13706    (set_attr "prefix_extra" "2")
13707    (set_attr "length_immediate" "1")
13708    (set_attr "mode" "TI")])
13709
13710 (define_insn "xop_vpermil2<mode>3"
13711   [(set (match_operand:VF_128_256 0 "register_operand" "=x")
13712         (unspec:VF_128_256
13713           [(match_operand:VF_128_256 1 "register_operand" "x")
13714            (match_operand:VF_128_256 2 "nonimmediate_operand" "%x")
13715            (match_operand:<sseintvecmode> 3 "nonimmediate_operand" "xm")
13716            (match_operand:SI 4 "const_0_to_3_operand" "n")]
13717           UNSPEC_VPERMIL2))]
13718   "TARGET_XOP"
13719   "vpermil2<ssemodesuffix>\t{%4, %3, %2, %1, %0|%0, %1, %2, %3, %4}"
13720   [(set_attr "type" "sse4arg")
13721    (set_attr "length_immediate" "1")
13722    (set_attr "mode" "<MODE>")])
13723
13724 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13725
13726 (define_insn "aesenc"
13727   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13728         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13729                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13730                       UNSPEC_AESENC))]
13731   "TARGET_AES"
13732   "@
13733    aesenc\t{%2, %0|%0, %2}
13734    vaesenc\t{%2, %1, %0|%0, %1, %2}"
13735   [(set_attr "isa" "noavx,avx")
13736    (set_attr "type" "sselog1")
13737    (set_attr "prefix_extra" "1")
13738    (set_attr "prefix" "orig,vex")
13739    (set_attr "btver2_decode" "double,double")
13740    (set_attr "mode" "TI")])
13741
13742 (define_insn "aesenclast"
13743   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13744         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13745                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13746                       UNSPEC_AESENCLAST))]
13747   "TARGET_AES"
13748   "@
13749    aesenclast\t{%2, %0|%0, %2}
13750    vaesenclast\t{%2, %1, %0|%0, %1, %2}"
13751   [(set_attr "isa" "noavx,avx")
13752    (set_attr "type" "sselog1")
13753    (set_attr "prefix_extra" "1")
13754    (set_attr "prefix" "orig,vex")
13755    (set_attr "btver2_decode" "double,double")
13756    (set_attr "mode" "TI")])
13757
13758 (define_insn "aesdec"
13759   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13760         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13761                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13762                       UNSPEC_AESDEC))]
13763   "TARGET_AES"
13764   "@
13765    aesdec\t{%2, %0|%0, %2}
13766    vaesdec\t{%2, %1, %0|%0, %1, %2}"
13767   [(set_attr "isa" "noavx,avx")
13768    (set_attr "type" "sselog1")
13769    (set_attr "prefix_extra" "1")
13770    (set_attr "prefix" "orig,vex")
13771    (set_attr "btver2_decode" "double,double")
13772    (set_attr "mode" "TI")])
13773
13774 (define_insn "aesdeclast"
13775   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13776         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13777                        (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")]
13778                       UNSPEC_AESDECLAST))]
13779   "TARGET_AES"
13780   "@
13781    aesdeclast\t{%2, %0|%0, %2}
13782    vaesdeclast\t{%2, %1, %0|%0, %1, %2}"
13783   [(set_attr "isa" "noavx,avx")
13784    (set_attr "type" "sselog1")
13785    (set_attr "prefix_extra" "1")
13786    (set_attr "prefix" "orig,vex")
13787    (set_attr "btver2_decode" "double,double")
13788    (set_attr "mode" "TI")])
13789
13790 (define_insn "aesimc"
13791   [(set (match_operand:V2DI 0 "register_operand" "=x")
13792         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")]
13793                       UNSPEC_AESIMC))]
13794   "TARGET_AES"
13795   "%vaesimc\t{%1, %0|%0, %1}"
13796   [(set_attr "type" "sselog1")
13797    (set_attr "prefix_extra" "1")
13798    (set_attr "prefix" "maybe_vex")
13799    (set_attr "mode" "TI")])
13800
13801 (define_insn "aeskeygenassist"
13802   [(set (match_operand:V2DI 0 "register_operand" "=x")
13803         (unspec:V2DI [(match_operand:V2DI 1 "nonimmediate_operand" "xm")
13804                       (match_operand:SI 2 "const_0_to_255_operand" "n")]
13805                      UNSPEC_AESKEYGENASSIST))]
13806   "TARGET_AES"
13807   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
13808   [(set_attr "type" "sselog1")
13809    (set_attr "prefix_extra" "1")
13810    (set_attr "length_immediate" "1")
13811    (set_attr "prefix" "maybe_vex")
13812    (set_attr "mode" "TI")])
13813
13814 (define_insn "pclmulqdq"
13815   [(set (match_operand:V2DI 0 "register_operand" "=x,x")
13816         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0,x")
13817                       (match_operand:V2DI 2 "nonimmediate_operand" "xm,xm")
13818                       (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
13819                      UNSPEC_PCLMUL))]
13820   "TARGET_PCLMUL"
13821   "@
13822    pclmulqdq\t{%3, %2, %0|%0, %2, %3}
13823    vpclmulqdq\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13824   [(set_attr "isa" "noavx,avx")
13825    (set_attr "type" "sselog1")
13826    (set_attr "prefix_extra" "1")
13827    (set_attr "length_immediate" "1")
13828    (set_attr "prefix" "orig,vex")
13829    (set_attr "mode" "TI")])
13830
13831 (define_expand "avx_vzeroall"
13832   [(match_par_dup 0 [(const_int 0)])]
13833   "TARGET_AVX"
13834 {
13835   int nregs = TARGET_64BIT ? 16 : 8;
13836   int regno;
13837
13838   operands[0] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs + 1));
13839
13840   XVECEXP (operands[0], 0, 0)
13841     = gen_rtx_UNSPEC_VOLATILE (VOIDmode, gen_rtvec (1, const0_rtx),
13842                                UNSPECV_VZEROALL);
13843
13844   for (regno = 0; regno < nregs; regno++)
13845     XVECEXP (operands[0], 0, regno + 1)
13846       = gen_rtx_SET (VOIDmode,
13847                      gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
13848                      CONST0_RTX (V8SImode));
13849 })
13850
13851 (define_insn "*avx_vzeroall"
13852   [(match_parallel 0 "vzeroall_operation"
13853     [(unspec_volatile [(const_int 0)] UNSPECV_VZEROALL)])]
13854   "TARGET_AVX"
13855   "vzeroall"
13856   [(set_attr "type" "sse")
13857    (set_attr "modrm" "0")
13858    (set_attr "memory" "none")
13859    (set_attr "prefix" "vex")
13860    (set_attr "btver2_decode" "vector")
13861    (set_attr "mode" "OI")])
13862
13863 ;; Clear the upper 128bits of AVX registers, equivalent to a NOP
13864 ;; if the upper 128bits are unused.
13865 (define_insn "avx_vzeroupper"
13866   [(unspec_volatile [(const_int 0)] UNSPECV_VZEROUPPER)]
13867   "TARGET_AVX"
13868   "vzeroupper"
13869   [(set_attr "type" "sse")
13870    (set_attr "modrm" "0")
13871    (set_attr "memory" "none")
13872    (set_attr "prefix" "vex")
13873    (set_attr "btver2_decode" "vector")
13874    (set_attr "mode" "OI")])
13875
13876 (define_insn "avx2_pbroadcast<mode>"
13877   [(set (match_operand:VI 0 "register_operand" "=x")
13878         (vec_duplicate:VI
13879           (vec_select:<ssescalarmode>
13880             (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "xm")
13881             (parallel [(const_int 0)]))))]
13882   "TARGET_AVX2"
13883   "vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}"
13884   [(set_attr "type" "ssemov")
13885    (set_attr "prefix_extra" "1")
13886    (set_attr "prefix" "vex")
13887    (set_attr "mode" "<sseinsnmode>")])
13888
13889 (define_insn "avx2_pbroadcast<mode>_1"
13890   [(set (match_operand:VI_256 0 "register_operand" "=x,x")
13891         (vec_duplicate:VI_256
13892           (vec_select:<ssescalarmode>
13893             (match_operand:VI_256 1 "nonimmediate_operand" "m,x")
13894             (parallel [(const_int 0)]))))]
13895   "TARGET_AVX2"
13896   "@
13897    vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}
13898    vpbroadcast<ssemodesuffix>\t{%x1, %0|%0, %x1}"
13899   [(set_attr "type" "ssemov")
13900    (set_attr "prefix_extra" "1")
13901    (set_attr "prefix" "vex")
13902    (set_attr "mode" "<sseinsnmode>")])
13903
13904 (define_insn "<avx2_avx512f>_permvar<mode><mask_name>"
13905   [(set (match_operand:VI48F_256_512 0 "register_operand" "=v")
13906         (unspec:VI48F_256_512
13907           [(match_operand:VI48F_256_512 1 "nonimmediate_operand" "vm")
13908            (match_operand:<sseintvecmode> 2 "register_operand" "v")]
13909           UNSPEC_VPERMVAR))]
13910   "TARGET_AVX2 && <mask_mode512bit_condition>"
13911   "vperm<ssemodesuffix>\t{%1, %2, %0<mask_operand3>|%0<mask_operand3>, %2, %1}"
13912   [(set_attr "type" "sselog")
13913    (set_attr "prefix" "<mask_prefix2>")
13914    (set_attr "mode" "<sseinsnmode>")])
13915
13916 (define_expand "<avx2_avx512f>_perm<mode>"
13917   [(match_operand:VI8F_256_512 0 "register_operand")
13918    (match_operand:VI8F_256_512 1 "nonimmediate_operand")
13919    (match_operand:SI 2 "const_0_to_255_operand")]
13920   "TARGET_AVX2"
13921 {
13922   int mask = INTVAL (operands[2]);
13923   emit_insn (gen_<avx2_avx512f>_perm<mode>_1 (operands[0], operands[1],
13924                                               GEN_INT ((mask >> 0) & 3),
13925                                               GEN_INT ((mask >> 2) & 3),
13926                                               GEN_INT ((mask >> 4) & 3),
13927                                               GEN_INT ((mask >> 6) & 3)));
13928   DONE;
13929 })
13930
13931 (define_expand "avx512f_perm<mode>_mask"
13932   [(match_operand:V8FI 0 "register_operand")
13933    (match_operand:V8FI 1 "nonimmediate_operand")
13934    (match_operand:SI 2 "const_0_to_255_operand")
13935    (match_operand:V8FI 3 "vector_move_operand")
13936    (match_operand:<avx512fmaskmode> 4 "register_operand")]
13937   "TARGET_AVX512F"
13938 {
13939   int mask = INTVAL (operands[2]);
13940   emit_insn (gen_<avx2_avx512f>_perm<mode>_1_mask (operands[0], operands[1],
13941                                                    GEN_INT ((mask >> 0) & 3),
13942                                                    GEN_INT ((mask >> 2) & 3),
13943                                                    GEN_INT ((mask >> 4) & 3),
13944                                                    GEN_INT ((mask >> 6) & 3),
13945                                                    operands[3], operands[4]));
13946   DONE;
13947 })
13948
13949 (define_insn "<avx2_avx512f>_perm<mode>_1<mask_name>"
13950   [(set (match_operand:VI8F_256_512 0 "register_operand" "=v")
13951         (vec_select:VI8F_256_512
13952           (match_operand:VI8F_256_512 1 "nonimmediate_operand" "vm")
13953           (parallel [(match_operand 2 "const_0_to_3_operand")
13954                      (match_operand 3 "const_0_to_3_operand")
13955                      (match_operand 4 "const_0_to_3_operand")
13956                      (match_operand 5 "const_0_to_3_operand")])))]
13957   "TARGET_AVX2 && <mask_mode512bit_condition>"
13958 {
13959   int mask = 0;
13960   mask |= INTVAL (operands[2]) << 0;
13961   mask |= INTVAL (operands[3]) << 2;
13962   mask |= INTVAL (operands[4]) << 4;
13963   mask |= INTVAL (operands[5]) << 6;
13964   operands[2] = GEN_INT (mask);
13965   return "vperm<ssemodesuffix>\t{%2, %1, %0<mask_operand6>|%0<mask_operand6>, %1, %2}";
13966 }
13967   [(set_attr "type" "sselog")
13968    (set_attr "prefix" "<mask_prefix2>")
13969    (set_attr "mode" "<sseinsnmode>")])
13970
13971 (define_insn "avx2_permv2ti"
13972   [(set (match_operand:V4DI 0 "register_operand" "=x")
13973         (unspec:V4DI
13974           [(match_operand:V4DI 1 "register_operand" "x")
13975            (match_operand:V4DI 2 "nonimmediate_operand" "xm")
13976            (match_operand:SI 3 "const_0_to_255_operand" "n")]
13977           UNSPEC_VPERMTI))]
13978   "TARGET_AVX2"
13979   "vperm2i128\t{%3, %2, %1, %0|%0, %1, %2, %3}"
13980   [(set_attr "type" "sselog")
13981    (set_attr "prefix" "vex")
13982    (set_attr "mode" "OI")])
13983
13984 (define_insn "avx2_vec_dupv4df"
13985   [(set (match_operand:V4DF 0 "register_operand" "=x")
13986         (vec_duplicate:V4DF
13987           (vec_select:DF
13988             (match_operand:V2DF 1 "register_operand" "x")
13989             (parallel [(const_int 0)]))))]
13990   "TARGET_AVX2"
13991   "vbroadcastsd\t{%1, %0|%0, %1}"
13992   [(set_attr "type" "sselog1")
13993    (set_attr "prefix" "vex")
13994    (set_attr "mode" "V4DF")])
13995
13996 ;; Modes handled by AVX vec_dup patterns.
13997 (define_mode_iterator AVX_VEC_DUP_MODE
13998   [V8SI V8SF V4DI V4DF])
13999
14000 (define_insn "vec_dup<mode>"
14001   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand" "=x,x,x")
14002         (vec_duplicate:AVX_VEC_DUP_MODE
14003           (match_operand:<ssescalarmode> 1 "nonimmediate_operand" "m,x,?x")))]
14004   "TARGET_AVX"
14005   "@
14006    vbroadcast<ssescalarmodesuffix>\t{%1, %0|%0, %1}
14007    vbroadcast<ssescalarmodesuffix>\t{%x1, %0|%0, %x1}
14008    #"
14009   [(set_attr "type" "ssemov")
14010    (set_attr "prefix_extra" "1")
14011    (set_attr "prefix" "vex")
14012    (set_attr "isa" "*,avx2,noavx2")
14013    (set_attr "mode" "V8SF")])
14014
14015 (define_insn "<mask_codefor>avx512f_vec_dup<mode><mask_name>"
14016   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14017         (vec_duplicate:VI48F_512
14018           (vec_select:<ssescalarmode>
14019             (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "vm")
14020             (parallel [(const_int 0)]))))]
14021   "TARGET_AVX512F"
14022   "v<sseintprefix>broadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14023   [(set_attr "type" "ssemov")
14024    (set_attr "prefix" "evex")
14025    (set_attr "mode" "<sseinsnmode>")])
14026
14027 (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
14028   [(set (match_operand:V16FI 0 "register_operand" "=v,v")
14029         (vec_duplicate:V16FI
14030           (match_operand:<ssexmmmode> 1 "nonimmediate_operand" "v,m")))]
14031   "TARGET_AVX512F"
14032   "@
14033    vshuf<shuffletype>32x4\t{$0x0, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x0}
14034    vbroadcast<shuffletype>32x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14035   [(set_attr "type" "ssemov")
14036    (set_attr "prefix" "evex")
14037    (set_attr "mode" "<sseinsnmode>")])
14038
14039 (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
14040   [(set (match_operand:V8FI 0 "register_operand" "=v,v")
14041         (vec_duplicate:V8FI
14042           (match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "v,m")))]
14043   "TARGET_AVX512F"
14044   "@
14045    vshuf<shuffletype>64x2\t{$0x44, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x44}
14046    vbroadcast<shuffletype>64x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14047   [(set_attr "type" "ssemov")
14048    (set_attr "prefix" "evex")
14049    (set_attr "mode" "<sseinsnmode>")])
14050
14051 (define_insn "<mask_codefor>avx512f_vec_dup_gpr<mode><mask_name>"
14052   [(set (match_operand:VI48_512 0 "register_operand" "=v")
14053         (vec_duplicate:VI48_512
14054           (match_operand:<ssescalarmode> 1 "register_operand" "r")))]
14055   "TARGET_AVX512F && (<MODE>mode != V8DImode || TARGET_64BIT)"
14056   "vpbroadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14057   [(set_attr "type" "ssemov")
14058    (set_attr "prefix" "evex")
14059    (set_attr "mode" "<sseinsnmode>")])
14060
14061 (define_insn "<mask_codefor>avx512f_vec_dup_mem<mode><mask_name>"
14062   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14063         (vec_duplicate:VI48F_512
14064           (match_operand:<ssescalarmode> 1 "nonimmediate_operand" "vm")))]
14065   "TARGET_AVX512F"
14066   "v<sseintprefix>broadcast<bcstscalarsuff>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
14067   [(set_attr "type" "ssemov")
14068    (set_attr "prefix" "evex")
14069    (set_attr "mode" "<sseinsnmode>")])
14070
14071 (define_insn "avx2_vbroadcasti128_<mode>"
14072   [(set (match_operand:VI_256 0 "register_operand" "=x")
14073         (vec_concat:VI_256
14074           (match_operand:<ssehalfvecmode> 1 "memory_operand" "m")
14075           (match_dup 1)))]
14076   "TARGET_AVX2"
14077   "vbroadcasti128\t{%1, %0|%0, %1}"
14078   [(set_attr "type" "ssemov")
14079    (set_attr "prefix_extra" "1")
14080    (set_attr "prefix" "vex")
14081    (set_attr "mode" "OI")])
14082
14083 (define_split
14084   [(set (match_operand:AVX_VEC_DUP_MODE 0 "register_operand")
14085         (vec_duplicate:AVX_VEC_DUP_MODE
14086           (match_operand:<ssescalarmode> 1 "register_operand")))]
14087   "TARGET_AVX && !TARGET_AVX2 && reload_completed"
14088   [(set (match_dup 2)
14089         (vec_duplicate:<ssehalfvecmode> (match_dup 1)))
14090    (set (match_dup 0)
14091         (vec_concat:AVX_VEC_DUP_MODE (match_dup 2) (match_dup 2)))]
14092   "operands[2] = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (operands[0]));")
14093
14094 (define_insn "avx_vbroadcastf128_<mode>"
14095   [(set (match_operand:V_256 0 "register_operand" "=x,x,x")
14096         (vec_concat:V_256
14097           (match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "m,0,?x")
14098           (match_dup 1)))]
14099   "TARGET_AVX"
14100   "@
14101    vbroadcast<i128>\t{%1, %0|%0, %1}
14102    vinsert<i128>\t{$1, %1, %0, %0|%0, %0, %1, 1}
14103    vperm2<i128>\t{$0, %t1, %t1, %0|%0, %t1, %t1, 0}"
14104   [(set_attr "type" "ssemov,sselog1,sselog1")
14105    (set_attr "prefix_extra" "1")
14106    (set_attr "length_immediate" "0,1,1")
14107    (set_attr "prefix" "vex")
14108    (set_attr "mode" "<sseinsnmode>")])
14109
14110 (define_insn "avx512cd_maskb_vec_dupv8di"
14111   [(set (match_operand:V8DI 0 "register_operand" "=v")
14112         (vec_duplicate:V8DI
14113           (zero_extend:DI
14114             (match_operand:QI 1 "register_operand" "Yk"))))]
14115   "TARGET_AVX512CD"
14116   "vpbroadcastmb2q\t{%1, %0|%0, %1}"
14117   [(set_attr "type" "mskmov")
14118    (set_attr "prefix" "evex")
14119    (set_attr "mode" "XI")])
14120
14121 (define_insn "avx512cd_maskw_vec_dupv16si"
14122   [(set (match_operand:V16SI 0 "register_operand" "=v")
14123         (vec_duplicate:V16SI
14124           (zero_extend:SI
14125             (match_operand:HI 1 "register_operand" "Yk"))))]
14126   "TARGET_AVX512CD"
14127   "vpbroadcastmw2d\t{%1, %0|%0, %1}"
14128   [(set_attr "type" "mskmov")
14129    (set_attr "prefix" "evex")
14130    (set_attr "mode" "XI")])
14131
14132 ;; Recognize broadcast as a vec_select as produced by builtin_vec_perm.
14133 ;; If it so happens that the input is in memory, use vbroadcast.
14134 ;; Otherwise use vpermilp (and in the case of 256-bit modes, vperm2f128).
14135 (define_insn "*avx_vperm_broadcast_v4sf"
14136   [(set (match_operand:V4SF 0 "register_operand" "=x,x,x")
14137         (vec_select:V4SF
14138           (match_operand:V4SF 1 "nonimmediate_operand" "m,o,x")
14139           (match_parallel 2 "avx_vbroadcast_operand"
14140             [(match_operand 3 "const_int_operand" "C,n,n")])))]
14141   "TARGET_AVX"
14142 {
14143   int elt = INTVAL (operands[3]);
14144   switch (which_alternative)
14145     {
14146     case 0:
14147     case 1:
14148       operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4);
14149       return "vbroadcastss\t{%1, %0|%0, %k1}";
14150     case 2:
14151       operands[2] = GEN_INT (elt * 0x55);
14152       return "vpermilps\t{%2, %1, %0|%0, %1, %2}";
14153     default:
14154       gcc_unreachable ();
14155     }
14156 }
14157   [(set_attr "type" "ssemov,ssemov,sselog1")
14158    (set_attr "prefix_extra" "1")
14159    (set_attr "length_immediate" "0,0,1")
14160    (set_attr "prefix" "vex")
14161    (set_attr "mode" "SF,SF,V4SF")])
14162
14163 (define_insn_and_split "*avx_vperm_broadcast_<mode>"
14164   [(set (match_operand:VF_256 0 "register_operand" "=x,x,x")
14165         (vec_select:VF_256
14166           (match_operand:VF_256 1 "nonimmediate_operand" "m,o,?x")
14167           (match_parallel 2 "avx_vbroadcast_operand"
14168             [(match_operand 3 "const_int_operand" "C,n,n")])))]
14169   "TARGET_AVX"
14170   "#"
14171   "&& reload_completed && (<MODE>mode != V4DFmode || !TARGET_AVX2)"
14172   [(set (match_dup 0) (vec_duplicate:VF_256 (match_dup 1)))]
14173 {
14174   rtx op0 = operands[0], op1 = operands[1];
14175   int elt = INTVAL (operands[3]);
14176
14177   if (REG_P (op1))
14178     {
14179       int mask;
14180
14181       if (TARGET_AVX2 && elt == 0)
14182         {
14183           emit_insn (gen_vec_dup<mode> (op0, gen_lowpart (<ssescalarmode>mode,
14184                                                           op1)));
14185           DONE;
14186         }
14187
14188       /* Shuffle element we care about into all elements of the 128-bit lane.
14189          The other lane gets shuffled too, but we don't care.  */
14190       if (<MODE>mode == V4DFmode)
14191         mask = (elt & 1 ? 15 : 0);
14192       else
14193         mask = (elt & 3) * 0x55;
14194       emit_insn (gen_avx_vpermil<mode> (op0, op1, GEN_INT (mask)));
14195
14196       /* Shuffle the lane we care about into both lanes of the dest.  */
14197       mask = (elt / (<ssescalarnum> / 2)) * 0x11;
14198       emit_insn (gen_avx_vperm2f128<mode>3 (op0, op0, op0, GEN_INT (mask)));
14199       DONE;
14200     }
14201
14202   operands[1] = adjust_address (op1, <ssescalarmode>mode,
14203                                 elt * GET_MODE_SIZE (<ssescalarmode>mode));
14204 })
14205
14206 (define_expand "<sse2_avx_avx512f>_vpermil<mode><mask_name>"
14207   [(set (match_operand:VF2 0 "register_operand")
14208         (vec_select:VF2
14209           (match_operand:VF2 1 "nonimmediate_operand")
14210           (match_operand:SI 2 "const_0_to_255_operand")))]
14211   "TARGET_AVX && <mask_mode512bit_condition>"
14212 {
14213   int mask = INTVAL (operands[2]);
14214   rtx perm[<ssescalarnum>];
14215
14216   int i;
14217   for (i = 0; i < <ssescalarnum>; i = i + 2)
14218     {
14219       perm[i]     = GEN_INT (((mask >> i)       & 1) + i);
14220       perm[i + 1] = GEN_INT (((mask >> (i + 1)) & 1) + i);
14221     }
14222
14223   operands[2]
14224     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
14225 })
14226
14227 (define_expand "<sse2_avx_avx512f>_vpermil<mode><mask_name>"
14228   [(set (match_operand:VF1 0 "register_operand")
14229         (vec_select:VF1
14230           (match_operand:VF1 1 "nonimmediate_operand")
14231           (match_operand:SI 2 "const_0_to_255_operand")))]
14232   "TARGET_AVX && <mask_mode512bit_condition>"
14233 {
14234   int mask = INTVAL (operands[2]);
14235   rtx perm[<ssescalarnum>];
14236
14237   int i;
14238   for (i = 0; i < <ssescalarnum>; i = i + 4)
14239     {
14240       perm[i]     = GEN_INT (((mask >> 0) & 3) + i);
14241       perm[i + 1] = GEN_INT (((mask >> 2) & 3) + i);
14242       perm[i + 2] = GEN_INT (((mask >> 4) & 3) + i);
14243       perm[i + 3] = GEN_INT (((mask >> 6) & 3) + i);
14244     }
14245
14246   operands[2]
14247     = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (<ssescalarnum>, perm));
14248 })
14249
14250 (define_insn "*<sse2_avx_avx512f>_vpermilp<mode><mask_name>"
14251   [(set (match_operand:VF 0 "register_operand" "=v")
14252         (vec_select:VF
14253           (match_operand:VF 1 "nonimmediate_operand" "vm")
14254           (match_parallel 2 ""
14255             [(match_operand 3 "const_int_operand")])))]
14256   "TARGET_AVX && <mask_mode512bit_condition>
14257    && avx_vpermilp_parallel (operands[2], <MODE>mode)"
14258 {
14259   int mask = avx_vpermilp_parallel (operands[2], <MODE>mode) - 1;
14260   operands[2] = GEN_INT (mask);
14261   return "vpermil<ssemodesuffix>\t{%2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2}";
14262 }
14263   [(set_attr "type" "sselog")
14264    (set_attr "prefix_extra" "1")
14265    (set_attr "length_immediate" "1")
14266    (set_attr "prefix" "<mask_prefix>")
14267    (set_attr "mode" "<sseinsnmode>")])
14268
14269 (define_insn "<sse2_avx_avx512f>_vpermilvar<mode>3<mask_name>"
14270   [(set (match_operand:VF 0 "register_operand" "=v")
14271         (unspec:VF
14272           [(match_operand:VF 1 "register_operand" "v")
14273            (match_operand:<sseintvecmode> 2 "nonimmediate_operand" "vm")]
14274           UNSPEC_VPERMIL))]
14275   "TARGET_AVX && <mask_mode512bit_condition>"
14276   "vpermil<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14277   [(set_attr "type" "sselog")
14278    (set_attr "prefix_extra" "1")
14279    (set_attr "btver2_decode" "vector")
14280    (set_attr "prefix" "<mask_prefix>")
14281    (set_attr "mode" "<sseinsnmode>")])
14282
14283 (define_expand "avx512f_vpermi2var<mode>3_maskz"
14284   [(match_operand:VI48F_512 0 "register_operand" "=v")
14285    (match_operand:VI48F_512 1 "register_operand" "v")
14286    (match_operand:<sseintvecmode> 2 "register_operand" "0")
14287    (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")
14288    (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")]
14289   "TARGET_AVX512F"
14290 {
14291   emit_insn (gen_avx512f_vpermi2var<mode>3_maskz_1 (
14292         operands[0], operands[1], operands[2], operands[3],
14293         CONST0_RTX (<MODE>mode), operands[4]));
14294   DONE;
14295 })
14296
14297 (define_insn "avx512f_vpermi2var<mode>3<sd_maskz_name>"
14298   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14299         (unspec:VI48F_512
14300           [(match_operand:VI48F_512 1 "register_operand" "v")
14301            (match_operand:<sseintvecmode> 2 "register_operand" "0")
14302            (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14303           UNSPEC_VPERMI2))]
14304   "TARGET_AVX512F"
14305   "vpermi2<ssemodesuffix>\t{%3, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %3}"
14306   [(set_attr "type" "sselog")
14307    (set_attr "prefix" "evex")
14308    (set_attr "mode" "<sseinsnmode>")])
14309
14310 (define_insn "avx512f_vpermi2var<mode>3_mask"
14311   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14312         (vec_merge:VI48F_512
14313           (unspec:VI48F_512
14314             [(match_operand:VI48F_512 1 "register_operand" "v")
14315             (match_operand:<sseintvecmode> 2 "register_operand" "0")
14316             (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14317             UNSPEC_VPERMI2_MASK)
14318           (match_dup 0)
14319           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
14320   "TARGET_AVX512F"
14321   "vpermi2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
14322   [(set_attr "type" "sselog")
14323    (set_attr "prefix" "evex")
14324    (set_attr "mode" "<sseinsnmode>")])
14325
14326 (define_expand "avx512f_vpermt2var<mode>3_maskz"
14327   [(match_operand:VI48F_512 0 "register_operand" "=v")
14328    (match_operand:<sseintvecmode> 1 "register_operand" "v")
14329    (match_operand:VI48F_512 2 "register_operand" "0")
14330    (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")
14331    (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")]
14332   "TARGET_AVX512F"
14333 {
14334   emit_insn (gen_avx512f_vpermt2var<mode>3_maskz_1 (
14335         operands[0], operands[1], operands[2], operands[3],
14336         CONST0_RTX (<MODE>mode), operands[4]));
14337   DONE;
14338 })
14339
14340 (define_insn "avx512f_vpermt2var<mode>3<sd_maskz_name>"
14341   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14342         (unspec:VI48F_512
14343           [(match_operand:<sseintvecmode> 1 "register_operand" "v")
14344            (match_operand:VI48F_512 2 "register_operand" "0")
14345            (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14346           UNSPEC_VPERMT2))]
14347   "TARGET_AVX512F"
14348   "vpermt2<ssemodesuffix>\t{%3, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %3}"
14349   [(set_attr "type" "sselog")
14350    (set_attr "prefix" "evex")
14351    (set_attr "mode" "<sseinsnmode>")])
14352
14353 (define_insn "avx512f_vpermt2var<mode>3_mask"
14354   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
14355         (vec_merge:VI48F_512
14356           (unspec:VI48F_512
14357             [(match_operand:<sseintvecmode> 1 "register_operand" "v")
14358             (match_operand:VI48F_512 2 "register_operand" "0")
14359             (match_operand:VI48F_512 3 "nonimmediate_operand" "vm")]
14360             UNSPEC_VPERMT2)
14361           (match_dup 2)
14362           (match_operand:<avx512fmaskmode> 4 "register_operand" "Yk")))]
14363   "TARGET_AVX512F"
14364   "vpermt2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
14365   [(set_attr "type" "sselog")
14366    (set_attr "prefix" "evex")
14367    (set_attr "mode" "<sseinsnmode>")])
14368
14369 (define_expand "avx_vperm2f128<mode>3"
14370   [(set (match_operand:AVX256MODE2P 0 "register_operand")
14371         (unspec:AVX256MODE2P
14372           [(match_operand:AVX256MODE2P 1 "register_operand")
14373            (match_operand:AVX256MODE2P 2 "nonimmediate_operand")
14374            (match_operand:SI 3 "const_0_to_255_operand")]
14375           UNSPEC_VPERMIL2F128))]
14376   "TARGET_AVX"
14377 {
14378   int mask = INTVAL (operands[3]);
14379   if ((mask & 0x88) == 0)
14380     {
14381       rtx perm[<ssescalarnum>], t1, t2;
14382       int i, base, nelt = <ssescalarnum>, nelt2 = nelt / 2;
14383
14384       base = (mask & 3) * nelt2;
14385       for (i = 0; i < nelt2; ++i)
14386         perm[i] = GEN_INT (base + i);
14387
14388       base = ((mask >> 4) & 3) * nelt2;
14389       for (i = 0; i < nelt2; ++i)
14390         perm[i + nelt2] = GEN_INT (base + i);
14391
14392       t2 = gen_rtx_VEC_CONCAT (<ssedoublevecmode>mode,
14393                                operands[1], operands[2]);
14394       t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
14395       t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
14396       t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
14397       emit_insn (t2);
14398       DONE;
14399     }
14400 })
14401
14402 ;; Note that bits 7 and 3 of the imm8 allow lanes to be zeroed, which
14403 ;; means that in order to represent this properly in rtl we'd have to
14404 ;; nest *another* vec_concat with a zero operand and do the select from
14405 ;; a 4x wide vector.  That doesn't seem very nice.
14406 (define_insn "*avx_vperm2f128<mode>_full"
14407   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
14408         (unspec:AVX256MODE2P
14409           [(match_operand:AVX256MODE2P 1 "register_operand" "x")
14410            (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm")
14411            (match_operand:SI 3 "const_0_to_255_operand" "n")]
14412           UNSPEC_VPERMIL2F128))]
14413   "TARGET_AVX"
14414   "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
14415   [(set_attr "type" "sselog")
14416    (set_attr "prefix_extra" "1")
14417    (set_attr "length_immediate" "1")
14418    (set_attr "prefix" "vex")
14419    (set_attr "mode" "<sseinsnmode>")])
14420
14421 (define_insn "*avx_vperm2f128<mode>_nozero"
14422   [(set (match_operand:AVX256MODE2P 0 "register_operand" "=x")
14423         (vec_select:AVX256MODE2P
14424           (vec_concat:<ssedoublevecmode>
14425             (match_operand:AVX256MODE2P 1 "register_operand" "x")
14426             (match_operand:AVX256MODE2P 2 "nonimmediate_operand" "xm"))
14427           (match_parallel 3 ""
14428             [(match_operand 4 "const_int_operand")])))]
14429   "TARGET_AVX
14430    && avx_vperm2f128_parallel (operands[3], <MODE>mode)"
14431 {
14432   int mask = avx_vperm2f128_parallel (operands[3], <MODE>mode) - 1;
14433   if (mask == 0x12)
14434     return "vinsert<i128>\t{$0, %x2, %1, %0|%0, %1, %x2, 0}";
14435   if (mask == 0x20)
14436     return "vinsert<i128>\t{$1, %x2, %1, %0|%0, %1, %x2, 1}";
14437   operands[3] = GEN_INT (mask);
14438   return "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
14439 }
14440   [(set_attr "type" "sselog")
14441    (set_attr "prefix_extra" "1")
14442    (set_attr "length_immediate" "1")
14443    (set_attr "prefix" "vex")
14444    (set_attr "mode" "<sseinsnmode>")])
14445
14446 (define_expand "avx_vinsertf128<mode>"
14447   [(match_operand:V_256 0 "register_operand")
14448    (match_operand:V_256 1 "register_operand")
14449    (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand")
14450    (match_operand:SI 3 "const_0_to_1_operand")]
14451   "TARGET_AVX"
14452 {
14453   rtx (*insn)(rtx, rtx, rtx);
14454
14455   switch (INTVAL (operands[3]))
14456     {
14457     case 0:
14458       insn = gen_vec_set_lo_<mode>;
14459       break;
14460     case 1:
14461       insn = gen_vec_set_hi_<mode>;
14462       break;
14463     default:
14464       gcc_unreachable ();
14465     }
14466
14467   emit_insn (insn (operands[0], operands[1], operands[2]));
14468   DONE;
14469 })
14470
14471 (define_insn "avx2_vec_set_lo_v4di"
14472   [(set (match_operand:V4DI 0 "register_operand" "=x")
14473         (vec_concat:V4DI
14474           (match_operand:V2DI 2 "nonimmediate_operand" "xm")
14475           (vec_select:V2DI
14476             (match_operand:V4DI 1 "register_operand" "x")
14477             (parallel [(const_int 2) (const_int 3)]))))]
14478   "TARGET_AVX2"
14479   "vinserti128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14480   [(set_attr "type" "sselog")
14481    (set_attr "prefix_extra" "1")
14482    (set_attr "length_immediate" "1")
14483    (set_attr "prefix" "vex")
14484    (set_attr "mode" "OI")])
14485
14486 (define_insn "avx2_vec_set_hi_v4di"
14487   [(set (match_operand:V4DI 0 "register_operand" "=x")
14488         (vec_concat:V4DI
14489           (vec_select:V2DI
14490             (match_operand:V4DI 1 "register_operand" "x")
14491             (parallel [(const_int 0) (const_int 1)]))
14492           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
14493   "TARGET_AVX2"
14494   "vinserti128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14495   [(set_attr "type" "sselog")
14496    (set_attr "prefix_extra" "1")
14497    (set_attr "length_immediate" "1")
14498    (set_attr "prefix" "vex")
14499    (set_attr "mode" "OI")])
14500
14501 (define_insn "vec_set_lo_<mode>"
14502   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
14503         (vec_concat:VI8F_256
14504           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
14505           (vec_select:<ssehalfvecmode>
14506             (match_operand:VI8F_256 1 "register_operand" "x")
14507             (parallel [(const_int 2) (const_int 3)]))))]
14508   "TARGET_AVX"
14509   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14510   [(set_attr "type" "sselog")
14511    (set_attr "prefix_extra" "1")
14512    (set_attr "length_immediate" "1")
14513    (set_attr "prefix" "vex")
14514    (set_attr "mode" "<sseinsnmode>")])
14515
14516 (define_insn "vec_set_hi_<mode>"
14517   [(set (match_operand:VI8F_256 0 "register_operand" "=x")
14518         (vec_concat:VI8F_256
14519           (vec_select:<ssehalfvecmode>
14520             (match_operand:VI8F_256 1 "register_operand" "x")
14521             (parallel [(const_int 0) (const_int 1)]))
14522           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
14523   "TARGET_AVX"
14524   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14525   [(set_attr "type" "sselog")
14526    (set_attr "prefix_extra" "1")
14527    (set_attr "length_immediate" "1")
14528    (set_attr "prefix" "vex")
14529    (set_attr "mode" "<sseinsnmode>")])
14530
14531 (define_insn "vec_set_lo_<mode>"
14532   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
14533         (vec_concat:VI4F_256
14534           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")
14535           (vec_select:<ssehalfvecmode>
14536             (match_operand:VI4F_256 1 "register_operand" "x")
14537             (parallel [(const_int 4) (const_int 5)
14538                        (const_int 6) (const_int 7)]))))]
14539   "TARGET_AVX"
14540   "vinsert<i128>\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
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_insn "vec_set_hi_<mode>"
14548   [(set (match_operand:VI4F_256 0 "register_operand" "=x")
14549         (vec_concat:VI4F_256
14550           (vec_select:<ssehalfvecmode>
14551             (match_operand:VI4F_256 1 "register_operand" "x")
14552             (parallel [(const_int 0) (const_int 1)
14553                        (const_int 2) (const_int 3)]))
14554           (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xm")))]
14555   "TARGET_AVX"
14556   "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14557   [(set_attr "type" "sselog")
14558    (set_attr "prefix_extra" "1")
14559    (set_attr "length_immediate" "1")
14560    (set_attr "prefix" "vex")
14561    (set_attr "mode" "<sseinsnmode>")])
14562
14563 (define_insn "vec_set_lo_v16hi"
14564   [(set (match_operand:V16HI 0 "register_operand" "=x")
14565         (vec_concat:V16HI
14566           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
14567           (vec_select:V8HI
14568             (match_operand:V16HI 1 "register_operand" "x")
14569             (parallel [(const_int 8) (const_int 9)
14570                        (const_int 10) (const_int 11)
14571                        (const_int 12) (const_int 13)
14572                        (const_int 14) (const_int 15)]))))]
14573   "TARGET_AVX"
14574   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14575   [(set_attr "type" "sselog")
14576    (set_attr "prefix_extra" "1")
14577    (set_attr "length_immediate" "1")
14578    (set_attr "prefix" "vex")
14579    (set_attr "mode" "OI")])
14580
14581 (define_insn "vec_set_hi_v16hi"
14582   [(set (match_operand:V16HI 0 "register_operand" "=x")
14583         (vec_concat:V16HI
14584           (vec_select:V8HI
14585             (match_operand:V16HI 1 "register_operand" "x")
14586             (parallel [(const_int 0) (const_int 1)
14587                        (const_int 2) (const_int 3)
14588                        (const_int 4) (const_int 5)
14589                        (const_int 6) (const_int 7)]))
14590           (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
14591   "TARGET_AVX"
14592   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14593   [(set_attr "type" "sselog")
14594    (set_attr "prefix_extra" "1")
14595    (set_attr "length_immediate" "1")
14596    (set_attr "prefix" "vex")
14597    (set_attr "mode" "OI")])
14598
14599 (define_insn "vec_set_lo_v32qi"
14600   [(set (match_operand:V32QI 0 "register_operand" "=x")
14601         (vec_concat:V32QI
14602           (match_operand:V16QI 2 "nonimmediate_operand" "xm")
14603           (vec_select:V16QI
14604             (match_operand:V32QI 1 "register_operand" "x")
14605             (parallel [(const_int 16) (const_int 17)
14606                        (const_int 18) (const_int 19)
14607                        (const_int 20) (const_int 21)
14608                        (const_int 22) (const_int 23)
14609                        (const_int 24) (const_int 25)
14610                        (const_int 26) (const_int 27)
14611                        (const_int 28) (const_int 29)
14612                        (const_int 30) (const_int 31)]))))]
14613   "TARGET_AVX"
14614   "vinsert%~128\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
14615   [(set_attr "type" "sselog")
14616    (set_attr "prefix_extra" "1")
14617    (set_attr "length_immediate" "1")
14618    (set_attr "prefix" "vex")
14619    (set_attr "mode" "OI")])
14620
14621 (define_insn "vec_set_hi_v32qi"
14622   [(set (match_operand:V32QI 0 "register_operand" "=x")
14623         (vec_concat:V32QI
14624           (vec_select:V16QI
14625             (match_operand:V32QI 1 "register_operand" "x")
14626             (parallel [(const_int 0) (const_int 1)
14627                        (const_int 2) (const_int 3)
14628                        (const_int 4) (const_int 5)
14629                        (const_int 6) (const_int 7)
14630                        (const_int 8) (const_int 9)
14631                        (const_int 10) (const_int 11)
14632                        (const_int 12) (const_int 13)
14633                        (const_int 14) (const_int 15)]))
14634           (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
14635   "TARGET_AVX"
14636   "vinsert%~128\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}"
14637   [(set_attr "type" "sselog")
14638    (set_attr "prefix_extra" "1")
14639    (set_attr "length_immediate" "1")
14640    (set_attr "prefix" "vex")
14641    (set_attr "mode" "OI")])
14642
14643 (define_insn "<avx_avx2>_maskload<ssemodesuffix><avxsizesuffix>"
14644   [(set (match_operand:V48_AVX2 0 "register_operand" "=x")
14645         (unspec:V48_AVX2
14646           [(match_operand:<sseintvecmode> 2 "register_operand" "x")
14647            (match_operand:V48_AVX2 1 "memory_operand" "m")]
14648           UNSPEC_MASKMOV))]
14649   "TARGET_AVX"
14650   "v<sseintprefix>maskmov<ssemodesuffix>\t{%1, %2, %0|%0, %2, %1}"
14651   [(set_attr "type" "sselog1")
14652    (set_attr "prefix_extra" "1")
14653    (set_attr "prefix" "vex")
14654    (set_attr "btver2_decode" "vector")
14655    (set_attr "mode" "<sseinsnmode>")])
14656
14657 (define_insn "<avx_avx2>_maskstore<ssemodesuffix><avxsizesuffix>"
14658   [(set (match_operand:V48_AVX2 0 "memory_operand" "+m")
14659         (unspec:V48_AVX2
14660           [(match_operand:<sseintvecmode> 1 "register_operand" "x")
14661            (match_operand:V48_AVX2 2 "register_operand" "x")
14662            (match_dup 0)]
14663           UNSPEC_MASKMOV))]
14664   "TARGET_AVX"
14665   "v<sseintprefix>maskmov<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
14666   [(set_attr "type" "sselog1")
14667    (set_attr "prefix_extra" "1")
14668    (set_attr "prefix" "vex")
14669    (set_attr "btver2_decode" "vector")
14670    (set_attr "mode" "<sseinsnmode>")])
14671
14672 (define_expand "maskload<mode>"
14673   [(set (match_operand:V48_AVX2 0 "register_operand")
14674         (unspec:V48_AVX2
14675           [(match_operand:<sseintvecmode> 2 "register_operand")
14676            (match_operand:V48_AVX2 1 "memory_operand")]
14677           UNSPEC_MASKMOV))]
14678   "TARGET_AVX")
14679
14680 (define_expand "maskstore<mode>"
14681   [(set (match_operand:V48_AVX2 0 "memory_operand")
14682         (unspec:V48_AVX2
14683           [(match_operand:<sseintvecmode> 2 "register_operand")
14684            (match_operand:V48_AVX2 1 "register_operand")
14685            (match_dup 0)]
14686           UNSPEC_MASKMOV))]
14687   "TARGET_AVX")
14688
14689 (define_insn_and_split "avx_<castmode><avxsizesuffix>_<castmode>"
14690   [(set (match_operand:AVX256MODE2P 0 "nonimmediate_operand" "=x,m")
14691         (unspec:AVX256MODE2P
14692           [(match_operand:<ssehalfvecmode> 1 "nonimmediate_operand" "xm,x")]
14693           UNSPEC_CAST))]
14694   "TARGET_AVX"
14695   "#"
14696   "&& reload_completed"
14697   [(const_int 0)]
14698 {
14699   rtx op0 = operands[0];
14700   rtx op1 = operands[1];
14701   if (REG_P (op0))
14702     op0 = gen_rtx_REG (<ssehalfvecmode>mode, REGNO (op0));
14703   else
14704     op1 = gen_rtx_REG (<MODE>mode, REGNO (op1));
14705   emit_move_insn (op0, op1);
14706   DONE;
14707 })
14708
14709 (define_expand "vec_init<mode>"
14710   [(match_operand:V_256 0 "register_operand")
14711    (match_operand 1)]
14712   "TARGET_AVX"
14713 {
14714   ix86_expand_vector_init (false, operands[0], operands[1]);
14715   DONE;
14716 })
14717
14718 (define_expand "vec_init<mode>"
14719   [(match_operand:VI48F_512 0 "register_operand")
14720    (match_operand 1)]
14721   "TARGET_AVX512F"
14722 {
14723   ix86_expand_vector_init (false, operands[0], operands[1]);
14724   DONE;
14725 })
14726
14727 (define_expand "avx2_extracti128"
14728   [(match_operand:V2DI 0 "nonimmediate_operand")
14729    (match_operand:V4DI 1 "register_operand")
14730    (match_operand:SI 2 "const_0_to_1_operand")]
14731   "TARGET_AVX2"
14732 {
14733   rtx (*insn)(rtx, rtx);
14734
14735   switch (INTVAL (operands[2]))
14736     {
14737     case 0:
14738       insn = gen_vec_extract_lo_v4di;
14739       break;
14740     case 1:
14741       insn = gen_vec_extract_hi_v4di;
14742       break;
14743     default:
14744       gcc_unreachable ();
14745     }
14746
14747   emit_insn (insn (operands[0], operands[1]));
14748   DONE;
14749 })
14750
14751 (define_expand "avx2_inserti128"
14752   [(match_operand:V4DI 0 "register_operand")
14753    (match_operand:V4DI 1 "register_operand")
14754    (match_operand:V2DI 2 "nonimmediate_operand")
14755    (match_operand:SI 3 "const_0_to_1_operand")]
14756   "TARGET_AVX2"
14757 {
14758   rtx (*insn)(rtx, rtx, rtx);
14759
14760   switch (INTVAL (operands[3]))
14761     {
14762     case 0:
14763       insn = gen_avx2_vec_set_lo_v4di;
14764       break;
14765     case 1:
14766       insn = gen_avx2_vec_set_hi_v4di;
14767       break;
14768     default:
14769       gcc_unreachable ();
14770     }
14771
14772   emit_insn (insn (operands[0], operands[1], operands[2]));
14773   DONE;
14774 })
14775
14776 (define_insn "<avx2_avx512f>_ashrv<mode><mask_name>"
14777   [(set (match_operand:VI48_AVX512F 0 "register_operand" "=v")
14778         (ashiftrt:VI48_AVX512F
14779           (match_operand:VI48_AVX512F 1 "register_operand" "v")
14780           (match_operand:VI48_AVX512F 2 "nonimmediate_operand" "vm")))]
14781   "TARGET_AVX2 && <mask_mode512bit_condition>"
14782   "vpsrav<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14783   [(set_attr "type" "sseishft")
14784    (set_attr "prefix" "maybe_evex")
14785    (set_attr "mode" "<sseinsnmode>")])
14786
14787 (define_insn "<avx2_avx512f>_<shift_insn>v<mode><mask_name>"
14788   [(set (match_operand:VI48_AVX2_48_AVX512F 0 "register_operand" "=v")
14789         (any_lshift:VI48_AVX2_48_AVX512F
14790           (match_operand:VI48_AVX2_48_AVX512F 1 "register_operand" "v")
14791           (match_operand:VI48_AVX2_48_AVX512F 2 "nonimmediate_operand" "vm")))]
14792   "TARGET_AVX2 && <mask_mode512bit_condition>"
14793   "vp<vshift>v<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14794   [(set_attr "type" "sseishft")
14795    (set_attr "prefix" "maybe_evex")
14796    (set_attr "mode" "<sseinsnmode>")])
14797
14798 ;; For avx_vec_concat<mode> insn pattern
14799 (define_mode_attr concat_tg_mode
14800   [(V32QI "t") (V16HI "t") (V8SI "t") (V4DI "t") (V8SF "t") (V4DF "t")
14801    (V64QI "g") (V32HI "g") (V16SI "g") (V8DI "g") (V16SF "g") (V8DF "g")])
14802
14803 (define_insn "avx_vec_concat<mode>"
14804   [(set (match_operand:V_256_512 0 "register_operand" "=x,x")
14805         (vec_concat:V_256_512
14806           (match_operand:<ssehalfvecmode> 1 "register_operand" "x,x")
14807           (match_operand:<ssehalfvecmode> 2 "vector_move_operand" "xm,C")))]
14808   "TARGET_AVX"
14809 {
14810   switch (which_alternative)
14811     {
14812     case 0:
14813       return "vinsert<i128>\t{$0x1, %2, %<concat_tg_mode>1, %0|%0, %<concat_tg_mode>1, %2, 0x1}";
14814     case 1:
14815       switch (get_attr_mode (insn))
14816         {
14817         case MODE_V16SF:
14818           return "vmovaps\t{%1, %t0|%t0, %1}";
14819         case MODE_V8DF:
14820           return "vmovapd\t{%1, %t0|%t0, %1}";
14821         case MODE_V8SF:
14822           return "vmovaps\t{%1, %x0|%x0, %1}";
14823         case MODE_V4DF:
14824           return "vmovapd\t{%1, %x0|%x0, %1}";
14825         case MODE_XI:
14826           return "vmovdqa\t{%1, %t0|%t0, %1}";
14827         case MODE_OI:
14828           return "vmovdqa\t{%1, %x0|%x0, %1}";
14829         default:
14830           gcc_unreachable ();
14831         }
14832     default:
14833       gcc_unreachable ();
14834     }
14835 }
14836   [(set_attr "type" "sselog,ssemov")
14837    (set_attr "prefix_extra" "1,*")
14838    (set_attr "length_immediate" "1,*")
14839    (set_attr "prefix" "maybe_evex")
14840    (set_attr "mode" "<sseinsnmode>")])
14841
14842 (define_insn "vcvtph2ps"
14843   [(set (match_operand:V4SF 0 "register_operand" "=x")
14844         (vec_select:V4SF
14845           (unspec:V8SF [(match_operand:V8HI 1 "register_operand" "x")]
14846                        UNSPEC_VCVTPH2PS)
14847           (parallel [(const_int 0) (const_int 1)
14848                      (const_int 2) (const_int 3)])))]
14849   "TARGET_F16C"
14850   "vcvtph2ps\t{%1, %0|%0, %1}"
14851   [(set_attr "type" "ssecvt")
14852    (set_attr "prefix" "vex")
14853    (set_attr "mode" "V4SF")])
14854
14855 (define_insn "*vcvtph2ps_load"
14856   [(set (match_operand:V4SF 0 "register_operand" "=x")
14857         (unspec:V4SF [(match_operand:V4HI 1 "memory_operand" "m")]
14858                      UNSPEC_VCVTPH2PS))]
14859   "TARGET_F16C"
14860   "vcvtph2ps\t{%1, %0|%0, %1}"
14861   [(set_attr "type" "ssecvt")
14862    (set_attr "prefix" "vex")
14863    (set_attr "mode" "V8SF")])
14864
14865 (define_insn "vcvtph2ps256"
14866   [(set (match_operand:V8SF 0 "register_operand" "=x")
14867         (unspec:V8SF [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
14868                      UNSPEC_VCVTPH2PS))]
14869   "TARGET_F16C"
14870   "vcvtph2ps\t{%1, %0|%0, %1}"
14871   [(set_attr "type" "ssecvt")
14872    (set_attr "prefix" "vex")
14873    (set_attr "btver2_decode" "double")
14874    (set_attr "mode" "V8SF")])
14875
14876 (define_insn "<mask_codefor>avx512f_vcvtph2ps512<mask_name><round_saeonly_name>"
14877   [(set (match_operand:V16SF 0 "register_operand" "=v")
14878         (unspec:V16SF
14879           [(match_operand:V16HI 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")]
14880           UNSPEC_VCVTPH2PS))]
14881   "TARGET_AVX512F"
14882   "vcvtph2ps\t{<round_saeonly_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_saeonly_mask_op2>}"
14883   [(set_attr "type" "ssecvt")
14884    (set_attr "prefix" "evex")
14885    (set_attr "mode" "V16SF")])
14886
14887 (define_expand "vcvtps2ph"
14888   [(set (match_operand:V8HI 0 "register_operand")
14889         (vec_concat:V8HI
14890           (unspec:V4HI [(match_operand:V4SF 1 "register_operand")
14891                         (match_operand:SI 2 "const_0_to_255_operand")]
14892                        UNSPEC_VCVTPS2PH)
14893           (match_dup 3)))]
14894   "TARGET_F16C"
14895   "operands[3] = CONST0_RTX (V4HImode);")
14896
14897 (define_insn "*vcvtps2ph"
14898   [(set (match_operand:V8HI 0 "register_operand" "=x")
14899         (vec_concat:V8HI
14900           (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
14901                         (match_operand:SI 2 "const_0_to_255_operand" "N")]
14902                        UNSPEC_VCVTPS2PH)
14903           (match_operand:V4HI 3 "const0_operand")))]
14904   "TARGET_F16C"
14905   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
14906   [(set_attr "type" "ssecvt")
14907    (set_attr "prefix" "vex")
14908    (set_attr "mode" "V4SF")])
14909
14910 (define_insn "*vcvtps2ph_store"
14911   [(set (match_operand:V4HI 0 "memory_operand" "=m")
14912         (unspec:V4HI [(match_operand:V4SF 1 "register_operand" "x")
14913                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
14914                      UNSPEC_VCVTPS2PH))]
14915   "TARGET_F16C"
14916   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
14917   [(set_attr "type" "ssecvt")
14918    (set_attr "prefix" "vex")
14919    (set_attr "mode" "V4SF")])
14920
14921 (define_insn "vcvtps2ph256"
14922   [(set (match_operand:V8HI 0 "nonimmediate_operand" "=xm")
14923         (unspec:V8HI [(match_operand:V8SF 1 "register_operand" "x")
14924                       (match_operand:SI 2 "const_0_to_255_operand" "N")]
14925                      UNSPEC_VCVTPS2PH))]
14926   "TARGET_F16C"
14927   "vcvtps2ph\t{%2, %1, %0|%0, %1, %2}"
14928   [(set_attr "type" "ssecvt")
14929    (set_attr "prefix" "vex")
14930    (set_attr "btver2_decode" "vector")
14931    (set_attr "mode" "V8SF")])
14932
14933 (define_insn "<mask_codefor>avx512f_vcvtps2ph512<mask_name>"
14934   [(set (match_operand:V16HI 0 "nonimmediate_operand" "=vm")
14935         (unspec:V16HI
14936           [(match_operand:V16SF 1 "register_operand" "v")
14937            (match_operand:SI 2 "const_0_to_255_operand" "N")]
14938           UNSPEC_VCVTPS2PH))]
14939   "TARGET_AVX512F"
14940   "vcvtps2ph\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
14941   [(set_attr "type" "ssecvt")
14942    (set_attr "prefix" "evex")
14943    (set_attr "mode" "V16SF")])
14944
14945 ;; For gather* insn patterns
14946 (define_mode_iterator VEC_GATHER_MODE
14947                       [V2DI V2DF V4DI V4DF V4SI V4SF V8SI V8SF])
14948 (define_mode_attr VEC_GATHER_IDXSI
14949                       [(V2DI "V4SI") (V4DI "V4SI") (V8DI "V8SI")
14950                        (V2DF "V4SI") (V4DF "V4SI") (V8DF "V8SI")
14951                        (V4SI "V4SI") (V8SI "V8SI") (V16SI "V16SI")
14952                        (V4SF "V4SI") (V8SF "V8SI") (V16SF "V16SI")])
14953
14954 (define_mode_attr VEC_GATHER_IDXDI
14955                       [(V2DI "V2DI") (V4DI "V4DI") (V8DI "V8DI")
14956                        (V2DF "V2DI") (V4DF "V4DI") (V8DF "V8DI")
14957                        (V4SI "V2DI") (V8SI "V4DI") (V16SI "V8DI")
14958                        (V4SF "V2DI") (V8SF "V4DI") (V16SF "V8DI")])
14959
14960 (define_mode_attr VEC_GATHER_SRCDI
14961                       [(V2DI "V2DI") (V4DI "V4DI") (V8DI "V8DI")
14962                        (V2DF "V2DF") (V4DF "V4DF") (V8DF "V8DF")
14963                        (V4SI "V4SI") (V8SI "V4SI") (V16SI "V8SI")
14964                        (V4SF "V4SF") (V8SF "V4SF") (V16SF "V8SF")])
14965
14966 (define_expand "avx2_gathersi<mode>"
14967   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
14968                    (unspec:VEC_GATHER_MODE
14969                      [(match_operand:VEC_GATHER_MODE 1 "register_operand")
14970                       (mem:<ssescalarmode>
14971                         (match_par_dup 7
14972                           [(match_operand 2 "vsib_address_operand")
14973                            (match_operand:<VEC_GATHER_IDXSI>
14974                               3 "register_operand")
14975                            (match_operand:SI 5 "const1248_operand ")]))
14976                       (mem:BLK (scratch))
14977                       (match_operand:VEC_GATHER_MODE 4 "register_operand")]
14978                      UNSPEC_GATHER))
14979               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
14980   "TARGET_AVX2"
14981 {
14982   operands[7]
14983     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
14984                                         operands[5]), UNSPEC_VSIBADDR);
14985 })
14986
14987 (define_insn "*avx2_gathersi<mode>"
14988   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
14989         (unspec:VEC_GATHER_MODE
14990           [(match_operand:VEC_GATHER_MODE 2 "register_operand" "0")
14991            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
14992              [(unspec:P
14993                 [(match_operand:P 3 "vsib_address_operand" "Tv")
14994                  (match_operand:<VEC_GATHER_IDXSI> 4 "register_operand" "x")
14995                  (match_operand:SI 6 "const1248_operand" "n")]
14996                 UNSPEC_VSIBADDR)])
14997            (mem:BLK (scratch))
14998            (match_operand:VEC_GATHER_MODE 5 "register_operand" "1")]
14999           UNSPEC_GATHER))
15000    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15001   "TARGET_AVX2"
15002   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %7, %0|%0, %7, %1}"
15003   [(set_attr "type" "ssemov")
15004    (set_attr "prefix" "vex")
15005    (set_attr "mode" "<sseinsnmode>")])
15006
15007 (define_insn "*avx2_gathersi<mode>_2"
15008   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15009         (unspec:VEC_GATHER_MODE
15010           [(pc)
15011            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15012              [(unspec:P
15013                 [(match_operand:P 2 "vsib_address_operand" "Tv")
15014                  (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand" "x")
15015                  (match_operand:SI 5 "const1248_operand" "n")]
15016                 UNSPEC_VSIBADDR)])
15017            (mem:BLK (scratch))
15018            (match_operand:VEC_GATHER_MODE 4 "register_operand" "1")]
15019           UNSPEC_GATHER))
15020    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15021   "TARGET_AVX2"
15022   "v<sseintprefix>gatherd<ssemodesuffix>\t{%1, %6, %0|%0, %6, %1}"
15023   [(set_attr "type" "ssemov")
15024    (set_attr "prefix" "vex")
15025    (set_attr "mode" "<sseinsnmode>")])
15026
15027 (define_expand "avx2_gatherdi<mode>"
15028   [(parallel [(set (match_operand:VEC_GATHER_MODE 0 "register_operand")
15029                    (unspec:VEC_GATHER_MODE
15030                      [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand")
15031                       (mem:<ssescalarmode>
15032                         (match_par_dup 7
15033                           [(match_operand 2 "vsib_address_operand")
15034                            (match_operand:<VEC_GATHER_IDXDI>
15035                               3 "register_operand")
15036                            (match_operand:SI 5 "const1248_operand ")]))
15037                       (mem:BLK (scratch))
15038                       (match_operand:<VEC_GATHER_SRCDI>
15039                         4 "register_operand")]
15040                      UNSPEC_GATHER))
15041               (clobber (match_scratch:VEC_GATHER_MODE 6))])]
15042   "TARGET_AVX2"
15043 {
15044   operands[7]
15045     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15046                                         operands[5]), UNSPEC_VSIBADDR);
15047 })
15048
15049 (define_insn "*avx2_gatherdi<mode>"
15050   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15051         (unspec:VEC_GATHER_MODE
15052           [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
15053            (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
15054              [(unspec:P
15055                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15056                  (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
15057                  (match_operand:SI 6 "const1248_operand" "n")]
15058                 UNSPEC_VSIBADDR)])
15059            (mem:BLK (scratch))
15060            (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
15061           UNSPEC_GATHER))
15062    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15063   "TARGET_AVX2"
15064   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %2|%2, %7, %5}"
15065   [(set_attr "type" "ssemov")
15066    (set_attr "prefix" "vex")
15067    (set_attr "mode" "<sseinsnmode>")])
15068
15069 (define_insn "*avx2_gatherdi<mode>_2"
15070   [(set (match_operand:VEC_GATHER_MODE 0 "register_operand" "=&x")
15071         (unspec:VEC_GATHER_MODE
15072           [(pc)
15073            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15074              [(unspec:P
15075                 [(match_operand:P 2 "vsib_address_operand" "Tv")
15076                  (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
15077                  (match_operand:SI 5 "const1248_operand" "n")]
15078                 UNSPEC_VSIBADDR)])
15079            (mem:BLK (scratch))
15080            (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
15081           UNSPEC_GATHER))
15082    (clobber (match_scratch:VEC_GATHER_MODE 1 "=&x"))]
15083   "TARGET_AVX2"
15084 {
15085   if (<MODE>mode != <VEC_GATHER_SRCDI>mode)
15086     return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %x0|%x0, %6, %4}";
15087   return "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}";
15088 }
15089   [(set_attr "type" "ssemov")
15090    (set_attr "prefix" "vex")
15091    (set_attr "mode" "<sseinsnmode>")])
15092
15093 (define_insn "*avx2_gatherdi<mode>_3"
15094   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
15095         (vec_select:<VEC_GATHER_SRCDI>
15096           (unspec:VI4F_256
15097             [(match_operand:<VEC_GATHER_SRCDI> 2 "register_operand" "0")
15098              (match_operator:<ssescalarmode> 7 "vsib_mem_operator"
15099                [(unspec:P
15100                   [(match_operand:P 3 "vsib_address_operand" "Tv")
15101                    (match_operand:<VEC_GATHER_IDXDI> 4 "register_operand" "x")
15102                    (match_operand:SI 6 "const1248_operand" "n")]
15103                   UNSPEC_VSIBADDR)])
15104              (mem:BLK (scratch))
15105              (match_operand:<VEC_GATHER_SRCDI> 5 "register_operand" "1")]
15106              UNSPEC_GATHER)
15107           (parallel [(const_int 0) (const_int 1)
15108                      (const_int 2) (const_int 3)])))
15109    (clobber (match_scratch:VI4F_256 1 "=&x"))]
15110   "TARGET_AVX2"
15111   "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %7, %0|%0, %7, %5}"
15112   [(set_attr "type" "ssemov")
15113    (set_attr "prefix" "vex")
15114    (set_attr "mode" "<sseinsnmode>")])
15115
15116 (define_insn "*avx2_gatherdi<mode>_4"
15117   [(set (match_operand:<VEC_GATHER_SRCDI> 0 "register_operand" "=&x")
15118         (vec_select:<VEC_GATHER_SRCDI>
15119           (unspec:VI4F_256
15120             [(pc)
15121              (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15122                [(unspec:P
15123                   [(match_operand:P 2 "vsib_address_operand" "Tv")
15124                    (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "x")
15125                    (match_operand:SI 5 "const1248_operand" "n")]
15126                   UNSPEC_VSIBADDR)])
15127              (mem:BLK (scratch))
15128              (match_operand:<VEC_GATHER_SRCDI> 4 "register_operand" "1")]
15129             UNSPEC_GATHER)
15130           (parallel [(const_int 0) (const_int 1)
15131                      (const_int 2) (const_int 3)])))
15132    (clobber (match_scratch:VI4F_256 1 "=&x"))]
15133   "TARGET_AVX2"
15134   "v<sseintprefix>gatherq<ssemodesuffix>\t{%4, %6, %0|%0, %6, %4}"
15135   [(set_attr "type" "ssemov")
15136    (set_attr "prefix" "vex")
15137    (set_attr "mode" "<sseinsnmode>")])
15138
15139 (define_expand "avx512f_gathersi<mode>"
15140   [(parallel [(set (match_operand:VI48F_512 0 "register_operand")
15141                    (unspec:VI48F_512
15142                      [(match_operand:VI48F_512 1 "register_operand")
15143                       (match_operand:<avx512fmaskmode> 4 "register_operand")
15144                       (mem:<ssescalarmode>
15145                         (match_par_dup 6
15146                           [(match_operand 2 "vsib_address_operand")
15147                            (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand")
15148                            (match_operand:SI 5 "const1248_operand")]))]
15149                      UNSPEC_GATHER))
15150               (clobber (match_scratch:<avx512fmaskmode> 7))])]
15151   "TARGET_AVX512F"
15152 {
15153   operands[6]
15154     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15155                                         operands[5]), UNSPEC_VSIBADDR);
15156 })
15157
15158 (define_insn "*avx512f_gathersi<mode>"
15159   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15160         (unspec:VI48F_512
15161           [(match_operand:VI48F_512 1 "register_operand" "0")
15162            (match_operand:<avx512fmaskmode> 7 "register_operand" "2")
15163            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15164              [(unspec:P
15165                 [(match_operand:P 4 "vsib_address_operand" "Tv")
15166                  (match_operand:<VEC_GATHER_IDXSI> 3 "register_operand" "v")
15167                  (match_operand:SI 5 "const1248_operand" "n")]
15168                 UNSPEC_VSIBADDR)])]
15169           UNSPEC_GATHER))
15170    (clobber (match_scratch:<avx512fmaskmode> 2 "=&Yk"))]
15171   "TARGET_AVX512F"
15172   "v<sseintprefix>gatherd<ssemodesuffix>\t{%6, %0%{%2%}|%0%{%2%}, %g6}"
15173   [(set_attr "type" "ssemov")
15174    (set_attr "prefix" "evex")
15175    (set_attr "mode" "<sseinsnmode>")])
15176
15177 (define_insn "*avx512f_gathersi<mode>_2"
15178   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15179         (unspec:VI48F_512
15180           [(pc)
15181            (match_operand:<avx512fmaskmode> 6 "register_operand" "1")
15182            (match_operator:<ssescalarmode> 5 "vsib_mem_operator"
15183              [(unspec:P
15184                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15185                  (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand" "v")
15186                  (match_operand:SI 4 "const1248_operand" "n")]
15187                 UNSPEC_VSIBADDR)])]
15188           UNSPEC_GATHER))
15189    (clobber (match_scratch:<avx512fmaskmode> 1 "=&Yk"))]
15190   "TARGET_AVX512F"
15191   "v<sseintprefix>gatherd<ssemodesuffix>\t{%5, %0%{%1%}|%0%{%1%}, %g5}"
15192   [(set_attr "type" "ssemov")
15193    (set_attr "prefix" "evex")
15194    (set_attr "mode" "<sseinsnmode>")])
15195
15196
15197 (define_expand "avx512f_gatherdi<mode>"
15198   [(parallel [(set (match_operand:VI48F_512 0 "register_operand")
15199                    (unspec:VI48F_512
15200                      [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand")
15201                       (match_operand:QI 4 "register_operand")
15202                       (mem:<ssescalarmode>
15203                         (match_par_dup 6
15204                           [(match_operand 2 "vsib_address_operand")
15205                            (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand")
15206                            (match_operand:SI 5 "const1248_operand")]))]
15207                      UNSPEC_GATHER))
15208               (clobber (match_scratch:QI 7))])]
15209   "TARGET_AVX512F"
15210 {
15211   operands[6]
15212     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[2], operands[3],
15213                                         operands[5]), UNSPEC_VSIBADDR);
15214 })
15215
15216 (define_insn "*avx512f_gatherdi<mode>"
15217   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15218         (unspec:VI48F_512
15219           [(match_operand:<VEC_GATHER_SRCDI> 1 "register_operand" "0")
15220            (match_operand:QI 7 "register_operand" "2")
15221            (match_operator:<ssescalarmode> 6 "vsib_mem_operator"
15222              [(unspec:P
15223                 [(match_operand:P 4 "vsib_address_operand" "Tv")
15224                  (match_operand:<VEC_GATHER_IDXDI> 3 "register_operand" "v")
15225                  (match_operand:SI 5 "const1248_operand" "n")]
15226                 UNSPEC_VSIBADDR)])]
15227           UNSPEC_GATHER))
15228    (clobber (match_scratch:QI 2 "=&Yk"))]
15229   "TARGET_AVX512F"
15230   "v<sseintprefix>gatherq<ssemodesuffix>\t{%6, %1%{%2%}|%1%{%2%}, %g6}"
15231   [(set_attr "type" "ssemov")
15232    (set_attr "prefix" "evex")
15233    (set_attr "mode" "<sseinsnmode>")])
15234
15235 (define_insn "*avx512f_gatherdi<mode>_2"
15236   [(set (match_operand:VI48F_512 0 "register_operand" "=&v")
15237         (unspec:VI48F_512
15238           [(pc)
15239            (match_operand:QI 6 "register_operand" "1")
15240            (match_operator:<ssescalarmode> 5 "vsib_mem_operator"
15241              [(unspec:P
15242                 [(match_operand:P 3 "vsib_address_operand" "Tv")
15243                  (match_operand:<VEC_GATHER_IDXDI> 2 "register_operand" "v")
15244                  (match_operand:SI 4 "const1248_operand" "n")]
15245                 UNSPEC_VSIBADDR)])]
15246           UNSPEC_GATHER))
15247    (clobber (match_scratch:QI 1 "=&Yk"))]
15248   "TARGET_AVX512F"
15249 {
15250   if (<MODE>mode != <VEC_GATHER_SRCDI>mode)
15251     return "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %t0%{%1%}|%t0%{%1%}, %g5}";
15252   return "v<sseintprefix>gatherq<ssemodesuffix>\t{%5, %0%{%1%}|%0%{%1%}, %g5}";
15253 }
15254   [(set_attr "type" "ssemov")
15255    (set_attr "prefix" "evex")
15256    (set_attr "mode" "<sseinsnmode>")])
15257
15258 (define_expand "avx512f_scattersi<mode>"
15259   [(parallel [(set (mem:VI48F_512
15260                      (match_par_dup 5
15261                        [(match_operand 0 "vsib_address_operand")
15262                         (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand")
15263                         (match_operand:SI 4 "const1248_operand")]))
15264                    (unspec:VI48F_512
15265                      [(match_operand:<avx512fmaskmode> 1 "register_operand")
15266                       (match_operand:VI48F_512 3 "register_operand")]
15267                      UNSPEC_SCATTER))
15268               (clobber (match_scratch:<avx512fmaskmode> 6))])]
15269   "TARGET_AVX512F"
15270 {
15271   operands[5]
15272     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[0], operands[2],
15273                                         operands[4]), UNSPEC_VSIBADDR);
15274 })
15275
15276 (define_insn "*avx512f_scattersi<mode>"
15277   [(set (match_operator:VI48F_512 5 "vsib_mem_operator"
15278           [(unspec:P
15279              [(match_operand:P 0 "vsib_address_operand" "Tv")
15280               (match_operand:<VEC_GATHER_IDXSI> 2 "register_operand" "v")
15281               (match_operand:SI 4 "const1248_operand" "n")]
15282              UNSPEC_VSIBADDR)])
15283         (unspec:VI48F_512
15284           [(match_operand:<avx512fmaskmode> 6 "register_operand" "1")
15285            (match_operand:VI48F_512 3 "register_operand" "v")]
15286           UNSPEC_SCATTER))
15287    (clobber (match_scratch:<avx512fmaskmode> 1 "=&Yk"))]
15288   "TARGET_AVX512F"
15289   "v<sseintprefix>scatterd<ssemodesuffix>\t{%3, %5%{%1%}|%5%{%1%}, %3}"
15290   [(set_attr "type" "ssemov")
15291    (set_attr "prefix" "evex")
15292    (set_attr "mode" "<sseinsnmode>")])
15293
15294 (define_expand "avx512f_scatterdi<mode>"
15295   [(parallel [(set (mem:VI48F_512
15296                      (match_par_dup 5
15297                        [(match_operand 0 "vsib_address_operand")
15298                         (match_operand:V8DI 2 "register_operand")
15299                         (match_operand:SI 4 "const1248_operand")]))
15300                    (unspec:VI48F_512
15301                      [(match_operand:QI 1 "register_operand")
15302                       (match_operand:<VEC_GATHER_SRCDI> 3 "register_operand")]
15303                      UNSPEC_SCATTER))
15304               (clobber (match_scratch:QI 6))])]
15305   "TARGET_AVX512F"
15306 {
15307   operands[5]
15308     = gen_rtx_UNSPEC (Pmode, gen_rtvec (3, operands[0], operands[2],
15309                                         operands[4]), UNSPEC_VSIBADDR);
15310 })
15311
15312 (define_insn "*avx512f_scatterdi<mode>"
15313   [(set (match_operator:VI48F_512 5 "vsib_mem_operator"
15314           [(unspec:P
15315              [(match_operand:P 0 "vsib_address_operand" "Tv")
15316               (match_operand:V8DI 2 "register_operand" "v")
15317               (match_operand:SI 4 "const1248_operand" "n")]
15318              UNSPEC_VSIBADDR)])
15319         (unspec:VI48F_512
15320           [(match_operand:QI 6 "register_operand" "1")
15321            (match_operand:<VEC_GATHER_SRCDI> 3 "register_operand" "v")]
15322           UNSPEC_SCATTER))
15323    (clobber (match_scratch:QI 1 "=&Yk"))]
15324   "TARGET_AVX512F"
15325   "v<sseintprefix>scatterq<ssemodesuffix>\t{%3, %5%{%1%}|%5%{%1%}, %3}"
15326   [(set_attr "type" "ssemov")
15327    (set_attr "prefix" "evex")
15328    (set_attr "mode" "<sseinsnmode>")])
15329
15330 (define_insn "avx512f_compress<mode>_mask"
15331   [(set (match_operand:VI48F_512 0 "register_operand" "=v")
15332         (unspec:VI48F_512
15333           [(match_operand:VI48F_512 1 "register_operand" "v")
15334            (match_operand:VI48F_512 2 "vector_move_operand" "0C")
15335            (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk")]
15336           UNSPEC_COMPRESS))]
15337   "TARGET_AVX512F"
15338   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
15339   [(set_attr "type" "ssemov")
15340    (set_attr "prefix" "evex")
15341    (set_attr "mode" "<sseinsnmode>")])
15342
15343 (define_insn "avx512f_compressstore<mode>_mask"
15344   [(set (match_operand:VI48F_512 0 "memory_operand" "=m")
15345         (unspec:VI48F_512
15346           [(match_operand:VI48F_512 1 "register_operand" "x")
15347            (match_dup 0)
15348            (match_operand:<avx512fmaskmode> 2 "register_operand" "Yk")]
15349           UNSPEC_COMPRESS_STORE))]
15350   "TARGET_AVX512F"
15351   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}"
15352   [(set_attr "type" "ssemov")
15353    (set_attr "prefix" "evex")
15354    (set_attr "memory" "store")
15355    (set_attr "mode" "<sseinsnmode>")])
15356
15357 (define_expand "avx512f_expand<mode>_maskz"
15358   [(set (match_operand:VI48F_512 0 "register_operand")
15359         (unspec:VI48F_512
15360           [(match_operand:VI48F_512 1 "nonimmediate_operand")
15361            (match_operand:VI48F_512 2 "vector_move_operand")
15362            (match_operand:<avx512fmaskmode> 3 "register_operand")]
15363           UNSPEC_EXPAND))]
15364   "TARGET_AVX512F"
15365   "operands[2] = CONST0_RTX (<MODE>mode);")
15366
15367 (define_insn "avx512f_expand<mode>_mask"
15368   [(set (match_operand:VI48F_512 0 "register_operand" "=v,v")
15369         (unspec:VI48F_512
15370           [(match_operand:VI48F_512 1 "nonimmediate_operand" "v,m")
15371            (match_operand:VI48F_512 2 "vector_move_operand" "0C,0C")
15372            (match_operand:<avx512fmaskmode> 3 "register_operand" "Yk,Yk")]
15373           UNSPEC_EXPAND))]
15374   "TARGET_AVX512F"
15375   "v<sseintprefix>expand<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
15376   [(set_attr "type" "ssemov")
15377    (set_attr "prefix" "evex")
15378    (set_attr "memory" "none,load")
15379    (set_attr "mode" "<sseinsnmode>")])
15380
15381 (define_insn "avx512f_getmant<mode><mask_name><round_saeonly_name>"
15382   [(set (match_operand:VF_512 0 "register_operand" "=v")
15383         (unspec:VF_512
15384           [(match_operand:VF_512 1 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
15385            (match_operand:SI 2 "const_0_to_15_operand")]
15386           UNSPEC_GETMANT))]
15387   "TARGET_AVX512F"
15388   "vgetmant<ssemodesuffix>\t{%2, <round_saeonly_mask_op3>%1, %0<mask_operand3>|%0<mask_operand3>, %1<round_saeonly_mask_op3>, %2}";
15389   [(set_attr "prefix" "evex")
15390    (set_attr "mode" "<MODE>")])
15391
15392 (define_insn "avx512f_getmant<mode><round_saeonly_name>"
15393   [(set (match_operand:VF_128 0 "register_operand" "=v")
15394         (vec_merge:VF_128
15395           (unspec:VF_128
15396             [(match_operand:VF_128 1 "register_operand" "v")
15397              (match_operand:VF_128 2 "<round_saeonly_nimm_predicate>" "<round_saeonly_constraint>")
15398              (match_operand:SI 3 "const_0_to_15_operand")]
15399             UNSPEC_GETMANT)
15400           (match_dup 1)
15401           (const_int 1)))]
15402    "TARGET_AVX512F"
15403    "vgetmant<ssescalarmodesuffix>\t{%3, <round_saeonly_op4>%2, %1, %0|%0, %1, %2<round_saeonly_op4>, %3}";
15404    [(set_attr "prefix" "evex")
15405    (set_attr "mode" "<ssescalarmode>")])
15406
15407 (define_insn "clz<mode>2<mask_name>"
15408   [(set (match_operand:VI48_512 0 "register_operand" "=v")
15409         (clz:VI48_512
15410           (match_operand:VI48_512 1 "nonimmediate_operand" "vm")))]
15411   "TARGET_AVX512CD"
15412   "vplzcnt<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
15413   [(set_attr "type" "sse")
15414    (set_attr "prefix" "evex")
15415    (set_attr "mode" "<sseinsnmode>")])
15416
15417 (define_insn "<mask_codefor>conflict<mode><mask_name>"
15418   [(set (match_operand:VI48_512 0 "register_operand" "=v")
15419         (unspec:VI48_512
15420           [(match_operand:VI48_512 1 "nonimmediate_operand" "vm")]
15421           UNSPEC_CONFLICT))]
15422   "TARGET_AVX512CD"
15423   "vpconflict<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
15424   [(set_attr "type" "sse")
15425    (set_attr "prefix" "evex")
15426    (set_attr "mode" "<sseinsnmode>")])
15427
15428 (define_insn "sha1msg1"
15429   [(set (match_operand:V4SI 0 "register_operand" "=x")
15430         (unspec:V4SI
15431           [(match_operand:V4SI 1 "register_operand" "0")
15432            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15433           UNSPEC_SHA1MSG1))]
15434   "TARGET_SHA"
15435   "sha1msg1\t{%2, %0|%0, %2}"
15436   [(set_attr "type" "sselog1")
15437    (set_attr "mode" "TI")])
15438
15439 (define_insn "sha1msg2"
15440   [(set (match_operand:V4SI 0 "register_operand" "=x")
15441         (unspec:V4SI
15442           [(match_operand:V4SI 1 "register_operand" "0")
15443            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15444           UNSPEC_SHA1MSG2))]
15445   "TARGET_SHA"
15446   "sha1msg2\t{%2, %0|%0, %2}"
15447   [(set_attr "type" "sselog1")
15448    (set_attr "mode" "TI")])
15449
15450 (define_insn "sha1nexte"
15451   [(set (match_operand:V4SI 0 "register_operand" "=x")
15452         (unspec:V4SI
15453           [(match_operand:V4SI 1 "register_operand" "0")
15454            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15455           UNSPEC_SHA1NEXTE))]
15456   "TARGET_SHA"
15457   "sha1nexte\t{%2, %0|%0, %2}"
15458   [(set_attr "type" "sselog1")
15459    (set_attr "mode" "TI")])
15460
15461 (define_insn "sha1rnds4"
15462   [(set (match_operand:V4SI 0 "register_operand" "=x")
15463         (unspec:V4SI
15464           [(match_operand:V4SI 1 "register_operand" "0")
15465            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
15466            (match_operand:SI 3 "const_0_to_3_operand" "n")]
15467           UNSPEC_SHA1RNDS4))]
15468   "TARGET_SHA"
15469   "sha1rnds4\t{%3, %2, %0|%0, %2, %3}"
15470   [(set_attr "type" "sselog1")
15471    (set_attr "length_immediate" "1")
15472    (set_attr "mode" "TI")])
15473
15474 (define_insn "sha256msg1"
15475   [(set (match_operand:V4SI 0 "register_operand" "=x")
15476         (unspec:V4SI
15477           [(match_operand:V4SI 1 "register_operand" "0")
15478            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15479           UNSPEC_SHA256MSG1))]
15480   "TARGET_SHA"
15481   "sha256msg1\t{%2, %0|%0, %2}"
15482   [(set_attr "type" "sselog1")
15483    (set_attr "mode" "TI")])
15484
15485 (define_insn "sha256msg2"
15486   [(set (match_operand:V4SI 0 "register_operand" "=x")
15487         (unspec:V4SI
15488           [(match_operand:V4SI 1 "register_operand" "0")
15489            (match_operand:V4SI 2 "nonimmediate_operand" "xm")]
15490           UNSPEC_SHA256MSG2))]
15491   "TARGET_SHA"
15492   "sha256msg2\t{%2, %0|%0, %2}"
15493   [(set_attr "type" "sselog1")
15494    (set_attr "mode" "TI")])
15495
15496 (define_insn "sha256rnds2"
15497   [(set (match_operand:V4SI 0 "register_operand" "=x")
15498         (unspec:V4SI
15499           [(match_operand:V4SI 1 "register_operand" "0")
15500            (match_operand:V4SI 2 "nonimmediate_operand" "xm")
15501            (match_operand:V4SI 3 "register_operand" "Yz")]
15502           UNSPEC_SHA256RNDS2))]
15503   "TARGET_SHA"
15504   "sha256rnds2\t{%3, %2, %0|%0, %2, %3}"
15505   [(set_attr "type" "sselog1")
15506    (set_attr "length_immediate" "1")
15507    (set_attr "mode" "TI")])