contrib/llvm/lib/Target/X86/X86InstrAVX512.td

   1 //===-- X86InstrAVX512.td - AVX512 Instruction Set ---------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the X86 AVX512 instruction set, defining the
  11 // instructions, and properties of the instructions which are needed for code
  12 // generation, machine code emission, and analysis.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 // Group template arguments that can be derived from the vector type (EltNum x
  17 // EltVT).  These are things like the register class for the writemask, etc.
  18 // The idea is to pass one of these as the template argument rather than the
  19 // individual arguments.
  20 // The template is also used for scalar types, in this case numelts is 1.
  21 class X86VectorVTInfo<int numelts, ValueType eltvt, RegisterClass rc,
  22                       string suffix = ""> {
  23   RegisterClass RC = rc;
  24   ValueType EltVT = eltvt;
  25   int NumElts = numelts;
  26
  27   // Corresponding mask register class.
  28   RegisterClass KRC = !cast<RegisterClass>("VK" # NumElts);
  29
  30   // Corresponding write-mask register class.
  31   RegisterClass KRCWM = !cast<RegisterClass>("VK" # NumElts # "WM");
  32
  33   // The mask VT.
  34   ValueType KVT = !cast<ValueType>("v" # NumElts # "i1");
  35
  36   // Suffix used in the instruction mnemonic.
  37   string Suffix = suffix;
  38
  39   // VTName is a string name for vector VT. For vector types it will be
  40   // v # NumElts # EltVT, so for vector of 8 elements of i32 it will be v8i32
  41   // It is a little bit complex for scalar types, where NumElts = 1.
  42   // In this case we build v4f32 or v2f64
  43   string VTName = "v" # !if (!eq (NumElts, 1),
  44                         !if (!eq (EltVT.Size, 32), 4,
  45                         !if (!eq (EltVT.Size, 64), 2, NumElts)), NumElts) # EltVT;
  46
  47   // The vector VT.
  48   ValueType VT = !cast<ValueType>(VTName);
  49
  50   string EltTypeName = !cast<string>(EltVT);
  51   // Size of the element type in bits, e.g. 32 for v16i32.
  52   string EltSizeName = !subst("i", "", !subst("f", "", EltTypeName));
  53   int EltSize = EltVT.Size;
  54
  55   // "i" for integer types and "f" for floating-point types
  56   string TypeVariantName = !subst(EltSizeName, "", EltTypeName);
  57
  58   // Size of RC in bits, e.g. 512 for VR512.
  59   int Size = VT.Size;
  60
  61   // The corresponding memory operand, e.g. i512mem for VR512.
  62   X86MemOperand MemOp = !cast<X86MemOperand>(TypeVariantName # Size # "mem");
  63   X86MemOperand ScalarMemOp = !cast<X86MemOperand>(EltVT # "mem");
  64   // FP scalar memory operand for intrinsics - ssmem/sdmem.
  65   Operand IntScalarMemOp = !if (!eq (EltTypeName, "f32"), !cast<Operand>("ssmem"),
  66                            !if (!eq (EltTypeName, "f64"), !cast<Operand>("sdmem"), ?));
  67
  68   // Load patterns
  69   // Note: For 128/256-bit integer VT we choose loadv2i64/loadv4i64
  70   //       due to load promotion during legalization
  71   PatFrag LdFrag = !cast<PatFrag>("load" #
  72                                   !if (!eq (TypeVariantName, "i"),
  73                                        !if (!eq (Size, 128), "v2i64",
  74                                        !if (!eq (Size, 256), "v4i64",
  75                                        !if (!eq (Size, 512), "v8i64",
  76                                             VTName))), VTName));
  77
  78   PatFrag AlignedLdFrag = !cast<PatFrag>("alignedload" #
  79                                          !if (!eq (TypeVariantName, "i"),
  80                                                !if (!eq (Size, 128), "v2i64",
  81                                                !if (!eq (Size, 256), "v4i64",
  82                                                !if (!eq (Size, 512), "v8i64",
  83                                                    VTName))), VTName));
  84
  85   PatFrag ScalarLdFrag = !cast<PatFrag>("load" # EltVT);
  86
  87   ComplexPattern ScalarIntMemCPat = !if (!eq (EltTypeName, "f32"),
  88                                           !cast<ComplexPattern>("sse_load_f32"),
  89                                     !if (!eq (EltTypeName, "f64"),
  90                                           !cast<ComplexPattern>("sse_load_f64"),
  91                                     ?));
  92
  93   // The corresponding float type, e.g. v16f32 for v16i32
  94   // Note: For EltSize < 32, FloatVT is illegal and TableGen
  95   //       fails to compile, so we choose FloatVT = VT
  96   ValueType FloatVT = !cast<ValueType>(
  97                         !if (!eq (!srl(EltSize,5),0),
  98                              VTName,
  99                              !if (!eq(TypeVariantName, "i"),
 100                                   "v" # NumElts # "f" # EltSize,
 101                                   VTName)));
 102
 103   ValueType IntVT = !cast<ValueType>(
 104                         !if (!eq (!srl(EltSize,5),0),
 105                              VTName,
 106                              !if (!eq(TypeVariantName, "f"),
 107                                   "v" # NumElts # "i" # EltSize,
 108                                   VTName)));
 109   // The string to specify embedded broadcast in assembly.
 110   string BroadcastStr = "{1to" # NumElts # "}";
 111
 112   // 8-bit compressed displacement tuple/subvector format.  This is only
 113   // defined for NumElts <= 8.
 114   CD8VForm CD8TupleForm = !if (!eq (!srl(NumElts, 4), 0),
 115                                !cast<CD8VForm>("CD8VT" # NumElts), ?);
 116
 117   SubRegIndex SubRegIdx = !if (!eq (Size, 128), sub_xmm,
 118                           !if (!eq (Size, 256), sub_ymm, ?));
 119
 120   Domain ExeDomain = !if (!eq (EltTypeName, "f32"), SSEPackedSingle,
 121                      !if (!eq (EltTypeName, "f64"), SSEPackedDouble,
 122                      SSEPackedInt));
 123
 124   RegisterClass FRC = !if (!eq (EltTypeName, "f32"), FR32X, FR64X);
 125
 126   // A vector tye of the same width with element type i64. This is used to
 127   // create patterns for logic ops.
 128   ValueType i64VT = !cast<ValueType>("v" # !srl(Size, 6) # "i64");
 129
 130   // A vector type of the same width with element type i32.  This is used to
 131   // create the canonical constant zero node ImmAllZerosV.
 132   ValueType i32VT = !cast<ValueType>("v" # !srl(Size, 5) # "i32");
 133   dag ImmAllZerosV = (VT (bitconvert (i32VT immAllZerosV)));
 134
 135   string ZSuffix = !if (!eq (Size, 128), "Z128",
 136                    !if (!eq (Size, 256), "Z256", "Z"));
 137 }
 138
 139 def v64i8_info  : X86VectorVTInfo<64,  i8, VR512, "b">;
 140 def v32i16_info : X86VectorVTInfo<32, i16, VR512, "w">;
 141 def v16i32_info : X86VectorVTInfo<16, i32, VR512, "d">;
 142 def v8i64_info  : X86VectorVTInfo<8,  i64, VR512, "q">;
 143 def v16f32_info : X86VectorVTInfo<16, f32, VR512, "ps">;
 144 def v8f64_info  : X86VectorVTInfo<8,  f64, VR512, "pd">;
 145
 146 // "x" in v32i8x_info means RC = VR256X
 147 def v32i8x_info  : X86VectorVTInfo<32,  i8, VR256X, "b">;
 148 def v16i16x_info : X86VectorVTInfo<16, i16, VR256X, "w">;
 149 def v8i32x_info  : X86VectorVTInfo<8,  i32, VR256X, "d">;
 150 def v4i64x_info  : X86VectorVTInfo<4,  i64, VR256X, "q">;
 151 def v8f32x_info  : X86VectorVTInfo<8,  f32, VR256X, "ps">;
 152 def v4f64x_info  : X86VectorVTInfo<4,  f64, VR256X, "pd">;
 153
 154 def v16i8x_info  : X86VectorVTInfo<16,  i8, VR128X, "b">;
 155 def v8i16x_info  : X86VectorVTInfo<8,  i16, VR128X, "w">;
 156 def v4i32x_info  : X86VectorVTInfo<4,  i32, VR128X, "d">;
 157 def v2i64x_info  : X86VectorVTInfo<2,  i64, VR128X, "q">;
 158 def v4f32x_info  : X86VectorVTInfo<4,  f32, VR128X, "ps">;
 159 def v2f64x_info  : X86VectorVTInfo<2,  f64, VR128X, "pd">;
 160
 161 // We map scalar types to the smallest (128-bit) vector type
 162 // with the appropriate element type. This allows to use the same masking logic.
 163 def i32x_info    : X86VectorVTInfo<1,  i32, GR32, "si">;
 164 def i64x_info    : X86VectorVTInfo<1,  i64, GR64, "sq">;
 165 def f32x_info    : X86VectorVTInfo<1,  f32, VR128X, "ss">;
 166 def f64x_info    : X86VectorVTInfo<1,  f64, VR128X, "sd">;
 167
 168 class AVX512VLVectorVTInfo<X86VectorVTInfo i512, X86VectorVTInfo i256,
 169                            X86VectorVTInfo i128> {
 170   X86VectorVTInfo info512 = i512;
 171   X86VectorVTInfo info256 = i256;
 172   X86VectorVTInfo info128 = i128;
 173 }
 174
 175 def avx512vl_i8_info  : AVX512VLVectorVTInfo<v64i8_info, v32i8x_info,
 176                                              v16i8x_info>;
 177 def avx512vl_i16_info : AVX512VLVectorVTInfo<v32i16_info, v16i16x_info,
 178                                              v8i16x_info>;
 179 def avx512vl_i32_info : AVX512VLVectorVTInfo<v16i32_info, v8i32x_info,
 180                                              v4i32x_info>;
 181 def avx512vl_i64_info : AVX512VLVectorVTInfo<v8i64_info, v4i64x_info,
 182                                              v2i64x_info>;
 183 def avx512vl_f32_info : AVX512VLVectorVTInfo<v16f32_info, v8f32x_info,
 184                                              v4f32x_info>;
 185 def avx512vl_f64_info : AVX512VLVectorVTInfo<v8f64_info, v4f64x_info,
 186                                              v2f64x_info>;
 187
 188 // This multiclass generates the masking variants from the non-masking
 189 // variant.  It only provides the assembly pieces for the masking variants.
 190 // It assumes custom ISel patterns for masking which can be provided as
 191 // template arguments.
 192 multiclass AVX512_maskable_custom<bits<8> O, Format F,
 193                                   dag Outs,
 194                                   dag Ins, dag MaskingIns, dag ZeroMaskingIns,
 195                                   string OpcodeStr,
 196                                   string AttSrcAsm, string IntelSrcAsm,
 197                                   list<dag> Pattern,
 198                                   list<dag> MaskingPattern,
 199                                   list<dag> ZeroMaskingPattern,
 200                                   string MaskingConstraint = "",
 201                                   InstrItinClass itin = NoItinerary,
 202                                   bit IsCommutable = 0,
 203                                   bit IsKCommutable = 0> {
 204   let isCommutable = IsCommutable in
 205     def NAME: AVX512<O, F, Outs, Ins,
 206                        OpcodeStr#"\t{"#AttSrcAsm#", $dst|"#
 207                                      "$dst, "#IntelSrcAsm#"}",
 208                        Pattern, itin>;
 209
 210   // Prefer over VMOV*rrk Pat<>
 211   let isCommutable = IsKCommutable in
 212     def NAME#k: AVX512<O, F, Outs, MaskingIns,
 213                        OpcodeStr#"\t{"#AttSrcAsm#", $dst {${mask}}|"#
 214                                      "$dst {${mask}}, "#IntelSrcAsm#"}",
 215                        MaskingPattern, itin>,
 216               EVEX_K {
 217       // In case of the 3src subclass this is overridden with a let.
 218       string Constraints = MaskingConstraint;
 219     }
 220
 221   // Zero mask does not add any restrictions to commute operands transformation.
 222   // So, it is Ok to use IsCommutable instead of IsKCommutable.
 223   let isCommutable = IsCommutable in // Prefer over VMOV*rrkz Pat<>
 224     def NAME#kz: AVX512<O, F, Outs, ZeroMaskingIns,
 225                        OpcodeStr#"\t{"#AttSrcAsm#", $dst {${mask}} {z}|"#
 226                                      "$dst {${mask}} {z}, "#IntelSrcAsm#"}",
 227                        ZeroMaskingPattern,
 228                        itin>,
 229               EVEX_KZ;
 230 }
 231
 232
 233 // Common base class of AVX512_maskable and AVX512_maskable_3src.
 234 multiclass AVX512_maskable_common<bits<8> O, Format F, X86VectorVTInfo _,
 235                                   dag Outs,
 236                                   dag Ins, dag MaskingIns, dag ZeroMaskingIns,
 237                                   string OpcodeStr,
 238                                   string AttSrcAsm, string IntelSrcAsm,
 239                                   dag RHS, dag MaskingRHS,
 240                                   SDNode Select = vselect,
 241                                   string MaskingConstraint = "",
 242                                   InstrItinClass itin = NoItinerary,
 243                                   bit IsCommutable = 0,
 244                                   bit IsKCommutable = 0> :
 245   AVX512_maskable_custom<O, F, Outs, Ins, MaskingIns, ZeroMaskingIns, OpcodeStr,
 246                          AttSrcAsm, IntelSrcAsm,
 247                          [(set _.RC:$dst, RHS)],
 248                          [(set _.RC:$dst, MaskingRHS)],
 249                          [(set _.RC:$dst,
 250                                (Select _.KRCWM:$mask, RHS, _.ImmAllZerosV))],
 251                          MaskingConstraint, NoItinerary, IsCommutable,
 252                          IsKCommutable>;
 253
 254 // Similar to AVX512_maskable_common, but with scalar types.
 255 multiclass AVX512_maskable_fp_common<bits<8> O, Format F, X86VectorVTInfo _,
 256                                   dag Outs,
 257                                   dag Ins, dag MaskingIns, dag ZeroMaskingIns,
 258                                   string OpcodeStr,
 259                                   string AttSrcAsm, string IntelSrcAsm,
 260                                   SDNode Select = vselect,
 261                                   string MaskingConstraint = "",
 262                                   InstrItinClass itin = NoItinerary,
 263                                   bit IsCommutable = 0,
 264                                   bit IsKCommutable = 0> :
 265   AVX512_maskable_custom<O, F, Outs, Ins, MaskingIns, ZeroMaskingIns, OpcodeStr,
 266                          AttSrcAsm, IntelSrcAsm,
 267                          [], [], [],
 268                          MaskingConstraint, NoItinerary, IsCommutable,
 269                          IsKCommutable>;
 270
 271 // This multiclass generates the unconditional/non-masking, the masking and
 272 // the zero-masking variant of the vector instruction.  In the masking case, the
 273 // perserved vector elements come from a new dummy input operand tied to $dst.
 274 multiclass AVX512_maskable<bits<8> O, Format F, X86VectorVTInfo _,
 275                            dag Outs, dag Ins, string OpcodeStr,
 276                            string AttSrcAsm, string IntelSrcAsm,
 277                            dag RHS,
 278                            InstrItinClass itin = NoItinerary,
 279                            bit IsCommutable = 0, bit IsKCommutable = 0,
 280                            SDNode Select = vselect> :
 281    AVX512_maskable_common<O, F, _, Outs, Ins,
 282                           !con((ins _.RC:$src0, _.KRCWM:$mask), Ins),
 283                           !con((ins _.KRCWM:$mask), Ins),
 284                           OpcodeStr, AttSrcAsm, IntelSrcAsm, RHS,
 285                           (Select _.KRCWM:$mask, RHS, _.RC:$src0), Select,
 286                           "$src0 = $dst", itin, IsCommutable, IsKCommutable>;
 287
 288 // This multiclass generates the unconditional/non-masking, the masking and
 289 // the zero-masking variant of the scalar instruction.
 290 multiclass AVX512_maskable_scalar<bits<8> O, Format F, X86VectorVTInfo _,
 291                            dag Outs, dag Ins, string OpcodeStr,
 292                            string AttSrcAsm, string IntelSrcAsm,
 293                            dag RHS,
 294                            InstrItinClass itin = NoItinerary,
 295                            bit IsCommutable = 0> :
 296    AVX512_maskable_common<O, F, _, Outs, Ins,
 297                           !con((ins _.RC:$src0, _.KRCWM:$mask), Ins),
 298                           !con((ins _.KRCWM:$mask), Ins),
 299                           OpcodeStr, AttSrcAsm, IntelSrcAsm, RHS,
 300                           (X86selects _.KRCWM:$mask, RHS, _.RC:$src0),
 301                           X86selects, "$src0 = $dst", itin, IsCommutable>;
 302
 303 // Similar to AVX512_maskable but in this case one of the source operands
 304 // ($src1) is already tied to $dst so we just use that for the preserved
 305 // vector elements.  NOTE that the NonTiedIns (the ins dag) should exclude
 306 // $src1.
 307 multiclass AVX512_maskable_3src<bits<8> O, Format F, X86VectorVTInfo _,
 308                                 dag Outs, dag NonTiedIns, string OpcodeStr,
 309                                 string AttSrcAsm, string IntelSrcAsm,
 310                                 dag RHS, bit IsCommutable = 0,
 311                                 bit IsKCommutable = 0> :
 312    AVX512_maskable_common<O, F, _, Outs,
 313                           !con((ins _.RC:$src1), NonTiedIns),
 314                           !con((ins _.RC:$src1, _.KRCWM:$mask), NonTiedIns),
 315                           !con((ins _.RC:$src1, _.KRCWM:$mask), NonTiedIns),
 316                           OpcodeStr, AttSrcAsm, IntelSrcAsm, RHS,
 317                           (vselect _.KRCWM:$mask, RHS, _.RC:$src1),
 318                           vselect, "", NoItinerary, IsCommutable, IsKCommutable>;
 319
 320 multiclass AVX512_maskable_3src_scalar<bits<8> O, Format F, X86VectorVTInfo _,
 321                                      dag Outs, dag NonTiedIns, string OpcodeStr,
 322                                      string AttSrcAsm, string IntelSrcAsm,
 323                                      dag RHS, bit IsCommutable = 0,
 324                                      bit IsKCommutable = 0> :
 325    AVX512_maskable_common<O, F, _, Outs,
 326                           !con((ins _.RC:$src1), NonTiedIns),
 327                           !con((ins _.RC:$src1, _.KRCWM:$mask), NonTiedIns),
 328                           !con((ins _.RC:$src1, _.KRCWM:$mask), NonTiedIns),
 329                           OpcodeStr, AttSrcAsm, IntelSrcAsm, RHS,
 330                           (X86selects _.KRCWM:$mask, RHS, _.RC:$src1),
 331                           X86selects, "", NoItinerary, IsCommutable,
 332                           IsKCommutable>;
 333
 334 multiclass AVX512_maskable_in_asm<bits<8> O, Format F, X86VectorVTInfo _,
 335                                   dag Outs, dag Ins,
 336                                   string OpcodeStr,
 337                                   string AttSrcAsm, string IntelSrcAsm,
 338                                   list<dag> Pattern> :
 339    AVX512_maskable_custom<O, F, Outs, Ins,
 340                           !con((ins _.RC:$src0, _.KRCWM:$mask), Ins),
 341                           !con((ins _.KRCWM:$mask), Ins),
 342                           OpcodeStr, AttSrcAsm, IntelSrcAsm, Pattern, [], [],
 343                           "$src0 = $dst">;
 344
 345
 346 // Instruction with mask that puts result in mask register,
 347 // like "compare" and "vptest"
 348 multiclass AVX512_maskable_custom_cmp<bits<8> O, Format F,
 349                                   dag Outs,
 350                                   dag Ins, dag MaskingIns,
 351                                   string OpcodeStr,
 352                                   string AttSrcAsm, string IntelSrcAsm,
 353                                   list<dag> Pattern,
 354                                   list<dag> MaskingPattern,
 355                                   bit IsCommutable = 0> {
 356     let isCommutable = IsCommutable in
 357     def NAME: AVX512<O, F, Outs, Ins,
 358                        OpcodeStr#"\t{"#AttSrcAsm#", $dst|"#
 359                                      "$dst, "#IntelSrcAsm#"}",
 360                        Pattern, NoItinerary>;
 361
 362     def NAME#k: AVX512<O, F, Outs, MaskingIns,
 363                        OpcodeStr#"\t{"#AttSrcAsm#", $dst {${mask}}|"#
 364                                      "$dst {${mask}}, "#IntelSrcAsm#"}",
 365                        MaskingPattern, NoItinerary>, EVEX_K;
 366 }
 367
 368 multiclass AVX512_maskable_common_cmp<bits<8> O, Format F, X86VectorVTInfo _,
 369                                   dag Outs,
 370                                   dag Ins, dag MaskingIns,
 371                                   string OpcodeStr,
 372                                   string AttSrcAsm, string IntelSrcAsm,
 373                                   dag RHS, dag MaskingRHS,
 374                                   bit IsCommutable = 0> :
 375   AVX512_maskable_custom_cmp<O, F, Outs, Ins, MaskingIns, OpcodeStr,
 376                          AttSrcAsm, IntelSrcAsm,
 377                          [(set _.KRC:$dst, RHS)],
 378                          [(set _.KRC:$dst, MaskingRHS)], IsCommutable>;
 379
 380 multiclass AVX512_maskable_cmp<bits<8> O, Format F, X86VectorVTInfo _,
 381                            dag Outs, dag Ins, string OpcodeStr,
 382                            string AttSrcAsm, string IntelSrcAsm,
 383                            dag RHS, bit IsCommutable = 0> :
 384    AVX512_maskable_common_cmp<O, F, _, Outs, Ins,
 385                           !con((ins _.KRCWM:$mask), Ins),
 386                           OpcodeStr, AttSrcAsm, IntelSrcAsm, RHS,
 387                           (and _.KRCWM:$mask, RHS), IsCommutable>;
 388
 389 multiclass AVX512_maskable_cmp_alt<bits<8> O, Format F, X86VectorVTInfo _,
 390                            dag Outs, dag Ins, string OpcodeStr,
 391                            string AttSrcAsm, string IntelSrcAsm> :
 392    AVX512_maskable_custom_cmp<O, F, Outs,
 393                              Ins, !con((ins _.KRCWM:$mask),Ins), OpcodeStr,
 394                              AttSrcAsm, IntelSrcAsm, [],[]>;
 395
 396 // This multiclass generates the unconditional/non-masking, the masking and
 397 // the zero-masking variant of the vector instruction.  In the masking case, the
 398 // perserved vector elements come from a new dummy input operand tied to $dst.
 399 multiclass AVX512_maskable_logic<bits<8> O, Format F, X86VectorVTInfo _,
 400                            dag Outs, dag Ins, string OpcodeStr,
 401                            string AttSrcAsm, string IntelSrcAsm,
 402                            dag RHS, dag MaskedRHS,
 403                            InstrItinClass itin = NoItinerary,
 404                            bit IsCommutable = 0, SDNode Select = vselect> :
 405    AVX512_maskable_custom<O, F, Outs, Ins,
 406                           !con((ins _.RC:$src0, _.KRCWM:$mask), Ins),
 407                           !con((ins _.KRCWM:$mask), Ins),
 408                           OpcodeStr, AttSrcAsm, IntelSrcAsm,
 409                           [(set _.RC:$dst, RHS)],
 410                           [(set _.RC:$dst,
 411                                 (Select _.KRCWM:$mask, MaskedRHS, _.RC:$src0))],
 412                           [(set _.RC:$dst,
 413                                 (Select _.KRCWM:$mask, MaskedRHS,
 414                                         _.ImmAllZerosV))],
 415                           "$src0 = $dst", itin, IsCommutable>;
 416
 417 // Bitcasts between 512-bit vector types. Return the original type since
 418 // no instruction is needed for the conversion.
 419 def : Pat<(v8f64  (bitconvert (v8i64  VR512:$src))), (v8f64  VR512:$src)>;
 420 def : Pat<(v8f64  (bitconvert (v16i32 VR512:$src))), (v8f64  VR512:$src)>;
 421 def : Pat<(v8f64  (bitconvert (v32i16 VR512:$src))), (v8f64  VR512:$src)>;
 422 def : Pat<(v8f64  (bitconvert (v64i8  VR512:$src))), (v8f64  VR512:$src)>;
 423 def : Pat<(v8f64  (bitconvert (v16f32 VR512:$src))), (v8f64  VR512:$src)>;
 424 def : Pat<(v16f32 (bitconvert (v8i64  VR512:$src))), (v16f32 VR512:$src)>;
 425 def : Pat<(v16f32 (bitconvert (v16i32 VR512:$src))), (v16f32 VR512:$src)>;
 426 def : Pat<(v16f32 (bitconvert (v32i16 VR512:$src))), (v16f32 VR512:$src)>;
 427 def : Pat<(v16f32 (bitconvert (v64i8  VR512:$src))), (v16f32 VR512:$src)>;
 428 def : Pat<(v16f32 (bitconvert (v8f64  VR512:$src))), (v16f32 VR512:$src)>;
 429 def : Pat<(v8i64  (bitconvert (v16i32 VR512:$src))), (v8i64  VR512:$src)>;
 430 def : Pat<(v8i64  (bitconvert (v32i16 VR512:$src))), (v8i64  VR512:$src)>;
 431 def : Pat<(v8i64  (bitconvert (v64i8  VR512:$src))), (v8i64  VR512:$src)>;
 432 def : Pat<(v8i64  (bitconvert (v8f64  VR512:$src))), (v8i64  VR512:$src)>;
 433 def : Pat<(v8i64  (bitconvert (v16f32 VR512:$src))), (v8i64  VR512:$src)>;
 434 def : Pat<(v16i32 (bitconvert (v8i64  VR512:$src))), (v16i32 VR512:$src)>;
 435 def : Pat<(v16i32 (bitconvert (v16f32 VR512:$src))), (v16i32 VR512:$src)>;
 436 def : Pat<(v16i32 (bitconvert (v32i16 VR512:$src))), (v16i32 VR512:$src)>;
 437 def : Pat<(v16i32 (bitconvert (v64i8  VR512:$src))), (v16i32 VR512:$src)>;
 438 def : Pat<(v16i32 (bitconvert (v8f64  VR512:$src))), (v16i32 VR512:$src)>;
 439 def : Pat<(v32i16 (bitconvert (v8i64  VR512:$src))), (v32i16 VR512:$src)>;
 440 def : Pat<(v32i16 (bitconvert (v16i32 VR512:$src))), (v32i16 VR512:$src)>;
 441 def : Pat<(v32i16 (bitconvert (v64i8  VR512:$src))), (v32i16 VR512:$src)>;
 442 def : Pat<(v32i16 (bitconvert (v8f64  VR512:$src))), (v32i16 VR512:$src)>;
 443 def : Pat<(v32i16 (bitconvert (v16f32 VR512:$src))), (v32i16 VR512:$src)>;
 444 def : Pat<(v32i16 (bitconvert (v16f32 VR512:$src))), (v32i16 VR512:$src)>;
 445 def : Pat<(v64i8  (bitconvert (v8i64  VR512:$src))), (v64i8  VR512:$src)>;
 446 def : Pat<(v64i8  (bitconvert (v16i32 VR512:$src))), (v64i8  VR512:$src)>;
 447 def : Pat<(v64i8  (bitconvert (v32i16 VR512:$src))), (v64i8  VR512:$src)>;
 448 def : Pat<(v64i8  (bitconvert (v8f64  VR512:$src))), (v64i8  VR512:$src)>;
 449 def : Pat<(v64i8  (bitconvert (v16f32 VR512:$src))), (v64i8  VR512:$src)>;
 450
 451 // Alias instruction that maps zero vector to pxor / xorp* for AVX-512.
 452 // This is expanded by ExpandPostRAPseudos to an xorps / vxorps, and then
 453 // swizzled by ExecutionDepsFix to pxor.
 454 // We set canFoldAsLoad because this can be converted to a constant-pool
 455 // load of an all-zeros value if folding it would be beneficial.
 456 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 457     isPseudo = 1, Predicates = [HasAVX512], SchedRW = [WriteZero] in {
 458 def AVX512_512_SET0 : I<0, Pseudo, (outs VR512:$dst), (ins), "",
 459                [(set VR512:$dst, (v16i32 immAllZerosV))]>;
 460 def AVX512_512_SETALLONES : I<0, Pseudo, (outs VR512:$dst), (ins), "",
 461                [(set VR512:$dst, (v16i32 immAllOnesV))]>;
 462 }
 463
 464 // Alias instructions that allow VPTERNLOG to be used with a mask to create
 465 // a mix of all ones and all zeros elements. This is done this way to force
 466 // the same register to be used as input for all three sources.
 467 let isPseudo = 1, Predicates = [HasAVX512] in {
 468 def AVX512_512_SEXT_MASK_32 : I<0, Pseudo, (outs VR512:$dst),
 469                                 (ins VK16WM:$mask), "",
 470                            [(set VR512:$dst, (vselect (v16i1 VK16WM:$mask),
 471                                                       (v16i32 immAllOnesV),
 472                                                       (v16i32 immAllZerosV)))]>;
 473 def AVX512_512_SEXT_MASK_64 : I<0, Pseudo, (outs VR512:$dst),
 474                                 (ins VK8WM:$mask), "",
 475                 [(set VR512:$dst, (vselect (v8i1 VK8WM:$mask),
 476                                            (bc_v8i64 (v16i32 immAllOnesV)),
 477                                            (bc_v8i64 (v16i32 immAllZerosV))))]>;
 478 }
 479
 480 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 481     isPseudo = 1, Predicates = [HasAVX512], SchedRW = [WriteZero] in {
 482 def AVX512_128_SET0 : I<0, Pseudo, (outs VR128X:$dst), (ins), "",
 483                [(set VR128X:$dst, (v4i32 immAllZerosV))]>;
 484 def AVX512_256_SET0 : I<0, Pseudo, (outs VR256X:$dst), (ins), "",
 485                [(set VR256X:$dst, (v8i32 immAllZerosV))]>;
 486 }
 487
 488 // Alias instructions that map fld0 to xorps for sse or vxorps for avx.
 489 // This is expanded by ExpandPostRAPseudos.
 490 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 491     isPseudo = 1, SchedRW = [WriteZero], Predicates = [HasAVX512] in {
 492   def AVX512_FsFLD0SS : I<0, Pseudo, (outs FR32X:$dst), (ins), "",
 493                           [(set FR32X:$dst, fp32imm0)]>;
 494   def AVX512_FsFLD0SD : I<0, Pseudo, (outs FR64X:$dst), (ins), "",
 495                           [(set FR64X:$dst, fpimm0)]>;
 496 }
 497
 498 //===----------------------------------------------------------------------===//
 499 // AVX-512 - VECTOR INSERT
 500 //
 501 multiclass vinsert_for_size<int Opcode, X86VectorVTInfo From, X86VectorVTInfo To,
 502                                                        PatFrag vinsert_insert> {
 503   let ExeDomain = To.ExeDomain in {
 504     defm rr : AVX512_maskable<Opcode, MRMSrcReg, To, (outs To.RC:$dst),
 505                    (ins To.RC:$src1, From.RC:$src2, u8imm:$src3),
 506                    "vinsert" # From.EltTypeName # "x" # From.NumElts,
 507                    "$src3, $src2, $src1", "$src1, $src2, $src3",
 508                    (vinsert_insert:$src3 (To.VT To.RC:$src1),
 509                                          (From.VT From.RC:$src2),
 510                                          (iPTR imm))>, AVX512AIi8Base, EVEX_4V;
 511
 512     defm rm : AVX512_maskable<Opcode, MRMSrcMem, To, (outs To.RC:$dst),
 513                    (ins To.RC:$src1, From.MemOp:$src2, u8imm:$src3),
 514                    "vinsert" # From.EltTypeName # "x" # From.NumElts,
 515                    "$src3, $src2, $src1", "$src1, $src2, $src3",
 516                    (vinsert_insert:$src3 (To.VT To.RC:$src1),
 517                                (From.VT (bitconvert (From.LdFrag addr:$src2))),
 518                                (iPTR imm))>, AVX512AIi8Base, EVEX_4V,
 519                    EVEX_CD8<From.EltSize, From.CD8TupleForm>;
 520   }
 521 }
 522
 523 multiclass vinsert_for_size_lowering<string InstrStr, X86VectorVTInfo From,
 524                        X86VectorVTInfo To, PatFrag vinsert_insert,
 525                        SDNodeXForm INSERT_get_vinsert_imm , list<Predicate> p> {
 526   let Predicates = p in {
 527     def : Pat<(vinsert_insert:$ins
 528                      (To.VT To.RC:$src1), (From.VT From.RC:$src2), (iPTR imm)),
 529               (To.VT (!cast<Instruction>(InstrStr#"rr")
 530                      To.RC:$src1, From.RC:$src2,
 531                      (INSERT_get_vinsert_imm To.RC:$ins)))>;
 532
 533     def : Pat<(vinsert_insert:$ins
 534                   (To.VT To.RC:$src1),
 535                   (From.VT (bitconvert (From.LdFrag addr:$src2))),
 536                   (iPTR imm)),
 537               (To.VT (!cast<Instruction>(InstrStr#"rm")
 538                   To.RC:$src1, addr:$src2,
 539                   (INSERT_get_vinsert_imm To.RC:$ins)))>;
 540   }
 541 }
 542
 543 multiclass vinsert_for_type<ValueType EltVT32, int Opcode128,
 544                             ValueType EltVT64, int Opcode256> {
 545
 546   let Predicates = [HasVLX] in
 547     defm NAME # "32x4Z256" : vinsert_for_size<Opcode128,
 548                                  X86VectorVTInfo< 4, EltVT32, VR128X>,
 549                                  X86VectorVTInfo< 8, EltVT32, VR256X>,
 550                                  vinsert128_insert>, EVEX_V256;
 551
 552   defm NAME # "32x4Z" : vinsert_for_size<Opcode128,
 553                                  X86VectorVTInfo< 4, EltVT32, VR128X>,
 554                                  X86VectorVTInfo<16, EltVT32, VR512>,
 555                                  vinsert128_insert>, EVEX_V512;
 556
 557   defm NAME # "64x4Z" : vinsert_for_size<Opcode256,
 558                                  X86VectorVTInfo< 4, EltVT64, VR256X>,
 559                                  X86VectorVTInfo< 8, EltVT64, VR512>,
 560                                  vinsert256_insert>, VEX_W, EVEX_V512;
 561
 562   let Predicates = [HasVLX, HasDQI] in
 563     defm NAME # "64x2Z256" : vinsert_for_size<Opcode128,
 564                                    X86VectorVTInfo< 2, EltVT64, VR128X>,
 565                                    X86VectorVTInfo< 4, EltVT64, VR256X>,
 566                                    vinsert128_insert>, VEX_W, EVEX_V256;
 567
 568   let Predicates = [HasDQI] in {
 569     defm NAME # "64x2Z" : vinsert_for_size<Opcode128,
 570                                  X86VectorVTInfo< 2, EltVT64, VR128X>,
 571                                  X86VectorVTInfo< 8, EltVT64, VR512>,
 572                                  vinsert128_insert>, VEX_W, EVEX_V512;
 573
 574     defm NAME # "32x8Z" : vinsert_for_size<Opcode256,
 575                                    X86VectorVTInfo< 8, EltVT32, VR256X>,
 576                                    X86VectorVTInfo<16, EltVT32, VR512>,
 577                                    vinsert256_insert>, EVEX_V512;
 578   }
 579 }
 580
 581 defm VINSERTF : vinsert_for_type<f32, 0x18, f64, 0x1a>;
 582 defm VINSERTI : vinsert_for_type<i32, 0x38, i64, 0x3a>;
 583
 584 // Codegen pattern with the alternative types,
 585 // Only add this if 64x2 and its friends are not supported natively via AVX512DQ.
 586 defm : vinsert_for_size_lowering<"VINSERTF32x4Z256", v2f64x_info, v4f64x_info,
 587               vinsert128_insert, INSERT_get_vinsert128_imm, [HasVLX, NoDQI]>;
 588 defm : vinsert_for_size_lowering<"VINSERTI32x4Z256", v2i64x_info, v4i64x_info,
 589               vinsert128_insert, INSERT_get_vinsert128_imm, [HasVLX, NoDQI]>;
 590
 591 defm : vinsert_for_size_lowering<"VINSERTF32x4Z", v2f64x_info, v8f64_info,
 592               vinsert128_insert, INSERT_get_vinsert128_imm, [HasAVX512, NoDQI]>;
 593 defm : vinsert_for_size_lowering<"VINSERTI32x4Z", v2i64x_info, v8i64_info,
 594               vinsert128_insert, INSERT_get_vinsert128_imm, [HasAVX512, NoDQI]>;
 595
 596 defm : vinsert_for_size_lowering<"VINSERTF64x4Z", v8f32x_info, v16f32_info,
 597               vinsert256_insert, INSERT_get_vinsert256_imm, [HasAVX512, NoDQI]>;
 598 defm : vinsert_for_size_lowering<"VINSERTI64x4Z", v8i32x_info, v16i32_info,
 599               vinsert256_insert, INSERT_get_vinsert256_imm, [HasAVX512, NoDQI]>;
 600
 601 // Codegen pattern with the alternative types insert VEC128 into VEC256
 602 defm : vinsert_for_size_lowering<"VINSERTI32x4Z256", v8i16x_info, v16i16x_info,
 603               vinsert128_insert, INSERT_get_vinsert128_imm, [HasVLX]>;
 604 defm : vinsert_for_size_lowering<"VINSERTI32x4Z256", v16i8x_info, v32i8x_info,
 605               vinsert128_insert, INSERT_get_vinsert128_imm, [HasVLX]>;
 606 // Codegen pattern with the alternative types insert VEC128 into VEC512
 607 defm : vinsert_for_size_lowering<"VINSERTI32x4Z", v8i16x_info, v32i16_info,
 608               vinsert128_insert, INSERT_get_vinsert128_imm, [HasAVX512]>;
 609 defm : vinsert_for_size_lowering<"VINSERTI32x4Z", v16i8x_info, v64i8_info,
 610                vinsert128_insert, INSERT_get_vinsert128_imm, [HasAVX512]>;
 611 // Codegen pattern with the alternative types insert VEC256 into VEC512
 612 defm : vinsert_for_size_lowering<"VINSERTI64x4Z", v16i16x_info, v32i16_info,
 613               vinsert256_insert, INSERT_get_vinsert256_imm, [HasAVX512]>;
 614 defm : vinsert_for_size_lowering<"VINSERTI64x4Z", v32i8x_info, v64i8_info,
 615               vinsert256_insert, INSERT_get_vinsert256_imm, [HasAVX512]>;
 616
 617 // vinsertps - insert f32 to XMM
 618 let ExeDomain = SSEPackedSingle in {
 619 def VINSERTPSZrr : AVX512AIi8<0x21, MRMSrcReg, (outs VR128X:$dst),
 620       (ins VR128X:$src1, VR128X:$src2, u8imm:$src3),
 621       "vinsertps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
 622       [(set VR128X:$dst, (X86insertps VR128X:$src1, VR128X:$src2, imm:$src3))]>,
 623       EVEX_4V;
 624 def VINSERTPSZrm: AVX512AIi8<0x21, MRMSrcMem, (outs VR128X:$dst),
 625       (ins VR128X:$src1, f32mem:$src2, u8imm:$src3),
 626       "vinsertps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
 627       [(set VR128X:$dst, (X86insertps VR128X:$src1,
 628                           (v4f32 (scalar_to_vector (loadf32 addr:$src2))),
 629                           imm:$src3))]>, EVEX_4V, EVEX_CD8<32, CD8VT1>;
 630 }
 631
 632 //===----------------------------------------------------------------------===//
 633 // AVX-512 VECTOR EXTRACT
 634 //---
 635
 636 multiclass vextract_for_size<int Opcode,
 637                              X86VectorVTInfo From, X86VectorVTInfo To,
 638                              PatFrag vextract_extract,
 639                              SDNodeXForm EXTRACT_get_vextract_imm> {
 640
 641   let hasSideEffects = 0, ExeDomain = To.ExeDomain in {
 642     // use AVX512_maskable_in_asm (AVX512_maskable can't be used due to
 643     // vextract_extract), we interesting only in patterns without mask,
 644     // intrinsics pattern match generated bellow.
 645     defm rr : AVX512_maskable_in_asm<Opcode, MRMDestReg, To, (outs To.RC:$dst),
 646                 (ins From.RC:$src1, u8imm:$idx),
 647                 "vextract" # To.EltTypeName # "x" # To.NumElts,
 648                 "$idx, $src1", "$src1, $idx",
 649                 [(set To.RC:$dst, (vextract_extract:$idx (From.VT From.RC:$src1),
 650                                                          (iPTR imm)))]>,
 651               AVX512AIi8Base, EVEX;
 652     def mr  : AVX512AIi8<Opcode, MRMDestMem, (outs),
 653                     (ins To.MemOp:$dst, From.RC:$src1, u8imm:$idx),
 654                     "vextract" # To.EltTypeName # "x" # To.NumElts #
 655                         "\t{$idx, $src1, $dst|$dst, $src1, $idx}",
 656                     [(store (To.VT (vextract_extract:$idx
 657                                     (From.VT From.RC:$src1), (iPTR imm))),
 658                              addr:$dst)]>, EVEX;
 659
 660     let mayStore = 1, hasSideEffects = 0 in
 661     def mrk : AVX512AIi8<Opcode, MRMDestMem, (outs),
 662                     (ins To.MemOp:$dst, To.KRCWM:$mask,
 663                                         From.RC:$src1, u8imm:$idx),
 664                      "vextract" # To.EltTypeName # "x" # To.NumElts #
 665                           "\t{$idx, $src1, $dst {${mask}}|"
 666                           "$dst {${mask}}, $src1, $idx}",
 667                     []>, EVEX_K, EVEX;
 668   }
 669
 670   def : Pat<(To.VT (vselect To.KRCWM:$mask,
 671                             (vextract_extract:$ext (From.VT From.RC:$src1),
 672                                                    (iPTR imm)),
 673                             To.RC:$src0)),
 674             (!cast<Instruction>(NAME # To.EltSize # "x" # To.NumElts #
 675                                 From.ZSuffix # "rrk")
 676                 To.RC:$src0, To.KRCWM:$mask, From.RC:$src1,
 677                 (EXTRACT_get_vextract_imm To.RC:$ext))>;
 678
 679   def : Pat<(To.VT (vselect To.KRCWM:$mask,
 680                             (vextract_extract:$ext (From.VT From.RC:$src1),
 681                                                    (iPTR imm)),
 682                             To.ImmAllZerosV)),
 683             (!cast<Instruction>(NAME # To.EltSize # "x" # To.NumElts #
 684                                 From.ZSuffix # "rrkz")
 685                 To.KRCWM:$mask, From.RC:$src1,
 686                 (EXTRACT_get_vextract_imm To.RC:$ext))>;
 687 }
 688
 689 // Codegen pattern for the alternative types
 690 multiclass vextract_for_size_lowering<string InstrStr, X86VectorVTInfo From,
 691                 X86VectorVTInfo To, PatFrag vextract_extract,
 692                 SDNodeXForm EXTRACT_get_vextract_imm, list<Predicate> p> {
 693   let Predicates = p in {
 694      def : Pat<(vextract_extract:$ext (From.VT From.RC:$src1), (iPTR imm)),
 695                (To.VT (!cast<Instruction>(InstrStr#"rr")
 696                           From.RC:$src1,
 697                           (EXTRACT_get_vextract_imm To.RC:$ext)))>;
 698      def : Pat<(store (To.VT (vextract_extract:$ext (From.VT From.RC:$src1),
 699                               (iPTR imm))), addr:$dst),
 700                (!cast<Instruction>(InstrStr#"mr") addr:$dst, From.RC:$src1,
 701                 (EXTRACT_get_vextract_imm To.RC:$ext))>;
 702   }
 703 }
 704
 705 multiclass vextract_for_type<ValueType EltVT32, int Opcode128,
 706                              ValueType EltVT64, int Opcode256> {
 707   defm NAME # "32x4Z" : vextract_for_size<Opcode128,
 708                                  X86VectorVTInfo<16, EltVT32, VR512>,
 709                                  X86VectorVTInfo< 4, EltVT32, VR128X>,
 710                                  vextract128_extract,
 711                                  EXTRACT_get_vextract128_imm>,
 712                                      EVEX_V512, EVEX_CD8<32, CD8VT4>;
 713   defm NAME # "64x4Z" : vextract_for_size<Opcode256,
 714                                  X86VectorVTInfo< 8, EltVT64, VR512>,
 715                                  X86VectorVTInfo< 4, EltVT64, VR256X>,
 716                                  vextract256_extract,
 717                                  EXTRACT_get_vextract256_imm>,
 718                                      VEX_W, EVEX_V512, EVEX_CD8<64, CD8VT4>;
 719   let Predicates = [HasVLX] in
 720     defm NAME # "32x4Z256" : vextract_for_size<Opcode128,
 721                                  X86VectorVTInfo< 8, EltVT32, VR256X>,
 722                                  X86VectorVTInfo< 4, EltVT32, VR128X>,
 723                                  vextract128_extract,
 724                                  EXTRACT_get_vextract128_imm>,
 725                                      EVEX_V256, EVEX_CD8<32, CD8VT4>;
 726   let Predicates = [HasVLX, HasDQI] in
 727     defm NAME # "64x2Z256" : vextract_for_size<Opcode128,
 728                                  X86VectorVTInfo< 4, EltVT64, VR256X>,
 729                                  X86VectorVTInfo< 2, EltVT64, VR128X>,
 730                                  vextract128_extract,
 731                                  EXTRACT_get_vextract128_imm>,
 732                                      VEX_W, EVEX_V256, EVEX_CD8<64, CD8VT2>;
 733   let Predicates = [HasDQI] in {
 734     defm NAME # "64x2Z" : vextract_for_size<Opcode128,
 735                                  X86VectorVTInfo< 8, EltVT64, VR512>,
 736                                  X86VectorVTInfo< 2, EltVT64, VR128X>,
 737                                  vextract128_extract,
 738                                  EXTRACT_get_vextract128_imm>,
 739                                      VEX_W, EVEX_V512, EVEX_CD8<64, CD8VT2>;
 740     defm NAME # "32x8Z" : vextract_for_size<Opcode256,
 741                                  X86VectorVTInfo<16, EltVT32, VR512>,
 742                                  X86VectorVTInfo< 8, EltVT32, VR256X>,
 743                                  vextract256_extract,
 744                                  EXTRACT_get_vextract256_imm>,
 745                                      EVEX_V512, EVEX_CD8<32, CD8VT8>;
 746   }
 747 }
 748
 749 defm VEXTRACTF : vextract_for_type<f32, 0x19, f64, 0x1b>;
 750 defm VEXTRACTI : vextract_for_type<i32, 0x39, i64, 0x3b>;
 751
 752 // extract_subvector codegen patterns with the alternative types.
 753 // Only add this if 64x2 and its friends are not supported natively via AVX512DQ.
 754 defm : vextract_for_size_lowering<"VEXTRACTF32x4Z", v8f64_info, v2f64x_info,
 755           vextract128_extract, EXTRACT_get_vextract128_imm, [HasAVX512, NoDQI]>;
 756 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z", v8i64_info, v2i64x_info,
 757           vextract128_extract, EXTRACT_get_vextract128_imm, [HasAVX512, NoDQI]>;
 758
 759 defm : vextract_for_size_lowering<"VEXTRACTF64x4Z", v16f32_info, v8f32x_info,
 760           vextract256_extract, EXTRACT_get_vextract256_imm, [HasAVX512, NoDQI]>;
 761 defm : vextract_for_size_lowering<"VEXTRACTI64x4Z", v16i32_info, v8i32x_info,
 762           vextract256_extract, EXTRACT_get_vextract256_imm, [HasAVX512, NoDQI]>;
 763
 764 defm : vextract_for_size_lowering<"VEXTRACTF32x4Z256", v4f64x_info, v2f64x_info,
 765           vextract128_extract, EXTRACT_get_vextract128_imm, [HasVLX, NoDQI]>;
 766 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z256", v4i64x_info, v2i64x_info,
 767           vextract128_extract, EXTRACT_get_vextract128_imm, [HasVLX, NoDQI]>;
 768
 769 // Codegen pattern with the alternative types extract VEC128 from VEC256
 770 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z256", v16i16x_info, v8i16x_info,
 771           vextract128_extract, EXTRACT_get_vextract128_imm, [HasVLX]>;
 772 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z256", v32i8x_info, v16i8x_info,
 773           vextract128_extract, EXTRACT_get_vextract128_imm, [HasVLX]>;
 774
 775 // Codegen pattern with the alternative types extract VEC128 from VEC512
 776 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z", v32i16_info, v8i16x_info,
 777                  vextract128_extract, EXTRACT_get_vextract128_imm, [HasAVX512]>;
 778 defm : vextract_for_size_lowering<"VEXTRACTI32x4Z", v64i8_info, v16i8x_info,
 779                  vextract128_extract, EXTRACT_get_vextract128_imm, [HasAVX512]>;
 780 // Codegen pattern with the alternative types extract VEC256 from VEC512
 781 defm : vextract_for_size_lowering<"VEXTRACTI64x4Z", v32i16_info, v16i16x_info,
 782                  vextract256_extract, EXTRACT_get_vextract256_imm, [HasAVX512]>;
 783 defm : vextract_for_size_lowering<"VEXTRACTI64x4Z", v64i8_info, v32i8x_info,
 784                  vextract256_extract, EXTRACT_get_vextract256_imm, [HasAVX512]>;
 785
 786 // A 128-bit subvector extract from the first 256-bit vector position
 787 // is a subregister copy that needs no instruction.
 788 def : Pat<(v2i64 (extract_subvector (v8i64 VR512:$src), (iPTR 0))),
 789           (v2i64 (EXTRACT_SUBREG (v8i64 VR512:$src), sub_xmm))>;
 790 def : Pat<(v2f64 (extract_subvector (v8f64 VR512:$src), (iPTR 0))),
 791           (v2f64 (EXTRACT_SUBREG (v8f64 VR512:$src), sub_xmm))>;
 792 def : Pat<(v4i32 (extract_subvector (v16i32 VR512:$src), (iPTR 0))),
 793           (v4i32 (EXTRACT_SUBREG (v16i32 VR512:$src), sub_xmm))>;
 794 def : Pat<(v4f32 (extract_subvector (v16f32 VR512:$src), (iPTR 0))),
 795           (v4f32 (EXTRACT_SUBREG (v16f32 VR512:$src), sub_xmm))>;
 796 def : Pat<(v8i16 (extract_subvector (v32i16 VR512:$src), (iPTR 0))),
 797           (v8i16 (EXTRACT_SUBREG (v32i16 VR512:$src), sub_xmm))>;
 798 def : Pat<(v16i8 (extract_subvector (v64i8 VR512:$src), (iPTR 0))),
 799           (v16i8 (EXTRACT_SUBREG (v64i8 VR512:$src), sub_xmm))>;
 800
 801 // A 256-bit subvector extract from the first 256-bit vector position
 802 // is a subregister copy that needs no instruction.
 803 def : Pat<(v4i64 (extract_subvector (v8i64 VR512:$src), (iPTR 0))),
 804           (v4i64 (EXTRACT_SUBREG (v8i64 VR512:$src), sub_ymm))>;
 805 def : Pat<(v4f64 (extract_subvector (v8f64 VR512:$src), (iPTR 0))),
 806           (v4f64 (EXTRACT_SUBREG (v8f64 VR512:$src), sub_ymm))>;
 807 def : Pat<(v8i32 (extract_subvector (v16i32 VR512:$src), (iPTR 0))),
 808           (v8i32 (EXTRACT_SUBREG (v16i32 VR512:$src), sub_ymm))>;
 809 def : Pat<(v8f32 (extract_subvector (v16f32 VR512:$src), (iPTR 0))),
 810           (v8f32 (EXTRACT_SUBREG (v16f32 VR512:$src), sub_ymm))>;
 811 def : Pat<(v16i16 (extract_subvector (v32i16 VR512:$src), (iPTR 0))),
 812           (v16i16 (EXTRACT_SUBREG (v32i16 VR512:$src), sub_ymm))>;
 813 def : Pat<(v32i8 (extract_subvector (v64i8 VR512:$src), (iPTR 0))),
 814           (v32i8 (EXTRACT_SUBREG (v64i8 VR512:$src), sub_ymm))>;
 815
 816 let AddedComplexity = 25 in { // to give priority over vinsertf128rm
 817 // A 128-bit subvector insert to the first 512-bit vector position
 818 // is a subregister copy that needs no instruction.
 819 def : Pat<(v8i64 (insert_subvector undef, (v2i64 VR128X:$src), (iPTR 0))),
 820           (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 821 def : Pat<(v8f64 (insert_subvector undef, (v2f64 VR128X:$src), (iPTR 0))),
 822           (INSERT_SUBREG (v8f64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 823 def : Pat<(v16i32 (insert_subvector undef, (v4i32 VR128X:$src), (iPTR 0))),
 824           (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 825 def : Pat<(v16f32 (insert_subvector undef, (v4f32 VR128X:$src), (iPTR 0))),
 826           (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 827 def : Pat<(v32i16 (insert_subvector undef, (v8i16 VR128X:$src), (iPTR 0))),
 828           (INSERT_SUBREG (v32i16 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 829 def : Pat<(v64i8 (insert_subvector undef, (v16i8 VR128X:$src), (iPTR 0))),
 830           (INSERT_SUBREG (v64i8 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)>;
 831
 832 // A 256-bit subvector insert to the first 512-bit vector position
 833 // is a subregister copy that needs no instruction.
 834 def : Pat<(v8i64 (insert_subvector undef, (v4i64 VR256X:$src), (iPTR 0))),
 835           (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 836 def : Pat<(v8f64 (insert_subvector undef, (v4f64 VR256X:$src), (iPTR 0))),
 837           (INSERT_SUBREG (v8f64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 838 def : Pat<(v16i32 (insert_subvector undef, (v8i32 VR256X:$src), (iPTR 0))),
 839           (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 840 def : Pat<(v16f32 (insert_subvector undef, (v8f32 VR256X:$src), (iPTR 0))),
 841           (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 842 def : Pat<(v32i16 (insert_subvector undef, (v16i16 VR256X:$src), (iPTR 0))),
 843           (INSERT_SUBREG (v32i16 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 844 def : Pat<(v64i8 (insert_subvector undef, (v32i8 VR256X:$src), (iPTR 0))),
 845           (INSERT_SUBREG (v64i8 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)>;
 846 }
 847
 848 // vextractps - extract 32 bits from XMM
 849 def VEXTRACTPSZrr : AVX512AIi8<0x17, MRMDestReg, (outs GR32:$dst),
 850       (ins VR128X:$src1, u8imm:$src2),
 851       "vextractps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 852       [(set GR32:$dst, (extractelt (bc_v4i32 (v4f32 VR128X:$src1)), imm:$src2))]>,
 853       EVEX;
 854
 855 def VEXTRACTPSZmr : AVX512AIi8<0x17, MRMDestMem, (outs),
 856       (ins f32mem:$dst, VR128X:$src1, u8imm:$src2),
 857       "vextractps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 858       [(store (extractelt (bc_v4i32 (v4f32 VR128X:$src1)), imm:$src2),
 859                           addr:$dst)]>, EVEX, EVEX_CD8<32, CD8VT1>;
 860
 861 //===---------------------------------------------------------------------===//
 862 // AVX-512 BROADCAST
 863 //---
 864 // broadcast with a scalar argument.
 865 multiclass avx512_broadcast_scalar<bits<8> opc, string OpcodeStr,
 866                             X86VectorVTInfo DestInfo, X86VectorVTInfo SrcInfo> {
 867   def : Pat<(DestInfo.VT (X86VBroadcast SrcInfo.FRC:$src)),
 868             (!cast<Instruction>(NAME#DestInfo.ZSuffix#r)
 869              (COPY_TO_REGCLASS SrcInfo.FRC:$src, SrcInfo.RC))>;
 870   def : Pat<(DestInfo.VT (vselect DestInfo.KRCWM:$mask,
 871                                   (X86VBroadcast SrcInfo.FRC:$src),
 872                                   DestInfo.RC:$src0)),
 873             (!cast<Instruction>(NAME#DestInfo.ZSuffix#rk)
 874              DestInfo.RC:$src0, DestInfo.KRCWM:$mask,
 875              (COPY_TO_REGCLASS SrcInfo.FRC:$src, SrcInfo.RC))>;
 876   def : Pat<(DestInfo.VT (vselect DestInfo.KRCWM:$mask,
 877                                   (X86VBroadcast SrcInfo.FRC:$src),
 878                                   DestInfo.ImmAllZerosV)),
 879             (!cast<Instruction>(NAME#DestInfo.ZSuffix#rkz)
 880              DestInfo.KRCWM:$mask, (COPY_TO_REGCLASS SrcInfo.FRC:$src, SrcInfo.RC))>;
 881 }
 882
 883 multiclass avx512_broadcast_rm<bits<8> opc, string OpcodeStr,
 884                             X86VectorVTInfo DestInfo, X86VectorVTInfo SrcInfo> {
 885   let ExeDomain = DestInfo.ExeDomain in {
 886   defm r : AVX512_maskable<opc, MRMSrcReg, DestInfo, (outs DestInfo.RC:$dst),
 887                    (ins SrcInfo.RC:$src), OpcodeStr, "$src", "$src",
 888                    (DestInfo.VT (X86VBroadcast (SrcInfo.VT SrcInfo.RC:$src)))>,
 889                    T8PD, EVEX;
 890   defm m : AVX512_maskable<opc, MRMSrcMem, DestInfo, (outs DestInfo.RC:$dst),
 891                    (ins SrcInfo.ScalarMemOp:$src), OpcodeStr, "$src", "$src",
 892                    (DestInfo.VT (X86VBroadcast
 893                                    (SrcInfo.ScalarLdFrag addr:$src)))>,
 894                    T8PD, EVEX, EVEX_CD8<SrcInfo.EltSize, CD8VT1>;
 895   }
 896
 897   def : Pat<(DestInfo.VT (X86VBroadcast
 898                           (SrcInfo.VT (scalar_to_vector
 899                                        (SrcInfo.ScalarLdFrag addr:$src))))),
 900             (!cast<Instruction>(NAME#DestInfo.ZSuffix#m) addr:$src)>;
 901   def : Pat<(DestInfo.VT (vselect DestInfo.KRCWM:$mask,
 902                           (X86VBroadcast
 903                            (SrcInfo.VT (scalar_to_vector
 904                                         (SrcInfo.ScalarLdFrag addr:$src)))),
 905                           DestInfo.RC:$src0)),
 906             (!cast<Instruction>(NAME#DestInfo.ZSuffix#mk)
 907              DestInfo.RC:$src0, DestInfo.KRCWM:$mask, addr:$src)>;
 908   def : Pat<(DestInfo.VT (vselect DestInfo.KRCWM:$mask,
 909                           (X86VBroadcast
 910                            (SrcInfo.VT (scalar_to_vector
 911                                         (SrcInfo.ScalarLdFrag addr:$src)))),
 912                           DestInfo.ImmAllZerosV)),
 913             (!cast<Instruction>(NAME#DestInfo.ZSuffix#mkz)
 914              DestInfo.KRCWM:$mask, addr:$src)>;
 915 }
 916
 917 multiclass avx512_fp_broadcast_sd<bits<8> opc, string OpcodeStr,
 918                                                        AVX512VLVectorVTInfo _> {
 919   let Predicates = [HasAVX512] in
 920     defm Z  : avx512_broadcast_rm<opc, OpcodeStr, _.info512, _.info128>,
 921               avx512_broadcast_scalar<opc, OpcodeStr, _.info512, _.info128>,
 922                                EVEX_V512;
 923
 924   let Predicates = [HasVLX] in {
 925     defm Z256  : avx512_broadcast_rm<opc, OpcodeStr, _.info256, _.info128>,
 926                  avx512_broadcast_scalar<opc, OpcodeStr, _.info256, _.info128>,
 927                              EVEX_V256;
 928   }
 929 }
 930
 931 multiclass avx512_fp_broadcast_ss<bits<8> opc, string OpcodeStr,
 932                                                        AVX512VLVectorVTInfo _> {
 933   let Predicates = [HasAVX512] in
 934     defm Z  : avx512_broadcast_rm<opc, OpcodeStr, _.info512, _.info128>,
 935               avx512_broadcast_scalar<opc, OpcodeStr, _.info512, _.info128>,
 936                                EVEX_V512;
 937
 938   let Predicates = [HasVLX] in {
 939     defm Z256  : avx512_broadcast_rm<opc, OpcodeStr, _.info256, _.info128>,
 940                  avx512_broadcast_scalar<opc, OpcodeStr, _.info256, _.info128>,
 941                              EVEX_V256;
 942     defm Z128  : avx512_broadcast_rm<opc, OpcodeStr, _.info128, _.info128>,
 943                  avx512_broadcast_scalar<opc, OpcodeStr, _.info128, _.info128>,
 944                              EVEX_V128;
 945   }
 946 }
 947 defm VBROADCASTSS  : avx512_fp_broadcast_ss<0x18, "vbroadcastss",
 948                                        avx512vl_f32_info>;
 949 defm VBROADCASTSD  : avx512_fp_broadcast_sd<0x19, "vbroadcastsd",
 950                                        avx512vl_f64_info>, VEX_W;
 951
 952 def : Pat<(int_x86_avx512_vbroadcast_ss_512 addr:$src),
 953           (VBROADCASTSSZm addr:$src)>;
 954 def : Pat<(int_x86_avx512_vbroadcast_sd_512 addr:$src),
 955           (VBROADCASTSDZm addr:$src)>;
 956
 957 multiclass avx512_int_broadcast_reg<bits<8> opc, X86VectorVTInfo _,
 958                                     SDPatternOperator OpNode,
 959                                     RegisterClass SrcRC> {
 960   let ExeDomain = _.ExeDomain in
 961   defm r : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
 962                          (ins SrcRC:$src),
 963                          "vpbroadcast"##_.Suffix, "$src", "$src",
 964                          (_.VT (OpNode SrcRC:$src))>, T8PD, EVEX;
 965 }
 966
 967 multiclass avx512_int_broadcast_reg_vl<bits<8> opc, AVX512VLVectorVTInfo _,
 968                                        SDPatternOperator OpNode,
 969                                        RegisterClass SrcRC, Predicate prd> {
 970   let Predicates = [prd] in
 971     defm Z : avx512_int_broadcast_reg<opc, _.info512, OpNode, SrcRC>, EVEX_V512;
 972   let Predicates = [prd, HasVLX] in {
 973     defm Z256 : avx512_int_broadcast_reg<opc, _.info256, OpNode, SrcRC>, EVEX_V256;
 974     defm Z128 : avx512_int_broadcast_reg<opc, _.info128, OpNode, SrcRC>, EVEX_V128;
 975   }
 976 }
 977
 978 let isCodeGenOnly = 1 in {
 979 defm VPBROADCASTBr : avx512_int_broadcast_reg_vl<0x7A, avx512vl_i8_info,
 980                                                  X86VBroadcast, GR8, HasBWI>;
 981 defm VPBROADCASTWr : avx512_int_broadcast_reg_vl<0x7B, avx512vl_i16_info,
 982                                                  X86VBroadcast, GR16, HasBWI>;
 983 }
 984 let isAsmParserOnly = 1 in {
 985   defm VPBROADCASTBr_Alt : avx512_int_broadcast_reg_vl<0x7A, avx512vl_i8_info,
 986                                                        null_frag, GR32, HasBWI>;
 987   defm VPBROADCASTWr_Alt : avx512_int_broadcast_reg_vl<0x7B, avx512vl_i16_info,
 988                                                        null_frag, GR32, HasBWI>;
 989 }
 990 defm VPBROADCASTDr : avx512_int_broadcast_reg_vl<0x7C, avx512vl_i32_info,
 991                                                  X86VBroadcast, GR32, HasAVX512>;
 992 defm VPBROADCASTQr : avx512_int_broadcast_reg_vl<0x7C, avx512vl_i64_info,
 993                                                  X86VBroadcast, GR64, HasAVX512>, VEX_W;
 994
 995 def : Pat <(v16i32 (X86vzext VK16WM:$mask)),
 996            (VPBROADCASTDrZrkz VK16WM:$mask, (i32 (MOV32ri 0x1)))>;
 997 def : Pat <(v8i64 (X86vzext VK8WM:$mask)),
 998            (VPBROADCASTQrZrkz VK8WM:$mask, (i64 (MOV64ri 0x1)))>;
 999
1000 // Provide aliases for broadcast from the same register class that
1001 // automatically does the extract.
1002 multiclass avx512_int_broadcast_rm_lowering<X86VectorVTInfo DestInfo,
1003                                             X86VectorVTInfo SrcInfo> {
1004   def : Pat<(DestInfo.VT (X86VBroadcast (SrcInfo.VT SrcInfo.RC:$src))),
1005             (!cast<Instruction>(NAME#DestInfo.ZSuffix#"r")
1006                 (EXTRACT_SUBREG (SrcInfo.VT SrcInfo.RC:$src), sub_xmm))>;
1007 }
1008
1009 multiclass avx512_int_broadcast_rm_vl<bits<8> opc, string OpcodeStr,
1010                                         AVX512VLVectorVTInfo _, Predicate prd> {
1011   let Predicates = [prd] in {
1012     defm Z :   avx512_broadcast_rm<opc, OpcodeStr, _.info512, _.info128>,
1013                avx512_int_broadcast_rm_lowering<_.info512, _.info256>,
1014                                   EVEX_V512;
1015     // Defined separately to avoid redefinition.
1016     defm Z_Alt : avx512_int_broadcast_rm_lowering<_.info512, _.info512>;
1017   }
1018   let Predicates = [prd, HasVLX] in {
1019     defm Z256 : avx512_broadcast_rm<opc, OpcodeStr, _.info256, _.info128>,
1020                 avx512_int_broadcast_rm_lowering<_.info256, _.info256>,
1021                                  EVEX_V256;
1022     defm Z128 : avx512_broadcast_rm<opc, OpcodeStr, _.info128, _.info128>,
1023                                  EVEX_V128;
1024   }
1025 }
1026
1027 defm VPBROADCASTB  : avx512_int_broadcast_rm_vl<0x78, "vpbroadcastb",
1028                                            avx512vl_i8_info, HasBWI>;
1029 defm VPBROADCASTW  : avx512_int_broadcast_rm_vl<0x79, "vpbroadcastw",
1030                                            avx512vl_i16_info, HasBWI>;
1031 defm VPBROADCASTD  : avx512_int_broadcast_rm_vl<0x58, "vpbroadcastd",
1032                                            avx512vl_i32_info, HasAVX512>;
1033 defm VPBROADCASTQ  : avx512_int_broadcast_rm_vl<0x59, "vpbroadcastq",
1034                                            avx512vl_i64_info, HasAVX512>, VEX_W;
1035
1036 multiclass avx512_subvec_broadcast_rm<bits<8> opc, string OpcodeStr,
1037                           X86VectorVTInfo _Dst, X86VectorVTInfo _Src> {
1038   defm rm : AVX512_maskable<opc, MRMSrcMem, _Dst, (outs _Dst.RC:$dst),
1039                            (ins _Src.MemOp:$src), OpcodeStr, "$src", "$src",
1040                            (_Dst.VT (X86SubVBroadcast
1041                              (_Src.VT (bitconvert (_Src.LdFrag addr:$src)))))>,
1042                             AVX5128IBase, EVEX;
1043 }
1044
1045 let Predicates = [HasAVX512] in {
1046   // 32-bit targets will fail to load a i64 directly but can use ZEXT_LOAD.
1047   def : Pat<(v8i64 (X86VBroadcast (v8i64 (X86vzload addr:$src)))),
1048             (VPBROADCASTQZm addr:$src)>;
1049 }
1050
1051 let Predicates = [HasVLX, HasBWI] in {
1052   // 32-bit targets will fail to load a i64 directly but can use ZEXT_LOAD.
1053   def : Pat<(v2i64 (X86VBroadcast (v2i64 (X86vzload addr:$src)))),
1054             (VPBROADCASTQZ128m addr:$src)>;
1055   def : Pat<(v4i64 (X86VBroadcast (v4i64 (X86vzload addr:$src)))),
1056             (VPBROADCASTQZ256m addr:$src)>;
1057   // loadi16 is tricky to fold, because !isTypeDesirableForOp, justifiably.
1058   // This means we'll encounter truncated i32 loads; match that here.
1059   def : Pat<(v8i16 (X86VBroadcast (i16 (trunc (i32 (load addr:$src)))))),
1060             (VPBROADCASTWZ128m addr:$src)>;
1061   def : Pat<(v16i16 (X86VBroadcast (i16 (trunc (i32 (load addr:$src)))))),
1062             (VPBROADCASTWZ256m addr:$src)>;
1063   def : Pat<(v8i16 (X86VBroadcast
1064               (i16 (trunc (i32 (zextloadi16 addr:$src)))))),
1065             (VPBROADCASTWZ128m addr:$src)>;
1066   def : Pat<(v16i16 (X86VBroadcast
1067               (i16 (trunc (i32 (zextloadi16 addr:$src)))))),
1068             (VPBROADCASTWZ256m addr:$src)>;
1069 }
1070
1071 //===----------------------------------------------------------------------===//
1072 // AVX-512 BROADCAST SUBVECTORS
1073 //
1074
1075 defm VBROADCASTI32X4 : avx512_subvec_broadcast_rm<0x5a, "vbroadcasti32x4",
1076                        v16i32_info, v4i32x_info>,
1077                        EVEX_V512, EVEX_CD8<32, CD8VT4>;
1078 defm VBROADCASTF32X4 : avx512_subvec_broadcast_rm<0x1a, "vbroadcastf32x4",
1079                        v16f32_info, v4f32x_info>,
1080                        EVEX_V512, EVEX_CD8<32, CD8VT4>;
1081 defm VBROADCASTI64X4 : avx512_subvec_broadcast_rm<0x5b, "vbroadcasti64x4",
1082                        v8i64_info, v4i64x_info>, VEX_W,
1083                        EVEX_V512, EVEX_CD8<64, CD8VT4>;
1084 defm VBROADCASTF64X4 : avx512_subvec_broadcast_rm<0x1b, "vbroadcastf64x4",
1085                        v8f64_info, v4f64x_info>, VEX_W,
1086                        EVEX_V512, EVEX_CD8<64, CD8VT4>;
1087
1088 let Predicates = [HasAVX512] in {
1089 def : Pat<(v32i16 (X86SubVBroadcast (bc_v16i16 (loadv4i64 addr:$src)))),
1090           (VBROADCASTI64X4rm addr:$src)>;
1091 def : Pat<(v64i8 (X86SubVBroadcast (bc_v32i8 (loadv4i64 addr:$src)))),
1092           (VBROADCASTI64X4rm addr:$src)>;
1093
1094 // Provide fallback in case the load node that is used in the patterns above
1095 // is used by additional users, which prevents the pattern selection.
1096 def : Pat<(v8f64 (X86SubVBroadcast (v4f64 VR256X:$src))),
1097           (VINSERTF64x4Zrr (INSERT_SUBREG (v8f64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1098                            (v4f64 VR256X:$src), 1)>;
1099 def : Pat<(v8i64 (X86SubVBroadcast (v4i64 VR256X:$src))),
1100           (VINSERTI64x4Zrr (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1101                            (v4i64 VR256X:$src), 1)>;
1102 def : Pat<(v32i16 (X86SubVBroadcast (v16i16 VR256X:$src))),
1103           (VINSERTI64x4Zrr (INSERT_SUBREG (v32i16 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1104                            (v16i16 VR256X:$src), 1)>;
1105 def : Pat<(v64i8 (X86SubVBroadcast (v32i8 VR256X:$src))),
1106           (VINSERTI64x4Zrr (INSERT_SUBREG (v64i8 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1107                            (v32i8 VR256X:$src), 1)>;
1108
1109 def : Pat<(v32i16 (X86SubVBroadcast (bc_v8i16 (loadv2i64 addr:$src)))),
1110           (VBROADCASTI32X4rm addr:$src)>;
1111 def : Pat<(v64i8 (X86SubVBroadcast (bc_v16i8 (loadv2i64 addr:$src)))),
1112           (VBROADCASTI32X4rm addr:$src)>;
1113 }
1114
1115 let Predicates = [HasVLX] in {
1116 defm VBROADCASTI32X4Z256 : avx512_subvec_broadcast_rm<0x5a, "vbroadcasti32x4",
1117                            v8i32x_info, v4i32x_info>,
1118                            EVEX_V256, EVEX_CD8<32, CD8VT4>;
1119 defm VBROADCASTF32X4Z256 : avx512_subvec_broadcast_rm<0x1a, "vbroadcastf32x4",
1120                            v8f32x_info, v4f32x_info>,
1121                            EVEX_V256, EVEX_CD8<32, CD8VT4>;
1122
1123 def : Pat<(v16i16 (X86SubVBroadcast (bc_v8i16 (loadv2i64 addr:$src)))),
1124           (VBROADCASTI32X4Z256rm addr:$src)>;
1125 def : Pat<(v32i8 (X86SubVBroadcast (bc_v16i8 (loadv2i64 addr:$src)))),
1126           (VBROADCASTI32X4Z256rm addr:$src)>;
1127
1128 // Provide fallback in case the load node that is used in the patterns above
1129 // is used by additional users, which prevents the pattern selection.
1130 def : Pat<(v8f32 (X86SubVBroadcast (v4f32 VR128X:$src))),
1131           (VINSERTF32x4Z256rr (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1132                               (v4f32 VR128X:$src), 1)>;
1133 def : Pat<(v8i32 (X86SubVBroadcast (v4i32 VR128X:$src))),
1134           (VINSERTI32x4Z256rr (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1135                               (v4i32 VR128X:$src), 1)>;
1136 def : Pat<(v16i16 (X86SubVBroadcast (v8i16 VR128X:$src))),
1137           (VINSERTI32x4Z256rr (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1138                               (v8i16 VR128X:$src), 1)>;
1139 def : Pat<(v32i8 (X86SubVBroadcast (v16i8 VR128X:$src))),
1140           (VINSERTI32x4Z256rr (INSERT_SUBREG (v32i8 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1141                               (v16i8 VR128X:$src), 1)>;
1142 }
1143
1144 let Predicates = [HasVLX, HasDQI] in {
1145 defm VBROADCASTI64X2Z128 : avx512_subvec_broadcast_rm<0x5a, "vbroadcasti64x2",
1146                            v4i64x_info, v2i64x_info>, VEX_W,
1147                            EVEX_V256, EVEX_CD8<64, CD8VT2>;
1148 defm VBROADCASTF64X2Z128 : avx512_subvec_broadcast_rm<0x1a, "vbroadcastf64x2",
1149                            v4f64x_info, v2f64x_info>, VEX_W,
1150                            EVEX_V256, EVEX_CD8<64, CD8VT2>;
1151
1152 // Provide fallback in case the load node that is used in the patterns above
1153 // is used by additional users, which prevents the pattern selection.
1154 def : Pat<(v4f64 (X86SubVBroadcast (v2f64 VR128X:$src))),
1155           (VINSERTF64x2Z256rr (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1156                               (v2f64 VR128X:$src), 1)>;
1157 def : Pat<(v4i64 (X86SubVBroadcast (v2i64 VR128X:$src))),
1158           (VINSERTI64x2Z256rr (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1159                               (v2i64 VR128X:$src), 1)>;
1160 }
1161
1162 let Predicates = [HasVLX, NoDQI] in {
1163 def : Pat<(v4f64 (X86SubVBroadcast (loadv2f64 addr:$src))),
1164           (VBROADCASTF32X4Z256rm addr:$src)>;
1165 def : Pat<(v4i64 (X86SubVBroadcast (loadv2i64 addr:$src))),
1166           (VBROADCASTI32X4Z256rm addr:$src)>;
1167
1168 // Provide fallback in case the load node that is used in the patterns above
1169 // is used by additional users, which prevents the pattern selection.
1170 def : Pat<(v4f64 (X86SubVBroadcast (v2f64 VR128X:$src))),
1171           (VINSERTF32x4Z256rr (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1172                               (v2f64 VR128X:$src), 1)>;
1173 def : Pat<(v4i64 (X86SubVBroadcast (v2i64 VR128X:$src))),
1174           (VINSERTI32x4Z256rr (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
1175                               (v2i64 VR128X:$src), 1)>;
1176 }
1177
1178 let Predicates = [HasAVX512, NoDQI] in {
1179 def : Pat<(v8f64 (X86SubVBroadcast (loadv2f64 addr:$src))),
1180           (VBROADCASTF32X4rm addr:$src)>;
1181 def : Pat<(v8i64 (X86SubVBroadcast (loadv2i64 addr:$src))),
1182           (VBROADCASTI32X4rm addr:$src)>;
1183
1184 def : Pat<(v16f32 (X86SubVBroadcast (loadv8f32 addr:$src))),
1185           (VBROADCASTF64X4rm addr:$src)>;
1186 def : Pat<(v16i32 (X86SubVBroadcast (bc_v8i32 (loadv4i64 addr:$src)))),
1187           (VBROADCASTI64X4rm addr:$src)>;
1188
1189 // Provide fallback in case the load node that is used in the patterns above
1190 // is used by additional users, which prevents the pattern selection.
1191 def : Pat<(v16f32 (X86SubVBroadcast (v8f32 VR256X:$src))),
1192           (VINSERTF64x4Zrr (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1193                            (v8f32 VR256X:$src), 1)>;
1194 def : Pat<(v16i32 (X86SubVBroadcast (v8i32 VR256X:$src))),
1195           (VINSERTI64x4Zrr (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1196                            (v8i32 VR256X:$src), 1)>;
1197 }
1198
1199 let Predicates = [HasDQI] in {
1200 defm VBROADCASTI64X2 : avx512_subvec_broadcast_rm<0x5a, "vbroadcasti64x2",
1201                        v8i64_info, v2i64x_info>, VEX_W,
1202                        EVEX_V512, EVEX_CD8<64, CD8VT2>;
1203 defm VBROADCASTI32X8 : avx512_subvec_broadcast_rm<0x5b, "vbroadcasti32x8",
1204                        v16i32_info, v8i32x_info>,
1205                        EVEX_V512, EVEX_CD8<32, CD8VT8>;
1206 defm VBROADCASTF64X2 : avx512_subvec_broadcast_rm<0x1a, "vbroadcastf64x2",
1207                        v8f64_info, v2f64x_info>, VEX_W,
1208                        EVEX_V512, EVEX_CD8<64, CD8VT2>;
1209 defm VBROADCASTF32X8 : avx512_subvec_broadcast_rm<0x1b, "vbroadcastf32x8",
1210                        v16f32_info, v8f32x_info>,
1211                        EVEX_V512, EVEX_CD8<32, CD8VT8>;
1212
1213 // Provide fallback in case the load node that is used in the patterns above
1214 // is used by additional users, which prevents the pattern selection.
1215 def : Pat<(v16f32 (X86SubVBroadcast (v8f32 VR256X:$src))),
1216           (VINSERTF32x8Zrr (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1217                            (v8f32 VR256X:$src), 1)>;
1218 def : Pat<(v16i32 (X86SubVBroadcast (v8i32 VR256X:$src))),
1219           (VINSERTI32x8Zrr (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm),
1220                            (v8i32 VR256X:$src), 1)>;
1221 }
1222
1223 multiclass avx512_common_broadcast_32x2<bits<8> opc, string OpcodeStr,
1224                          AVX512VLVectorVTInfo _Dst, AVX512VLVectorVTInfo _Src> {
1225   let Predicates = [HasDQI] in
1226     defm Z :    avx512_broadcast_rm<opc, OpcodeStr, _Dst.info512, _Src.info128>,
1227                                   EVEX_V512;
1228   let Predicates = [HasDQI, HasVLX] in
1229     defm Z256 : avx512_broadcast_rm<opc, OpcodeStr, _Dst.info256, _Src.info128>,
1230                                   EVEX_V256;
1231 }
1232
1233 multiclass avx512_common_broadcast_i32x2<bits<8> opc, string OpcodeStr,
1234                          AVX512VLVectorVTInfo _Dst, AVX512VLVectorVTInfo _Src> :
1235   avx512_common_broadcast_32x2<opc, OpcodeStr, _Dst, _Src> {
1236
1237   let Predicates = [HasDQI, HasVLX] in
1238     defm Z128 : avx512_broadcast_rm<opc, OpcodeStr, _Dst.info128, _Src.info128>,
1239                                       EVEX_V128;
1240 }
1241
1242 defm VBROADCASTI32X2  : avx512_common_broadcast_i32x2<0x59, "vbroadcasti32x2",
1243                                           avx512vl_i32_info, avx512vl_i64_info>;
1244 defm VBROADCASTF32X2  : avx512_common_broadcast_32x2<0x19, "vbroadcastf32x2",
1245                                           avx512vl_f32_info, avx512vl_f64_info>;
1246
1247 let Predicates = [HasVLX] in {
1248 def : Pat<(v8f32 (X86VBroadcast (v8f32 VR256X:$src))),
1249           (VBROADCASTSSZ256r (EXTRACT_SUBREG (v8f32 VR256X:$src), sub_xmm))>;
1250 def : Pat<(v4f64 (X86VBroadcast (v4f64 VR256X:$src))),
1251           (VBROADCASTSDZ256r (EXTRACT_SUBREG (v4f64 VR256X:$src), sub_xmm))>;
1252 }
1253
1254 def : Pat<(v16f32 (X86VBroadcast (v16f32 VR512:$src))),
1255           (VBROADCASTSSZr (EXTRACT_SUBREG (v16f32 VR512:$src), sub_xmm))>;
1256 def : Pat<(v16f32 (X86VBroadcast (v8f32 VR256X:$src))),
1257           (VBROADCASTSSZr (EXTRACT_SUBREG (v8f32 VR256X:$src), sub_xmm))>;
1258
1259 def : Pat<(v8f64 (X86VBroadcast (v8f64 VR512:$src))),
1260           (VBROADCASTSDZr (EXTRACT_SUBREG (v8f64 VR512:$src), sub_xmm))>;
1261 def : Pat<(v8f64 (X86VBroadcast (v4f64 VR256X:$src))),
1262           (VBROADCASTSDZr (EXTRACT_SUBREG (v4f64 VR256X:$src), sub_xmm))>;
1263
1264 //===----------------------------------------------------------------------===//
1265 // AVX-512 BROADCAST MASK TO VECTOR REGISTER
1266 //---
1267 multiclass avx512_mask_broadcastm<bits<8> opc, string OpcodeStr,
1268                                   X86VectorVTInfo _, RegisterClass KRC> {
1269   def rr : AVX512XS8I<opc, MRMSrcReg, (outs _.RC:$dst), (ins KRC:$src),
1270                   !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
1271                   [(set _.RC:$dst, (_.VT (X86VBroadcastm KRC:$src)))]>, EVEX;
1272 }
1273
1274 multiclass avx512_mask_broadcast<bits<8> opc, string OpcodeStr,
1275                                  AVX512VLVectorVTInfo VTInfo, RegisterClass KRC> {
1276   let Predicates = [HasCDI] in
1277     defm Z : avx512_mask_broadcastm<opc, OpcodeStr, VTInfo.info512, KRC>, EVEX_V512;
1278   let Predicates = [HasCDI, HasVLX] in {
1279     defm Z256 : avx512_mask_broadcastm<opc, OpcodeStr, VTInfo.info256, KRC>, EVEX_V256;
1280     defm Z128 : avx512_mask_broadcastm<opc, OpcodeStr, VTInfo.info128, KRC>, EVEX_V128;
1281   }
1282 }
1283
1284 defm VPBROADCASTMW2D : avx512_mask_broadcast<0x3A, "vpbroadcastmw2d",
1285                                                avx512vl_i32_info, VK16>;
1286 defm VPBROADCASTMB2Q : avx512_mask_broadcast<0x2A, "vpbroadcastmb2q",
1287                                                avx512vl_i64_info, VK8>, VEX_W;
1288
1289 //===----------------------------------------------------------------------===//
1290 // -- VPERMI2 - 3 source operands form --
1291 multiclass avx512_perm_i<bits<8> opc, string OpcodeStr, X86VectorVTInfo _> {
1292 let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
1293   // The index operand in the pattern should really be an integer type. However,
1294   // if we do that and it happens to come from a bitcast, then it becomes
1295   // difficult to find the bitcast needed to convert the index to the
1296   // destination type for the passthru since it will be folded with the bitcast
1297   // of the index operand.
1298   defm rr: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
1299           (ins _.RC:$src2, _.RC:$src3),
1300           OpcodeStr, "$src3, $src2", "$src2, $src3",
1301           (_.VT (X86VPermi2X _.RC:$src1, _.RC:$src2, _.RC:$src3)), 1>, EVEX_4V,
1302          AVX5128IBase;
1303
1304   defm rm: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
1305             (ins _.RC:$src2, _.MemOp:$src3),
1306             OpcodeStr, "$src3, $src2", "$src2, $src3",
1307             (_.VT (X86VPermi2X _.RC:$src1, _.RC:$src2,
1308                    (_.VT (bitconvert (_.LdFrag addr:$src3))))), 1>,
1309             EVEX_4V, AVX5128IBase;
1310   }
1311 }
1312 multiclass avx512_perm_i_mb<bits<8> opc, string OpcodeStr,
1313                             X86VectorVTInfo _> {
1314   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in
1315   defm rmb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
1316               (ins _.RC:$src2, _.ScalarMemOp:$src3),
1317               OpcodeStr,   !strconcat("${src3}", _.BroadcastStr,", $src2"),
1318               !strconcat("$src2, ${src3}", _.BroadcastStr ),
1319               (_.VT (X86VPermi2X _.RC:$src1,
1320                _.RC:$src2,(_.VT (X86VBroadcast (_.ScalarLdFrag addr:$src3))))),
1321               1>, AVX5128IBase, EVEX_4V, EVEX_B;
1322 }
1323
1324 multiclass avx512_perm_i_sizes<bits<8> opc, string OpcodeStr,
1325                                AVX512VLVectorVTInfo VTInfo> {
1326   defm NAME: avx512_perm_i<opc, OpcodeStr, VTInfo.info512>,
1327             avx512_perm_i_mb<opc, OpcodeStr, VTInfo.info512>, EVEX_V512;
1328   let Predicates = [HasVLX] in {
1329   defm NAME#128: avx512_perm_i<opc, OpcodeStr, VTInfo.info128>,
1330                  avx512_perm_i_mb<opc, OpcodeStr, VTInfo.info128>, EVEX_V128;
1331   defm NAME#256: avx512_perm_i<opc, OpcodeStr, VTInfo.info256>,
1332                  avx512_perm_i_mb<opc, OpcodeStr, VTInfo.info256>, EVEX_V256;
1333   }
1334 }
1335
1336 multiclass avx512_perm_i_sizes_bw<bits<8> opc, string OpcodeStr,
1337                                  AVX512VLVectorVTInfo VTInfo,
1338                                  Predicate Prd> {
1339   let Predicates = [Prd] in
1340   defm NAME: avx512_perm_i<opc, OpcodeStr, VTInfo.info512>, EVEX_V512;
1341   let Predicates = [Prd, HasVLX] in {
1342   defm NAME#128: avx512_perm_i<opc, OpcodeStr, VTInfo.info128>, EVEX_V128;
1343   defm NAME#256: avx512_perm_i<opc, OpcodeStr, VTInfo.info256>,  EVEX_V256;
1344   }
1345 }
1346
1347 defm VPERMI2D  : avx512_perm_i_sizes<0x76, "vpermi2d",
1348                   avx512vl_i32_info>, EVEX_CD8<32, CD8VF>;
1349 defm VPERMI2Q  : avx512_perm_i_sizes<0x76, "vpermi2q",
1350                   avx512vl_i64_info>, VEX_W, EVEX_CD8<64, CD8VF>;
1351 defm VPERMI2W  : avx512_perm_i_sizes_bw<0x75, "vpermi2w",
1352                   avx512vl_i16_info, HasBWI>,
1353                   VEX_W, EVEX_CD8<16, CD8VF>;
1354 defm VPERMI2B  : avx512_perm_i_sizes_bw<0x75, "vpermi2b",
1355                   avx512vl_i8_info, HasVBMI>,
1356                   EVEX_CD8<8, CD8VF>;
1357 defm VPERMI2PS : avx512_perm_i_sizes<0x77, "vpermi2ps",
1358                   avx512vl_f32_info>, EVEX_CD8<32, CD8VF>;
1359 defm VPERMI2PD : avx512_perm_i_sizes<0x77, "vpermi2pd",
1360                   avx512vl_f64_info>, VEX_W, EVEX_CD8<64, CD8VF>;
1361
1362 // VPERMT2
1363 multiclass avx512_perm_t<bits<8> opc, string OpcodeStr,
1364                          X86VectorVTInfo _, X86VectorVTInfo IdxVT> {
1365 let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
1366   defm rr: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
1367           (ins IdxVT.RC:$src2, _.RC:$src3),
1368           OpcodeStr, "$src3, $src2", "$src2, $src3",
1369           (_.VT (X86VPermt2 _.RC:$src1, IdxVT.RC:$src2, _.RC:$src3)), 1>,
1370           EVEX_4V, AVX5128IBase;
1371
1372   defm rm: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
1373             (ins IdxVT.RC:$src2, _.MemOp:$src3),
1374             OpcodeStr, "$src3, $src2", "$src2, $src3",
1375             (_.VT (X86VPermt2 _.RC:$src1, IdxVT.RC:$src2,
1376                    (bitconvert (_.LdFrag addr:$src3)))), 1>,
1377             EVEX_4V, AVX5128IBase;
1378   }
1379 }
1380 multiclass avx512_perm_t_mb<bits<8> opc, string OpcodeStr,
1381                             X86VectorVTInfo _, X86VectorVTInfo IdxVT> {
1382   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in
1383   defm rmb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
1384               (ins IdxVT.RC:$src2, _.ScalarMemOp:$src3),
1385               OpcodeStr,   !strconcat("${src3}", _.BroadcastStr,", $src2"),
1386               !strconcat("$src2, ${src3}", _.BroadcastStr ),
1387               (_.VT (X86VPermt2 _.RC:$src1,
1388                IdxVT.RC:$src2,(_.VT (X86VBroadcast (_.ScalarLdFrag addr:$src3))))),
1389               1>, AVX5128IBase, EVEX_4V, EVEX_B;
1390 }
1391
1392 multiclass avx512_perm_t_sizes<bits<8> opc, string OpcodeStr,
1393                                AVX512VLVectorVTInfo VTInfo,
1394                                AVX512VLVectorVTInfo ShuffleMask> {
1395   defm NAME: avx512_perm_t<opc, OpcodeStr, VTInfo.info512,
1396                               ShuffleMask.info512>,
1397             avx512_perm_t_mb<opc, OpcodeStr, VTInfo.info512,
1398                               ShuffleMask.info512>, EVEX_V512;
1399   let Predicates = [HasVLX] in {
1400   defm NAME#128: avx512_perm_t<opc, OpcodeStr, VTInfo.info128,
1401                               ShuffleMask.info128>,
1402                  avx512_perm_t_mb<opc, OpcodeStr, VTInfo.info128,
1403                               ShuffleMask.info128>, EVEX_V128;
1404   defm NAME#256: avx512_perm_t<opc, OpcodeStr, VTInfo.info256,
1405                               ShuffleMask.info256>,
1406                  avx512_perm_t_mb<opc, OpcodeStr, VTInfo.info256,
1407                               ShuffleMask.info256>, EVEX_V256;
1408   }
1409 }
1410
1411 multiclass avx512_perm_t_sizes_bw<bits<8> opc, string OpcodeStr,
1412                                  AVX512VLVectorVTInfo VTInfo,
1413                                  AVX512VLVectorVTInfo Idx,
1414                                  Predicate Prd> {
1415   let Predicates = [Prd] in
1416   defm NAME: avx512_perm_t<opc, OpcodeStr, VTInfo.info512,
1417                            Idx.info512>, EVEX_V512;
1418   let Predicates = [Prd, HasVLX] in {
1419   defm NAME#128: avx512_perm_t<opc, OpcodeStr, VTInfo.info128,
1420                                Idx.info128>, EVEX_V128;
1421   defm NAME#256: avx512_perm_t<opc, OpcodeStr, VTInfo.info256,
1422                                Idx.info256>, EVEX_V256;
1423   }
1424 }
1425
1426 defm VPERMT2D  : avx512_perm_t_sizes<0x7E, "vpermt2d",
1427                   avx512vl_i32_info, avx512vl_i32_info>, EVEX_CD8<32, CD8VF>;
1428 defm VPERMT2Q  : avx512_perm_t_sizes<0x7E, "vpermt2q",
1429                   avx512vl_i64_info, avx512vl_i64_info>, VEX_W, EVEX_CD8<64, CD8VF>;
1430 defm VPERMT2W  : avx512_perm_t_sizes_bw<0x7D, "vpermt2w",
1431                   avx512vl_i16_info, avx512vl_i16_info, HasBWI>,
1432                   VEX_W, EVEX_CD8<16, CD8VF>;
1433 defm VPERMT2B  : avx512_perm_t_sizes_bw<0x7D, "vpermt2b",
1434                   avx512vl_i8_info, avx512vl_i8_info, HasVBMI>,
1435                   EVEX_CD8<8, CD8VF>;
1436 defm VPERMT2PS : avx512_perm_t_sizes<0x7F, "vpermt2ps",
1437                   avx512vl_f32_info, avx512vl_i32_info>, EVEX_CD8<32, CD8VF>;
1438 defm VPERMT2PD : avx512_perm_t_sizes<0x7F, "vpermt2pd",
1439                   avx512vl_f64_info, avx512vl_i64_info>, VEX_W, EVEX_CD8<64, CD8VF>;
1440
1441 //===----------------------------------------------------------------------===//
1442 // AVX-512 - BLEND using mask
1443 //
1444 multiclass avx512_blendmask<bits<8> opc, string OpcodeStr, X86VectorVTInfo _> {
1445   let ExeDomain = _.ExeDomain, hasSideEffects = 0 in {
1446   def rr : AVX5128I<opc, MRMSrcReg, (outs _.RC:$dst),
1447              (ins _.RC:$src1, _.RC:$src2),
1448              !strconcat(OpcodeStr,
1449              "\t{$src2, $src1, ${dst}|${dst}, $src1, $src2}"),
1450              []>, EVEX_4V;
1451   def rrk : AVX5128I<opc, MRMSrcReg, (outs _.RC:$dst),
1452              (ins _.KRCWM:$mask, _.RC:$src1, _.RC:$src2),
1453              !strconcat(OpcodeStr,
1454              "\t{$src2, $src1, ${dst} {${mask}}|${dst} {${mask}}, $src1, $src2}"),
1455              []>, EVEX_4V, EVEX_K;
1456   def rrkz : AVX5128I<opc, MRMSrcReg, (outs _.RC:$dst),
1457              (ins _.KRCWM:$mask, _.RC:$src1, _.RC:$src2),
1458              !strconcat(OpcodeStr,
1459              "\t{$src2, $src1, ${dst} {${mask}} {z}|${dst} {${mask}} {z}, $src1, $src2}"),
1460              []>, EVEX_4V, EVEX_KZ;
1461   let mayLoad = 1 in {
1462   def rm  : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst),
1463              (ins _.RC:$src1, _.MemOp:$src2),
1464              !strconcat(OpcodeStr,
1465              "\t{$src2, $src1, ${dst}|${dst}, $src1, $src2}"),
1466              []>, EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
1467   def rmk : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst),
1468              (ins _.KRCWM:$mask, _.RC:$src1, _.MemOp:$src2),
1469              !strconcat(OpcodeStr,
1470              "\t{$src2, $src1, ${dst} {${mask}}|${dst} {${mask}}, $src1, $src2}"),
1471              []>, EVEX_4V, EVEX_K, EVEX_CD8<_.EltSize, CD8VF>;
1472   def rmkz : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst),
1473              (ins _.KRCWM:$mask, _.RC:$src1, _.MemOp:$src2),
1474              !strconcat(OpcodeStr,
1475              "\t{$src2, $src1, ${dst} {${mask}} {z}|${dst} {${mask}} {z}, $src1, $src2}"),
1476              []>, EVEX_4V, EVEX_KZ, EVEX_CD8<_.EltSize, CD8VF>;
1477   }
1478   }
1479 }
1480 multiclass avx512_blendmask_rmb<bits<8> opc, string OpcodeStr, X86VectorVTInfo _> {
1481
1482   let mayLoad = 1, hasSideEffects = 0 in {
1483   def rmbk : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst),
1484       (ins _.KRCWM:$mask, _.RC:$src1, _.ScalarMemOp:$src2),
1485        !strconcat(OpcodeStr,
1486             "\t{${src2}", _.BroadcastStr, ", $src1, $dst {${mask}}|",
1487             "$dst {${mask}}, $src1, ${src2}", _.BroadcastStr, "}"),
1488       []>, EVEX_4V, EVEX_K, EVEX_B, EVEX_CD8<_.EltSize, CD8VF>;
1489
1490   def rmb : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst),
1491       (ins _.RC:$src1, _.ScalarMemOp:$src2),
1492        !strconcat(OpcodeStr,
1493             "\t{${src2}", _.BroadcastStr, ", $src1, $dst|",
1494             "$dst, $src1, ${src2}", _.BroadcastStr, "}"),
1495       []>,  EVEX_4V, EVEX_B, EVEX_CD8<_.EltSize, CD8VF>;
1496   }
1497 }
1498
1499 multiclass blendmask_dq <bits<8> opc, string OpcodeStr,
1500                                  AVX512VLVectorVTInfo VTInfo> {
1501   defm Z : avx512_blendmask      <opc, OpcodeStr, VTInfo.info512>,
1502            avx512_blendmask_rmb  <opc, OpcodeStr, VTInfo.info512>, EVEX_V512;
1503
1504   let Predicates = [HasVLX] in {
1505     defm Z256 : avx512_blendmask<opc, OpcodeStr, VTInfo.info256>,
1506                 avx512_blendmask_rmb  <opc, OpcodeStr, VTInfo.info256>, EVEX_V256;
1507     defm Z128 : avx512_blendmask<opc, OpcodeStr, VTInfo.info128>,
1508                 avx512_blendmask_rmb  <opc, OpcodeStr, VTInfo.info128>, EVEX_V128;
1509   }
1510 }
1511
1512 multiclass blendmask_bw <bits<8> opc, string OpcodeStr,
1513                          AVX512VLVectorVTInfo VTInfo> {
1514   let Predicates = [HasBWI] in
1515     defm Z : avx512_blendmask    <opc, OpcodeStr, VTInfo.info512>, EVEX_V512;
1516
1517   let Predicates = [HasBWI, HasVLX] in {
1518     defm Z256 : avx512_blendmask <opc, OpcodeStr, VTInfo.info256>, EVEX_V256;
1519     defm Z128 : avx512_blendmask <opc, OpcodeStr, VTInfo.info128>, EVEX_V128;
1520   }
1521 }
1522
1523
1524 defm VBLENDMPS : blendmask_dq <0x65, "vblendmps", avx512vl_f32_info>;
1525 defm VBLENDMPD : blendmask_dq <0x65, "vblendmpd", avx512vl_f64_info>, VEX_W;
1526 defm VPBLENDMD : blendmask_dq <0x64, "vpblendmd", avx512vl_i32_info>;
1527 defm VPBLENDMQ : blendmask_dq <0x64, "vpblendmq", avx512vl_i64_info>, VEX_W;
1528 defm VPBLENDMB : blendmask_bw <0x66, "vpblendmb", avx512vl_i8_info>;
1529 defm VPBLENDMW : blendmask_bw <0x66, "vpblendmw", avx512vl_i16_info>, VEX_W;
1530
1531
1532 //===----------------------------------------------------------------------===//
1533 // Compare Instructions
1534 //===----------------------------------------------------------------------===//
1535
1536 // avx512_cmp_scalar - AVX512 CMPSS and CMPSD
1537
1538 multiclass avx512_cmp_scalar<X86VectorVTInfo _, SDNode OpNode, SDNode OpNodeRnd>{
1539
1540   defm  rr_Int  : AVX512_maskable_cmp<0xC2, MRMSrcReg, _,
1541                       (outs _.KRC:$dst),
1542                       (ins _.RC:$src1, _.RC:$src2, AVXCC:$cc),
1543                       "vcmp${cc}"#_.Suffix,
1544                       "$src2, $src1", "$src1, $src2",
1545                       (OpNode (_.VT _.RC:$src1),
1546                               (_.VT _.RC:$src2),
1547                               imm:$cc)>, EVEX_4V;
1548   let mayLoad = 1 in
1549   defm  rm_Int  : AVX512_maskable_cmp<0xC2, MRMSrcMem, _,
1550                     (outs _.KRC:$dst),
1551                     (ins _.RC:$src1, _.IntScalarMemOp:$src2, AVXCC:$cc),
1552                     "vcmp${cc}"#_.Suffix,
1553                     "$src2, $src1", "$src1, $src2",
1554                     (OpNode (_.VT _.RC:$src1), _.ScalarIntMemCPat:$src2,
1555                         imm:$cc)>, EVEX_4V, EVEX_CD8<_.EltSize, CD8VT1>;
1556
1557   defm  rrb_Int  : AVX512_maskable_cmp<0xC2, MRMSrcReg, _,
1558                      (outs _.KRC:$dst),
1559                      (ins _.RC:$src1, _.RC:$src2, AVXCC:$cc),
1560                      "vcmp${cc}"#_.Suffix,
1561                      "{sae}, $src2, $src1", "$src1, $src2, {sae}",
1562                      (OpNodeRnd (_.VT _.RC:$src1),
1563                                 (_.VT _.RC:$src2),
1564                                 imm:$cc,
1565                                 (i32 FROUND_NO_EXC))>, EVEX_4V, EVEX_B;
1566   // Accept explicit immediate argument form instead of comparison code.
1567   let isAsmParserOnly = 1, hasSideEffects = 0 in {
1568     defm  rri_alt  : AVX512_maskable_cmp_alt<0xC2, MRMSrcReg, _,
1569                         (outs VK1:$dst),
1570                         (ins _.RC:$src1, _.RC:$src2, u8imm:$cc),
1571                         "vcmp"#_.Suffix,
1572                         "$cc, $src2, $src1", "$src1, $src2, $cc">, EVEX_4V;
1573   let mayLoad = 1 in
1574     defm  rmi_alt  : AVX512_maskable_cmp_alt<0xC2, MRMSrcMem, _,
1575                         (outs _.KRC:$dst),
1576                         (ins _.RC:$src1, _.ScalarMemOp:$src2, u8imm:$cc),
1577                         "vcmp"#_.Suffix,
1578                         "$cc, $src2, $src1", "$src1, $src2, $cc">,
1579                         EVEX_4V, EVEX_CD8<_.EltSize, CD8VT1>;
1580
1581     defm  rrb_alt  : AVX512_maskable_cmp_alt<0xC2, MRMSrcReg, _,
1582                        (outs _.KRC:$dst),
1583                        (ins _.RC:$src1, _.RC:$src2, u8imm:$cc),
1584                        "vcmp"#_.Suffix,
1585                        "$cc, {sae}, $src2, $src1","$src1, $src2, {sae}, $cc">,
1586                        EVEX_4V, EVEX_B;
1587   }// let isAsmParserOnly = 1, hasSideEffects = 0
1588
1589   let isCodeGenOnly = 1 in {
1590     let isCommutable = 1 in
1591     def rr : AVX512Ii8<0xC2, MRMSrcReg,
1592                 (outs _.KRC:$dst), (ins _.FRC:$src1, _.FRC:$src2, AVXCC:$cc),
1593                 !strconcat("vcmp${cc}", _.Suffix,
1594                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1595                 [(set _.KRC:$dst, (OpNode _.FRC:$src1,
1596                                           _.FRC:$src2,
1597                                           imm:$cc))],
1598                 IIC_SSE_ALU_F32S_RR>, EVEX_4V;
1599     def rm : AVX512Ii8<0xC2, MRMSrcMem,
1600               (outs _.KRC:$dst),
1601               (ins _.FRC:$src1, _.ScalarMemOp:$src2, AVXCC:$cc),
1602               !strconcat("vcmp${cc}", _.Suffix,
1603                          "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1604               [(set _.KRC:$dst, (OpNode _.FRC:$src1,
1605                                         (_.ScalarLdFrag addr:$src2),
1606                                         imm:$cc))],
1607               IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_CD8<_.EltSize, CD8VT1>;
1608   }
1609 }
1610
1611 let Predicates = [HasAVX512] in {
1612   let ExeDomain = SSEPackedSingle in
1613   defm VCMPSSZ : avx512_cmp_scalar<f32x_info, X86cmpms, X86cmpmsRnd>,
1614                                    AVX512XSIi8Base;
1615   let ExeDomain = SSEPackedDouble in
1616   defm VCMPSDZ : avx512_cmp_scalar<f64x_info, X86cmpms, X86cmpmsRnd>,
1617                                    AVX512XDIi8Base, VEX_W;
1618 }
1619
1620 multiclass avx512_icmp_packed<bits<8> opc, string OpcodeStr, SDNode OpNode,
1621               X86VectorVTInfo _, bit IsCommutable> {
1622   let isCommutable = IsCommutable in
1623   def rr : AVX512BI<opc, MRMSrcReg,
1624              (outs _.KRC:$dst), (ins _.RC:$src1, _.RC:$src2),
1625              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1626              [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2)))],
1627              IIC_SSE_ALU_F32P_RR>, EVEX_4V;
1628   def rm : AVX512BI<opc, MRMSrcMem,
1629              (outs _.KRC:$dst), (ins _.RC:$src1, _.MemOp:$src2),
1630              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1631              [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1),
1632                                      (_.VT (bitconvert (_.LdFrag addr:$src2)))))],
1633              IIC_SSE_ALU_F32P_RM>, EVEX_4V;
1634   def rrk : AVX512BI<opc, MRMSrcReg,
1635               (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.RC:$src2),
1636               !strconcat(OpcodeStr, "\t{$src2, $src1, $dst {${mask}}|",
1637                           "$dst {${mask}}, $src1, $src2}"),
1638               [(set _.KRC:$dst, (and _.KRCWM:$mask,
1639                                    (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2))))],
1640               IIC_SSE_ALU_F32P_RR>, EVEX_4V, EVEX_K;
1641   def rmk : AVX512BI<opc, MRMSrcMem,
1642               (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.MemOp:$src2),
1643               !strconcat(OpcodeStr, "\t{$src2, $src1, $dst {${mask}}|",
1644                           "$dst {${mask}}, $src1, $src2}"),
1645               [(set _.KRC:$dst, (and _.KRCWM:$mask,
1646                                    (OpNode (_.VT _.RC:$src1),
1647                                        (_.VT (bitconvert
1648                                               (_.LdFrag addr:$src2))))))],
1649               IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K;
1650 }
1651
1652 multiclass avx512_icmp_packed_rmb<bits<8> opc, string OpcodeStr, SDNode OpNode,
1653               X86VectorVTInfo _, bit IsCommutable> :
1654            avx512_icmp_packed<opc, OpcodeStr, OpNode, _, IsCommutable> {
1655   def rmb : AVX512BI<opc, MRMSrcMem,
1656               (outs _.KRC:$dst), (ins _.RC:$src1, _.ScalarMemOp:$src2),
1657               !strconcat(OpcodeStr, "\t{${src2}", _.BroadcastStr, ", $src1, $dst",
1658                                     "|$dst, $src1, ${src2}", _.BroadcastStr, "}"),
1659               [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1),
1660                               (X86VBroadcast (_.ScalarLdFrag addr:$src2))))],
1661               IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_B;
1662   def rmbk : AVX512BI<opc, MRMSrcMem,
1663                (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1,
1664                                        _.ScalarMemOp:$src2),
1665                !strconcat(OpcodeStr,
1666                           "\t{${src2}", _.BroadcastStr, ", $src1, $dst {${mask}}|",
1667                           "$dst {${mask}}, $src1, ${src2}", _.BroadcastStr, "}"),
1668                [(set _.KRC:$dst, (and _.KRCWM:$mask,
1669                                       (OpNode (_.VT _.RC:$src1),
1670                                         (X86VBroadcast
1671                                           (_.ScalarLdFrag addr:$src2)))))],
1672                IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K, EVEX_B;
1673 }
1674
1675 multiclass avx512_icmp_packed_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
1676                                  AVX512VLVectorVTInfo VTInfo, Predicate prd,
1677                                  bit IsCommutable = 0> {
1678   let Predicates = [prd] in
1679   defm Z : avx512_icmp_packed<opc, OpcodeStr, OpNode, VTInfo.info512,
1680                               IsCommutable>, EVEX_V512;
1681
1682   let Predicates = [prd, HasVLX] in {
1683     defm Z256 : avx512_icmp_packed<opc, OpcodeStr, OpNode, VTInfo.info256,
1684                                    IsCommutable>, EVEX_V256;
1685     defm Z128 : avx512_icmp_packed<opc, OpcodeStr, OpNode, VTInfo.info128,
1686                                    IsCommutable>, EVEX_V128;
1687   }
1688 }
1689
1690 multiclass avx512_icmp_packed_rmb_vl<bits<8> opc, string OpcodeStr,
1691                                   SDNode OpNode, AVX512VLVectorVTInfo VTInfo,
1692                                   Predicate prd, bit IsCommutable = 0> {
1693   let Predicates = [prd] in
1694   defm Z : avx512_icmp_packed_rmb<opc, OpcodeStr, OpNode, VTInfo.info512,
1695                                   IsCommutable>, EVEX_V512;
1696
1697   let Predicates = [prd, HasVLX] in {
1698     defm Z256 : avx512_icmp_packed_rmb<opc, OpcodeStr, OpNode, VTInfo.info256,
1699                                        IsCommutable>, EVEX_V256;
1700     defm Z128 : avx512_icmp_packed_rmb<opc, OpcodeStr, OpNode, VTInfo.info128,
1701                                        IsCommutable>, EVEX_V128;
1702   }
1703 }
1704
1705 defm VPCMPEQB : avx512_icmp_packed_vl<0x74, "vpcmpeqb", X86pcmpeqm,
1706                       avx512vl_i8_info, HasBWI, 1>,
1707                 EVEX_CD8<8, CD8VF>;
1708
1709 defm VPCMPEQW : avx512_icmp_packed_vl<0x75, "vpcmpeqw", X86pcmpeqm,
1710                       avx512vl_i16_info, HasBWI, 1>,
1711                 EVEX_CD8<16, CD8VF>;
1712
1713 defm VPCMPEQD : avx512_icmp_packed_rmb_vl<0x76, "vpcmpeqd", X86pcmpeqm,
1714                       avx512vl_i32_info, HasAVX512, 1>,
1715                 EVEX_CD8<32, CD8VF>;
1716
1717 defm VPCMPEQQ : avx512_icmp_packed_rmb_vl<0x29, "vpcmpeqq", X86pcmpeqm,
1718                       avx512vl_i64_info, HasAVX512, 1>,
1719                 T8PD, VEX_W, EVEX_CD8<64, CD8VF>;
1720
1721 defm VPCMPGTB : avx512_icmp_packed_vl<0x64, "vpcmpgtb", X86pcmpgtm,
1722                       avx512vl_i8_info, HasBWI>,
1723                 EVEX_CD8<8, CD8VF>;
1724
1725 defm VPCMPGTW : avx512_icmp_packed_vl<0x65, "vpcmpgtw", X86pcmpgtm,
1726                       avx512vl_i16_info, HasBWI>,
1727                 EVEX_CD8<16, CD8VF>;
1728
1729 defm VPCMPGTD : avx512_icmp_packed_rmb_vl<0x66, "vpcmpgtd", X86pcmpgtm,
1730                       avx512vl_i32_info, HasAVX512>,
1731                 EVEX_CD8<32, CD8VF>;
1732
1733 defm VPCMPGTQ : avx512_icmp_packed_rmb_vl<0x37, "vpcmpgtq", X86pcmpgtm,
1734                       avx512vl_i64_info, HasAVX512>,
1735                 T8PD, VEX_W, EVEX_CD8<64, CD8VF>;
1736
1737 let Predicates = [HasAVX512, NoVLX] in {
1738 def : Pat<(v8i1 (X86pcmpgtm (v8i32 VR256X:$src1), (v8i32 VR256X:$src2))),
1739             (COPY_TO_REGCLASS (VPCMPGTDZrr
1740             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
1741             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src2, sub_ymm))), VK8)>;
1742
1743 def : Pat<(v8i1 (X86pcmpeqm (v8i32 VR256X:$src1), (v8i32 VR256X:$src2))),
1744             (COPY_TO_REGCLASS (VPCMPEQDZrr
1745             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
1746             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src2, sub_ymm))), VK8)>;
1747 }
1748
1749 multiclass avx512_icmp_cc<bits<8> opc, string Suffix, SDNode OpNode,
1750                           X86VectorVTInfo _> {
1751   let isCommutable = 1 in
1752   def rri : AVX512AIi8<opc, MRMSrcReg,
1753              (outs _.KRC:$dst), (ins _.RC:$src1, _.RC:$src2, AVX512ICC:$cc),
1754              !strconcat("vpcmp${cc}", Suffix,
1755                         "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1756              [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
1757                                        imm:$cc))],
1758              IIC_SSE_ALU_F32P_RR>, EVEX_4V;
1759   def rmi : AVX512AIi8<opc, MRMSrcMem,
1760              (outs _.KRC:$dst), (ins _.RC:$src1, _.MemOp:$src2, AVX512ICC:$cc),
1761              !strconcat("vpcmp${cc}", Suffix,
1762                         "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1763              [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1),
1764                               (_.VT (bitconvert (_.LdFrag addr:$src2))),
1765                               imm:$cc))],
1766              IIC_SSE_ALU_F32P_RM>, EVEX_4V;
1767   def rrik : AVX512AIi8<opc, MRMSrcReg,
1768               (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.RC:$src2,
1769                                       AVX512ICC:$cc),
1770               !strconcat("vpcmp${cc}", Suffix,
1771                          "\t{$src2, $src1, $dst {${mask}}|",
1772                          "$dst {${mask}}, $src1, $src2}"),
1773               [(set _.KRC:$dst, (and _.KRCWM:$mask,
1774                                   (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
1775                                           imm:$cc)))],
1776               IIC_SSE_ALU_F32P_RR>, EVEX_4V, EVEX_K;
1777   def rmik : AVX512AIi8<opc, MRMSrcMem,
1778               (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.MemOp:$src2,
1779                                     AVX512ICC:$cc),
1780               !strconcat("vpcmp${cc}", Suffix,
1781                          "\t{$src2, $src1, $dst {${mask}}|",
1782                          "$dst {${mask}}, $src1, $src2}"),
1783               [(set _.KRC:$dst, (and _.KRCWM:$mask,
1784                                    (OpNode (_.VT _.RC:$src1),
1785                                       (_.VT (bitconvert (_.LdFrag addr:$src2))),
1786                                       imm:$cc)))],
1787               IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K;
1788
1789   // Accept explicit immediate argument form instead of comparison code.
1790   let isAsmParserOnly = 1, hasSideEffects = 0 in {
1791     def rri_alt : AVX512AIi8<opc, MRMSrcReg,
1792                (outs _.KRC:$dst), (ins _.RC:$src1, _.RC:$src2, u8imm:$cc),
1793                !strconcat("vpcmp", Suffix, "\t{$cc, $src2, $src1, $dst|",
1794                           "$dst, $src1, $src2, $cc}"),
1795                [], IIC_SSE_ALU_F32P_RR>, EVEX_4V;
1796     let mayLoad = 1 in
1797     def rmi_alt : AVX512AIi8<opc, MRMSrcMem,
1798                (outs _.KRC:$dst), (ins _.RC:$src1, _.MemOp:$src2, u8imm:$cc),
1799                !strconcat("vpcmp", Suffix, "\t{$cc, $src2, $src1, $dst|",
1800                           "$dst, $src1, $src2, $cc}"),
1801                [], IIC_SSE_ALU_F32P_RM>, EVEX_4V;
1802     def rrik_alt : AVX512AIi8<opc, MRMSrcReg,
1803                (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.RC:$src2,
1804                                        u8imm:$cc),
1805                !strconcat("vpcmp", Suffix,
1806                           "\t{$cc, $src2, $src1, $dst {${mask}}|",
1807                           "$dst {${mask}}, $src1, $src2, $cc}"),
1808                [], IIC_SSE_ALU_F32P_RR>, EVEX_4V, EVEX_K;
1809     let mayLoad = 1 in
1810     def rmik_alt : AVX512AIi8<opc, MRMSrcMem,
1811                (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1, _.MemOp:$src2,
1812                                        u8imm:$cc),
1813                !strconcat("vpcmp", Suffix,
1814                           "\t{$cc, $src2, $src1, $dst {${mask}}|",
1815                           "$dst {${mask}}, $src1, $src2, $cc}"),
1816                [], IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K;
1817   }
1818 }
1819
1820 multiclass avx512_icmp_cc_rmb<bits<8> opc, string Suffix, SDNode OpNode,
1821                               X86VectorVTInfo _> :
1822            avx512_icmp_cc<opc, Suffix, OpNode, _> {
1823   def rmib : AVX512AIi8<opc, MRMSrcMem,
1824              (outs _.KRC:$dst), (ins _.RC:$src1, _.ScalarMemOp:$src2,
1825                                      AVX512ICC:$cc),
1826              !strconcat("vpcmp${cc}", Suffix,
1827                         "\t{${src2}", _.BroadcastStr, ", $src1, $dst|",
1828                         "$dst, $src1, ${src2}", _.BroadcastStr, "}"),
1829              [(set _.KRC:$dst, (OpNode (_.VT _.RC:$src1),
1830                                (X86VBroadcast (_.ScalarLdFrag addr:$src2)),
1831                                imm:$cc))],
1832              IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_B;
1833   def rmibk : AVX512AIi8<opc, MRMSrcMem,
1834               (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1,
1835                                        _.ScalarMemOp:$src2, AVX512ICC:$cc),
1836               !strconcat("vpcmp${cc}", Suffix,
1837                        "\t{${src2}", _.BroadcastStr, ", $src1, $dst {${mask}}|",
1838                        "$dst {${mask}}, $src1, ${src2}", _.BroadcastStr, "}"),
1839               [(set _.KRC:$dst, (and _.KRCWM:$mask,
1840                                   (OpNode (_.VT _.RC:$src1),
1841                                     (X86VBroadcast (_.ScalarLdFrag addr:$src2)),
1842                                     imm:$cc)))],
1843               IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K, EVEX_B;
1844
1845   // Accept explicit immediate argument form instead of comparison code.
1846   let isAsmParserOnly = 1, hasSideEffects = 0, mayLoad = 1 in {
1847     def rmib_alt : AVX512AIi8<opc, MRMSrcMem,
1848                (outs _.KRC:$dst), (ins _.RC:$src1, _.ScalarMemOp:$src2,
1849                                        u8imm:$cc),
1850                !strconcat("vpcmp", Suffix,
1851                    "\t{$cc, ${src2}", _.BroadcastStr, ", $src1, $dst|",
1852                    "$dst, $src1, ${src2}", _.BroadcastStr, ", $cc}"),
1853                [], IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_B;
1854     def rmibk_alt : AVX512AIi8<opc, MRMSrcMem,
1855                (outs _.KRC:$dst), (ins _.KRCWM:$mask, _.RC:$src1,
1856                                        _.ScalarMemOp:$src2, u8imm:$cc),
1857                !strconcat("vpcmp", Suffix,
1858                   "\t{$cc, ${src2}", _.BroadcastStr, ", $src1, $dst {${mask}}|",
1859                   "$dst {${mask}}, $src1, ${src2}", _.BroadcastStr, ", $cc}"),
1860                [], IIC_SSE_ALU_F32P_RM>, EVEX_4V, EVEX_K, EVEX_B;
1861   }
1862 }
1863
1864 multiclass avx512_icmp_cc_vl<bits<8> opc, string Suffix, SDNode OpNode,
1865                              AVX512VLVectorVTInfo VTInfo, Predicate prd> {
1866   let Predicates = [prd] in
1867   defm Z : avx512_icmp_cc<opc, Suffix, OpNode, VTInfo.info512>, EVEX_V512;
1868
1869   let Predicates = [prd, HasVLX] in {
1870     defm Z256 : avx512_icmp_cc<opc, Suffix, OpNode, VTInfo.info256>, EVEX_V256;
1871     defm Z128 : avx512_icmp_cc<opc, Suffix, OpNode, VTInfo.info128>, EVEX_V128;
1872   }
1873 }
1874
1875 multiclass avx512_icmp_cc_rmb_vl<bits<8> opc, string Suffix, SDNode OpNode,
1876                                 AVX512VLVectorVTInfo VTInfo, Predicate prd> {
1877   let Predicates = [prd] in
1878   defm Z : avx512_icmp_cc_rmb<opc, Suffix, OpNode, VTInfo.info512>,
1879            EVEX_V512;
1880
1881   let Predicates = [prd, HasVLX] in {
1882     defm Z256 : avx512_icmp_cc_rmb<opc, Suffix, OpNode, VTInfo.info256>,
1883                 EVEX_V256;
1884     defm Z128 : avx512_icmp_cc_rmb<opc, Suffix, OpNode, VTInfo.info128>,
1885                 EVEX_V128;
1886   }
1887 }
1888
1889 defm VPCMPB : avx512_icmp_cc_vl<0x3F, "b", X86cmpm, avx512vl_i8_info,
1890                                 HasBWI>, EVEX_CD8<8, CD8VF>;
1891 defm VPCMPUB : avx512_icmp_cc_vl<0x3E, "ub", X86cmpmu, avx512vl_i8_info,
1892                                  HasBWI>, EVEX_CD8<8, CD8VF>;
1893
1894 defm VPCMPW : avx512_icmp_cc_vl<0x3F, "w", X86cmpm, avx512vl_i16_info,
1895                                 HasBWI>, VEX_W, EVEX_CD8<16, CD8VF>;
1896 defm VPCMPUW : avx512_icmp_cc_vl<0x3E, "uw", X86cmpmu, avx512vl_i16_info,
1897                                  HasBWI>, VEX_W, EVEX_CD8<16, CD8VF>;
1898
1899 defm VPCMPD : avx512_icmp_cc_rmb_vl<0x1F, "d", X86cmpm, avx512vl_i32_info,
1900                                     HasAVX512>, EVEX_CD8<32, CD8VF>;
1901 defm VPCMPUD : avx512_icmp_cc_rmb_vl<0x1E, "ud", X86cmpmu, avx512vl_i32_info,
1902                                      HasAVX512>, EVEX_CD8<32, CD8VF>;
1903
1904 defm VPCMPQ : avx512_icmp_cc_rmb_vl<0x1F, "q", X86cmpm, avx512vl_i64_info,
1905                                     HasAVX512>, VEX_W, EVEX_CD8<64, CD8VF>;
1906 defm VPCMPUQ : avx512_icmp_cc_rmb_vl<0x1E, "uq", X86cmpmu, avx512vl_i64_info,
1907                                      HasAVX512>, VEX_W, EVEX_CD8<64, CD8VF>;
1908
1909 multiclass avx512_vcmp_common<X86VectorVTInfo _> {
1910
1911   defm  rri  : AVX512_maskable_cmp<0xC2, MRMSrcReg, _,
1912                    (outs _.KRC:$dst), (ins _.RC:$src1, _.RC:$src2,AVXCC:$cc),
1913                    "vcmp${cc}"#_.Suffix,
1914                    "$src2, $src1", "$src1, $src2",
1915                    (X86cmpm (_.VT _.RC:$src1),
1916                          (_.VT _.RC:$src2),
1917                            imm:$cc), 1>;
1918
1919   defm  rmi  : AVX512_maskable_cmp<0xC2, MRMSrcMem, _,
1920                 (outs _.KRC:$dst),(ins _.RC:$src1, _.MemOp:$src2, AVXCC:$cc),
1921                 "vcmp${cc}"#_.Suffix,
1922                 "$src2, $src1", "$src1, $src2",
1923                 (X86cmpm (_.VT _.RC:$src1),
1924                         (_.VT (bitconvert (_.LdFrag addr:$src2))),
1925                         imm:$cc)>;
1926
1927   defm  rmbi : AVX512_maskable_cmp<0xC2, MRMSrcMem, _,
1928                 (outs _.KRC:$dst),
1929                 (ins _.RC:$src1, _.ScalarMemOp:$src2, AVXCC:$cc),
1930                 "vcmp${cc}"#_.Suffix,
1931                 "${src2}"##_.BroadcastStr##", $src1",
1932                 "$src1, ${src2}"##_.BroadcastStr,
1933                 (X86cmpm (_.VT _.RC:$src1),
1934                         (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src2))),
1935                         imm:$cc)>,EVEX_B;
1936   // Accept explicit immediate argument form instead of comparison code.
1937   let isAsmParserOnly = 1, hasSideEffects = 0 in {
1938     defm  rri_alt : AVX512_maskable_cmp_alt<0xC2, MRMSrcReg, _,
1939                          (outs _.KRC:$dst),
1940                          (ins _.RC:$src1, _.RC:$src2, u8imm:$cc),
1941                          "vcmp"#_.Suffix,
1942                          "$cc, $src2, $src1", "$src1, $src2, $cc">;
1943
1944     let mayLoad = 1 in {
1945       defm rmi_alt : AVX512_maskable_cmp_alt<0xC2, MRMSrcMem, _,
1946                              (outs _.KRC:$dst),
1947                              (ins _.RC:$src1, _.MemOp:$src2, u8imm:$cc),
1948                              "vcmp"#_.Suffix,
1949                              "$cc, $src2, $src1", "$src1, $src2, $cc">;
1950
1951       defm  rmbi_alt : AVX512_maskable_cmp_alt<0xC2, MRMSrcMem, _,
1952                          (outs _.KRC:$dst),
1953                          (ins _.RC:$src1, _.ScalarMemOp:$src2, u8imm:$cc),
1954                          "vcmp"#_.Suffix,
1955                          "$cc, ${src2}"##_.BroadcastStr##", $src1",
1956                          "$src1, ${src2}"##_.BroadcastStr##", $cc">,EVEX_B;
1957     }
1958  }
1959 }
1960
1961 multiclass avx512_vcmp_sae<X86VectorVTInfo _> {
1962   // comparison code form (VCMP[EQ/LT/LE/...]
1963   defm  rrib  : AVX512_maskable_cmp<0xC2, MRMSrcReg, _,
1964                      (outs _.KRC:$dst),(ins _.RC:$src1, _.RC:$src2, AVXCC:$cc),
1965                      "vcmp${cc}"#_.Suffix,
1966                      "{sae}, $src2, $src1", "$src1, $src2, {sae}",
1967                      (X86cmpmRnd (_.VT _.RC:$src1),
1968                                     (_.VT _.RC:$src2),
1969                                     imm:$cc,
1970                                 (i32 FROUND_NO_EXC))>, EVEX_B;
1971
1972   let isAsmParserOnly = 1, hasSideEffects = 0 in {
1973     defm  rrib_alt  : AVX512_maskable_cmp_alt<0xC2, MRMSrcReg, _,
1974                          (outs _.KRC:$dst),
1975                          (ins _.RC:$src1, _.RC:$src2, u8imm:$cc),
1976                          "vcmp"#_.Suffix,
1977                          "$cc, {sae}, $src2, $src1",
1978                          "$src1, $src2, {sae}, $cc">, EVEX_B;
1979    }
1980 }
1981
1982 multiclass avx512_vcmp<AVX512VLVectorVTInfo _> {
1983   let Predicates = [HasAVX512] in {
1984     defm Z    : avx512_vcmp_common<_.info512>,
1985                 avx512_vcmp_sae<_.info512>, EVEX_V512;
1986
1987   }
1988   let Predicates = [HasAVX512,HasVLX] in {
1989    defm Z128 : avx512_vcmp_common<_.info128>, EVEX_V128;
1990    defm Z256 : avx512_vcmp_common<_.info256>, EVEX_V256;
1991   }
1992 }
1993
1994 defm VCMPPD : avx512_vcmp<avx512vl_f64_info>,
1995                           AVX512PDIi8Base, EVEX_4V, EVEX_CD8<64, CD8VF>, VEX_W;
1996 defm VCMPPS : avx512_vcmp<avx512vl_f32_info>,
1997                           AVX512PSIi8Base, EVEX_4V, EVEX_CD8<32, CD8VF>;
1998
1999 def : Pat<(v8i1 (X86cmpm (v8f32 VR256X:$src1), (v8f32 VR256X:$src2), imm:$cc)),
2000           (COPY_TO_REGCLASS (VCMPPSZrri
2001             (v16f32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
2002             (v16f32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src2, sub_ymm)),
2003             imm:$cc), VK8)>;
2004 def : Pat<(v8i1 (X86cmpm (v8i32 VR256X:$src1), (v8i32 VR256X:$src2), imm:$cc)),
2005           (COPY_TO_REGCLASS (VPCMPDZrri
2006             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
2007             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src2, sub_ymm)),
2008             imm:$cc), VK8)>;
2009 def : Pat<(v8i1 (X86cmpmu (v8i32 VR256X:$src1), (v8i32 VR256X:$src2), imm:$cc)),
2010           (COPY_TO_REGCLASS (VPCMPUDZrri
2011             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
2012             (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src2, sub_ymm)),
2013             imm:$cc), VK8)>;
2014
2015 // ----------------------------------------------------------------
2016 // FPClass
2017 //handle fpclass instruction  mask =  op(reg_scalar,imm)
2018 //                                    op(mem_scalar,imm)
2019 multiclass avx512_scalar_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
2020                                  X86VectorVTInfo _, Predicate prd> {
2021   let Predicates = [prd] in {
2022       def rr : AVX512<opc, MRMSrcReg, (outs _.KRC:$dst),//_.KRC:$dst),
2023                       (ins _.RC:$src1, i32u8imm:$src2),
2024                       OpcodeStr##_.Suffix#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2025                       [(set _.KRC:$dst,(OpNode (_.VT _.RC:$src1),
2026                               (i32 imm:$src2)))], NoItinerary>;
2027       def rrk : AVX512<opc, MRMSrcReg, (outs _.KRC:$dst),
2028                       (ins _.KRCWM:$mask, _.RC:$src1, i32u8imm:$src2),
2029                       OpcodeStr##_.Suffix#
2030                       "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
2031                       [(set _.KRC:$dst,(or _.KRCWM:$mask,
2032                                       (OpNode (_.VT _.RC:$src1),
2033                                       (i32 imm:$src2))))], NoItinerary>, EVEX_K;
2034     def rm : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2035                     (ins _.MemOp:$src1, i32u8imm:$src2),
2036                     OpcodeStr##_.Suffix##
2037                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2038                     [(set _.KRC:$dst,
2039                           (OpNode (_.VT (bitconvert (_.LdFrag addr:$src1))),
2040                                   (i32 imm:$src2)))], NoItinerary>;
2041     def rmk : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2042                     (ins _.KRCWM:$mask, _.MemOp:$src1, i32u8imm:$src2),
2043                     OpcodeStr##_.Suffix##
2044                     "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
2045                     [(set _.KRC:$dst,(or _.KRCWM:$mask,
2046                         (OpNode (_.VT (bitconvert (_.LdFrag addr:$src1))),
2047                             (i32 imm:$src2))))], NoItinerary>, EVEX_K;
2048   }
2049 }
2050
2051 //handle fpclass instruction mask = fpclass(reg_vec, reg_vec, imm)
2052 //                                  fpclass(reg_vec, mem_vec, imm)
2053 //                                  fpclass(reg_vec, broadcast(eltVt), imm)
2054 multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
2055                                  X86VectorVTInfo _, string mem, string broadcast>{
2056   def rr : AVX512<opc, MRMSrcReg, (outs _.KRC:$dst),
2057                       (ins _.RC:$src1, i32u8imm:$src2),
2058                       OpcodeStr##_.Suffix#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2059                       [(set _.KRC:$dst,(OpNode (_.VT _.RC:$src1),
2060                                        (i32 imm:$src2)))], NoItinerary>;
2061   def rrk : AVX512<opc, MRMSrcReg, (outs _.KRC:$dst),
2062                       (ins _.KRCWM:$mask, _.RC:$src1, i32u8imm:$src2),
2063                       OpcodeStr##_.Suffix#
2064                       "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
2065                       [(set _.KRC:$dst,(or _.KRCWM:$mask,
2066                                        (OpNode (_.VT _.RC:$src1),
2067                                        (i32 imm:$src2))))], NoItinerary>, EVEX_K;
2068   def rm : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2069                     (ins _.MemOp:$src1, i32u8imm:$src2),
2070                     OpcodeStr##_.Suffix##mem#
2071                     "\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2072                     [(set _.KRC:$dst,(OpNode
2073                                      (_.VT (bitconvert (_.LdFrag addr:$src1))),
2074                                      (i32 imm:$src2)))], NoItinerary>;
2075   def rmk : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2076                     (ins _.KRCWM:$mask, _.MemOp:$src1, i32u8imm:$src2),
2077                     OpcodeStr##_.Suffix##mem#
2078                     "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
2079                     [(set _.KRC:$dst, (or _.KRCWM:$mask, (OpNode
2080                                   (_.VT (bitconvert (_.LdFrag addr:$src1))),
2081                                   (i32 imm:$src2))))], NoItinerary>, EVEX_K;
2082   def rmb : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2083                     (ins _.ScalarMemOp:$src1, i32u8imm:$src2),
2084                     OpcodeStr##_.Suffix##broadcast##"\t{$src2, ${src1}"##
2085                                       _.BroadcastStr##", $dst|$dst, ${src1}"
2086                                                   ##_.BroadcastStr##", $src2}",
2087                     [(set _.KRC:$dst,(OpNode
2088                                      (_.VT (X86VBroadcast
2089                                            (_.ScalarLdFrag addr:$src1))),
2090                                      (i32 imm:$src2)))], NoItinerary>,EVEX_B;
2091   def rmbk : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
2092                     (ins _.KRCWM:$mask, _.ScalarMemOp:$src1, i32u8imm:$src2),
2093                     OpcodeStr##_.Suffix##broadcast##"\t{$src2, ${src1}"##
2094                           _.BroadcastStr##", $dst {${mask}}|$dst {${mask}}, ${src1}"##
2095                                                    _.BroadcastStr##", $src2}",
2096                     [(set _.KRC:$dst,(or _.KRCWM:$mask, (OpNode
2097                                      (_.VT (X86VBroadcast
2098                                            (_.ScalarLdFrag addr:$src1))),
2099                                      (i32 imm:$src2))))], NoItinerary>,
2100                                                           EVEX_B, EVEX_K;
2101 }
2102
2103 multiclass avx512_vector_fpclass_all<string OpcodeStr,
2104             AVX512VLVectorVTInfo _, bits<8> opc, SDNode OpNode, Predicate prd,
2105                                                               string broadcast>{
2106   let Predicates = [prd] in {
2107     defm Z    : avx512_vector_fpclass<opc, OpcodeStr, OpNode, _.info512, "{z}",
2108                                       broadcast>, EVEX_V512;
2109   }
2110   let Predicates = [prd, HasVLX] in {
2111     defm Z128 : avx512_vector_fpclass<opc, OpcodeStr, OpNode, _.info128, "{x}",
2112                                       broadcast>, EVEX_V128;
2113     defm Z256 : avx512_vector_fpclass<opc, OpcodeStr, OpNode, _.info256, "{y}",
2114                                       broadcast>, EVEX_V256;
2115   }
2116 }
2117
2118 multiclass avx512_fp_fpclass_all<string OpcodeStr, bits<8> opcVec,
2119              bits<8> opcScalar, SDNode VecOpNode, SDNode ScalarOpNode, Predicate prd>{
2120   defm PS : avx512_vector_fpclass_all<OpcodeStr,  avx512vl_f32_info, opcVec,
2121                                       VecOpNode, prd, "{l}">, EVEX_CD8<32, CD8VF>;
2122   defm PD : avx512_vector_fpclass_all<OpcodeStr,  avx512vl_f64_info, opcVec,
2123                                       VecOpNode, prd, "{q}">,EVEX_CD8<64, CD8VF> , VEX_W;
2124   defm SS : avx512_scalar_fpclass<opcScalar, OpcodeStr, ScalarOpNode,
2125                                       f32x_info, prd>, EVEX_CD8<32, CD8VT1>;
2126   defm SD : avx512_scalar_fpclass<opcScalar, OpcodeStr, ScalarOpNode,
2127                                       f64x_info, prd>, EVEX_CD8<64, CD8VT1>, VEX_W;
2128 }
2129
2130 defm VFPCLASS : avx512_fp_fpclass_all<"vfpclass", 0x66, 0x67, X86Vfpclass,
2131                                       X86Vfpclasss, HasDQI>, AVX512AIi8Base,EVEX;
2132
2133 //-----------------------------------------------------------------
2134 // Mask register copy, including
2135 // - copy between mask registers
2136 // - load/store mask registers
2137 // - copy from GPR to mask register and vice versa
2138 //
2139 multiclass avx512_mask_mov<bits<8> opc_kk, bits<8> opc_km, bits<8> opc_mk,
2140                          string OpcodeStr, RegisterClass KRC,
2141                          ValueType vvt, X86MemOperand x86memop> {
2142   let hasSideEffects = 0 in
2143   def kk : I<opc_kk, MRMSrcReg, (outs KRC:$dst), (ins KRC:$src),
2144              !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"), []>;
2145   def km : I<opc_km, MRMSrcMem, (outs KRC:$dst), (ins x86memop:$src),
2146              !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2147              [(set KRC:$dst, (vvt (load addr:$src)))]>;
2148   def mk : I<opc_mk, MRMDestMem, (outs), (ins x86memop:$dst, KRC:$src),
2149              !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2150              [(store KRC:$src, addr:$dst)]>;
2151 }
2152
2153 multiclass avx512_mask_mov_gpr<bits<8> opc_kr, bits<8> opc_rk,
2154                              string OpcodeStr,
2155                              RegisterClass KRC, RegisterClass GRC> {
2156   let hasSideEffects = 0 in {
2157     def kr : I<opc_kr, MRMSrcReg, (outs KRC:$dst), (ins GRC:$src),
2158                !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"), []>;
2159     def rk : I<opc_rk, MRMSrcReg, (outs GRC:$dst), (ins KRC:$src),
2160                !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"), []>;
2161   }
2162 }
2163
2164 let Predicates = [HasDQI] in
2165   defm KMOVB : avx512_mask_mov<0x90, 0x90, 0x91, "kmovb", VK8, v8i1, i8mem>,
2166                avx512_mask_mov_gpr<0x92, 0x93, "kmovb", VK8, GR32>,
2167                VEX, PD;
2168
2169 let Predicates = [HasAVX512] in
2170   defm KMOVW : avx512_mask_mov<0x90, 0x90, 0x91, "kmovw", VK16, v16i1, i16mem>,
2171                avx512_mask_mov_gpr<0x92, 0x93, "kmovw", VK16, GR32>,
2172                VEX, PS;
2173
2174 let Predicates = [HasBWI] in {
2175   defm KMOVD : avx512_mask_mov<0x90, 0x90, 0x91, "kmovd", VK32, v32i1,i32mem>,
2176                VEX, PD, VEX_W;
2177   defm KMOVD : avx512_mask_mov_gpr<0x92, 0x93, "kmovd", VK32, GR32>,
2178                VEX, XD;
2179   defm KMOVQ : avx512_mask_mov<0x90, 0x90, 0x91, "kmovq", VK64, v64i1, i64mem>,
2180                VEX, PS, VEX_W;
2181   defm KMOVQ : avx512_mask_mov_gpr<0x92, 0x93, "kmovq", VK64, GR64>,
2182                VEX, XD, VEX_W;
2183 }
2184
2185 // GR from/to mask register
2186 def : Pat<(v16i1 (bitconvert (i16 GR16:$src))),
2187           (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), GR16:$src, sub_16bit)), VK16)>;
2188 def : Pat<(i16 (bitconvert (v16i1 VK16:$src))),
2189           (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK16:$src, GR32)), sub_16bit)>;
2190
2191 def : Pat<(v8i1 (bitconvert (i8 GR8:$src))),
2192           (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), GR8:$src, sub_8bit)), VK8)>;
2193 def : Pat<(i8 (bitconvert (v8i1 VK8:$src))),
2194           (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK8:$src, GR32)), sub_8bit)>;
2195
2196 def : Pat<(i32 (zext (i16 (bitconvert (v16i1 VK16:$src))))),
2197           (KMOVWrk VK16:$src)>;
2198 def : Pat<(i32 (anyext (i16 (bitconvert (v16i1 VK16:$src))))),
2199           (COPY_TO_REGCLASS VK16:$src, GR32)>;
2200
2201 def : Pat<(i32 (zext (i8 (bitconvert (v8i1 VK8:$src))))),
2202           (MOVZX32rr8 (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK8:$src, GR32)), sub_8bit))>, Requires<[NoDQI]>;
2203 def : Pat<(i32 (zext (i8 (bitconvert (v8i1 VK8:$src))))),
2204           (KMOVBrk VK8:$src)>, Requires<[HasDQI]>;
2205 def : Pat<(i32 (anyext (i8 (bitconvert (v8i1 VK8:$src))))),
2206           (COPY_TO_REGCLASS VK8:$src, GR32)>;
2207
2208 def : Pat<(v32i1 (bitconvert (i32 GR32:$src))),
2209           (COPY_TO_REGCLASS GR32:$src, VK32)>;
2210 def : Pat<(i32 (bitconvert (v32i1 VK32:$src))),
2211           (COPY_TO_REGCLASS VK32:$src, GR32)>;
2212 def : Pat<(v64i1 (bitconvert (i64 GR64:$src))),
2213           (COPY_TO_REGCLASS GR64:$src, VK64)>;
2214 def : Pat<(i64 (bitconvert (v64i1 VK64:$src))),
2215           (COPY_TO_REGCLASS VK64:$src, GR64)>;
2216
2217 // Load/store kreg
2218 let Predicates = [HasDQI] in {
2219   def : Pat<(store (i8 (bitconvert (v8i1 VK8:$src))), addr:$dst),
2220             (KMOVBmk addr:$dst, VK8:$src)>;
2221   def : Pat<(v8i1 (bitconvert (i8 (load addr:$src)))),
2222             (KMOVBkm addr:$src)>;
2223
2224   def : Pat<(store VK4:$src, addr:$dst),
2225             (KMOVBmk addr:$dst, (COPY_TO_REGCLASS VK4:$src, VK8))>;
2226   def : Pat<(store VK2:$src, addr:$dst),
2227             (KMOVBmk addr:$dst, (COPY_TO_REGCLASS VK2:$src, VK8))>;
2228   def : Pat<(store VK1:$src, addr:$dst),
2229             (KMOVBmk addr:$dst, (COPY_TO_REGCLASS VK1:$src, VK8))>;
2230
2231   def : Pat<(v2i1 (load addr:$src)),
2232             (COPY_TO_REGCLASS (KMOVBkm addr:$src), VK2)>;
2233   def : Pat<(v4i1 (load addr:$src)),
2234             (COPY_TO_REGCLASS (KMOVBkm addr:$src), VK4)>;
2235 }
2236 let Predicates = [HasAVX512, NoDQI] in {
2237   def : Pat<(store VK1:$src, addr:$dst),
2238             (MOV8mr addr:$dst,
2239              (i8 (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK1:$src, GR32)),
2240               sub_8bit)))>;
2241   def : Pat<(store VK2:$src, addr:$dst),
2242             (MOV8mr addr:$dst,
2243              (i8 (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK2:$src, GR32)),
2244               sub_8bit)))>;
2245   def : Pat<(store VK4:$src, addr:$dst),
2246             (MOV8mr addr:$dst,
2247              (i8 (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK4:$src, GR32)),
2248               sub_8bit)))>;
2249   def : Pat<(store VK8:$src, addr:$dst),
2250             (MOV8mr addr:$dst,
2251              (i8 (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS VK8:$src, GR32)),
2252               sub_8bit)))>;
2253
2254   def : Pat<(v8i1 (load addr:$src)),
2255             (COPY_TO_REGCLASS (MOVZX32rm8 addr:$src), VK8)>;
2256   def : Pat<(v2i1 (load addr:$src)),
2257             (COPY_TO_REGCLASS (MOVZX32rm8 addr:$src), VK2)>;
2258   def : Pat<(v4i1 (load addr:$src)),
2259             (COPY_TO_REGCLASS (MOVZX32rm8 addr:$src), VK4)>;
2260 }
2261
2262 let Predicates = [HasAVX512] in {
2263   def : Pat<(store (i16 (bitconvert (v16i1 VK16:$src))), addr:$dst),
2264             (KMOVWmk addr:$dst, VK16:$src)>;
2265   def : Pat<(v1i1 (load addr:$src)),
2266             (COPY_TO_REGCLASS (AND32ri8 (MOVZX32rm8 addr:$src), (i32 1)), VK1)>;
2267   def : Pat<(v16i1 (bitconvert (i16 (load addr:$src)))),
2268             (KMOVWkm addr:$src)>;
2269 }
2270 let Predicates = [HasBWI] in {
2271   def : Pat<(store (i32 (bitconvert (v32i1 VK32:$src))), addr:$dst),
2272             (KMOVDmk addr:$dst, VK32:$src)>;
2273   def : Pat<(v32i1 (bitconvert (i32 (load addr:$src)))),
2274             (KMOVDkm addr:$src)>;
2275   def : Pat<(store (i64 (bitconvert (v64i1 VK64:$src))), addr:$dst),
2276             (KMOVQmk addr:$dst, VK64:$src)>;
2277   def : Pat<(v64i1 (bitconvert (i64 (load addr:$src)))),
2278             (KMOVQkm addr:$src)>;
2279 }
2280
2281 let Predicates = [HasAVX512] in {
2282   multiclass operation_gpr_mask_copy_lowering<RegisterClass maskRC, ValueType maskVT> {
2283     def : Pat<(maskVT (scalar_to_vector GR32:$src)),
2284               (COPY_TO_REGCLASS GR32:$src, maskRC)>;
2285
2286     def : Pat<(i32 (X86Vextract maskRC:$src, (iPTR 0))),
2287               (COPY_TO_REGCLASS maskRC:$src, GR32)>;
2288
2289     def : Pat<(maskVT (scalar_to_vector GR8:$src)),
2290               (COPY_TO_REGCLASS (INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$src, sub_8bit), maskRC)>;
2291
2292     def : Pat<(i8 (X86Vextract maskRC:$src, (iPTR 0))),
2293               (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS maskRC:$src, GR32)), sub_8bit)>;
2294
2295     def : Pat<(i32 (anyext (i8 (X86Vextract maskRC:$src, (iPTR 0))))),
2296               (COPY_TO_REGCLASS maskRC:$src, GR32)>;
2297   }
2298
2299   defm : operation_gpr_mask_copy_lowering<VK1,  v1i1>;
2300   defm : operation_gpr_mask_copy_lowering<VK2,  v2i1>;
2301   defm : operation_gpr_mask_copy_lowering<VK4,  v4i1>;
2302   defm : operation_gpr_mask_copy_lowering<VK8,  v8i1>;
2303   defm : operation_gpr_mask_copy_lowering<VK16,  v16i1>;
2304   defm : operation_gpr_mask_copy_lowering<VK32,  v32i1>;
2305   defm : operation_gpr_mask_copy_lowering<VK64,  v64i1>;
2306
2307   def : Pat<(X86kshiftr  (X86kshiftl (v1i1 (scalar_to_vector GR8:$src)), (i8 15)), (i8 15)) ,
2308           (COPY_TO_REGCLASS
2309                 (KMOVWkr (AND32ri8 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
2310                                             GR8:$src, sub_8bit), (i32 1))), VK1)>;
2311   def : Pat<(X86kshiftr  (X86kshiftl (v16i1 (scalar_to_vector GR8:$src)), (i8 15)), (i8 15)) ,
2312             (COPY_TO_REGCLASS
2313                 (KMOVWkr (AND32ri8 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
2314                                             GR8:$src, sub_8bit), (i32 1))), VK16)>;
2315   def : Pat<(X86kshiftr  (X86kshiftl (v8i1 (scalar_to_vector GR8:$src)), (i8 15)), (i8 15)) ,
2316          (COPY_TO_REGCLASS
2317           (KMOVWkr (AND32ri8 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
2318                                             GR8:$src, sub_8bit), (i32 1))), VK8)>;
2319
2320 }
2321
2322 // Mask unary operation
2323 // - KNOT
2324 multiclass avx512_mask_unop<bits<8> opc, string OpcodeStr,
2325                             RegisterClass KRC, SDPatternOperator OpNode,
2326                             Predicate prd> {
2327   let Predicates = [prd] in
2328     def rr : I<opc, MRMSrcReg, (outs KRC:$dst), (ins KRC:$src),
2329                !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2330                [(set KRC:$dst, (OpNode KRC:$src))]>;
2331 }
2332
2333 multiclass avx512_mask_unop_all<bits<8> opc, string OpcodeStr,
2334                                 SDPatternOperator OpNode> {
2335   defm B : avx512_mask_unop<opc, !strconcat(OpcodeStr, "b"), VK8, OpNode,
2336                             HasDQI>, VEX, PD;
2337   defm W : avx512_mask_unop<opc, !strconcat(OpcodeStr, "w"), VK16, OpNode,
2338                             HasAVX512>, VEX, PS;
2339   defm D : avx512_mask_unop<opc, !strconcat(OpcodeStr, "d"), VK32, OpNode,
2340                             HasBWI>, VEX, PD, VEX_W;
2341   defm Q : avx512_mask_unop<opc, !strconcat(OpcodeStr, "q"), VK64, OpNode,
2342                             HasBWI>, VEX, PS, VEX_W;
2343 }
2344
2345 defm KNOT : avx512_mask_unop_all<0x44, "knot", vnot>;
2346
2347 // KNL does not support KMOVB, 8-bit mask is promoted to 16-bit
2348 let Predicates = [HasAVX512, NoDQI] in
2349 def : Pat<(vnot VK8:$src),
2350           (COPY_TO_REGCLASS (KNOTWrr (COPY_TO_REGCLASS VK8:$src, VK16)), VK8)>;
2351
2352 def : Pat<(vnot VK4:$src),
2353           (COPY_TO_REGCLASS (KNOTWrr (COPY_TO_REGCLASS VK4:$src, VK16)), VK4)>;
2354 def : Pat<(vnot VK2:$src),
2355           (COPY_TO_REGCLASS (KNOTWrr (COPY_TO_REGCLASS VK2:$src, VK16)), VK2)>;
2356
2357 // Mask binary operation
2358 // - KAND, KANDN, KOR, KXNOR, KXOR
2359 multiclass avx512_mask_binop<bits<8> opc, string OpcodeStr,
2360                            RegisterClass KRC, SDPatternOperator OpNode,
2361                            Predicate prd, bit IsCommutable> {
2362   let Predicates = [prd], isCommutable = IsCommutable in
2363     def rr : I<opc, MRMSrcReg, (outs KRC:$dst), (ins KRC:$src1, KRC:$src2),
2364                !strconcat(OpcodeStr,
2365                           "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
2366                [(set KRC:$dst, (OpNode KRC:$src1, KRC:$src2))]>;
2367 }
2368
2369 multiclass avx512_mask_binop_all<bits<8> opc, string OpcodeStr,
2370                                SDPatternOperator OpNode, bit IsCommutable,
2371                                Predicate prdW = HasAVX512> {
2372   defm B : avx512_mask_binop<opc, !strconcat(OpcodeStr, "b"), VK8, OpNode,
2373                              HasDQI, IsCommutable>, VEX_4V, VEX_L, PD;
2374   defm W : avx512_mask_binop<opc, !strconcat(OpcodeStr, "w"), VK16, OpNode,
2375                              prdW, IsCommutable>, VEX_4V, VEX_L, PS;
2376   defm D : avx512_mask_binop<opc, !strconcat(OpcodeStr, "d"), VK32, OpNode,
2377                              HasBWI, IsCommutable>, VEX_4V, VEX_L, VEX_W, PD;
2378   defm Q : avx512_mask_binop<opc, !strconcat(OpcodeStr, "q"), VK64, OpNode,
2379                              HasBWI, IsCommutable>, VEX_4V, VEX_L, VEX_W, PS;
2380 }
2381
2382 def andn : PatFrag<(ops node:$i0, node:$i1), (and (not node:$i0), node:$i1)>;
2383 def xnor : PatFrag<(ops node:$i0, node:$i1), (not (xor node:$i0, node:$i1))>;
2384 // These nodes use 'vnot' instead of 'not' to support vectors.
2385 def vandn : PatFrag<(ops node:$i0, node:$i1), (and (vnot node:$i0), node:$i1)>;
2386 def vxnor : PatFrag<(ops node:$i0, node:$i1), (vnot (xor node:$i0, node:$i1))>;
2387
2388 defm KAND  : avx512_mask_binop_all<0x41, "kand",  and,   1>;
2389 defm KOR   : avx512_mask_binop_all<0x45, "kor",   or,    1>;
2390 defm KXNOR : avx512_mask_binop_all<0x46, "kxnor", vxnor, 1>;
2391 defm KXOR  : avx512_mask_binop_all<0x47, "kxor",  xor,   1>;
2392 defm KANDN : avx512_mask_binop_all<0x42, "kandn", vandn, 0>;
2393 defm KADD  : avx512_mask_binop_all<0x4A, "kadd",  add,   1, HasDQI>;
2394
2395 multiclass avx512_binop_pat<SDPatternOperator VOpNode, SDPatternOperator OpNode,
2396                             Instruction Inst> {
2397   // With AVX512F, 8-bit mask is promoted to 16-bit mask,
2398   // for the DQI set, this type is legal and KxxxB instruction is used
2399   let Predicates = [NoDQI] in
2400   def : Pat<(VOpNode VK8:$src1, VK8:$src2),
2401             (COPY_TO_REGCLASS
2402               (Inst (COPY_TO_REGCLASS VK8:$src1, VK16),
2403                     (COPY_TO_REGCLASS VK8:$src2, VK16)), VK8)>;
2404
2405   // All types smaller than 8 bits require conversion anyway
2406   def : Pat<(OpNode VK1:$src1, VK1:$src2),
2407         (COPY_TO_REGCLASS (Inst
2408                            (COPY_TO_REGCLASS VK1:$src1, VK16),
2409                            (COPY_TO_REGCLASS VK1:$src2, VK16)), VK1)>;
2410   def : Pat<(VOpNode VK2:$src1, VK2:$src2),
2411         (COPY_TO_REGCLASS (Inst
2412                            (COPY_TO_REGCLASS VK2:$src1, VK16),
2413                            (COPY_TO_REGCLASS VK2:$src2, VK16)), VK1)>;
2414   def : Pat<(VOpNode VK4:$src1, VK4:$src2),
2415         (COPY_TO_REGCLASS (Inst
2416                            (COPY_TO_REGCLASS VK4:$src1, VK16),
2417                            (COPY_TO_REGCLASS VK4:$src2, VK16)), VK1)>;
2418 }
2419
2420 defm : avx512_binop_pat<and,   and,  KANDWrr>;
2421 defm : avx512_binop_pat<vandn, andn, KANDNWrr>;
2422 defm : avx512_binop_pat<or,    or,   KORWrr>;
2423 defm : avx512_binop_pat<vxnor, xnor, KXNORWrr>;
2424 defm : avx512_binop_pat<xor,   xor,  KXORWrr>;
2425
2426 // Mask unpacking
2427 multiclass avx512_mask_unpck<string Suffix,RegisterClass KRC, ValueType VT,
2428                              RegisterClass KRCSrc, Predicate prd> {
2429   let Predicates = [prd] in {
2430     let hasSideEffects = 0 in
2431     def rr : I<0x4b, MRMSrcReg, (outs KRC:$dst),
2432                (ins KRC:$src1, KRC:$src2),
2433                "kunpck"#Suffix#"\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
2434                VEX_4V, VEX_L;
2435
2436     def : Pat<(VT (concat_vectors KRCSrc:$src1, KRCSrc:$src2)),
2437               (!cast<Instruction>(NAME##rr)
2438                         (COPY_TO_REGCLASS KRCSrc:$src2, KRC),
2439                         (COPY_TO_REGCLASS KRCSrc:$src1, KRC))>;
2440   }
2441 }
2442
2443 defm KUNPCKBW : avx512_mask_unpck<"bw", VK16, v16i1, VK8, HasAVX512>, PD;
2444 defm KUNPCKWD : avx512_mask_unpck<"wd", VK32, v32i1, VK16, HasBWI>, PS;
2445 defm KUNPCKDQ : avx512_mask_unpck<"dq", VK64, v64i1, VK32, HasBWI>, PS, VEX_W;
2446
2447 // Mask bit testing
2448 multiclass avx512_mask_testop<bits<8> opc, string OpcodeStr, RegisterClass KRC,
2449                               SDNode OpNode, Predicate prd> {
2450   let Predicates = [prd], Defs = [EFLAGS] in
2451     def rr : I<opc, MRMSrcReg, (outs), (ins KRC:$src1, KRC:$src2),
2452                !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2453                [(set EFLAGS, (OpNode KRC:$src1, KRC:$src2))]>;
2454 }
2455
2456 multiclass avx512_mask_testop_w<bits<8> opc, string OpcodeStr, SDNode OpNode,
2457                                 Predicate prdW = HasAVX512> {
2458   defm B : avx512_mask_testop<opc, OpcodeStr#"b", VK8, OpNode, HasDQI>,
2459                                                                 VEX, PD;
2460   defm W : avx512_mask_testop<opc, OpcodeStr#"w", VK16, OpNode, prdW>,
2461                                                                 VEX, PS;
2462   defm Q : avx512_mask_testop<opc, OpcodeStr#"q", VK64, OpNode, HasBWI>,
2463                                                                 VEX, PS, VEX_W;
2464   defm D : avx512_mask_testop<opc, OpcodeStr#"d", VK32, OpNode, HasBWI>,
2465                                                                 VEX, PD, VEX_W;
2466 }
2467
2468 defm KORTEST : avx512_mask_testop_w<0x98, "kortest", X86kortest>;
2469 defm KTEST   : avx512_mask_testop_w<0x99, "ktest", X86ktest, HasDQI>;
2470
2471 // Mask shift
2472 multiclass avx512_mask_shiftop<bits<8> opc, string OpcodeStr, RegisterClass KRC,
2473                              SDNode OpNode> {
2474   let Predicates = [HasAVX512] in
2475     def ri : Ii8<opc, MRMSrcReg, (outs KRC:$dst), (ins KRC:$src, u8imm:$imm),
2476                  !strconcat(OpcodeStr,
2477                             "\t{$imm, $src, $dst|$dst, $src, $imm}"),
2478                             [(set KRC:$dst, (OpNode KRC:$src, (i8 imm:$imm)))]>;
2479 }
2480
2481 multiclass avx512_mask_shiftop_w<bits<8> opc1, bits<8> opc2, string OpcodeStr,
2482                                SDNode OpNode> {
2483   defm W : avx512_mask_shiftop<opc1, !strconcat(OpcodeStr, "w"), VK16, OpNode>,
2484                                VEX, TAPD, VEX_W;
2485   let Predicates = [HasDQI] in
2486   defm B : avx512_mask_shiftop<opc1, !strconcat(OpcodeStr, "b"), VK8, OpNode>,
2487                                VEX, TAPD;
2488   let Predicates = [HasBWI] in {
2489   defm Q : avx512_mask_shiftop<opc2, !strconcat(OpcodeStr, "q"), VK64, OpNode>,
2490                                VEX, TAPD, VEX_W;
2491   defm D : avx512_mask_shiftop<opc2, !strconcat(OpcodeStr, "d"), VK32, OpNode>,
2492                                VEX, TAPD;
2493   }
2494 }
2495
2496 defm KSHIFTL : avx512_mask_shiftop_w<0x32, 0x33, "kshiftl", X86kshiftl>;
2497 defm KSHIFTR : avx512_mask_shiftop_w<0x30, 0x31, "kshiftr", X86kshiftr>;
2498
2499 // Mask setting all 0s or 1s
2500 multiclass avx512_mask_setop<RegisterClass KRC, ValueType VT, PatFrag Val> {
2501   let Predicates = [HasAVX512] in
2502     let isReMaterializable = 1, isAsCheapAsAMove = 1, isPseudo = 1 in
2503       def #NAME# : I<0, Pseudo, (outs KRC:$dst), (ins), "",
2504                      [(set KRC:$dst, (VT Val))]>;
2505 }
2506
2507 multiclass avx512_mask_setop_w<PatFrag Val> {
2508   defm W : avx512_mask_setop<VK16, v16i1, Val>;
2509   defm D : avx512_mask_setop<VK32,  v32i1, Val>;
2510   defm Q : avx512_mask_setop<VK64, v64i1, Val>;
2511 }
2512
2513 defm KSET0 : avx512_mask_setop_w<immAllZerosV>;
2514 defm KSET1 : avx512_mask_setop_w<immAllOnesV>;
2515
2516 // With AVX-512 only, 8-bit mask is promoted to 16-bit mask.
2517 let Predicates = [HasAVX512] in {
2518   def : Pat<(v8i1 immAllZerosV), (COPY_TO_REGCLASS (KSET0W), VK8)>;
2519   def : Pat<(v4i1 immAllZerosV), (COPY_TO_REGCLASS (KSET0W), VK4)>;
2520   def : Pat<(v2i1 immAllZerosV), (COPY_TO_REGCLASS (KSET0W), VK2)>;
2521   def : Pat<(v1i1 immAllZerosV), (COPY_TO_REGCLASS (KSET0W), VK1)>;
2522   def : Pat<(v8i1 immAllOnesV),  (COPY_TO_REGCLASS (KSET1W), VK8)>;
2523   def : Pat<(v4i1 immAllOnesV),  (COPY_TO_REGCLASS (KSET1W), VK4)>;
2524   def : Pat<(v2i1 immAllOnesV),  (COPY_TO_REGCLASS (KSET1W), VK2)>;
2525   def : Pat<(v1i1 immAllOnesV),  (COPY_TO_REGCLASS (KSET1W), VK1)>;
2526 }
2527
2528 // Patterns for kmask insert_subvector/extract_subvector to/from index=0
2529 multiclass operation_subvector_mask_lowering<RegisterClass subRC, ValueType subVT,
2530                                              RegisterClass RC, ValueType VT> {
2531   def : Pat<(subVT (extract_subvector (VT RC:$src), (iPTR 0))),
2532             (subVT (COPY_TO_REGCLASS RC:$src, subRC))>;
2533
2534   def : Pat<(VT (insert_subvector undef, subRC:$src, (iPTR 0))),
2535             (VT (COPY_TO_REGCLASS subRC:$src, RC))>;
2536 }
2537 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK2,  v2i1>;
2538 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK4,  v4i1>;
2539 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK8,  v8i1>;
2540 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK16, v16i1>;
2541 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK32, v32i1>;
2542 defm : operation_subvector_mask_lowering<VK1,  v1i1,  VK64, v64i1>;
2543
2544 defm : operation_subvector_mask_lowering<VK2,  v2i1,  VK4,  v4i1>;
2545 defm : operation_subvector_mask_lowering<VK2,  v2i1,  VK8,  v8i1>;
2546 defm : operation_subvector_mask_lowering<VK2,  v2i1,  VK16, v16i1>;
2547 defm : operation_subvector_mask_lowering<VK2,  v2i1,  VK32, v32i1>;
2548 defm : operation_subvector_mask_lowering<VK2,  v2i1,  VK64, v64i1>;
2549
2550 defm : operation_subvector_mask_lowering<VK4,  v4i1,  VK8,  v8i1>;
2551 defm : operation_subvector_mask_lowering<VK4,  v4i1,  VK16, v16i1>;
2552 defm : operation_subvector_mask_lowering<VK4,  v4i1,  VK32, v32i1>;
2553 defm : operation_subvector_mask_lowering<VK4,  v4i1,  VK64, v64i1>;
2554
2555 defm : operation_subvector_mask_lowering<VK8,  v8i1,  VK16, v16i1>;
2556 defm : operation_subvector_mask_lowering<VK8,  v8i1,  VK32, v32i1>;
2557 defm : operation_subvector_mask_lowering<VK8,  v8i1,  VK64, v64i1>;
2558
2559 defm : operation_subvector_mask_lowering<VK16, v16i1, VK32, v32i1>;
2560 defm : operation_subvector_mask_lowering<VK16, v16i1, VK64, v64i1>;
2561
2562 defm : operation_subvector_mask_lowering<VK32, v32i1, VK64, v64i1>;
2563
2564 def : Pat<(v2i1 (extract_subvector (v4i1 VK4:$src), (iPTR 2))),
2565           (v2i1 (COPY_TO_REGCLASS
2566                   (KSHIFTRWri (COPY_TO_REGCLASS VK4:$src, VK16), (i8 2)),
2567                    VK2))>;
2568 def : Pat<(v4i1 (extract_subvector (v8i1 VK8:$src), (iPTR 4))),
2569           (v4i1 (COPY_TO_REGCLASS
2570                   (KSHIFTRWri (COPY_TO_REGCLASS VK8:$src, VK16), (i8 4)),
2571                    VK4))>;
2572 def : Pat<(v8i1 (extract_subvector (v16i1 VK16:$src), (iPTR 8))),
2573           (v8i1 (COPY_TO_REGCLASS (KSHIFTRWri VK16:$src, (i8 8)), VK8))>;
2574 def : Pat<(v16i1 (extract_subvector (v32i1 VK32:$src), (iPTR 16))),
2575           (v16i1 (COPY_TO_REGCLASS (KSHIFTRDri VK32:$src, (i8 16)), VK16))>;
2576 def : Pat<(v32i1 (extract_subvector (v64i1 VK64:$src), (iPTR 32))),
2577           (v32i1 (COPY_TO_REGCLASS (KSHIFTRQri VK64:$src, (i8 32)), VK32))>;
2578
2579
2580 // Patterns for kmask shift
2581 multiclass mask_shift_lowering<RegisterClass RC, ValueType VT> {
2582   def : Pat<(VT (X86kshiftl RC:$src, (i8 imm:$imm))),
2583             (VT (COPY_TO_REGCLASS
2584                    (KSHIFTLWri (COPY_TO_REGCLASS RC:$src, VK16),
2585                                (I8Imm $imm)),
2586                    RC))>;
2587   def : Pat<(VT (X86kshiftr RC:$src, (i8 imm:$imm))),
2588             (VT (COPY_TO_REGCLASS
2589                    (KSHIFTRWri (COPY_TO_REGCLASS RC:$src, VK16),
2590                                (I8Imm $imm)),
2591                    RC))>;
2592 }
2593
2594 defm : mask_shift_lowering<VK8, v8i1>, Requires<[HasAVX512, NoDQI]>;
2595 defm : mask_shift_lowering<VK4, v4i1>, Requires<[HasAVX512]>;
2596 defm : mask_shift_lowering<VK2, v2i1>, Requires<[HasAVX512]>;
2597 //===----------------------------------------------------------------------===//
2598 // AVX-512 - Aligned and unaligned load and store
2599 //
2600
2601
2602 multiclass avx512_load<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
2603                          PatFrag ld_frag, PatFrag mload,
2604                          SDPatternOperator SelectOprr = vselect> {
2605   let hasSideEffects = 0 in {
2606   def rr : AVX512PI<opc, MRMSrcReg, (outs _.RC:$dst), (ins _.RC:$src),
2607                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"), [],
2608                     _.ExeDomain>, EVEX;
2609   def rrkz : AVX512PI<opc, MRMSrcReg, (outs _.RC:$dst),
2610                       (ins _.KRCWM:$mask,  _.RC:$src),
2611                       !strconcat(OpcodeStr, "\t{$src, ${dst} {${mask}} {z}|",
2612                        "${dst} {${mask}} {z}, $src}"),
2613                        [(set _.RC:$dst, (_.VT (SelectOprr _.KRCWM:$mask,
2614                                            (_.VT _.RC:$src),
2615                                            _.ImmAllZerosV)))], _.ExeDomain>,
2616                        EVEX, EVEX_KZ;
2617
2618   let canFoldAsLoad = 1, isReMaterializable = 1,
2619       SchedRW = [WriteLoad] in
2620   def rm : AVX512PI<opc, MRMSrcMem, (outs _.RC:$dst), (ins _.MemOp:$src),
2621                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2622                     [(set _.RC:$dst, (_.VT (bitconvert (ld_frag addr:$src))))],
2623                     _.ExeDomain>, EVEX;
2624
2625   let Constraints = "$src0 = $dst", isConvertibleToThreeAddress = 1 in {
2626   def rrk : AVX512PI<opc, MRMSrcReg, (outs _.RC:$dst),
2627                     (ins _.RC:$src0, _.KRCWM:$mask, _.RC:$src1),
2628                     !strconcat(OpcodeStr, "\t{$src1, ${dst} {${mask}}|",
2629                     "${dst} {${mask}}, $src1}"),
2630                     [(set _.RC:$dst, (_.VT (SelectOprr _.KRCWM:$mask,
2631                                         (_.VT _.RC:$src1),
2632                                         (_.VT _.RC:$src0))))], _.ExeDomain>,
2633                      EVEX, EVEX_K;
2634     let SchedRW = [WriteLoad] in
2635     def rmk : AVX512PI<opc, MRMSrcMem, (outs _.RC:$dst),
2636                      (ins _.RC:$src0, _.KRCWM:$mask, _.MemOp:$src1),
2637                      !strconcat(OpcodeStr, "\t{$src1, ${dst} {${mask}}|",
2638                       "${dst} {${mask}}, $src1}"),
2639                      [(set _.RC:$dst, (_.VT
2640                          (vselect _.KRCWM:$mask,
2641                           (_.VT (bitconvert (ld_frag addr:$src1))),
2642                            (_.VT _.RC:$src0))))], _.ExeDomain>, EVEX, EVEX_K;
2643   }
2644   let SchedRW = [WriteLoad] in
2645   def rmkz : AVX512PI<opc, MRMSrcMem, (outs _.RC:$dst),
2646                   (ins _.KRCWM:$mask, _.MemOp:$src),
2647                   OpcodeStr #"\t{$src, ${dst} {${mask}} {z}|"#
2648                                 "${dst} {${mask}} {z}, $src}",
2649                   [(set _.RC:$dst, (_.VT (vselect _.KRCWM:$mask,
2650                     (_.VT (bitconvert (ld_frag addr:$src))), _.ImmAllZerosV)))],
2651                   _.ExeDomain>, EVEX, EVEX_KZ;
2652   }
2653   def : Pat<(_.VT (mload addr:$ptr, _.KRCWM:$mask, undef)),
2654             (!cast<Instruction>(NAME#_.ZSuffix##rmkz) _.KRCWM:$mask, addr:$ptr)>;
2655
2656   def : Pat<(_.VT (mload addr:$ptr, _.KRCWM:$mask, _.ImmAllZerosV)),
2657             (!cast<Instruction>(NAME#_.ZSuffix##rmkz) _.KRCWM:$mask, addr:$ptr)>;
2658
2659   def : Pat<(_.VT (mload addr:$ptr, _.KRCWM:$mask, (_.VT _.RC:$src0))),
2660             (!cast<Instruction>(NAME#_.ZSuffix##rmk) _.RC:$src0,
2661              _.KRCWM:$mask, addr:$ptr)>;
2662 }
2663
2664 multiclass avx512_alignedload_vl<bits<8> opc, string OpcodeStr,
2665                                   AVX512VLVectorVTInfo _,
2666                                   Predicate prd> {
2667   let Predicates = [prd] in
2668   defm Z : avx512_load<opc, OpcodeStr, _.info512, _.info512.AlignedLdFrag,
2669                        masked_load_aligned512>, EVEX_V512;
2670
2671   let Predicates = [prd, HasVLX] in {
2672   defm Z256 : avx512_load<opc, OpcodeStr, _.info256, _.info256.AlignedLdFrag,
2673                           masked_load_aligned256>, EVEX_V256;
2674   defm Z128 : avx512_load<opc, OpcodeStr, _.info128, _.info128.AlignedLdFrag,
2675                           masked_load_aligned128>, EVEX_V128;
2676   }
2677 }
2678
2679 multiclass avx512_load_vl<bits<8> opc, string OpcodeStr,
2680                                   AVX512VLVectorVTInfo _,
2681                                   Predicate prd,
2682                                   SDPatternOperator SelectOprr = vselect> {
2683   let Predicates = [prd] in
2684   defm Z : avx512_load<opc, OpcodeStr, _.info512, _.info512.LdFrag,
2685                        masked_load_unaligned, SelectOprr>, EVEX_V512;
2686
2687   let Predicates = [prd, HasVLX] in {
2688   defm Z256 : avx512_load<opc, OpcodeStr, _.info256, _.info256.LdFrag,
2689                          masked_load_unaligned, SelectOprr>, EVEX_V256;
2690   defm Z128 : avx512_load<opc, OpcodeStr, _.info128, _.info128.LdFrag,
2691                          masked_load_unaligned, SelectOprr>, EVEX_V128;
2692   }
2693 }
2694
2695 multiclass avx512_store<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
2696                         PatFrag st_frag, PatFrag mstore> {
2697
2698   let hasSideEffects = 0 in {
2699   def rr_REV  : AVX512PI<opc, MRMDestReg, (outs _.RC:$dst), (ins _.RC:$src),
2700                          OpcodeStr # ".s\t{$src, $dst|$dst, $src}",
2701                          [], _.ExeDomain>, EVEX;
2702   def rrk_REV : AVX512PI<opc, MRMDestReg, (outs  _.RC:$dst),
2703                          (ins _.KRCWM:$mask, _.RC:$src),
2704                          OpcodeStr # ".s\t{$src, ${dst} {${mask}}|"#
2705                          "${dst} {${mask}}, $src}",
2706                          [], _.ExeDomain>,  EVEX, EVEX_K;
2707   def rrkz_REV : AVX512PI<opc, MRMDestReg, (outs  _.RC:$dst),
2708                           (ins _.KRCWM:$mask, _.RC:$src),
2709                           OpcodeStr # ".s\t{$src, ${dst} {${mask}} {z}|" #
2710                           "${dst} {${mask}} {z}, $src}",
2711                           [], _.ExeDomain>, EVEX, EVEX_KZ;
2712   }
2713
2714   def mr : AVX512PI<opc, MRMDestMem, (outs), (ins _.MemOp:$dst, _.RC:$src),
2715                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2716                     [(st_frag (_.VT _.RC:$src), addr:$dst)], _.ExeDomain>, EVEX;
2717   def mrk : AVX512PI<opc, MRMDestMem, (outs),
2718                      (ins _.MemOp:$dst, _.KRCWM:$mask, _.RC:$src),
2719               OpcodeStr # "\t{$src, ${dst} {${mask}}|${dst} {${mask}}, $src}",
2720                [], _.ExeDomain>, EVEX, EVEX_K;
2721
2722   def: Pat<(mstore addr:$ptr, _.KRCWM:$mask, (_.VT _.RC:$src)),
2723            (!cast<Instruction>(NAME#_.ZSuffix##mrk) addr:$ptr,
2724                                                     _.KRCWM:$mask, _.RC:$src)>;
2725 }
2726
2727
2728 multiclass avx512_store_vl< bits<8> opc, string OpcodeStr,
2729                             AVX512VLVectorVTInfo _, Predicate prd> {
2730   let Predicates = [prd] in
2731   defm Z : avx512_store<opc, OpcodeStr, _.info512, store,
2732                         masked_store_unaligned>, EVEX_V512;
2733
2734   let Predicates = [prd, HasVLX] in {
2735     defm Z256 : avx512_store<opc, OpcodeStr, _.info256, store,
2736                              masked_store_unaligned>, EVEX_V256;
2737     defm Z128 : avx512_store<opc, OpcodeStr, _.info128, store,
2738                              masked_store_unaligned>, EVEX_V128;
2739   }
2740 }
2741
2742 multiclass avx512_alignedstore_vl<bits<8> opc, string OpcodeStr,
2743                                   AVX512VLVectorVTInfo _,  Predicate prd> {
2744   let Predicates = [prd] in
2745   defm Z : avx512_store<opc, OpcodeStr, _.info512, alignedstore512,
2746                         masked_store_aligned512>, EVEX_V512;
2747
2748   let Predicates = [prd, HasVLX] in {
2749     defm Z256 : avx512_store<opc, OpcodeStr, _.info256, alignedstore256,
2750                              masked_store_aligned256>, EVEX_V256;
2751     defm Z128 : avx512_store<opc, OpcodeStr, _.info128, alignedstore,
2752                              masked_store_aligned128>, EVEX_V128;
2753   }
2754 }
2755
2756 defm VMOVAPS : avx512_alignedload_vl<0x28, "vmovaps", avx512vl_f32_info,
2757                                      HasAVX512>,
2758                avx512_alignedstore_vl<0x29, "vmovaps", avx512vl_f32_info,
2759                                       HasAVX512>,  PS, EVEX_CD8<32, CD8VF>;
2760
2761 defm VMOVAPD : avx512_alignedload_vl<0x28, "vmovapd", avx512vl_f64_info,
2762                                      HasAVX512>,
2763                avx512_alignedstore_vl<0x29, "vmovapd", avx512vl_f64_info,
2764                                      HasAVX512>, PD, VEX_W, EVEX_CD8<64, CD8VF>;
2765
2766 defm VMOVUPS : avx512_load_vl<0x10, "vmovups", avx512vl_f32_info, HasAVX512,
2767                               null_frag>,
2768                avx512_store_vl<0x11, "vmovups", avx512vl_f32_info, HasAVX512>,
2769                               PS, EVEX_CD8<32, CD8VF>;
2770
2771 defm VMOVUPD : avx512_load_vl<0x10, "vmovupd", avx512vl_f64_info, HasAVX512,
2772                               null_frag>,
2773                avx512_store_vl<0x11, "vmovupd", avx512vl_f64_info, HasAVX512>,
2774                PD, VEX_W, EVEX_CD8<64, CD8VF>;
2775
2776 defm VMOVDQA32 : avx512_alignedload_vl<0x6F, "vmovdqa32", avx512vl_i32_info,
2777                                        HasAVX512>,
2778                  avx512_alignedstore_vl<0x7F, "vmovdqa32", avx512vl_i32_info,
2779                                        HasAVX512>, PD, EVEX_CD8<32, CD8VF>;
2780
2781 defm VMOVDQA64 : avx512_alignedload_vl<0x6F, "vmovdqa64", avx512vl_i64_info,
2782                                        HasAVX512>,
2783                  avx512_alignedstore_vl<0x7F, "vmovdqa64", avx512vl_i64_info,
2784                                     HasAVX512>, PD, VEX_W, EVEX_CD8<64, CD8VF>;
2785
2786 defm VMOVDQU8 : avx512_load_vl<0x6F, "vmovdqu8", avx512vl_i8_info, HasBWI>,
2787                  avx512_store_vl<0x7F, "vmovdqu8", avx512vl_i8_info,
2788                                  HasBWI>, XD, EVEX_CD8<8, CD8VF>;
2789
2790 defm VMOVDQU16 : avx512_load_vl<0x6F, "vmovdqu16", avx512vl_i16_info, HasBWI>,
2791                  avx512_store_vl<0x7F, "vmovdqu16", avx512vl_i16_info,
2792                                  HasBWI>, XD, VEX_W, EVEX_CD8<16, CD8VF>;
2793
2794 defm VMOVDQU32 : avx512_load_vl<0x6F, "vmovdqu32", avx512vl_i32_info, HasAVX512,
2795                                 null_frag>,
2796                  avx512_store_vl<0x7F, "vmovdqu32", avx512vl_i32_info,
2797                                  HasAVX512>, XS, EVEX_CD8<32, CD8VF>;
2798
2799 defm VMOVDQU64 : avx512_load_vl<0x6F, "vmovdqu64", avx512vl_i64_info, HasAVX512,
2800                                 null_frag>,
2801                  avx512_store_vl<0x7F, "vmovdqu64", avx512vl_i64_info,
2802                                  HasAVX512>, XS, VEX_W, EVEX_CD8<64, CD8VF>;
2803
2804 // Special instructions to help with spilling when we don't have VLX. We need
2805 // to load or store from a ZMM register instead. These are converted in
2806 // expandPostRAPseudos.
2807 let isReMaterializable = 1, canFoldAsLoad = 1,
2808     isPseudo = 1, SchedRW = [WriteLoad], mayLoad = 1, hasSideEffects = 0 in {
2809 def VMOVAPSZ128rm_NOVLX : I<0, Pseudo, (outs VR128X:$dst), (ins f128mem:$src),
2810                             "", []>;
2811 def VMOVAPSZ256rm_NOVLX : I<0, Pseudo, (outs VR256X:$dst), (ins f256mem:$src),
2812                             "", []>;
2813 def VMOVUPSZ128rm_NOVLX : I<0, Pseudo, (outs VR128X:$dst), (ins f128mem:$src),
2814                             "", []>;
2815 def VMOVUPSZ256rm_NOVLX : I<0, Pseudo, (outs VR256X:$dst), (ins f256mem:$src),
2816                             "", []>;
2817 }
2818
2819 let isPseudo = 1, mayStore = 1, hasSideEffects = 0 in {
2820 def VMOVAPSZ128mr_NOVLX : I<0, Pseudo, (outs), (ins f128mem:$dst, VR128X:$src),
2821                             "", []>;
2822 def VMOVAPSZ256mr_NOVLX : I<0, Pseudo, (outs), (ins f256mem:$dst, VR256X:$src),
2823                             "", []>;
2824 def VMOVUPSZ128mr_NOVLX : I<0, Pseudo, (outs), (ins f128mem:$dst, VR128X:$src),
2825                             "", []>;
2826 def VMOVUPSZ256mr_NOVLX : I<0, Pseudo, (outs), (ins f256mem:$dst, VR256X:$src),
2827                             "", []>;
2828 }
2829
2830 def : Pat<(v8i64 (vselect VK8WM:$mask, (bc_v8i64 (v16i32 immAllZerosV)),
2831                           (v8i64 VR512:$src))),
2832    (VMOVDQA64Zrrkz (COPY_TO_REGCLASS (KNOTWrr (COPY_TO_REGCLASS VK8:$mask, VK16)),
2833                                               VK8), VR512:$src)>;
2834
2835 def : Pat<(v16i32 (vselect VK16WM:$mask, (v16i32 immAllZerosV),
2836                            (v16i32 VR512:$src))),
2837                   (VMOVDQA32Zrrkz (KNOTWrr VK16WM:$mask), VR512:$src)>;
2838
2839 // These patterns exist to prevent the above patterns from introducing a second
2840 // mask inversion when one already exists.
2841 def : Pat<(v8i64 (vselect (xor VK8:$mask, (v8i1 immAllOnesV)),
2842                           (bc_v8i64 (v16i32 immAllZerosV)),
2843                           (v8i64 VR512:$src))),
2844                  (VMOVDQA64Zrrkz VK8:$mask, VR512:$src)>;
2845 def : Pat<(v16i32 (vselect (xor VK16:$mask, (v16i1 immAllOnesV)),
2846                            (v16i32 immAllZerosV),
2847                            (v16i32 VR512:$src))),
2848                   (VMOVDQA32Zrrkz VK16WM:$mask, VR512:$src)>;
2849
2850 // Patterns for handling v8i1 selects of 256-bit vectors when VLX isn't
2851 // available. Use a 512-bit operation and extract.
2852 let Predicates = [HasAVX512, NoVLX] in {
2853 def : Pat<(v8f32 (vselect (v8i1 VK8WM:$mask), (v8f32 VR256X:$src1),
2854                           (v8f32 VR256X:$src0))),
2855           (EXTRACT_SUBREG
2856            (v16f32
2857             (VMOVAPSZrrk
2858              (v16f32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src0, sub_ymm)),
2859              (COPY_TO_REGCLASS VK8WM:$mask, VK16WM),
2860              (v16f32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)))),
2861            sub_ymm)>;
2862
2863 def : Pat<(v8i32 (vselect (v8i1 VK8WM:$mask), (v8i32 VR256X:$src1),
2864                           (v8i32 VR256X:$src0))),
2865           (EXTRACT_SUBREG
2866            (v16i32
2867             (VMOVDQA32Zrrk
2868              (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src0, sub_ymm)),
2869              (COPY_TO_REGCLASS VK8WM:$mask, VK16WM),
2870              (v16i32 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)))),
2871            sub_ymm)>;
2872 }
2873
2874 let Predicates = [HasVLX, NoBWI] in {
2875   // 128-bit load/store without BWI.
2876   def : Pat<(alignedstore (v8i16 VR128X:$src), addr:$dst),
2877             (VMOVDQA32Z128mr addr:$dst, VR128X:$src)>;
2878   def : Pat<(alignedstore (v16i8 VR128X:$src), addr:$dst),
2879             (VMOVDQA32Z128mr addr:$dst, VR128X:$src)>;
2880   def : Pat<(store (v8i16 VR128X:$src), addr:$dst),
2881             (VMOVDQU32Z128mr addr:$dst, VR128X:$src)>;
2882   def : Pat<(store (v16i8 VR128X:$src), addr:$dst),
2883             (VMOVDQU32Z128mr addr:$dst, VR128X:$src)>;
2884
2885   // 256-bit load/store without BWI.
2886   def : Pat<(alignedstore256 (v16i16 VR256X:$src), addr:$dst),
2887             (VMOVDQA32Z256mr addr:$dst, VR256X:$src)>;
2888   def : Pat<(alignedstore256 (v32i8 VR256X:$src), addr:$dst),
2889             (VMOVDQA32Z256mr addr:$dst, VR256X:$src)>;
2890   def : Pat<(store (v16i16 VR256X:$src), addr:$dst),
2891             (VMOVDQU32Z256mr addr:$dst, VR256X:$src)>;
2892   def : Pat<(store (v32i8 VR256X:$src), addr:$dst),
2893             (VMOVDQU32Z256mr addr:$dst, VR256X:$src)>;
2894 }
2895
2896 let Predicates = [HasVLX] in {
2897   // Special patterns for storing subvector extracts of lower 128-bits of 256.
2898   // Its cheaper to just use VMOVAPS/VMOVUPS instead of VEXTRACTF128mr
2899   def : Pat<(alignedstore (v2f64 (extract_subvector
2900                                   (v4f64 VR256X:$src), (iPTR 0))), addr:$dst),
2901      (VMOVAPDZ128mr addr:$dst, (v2f64 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2902   def : Pat<(alignedstore (v4f32 (extract_subvector
2903                                   (v8f32 VR256X:$src), (iPTR 0))), addr:$dst),
2904      (VMOVAPSZ128mr addr:$dst, (v4f32 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2905   def : Pat<(alignedstore (v2i64 (extract_subvector
2906                                   (v4i64 VR256X:$src), (iPTR 0))), addr:$dst),
2907      (VMOVDQA64Z128mr addr:$dst, (v2i64 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2908   def : Pat<(alignedstore (v4i32 (extract_subvector
2909                                   (v8i32 VR256X:$src), (iPTR 0))), addr:$dst),
2910      (VMOVDQA32Z128mr addr:$dst, (v4i32 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2911   def : Pat<(alignedstore (v8i16 (extract_subvector
2912                                   (v16i16 VR256X:$src), (iPTR 0))), addr:$dst),
2913      (VMOVDQA32Z128mr addr:$dst, (v8i16 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2914   def : Pat<(alignedstore (v16i8 (extract_subvector
2915                                   (v32i8 VR256X:$src), (iPTR 0))), addr:$dst),
2916      (VMOVDQA32Z128mr addr:$dst, (v16i8 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2917
2918   def : Pat<(store (v2f64 (extract_subvector
2919                            (v4f64 VR256X:$src), (iPTR 0))), addr:$dst),
2920      (VMOVUPDZ128mr addr:$dst, (v2f64 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2921   def : Pat<(store (v4f32 (extract_subvector
2922                            (v8f32 VR256X:$src), (iPTR 0))), addr:$dst),
2923      (VMOVUPSZ128mr addr:$dst, (v4f32 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2924   def : Pat<(store (v2i64 (extract_subvector
2925                            (v4i64 VR256X:$src), (iPTR 0))), addr:$dst),
2926      (VMOVDQU64Z128mr addr:$dst, (v2i64 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2927   def : Pat<(store (v4i32 (extract_subvector
2928                            (v8i32 VR256X:$src), (iPTR 0))), addr:$dst),
2929      (VMOVDQU32Z128mr addr:$dst, (v4i32 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2930   def : Pat<(store (v8i16 (extract_subvector
2931                            (v16i16 VR256X:$src), (iPTR 0))), addr:$dst),
2932      (VMOVDQU32Z128mr addr:$dst, (v8i16 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2933   def : Pat<(store (v16i8 (extract_subvector
2934                            (v32i8 VR256X:$src), (iPTR 0))), addr:$dst),
2935      (VMOVDQU32Z128mr addr:$dst, (v16i8 (EXTRACT_SUBREG VR256X:$src,sub_xmm)))>;
2936
2937   // Special patterns for storing subvector extracts of lower 128-bits of 512.
2938   // Its cheaper to just use VMOVAPS/VMOVUPS instead of VEXTRACTF128mr
2939   def : Pat<(alignedstore (v2f64 (extract_subvector
2940                                   (v8f64 VR512:$src), (iPTR 0))), addr:$dst),
2941      (VMOVAPDZ128mr addr:$dst, (v2f64 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2942   def : Pat<(alignedstore (v4f32 (extract_subvector
2943                                   (v16f32 VR512:$src), (iPTR 0))), addr:$dst),
2944      (VMOVAPSZ128mr addr:$dst, (v4f32 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2945   def : Pat<(alignedstore (v2i64 (extract_subvector
2946                                   (v8i64 VR512:$src), (iPTR 0))), addr:$dst),
2947      (VMOVDQA64Z128mr addr:$dst, (v2i64 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2948   def : Pat<(alignedstore (v4i32 (extract_subvector
2949                                   (v16i32 VR512:$src), (iPTR 0))), addr:$dst),
2950      (VMOVDQA32Z128mr addr:$dst, (v4i32 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2951   def : Pat<(alignedstore (v8i16 (extract_subvector
2952                                   (v32i16 VR512:$src), (iPTR 0))), addr:$dst),
2953      (VMOVDQA32Z128mr addr:$dst, (v8i16 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2954   def : Pat<(alignedstore (v16i8 (extract_subvector
2955                                   (v64i8 VR512:$src), (iPTR 0))), addr:$dst),
2956      (VMOVDQA32Z128mr addr:$dst, (v16i8 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2957
2958   def : Pat<(store (v2f64 (extract_subvector
2959                            (v8f64 VR512:$src), (iPTR 0))), addr:$dst),
2960      (VMOVUPDZ128mr addr:$dst, (v2f64 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2961   def : Pat<(store (v4f32 (extract_subvector
2962                            (v16f32 VR512:$src), (iPTR 0))), addr:$dst),
2963      (VMOVUPSZ128mr addr:$dst, (v4f32 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2964   def : Pat<(store (v2i64 (extract_subvector
2965                            (v8i64 VR512:$src), (iPTR 0))), addr:$dst),
2966      (VMOVDQU64Z128mr addr:$dst, (v2i64 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2967   def : Pat<(store (v4i32 (extract_subvector
2968                            (v16i32 VR512:$src), (iPTR 0))), addr:$dst),
2969      (VMOVDQU32Z128mr addr:$dst, (v4i32 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2970   def : Pat<(store (v8i16 (extract_subvector
2971                            (v32i16 VR512:$src), (iPTR 0))), addr:$dst),
2972      (VMOVDQU32Z128mr addr:$dst, (v8i16 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2973   def : Pat<(store (v16i8 (extract_subvector
2974                            (v64i8 VR512:$src), (iPTR 0))), addr:$dst),
2975      (VMOVDQU32Z128mr addr:$dst, (v16i8 (EXTRACT_SUBREG VR512:$src,sub_xmm)))>;
2976
2977   // Special patterns for storing subvector extracts of lower 256-bits of 512.
2978   // Its cheaper to just use VMOVAPS/VMOVUPS instead of VEXTRACTF128mr
2979   def : Pat<(alignedstore256 (v4f64 (extract_subvector
2980                                      (v8f64 VR512:$src), (iPTR 0))), addr:$dst),
2981      (VMOVAPDZ256mr addr:$dst, (v4f64 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2982   def : Pat<(alignedstore (v8f32 (extract_subvector
2983                                   (v16f32 VR512:$src), (iPTR 0))), addr:$dst),
2984      (VMOVAPSZ256mr addr:$dst, (v8f32 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2985   def : Pat<(alignedstore256 (v4i64 (extract_subvector
2986                                      (v8i64 VR512:$src), (iPTR 0))), addr:$dst),
2987      (VMOVDQA64Z256mr addr:$dst, (v4i64 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2988   def : Pat<(alignedstore256 (v8i32 (extract_subvector
2989                                      (v16i32 VR512:$src), (iPTR 0))), addr:$dst),
2990      (VMOVDQA32Z256mr addr:$dst, (v8i32 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2991   def : Pat<(alignedstore256 (v16i16 (extract_subvector
2992                                       (v32i16 VR512:$src), (iPTR 0))), addr:$dst),
2993      (VMOVDQA32Z256mr addr:$dst, (v16i16 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2994   def : Pat<(alignedstore256 (v32i8 (extract_subvector
2995                                      (v64i8 VR512:$src), (iPTR 0))), addr:$dst),
2996      (VMOVDQA32Z256mr addr:$dst, (v32i8 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
2997
2998   def : Pat<(store (v4f64 (extract_subvector
2999                            (v8f64 VR512:$src), (iPTR 0))), addr:$dst),
3000      (VMOVUPDZ256mr addr:$dst, (v4f64 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3001   def : Pat<(store (v8f32 (extract_subvector
3002                            (v16f32 VR512:$src), (iPTR 0))), addr:$dst),
3003      (VMOVUPSZ256mr addr:$dst, (v8f32 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3004   def : Pat<(store (v4i64 (extract_subvector
3005                            (v8i64 VR512:$src), (iPTR 0))), addr:$dst),
3006      (VMOVDQU64Z256mr addr:$dst, (v4i64 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3007   def : Pat<(store (v8i32 (extract_subvector
3008                            (v16i32 VR512:$src), (iPTR 0))), addr:$dst),
3009      (VMOVDQU32Z256mr addr:$dst, (v8i32 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3010   def : Pat<(store (v16i16 (extract_subvector
3011                             (v32i16 VR512:$src), (iPTR 0))), addr:$dst),
3012      (VMOVDQU32Z256mr addr:$dst, (v16i16 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3013   def : Pat<(store (v32i8 (extract_subvector
3014                            (v64i8 VR512:$src), (iPTR 0))), addr:$dst),
3015      (VMOVDQU32Z256mr addr:$dst, (v32i8 (EXTRACT_SUBREG VR512:$src,sub_ymm)))>;
3016 }
3017
3018
3019 // Move Int Doubleword to Packed Double Int
3020 //
3021 let ExeDomain = SSEPackedInt in {
3022 def VMOVDI2PDIZrr : AVX512BI<0x6E, MRMSrcReg, (outs VR128X:$dst), (ins GR32:$src),
3023                       "vmovd\t{$src, $dst|$dst, $src}",
3024                       [(set VR128X:$dst,
3025                         (v4i32 (scalar_to_vector GR32:$src)))], IIC_SSE_MOVDQ>,
3026                         EVEX;
3027 def VMOVDI2PDIZrm : AVX512BI<0x6E, MRMSrcMem, (outs VR128X:$dst), (ins i32mem:$src),
3028                       "vmovd\t{$src, $dst|$dst, $src}",
3029                       [(set VR128X:$dst,
3030                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))],
3031                         IIC_SSE_MOVDQ>, EVEX, EVEX_CD8<32, CD8VT1>;
3032 def VMOV64toPQIZrr : AVX512BI<0x6E, MRMSrcReg, (outs VR128X:$dst), (ins GR64:$src),
3033                       "vmovq\t{$src, $dst|$dst, $src}",
3034                         [(set VR128X:$dst,
3035                           (v2i64 (scalar_to_vector GR64:$src)))],
3036                           IIC_SSE_MOVDQ>, EVEX, VEX_W;
3037 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayLoad = 1 in
3038 def VMOV64toPQIZrm : AVX512BI<0x6E, MRMSrcMem, (outs VR128X:$dst),
3039                       (ins i64mem:$src),
3040                       "vmovq\t{$src, $dst|$dst, $src}", []>,
3041                       EVEX, VEX_W, EVEX_CD8<64, CD8VT1>;
3042 let isCodeGenOnly = 1 in {
3043 def VMOV64toSDZrr : AVX512BI<0x6E, MRMSrcReg, (outs FR64X:$dst), (ins GR64:$src),
3044                        "vmovq\t{$src, $dst|$dst, $src}",
3045                        [(set FR64X:$dst, (bitconvert GR64:$src))],
3046                        IIC_SSE_MOVDQ>, EVEX, VEX_W, Sched<[WriteMove]>;
3047 def VMOV64toSDZrm : AVX512XSI<0x7E, MRMSrcMem, (outs FR64X:$dst), (ins i64mem:$src),
3048                       "vmovq\t{$src, $dst|$dst, $src}",
3049                       [(set FR64X:$dst, (bitconvert (loadi64 addr:$src)))]>,
3050                       EVEX, VEX_W, EVEX_CD8<8, CD8VT8>;
3051 def VMOVSDto64Zrr : AVX512BI<0x7E, MRMDestReg, (outs GR64:$dst), (ins FR64X:$src),
3052                          "vmovq\t{$src, $dst|$dst, $src}",
3053                          [(set GR64:$dst, (bitconvert FR64X:$src))],
3054                          IIC_SSE_MOVDQ>, EVEX, VEX_W, Sched<[WriteMove]>;
3055 def VMOVSDto64Zmr : AVX512BI<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, FR64X:$src),
3056                          "vmovq\t{$src, $dst|$dst, $src}",
3057                          [(store (i64 (bitconvert FR64X:$src)), addr:$dst)],
3058                          IIC_SSE_MOVDQ>, EVEX, VEX_W, Sched<[WriteStore]>,
3059                          EVEX_CD8<64, CD8VT1>;
3060 }
3061 } // ExeDomain = SSEPackedInt
3062
3063 // Move Int Doubleword to Single Scalar
3064 //
3065 let ExeDomain = SSEPackedInt, isCodeGenOnly = 1 in {
3066 def VMOVDI2SSZrr  : AVX512BI<0x6E, MRMSrcReg, (outs FR32X:$dst), (ins GR32:$src),
3067                       "vmovd\t{$src, $dst|$dst, $src}",
3068                       [(set FR32X:$dst, (bitconvert GR32:$src))],
3069                       IIC_SSE_MOVDQ>, EVEX;
3070
3071 def VMOVDI2SSZrm  : AVX512BI<0x6E, MRMSrcMem, (outs FR32X:$dst), (ins i32mem:$src),
3072                       "vmovd\t{$src, $dst|$dst, $src}",
3073                       [(set FR32X:$dst, (bitconvert (loadi32 addr:$src)))],
3074                       IIC_SSE_MOVDQ>, EVEX, EVEX_CD8<32, CD8VT1>;
3075 } // ExeDomain = SSEPackedInt, isCodeGenOnly = 1
3076
3077 // Move doubleword from xmm register to r/m32
3078 //
3079 let ExeDomain = SSEPackedInt in {
3080 def VMOVPDI2DIZrr  : AVX512BI<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128X:$src),
3081                        "vmovd\t{$src, $dst|$dst, $src}",
3082                        [(set GR32:$dst, (extractelt (v4i32 VR128X:$src),
3083                                         (iPTR 0)))], IIC_SSE_MOVD_ToGP>,
3084                        EVEX;
3085 def VMOVPDI2DIZmr  : AVX512BI<0x7E, MRMDestMem, (outs),
3086                        (ins i32mem:$dst, VR128X:$src),
3087                        "vmovd\t{$src, $dst|$dst, $src}",
3088                        [(store (i32 (extractelt (v4i32 VR128X:$src),
3089                                      (iPTR 0))), addr:$dst)], IIC_SSE_MOVDQ>,
3090                        EVEX, EVEX_CD8<32, CD8VT1>;
3091 } // ExeDomain = SSEPackedInt
3092
3093 // Move quadword from xmm1 register to r/m64
3094 //
3095 let ExeDomain = SSEPackedInt in {
3096 def VMOVPQIto64Zrr : I<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128X:$src),
3097                       "vmovq\t{$src, $dst|$dst, $src}",
3098                       [(set GR64:$dst, (extractelt (v2i64 VR128X:$src),
3099                                                    (iPTR 0)))],
3100                       IIC_SSE_MOVD_ToGP>, PD, EVEX, VEX_W,
3101                       Requires<[HasAVX512, In64BitMode]>;
3102
3103 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayStore = 1 in
3104 def VMOVPQIto64Zmr : I<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, VR128X:$src),
3105                       "vmovq\t{$src, $dst|$dst, $src}",
3106                       [], IIC_SSE_MOVD_ToGP>, PD, EVEX, VEX_W,
3107                       Requires<[HasAVX512, In64BitMode]>;
3108
3109 def VMOVPQI2QIZmr : I<0xD6, MRMDestMem, (outs),
3110                       (ins i64mem:$dst, VR128X:$src),
3111                       "vmovq\t{$src, $dst|$dst, $src}",
3112                       [(store (extractelt (v2i64 VR128X:$src), (iPTR 0)),
3113                               addr:$dst)], IIC_SSE_MOVDQ>,
3114                       EVEX, PD, VEX_W, EVEX_CD8<64, CD8VT1>,
3115                       Sched<[WriteStore]>, Requires<[HasAVX512, In64BitMode]>;
3116
3117 let hasSideEffects = 0 in
3118 def VMOVPQI2QIZrr : AVX512BI<0xD6, MRMDestReg, (outs VR128X:$dst),
3119                              (ins VR128X:$src),
3120                              "vmovq.s\t{$src, $dst|$dst, $src}",[]>,
3121                              EVEX, VEX_W;
3122 } // ExeDomain = SSEPackedInt
3123
3124 // Move Scalar Single to Double Int
3125 //
3126 let ExeDomain = SSEPackedInt, isCodeGenOnly = 1 in {
3127 def VMOVSS2DIZrr  : AVX512BI<0x7E, MRMDestReg, (outs GR32:$dst),
3128                       (ins FR32X:$src),
3129                       "vmovd\t{$src, $dst|$dst, $src}",
3130                       [(set GR32:$dst, (bitconvert FR32X:$src))],
3131                       IIC_SSE_MOVD_ToGP>, EVEX;
3132 def VMOVSS2DIZmr  : AVX512BI<0x7E, MRMDestMem, (outs),
3133                       (ins i32mem:$dst, FR32X:$src),
3134                       "vmovd\t{$src, $dst|$dst, $src}",
3135                       [(store (i32 (bitconvert FR32X:$src)), addr:$dst)],
3136                       IIC_SSE_MOVDQ>, EVEX, EVEX_CD8<32, CD8VT1>;
3137 } // ExeDomain = SSEPackedInt, isCodeGenOnly = 1
3138
3139 // Move Quadword Int to Packed Quadword Int
3140 //
3141 let ExeDomain = SSEPackedInt in {
3142 def VMOVQI2PQIZrm : AVX512XSI<0x7E, MRMSrcMem, (outs VR128X:$dst),
3143                       (ins i64mem:$src),
3144                       "vmovq\t{$src, $dst|$dst, $src}",
3145                       [(set VR128X:$dst,
3146                         (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>,
3147                       EVEX, VEX_W, EVEX_CD8<8, CD8VT8>;
3148 } // ExeDomain = SSEPackedInt
3149
3150 //===----------------------------------------------------------------------===//
3151 // AVX-512  MOVSS, MOVSD
3152 //===----------------------------------------------------------------------===//
3153
3154 multiclass avx512_move_scalar<string asm, SDNode OpNode,
3155                               X86VectorVTInfo _> {
3156   def rr : AVX512PI<0x10, MRMSrcReg, (outs _.RC:$dst),
3157              (ins _.RC:$src1, _.FRC:$src2),
3158              !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3159              [(set _.RC:$dst, (_.VT (OpNode _.RC:$src1,
3160                                     (scalar_to_vector _.FRC:$src2))))],
3161              _.ExeDomain,IIC_SSE_MOV_S_RR>, EVEX_4V;
3162   def rrkz : AVX512PI<0x10, MRMSrcReg, (outs _.RC:$dst),
3163               (ins _.KRCWM:$mask, _.RC:$src1, _.FRC:$src2),
3164               !strconcat(asm, "\t{$src2, $src1, $dst {${mask}} {z}|",
3165               "$dst {${mask}} {z}, $src1, $src2}"),
3166               [(set _.RC:$dst, (_.VT (X86selects _.KRCWM:$mask,
3167                                       (_.VT (OpNode _.RC:$src1,
3168                                             (scalar_to_vector _.FRC:$src2))),
3169                                       _.ImmAllZerosV)))],
3170               _.ExeDomain,IIC_SSE_MOV_S_RR>, EVEX_4V, EVEX_KZ;
3171   let Constraints = "$src0 = $dst"  in
3172   def rrk : AVX512PI<0x10, MRMSrcReg, (outs _.RC:$dst),
3173              (ins _.RC:$src0, _.KRCWM:$mask, _.RC:$src1, _.FRC:$src2),
3174              !strconcat(asm, "\t{$src2, $src1, $dst {${mask}}|",
3175              "$dst {${mask}}, $src1, $src2}"),
3176              [(set _.RC:$dst, (_.VT (X86selects _.KRCWM:$mask,
3177                                      (_.VT (OpNode _.RC:$src1,
3178                                            (scalar_to_vector _.FRC:$src2))),
3179                                      (_.VT _.RC:$src0))))],
3180              _.ExeDomain,IIC_SSE_MOV_S_RR>, EVEX_4V, EVEX_K;
3181   let canFoldAsLoad = 1, isReMaterializable = 1 in
3182   def rm : AVX512PI<0x10, MRMSrcMem, (outs _.FRC:$dst), (ins _.ScalarMemOp:$src),
3183              !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
3184              [(set _.FRC:$dst, (_.ScalarLdFrag addr:$src))],
3185              _.ExeDomain, IIC_SSE_MOV_S_RM>, EVEX;
3186   let mayLoad = 1, hasSideEffects = 0 in {
3187     let Constraints = "$src0 = $dst" in
3188     def rmk : AVX512PI<0x10, MRMSrcMem, (outs _.RC:$dst),
3189                (ins _.RC:$src0, _.KRCWM:$mask, _.ScalarMemOp:$src),
3190                !strconcat(asm, "\t{$src, $dst {${mask}}|",
3191                "$dst {${mask}}, $src}"),
3192                [], _.ExeDomain, IIC_SSE_MOV_S_RM>, EVEX, EVEX_K;
3193     def rmkz : AVX512PI<0x10, MRMSrcMem, (outs _.RC:$dst),
3194                (ins _.KRCWM:$mask, _.ScalarMemOp:$src),
3195                !strconcat(asm, "\t{$src, $dst {${mask}} {z}|",
3196                "$dst {${mask}} {z}, $src}"),
3197                [], _.ExeDomain, IIC_SSE_MOV_S_RM>, EVEX, EVEX_KZ;
3198   }
3199   def mr: AVX512PI<0x11, MRMDestMem, (outs), (ins _.ScalarMemOp:$dst, _.FRC:$src),
3200              !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
3201              [(store _.FRC:$src, addr:$dst)],  _.ExeDomain, IIC_SSE_MOV_S_MR>,
3202              EVEX;
3203   let mayStore = 1, hasSideEffects = 0 in
3204   def mrk: AVX512PI<0x11, MRMDestMem, (outs),
3205               (ins _.ScalarMemOp:$dst, VK1WM:$mask, _.FRC:$src),
3206               !strconcat(asm, "\t{$src, $dst {${mask}}|$dst {${mask}}, $src}"),
3207               [], _.ExeDomain, IIC_SSE_MOV_S_MR>, EVEX, EVEX_K;
3208 }
3209
3210 defm VMOVSSZ : avx512_move_scalar<"vmovss", X86Movss, f32x_info>,
3211                                   VEX_LIG, XS, EVEX_CD8<32, CD8VT1>;
3212
3213 defm VMOVSDZ : avx512_move_scalar<"vmovsd", X86Movsd, f64x_info>,
3214                                   VEX_LIG, XD, VEX_W, EVEX_CD8<64, CD8VT1>;
3215
3216
3217 multiclass avx512_move_scalar_lowering<string InstrStr, SDNode OpNode,
3218                                        PatLeaf ZeroFP, X86VectorVTInfo _> {
3219
3220 def : Pat<(_.VT (OpNode _.RC:$src0,
3221                         (_.VT (scalar_to_vector
3222                                   (_.EltVT (X86selects (scalar_to_vector (and (i8 (trunc GR32:$mask)), (i8 1))),
3223                                                        (_.EltVT _.FRC:$src1),
3224                                                        (_.EltVT _.FRC:$src2))))))),
3225           (COPY_TO_REGCLASS (!cast<Instruction>(InstrStr#rrk)
3226                                           (COPY_TO_REGCLASS _.FRC:$src2, _.RC),
3227                                           (COPY_TO_REGCLASS GR32:$mask, VK1WM),
3228                                           (_.VT _.RC:$src0), _.FRC:$src1),
3229                             _.RC)>;
3230
3231 def : Pat<(_.VT (OpNode _.RC:$src0,
3232                         (_.VT (scalar_to_vector
3233                                   (_.EltVT (X86selects (scalar_to_vector (and (i8 (trunc GR32:$mask)), (i8 1))),
3234                                                        (_.EltVT _.FRC:$src1),
3235                                                        (_.EltVT ZeroFP))))))),
3236           (COPY_TO_REGCLASS (!cast<Instruction>(InstrStr#rrkz)
3237                                           (COPY_TO_REGCLASS GR32:$mask, VK1WM),
3238                                           (_.VT _.RC:$src0), _.FRC:$src1),
3239                             _.RC)>;
3240 }
3241
3242 multiclass avx512_store_scalar_lowering<string InstrStr, AVX512VLVectorVTInfo _,
3243                                         dag Mask, RegisterClass MaskRC> {
3244
3245 def : Pat<(masked_store addr:$dst, Mask,
3246              (_.info512.VT (insert_subvector undef,
3247                                (_.info256.VT (insert_subvector undef,
3248                                                  (_.info128.VT _.info128.RC:$src),
3249                                                  (iPTR 0))),
3250                                (iPTR 0)))),
3251           (!cast<Instruction>(InstrStr#mrk) addr:$dst,
3252                       (COPY_TO_REGCLASS MaskRC:$mask, VK1WM),
3253                       (COPY_TO_REGCLASS _.info128.RC:$src, _.info128.FRC))>;
3254
3255 }
3256
3257 multiclass avx512_store_scalar_lowering_subreg<string InstrStr,
3258                                                AVX512VLVectorVTInfo _,
3259                                                dag Mask, RegisterClass MaskRC,
3260                                                SubRegIndex subreg> {
3261
3262 def : Pat<(masked_store addr:$dst, Mask,
3263              (_.info512.VT (insert_subvector undef,
3264                                (_.info256.VT (insert_subvector undef,
3265                                                  (_.info128.VT _.info128.RC:$src),
3266                                                  (iPTR 0))),
3267                                (iPTR 0)))),
3268           (!cast<Instruction>(InstrStr#mrk) addr:$dst,
3269                       (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), MaskRC:$mask, subreg)), VK1WM),
3270                       (COPY_TO_REGCLASS _.info128.RC:$src, _.info128.FRC))>;
3271
3272 }
3273
3274 multiclass avx512_load_scalar_lowering<string InstrStr, AVX512VLVectorVTInfo _,
3275                                        dag Mask, RegisterClass MaskRC> {
3276
3277 def : Pat<(_.info128.VT (extract_subvector
3278                          (_.info512.VT (masked_load addr:$srcAddr, Mask,
3279                                         (_.info512.VT (bitconvert
3280                                                        (v16i32 immAllZerosV))))),
3281                            (iPTR 0))),
3282           (!cast<Instruction>(InstrStr#rmkz)
3283                       (COPY_TO_REGCLASS MaskRC:$mask, VK1WM),
3284                       addr:$srcAddr)>;
3285
3286 def : Pat<(_.info128.VT (extract_subvector
3287                 (_.info512.VT (masked_load addr:$srcAddr, Mask,
3288                       (_.info512.VT (insert_subvector undef,
3289                             (_.info256.VT (insert_subvector undef,
3290                                   (_.info128.VT (X86vzmovl _.info128.RC:$src)),
3291                                   (iPTR 0))),
3292                             (iPTR 0))))),
3293                 (iPTR 0))),
3294           (!cast<Instruction>(InstrStr#rmk) _.info128.RC:$src,
3295                       (COPY_TO_REGCLASS MaskRC:$mask, VK1WM),
3296                       addr:$srcAddr)>;
3297
3298 }
3299
3300 multiclass avx512_load_scalar_lowering_subreg<string InstrStr,
3301                                               AVX512VLVectorVTInfo _,
3302                                               dag Mask, RegisterClass MaskRC,
3303                                               SubRegIndex subreg> {
3304
3305 def : Pat<(_.info128.VT (extract_subvector
3306                          (_.info512.VT (masked_load addr:$srcAddr, Mask,
3307                                         (_.info512.VT (bitconvert
3308                                                        (v16i32 immAllZerosV))))),
3309                            (iPTR 0))),
3310           (!cast<Instruction>(InstrStr#rmkz)
3311                       (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), MaskRC:$mask, subreg)), VK1WM),
3312                       addr:$srcAddr)>;
3313
3314 def : Pat<(_.info128.VT (extract_subvector
3315                 (_.info512.VT (masked_load addr:$srcAddr, Mask,
3316                       (_.info512.VT (insert_subvector undef,
3317                             (_.info256.VT (insert_subvector undef,
3318                                   (_.info128.VT (X86vzmovl _.info128.RC:$src)),
3319                                   (iPTR 0))),
3320                             (iPTR 0))))),
3321                 (iPTR 0))),
3322           (!cast<Instruction>(InstrStr#rmk) _.info128.RC:$src,
3323                       (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), MaskRC:$mask, subreg)), VK1WM),
3324                       addr:$srcAddr)>;
3325
3326 }
3327
3328 defm : avx512_move_scalar_lowering<"VMOVSSZ", X86Movss, fp32imm0, v4f32x_info>;
3329 defm : avx512_move_scalar_lowering<"VMOVSDZ", X86Movsd, fp64imm0, v2f64x_info>;
3330
3331 defm : avx512_store_scalar_lowering<"VMOVSSZ", avx512vl_f32_info,
3332                    (v16i1 (bitconvert (i16 (trunc (and GR32:$mask, (i32 1)))))), GR32>;
3333 defm : avx512_store_scalar_lowering_subreg<"VMOVSSZ", avx512vl_f32_info,
3334                    (v16i1 (bitconvert (i16 (and GR16:$mask, (i16 1))))), GR16, sub_16bit>;
3335 defm : avx512_store_scalar_lowering_subreg<"VMOVSDZ", avx512vl_f64_info,
3336                    (v8i1 (bitconvert (i8 (and GR8:$mask, (i8 1))))), GR8, sub_8bit>;
3337
3338 defm : avx512_load_scalar_lowering<"VMOVSSZ", avx512vl_f32_info,
3339                    (v16i1 (bitconvert (i16 (trunc (and GR32:$mask, (i32 1)))))), GR32>;
3340 defm : avx512_load_scalar_lowering_subreg<"VMOVSSZ", avx512vl_f32_info,
3341                    (v16i1 (bitconvert (i16 (and GR16:$mask, (i16 1))))), GR16, sub_16bit>;
3342 defm : avx512_load_scalar_lowering_subreg<"VMOVSDZ", avx512vl_f64_info,
3343                    (v8i1 (bitconvert (i8 (and GR8:$mask, (i8 1))))), GR8, sub_8bit>;
3344
3345 def : Pat<(f32 (X86selects VK1WM:$mask, (f32 FR32X:$src1), (f32 FR32X:$src2))),
3346           (COPY_TO_REGCLASS (VMOVSSZrrk (COPY_TO_REGCLASS FR32X:$src2, VR128X),
3347            VK1WM:$mask, (v4f32 (IMPLICIT_DEF)), FR32X:$src1), FR32X)>;
3348
3349 def : Pat<(f64 (X86selects VK1WM:$mask, (f64 FR64X:$src1), (f64 FR64X:$src2))),
3350           (COPY_TO_REGCLASS (VMOVSDZrrk (COPY_TO_REGCLASS FR64X:$src2, VR128X),
3351            VK1WM:$mask, (v2f64 (IMPLICIT_DEF)), FR64X:$src1), FR64X)>;
3352
3353 def : Pat<(int_x86_avx512_mask_store_ss addr:$dst, VR128X:$src, GR8:$mask),
3354           (VMOVSSZmrk addr:$dst, (COPY_TO_REGCLASS (i32 (INSERT_SUBREG (IMPLICIT_DEF), GR8:$mask, sub_8bit)), VK1WM),
3355            (COPY_TO_REGCLASS VR128X:$src, FR32X))>;
3356
3357 let hasSideEffects = 0 in
3358 defm VMOVSSZrr_REV : AVX512_maskable_in_asm<0x11, MRMDestReg, f32x_info,
3359                            (outs VR128X:$dst), (ins VR128X:$src1, FR32X:$src2),
3360                            "vmovss.s", "$src2, $src1", "$src1, $src2", []>,
3361                            XS, EVEX_4V, VEX_LIG;
3362
3363 let hasSideEffects = 0 in
3364 defm VMOVSDZrr_REV : AVX512_maskable_in_asm<0x11, MRMDestReg, f64x_info,
3365                            (outs VR128X:$dst), (ins VR128X:$src1, FR64X:$src2),
3366                            "vmovsd.s", "$src2, $src1", "$src1, $src2", []>,
3367                            XD, EVEX_4V, VEX_LIG, VEX_W;
3368
3369 let Predicates = [HasAVX512] in {
3370   let AddedComplexity = 15 in {
3371   // Move scalar to XMM zero-extended, zeroing a VR128X then do a
3372   // MOVS{S,D} to the lower bits.
3373   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32X:$src)))),
3374             (VMOVSSZrr (v4f32 (AVX512_128_SET0)), FR32X:$src)>;
3375   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128X:$src))),
3376             (VMOVSSZrr (v4f32 (AVX512_128_SET0)), (COPY_TO_REGCLASS VR128X:$src, FR32X))>;
3377   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128X:$src))),
3378             (VMOVSSZrr (v4i32 (AVX512_128_SET0)), (COPY_TO_REGCLASS VR128X:$src, FR32X))>;
3379   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64X:$src)))),
3380             (VMOVSDZrr (v2f64 (AVX512_128_SET0)), FR64X:$src)>;
3381   }
3382
3383   // Move low f32 and clear high bits.
3384   def : Pat<(v8f32 (X86vzmovl (v8f32 VR256X:$src))),
3385             (SUBREG_TO_REG (i32 0),
3386              (VMOVSSZrr (v4f32 (AVX512_128_SET0)),
3387               (EXTRACT_SUBREG (v8f32 VR256X:$src), sub_xmm)), sub_xmm)>;
3388   def : Pat<(v8i32 (X86vzmovl (v8i32 VR256X:$src))),
3389             (SUBREG_TO_REG (i32 0),
3390              (VMOVSSZrr (v4i32 (AVX512_128_SET0)),
3391               (EXTRACT_SUBREG (v8i32 VR256X:$src), sub_xmm)), sub_xmm)>;
3392   def : Pat<(v16f32 (X86vzmovl (v16f32 VR512:$src))),
3393             (SUBREG_TO_REG (i32 0),
3394              (VMOVSSZrr (v4f32 (AVX512_128_SET0)),
3395               (EXTRACT_SUBREG (v16f32 VR512:$src), sub_xmm)), sub_xmm)>;
3396   def : Pat<(v16i32 (X86vzmovl (v16i32 VR512:$src))),
3397             (SUBREG_TO_REG (i32 0),
3398              (VMOVSSZrr (v4i32 (AVX512_128_SET0)),
3399               (EXTRACT_SUBREG (v16i32 VR512:$src), sub_xmm)), sub_xmm)>;
3400
3401   let AddedComplexity = 20 in {
3402   // MOVSSrm zeros the high parts of the register; represent this
3403   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
3404   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector (loadf32 addr:$src))))),
3405             (COPY_TO_REGCLASS (VMOVSSZrm addr:$src), VR128X)>;
3406   def : Pat<(v4f32 (scalar_to_vector (loadf32 addr:$src))),
3407             (COPY_TO_REGCLASS (VMOVSSZrm addr:$src), VR128X)>;
3408   def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
3409             (COPY_TO_REGCLASS (VMOVSSZrm addr:$src), VR128X)>;
3410   def : Pat<(v4f32 (X86vzload addr:$src)),
3411             (COPY_TO_REGCLASS (VMOVSSZrm addr:$src), VR128X)>;
3412
3413   // MOVSDrm zeros the high parts of the register; represent this
3414   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
3415   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector (loadf64 addr:$src))))),
3416             (COPY_TO_REGCLASS (VMOVSDZrm addr:$src), VR128X)>;
3417   def : Pat<(v2f64 (scalar_to_vector (loadf64 addr:$src))),
3418             (COPY_TO_REGCLASS (VMOVSDZrm addr:$src), VR128X)>;
3419   def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
3420             (COPY_TO_REGCLASS (VMOVSDZrm addr:$src), VR128X)>;
3421   def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
3422             (COPY_TO_REGCLASS (VMOVSDZrm addr:$src), VR128X)>;
3423   def : Pat<(v2f64 (X86vzload addr:$src)),
3424             (COPY_TO_REGCLASS (VMOVSDZrm addr:$src), VR128X)>;
3425
3426   // Represent the same patterns above but in the form they appear for
3427   // 256-bit types
3428   def : Pat<(v8i32 (X86vzmovl (insert_subvector undef,
3429                    (v4i32 (scalar_to_vector (loadi32 addr:$src))), (iPTR 0)))),
3430             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrm addr:$src), sub_xmm)>;
3431   def : Pat<(v8f32 (X86vzmovl (insert_subvector undef,
3432                    (v4f32 (scalar_to_vector (loadf32 addr:$src))), (iPTR 0)))),
3433             (SUBREG_TO_REG (i32 0), (VMOVSSZrm addr:$src), sub_xmm)>;
3434   def : Pat<(v8f32 (X86vzload addr:$src)),
3435             (SUBREG_TO_REG (i32 0), (VMOVSSZrm addr:$src), sub_xmm)>;
3436   def : Pat<(v4f64 (X86vzmovl (insert_subvector undef,
3437                    (v2f64 (scalar_to_vector (loadf64 addr:$src))), (iPTR 0)))),
3438             (SUBREG_TO_REG (i32 0), (VMOVSDZrm addr:$src), sub_xmm)>;
3439   def : Pat<(v4f64 (X86vzload addr:$src)),
3440             (SUBREG_TO_REG (i32 0), (VMOVSDZrm addr:$src), sub_xmm)>;
3441
3442   // Represent the same patterns above but in the form they appear for
3443   // 512-bit types
3444   def : Pat<(v16i32 (X86vzmovl (insert_subvector undef,
3445                    (v4i32 (scalar_to_vector (loadi32 addr:$src))), (iPTR 0)))),
3446             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrm addr:$src), sub_xmm)>;
3447   def : Pat<(v16f32 (X86vzmovl (insert_subvector undef,
3448                    (v4f32 (scalar_to_vector (loadf32 addr:$src))), (iPTR 0)))),
3449             (SUBREG_TO_REG (i32 0), (VMOVSSZrm addr:$src), sub_xmm)>;
3450   def : Pat<(v16f32 (X86vzload addr:$src)),
3451             (SUBREG_TO_REG (i32 0), (VMOVSSZrm addr:$src), sub_xmm)>;
3452   def : Pat<(v8f64 (X86vzmovl (insert_subvector undef,
3453                    (v2f64 (scalar_to_vector (loadf64 addr:$src))), (iPTR 0)))),
3454             (SUBREG_TO_REG (i32 0), (VMOVSDZrm addr:$src), sub_xmm)>;
3455   def : Pat<(v8f64 (X86vzload addr:$src)),
3456             (SUBREG_TO_REG (i32 0), (VMOVSDZrm addr:$src), sub_xmm)>;
3457   }
3458   def : Pat<(v8f32 (X86vzmovl (insert_subvector undef,
3459                    (v4f32 (scalar_to_vector FR32X:$src)), (iPTR 0)))),
3460             (SUBREG_TO_REG (i32 0), (v4f32 (VMOVSSZrr (v4f32 (AVX512_128_SET0)),
3461                                             FR32X:$src)), sub_xmm)>;
3462   def : Pat<(v4f64 (X86vzmovl (insert_subvector undef,
3463                    (v2f64 (scalar_to_vector FR64X:$src)), (iPTR 0)))),
3464             (SUBREG_TO_REG (i64 0), (v2f64 (VMOVSDZrr (v2f64 (AVX512_128_SET0)),
3465                                      FR64X:$src)), sub_xmm)>;
3466   def : Pat<(v4i64 (X86vzmovl (insert_subvector undef,
3467                    (v2i64 (scalar_to_vector (loadi64 addr:$src))), (iPTR 0)))),
3468             (SUBREG_TO_REG (i64 0), (VMOVQI2PQIZrm addr:$src), sub_xmm)>;
3469
3470   // Move low f64 and clear high bits.
3471   def : Pat<(v4f64 (X86vzmovl (v4f64 VR256X:$src))),
3472             (SUBREG_TO_REG (i32 0),
3473              (VMOVSDZrr (v2f64 (AVX512_128_SET0)),
3474                        (EXTRACT_SUBREG (v4f64 VR256X:$src), sub_xmm)), sub_xmm)>;
3475   def : Pat<(v8f64 (X86vzmovl (v8f64 VR512:$src))),
3476             (SUBREG_TO_REG (i32 0),
3477              (VMOVSDZrr (v2f64 (AVX512_128_SET0)),
3478                        (EXTRACT_SUBREG (v8f64 VR512:$src), sub_xmm)), sub_xmm)>;
3479
3480   def : Pat<(v4i64 (X86vzmovl (v4i64 VR256X:$src))),
3481             (SUBREG_TO_REG (i32 0), (VMOVSDZrr (v2i64 (AVX512_128_SET0)),
3482                        (EXTRACT_SUBREG (v4i64 VR256X:$src), sub_xmm)), sub_xmm)>;
3483   def : Pat<(v8i64 (X86vzmovl (v8i64 VR512:$src))),
3484             (SUBREG_TO_REG (i32 0), (VMOVSDZrr (v2i64 (AVX512_128_SET0)),
3485                        (EXTRACT_SUBREG (v8i64 VR512:$src), sub_xmm)), sub_xmm)>;
3486
3487   // Extract and store.
3488   def : Pat<(store (f32 (extractelt (v4f32 VR128X:$src), (iPTR 0))),
3489                    addr:$dst),
3490             (VMOVSSZmr addr:$dst, (COPY_TO_REGCLASS (v4f32 VR128X:$src), FR32X))>;
3491
3492   // Shuffle with VMOVSS
3493   def : Pat<(v4i32 (X86Movss VR128X:$src1, VR128X:$src2)),
3494             (VMOVSSZrr (v4i32 VR128X:$src1),
3495                       (COPY_TO_REGCLASS (v4i32 VR128X:$src2), FR32X))>;
3496   def : Pat<(v4f32 (X86Movss VR128X:$src1, VR128X:$src2)),
3497             (VMOVSSZrr (v4f32 VR128X:$src1),
3498                       (COPY_TO_REGCLASS (v4f32 VR128X:$src2), FR32X))>;
3499
3500   // 256-bit variants
3501   def : Pat<(v8i32 (X86Movss VR256X:$src1, VR256X:$src2)),
3502             (SUBREG_TO_REG (i32 0),
3503               (VMOVSSZrr (EXTRACT_SUBREG (v8i32 VR256X:$src1), sub_xmm),
3504                         (EXTRACT_SUBREG (v8i32 VR256X:$src2), sub_xmm)),
3505               sub_xmm)>;
3506   def : Pat<(v8f32 (X86Movss VR256X:$src1, VR256X:$src2)),
3507             (SUBREG_TO_REG (i32 0),
3508               (VMOVSSZrr (EXTRACT_SUBREG (v8f32 VR256X:$src1), sub_xmm),
3509                         (EXTRACT_SUBREG (v8f32 VR256X:$src2), sub_xmm)),
3510               sub_xmm)>;
3511
3512   // Shuffle with VMOVSD
3513   def : Pat<(v2i64 (X86Movsd VR128X:$src1, VR128X:$src2)),
3514             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3515   def : Pat<(v2f64 (X86Movsd VR128X:$src1, VR128X:$src2)),
3516             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3517
3518   // 256-bit variants
3519   def : Pat<(v4i64 (X86Movsd VR256X:$src1, VR256X:$src2)),
3520             (SUBREG_TO_REG (i32 0),
3521               (VMOVSDZrr (EXTRACT_SUBREG (v4i64 VR256X:$src1), sub_xmm),
3522                         (EXTRACT_SUBREG (v4i64 VR256X:$src2), sub_xmm)),
3523               sub_xmm)>;
3524   def : Pat<(v4f64 (X86Movsd VR256X:$src1, VR256X:$src2)),
3525             (SUBREG_TO_REG (i32 0),
3526               (VMOVSDZrr (EXTRACT_SUBREG (v4f64 VR256X:$src1), sub_xmm),
3527                         (EXTRACT_SUBREG (v4f64 VR256X:$src2), sub_xmm)),
3528               sub_xmm)>;
3529
3530   def : Pat<(v2f64 (X86Movlpd VR128X:$src1, VR128X:$src2)),
3531             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3532   def : Pat<(v2i64 (X86Movlpd VR128X:$src1, VR128X:$src2)),
3533             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3534   def : Pat<(v4f32 (X86Movlps VR128X:$src1, VR128X:$src2)),
3535             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3536   def : Pat<(v4i32 (X86Movlps VR128X:$src1, VR128X:$src2)),
3537             (VMOVSDZrr VR128X:$src1, (COPY_TO_REGCLASS VR128X:$src2, FR64X))>;
3538 }
3539
3540 let AddedComplexity = 15 in
3541 def VMOVZPQILo2PQIZrr : AVX512XSI<0x7E, MRMSrcReg, (outs VR128X:$dst),
3542                                 (ins VR128X:$src),
3543                                 "vmovq\t{$src, $dst|$dst, $src}",
3544                                 [(set VR128X:$dst, (v2i64 (X86vzmovl
3545                                                    (v2i64 VR128X:$src))))],
3546                                 IIC_SSE_MOVQ_RR>, EVEX, VEX_W;
3547
3548 let Predicates = [HasAVX512] in {
3549   let AddedComplexity = 15 in {
3550     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector GR32:$src)))),
3551               (VMOVDI2PDIZrr GR32:$src)>;
3552
3553     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector GR64:$src)))),
3554               (VMOV64toPQIZrr GR64:$src)>;
3555
3556     def : Pat<(v4i64 (X86vzmovl (insert_subvector undef,
3557                                  (v2i64 (scalar_to_vector GR64:$src)),(iPTR 0)))),
3558               (SUBREG_TO_REG (i64 0), (VMOV64toPQIZrr GR64:$src), sub_xmm)>;
3559
3560     def : Pat<(v8i64 (X86vzmovl (insert_subvector undef,
3561                                  (v2i64 (scalar_to_vector GR64:$src)),(iPTR 0)))),
3562               (SUBREG_TO_REG (i64 0), (VMOV64toPQIZrr GR64:$src), sub_xmm)>;
3563   }
3564   // AVX 128-bit movd/movq instruction write zeros in the high 128-bit part.
3565   let AddedComplexity = 20 in {
3566     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector (zextloadi64i32 addr:$src))))),
3567               (VMOVDI2PDIZrm addr:$src)>;
3568     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector (loadi32 addr:$src))))),
3569               (VMOVDI2PDIZrm addr:$src)>;
3570     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
3571               (VMOVDI2PDIZrm addr:$src)>;
3572     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
3573               (VMOVDI2PDIZrm addr:$src)>;
3574     def : Pat<(v4i32 (X86vzload addr:$src)),
3575               (VMOVDI2PDIZrm addr:$src)>;
3576     def : Pat<(v8i32 (X86vzload addr:$src)),
3577               (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrm addr:$src), sub_xmm)>;
3578     def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
3579               (VMOVQI2PQIZrm addr:$src)>;
3580     def : Pat<(v2f64 (X86vzmovl (v2f64 VR128X:$src))),
3581               (VMOVZPQILo2PQIZrr VR128X:$src)>;
3582     def : Pat<(v2i64 (X86vzload addr:$src)),
3583               (VMOVQI2PQIZrm addr:$src)>;
3584     def : Pat<(v4i64 (X86vzload addr:$src)),
3585               (SUBREG_TO_REG (i64 0), (VMOVQI2PQIZrm addr:$src), sub_xmm)>;
3586   }
3587
3588   // Use regular 128-bit instructions to match 256-bit scalar_to_vec+zext.
3589   def : Pat<(v8i32 (X86vzmovl (insert_subvector undef,
3590                                (v4i32 (scalar_to_vector GR32:$src)),(iPTR 0)))),
3591             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrr GR32:$src), sub_xmm)>;
3592   def : Pat<(v16i32 (X86vzmovl (insert_subvector undef,
3593                                 (v4i32 (scalar_to_vector GR32:$src)),(iPTR 0)))),
3594             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrr GR32:$src), sub_xmm)>;
3595
3596   // Use regular 128-bit instructions to match 512-bit scalar_to_vec+zext.
3597   def : Pat<(v16i32 (X86vzload addr:$src)),
3598             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIZrm addr:$src), sub_xmm)>;
3599   def : Pat<(v8i64 (X86vzload addr:$src)),
3600             (SUBREG_TO_REG (i64 0), (VMOVQI2PQIZrm addr:$src), sub_xmm)>;
3601 }
3602 //===----------------------------------------------------------------------===//
3603 // AVX-512 - Non-temporals
3604 //===----------------------------------------------------------------------===//
3605 let SchedRW = [WriteLoad] in {
3606   def VMOVNTDQAZrm : AVX512PI<0x2A, MRMSrcMem, (outs VR512:$dst),
3607                         (ins i512mem:$src), "vmovntdqa\t{$src, $dst|$dst, $src}",
3608                         [], SSEPackedInt>, EVEX, T8PD, EVEX_V512,
3609                         EVEX_CD8<64, CD8VF>;
3610
3611   let Predicates = [HasVLX] in {
3612     def VMOVNTDQAZ256rm : AVX512PI<0x2A, MRMSrcMem, (outs VR256X:$dst),
3613                          (ins i256mem:$src),
3614                          "vmovntdqa\t{$src, $dst|$dst, $src}",
3615                          [], SSEPackedInt>, EVEX, T8PD, EVEX_V256,
3616                          EVEX_CD8<64, CD8VF>;
3617
3618     def VMOVNTDQAZ128rm : AVX512PI<0x2A, MRMSrcMem, (outs VR128X:$dst),
3619                         (ins i128mem:$src),
3620                         "vmovntdqa\t{$src, $dst|$dst, $src}",
3621                         [], SSEPackedInt>, EVEX, T8PD, EVEX_V128,
3622                         EVEX_CD8<64, CD8VF>;
3623   }
3624 }
3625
3626 multiclass avx512_movnt<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
3627                         PatFrag st_frag = alignednontemporalstore,
3628                         InstrItinClass itin = IIC_SSE_MOVNT> {
3629   let SchedRW = [WriteStore], AddedComplexity = 400 in
3630   def mr : AVX512PI<opc, MRMDestMem, (outs), (ins _.MemOp:$dst, _.RC:$src),
3631                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3632                     [(st_frag (_.VT _.RC:$src), addr:$dst)],
3633                     _.ExeDomain, itin>, EVEX, EVEX_CD8<_.EltSize, CD8VF>;
3634 }
3635
3636 multiclass avx512_movnt_vl<bits<8> opc, string OpcodeStr,
3637                                                   AVX512VLVectorVTInfo VTInfo> {
3638   let Predicates = [HasAVX512] in
3639     defm Z : avx512_movnt<opc, OpcodeStr, VTInfo.info512>, EVEX_V512;
3640
3641   let Predicates = [HasAVX512, HasVLX] in {
3642     defm Z256 : avx512_movnt<opc, OpcodeStr, VTInfo.info256>, EVEX_V256;
3643     defm Z128 : avx512_movnt<opc, OpcodeStr, VTInfo.info128>, EVEX_V128;
3644   }
3645 }
3646
3647 defm VMOVNTDQ : avx512_movnt_vl<0xE7, "vmovntdq", avx512vl_i64_info>, PD;
3648 defm VMOVNTPD : avx512_movnt_vl<0x2B, "vmovntpd", avx512vl_f64_info>, PD, VEX_W;
3649 defm VMOVNTPS : avx512_movnt_vl<0x2B, "vmovntps", avx512vl_f32_info>, PS;
3650
3651 let Predicates = [HasAVX512], AddedComplexity = 400 in {
3652   def : Pat<(alignednontemporalstore (v16i32 VR512:$src), addr:$dst),
3653             (VMOVNTDQZmr addr:$dst, VR512:$src)>;
3654   def : Pat<(alignednontemporalstore (v32i16 VR512:$src), addr:$dst),
3655             (VMOVNTDQZmr addr:$dst, VR512:$src)>;
3656   def : Pat<(alignednontemporalstore (v64i8 VR512:$src), addr:$dst),
3657             (VMOVNTDQZmr addr:$dst, VR512:$src)>;
3658
3659   def : Pat<(v8f64 (alignednontemporalload addr:$src)),
3660             (VMOVNTDQAZrm addr:$src)>;
3661   def : Pat<(v16f32 (alignednontemporalload addr:$src)),
3662             (VMOVNTDQAZrm addr:$src)>;
3663   def : Pat<(v8i64 (alignednontemporalload addr:$src)),
3664             (VMOVNTDQAZrm addr:$src)>;
3665   def : Pat<(v16i32 (bitconvert (v8i64 (alignednontemporalload addr:$src)))),
3666             (VMOVNTDQAZrm addr:$src)>;
3667   def : Pat<(v32i16 (bitconvert (v8i64 (alignednontemporalload addr:$src)))),
3668             (VMOVNTDQAZrm addr:$src)>;
3669   def : Pat<(v64i8 (bitconvert (v8i64 (alignednontemporalload addr:$src)))),
3670             (VMOVNTDQAZrm addr:$src)>;
3671 }
3672
3673 let Predicates = [HasVLX], AddedComplexity = 400 in {
3674   def : Pat<(alignednontemporalstore (v8i32 VR256X:$src), addr:$dst),
3675             (VMOVNTDQZ256mr addr:$dst, VR256X:$src)>;
3676   def : Pat<(alignednontemporalstore (v16i16 VR256X:$src), addr:$dst),
3677             (VMOVNTDQZ256mr addr:$dst, VR256X:$src)>;
3678   def : Pat<(alignednontemporalstore (v32i8 VR256X:$src), addr:$dst),
3679             (VMOVNTDQZ256mr addr:$dst, VR256X:$src)>;
3680
3681   def : Pat<(v4f64 (alignednontemporalload addr:$src)),
3682             (VMOVNTDQAZ256rm addr:$src)>;
3683   def : Pat<(v8f32 (alignednontemporalload addr:$src)),
3684             (VMOVNTDQAZ256rm addr:$src)>;
3685   def : Pat<(v4i64 (alignednontemporalload addr:$src)),
3686             (VMOVNTDQAZ256rm addr:$src)>;
3687   def : Pat<(v8i32 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3688             (VMOVNTDQAZ256rm addr:$src)>;
3689   def : Pat<(v16i16 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3690             (VMOVNTDQAZ256rm addr:$src)>;
3691   def : Pat<(v32i8 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3692             (VMOVNTDQAZ256rm addr:$src)>;
3693
3694   def : Pat<(alignednontemporalstore (v4i32 VR128X:$src), addr:$dst),
3695             (VMOVNTDQZ128mr addr:$dst, VR128X:$src)>;
3696   def : Pat<(alignednontemporalstore (v8i16 VR128X:$src), addr:$dst),
3697             (VMOVNTDQZ128mr addr:$dst, VR128X:$src)>;
3698   def : Pat<(alignednontemporalstore (v16i8 VR128X:$src), addr:$dst),
3699             (VMOVNTDQZ128mr addr:$dst, VR128X:$src)>;
3700
3701   def : Pat<(v2f64 (alignednontemporalload addr:$src)),
3702             (VMOVNTDQAZ128rm addr:$src)>;
3703   def : Pat<(v4f32 (alignednontemporalload addr:$src)),
3704             (VMOVNTDQAZ128rm addr:$src)>;
3705   def : Pat<(v2i64 (alignednontemporalload addr:$src)),
3706             (VMOVNTDQAZ128rm addr:$src)>;
3707   def : Pat<(v4i32 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3708             (VMOVNTDQAZ128rm addr:$src)>;
3709   def : Pat<(v8i16 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3710             (VMOVNTDQAZ128rm addr:$src)>;
3711   def : Pat<(v16i8 (bitconvert (v2i64 (alignednontemporalload addr:$src)))),
3712             (VMOVNTDQAZ128rm addr:$src)>;
3713 }
3714
3715 //===----------------------------------------------------------------------===//
3716 // AVX-512 - Integer arithmetic
3717 //
3718 multiclass avx512_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
3719                            X86VectorVTInfo _, OpndItins itins,
3720                            bit IsCommutable = 0> {
3721   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
3722                     (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
3723                     "$src2, $src1", "$src1, $src2",
3724                     (_.VT (OpNode _.RC:$src1, _.RC:$src2)),
3725                     itins.rr, IsCommutable>,
3726             AVX512BIBase, EVEX_4V;
3727
3728   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
3729                   (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr,
3730                   "$src2, $src1", "$src1, $src2",
3731                   (_.VT (OpNode _.RC:$src1,
3732                                 (bitconvert (_.LdFrag addr:$src2)))),
3733                   itins.rm>,
3734             AVX512BIBase, EVEX_4V;
3735 }
3736
3737 multiclass avx512_binop_rmb<bits<8> opc, string OpcodeStr, SDNode OpNode,
3738                             X86VectorVTInfo _, OpndItins itins,
3739                             bit IsCommutable = 0> :
3740            avx512_binop_rm<opc, OpcodeStr, OpNode, _, itins, IsCommutable> {
3741   defm rmb : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
3742                   (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
3743                   "${src2}"##_.BroadcastStr##", $src1",
3744                   "$src1, ${src2}"##_.BroadcastStr,
3745                   (_.VT (OpNode _.RC:$src1,
3746                                 (X86VBroadcast
3747                                     (_.ScalarLdFrag addr:$src2)))),
3748                   itins.rm>,
3749              AVX512BIBase, EVEX_4V, EVEX_B;
3750 }
3751
3752 multiclass avx512_binop_rm_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
3753                               AVX512VLVectorVTInfo VTInfo, OpndItins itins,
3754                               Predicate prd, bit IsCommutable = 0> {
3755   let Predicates = [prd] in
3756     defm Z : avx512_binop_rm<opc, OpcodeStr, OpNode, VTInfo.info512, itins,
3757                              IsCommutable>, EVEX_V512;
3758
3759   let Predicates = [prd, HasVLX] in {
3760     defm Z256 : avx512_binop_rm<opc, OpcodeStr, OpNode, VTInfo.info256, itins,
3761                              IsCommutable>, EVEX_V256;
3762     defm Z128 : avx512_binop_rm<opc, OpcodeStr, OpNode, VTInfo.info128, itins,
3763                              IsCommutable>, EVEX_V128;
3764   }
3765 }
3766
3767 multiclass avx512_binop_rmb_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
3768                                AVX512VLVectorVTInfo VTInfo, OpndItins itins,
3769                                Predicate prd, bit IsCommutable = 0> {
3770   let Predicates = [prd] in
3771     defm Z : avx512_binop_rmb<opc, OpcodeStr, OpNode, VTInfo.info512, itins,
3772                              IsCommutable>, EVEX_V512;
3773
3774   let Predicates = [prd, HasVLX] in {
3775     defm Z256 : avx512_binop_rmb<opc, OpcodeStr, OpNode, VTInfo.info256, itins,
3776                              IsCommutable>, EVEX_V256;
3777     defm Z128 : avx512_binop_rmb<opc, OpcodeStr, OpNode, VTInfo.info128, itins,
3778                              IsCommutable>, EVEX_V128;
3779   }
3780 }
3781
3782 multiclass avx512_binop_rm_vl_q<bits<8> opc, string OpcodeStr, SDNode OpNode,
3783                                 OpndItins itins, Predicate prd,
3784                                 bit IsCommutable = 0> {
3785   defm NAME : avx512_binop_rmb_vl<opc, OpcodeStr, OpNode, avx512vl_i64_info,
3786                                itins, prd, IsCommutable>,
3787                                VEX_W, EVEX_CD8<64, CD8VF>;
3788 }
3789
3790 multiclass avx512_binop_rm_vl_d<bits<8> opc, string OpcodeStr, SDNode OpNode,
3791                                 OpndItins itins, Predicate prd,
3792                                 bit IsCommutable = 0> {
3793   defm NAME : avx512_binop_rmb_vl<opc, OpcodeStr, OpNode, avx512vl_i32_info,
3794                                itins, prd, IsCommutable>, EVEX_CD8<32, CD8VF>;
3795 }
3796
3797 multiclass avx512_binop_rm_vl_w<bits<8> opc, string OpcodeStr, SDNode OpNode,
3798                                 OpndItins itins, Predicate prd,
3799                                 bit IsCommutable = 0> {
3800   defm NAME : avx512_binop_rm_vl<opc, OpcodeStr, OpNode, avx512vl_i16_info,
3801                               itins, prd, IsCommutable>, EVEX_CD8<16, CD8VF>;
3802 }
3803
3804 multiclass avx512_binop_rm_vl_b<bits<8> opc, string OpcodeStr, SDNode OpNode,
3805                                 OpndItins itins, Predicate prd,
3806                                 bit IsCommutable = 0> {
3807   defm NAME : avx512_binop_rm_vl<opc, OpcodeStr, OpNode, avx512vl_i8_info,
3808                               itins, prd, IsCommutable>, EVEX_CD8<8, CD8VF>;
3809 }
3810
3811 multiclass avx512_binop_rm_vl_dq<bits<8> opc_d, bits<8> opc_q, string OpcodeStr,
3812                                  SDNode OpNode, OpndItins itins, Predicate prd,
3813                                  bit IsCommutable = 0> {
3814   defm Q : avx512_binop_rm_vl_q<opc_q, OpcodeStr#"q", OpNode, itins, prd,
3815                                    IsCommutable>;
3816
3817   defm D : avx512_binop_rm_vl_d<opc_d, OpcodeStr#"d", OpNode, itins, prd,
3818                                    IsCommutable>;
3819 }
3820
3821 multiclass avx512_binop_rm_vl_bw<bits<8> opc_b, bits<8> opc_w, string OpcodeStr,
3822                                  SDNode OpNode, OpndItins itins, Predicate prd,
3823                                  bit IsCommutable = 0> {
3824   defm W : avx512_binop_rm_vl_w<opc_w, OpcodeStr#"w", OpNode, itins, prd,
3825                                    IsCommutable>;
3826
3827   defm B : avx512_binop_rm_vl_b<opc_b, OpcodeStr#"b", OpNode, itins, prd,
3828                                    IsCommutable>;
3829 }
3830
3831 multiclass avx512_binop_rm_vl_all<bits<8> opc_b, bits<8> opc_w,
3832                                   bits<8> opc_d, bits<8> opc_q,
3833                                   string OpcodeStr, SDNode OpNode,
3834                                   OpndItins itins, bit IsCommutable = 0> {
3835   defm NAME : avx512_binop_rm_vl_dq<opc_d, opc_q, OpcodeStr, OpNode,
3836                                     itins, HasAVX512, IsCommutable>,
3837               avx512_binop_rm_vl_bw<opc_b, opc_w, OpcodeStr, OpNode,
3838                                     itins, HasBWI, IsCommutable>;
3839 }
3840
3841 multiclass avx512_binop_rm2<bits<8> opc, string OpcodeStr, OpndItins itins,
3842                             SDNode OpNode,X86VectorVTInfo _Src,
3843                             X86VectorVTInfo _Dst, X86VectorVTInfo _Brdct,
3844                             bit IsCommutable = 0> {
3845   defm rr : AVX512_maskable<opc, MRMSrcReg, _Dst, (outs _Dst.RC:$dst),
3846                             (ins _Src.RC:$src1, _Src.RC:$src2), OpcodeStr,
3847                             "$src2, $src1","$src1, $src2",
3848                             (_Dst.VT (OpNode
3849                                          (_Src.VT _Src.RC:$src1),
3850                                          (_Src.VT _Src.RC:$src2))),
3851                             itins.rr, IsCommutable>,
3852                             AVX512BIBase, EVEX_4V;
3853   defm rm : AVX512_maskable<opc, MRMSrcMem, _Dst, (outs _Dst.RC:$dst),
3854                         (ins _Src.RC:$src1, _Src.MemOp:$src2), OpcodeStr,
3855                         "$src2, $src1", "$src1, $src2",
3856                         (_Dst.VT (OpNode (_Src.VT _Src.RC:$src1),
3857                                       (bitconvert (_Src.LdFrag addr:$src2)))),
3858                         itins.rm>,
3859                         AVX512BIBase, EVEX_4V;
3860
3861   defm rmb : AVX512_maskable<opc, MRMSrcMem, _Dst, (outs _Dst.RC:$dst),
3862                     (ins _Src.RC:$src1, _Brdct.ScalarMemOp:$src2),
3863                     OpcodeStr,
3864                     "${src2}"##_Brdct.BroadcastStr##", $src1",
3865                      "$src1, ${src2}"##_Brdct.BroadcastStr,
3866                     (_Dst.VT (OpNode (_Src.VT _Src.RC:$src1), (bitconvert
3867                                  (_Brdct.VT (X86VBroadcast
3868                                           (_Brdct.ScalarLdFrag addr:$src2)))))),
3869                     itins.rm>,
3870                     AVX512BIBase, EVEX_4V, EVEX_B;
3871 }
3872
3873 defm VPADD : avx512_binop_rm_vl_all<0xFC, 0xFD, 0xFE, 0xD4, "vpadd", add,
3874                                     SSE_INTALU_ITINS_P, 1>;
3875 defm VPSUB : avx512_binop_rm_vl_all<0xF8, 0xF9, 0xFA, 0xFB, "vpsub", sub,
3876                                     SSE_INTALU_ITINS_P, 0>;
3877 defm VPADDS : avx512_binop_rm_vl_bw<0xEC, 0xED, "vpadds", X86adds,
3878                                     SSE_INTALU_ITINS_P, HasBWI, 1>;
3879 defm VPSUBS : avx512_binop_rm_vl_bw<0xE8, 0xE9, "vpsubs", X86subs,
3880                                     SSE_INTALU_ITINS_P, HasBWI, 0>;
3881 defm VPADDUS : avx512_binop_rm_vl_bw<0xDC, 0xDD, "vpaddus", X86addus,
3882                                      SSE_INTALU_ITINS_P, HasBWI, 1>;
3883 defm VPSUBUS : avx512_binop_rm_vl_bw<0xD8, 0xD9, "vpsubus", X86subus,
3884                                      SSE_INTALU_ITINS_P, HasBWI, 0>;
3885 defm VPMULLD : avx512_binop_rm_vl_d<0x40, "vpmulld", mul,
3886                                     SSE_INTALU_ITINS_P, HasAVX512, 1>, T8PD;
3887 defm VPMULLW : avx512_binop_rm_vl_w<0xD5, "vpmullw", mul,
3888                                     SSE_INTALU_ITINS_P, HasBWI, 1>;
3889 defm VPMULLQ : avx512_binop_rm_vl_q<0x40, "vpmullq", mul,
3890                                     SSE_INTALU_ITINS_P, HasDQI, 1>, T8PD;
3891 defm VPMULHW : avx512_binop_rm_vl_w<0xE5, "vpmulhw", mulhs, SSE_INTALU_ITINS_P,
3892                                     HasBWI, 1>;
3893 defm VPMULHUW : avx512_binop_rm_vl_w<0xE4, "vpmulhuw", mulhu, SSE_INTMUL_ITINS_P,
3894                                      HasBWI, 1>;
3895 defm VPMULHRSW : avx512_binop_rm_vl_w<0x0B, "vpmulhrsw", X86mulhrs, SSE_INTMUL_ITINS_P,
3896                                       HasBWI, 1>, T8PD;
3897 defm VPAVG : avx512_binop_rm_vl_bw<0xE0, 0xE3, "vpavg", X86avg,
3898                                    SSE_INTALU_ITINS_P, HasBWI, 1>;
3899
3900 multiclass avx512_binop_all<bits<8> opc, string OpcodeStr, OpndItins itins,
3901                             AVX512VLVectorVTInfo _SrcVTInfo, AVX512VLVectorVTInfo _DstVTInfo,
3902                             SDNode OpNode, Predicate prd,  bit IsCommutable = 0> {
3903   let Predicates = [prd] in
3904     defm NAME#Z : avx512_binop_rm2<opc, OpcodeStr, itins, OpNode,
3905                                  _SrcVTInfo.info512, _DstVTInfo.info512,
3906                                  v8i64_info, IsCommutable>,
3907                                   EVEX_V512, EVEX_CD8<64, CD8VF>, VEX_W;
3908   let Predicates = [HasVLX, prd] in {
3909     defm NAME#Z256 : avx512_binop_rm2<opc, OpcodeStr, itins, OpNode,
3910                                       _SrcVTInfo.info256, _DstVTInfo.info256,
3911                                       v4i64x_info, IsCommutable>,
3912                                       EVEX_V256, EVEX_CD8<64, CD8VF>, VEX_W;
3913     defm NAME#Z128 : avx512_binop_rm2<opc, OpcodeStr, itins, OpNode,
3914                                       _SrcVTInfo.info128, _DstVTInfo.info128,
3915                                       v2i64x_info, IsCommutable>,
3916                                      EVEX_V128, EVEX_CD8<64, CD8VF>, VEX_W;
3917   }
3918 }
3919
3920 defm VPMULDQ : avx512_binop_all<0x28, "vpmuldq", SSE_INTALU_ITINS_P,
3921                                 avx512vl_i32_info, avx512vl_i64_info,
3922                                 X86pmuldq, HasAVX512, 1>,T8PD;
3923 defm VPMULUDQ : avx512_binop_all<0xF4, "vpmuludq", SSE_INTMUL_ITINS_P,
3924                                 avx512vl_i32_info, avx512vl_i64_info,
3925                                 X86pmuludq, HasAVX512, 1>;
3926 defm VPMULTISHIFTQB : avx512_binop_all<0x83, "vpmultishiftqb", SSE_INTALU_ITINS_P,
3927                                 avx512vl_i8_info, avx512vl_i8_info,
3928                                 X86multishift, HasVBMI, 0>, T8PD;
3929
3930 multiclass avx512_packs_rmb<bits<8> opc, string OpcodeStr, SDNode OpNode,
3931                             X86VectorVTInfo _Src, X86VectorVTInfo _Dst> {
3932   defm rmb : AVX512_maskable<opc, MRMSrcMem, _Dst, (outs _Dst.RC:$dst),
3933                     (ins _Src.RC:$src1, _Src.ScalarMemOp:$src2),
3934                     OpcodeStr,
3935                     "${src2}"##_Src.BroadcastStr##", $src1",
3936                      "$src1, ${src2}"##_Src.BroadcastStr,
3937                     (_Dst.VT (OpNode (_Src.VT _Src.RC:$src1), (bitconvert
3938                                  (_Src.VT (X86VBroadcast
3939                                           (_Src.ScalarLdFrag addr:$src2))))))>,
3940                     EVEX_4V, EVEX_B, EVEX_CD8<_Src.EltSize, CD8VF>;
3941 }
3942
3943 multiclass avx512_packs_rm<bits<8> opc, string OpcodeStr,
3944                             SDNode OpNode,X86VectorVTInfo _Src,
3945                             X86VectorVTInfo _Dst, bit IsCommutable = 0> {
3946   defm rr : AVX512_maskable<opc, MRMSrcReg, _Dst, (outs _Dst.RC:$dst),
3947                             (ins _Src.RC:$src1, _Src.RC:$src2), OpcodeStr,
3948                             "$src2, $src1","$src1, $src2",
3949                             (_Dst.VT (OpNode
3950                                          (_Src.VT _Src.RC:$src1),
3951                                          (_Src.VT _Src.RC:$src2))),
3952                             NoItinerary, IsCommutable>,
3953                             EVEX_CD8<_Src.EltSize, CD8VF>, EVEX_4V;
3954   defm rm : AVX512_maskable<opc, MRMSrcMem, _Dst, (outs _Dst.RC:$dst),
3955                         (ins _Src.RC:$src1, _Src.MemOp:$src2), OpcodeStr,
3956                         "$src2, $src1", "$src1, $src2",
3957                         (_Dst.VT (OpNode (_Src.VT _Src.RC:$src1),
3958                                       (bitconvert (_Src.LdFrag addr:$src2))))>,
3959                          EVEX_4V, EVEX_CD8<_Src.EltSize, CD8VF>;
3960 }
3961
3962 multiclass avx512_packs_all_i32_i16<bits<8> opc, string OpcodeStr,
3963                                     SDNode OpNode> {
3964   let Predicates = [HasBWI] in
3965   defm NAME#Z : avx512_packs_rm<opc, OpcodeStr, OpNode, v16i32_info,
3966                                  v32i16_info>,
3967                 avx512_packs_rmb<opc, OpcodeStr, OpNode, v16i32_info,
3968                                  v32i16_info>, EVEX_V512;
3969   let Predicates = [HasBWI, HasVLX] in {
3970     defm NAME#Z256 : avx512_packs_rm<opc, OpcodeStr, OpNode, v8i32x_info,
3971                                      v16i16x_info>,
3972                      avx512_packs_rmb<opc, OpcodeStr, OpNode, v8i32x_info,
3973                                      v16i16x_info>, EVEX_V256;
3974     defm NAME#Z128 : avx512_packs_rm<opc, OpcodeStr, OpNode, v4i32x_info,
3975                                      v8i16x_info>,
3976                      avx512_packs_rmb<opc, OpcodeStr, OpNode, v4i32x_info,
3977                                      v8i16x_info>, EVEX_V128;
3978   }
3979 }
3980 multiclass avx512_packs_all_i16_i8<bits<8> opc, string OpcodeStr,
3981                             SDNode OpNode> {
3982   let Predicates = [HasBWI] in
3983   defm NAME#Z : avx512_packs_rm<opc, OpcodeStr, OpNode, v32i16_info,
3984                                 v64i8_info>, EVEX_V512;
3985   let Predicates = [HasBWI, HasVLX] in {
3986     defm NAME#Z256 : avx512_packs_rm<opc, OpcodeStr, OpNode, v16i16x_info,
3987                                     v32i8x_info>, EVEX_V256;
3988     defm NAME#Z128 : avx512_packs_rm<opc, OpcodeStr, OpNode, v8i16x_info,
3989                                     v16i8x_info>, EVEX_V128;
3990   }
3991 }
3992
3993 multiclass avx512_vpmadd<bits<8> opc, string OpcodeStr,
3994                             SDNode OpNode, AVX512VLVectorVTInfo _Src,
3995                             AVX512VLVectorVTInfo _Dst, bit IsCommutable = 0> {
3996   let Predicates = [HasBWI] in
3997   defm NAME#Z : avx512_packs_rm<opc, OpcodeStr, OpNode, _Src.info512,
3998                                 _Dst.info512, IsCommutable>, EVEX_V512;
3999   let Predicates = [HasBWI, HasVLX] in {
4000     defm NAME#Z256 : avx512_packs_rm<opc, OpcodeStr, OpNode, _Src.info256,
4001                                      _Dst.info256, IsCommutable>, EVEX_V256;
4002     defm NAME#Z128 : avx512_packs_rm<opc, OpcodeStr, OpNode, _Src.info128,
4003                                      _Dst.info128, IsCommutable>, EVEX_V128;
4004   }
4005 }
4006
4007 defm VPACKSSDW : avx512_packs_all_i32_i16<0x6B, "vpackssdw", X86Packss>, AVX512BIBase;
4008 defm VPACKUSDW : avx512_packs_all_i32_i16<0x2b, "vpackusdw", X86Packus>, AVX5128IBase;
4009 defm VPACKSSWB : avx512_packs_all_i16_i8 <0x63, "vpacksswb", X86Packss>, AVX512BIBase;
4010 defm VPACKUSWB : avx512_packs_all_i16_i8 <0x67, "vpackuswb", X86Packus>, AVX512BIBase;
4011
4012 defm VPMADDUBSW : avx512_vpmadd<0x04, "vpmaddubsw", X86vpmaddubsw,
4013                      avx512vl_i8_info, avx512vl_i16_info>, AVX512BIBase, T8PD;
4014 defm VPMADDWD   : avx512_vpmadd<0xF5, "vpmaddwd", X86vpmaddwd,
4015                      avx512vl_i16_info, avx512vl_i32_info, 1>, AVX512BIBase;
4016
4017 defm VPMAXSB : avx512_binop_rm_vl_b<0x3C, "vpmaxsb", smax,
4018                                      SSE_INTALU_ITINS_P, HasBWI, 1>, T8PD;
4019 defm VPMAXSW : avx512_binop_rm_vl_w<0xEE, "vpmaxsw", smax,
4020                                      SSE_INTALU_ITINS_P, HasBWI, 1>;
4021 defm VPMAXS : avx512_binop_rm_vl_dq<0x3D, 0x3D, "vpmaxs", smax,
4022                                      SSE_INTALU_ITINS_P, HasAVX512, 1>, T8PD;
4023
4024 defm VPMAXUB : avx512_binop_rm_vl_b<0xDE, "vpmaxub", umax,
4025                                      SSE_INTALU_ITINS_P, HasBWI, 1>;
4026 defm VPMAXUW : avx512_binop_rm_vl_w<0x3E, "vpmaxuw", umax,
4027                                      SSE_INTALU_ITINS_P, HasBWI, 1>, T8PD;
4028 defm VPMAXU : avx512_binop_rm_vl_dq<0x3F, 0x3F, "vpmaxu", umax,
4029                                      SSE_INTALU_ITINS_P, HasAVX512, 1>, T8PD;
4030
4031 defm VPMINSB : avx512_binop_rm_vl_b<0x38, "vpminsb", smin,
4032                                      SSE_INTALU_ITINS_P, HasBWI, 1>, T8PD;
4033 defm VPMINSW : avx512_binop_rm_vl_w<0xEA, "vpminsw", smin,
4034                                      SSE_INTALU_ITINS_P, HasBWI, 1>;
4035 defm VPMINS : avx512_binop_rm_vl_dq<0x39, 0x39, "vpmins", smin,
4036                                      SSE_INTALU_ITINS_P, HasAVX512, 1>, T8PD;
4037
4038 defm VPMINUB : avx512_binop_rm_vl_b<0xDA, "vpminub", umin,
4039                                      SSE_INTALU_ITINS_P, HasBWI, 1>;
4040 defm VPMINUW : avx512_binop_rm_vl_w<0x3A, "vpminuw", umin,
4041                                      SSE_INTALU_ITINS_P, HasBWI, 1>, T8PD;
4042 defm VPMINU : avx512_binop_rm_vl_dq<0x3B, 0x3B, "vpminu", umin,
4043                                      SSE_INTALU_ITINS_P, HasAVX512, 1>, T8PD;
4044
4045 // PMULLQ: Use 512bit version to implement 128/256 bit in case NoVLX.
4046 let Predicates = [HasDQI, NoVLX] in {
4047   def : Pat<(v4i64 (mul (v4i64 VR256X:$src1), (v4i64 VR256X:$src2))),
4048             (EXTRACT_SUBREG
4049                 (VPMULLQZrr
4050                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src1, sub_ymm),
4051                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src2, sub_ymm)),
4052              sub_ymm)>;
4053
4054   def : Pat<(v2i64 (mul (v2i64 VR128X:$src1), (v2i64 VR128X:$src2))),
4055             (EXTRACT_SUBREG
4056                 (VPMULLQZrr
4057                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src1, sub_xmm),
4058                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src2, sub_xmm)),
4059              sub_xmm)>;
4060 }
4061
4062 //===----------------------------------------------------------------------===//
4063 // AVX-512  Logical Instructions
4064 //===----------------------------------------------------------------------===//
4065
4066 multiclass avx512_logic_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
4067                            X86VectorVTInfo _, bit IsCommutable = 0> {
4068   defm rr : AVX512_maskable_logic<opc, MRMSrcReg, _, (outs _.RC:$dst),
4069                     (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4070                     "$src2, $src1", "$src1, $src2",
4071                     (_.i64VT (OpNode (bitconvert (_.VT _.RC:$src1)),
4072                                      (bitconvert (_.VT _.RC:$src2)))),
4073                     (_.VT (bitconvert (_.i64VT (OpNode _.RC:$src1,
4074                                                        _.RC:$src2)))),
4075                     IIC_SSE_BIT_P_RR, IsCommutable>,
4076             AVX512BIBase, EVEX_4V;
4077
4078   defm rm : AVX512_maskable_logic<opc, MRMSrcMem, _, (outs _.RC:$dst),
4079                   (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr,
4080                   "$src2, $src1", "$src1, $src2",
4081                   (_.i64VT (OpNode (bitconvert (_.VT _.RC:$src1)),
4082                                    (bitconvert (_.LdFrag addr:$src2)))),
4083                   (_.VT (bitconvert (_.i64VT (OpNode _.RC:$src1,
4084                                      (bitconvert (_.LdFrag addr:$src2)))))),
4085                   IIC_SSE_BIT_P_RM>,
4086             AVX512BIBase, EVEX_4V;
4087 }
4088
4089 multiclass avx512_logic_rmb<bits<8> opc, string OpcodeStr, SDNode OpNode,
4090                             X86VectorVTInfo _, bit IsCommutable = 0> :
4091            avx512_logic_rm<opc, OpcodeStr, OpNode, _, IsCommutable> {
4092   defm rmb : AVX512_maskable_logic<opc, MRMSrcMem, _, (outs _.RC:$dst),
4093                   (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
4094                   "${src2}"##_.BroadcastStr##", $src1",
4095                   "$src1, ${src2}"##_.BroadcastStr,
4096                   (_.i64VT (OpNode _.RC:$src1,
4097                                    (bitconvert
4098                                     (_.VT (X86VBroadcast
4099                                             (_.ScalarLdFrag addr:$src2)))))),
4100                   (_.VT (bitconvert (_.i64VT (OpNode _.RC:$src1,
4101                                      (bitconvert
4102                                       (_.VT (X86VBroadcast
4103                                              (_.ScalarLdFrag addr:$src2)))))))),
4104                   IIC_SSE_BIT_P_RM>,
4105              AVX512BIBase, EVEX_4V, EVEX_B;
4106 }
4107
4108 multiclass avx512_logic_rmb_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
4109                                AVX512VLVectorVTInfo VTInfo,
4110                                bit IsCommutable = 0> {
4111   let Predicates = [HasAVX512] in
4112     defm Z : avx512_logic_rmb<opc, OpcodeStr, OpNode, VTInfo.info512,
4113                              IsCommutable>, EVEX_V512;
4114
4115   let Predicates = [HasAVX512, HasVLX] in {
4116     defm Z256 : avx512_logic_rmb<opc, OpcodeStr, OpNode, VTInfo.info256,
4117                              IsCommutable>, EVEX_V256;
4118     defm Z128 : avx512_logic_rmb<opc, OpcodeStr, OpNode, VTInfo.info128,
4119                              IsCommutable>, EVEX_V128;
4120   }
4121 }
4122
4123 multiclass avx512_logic_rm_vl_d<bits<8> opc, string OpcodeStr, SDNode OpNode,
4124                                 bit IsCommutable = 0> {
4125   defm NAME : avx512_logic_rmb_vl<opc, OpcodeStr, OpNode, avx512vl_i32_info,
4126                                   IsCommutable>, EVEX_CD8<32, CD8VF>;
4127 }
4128
4129 multiclass avx512_logic_rm_vl_q<bits<8> opc, string OpcodeStr, SDNode OpNode,
4130                                 bit IsCommutable = 0> {
4131   defm NAME : avx512_logic_rmb_vl<opc, OpcodeStr, OpNode, avx512vl_i64_info,
4132                                   IsCommutable>,
4133                                   VEX_W, EVEX_CD8<64, CD8VF>;
4134 }
4135
4136 multiclass avx512_logic_rm_vl_dq<bits<8> opc_d, bits<8> opc_q, string OpcodeStr,
4137                                  SDNode OpNode, bit IsCommutable = 0> {
4138   defm Q : avx512_logic_rm_vl_q<opc_q, OpcodeStr#"q", OpNode, IsCommutable>;
4139   defm D : avx512_logic_rm_vl_d<opc_d, OpcodeStr#"d", OpNode, IsCommutable>;
4140 }
4141
4142 defm VPAND : avx512_logic_rm_vl_dq<0xDB, 0xDB, "vpand", and, 1>;
4143 defm VPOR : avx512_logic_rm_vl_dq<0xEB, 0xEB, "vpor", or, 1>;
4144 defm VPXOR : avx512_logic_rm_vl_dq<0xEF, 0xEF, "vpxor", xor, 1>;
4145 defm VPANDN : avx512_logic_rm_vl_dq<0xDF, 0xDF, "vpandn", X86andnp>;
4146
4147 //===----------------------------------------------------------------------===//
4148 // AVX-512  FP arithmetic
4149 //===----------------------------------------------------------------------===//
4150 multiclass avx512_fp_scalar<bits<8> opc, string OpcodeStr,X86VectorVTInfo _,
4151                          SDNode OpNode, SDNode VecNode, OpndItins itins,
4152                          bit IsCommutable> {
4153   let ExeDomain = _.ExeDomain in {
4154   defm rr_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
4155                            (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4156                            "$src2, $src1", "$src1, $src2",
4157                            (_.VT (VecNode _.RC:$src1, _.RC:$src2,
4158                                           (i32 FROUND_CURRENT))),
4159                            itins.rr>;
4160
4161   defm rm_Int : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
4162                          (ins _.RC:$src1, _.IntScalarMemOp:$src2), OpcodeStr,
4163                          "$src2, $src1", "$src1, $src2",
4164                          (_.VT (VecNode _.RC:$src1,
4165                                         _.ScalarIntMemCPat:$src2,
4166                                         (i32 FROUND_CURRENT))),
4167                          itins.rm>;
4168   let isCodeGenOnly = 1, Predicates = [HasAVX512] in {
4169   def rr : I< opc, MRMSrcReg, (outs _.FRC:$dst),
4170                          (ins _.FRC:$src1, _.FRC:$src2),
4171                           OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4172                           [(set _.FRC:$dst, (OpNode _.FRC:$src1, _.FRC:$src2))],
4173                           itins.rr> {
4174     let isCommutable = IsCommutable;
4175   }
4176   def rm : I< opc, MRMSrcMem, (outs _.FRC:$dst),
4177                          (ins _.FRC:$src1, _.ScalarMemOp:$src2),
4178                          OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4179                          [(set _.FRC:$dst, (OpNode _.FRC:$src1,
4180                          (_.ScalarLdFrag addr:$src2)))], itins.rm>;
4181   }
4182   }
4183 }
4184
4185 multiclass avx512_fp_scalar_round<bits<8> opc, string OpcodeStr,X86VectorVTInfo _,
4186                          SDNode VecNode, OpndItins itins, bit IsCommutable = 0> {
4187   let ExeDomain = _.ExeDomain in
4188   defm rrb : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
4189                           (ins _.RC:$src1, _.RC:$src2, AVX512RC:$rc), OpcodeStr,
4190                           "$rc, $src2, $src1", "$src1, $src2, $rc",
4191                           (VecNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
4192                           (i32 imm:$rc)), itins.rr, IsCommutable>,
4193                           EVEX_B, EVEX_RC;
4194 }
4195 multiclass avx512_fp_scalar_sae<bits<8> opc, string OpcodeStr,X86VectorVTInfo _,
4196                                 SDNode OpNode, SDNode VecNode, SDNode SaeNode,
4197                                 OpndItins itins, bit IsCommutable> {
4198   let ExeDomain = _.ExeDomain in {
4199   defm rr_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
4200                            (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4201                            "$src2, $src1", "$src1, $src2",
4202                            (_.VT (VecNode _.RC:$src1, _.RC:$src2)),
4203                            itins.rr>;
4204
4205   defm rm_Int : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
4206                          (ins _.RC:$src1, _.IntScalarMemOp:$src2), OpcodeStr,
4207                          "$src2, $src1", "$src1, $src2",
4208                          (_.VT (VecNode _.RC:$src1,
4209                                         _.ScalarIntMemCPat:$src2)),
4210                          itins.rm>;
4211
4212   let isCodeGenOnly = 1, Predicates = [HasAVX512] in {
4213   def rr : I< opc, MRMSrcReg, (outs _.FRC:$dst),
4214                          (ins _.FRC:$src1, _.FRC:$src2),
4215                           OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4216                           [(set _.FRC:$dst, (OpNode _.FRC:$src1, _.FRC:$src2))],
4217                           itins.rr> {
4218     let isCommutable = IsCommutable;
4219   }
4220   def rm : I< opc, MRMSrcMem, (outs _.FRC:$dst),
4221                          (ins _.FRC:$src1, _.ScalarMemOp:$src2),
4222                          OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4223                          [(set _.FRC:$dst, (OpNode _.FRC:$src1,
4224                          (_.ScalarLdFrag addr:$src2)))], itins.rm>;
4225   }
4226
4227   defm rrb : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
4228                             (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4229                             "{sae}, $src2, $src1", "$src1, $src2, {sae}",
4230                             (SaeNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
4231                             (i32 FROUND_NO_EXC))>, EVEX_B;
4232   }
4233 }
4234
4235 multiclass avx512_binop_s_round<bits<8> opc, string OpcodeStr, SDNode OpNode,
4236                                   SDNode VecNode,
4237                                   SizeItins itins, bit IsCommutable> {
4238   defm SSZ : avx512_fp_scalar<opc, OpcodeStr#"ss", f32x_info, OpNode, VecNode,
4239                               itins.s, IsCommutable>,
4240              avx512_fp_scalar_round<opc, OpcodeStr#"ss", f32x_info, VecNode,
4241                               itins.s, IsCommutable>,
4242                               XS, EVEX_4V, VEX_LIG,  EVEX_CD8<32, CD8VT1>;
4243   defm SDZ : avx512_fp_scalar<opc, OpcodeStr#"sd", f64x_info, OpNode, VecNode,
4244                               itins.d,                  IsCommutable>,
4245              avx512_fp_scalar_round<opc, OpcodeStr#"sd", f64x_info, VecNode,
4246                               itins.d, IsCommutable>,
4247                               XD, VEX_W, EVEX_4V, VEX_LIG, EVEX_CD8<64, CD8VT1>;
4248 }
4249
4250 multiclass avx512_binop_s_sae<bits<8> opc, string OpcodeStr, SDNode OpNode,
4251                                   SDNode VecNode, SDNode SaeNode,
4252                                   SizeItins itins, bit IsCommutable> {
4253   defm SSZ : avx512_fp_scalar_sae<opc, OpcodeStr#"ss", f32x_info, OpNode,
4254                               VecNode, SaeNode, itins.s, IsCommutable>,
4255                               XS, EVEX_4V, VEX_LIG,  EVEX_CD8<32, CD8VT1>;
4256   defm SDZ : avx512_fp_scalar_sae<opc, OpcodeStr#"sd", f64x_info, OpNode,
4257                               VecNode, SaeNode, itins.d, IsCommutable>,
4258                               XD, VEX_W, EVEX_4V, VEX_LIG, EVEX_CD8<64, CD8VT1>;
4259 }
4260 defm VADD : avx512_binop_s_round<0x58, "vadd", fadd, X86faddRnds, SSE_ALU_ITINS_S, 1>;
4261 defm VMUL : avx512_binop_s_round<0x59, "vmul", fmul, X86fmulRnds, SSE_MUL_ITINS_S, 1>;
4262 defm VSUB : avx512_binop_s_round<0x5C, "vsub", fsub, X86fsubRnds, SSE_ALU_ITINS_S, 0>;
4263 defm VDIV : avx512_binop_s_round<0x5E, "vdiv", fdiv, X86fdivRnds, SSE_DIV_ITINS_S, 0>;
4264 defm VMIN : avx512_binop_s_sae  <0x5D, "vmin", X86fmin, X86fmins, X86fminRnds,
4265                                  SSE_ALU_ITINS_S, 0>;
4266 defm VMAX : avx512_binop_s_sae  <0x5F, "vmax", X86fmax, X86fmaxs, X86fmaxRnds,
4267                                  SSE_ALU_ITINS_S, 0>;
4268
4269 // MIN/MAX nodes are commutable under "unsafe-fp-math". In this case we use
4270 // X86fminc and X86fmaxc instead of X86fmin and X86fmax
4271 multiclass avx512_comutable_binop_s<bits<8> opc, string OpcodeStr,
4272                           X86VectorVTInfo _, SDNode OpNode, OpndItins itins> {
4273   let isCodeGenOnly = 1, Predicates = [HasAVX512], ExeDomain = _.ExeDomain in {
4274   def rr : I< opc, MRMSrcReg, (outs _.FRC:$dst),
4275                          (ins _.FRC:$src1, _.FRC:$src2),
4276                           OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4277                           [(set _.FRC:$dst, (OpNode _.FRC:$src1, _.FRC:$src2))],
4278                           itins.rr> {
4279     let isCommutable = 1;
4280   }
4281   def rm : I< opc, MRMSrcMem, (outs _.FRC:$dst),
4282                          (ins _.FRC:$src1, _.ScalarMemOp:$src2),
4283                          OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4284                          [(set _.FRC:$dst, (OpNode _.FRC:$src1,
4285                          (_.ScalarLdFrag addr:$src2)))], itins.rm>;
4286   }
4287 }
4288 defm VMINCSSZ : avx512_comutable_binop_s<0x5D, "vminss", f32x_info, X86fminc,
4289                                 SSE_ALU_ITINS_S.s>, XS, EVEX_4V, VEX_LIG,
4290                                 EVEX_CD8<32, CD8VT1>;
4291
4292 defm VMINCSDZ : avx512_comutable_binop_s<0x5D, "vminsd", f64x_info, X86fminc,
4293                                 SSE_ALU_ITINS_S.d>, XD, VEX_W, EVEX_4V, VEX_LIG,
4294                                 EVEX_CD8<64, CD8VT1>;
4295
4296 defm VMAXCSSZ : avx512_comutable_binop_s<0x5F, "vmaxss", f32x_info, X86fmaxc,
4297                                 SSE_ALU_ITINS_S.s>, XS, EVEX_4V, VEX_LIG,
4298                                 EVEX_CD8<32, CD8VT1>;
4299
4300 defm VMAXCSDZ : avx512_comutable_binop_s<0x5F, "vmaxsd", f64x_info, X86fmaxc,
4301                                 SSE_ALU_ITINS_S.d>, XD, VEX_W, EVEX_4V, VEX_LIG,
4302                                 EVEX_CD8<64, CD8VT1>;
4303
4304 multiclass avx512_fp_packed<bits<8> opc, string OpcodeStr, SDPatternOperator OpNode,
4305                             X86VectorVTInfo _, OpndItins itins,
4306                             bit IsCommutable> {
4307   let ExeDomain = _.ExeDomain, hasSideEffects = 0 in {
4308   defm rr: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4309                   (ins _.RC:$src1, _.RC:$src2), OpcodeStr##_.Suffix,
4310                   "$src2, $src1", "$src1, $src2",
4311                   (_.VT (OpNode _.RC:$src1, _.RC:$src2)), itins.rr,
4312                   IsCommutable>, EVEX_4V;
4313   let mayLoad = 1 in {
4314     defm rm: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4315                     (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr##_.Suffix,
4316                     "$src2, $src1", "$src1, $src2",
4317                     (OpNode _.RC:$src1, (_.LdFrag addr:$src2)), itins.rm>,
4318                     EVEX_4V;
4319     defm rmb: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4320                      (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr##_.Suffix,
4321                      "${src2}"##_.BroadcastStr##", $src1",
4322                      "$src1, ${src2}"##_.BroadcastStr,
4323                      (OpNode  _.RC:$src1, (_.VT (X86VBroadcast
4324                                                 (_.ScalarLdFrag addr:$src2)))),
4325                      itins.rm>, EVEX_4V, EVEX_B;
4326     }
4327   }
4328 }
4329
4330 multiclass avx512_fp_round_packed<bits<8> opc, string OpcodeStr, SDPatternOperator OpNodeRnd,
4331                                   X86VectorVTInfo _> {
4332   let ExeDomain = _.ExeDomain in
4333   defm rb: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4334                   (ins _.RC:$src1, _.RC:$src2, AVX512RC:$rc), OpcodeStr##_.Suffix,
4335                   "$rc, $src2, $src1", "$src1, $src2, $rc",
4336                   (_.VT (OpNodeRnd _.RC:$src1, _.RC:$src2, (i32 imm:$rc)))>,
4337                   EVEX_4V, EVEX_B, EVEX_RC;
4338 }
4339
4340
4341 multiclass avx512_fp_sae_packed<bits<8> opc, string OpcodeStr, SDPatternOperator OpNodeRnd,
4342                                 X86VectorVTInfo _> {
4343   let ExeDomain = _.ExeDomain in
4344   defm rb: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4345                   (ins _.RC:$src1, _.RC:$src2), OpcodeStr##_.Suffix,
4346                   "{sae}, $src2, $src1", "$src1, $src2, {sae}",
4347                   (_.VT (OpNodeRnd _.RC:$src1, _.RC:$src2, (i32 FROUND_NO_EXC)))>,
4348                   EVEX_4V, EVEX_B;
4349 }
4350
4351 multiclass avx512_fp_binop_p<bits<8> opc, string OpcodeStr, SDPatternOperator OpNode,
4352                              Predicate prd, SizeItins itins,
4353                              bit IsCommutable = 0> {
4354   let Predicates = [prd] in {
4355   defm PSZ : avx512_fp_packed<opc, OpcodeStr, OpNode, v16f32_info,
4356                               itins.s, IsCommutable>, EVEX_V512, PS,
4357                               EVEX_CD8<32, CD8VF>;
4358   defm PDZ : avx512_fp_packed<opc, OpcodeStr, OpNode, v8f64_info,
4359                               itins.d, IsCommutable>, EVEX_V512, PD, VEX_W,
4360                               EVEX_CD8<64, CD8VF>;
4361   }
4362
4363     // Define only if AVX512VL feature is present.
4364   let Predicates = [prd, HasVLX] in {
4365     defm PSZ128 : avx512_fp_packed<opc, OpcodeStr, OpNode, v4f32x_info,
4366                                    itins.s, IsCommutable>, EVEX_V128, PS,
4367                                    EVEX_CD8<32, CD8VF>;
4368     defm PSZ256 : avx512_fp_packed<opc, OpcodeStr, OpNode, v8f32x_info,
4369                                    itins.s, IsCommutable>, EVEX_V256, PS,
4370                                    EVEX_CD8<32, CD8VF>;
4371     defm PDZ128 : avx512_fp_packed<opc, OpcodeStr, OpNode, v2f64x_info,
4372                                    itins.d, IsCommutable>, EVEX_V128, PD, VEX_W,
4373                                    EVEX_CD8<64, CD8VF>;
4374     defm PDZ256 : avx512_fp_packed<opc, OpcodeStr, OpNode, v4f64x_info,
4375                                    itins.d, IsCommutable>, EVEX_V256, PD, VEX_W,
4376                                    EVEX_CD8<64, CD8VF>;
4377   }
4378 }
4379
4380 multiclass avx512_fp_binop_p_round<bits<8> opc, string OpcodeStr, SDNode OpNodeRnd> {
4381   defm PSZ : avx512_fp_round_packed<opc, OpcodeStr, OpNodeRnd, v16f32_info>,
4382                               EVEX_V512, PS, EVEX_CD8<32, CD8VF>;
4383   defm PDZ : avx512_fp_round_packed<opc, OpcodeStr, OpNodeRnd, v8f64_info>,
4384                               EVEX_V512, PD, VEX_W,EVEX_CD8<64, CD8VF>;
4385 }
4386
4387 multiclass avx512_fp_binop_p_sae<bits<8> opc, string OpcodeStr, SDNode OpNodeRnd> {
4388   defm PSZ : avx512_fp_sae_packed<opc, OpcodeStr, OpNodeRnd, v16f32_info>,
4389                               EVEX_V512, PS, EVEX_CD8<32, CD8VF>;
4390   defm PDZ : avx512_fp_sae_packed<opc, OpcodeStr, OpNodeRnd, v8f64_info>,
4391                               EVEX_V512, PD, VEX_W,EVEX_CD8<64, CD8VF>;
4392 }
4393
4394 defm VADD : avx512_fp_binop_p<0x58, "vadd", fadd, HasAVX512,
4395                               SSE_ALU_ITINS_P, 1>,
4396             avx512_fp_binop_p_round<0x58, "vadd", X86faddRnd>;
4397 defm VMUL : avx512_fp_binop_p<0x59, "vmul", fmul, HasAVX512,
4398                               SSE_MUL_ITINS_P, 1>,
4399             avx512_fp_binop_p_round<0x59, "vmul", X86fmulRnd>;
4400 defm VSUB : avx512_fp_binop_p<0x5C, "vsub", fsub, HasAVX512, SSE_ALU_ITINS_P>,
4401             avx512_fp_binop_p_round<0x5C, "vsub", X86fsubRnd>;
4402 defm VDIV : avx512_fp_binop_p<0x5E, "vdiv", fdiv, HasAVX512, SSE_DIV_ITINS_P>,
4403             avx512_fp_binop_p_round<0x5E, "vdiv", X86fdivRnd>;
4404 defm VMIN : avx512_fp_binop_p<0x5D, "vmin", X86fmin, HasAVX512,
4405                               SSE_ALU_ITINS_P, 0>,
4406             avx512_fp_binop_p_sae<0x5D, "vmin", X86fminRnd>;
4407 defm VMAX : avx512_fp_binop_p<0x5F, "vmax", X86fmax, HasAVX512,
4408                               SSE_ALU_ITINS_P, 0>,
4409             avx512_fp_binop_p_sae<0x5F, "vmax", X86fmaxRnd>;
4410 let isCodeGenOnly = 1 in {
4411   defm VMINC : avx512_fp_binop_p<0x5D, "vmin", X86fminc, HasAVX512,
4412                                  SSE_ALU_ITINS_P, 1>;
4413   defm VMAXC : avx512_fp_binop_p<0x5F, "vmax", X86fmaxc, HasAVX512,
4414                                  SSE_ALU_ITINS_P, 1>;
4415 }
4416 defm VAND  : avx512_fp_binop_p<0x54, "vand", null_frag, HasDQI,
4417                                SSE_ALU_ITINS_P, 1>;
4418 defm VANDN : avx512_fp_binop_p<0x55, "vandn", null_frag, HasDQI,
4419                                SSE_ALU_ITINS_P, 0>;
4420 defm VOR   : avx512_fp_binop_p<0x56, "vor", null_frag, HasDQI,
4421                                SSE_ALU_ITINS_P, 1>;
4422 defm VXOR  : avx512_fp_binop_p<0x57, "vxor", null_frag, HasDQI,
4423                                SSE_ALU_ITINS_P, 1>;
4424
4425 // Patterns catch floating point selects with bitcasted integer logic ops.
4426 multiclass avx512_fp_logical_lowering<string InstrStr, SDNode OpNode,
4427                                       X86VectorVTInfo _, Predicate prd> {
4428 let Predicates = [prd] in {
4429   // Masked register-register logical operations.
4430   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4431                    (bitconvert (_.i64VT (OpNode _.RC:$src1, _.RC:$src2))),
4432                    _.RC:$src0)),
4433             (!cast<Instruction>(InstrStr#rrk) _.RC:$src0, _.KRCWM:$mask,
4434              _.RC:$src1, _.RC:$src2)>;
4435   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4436                    (bitconvert (_.i64VT (OpNode _.RC:$src1, _.RC:$src2))),
4437                    _.ImmAllZerosV)),
4438             (!cast<Instruction>(InstrStr#rrkz) _.KRCWM:$mask, _.RC:$src1,
4439              _.RC:$src2)>;
4440   // Masked register-memory logical operations.
4441   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4442                    (bitconvert (_.i64VT (OpNode _.RC:$src1,
4443                                          (load addr:$src2)))),
4444                    _.RC:$src0)),
4445             (!cast<Instruction>(InstrStr#rmk) _.RC:$src0, _.KRCWM:$mask,
4446              _.RC:$src1, addr:$src2)>;
4447   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4448                    (bitconvert (_.i64VT (OpNode _.RC:$src1, (load addr:$src2)))),
4449                    _.ImmAllZerosV)),
4450             (!cast<Instruction>(InstrStr#rmkz) _.KRCWM:$mask, _.RC:$src1,
4451              addr:$src2)>;
4452   // Register-broadcast logical operations.
4453   def : Pat<(_.i64VT (OpNode _.RC:$src1,
4454                       (bitconvert (_.VT (X86VBroadcast
4455                                          (_.ScalarLdFrag addr:$src2)))))),
4456             (!cast<Instruction>(InstrStr#rmb) _.RC:$src1, addr:$src2)>;
4457   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4458                    (bitconvert
4459                     (_.i64VT (OpNode _.RC:$src1,
4460                               (bitconvert (_.VT
4461                                            (X86VBroadcast
4462                                             (_.ScalarLdFrag addr:$src2))))))),
4463                    _.RC:$src0)),
4464             (!cast<Instruction>(InstrStr#rmbk) _.RC:$src0, _.KRCWM:$mask,
4465              _.RC:$src1, addr:$src2)>;
4466   def : Pat<(_.VT (vselect _.KRCWM:$mask,
4467                    (bitconvert
4468                     (_.i64VT (OpNode _.RC:$src1,
4469                               (bitconvert (_.VT
4470                                            (X86VBroadcast
4471                                             (_.ScalarLdFrag addr:$src2))))))),
4472                    _.ImmAllZerosV)),
4473             (!cast<Instruction>(InstrStr#rmbkz)  _.KRCWM:$mask,
4474              _.RC:$src1, addr:$src2)>;
4475 }
4476 }
4477
4478 multiclass avx512_fp_logical_lowering_sizes<string InstrStr, SDNode OpNode> {
4479   defm : avx512_fp_logical_lowering<InstrStr#DZ128, OpNode, v4f32x_info, HasVLX>;
4480   defm : avx512_fp_logical_lowering<InstrStr#QZ128, OpNode, v2f64x_info, HasVLX>;
4481   defm : avx512_fp_logical_lowering<InstrStr#DZ256, OpNode, v8f32x_info, HasVLX>;
4482   defm : avx512_fp_logical_lowering<InstrStr#QZ256, OpNode, v4f64x_info, HasVLX>;
4483   defm : avx512_fp_logical_lowering<InstrStr#DZ, OpNode, v16f32_info, HasAVX512>;
4484   defm : avx512_fp_logical_lowering<InstrStr#QZ, OpNode, v8f64_info, HasAVX512>;
4485 }
4486
4487 defm : avx512_fp_logical_lowering_sizes<"VPAND", and>;
4488 defm : avx512_fp_logical_lowering_sizes<"VPOR", or>;
4489 defm : avx512_fp_logical_lowering_sizes<"VPXOR", xor>;
4490 defm : avx512_fp_logical_lowering_sizes<"VPANDN", X86andnp>;
4491
4492 let Predicates = [HasVLX,HasDQI] in {
4493   // Use packed logical operations for scalar ops.
4494   def : Pat<(f64 (X86fand FR64X:$src1, FR64X:$src2)),
4495             (COPY_TO_REGCLASS (VANDPDZ128rr
4496                                (COPY_TO_REGCLASS FR64X:$src1, VR128X),
4497                                (COPY_TO_REGCLASS FR64X:$src2, VR128X)), FR64X)>;
4498   def : Pat<(f64 (X86for FR64X:$src1, FR64X:$src2)),
4499             (COPY_TO_REGCLASS (VORPDZ128rr
4500                                (COPY_TO_REGCLASS FR64X:$src1, VR128X),
4501                                (COPY_TO_REGCLASS FR64X:$src2, VR128X)), FR64X)>;
4502   def : Pat<(f64 (X86fxor FR64X:$src1, FR64X:$src2)),
4503             (COPY_TO_REGCLASS (VXORPDZ128rr
4504                                (COPY_TO_REGCLASS FR64X:$src1, VR128X),
4505                                (COPY_TO_REGCLASS FR64X:$src2, VR128X)), FR64X)>;
4506   def : Pat<(f64 (X86fandn FR64X:$src1, FR64X:$src2)),
4507             (COPY_TO_REGCLASS (VANDNPDZ128rr
4508                                (COPY_TO_REGCLASS FR64X:$src1, VR128X),
4509                                (COPY_TO_REGCLASS FR64X:$src2, VR128X)), FR64X)>;
4510
4511   def : Pat<(f32 (X86fand FR32X:$src1, FR32X:$src2)),
4512             (COPY_TO_REGCLASS (VANDPSZ128rr
4513                                (COPY_TO_REGCLASS FR32X:$src1, VR128X),
4514                                (COPY_TO_REGCLASS FR32X:$src2, VR128X)), FR32X)>;
4515   def : Pat<(f32 (X86for FR32X:$src1, FR32X:$src2)),
4516             (COPY_TO_REGCLASS (VORPSZ128rr
4517                                (COPY_TO_REGCLASS FR32X:$src1, VR128X),
4518                                (COPY_TO_REGCLASS FR32X:$src2, VR128X)), FR32X)>;
4519   def : Pat<(f32 (X86fxor FR32X:$src1, FR32X:$src2)),
4520             (COPY_TO_REGCLASS (VXORPSZ128rr
4521                                (COPY_TO_REGCLASS FR32X:$src1, VR128X),
4522                                (COPY_TO_REGCLASS FR32X:$src2, VR128X)), FR32X)>;
4523   def : Pat<(f32 (X86fandn FR32X:$src1, FR32X:$src2)),
4524             (COPY_TO_REGCLASS (VANDNPSZ128rr
4525                                (COPY_TO_REGCLASS FR32X:$src1, VR128X),
4526                                (COPY_TO_REGCLASS FR32X:$src2, VR128X)), FR32X)>;
4527 }
4528
4529 multiclass avx512_fp_scalef_p<bits<8> opc, string OpcodeStr, SDNode OpNode,
4530                             X86VectorVTInfo _> {
4531   let ExeDomain = _.ExeDomain in {
4532   defm rr: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4533                   (ins _.RC:$src1, _.RC:$src2), OpcodeStr##_.Suffix,
4534                   "$src2, $src1", "$src1, $src2",
4535                   (_.VT (OpNode _.RC:$src1, _.RC:$src2, (i32 FROUND_CURRENT)))>, EVEX_4V;
4536   defm rm: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4537                   (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr##_.Suffix,
4538                   "$src2, $src1", "$src1, $src2",
4539                   (OpNode _.RC:$src1, (_.LdFrag addr:$src2), (i32 FROUND_CURRENT))>, EVEX_4V;
4540   defm rmb: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4541                    (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr##_.Suffix,
4542                    "${src2}"##_.BroadcastStr##", $src1",
4543                    "$src1, ${src2}"##_.BroadcastStr,
4544                    (OpNode  _.RC:$src1, (_.VT (X86VBroadcast
4545                                               (_.ScalarLdFrag addr:$src2))), (i32 FROUND_CURRENT))>,
4546                    EVEX_4V, EVEX_B;
4547   }
4548 }
4549
4550 multiclass avx512_fp_scalef_scalar<bits<8> opc, string OpcodeStr, SDNode OpNode,
4551                             X86VectorVTInfo _> {
4552   let ExeDomain = _.ExeDomain in {
4553   defm rr: AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
4554                   (ins _.RC:$src1, _.RC:$src2), OpcodeStr##_.Suffix,
4555                   "$src2, $src1", "$src1, $src2",
4556                   (_.VT (OpNode _.RC:$src1, _.RC:$src2, (i32 FROUND_CURRENT)))>;
4557   defm rm: AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
4558                   (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr##_.Suffix,
4559                   "$src2, $src1", "$src1, $src2",
4560                   (OpNode _.RC:$src1,
4561                           (_.VT (scalar_to_vector (_.ScalarLdFrag addr:$src2))),
4562                           (i32 FROUND_CURRENT))>;
4563   }
4564 }
4565
4566 multiclass avx512_fp_scalef_all<bits<8> opc, bits<8> opcScaler, string OpcodeStr, SDNode OpNode, SDNode OpNodeScal> {
4567   defm PSZ : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v16f32_info>,
4568              avx512_fp_round_packed<opc, OpcodeStr, OpNode, v16f32_info>,
4569                               EVEX_V512, EVEX_CD8<32, CD8VF>;
4570   defm PDZ : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v8f64_info>,
4571              avx512_fp_round_packed<opc, OpcodeStr, OpNode, v8f64_info>,
4572                               EVEX_V512, VEX_W, EVEX_CD8<64, CD8VF>;
4573   defm SSZ128 : avx512_fp_scalef_scalar<opcScaler, OpcodeStr, OpNodeScal, f32x_info>,
4574                 avx512_fp_scalar_round<opcScaler, OpcodeStr##"ss", f32x_info, OpNodeScal, SSE_ALU_ITINS_S.s>,
4575                               EVEX_4V,EVEX_CD8<32, CD8VT1>;
4576   defm SDZ128 : avx512_fp_scalef_scalar<opcScaler, OpcodeStr, OpNodeScal, f64x_info>,
4577                 avx512_fp_scalar_round<opcScaler, OpcodeStr##"sd", f64x_info, OpNodeScal, SSE_ALU_ITINS_S.d>,
4578                               EVEX_4V, EVEX_CD8<64, CD8VT1>, VEX_W;
4579
4580   // Define only if AVX512VL feature is present.
4581   let Predicates = [HasVLX] in {
4582     defm PSZ128 : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v4f32x_info>,
4583                                    EVEX_V128, EVEX_CD8<32, CD8VF>;
4584     defm PSZ256 : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v8f32x_info>,
4585                                    EVEX_V256, EVEX_CD8<32, CD8VF>;
4586     defm PDZ128 : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v2f64x_info>,
4587                                    EVEX_V128, VEX_W, EVEX_CD8<64, CD8VF>;
4588     defm PDZ256 : avx512_fp_scalef_p<opc, OpcodeStr, OpNode, v4f64x_info>,
4589                                    EVEX_V256, VEX_W, EVEX_CD8<64, CD8VF>;
4590   }
4591 }
4592 defm VSCALEF : avx512_fp_scalef_all<0x2C, 0x2D, "vscalef", X86scalef, X86scalefs>, T8PD;
4593
4594 //===----------------------------------------------------------------------===//
4595 // AVX-512  VPTESTM instructions
4596 //===----------------------------------------------------------------------===//
4597
4598 multiclass avx512_vptest<bits<8> opc, string OpcodeStr, SDNode OpNode,
4599                             X86VectorVTInfo _> {
4600   let isCommutable = 1 in
4601   defm rr : AVX512_maskable_cmp<opc, MRMSrcReg, _, (outs _.KRC:$dst),
4602                    (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4603                       "$src2, $src1", "$src1, $src2",
4604                    (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2))>,
4605                     EVEX_4V;
4606   defm rm : AVX512_maskable_cmp<opc, MRMSrcMem, _, (outs _.KRC:$dst),
4607                    (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr,
4608                        "$src2, $src1", "$src1, $src2",
4609                    (OpNode (_.VT _.RC:$src1),
4610                     (_.VT (bitconvert (_.LdFrag addr:$src2))))>,
4611                     EVEX_4V,
4612                    EVEX_CD8<_.EltSize, CD8VF>;
4613 }
4614
4615 multiclass avx512_vptest_mb<bits<8> opc, string OpcodeStr, SDNode OpNode,
4616                             X86VectorVTInfo _> {
4617   defm rmb : AVX512_maskable_cmp<opc, MRMSrcMem, _, (outs _.KRC:$dst),
4618                     (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
4619                     "${src2}"##_.BroadcastStr##", $src1",
4620                     "$src1, ${src2}"##_.BroadcastStr,
4621                     (OpNode (_.VT _.RC:$src1), (_.VT (X86VBroadcast
4622                                                 (_.ScalarLdFrag addr:$src2))))>,
4623                     EVEX_B, EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
4624 }
4625
4626 // Use 512bit version to implement 128/256 bit in case NoVLX.
4627 multiclass avx512_vptest_lowering<SDNode OpNode, X86VectorVTInfo ExtendInfo,
4628                                   X86VectorVTInfo _, string Suffix> {
4629     def : Pat<(_.KVT (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2))),
4630               (_.KVT (COPY_TO_REGCLASS
4631                        (!cast<Instruction>(NAME # Suffix # "Zrr")
4632                          (INSERT_SUBREG (ExtendInfo.VT (IMPLICIT_DEF)),
4633                                         _.RC:$src1, _.SubRegIdx),
4634                          (INSERT_SUBREG (ExtendInfo.VT (IMPLICIT_DEF)),
4635                                         _.RC:$src2, _.SubRegIdx)),
4636                      _.KRC))>;
4637 }
4638
4639 multiclass avx512_vptest_dq_sizes<bits<8> opc, string OpcodeStr, SDNode OpNode,
4640                                   AVX512VLVectorVTInfo _, string Suffix> {
4641   let Predicates  = [HasAVX512] in
4642   defm Z : avx512_vptest<opc, OpcodeStr, OpNode, _.info512>,
4643            avx512_vptest_mb<opc, OpcodeStr, OpNode, _.info512>, EVEX_V512;
4644
4645   let Predicates = [HasAVX512, HasVLX] in {
4646   defm Z256 : avx512_vptest<opc, OpcodeStr, OpNode, _.info256>,
4647               avx512_vptest_mb<opc, OpcodeStr, OpNode, _.info256>, EVEX_V256;
4648   defm Z128 : avx512_vptest<opc, OpcodeStr, OpNode, _.info128>,
4649               avx512_vptest_mb<opc, OpcodeStr, OpNode, _.info128>, EVEX_V128;
4650   }
4651   let Predicates = [HasAVX512, NoVLX] in {
4652   defm Z256_Alt : avx512_vptest_lowering< OpNode, _.info512, _.info256, Suffix>;
4653   defm Z128_Alt : avx512_vptest_lowering< OpNode, _.info512, _.info128, Suffix>;
4654   }
4655 }
4656
4657 multiclass avx512_vptest_dq<bits<8> opc, string OpcodeStr, SDNode OpNode> {
4658   defm D : avx512_vptest_dq_sizes<opc, OpcodeStr#"d", OpNode,
4659                                  avx512vl_i32_info, "D">;
4660   defm Q : avx512_vptest_dq_sizes<opc, OpcodeStr#"q", OpNode,
4661                                  avx512vl_i64_info, "Q">, VEX_W;
4662 }
4663
4664 multiclass avx512_vptest_wb<bits<8> opc, string OpcodeStr,
4665                                  SDNode OpNode> {
4666   let Predicates = [HasBWI] in {
4667   defm WZ:    avx512_vptest<opc, OpcodeStr#"w", OpNode, v32i16_info>,
4668               EVEX_V512, VEX_W;
4669   defm BZ:    avx512_vptest<opc, OpcodeStr#"b", OpNode, v64i8_info>,
4670               EVEX_V512;
4671   }
4672   let Predicates = [HasVLX, HasBWI] in {
4673
4674   defm WZ256: avx512_vptest<opc, OpcodeStr#"w", OpNode, v16i16x_info>,
4675               EVEX_V256, VEX_W;
4676   defm WZ128: avx512_vptest<opc, OpcodeStr#"w", OpNode, v8i16x_info>,
4677               EVEX_V128, VEX_W;
4678   defm BZ256: avx512_vptest<opc, OpcodeStr#"b", OpNode, v32i8x_info>,
4679               EVEX_V256;
4680   defm BZ128: avx512_vptest<opc, OpcodeStr#"b", OpNode, v16i8x_info>,
4681               EVEX_V128;
4682   }
4683
4684   let Predicates = [HasAVX512, NoVLX] in {
4685   defm BZ256_Alt : avx512_vptest_lowering< OpNode, v64i8_info, v32i8x_info, "B">;
4686   defm BZ128_Alt : avx512_vptest_lowering< OpNode, v64i8_info, v16i8x_info, "B">;
4687   defm WZ256_Alt : avx512_vptest_lowering< OpNode, v32i16_info, v16i16x_info, "W">;
4688   defm WZ128_Alt : avx512_vptest_lowering< OpNode, v32i16_info, v8i16x_info, "W">;
4689   }
4690
4691 }
4692
4693 multiclass avx512_vptest_all_forms<bits<8> opc_wb, bits<8> opc_dq, string OpcodeStr,
4694                                    SDNode OpNode> :
4695   avx512_vptest_wb <opc_wb, OpcodeStr, OpNode>,
4696   avx512_vptest_dq<opc_dq, OpcodeStr, OpNode>;
4697
4698 defm VPTESTM   : avx512_vptest_all_forms<0x26, 0x27, "vptestm", X86testm>, T8PD;
4699 defm VPTESTNM  : avx512_vptest_all_forms<0x26, 0x27, "vptestnm", X86testnm>, T8XS;
4700
4701
4702 //===----------------------------------------------------------------------===//
4703 // AVX-512  Shift instructions
4704 //===----------------------------------------------------------------------===//
4705 multiclass avx512_shift_rmi<bits<8> opc, Format ImmFormR, Format ImmFormM,
4706                          string OpcodeStr, SDNode OpNode, X86VectorVTInfo _> {
4707   let ExeDomain = _.ExeDomain in {
4708   defm ri : AVX512_maskable<opc, ImmFormR, _, (outs _.RC:$dst),
4709                    (ins _.RC:$src1, u8imm:$src2), OpcodeStr,
4710                       "$src2, $src1", "$src1, $src2",
4711                    (_.VT (OpNode _.RC:$src1, (i8 imm:$src2))),
4712                    SSE_INTSHIFT_ITINS_P.rr>;
4713   defm mi : AVX512_maskable<opc, ImmFormM, _, (outs _.RC:$dst),
4714                    (ins _.MemOp:$src1, u8imm:$src2), OpcodeStr,
4715                        "$src2, $src1", "$src1, $src2",
4716                    (_.VT (OpNode (_.VT (bitconvert (_.LdFrag addr:$src1))),
4717                           (i8 imm:$src2))),
4718                    SSE_INTSHIFT_ITINS_P.rm>;
4719   }
4720 }
4721
4722 multiclass avx512_shift_rmbi<bits<8> opc, Format ImmFormM,
4723                          string OpcodeStr, SDNode OpNode, X86VectorVTInfo _> {
4724   let ExeDomain = _.ExeDomain in
4725   defm mbi : AVX512_maskable<opc, ImmFormM, _, (outs _.RC:$dst),
4726                    (ins _.ScalarMemOp:$src1, u8imm:$src2), OpcodeStr,
4727       "$src2, ${src1}"##_.BroadcastStr, "${src1}"##_.BroadcastStr##", $src2",
4728      (_.VT (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src1)), (i8 imm:$src2))),
4729      SSE_INTSHIFT_ITINS_P.rm>, EVEX_B;
4730 }
4731
4732 multiclass avx512_shift_rrm<bits<8> opc, string OpcodeStr, SDNode OpNode,
4733                          ValueType SrcVT, PatFrag bc_frag, X86VectorVTInfo _> {
4734    // src2 is always 128-bit
4735   let ExeDomain = _.ExeDomain in {
4736   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4737                    (ins _.RC:$src1, VR128X:$src2), OpcodeStr,
4738                       "$src2, $src1", "$src1, $src2",
4739                    (_.VT (OpNode _.RC:$src1, (SrcVT VR128X:$src2))),
4740                    SSE_INTSHIFT_ITINS_P.rr>, AVX512BIBase, EVEX_4V;
4741   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4742                    (ins _.RC:$src1, i128mem:$src2), OpcodeStr,
4743                        "$src2, $src1", "$src1, $src2",
4744                    (_.VT (OpNode _.RC:$src1, (bc_frag (loadv2i64 addr:$src2)))),
4745                    SSE_INTSHIFT_ITINS_P.rm>, AVX512BIBase,
4746                    EVEX_4V;
4747   }
4748 }
4749
4750 multiclass avx512_shift_sizes<bits<8> opc, string OpcodeStr, SDNode OpNode,
4751                                   ValueType SrcVT, PatFrag bc_frag,
4752                                   AVX512VLVectorVTInfo VTInfo, Predicate prd> {
4753   let Predicates = [prd] in
4754   defm Z    : avx512_shift_rrm<opc, OpcodeStr, OpNode, SrcVT, bc_frag,
4755                             VTInfo.info512>, EVEX_V512,
4756                             EVEX_CD8<VTInfo.info512.EltSize, CD8VQ> ;
4757   let Predicates = [prd, HasVLX] in {
4758   defm Z256 : avx512_shift_rrm<opc, OpcodeStr, OpNode, SrcVT, bc_frag,
4759                             VTInfo.info256>, EVEX_V256,
4760                             EVEX_CD8<VTInfo.info256.EltSize, CD8VH>;
4761   defm Z128 : avx512_shift_rrm<opc, OpcodeStr, OpNode, SrcVT, bc_frag,
4762                             VTInfo.info128>, EVEX_V128,
4763                             EVEX_CD8<VTInfo.info128.EltSize, CD8VF>;
4764   }
4765 }
4766
4767 multiclass avx512_shift_types<bits<8> opcd, bits<8> opcq, bits<8> opcw,
4768                               string OpcodeStr, SDNode OpNode> {
4769   defm D : avx512_shift_sizes<opcd, OpcodeStr#"d", OpNode, v4i32, bc_v4i32,
4770                                  avx512vl_i32_info, HasAVX512>;
4771   defm Q : avx512_shift_sizes<opcq, OpcodeStr#"q", OpNode, v2i64, bc_v2i64,
4772                                  avx512vl_i64_info, HasAVX512>, VEX_W;
4773   defm W : avx512_shift_sizes<opcw, OpcodeStr#"w", OpNode, v8i16, bc_v8i16,
4774                                  avx512vl_i16_info, HasBWI>;
4775 }
4776
4777 multiclass avx512_shift_rmi_sizes<bits<8> opc, Format ImmFormR, Format ImmFormM,
4778                                  string OpcodeStr, SDNode OpNode,
4779                                  AVX512VLVectorVTInfo VTInfo> {
4780   let Predicates = [HasAVX512] in
4781   defm Z:    avx512_shift_rmi<opc, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4782                               VTInfo.info512>,
4783              avx512_shift_rmbi<opc, ImmFormM, OpcodeStr, OpNode,
4784                               VTInfo.info512>, EVEX_V512;
4785   let Predicates = [HasAVX512, HasVLX] in {
4786   defm Z256: avx512_shift_rmi<opc, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4787                               VTInfo.info256>,
4788              avx512_shift_rmbi<opc, ImmFormM, OpcodeStr, OpNode,
4789                               VTInfo.info256>, EVEX_V256;
4790   defm Z128: avx512_shift_rmi<opc, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4791                               VTInfo.info128>,
4792              avx512_shift_rmbi<opc, ImmFormM, OpcodeStr, OpNode,
4793                               VTInfo.info128>, EVEX_V128;
4794   }
4795 }
4796
4797 multiclass avx512_shift_rmi_w<bits<8> opcw,
4798                                  Format ImmFormR, Format ImmFormM,
4799                                  string OpcodeStr, SDNode OpNode> {
4800   let Predicates = [HasBWI] in
4801   defm WZ:    avx512_shift_rmi<opcw, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4802                                v32i16_info>, EVEX_V512;
4803   let Predicates = [HasVLX, HasBWI] in {
4804   defm WZ256: avx512_shift_rmi<opcw, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4805                                v16i16x_info>, EVEX_V256;
4806   defm WZ128: avx512_shift_rmi<opcw, ImmFormR, ImmFormM, OpcodeStr, OpNode,
4807                                v8i16x_info>, EVEX_V128;
4808   }
4809 }
4810
4811 multiclass avx512_shift_rmi_dq<bits<8> opcd, bits<8> opcq,
4812                                  Format ImmFormR, Format ImmFormM,
4813                                  string OpcodeStr, SDNode OpNode> {
4814   defm D: avx512_shift_rmi_sizes<opcd, ImmFormR, ImmFormM, OpcodeStr#"d", OpNode,
4815                                  avx512vl_i32_info>, EVEX_CD8<32, CD8VF>;
4816   defm Q: avx512_shift_rmi_sizes<opcq, ImmFormR, ImmFormM, OpcodeStr#"q", OpNode,
4817                                  avx512vl_i64_info>, EVEX_CD8<64, CD8VF>, VEX_W;
4818 }
4819
4820 defm VPSRL : avx512_shift_rmi_dq<0x72, 0x73, MRM2r, MRM2m, "vpsrl", X86vsrli>,
4821              avx512_shift_rmi_w<0x71, MRM2r, MRM2m, "vpsrlw", X86vsrli>, AVX512BIi8Base, EVEX_4V;
4822
4823 defm VPSLL : avx512_shift_rmi_dq<0x72, 0x73, MRM6r, MRM6m, "vpsll", X86vshli>,
4824              avx512_shift_rmi_w<0x71, MRM6r, MRM6m, "vpsllw", X86vshli>, AVX512BIi8Base, EVEX_4V;
4825
4826 defm VPSRA : avx512_shift_rmi_dq<0x72, 0x72, MRM4r, MRM4m, "vpsra", X86vsrai>,
4827              avx512_shift_rmi_w<0x71, MRM4r, MRM4m, "vpsraw", X86vsrai>, AVX512BIi8Base, EVEX_4V;
4828
4829 defm VPROR : avx512_shift_rmi_dq<0x72, 0x72, MRM0r, MRM0m, "vpror", X86vrotri>, AVX512BIi8Base, EVEX_4V;
4830 defm VPROL : avx512_shift_rmi_dq<0x72, 0x72, MRM1r, MRM1m, "vprol", X86vrotli>, AVX512BIi8Base, EVEX_4V;
4831
4832 defm VPSLL : avx512_shift_types<0xF2, 0xF3, 0xF1, "vpsll", X86vshl>;
4833 defm VPSRA : avx512_shift_types<0xE2, 0xE2, 0xE1, "vpsra", X86vsra>;
4834 defm VPSRL : avx512_shift_types<0xD2, 0xD3, 0xD1, "vpsrl", X86vsrl>;
4835
4836 // Use 512bit VPSRA/VPSRAI version to implement v2i64/v4i64 in case NoVLX.
4837 let Predicates = [HasAVX512, NoVLX] in {
4838   def : Pat<(v4i64 (X86vsra (v4i64 VR256X:$src1), (v2i64 VR128X:$src2))),
4839             (EXTRACT_SUBREG (v8i64
4840               (VPSRAQZrr
4841                 (v8i64 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
4842                  VR128X:$src2)), sub_ymm)>;
4843
4844   def : Pat<(v2i64 (X86vsra (v2i64 VR128X:$src1), (v2i64 VR128X:$src2))),
4845             (EXTRACT_SUBREG (v8i64
4846               (VPSRAQZrr
4847                 (v8i64 (INSERT_SUBREG (IMPLICIT_DEF), VR128X:$src1, sub_xmm)),
4848                  VR128X:$src2)), sub_xmm)>;
4849
4850   def : Pat<(v4i64 (X86vsrai (v4i64 VR256X:$src1), (i8 imm:$src2))),
4851             (EXTRACT_SUBREG (v8i64
4852               (VPSRAQZri
4853                 (v8i64 (INSERT_SUBREG (IMPLICIT_DEF), VR256X:$src1, sub_ymm)),
4854                  imm:$src2)), sub_ymm)>;
4855
4856   def : Pat<(v2i64 (X86vsrai (v2i64 VR128X:$src1), (i8 imm:$src2))),
4857             (EXTRACT_SUBREG (v8i64
4858               (VPSRAQZri
4859                 (v8i64 (INSERT_SUBREG (IMPLICIT_DEF), VR128X:$src1, sub_xmm)),
4860                  imm:$src2)), sub_xmm)>;
4861 }
4862
4863 //===-------------------------------------------------------------------===//
4864 // Variable Bit Shifts
4865 //===-------------------------------------------------------------------===//
4866 multiclass avx512_var_shift<bits<8> opc, string OpcodeStr, SDNode OpNode,
4867                             X86VectorVTInfo _> {
4868   let ExeDomain = _.ExeDomain in {
4869   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
4870                    (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
4871                       "$src2, $src1", "$src1, $src2",
4872                    (_.VT (OpNode _.RC:$src1, (_.VT _.RC:$src2))),
4873                    SSE_INTSHIFT_ITINS_P.rr>, AVX5128IBase, EVEX_4V;
4874   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4875                    (ins _.RC:$src1, _.MemOp:$src2), OpcodeStr,
4876                        "$src2, $src1", "$src1, $src2",
4877                    (_.VT (OpNode _.RC:$src1,
4878                    (_.VT (bitconvert (_.LdFrag addr:$src2))))),
4879                    SSE_INTSHIFT_ITINS_P.rm>, AVX5128IBase, EVEX_4V,
4880                    EVEX_CD8<_.EltSize, CD8VF>;
4881   }
4882 }
4883
4884 multiclass avx512_var_shift_mb<bits<8> opc, string OpcodeStr, SDNode OpNode,
4885                             X86VectorVTInfo _> {
4886   let ExeDomain = _.ExeDomain in
4887   defm rmb : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
4888                     (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
4889                     "${src2}"##_.BroadcastStr##", $src1",
4890                     "$src1, ${src2}"##_.BroadcastStr,
4891                     (_.VT (OpNode _.RC:$src1, (_.VT (X86VBroadcast
4892                                                 (_.ScalarLdFrag addr:$src2))))),
4893                     SSE_INTSHIFT_ITINS_P.rm>, AVX5128IBase, EVEX_B,
4894                     EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
4895 }
4896
4897 multiclass avx512_var_shift_sizes<bits<8> opc, string OpcodeStr, SDNode OpNode,
4898                                   AVX512VLVectorVTInfo _> {
4899   let Predicates  = [HasAVX512] in
4900   defm Z : avx512_var_shift<opc, OpcodeStr, OpNode, _.info512>,
4901            avx512_var_shift_mb<opc, OpcodeStr, OpNode, _.info512>, EVEX_V512;
4902
4903   let Predicates = [HasAVX512, HasVLX] in {
4904   defm Z256 : avx512_var_shift<opc, OpcodeStr, OpNode, _.info256>,
4905               avx512_var_shift_mb<opc, OpcodeStr, OpNode, _.info256>, EVEX_V256;
4906   defm Z128 : avx512_var_shift<opc, OpcodeStr, OpNode, _.info128>,
4907               avx512_var_shift_mb<opc, OpcodeStr, OpNode, _.info128>, EVEX_V128;
4908   }
4909 }
4910
4911 multiclass avx512_var_shift_types<bits<8> opc, string OpcodeStr,
4912                                  SDNode OpNode> {
4913   defm D : avx512_var_shift_sizes<opc, OpcodeStr#"d", OpNode,
4914                                  avx512vl_i32_info>;
4915   defm Q : avx512_var_shift_sizes<opc, OpcodeStr#"q", OpNode,
4916                                  avx512vl_i64_info>, VEX_W;
4917 }
4918
4919 // Use 512bit version to implement 128/256 bit in case NoVLX.
4920 multiclass avx512_var_shift_lowering<AVX512VLVectorVTInfo _, string OpcodeStr,
4921                                      SDNode OpNode, list<Predicate> p> {
4922   let Predicates = p in {
4923   def : Pat<(_.info256.VT (OpNode (_.info256.VT _.info256.RC:$src1),
4924                                   (_.info256.VT _.info256.RC:$src2))),
4925             (EXTRACT_SUBREG
4926                 (!cast<Instruction>(OpcodeStr#"Zrr")
4927                     (INSERT_SUBREG (_.info512.VT (IMPLICIT_DEF)), VR256X:$src1, sub_ymm),
4928                     (INSERT_SUBREG (_.info512.VT (IMPLICIT_DEF)), VR256X:$src2, sub_ymm)),
4929              sub_ymm)>;
4930
4931   def : Pat<(_.info128.VT (OpNode (_.info128.VT _.info128.RC:$src1),
4932                                   (_.info128.VT _.info128.RC:$src2))),
4933             (EXTRACT_SUBREG
4934                 (!cast<Instruction>(OpcodeStr#"Zrr")
4935                     (INSERT_SUBREG (_.info512.VT (IMPLICIT_DEF)), VR128X:$src1, sub_xmm),
4936                     (INSERT_SUBREG (_.info512.VT (IMPLICIT_DEF)), VR128X:$src2, sub_xmm)),
4937              sub_xmm)>;
4938   }
4939 }
4940 multiclass avx512_var_shift_w<bits<8> opc, string OpcodeStr,
4941                                  SDNode OpNode> {
4942   let Predicates = [HasBWI] in
4943   defm WZ:    avx512_var_shift<opc, OpcodeStr, OpNode, v32i16_info>,
4944               EVEX_V512, VEX_W;
4945   let Predicates = [HasVLX, HasBWI] in {
4946
4947   defm WZ256: avx512_var_shift<opc, OpcodeStr, OpNode, v16i16x_info>,
4948               EVEX_V256, VEX_W;
4949   defm WZ128: avx512_var_shift<opc, OpcodeStr, OpNode, v8i16x_info>,
4950               EVEX_V128, VEX_W;
4951   }
4952 }
4953
4954 defm VPSLLV : avx512_var_shift_types<0x47, "vpsllv", shl>,
4955               avx512_var_shift_w<0x12, "vpsllvw", shl>;
4956
4957 defm VPSRAV : avx512_var_shift_types<0x46, "vpsrav", sra>,
4958               avx512_var_shift_w<0x11, "vpsravw", sra>;
4959
4960 defm VPSRLV : avx512_var_shift_types<0x45, "vpsrlv", srl>,
4961               avx512_var_shift_w<0x10, "vpsrlvw", srl>;
4962
4963 defm VPRORV : avx512_var_shift_types<0x14, "vprorv", rotr>;
4964 defm VPROLV : avx512_var_shift_types<0x15, "vprolv", rotl>;
4965
4966 defm : avx512_var_shift_lowering<avx512vl_i64_info, "VPSRAVQ", sra, [HasAVX512, NoVLX]>;
4967 defm : avx512_var_shift_lowering<avx512vl_i16_info, "VPSLLVW", shl, [HasBWI, NoVLX]>;
4968 defm : avx512_var_shift_lowering<avx512vl_i16_info, "VPSRAVW", sra, [HasBWI, NoVLX]>;
4969 defm : avx512_var_shift_lowering<avx512vl_i16_info, "VPSRLVW", srl, [HasBWI, NoVLX]>;
4970
4971 // Special handing for handling VPSRAV intrinsics.
4972 multiclass avx512_var_shift_int_lowering<string InstrStr, X86VectorVTInfo _,
4973                                          list<Predicate> p> {
4974   let Predicates = p in {
4975     def : Pat<(_.VT (X86vsrav _.RC:$src1, _.RC:$src2)),
4976               (!cast<Instruction>(InstrStr#_.ZSuffix#rr) _.RC:$src1,
4977                _.RC:$src2)>;
4978     def : Pat<(_.VT (X86vsrav _.RC:$src1, (bitconvert (_.LdFrag addr:$src2)))),
4979               (!cast<Instruction>(InstrStr#_.ZSuffix##rm)
4980                _.RC:$src1, addr:$src2)>;
4981     def : Pat<(_.VT (vselect _.KRCWM:$mask,
4982                      (X86vsrav _.RC:$src1, _.RC:$src2), _.RC:$src0)),
4983               (!cast<Instruction>(InstrStr#_.ZSuffix#rrk) _.RC:$src0,
4984                _.KRC:$mask, _.RC:$src1, _.RC:$src2)>;
4985     def : Pat<(_.VT (vselect _.KRCWM:$mask,
4986                      (X86vsrav _.RC:$src1, (bitconvert (_.LdFrag addr:$src2))),
4987                      _.RC:$src0)),
4988               (!cast<Instruction>(InstrStr#_.ZSuffix##rmk) _.RC:$src0,
4989                _.KRC:$mask, _.RC:$src1, addr:$src2)>;
4990     def : Pat<(_.VT (vselect _.KRCWM:$mask,
4991                      (X86vsrav _.RC:$src1, _.RC:$src2), _.ImmAllZerosV)),
4992               (!cast<Instruction>(InstrStr#_.ZSuffix#rrkz) _.KRC:$mask,
4993                _.RC:$src1, _.RC:$src2)>;
4994     def : Pat<(_.VT (vselect _.KRCWM:$mask,
4995                      (X86vsrav _.RC:$src1, (bitconvert (_.LdFrag addr:$src2))),
4996                      _.ImmAllZerosV)),
4997               (!cast<Instruction>(InstrStr#_.ZSuffix##rmkz) _.KRC:$mask,
4998                _.RC:$src1, addr:$src2)>;
4999   }
5000 }
5001
5002 multiclass avx512_var_shift_int_lowering_mb<string InstrStr, X86VectorVTInfo _,
5003                                          list<Predicate> p> :
5004            avx512_var_shift_int_lowering<InstrStr, _, p> {
5005   let Predicates = p in {
5006     def : Pat<(_.VT (X86vsrav _.RC:$src1,
5007                      (X86VBroadcast (_.ScalarLdFrag addr:$src2)))),
5008               (!cast<Instruction>(InstrStr#_.ZSuffix##rmb)
5009                _.RC:$src1, addr:$src2)>;
5010     def : Pat<(_.VT (vselect _.KRCWM:$mask,
5011                      (X86vsrav _.RC:$src1,
5012                       (X86VBroadcast (_.ScalarLdFrag addr:$src2))),
5013                      _.RC:$src0)),
5014               (!cast<Instruction>(InstrStr#_.ZSuffix##rmbk) _.RC:$src0,
5015                _.KRC:$mask, _.RC:$src1, addr:$src2)>;
5016     def : Pat<(_.VT (vselect _.KRCWM:$mask,
5017                      (X86vsrav _.RC:$src1,
5018                       (X86VBroadcast (_.ScalarLdFrag addr:$src2))),
5019                      _.ImmAllZerosV)),
5020               (!cast<Instruction>(InstrStr#_.ZSuffix##rmbkz) _.KRC:$mask,
5021                _.RC:$src1, addr:$src2)>;
5022   }
5023 }
5024
5025 defm : avx512_var_shift_int_lowering<"VPSRAVW", v8i16x_info, [HasVLX, HasBWI]>;
5026 defm : avx512_var_shift_int_lowering<"VPSRAVW", v16i16x_info, [HasVLX, HasBWI]>;
5027 defm : avx512_var_shift_int_lowering<"VPSRAVW", v32i16_info, [HasBWI]>;
5028 defm : avx512_var_shift_int_lowering_mb<"VPSRAVD", v4i32x_info, [HasVLX]>;
5029 defm : avx512_var_shift_int_lowering_mb<"VPSRAVD", v8i32x_info, [HasVLX]>;
5030 defm : avx512_var_shift_int_lowering_mb<"VPSRAVD", v16i32_info, [HasAVX512]>;
5031 defm : avx512_var_shift_int_lowering_mb<"VPSRAVQ", v2i64x_info, [HasVLX]>;
5032 defm : avx512_var_shift_int_lowering_mb<"VPSRAVQ", v4i64x_info, [HasVLX]>;
5033 defm : avx512_var_shift_int_lowering_mb<"VPSRAVQ", v8i64_info, [HasAVX512]>;
5034
5035 //===-------------------------------------------------------------------===//
5036 // 1-src variable permutation VPERMW/D/Q
5037 //===-------------------------------------------------------------------===//
5038 multiclass avx512_vperm_dq_sizes<bits<8> opc, string OpcodeStr, SDNode OpNode,
5039                                   AVX512VLVectorVTInfo _> {
5040   let Predicates  = [HasAVX512] in
5041   defm Z : avx512_var_shift<opc, OpcodeStr, OpNode, _.info512>,
5042            avx512_var_shift_mb<opc, OpcodeStr, OpNode, _.info512>, EVEX_V512;
5043
5044   let Predicates = [HasAVX512, HasVLX] in
5045   defm Z256 : avx512_var_shift<opc, OpcodeStr, OpNode, _.info256>,
5046               avx512_var_shift_mb<opc, OpcodeStr, OpNode, _.info256>, EVEX_V256;
5047 }
5048
5049 multiclass avx512_vpermi_dq_sizes<bits<8> opc, Format ImmFormR, Format ImmFormM,
5050                                  string OpcodeStr, SDNode OpNode,
5051                                  AVX512VLVectorVTInfo VTInfo> {
5052   let Predicates = [HasAVX512] in
5053   defm Z:    avx512_shift_rmi<opc, ImmFormR, ImmFormM, OpcodeStr, OpNode,
5054                               VTInfo.info512>,
5055              avx512_shift_rmbi<opc, ImmFormM, OpcodeStr, OpNode,
5056                               VTInfo.info512>, EVEX_V512;
5057   let Predicates = [HasAVX512, HasVLX] in
5058   defm Z256: avx512_shift_rmi<opc, ImmFormR, ImmFormM, OpcodeStr, OpNode,
5059                               VTInfo.info256>,
5060              avx512_shift_rmbi<opc, ImmFormM, OpcodeStr, OpNode,
5061                               VTInfo.info256>, EVEX_V256;
5062 }
5063
5064 multiclass avx512_vperm_bw<bits<8> opc, string OpcodeStr,
5065                               Predicate prd, SDNode OpNode,
5066                               AVX512VLVectorVTInfo _> {
5067   let Predicates = [prd] in
5068   defm Z:    avx512_var_shift<opc, OpcodeStr, OpNode, _.info512>,
5069               EVEX_V512 ;
5070   let Predicates = [HasVLX, prd] in {
5071   defm Z256: avx512_var_shift<opc, OpcodeStr, OpNode, _.info256>,
5072               EVEX_V256 ;
5073   defm Z128: avx512_var_shift<opc, OpcodeStr, OpNode, _.info128>,
5074               EVEX_V128 ;
5075   }
5076 }
5077
5078 defm VPERMW  : avx512_vperm_bw<0x8D, "vpermw", HasBWI, X86VPermv,
5079                                   avx512vl_i16_info>, VEX_W;
5080 defm VPERMB  : avx512_vperm_bw<0x8D, "vpermb", HasVBMI, X86VPermv,
5081                                   avx512vl_i8_info>;
5082
5083 defm VPERMD : avx512_vperm_dq_sizes<0x36, "vpermd", X86VPermv,
5084                                     avx512vl_i32_info>;
5085 defm VPERMQ : avx512_vperm_dq_sizes<0x36, "vpermq", X86VPermv,
5086                                     avx512vl_i64_info>, VEX_W;
5087 defm VPERMPS : avx512_vperm_dq_sizes<0x16, "vpermps", X86VPermv,
5088                                     avx512vl_f32_info>;
5089 defm VPERMPD : avx512_vperm_dq_sizes<0x16, "vpermpd", X86VPermv,
5090                                     avx512vl_f64_info>, VEX_W;
5091
5092 defm VPERMQ : avx512_vpermi_dq_sizes<0x00, MRMSrcReg, MRMSrcMem, "vpermq",
5093                              X86VPermi, avx512vl_i64_info>,
5094                              EVEX, AVX512AIi8Base, EVEX_CD8<64, CD8VF>, VEX_W;
5095 defm VPERMPD : avx512_vpermi_dq_sizes<0x01, MRMSrcReg, MRMSrcMem, "vpermpd",
5096                              X86VPermi, avx512vl_f64_info>,
5097                              EVEX, AVX512AIi8Base, EVEX_CD8<64, CD8VF>, VEX_W;
5098 //===----------------------------------------------------------------------===//
5099 // AVX-512 - VPERMIL
5100 //===----------------------------------------------------------------------===//
5101
5102 multiclass avx512_permil_vec<bits<8> OpcVar, string OpcodeStr,  SDNode OpNode,
5103                              X86VectorVTInfo _, X86VectorVTInfo Ctrl> {
5104   defm rr: AVX512_maskable<OpcVar, MRMSrcReg, _, (outs _.RC:$dst),
5105                   (ins _.RC:$src1, Ctrl.RC:$src2), OpcodeStr,
5106                   "$src2, $src1", "$src1, $src2",
5107                   (_.VT (OpNode _.RC:$src1,
5108                                (Ctrl.VT Ctrl.RC:$src2)))>,
5109                   T8PD, EVEX_4V;
5110   defm rm: AVX512_maskable<OpcVar, MRMSrcMem, _, (outs _.RC:$dst),
5111                   (ins _.RC:$src1, Ctrl.MemOp:$src2), OpcodeStr,
5112                   "$src2, $src1", "$src1, $src2",
5113                   (_.VT (OpNode
5114                            _.RC:$src1,
5115                            (Ctrl.VT (bitconvert(Ctrl.LdFrag addr:$src2)))))>,
5116                   T8PD, EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
5117   defm rmb: AVX512_maskable<OpcVar, MRMSrcMem, _, (outs _.RC:$dst),
5118                    (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
5119                    "${src2}"##_.BroadcastStr##", $src1",
5120                    "$src1, ${src2}"##_.BroadcastStr,
5121                    (_.VT (OpNode
5122                             _.RC:$src1,
5123                             (Ctrl.VT (X86VBroadcast
5124                                        (Ctrl.ScalarLdFrag addr:$src2)))))>,
5125                    T8PD, EVEX_4V, EVEX_B, EVEX_CD8<_.EltSize, CD8VF>;
5126 }
5127
5128 multiclass avx512_permil_vec_common<string OpcodeStr, bits<8> OpcVar,
5129                              AVX512VLVectorVTInfo _, AVX512VLVectorVTInfo Ctrl>{
5130   let Predicates = [HasAVX512] in {
5131     defm Z    : avx512_permil_vec<OpcVar, OpcodeStr, X86VPermilpv, _.info512,
5132                                   Ctrl.info512>, EVEX_V512;
5133   }
5134   let Predicates = [HasAVX512, HasVLX] in {
5135     defm Z128 : avx512_permil_vec<OpcVar, OpcodeStr, X86VPermilpv, _.info128,
5136                                   Ctrl.info128>, EVEX_V128;
5137     defm Z256 : avx512_permil_vec<OpcVar, OpcodeStr, X86VPermilpv, _.info256,
5138                                   Ctrl.info256>, EVEX_V256;
5139   }
5140 }
5141
5142 multiclass avx512_permil<string OpcodeStr, bits<8> OpcImm, bits<8> OpcVar,
5143                          AVX512VLVectorVTInfo _, AVX512VLVectorVTInfo Ctrl>{
5144
5145   defm NAME: avx512_permil_vec_common<OpcodeStr, OpcVar, _, Ctrl>;
5146   defm NAME: avx512_shift_rmi_sizes<OpcImm, MRMSrcReg, MRMSrcMem, OpcodeStr,
5147                                     X86VPermilpi, _>,
5148                     EVEX, AVX512AIi8Base, EVEX_CD8<_.info128.EltSize, CD8VF>;
5149 }
5150
5151 let ExeDomain = SSEPackedSingle in
5152 defm VPERMILPS : avx512_permil<"vpermilps", 0x04, 0x0C, avx512vl_f32_info,
5153                                avx512vl_i32_info>;
5154 let ExeDomain = SSEPackedDouble in
5155 defm VPERMILPD : avx512_permil<"vpermilpd", 0x05, 0x0D, avx512vl_f64_info,
5156                                avx512vl_i64_info>, VEX_W;
5157 //===----------------------------------------------------------------------===//
5158 // AVX-512 - VPSHUFD, VPSHUFLW, VPSHUFHW
5159 //===----------------------------------------------------------------------===//
5160
5161 defm VPSHUFD : avx512_shift_rmi_sizes<0x70, MRMSrcReg, MRMSrcMem, "vpshufd",
5162                              X86PShufd, avx512vl_i32_info>,
5163                              EVEX, AVX512BIi8Base, EVEX_CD8<32, CD8VF>;
5164 defm VPSHUFH : avx512_shift_rmi_w<0x70, MRMSrcReg, MRMSrcMem, "vpshufhw",
5165                                   X86PShufhw>, EVEX, AVX512XSIi8Base;
5166 defm VPSHUFL : avx512_shift_rmi_w<0x70, MRMSrcReg, MRMSrcMem, "vpshuflw",
5167                                   X86PShuflw>, EVEX, AVX512XDIi8Base;
5168
5169 multiclass avx512_pshufb_sizes<bits<8> opc, string OpcodeStr, SDNode OpNode> {
5170   let Predicates = [HasBWI] in
5171   defm Z:    avx512_var_shift<opc, OpcodeStr, OpNode, v64i8_info>, EVEX_V512;
5172
5173   let Predicates = [HasVLX, HasBWI] in {
5174   defm Z256: avx512_var_shift<opc, OpcodeStr, OpNode, v32i8x_info>, EVEX_V256;
5175   defm Z128: avx512_var_shift<opc, OpcodeStr, OpNode, v16i8x_info>, EVEX_V128;
5176   }
5177 }
5178
5179 defm VPSHUFB: avx512_pshufb_sizes<0x00, "vpshufb", X86pshufb>;
5180
5181 //===----------------------------------------------------------------------===//
5182 // Move Low to High and High to Low packed FP Instructions
5183 //===----------------------------------------------------------------------===//
5184 def VMOVLHPSZrr : AVX512PSI<0x16, MRMSrcReg, (outs VR128X:$dst),
5185           (ins VR128X:$src1, VR128X:$src2),
5186           "vmovlhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
5187           [(set VR128X:$dst, (v4f32 (X86Movlhps VR128X:$src1, VR128X:$src2)))],
5188            IIC_SSE_MOV_LH>, EVEX_4V;
5189 def VMOVHLPSZrr : AVX512PSI<0x12, MRMSrcReg, (outs VR128X:$dst),
5190           (ins VR128X:$src1, VR128X:$src2),
5191           "vmovhlps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
5192           [(set VR128X:$dst, (v4f32 (X86Movhlps VR128X:$src1, VR128X:$src2)))],
5193           IIC_SSE_MOV_LH>, EVEX_4V;
5194
5195 let Predicates = [HasAVX512] in {
5196   // MOVLHPS patterns
5197   def : Pat<(v4i32 (X86Movlhps VR128X:$src1, VR128X:$src2)),
5198             (VMOVLHPSZrr VR128X:$src1, VR128X:$src2)>;
5199   def : Pat<(v2i64 (X86Movlhps VR128X:$src1, VR128X:$src2)),
5200             (VMOVLHPSZrr (v2i64 VR128X:$src1), VR128X:$src2)>;
5201
5202   // MOVHLPS patterns
5203   def : Pat<(v4i32 (X86Movhlps VR128X:$src1, VR128X:$src2)),
5204             (VMOVHLPSZrr VR128X:$src1, VR128X:$src2)>;
5205 }
5206
5207 //===----------------------------------------------------------------------===//
5208 // VMOVHPS/PD VMOVLPS Instructions
5209 // All patterns was taken from SSS implementation.
5210 //===----------------------------------------------------------------------===//
5211 multiclass avx512_mov_hilo_packed<bits<8> opc, string OpcodeStr, SDNode OpNode,
5212                                   X86VectorVTInfo _> {
5213   let ExeDomain = _.ExeDomain in
5214   def rm : AVX512<opc, MRMSrcMem, (outs _.RC:$dst),
5215                   (ins _.RC:$src1, f64mem:$src2),
5216                   !strconcat(OpcodeStr,
5217                              "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5218                   [(set _.RC:$dst,
5219                      (OpNode _.RC:$src1,
5220                        (_.VT (bitconvert
5221                          (v2f64 (scalar_to_vector (loadf64 addr:$src2)))))))],
5222                   IIC_SSE_MOV_LH>, EVEX_4V;
5223 }
5224
5225 defm VMOVHPSZ128 : avx512_mov_hilo_packed<0x16, "vmovhps", X86Movlhps,
5226                                   v4f32x_info>, EVEX_CD8<32, CD8VT2>, PS;
5227 defm VMOVHPDZ128 : avx512_mov_hilo_packed<0x16, "vmovhpd", X86Movlhpd,
5228                                   v2f64x_info>, EVEX_CD8<64, CD8VT1>, PD, VEX_W;
5229 defm VMOVLPSZ128 : avx512_mov_hilo_packed<0x12, "vmovlps", X86Movlps,
5230                                   v4f32x_info>, EVEX_CD8<32, CD8VT2>, PS;
5231 defm VMOVLPDZ128 : avx512_mov_hilo_packed<0x12, "vmovlpd", X86Movlpd,
5232                                   v2f64x_info>, EVEX_CD8<64, CD8VT1>, PD, VEX_W;
5233
5234 let Predicates = [HasAVX512] in {
5235   // VMOVHPS patterns
5236   def : Pat<(X86Movlhps VR128X:$src1,
5237                (bc_v4f32 (v2i64 (scalar_to_vector (loadi64 addr:$src2))))),
5238           (VMOVHPSZ128rm VR128X:$src1, addr:$src2)>;
5239   def : Pat<(X86Movlhps VR128X:$src1,
5240                (bc_v4i32 (v2i64 (X86vzload addr:$src2)))),
5241           (VMOVHPSZ128rm VR128X:$src1, addr:$src2)>;
5242   // VMOVHPD patterns
5243   def : Pat<(v2f64 (X86Unpckl VR128X:$src1,
5244                     (scalar_to_vector (loadf64 addr:$src2)))),
5245            (VMOVHPDZ128rm VR128X:$src1, addr:$src2)>;
5246   def : Pat<(v2f64 (X86Unpckl VR128X:$src1,
5247                     (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src2)))))),
5248            (VMOVHPDZ128rm VR128X:$src1, addr:$src2)>;
5249   // VMOVLPS patterns
5250   def : Pat<(v4f32 (X86Movlps VR128X:$src1, (load addr:$src2))),
5251           (VMOVLPSZ128rm VR128X:$src1, addr:$src2)>;
5252   def : Pat<(v4i32 (X86Movlps VR128X:$src1, (load addr:$src2))),
5253           (VMOVLPSZ128rm VR128X:$src1, addr:$src2)>;
5254   // VMOVLPD patterns
5255   def : Pat<(v2f64 (X86Movlpd VR128X:$src1, (load addr:$src2))),
5256           (VMOVLPDZ128rm VR128X:$src1, addr:$src2)>;
5257   def : Pat<(v2i64 (X86Movlpd VR128X:$src1, (load addr:$src2))),
5258           (VMOVLPDZ128rm VR128X:$src1, addr:$src2)>;
5259   def : Pat<(v2f64 (X86Movsd VR128X:$src1,
5260                            (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
5261           (VMOVLPDZ128rm VR128X:$src1, addr:$src2)>;
5262 }
5263
5264 def VMOVHPSZ128mr : AVX512PSI<0x17, MRMDestMem, (outs),
5265                        (ins f64mem:$dst, VR128X:$src),
5266                        "vmovhps\t{$src, $dst|$dst, $src}",
5267                        [(store (f64 (extractelt
5268                                      (X86Unpckh (bc_v2f64 (v4f32 VR128X:$src)),
5269                                                 (bc_v2f64 (v4f32 VR128X:$src))),
5270                                      (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>,
5271                        EVEX, EVEX_CD8<32, CD8VT2>;
5272 def VMOVHPDZ128mr : AVX512PDI<0x17, MRMDestMem, (outs),
5273                        (ins f64mem:$dst, VR128X:$src),
5274                        "vmovhpd\t{$src, $dst|$dst, $src}",
5275                        [(store (f64 (extractelt
5276                                      (v2f64 (X86Unpckh VR128X:$src, VR128X:$src)),
5277                                      (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>,
5278                        EVEX, EVEX_CD8<64, CD8VT1>, VEX_W;
5279 def VMOVLPSZ128mr : AVX512PSI<0x13, MRMDestMem, (outs),
5280                        (ins f64mem:$dst, VR128X:$src),
5281                        "vmovlps\t{$src, $dst|$dst, $src}",
5282                        [(store (f64 (extractelt (bc_v2f64 (v4f32 VR128X:$src)),
5283                                      (iPTR 0))), addr:$dst)],
5284                                      IIC_SSE_MOV_LH>,
5285                        EVEX, EVEX_CD8<32, CD8VT2>;
5286 def VMOVLPDZ128mr : AVX512PDI<0x13, MRMDestMem, (outs),
5287                        (ins f64mem:$dst, VR128X:$src),
5288                        "vmovlpd\t{$src, $dst|$dst, $src}",
5289                        [(store (f64 (extractelt (v2f64 VR128X:$src),
5290                                      (iPTR 0))), addr:$dst)],
5291                                      IIC_SSE_MOV_LH>,
5292                        EVEX, EVEX_CD8<64, CD8VT1>, VEX_W;
5293
5294 let Predicates = [HasAVX512] in {
5295   // VMOVHPD patterns
5296   def : Pat<(store (f64 (extractelt
5297                            (v2f64 (X86VPermilpi VR128X:$src, (i8 1))),
5298                            (iPTR 0))), addr:$dst),
5299            (VMOVHPDZ128mr addr:$dst, VR128X:$src)>;
5300   // VMOVLPS patterns
5301   def : Pat<(store (v4f32 (X86Movlps (load addr:$src1), VR128X:$src2)),
5302                    addr:$src1),
5303             (VMOVLPSZ128mr addr:$src1, VR128X:$src2)>;
5304   def : Pat<(store (v4i32 (X86Movlps
5305                    (bc_v4i32 (loadv2i64 addr:$src1)), VR128X:$src2)), addr:$src1),
5306             (VMOVLPSZ128mr addr:$src1, VR128X:$src2)>;
5307   // VMOVLPD patterns
5308   def : Pat<(store (v2f64 (X86Movlpd (load addr:$src1), VR128X:$src2)),
5309                    addr:$src1),
5310             (VMOVLPDZ128mr addr:$src1, VR128X:$src2)>;
5311   def : Pat<(store (v2i64 (X86Movlpd (load addr:$src1), VR128X:$src2)),
5312                    addr:$src1),
5313             (VMOVLPDZ128mr addr:$src1, VR128X:$src2)>;
5314 }
5315 //===----------------------------------------------------------------------===//
5316 // FMA - Fused Multiply Operations
5317 //
5318
5319 multiclass avx512_fma3p_213_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5320                                X86VectorVTInfo _, string Suff> {
5321   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
5322   defm r: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5323           (ins _.RC:$src2, _.RC:$src3),
5324           OpcodeStr, "$src3, $src2", "$src2, $src3",
5325           (_.VT (OpNode _.RC:$src2, _.RC:$src1, _.RC:$src3)), 1, 1>,
5326          AVX512FMA3Base;
5327
5328   defm m: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5329           (ins _.RC:$src2, _.MemOp:$src3),
5330           OpcodeStr, "$src3, $src2", "$src2, $src3",
5331           (_.VT (OpNode _.RC:$src2, _.RC:$src1, (_.LdFrag addr:$src3))), 1, 0>,
5332           AVX512FMA3Base;
5333
5334   defm mb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5335             (ins _.RC:$src2, _.ScalarMemOp:$src3),
5336             OpcodeStr,   !strconcat("${src3}", _.BroadcastStr,", $src2"),
5337             !strconcat("$src2, ${src3}", _.BroadcastStr ),
5338             (OpNode _.RC:$src2,
5339              _.RC:$src1,(_.VT (X86VBroadcast (_.ScalarLdFrag addr:$src3)))), 1, 0>,
5340             AVX512FMA3Base, EVEX_B;
5341   }
5342
5343   // Additional pattern for folding broadcast nodes in other orders.
5344   def : Pat<(_.VT (vselect _.KRCWM:$mask,
5345                    (OpNode _.RC:$src1, _.RC:$src2,
5346                     (X86VBroadcast (_.ScalarLdFrag addr:$src3))),
5347                    _.RC:$src1)),
5348             (!cast<Instruction>(NAME#Suff#_.ZSuffix#mbk) _.RC:$src1,
5349              _.KRCWM:$mask, _.RC:$src2, addr:$src3)>;
5350 }
5351
5352 multiclass avx512_fma3_213_round<bits<8> opc, string OpcodeStr, SDNode OpNode,
5353                                  X86VectorVTInfo _, string Suff> {
5354   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in
5355   defm rb: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5356           (ins _.RC:$src2, _.RC:$src3, AVX512RC:$rc),
5357           OpcodeStr, "$rc, $src3, $src2", "$src2, $src3, $rc",
5358           (_.VT ( OpNode _.RC:$src2, _.RC:$src1, _.RC:$src3, (i32 imm:$rc))), 1, 1>,
5359           AVX512FMA3Base, EVEX_B, EVEX_RC;
5360 }
5361
5362 multiclass avx512_fma3p_213_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
5363                                    SDNode OpNodeRnd, AVX512VLVectorVTInfo _,
5364                                    string Suff> {
5365   let Predicates = [HasAVX512] in {
5366     defm Z      : avx512_fma3p_213_rm<opc, OpcodeStr, OpNode, _.info512, Suff>,
5367                   avx512_fma3_213_round<opc, OpcodeStr, OpNodeRnd, _.info512,
5368                       Suff>, EVEX_V512, EVEX_CD8<_.info512.EltSize, CD8VF>;
5369   }
5370   let Predicates = [HasVLX, HasAVX512] in {
5371     defm Z256 : avx512_fma3p_213_rm<opc, OpcodeStr, OpNode, _.info256, Suff>,
5372                       EVEX_V256, EVEX_CD8<_.info256.EltSize, CD8VF>;
5373     defm Z128 : avx512_fma3p_213_rm<opc, OpcodeStr, OpNode, _.info128, Suff>,
5374                       EVEX_V128, EVEX_CD8<_.info128.EltSize, CD8VF>;
5375   }
5376 }
5377
5378 multiclass avx512_fma3p_213_f<bits<8> opc, string OpcodeStr, SDNode OpNode,
5379                               SDNode OpNodeRnd > {
5380     defm PS : avx512_fma3p_213_common<opc, OpcodeStr#"ps", OpNode, OpNodeRnd,
5381                                       avx512vl_f32_info, "PS">;
5382     defm PD : avx512_fma3p_213_common<opc, OpcodeStr#"pd", OpNode, OpNodeRnd,
5383                                       avx512vl_f64_info, "PD">, VEX_W;
5384 }
5385
5386 defm VFMADD213    : avx512_fma3p_213_f<0xA8, "vfmadd213", X86Fmadd, X86FmaddRnd>;
5387 defm VFMSUB213    : avx512_fma3p_213_f<0xAA, "vfmsub213", X86Fmsub, X86FmsubRnd>;
5388 defm VFMADDSUB213 : avx512_fma3p_213_f<0xA6, "vfmaddsub213", X86Fmaddsub, X86FmaddsubRnd>;
5389 defm VFMSUBADD213 : avx512_fma3p_213_f<0xA7, "vfmsubadd213", X86Fmsubadd, X86FmsubaddRnd>;
5390 defm VFNMADD213   : avx512_fma3p_213_f<0xAC, "vfnmadd213", X86Fnmadd, X86FnmaddRnd>;
5391 defm VFNMSUB213   : avx512_fma3p_213_f<0xAE, "vfnmsub213", X86Fnmsub, X86FnmsubRnd>;
5392
5393
5394 multiclass avx512_fma3p_231_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5395                                X86VectorVTInfo _, string Suff> {
5396   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
5397   defm r: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5398           (ins _.RC:$src2, _.RC:$src3),
5399           OpcodeStr, "$src3, $src2", "$src2, $src3",
5400           (_.VT (OpNode _.RC:$src2, _.RC:$src3, _.RC:$src1)), 1, 1>,
5401          AVX512FMA3Base;
5402
5403   defm m: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5404           (ins _.RC:$src2, _.MemOp:$src3),
5405           OpcodeStr, "$src3, $src2", "$src2, $src3",
5406           (_.VT (OpNode _.RC:$src2, (_.LdFrag addr:$src3), _.RC:$src1)), 1, 0>,
5407          AVX512FMA3Base;
5408
5409   defm mb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5410          (ins _.RC:$src2, _.ScalarMemOp:$src3),
5411          OpcodeStr, "${src3}"##_.BroadcastStr##", $src2",
5412          "$src2, ${src3}"##_.BroadcastStr,
5413          (_.VT (OpNode _.RC:$src2,
5414                       (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src3))),
5415                       _.RC:$src1)), 1, 0>, AVX512FMA3Base, EVEX_B;
5416   }
5417
5418   // Additional patterns for folding broadcast nodes in other orders.
5419   def : Pat<(_.VT (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
5420                    _.RC:$src2, _.RC:$src1)),
5421             (!cast<Instruction>(NAME#Suff#_.ZSuffix#mb) _.RC:$src1,
5422              _.RC:$src2, addr:$src3)>;
5423   def : Pat<(_.VT (vselect _.KRCWM:$mask,
5424                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
5425                     _.RC:$src2, _.RC:$src1),
5426                    _.RC:$src1)),
5427             (!cast<Instruction>(NAME#Suff#_.ZSuffix#mbk) _.RC:$src1,
5428              _.KRCWM:$mask, _.RC:$src2, addr:$src3)>;
5429   def : Pat<(_.VT (vselect _.KRCWM:$mask,
5430                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
5431                     _.RC:$src2, _.RC:$src1),
5432                    _.ImmAllZerosV)),
5433             (!cast<Instruction>(NAME#Suff#_.ZSuffix#mbkz) _.RC:$src1,
5434              _.KRCWM:$mask, _.RC:$src2, addr:$src3)>;
5435 }
5436
5437 multiclass avx512_fma3_231_round<bits<8> opc, string OpcodeStr, SDNode OpNode,
5438                                  X86VectorVTInfo _, string Suff> {
5439   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in
5440   defm rb: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5441           (ins _.RC:$src2, _.RC:$src3, AVX512RC:$rc),
5442           OpcodeStr, "$rc, $src3, $src2", "$src2, $src3, $rc",
5443           (_.VT ( OpNode _.RC:$src2, _.RC:$src3, _.RC:$src1, (i32 imm:$rc))), 1, 1>,
5444           AVX512FMA3Base, EVEX_B, EVEX_RC;
5445 }
5446
5447 multiclass avx512_fma3p_231_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
5448                                    SDNode OpNodeRnd, AVX512VLVectorVTInfo _,
5449                                    string Suff> {
5450   let Predicates = [HasAVX512] in {
5451     defm Z      : avx512_fma3p_231_rm<opc, OpcodeStr, OpNode, _.info512, Suff>,
5452                   avx512_fma3_231_round<opc, OpcodeStr, OpNodeRnd, _.info512,
5453                       Suff>, EVEX_V512, EVEX_CD8<_.info512.EltSize, CD8VF>;
5454   }
5455   let Predicates = [HasVLX, HasAVX512] in {
5456     defm Z256 : avx512_fma3p_231_rm<opc, OpcodeStr, OpNode, _.info256, Suff>,
5457                       EVEX_V256, EVEX_CD8<_.info256.EltSize, CD8VF>;
5458     defm Z128 : avx512_fma3p_231_rm<opc, OpcodeStr, OpNode, _.info128, Suff>,
5459                       EVEX_V128, EVEX_CD8<_.info128.EltSize, CD8VF>;
5460   }
5461 }
5462
5463 multiclass avx512_fma3p_231_f<bits<8> opc, string OpcodeStr, SDNode OpNode,
5464                               SDNode OpNodeRnd > {
5465     defm PS : avx512_fma3p_231_common<opc, OpcodeStr#"ps", OpNode, OpNodeRnd,
5466                                       avx512vl_f32_info, "PS">;
5467     defm PD : avx512_fma3p_231_common<opc, OpcodeStr#"pd", OpNode, OpNodeRnd,
5468                                       avx512vl_f64_info, "PD">, VEX_W;
5469 }
5470
5471 defm VFMADD231    : avx512_fma3p_231_f<0xB8, "vfmadd231", X86Fmadd, X86FmaddRnd>;
5472 defm VFMSUB231    : avx512_fma3p_231_f<0xBA, "vfmsub231", X86Fmsub, X86FmsubRnd>;
5473 defm VFMADDSUB231 : avx512_fma3p_231_f<0xB6, "vfmaddsub231", X86Fmaddsub, X86FmaddsubRnd>;
5474 defm VFMSUBADD231 : avx512_fma3p_231_f<0xB7, "vfmsubadd231", X86Fmsubadd, X86FmsubaddRnd>;
5475 defm VFNMADD231   : avx512_fma3p_231_f<0xBC, "vfnmadd231", X86Fnmadd, X86FnmaddRnd>;
5476 defm VFNMSUB231   : avx512_fma3p_231_f<0xBE, "vfnmsub231", X86Fnmsub, X86FnmsubRnd>;
5477
5478 multiclass avx512_fma3p_132_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5479                                X86VectorVTInfo _, string Suff> {
5480   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
5481   defm r: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5482           (ins _.RC:$src2, _.RC:$src3),
5483           OpcodeStr, "$src3, $src2", "$src2, $src3",
5484           (_.VT (OpNode _.RC:$src1, _.RC:$src3, _.RC:$src2)), 1, 1>,
5485          AVX512FMA3Base;
5486
5487   defm m: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5488           (ins _.RC:$src2, _.MemOp:$src3),
5489           OpcodeStr, "$src3, $src2", "$src2, $src3",
5490           (_.VT (OpNode _.RC:$src1, (_.LdFrag addr:$src3), _.RC:$src2)), 1, 0>,
5491          AVX512FMA3Base;
5492
5493   defm mb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5494          (ins _.RC:$src2, _.ScalarMemOp:$src3),
5495          OpcodeStr, "${src3}"##_.BroadcastStr##", $src2",
5496          "$src2, ${src3}"##_.BroadcastStr,
5497          (_.VT (OpNode _.RC:$src1,
5498                       (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src3))),
5499                       _.RC:$src2)), 1, 0>, AVX512FMA3Base, EVEX_B;
5500   }
5501
5502   // Additional patterns for folding broadcast nodes in other orders.
5503   def : Pat<(_.VT (vselect _.KRCWM:$mask,
5504                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
5505                     _.RC:$src1, _.RC:$src2),
5506                    _.RC:$src1)),
5507             (!cast<Instruction>(NAME#Suff#_.ZSuffix#mbk) _.RC:$src1,
5508              _.KRCWM:$mask, _.RC:$src2, addr:$src3)>;
5509 }
5510
5511 multiclass avx512_fma3_132_round<bits<8> opc, string OpcodeStr, SDNode OpNode,
5512                                  X86VectorVTInfo _, string Suff> {
5513   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in
5514   defm rb: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5515           (ins _.RC:$src2, _.RC:$src3, AVX512RC:$rc),
5516           OpcodeStr, "$rc, $src3, $src2", "$src2, $src3, $rc",
5517           (_.VT ( OpNode _.RC:$src1, _.RC:$src3, _.RC:$src2, (i32 imm:$rc))), 1, 1>,
5518           AVX512FMA3Base, EVEX_B, EVEX_RC;
5519 }
5520
5521 multiclass avx512_fma3p_132_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
5522                                    SDNode OpNodeRnd, AVX512VLVectorVTInfo _,
5523                                    string Suff> {
5524   let Predicates = [HasAVX512] in {
5525     defm Z      : avx512_fma3p_132_rm<opc, OpcodeStr, OpNode, _.info512, Suff>,
5526                   avx512_fma3_132_round<opc, OpcodeStr, OpNodeRnd, _.info512,
5527                       Suff>, EVEX_V512, EVEX_CD8<_.info512.EltSize, CD8VF>;
5528   }
5529   let Predicates = [HasVLX, HasAVX512] in {
5530     defm Z256 : avx512_fma3p_132_rm<opc, OpcodeStr, OpNode, _.info256, Suff>,
5531                       EVEX_V256, EVEX_CD8<_.info256.EltSize, CD8VF>;
5532     defm Z128 : avx512_fma3p_132_rm<opc, OpcodeStr, OpNode, _.info128, Suff>,
5533                       EVEX_V128, EVEX_CD8<_.info128.EltSize, CD8VF>;
5534   }
5535 }
5536
5537 multiclass avx512_fma3p_132_f<bits<8> opc, string OpcodeStr, SDNode OpNode,
5538                               SDNode OpNodeRnd > {
5539     defm PS : avx512_fma3p_132_common<opc, OpcodeStr#"ps", OpNode, OpNodeRnd,
5540                                       avx512vl_f32_info, "PS">;
5541     defm PD : avx512_fma3p_132_common<opc, OpcodeStr#"pd", OpNode, OpNodeRnd,
5542                                       avx512vl_f64_info, "PD">, VEX_W;
5543 }
5544
5545 defm VFMADD132    : avx512_fma3p_132_f<0x98, "vfmadd132", X86Fmadd, X86FmaddRnd>;
5546 defm VFMSUB132    : avx512_fma3p_132_f<0x9A, "vfmsub132", X86Fmsub, X86FmsubRnd>;
5547 defm VFMADDSUB132 : avx512_fma3p_132_f<0x96, "vfmaddsub132", X86Fmaddsub, X86FmaddsubRnd>;
5548 defm VFMSUBADD132 : avx512_fma3p_132_f<0x97, "vfmsubadd132", X86Fmsubadd, X86FmsubaddRnd>;
5549 defm VFNMADD132   : avx512_fma3p_132_f<0x9C, "vfnmadd132", X86Fnmadd, X86FnmaddRnd>;
5550 defm VFNMSUB132   : avx512_fma3p_132_f<0x9E, "vfnmsub132", X86Fnmsub, X86FnmsubRnd>;
5551
5552 // Scalar FMA
5553 let Constraints = "$src1 = $dst" in {
5554 multiclass avx512_fma3s_common<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
5555                                dag RHS_VEC_r, dag RHS_VEC_m, dag RHS_VEC_rb,
5556                                                         dag RHS_r, dag RHS_m > {
5557   defm r_Int: AVX512_maskable_3src_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
5558           (ins _.RC:$src2, _.RC:$src3), OpcodeStr,
5559           "$src3, $src2", "$src2, $src3", RHS_VEC_r, 1, 1>, AVX512FMA3Base;
5560
5561   defm m_Int: AVX512_maskable_3src_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
5562           (ins _.RC:$src2, _.IntScalarMemOp:$src3), OpcodeStr,
5563           "$src3, $src2", "$src2, $src3", RHS_VEC_m, 1, 1>, AVX512FMA3Base;
5564
5565   defm rb_Int: AVX512_maskable_3src_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
5566          (ins _.RC:$src2, _.RC:$src3, AVX512RC:$rc),
5567          OpcodeStr, "$rc, $src3, $src2", "$src2, $src3, $rc", RHS_VEC_rb, 1, 1>,
5568                                        AVX512FMA3Base, EVEX_B, EVEX_RC;
5569
5570   let isCodeGenOnly = 1, isCommutable = 1 in {
5571     def r     : AVX512FMA3<opc, MRMSrcReg, (outs _.FRC:$dst),
5572                      (ins _.FRC:$src1, _.FRC:$src2, _.FRC:$src3),
5573                      !strconcat(OpcodeStr,
5574                               "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5575                      [RHS_r]>;
5576     def m     : AVX512FMA3<opc, MRMSrcMem, (outs _.FRC:$dst),
5577                     (ins _.FRC:$src1, _.FRC:$src2, _.ScalarMemOp:$src3),
5578                     !strconcat(OpcodeStr,
5579                                "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5580                     [RHS_m]>;
5581   }// isCodeGenOnly = 1
5582 }
5583 }// Constraints = "$src1 = $dst"
5584
5585 multiclass avx512_fma3s_all<bits<8> opc213, bits<8> opc231, bits<8> opc132,
5586                             string OpcodeStr, SDNode OpNode, SDNode OpNodeRnds1,
5587                             SDNode OpNodeRnds3, X86VectorVTInfo _ , string SUFF> {
5588   let ExeDomain = _.ExeDomain in {
5589   defm NAME#213#SUFF#Z: avx512_fma3s_common<opc213, OpcodeStr#"213"#_.Suffix , _ ,
5590                 // Operands for intrinsic are in 123 order to preserve passthu
5591                 // semantics.
5592                 (_.VT (OpNodeRnds1 _.RC:$src1, _.RC:$src2, _.RC:$src3, (i32 FROUND_CURRENT))),
5593                 (_.VT (OpNodeRnds1 _.RC:$src1, _.RC:$src2,
5594                          _.ScalarIntMemCPat:$src3, (i32 FROUND_CURRENT))),
5595                 (_.VT (OpNodeRnds1 _.RC:$src1, _.RC:$src2, _.RC:$src3,
5596                          (i32 imm:$rc))),
5597                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src2, _.FRC:$src1,
5598                          _.FRC:$src3))),
5599                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src2, _.FRC:$src1,
5600                          (_.ScalarLdFrag addr:$src3))))>;
5601
5602   defm NAME#231#SUFF#Z: avx512_fma3s_common<opc231, OpcodeStr#"231"#_.Suffix , _ ,
5603                 (_.VT (OpNodeRnds3 _.RC:$src2, _.RC:$src3, _.RC:$src1, (i32 FROUND_CURRENT))),
5604                 (_.VT (OpNodeRnds3 _.RC:$src2, _.ScalarIntMemCPat:$src3,
5605                               _.RC:$src1, (i32 FROUND_CURRENT))),
5606                 (_.VT ( OpNodeRnds3 _.RC:$src2, _.RC:$src3, _.RC:$src1,
5607                                   (i32 imm:$rc))),
5608                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src2, _.FRC:$src3,
5609                                           _.FRC:$src1))),
5610                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src2,
5611                             (_.ScalarLdFrag addr:$src3), _.FRC:$src1)))>;
5612
5613   defm NAME#132#SUFF#Z: avx512_fma3s_common<opc132, OpcodeStr#"132"#_.Suffix , _ ,
5614                 (_.VT (OpNodeRnds1 _.RC:$src1, _.RC:$src3, _.RC:$src2, (i32 FROUND_CURRENT))),
5615                 (_.VT (OpNodeRnds1 _.RC:$src1, _.ScalarIntMemCPat:$src3,
5616                               _.RC:$src2, (i32 FROUND_CURRENT))),
5617                 (_.VT (OpNodeRnds1 _.RC:$src1, _.RC:$src3, _.RC:$src2,
5618                          (i32 imm:$rc))),
5619                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src1, _.FRC:$src3,
5620                          _.FRC:$src2))),
5621                 (set _.FRC:$dst, (_.EltVT (OpNode _.FRC:$src1,
5622                           (_.ScalarLdFrag addr:$src3), _.FRC:$src2)))>;
5623   }
5624 }
5625
5626 multiclass avx512_fma3s<bits<8> opc213, bits<8> opc231, bits<8> opc132,
5627                         string OpcodeStr, SDNode OpNode, SDNode OpNodeRnds1,
5628                         SDNode OpNodeRnds3> {
5629   let Predicates = [HasAVX512] in {
5630     defm NAME : avx512_fma3s_all<opc213, opc231, opc132, OpcodeStr, OpNode,
5631                                  OpNodeRnds1, OpNodeRnds3, f32x_info, "SS">,
5632                                  EVEX_CD8<32, CD8VT1>, VEX_LIG;
5633     defm NAME : avx512_fma3s_all<opc213, opc231, opc132, OpcodeStr, OpNode,
5634                                  OpNodeRnds1, OpNodeRnds3, f64x_info, "SD">,
5635                                  EVEX_CD8<64, CD8VT1>, VEX_LIG, VEX_W;
5636   }
5637 }
5638
5639 defm VFMADD  : avx512_fma3s<0xA9, 0xB9, 0x99, "vfmadd", X86Fmadd, X86FmaddRnds1,
5640                             X86FmaddRnds3>;
5641 defm VFMSUB  : avx512_fma3s<0xAB, 0xBB, 0x9B, "vfmsub", X86Fmsub, X86FmsubRnds1,
5642                             X86FmsubRnds3>;
5643 defm VFNMADD : avx512_fma3s<0xAD, 0xBD, 0x9D, "vfnmadd", X86Fnmadd,
5644                             X86FnmaddRnds1, X86FnmaddRnds3>;
5645 defm VFNMSUB : avx512_fma3s<0xAF, 0xBF, 0x9F, "vfnmsub", X86Fnmsub,
5646                             X86FnmsubRnds1, X86FnmsubRnds3>;
5647
5648 //===----------------------------------------------------------------------===//
5649 // AVX-512  Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit IFMA
5650 //===----------------------------------------------------------------------===//
5651 let Constraints = "$src1 = $dst" in {
5652 multiclass avx512_pmadd52_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5653                                                             X86VectorVTInfo _> {
5654   let ExeDomain = _.ExeDomain in {
5655   defm r: AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
5656           (ins _.RC:$src2, _.RC:$src3),
5657           OpcodeStr, "$src3, $src2", "$src2, $src3",
5658           (_.VT (OpNode _.RC:$src1, _.RC:$src2, _.RC:$src3))>,
5659          AVX512FMA3Base;
5660
5661   defm m: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5662           (ins _.RC:$src2, _.MemOp:$src3),
5663           OpcodeStr, "$src3, $src2", "$src2, $src3",
5664           (_.VT (OpNode _.RC:$src1, _.RC:$src2, (_.LdFrag addr:$src3)))>,
5665           AVX512FMA3Base;
5666
5667   defm mb: AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
5668             (ins _.RC:$src2, _.ScalarMemOp:$src3),
5669             OpcodeStr,   !strconcat("${src3}", _.BroadcastStr,", $src2"),
5670             !strconcat("$src2, ${src3}", _.BroadcastStr ),
5671             (OpNode _.RC:$src1,
5672              _.RC:$src2,(_.VT (X86VBroadcast (_.ScalarLdFrag addr:$src3))))>,
5673             AVX512FMA3Base, EVEX_B;
5674   }
5675 }
5676 } // Constraints = "$src1 = $dst"
5677
5678 multiclass avx512_pmadd52_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
5679                                      AVX512VLVectorVTInfo _> {
5680   let Predicates = [HasIFMA] in {
5681     defm Z      : avx512_pmadd52_rm<opc, OpcodeStr, OpNode, _.info512>,
5682                       EVEX_V512, EVEX_CD8<_.info512.EltSize, CD8VF>;
5683   }
5684   let Predicates = [HasVLX, HasIFMA] in {
5685     defm Z256 : avx512_pmadd52_rm<opc, OpcodeStr, OpNode, _.info256>,
5686                       EVEX_V256, EVEX_CD8<_.info256.EltSize, CD8VF>;
5687     defm Z128 : avx512_pmadd52_rm<opc, OpcodeStr, OpNode, _.info128>,
5688                       EVEX_V128, EVEX_CD8<_.info128.EltSize, CD8VF>;
5689   }
5690 }
5691
5692 defm VPMADD52LUQ : avx512_pmadd52_common<0xb4, "vpmadd52luq", x86vpmadd52l,
5693                                   avx512vl_i64_info>, VEX_W;
5694 defm VPMADD52HUQ : avx512_pmadd52_common<0xb5, "vpmadd52huq", x86vpmadd52h,
5695                                   avx512vl_i64_info>, VEX_W;
5696
5697 //===----------------------------------------------------------------------===//
5698 // AVX-512  Scalar convert from sign integer to float/double
5699 //===----------------------------------------------------------------------===//
5700
5701 multiclass avx512_vcvtsi<bits<8> opc, SDNode OpNode, RegisterClass SrcRC,
5702                     X86VectorVTInfo DstVT, X86MemOperand x86memop,
5703                     PatFrag ld_frag, string asm> {
5704   let hasSideEffects = 0 in {
5705     def rr : SI<opc, MRMSrcReg, (outs DstVT.FRC:$dst),
5706               (ins DstVT.FRC:$src1, SrcRC:$src),
5707               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>,
5708               EVEX_4V;
5709     let mayLoad = 1 in
5710       def rm : SI<opc, MRMSrcMem, (outs DstVT.FRC:$dst),
5711               (ins DstVT.FRC:$src1, x86memop:$src),
5712               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>,
5713               EVEX_4V;
5714   } // hasSideEffects = 0
5715   let isCodeGenOnly = 1 in {
5716     def rr_Int : SI<opc, MRMSrcReg, (outs DstVT.RC:$dst),
5717                   (ins DstVT.RC:$src1, SrcRC:$src2),
5718                   !strconcat(asm,"\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5719                   [(set DstVT.RC:$dst,
5720                         (OpNode (DstVT.VT DstVT.RC:$src1),
5721                                  SrcRC:$src2,
5722                                  (i32 FROUND_CURRENT)))]>, EVEX_4V;
5723
5724     def rm_Int : SI<opc, MRMSrcMem, (outs DstVT.RC:$dst),
5725                   (ins DstVT.RC:$src1, x86memop:$src2),
5726                   !strconcat(asm,"\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5727                   [(set DstVT.RC:$dst,
5728                         (OpNode (DstVT.VT DstVT.RC:$src1),
5729                                  (ld_frag addr:$src2),
5730                                  (i32 FROUND_CURRENT)))]>, EVEX_4V;
5731   }//isCodeGenOnly = 1
5732 }
5733
5734 multiclass avx512_vcvtsi_round<bits<8> opc, SDNode OpNode, RegisterClass SrcRC,
5735                     X86VectorVTInfo DstVT, string asm> {
5736   def rrb_Int : SI<opc, MRMSrcReg, (outs DstVT.RC:$dst),
5737               (ins DstVT.RC:$src1, SrcRC:$src2, AVX512RC:$rc),
5738               !strconcat(asm,
5739                   "\t{$src2, $rc, $src1, $dst|$dst, $src1, $rc, $src2}"),
5740               [(set DstVT.RC:$dst,
5741                     (OpNode (DstVT.VT DstVT.RC:$src1),
5742                              SrcRC:$src2,
5743                              (i32 imm:$rc)))]>, EVEX_4V, EVEX_B, EVEX_RC;
5744 }
5745
5746 multiclass avx512_vcvtsi_common<bits<8> opc, SDNode OpNode, RegisterClass SrcRC,
5747                     X86VectorVTInfo DstVT, X86MemOperand x86memop,
5748                     PatFrag ld_frag, string asm> {
5749   defm NAME : avx512_vcvtsi_round<opc, OpNode, SrcRC, DstVT, asm>,
5750               avx512_vcvtsi<opc, OpNode, SrcRC, DstVT, x86memop, ld_frag, asm>,
5751                         VEX_LIG;
5752 }
5753
5754 let Predicates = [HasAVX512] in {
5755 defm VCVTSI2SSZ  : avx512_vcvtsi_common<0x2A, X86SintToFpRnd, GR32,
5756                                  v4f32x_info, i32mem, loadi32, "cvtsi2ss{l}">,
5757                                  XS, EVEX_CD8<32, CD8VT1>;
5758 defm VCVTSI642SSZ: avx512_vcvtsi_common<0x2A, X86SintToFpRnd, GR64,
5759                                  v4f32x_info, i64mem, loadi64, "cvtsi2ss{q}">,
5760                                  XS, VEX_W, EVEX_CD8<64, CD8VT1>;
5761 defm VCVTSI2SDZ  : avx512_vcvtsi_common<0x2A, X86SintToFpRnd, GR32,
5762                                  v2f64x_info, i32mem, loadi32, "cvtsi2sd{l}">,
5763                                  XD, EVEX_CD8<32, CD8VT1>;
5764 defm VCVTSI642SDZ: avx512_vcvtsi_common<0x2A, X86SintToFpRnd, GR64,
5765                                  v2f64x_info, i64mem, loadi64, "cvtsi2sd{q}">,
5766                                  XD, VEX_W, EVEX_CD8<64, CD8VT1>;
5767
5768 def : InstAlias<"vcvtsi2ss\t{$src, $src1, $dst|$dst, $src1, $src}",
5769               (VCVTSI2SSZrm FR64X:$dst, FR64X:$src1, i32mem:$src), 0>;
5770 def : InstAlias<"vcvtsi2sd\t{$src, $src1, $dst|$dst, $src1, $src}",
5771               (VCVTSI2SDZrm FR64X:$dst, FR64X:$src1, i32mem:$src), 0>;
5772
5773 def : Pat<(f32 (sint_to_fp (loadi32 addr:$src))),
5774           (VCVTSI2SSZrm (f32 (IMPLICIT_DEF)), addr:$src)>;
5775 def : Pat<(f32 (sint_to_fp (loadi64 addr:$src))),
5776           (VCVTSI642SSZrm (f32 (IMPLICIT_DEF)), addr:$src)>;
5777 def : Pat<(f64 (sint_to_fp (loadi32 addr:$src))),
5778           (VCVTSI2SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>;
5779 def : Pat<(f64 (sint_to_fp (loadi64 addr:$src))),
5780           (VCVTSI642SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>;
5781
5782 def : Pat<(f32 (sint_to_fp GR32:$src)),
5783           (VCVTSI2SSZrr (f32 (IMPLICIT_DEF)), GR32:$src)>;
5784 def : Pat<(f32 (sint_to_fp GR64:$src)),
5785           (VCVTSI642SSZrr (f32 (IMPLICIT_DEF)), GR64:$src)>;
5786 def : Pat<(f64 (sint_to_fp GR32:$src)),
5787           (VCVTSI2SDZrr (f64 (IMPLICIT_DEF)), GR32:$src)>;
5788 def : Pat<(f64 (sint_to_fp GR64:$src)),
5789           (VCVTSI642SDZrr (f64 (IMPLICIT_DEF)), GR64:$src)>;
5790
5791 defm VCVTUSI2SSZ   : avx512_vcvtsi_common<0x7B, X86UintToFpRnd, GR32,
5792                                   v4f32x_info, i32mem, loadi32,
5793                                   "cvtusi2ss{l}">, XS, EVEX_CD8<32, CD8VT1>;
5794 defm VCVTUSI642SSZ : avx512_vcvtsi_common<0x7B, X86UintToFpRnd, GR64,
5795                                   v4f32x_info, i64mem, loadi64, "cvtusi2ss{q}">,
5796                                   XS, VEX_W, EVEX_CD8<64, CD8VT1>;
5797 defm VCVTUSI2SDZ   : avx512_vcvtsi<0x7B, X86UintToFpRnd, GR32, v2f64x_info,
5798                                   i32mem, loadi32, "cvtusi2sd{l}">,
5799                                   XD, VEX_LIG, EVEX_CD8<32, CD8VT1>;
5800 defm VCVTUSI642SDZ : avx512_vcvtsi_common<0x7B, X86UintToFpRnd, GR64,
5801                                   v2f64x_info, i64mem, loadi64, "cvtusi2sd{q}">,
5802                                   XD, VEX_W, EVEX_CD8<64, CD8VT1>;
5803
5804 def : InstAlias<"vcvtusi2ss\t{$src, $src1, $dst|$dst, $src1, $src}",
5805               (VCVTUSI2SSZrm FR64X:$dst, FR64X:$src1, i32mem:$src), 0>;
5806 def : InstAlias<"vcvtusi2sd\t{$src, $src1, $dst|$dst, $src1, $src}",
5807               (VCVTUSI2SDZrm FR64X:$dst, FR64X:$src1, i32mem:$src), 0>;
5808
5809 def : Pat<(f32 (uint_to_fp (loadi32 addr:$src))),
5810           (VCVTUSI2SSZrm (f32 (IMPLICIT_DEF)), addr:$src)>;
5811 def : Pat<(f32 (uint_to_fp (loadi64 addr:$src))),
5812           (VCVTUSI642SSZrm (f32 (IMPLICIT_DEF)), addr:$src)>;
5813 def : Pat<(f64 (uint_to_fp (loadi32 addr:$src))),
5814           (VCVTUSI2SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>;
5815 def : Pat<(f64 (uint_to_fp (loadi64 addr:$src))),
5816           (VCVTUSI642SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>;
5817
5818 def : Pat<(f32 (uint_to_fp GR32:$src)),
5819           (VCVTUSI2SSZrr (f32 (IMPLICIT_DEF)), GR32:$src)>;
5820 def : Pat<(f32 (uint_to_fp GR64:$src)),
5821           (VCVTUSI642SSZrr (f32 (IMPLICIT_DEF)), GR64:$src)>;
5822 def : Pat<(f64 (uint_to_fp GR32:$src)),
5823           (VCVTUSI2SDZrr (f64 (IMPLICIT_DEF)), GR32:$src)>;
5824 def : Pat<(f64 (uint_to_fp GR64:$src)),
5825           (VCVTUSI642SDZrr (f64 (IMPLICIT_DEF)), GR64:$src)>;
5826 }
5827
5828 //===----------------------------------------------------------------------===//
5829 // AVX-512  Scalar convert from float/double to integer
5830 //===----------------------------------------------------------------------===//
5831 multiclass avx512_cvt_s_int_round<bits<8> opc, X86VectorVTInfo SrcVT ,
5832                                   X86VectorVTInfo DstVT, SDNode OpNode, string asm> {
5833   let Predicates = [HasAVX512] in {
5834     def rr : SI<opc, MRMSrcReg, (outs DstVT.RC:$dst), (ins SrcVT.RC:$src),
5835                 !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5836                 [(set DstVT.RC:$dst, (OpNode (SrcVT.VT SrcVT.RC:$src),(i32 FROUND_CURRENT)))]>,
5837                 EVEX, VEX_LIG;
5838     def rb : SI<opc, MRMSrcReg, (outs DstVT.RC:$dst), (ins SrcVT.RC:$src, AVX512RC:$rc),
5839                 !strconcat(asm,"\t{$rc, $src, $dst|$dst, $src, $rc}"),
5840                 [(set DstVT.RC:$dst, (OpNode (SrcVT.VT SrcVT.RC:$src),(i32 imm:$rc)))]>,
5841                 EVEX, VEX_LIG, EVEX_B, EVEX_RC;
5842     def rm : SI<opc, MRMSrcMem, (outs DstVT.RC:$dst), (ins SrcVT.IntScalarMemOp:$src),
5843                 !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5844                 [(set DstVT.RC:$dst, (OpNode
5845                       (SrcVT.VT SrcVT.ScalarIntMemCPat:$src),
5846                       (i32 FROUND_CURRENT)))]>,
5847                 EVEX, VEX_LIG;
5848   } // Predicates = [HasAVX512]
5849 }
5850
5851 // Convert float/double to signed/unsigned int 32/64
5852 defm VCVTSS2SIZ: avx512_cvt_s_int_round<0x2D, f32x_info, i32x_info,
5853                                    X86cvts2si, "cvtss2si">,
5854                                    XS, EVEX_CD8<32, CD8VT1>;
5855 defm VCVTSS2SI64Z: avx512_cvt_s_int_round<0x2D, f32x_info, i64x_info,
5856                                    X86cvts2si, "cvtss2si">,
5857                                    XS, VEX_W, EVEX_CD8<32, CD8VT1>;
5858 defm VCVTSS2USIZ: avx512_cvt_s_int_round<0x79, f32x_info, i32x_info,
5859                                    X86cvts2usi, "cvtss2usi">,
5860                                    XS, EVEX_CD8<32, CD8VT1>;
5861 defm VCVTSS2USI64Z: avx512_cvt_s_int_round<0x79, f32x_info, i64x_info,
5862                                    X86cvts2usi, "cvtss2usi">, XS, VEX_W,
5863                                    EVEX_CD8<32, CD8VT1>;
5864 defm VCVTSD2SIZ: avx512_cvt_s_int_round<0x2D, f64x_info, i32x_info,
5865                                    X86cvts2si, "cvtsd2si">,
5866                                    XD, EVEX_CD8<64, CD8VT1>;
5867 defm VCVTSD2SI64Z: avx512_cvt_s_int_round<0x2D, f64x_info, i64x_info,
5868                                    X86cvts2si, "cvtsd2si">,
5869                                    XD, VEX_W, EVEX_CD8<64, CD8VT1>;
5870 defm VCVTSD2USIZ:   avx512_cvt_s_int_round<0x79, f64x_info, i32x_info,
5871                                    X86cvts2usi, "cvtsd2usi">,
5872                                    XD, EVEX_CD8<64, CD8VT1>;
5873 defm VCVTSD2USI64Z: avx512_cvt_s_int_round<0x79, f64x_info, i64x_info,
5874                                    X86cvts2usi, "cvtsd2usi">, XD, VEX_W,
5875                                    EVEX_CD8<64, CD8VT1>;
5876
5877 // The SSE version of these instructions are disabled for AVX512.
5878 // Therefore, the SSE intrinsics are mapped to the AVX512 instructions.
5879 let Predicates = [HasAVX512] in {
5880   def : Pat<(i32 (int_x86_sse_cvtss2si (v4f32 VR128X:$src))),
5881             (VCVTSS2SIZrr VR128X:$src)>;
5882   def : Pat<(i32 (int_x86_sse_cvtss2si sse_load_f32:$src)),
5883             (VCVTSS2SIZrm sse_load_f32:$src)>;
5884   def : Pat<(i64 (int_x86_sse_cvtss2si64 (v4f32 VR128X:$src))),
5885             (VCVTSS2SI64Zrr VR128X:$src)>;
5886   def : Pat<(i64 (int_x86_sse_cvtss2si64 sse_load_f32:$src)),
5887             (VCVTSS2SI64Zrm sse_load_f32:$src)>;
5888   def : Pat<(i32 (int_x86_sse2_cvtsd2si (v2f64 VR128X:$src))),
5889             (VCVTSD2SIZrr VR128X:$src)>;
5890   def : Pat<(i32 (int_x86_sse2_cvtsd2si sse_load_f64:$src)),
5891             (VCVTSD2SIZrm sse_load_f64:$src)>;
5892   def : Pat<(i64 (int_x86_sse2_cvtsd2si64 (v2f64 VR128X:$src))),
5893             (VCVTSD2SI64Zrr VR128X:$src)>;
5894   def : Pat<(i64 (int_x86_sse2_cvtsd2si64 sse_load_f64:$src)),
5895             (VCVTSD2SI64Zrm sse_load_f64:$src)>;
5896 } // HasAVX512
5897
5898 let Predicates = [HasAVX512] in {
5899   def : Pat<(int_x86_sse_cvtsi2ss VR128X:$src1, GR32:$src2),
5900             (VCVTSI2SSZrr_Int VR128X:$src1, GR32:$src2)>;
5901   def : Pat<(int_x86_sse_cvtsi2ss VR128X:$src1, (loadi32 addr:$src2)),
5902             (VCVTSI2SSZrm_Int VR128X:$src1, addr:$src2)>;
5903   def : Pat<(int_x86_sse_cvtsi642ss VR128X:$src1, GR64:$src2),
5904             (VCVTSI642SSZrr_Int VR128X:$src1, GR64:$src2)>;
5905   def : Pat<(int_x86_sse_cvtsi642ss VR128X:$src1, (loadi64 addr:$src2)),
5906             (VCVTSI642SSZrm_Int VR128X:$src1, addr:$src2)>;
5907   def : Pat<(int_x86_sse2_cvtsi2sd VR128X:$src1, GR32:$src2),
5908             (VCVTSI2SDZrr_Int VR128X:$src1, GR32:$src2)>;
5909   def : Pat<(int_x86_sse2_cvtsi2sd VR128X:$src1, (loadi32 addr:$src2)),
5910             (VCVTSI2SDZrm_Int VR128X:$src1, addr:$src2)>;
5911   def : Pat<(int_x86_sse2_cvtsi642sd VR128X:$src1, GR64:$src2),
5912             (VCVTSI642SDZrr_Int VR128X:$src1, GR64:$src2)>;
5913   def : Pat<(int_x86_sse2_cvtsi642sd VR128X:$src1, (loadi64 addr:$src2)),
5914             (VCVTSI642SDZrm_Int VR128X:$src1, addr:$src2)>;
5915   def : Pat<(int_x86_avx512_cvtusi2sd VR128X:$src1, GR32:$src2),
5916             (VCVTUSI2SDZrr_Int VR128X:$src1, GR32:$src2)>;
5917   def : Pat<(int_x86_avx512_cvtusi2sd VR128X:$src1, (loadi32 addr:$src2)),
5918             (VCVTUSI2SDZrm_Int VR128X:$src1, addr:$src2)>;
5919 } // Predicates = [HasAVX512]
5920
5921 // Patterns used for matching vcvtsi2s{s,d} intrinsic sequences from clang
5922 // which produce unnecessary vmovs{s,d} instructions
5923 let Predicates = [HasAVX512] in {
5924 def : Pat<(v4f32 (X86Movss
5925                    (v4f32 VR128X:$dst),
5926                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR64:$src)))))),
5927           (VCVTSI642SSZrr_Int VR128X:$dst, GR64:$src)>;
5928
5929 def : Pat<(v4f32 (X86Movss
5930                    (v4f32 VR128X:$dst),
5931                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR32:$src)))))),
5932           (VCVTSI2SSZrr_Int VR128X:$dst, GR32:$src)>;
5933
5934 def : Pat<(v2f64 (X86Movsd
5935                    (v2f64 VR128X:$dst),
5936                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR64:$src)))))),
5937           (VCVTSI642SDZrr_Int VR128X:$dst, GR64:$src)>;
5938
5939 def : Pat<(v2f64 (X86Movsd
5940                    (v2f64 VR128X:$dst),
5941                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR32:$src)))))),
5942           (VCVTSI2SDZrr_Int VR128X:$dst, GR32:$src)>;
5943 } // Predicates = [HasAVX512]
5944
5945 // Convert float/double to signed/unsigned int 32/64 with truncation
5946 multiclass avx512_cvt_s_all<bits<8> opc, string asm, X86VectorVTInfo _SrcRC,
5947                             X86VectorVTInfo _DstRC, SDNode OpNode,
5948                             SDNode OpNodeRnd, string aliasStr>{
5949 let Predicates = [HasAVX512] in {
5950   def rr : AVX512<opc, MRMSrcReg, (outs _DstRC.RC:$dst), (ins _SrcRC.FRC:$src),
5951               !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5952               [(set _DstRC.RC:$dst, (OpNode _SrcRC.FRC:$src))]>, EVEX;
5953   let hasSideEffects = 0 in
5954   def rb : AVX512<opc, MRMSrcReg, (outs _DstRC.RC:$dst), (ins _SrcRC.FRC:$src),
5955                 !strconcat(asm,"\t{{sae}, $src, $dst|$dst, $src, {sae}}"),
5956                 []>, EVEX, EVEX_B;
5957   def rm : AVX512<opc, MRMSrcMem, (outs _DstRC.RC:$dst), (ins _SrcRC.ScalarMemOp:$src),
5958               !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5959               [(set _DstRC.RC:$dst, (OpNode (_SrcRC.ScalarLdFrag addr:$src)))]>,
5960               EVEX;
5961
5962   def : InstAlias<asm # aliasStr # "\t{$src, $dst|$dst, $src}",
5963           (!cast<Instruction>(NAME # "rr") _DstRC.RC:$dst, _SrcRC.FRC:$src), 0>;
5964   def : InstAlias<asm # aliasStr # "\t\t{{sae}, $src, $dst|$dst, $src, {sae}}",
5965           (!cast<Instruction>(NAME # "rb") _DstRC.RC:$dst, _SrcRC.FRC:$src), 0>;
5966   def : InstAlias<asm # aliasStr # "\t{$src, $dst|$dst, $src}",
5967           (!cast<Instruction>(NAME # "rm") _DstRC.RC:$dst,
5968                                           _SrcRC.ScalarMemOp:$src), 0>;
5969
5970   let isCodeGenOnly = 1 in {
5971     def rr_Int : AVX512<opc, MRMSrcReg, (outs _DstRC.RC:$dst), (ins _SrcRC.RC:$src),
5972               !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5973              [(set _DstRC.RC:$dst, (OpNodeRnd (_SrcRC.VT _SrcRC.RC:$src),
5974                                    (i32 FROUND_CURRENT)))]>, EVEX, VEX_LIG;
5975     def rb_Int : AVX512<opc, MRMSrcReg, (outs _DstRC.RC:$dst), (ins _SrcRC.RC:$src),
5976               !strconcat(asm,"\t{{sae}, $src, $dst|$dst, $src, {sae}}"),
5977               [(set _DstRC.RC:$dst, (OpNodeRnd (_SrcRC.VT _SrcRC.RC:$src),
5978                                     (i32 FROUND_NO_EXC)))]>,
5979                                     EVEX,VEX_LIG , EVEX_B;
5980     let mayLoad = 1, hasSideEffects = 0 in
5981       def rm_Int : AVX512<opc, MRMSrcMem, (outs _DstRC.RC:$dst),
5982                   (ins _SrcRC.IntScalarMemOp:$src),
5983                   !strconcat(asm,"\t{$src, $dst|$dst, $src}"),
5984                   []>, EVEX, VEX_LIG;
5985
5986   } // isCodeGenOnly = 1
5987 } //HasAVX512
5988 }
5989
5990
5991 defm VCVTTSS2SIZ: avx512_cvt_s_all<0x2C, "vcvttss2si", f32x_info, i32x_info,
5992                         fp_to_sint, X86cvtts2IntRnd, "{l}">,
5993                         XS, EVEX_CD8<32, CD8VT1>;
5994 defm VCVTTSS2SI64Z: avx512_cvt_s_all<0x2C, "vcvttss2si", f32x_info, i64x_info,
5995                         fp_to_sint, X86cvtts2IntRnd, "{q}">,
5996                         VEX_W, XS, EVEX_CD8<32, CD8VT1>;
5997 defm VCVTTSD2SIZ: avx512_cvt_s_all<0x2C, "vcvttsd2si", f64x_info, i32x_info,
5998                         fp_to_sint, X86cvtts2IntRnd, "{l}">,
5999                         XD, EVEX_CD8<64, CD8VT1>;
6000 defm VCVTTSD2SI64Z: avx512_cvt_s_all<0x2C, "vcvttsd2si", f64x_info, i64x_info,
6001                         fp_to_sint, X86cvtts2IntRnd, "{q}">,
6002                         VEX_W, XD, EVEX_CD8<64, CD8VT1>;
6003
6004 defm VCVTTSS2USIZ: avx512_cvt_s_all<0x78, "vcvttss2usi", f32x_info, i32x_info,
6005                         fp_to_uint, X86cvtts2UIntRnd, "{l}">,
6006                         XS, EVEX_CD8<32, CD8VT1>;
6007 defm VCVTTSS2USI64Z: avx512_cvt_s_all<0x78, "vcvttss2usi", f32x_info, i64x_info,
6008                         fp_to_uint, X86cvtts2UIntRnd, "{q}">,
6009                         XS,VEX_W, EVEX_CD8<32, CD8VT1>;
6010 defm VCVTTSD2USIZ: avx512_cvt_s_all<0x78, "vcvttsd2usi", f64x_info, i32x_info,
6011                         fp_to_uint, X86cvtts2UIntRnd, "{l}">,
6012                         XD, EVEX_CD8<64, CD8VT1>;
6013 defm VCVTTSD2USI64Z: avx512_cvt_s_all<0x78, "vcvttsd2usi", f64x_info, i64x_info,
6014                         fp_to_uint, X86cvtts2UIntRnd, "{q}">,
6015                         XD, VEX_W, EVEX_CD8<64, CD8VT1>;
6016 let Predicates = [HasAVX512] in {
6017   def : Pat<(i32 (int_x86_sse_cvttss2si (v4f32 VR128X:$src))),
6018             (VCVTTSS2SIZrr_Int VR128X:$src)>;
6019   def : Pat<(i32 (int_x86_sse_cvttss2si sse_load_f32:$src)),
6020             (VCVTTSS2SIZrm_Int ssmem:$src)>;
6021   def : Pat<(i64 (int_x86_sse_cvttss2si64 (v4f32 VR128X:$src))),
6022             (VCVTTSS2SI64Zrr_Int VR128X:$src)>;
6023   def : Pat<(i64 (int_x86_sse_cvttss2si64 sse_load_f32:$src)),
6024             (VCVTTSS2SI64Zrm_Int ssmem:$src)>;
6025   def : Pat<(i32 (int_x86_sse2_cvttsd2si (v2f64 VR128X:$src))),
6026             (VCVTTSD2SIZrr_Int VR128X:$src)>;
6027   def : Pat<(i32 (int_x86_sse2_cvttsd2si sse_load_f64:$src)),
6028             (VCVTTSD2SIZrm_Int sdmem:$src)>;
6029   def : Pat<(i64 (int_x86_sse2_cvttsd2si64 (v2f64 VR128X:$src))),
6030             (VCVTTSD2SI64Zrr_Int VR128X:$src)>;
6031   def : Pat<(i64 (int_x86_sse2_cvttsd2si64 sse_load_f64:$src)),
6032             (VCVTTSD2SI64Zrm_Int sdmem:$src)>;
6033 } // HasAVX512
6034 //===----------------------------------------------------------------------===//
6035 // AVX-512  Convert form float to double and back
6036 //===----------------------------------------------------------------------===//
6037 multiclass avx512_cvt_fp_scalar<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6038                          X86VectorVTInfo _Src, SDNode OpNode> {
6039   defm rr_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6040                          (ins _.RC:$src1, _Src.RC:$src2), OpcodeStr,
6041                          "$src2, $src1", "$src1, $src2",
6042                          (_.VT (OpNode (_.VT _.RC:$src1),
6043                                        (_Src.VT _Src.RC:$src2),
6044                                        (i32 FROUND_CURRENT)))>,
6045                          EVEX_4V, VEX_LIG, Sched<[WriteCvtF2F]>;
6046   defm rm_Int : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
6047                          (ins _.RC:$src1, _Src.IntScalarMemOp:$src2), OpcodeStr,
6048                          "$src2, $src1", "$src1, $src2",
6049                          (_.VT (OpNode (_.VT _.RC:$src1),
6050                                   (_Src.VT _Src.ScalarIntMemCPat:$src2),
6051                                   (i32 FROUND_CURRENT)))>,
6052                          EVEX_4V, VEX_LIG, Sched<[WriteCvtF2FLd, ReadAfterLd]>;
6053
6054   let isCodeGenOnly = 1, hasSideEffects = 0 in {
6055     def rr : I<opc, MRMSrcReg, (outs _.FRC:$dst),
6056                (ins _.FRC:$src1, _Src.FRC:$src2),
6057                OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
6058                EVEX_4V, VEX_LIG, Sched<[WriteCvtF2F]>;
6059     let mayLoad = 1 in
6060     def rm : I<opc, MRMSrcMem, (outs _.FRC:$dst),
6061                (ins _.FRC:$src1, _Src.ScalarMemOp:$src2),
6062                OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
6063                EVEX_4V, VEX_LIG, Sched<[WriteCvtF2FLd, ReadAfterLd]>;
6064   }
6065 }
6066
6067 // Scalar Coversion with SAE - suppress all exceptions
6068 multiclass avx512_cvt_fp_sae_scalar<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6069                          X86VectorVTInfo _Src, SDNode OpNodeRnd> {
6070   defm rrb_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6071                         (ins _.RC:$src1, _Src.RC:$src2), OpcodeStr,
6072                         "{sae}, $src2, $src1", "$src1, $src2, {sae}",
6073                         (_.VT (OpNodeRnd (_.VT _.RC:$src1),
6074                                          (_Src.VT _Src.RC:$src2),
6075                                          (i32 FROUND_NO_EXC)))>,
6076                         EVEX_4V, VEX_LIG, EVEX_B;
6077 }
6078
6079 // Scalar Conversion with rounding control (RC)
6080 multiclass avx512_cvt_fp_rc_scalar<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6081                          X86VectorVTInfo _Src, SDNode OpNodeRnd> {
6082   defm rrb_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6083                         (ins _.RC:$src1, _Src.RC:$src2, AVX512RC:$rc), OpcodeStr,
6084                         "$rc, $src2, $src1", "$src1, $src2, $rc",
6085                         (_.VT (OpNodeRnd (_.VT _.RC:$src1),
6086                                          (_Src.VT _Src.RC:$src2), (i32 imm:$rc)))>,
6087                         EVEX_4V, VEX_LIG, Sched<[WriteCvtF2FLd, ReadAfterLd]>,
6088                         EVEX_B, EVEX_RC;
6089 }
6090 multiclass avx512_cvt_fp_scalar_sd2ss<bits<8> opc, string OpcodeStr,
6091                                   SDNode OpNodeRnd, X86VectorVTInfo _src,
6092                                                         X86VectorVTInfo _dst> {
6093   let Predicates = [HasAVX512] in {
6094     defm Z : avx512_cvt_fp_scalar<opc, OpcodeStr, _dst, _src, OpNodeRnd>,
6095              avx512_cvt_fp_rc_scalar<opc, OpcodeStr, _dst, _src,
6096                                OpNodeRnd>, VEX_W, EVEX_CD8<64, CD8VT1>, XD;
6097   }
6098 }
6099
6100 multiclass avx512_cvt_fp_scalar_ss2sd<bits<8> opc, string OpcodeStr,
6101                                     SDNode OpNodeRnd, X86VectorVTInfo _src,
6102                                                           X86VectorVTInfo _dst> {
6103   let Predicates = [HasAVX512] in {
6104     defm Z : avx512_cvt_fp_scalar<opc, OpcodeStr, _dst, _src, OpNodeRnd>,
6105              avx512_cvt_fp_sae_scalar<opc, OpcodeStr, _dst, _src, OpNodeRnd>,
6106              EVEX_CD8<32, CD8VT1>, XS;
6107   }
6108 }
6109 defm VCVTSD2SS : avx512_cvt_fp_scalar_sd2ss<0x5A, "vcvtsd2ss",
6110                                          X86froundRnd, f64x_info, f32x_info>;
6111 defm VCVTSS2SD : avx512_cvt_fp_scalar_ss2sd<0x5A, "vcvtss2sd",
6112                                           X86fpextRnd,f32x_info, f64x_info >;
6113
6114 def : Pat<(f64 (fpextend FR32X:$src)),
6115           (VCVTSS2SDZrr (COPY_TO_REGCLASS FR32X:$src, FR64X), FR32X:$src)>,
6116           Requires<[HasAVX512]>;
6117 def : Pat<(f64 (fpextend (loadf32 addr:$src))),
6118           (VCVTSS2SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>,
6119           Requires<[HasAVX512]>;
6120
6121 def : Pat<(f64 (extloadf32 addr:$src)),
6122           (VCVTSS2SDZrm (f64 (IMPLICIT_DEF)), addr:$src)>,
6123       Requires<[HasAVX512, OptForSize]>;
6124
6125 def : Pat<(f64 (extloadf32 addr:$src)),
6126           (VCVTSS2SDZrr (f64 (IMPLICIT_DEF)), (VMOVSSZrm addr:$src))>,
6127           Requires<[HasAVX512, OptForSpeed]>;
6128
6129 def : Pat<(f32 (fpround FR64X:$src)),
6130           (VCVTSD2SSZrr (COPY_TO_REGCLASS FR64X:$src, FR32X), FR64X:$src)>,
6131            Requires<[HasAVX512]>;
6132
6133 def : Pat<(v4f32 (X86Movss
6134                    (v4f32 VR128X:$dst),
6135                    (v4f32 (scalar_to_vector
6136                      (f32 (fpround (f64 (extractelt VR128X:$src, (iPTR 0))))))))),
6137           (VCVTSD2SSZrr_Int VR128X:$dst, VR128X:$src)>,
6138           Requires<[HasAVX512]>;
6139
6140 def : Pat<(v2f64 (X86Movsd
6141                    (v2f64 VR128X:$dst),
6142                    (v2f64 (scalar_to_vector
6143                      (f64 (fpextend (f32 (extractelt VR128X:$src, (iPTR 0))))))))),
6144           (VCVTSS2SDZrr_Int VR128X:$dst, VR128X:$src)>,
6145           Requires<[HasAVX512]>;
6146
6147 //===----------------------------------------------------------------------===//
6148 // AVX-512  Vector convert from signed/unsigned integer to float/double
6149 //          and from float/double to signed/unsigned integer
6150 //===----------------------------------------------------------------------===//
6151
6152 multiclass avx512_vcvt_fp<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6153                          X86VectorVTInfo _Src, SDNode OpNode,
6154                          string Broadcast = _.BroadcastStr,
6155                          string Alias = "", X86MemOperand MemOp = _Src.MemOp> {
6156
6157   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
6158                          (ins _Src.RC:$src), OpcodeStr, "$src", "$src",
6159                          (_.VT (OpNode (_Src.VT _Src.RC:$src)))>, EVEX;
6160
6161   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
6162                          (ins MemOp:$src), OpcodeStr#Alias, "$src", "$src",
6163                          (_.VT (OpNode (_Src.VT
6164                              (bitconvert (_Src.LdFrag addr:$src)))))>, EVEX;
6165
6166   defm rmb : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
6167                          (ins _Src.ScalarMemOp:$src), OpcodeStr,
6168                          "${src}"##Broadcast, "${src}"##Broadcast,
6169                          (_.VT (OpNode (_Src.VT
6170                                   (X86VBroadcast (_Src.ScalarLdFrag addr:$src)))
6171                             ))>, EVEX, EVEX_B;
6172 }
6173 // Coversion with SAE - suppress all exceptions
6174 multiclass avx512_vcvt_fp_sae<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6175                          X86VectorVTInfo _Src, SDNode OpNodeRnd> {
6176   defm rrb : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
6177                         (ins _Src.RC:$src), OpcodeStr,
6178                         "{sae}, $src", "$src, {sae}",
6179                         (_.VT (OpNodeRnd (_Src.VT _Src.RC:$src),
6180                                (i32 FROUND_NO_EXC)))>,
6181                         EVEX, EVEX_B;
6182 }
6183
6184 // Conversion with rounding control (RC)
6185 multiclass avx512_vcvt_fp_rc<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6186                          X86VectorVTInfo _Src, SDNode OpNodeRnd> {
6187   defm rrb : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
6188                         (ins _Src.RC:$src, AVX512RC:$rc), OpcodeStr,
6189                         "$rc, $src", "$src, $rc",
6190                         (_.VT (OpNodeRnd (_Src.VT _Src.RC:$src), (i32 imm:$rc)))>,
6191                         EVEX, EVEX_B, EVEX_RC;
6192 }
6193
6194 // Extend Float to Double
6195 multiclass avx512_cvtps2pd<bits<8> opc, string OpcodeStr> {
6196   let Predicates = [HasAVX512] in {
6197     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8f64_info, v8f32x_info, fpextend>,
6198              avx512_vcvt_fp_sae<opc, OpcodeStr, v8f64_info, v8f32x_info,
6199                                 X86vfpextRnd>, EVEX_V512;
6200   }
6201   let Predicates = [HasVLX] in {
6202     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2f64x_info, v4f32x_info,
6203                                X86vfpext, "{1to2}", "", f64mem>, EVEX_V128;
6204     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f64x_info, v4f32x_info, fpextend>,
6205                                      EVEX_V256;
6206   }
6207 }
6208
6209 // Truncate Double to Float
6210 multiclass avx512_cvtpd2ps<bits<8> opc, string OpcodeStr> {
6211   let Predicates = [HasAVX512] in {
6212     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8f32x_info, v8f64_info, fpround>,
6213              avx512_vcvt_fp_rc<opc, OpcodeStr, v8f32x_info, v8f64_info,
6214                                X86vfproundRnd>, EVEX_V512;
6215   }
6216   let Predicates = [HasVLX] in {
6217     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v2f64x_info,
6218                                X86vfpround, "{1to2}", "{x}">, EVEX_V128;
6219     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v4f64x_info, fpround,
6220                                "{1to4}", "{y}">, EVEX_V256;
6221
6222     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6223                     (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
6224     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6225                     (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, f128mem:$src), 0>;
6226     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6227                     (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
6228     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6229                     (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, f256mem:$src), 0>;
6230   }
6231 }
6232
6233 defm VCVTPD2PS : avx512_cvtpd2ps<0x5A, "vcvtpd2ps">,
6234                                   VEX_W, PD, EVEX_CD8<64, CD8VF>;
6235 defm VCVTPS2PD : avx512_cvtps2pd<0x5A, "vcvtps2pd">,
6236                                   PS, EVEX_CD8<32, CD8VH>;
6237
6238 def : Pat<(v8f64 (extloadv8f32 addr:$src)),
6239             (VCVTPS2PDZrm addr:$src)>;
6240
6241 let Predicates = [HasVLX] in {
6242   let AddedComplexity = 15 in
6243   def : Pat<(X86vzmovl (v2f64 (bitconvert
6244                                (v4f32 (X86vfpround (v2f64 VR128X:$src)))))),
6245             (VCVTPD2PSZ128rr VR128X:$src)>;
6246   def : Pat<(v2f64 (extloadv2f32 addr:$src)),
6247               (VCVTPS2PDZ128rm addr:$src)>;
6248   def : Pat<(v4f64 (extloadv4f32 addr:$src)),
6249               (VCVTPS2PDZ256rm addr:$src)>;
6250 }
6251
6252 // Convert Signed/Unsigned Doubleword to Double
6253 multiclass avx512_cvtdq2pd<bits<8> opc, string OpcodeStr, SDNode OpNode,
6254                            SDNode OpNode128> {
6255   // No rounding in this op
6256   let Predicates = [HasAVX512] in
6257     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8f64_info, v8i32x_info, OpNode>,
6258                                      EVEX_V512;
6259
6260   let Predicates = [HasVLX] in {
6261     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2f64x_info, v4i32x_info,
6262                                      OpNode128, "{1to2}", "", i64mem>, EVEX_V128;
6263     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f64x_info, v4i32x_info, OpNode>,
6264                                      EVEX_V256;
6265   }
6266 }
6267
6268 // Convert Signed/Unsigned Doubleword to Float
6269 multiclass avx512_cvtdq2ps<bits<8> opc, string OpcodeStr, SDNode OpNode,
6270                            SDNode OpNodeRnd> {
6271   let Predicates = [HasAVX512] in
6272     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v16f32_info, v16i32_info, OpNode>,
6273              avx512_vcvt_fp_rc<opc, OpcodeStr, v16f32_info, v16i32_info,
6274                                OpNodeRnd>, EVEX_V512;
6275
6276   let Predicates = [HasVLX] in {
6277     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v4i32x_info, OpNode>,
6278                                      EVEX_V128;
6279     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v8f32x_info, v8i32x_info, OpNode>,
6280                                      EVEX_V256;
6281   }
6282 }
6283
6284 // Convert Float to Signed/Unsigned Doubleword with truncation
6285 multiclass avx512_cvttps2dq<bits<8> opc, string OpcodeStr,
6286                                   SDNode OpNode, SDNode OpNodeRnd> {
6287   let Predicates = [HasAVX512] in {
6288     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v16i32_info, v16f32_info, OpNode>,
6289              avx512_vcvt_fp_sae<opc, OpcodeStr, v16i32_info, v16f32_info,
6290                                 OpNodeRnd>, EVEX_V512;
6291   }
6292   let Predicates = [HasVLX] in {
6293     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f32x_info, OpNode>,
6294                                      EVEX_V128;
6295     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v8i32x_info, v8f32x_info, OpNode>,
6296                                      EVEX_V256;
6297   }
6298 }
6299
6300 // Convert Float to Signed/Unsigned Doubleword
6301 multiclass avx512_cvtps2dq<bits<8> opc, string OpcodeStr,
6302                                   SDNode OpNode, SDNode OpNodeRnd> {
6303   let Predicates = [HasAVX512] in {
6304     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v16i32_info, v16f32_info, OpNode>,
6305              avx512_vcvt_fp_rc<opc, OpcodeStr, v16i32_info, v16f32_info,
6306                                 OpNodeRnd>, EVEX_V512;
6307   }
6308   let Predicates = [HasVLX] in {
6309     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f32x_info, OpNode>,
6310                                      EVEX_V128;
6311     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v8i32x_info, v8f32x_info, OpNode>,
6312                                      EVEX_V256;
6313   }
6314 }
6315
6316 // Convert Double to Signed/Unsigned Doubleword with truncation
6317 multiclass avx512_cvttpd2dq<bits<8> opc, string OpcodeStr, SDNode OpNode,
6318                             SDNode OpNode128, SDNode OpNodeRnd> {
6319   let Predicates = [HasAVX512] in {
6320     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i32x_info, v8f64_info, OpNode>,
6321              avx512_vcvt_fp_sae<opc, OpcodeStr, v8i32x_info, v8f64_info,
6322                                 OpNodeRnd>, EVEX_V512;
6323   }
6324   let Predicates = [HasVLX] in {
6325     // we need "x"/"y" suffixes in order to distinguish between 128 and 256
6326     // memory forms of these instructions in Asm Parser. They have the same
6327     // dest type - 'v4i32x_info'. We also specify the broadcast string explicitly
6328     // due to the same reason.
6329     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v2f64x_info,
6330                                OpNode128, "{1to2}", "{x}">, EVEX_V128;
6331     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f64x_info, OpNode,
6332                                "{1to4}", "{y}">, EVEX_V256;
6333
6334     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6335                     (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
6336     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6337                     (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, i128mem:$src), 0>;
6338     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6339                     (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
6340     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6341                     (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, i256mem:$src), 0>;
6342   }
6343 }
6344
6345 // Convert Double to Signed/Unsigned Doubleword
6346 multiclass avx512_cvtpd2dq<bits<8> opc, string OpcodeStr,
6347                                   SDNode OpNode, SDNode OpNodeRnd> {
6348   let Predicates = [HasAVX512] in {
6349     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i32x_info, v8f64_info, OpNode>,
6350              avx512_vcvt_fp_rc<opc, OpcodeStr, v8i32x_info, v8f64_info,
6351                                OpNodeRnd>, EVEX_V512;
6352   }
6353   let Predicates = [HasVLX] in {
6354     // we need "x"/"y" suffixes in order to distinguish between 128 and 256
6355     // memory forms of these instructions in Asm Parcer. They have the same
6356     // dest type - 'v4i32x_info'. We also specify the broadcast string explicitly
6357     // due to the same reason.
6358     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v2f64x_info, OpNode,
6359                                "{1to2}", "{x}">, EVEX_V128;
6360     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f64x_info, OpNode,
6361                                "{1to4}", "{y}">, EVEX_V256;
6362
6363     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6364                     (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
6365     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6366                     (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, f128mem:$src), 0>;
6367     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6368                     (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
6369     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6370                     (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, f256mem:$src), 0>;
6371   }
6372 }
6373
6374 // Convert Double to Signed/Unsigned Quardword
6375 multiclass avx512_cvtpd2qq<bits<8> opc, string OpcodeStr,
6376                                   SDNode OpNode, SDNode OpNodeRnd> {
6377   let Predicates = [HasDQI] in {
6378     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i64_info, v8f64_info, OpNode>,
6379              avx512_vcvt_fp_rc<opc, OpcodeStr, v8i64_info, v8f64_info,
6380                                OpNodeRnd>, EVEX_V512;
6381   }
6382   let Predicates = [HasDQI, HasVLX] in {
6383     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2i64x_info, v2f64x_info, OpNode>,
6384                                EVEX_V128;
6385     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i64x_info, v4f64x_info, OpNode>,
6386                                EVEX_V256;
6387   }
6388 }
6389
6390 // Convert Double to Signed/Unsigned Quardword with truncation
6391 multiclass avx512_cvttpd2qq<bits<8> opc, string OpcodeStr,
6392                                   SDNode OpNode, SDNode OpNodeRnd> {
6393   let Predicates = [HasDQI] in {
6394     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i64_info, v8f64_info, OpNode>,
6395              avx512_vcvt_fp_sae<opc, OpcodeStr, v8i64_info, v8f64_info,
6396                                OpNodeRnd>, EVEX_V512;
6397   }
6398   let Predicates = [HasDQI, HasVLX] in {
6399     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2i64x_info, v2f64x_info, OpNode>,
6400                                EVEX_V128;
6401     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i64x_info, v4f64x_info, OpNode>,
6402                                EVEX_V256;
6403   }
6404 }
6405
6406 // Convert Signed/Unsigned Quardword to Double
6407 multiclass avx512_cvtqq2pd<bits<8> opc, string OpcodeStr,
6408                                   SDNode OpNode, SDNode OpNodeRnd> {
6409   let Predicates = [HasDQI] in {
6410     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8f64_info, v8i64_info, OpNode>,
6411              avx512_vcvt_fp_rc<opc, OpcodeStr, v8f64_info, v8i64_info,
6412                                OpNodeRnd>, EVEX_V512;
6413   }
6414   let Predicates = [HasDQI, HasVLX] in {
6415     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2f64x_info, v2i64x_info, OpNode>,
6416                                EVEX_V128;
6417     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f64x_info, v4i64x_info, OpNode>,
6418                                EVEX_V256;
6419   }
6420 }
6421
6422 // Convert Float to Signed/Unsigned Quardword
6423 multiclass avx512_cvtps2qq<bits<8> opc, string OpcodeStr,
6424                                   SDNode OpNode, SDNode OpNodeRnd> {
6425   let Predicates = [HasDQI] in {
6426     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i64_info, v8f32x_info, OpNode>,
6427              avx512_vcvt_fp_rc<opc, OpcodeStr, v8i64_info, v8f32x_info,
6428                                OpNodeRnd>, EVEX_V512;
6429   }
6430   let Predicates = [HasDQI, HasVLX] in {
6431     // Explicitly specified broadcast string, since we take only 2 elements
6432     // from v4f32x_info source
6433     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2i64x_info, v4f32x_info, OpNode,
6434                                "{1to2}", "", f64mem>, EVEX_V128;
6435     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i64x_info, v4f32x_info, OpNode>,
6436                                EVEX_V256;
6437   }
6438 }
6439
6440 // Convert Float to Signed/Unsigned Quardword with truncation
6441 multiclass avx512_cvttps2qq<bits<8> opc, string OpcodeStr, SDNode OpNode,
6442                             SDNode OpNode128, SDNode OpNodeRnd> {
6443   let Predicates = [HasDQI] in {
6444     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8i64_info, v8f32x_info, OpNode>,
6445              avx512_vcvt_fp_sae<opc, OpcodeStr, v8i64_info, v8f32x_info,
6446                                OpNodeRnd>, EVEX_V512;
6447   }
6448   let Predicates = [HasDQI, HasVLX] in {
6449     // Explicitly specified broadcast string, since we take only 2 elements
6450     // from v4f32x_info source
6451     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v2i64x_info, v4f32x_info, OpNode128,
6452                                "{1to2}", "", f64mem>, EVEX_V128;
6453     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i64x_info, v4f32x_info, OpNode>,
6454                                EVEX_V256;
6455   }
6456 }
6457
6458 // Convert Signed/Unsigned Quardword to Float
6459 multiclass avx512_cvtqq2ps<bits<8> opc, string OpcodeStr, SDNode OpNode,
6460                                   SDNode OpNode128, SDNode OpNodeRnd> {
6461   let Predicates = [HasDQI] in {
6462     defm Z : avx512_vcvt_fp<opc, OpcodeStr, v8f32x_info, v8i64_info, OpNode>,
6463              avx512_vcvt_fp_rc<opc, OpcodeStr, v8f32x_info, v8i64_info,
6464                                OpNodeRnd>, EVEX_V512;
6465   }
6466   let Predicates = [HasDQI, HasVLX] in {
6467     // we need "x"/"y" suffixes in order to distinguish between 128 and 256
6468     // memory forms of these instructions in Asm Parcer. They have the same
6469     // dest type - 'v4i32x_info'. We also specify the broadcast string explicitly
6470     // due to the same reason.
6471     defm Z128 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v2i64x_info, OpNode128,
6472                                "{1to2}", "{x}">, EVEX_V128;
6473     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v4i64x_info, OpNode,
6474                                "{1to4}", "{y}">, EVEX_V256;
6475
6476     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6477                     (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
6478     def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
6479                     (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, i128mem:$src), 0>;
6480     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6481                     (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
6482     def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
6483                     (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, i256mem:$src), 0>;
6484   }
6485 }
6486
6487 defm VCVTDQ2PD : avx512_cvtdq2pd<0xE6, "vcvtdq2pd", sint_to_fp, X86VSintToFP>,
6488                                 XS, EVEX_CD8<32, CD8VH>;
6489
6490 defm VCVTDQ2PS : avx512_cvtdq2ps<0x5B, "vcvtdq2ps", sint_to_fp,
6491                                 X86VSintToFpRnd>,
6492                                 PS, EVEX_CD8<32, CD8VF>;
6493
6494 defm VCVTTPS2DQ : avx512_cvttps2dq<0x5B, "vcvttps2dq", fp_to_sint,
6495                                 X86cvttp2siRnd>,
6496                                 XS, EVEX_CD8<32, CD8VF>;
6497
6498 defm VCVTTPD2DQ : avx512_cvttpd2dq<0xE6, "vcvttpd2dq", fp_to_sint, X86cvttp2si,
6499                                  X86cvttp2siRnd>,
6500                                  PD, VEX_W, EVEX_CD8<64, CD8VF>;
6501
6502 defm VCVTTPS2UDQ : avx512_cvttps2dq<0x78, "vcvttps2udq", fp_to_uint,
6503                                  X86cvttp2uiRnd>, PS,
6504                                  EVEX_CD8<32, CD8VF>;
6505
6506 defm VCVTTPD2UDQ : avx512_cvttpd2dq<0x78, "vcvttpd2udq", fp_to_uint,
6507                                  X86cvttp2ui, X86cvttp2uiRnd>, PS, VEX_W,
6508                                  EVEX_CD8<64, CD8VF>;
6509
6510 defm VCVTUDQ2PD : avx512_cvtdq2pd<0x7A, "vcvtudq2pd", uint_to_fp, X86VUintToFP>,
6511                                  XS, EVEX_CD8<32, CD8VH>;
6512
6513 defm VCVTUDQ2PS : avx512_cvtdq2ps<0x7A, "vcvtudq2ps", uint_to_fp,
6514                                  X86VUintToFpRnd>, XD,
6515                                  EVEX_CD8<32, CD8VF>;
6516
6517 defm VCVTPS2DQ : avx512_cvtps2dq<0x5B, "vcvtps2dq", X86cvtp2Int,
6518                                  X86cvtp2IntRnd>, PD, EVEX_CD8<32, CD8VF>;
6519
6520 defm VCVTPD2DQ : avx512_cvtpd2dq<0xE6, "vcvtpd2dq", X86cvtp2Int,
6521                                  X86cvtp2IntRnd>, XD, VEX_W,
6522                                  EVEX_CD8<64, CD8VF>;
6523
6524 defm VCVTPS2UDQ : avx512_cvtps2dq<0x79, "vcvtps2udq", X86cvtp2UInt,
6525                                  X86cvtp2UIntRnd>,
6526                                  PS, EVEX_CD8<32, CD8VF>;
6527 defm VCVTPD2UDQ : avx512_cvtpd2dq<0x79, "vcvtpd2udq", X86cvtp2UInt,
6528                                  X86cvtp2UIntRnd>, VEX_W,
6529                                  PS, EVEX_CD8<64, CD8VF>;
6530
6531 defm VCVTPD2QQ : avx512_cvtpd2qq<0x7B, "vcvtpd2qq", X86cvtp2Int,
6532                                  X86cvtp2IntRnd>, VEX_W,
6533                                  PD, EVEX_CD8<64, CD8VF>;
6534
6535 defm VCVTPS2QQ : avx512_cvtps2qq<0x7B, "vcvtps2qq", X86cvtp2Int,
6536                                  X86cvtp2IntRnd>, PD, EVEX_CD8<32, CD8VH>;
6537
6538 defm VCVTPD2UQQ : avx512_cvtpd2qq<0x79, "vcvtpd2uqq", X86cvtp2UInt,
6539                                  X86cvtp2UIntRnd>, VEX_W,
6540                                  PD, EVEX_CD8<64, CD8VF>;
6541
6542 defm VCVTPS2UQQ : avx512_cvtps2qq<0x79, "vcvtps2uqq", X86cvtp2UInt,
6543                                  X86cvtp2UIntRnd>, PD, EVEX_CD8<32, CD8VH>;
6544
6545 defm VCVTTPD2QQ : avx512_cvttpd2qq<0x7A, "vcvttpd2qq", fp_to_sint,
6546                                  X86cvttp2siRnd>, VEX_W,
6547                                  PD, EVEX_CD8<64, CD8VF>;
6548
6549 defm VCVTTPS2QQ : avx512_cvttps2qq<0x7A, "vcvttps2qq", fp_to_sint, X86cvttp2si,
6550                                  X86cvttp2siRnd>, PD, EVEX_CD8<32, CD8VH>;
6551
6552 defm VCVTTPD2UQQ : avx512_cvttpd2qq<0x78, "vcvttpd2uqq", fp_to_uint,
6553                                  X86cvttp2uiRnd>, VEX_W,
6554                                  PD, EVEX_CD8<64, CD8VF>;
6555
6556 defm VCVTTPS2UQQ : avx512_cvttps2qq<0x78, "vcvttps2uqq", fp_to_uint, X86cvttp2ui,
6557                                  X86cvttp2uiRnd>, PD, EVEX_CD8<32, CD8VH>;
6558
6559 defm VCVTQQ2PD : avx512_cvtqq2pd<0xE6, "vcvtqq2pd", sint_to_fp,
6560                             X86VSintToFpRnd>, VEX_W, XS, EVEX_CD8<64, CD8VF>;
6561
6562 defm VCVTUQQ2PD : avx512_cvtqq2pd<0x7A, "vcvtuqq2pd", uint_to_fp,
6563                             X86VUintToFpRnd>, VEX_W, XS, EVEX_CD8<64, CD8VF>;
6564
6565 defm VCVTQQ2PS : avx512_cvtqq2ps<0x5B, "vcvtqq2ps", sint_to_fp, X86VSintToFP,
6566                             X86VSintToFpRnd>, VEX_W, PS, EVEX_CD8<64, CD8VF>;
6567
6568 defm VCVTUQQ2PS : avx512_cvtqq2ps<0x7A, "vcvtuqq2ps", uint_to_fp, X86VUintToFP,
6569                             X86VUintToFpRnd>, VEX_W, XD, EVEX_CD8<64, CD8VF>;
6570
6571 let Predicates = [HasAVX512, NoVLX] in {
6572 def : Pat<(v8i32 (fp_to_uint (v8f32 VR256X:$src1))),
6573           (EXTRACT_SUBREG (v16i32 (VCVTTPS2UDQZrr
6574            (v16f32 (INSERT_SUBREG (IMPLICIT_DEF),
6575                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6576
6577 def : Pat<(v4i32 (fp_to_uint (v4f32 VR128X:$src1))),
6578           (EXTRACT_SUBREG (v16i32 (VCVTTPS2UDQZrr
6579            (v16f32 (INSERT_SUBREG (IMPLICIT_DEF),
6580                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6581
6582 def : Pat<(v4i32 (fp_to_uint (v4f64 VR256X:$src1))),
6583           (EXTRACT_SUBREG (v8i32 (VCVTTPD2UDQZrr
6584            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6585                                  VR256X:$src1, sub_ymm)))), sub_xmm)>;
6586
6587 def : Pat<(v4i32 (X86cvttp2ui (v2f64 VR128X:$src))),
6588           (EXTRACT_SUBREG (v8i32 (VCVTTPD2UDQZrr
6589            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6590                                  VR128X:$src, sub_xmm)))), sub_xmm)>;
6591
6592 def : Pat<(v8f32 (uint_to_fp (v8i32 VR256X:$src1))),
6593           (EXTRACT_SUBREG (v16f32 (VCVTUDQ2PSZrr
6594            (v16i32 (INSERT_SUBREG (IMPLICIT_DEF),
6595                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6596
6597 def : Pat<(v4f32 (uint_to_fp (v4i32 VR128X:$src1))),
6598           (EXTRACT_SUBREG (v16f32 (VCVTUDQ2PSZrr
6599            (v16i32 (INSERT_SUBREG (IMPLICIT_DEF),
6600                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6601
6602 def : Pat<(v4f64 (uint_to_fp (v4i32 VR128X:$src1))),
6603           (EXTRACT_SUBREG (v8f64 (VCVTUDQ2PDZrr
6604            (v8i32 (INSERT_SUBREG (IMPLICIT_DEF),
6605                                  VR128X:$src1, sub_xmm)))), sub_ymm)>;
6606
6607 def : Pat<(v2f64 (X86VUintToFP (v4i32 VR128X:$src1))),
6608           (EXTRACT_SUBREG (v8f64 (VCVTUDQ2PDZrr
6609            (v8i32 (INSERT_SUBREG (IMPLICIT_DEF),
6610                                  VR128X:$src1, sub_xmm)))), sub_xmm)>;
6611 }
6612
6613 let Predicates = [HasAVX512, HasVLX] in {
6614   let AddedComplexity = 15 in {
6615     def : Pat<(X86vzmovl (v2i64 (bitconvert
6616                                 (v4i32 (X86cvtp2Int (v2f64 VR128X:$src)))))),
6617               (VCVTPD2DQZ128rr VR128X:$src)>;
6618     def : Pat<(v4i32 (bitconvert (X86vzmovl (v2i64 (bitconvert
6619                                  (v4i32 (X86cvtp2UInt (v2f64 VR128X:$src)))))))),
6620               (VCVTPD2UDQZ128rr VR128X:$src)>;
6621     def : Pat<(X86vzmovl (v2i64 (bitconvert
6622                                 (v4i32 (X86cvttp2si (v2f64 VR128X:$src)))))),
6623               (VCVTTPD2DQZ128rr VR128X:$src)>;
6624     def : Pat<(v4i32 (bitconvert (X86vzmovl (v2i64 (bitconvert
6625                                  (v4i32 (X86cvttp2ui (v2f64 VR128X:$src)))))))),
6626               (VCVTTPD2UDQZ128rr VR128X:$src)>;
6627   }
6628 }
6629
6630 let Predicates = [HasAVX512] in {
6631   def : Pat<(v8f32 (fpround (loadv8f64 addr:$src))),
6632             (VCVTPD2PSZrm addr:$src)>;
6633   def : Pat<(v8f64 (extloadv8f32 addr:$src)),
6634             (VCVTPS2PDZrm addr:$src)>;
6635 }
6636
6637 let Predicates = [HasDQI, HasVLX] in {
6638   let AddedComplexity = 15 in {
6639     def : Pat<(X86vzmovl (v2f64 (bitconvert
6640                                 (v4f32 (X86VSintToFP (v2i64 VR128X:$src)))))),
6641               (VCVTQQ2PSZ128rr VR128X:$src)>;
6642     def : Pat<(X86vzmovl (v2f64 (bitconvert
6643                                 (v4f32 (X86VUintToFP (v2i64 VR128X:$src)))))),
6644               (VCVTUQQ2PSZ128rr VR128X:$src)>;
6645   }
6646 }
6647
6648 let Predicates = [HasDQI, NoVLX] in {
6649 def : Pat<(v2i64 (fp_to_sint (v2f64 VR128X:$src1))),
6650           (EXTRACT_SUBREG (v8i64 (VCVTTPD2QQZrr
6651            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6652                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6653
6654 def : Pat<(v4i64 (fp_to_sint (v4f32 VR128X:$src1))),
6655           (EXTRACT_SUBREG (v8i64 (VCVTTPS2QQZrr
6656            (v8f32 (INSERT_SUBREG (IMPLICIT_DEF),
6657                                   VR128X:$src1, sub_xmm)))), sub_ymm)>;
6658
6659 def : Pat<(v4i64 (fp_to_sint (v4f64 VR256X:$src1))),
6660           (EXTRACT_SUBREG (v8i64 (VCVTTPD2QQZrr
6661            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6662                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6663
6664 def : Pat<(v2i64 (fp_to_uint (v2f64 VR128X:$src1))),
6665           (EXTRACT_SUBREG (v8i64 (VCVTTPD2UQQZrr
6666            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6667                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6668
6669 def : Pat<(v4i64 (fp_to_uint (v4f32 VR128X:$src1))),
6670           (EXTRACT_SUBREG (v8i64 (VCVTTPS2UQQZrr
6671            (v8f32 (INSERT_SUBREG (IMPLICIT_DEF),
6672                                   VR128X:$src1, sub_xmm)))), sub_ymm)>;
6673
6674 def : Pat<(v4i64 (fp_to_uint (v4f64 VR256X:$src1))),
6675           (EXTRACT_SUBREG (v8i64 (VCVTTPD2UQQZrr
6676            (v8f64 (INSERT_SUBREG (IMPLICIT_DEF),
6677                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6678
6679 def : Pat<(v4f32 (sint_to_fp (v4i64 VR256X:$src1))),
6680           (EXTRACT_SUBREG (v8f32 (VCVTQQ2PSZrr
6681            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6682                                   VR256X:$src1, sub_ymm)))), sub_xmm)>;
6683
6684 def : Pat<(v2f64 (sint_to_fp (v2i64 VR128X:$src1))),
6685           (EXTRACT_SUBREG (v8f64 (VCVTQQ2PDZrr
6686            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6687                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6688
6689 def : Pat<(v4f64 (sint_to_fp (v4i64 VR256X:$src1))),
6690           (EXTRACT_SUBREG (v8f64 (VCVTQQ2PDZrr
6691            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6692                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6693
6694 def : Pat<(v4f32 (uint_to_fp (v4i64 VR256X:$src1))),
6695           (EXTRACT_SUBREG (v8f32 (VCVTUQQ2PSZrr
6696            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6697                                   VR256X:$src1, sub_ymm)))), sub_xmm)>;
6698
6699 def : Pat<(v2f64 (uint_to_fp (v2i64 VR128X:$src1))),
6700           (EXTRACT_SUBREG (v8f64 (VCVTUQQ2PDZrr
6701            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6702                                   VR128X:$src1, sub_xmm)))), sub_xmm)>;
6703
6704 def : Pat<(v4f64 (uint_to_fp (v4i64 VR256X:$src1))),
6705           (EXTRACT_SUBREG (v8f64 (VCVTUQQ2PDZrr
6706            (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
6707                                   VR256X:$src1, sub_ymm)))), sub_ymm)>;
6708 }
6709
6710 //===----------------------------------------------------------------------===//
6711 // Half precision conversion instructions
6712 //===----------------------------------------------------------------------===//
6713 multiclass avx512_cvtph2ps<X86VectorVTInfo _dest, X86VectorVTInfo _src,
6714                            X86MemOperand x86memop, PatFrag ld_frag> {
6715   defm rr : AVX512_maskable<0x13, MRMSrcReg, _dest ,(outs _dest.RC:$dst), (ins _src.RC:$src),
6716                     "vcvtph2ps", "$src", "$src",
6717                    (X86cvtph2ps (_src.VT _src.RC:$src),
6718                                                 (i32 FROUND_CURRENT))>, T8PD;
6719   defm rm : AVX512_maskable<0x13, MRMSrcMem, _dest, (outs _dest.RC:$dst), (ins x86memop:$src),
6720                     "vcvtph2ps", "$src", "$src",
6721                     (X86cvtph2ps (_src.VT (bitconvert (ld_frag addr:$src))),
6722                                      (i32 FROUND_CURRENT))>, T8PD;
6723 }
6724
6725 multiclass avx512_cvtph2ps_sae<X86VectorVTInfo _dest, X86VectorVTInfo _src> {
6726   defm rb : AVX512_maskable<0x13, MRMSrcReg, _dest ,(outs _dest.RC:$dst), (ins _src.RC:$src),
6727                     "vcvtph2ps", "{sae}, $src", "$src, {sae}",
6728                    (X86cvtph2ps (_src.VT _src.RC:$src),
6729                                                 (i32 FROUND_NO_EXC))>, T8PD, EVEX_B;
6730
6731 }
6732
6733 let Predicates = [HasAVX512] in {
6734   defm VCVTPH2PSZ : avx512_cvtph2ps<v16f32_info, v16i16x_info, f256mem, loadv4i64>,
6735                     avx512_cvtph2ps_sae<v16f32_info, v16i16x_info>,
6736                     EVEX, EVEX_V512, EVEX_CD8<32, CD8VH>;
6737   let Predicates = [HasVLX] in {
6738     defm VCVTPH2PSZ256 : avx512_cvtph2ps<v8f32x_info, v8i16x_info, f128mem,
6739                          loadv2i64>,EVEX, EVEX_V256, EVEX_CD8<32, CD8VH>;
6740     defm VCVTPH2PSZ128 : avx512_cvtph2ps<v4f32x_info, v8i16x_info, f64mem,
6741                          loadv2i64>, EVEX, EVEX_V128, EVEX_CD8<32, CD8VH>;
6742   }
6743 }
6744
6745 multiclass avx512_cvtps2ph<X86VectorVTInfo _dest, X86VectorVTInfo _src,
6746                            X86MemOperand x86memop> {
6747   defm rr : AVX512_maskable<0x1D, MRMDestReg, _dest ,(outs _dest.RC:$dst),
6748                    (ins _src.RC:$src1, i32u8imm:$src2),
6749                    "vcvtps2ph", "$src2, $src1", "$src1, $src2",
6750                    (X86cvtps2ph (_src.VT _src.RC:$src1),
6751                                 (i32 imm:$src2)),
6752                    NoItinerary, 0, 0, X86select>, AVX512AIi8Base;
6753   def mr : AVX512AIi8<0x1D, MRMDestMem, (outs),
6754              (ins x86memop:$dst, _src.RC:$src1, i32u8imm:$src2),
6755              "vcvtps2ph\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6756              [(store (_dest.VT (X86cvtps2ph (_src.VT _src.RC:$src1),
6757                                      (i32 imm:$src2))),
6758                                      addr:$dst)]>;
6759   let hasSideEffects = 0, mayStore = 1 in
6760   def mrk : AVX512AIi8<0x1D, MRMDestMem, (outs),
6761              (ins x86memop:$dst, _dest.KRCWM:$mask, _src.RC:$src1, i32u8imm:$src2),
6762              "vcvtps2ph\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
6763               []>, EVEX_K;
6764 }
6765 multiclass avx512_cvtps2ph_sae<X86VectorVTInfo _dest, X86VectorVTInfo _src> {
6766   let hasSideEffects = 0 in
6767   defm rb : AVX512_maskable_in_asm<0x1D, MRMDestReg, _dest,
6768                    (outs _dest.RC:$dst),
6769                    (ins _src.RC:$src1, i32u8imm:$src2),
6770                    "vcvtps2ph", "$src2, {sae}, $src1", "$src1, {sae}, $src2",
6771                    []>, EVEX_B, AVX512AIi8Base;
6772 }
6773 let Predicates = [HasAVX512] in {
6774   defm VCVTPS2PHZ : avx512_cvtps2ph<v16i16x_info, v16f32_info, f256mem>,
6775                     avx512_cvtps2ph_sae<v16i16x_info, v16f32_info>,
6776                       EVEX, EVEX_V512, EVEX_CD8<32, CD8VH>;
6777   let Predicates = [HasVLX] in {
6778     defm VCVTPS2PHZ256 : avx512_cvtps2ph<v8i16x_info, v8f32x_info, f128mem>,
6779                         EVEX, EVEX_V256, EVEX_CD8<32, CD8VH>;
6780     defm VCVTPS2PHZ128 : avx512_cvtps2ph<v8i16x_info, v4f32x_info, f64mem>,
6781                         EVEX, EVEX_V128, EVEX_CD8<32, CD8VH>;
6782   }
6783 }
6784
6785 // Patterns for matching conversions from float to half-float and vice versa.
6786 let Predicates = [HasVLX] in {
6787   // Use MXCSR.RC for rounding instead of explicitly specifying the default
6788   // rounding mode (Nearest-Even, encoded as 0). Both are equivalent in the
6789   // configurations we support (the default). However, falling back to MXCSR is
6790   // more consistent with other instructions, which are always controlled by it.
6791   // It's encoded as 0b100.
6792   def : Pat<(fp_to_f16 FR32X:$src),
6793             (i16 (EXTRACT_SUBREG (VMOVPDI2DIZrr (VCVTPS2PHZ128rr
6794               (COPY_TO_REGCLASS FR32X:$src, VR128X), 4)), sub_16bit))>;
6795
6796   def : Pat<(f16_to_fp GR16:$src),
6797             (f32 (COPY_TO_REGCLASS (VCVTPH2PSZ128rr
6798               (COPY_TO_REGCLASS (MOVSX32rr16 GR16:$src), VR128X)), FR32X)) >;
6799
6800   def : Pat<(f16_to_fp (i16 (fp_to_f16 FR32X:$src))),
6801             (f32 (COPY_TO_REGCLASS (VCVTPH2PSZ128rr
6802               (VCVTPS2PHZ128rr (COPY_TO_REGCLASS FR32X:$src, VR128X), 4)), FR32X)) >;
6803 }
6804
6805 // Patterns for matching float to half-float conversion when AVX512 is supported
6806 // but F16C isn't. In that case we have to use 512-bit vectors.
6807 let Predicates = [HasAVX512, NoVLX, NoF16C] in {
6808   def : Pat<(fp_to_f16 FR32X:$src),
6809             (i16 (EXTRACT_SUBREG
6810                   (VMOVPDI2DIZrr
6811                    (v8i16 (EXTRACT_SUBREG
6812                     (VCVTPS2PHZrr
6813                      (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)),
6814                       (v4f32 (COPY_TO_REGCLASS FR32X:$src, VR128X)),
6815                       sub_xmm), 4), sub_xmm))), sub_16bit))>;
6816
6817   def : Pat<(f16_to_fp GR16:$src),
6818             (f32 (COPY_TO_REGCLASS
6819                   (v4f32 (EXTRACT_SUBREG
6820                    (VCVTPH2PSZrr
6821                     (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)),
6822                      (v8i16 (COPY_TO_REGCLASS (MOVSX32rr16 GR16:$src), VR128X)),
6823                      sub_xmm)), sub_xmm)), FR32X))>;
6824
6825   def : Pat<(f16_to_fp (i16 (fp_to_f16 FR32X:$src))),
6826             (f32 (COPY_TO_REGCLASS
6827                   (v4f32 (EXTRACT_SUBREG
6828                           (VCVTPH2PSZrr
6829                            (VCVTPS2PHZrr (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)),
6830                             (v4f32 (COPY_TO_REGCLASS FR32X:$src, VR128X)),
6831                             sub_xmm), 4)), sub_xmm)), FR32X))>;
6832 }
6833
6834 //  Unordered/Ordered scalar fp compare with Sea and set EFLAGS
6835 multiclass avx512_ord_cmp_sae<bits<8> opc, X86VectorVTInfo _,
6836                             string OpcodeStr> {
6837   def rb: AVX512<opc, MRMSrcReg, (outs), (ins _.RC:$src1, _.RC:$src2),
6838                  !strconcat(OpcodeStr, "\t{{sae}, $src2, $src1|$src1, $src2, {sae}}"),
6839                  [], IIC_SSE_COMIS_RR>, EVEX, EVEX_B, VEX_LIG, EVEX_V128,
6840                  Sched<[WriteFAdd]>;
6841 }
6842
6843 let Defs = [EFLAGS], Predicates = [HasAVX512] in {
6844   defm VUCOMISSZ : avx512_ord_cmp_sae<0x2E, v4f32x_info, "vucomiss">,
6845                                    AVX512PSIi8Base, EVEX_CD8<32, CD8VT1>;
6846   defm VUCOMISDZ : avx512_ord_cmp_sae<0x2E, v2f64x_info, "vucomisd">,
6847                                    AVX512PDIi8Base, VEX_W, EVEX_CD8<64, CD8VT1>;
6848   defm VCOMISSZ : avx512_ord_cmp_sae<0x2F, v4f32x_info, "vcomiss">,
6849                                    AVX512PSIi8Base, EVEX_CD8<32, CD8VT1>;
6850   defm VCOMISDZ : avx512_ord_cmp_sae<0x2F, v2f64x_info, "vcomisd">,
6851                                    AVX512PDIi8Base, VEX_W, EVEX_CD8<64, CD8VT1>;
6852 }
6853
6854 let Defs = [EFLAGS], Predicates = [HasAVX512] in {
6855   defm VUCOMISSZ : sse12_ord_cmp<0x2E, FR32X, X86cmp, f32, f32mem, loadf32,
6856                                  "ucomiss">, PS, EVEX, VEX_LIG,
6857                                  EVEX_CD8<32, CD8VT1>;
6858   defm VUCOMISDZ : sse12_ord_cmp<0x2E, FR64X, X86cmp, f64, f64mem, loadf64,
6859                                   "ucomisd">, PD, EVEX,
6860                                   VEX_LIG, VEX_W, EVEX_CD8<64, CD8VT1>;
6861   let Pattern = []<dag> in {
6862     defm VCOMISSZ  : sse12_ord_cmp<0x2F, FR32X, undef, f32, f32mem, loadf32,
6863                                    "comiss">, PS, EVEX, VEX_LIG,
6864                                    EVEX_CD8<32, CD8VT1>;
6865     defm VCOMISDZ  : sse12_ord_cmp<0x2F, FR64X, undef, f64, f64mem, loadf64,
6866                                    "comisd">, PD, EVEX,
6867                                     VEX_LIG, VEX_W, EVEX_CD8<64, CD8VT1>;
6868   }
6869   let isCodeGenOnly = 1 in {
6870     defm Int_VUCOMISSZ  : sse12_ord_cmp_int<0x2E, VR128X, X86ucomi, v4f32, ssmem,
6871                               sse_load_f32, "ucomiss">, PS, EVEX, VEX_LIG,
6872                               EVEX_CD8<32, CD8VT1>;
6873     defm Int_VUCOMISDZ  : sse12_ord_cmp_int<0x2E, VR128X, X86ucomi, v2f64, sdmem,
6874                               sse_load_f64, "ucomisd">, PD, EVEX,
6875                               VEX_LIG, VEX_W, EVEX_CD8<64, CD8VT1>;
6876
6877     defm Int_VCOMISSZ  : sse12_ord_cmp_int<0x2F, VR128X, X86comi, v4f32, ssmem,
6878                               sse_load_f32, "comiss">, PS, EVEX, VEX_LIG,
6879                               EVEX_CD8<32, CD8VT1>;
6880     defm Int_VCOMISDZ  : sse12_ord_cmp_int<0x2F, VR128X, X86comi, v2f64, sdmem,
6881                               sse_load_f64, "comisd">, PD, EVEX,
6882                               VEX_LIG, VEX_W, EVEX_CD8<64, CD8VT1>;
6883   }
6884 }
6885
6886 /// avx512_fp14_s rcp14ss, rcp14sd, rsqrt14ss, rsqrt14sd
6887 multiclass avx512_fp14_s<bits<8> opc, string OpcodeStr, SDNode OpNode,
6888                             X86VectorVTInfo _> {
6889   let Predicates = [HasAVX512], ExeDomain = _.ExeDomain in {
6890   defm rr : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6891                            (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
6892                            "$src2, $src1", "$src1, $src2",
6893                            (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2))>, EVEX_4V;
6894   defm rm : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
6895                          (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
6896                          "$src2, $src1", "$src1, $src2",
6897                          (OpNode (_.VT _.RC:$src1),
6898                           (_.VT (scalar_to_vector (_.ScalarLdFrag addr:$src2))))>, EVEX_4V;
6899 }
6900 }
6901
6902 defm VRCP14SS   : avx512_fp14_s<0x4D, "vrcp14ss", X86frcp14s, f32x_info>,
6903                   EVEX_CD8<32, CD8VT1>, T8PD;
6904 defm VRCP14SD   : avx512_fp14_s<0x4D, "vrcp14sd", X86frcp14s, f64x_info>,
6905                   VEX_W, EVEX_CD8<64, CD8VT1>, T8PD;
6906 defm VRSQRT14SS   : avx512_fp14_s<0x4F, "vrsqrt14ss", X86frsqrt14s, f32x_info>,
6907                   EVEX_CD8<32, CD8VT1>, T8PD;
6908 defm VRSQRT14SD   : avx512_fp14_s<0x4F, "vrsqrt14sd", X86frsqrt14s, f64x_info>,
6909                   VEX_W, EVEX_CD8<64, CD8VT1>, T8PD;
6910
6911 /// avx512_fp14_p rcp14ps, rcp14pd, rsqrt14ps, rsqrt14pd
6912 multiclass avx512_fp14_p<bits<8> opc, string OpcodeStr, SDNode OpNode,
6913                          X86VectorVTInfo _> {
6914   let ExeDomain = _.ExeDomain in {
6915   defm r: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
6916                          (ins _.RC:$src), OpcodeStr, "$src", "$src",
6917                          (_.FloatVT (OpNode _.RC:$src))>, EVEX, T8PD;
6918   defm m: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
6919                          (ins _.MemOp:$src), OpcodeStr, "$src", "$src",
6920                          (OpNode (_.FloatVT
6921                            (bitconvert (_.LdFrag addr:$src))))>, EVEX, T8PD;
6922   defm mb: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
6923                           (ins _.ScalarMemOp:$src), OpcodeStr,
6924                           "${src}"##_.BroadcastStr, "${src}"##_.BroadcastStr,
6925                           (OpNode (_.FloatVT
6926                             (X86VBroadcast (_.ScalarLdFrag addr:$src))))>,
6927                           EVEX, T8PD, EVEX_B;
6928   }
6929 }
6930
6931 multiclass avx512_fp14_p_vl_all<bits<8> opc, string OpcodeStr, SDNode OpNode> {
6932   defm PSZ : avx512_fp14_p<opc, !strconcat(OpcodeStr, "ps"), OpNode, v16f32_info>,
6933                           EVEX_V512, EVEX_CD8<32, CD8VF>;
6934   defm PDZ : avx512_fp14_p<opc, !strconcat(OpcodeStr, "pd"), OpNode, v8f64_info>,
6935                           EVEX_V512, VEX_W, EVEX_CD8<64, CD8VF>;
6936
6937   // Define only if AVX512VL feature is present.
6938   let Predicates = [HasVLX] in {
6939     defm PSZ128 : avx512_fp14_p<opc, !strconcat(OpcodeStr, "ps"),
6940                                 OpNode, v4f32x_info>,
6941                                EVEX_V128, EVEX_CD8<32, CD8VF>;
6942     defm PSZ256 : avx512_fp14_p<opc, !strconcat(OpcodeStr, "ps"),
6943                                 OpNode, v8f32x_info>,
6944                                EVEX_V256, EVEX_CD8<32, CD8VF>;
6945     defm PDZ128 : avx512_fp14_p<opc, !strconcat(OpcodeStr, "pd"),
6946                                 OpNode, v2f64x_info>,
6947                                EVEX_V128, VEX_W, EVEX_CD8<64, CD8VF>;
6948     defm PDZ256 : avx512_fp14_p<opc, !strconcat(OpcodeStr, "pd"),
6949                                 OpNode, v4f64x_info>,
6950                                EVEX_V256, VEX_W, EVEX_CD8<64, CD8VF>;
6951   }
6952 }
6953
6954 defm VRSQRT14 : avx512_fp14_p_vl_all<0x4E, "vrsqrt14", X86frsqrt>;
6955 defm VRCP14 : avx512_fp14_p_vl_all<0x4C, "vrcp14", X86frcp>;
6956
6957 /// avx512_fp28_s rcp28ss, rcp28sd, rsqrt28ss, rsqrt28sd
6958 multiclass avx512_fp28_s<bits<8> opc, string OpcodeStr,X86VectorVTInfo _,
6959                          SDNode OpNode> {
6960   let ExeDomain = _.ExeDomain in {
6961   defm r : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6962                            (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
6963                            "$src2, $src1", "$src1, $src2",
6964                            (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
6965                            (i32 FROUND_CURRENT))>;
6966
6967   defm rb : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
6968                             (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
6969                             "{sae}, $src2, $src1", "$src1, $src2, {sae}",
6970                             (OpNode (_.VT _.RC:$src1), (_.VT _.RC:$src2),
6971                             (i32 FROUND_NO_EXC))>, EVEX_B;
6972
6973   defm m : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
6974                          (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
6975                          "$src2, $src1", "$src1, $src2",
6976                          (OpNode (_.VT _.RC:$src1),
6977                           (_.VT (scalar_to_vector (_.ScalarLdFrag addr:$src2))),
6978                          (i32 FROUND_CURRENT))>;
6979   }
6980 }
6981
6982 multiclass avx512_eri_s<bits<8> opc, string OpcodeStr, SDNode OpNode> {
6983   defm SS : avx512_fp28_s<opc, OpcodeStr#"ss", f32x_info, OpNode>,
6984               EVEX_CD8<32, CD8VT1>;
6985   defm SD : avx512_fp28_s<opc, OpcodeStr#"sd", f64x_info, OpNode>,
6986               EVEX_CD8<64, CD8VT1>, VEX_W;
6987 }
6988
6989 let Predicates = [HasERI] in {
6990   defm VRCP28   : avx512_eri_s<0xCB, "vrcp28",   X86rcp28s>,   T8PD, EVEX_4V;
6991   defm VRSQRT28 : avx512_eri_s<0xCD, "vrsqrt28", X86rsqrt28s>, T8PD, EVEX_4V;
6992 }
6993
6994 defm VGETEXP   : avx512_eri_s<0x43, "vgetexp", X86fgetexpRnds>, T8PD, EVEX_4V;
6995 /// avx512_fp28_p rcp28ps, rcp28pd, rsqrt28ps, rsqrt28pd
6996
6997 multiclass avx512_fp28_p<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
6998                          SDNode OpNode> {
6999   let ExeDomain = _.ExeDomain in {
7000   defm r : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
7001                          (ins _.RC:$src), OpcodeStr, "$src", "$src",
7002                          (OpNode (_.VT _.RC:$src), (i32 FROUND_CURRENT))>;
7003
7004   defm m : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
7005                          (ins _.MemOp:$src), OpcodeStr, "$src", "$src",
7006                          (OpNode (_.FloatVT
7007                              (bitconvert (_.LdFrag addr:$src))),
7008                           (i32 FROUND_CURRENT))>;
7009
7010   defm mb : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
7011                          (ins _.ScalarMemOp:$src), OpcodeStr,
7012                          "${src}"##_.BroadcastStr, "${src}"##_.BroadcastStr,
7013                          (OpNode (_.FloatVT
7014                                   (X86VBroadcast (_.ScalarLdFrag addr:$src))),
7015                                  (i32 FROUND_CURRENT))>, EVEX_B;
7016   }
7017 }
7018 multiclass avx512_fp28_p_round<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
7019                          SDNode OpNode> {
7020   let ExeDomain = _.ExeDomain in
7021   defm rb : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
7022                         (ins _.RC:$src), OpcodeStr,
7023                         "{sae}, $src", "$src, {sae}",
7024                         (OpNode (_.VT _.RC:$src), (i32 FROUND_NO_EXC))>, EVEX_B;
7025 }
7026
7027 multiclass  avx512_eri<bits<8> opc, string OpcodeStr, SDNode OpNode> {
7028    defm PS : avx512_fp28_p<opc, OpcodeStr#"ps", v16f32_info, OpNode>,
7029              avx512_fp28_p_round<opc, OpcodeStr#"ps", v16f32_info, OpNode>,
7030              T8PD, EVEX_V512, EVEX_CD8<32, CD8VF>;
7031    defm PD : avx512_fp28_p<opc, OpcodeStr#"pd", v8f64_info, OpNode>,
7032              avx512_fp28_p_round<opc, OpcodeStr#"pd", v8f64_info, OpNode>,
7033              T8PD, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VF>;
7034 }
7035
7036 multiclass avx512_fp_unaryop_packed<bits<8> opc, string OpcodeStr,
7037                                   SDNode OpNode> {
7038   // Define only if AVX512VL feature is present.
7039   let Predicates = [HasVLX] in {
7040     defm PSZ128 : avx512_fp28_p<opc, OpcodeStr#"ps", v4f32x_info, OpNode>,
7041                                      EVEX_V128, T8PD, EVEX_CD8<32, CD8VF>;
7042     defm PSZ256 : avx512_fp28_p<opc, OpcodeStr#"ps", v8f32x_info, OpNode>,
7043                                      EVEX_V256, T8PD, EVEX_CD8<32, CD8VF>;
7044     defm PDZ128 : avx512_fp28_p<opc, OpcodeStr#"pd", v2f64x_info, OpNode>,
7045                                      EVEX_V128, VEX_W, T8PD, EVEX_CD8<64, CD8VF>;
7046     defm PDZ256 : avx512_fp28_p<opc, OpcodeStr#"pd", v4f64x_info, OpNode>,
7047                                      EVEX_V256, VEX_W, T8PD, EVEX_CD8<64, CD8VF>;
7048   }
7049 }
7050 let Predicates = [HasERI] in {
7051
7052  defm VRSQRT28 : avx512_eri<0xCC, "vrsqrt28", X86rsqrt28>, EVEX;
7053  defm VRCP28   : avx512_eri<0xCA, "vrcp28",   X86rcp28>,   EVEX;
7054  defm VEXP2    : avx512_eri<0xC8, "vexp2",    X86exp2>,    EVEX;
7055 }
7056 defm VGETEXP   : avx512_eri<0x42, "vgetexp", X86fgetexpRnd>,
7057                  avx512_fp_unaryop_packed<0x42, "vgetexp", X86fgetexpRnd> , EVEX;
7058
7059 multiclass avx512_sqrt_packed_round<bits<8> opc, string OpcodeStr,
7060                               SDNode OpNodeRnd, X86VectorVTInfo _>{
7061   let ExeDomain = _.ExeDomain in
7062   defm rb: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
7063                          (ins _.RC:$src, AVX512RC:$rc), OpcodeStr, "$rc, $src", "$src, $rc",
7064                          (_.VT (OpNodeRnd _.RC:$src, (i32 imm:$rc)))>,
7065                          EVEX, EVEX_B, EVEX_RC;
7066 }
7067
7068 multiclass avx512_sqrt_packed<bits<8> opc, string OpcodeStr,
7069                               SDNode OpNode, X86VectorVTInfo _>{
7070   let ExeDomain = _.ExeDomain in {
7071   defm r: AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
7072                          (ins _.RC:$src), OpcodeStr, "$src", "$src",
7073                          (_.FloatVT (OpNode _.RC:$src))>, EVEX;
7074   defm m: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
7075                          (ins _.MemOp:$src), OpcodeStr, "$src", "$src",
7076                          (OpNode (_.FloatVT
7077                            (bitconvert (_.LdFrag addr:$src))))>, EVEX;
7078
7079   defm mb: AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
7080                           (ins _.ScalarMemOp:$src), OpcodeStr,
7081                           "${src}"##_.BroadcastStr, "${src}"##_.BroadcastStr,
7082                           (OpNode (_.FloatVT
7083                             (X86VBroadcast (_.ScalarLdFrag addr:$src))))>,
7084                           EVEX, EVEX_B;
7085   }
7086 }
7087
7088 multiclass avx512_sqrt_packed_all<bits<8> opc, string OpcodeStr,
7089                                   SDNode OpNode> {
7090   defm PSZ : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode,
7091                                 v16f32_info>,
7092                                 EVEX_V512, PS, EVEX_CD8<32, CD8VF>;
7093   defm PDZ : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode,
7094                                 v8f64_info>,
7095                                 EVEX_V512, VEX_W, PD, EVEX_CD8<64, CD8VF>;
7096   // Define only if AVX512VL feature is present.
7097   let Predicates = [HasVLX] in {
7098     defm PSZ128 : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "ps"),
7099                                      OpNode, v4f32x_info>,
7100                                      EVEX_V128, PS, EVEX_CD8<32, CD8VF>;
7101     defm PSZ256 : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "ps"),
7102                                      OpNode, v8f32x_info>,
7103                                      EVEX_V256, PS, EVEX_CD8<32, CD8VF>;
7104     defm PDZ128 : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "pd"),
7105                                      OpNode, v2f64x_info>,
7106                                      EVEX_V128, VEX_W, PD, EVEX_CD8<64, CD8VF>;
7107     defm PDZ256 : avx512_sqrt_packed<opc, !strconcat(OpcodeStr, "pd"),
7108                                      OpNode, v4f64x_info>,
7109                                      EVEX_V256, VEX_W, PD, EVEX_CD8<64, CD8VF>;
7110   }
7111 }
7112
7113 multiclass avx512_sqrt_packed_all_round<bits<8> opc, string OpcodeStr,
7114                                           SDNode OpNodeRnd> {
7115   defm PSZ : avx512_sqrt_packed_round<opc, !strconcat(OpcodeStr, "ps"), OpNodeRnd,
7116                                 v16f32_info>, EVEX_V512, PS, EVEX_CD8<32, CD8VF>;
7117   defm PDZ : avx512_sqrt_packed_round<opc, !strconcat(OpcodeStr, "pd"), OpNodeRnd,
7118                                 v8f64_info>, EVEX_V512, VEX_W, PD, EVEX_CD8<64, CD8VF>;
7119 }
7120
7121 multiclass avx512_sqrt_scalar<bits<8> opc, string OpcodeStr,X86VectorVTInfo _,
7122                               string SUFF, SDNode OpNode, SDNode OpNodeRnd> {
7123   let ExeDomain = _.ExeDomain in {
7124   defm r_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
7125                          (ins _.RC:$src1, _.RC:$src2), OpcodeStr,
7126                          "$src2, $src1", "$src1, $src2",
7127                          (OpNodeRnd (_.VT _.RC:$src1),
7128                                     (_.VT _.RC:$src2),
7129                                     (i32 FROUND_CURRENT))>;
7130   defm m_Int : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
7131                        (ins _.RC:$src1, _.ScalarMemOp:$src2), OpcodeStr,
7132                        "$src2, $src1", "$src1, $src2",
7133                        (OpNodeRnd (_.VT _.RC:$src1),
7134                                   (_.VT (scalar_to_vector
7135                                             (_.ScalarLdFrag addr:$src2))),
7136                                   (i32 FROUND_CURRENT))>;
7137
7138   defm rb_Int : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
7139                          (ins _.RC:$src1, _.RC:$src2, AVX512RC:$rc), OpcodeStr,
7140                          "$rc, $src2, $src1", "$src1, $src2, $rc",
7141                          (OpNodeRnd (_.VT _.RC:$src1),
7142                                      (_.VT _.RC:$src2),
7143                                      (i32 imm:$rc))>,
7144                          EVEX_B, EVEX_RC;
7145
7146   let isCodeGenOnly = 1, hasSideEffects = 0 in {
7147     def r : I<opc, MRMSrcReg, (outs _.FRC:$dst),
7148                (ins _.FRC:$src1, _.FRC:$src2),
7149                OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>;
7150
7151     let mayLoad = 1 in
7152       def m : I<opc, MRMSrcMem, (outs _.FRC:$dst),
7153                  (ins _.FRC:$src1, _.ScalarMemOp:$src2),
7154                  OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>;
7155   }
7156   }
7157
7158   def : Pat<(_.EltVT (OpNode _.FRC:$src)),
7159             (!cast<Instruction>(NAME#SUFF#Zr)
7160                 (_.EltVT (IMPLICIT_DEF)), _.FRC:$src)>;
7161
7162   def : Pat<(_.EltVT (OpNode (load addr:$src))),
7163             (!cast<Instruction>(NAME#SUFF#Zm)
7164                 (_.EltVT (IMPLICIT_DEF)), addr:$src)>, Requires<[HasAVX512, OptForSize]>;
7165 }
7166
7167 multiclass avx512_sqrt_scalar_all<bits<8> opc, string OpcodeStr> {
7168   defm SSZ : avx512_sqrt_scalar<opc, OpcodeStr#"ss", f32x_info, "SS", fsqrt,
7169                         X86fsqrtRnds>, EVEX_CD8<32, CD8VT1>, EVEX_4V, XS;
7170   defm SDZ : avx512_sqrt_scalar<opc, OpcodeStr#"sd", f64x_info, "SD", fsqrt,
7171                         X86fsqrtRnds>, EVEX_CD8<64, CD8VT1>, EVEX_4V, XD, VEX_W;
7172 }
7173
7174 defm VSQRT   : avx512_sqrt_packed_all<0x51, "vsqrt", fsqrt>,
7175                avx512_sqrt_packed_all_round<0x51, "vsqrt", X86fsqrtRnd>;
7176
7177 defm VSQRT   : avx512_sqrt_scalar_all<0x51, "vsqrt">, VEX_LIG;
7178
7179 let Predicates = [HasAVX512] in {
7180   def : Pat<(f32 (X86frsqrt FR32X:$src)),
7181             (COPY_TO_REGCLASS (VRSQRT14SSrr (v4f32 (IMPLICIT_DEF)), (COPY_TO_REGCLASS FR32X:$src, VR128X)), VR128X)>;
7182   def : Pat<(f32 (X86frsqrt (load addr:$src))),
7183             (COPY_TO_REGCLASS (VRSQRT14SSrm (v4f32 (IMPLICIT_DEF)), addr:$src), VR128X)>,
7184             Requires<[OptForSize]>;
7185   def : Pat<(f32 (X86frcp FR32X:$src)),
7186             (COPY_TO_REGCLASS (VRCP14SSrr (v4f32 (IMPLICIT_DEF)), (COPY_TO_REGCLASS FR32X:$src, VR128X)), VR128X )>;
7187   def : Pat<(f32 (X86frcp (load addr:$src))),
7188             (COPY_TO_REGCLASS (VRCP14SSrm (v4f32 (IMPLICIT_DEF)), addr:$src), VR128X)>,
7189             Requires<[OptForSize]>;
7190 }
7191
7192 multiclass
7193 avx512_rndscale_scalar<bits<8> opc, string OpcodeStr, X86VectorVTInfo _> {
7194
7195   let ExeDomain = _.ExeDomain in {
7196   defm r : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
7197                            (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3), OpcodeStr,
7198                            "$src3, $src2, $src1", "$src1, $src2, $src3",
7199                            (_.VT (X86RndScales (_.VT _.RC:$src1), (_.VT _.RC:$src2),
7200                             (i32 imm:$src3), (i32 FROUND_CURRENT)))>;
7201
7202   defm rb : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
7203                          (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3), OpcodeStr,
7204                          "$src3, {sae}, $src2, $src1", "$src1, $src2, {sae}, $src3",
7205                          (_.VT (X86RndScales (_.VT _.RC:$src1), (_.VT _.RC:$src2),
7206                          (i32 imm:$src3), (i32 FROUND_NO_EXC)))>, EVEX_B;
7207
7208   defm m : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
7209                          (ins _.RC:$src1, _.ScalarMemOp:$src2, i32u8imm:$src3),
7210                          OpcodeStr,
7211                          "$src3, $src2, $src1", "$src1, $src2, $src3",
7212                          (_.VT (X86RndScales (_.VT _.RC:$src1),
7213                           (_.VT (scalar_to_vector (_.ScalarLdFrag addr:$src2))),
7214                           (i32 imm:$src3), (i32 FROUND_CURRENT)))>;
7215   }
7216   let Predicates = [HasAVX512] in {
7217   def : Pat<(ffloor _.FRC:$src), (COPY_TO_REGCLASS
7218              (_.VT (!cast<Instruction>(NAME##r) (_.VT (IMPLICIT_DEF)),
7219              (_.VT (COPY_TO_REGCLASS _.FRC:$src, _.RC)), (i32 0x1))), _.FRC)>;
7220   def : Pat<(fceil _.FRC:$src), (COPY_TO_REGCLASS
7221              (_.VT (!cast<Instruction>(NAME##r) (_.VT (IMPLICIT_DEF)),
7222              (_.VT (COPY_TO_REGCLASS _.FRC:$src, _.RC)), (i32 0x2))), _.FRC)>;
7223   def : Pat<(ftrunc _.FRC:$src), (COPY_TO_REGCLASS
7224              (_.VT (!cast<Instruction>(NAME##r) (_.VT (IMPLICIT_DEF)),
7225              (_.VT (COPY_TO_REGCLASS _.FRC:$src, _.RC)), (i32 0x3))), _.FRC)>;
7226   def : Pat<(frint _.FRC:$src), (COPY_TO_REGCLASS
7227              (_.VT (!cast<Instruction>(NAME##r) (_.VT (IMPLICIT_DEF)),
7228              (_.VT (COPY_TO_REGCLASS _.FRC:$src, _.RC)), (i32 0x4))), _.FRC)>;
7229   def : Pat<(fnearbyint _.FRC:$src), (COPY_TO_REGCLASS
7230              (_.VT (!cast<Instruction>(NAME##r) (_.VT (IMPLICIT_DEF)),
7231              (_.VT (COPY_TO_REGCLASS _.FRC:$src, _.RC)), (i32 0xc))), _.FRC)>;
7232
7233   def : Pat<(ffloor (_.ScalarLdFrag addr:$src)), (COPY_TO_REGCLASS
7234              (_.VT (!cast<Instruction>(NAME##m) (_.VT (IMPLICIT_DEF)),
7235              addr:$src, (i32 0x1))), _.FRC)>;
7236   def : Pat<(fceil (_.ScalarLdFrag addr:$src)), (COPY_TO_REGCLASS
7237              (_.VT (!cast<Instruction>(NAME##m) (_.VT (IMPLICIT_DEF)),
7238              addr:$src, (i32 0x2))), _.FRC)>;
7239   def : Pat<(ftrunc (_.ScalarLdFrag addr:$src)), (COPY_TO_REGCLASS
7240              (_.VT (!cast<Instruction>(NAME##m) (_.VT (IMPLICIT_DEF)),
7241              addr:$src, (i32 0x3))), _.FRC)>;
7242   def : Pat<(frint (_.ScalarLdFrag addr:$src)), (COPY_TO_REGCLASS
7243              (_.VT (!cast<Instruction>(NAME##m) (_.VT (IMPLICIT_DEF)),
7244              addr:$src, (i32 0x4))), _.FRC)>;
7245   def : Pat<(fnearbyint (_.ScalarLdFrag addr:$src)), (COPY_TO_REGCLASS
7246              (_.VT (!cast<Instruction>(NAME##m) (_.VT (IMPLICIT_DEF)),
7247              addr:$src, (i32 0xc))), _.FRC)>;
7248   }
7249 }
7250
7251 defm VRNDSCALESS : avx512_rndscale_scalar<0x0A, "vrndscaless", f32x_info>,
7252                                 AVX512AIi8Base, EVEX_4V, EVEX_CD8<32, CD8VT1>;
7253
7254 defm VRNDSCALESD : avx512_rndscale_scalar<0x0B, "vrndscalesd", f64x_info>, VEX_W,
7255                                 AVX512AIi8Base, EVEX_4V, EVEX_CD8<64, CD8VT1>;
7256
7257 //-------------------------------------------------
7258 // Integer truncate and extend operations
7259 //-------------------------------------------------
7260
7261 multiclass avx512_trunc_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
7262                               X86VectorVTInfo SrcInfo, X86VectorVTInfo DestInfo,
7263                               X86MemOperand x86memop> {
7264   let ExeDomain = DestInfo.ExeDomain in
7265   defm rr  : AVX512_maskable<opc, MRMDestReg, DestInfo, (outs DestInfo.RC:$dst),
7266                       (ins SrcInfo.RC:$src1), OpcodeStr ,"$src1", "$src1",
7267                       (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1)))>,
7268                        EVEX, T8XS;
7269
7270   // for intrinsic patter match
7271   def : Pat<(DestInfo.VT (X86select DestInfo.KRCWM:$mask,
7272                            (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1))),
7273                            undef)),
7274             (!cast<Instruction>(NAME#SrcInfo.ZSuffix##rrkz) DestInfo.KRCWM:$mask ,
7275                                       SrcInfo.RC:$src1)>;
7276
7277   def : Pat<(DestInfo.VT (X86select DestInfo.KRCWM:$mask,
7278                            (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1))),
7279                            DestInfo.ImmAllZerosV)),
7280             (!cast<Instruction>(NAME#SrcInfo.ZSuffix##rrkz) DestInfo.KRCWM:$mask ,
7281                                       SrcInfo.RC:$src1)>;
7282
7283   def : Pat<(DestInfo.VT (X86select DestInfo.KRCWM:$mask,
7284                            (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1))),
7285                            DestInfo.RC:$src0)),
7286             (!cast<Instruction>(NAME#SrcInfo.ZSuffix##rrk) DestInfo.RC:$src0,
7287                                       DestInfo.KRCWM:$mask ,
7288                                       SrcInfo.RC:$src1)>;
7289
7290   let mayStore = 1, mayLoad = 1, hasSideEffects = 0,
7291       ExeDomain = DestInfo.ExeDomain in {
7292     def mr : AVX512XS8I<opc, MRMDestMem, (outs),
7293                (ins x86memop:$dst, SrcInfo.RC:$src),
7294                OpcodeStr # "\t{$src, $dst|$dst, $src}",
7295                []>, EVEX;
7296
7297     def mrk : AVX512XS8I<opc, MRMDestMem, (outs),
7298                (ins x86memop:$dst, SrcInfo.KRCWM:$mask, SrcInfo.RC:$src),
7299                OpcodeStr # "\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
7300                []>, EVEX, EVEX_K;
7301   }//mayStore = 1, mayLoad = 1, hasSideEffects = 0
7302 }
7303
7304 multiclass avx512_trunc_mr_lowering<X86VectorVTInfo SrcInfo,
7305                                     X86VectorVTInfo DestInfo,
7306                                     PatFrag truncFrag, PatFrag mtruncFrag > {
7307
7308   def : Pat<(truncFrag (SrcInfo.VT SrcInfo.RC:$src), addr:$dst),
7309             (!cast<Instruction>(NAME#SrcInfo.ZSuffix##mr)
7310                                     addr:$dst, SrcInfo.RC:$src)>;
7311
7312   def : Pat<(mtruncFrag addr:$dst, SrcInfo.KRCWM:$mask,
7313                                                (SrcInfo.VT SrcInfo.RC:$src)),
7314             (!cast<Instruction>(NAME#SrcInfo.ZSuffix##mrk)
7315                             addr:$dst, SrcInfo.KRCWM:$mask, SrcInfo.RC:$src)>;
7316 }
7317
7318 multiclass avx512_trunc<bits<8> opc, string OpcodeStr, SDNode OpNode,
7319          AVX512VLVectorVTInfo VTSrcInfo, X86VectorVTInfo DestInfoZ128,
7320          X86VectorVTInfo DestInfoZ256, X86VectorVTInfo DestInfoZ,
7321          X86MemOperand x86memopZ128, X86MemOperand x86memopZ256,
7322          X86MemOperand x86memopZ, PatFrag truncFrag, PatFrag mtruncFrag,
7323                                                      Predicate prd = HasAVX512>{
7324
7325   let Predicates = [HasVLX, prd] in {
7326     defm Z128:  avx512_trunc_common<opc, OpcodeStr, OpNode, VTSrcInfo.info128,
7327                              DestInfoZ128, x86memopZ128>,
7328                 avx512_trunc_mr_lowering<VTSrcInfo.info128, DestInfoZ128,
7329                              truncFrag, mtruncFrag>, EVEX_V128;
7330
7331     defm Z256:  avx512_trunc_common<opc, OpcodeStr, OpNode, VTSrcInfo.info256,
7332                              DestInfoZ256, x86memopZ256>,
7333                 avx512_trunc_mr_lowering<VTSrcInfo.info256, DestInfoZ256,
7334                              truncFrag, mtruncFrag>, EVEX_V256;
7335   }
7336   let Predicates = [prd] in
7337     defm Z:     avx512_trunc_common<opc, OpcodeStr, OpNode, VTSrcInfo.info512,
7338                              DestInfoZ, x86memopZ>,
7339                 avx512_trunc_mr_lowering<VTSrcInfo.info512, DestInfoZ,
7340                              truncFrag, mtruncFrag>, EVEX_V512;
7341 }
7342
7343 multiclass avx512_trunc_qb<bits<8> opc, string OpcodeStr, SDNode OpNode,
7344                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7345   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i64_info,
7346                v16i8x_info, v16i8x_info, v16i8x_info, i16mem, i32mem, i64mem,
7347                StoreNode, MaskedStoreNode>, EVEX_CD8<8, CD8VO>;
7348 }
7349
7350 multiclass avx512_trunc_qw<bits<8> opc, string OpcodeStr, SDNode OpNode,
7351                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7352   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i64_info,
7353                v8i16x_info, v8i16x_info, v8i16x_info, i32mem, i64mem, i128mem,
7354                StoreNode, MaskedStoreNode>, EVEX_CD8<16, CD8VQ>;
7355 }
7356
7357 multiclass avx512_trunc_qd<bits<8> opc, string OpcodeStr, SDNode OpNode,
7358                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7359   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i64_info,
7360                v4i32x_info, v4i32x_info, v8i32x_info, i64mem, i128mem, i256mem,
7361                StoreNode, MaskedStoreNode>, EVEX_CD8<32, CD8VH>;
7362 }
7363
7364 multiclass avx512_trunc_db<bits<8> opc, string OpcodeStr, SDNode OpNode,
7365                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7366   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i32_info,
7367                v16i8x_info, v16i8x_info, v16i8x_info, i32mem, i64mem, i128mem,
7368                StoreNode, MaskedStoreNode>, EVEX_CD8<8, CD8VQ>;
7369 }
7370
7371 multiclass avx512_trunc_dw<bits<8> opc, string OpcodeStr, SDNode OpNode,
7372                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7373   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i32_info,
7374               v8i16x_info, v8i16x_info, v16i16x_info, i64mem, i128mem, i256mem,
7375               StoreNode, MaskedStoreNode>, EVEX_CD8<16, CD8VH>;
7376 }
7377
7378 multiclass avx512_trunc_wb<bits<8> opc, string OpcodeStr, SDNode OpNode,
7379                            PatFrag StoreNode, PatFrag MaskedStoreNode> {
7380   defm NAME: avx512_trunc<opc, OpcodeStr, OpNode, avx512vl_i16_info,
7381               v16i8x_info, v16i8x_info, v32i8x_info, i64mem, i128mem, i256mem,
7382               StoreNode, MaskedStoreNode, HasBWI>, EVEX_CD8<16, CD8VH>;
7383 }
7384
7385 defm VPMOVQB    : avx512_trunc_qb<0x32, "vpmovqb",   X86vtrunc,
7386                                   truncstorevi8, masked_truncstorevi8>;
7387 defm VPMOVSQB   : avx512_trunc_qb<0x22, "vpmovsqb",  X86vtruncs,
7388                                   truncstore_s_vi8, masked_truncstore_s_vi8>;
7389 defm VPMOVUSQB  : avx512_trunc_qb<0x12, "vpmovusqb", X86vtruncus,
7390                                   truncstore_us_vi8, masked_truncstore_us_vi8>;
7391
7392 defm VPMOVQW    : avx512_trunc_qw<0x34, "vpmovqw",   X86vtrunc,
7393                                   truncstorevi16, masked_truncstorevi16>;
7394 defm VPMOVSQW   : avx512_trunc_qw<0x24, "vpmovsqw",  X86vtruncs,
7395                                   truncstore_s_vi16, masked_truncstore_s_vi16>;
7396 defm VPMOVUSQW  : avx512_trunc_qw<0x14, "vpmovusqw", X86vtruncus,
7397                                   truncstore_us_vi16, masked_truncstore_us_vi16>;
7398
7399 defm VPMOVQD    : avx512_trunc_qd<0x35, "vpmovqd",   X86vtrunc,
7400                                   truncstorevi32, masked_truncstorevi32>;
7401 defm VPMOVSQD   : avx512_trunc_qd<0x25, "vpmovsqd",  X86vtruncs,
7402                                   truncstore_s_vi32, masked_truncstore_s_vi32>;
7403 defm VPMOVUSQD  : avx512_trunc_qd<0x15, "vpmovusqd", X86vtruncus,
7404                                   truncstore_us_vi32, masked_truncstore_us_vi32>;
7405
7406 defm VPMOVDB    : avx512_trunc_db<0x31, "vpmovdb", X86vtrunc,
7407                                   truncstorevi8, masked_truncstorevi8>;
7408 defm VPMOVSDB   : avx512_trunc_db<0x21, "vpmovsdb",   X86vtruncs,
7409                                   truncstore_s_vi8, masked_truncstore_s_vi8>;
7410 defm VPMOVUSDB  : avx512_trunc_db<0x11, "vpmovusdb",  X86vtruncus,
7411                                   truncstore_us_vi8, masked_truncstore_us_vi8>;
7412
7413 defm VPMOVDW    : avx512_trunc_dw<0x33, "vpmovdw", X86vtrunc,
7414                                   truncstorevi16, masked_truncstorevi16>;
7415 defm VPMOVSDW   : avx512_trunc_dw<0x23, "vpmovsdw",   X86vtruncs,
7416                                   truncstore_s_vi16, masked_truncstore_s_vi16>;
7417 defm VPMOVUSDW  : avx512_trunc_dw<0x13, "vpmovusdw",  X86vtruncus,
7418                                   truncstore_us_vi16, masked_truncstore_us_vi16>;
7419
7420 defm VPMOVWB    : avx512_trunc_wb<0x30, "vpmovwb", X86vtrunc,
7421                                   truncstorevi8, masked_truncstorevi8>;
7422 defm VPMOVSWB   : avx512_trunc_wb<0x20, "vpmovswb",   X86vtruncs,
7423                                   truncstore_s_vi8, masked_truncstore_s_vi8>;
7424 defm VPMOVUSWB  : avx512_trunc_wb<0x10, "vpmovuswb",  X86vtruncus,
7425                                   truncstore_us_vi8, masked_truncstore_us_vi8>;
7426
7427 let Predicates = [HasAVX512, NoVLX] in {
7428 def: Pat<(v8i16 (X86vtrunc (v8i32 VR256X:$src))),
7429          (v8i16 (EXTRACT_SUBREG
7430                  (v16i16 (VPMOVDWZrr (v16i32 (INSERT_SUBREG (IMPLICIT_DEF),
7431                                           VR256X:$src, sub_ymm)))), sub_xmm))>;
7432 def: Pat<(v4i32 (X86vtrunc (v4i64 VR256X:$src))),
7433          (v4i32 (EXTRACT_SUBREG
7434                  (v8i32 (VPMOVQDZrr (v8i64 (INSERT_SUBREG (IMPLICIT_DEF),
7435                                            VR256X:$src, sub_ymm)))), sub_xmm))>;
7436 }
7437
7438 let Predicates = [HasBWI, NoVLX] in {
7439 def: Pat<(v16i8 (X86vtrunc (v16i16 VR256X:$src))),
7440          (v16i8 (EXTRACT_SUBREG (VPMOVWBZrr (v32i16 (INSERT_SUBREG (IMPLICIT_DEF),
7441                                             VR256X:$src, sub_ymm))), sub_xmm))>;
7442 }
7443
7444 multiclass avx512_extend_common<bits<8> opc, string OpcodeStr,
7445               X86VectorVTInfo DestInfo, X86VectorVTInfo SrcInfo,
7446               X86MemOperand x86memop, PatFrag LdFrag, SDPatternOperator OpNode>{
7447   let ExeDomain = DestInfo.ExeDomain in {
7448   defm rr   : AVX512_maskable<opc, MRMSrcReg, DestInfo, (outs DestInfo.RC:$dst),
7449                     (ins SrcInfo.RC:$src), OpcodeStr ,"$src", "$src",
7450                     (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src)))>,
7451                   EVEX;
7452
7453   defm rm : AVX512_maskable<opc, MRMSrcMem, DestInfo, (outs DestInfo.RC:$dst),
7454                   (ins x86memop:$src), OpcodeStr ,"$src", "$src",
7455                   (DestInfo.VT (LdFrag addr:$src))>,
7456                 EVEX;
7457   }
7458 }
7459
7460 multiclass avx512_extend_BW<bits<8> opc, string OpcodeStr,
7461           SDPatternOperator OpNode, SDPatternOperator InVecNode,
7462           string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi8")> {
7463   let Predicates = [HasVLX, HasBWI] in {
7464     defm Z128:  avx512_extend_common<opc, OpcodeStr, v8i16x_info,
7465                     v16i8x_info, i64mem, LdFrag, InVecNode>,
7466                      EVEX_CD8<8, CD8VH>, T8PD, EVEX_V128;
7467
7468     defm Z256:  avx512_extend_common<opc, OpcodeStr, v16i16x_info,
7469                     v16i8x_info, i128mem, LdFrag, OpNode>,
7470                      EVEX_CD8<8, CD8VH>, T8PD, EVEX_V256;
7471   }
7472   let Predicates = [HasBWI] in {
7473     defm Z   :  avx512_extend_common<opc, OpcodeStr, v32i16_info,
7474                     v32i8x_info, i256mem, LdFrag, OpNode>,
7475                      EVEX_CD8<8, CD8VH>, T8PD, EVEX_V512;
7476   }
7477 }
7478
7479 multiclass avx512_extend_BD<bits<8> opc, string OpcodeStr,
7480           SDPatternOperator OpNode, SDPatternOperator InVecNode,
7481           string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi8")> {
7482   let Predicates = [HasVLX, HasAVX512] in {
7483     defm Z128:  avx512_extend_common<opc, OpcodeStr, v4i32x_info,
7484                    v16i8x_info, i32mem, LdFrag, InVecNode>,
7485                          EVEX_CD8<8, CD8VQ>, T8PD, EVEX_V128;
7486
7487     defm Z256:  avx512_extend_common<opc, OpcodeStr, v8i32x_info,
7488                    v16i8x_info, i64mem, LdFrag, OpNode>,
7489                          EVEX_CD8<8, CD8VQ>, T8PD, EVEX_V256;
7490   }
7491   let Predicates = [HasAVX512] in {
7492     defm Z   :  avx512_extend_common<opc, OpcodeStr, v16i32_info,
7493                    v16i8x_info, i128mem, LdFrag, OpNode>,
7494                          EVEX_CD8<8, CD8VQ>, T8PD, EVEX_V512;
7495   }
7496 }
7497
7498 multiclass avx512_extend_BQ<bits<8> opc, string OpcodeStr,
7499           SDPatternOperator OpNode, SDPatternOperator InVecNode,
7500           string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi8")> {
7501   let Predicates = [HasVLX, HasAVX512] in {
7502     defm Z128:  avx512_extend_common<opc, OpcodeStr, v2i64x_info,
7503                    v16i8x_info, i16mem, LdFrag, InVecNode>,
7504                      EVEX_CD8<8, CD8VO>, T8PD, EVEX_V128;
7505
7506     defm Z256:  avx512_extend_common<opc, OpcodeStr, v4i64x_info,
7507                    v16i8x_info, i32mem, LdFrag, OpNode>,
7508                      EVEX_CD8<8, CD8VO>, T8PD, EVEX_V256;
7509   }
7510   let Predicates = [HasAVX512] in {
7511     defm Z   :  avx512_extend_common<opc, OpcodeStr, v8i64_info,
7512                    v16i8x_info, i64mem, LdFrag, OpNode>,
7513                      EVEX_CD8<8, CD8VO>, T8PD, EVEX_V512;
7514   }
7515 }
7516
7517 multiclass avx512_extend_WD<bits<8> opc, string OpcodeStr,
7518          SDPatternOperator OpNode, SDPatternOperator InVecNode,
7519          string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi16")> {
7520   let Predicates = [HasVLX, HasAVX512] in {
7521     defm Z128:  avx512_extend_common<opc, OpcodeStr, v4i32x_info,
7522                    v8i16x_info, i64mem, LdFrag, InVecNode>,
7523                      EVEX_CD8<16, CD8VH>, T8PD, EVEX_V128;
7524
7525     defm Z256:  avx512_extend_common<opc, OpcodeStr, v8i32x_info,
7526                    v8i16x_info, i128mem, LdFrag, OpNode>,
7527                      EVEX_CD8<16, CD8VH>, T8PD, EVEX_V256;
7528   }
7529   let Predicates = [HasAVX512] in {
7530     defm Z   :  avx512_extend_common<opc, OpcodeStr, v16i32_info,
7531                    v16i16x_info, i256mem, LdFrag, OpNode>,
7532                      EVEX_CD8<16, CD8VH>, T8PD, EVEX_V512;
7533   }
7534 }
7535
7536 multiclass avx512_extend_WQ<bits<8> opc, string OpcodeStr,
7537          SDPatternOperator OpNode, SDPatternOperator InVecNode,
7538          string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi16")> {
7539   let Predicates = [HasVLX, HasAVX512] in {
7540     defm Z128:  avx512_extend_common<opc, OpcodeStr, v2i64x_info,
7541                    v8i16x_info, i32mem, LdFrag, InVecNode>,
7542                      EVEX_CD8<16, CD8VQ>, T8PD, EVEX_V128;
7543
7544     defm Z256:  avx512_extend_common<opc, OpcodeStr, v4i64x_info,
7545                    v8i16x_info, i64mem, LdFrag, OpNode>,
7546                      EVEX_CD8<16, CD8VQ>, T8PD, EVEX_V256;
7547   }
7548   let Predicates = [HasAVX512] in {
7549     defm Z   :  avx512_extend_common<opc, OpcodeStr, v8i64_info,
7550                    v8i16x_info, i128mem, LdFrag, OpNode>,
7551                      EVEX_CD8<16, CD8VQ>, T8PD, EVEX_V512;
7552   }
7553 }
7554
7555 multiclass avx512_extend_DQ<bits<8> opc, string OpcodeStr,
7556          SDPatternOperator OpNode, SDPatternOperator InVecNode,
7557          string ExtTy,PatFrag LdFrag = !cast<PatFrag>(ExtTy#"extloadvi32")> {
7558
7559   let Predicates = [HasVLX, HasAVX512] in {
7560     defm Z128:  avx512_extend_common<opc, OpcodeStr, v2i64x_info,
7561                    v4i32x_info, i64mem, LdFrag, InVecNode>,
7562                      EVEX_CD8<32, CD8VH>, T8PD, EVEX_V128;
7563
7564     defm Z256:  avx512_extend_common<opc, OpcodeStr, v4i64x_info,
7565                    v4i32x_info, i128mem, LdFrag, OpNode>,
7566                      EVEX_CD8<32, CD8VH>, T8PD, EVEX_V256;
7567   }
7568   let Predicates = [HasAVX512] in {
7569     defm Z   :  avx512_extend_common<opc, OpcodeStr, v8i64_info,
7570                    v8i32x_info, i256mem, LdFrag, OpNode>,
7571                      EVEX_CD8<32, CD8VH>, T8PD, EVEX_V512;
7572   }
7573 }
7574
7575 defm VPMOVZXBW : avx512_extend_BW<0x30, "vpmovzxbw", X86vzext, zext_invec, "z">;
7576 defm VPMOVZXBD : avx512_extend_BD<0x31, "vpmovzxbd", X86vzext, zext_invec, "z">;
7577 defm VPMOVZXBQ : avx512_extend_BQ<0x32, "vpmovzxbq", X86vzext, zext_invec, "z">;
7578 defm VPMOVZXWD : avx512_extend_WD<0x33, "vpmovzxwd", X86vzext, zext_invec, "z">;
7579 defm VPMOVZXWQ : avx512_extend_WQ<0x34, "vpmovzxwq", X86vzext, zext_invec, "z">;
7580 defm VPMOVZXDQ : avx512_extend_DQ<0x35, "vpmovzxdq", X86vzext, zext_invec, "z">;
7581
7582 defm VPMOVSXBW: avx512_extend_BW<0x20, "vpmovsxbw", X86vsext, sext_invec, "s">;
7583 defm VPMOVSXBD: avx512_extend_BD<0x21, "vpmovsxbd", X86vsext, sext_invec, "s">;
7584 defm VPMOVSXBQ: avx512_extend_BQ<0x22, "vpmovsxbq", X86vsext, sext_invec, "s">;
7585 defm VPMOVSXWD: avx512_extend_WD<0x23, "vpmovsxwd", X86vsext, sext_invec, "s">;
7586 defm VPMOVSXWQ: avx512_extend_WQ<0x24, "vpmovsxwq", X86vsext, sext_invec, "s">;
7587 defm VPMOVSXDQ: avx512_extend_DQ<0x25, "vpmovsxdq", X86vsext, sext_invec, "s">;
7588
7589 // EXTLOAD patterns, implemented using vpmovz
7590 multiclass avx512_ext_lowering<string InstrStr, X86VectorVTInfo To,
7591                                X86VectorVTInfo From, PatFrag LdFrag> {
7592   def : Pat<(To.VT (LdFrag addr:$src)),
7593             (!cast<Instruction>("VPMOVZX"#InstrStr#"rm") addr:$src)>;
7594   def : Pat<(To.VT (vselect To.KRCWM:$mask, (LdFrag addr:$src), To.RC:$src0)),
7595             (!cast<Instruction>("VPMOVZX"#InstrStr#"rmk") To.RC:$src0,
7596              To.KRC:$mask, addr:$src)>;
7597   def : Pat<(To.VT (vselect To.KRCWM:$mask, (LdFrag addr:$src),
7598                     To.ImmAllZerosV)),
7599             (!cast<Instruction>("VPMOVZX"#InstrStr#"rmkz") To.KRC:$mask,
7600              addr:$src)>;
7601 }
7602
7603 let Predicates = [HasVLX, HasBWI] in {
7604   defm : avx512_ext_lowering<"BWZ128", v8i16x_info,  v16i8x_info,  extloadvi8>;
7605   defm : avx512_ext_lowering<"BWZ256", v16i16x_info, v16i8x_info,  extloadvi8>;
7606 }
7607 let Predicates = [HasBWI] in {
7608   defm : avx512_ext_lowering<"BWZ",    v32i16_info,  v32i8x_info,  extloadvi8>;
7609 }
7610 let Predicates = [HasVLX, HasAVX512] in {
7611   defm : avx512_ext_lowering<"BDZ128", v4i32x_info,  v16i8x_info,  extloadvi8>;
7612   defm : avx512_ext_lowering<"BDZ256", v8i32x_info,  v16i8x_info,  extloadvi8>;
7613   defm : avx512_ext_lowering<"BQZ128", v2i64x_info,  v16i8x_info,  extloadvi8>;
7614   defm : avx512_ext_lowering<"BQZ256", v4i64x_info,  v16i8x_info,  extloadvi8>;
7615   defm : avx512_ext_lowering<"WDZ128", v4i32x_info,  v8i16x_info,  extloadvi16>;
7616   defm : avx512_ext_lowering<"WDZ256", v8i32x_info,  v8i16x_info,  extloadvi16>;
7617   defm : avx512_ext_lowering<"WQZ128", v2i64x_info,  v8i16x_info,  extloadvi16>;
7618   defm : avx512_ext_lowering<"WQZ256", v4i64x_info,  v8i16x_info,  extloadvi16>;
7619   defm : avx512_ext_lowering<"DQZ128", v2i64x_info,  v4i32x_info,  extloadvi32>;
7620   defm : avx512_ext_lowering<"DQZ256", v4i64x_info,  v4i32x_info,  extloadvi32>;
7621 }
7622 let Predicates = [HasAVX512] in {
7623   defm : avx512_ext_lowering<"BDZ",    v16i32_info,  v16i8x_info,  extloadvi8>;
7624   defm : avx512_ext_lowering<"BQZ",    v8i64_info,   v16i8x_info,  extloadvi8>;
7625   defm : avx512_ext_lowering<"WDZ",    v16i32_info,  v16i16x_info, extloadvi16>;
7626   defm : avx512_ext_lowering<"WQZ",    v8i64_info,   v8i16x_info,  extloadvi16>;
7627   defm : avx512_ext_lowering<"DQZ",    v8i64_info,   v8i32x_info,  extloadvi32>;
7628 }
7629
7630 multiclass AVX512_pmovx_patterns<string OpcPrefix, SDNode ExtOp,
7631                                  SDNode InVecOp, PatFrag ExtLoad16> {
7632   // 128-bit patterns
7633   let Predicates = [HasVLX, HasBWI] in {
7634   def : Pat<(v8i16 (InVecOp (bc_v16i8 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7635             (!cast<I>(OpcPrefix#BWZ128rm) addr:$src)>;
7636   def : Pat<(v8i16 (InVecOp (bc_v16i8 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
7637             (!cast<I>(OpcPrefix#BWZ128rm) addr:$src)>;
7638   def : Pat<(v8i16 (InVecOp (v16i8 (vzmovl_v2i64 addr:$src)))),
7639             (!cast<I>(OpcPrefix#BWZ128rm) addr:$src)>;
7640   def : Pat<(v8i16 (InVecOp (v16i8 (vzload_v2i64 addr:$src)))),
7641             (!cast<I>(OpcPrefix#BWZ128rm) addr:$src)>;
7642   def : Pat<(v8i16 (InVecOp (bc_v16i8 (loadv2i64 addr:$src)))),
7643             (!cast<I>(OpcPrefix#BWZ128rm) addr:$src)>;
7644   }
7645   let Predicates = [HasVLX] in {
7646   def : Pat<(v4i32 (InVecOp (bc_v16i8 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
7647             (!cast<I>(OpcPrefix#BDZ128rm) addr:$src)>;
7648   def : Pat<(v4i32 (InVecOp (v16i8 (vzmovl_v4i32 addr:$src)))),
7649             (!cast<I>(OpcPrefix#BDZ128rm) addr:$src)>;
7650   def : Pat<(v4i32 (InVecOp (v16i8 (vzload_v2i64 addr:$src)))),
7651             (!cast<I>(OpcPrefix#BDZ128rm) addr:$src)>;
7652   def : Pat<(v4i32 (InVecOp (bc_v16i8 (loadv2i64 addr:$src)))),
7653             (!cast<I>(OpcPrefix#BDZ128rm) addr:$src)>;
7654
7655   def : Pat<(v2i64 (InVecOp (bc_v16i8 (v4i32 (scalar_to_vector (ExtLoad16 addr:$src)))))),
7656             (!cast<I>(OpcPrefix#BQZ128rm) addr:$src)>;
7657   def : Pat<(v2i64 (InVecOp (v16i8 (vzmovl_v4i32 addr:$src)))),
7658             (!cast<I>(OpcPrefix#BQZ128rm) addr:$src)>;
7659   def : Pat<(v2i64 (InVecOp (v16i8 (vzload_v2i64 addr:$src)))),
7660             (!cast<I>(OpcPrefix#BQZ128rm) addr:$src)>;
7661   def : Pat<(v2i64 (InVecOp (bc_v16i8 (loadv2i64 addr:$src)))),
7662             (!cast<I>(OpcPrefix#BQZ128rm) addr:$src)>;
7663
7664   def : Pat<(v4i32 (InVecOp (bc_v8i16 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7665             (!cast<I>(OpcPrefix#WDZ128rm) addr:$src)>;
7666   def : Pat<(v4i32 (InVecOp (bc_v8i16 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
7667             (!cast<I>(OpcPrefix#WDZ128rm) addr:$src)>;
7668   def : Pat<(v4i32 (InVecOp (v8i16 (vzmovl_v2i64 addr:$src)))),
7669             (!cast<I>(OpcPrefix#WDZ128rm) addr:$src)>;
7670   def : Pat<(v4i32 (InVecOp (v8i16 (vzload_v2i64 addr:$src)))),
7671             (!cast<I>(OpcPrefix#WDZ128rm) addr:$src)>;
7672   def : Pat<(v4i32 (InVecOp (bc_v8i16 (loadv2i64 addr:$src)))),
7673             (!cast<I>(OpcPrefix#WDZ128rm) addr:$src)>;
7674
7675   def : Pat<(v2i64 (InVecOp (bc_v8i16 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
7676             (!cast<I>(OpcPrefix#WQZ128rm) addr:$src)>;
7677   def : Pat<(v2i64 (InVecOp (v8i16 (vzmovl_v4i32 addr:$src)))),
7678             (!cast<I>(OpcPrefix#WQZ128rm) addr:$src)>;
7679   def : Pat<(v2i64 (InVecOp (v8i16 (vzload_v2i64 addr:$src)))),
7680             (!cast<I>(OpcPrefix#WQZ128rm) addr:$src)>;
7681   def : Pat<(v2i64 (InVecOp (bc_v8i16 (loadv2i64 addr:$src)))),
7682             (!cast<I>(OpcPrefix#WQZ128rm) addr:$src)>;
7683
7684   def : Pat<(v2i64 (InVecOp (bc_v4i32 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7685             (!cast<I>(OpcPrefix#DQZ128rm) addr:$src)>;
7686   def : Pat<(v2i64 (InVecOp (bc_v4i32 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
7687             (!cast<I>(OpcPrefix#DQZ128rm) addr:$src)>;
7688   def : Pat<(v2i64 (InVecOp (v4i32 (vzmovl_v2i64 addr:$src)))),
7689             (!cast<I>(OpcPrefix#DQZ128rm) addr:$src)>;
7690   def : Pat<(v2i64 (InVecOp (v4i32 (vzload_v2i64 addr:$src)))),
7691             (!cast<I>(OpcPrefix#DQZ128rm) addr:$src)>;
7692   def : Pat<(v2i64 (InVecOp (bc_v4i32 (loadv2i64 addr:$src)))),
7693             (!cast<I>(OpcPrefix#DQZ128rm) addr:$src)>;
7694   }
7695   // 256-bit patterns
7696   let Predicates = [HasVLX, HasBWI] in {
7697   def : Pat<(v16i16 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
7698             (!cast<I>(OpcPrefix#BWZ256rm) addr:$src)>;
7699   def : Pat<(v16i16 (ExtOp (v16i8 (vzmovl_v2i64 addr:$src)))),
7700             (!cast<I>(OpcPrefix#BWZ256rm) addr:$src)>;
7701   def : Pat<(v16i16 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
7702             (!cast<I>(OpcPrefix#BWZ256rm) addr:$src)>;
7703   }
7704   let Predicates = [HasVLX] in {
7705   def : Pat<(v8i32 (ExtOp (bc_v16i8 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7706             (!cast<I>(OpcPrefix#BDZ256rm) addr:$src)>;
7707   def : Pat<(v8i32 (ExtOp (v16i8 (vzmovl_v2i64 addr:$src)))),
7708             (!cast<I>(OpcPrefix#BDZ256rm) addr:$src)>;
7709   def : Pat<(v8i32 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
7710             (!cast<I>(OpcPrefix#BDZ256rm) addr:$src)>;
7711   def : Pat<(v8i32 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
7712             (!cast<I>(OpcPrefix#BDZ256rm) addr:$src)>;
7713
7714   def : Pat<(v4i64 (ExtOp (bc_v16i8 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
7715             (!cast<I>(OpcPrefix#BQZ256rm) addr:$src)>;
7716   def : Pat<(v4i64 (ExtOp (v16i8 (vzmovl_v4i32 addr:$src)))),
7717             (!cast<I>(OpcPrefix#BQZ256rm) addr:$src)>;
7718   def : Pat<(v4i64 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
7719             (!cast<I>(OpcPrefix#BQZ256rm) addr:$src)>;
7720   def : Pat<(v4i64 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
7721             (!cast<I>(OpcPrefix#BQZ256rm) addr:$src)>;
7722
7723   def : Pat<(v8i32 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
7724             (!cast<I>(OpcPrefix#WDZ256rm) addr:$src)>;
7725   def : Pat<(v8i32 (ExtOp (v8i16 (vzmovl_v2i64 addr:$src)))),
7726             (!cast<I>(OpcPrefix#WDZ256rm) addr:$src)>;
7727   def : Pat<(v8i32 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
7728             (!cast<I>(OpcPrefix#WDZ256rm) addr:$src)>;
7729
7730   def : Pat<(v4i64 (ExtOp (bc_v8i16 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7731             (!cast<I>(OpcPrefix#WQZ256rm) addr:$src)>;
7732   def : Pat<(v4i64 (ExtOp (v8i16 (vzmovl_v2i64 addr:$src)))),
7733             (!cast<I>(OpcPrefix#WQZ256rm) addr:$src)>;
7734   def : Pat<(v4i64 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
7735             (!cast<I>(OpcPrefix#WQZ256rm) addr:$src)>;
7736   def : Pat<(v4i64 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
7737             (!cast<I>(OpcPrefix#WQZ256rm) addr:$src)>;
7738
7739   def : Pat<(v4i64 (ExtOp (bc_v4i32 (loadv2i64 addr:$src)))),
7740             (!cast<I>(OpcPrefix#DQZ256rm) addr:$src)>;
7741   def : Pat<(v4i64 (ExtOp (v4i32 (vzmovl_v2i64 addr:$src)))),
7742             (!cast<I>(OpcPrefix#DQZ256rm) addr:$src)>;
7743   def : Pat<(v4i64 (ExtOp (v4i32 (vzload_v2i64 addr:$src)))),
7744             (!cast<I>(OpcPrefix#DQZ256rm) addr:$src)>;
7745   }
7746   // 512-bit patterns
7747   let Predicates = [HasBWI] in {
7748   def : Pat<(v32i16 (ExtOp (bc_v32i8 (loadv4i64 addr:$src)))),
7749             (!cast<I>(OpcPrefix#BWZrm) addr:$src)>;
7750   }
7751   let Predicates = [HasAVX512] in {
7752   def : Pat<(v16i32 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
7753             (!cast<I>(OpcPrefix#BDZrm) addr:$src)>;
7754
7755   def : Pat<(v8i64 (ExtOp (bc_v16i8 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
7756             (!cast<I>(OpcPrefix#BQZrm) addr:$src)>;
7757   def : Pat<(v8i64 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
7758             (!cast<I>(OpcPrefix#BQZrm) addr:$src)>;
7759
7760   def : Pat<(v16i32 (ExtOp (bc_v16i16 (loadv4i64 addr:$src)))),
7761             (!cast<I>(OpcPrefix#WDZrm) addr:$src)>;
7762
7763   def : Pat<(v8i64 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
7764             (!cast<I>(OpcPrefix#WQZrm) addr:$src)>;
7765
7766   def : Pat<(v8i64 (ExtOp (bc_v8i32 (loadv4i64 addr:$src)))),
7767             (!cast<I>(OpcPrefix#DQZrm) addr:$src)>;
7768   }
7769 }
7770
7771 defm : AVX512_pmovx_patterns<"VPMOVSX", X86vsext, sext_invec, extloadi32i16>;
7772 defm : AVX512_pmovx_patterns<"VPMOVZX", X86vzext, zext_invec, loadi16_anyext>;
7773
7774 //===----------------------------------------------------------------------===//
7775 // GATHER - SCATTER Operations
7776
7777 multiclass avx512_gather<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
7778                          X86MemOperand memop, PatFrag GatherNode> {
7779   let Constraints = "@earlyclobber $dst, $src1 = $dst, $mask = $mask_wb",
7780       ExeDomain = _.ExeDomain in
7781   def rm  : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst, _.KRCWM:$mask_wb),
7782             (ins _.RC:$src1, _.KRCWM:$mask, memop:$src2),
7783             !strconcat(OpcodeStr#_.Suffix,
7784             "\t{$src2, ${dst} {${mask}}|${dst} {${mask}}, $src2}"),
7785             [(set _.RC:$dst, _.KRCWM:$mask_wb,
7786               (GatherNode  (_.VT _.RC:$src1), _.KRCWM:$mask,
7787                      vectoraddr:$src2))]>, EVEX, EVEX_K,
7788              EVEX_CD8<_.EltSize, CD8VT1>;
7789 }
7790
7791 multiclass avx512_gather_q_pd<bits<8> dopc, bits<8> qopc,
7792                         AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
7793   defm NAME##D##SUFF##Z: avx512_gather<dopc, OpcodeStr##"d", _.info512,
7794                                       vy512mem, mgatherv8i32>, EVEX_V512, VEX_W;
7795   defm NAME##Q##SUFF##Z: avx512_gather<qopc, OpcodeStr##"q", _.info512,
7796                                       vz512mem,  mgatherv8i64>, EVEX_V512, VEX_W;
7797 let Predicates = [HasVLX] in {
7798   defm NAME##D##SUFF##Z256: avx512_gather<dopc, OpcodeStr##"d", _.info256,
7799                               vx256xmem, mgatherv4i32>, EVEX_V256, VEX_W;
7800   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info256,
7801                               vy256xmem, mgatherv4i64>, EVEX_V256, VEX_W;
7802   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
7803                               vx128xmem, mgatherv4i32>, EVEX_V128, VEX_W;
7804   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
7805                               vx128xmem, mgatherv2i64>, EVEX_V128, VEX_W;
7806 }
7807 }
7808
7809 multiclass avx512_gather_d_ps<bits<8> dopc, bits<8> qopc,
7810                        AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
7811   defm NAME##D##SUFF##Z: avx512_gather<dopc, OpcodeStr##"d", _.info512, vz512mem,
7812                                        mgatherv16i32>, EVEX_V512;
7813   defm NAME##Q##SUFF##Z: avx512_gather<qopc, OpcodeStr##"q", _.info256, vz256xmem,
7814                                        mgatherv8i64>, EVEX_V512;
7815 let Predicates = [HasVLX] in {
7816   defm NAME##D##SUFF##Z256: avx512_gather<dopc, OpcodeStr##"d", _.info256,
7817                                           vy256xmem, mgatherv8i32>, EVEX_V256;
7818   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info128,
7819                                           vy128xmem, mgatherv4i64>, EVEX_V256;
7820   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
7821                                           vx128xmem, mgatherv4i32>, EVEX_V128;
7822   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
7823                                           vx64xmem, mgatherv2i64>, EVEX_V128;
7824 }
7825 }
7826
7827
7828 defm VGATHER : avx512_gather_q_pd<0x92, 0x93, avx512vl_f64_info, "vgather", "PD">,
7829                avx512_gather_d_ps<0x92, 0x93, avx512vl_f32_info, "vgather", "PS">;
7830
7831 defm VPGATHER : avx512_gather_q_pd<0x90, 0x91, avx512vl_i64_info, "vpgather", "Q">,
7832                 avx512_gather_d_ps<0x90, 0x91, avx512vl_i32_info, "vpgather", "D">;
7833
7834 multiclass avx512_scatter<bits<8> opc, string OpcodeStr, X86VectorVTInfo _,
7835                           X86MemOperand memop, PatFrag ScatterNode> {
7836
7837 let mayStore = 1, Constraints = "$mask = $mask_wb", ExeDomain = _.ExeDomain in
7838
7839   def mr  : AVX5128I<opc, MRMDestMem, (outs _.KRCWM:$mask_wb),
7840             (ins memop:$dst, _.KRCWM:$mask, _.RC:$src),
7841             !strconcat(OpcodeStr#_.Suffix,
7842             "\t{$src, ${dst} {${mask}}|${dst} {${mask}}, $src}"),
7843             [(set _.KRCWM:$mask_wb, (ScatterNode (_.VT _.RC:$src),
7844                                      _.KRCWM:$mask,  vectoraddr:$dst))]>,
7845             EVEX, EVEX_K, EVEX_CD8<_.EltSize, CD8VT1>;
7846 }
7847
7848 multiclass avx512_scatter_q_pd<bits<8> dopc, bits<8> qopc,
7849                         AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
7850   defm NAME##D##SUFF##Z: avx512_scatter<dopc, OpcodeStr##"d", _.info512,
7851                                       vy512mem, mscatterv8i32>, EVEX_V512, VEX_W;
7852   defm NAME##Q##SUFF##Z: avx512_scatter<qopc, OpcodeStr##"q", _.info512,
7853                                       vz512mem,  mscatterv8i64>, EVEX_V512, VEX_W;
7854 let Predicates = [HasVLX] in {
7855   defm NAME##D##SUFF##Z256: avx512_scatter<dopc, OpcodeStr##"d", _.info256,
7856                               vx256xmem, mscatterv4i32>, EVEX_V256, VEX_W;
7857   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info256,
7858                               vy256xmem, mscatterv4i64>, EVEX_V256, VEX_W;
7859   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
7860                               vx128xmem, mscatterv4i32>, EVEX_V128, VEX_W;
7861   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
7862                               vx128xmem, mscatterv2i64>, EVEX_V128, VEX_W;
7863 }
7864 }
7865
7866 multiclass avx512_scatter_d_ps<bits<8> dopc, bits<8> qopc,
7867                        AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
7868   defm NAME##D##SUFF##Z: avx512_scatter<dopc, OpcodeStr##"d", _.info512, vz512mem,
7869                                        mscatterv16i32>, EVEX_V512;
7870   defm NAME##Q##SUFF##Z: avx512_scatter<qopc, OpcodeStr##"q", _.info256, vz256xmem,
7871                                        mscatterv8i64>, EVEX_V512;
7872 let Predicates = [HasVLX] in {
7873   defm NAME##D##SUFF##Z256: avx512_scatter<dopc, OpcodeStr##"d", _.info256,
7874                                           vy256xmem, mscatterv8i32>, EVEX_V256;
7875   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
7876                                           vy128xmem, mscatterv4i64>, EVEX_V256;
7877   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
7878                                           vx128xmem, mscatterv4i32>, EVEX_V128;
7879   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
7880                                           vx64xmem, mscatterv2i64>, EVEX_V128;
7881 }
7882 }
7883
7884 defm VSCATTER : avx512_scatter_q_pd<0xA2, 0xA3, avx512vl_f64_info, "vscatter", "PD">,
7885                avx512_scatter_d_ps<0xA2, 0xA3, avx512vl_f32_info, "vscatter", "PS">;
7886
7887 defm VPSCATTER : avx512_scatter_q_pd<0xA0, 0xA1, avx512vl_i64_info, "vpscatter", "Q">,
7888                 avx512_scatter_d_ps<0xA0, 0xA1, avx512vl_i32_info, "vpscatter", "D">;
7889
7890 // prefetch
7891 multiclass avx512_gather_scatter_prefetch<bits<8> opc, Format F, string OpcodeStr,
7892                        RegisterClass KRC, X86MemOperand memop> {
7893   let Predicates = [HasPFI], hasSideEffects = 1 in
7894   def m  : AVX5128I<opc, F, (outs), (ins KRC:$mask, memop:$src),
7895             !strconcat(OpcodeStr, "\t{$src {${mask}}|{${mask}}, $src}"),
7896             []>, EVEX, EVEX_K;
7897 }
7898
7899 defm VGATHERPF0DPS: avx512_gather_scatter_prefetch<0xC6, MRM1m, "vgatherpf0dps",
7900                      VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
7901
7902 defm VGATHERPF0QPS: avx512_gather_scatter_prefetch<0xC7, MRM1m, "vgatherpf0qps",
7903                      VK8WM, vz256xmem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
7904
7905 defm VGATHERPF0DPD: avx512_gather_scatter_prefetch<0xC6, MRM1m, "vgatherpf0dpd",
7906                      VK8WM, vy512mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
7907
7908 defm VGATHERPF0QPD: avx512_gather_scatter_prefetch<0xC7, MRM1m, "vgatherpf0qpd",
7909                      VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
7910
7911 defm VGATHERPF1DPS: avx512_gather_scatter_prefetch<0xC6, MRM2m, "vgatherpf1dps",
7912                      VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
7913
7914 defm VGATHERPF1QPS: avx512_gather_scatter_prefetch<0xC7, MRM2m, "vgatherpf1qps",
7915                      VK8WM, vz256xmem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
7916
7917 defm VGATHERPF1DPD: avx512_gather_scatter_prefetch<0xC6, MRM2m, "vgatherpf1dpd",
7918                      VK8WM, vy512mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
7919
7920 defm VGATHERPF1QPD: avx512_gather_scatter_prefetch<0xC7, MRM2m, "vgatherpf1qpd",
7921                      VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
7922
7923 defm VSCATTERPF0DPS: avx512_gather_scatter_prefetch<0xC6, MRM5m, "vscatterpf0dps",
7924                      VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
7925
7926 defm VSCATTERPF0QPS: avx512_gather_scatter_prefetch<0xC7, MRM5m, "vscatterpf0qps",
7927                      VK8WM, vz256xmem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
7928
7929 defm VSCATTERPF0DPD: avx512_gather_scatter_prefetch<0xC6, MRM5m, "vscatterpf0dpd",
7930                      VK8WM, vy512mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
7931
7932 defm VSCATTERPF0QPD: avx512_gather_scatter_prefetch<0xC7, MRM5m, "vscatterpf0qpd",
7933                      VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
7934
7935 defm VSCATTERPF1DPS: avx512_gather_scatter_prefetch<0xC6, MRM6m, "vscatterpf1dps",
7936                      VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
7937
7938 defm VSCATTERPF1QPS: avx512_gather_scatter_prefetch<0xC7, MRM6m, "vscatterpf1qps",
7939                      VK8WM, vz256xmem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
7940
7941 defm VSCATTERPF1DPD: avx512_gather_scatter_prefetch<0xC6, MRM6m, "vscatterpf1dpd",
7942                      VK8WM, vy512mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
7943
7944 defm VSCATTERPF1QPD: avx512_gather_scatter_prefetch<0xC7, MRM6m, "vscatterpf1qpd",
7945                      VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
7946
7947 // Helper fragments to match sext vXi1 to vXiY.
7948 def v64i1sextv64i8 : PatLeaf<(v64i8
7949                               (X86vsext
7950                                (v64i1 (X86pcmpgtm
7951                                 (bc_v64i8 (v16i32 immAllZerosV)),
7952                                 VR512:$src))))>;
7953 def v32i1sextv32i16 : PatLeaf<(v32i16 (X86vsrai VR512:$src, (i8 15)))>;
7954 def v16i1sextv16i32 : PatLeaf<(v16i32 (X86vsrai VR512:$src, (i8 31)))>;
7955 def v8i1sextv8i64   : PatLeaf<(v8i64 (X86vsrai VR512:$src, (i8 63)))>;
7956
7957 multiclass cvt_by_vec_width<bits<8> opc, X86VectorVTInfo Vec, string OpcodeStr > {
7958 def rr : AVX512XS8I<opc, MRMSrcReg, (outs Vec.RC:$dst), (ins Vec.KRC:$src),
7959                   !strconcat(OpcodeStr##Vec.Suffix, "\t{$src, $dst|$dst, $src}"),
7960                   [(set Vec.RC:$dst, (Vec.VT (X86vsext Vec.KRC:$src)))]>, EVEX;
7961 }
7962
7963 // Use 512bit version to implement 128/256 bit in case NoVLX.
7964 multiclass avx512_convert_mask_to_vector_lowering<X86VectorVTInfo X86Info,
7965                                                             X86VectorVTInfo _> {
7966
7967   def : Pat<(X86Info.VT (X86vsext (X86Info.KVT X86Info.KRC:$src))),
7968             (X86Info.VT (EXTRACT_SUBREG
7969                            (_.VT (!cast<Instruction>(NAME#"Zrr")
7970                              (_.KVT (COPY_TO_REGCLASS X86Info.KRC:$src,_.KRC)))),
7971                            X86Info.SubRegIdx))>;
7972 }
7973
7974 multiclass cvt_mask_by_elt_width<bits<8> opc, AVX512VLVectorVTInfo VTInfo,
7975                                  string OpcodeStr, Predicate prd> {
7976 let Predicates = [prd] in
7977   defm Z : cvt_by_vec_width<opc, VTInfo.info512, OpcodeStr>, EVEX_V512;
7978
7979   let Predicates = [prd, HasVLX] in {
7980     defm Z256 : cvt_by_vec_width<opc, VTInfo.info256, OpcodeStr>, EVEX_V256;
7981     defm Z128 : cvt_by_vec_width<opc, VTInfo.info128, OpcodeStr>, EVEX_V128;
7982   }
7983 let Predicates = [prd, NoVLX] in {
7984    defm Z256_Alt :   avx512_convert_mask_to_vector_lowering<VTInfo.info256,VTInfo.info512>;
7985    defm Z128_Alt :   avx512_convert_mask_to_vector_lowering<VTInfo.info128,VTInfo.info512>;
7986   }
7987
7988 }
7989
7990 defm VPMOVM2B : cvt_mask_by_elt_width<0x28, avx512vl_i8_info, "vpmovm2" , HasBWI>;
7991 defm VPMOVM2W : cvt_mask_by_elt_width<0x28, avx512vl_i16_info, "vpmovm2", HasBWI> , VEX_W;
7992 defm VPMOVM2D : cvt_mask_by_elt_width<0x38, avx512vl_i32_info, "vpmovm2", HasDQI>;
7993 defm VPMOVM2Q : cvt_mask_by_elt_width<0x38, avx512vl_i64_info, "vpmovm2", HasDQI> , VEX_W;
7994
7995 multiclass convert_vector_to_mask_common<bits<8> opc, X86VectorVTInfo _, string OpcodeStr > {
7996     def rr : AVX512XS8I<opc, MRMSrcReg, (outs _.KRC:$dst), (ins _.RC:$src),
7997                         !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
7998                         [(set _.KRC:$dst, (X86cvt2mask (_.VT _.RC:$src)))]>, EVEX;
7999 }
8000
8001 // Use 512bit version to implement 128/256 bit in case NoVLX.
8002 multiclass convert_vector_to_mask_lowering<X86VectorVTInfo ExtendInfo,
8003                                                             X86VectorVTInfo _> {
8004
8005   def : Pat<(_.KVT (X86cvt2mask (_.VT _.RC:$src))),
8006             (_.KVT (COPY_TO_REGCLASS
8007                      (!cast<Instruction>(NAME#"Zrr")
8008                        (INSERT_SUBREG (ExtendInfo.VT (IMPLICIT_DEF)),
8009                                       _.RC:$src, _.SubRegIdx)),
8010                    _.KRC))>;
8011 }
8012
8013 multiclass avx512_convert_vector_to_mask<bits<8> opc, string OpcodeStr,
8014                                    AVX512VLVectorVTInfo VTInfo, Predicate prd> {
8015   let Predicates = [prd] in
8016     defm Z : convert_vector_to_mask_common <opc, VTInfo.info512, OpcodeStr>,
8017                                             EVEX_V512;
8018
8019   let Predicates = [prd, HasVLX] in {
8020     defm Z256 : convert_vector_to_mask_common<opc, VTInfo.info256, OpcodeStr>,
8021                                               EVEX_V256;
8022     defm Z128 : convert_vector_to_mask_common<opc, VTInfo.info128, OpcodeStr>,
8023                                                EVEX_V128;
8024   }
8025   let Predicates = [prd, NoVLX] in {
8026     defm Z256_Alt : convert_vector_to_mask_lowering<VTInfo.info512, VTInfo.info256>;
8027     defm Z128_Alt : convert_vector_to_mask_lowering<VTInfo.info512, VTInfo.info128>;
8028   }
8029 }
8030
8031 defm VPMOVB2M : avx512_convert_vector_to_mask<0x29, "vpmovb2m",
8032                                               avx512vl_i8_info, HasBWI>;
8033 defm VPMOVW2M : avx512_convert_vector_to_mask<0x29, "vpmovw2m",
8034                                               avx512vl_i16_info, HasBWI>, VEX_W;
8035 defm VPMOVD2M : avx512_convert_vector_to_mask<0x39, "vpmovd2m",
8036                                               avx512vl_i32_info, HasDQI>;
8037 defm VPMOVQ2M : avx512_convert_vector_to_mask<0x39, "vpmovq2m",
8038                                               avx512vl_i64_info, HasDQI>, VEX_W;
8039
8040 //===----------------------------------------------------------------------===//
8041 // AVX-512 - COMPRESS and EXPAND
8042 //
8043
8044 multiclass compress_by_vec_width_common<bits<8> opc, X86VectorVTInfo _,
8045                                  string OpcodeStr> {
8046   defm rr : AVX512_maskable<opc, MRMDestReg, _, (outs _.RC:$dst),
8047               (ins _.RC:$src1), OpcodeStr, "$src1", "$src1",
8048               (_.VT (X86compress _.RC:$src1))>, AVX5128IBase;
8049
8050   let mayStore = 1, hasSideEffects = 0 in
8051   def mr : AVX5128I<opc, MRMDestMem, (outs),
8052               (ins _.MemOp:$dst, _.RC:$src),
8053               OpcodeStr # "\t{$src, $dst|$dst, $src}",
8054               []>, EVEX_CD8<_.EltSize, CD8VT1>;
8055
8056   def mrk : AVX5128I<opc, MRMDestMem, (outs),
8057               (ins _.MemOp:$dst, _.KRCWM:$mask, _.RC:$src),
8058               OpcodeStr # "\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
8059               []>,
8060               EVEX_K, EVEX_CD8<_.EltSize, CD8VT1>;
8061 }
8062
8063 multiclass compress_by_vec_width_lowering<X86VectorVTInfo _ > {
8064
8065   def : Pat<(X86mCompressingStore addr:$dst, _.KRCWM:$mask,
8066                                                (_.VT _.RC:$src)),
8067             (!cast<Instruction>(NAME#_.ZSuffix##mrk)
8068                             addr:$dst, _.KRCWM:$mask, _.RC:$src)>;
8069 }
8070
8071 multiclass compress_by_elt_width<bits<8> opc, string OpcodeStr,
8072                                  AVX512VLVectorVTInfo VTInfo> {
8073   defm Z : compress_by_vec_width_common<opc, VTInfo.info512, OpcodeStr>,
8074            compress_by_vec_width_lowering<VTInfo.info512>, EVEX_V512;
8075
8076   let Predicates = [HasVLX] in {
8077     defm Z256 : compress_by_vec_width_common<opc, VTInfo.info256, OpcodeStr>,
8078                 compress_by_vec_width_lowering<VTInfo.info256>, EVEX_V256;
8079     defm Z128 : compress_by_vec_width_common<opc, VTInfo.info128, OpcodeStr>,
8080                 compress_by_vec_width_lowering<VTInfo.info128>, EVEX_V128;
8081   }
8082 }
8083
8084 defm VPCOMPRESSD : compress_by_elt_width <0x8B, "vpcompressd", avx512vl_i32_info>,
8085                                          EVEX;
8086 defm VPCOMPRESSQ : compress_by_elt_width <0x8B, "vpcompressq", avx512vl_i64_info>,
8087                                          EVEX, VEX_W;
8088 defm VCOMPRESSPS : compress_by_elt_width <0x8A, "vcompressps", avx512vl_f32_info>,
8089                                          EVEX;
8090 defm VCOMPRESSPD : compress_by_elt_width <0x8A, "vcompresspd", avx512vl_f64_info>,
8091                                          EVEX, VEX_W;
8092
8093 // expand
8094 multiclass expand_by_vec_width<bits<8> opc, X86VectorVTInfo _,
8095                                  string OpcodeStr> {
8096   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8097               (ins _.RC:$src1), OpcodeStr, "$src1", "$src1",
8098               (_.VT (X86expand _.RC:$src1))>, AVX5128IBase;
8099
8100   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8101               (ins _.MemOp:$src1), OpcodeStr, "$src1", "$src1",
8102               (_.VT (X86expand (_.VT (bitconvert
8103                                       (_.LdFrag addr:$src1)))))>,
8104             AVX5128IBase, EVEX_CD8<_.EltSize, CD8VT1>;
8105 }
8106
8107 multiclass expand_by_vec_width_lowering<X86VectorVTInfo _ > {
8108
8109   def : Pat<(_.VT (X86mExpandingLoad addr:$src, _.KRCWM:$mask, undef)),
8110             (!cast<Instruction>(NAME#_.ZSuffix##rmkz)
8111                                         _.KRCWM:$mask, addr:$src)>;
8112
8113   def : Pat<(_.VT (X86mExpandingLoad addr:$src, _.KRCWM:$mask,
8114                                                (_.VT _.RC:$src0))),
8115             (!cast<Instruction>(NAME#_.ZSuffix##rmk)
8116                             _.RC:$src0, _.KRCWM:$mask, addr:$src)>;
8117 }
8118
8119 multiclass expand_by_elt_width<bits<8> opc, string OpcodeStr,
8120                                  AVX512VLVectorVTInfo VTInfo> {
8121   defm Z : expand_by_vec_width<opc, VTInfo.info512, OpcodeStr>,
8122            expand_by_vec_width_lowering<VTInfo.info512>, EVEX_V512;
8123
8124   let Predicates = [HasVLX] in {
8125     defm Z256 : expand_by_vec_width<opc, VTInfo.info256, OpcodeStr>,
8126                 expand_by_vec_width_lowering<VTInfo.info256>, EVEX_V256;
8127     defm Z128 : expand_by_vec_width<opc, VTInfo.info128, OpcodeStr>,
8128                 expand_by_vec_width_lowering<VTInfo.info128>, EVEX_V128;
8129   }
8130 }
8131
8132 defm VPEXPANDD : expand_by_elt_width <0x89, "vpexpandd", avx512vl_i32_info>,
8133                                          EVEX;
8134 defm VPEXPANDQ : expand_by_elt_width <0x89, "vpexpandq", avx512vl_i64_info>,
8135                                          EVEX, VEX_W;
8136 defm VEXPANDPS : expand_by_elt_width <0x88, "vexpandps", avx512vl_f32_info>,
8137                                          EVEX;
8138 defm VEXPANDPD : expand_by_elt_width <0x88, "vexpandpd", avx512vl_f64_info>,
8139                                          EVEX, VEX_W;
8140
8141 //handle instruction  reg_vec1 = op(reg_vec,imm)
8142 //                               op(mem_vec,imm)
8143 //                               op(broadcast(eltVt),imm)
8144 //all instruction created with FROUND_CURRENT
8145 multiclass avx512_unary_fp_packed_imm<bits<8> opc, string OpcodeStr, SDNode OpNode,
8146                                       X86VectorVTInfo _>{
8147   let ExeDomain = _.ExeDomain in {
8148   defm rri : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8149                       (ins _.RC:$src1, i32u8imm:$src2),
8150                       OpcodeStr##_.Suffix, "$src2, $src1", "$src1, $src2",
8151                       (OpNode (_.VT _.RC:$src1),
8152                               (i32 imm:$src2),
8153                               (i32 FROUND_CURRENT))>;
8154   defm rmi : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8155                     (ins _.MemOp:$src1, i32u8imm:$src2),
8156                     OpcodeStr##_.Suffix, "$src2, $src1", "$src1, $src2",
8157                     (OpNode (_.VT (bitconvert (_.LdFrag addr:$src1))),
8158                             (i32 imm:$src2),
8159                             (i32 FROUND_CURRENT))>;
8160   defm rmbi : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8161                     (ins _.ScalarMemOp:$src1, i32u8imm:$src2),
8162                     OpcodeStr##_.Suffix, "$src2, ${src1}"##_.BroadcastStr,
8163                     "${src1}"##_.BroadcastStr##", $src2",
8164                     (OpNode (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src1))),
8165                             (i32 imm:$src2),
8166                             (i32 FROUND_CURRENT))>, EVEX_B;
8167   }
8168 }
8169
8170 //handle instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm),{sae}
8171 multiclass avx512_unary_fp_sae_packed_imm<bits<8> opc, string OpcodeStr,
8172                                              SDNode OpNode, X86VectorVTInfo _>{
8173   let ExeDomain = _.ExeDomain in
8174   defm rrib : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8175                       (ins _.RC:$src1, i32u8imm:$src2),
8176                       OpcodeStr##_.Suffix, "$src2, {sae}, $src1",
8177                       "$src1, {sae}, $src2",
8178                       (OpNode (_.VT _.RC:$src1),
8179                               (i32 imm:$src2),
8180                               (i32 FROUND_NO_EXC))>, EVEX_B;
8181 }
8182
8183 multiclass avx512_common_unary_fp_sae_packed_imm<string OpcodeStr,
8184             AVX512VLVectorVTInfo _, bits<8> opc, SDNode OpNode, Predicate prd>{
8185   let Predicates = [prd] in {
8186     defm Z    : avx512_unary_fp_packed_imm<opc, OpcodeStr, OpNode, _.info512>,
8187                 avx512_unary_fp_sae_packed_imm<opc, OpcodeStr, OpNode, _.info512>,
8188                                   EVEX_V512;
8189   }
8190   let Predicates = [prd, HasVLX] in {
8191     defm Z128 : avx512_unary_fp_packed_imm<opc, OpcodeStr, OpNode, _.info128>,
8192                                   EVEX_V128;
8193     defm Z256 : avx512_unary_fp_packed_imm<opc, OpcodeStr, OpNode, _.info256>,
8194                                   EVEX_V256;
8195   }
8196 }
8197
8198 //handle instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm)
8199 //                               op(reg_vec2,mem_vec,imm)
8200 //                               op(reg_vec2,broadcast(eltVt),imm)
8201 //all instruction created with FROUND_CURRENT
8202 multiclass avx512_fp_packed_imm<bits<8> opc, string OpcodeStr, SDNode OpNode,
8203                                 X86VectorVTInfo _>{
8204   let ExeDomain = _.ExeDomain in {
8205   defm rri : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8206                       (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3),
8207                       OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8208                       (OpNode (_.VT _.RC:$src1),
8209                               (_.VT _.RC:$src2),
8210                               (i32 imm:$src3),
8211                               (i32 FROUND_CURRENT))>;
8212   defm rmi : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8213                     (ins _.RC:$src1, _.MemOp:$src2, i32u8imm:$src3),
8214                     OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8215                     (OpNode (_.VT _.RC:$src1),
8216                             (_.VT (bitconvert (_.LdFrag addr:$src2))),
8217                             (i32 imm:$src3),
8218                             (i32 FROUND_CURRENT))>;
8219   defm rmbi : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8220                     (ins _.RC:$src1, _.ScalarMemOp:$src2, i32u8imm:$src3),
8221                     OpcodeStr, "$src3, ${src2}"##_.BroadcastStr##", $src1",
8222                     "$src1, ${src2}"##_.BroadcastStr##", $src3",
8223                     (OpNode (_.VT _.RC:$src1),
8224                             (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src2))),
8225                             (i32 imm:$src3),
8226                             (i32 FROUND_CURRENT))>, EVEX_B;
8227   }
8228 }
8229
8230 //handle instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm)
8231 //                               op(reg_vec2,mem_vec,imm)
8232 multiclass avx512_3Op_rm_imm8<bits<8> opc, string OpcodeStr, SDNode OpNode,
8233                              X86VectorVTInfo DestInfo, X86VectorVTInfo SrcInfo>{
8234   let ExeDomain = DestInfo.ExeDomain in {
8235   defm rri : AVX512_maskable<opc, MRMSrcReg, DestInfo, (outs DestInfo.RC:$dst),
8236                   (ins SrcInfo.RC:$src1, SrcInfo.RC:$src2, u8imm:$src3),
8237                   OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8238                   (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1),
8239                                (SrcInfo.VT SrcInfo.RC:$src2),
8240                                (i8 imm:$src3)))>;
8241   defm rmi : AVX512_maskable<opc, MRMSrcMem, DestInfo, (outs DestInfo.RC:$dst),
8242                 (ins SrcInfo.RC:$src1, SrcInfo.MemOp:$src2, u8imm:$src3),
8243                 OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8244                 (DestInfo.VT (OpNode (SrcInfo.VT SrcInfo.RC:$src1),
8245                              (SrcInfo.VT (bitconvert
8246                                                 (SrcInfo.LdFrag addr:$src2))),
8247                              (i8 imm:$src3)))>;
8248   }
8249 }
8250
8251 //handle instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm)
8252 //                               op(reg_vec2,mem_vec,imm)
8253 //                               op(reg_vec2,broadcast(eltVt),imm)
8254 multiclass avx512_3Op_imm8<bits<8> opc, string OpcodeStr, SDNode OpNode,
8255                            X86VectorVTInfo _>:
8256   avx512_3Op_rm_imm8<opc, OpcodeStr, OpNode, _, _>{
8257
8258   let ExeDomain = _.ExeDomain in
8259   defm rmbi : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8260                     (ins _.RC:$src1, _.ScalarMemOp:$src2, u8imm:$src3),
8261                     OpcodeStr, "$src3, ${src2}"##_.BroadcastStr##", $src1",
8262                     "$src1, ${src2}"##_.BroadcastStr##", $src3",
8263                     (OpNode (_.VT _.RC:$src1),
8264                             (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src2))),
8265                             (i8 imm:$src3))>, EVEX_B;
8266 }
8267
8268 //handle scalar instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm)
8269 //                                      op(reg_vec2,mem_scalar,imm)
8270 //all instruction created with FROUND_CURRENT
8271 multiclass avx512_fp_scalar_imm<bits<8> opc, string OpcodeStr, SDNode OpNode,
8272                                 X86VectorVTInfo _> {
8273   let ExeDomain = _.ExeDomain in {
8274   defm rri : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
8275                       (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3),
8276                       OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8277                       (OpNode (_.VT _.RC:$src1),
8278                               (_.VT _.RC:$src2),
8279                               (i32 imm:$src3),
8280                               (i32 FROUND_CURRENT))>;
8281   defm rmi : AVX512_maskable_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
8282                     (ins _.RC:$src1, _.ScalarMemOp:$src2, i32u8imm:$src3),
8283                     OpcodeStr, "$src3, $src2, $src1", "$src1, $src2, $src3",
8284                     (OpNode (_.VT _.RC:$src1),
8285                             (_.VT (scalar_to_vector
8286                                       (_.ScalarLdFrag addr:$src2))),
8287                             (i32 imm:$src3),
8288                             (i32 FROUND_CURRENT))>;
8289   }
8290 }
8291
8292 //handle instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm),{sae}
8293 multiclass avx512_fp_sae_packed_imm<bits<8> opc, string OpcodeStr,
8294                                              SDNode OpNode, X86VectorVTInfo _>{
8295   let ExeDomain = _.ExeDomain in
8296   defm rrib : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8297                       (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3),
8298                       OpcodeStr, "$src3, {sae}, $src2, $src1",
8299                       "$src1, $src2, {sae}, $src3",
8300                       (OpNode (_.VT _.RC:$src1),
8301                               (_.VT _.RC:$src2),
8302                               (i32 imm:$src3),
8303                               (i32 FROUND_NO_EXC))>, EVEX_B;
8304 }
8305 //handle scalar instruction  reg_vec1 = op(reg_vec2,reg_vec3,imm),{sae}
8306 multiclass avx512_fp_sae_scalar_imm<bits<8> opc, string OpcodeStr,
8307                                              SDNode OpNode, X86VectorVTInfo _> {
8308   let ExeDomain = _.ExeDomain in
8309   defm NAME#rrib : AVX512_maskable_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
8310                       (ins _.RC:$src1, _.RC:$src2, i32u8imm:$src3),
8311                       OpcodeStr, "$src3, {sae}, $src2, $src1",
8312                       "$src1, $src2, {sae}, $src3",
8313                       (OpNode (_.VT _.RC:$src1),
8314                               (_.VT _.RC:$src2),
8315                               (i32 imm:$src3),
8316                               (i32 FROUND_NO_EXC))>, EVEX_B;
8317 }
8318
8319 multiclass avx512_common_fp_sae_packed_imm<string OpcodeStr,
8320             AVX512VLVectorVTInfo _, bits<8> opc, SDNode OpNode, Predicate prd>{
8321   let Predicates = [prd] in {
8322     defm Z    : avx512_fp_packed_imm<opc, OpcodeStr, OpNode, _.info512>,
8323                 avx512_fp_sae_packed_imm<opc, OpcodeStr, OpNode, _.info512>,
8324                                   EVEX_V512;
8325
8326   }
8327   let Predicates = [prd, HasVLX] in {
8328     defm Z128 : avx512_fp_packed_imm<opc, OpcodeStr, OpNode, _.info128>,
8329                                   EVEX_V128;
8330     defm Z256 : avx512_fp_packed_imm<opc, OpcodeStr, OpNode, _.info256>,
8331                                   EVEX_V256;
8332   }
8333 }
8334
8335 multiclass avx512_common_3Op_rm_imm8<bits<8> opc, SDNode OpNode, string OpStr,
8336                    AVX512VLVectorVTInfo DestInfo, AVX512VLVectorVTInfo SrcInfo>{
8337   let Predicates = [HasBWI] in {
8338     defm Z    : avx512_3Op_rm_imm8<opc, OpStr, OpNode, DestInfo.info512,
8339                            SrcInfo.info512>, EVEX_V512, AVX512AIi8Base, EVEX_4V;
8340   }
8341   let Predicates = [HasBWI, HasVLX] in {
8342     defm Z128 : avx512_3Op_rm_imm8<opc, OpStr, OpNode, DestInfo.info128,
8343                            SrcInfo.info128>, EVEX_V128, AVX512AIi8Base, EVEX_4V;
8344     defm Z256 : avx512_3Op_rm_imm8<opc, OpStr, OpNode,  DestInfo.info256,
8345                            SrcInfo.info256>, EVEX_V256, AVX512AIi8Base, EVEX_4V;
8346   }
8347 }
8348
8349 multiclass avx512_common_3Op_imm8<string OpcodeStr, AVX512VLVectorVTInfo _,
8350                                 bits<8> opc, SDNode OpNode>{
8351   let Predicates = [HasAVX512] in {
8352     defm Z    : avx512_3Op_imm8<opc, OpcodeStr, OpNode, _.info512>, EVEX_V512;
8353   }
8354   let Predicates = [HasAVX512, HasVLX] in {
8355     defm Z128 : avx512_3Op_imm8<opc, OpcodeStr, OpNode, _.info128>, EVEX_V128;
8356     defm Z256 : avx512_3Op_imm8<opc, OpcodeStr, OpNode, _.info256>, EVEX_V256;
8357   }
8358 }
8359
8360 multiclass avx512_common_fp_sae_scalar_imm<string OpcodeStr,
8361                   X86VectorVTInfo _, bits<8> opc, SDNode OpNode, Predicate prd>{
8362   let Predicates = [prd] in {
8363      defm Z128 : avx512_fp_scalar_imm<opc, OpcodeStr, OpNode, _>,
8364                  avx512_fp_sae_scalar_imm<opc, OpcodeStr, OpNode, _>;
8365   }
8366 }
8367
8368 multiclass avx512_common_unary_fp_sae_packed_imm_all<string OpcodeStr,
8369                     bits<8> opcPs, bits<8> opcPd, SDNode OpNode, Predicate prd>{
8370   defm PS : avx512_common_unary_fp_sae_packed_imm<OpcodeStr, avx512vl_f32_info,
8371                             opcPs, OpNode, prd>, EVEX_CD8<32, CD8VF>;
8372   defm PD : avx512_common_unary_fp_sae_packed_imm<OpcodeStr, avx512vl_f64_info,
8373                             opcPd, OpNode, prd>, EVEX_CD8<64, CD8VF>, VEX_W;
8374 }
8375
8376
8377 defm VREDUCE   : avx512_common_unary_fp_sae_packed_imm_all<"vreduce", 0x56, 0x56,
8378                               X86VReduce, HasDQI>, AVX512AIi8Base, EVEX;
8379 defm VRNDSCALE : avx512_common_unary_fp_sae_packed_imm_all<"vrndscale", 0x08, 0x09,
8380                               X86VRndScale, HasAVX512>, AVX512AIi8Base, EVEX;
8381 defm VGETMANT : avx512_common_unary_fp_sae_packed_imm_all<"vgetmant", 0x26, 0x26,
8382                               X86VGetMant, HasAVX512>, AVX512AIi8Base, EVEX;
8383
8384
8385 defm VRANGEPD : avx512_common_fp_sae_packed_imm<"vrangepd", avx512vl_f64_info,
8386                                                        0x50, X86VRange, HasDQI>,
8387       AVX512AIi8Base, EVEX_4V, EVEX_CD8<64, CD8VF>, VEX_W;
8388 defm VRANGEPS : avx512_common_fp_sae_packed_imm<"vrangeps", avx512vl_f32_info,
8389                                                        0x50, X86VRange, HasDQI>,
8390       AVX512AIi8Base, EVEX_4V, EVEX_CD8<32, CD8VF>;
8391
8392 defm VRANGESD: avx512_common_fp_sae_scalar_imm<"vrangesd", f64x_info,
8393                                                  0x51, X86VRange, HasDQI>,
8394       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<64, CD8VT1>, VEX_W;
8395 defm VRANGESS: avx512_common_fp_sae_scalar_imm<"vrangess", f32x_info,
8396                                                  0x51, X86VRange, HasDQI>,
8397       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<32, CD8VT1>;
8398
8399 defm VREDUCESD: avx512_common_fp_sae_scalar_imm<"vreducesd", f64x_info,
8400                                                  0x57, X86Reduces, HasDQI>,
8401       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<64, CD8VT1>, VEX_W;
8402 defm VREDUCESS: avx512_common_fp_sae_scalar_imm<"vreducess", f32x_info,
8403                                                  0x57, X86Reduces, HasDQI>,
8404       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<32, CD8VT1>;
8405
8406 defm VGETMANTSD: avx512_common_fp_sae_scalar_imm<"vgetmantsd", f64x_info,
8407                                                  0x27, X86GetMants, HasAVX512>,
8408       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<64, CD8VT1>, VEX_W;
8409 defm VGETMANTSS: avx512_common_fp_sae_scalar_imm<"vgetmantss", f32x_info,
8410                                                  0x27, X86GetMants, HasAVX512>,
8411       AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<32, CD8VT1>;
8412
8413 multiclass avx512_shuff_packed_128<string OpcodeStr, AVX512VLVectorVTInfo _,
8414                                        bits<8> opc, SDNode OpNode = X86Shuf128>{
8415   let Predicates = [HasAVX512] in {
8416     defm Z    : avx512_3Op_imm8<opc, OpcodeStr, OpNode, _.info512>, EVEX_V512;
8417
8418   }
8419   let Predicates = [HasAVX512, HasVLX] in {
8420      defm Z256 : avx512_3Op_imm8<opc, OpcodeStr, OpNode, _.info256>, EVEX_V256;
8421   }
8422 }
8423 let Predicates = [HasAVX512] in {
8424 def : Pat<(v16f32 (ffloor VR512:$src)),
8425           (VRNDSCALEPSZrri VR512:$src, (i32 0x1))>;
8426 def : Pat<(v16f32 (fnearbyint VR512:$src)),
8427           (VRNDSCALEPSZrri VR512:$src, (i32 0xC))>;
8428 def : Pat<(v16f32 (fceil VR512:$src)),
8429           (VRNDSCALEPSZrri VR512:$src, (i32 0x2))>;
8430 def : Pat<(v16f32 (frint VR512:$src)),
8431           (VRNDSCALEPSZrri VR512:$src, (i32 0x4))>;
8432 def : Pat<(v16f32 (ftrunc VR512:$src)),
8433           (VRNDSCALEPSZrri VR512:$src, (i32 0x3))>;
8434
8435 def : Pat<(v8f64 (ffloor VR512:$src)),
8436           (VRNDSCALEPDZrri VR512:$src, (i32 0x1))>;
8437 def : Pat<(v8f64 (fnearbyint VR512:$src)),
8438           (VRNDSCALEPDZrri VR512:$src, (i32 0xC))>;
8439 def : Pat<(v8f64 (fceil VR512:$src)),
8440           (VRNDSCALEPDZrri VR512:$src, (i32 0x2))>;
8441 def : Pat<(v8f64 (frint VR512:$src)),
8442           (VRNDSCALEPDZrri VR512:$src, (i32 0x4))>;
8443 def : Pat<(v8f64 (ftrunc VR512:$src)),
8444           (VRNDSCALEPDZrri VR512:$src, (i32 0x3))>;
8445 }
8446
8447 defm VSHUFF32X4 : avx512_shuff_packed_128<"vshuff32x4",avx512vl_f32_info, 0x23>,
8448       AVX512AIi8Base, EVEX_4V, EVEX_CD8<32, CD8VF>;
8449 defm VSHUFF64X2 : avx512_shuff_packed_128<"vshuff64x2",avx512vl_f64_info, 0x23>,
8450       AVX512AIi8Base, EVEX_4V, EVEX_CD8<64, CD8VF>, VEX_W;
8451 defm VSHUFI32X4 : avx512_shuff_packed_128<"vshufi32x4",avx512vl_i32_info, 0x43>,
8452       AVX512AIi8Base, EVEX_4V, EVEX_CD8<32, CD8VF>;
8453 defm VSHUFI64X2 : avx512_shuff_packed_128<"vshufi64x2",avx512vl_i64_info, 0x43>,
8454       AVX512AIi8Base, EVEX_4V, EVEX_CD8<64, CD8VF>, VEX_W;
8455
8456 let Predicates = [HasAVX512] in {
8457 // Provide fallback in case the load node that is used in the broadcast
8458 // patterns above is used by additional users, which prevents the pattern
8459 // selection.
8460 def : Pat<(v8f64 (X86SubVBroadcast (v2f64 VR128X:$src))),
8461           (VSHUFF64X2Zrri (INSERT_SUBREG (v8f64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8462                           (INSERT_SUBREG (v8f64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8463                           0)>;
8464 def : Pat<(v8i64 (X86SubVBroadcast (v2i64 VR128X:$src))),
8465           (VSHUFI64X2Zrri (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8466                           (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8467                           0)>;
8468
8469 def : Pat<(v16f32 (X86SubVBroadcast (v4f32 VR128X:$src))),
8470           (VSHUFF32X4Zrri (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8471                           (INSERT_SUBREG (v16f32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8472                           0)>;
8473 def : Pat<(v16i32 (X86SubVBroadcast (v4i32 VR128X:$src))),
8474           (VSHUFI32X4Zrri (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8475                           (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8476                           0)>;
8477
8478 def : Pat<(v32i16 (X86SubVBroadcast (v8i16 VR128X:$src))),
8479           (VSHUFI32X4Zrri (INSERT_SUBREG (v32i16 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8480                           (INSERT_SUBREG (v32i16 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8481                           0)>;
8482
8483 def : Pat<(v64i8 (X86SubVBroadcast (v16i8 VR128X:$src))),
8484           (VSHUFI32X4Zrri (INSERT_SUBREG (v64i8 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8485                           (INSERT_SUBREG (v64i8 (IMPLICIT_DEF)), VR128X:$src, sub_xmm),
8486                           0)>;
8487 }
8488
8489 multiclass avx512_valign<string OpcodeStr, AVX512VLVectorVTInfo VTInfo_I> {
8490   defm NAME:       avx512_common_3Op_imm8<OpcodeStr, VTInfo_I, 0x03, X86VAlign>,
8491                            AVX512AIi8Base, EVEX_4V;
8492 }
8493
8494 defm VALIGND: avx512_valign<"valignd", avx512vl_i32_info>,
8495                                                   EVEX_CD8<32, CD8VF>;
8496 defm VALIGNQ: avx512_valign<"valignq", avx512vl_i64_info>,
8497                                                   EVEX_CD8<64, CD8VF>, VEX_W;
8498
8499 multiclass avx512_vpalignr_lowering<X86VectorVTInfo _ , list<Predicate> p>{
8500   let Predicates = p in
8501     def NAME#_.VTName#rri:
8502           Pat<(_.VT (X86PAlignr _.RC:$src1, _.RC:$src2, (i8 imm:$imm))),
8503               (!cast<Instruction>(NAME#_.ZSuffix#rri)
8504                     _.RC:$src1, _.RC:$src2, imm:$imm)>;
8505 }
8506
8507 multiclass avx512_vpalignr_lowering_common<AVX512VLVectorVTInfo _>:
8508       avx512_vpalignr_lowering<_.info512, [HasBWI]>,
8509       avx512_vpalignr_lowering<_.info128, [HasBWI, HasVLX]>,
8510       avx512_vpalignr_lowering<_.info256, [HasBWI, HasVLX]>;
8511
8512 defm VPALIGNR:   avx512_common_3Op_rm_imm8<0x0F, X86PAlignr, "vpalignr" ,
8513                                           avx512vl_i8_info, avx512vl_i8_info>,
8514                 avx512_vpalignr_lowering_common<avx512vl_i16_info>,
8515                 avx512_vpalignr_lowering_common<avx512vl_i32_info>,
8516                 avx512_vpalignr_lowering_common<avx512vl_f32_info>,
8517                 avx512_vpalignr_lowering_common<avx512vl_i64_info>,
8518                 avx512_vpalignr_lowering_common<avx512vl_f64_info>,
8519                 EVEX_CD8<8, CD8VF>;
8520
8521 defm VDBPSADBW: avx512_common_3Op_rm_imm8<0x42, X86dbpsadbw, "vdbpsadbw" ,
8522                     avx512vl_i16_info, avx512vl_i8_info>, EVEX_CD8<8, CD8VF>;
8523
8524 multiclass avx512_unary_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
8525                            X86VectorVTInfo _> {
8526   let ExeDomain = _.ExeDomain in {
8527   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8528                     (ins _.RC:$src1), OpcodeStr,
8529                     "$src1", "$src1",
8530                     (_.VT (OpNode _.RC:$src1))>, EVEX, AVX5128IBase;
8531
8532   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8533                   (ins _.MemOp:$src1), OpcodeStr,
8534                   "$src1", "$src1",
8535                   (_.VT (OpNode (bitconvert (_.LdFrag addr:$src1))))>,
8536             EVEX, AVX5128IBase, EVEX_CD8<_.EltSize, CD8VF>;
8537   }
8538 }
8539
8540 multiclass avx512_unary_rmb<bits<8> opc, string OpcodeStr, SDNode OpNode,
8541                             X86VectorVTInfo _> :
8542            avx512_unary_rm<opc, OpcodeStr, OpNode, _> {
8543   defm rmb : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8544                   (ins _.ScalarMemOp:$src1), OpcodeStr,
8545                   "${src1}"##_.BroadcastStr,
8546                   "${src1}"##_.BroadcastStr,
8547                   (_.VT (OpNode (X86VBroadcast
8548                                     (_.ScalarLdFrag addr:$src1))))>,
8549              EVEX, AVX5128IBase, EVEX_B, EVEX_CD8<_.EltSize, CD8VF>;
8550 }
8551
8552 multiclass avx512_unary_rm_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
8553                               AVX512VLVectorVTInfo VTInfo, Predicate prd> {
8554   let Predicates = [prd] in
8555     defm Z : avx512_unary_rm<opc, OpcodeStr, OpNode, VTInfo.info512>, EVEX_V512;
8556
8557   let Predicates = [prd, HasVLX] in {
8558     defm Z256 : avx512_unary_rm<opc, OpcodeStr, OpNode, VTInfo.info256>,
8559                               EVEX_V256;
8560     defm Z128 : avx512_unary_rm<opc, OpcodeStr, OpNode, VTInfo.info128>,
8561                               EVEX_V128;
8562   }
8563 }
8564
8565 multiclass avx512_unary_rmb_vl<bits<8> opc, string OpcodeStr, SDNode OpNode,
8566                                AVX512VLVectorVTInfo VTInfo, Predicate prd> {
8567   let Predicates = [prd] in
8568     defm Z : avx512_unary_rmb<opc, OpcodeStr, OpNode, VTInfo.info512>,
8569                               EVEX_V512;
8570
8571   let Predicates = [prd, HasVLX] in {
8572     defm Z256 : avx512_unary_rmb<opc, OpcodeStr, OpNode, VTInfo.info256>,
8573                                  EVEX_V256;
8574     defm Z128 : avx512_unary_rmb<opc, OpcodeStr, OpNode, VTInfo.info128>,
8575                                  EVEX_V128;
8576   }
8577 }
8578
8579 multiclass avx512_unary_rm_vl_dq<bits<8> opc_d, bits<8> opc_q, string OpcodeStr,
8580                                  SDNode OpNode, Predicate prd> {
8581   defm Q : avx512_unary_rmb_vl<opc_q, OpcodeStr#"q", OpNode, avx512vl_i64_info,
8582                                prd>, VEX_W;
8583   defm D : avx512_unary_rmb_vl<opc_d, OpcodeStr#"d", OpNode, avx512vl_i32_info,
8584                                prd>;
8585 }
8586
8587 multiclass avx512_unary_rm_vl_bw<bits<8> opc_b, bits<8> opc_w, string OpcodeStr,
8588                                  SDNode OpNode, Predicate prd> {
8589   defm W : avx512_unary_rm_vl<opc_w, OpcodeStr#"w", OpNode, avx512vl_i16_info, prd>;
8590   defm B : avx512_unary_rm_vl<opc_b, OpcodeStr#"b", OpNode, avx512vl_i8_info, prd>;
8591 }
8592
8593 multiclass avx512_unary_rm_vl_all<bits<8> opc_b, bits<8> opc_w,
8594                                   bits<8> opc_d, bits<8> opc_q,
8595                                   string OpcodeStr, SDNode OpNode> {
8596   defm NAME : avx512_unary_rm_vl_dq<opc_d, opc_q, OpcodeStr, OpNode,
8597                                     HasAVX512>,
8598               avx512_unary_rm_vl_bw<opc_b, opc_w, OpcodeStr, OpNode,
8599                                     HasBWI>;
8600 }
8601
8602 defm VPABS : avx512_unary_rm_vl_all<0x1C, 0x1D, 0x1E, 0x1F, "vpabs", abs>;
8603
8604 // VPABS: Use 512bit version to implement 128/256 bit in case NoVLX.
8605 let Predicates = [HasAVX512, NoVLX] in {
8606   def : Pat<(v4i64 (abs VR256X:$src)),
8607             (EXTRACT_SUBREG
8608                 (VPABSQZrr
8609                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)),
8610              sub_ymm)>;
8611   def : Pat<(v2i64 (abs VR128X:$src)),
8612             (EXTRACT_SUBREG
8613                 (VPABSQZrr
8614                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)),
8615              sub_xmm)>;
8616 }
8617
8618 multiclass avx512_ctlz<bits<8> opc, string OpcodeStr, Predicate prd>{
8619
8620   defm NAME :          avx512_unary_rm_vl_dq<opc, opc, OpcodeStr, ctlz, prd>;
8621 }
8622
8623 defm VPLZCNT    : avx512_ctlz<0x44, "vplzcnt", HasCDI>;
8624 defm VPCONFLICT : avx512_unary_rm_vl_dq<0xC4, 0xC4, "vpconflict", X86Conflict, HasCDI>;
8625
8626 // VPLZCNT: Use 512bit version to implement 128/256 bit in case NoVLX.
8627 let Predicates = [HasCDI, NoVLX] in {
8628   def : Pat<(v4i64 (ctlz VR256X:$src)),
8629             (EXTRACT_SUBREG
8630                 (VPLZCNTQZrr
8631                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)),
8632              sub_ymm)>;
8633   def : Pat<(v2i64 (ctlz VR128X:$src)),
8634             (EXTRACT_SUBREG
8635                 (VPLZCNTQZrr
8636                     (INSERT_SUBREG (v8i64 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)),
8637              sub_xmm)>;
8638
8639   def : Pat<(v8i32 (ctlz VR256X:$src)),
8640             (EXTRACT_SUBREG
8641                 (VPLZCNTDZrr
8642                     (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR256X:$src, sub_ymm)),
8643              sub_ymm)>;
8644   def : Pat<(v4i32 (ctlz VR128X:$src)),
8645             (EXTRACT_SUBREG
8646                 (VPLZCNTDZrr
8647                     (INSERT_SUBREG (v16i32 (IMPLICIT_DEF)), VR128X:$src, sub_xmm)),
8648              sub_xmm)>;
8649 }
8650
8651 //===---------------------------------------------------------------------===//
8652 // Replicate Single FP - MOVSHDUP and MOVSLDUP
8653 //===---------------------------------------------------------------------===//
8654 multiclass avx512_replicate<bits<8> opc, string OpcodeStr, SDNode OpNode>{
8655   defm NAME:       avx512_unary_rm_vl<opc, OpcodeStr, OpNode, avx512vl_f32_info,
8656                                       HasAVX512>, XS;
8657 }
8658
8659 defm VMOVSHDUP : avx512_replicate<0x16, "vmovshdup", X86Movshdup>;
8660 defm VMOVSLDUP : avx512_replicate<0x12, "vmovsldup", X86Movsldup>;
8661
8662 //===----------------------------------------------------------------------===//
8663 // AVX-512 - MOVDDUP
8664 //===----------------------------------------------------------------------===//
8665
8666 multiclass avx512_movddup_128<bits<8> opc, string OpcodeStr, SDNode OpNode,
8667                                                             X86VectorVTInfo _> {
8668   let ExeDomain = _.ExeDomain in {
8669   defm rr : AVX512_maskable<opc, MRMSrcReg, _, (outs _.RC:$dst),
8670                    (ins _.RC:$src), OpcodeStr, "$src", "$src",
8671                    (_.VT (OpNode (_.VT _.RC:$src)))>, EVEX;
8672   defm rm : AVX512_maskable<opc, MRMSrcMem, _, (outs _.RC:$dst),
8673                  (ins _.ScalarMemOp:$src), OpcodeStr, "$src", "$src",
8674                  (_.VT (OpNode (_.VT (scalar_to_vector
8675                                        (_.ScalarLdFrag addr:$src)))))>,
8676                  EVEX, EVEX_CD8<_.EltSize, CD8VH>;
8677   }
8678 }
8679
8680 multiclass avx512_movddup_common<bits<8> opc, string OpcodeStr, SDNode OpNode,
8681                                                   AVX512VLVectorVTInfo VTInfo> {
8682
8683   defm Z : avx512_unary_rm<opc, OpcodeStr, OpNode, VTInfo.info512>, EVEX_V512;
8684
8685   let Predicates = [HasAVX512, HasVLX] in {
8686     defm Z256 : avx512_unary_rm<opc, OpcodeStr, OpNode, VTInfo.info256>,
8687                                EVEX_V256;
8688     defm Z128 : avx512_movddup_128<opc, OpcodeStr, OpNode, VTInfo.info128>,
8689                                EVEX_V128;
8690   }
8691 }
8692
8693 multiclass avx512_movddup<bits<8> opc, string OpcodeStr, SDNode OpNode>{
8694   defm NAME:      avx512_movddup_common<opc, OpcodeStr, OpNode,
8695                                         avx512vl_f64_info>, XD, VEX_W;
8696 }
8697
8698 defm VMOVDDUP : avx512_movddup<0x12, "vmovddup", X86Movddup>;
8699
8700 let Predicates = [HasVLX] in {
8701 def : Pat<(X86Movddup (loadv2f64 addr:$src)),
8702           (VMOVDDUPZ128rm addr:$src)>;
8703 def : Pat<(v2f64 (X86VBroadcast (loadf64 addr:$src))),
8704           (VMOVDDUPZ128rm addr:$src)>;
8705 def : Pat<(v2f64 (X86VBroadcast f64:$src)),
8706           (VMOVDDUPZ128rr (COPY_TO_REGCLASS FR64X:$src, VR128X))>;
8707
8708 def : Pat<(vselect (v2i1 VK2WM:$mask), (X86Movddup (loadv2f64 addr:$src)),
8709                    (v2f64 VR128X:$src0)),
8710           (VMOVDDUPZ128rmk VR128X:$src0, VK2WM:$mask, addr:$src)>;
8711 def : Pat<(vselect (v2i1 VK2WM:$mask), (X86Movddup (loadv2f64 addr:$src)),
8712                    (bitconvert (v4i32 immAllZerosV))),
8713           (VMOVDDUPZ128rmkz VK2WM:$mask, addr:$src)>;
8714
8715 def : Pat<(vselect (v2i1 VK2WM:$mask), (v2f64 (X86VBroadcast f64:$src)),
8716                    (v2f64 VR128X:$src0)),
8717           (VMOVDDUPZ128rrk VR128X:$src0, VK2WM:$mask,
8718                            (COPY_TO_REGCLASS FR64X:$src, VR128X))>;
8719 def : Pat<(vselect (v2i1 VK2WM:$mask), (v2f64 (X86VBroadcast f64:$src)),
8720                    (bitconvert (v4i32 immAllZerosV))),
8721           (VMOVDDUPZ128rrkz VK2WM:$mask, (COPY_TO_REGCLASS FR64X:$src, VR128X))>;
8722
8723 def : Pat<(vselect (v2i1 VK2WM:$mask), (v2f64 (X86VBroadcast (loadf64 addr:$src))),
8724                    (v2f64 VR128X:$src0)),
8725           (VMOVDDUPZ128rmk VR128X:$src0, VK2WM:$mask, addr:$src)>;
8726 def : Pat<(vselect (v2i1 VK2WM:$mask), (v2f64 (X86VBroadcast (loadf64 addr:$src))),
8727                    (bitconvert (v4i32 immAllZerosV))),
8728           (VMOVDDUPZ128rmkz VK2WM:$mask, addr:$src)>;
8729 }
8730
8731 //===----------------------------------------------------------------------===//
8732 // AVX-512 - Unpack Instructions
8733 //===----------------------------------------------------------------------===//
8734 defm VUNPCKH : avx512_fp_binop_p<0x15, "vunpckh", X86Unpckh, HasAVX512,
8735                                  SSE_ALU_ITINS_S>;
8736 defm VUNPCKL : avx512_fp_binop_p<0x14, "vunpckl", X86Unpckl, HasAVX512,
8737                                  SSE_ALU_ITINS_S>;
8738
8739 defm VPUNPCKLBW : avx512_binop_rm_vl_b<0x60, "vpunpcklbw", X86Unpckl,
8740                                        SSE_INTALU_ITINS_P, HasBWI>;
8741 defm VPUNPCKHBW : avx512_binop_rm_vl_b<0x68, "vpunpckhbw", X86Unpckh,
8742                                        SSE_INTALU_ITINS_P, HasBWI>;
8743 defm VPUNPCKLWD : avx512_binop_rm_vl_w<0x61, "vpunpcklwd", X86Unpckl,
8744                                        SSE_INTALU_ITINS_P, HasBWI>;
8745 defm VPUNPCKHWD : avx512_binop_rm_vl_w<0x69, "vpunpckhwd", X86Unpckh,
8746                                        SSE_INTALU_ITINS_P, HasBWI>;
8747
8748 defm VPUNPCKLDQ : avx512_binop_rm_vl_d<0x62, "vpunpckldq", X86Unpckl,
8749                                        SSE_INTALU_ITINS_P, HasAVX512>;
8750 defm VPUNPCKHDQ : avx512_binop_rm_vl_d<0x6A, "vpunpckhdq", X86Unpckh,
8751                                        SSE_INTALU_ITINS_P, HasAVX512>;
8752 defm VPUNPCKLQDQ : avx512_binop_rm_vl_q<0x6C, "vpunpcklqdq", X86Unpckl,
8753                                        SSE_INTALU_ITINS_P, HasAVX512>;
8754 defm VPUNPCKHQDQ : avx512_binop_rm_vl_q<0x6D, "vpunpckhqdq", X86Unpckh,
8755                                        SSE_INTALU_ITINS_P, HasAVX512>;
8756
8757 //===----------------------------------------------------------------------===//
8758 // AVX-512 - Extract & Insert Integer Instructions
8759 //===----------------------------------------------------------------------===//
8760
8761 multiclass avx512_extract_elt_bw_m<bits<8> opc, string OpcodeStr, SDNode OpNode,
8762                                                             X86VectorVTInfo _> {
8763   def mr : AVX512Ii8<opc, MRMDestMem, (outs),
8764               (ins _.ScalarMemOp:$dst, _.RC:$src1, u8imm:$src2),
8765               OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8766               [(store (_.EltVT (trunc (assertzext (OpNode (_.VT _.RC:$src1),
8767                                                           imm:$src2)))),
8768                       addr:$dst)]>,
8769               EVEX, EVEX_CD8<_.EltSize, CD8VT1>;
8770 }
8771
8772 multiclass avx512_extract_elt_b<string OpcodeStr, X86VectorVTInfo _> {
8773   let Predicates = [HasBWI] in {
8774     def rr : AVX512Ii8<0x14, MRMDestReg, (outs GR32orGR64:$dst),
8775                   (ins _.RC:$src1, u8imm:$src2),
8776                   OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8777                   [(set GR32orGR64:$dst,
8778                         (X86pextrb (_.VT _.RC:$src1), imm:$src2))]>,
8779                   EVEX, TAPD;
8780
8781     defm NAME : avx512_extract_elt_bw_m<0x14, OpcodeStr, X86pextrb, _>, TAPD;
8782   }
8783 }
8784
8785 multiclass avx512_extract_elt_w<string OpcodeStr, X86VectorVTInfo _> {
8786   let Predicates = [HasBWI] in {
8787     def rr : AVX512Ii8<0xC5, MRMSrcReg, (outs GR32orGR64:$dst),
8788                   (ins _.RC:$src1, u8imm:$src2),
8789                   OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8790                   [(set GR32orGR64:$dst,
8791                         (X86pextrw (_.VT _.RC:$src1), imm:$src2))]>,
8792                   EVEX, PD;
8793
8794     let hasSideEffects = 0 in
8795     def rr_REV : AVX512Ii8<0x15, MRMDestReg, (outs GR32orGR64:$dst),
8796                    (ins _.RC:$src1, u8imm:$src2),
8797                    OpcodeStr#".s\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
8798                    EVEX, TAPD;
8799
8800     defm NAME : avx512_extract_elt_bw_m<0x15, OpcodeStr, X86pextrw, _>, TAPD;
8801   }
8802 }
8803
8804 multiclass avx512_extract_elt_dq<string OpcodeStr, X86VectorVTInfo _,
8805                                                             RegisterClass GRC> {
8806   let Predicates = [HasDQI] in {
8807     def rr : AVX512Ii8<0x16, MRMDestReg, (outs GRC:$dst),
8808                   (ins _.RC:$src1, u8imm:$src2),
8809                   OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8810                   [(set GRC:$dst,
8811                       (extractelt (_.VT _.RC:$src1), imm:$src2))]>,
8812                   EVEX, TAPD;
8813
8814     def mr : AVX512Ii8<0x16, MRMDestMem, (outs),
8815                 (ins _.ScalarMemOp:$dst, _.RC:$src1, u8imm:$src2),
8816                 OpcodeStr#"\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8817                 [(store (extractelt (_.VT _.RC:$src1),
8818                                     imm:$src2),addr:$dst)]>,
8819                 EVEX, EVEX_CD8<_.EltSize, CD8VT1>, TAPD;
8820   }
8821 }
8822
8823 defm VPEXTRBZ : avx512_extract_elt_b<"vpextrb", v16i8x_info>;
8824 defm VPEXTRWZ : avx512_extract_elt_w<"vpextrw", v8i16x_info>;
8825 defm VPEXTRDZ : avx512_extract_elt_dq<"vpextrd", v4i32x_info, GR32>;
8826 defm VPEXTRQZ : avx512_extract_elt_dq<"vpextrq", v2i64x_info, GR64>, VEX_W;
8827
8828 multiclass avx512_insert_elt_m<bits<8> opc, string OpcodeStr, SDNode OpNode,
8829                                             X86VectorVTInfo _, PatFrag LdFrag> {
8830   def rm : AVX512Ii8<opc, MRMSrcMem, (outs _.RC:$dst),
8831       (ins _.RC:$src1,  _.ScalarMemOp:$src2, u8imm:$src3),
8832       OpcodeStr#"\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8833       [(set _.RC:$dst,
8834           (_.VT (OpNode _.RC:$src1, (LdFrag addr:$src2), imm:$src3)))]>,
8835       EVEX_4V, EVEX_CD8<_.EltSize, CD8VT1>;
8836 }
8837
8838 multiclass avx512_insert_elt_bw<bits<8> opc, string OpcodeStr, SDNode OpNode,
8839                                             X86VectorVTInfo _, PatFrag LdFrag> {
8840   let Predicates = [HasBWI] in {
8841     def rr : AVX512Ii8<opc, MRMSrcReg, (outs _.RC:$dst),
8842         (ins _.RC:$src1, GR32orGR64:$src2, u8imm:$src3),
8843         OpcodeStr#"\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8844         [(set _.RC:$dst,
8845             (OpNode _.RC:$src1, GR32orGR64:$src2, imm:$src3))]>, EVEX_4V;
8846
8847     defm NAME : avx512_insert_elt_m<opc, OpcodeStr, OpNode, _, LdFrag>;
8848   }
8849 }
8850
8851 multiclass avx512_insert_elt_dq<bits<8> opc, string OpcodeStr,
8852                                          X86VectorVTInfo _, RegisterClass GRC> {
8853   let Predicates = [HasDQI] in {
8854     def rr : AVX512Ii8<opc, MRMSrcReg, (outs _.RC:$dst),
8855         (ins _.RC:$src1, GRC:$src2, u8imm:$src3),
8856         OpcodeStr#"\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8857         [(set _.RC:$dst,
8858             (_.VT (insertelt _.RC:$src1, GRC:$src2, imm:$src3)))]>,
8859         EVEX_4V, TAPD;
8860
8861     defm NAME : avx512_insert_elt_m<opc, OpcodeStr, insertelt, _,
8862                                     _.ScalarLdFrag>, TAPD;
8863   }
8864 }
8865
8866 defm VPINSRBZ : avx512_insert_elt_bw<0x20, "vpinsrb", X86pinsrb, v16i8x_info,
8867                                      extloadi8>, TAPD;
8868 defm VPINSRWZ : avx512_insert_elt_bw<0xC4, "vpinsrw", X86pinsrw, v8i16x_info,
8869                                      extloadi16>, PD;
8870 defm VPINSRDZ : avx512_insert_elt_dq<0x22, "vpinsrd", v4i32x_info, GR32>;
8871 defm VPINSRQZ : avx512_insert_elt_dq<0x22, "vpinsrq", v2i64x_info, GR64>, VEX_W;
8872 //===----------------------------------------------------------------------===//
8873 // VSHUFPS - VSHUFPD Operations
8874 //===----------------------------------------------------------------------===//
8875 multiclass avx512_shufp<string OpcodeStr, AVX512VLVectorVTInfo VTInfo_I,
8876                                                 AVX512VLVectorVTInfo VTInfo_FP>{
8877   defm NAME:     avx512_common_3Op_imm8<OpcodeStr, VTInfo_FP, 0xC6, X86Shufp>,
8878                                    EVEX_CD8<VTInfo_FP.info512.EltSize, CD8VF>,
8879                                    AVX512AIi8Base, EVEX_4V;
8880 }
8881
8882 defm VSHUFPS: avx512_shufp<"vshufps", avx512vl_i32_info, avx512vl_f32_info>, PS;
8883 defm VSHUFPD: avx512_shufp<"vshufpd", avx512vl_i64_info, avx512vl_f64_info>, PD, VEX_W;
8884 //===----------------------------------------------------------------------===//
8885 // AVX-512 - Byte shift Left/Right
8886 //===----------------------------------------------------------------------===//
8887
8888 multiclass avx512_shift_packed<bits<8> opc, SDNode OpNode, Format MRMr,
8889                              Format MRMm, string OpcodeStr, X86VectorVTInfo _>{
8890   def rr : AVX512<opc, MRMr,
8891              (outs _.RC:$dst), (ins _.RC:$src1, u8imm:$src2),
8892              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8893              [(set _.RC:$dst,(_.VT (OpNode _.RC:$src1, (i8 imm:$src2))))]>;
8894   def rm : AVX512<opc, MRMm,
8895            (outs _.RC:$dst), (ins _.MemOp:$src1, u8imm:$src2),
8896            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8897            [(set _.RC:$dst,(_.VT (OpNode
8898                                  (_.VT (bitconvert (_.LdFrag addr:$src1))),
8899                                  (i8 imm:$src2))))]>;
8900 }
8901
8902 multiclass avx512_shift_packed_all<bits<8> opc, SDNode OpNode, Format MRMr,
8903                                  Format MRMm, string OpcodeStr, Predicate prd>{
8904   let Predicates = [prd] in
8905     defm Z512 : avx512_shift_packed<opc, OpNode, MRMr, MRMm,
8906                                     OpcodeStr, v64i8_info>, EVEX_V512;
8907   let Predicates = [prd, HasVLX] in {
8908     defm Z256 : avx512_shift_packed<opc, OpNode, MRMr, MRMm,
8909                                     OpcodeStr, v32i8x_info>, EVEX_V256;
8910     defm Z128 : avx512_shift_packed<opc, OpNode, MRMr, MRMm,
8911                                     OpcodeStr, v16i8x_info>, EVEX_V128;
8912   }
8913 }
8914 defm VPSLLDQ : avx512_shift_packed_all<0x73, X86vshldq, MRM7r, MRM7m, "vpslldq",
8915                                        HasBWI>, AVX512PDIi8Base, EVEX_4V;
8916 defm VPSRLDQ : avx512_shift_packed_all<0x73, X86vshrdq, MRM3r, MRM3m, "vpsrldq",
8917                                        HasBWI>, AVX512PDIi8Base, EVEX_4V;
8918
8919
8920 multiclass avx512_psadbw_packed<bits<8> opc, SDNode OpNode,
8921                                 string OpcodeStr, X86VectorVTInfo _dst,
8922                                 X86VectorVTInfo _src>{
8923   def rr : AVX512BI<opc, MRMSrcReg,
8924              (outs _dst.RC:$dst), (ins _src.RC:$src1, _src.RC:$src2),
8925              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8926              [(set _dst.RC:$dst,(_dst.VT
8927                                 (OpNode (_src.VT _src.RC:$src1),
8928                                         (_src.VT _src.RC:$src2))))]>;
8929   def rm : AVX512BI<opc, MRMSrcMem,
8930            (outs _dst.RC:$dst), (ins _src.RC:$src1, _src.MemOp:$src2),
8931            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8932            [(set _dst.RC:$dst,(_dst.VT
8933                               (OpNode (_src.VT _src.RC:$src1),
8934                               (_src.VT (bitconvert
8935                                         (_src.LdFrag addr:$src2))))))]>;
8936 }
8937
8938 multiclass avx512_psadbw_packed_all<bits<8> opc, SDNode OpNode,
8939                                     string OpcodeStr, Predicate prd> {
8940   let Predicates = [prd] in
8941     defm Z512 : avx512_psadbw_packed<opc, OpNode, OpcodeStr, v8i64_info,
8942                                     v64i8_info>, EVEX_V512;
8943   let Predicates = [prd, HasVLX] in {
8944     defm Z256 : avx512_psadbw_packed<opc, OpNode, OpcodeStr, v4i64x_info,
8945                                     v32i8x_info>, EVEX_V256;
8946     defm Z128 : avx512_psadbw_packed<opc, OpNode, OpcodeStr, v2i64x_info,
8947                                     v16i8x_info>, EVEX_V128;
8948   }
8949 }
8950
8951 defm VPSADBW : avx512_psadbw_packed_all<0xf6, X86psadbw, "vpsadbw",
8952                                        HasBWI>, EVEX_4V;
8953
8954 // Transforms to swizzle an immediate to enable better matching when
8955 // memory operand isn't in the right place.
8956 def VPTERNLOG321_imm8 : SDNodeXForm<imm, [{
8957   // Convert a VPTERNLOG immediate by swapping operand 0 and operand 2.
8958   uint8_t Imm = N->getZExtValue();
8959   // Swap bits 1/4 and 3/6.
8960   uint8_t NewImm = Imm & 0xa5;
8961   if (Imm & 0x02) NewImm |= 0x10;
8962   if (Imm & 0x10) NewImm |= 0x02;
8963   if (Imm & 0x08) NewImm |= 0x40;
8964   if (Imm & 0x40) NewImm |= 0x08;
8965   return getI8Imm(NewImm, SDLoc(N));
8966 }]>;
8967 def VPTERNLOG213_imm8 : SDNodeXForm<imm, [{
8968   // Convert a VPTERNLOG immediate by swapping operand 1 and operand 2.
8969   uint8_t Imm = N->getZExtValue();
8970   // Swap bits 2/4 and 3/5.
8971   uint8_t NewImm = Imm & 0xc3;
8972   if (Imm & 0x04) NewImm |= 0x10;
8973   if (Imm & 0x10) NewImm |= 0x04;
8974   if (Imm & 0x08) NewImm |= 0x20;
8975   if (Imm & 0x20) NewImm |= 0x08;
8976   return getI8Imm(NewImm, SDLoc(N));
8977 }]>;
8978 def VPTERNLOG132_imm8 : SDNodeXForm<imm, [{
8979   // Convert a VPTERNLOG immediate by swapping operand 1 and operand 2.
8980   uint8_t Imm = N->getZExtValue();
8981   // Swap bits 1/2 and 5/6.
8982   uint8_t NewImm = Imm & 0x99;
8983   if (Imm & 0x02) NewImm |= 0x04;
8984   if (Imm & 0x04) NewImm |= 0x02;
8985   if (Imm & 0x20) NewImm |= 0x40;
8986   if (Imm & 0x40) NewImm |= 0x20;
8987   return getI8Imm(NewImm, SDLoc(N));
8988 }]>;
8989 def VPTERNLOG231_imm8 : SDNodeXForm<imm, [{
8990   // Convert a VPTERNLOG immediate by moving operand 1 to the end.
8991   uint8_t Imm = N->getZExtValue();
8992   // Move bits 1->2, 2->4, 3->6, 4->1, 5->3, 6->5
8993   uint8_t NewImm = Imm & 0x81;
8994   if (Imm & 0x02) NewImm |= 0x04;
8995   if (Imm & 0x04) NewImm |= 0x10;
8996   if (Imm & 0x08) NewImm |= 0x40;
8997   if (Imm & 0x10) NewImm |= 0x02;
8998   if (Imm & 0x20) NewImm |= 0x08;
8999   if (Imm & 0x40) NewImm |= 0x20;
9000   return getI8Imm(NewImm, SDLoc(N));
9001 }]>;
9002 def VPTERNLOG312_imm8 : SDNodeXForm<imm, [{
9003   // Convert a VPTERNLOG immediate by moving operand 2 to the beginning.
9004   uint8_t Imm = N->getZExtValue();
9005   // Move bits 1->4, 2->1, 3->5, 4->2, 5->6, 6->3
9006   uint8_t NewImm = Imm & 0x81;
9007   if (Imm & 0x02) NewImm |= 0x10;
9008   if (Imm & 0x04) NewImm |= 0x02;
9009   if (Imm & 0x08) NewImm |= 0x20;
9010   if (Imm & 0x10) NewImm |= 0x04;
9011   if (Imm & 0x20) NewImm |= 0x40;
9012   if (Imm & 0x40) NewImm |= 0x08;
9013   return getI8Imm(NewImm, SDLoc(N));
9014 }]>;
9015
9016 multiclass avx512_ternlog<bits<8> opc, string OpcodeStr, SDNode OpNode,
9017                           X86VectorVTInfo _>{
9018   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
9019   defm rri : AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
9020                       (ins _.RC:$src2, _.RC:$src3, u8imm:$src4),
9021                       OpcodeStr, "$src4, $src3, $src2", "$src2, $src3, $src4",
9022                       (OpNode (_.VT _.RC:$src1),
9023                               (_.VT _.RC:$src2),
9024                               (_.VT _.RC:$src3),
9025                               (i8 imm:$src4)), 1, 1>, AVX512AIi8Base, EVEX_4V;
9026   defm rmi : AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
9027                     (ins _.RC:$src2, _.MemOp:$src3, u8imm:$src4),
9028                     OpcodeStr, "$src4, $src3, $src2", "$src2, $src3, $src4",
9029                     (OpNode (_.VT _.RC:$src1),
9030                             (_.VT _.RC:$src2),
9031                             (_.VT (bitconvert (_.LdFrag addr:$src3))),
9032                             (i8 imm:$src4)), 1, 0>,
9033                     AVX512AIi8Base, EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
9034   defm rmbi : AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
9035                     (ins _.RC:$src2, _.ScalarMemOp:$src3, u8imm:$src4),
9036                     OpcodeStr, "$src4, ${src3}"##_.BroadcastStr##", $src2",
9037                     "$src2, ${src3}"##_.BroadcastStr##", $src4",
9038                     (OpNode (_.VT _.RC:$src1),
9039                             (_.VT _.RC:$src2),
9040                             (_.VT (X86VBroadcast(_.ScalarLdFrag addr:$src3))),
9041                             (i8 imm:$src4)), 1, 0>, EVEX_B,
9042                     AVX512AIi8Base, EVEX_4V, EVEX_CD8<_.EltSize, CD8VF>;
9043   }// Constraints = "$src1 = $dst"
9044
9045   // Additional patterns for matching passthru operand in other positions.
9046   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9047                    (OpNode _.RC:$src3, _.RC:$src2, _.RC:$src1, (i8 imm:$src4)),
9048                    _.RC:$src1)),
9049             (!cast<Instruction>(NAME#_.ZSuffix#rrik) _.RC:$src1, _.KRCWM:$mask,
9050              _.RC:$src2, _.RC:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9051   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9052                    (OpNode _.RC:$src2, _.RC:$src1, _.RC:$src3, (i8 imm:$src4)),
9053                    _.RC:$src1)),
9054             (!cast<Instruction>(NAME#_.ZSuffix#rrik) _.RC:$src1, _.KRCWM:$mask,
9055              _.RC:$src2, _.RC:$src3, (VPTERNLOG213_imm8 imm:$src4))>;
9056
9057   // Additional patterns for matching loads in other positions.
9058   def : Pat<(_.VT (OpNode (bitconvert (_.LdFrag addr:$src3)),
9059                           _.RC:$src2, _.RC:$src1, (i8 imm:$src4))),
9060             (!cast<Instruction>(NAME#_.ZSuffix#rmi) _.RC:$src1, _.RC:$src2,
9061                                    addr:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9062   def : Pat<(_.VT (OpNode _.RC:$src1,
9063                           (bitconvert (_.LdFrag addr:$src3)),
9064                           _.RC:$src2, (i8 imm:$src4))),
9065             (!cast<Instruction>(NAME#_.ZSuffix#rmi) _.RC:$src1, _.RC:$src2,
9066                                    addr:$src3, (VPTERNLOG132_imm8 imm:$src4))>;
9067
9068   // Additional patterns for matching zero masking with loads in other
9069   // positions.
9070   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9071                    (OpNode (bitconvert (_.LdFrag addr:$src3)),
9072                     _.RC:$src2, _.RC:$src1, (i8 imm:$src4)),
9073                    _.ImmAllZerosV)),
9074             (!cast<Instruction>(NAME#_.ZSuffix#rmikz) _.RC:$src1, _.KRCWM:$mask,
9075              _.RC:$src2, addr:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9076   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9077                    (OpNode _.RC:$src1, (bitconvert (_.LdFrag addr:$src3)),
9078                     _.RC:$src2, (i8 imm:$src4)),
9079                    _.ImmAllZerosV)),
9080             (!cast<Instruction>(NAME#_.ZSuffix#rmikz) _.RC:$src1, _.KRCWM:$mask,
9081              _.RC:$src2, addr:$src3, (VPTERNLOG132_imm8 imm:$src4))>;
9082
9083   // Additional patterns for matching masked loads with different
9084   // operand orders.
9085   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9086                    (OpNode _.RC:$src1, (bitconvert (_.LdFrag addr:$src3)),
9087                     _.RC:$src2, (i8 imm:$src4)),
9088                    _.RC:$src1)),
9089             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9090              _.RC:$src2, addr:$src3, (VPTERNLOG132_imm8 imm:$src4))>;
9091   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9092                    (OpNode (bitconvert (_.LdFrag addr:$src3)),
9093                     _.RC:$src2, _.RC:$src1, (i8 imm:$src4)),
9094                    _.RC:$src1)),
9095             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9096              _.RC:$src2, addr:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9097   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9098                    (OpNode _.RC:$src2, _.RC:$src1,
9099                     (bitconvert (_.LdFrag addr:$src3)), (i8 imm:$src4)),
9100                    _.RC:$src1)),
9101             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9102              _.RC:$src2, addr:$src3, (VPTERNLOG213_imm8 imm:$src4))>;
9103   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9104                    (OpNode _.RC:$src2, (bitconvert (_.LdFrag addr:$src3)),
9105                     _.RC:$src1, (i8 imm:$src4)),
9106                    _.RC:$src1)),
9107             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9108              _.RC:$src2, addr:$src3, (VPTERNLOG231_imm8 imm:$src4))>;
9109   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9110                    (OpNode (bitconvert (_.LdFrag addr:$src3)),
9111                     _.RC:$src1, _.RC:$src2, (i8 imm:$src4)),
9112                    _.RC:$src1)),
9113             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9114              _.RC:$src2, addr:$src3, (VPTERNLOG312_imm8 imm:$src4))>;
9115
9116   // Additional patterns for matching broadcasts in other positions.
9117   def : Pat<(_.VT (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9118                           _.RC:$src2, _.RC:$src1, (i8 imm:$src4))),
9119             (!cast<Instruction>(NAME#_.ZSuffix#rmbi) _.RC:$src1, _.RC:$src2,
9120                                    addr:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9121   def : Pat<(_.VT (OpNode _.RC:$src1,
9122                           (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9123                           _.RC:$src2, (i8 imm:$src4))),
9124             (!cast<Instruction>(NAME#_.ZSuffix#rmbi) _.RC:$src1, _.RC:$src2,
9125                                    addr:$src3, (VPTERNLOG132_imm8 imm:$src4))>;
9126
9127   // Additional patterns for matching zero masking with broadcasts in other
9128   // positions.
9129   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9130                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9131                     _.RC:$src2, _.RC:$src1, (i8 imm:$src4)),
9132                    _.ImmAllZerosV)),
9133             (!cast<Instruction>(NAME#_.ZSuffix#rmbikz) _.RC:$src1,
9134              _.KRCWM:$mask, _.RC:$src2, addr:$src3,
9135              (VPTERNLOG321_imm8 imm:$src4))>;
9136   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9137                    (OpNode _.RC:$src1,
9138                     (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9139                     _.RC:$src2, (i8 imm:$src4)),
9140                    _.ImmAllZerosV)),
9141             (!cast<Instruction>(NAME#_.ZSuffix#rmbikz) _.RC:$src1,
9142              _.KRCWM:$mask, _.RC:$src2, addr:$src3,
9143              (VPTERNLOG132_imm8 imm:$src4))>;
9144
9145   // Additional patterns for matching masked broadcasts with different
9146   // operand orders.
9147   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9148                    (OpNode _.RC:$src1,
9149                     (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9150                     _.RC:$src2, (i8 imm:$src4)),
9151                    _.RC:$src1)),
9152             (!cast<Instruction>(NAME#_.ZSuffix#rmbik) _.RC:$src1, _.KRCWM:$mask,
9153              _.RC:$src2, addr:$src3, (VPTERNLOG132_imm8 imm:$src4))>;
9154   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9155                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9156                     _.RC:$src2, _.RC:$src1, (i8 imm:$src4)),
9157                    _.RC:$src1)),
9158             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9159              _.RC:$src2, addr:$src3, (VPTERNLOG321_imm8 imm:$src4))>;
9160   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9161                    (OpNode _.RC:$src2, _.RC:$src1,
9162                     (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9163                     (i8 imm:$src4)), _.RC:$src1)),
9164             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9165              _.RC:$src2, addr:$src3, (VPTERNLOG213_imm8 imm:$src4))>;
9166   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9167                    (OpNode _.RC:$src2,
9168                     (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9169                     _.RC:$src1, (i8 imm:$src4)),
9170                    _.RC:$src1)),
9171             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9172              _.RC:$src2, addr:$src3, (VPTERNLOG231_imm8 imm:$src4))>;
9173   def : Pat<(_.VT (vselect _.KRCWM:$mask,
9174                    (OpNode (X86VBroadcast (_.ScalarLdFrag addr:$src3)),
9175                     _.RC:$src1, _.RC:$src2, (i8 imm:$src4)),
9176                    _.RC:$src1)),
9177             (!cast<Instruction>(NAME#_.ZSuffix#rmik) _.RC:$src1, _.KRCWM:$mask,
9178              _.RC:$src2, addr:$src3, (VPTERNLOG312_imm8 imm:$src4))>;
9179 }
9180
9181 multiclass avx512_common_ternlog<string OpcodeStr, AVX512VLVectorVTInfo _>{
9182   let Predicates = [HasAVX512] in
9183     defm Z    : avx512_ternlog<0x25, OpcodeStr, X86vpternlog, _.info512>, EVEX_V512;
9184   let Predicates = [HasAVX512, HasVLX] in {
9185     defm Z128 : avx512_ternlog<0x25, OpcodeStr, X86vpternlog, _.info128>, EVEX_V128;
9186     defm Z256 : avx512_ternlog<0x25, OpcodeStr, X86vpternlog, _.info256>, EVEX_V256;
9187   }
9188 }
9189
9190 defm VPTERNLOGD : avx512_common_ternlog<"vpternlogd", avx512vl_i32_info>;
9191 defm VPTERNLOGQ : avx512_common_ternlog<"vpternlogq", avx512vl_i64_info>, VEX_W;
9192
9193 //===----------------------------------------------------------------------===//
9194 // AVX-512 - FixupImm
9195 //===----------------------------------------------------------------------===//
9196
9197 multiclass avx512_fixupimm_packed<bits<8> opc, string OpcodeStr, SDNode OpNode,
9198                                   X86VectorVTInfo _>{
9199   let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
9200     defm rri : AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
9201                         (ins _.RC:$src2, _.RC:$src3, i32u8imm:$src4),
9202                          OpcodeStr##_.Suffix, "$src4, $src3, $src2", "$src2, $src3, $src4",
9203                         (OpNode (_.VT _.RC:$src1),
9204                                 (_.VT _.RC:$src2),
9205                                 (_.IntVT _.RC:$src3),
9206                                 (i32 imm:$src4),
9207                                 (i32 FROUND_CURRENT))>;
9208     defm rmi : AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
9209                       (ins _.RC:$src2, _.MemOp:$src3, i32u8imm:$src4),
9210                       OpcodeStr##_.Suffix, "$src4, $src3, $src2", "$src2, $src3, $src4",
9211                       (OpNode (_.VT _.RC:$src1),
9212                               (_.VT _.RC:$src2),
9213                               (_.IntVT (bitconvert (_.LdFrag addr:$src3))),
9214                               (i32 imm:$src4),
9215                               (i32 FROUND_CURRENT))>;
9216     defm rmbi : AVX512_maskable_3src<opc, MRMSrcMem, _, (outs _.RC:$dst),
9217                       (ins _.RC:$src2, _.ScalarMemOp:$src3, i32u8imm:$src4),
9218                     OpcodeStr##_.Suffix, "$src4, ${src3}"##_.BroadcastStr##", $src2",
9219                     "$src2, ${src3}"##_.BroadcastStr##", $src4",
9220                       (OpNode (_.VT _.RC:$src1),
9221                               (_.VT _.RC:$src2),
9222                               (_.IntVT (X86VBroadcast(_.ScalarLdFrag addr:$src3))),
9223                               (i32 imm:$src4),
9224                               (i32 FROUND_CURRENT))>, EVEX_B;
9225   } // Constraints = "$src1 = $dst"
9226 }
9227
9228 multiclass avx512_fixupimm_packed_sae<bits<8> opc, string OpcodeStr,
9229                                       SDNode OpNode, X86VectorVTInfo _>{
9230 let Constraints = "$src1 = $dst", ExeDomain = _.ExeDomain in {
9231   defm rrib : AVX512_maskable_3src<opc, MRMSrcReg, _, (outs _.RC:$dst),
9232                       (ins _.RC:$src2, _.RC:$src3, i32u8imm:$src4),
9233                       OpcodeStr##_.Suffix, "$src4, {sae}, $src3, $src2",
9234                       "$src2, $src3, {sae}, $src4",
9235                       (OpNode (_.VT _.RC:$src1),
9236                                 (_.VT _.RC:$src2),
9237                                 (_.IntVT _.RC:$src3),
9238                                 (i32 imm:$src4),
9239                                 (i32 FROUND_NO_EXC))>, EVEX_B;
9240   }
9241 }
9242
9243 multiclass avx512_fixupimm_scalar<bits<8> opc, string OpcodeStr, SDNode OpNode,
9244                                   X86VectorVTInfo _, X86VectorVTInfo _src3VT> {
9245   let Constraints = "$src1 = $dst" , Predicates = [HasAVX512],
9246       ExeDomain = _.ExeDomain in {
9247     defm rri : AVX512_maskable_3src_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
9248                       (ins _.RC:$src2, _.RC:$src3, i32u8imm:$src4),
9249                       OpcodeStr##_.Suffix, "$src4, $src3, $src2", "$src2, $src3, $src4",
9250                       (OpNode (_.VT _.RC:$src1),
9251                               (_.VT _.RC:$src2),
9252                               (_src3VT.VT _src3VT.RC:$src3),
9253                               (i32 imm:$src4),
9254                               (i32 FROUND_CURRENT))>;
9255
9256     defm rrib : AVX512_maskable_3src_scalar<opc, MRMSrcReg, _, (outs _.RC:$dst),
9257                       (ins _.RC:$src2, _.RC:$src3, i32u8imm:$src4),
9258                       OpcodeStr##_.Suffix, "$src4, {sae}, $src3, $src2",
9259                       "$src2, $src3, {sae}, $src4",
9260                       (OpNode (_.VT _.RC:$src1),
9261                               (_.VT _.RC:$src2),
9262                               (_src3VT.VT _src3VT.RC:$src3),
9263                               (i32 imm:$src4),
9264                               (i32 FROUND_NO_EXC))>, EVEX_B;
9265     defm rmi : AVX512_maskable_3src_scalar<opc, MRMSrcMem, _, (outs _.RC:$dst),
9266                      (ins _.RC:$src2, _.ScalarMemOp:$src3, i32u8imm:$src4),
9267                      OpcodeStr##_.Suffix, "$src4, $src3, $src2", "$src2, $src3, $src4",
9268                      (OpNode (_.VT _.RC:$src1),
9269                              (_.VT _.RC:$src2),
9270                              (_src3VT.VT (scalar_to_vector
9271                                        (_src3VT.ScalarLdFrag addr:$src3))),
9272                              (i32 imm:$src4),
9273                              (i32 FROUND_CURRENT))>;
9274   }
9275 }
9276
9277 multiclass avx512_fixupimm_packed_all<AVX512VLVectorVTInfo _Vec>{
9278   let Predicates = [HasAVX512] in
9279     defm Z    : avx512_fixupimm_packed<0x54, "vfixupimm", X86VFixupimm, _Vec.info512>,
9280                 avx512_fixupimm_packed_sae<0x54, "vfixupimm", X86VFixupimm, _Vec.info512>,
9281                                   AVX512AIi8Base, EVEX_4V, EVEX_V512;
9282   let Predicates = [HasAVX512, HasVLX] in {
9283     defm Z128 : avx512_fixupimm_packed<0x54, "vfixupimm", X86VFixupimm, _Vec.info128>,
9284                                   AVX512AIi8Base, EVEX_4V, EVEX_V128;
9285     defm Z256 : avx512_fixupimm_packed<0x54, "vfixupimm", X86VFixupimm, _Vec.info256>,
9286                                   AVX512AIi8Base, EVEX_4V, EVEX_V256;
9287   }
9288 }
9289
9290 defm VFIXUPIMMSS : avx512_fixupimm_scalar<0x55, "vfixupimm", X86VFixupimmScalar,
9291                                           f32x_info, v4i32x_info>,
9292                          AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<32, CD8VT1>;
9293 defm VFIXUPIMMSD : avx512_fixupimm_scalar<0x55, "vfixupimm", X86VFixupimmScalar,
9294                                           f64x_info, v2i64x_info>,
9295                          AVX512AIi8Base, VEX_LIG, EVEX_4V, EVEX_CD8<64, CD8VT1>, VEX_W;
9296 defm VFIXUPIMMPS : avx512_fixupimm_packed_all<avx512vl_f32_info>,
9297                          EVEX_CD8<32, CD8VF>;
9298 defm VFIXUPIMMPD : avx512_fixupimm_packed_all<avx512vl_f64_info>,
9299                          EVEX_CD8<64, CD8VF>, VEX_W;
9300
9301
9302
9303 // Patterns used to select SSE scalar fp arithmetic instructions from
9304 // either:
9305 //
9306 // (1) a scalar fp operation followed by a blend
9307 //
9308 // The effect is that the backend no longer emits unnecessary vector
9309 // insert instructions immediately after SSE scalar fp instructions
9310 // like addss or mulss.
9311 //
9312 // For example, given the following code:
9313 //   __m128 foo(__m128 A, __m128 B) {
9314 //     A[0] += B[0];
9315 //     return A;
9316 //   }
9317 //
9318 // Previously we generated:
9319 //   addss %xmm0, %xmm1
9320 //   movss %xmm1, %xmm0
9321 //
9322 // We now generate:
9323 //   addss %xmm1, %xmm0
9324 //
9325 // (2) a vector packed single/double fp operation followed by a vector insert
9326 //
9327 // The effect is that the backend converts the packed fp instruction
9328 // followed by a vector insert into a single SSE scalar fp instruction.
9329 //
9330 // For example, given the following code:
9331 //   __m128 foo(__m128 A, __m128 B) {
9332 //     __m128 C = A + B;
9333 //     return (__m128) {c[0], a[1], a[2], a[3]};
9334 //   }
9335 //
9336 // Previously we generated:
9337 //   addps %xmm0, %xmm1
9338 //   movss %xmm1, %xmm0
9339 //
9340 // We now generate:
9341 //   addss %xmm1, %xmm0
9342
9343 // TODO: Some canonicalization in lowering would simplify the number of
9344 // patterns we have to try to match.
9345 multiclass AVX512_scalar_math_f32_patterns<SDNode Op, string OpcPrefix> {
9346   let Predicates = [HasAVX512] in {
9347     // extracted scalar math op with insert via movss
9348     def : Pat<(v4f32 (X86Movss (v4f32 VR128X:$dst), (v4f32 (scalar_to_vector
9349           (Op (f32 (extractelt (v4f32 VR128X:$dst), (iPTR 0))),
9350           FR32X:$src))))),
9351       (!cast<I>("V"#OpcPrefix#SSZrr_Int) v4f32:$dst,
9352           (COPY_TO_REGCLASS FR32X:$src, VR128X))>;
9353
9354     // extracted scalar math op with insert via blend
9355     def : Pat<(v4f32 (X86Blendi (v4f32 VR128X:$dst), (v4f32 (scalar_to_vector
9356           (Op (f32 (extractelt (v4f32 VR128X:$dst), (iPTR 0))),
9357           FR32X:$src))), (i8 1))),
9358       (!cast<I>("V"#OpcPrefix#SSZrr_Int) v4f32:$dst,
9359           (COPY_TO_REGCLASS FR32X:$src, VR128X))>;
9360
9361     // vector math op with insert via movss
9362     def : Pat<(v4f32 (X86Movss (v4f32 VR128X:$dst),
9363           (Op (v4f32 VR128X:$dst), (v4f32 VR128X:$src)))),
9364       (!cast<I>("V"#OpcPrefix#SSZrr_Int) v4f32:$dst, v4f32:$src)>;
9365
9366     // vector math op with insert via blend
9367     def : Pat<(v4f32 (X86Blendi (v4f32 VR128X:$dst),
9368           (Op (v4f32 VR128X:$dst), (v4f32 VR128X:$src)), (i8 1))),
9369       (!cast<I>("V"#OpcPrefix#SSZrr_Int) v4f32:$dst, v4f32:$src)>;
9370
9371     // extracted masked scalar math op with insert via movss
9372     def : Pat<(X86Movss (v4f32 VR128X:$src1),
9373                (scalar_to_vector
9374                 (X86selects VK1WM:$mask,
9375                             (Op (f32 (extractelt (v4f32 VR128X:$src1), (iPTR 0))),
9376                                 FR32X:$src2),
9377                             FR32X:$src0))),
9378       (!cast<I>("V"#OpcPrefix#SSZrr_Intk) (COPY_TO_REGCLASS FR32X:$src0, VR128X),
9379           VK1WM:$mask, v4f32:$src1,
9380           (COPY_TO_REGCLASS FR32X:$src2, VR128X))>;
9381   }
9382 }
9383
9384 defm : AVX512_scalar_math_f32_patterns<fadd, "ADD">;
9385 defm : AVX512_scalar_math_f32_patterns<fsub, "SUB">;
9386 defm : AVX512_scalar_math_f32_patterns<fmul, "MUL">;
9387 defm : AVX512_scalar_math_f32_patterns<fdiv, "DIV">;
9388
9389 multiclass AVX512_scalar_math_f64_patterns<SDNode Op, string OpcPrefix> {
9390   let Predicates = [HasAVX512] in {
9391     // extracted scalar math op with insert via movsd
9392     def : Pat<(v2f64 (X86Movsd (v2f64 VR128X:$dst), (v2f64 (scalar_to_vector
9393           (Op (f64 (extractelt (v2f64 VR128X:$dst), (iPTR 0))),
9394           FR64X:$src))))),
9395       (!cast<I>("V"#OpcPrefix#SDZrr_Int) v2f64:$dst,
9396           (COPY_TO_REGCLASS FR64X:$src, VR128X))>;
9397
9398     // extracted scalar math op with insert via blend
9399     def : Pat<(v2f64 (X86Blendi (v2f64 VR128X:$dst), (v2f64 (scalar_to_vector
9400           (Op (f64 (extractelt (v2f64 VR128X:$dst), (iPTR 0))),
9401           FR64X:$src))), (i8 1))),
9402       (!cast<I>("V"#OpcPrefix#SDZrr_Int) v2f64:$dst,
9403           (COPY_TO_REGCLASS FR64X:$src, VR128X))>;
9404
9405     // vector math op with insert via movsd
9406     def : Pat<(v2f64 (X86Movsd (v2f64 VR128X:$dst),
9407           (Op (v2f64 VR128X:$dst), (v2f64 VR128X:$src)))),
9408       (!cast<I>("V"#OpcPrefix#SDZrr_Int) v2f64:$dst, v2f64:$src)>;
9409
9410     // vector math op with insert via blend
9411     def : Pat<(v2f64 (X86Blendi (v2f64 VR128X:$dst),
9412           (Op (v2f64 VR128X:$dst), (v2f64 VR128X:$src)), (i8 1))),
9413       (!cast<I>("V"#OpcPrefix#SDZrr_Int) v2f64:$dst, v2f64:$src)>;
9414
9415     // extracted masked scalar math op with insert via movss
9416     def : Pat<(X86Movsd (v2f64 VR128X:$src1),
9417                (scalar_to_vector
9418                 (X86selects VK1WM:$mask,
9419                             (Op (f64 (extractelt (v2f64 VR128X:$src1), (iPTR 0))),
9420                                 FR64X:$src2),
9421                             FR64X:$src0))),
9422       (!cast<I>("V"#OpcPrefix#SDZrr_Intk) (COPY_TO_REGCLASS FR64X:$src0, VR128X),
9423           VK1WM:$mask, v2f64:$src1,
9424           (COPY_TO_REGCLASS FR64X:$src2, VR128X))>;
9425   }
9426 }
9427
9428 defm : AVX512_scalar_math_f64_patterns<fadd, "ADD">;
9429 defm : AVX512_scalar_math_f64_patterns<fsub, "SUB">;
9430 defm : AVX512_scalar_math_f64_patterns<fmul, "MUL">;
9431 defm : AVX512_scalar_math_f64_patterns<fdiv, "DIV">;