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

   1 //===-- X86InstrSSE.td - SSE 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 SSE instruction set, defining the instructions,
  11 // and properties of the instructions which are needed for code generation,
  12 // machine code emission, and analysis.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 class OpndItins<InstrItinClass arg_rr, InstrItinClass arg_rm> {
  17   InstrItinClass rr = arg_rr;
  18   InstrItinClass rm = arg_rm;
  19   // InstrSchedModel info.
  20   X86FoldableSchedWrite Sched = WriteFAdd;
  21 }
  22
  23 class SizeItins<OpndItins arg_s, OpndItins arg_d> {
  24   OpndItins s = arg_s;
  25   OpndItins d = arg_d;
  26 }
  27
  28
  29 class ShiftOpndItins<InstrItinClass arg_rr, InstrItinClass arg_rm,
  30   InstrItinClass arg_ri> {
  31   InstrItinClass rr = arg_rr;
  32   InstrItinClass rm = arg_rm;
  33   InstrItinClass ri = arg_ri;
  34 }
  35
  36 // scalar
  37 let Sched = WriteFAdd in {
  38 def SSE_ALU_F32S : OpndItins<
  39   IIC_SSE_ALU_F32S_RR, IIC_SSE_ALU_F32S_RM
  40 >;
  41
  42 def SSE_ALU_F64S : OpndItins<
  43   IIC_SSE_ALU_F64S_RR, IIC_SSE_ALU_F64S_RM
  44 >;
  45 }
  46
  47 def SSE_ALU_ITINS_S : SizeItins<
  48   SSE_ALU_F32S, SSE_ALU_F64S
  49 >;
  50
  51 let Sched = WriteFMul in {
  52 def SSE_MUL_F32S : OpndItins<
  53   IIC_SSE_MUL_F32S_RR, IIC_SSE_MUL_F64S_RM
  54 >;
  55
  56 def SSE_MUL_F64S : OpndItins<
  57   IIC_SSE_MUL_F64S_RR, IIC_SSE_MUL_F64S_RM
  58 >;
  59 }
  60
  61 def SSE_MUL_ITINS_S : SizeItins<
  62   SSE_MUL_F32S, SSE_MUL_F64S
  63 >;
  64
  65 let Sched = WriteFDiv in {
  66 def SSE_DIV_F32S : OpndItins<
  67   IIC_SSE_DIV_F32S_RR, IIC_SSE_DIV_F64S_RM
  68 >;
  69
  70 def SSE_DIV_F64S : OpndItins<
  71   IIC_SSE_DIV_F64S_RR, IIC_SSE_DIV_F64S_RM
  72 >;
  73 }
  74
  75 def SSE_DIV_ITINS_S : SizeItins<
  76   SSE_DIV_F32S, SSE_DIV_F64S
  77 >;
  78
  79 // parallel
  80 let Sched = WriteFAdd in {
  81 def SSE_ALU_F32P : OpndItins<
  82   IIC_SSE_ALU_F32P_RR, IIC_SSE_ALU_F32P_RM
  83 >;
  84
  85 def SSE_ALU_F64P : OpndItins<
  86   IIC_SSE_ALU_F64P_RR, IIC_SSE_ALU_F64P_RM
  87 >;
  88 }
  89
  90 def SSE_ALU_ITINS_P : SizeItins<
  91   SSE_ALU_F32P, SSE_ALU_F64P
  92 >;
  93
  94 let Sched = WriteFMul in {
  95 def SSE_MUL_F32P : OpndItins<
  96   IIC_SSE_MUL_F32P_RR, IIC_SSE_MUL_F64P_RM
  97 >;
  98
  99 def SSE_MUL_F64P : OpndItins<
 100   IIC_SSE_MUL_F64P_RR, IIC_SSE_MUL_F64P_RM
 101 >;
 102 }
 103
 104 def SSE_MUL_ITINS_P : SizeItins<
 105   SSE_MUL_F32P, SSE_MUL_F64P
 106 >;
 107
 108 let Sched = WriteFDiv in {
 109 def SSE_DIV_F32P : OpndItins<
 110   IIC_SSE_DIV_F32P_RR, IIC_SSE_DIV_F64P_RM
 111 >;
 112
 113 def SSE_DIV_F64P : OpndItins<
 114   IIC_SSE_DIV_F64P_RR, IIC_SSE_DIV_F64P_RM
 115 >;
 116 }
 117
 118 def SSE_DIV_ITINS_P : SizeItins<
 119   SSE_DIV_F32P, SSE_DIV_F64P
 120 >;
 121
 122 let Sched = WriteVecLogic in
 123 def SSE_VEC_BIT_ITINS_P : OpndItins<
 124   IIC_SSE_BIT_P_RR, IIC_SSE_BIT_P_RM
 125 >;
 126
 127 def SSE_BIT_ITINS_P : OpndItins<
 128   IIC_SSE_BIT_P_RR, IIC_SSE_BIT_P_RM
 129 >;
 130
 131 let Sched = WriteVecALU in {
 132 def SSE_INTALU_ITINS_P : OpndItins<
 133   IIC_SSE_INTALU_P_RR, IIC_SSE_INTALU_P_RM
 134 >;
 135
 136 def SSE_INTALUQ_ITINS_P : OpndItins<
 137   IIC_SSE_INTALUQ_P_RR, IIC_SSE_INTALUQ_P_RM
 138 >;
 139 }
 140
 141 let Sched = WriteVecIMul in
 142 def SSE_INTMUL_ITINS_P : OpndItins<
 143   IIC_SSE_INTMUL_P_RR, IIC_SSE_INTMUL_P_RM
 144 >;
 145
 146 def SSE_INTSHIFT_ITINS_P : ShiftOpndItins<
 147   IIC_SSE_INTSH_P_RR, IIC_SSE_INTSH_P_RM, IIC_SSE_INTSH_P_RI
 148 >;
 149
 150 def SSE_MOVA_ITINS : OpndItins<
 151   IIC_SSE_MOVA_P_RR, IIC_SSE_MOVA_P_RM
 152 >;
 153
 154 def SSE_MOVU_ITINS : OpndItins<
 155   IIC_SSE_MOVU_P_RR, IIC_SSE_MOVU_P_RM
 156 >;
 157
 158 def SSE_DPPD_ITINS : OpndItins<
 159   IIC_SSE_DPPD_RR, IIC_SSE_DPPD_RM
 160 >;
 161
 162 def SSE_DPPS_ITINS : OpndItins<
 163   IIC_SSE_DPPS_RR, IIC_SSE_DPPD_RM
 164 >;
 165
 166 def DEFAULT_ITINS : OpndItins<
 167   IIC_ALU_NONMEM, IIC_ALU_MEM
 168 >;
 169
 170 def SSE_EXTRACT_ITINS : OpndItins<
 171   IIC_SSE_EXTRACTPS_RR, IIC_SSE_EXTRACTPS_RM
 172 >;
 173
 174 def SSE_INSERT_ITINS : OpndItins<
 175   IIC_SSE_INSERTPS_RR, IIC_SSE_INSERTPS_RM
 176 >;
 177
 178 let Sched = WriteMPSAD in
 179 def SSE_MPSADBW_ITINS : OpndItins<
 180   IIC_SSE_MPSADBW_RR, IIC_SSE_MPSADBW_RM
 181 >;
 182
 183 let Sched = WriteVecIMul in
 184 def SSE_PMULLD_ITINS : OpndItins<
 185   IIC_SSE_PMULLD_RR, IIC_SSE_PMULLD_RM
 186 >;
 187
 188 // Definitions for backward compatibility.
 189 // The instructions mapped on these definitions uses a different itinerary
 190 // than the actual scheduling model.
 191 let Sched = WriteShuffle in
 192 def DEFAULT_ITINS_SHUFFLESCHED :  OpndItins<
 193   IIC_ALU_NONMEM, IIC_ALU_MEM
 194 >;
 195
 196 let Sched = WriteVecIMul in
 197 def DEFAULT_ITINS_VECIMULSCHED :  OpndItins<
 198   IIC_ALU_NONMEM, IIC_ALU_MEM
 199 >;
 200
 201 let Sched = WriteShuffle in
 202 def SSE_INTALU_ITINS_SHUFF_P : OpndItins<
 203   IIC_SSE_INTALU_P_RR, IIC_SSE_INTALU_P_RM
 204 >;
 205
 206 let Sched = WriteMPSAD in
 207 def DEFAULT_ITINS_MPSADSCHED :  OpndItins<
 208   IIC_ALU_NONMEM, IIC_ALU_MEM
 209 >;
 210
 211 let Sched = WriteFBlend in
 212 def DEFAULT_ITINS_FBLENDSCHED :  OpndItins<
 213   IIC_ALU_NONMEM, IIC_ALU_MEM
 214 >;
 215
 216 let Sched = WriteBlend in
 217 def DEFAULT_ITINS_BLENDSCHED :  OpndItins<
 218   IIC_ALU_NONMEM, IIC_ALU_MEM
 219 >;
 220
 221 let Sched = WriteVarBlend in
 222 def DEFAULT_ITINS_VARBLENDSCHED :  OpndItins<
 223   IIC_ALU_NONMEM, IIC_ALU_MEM
 224 >;
 225
 226 let Sched = WriteFBlend in
 227 def SSE_INTALU_ITINS_FBLEND_P : OpndItins<
 228   IIC_SSE_INTALU_P_RR, IIC_SSE_INTALU_P_RM
 229 >;
 230
 231 let Sched = WriteBlend in
 232 def SSE_INTALU_ITINS_BLEND_P : OpndItins<
 233   IIC_SSE_INTALU_P_RR, IIC_SSE_INTALU_P_RM
 234 >;
 235
 236 //===----------------------------------------------------------------------===//
 237 // SSE 1 & 2 Instructions Classes
 238 //===----------------------------------------------------------------------===//
 239
 240 /// sse12_fp_scalar - SSE 1 & 2 scalar instructions class
 241 multiclass sse12_fp_scalar<bits<8> opc, string OpcodeStr, SDNode OpNode,
 242                            RegisterClass RC, X86MemOperand x86memop,
 243                            Domain d, OpndItins itins, bit Is2Addr = 1> {
 244   let isCommutable = 1 in {
 245     def rr : SI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
 246        !if(Is2Addr,
 247            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 248            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 249        [(set RC:$dst, (OpNode RC:$src1, RC:$src2))], itins.rr, d>,
 250        Sched<[itins.Sched]>;
 251   }
 252   def rm : SI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
 253        !if(Is2Addr,
 254            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 255            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 256        [(set RC:$dst, (OpNode RC:$src1, (load addr:$src2)))], itins.rm, d>,
 257        Sched<[itins.Sched.Folded, ReadAfterLd]>;
 258 }
 259
 260 /// sse12_fp_scalar_int - SSE 1 & 2 scalar instructions intrinsics class
 261 multiclass sse12_fp_scalar_int<bits<8> opc, string OpcodeStr,
 262                                SDPatternOperator OpNode, RegisterClass RC,
 263                                ValueType VT, string asm, Operand memopr,
 264                                ComplexPattern mem_cpat, Domain d,
 265                                OpndItins itins, bit Is2Addr = 1> {
 266 let isCodeGenOnly = 1, hasSideEffects = 0 in {
 267   def rr_Int : SI_Int<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
 268        !if(Is2Addr,
 269            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
 270            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 271        [(set RC:$dst, (VT (OpNode RC:$src1, RC:$src2)))], itins.rr, d>,
 272        Sched<[itins.Sched]>;
 273   let mayLoad = 1 in
 274   def rm_Int : SI_Int<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, memopr:$src2),
 275        !if(Is2Addr,
 276            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
 277            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 278        [(set RC:$dst, (VT (OpNode RC:$src1, mem_cpat:$src2)))], itins.rm, d>,
 279        Sched<[itins.Sched.Folded, ReadAfterLd]>;
 280 }
 281 }
 282
 283 /// sse12_fp_packed - SSE 1 & 2 packed instructions class
 284 multiclass sse12_fp_packed<bits<8> opc, string OpcodeStr, SDNode OpNode,
 285                            RegisterClass RC, ValueType vt,
 286                            X86MemOperand x86memop, PatFrag mem_frag,
 287                            Domain d, OpndItins itins, bit Is2Addr = 1> {
 288   let isCommutable = 1 in
 289     def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
 290        !if(Is2Addr,
 291            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 292            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 293        [(set RC:$dst, (vt (OpNode RC:$src1, RC:$src2)))], itins.rr, d>,
 294        Sched<[itins.Sched]>;
 295   let mayLoad = 1 in
 296     def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
 297        !if(Is2Addr,
 298            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 299            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 300        [(set RC:$dst, (OpNode RC:$src1, (mem_frag addr:$src2)))],
 301           itins.rm, d>,
 302        Sched<[itins.Sched.Folded, ReadAfterLd]>;
 303 }
 304
 305 /// sse12_fp_packed_logical_rm - SSE 1 & 2 packed instructions class
 306 multiclass sse12_fp_packed_logical_rm<bits<8> opc, RegisterClass RC, Domain d,
 307                                       string OpcodeStr, X86MemOperand x86memop,
 308                                       list<dag> pat_rr, list<dag> pat_rm,
 309                                       bit Is2Addr = 1> {
 310   let isCommutable = 1, hasSideEffects = 0 in
 311     def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
 312        !if(Is2Addr,
 313            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 314            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 315        pat_rr, NoItinerary, d>,
 316        Sched<[WriteVecLogic]>;
 317   def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
 318        !if(Is2Addr,
 319            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
 320            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 321        pat_rm, NoItinerary, d>,
 322        Sched<[WriteVecLogicLd, ReadAfterLd]>;
 323 }
 324
 325 //===----------------------------------------------------------------------===//
 326 //  Non-instruction patterns
 327 //===----------------------------------------------------------------------===//
 328
 329 // A vector extract of the first f32/f64 position is a subregister copy
 330 def : Pat<(f32 (extractelt (v4f32 VR128:$src), (iPTR 0))),
 331           (COPY_TO_REGCLASS (v4f32 VR128:$src), FR32)>;
 332 def : Pat<(f64 (extractelt (v2f64 VR128:$src), (iPTR 0))),
 333           (COPY_TO_REGCLASS (v2f64 VR128:$src), FR64)>;
 334
 335 // A 128-bit subvector extract from the first 256-bit vector position
 336 // is a subregister copy that needs no instruction.
 337 def : Pat<(v4i32 (extract_subvector (v8i32 VR256:$src), (iPTR 0))),
 338           (v4i32 (EXTRACT_SUBREG (v8i32 VR256:$src), sub_xmm))>;
 339 def : Pat<(v4f32 (extract_subvector (v8f32 VR256:$src), (iPTR 0))),
 340           (v4f32 (EXTRACT_SUBREG (v8f32 VR256:$src), sub_xmm))>;
 341
 342 def : Pat<(v2i64 (extract_subvector (v4i64 VR256:$src), (iPTR 0))),
 343           (v2i64 (EXTRACT_SUBREG (v4i64 VR256:$src), sub_xmm))>;
 344 def : Pat<(v2f64 (extract_subvector (v4f64 VR256:$src), (iPTR 0))),
 345           (v2f64 (EXTRACT_SUBREG (v4f64 VR256:$src), sub_xmm))>;
 346
 347 def : Pat<(v8i16 (extract_subvector (v16i16 VR256:$src), (iPTR 0))),
 348           (v8i16 (EXTRACT_SUBREG (v16i16 VR256:$src), sub_xmm))>;
 349 def : Pat<(v16i8 (extract_subvector (v32i8 VR256:$src), (iPTR 0))),
 350           (v16i8 (EXTRACT_SUBREG (v32i8 VR256:$src), sub_xmm))>;
 351
 352 // A 128-bit subvector insert to the first 256-bit vector position
 353 // is a subregister copy that needs no instruction.
 354 let AddedComplexity = 25 in { // to give priority over vinsertf128rm
 355 def : Pat<(insert_subvector undef, (v2i64 VR128:$src), (iPTR 0)),
 356           (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 357 def : Pat<(insert_subvector undef, (v2f64 VR128:$src), (iPTR 0)),
 358           (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 359 def : Pat<(insert_subvector undef, (v4i32 VR128:$src), (iPTR 0)),
 360           (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 361 def : Pat<(insert_subvector undef, (v4f32 VR128:$src), (iPTR 0)),
 362           (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 363 def : Pat<(insert_subvector undef, (v8i16 VR128:$src), (iPTR 0)),
 364           (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 365 def : Pat<(insert_subvector undef, (v16i8 VR128:$src), (iPTR 0)),
 366           (INSERT_SUBREG (v32i8 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 367 }
 368
 369 // Implicitly promote a 32-bit scalar to a vector.
 370 def : Pat<(v4f32 (scalar_to_vector FR32:$src)),
 371           (COPY_TO_REGCLASS FR32:$src, VR128)>;
 372 // Implicitly promote a 64-bit scalar to a vector.
 373 def : Pat<(v2f64 (scalar_to_vector FR64:$src)),
 374           (COPY_TO_REGCLASS FR64:$src, VR128)>;
 375
 376 // Bitcasts between 128-bit vector types. Return the original type since
 377 // no instruction is needed for the conversion
 378 def : Pat<(v2i64 (bitconvert (v4i32 VR128:$src))), (v2i64 VR128:$src)>;
 379 def : Pat<(v2i64 (bitconvert (v8i16 VR128:$src))), (v2i64 VR128:$src)>;
 380 def : Pat<(v2i64 (bitconvert (v16i8 VR128:$src))), (v2i64 VR128:$src)>;
 381 def : Pat<(v2i64 (bitconvert (v2f64 VR128:$src))), (v2i64 VR128:$src)>;
 382 def : Pat<(v2i64 (bitconvert (v4f32 VR128:$src))), (v2i64 VR128:$src)>;
 383 def : Pat<(v4i32 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>;
 384 def : Pat<(v4i32 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>;
 385 def : Pat<(v4i32 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>;
 386 def : Pat<(v4i32 (bitconvert (v2f64 VR128:$src))), (v4i32 VR128:$src)>;
 387 def : Pat<(v4i32 (bitconvert (v4f32 VR128:$src))), (v4i32 VR128:$src)>;
 388 def : Pat<(v8i16 (bitconvert (v2i64 VR128:$src))), (v8i16 VR128:$src)>;
 389 def : Pat<(v8i16 (bitconvert (v4i32 VR128:$src))), (v8i16 VR128:$src)>;
 390 def : Pat<(v8i16 (bitconvert (v16i8 VR128:$src))), (v8i16 VR128:$src)>;
 391 def : Pat<(v8i16 (bitconvert (v2f64 VR128:$src))), (v8i16 VR128:$src)>;
 392 def : Pat<(v8i16 (bitconvert (v4f32 VR128:$src))), (v8i16 VR128:$src)>;
 393 def : Pat<(v16i8 (bitconvert (v2i64 VR128:$src))), (v16i8 VR128:$src)>;
 394 def : Pat<(v16i8 (bitconvert (v4i32 VR128:$src))), (v16i8 VR128:$src)>;
 395 def : Pat<(v16i8 (bitconvert (v8i16 VR128:$src))), (v16i8 VR128:$src)>;
 396 def : Pat<(v16i8 (bitconvert (v2f64 VR128:$src))), (v16i8 VR128:$src)>;
 397 def : Pat<(v16i8 (bitconvert (v4f32 VR128:$src))), (v16i8 VR128:$src)>;
 398 def : Pat<(v4f32 (bitconvert (v2i64 VR128:$src))), (v4f32 VR128:$src)>;
 399 def : Pat<(v4f32 (bitconvert (v4i32 VR128:$src))), (v4f32 VR128:$src)>;
 400 def : Pat<(v4f32 (bitconvert (v8i16 VR128:$src))), (v4f32 VR128:$src)>;
 401 def : Pat<(v4f32 (bitconvert (v16i8 VR128:$src))), (v4f32 VR128:$src)>;
 402 def : Pat<(v4f32 (bitconvert (v2f64 VR128:$src))), (v4f32 VR128:$src)>;
 403 def : Pat<(v2f64 (bitconvert (v2i64 VR128:$src))), (v2f64 VR128:$src)>;
 404 def : Pat<(v2f64 (bitconvert (v4i32 VR128:$src))), (v2f64 VR128:$src)>;
 405 def : Pat<(v2f64 (bitconvert (v8i16 VR128:$src))), (v2f64 VR128:$src)>;
 406 def : Pat<(v2f64 (bitconvert (v16i8 VR128:$src))), (v2f64 VR128:$src)>;
 407 def : Pat<(v2f64 (bitconvert (v4f32 VR128:$src))), (v2f64 VR128:$src)>;
 408 def : Pat<(f128  (bitconvert (i128  FR128:$src))), (f128  FR128:$src)>;
 409 def : Pat<(i128  (bitconvert (f128  FR128:$src))), (i128  FR128:$src)>;
 410
 411 // Bitcasts between 256-bit vector types. Return the original type since
 412 // no instruction is needed for the conversion
 413 def : Pat<(v4i64  (bitconvert (v8i32  VR256:$src))), (v4i64  VR256:$src)>;
 414 def : Pat<(v4i64  (bitconvert (v16i16 VR256:$src))), (v4i64  VR256:$src)>;
 415 def : Pat<(v4i64  (bitconvert (v32i8  VR256:$src))), (v4i64  VR256:$src)>;
 416 def : Pat<(v4i64  (bitconvert (v8f32  VR256:$src))), (v4i64  VR256:$src)>;
 417 def : Pat<(v4i64  (bitconvert (v4f64  VR256:$src))), (v4i64  VR256:$src)>;
 418 def : Pat<(v8i32  (bitconvert (v4i64  VR256:$src))), (v8i32  VR256:$src)>;
 419 def : Pat<(v8i32  (bitconvert (v16i16 VR256:$src))), (v8i32  VR256:$src)>;
 420 def : Pat<(v8i32  (bitconvert (v32i8  VR256:$src))), (v8i32  VR256:$src)>;
 421 def : Pat<(v8i32  (bitconvert (v4f64  VR256:$src))), (v8i32  VR256:$src)>;
 422 def : Pat<(v8i32  (bitconvert (v8f32  VR256:$src))), (v8i32  VR256:$src)>;
 423 def : Pat<(v16i16 (bitconvert (v4i64  VR256:$src))), (v16i16 VR256:$src)>;
 424 def : Pat<(v16i16 (bitconvert (v8i32  VR256:$src))), (v16i16 VR256:$src)>;
 425 def : Pat<(v16i16 (bitconvert (v32i8  VR256:$src))), (v16i16 VR256:$src)>;
 426 def : Pat<(v16i16 (bitconvert (v4f64  VR256:$src))), (v16i16 VR256:$src)>;
 427 def : Pat<(v16i16 (bitconvert (v8f32  VR256:$src))), (v16i16 VR256:$src)>;
 428 def : Pat<(v32i8  (bitconvert (v4i64  VR256:$src))), (v32i8  VR256:$src)>;
 429 def : Pat<(v32i8  (bitconvert (v8i32  VR256:$src))), (v32i8  VR256:$src)>;
 430 def : Pat<(v32i8  (bitconvert (v16i16 VR256:$src))), (v32i8  VR256:$src)>;
 431 def : Pat<(v32i8  (bitconvert (v4f64  VR256:$src))), (v32i8  VR256:$src)>;
 432 def : Pat<(v32i8  (bitconvert (v8f32  VR256:$src))), (v32i8  VR256:$src)>;
 433 def : Pat<(v8f32  (bitconvert (v4i64  VR256:$src))), (v8f32  VR256:$src)>;
 434 def : Pat<(v8f32  (bitconvert (v8i32  VR256:$src))), (v8f32  VR256:$src)>;
 435 def : Pat<(v8f32  (bitconvert (v16i16 VR256:$src))), (v8f32  VR256:$src)>;
 436 def : Pat<(v8f32  (bitconvert (v32i8  VR256:$src))), (v8f32  VR256:$src)>;
 437 def : Pat<(v8f32  (bitconvert (v4f64  VR256:$src))), (v8f32  VR256:$src)>;
 438 def : Pat<(v4f64  (bitconvert (v4i64  VR256:$src))), (v4f64  VR256:$src)>;
 439 def : Pat<(v4f64  (bitconvert (v8i32  VR256:$src))), (v4f64  VR256:$src)>;
 440 def : Pat<(v4f64  (bitconvert (v16i16 VR256:$src))), (v4f64  VR256:$src)>;
 441 def : Pat<(v4f64  (bitconvert (v32i8  VR256:$src))), (v4f64  VR256:$src)>;
 442 def : Pat<(v4f64  (bitconvert (v8f32  VR256:$src))), (v4f64  VR256:$src)>;
 443
 444 // Alias instructions that map fld0 to xorps for sse or vxorps for avx.
 445 // This is expanded by ExpandPostRAPseudos.
 446 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 447     isPseudo = 1, SchedRW = [WriteZero] in {
 448   def FsFLD0SS : I<0, Pseudo, (outs FR32:$dst), (ins), "",
 449                    [(set FR32:$dst, fp32imm0)]>, Requires<[HasSSE1, NoAVX512]>;
 450   def FsFLD0SD : I<0, Pseudo, (outs FR64:$dst), (ins), "",
 451                    [(set FR64:$dst, fpimm0)]>, Requires<[HasSSE2, NoAVX512]>;
 452 }
 453
 454 //===----------------------------------------------------------------------===//
 455 // AVX & SSE - Zero/One Vectors
 456 //===----------------------------------------------------------------------===//
 457
 458 // Alias instruction that maps zero vector to pxor / xorp* for sse.
 459 // This is expanded by ExpandPostRAPseudos to an xorps / vxorps, and then
 460 // swizzled by ExecutionDepsFix to pxor.
 461 // We set canFoldAsLoad because this can be converted to a constant-pool
 462 // load of an all-zeros value if folding it would be beneficial.
 463 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 464     isPseudo = 1, SchedRW = [WriteZero] in {
 465 def V_SET0 : I<0, Pseudo, (outs VR128:$dst), (ins), "",
 466                [(set VR128:$dst, (v4f32 immAllZerosV))]>;
 467 }
 468
 469 let Predicates = [NoAVX512] in
 470 def : Pat<(v4i32 immAllZerosV), (V_SET0)>;
 471
 472
 473 // The same as done above but for AVX.  The 256-bit AVX1 ISA doesn't support PI,
 474 // and doesn't need it because on sandy bridge the register is set to zero
 475 // at the rename stage without using any execution unit, so SET0PSY
 476 // and SET0PDY can be used for vector int instructions without penalty
 477 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 478     isPseudo = 1, Predicates = [NoAVX512], SchedRW = [WriteZero] in {
 479 def AVX_SET0 : I<0, Pseudo, (outs VR256:$dst), (ins), "",
 480                  [(set VR256:$dst, (v8i32 immAllZerosV))]>;
 481 }
 482
 483 // We set canFoldAsLoad because this can be converted to a constant-pool
 484 // load of an all-ones value if folding it would be beneficial.
 485 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 486     isPseudo = 1, SchedRW = [WriteZero] in {
 487   def V_SETALLONES : I<0, Pseudo, (outs VR128:$dst), (ins), "",
 488                        [(set VR128:$dst, (v4i32 immAllOnesV))]>;
 489   let Predicates = [HasAVX2] in
 490   def AVX2_SETALLONES : I<0, Pseudo, (outs VR256:$dst), (ins), "",
 491                           [(set VR256:$dst, (v8i32 immAllOnesV))]>;
 492 }
 493
 494 //===----------------------------------------------------------------------===//
 495 // SSE 1 & 2 - Move FP Scalar Instructions
 496 //
 497 // Move Instructions. Register-to-register movss/movsd is not used for FR32/64
 498 // register copies because it's a partial register update; Register-to-register
 499 // movss/movsd is not modeled as an INSERT_SUBREG because INSERT_SUBREG requires
 500 // that the insert be implementable in terms of a copy, and just mentioned, we
 501 // don't use movss/movsd for copies.
 502 //===----------------------------------------------------------------------===//
 503
 504 multiclass sse12_move_rr<RegisterClass RC, SDNode OpNode, ValueType vt,
 505                          X86MemOperand x86memop, string base_opc,
 506                          string asm_opr, Domain d = GenericDomain> {
 507   let isCommutable = 1 in
 508   def rr : SI<0x10, MRMSrcReg, (outs VR128:$dst),
 509               (ins VR128:$src1, RC:$src2),
 510               !strconcat(base_opc, asm_opr),
 511               [(set VR128:$dst, (vt (OpNode VR128:$src1,
 512                                  (scalar_to_vector RC:$src2))))],
 513               IIC_SSE_MOV_S_RR, d>, Sched<[WriteFShuffle]>;
 514
 515   // For the disassembler
 516   let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0 in
 517   def rr_REV : SI<0x11, MRMDestReg, (outs VR128:$dst),
 518                   (ins VR128:$src1, RC:$src2),
 519                   !strconcat(base_opc, asm_opr),
 520                   [], IIC_SSE_MOV_S_RR>, Sched<[WriteFShuffle]>;
 521 }
 522
 523 multiclass sse12_move<RegisterClass RC, SDNode OpNode, ValueType vt,
 524                       X86MemOperand x86memop, string OpcodeStr,
 525                       Domain d = GenericDomain> {
 526   // AVX
 527   defm V#NAME : sse12_move_rr<RC, OpNode, vt, x86memop, OpcodeStr,
 528                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}", d>,
 529                               VEX_4V, VEX_LIG, VEX_WIG;
 530
 531   def V#NAME#mr : SI<0x11, MRMDestMem, (outs), (ins x86memop:$dst, RC:$src),
 532                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
 533                      [(store RC:$src, addr:$dst)], IIC_SSE_MOV_S_MR, d>,
 534                      VEX, VEX_LIG, Sched<[WriteStore]>, VEX_WIG;
 535   // SSE1 & 2
 536   let Constraints = "$src1 = $dst" in {
 537     defm NAME : sse12_move_rr<RC, OpNode, vt, x86memop, OpcodeStr,
 538                               "\t{$src2, $dst|$dst, $src2}", d>;
 539   }
 540
 541   def NAME#mr   : SI<0x11, MRMDestMem, (outs), (ins x86memop:$dst, RC:$src),
 542                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
 543                      [(store RC:$src, addr:$dst)], IIC_SSE_MOV_S_MR, d>,
 544                   Sched<[WriteStore]>;
 545 }
 546
 547 // Loading from memory automatically zeroing upper bits.
 548 multiclass sse12_move_rm<RegisterClass RC, X86MemOperand x86memop,
 549                          PatFrag mem_pat, string OpcodeStr,
 550                          Domain d = GenericDomain> {
 551   def V#NAME#rm : SI<0x10, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
 552                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
 553                      [(set RC:$dst, (mem_pat addr:$src))],
 554                      IIC_SSE_MOV_S_RM, d>, VEX, VEX_LIG, Sched<[WriteLoad]>, VEX_WIG;
 555   def NAME#rm   : SI<0x10, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
 556                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
 557                      [(set RC:$dst, (mem_pat addr:$src))],
 558                      IIC_SSE_MOV_S_RM, d>, Sched<[WriteLoad]>;
 559 }
 560
 561 defm MOVSS : sse12_move<FR32, X86Movss, v4f32, f32mem, "movss",
 562                         SSEPackedSingle>, XS;
 563 defm MOVSD : sse12_move<FR64, X86Movsd, v2f64, f64mem, "movsd",
 564                         SSEPackedDouble>, XD;
 565
 566 let canFoldAsLoad = 1, isReMaterializable = 1 in {
 567   defm MOVSS : sse12_move_rm<FR32, f32mem, loadf32, "movss",
 568                              SSEPackedSingle>, XS;
 569
 570   let AddedComplexity = 20 in
 571     defm MOVSD : sse12_move_rm<FR64, f64mem, loadf64, "movsd",
 572                                SSEPackedDouble>, XD;
 573 }
 574
 575 // Patterns
 576 let Predicates = [UseAVX] in {
 577   let AddedComplexity = 20 in {
 578   // MOVSSrm zeros the high parts of the register; represent this
 579   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
 580   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector (loadf32 addr:$src))))),
 581             (COPY_TO_REGCLASS (VMOVSSrm addr:$src), VR128)>;
 582   def : Pat<(v4f32 (scalar_to_vector (loadf32 addr:$src))),
 583             (COPY_TO_REGCLASS (VMOVSSrm addr:$src), VR128)>;
 584   def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
 585             (COPY_TO_REGCLASS (VMOVSSrm addr:$src), VR128)>;
 586   def : Pat<(v4f32 (X86vzload addr:$src)),
 587             (COPY_TO_REGCLASS (VMOVSSrm addr:$src), VR128)>;
 588
 589   // MOVSDrm zeros the high parts of the register; represent this
 590   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
 591   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector (loadf64 addr:$src))))),
 592             (COPY_TO_REGCLASS (VMOVSDrm addr:$src), VR128)>;
 593   def : Pat<(v2f64 (scalar_to_vector (loadf64 addr:$src))),
 594             (COPY_TO_REGCLASS (VMOVSDrm addr:$src), VR128)>;
 595   def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
 596             (COPY_TO_REGCLASS (VMOVSDrm addr:$src), VR128)>;
 597   def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
 598             (COPY_TO_REGCLASS (VMOVSDrm addr:$src), VR128)>;
 599   def : Pat<(v2f64 (X86vzload addr:$src)),
 600             (COPY_TO_REGCLASS (VMOVSDrm addr:$src), VR128)>;
 601
 602   // Represent the same patterns above but in the form they appear for
 603   // 256-bit types
 604   def : Pat<(v8f32 (X86vzmovl (insert_subvector undef,
 605                    (v4f32 (scalar_to_vector (loadf32 addr:$src))), (iPTR 0)))),
 606             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_xmm)>;
 607   def : Pat<(v8f32 (X86vzload addr:$src)),
 608             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_xmm)>;
 609   def : Pat<(v4f64 (X86vzmovl (insert_subvector undef,
 610                    (v2f64 (scalar_to_vector (loadf64 addr:$src))), (iPTR 0)))),
 611             (SUBREG_TO_REG (i32 0), (VMOVSDrm addr:$src), sub_xmm)>;
 612   def : Pat<(v4f64 (X86vzload addr:$src)),
 613             (SUBREG_TO_REG (i32 0), (VMOVSDrm addr:$src), sub_xmm)>;
 614   }
 615
 616   // Extract and store.
 617   def : Pat<(store (f32 (extractelt (v4f32 VR128:$src), (iPTR 0))),
 618                    addr:$dst),
 619             (VMOVSSmr addr:$dst, (COPY_TO_REGCLASS (v4f32 VR128:$src), FR32))>;
 620
 621   // Shuffle with VMOVSS
 622   def : Pat<(v4i32 (X86Movss VR128:$src1, VR128:$src2)),
 623             (VMOVSSrr (v4i32 VR128:$src1),
 624                       (COPY_TO_REGCLASS (v4i32 VR128:$src2), FR32))>;
 625   def : Pat<(v4f32 (X86Movss VR128:$src1, VR128:$src2)),
 626             (VMOVSSrr (v4f32 VR128:$src1),
 627                       (COPY_TO_REGCLASS (v4f32 VR128:$src2), FR32))>;
 628
 629   // 256-bit variants
 630   def : Pat<(v8i32 (X86Movss VR256:$src1, VR256:$src2)),
 631             (SUBREG_TO_REG (i32 0),
 632               (VMOVSSrr (EXTRACT_SUBREG (v8i32 VR256:$src1), sub_xmm),
 633                         (EXTRACT_SUBREG (v8i32 VR256:$src2), sub_xmm)),
 634               sub_xmm)>;
 635   def : Pat<(v8f32 (X86Movss VR256:$src1, VR256:$src2)),
 636             (SUBREG_TO_REG (i32 0),
 637               (VMOVSSrr (EXTRACT_SUBREG (v8f32 VR256:$src1), sub_xmm),
 638                         (EXTRACT_SUBREG (v8f32 VR256:$src2), sub_xmm)),
 639               sub_xmm)>;
 640
 641   // Shuffle with VMOVSD
 642   def : Pat<(v2i64 (X86Movsd VR128:$src1, VR128:$src2)),
 643             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 644   def : Pat<(v2f64 (X86Movsd VR128:$src1, VR128:$src2)),
 645             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 646
 647   // 256-bit variants
 648   def : Pat<(v4i64 (X86Movsd VR256:$src1, VR256:$src2)),
 649             (SUBREG_TO_REG (i32 0),
 650               (VMOVSDrr (EXTRACT_SUBREG (v4i64 VR256:$src1), sub_xmm),
 651                         (EXTRACT_SUBREG (v4i64 VR256:$src2), sub_xmm)),
 652               sub_xmm)>;
 653   def : Pat<(v4f64 (X86Movsd VR256:$src1, VR256:$src2)),
 654             (SUBREG_TO_REG (i32 0),
 655               (VMOVSDrr (EXTRACT_SUBREG (v4f64 VR256:$src1), sub_xmm),
 656                         (EXTRACT_SUBREG (v4f64 VR256:$src2), sub_xmm)),
 657               sub_xmm)>;
 658
 659   // FIXME: Instead of a X86Movlps there should be a X86Movsd here, the problem
 660   // is during lowering, where it's not possible to recognize the fold cause
 661   // it has two uses through a bitcast. One use disappears at isel time and the
 662   // fold opportunity reappears.
 663   def : Pat<(v2f64 (X86Movlpd VR128:$src1, VR128:$src2)),
 664             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 665   def : Pat<(v2i64 (X86Movlpd VR128:$src1, VR128:$src2)),
 666             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 667   def : Pat<(v4f32 (X86Movlps VR128:$src1, VR128:$src2)),
 668             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 669   def : Pat<(v4i32 (X86Movlps VR128:$src1, VR128:$src2)),
 670             (VMOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 671 }
 672
 673 let Predicates = [UseSSE1] in {
 674   let Predicates = [NoSSE41], AddedComplexity = 15 in {
 675   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
 676   // MOVSS to the lower bits.
 677   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32:$src)))),
 678             (MOVSSrr (v4f32 (V_SET0)), FR32:$src)>;
 679   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
 680             (MOVSSrr (v4f32 (V_SET0)), (COPY_TO_REGCLASS VR128:$src, FR32))>;
 681   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
 682             (MOVSSrr (v4i32 (V_SET0)), (COPY_TO_REGCLASS VR128:$src, FR32))>;
 683   }
 684
 685   let AddedComplexity = 20 in {
 686   // MOVSSrm already zeros the high parts of the register.
 687   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector (loadf32 addr:$src))))),
 688             (COPY_TO_REGCLASS (MOVSSrm addr:$src), VR128)>;
 689   def : Pat<(v4f32 (scalar_to_vector (loadf32 addr:$src))),
 690             (COPY_TO_REGCLASS (MOVSSrm addr:$src), VR128)>;
 691   def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
 692             (COPY_TO_REGCLASS (MOVSSrm addr:$src), VR128)>;
 693   def : Pat<(v4f32 (X86vzload addr:$src)),
 694             (COPY_TO_REGCLASS (MOVSSrm addr:$src), VR128)>;
 695   }
 696
 697   // Extract and store.
 698   def : Pat<(store (f32 (extractelt (v4f32 VR128:$src), (iPTR 0))),
 699                    addr:$dst),
 700             (MOVSSmr addr:$dst, (COPY_TO_REGCLASS VR128:$src, FR32))>;
 701
 702   // Shuffle with MOVSS
 703   def : Pat<(v4i32 (X86Movss VR128:$src1, VR128:$src2)),
 704             (MOVSSrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR32))>;
 705   def : Pat<(v4f32 (X86Movss VR128:$src1, VR128:$src2)),
 706             (MOVSSrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR32))>;
 707 }
 708
 709 let Predicates = [UseSSE2] in {
 710   let Predicates = [NoSSE41], AddedComplexity = 15 in {
 711   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
 712   // MOVSD to the lower bits.
 713   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64:$src)))),
 714             (MOVSDrr (v2f64 (V_SET0)), FR64:$src)>;
 715   }
 716
 717   let AddedComplexity = 20 in {
 718   // MOVSDrm already zeros the high parts of the register.
 719   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector (loadf64 addr:$src))))),
 720             (COPY_TO_REGCLASS (MOVSDrm addr:$src), VR128)>;
 721   def : Pat<(v2f64 (scalar_to_vector (loadf64 addr:$src))),
 722             (COPY_TO_REGCLASS (MOVSDrm addr:$src), VR128)>;
 723   def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
 724             (COPY_TO_REGCLASS (MOVSDrm addr:$src), VR128)>;
 725   def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
 726             (COPY_TO_REGCLASS (MOVSDrm addr:$src), VR128)>;
 727   def : Pat<(v2f64 (X86vzload addr:$src)),
 728             (COPY_TO_REGCLASS (MOVSDrm addr:$src), VR128)>;
 729   }
 730
 731   // Shuffle with MOVSD
 732   def : Pat<(v2i64 (X86Movsd VR128:$src1, VR128:$src2)),
 733             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 734   def : Pat<(v2f64 (X86Movsd VR128:$src1, VR128:$src2)),
 735             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 736
 737   // FIXME: Instead of a X86Movlps there should be a X86Movsd here, the problem
 738   // is during lowering, where it's not possible to recognize the fold because
 739   // it has two uses through a bitcast. One use disappears at isel time and the
 740   // fold opportunity reappears.
 741   def : Pat<(v2f64 (X86Movlpd VR128:$src1, VR128:$src2)),
 742             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 743   def : Pat<(v2i64 (X86Movlpd VR128:$src1, VR128:$src2)),
 744             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 745   def : Pat<(v4f32 (X86Movlps VR128:$src1, VR128:$src2)),
 746             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 747   def : Pat<(v4i32 (X86Movlps VR128:$src1, VR128:$src2)),
 748             (MOVSDrr VR128:$src1, (COPY_TO_REGCLASS VR128:$src2, FR64))>;
 749 }
 750
 751 // Aliases to help the assembler pick two byte VEX encodings by swapping the
 752 // operands relative to the normal instructions to use VEX.R instead of VEX.B.
 753 def : InstAlias<"vmovss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 754                 (VMOVSSrr_REV VR128L:$dst, VR128:$src1, VR128H:$src2), 0>;
 755 def : InstAlias<"vmovsd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 756                 (VMOVSDrr_REV VR128L:$dst, VR128:$src1, VR128H:$src2), 0>;
 757
 758 //===----------------------------------------------------------------------===//
 759 // SSE 1 & 2 - Move Aligned/Unaligned FP Instructions
 760 //===----------------------------------------------------------------------===//
 761
 762 multiclass sse12_mov_packed<bits<8> opc, RegisterClass RC,
 763                             X86MemOperand x86memop, PatFrag ld_frag,
 764                             string asm, Domain d,
 765                             OpndItins itins> {
 766 let hasSideEffects = 0 in
 767   def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src),
 768               !strconcat(asm, "\t{$src, $dst|$dst, $src}"), [], itins.rr, d>,
 769            Sched<[WriteFShuffle]>;
 770 let canFoldAsLoad = 1, isReMaterializable = 1 in
 771   def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
 772               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
 773                    [(set RC:$dst, (ld_frag addr:$src))], itins.rm, d>,
 774            Sched<[WriteLoad]>;
 775 }
 776
 777 let Predicates = [HasAVX, NoVLX] in {
 778 defm VMOVAPS : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv4f32,
 779                               "movaps", SSEPackedSingle, SSE_MOVA_ITINS>,
 780                               PS, VEX, VEX_WIG;
 781 defm VMOVAPD : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv2f64,
 782                               "movapd", SSEPackedDouble, SSE_MOVA_ITINS>,
 783                               PD, VEX, VEX_WIG;
 784 defm VMOVUPS : sse12_mov_packed<0x10, VR128, f128mem, loadv4f32,
 785                               "movups", SSEPackedSingle, SSE_MOVU_ITINS>,
 786                               PS, VEX, VEX_WIG;
 787 defm VMOVUPD : sse12_mov_packed<0x10, VR128, f128mem, loadv2f64,
 788                               "movupd", SSEPackedDouble, SSE_MOVU_ITINS>,
 789                               PD, VEX, VEX_WIG;
 790
 791 defm VMOVAPSY : sse12_mov_packed<0x28, VR256, f256mem, alignedloadv8f32,
 792                               "movaps", SSEPackedSingle, SSE_MOVA_ITINS>,
 793                               PS, VEX, VEX_L, VEX_WIG;
 794 defm VMOVAPDY : sse12_mov_packed<0x28, VR256, f256mem, alignedloadv4f64,
 795                               "movapd", SSEPackedDouble, SSE_MOVA_ITINS>,
 796                               PD, VEX, VEX_L, VEX_WIG;
 797 defm VMOVUPSY : sse12_mov_packed<0x10, VR256, f256mem, loadv8f32,
 798                               "movups", SSEPackedSingle, SSE_MOVU_ITINS>,
 799                               PS, VEX, VEX_L, VEX_WIG;
 800 defm VMOVUPDY : sse12_mov_packed<0x10, VR256, f256mem, loadv4f64,
 801                               "movupd", SSEPackedDouble, SSE_MOVU_ITINS>,
 802                               PD, VEX, VEX_L, VEX_WIG;
 803 }
 804
 805 let Predicates = [UseSSE1] in {
 806 defm MOVAPS : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv4f32,
 807                               "movaps", SSEPackedSingle, SSE_MOVA_ITINS>,
 808                               PS;
 809 defm MOVUPS : sse12_mov_packed<0x10, VR128, f128mem, loadv4f32,
 810                               "movups", SSEPackedSingle, SSE_MOVU_ITINS>,
 811                               PS;
 812 }
 813 let Predicates = [UseSSE2] in {
 814 defm MOVAPD : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv2f64,
 815                               "movapd", SSEPackedDouble, SSE_MOVA_ITINS>,
 816                               PD;
 817 defm MOVUPD : sse12_mov_packed<0x10, VR128, f128mem, loadv2f64,
 818                               "movupd", SSEPackedDouble, SSE_MOVU_ITINS>,
 819                               PD;
 820 }
 821
 822 let SchedRW = [WriteStore], Predicates = [HasAVX, NoVLX]  in {
 823 def VMOVAPSmr : VPSI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 824                    "movaps\t{$src, $dst|$dst, $src}",
 825                    [(alignedstore (v4f32 VR128:$src), addr:$dst)],
 826                    IIC_SSE_MOVA_P_MR>, VEX, VEX_WIG;
 827 def VMOVAPDmr : VPDI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 828                    "movapd\t{$src, $dst|$dst, $src}",
 829                    [(alignedstore (v2f64 VR128:$src), addr:$dst)],
 830                    IIC_SSE_MOVA_P_MR>, VEX, VEX_WIG;
 831 def VMOVUPSmr : VPSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 832                    "movups\t{$src, $dst|$dst, $src}",
 833                    [(store (v4f32 VR128:$src), addr:$dst)],
 834                    IIC_SSE_MOVU_P_MR>, VEX, VEX_WIG;
 835 def VMOVUPDmr : VPDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 836                    "movupd\t{$src, $dst|$dst, $src}",
 837                    [(store (v2f64 VR128:$src), addr:$dst)],
 838                    IIC_SSE_MOVU_P_MR>, VEX, VEX_WIG;
 839 def VMOVAPSYmr : VPSI<0x29, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 840                    "movaps\t{$src, $dst|$dst, $src}",
 841                    [(alignedstore256 (v8f32 VR256:$src), addr:$dst)],
 842                    IIC_SSE_MOVA_P_MR>, VEX, VEX_L, VEX_WIG;
 843 def VMOVAPDYmr : VPDI<0x29, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 844                    "movapd\t{$src, $dst|$dst, $src}",
 845                    [(alignedstore256 (v4f64 VR256:$src), addr:$dst)],
 846                    IIC_SSE_MOVA_P_MR>, VEX, VEX_L, VEX_WIG;
 847 def VMOVUPSYmr : VPSI<0x11, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 848                    "movups\t{$src, $dst|$dst, $src}",
 849                    [(store (v8f32 VR256:$src), addr:$dst)],
 850                    IIC_SSE_MOVU_P_MR>, VEX, VEX_L, VEX_WIG;
 851 def VMOVUPDYmr : VPDI<0x11, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 852                    "movupd\t{$src, $dst|$dst, $src}",
 853                    [(store (v4f64 VR256:$src), addr:$dst)],
 854                    IIC_SSE_MOVU_P_MR>, VEX, VEX_L, VEX_WIG;
 855 } // SchedRW
 856
 857 // For disassembler
 858 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
 859     SchedRW = [WriteFShuffle] in {
 860   def VMOVAPSrr_REV : VPSI<0x29, MRMDestReg, (outs VR128:$dst),
 861                           (ins VR128:$src),
 862                           "movaps\t{$src, $dst|$dst, $src}", [],
 863                           IIC_SSE_MOVA_P_RR>, VEX, VEX_WIG;
 864   def VMOVAPDrr_REV : VPDI<0x29, MRMDestReg, (outs VR128:$dst),
 865                            (ins VR128:$src),
 866                            "movapd\t{$src, $dst|$dst, $src}", [],
 867                            IIC_SSE_MOVA_P_RR>, VEX, VEX_WIG;
 868   def VMOVUPSrr_REV : VPSI<0x11, MRMDestReg, (outs VR128:$dst),
 869                            (ins VR128:$src),
 870                            "movups\t{$src, $dst|$dst, $src}", [],
 871                            IIC_SSE_MOVU_P_RR>, VEX, VEX_WIG;
 872   def VMOVUPDrr_REV : VPDI<0x11, MRMDestReg, (outs VR128:$dst),
 873                            (ins VR128:$src),
 874                            "movupd\t{$src, $dst|$dst, $src}", [],
 875                            IIC_SSE_MOVU_P_RR>, VEX, VEX_WIG;
 876   def VMOVAPSYrr_REV : VPSI<0x29, MRMDestReg, (outs VR256:$dst),
 877                             (ins VR256:$src),
 878                             "movaps\t{$src, $dst|$dst, $src}", [],
 879                             IIC_SSE_MOVA_P_RR>, VEX, VEX_L, VEX_WIG;
 880   def VMOVAPDYrr_REV : VPDI<0x29, MRMDestReg, (outs VR256:$dst),
 881                             (ins VR256:$src),
 882                             "movapd\t{$src, $dst|$dst, $src}", [],
 883                             IIC_SSE_MOVA_P_RR>, VEX, VEX_L, VEX_WIG;
 884   def VMOVUPSYrr_REV : VPSI<0x11, MRMDestReg, (outs VR256:$dst),
 885                             (ins VR256:$src),
 886                             "movups\t{$src, $dst|$dst, $src}", [],
 887                             IIC_SSE_MOVU_P_RR>, VEX, VEX_L, VEX_WIG;
 888   def VMOVUPDYrr_REV : VPDI<0x11, MRMDestReg, (outs VR256:$dst),
 889                             (ins VR256:$src),
 890                             "movupd\t{$src, $dst|$dst, $src}", [],
 891                             IIC_SSE_MOVU_P_RR>, VEX, VEX_L, VEX_WIG;
 892 }
 893
 894 // Aliases to help the assembler pick two byte VEX encodings by swapping the
 895 // operands relative to the normal instructions to use VEX.R instead of VEX.B.
 896 def : InstAlias<"vmovaps\t{$src, $dst|$dst, $src}",
 897                 (VMOVAPSrr_REV VR128L:$dst, VR128H:$src), 0>;
 898 def : InstAlias<"vmovapd\t{$src, $dst|$dst, $src}",
 899                 (VMOVAPDrr_REV VR128L:$dst, VR128H:$src), 0>;
 900 def : InstAlias<"vmovups\t{$src, $dst|$dst, $src}",
 901                 (VMOVUPSrr_REV VR128L:$dst, VR128H:$src), 0>;
 902 def : InstAlias<"vmovupd\t{$src, $dst|$dst, $src}",
 903                 (VMOVUPDrr_REV VR128L:$dst, VR128H:$src), 0>;
 904 def : InstAlias<"vmovaps\t{$src, $dst|$dst, $src}",
 905                 (VMOVAPSYrr_REV VR256L:$dst, VR256H:$src), 0>;
 906 def : InstAlias<"vmovapd\t{$src, $dst|$dst, $src}",
 907                 (VMOVAPDYrr_REV VR256L:$dst, VR256H:$src), 0>;
 908 def : InstAlias<"vmovups\t{$src, $dst|$dst, $src}",
 909                 (VMOVUPSYrr_REV VR256L:$dst, VR256H:$src), 0>;
 910 def : InstAlias<"vmovupd\t{$src, $dst|$dst, $src}",
 911                 (VMOVUPDYrr_REV VR256L:$dst, VR256H:$src), 0>;
 912
 913 let SchedRW = [WriteStore] in {
 914 def MOVAPSmr : PSI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 915                    "movaps\t{$src, $dst|$dst, $src}",
 916                    [(alignedstore (v4f32 VR128:$src), addr:$dst)],
 917                    IIC_SSE_MOVA_P_MR>;
 918 def MOVAPDmr : PDI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 919                    "movapd\t{$src, $dst|$dst, $src}",
 920                    [(alignedstore (v2f64 VR128:$src), addr:$dst)],
 921                    IIC_SSE_MOVA_P_MR>;
 922 def MOVUPSmr : PSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 923                    "movups\t{$src, $dst|$dst, $src}",
 924                    [(store (v4f32 VR128:$src), addr:$dst)],
 925                    IIC_SSE_MOVU_P_MR>;
 926 def MOVUPDmr : PDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 927                    "movupd\t{$src, $dst|$dst, $src}",
 928                    [(store (v2f64 VR128:$src), addr:$dst)],
 929                    IIC_SSE_MOVU_P_MR>;
 930 } // SchedRW
 931
 932 // For disassembler
 933 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
 934     SchedRW = [WriteFShuffle] in {
 935   def MOVAPSrr_REV : PSI<0x29, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 936                          "movaps\t{$src, $dst|$dst, $src}", [],
 937                          IIC_SSE_MOVA_P_RR>;
 938   def MOVAPDrr_REV : PDI<0x29, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 939                          "movapd\t{$src, $dst|$dst, $src}", [],
 940                          IIC_SSE_MOVA_P_RR>;
 941   def MOVUPSrr_REV : PSI<0x11, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 942                          "movups\t{$src, $dst|$dst, $src}", [],
 943                          IIC_SSE_MOVU_P_RR>;
 944   def MOVUPDrr_REV : PDI<0x11, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 945                          "movupd\t{$src, $dst|$dst, $src}", [],
 946                          IIC_SSE_MOVU_P_RR>;
 947 }
 948
 949 let Predicates = [HasAVX, NoVLX] in {
 950   // 256-bit load/store need to use floating point load/store in case we don't
 951   // have AVX2. Execution domain fixing will convert to integer if AVX2 is
 952   // available and changing the domain is beneficial.
 953   def : Pat<(alignedloadv4i64 addr:$src),
 954             (VMOVAPSYrm addr:$src)>;
 955   def : Pat<(loadv4i64 addr:$src),
 956             (VMOVUPSYrm addr:$src)>;
 957   def : Pat<(alignedstore256 (v4i64 VR256:$src), addr:$dst),
 958             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 959   def : Pat<(alignedstore256 (v8i32 VR256:$src), addr:$dst),
 960             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 961   def : Pat<(alignedstore256 (v16i16 VR256:$src), addr:$dst),
 962             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 963   def : Pat<(alignedstore256 (v32i8 VR256:$src), addr:$dst),
 964             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 965   def : Pat<(store (v4i64 VR256:$src), addr:$dst),
 966             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 967   def : Pat<(store (v8i32 VR256:$src), addr:$dst),
 968             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 969   def : Pat<(store (v16i16 VR256:$src), addr:$dst),
 970             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 971   def : Pat<(store (v32i8 VR256:$src), addr:$dst),
 972             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 973
 974   // Special patterns for storing subvector extracts of lower 128-bits
 975   // Its cheaper to just use VMOVAPS/VMOVUPS instead of VEXTRACTF128mr
 976   def : Pat<(alignedstore (v2f64 (extract_subvector
 977                                   (v4f64 VR256:$src), (iPTR 0))), addr:$dst),
 978             (VMOVAPDmr addr:$dst, (v2f64 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
 979   def : Pat<(alignedstore (v4f32 (extract_subvector
 980                                   (v8f32 VR256:$src), (iPTR 0))), addr:$dst),
 981             (VMOVAPSmr addr:$dst, (v4f32 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
 982
 983   def : Pat<(store (v2f64 (extract_subvector
 984                            (v4f64 VR256:$src), (iPTR 0))), addr:$dst),
 985             (VMOVUPDmr addr:$dst, (v2f64 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
 986   def : Pat<(store (v4f32 (extract_subvector
 987                            (v8f32 VR256:$src), (iPTR 0))), addr:$dst),
 988             (VMOVUPSmr addr:$dst, (v4f32 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
 989 }
 990
 991 // Use movaps / movups for SSE integer load / store (one byte shorter).
 992 // The instructions selected below are then converted to MOVDQA/MOVDQU
 993 // during the SSE domain pass.
 994 let Predicates = [UseSSE1] in {
 995   def : Pat<(alignedloadv2i64 addr:$src),
 996             (MOVAPSrm addr:$src)>;
 997   def : Pat<(loadv2i64 addr:$src),
 998             (MOVUPSrm addr:$src)>;
 999
1000   def : Pat<(alignedstore (v2i64 VR128:$src), addr:$dst),
1001             (MOVAPSmr addr:$dst, VR128:$src)>;
1002   def : Pat<(alignedstore (v4i32 VR128:$src), addr:$dst),
1003             (MOVAPSmr addr:$dst, VR128:$src)>;
1004   def : Pat<(alignedstore (v8i16 VR128:$src), addr:$dst),
1005             (MOVAPSmr addr:$dst, VR128:$src)>;
1006   def : Pat<(alignedstore (v16i8 VR128:$src), addr:$dst),
1007             (MOVAPSmr addr:$dst, VR128:$src)>;
1008   def : Pat<(store (v2i64 VR128:$src), addr:$dst),
1009             (MOVUPSmr addr:$dst, VR128:$src)>;
1010   def : Pat<(store (v4i32 VR128:$src), addr:$dst),
1011             (MOVUPSmr addr:$dst, VR128:$src)>;
1012   def : Pat<(store (v8i16 VR128:$src), addr:$dst),
1013             (MOVUPSmr addr:$dst, VR128:$src)>;
1014   def : Pat<(store (v16i8 VR128:$src), addr:$dst),
1015             (MOVUPSmr addr:$dst, VR128:$src)>;
1016 }
1017
1018 //===----------------------------------------------------------------------===//
1019 // SSE 1 & 2 - Move Low packed FP Instructions
1020 //===----------------------------------------------------------------------===//
1021
1022 multiclass sse12_mov_hilo_packed_base<bits<8>opc, SDNode psnode, SDNode pdnode,
1023                                       string base_opc, string asm_opr,
1024                                       InstrItinClass itin> {
1025   def PSrm : PI<opc, MRMSrcMem,
1026          (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
1027          !strconcat(base_opc, "s", asm_opr),
1028      [(set VR128:$dst,
1029        (psnode VR128:$src1,
1030               (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))))],
1031               itin, SSEPackedSingle>, PS,
1032      Sched<[WriteFShuffleLd, ReadAfterLd]>;
1033
1034   def PDrm : PI<opc, MRMSrcMem,
1035          (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
1036          !strconcat(base_opc, "d", asm_opr),
1037      [(set VR128:$dst, (v2f64 (pdnode VR128:$src1,
1038                               (scalar_to_vector (loadf64 addr:$src2)))))],
1039               itin, SSEPackedDouble>, PD,
1040      Sched<[WriteFShuffleLd, ReadAfterLd]>;
1041
1042 }
1043
1044 multiclass sse12_mov_hilo_packed<bits<8>opc, SDNode psnode, SDNode pdnode,
1045                                  string base_opc, InstrItinClass itin> {
1046   let Predicates = [UseAVX] in
1047     defm V#NAME : sse12_mov_hilo_packed_base<opc, psnode, pdnode, base_opc,
1048                                     "\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1049                                     itin>, VEX_4V, VEX_WIG;
1050
1051   let Constraints = "$src1 = $dst" in
1052     defm NAME : sse12_mov_hilo_packed_base<opc, psnode, pdnode, base_opc,
1053                                     "\t{$src2, $dst|$dst, $src2}",
1054                                     itin>;
1055 }
1056
1057 let AddedComplexity = 20 in {
1058   defm MOVL : sse12_mov_hilo_packed<0x12, X86Movlps, X86Movlpd, "movlp",
1059                                     IIC_SSE_MOV_LH>;
1060 }
1061
1062 let SchedRW = [WriteStore] in {
1063 let Predicates = [UseAVX] in {
1064 def VMOVLPSmr : VPSI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1065                    "movlps\t{$src, $dst|$dst, $src}",
1066                    [(store (f64 (extractelt (bc_v2f64 (v4f32 VR128:$src)),
1067                                  (iPTR 0))), addr:$dst)],
1068                                  IIC_SSE_MOV_LH>, VEX, VEX_WIG;
1069 def VMOVLPDmr : VPDI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1070                    "movlpd\t{$src, $dst|$dst, $src}",
1071                    [(store (f64 (extractelt (v2f64 VR128:$src),
1072                                  (iPTR 0))), addr:$dst)],
1073                                  IIC_SSE_MOV_LH>, VEX, VEX_WIG;
1074 }// UseAVX
1075 def MOVLPSmr : PSI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1076                    "movlps\t{$src, $dst|$dst, $src}",
1077                    [(store (f64 (extractelt (bc_v2f64 (v4f32 VR128:$src)),
1078                                  (iPTR 0))), addr:$dst)],
1079                                  IIC_SSE_MOV_LH>;
1080 def MOVLPDmr : PDI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1081                    "movlpd\t{$src, $dst|$dst, $src}",
1082                    [(store (f64 (extractelt (v2f64 VR128:$src),
1083                                  (iPTR 0))), addr:$dst)],
1084                                  IIC_SSE_MOV_LH>;
1085 } // SchedRW
1086
1087 let Predicates = [UseAVX] in {
1088   // Shuffle with VMOVLPS
1089   def : Pat<(v4f32 (X86Movlps VR128:$src1, (load addr:$src2))),
1090             (VMOVLPSrm VR128:$src1, addr:$src2)>;
1091   def : Pat<(v4i32 (X86Movlps VR128:$src1, (load addr:$src2))),
1092             (VMOVLPSrm VR128:$src1, addr:$src2)>;
1093
1094   // Shuffle with VMOVLPD
1095   def : Pat<(v2f64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1096             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1097   def : Pat<(v2i64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1098             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1099   def : Pat<(v2f64 (X86Movsd VR128:$src1,
1100                              (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1101             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1102
1103   // Store patterns
1104   def : Pat<(store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)),
1105                    addr:$src1),
1106             (VMOVLPSmr addr:$src1, VR128:$src2)>;
1107   def : Pat<(store (v4i32 (X86Movlps
1108                    (bc_v4i32 (loadv2i64 addr:$src1)), VR128:$src2)), addr:$src1),
1109             (VMOVLPSmr addr:$src1, VR128:$src2)>;
1110   def : Pat<(store (v2f64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1111                    addr:$src1),
1112             (VMOVLPDmr addr:$src1, VR128:$src2)>;
1113   def : Pat<(store (v2i64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1114                    addr:$src1),
1115             (VMOVLPDmr addr:$src1, VR128:$src2)>;
1116 }
1117
1118 let Predicates = [UseSSE1] in {
1119   // (store (vector_shuffle (load addr), v2, <4, 5, 2, 3>), addr) using MOVLPS
1120   def : Pat<(store (i64 (extractelt (bc_v2i64 (v4f32 VR128:$src2)),
1121                                  (iPTR 0))), addr:$src1),
1122             (MOVLPSmr addr:$src1, VR128:$src2)>;
1123
1124   // Shuffle with MOVLPS
1125   def : Pat<(v4f32 (X86Movlps VR128:$src1, (load addr:$src2))),
1126             (MOVLPSrm VR128:$src1, addr:$src2)>;
1127   def : Pat<(v4i32 (X86Movlps VR128:$src1, (load addr:$src2))),
1128             (MOVLPSrm VR128:$src1, addr:$src2)>;
1129   def : Pat<(X86Movlps VR128:$src1,
1130                       (bc_v4f32 (v2i64 (scalar_to_vector (loadi64 addr:$src2))))),
1131             (MOVLPSrm VR128:$src1, addr:$src2)>;
1132
1133   // Store patterns
1134   def : Pat<(store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)),
1135                                       addr:$src1),
1136             (MOVLPSmr addr:$src1, VR128:$src2)>;
1137   def : Pat<(store (v4i32 (X86Movlps
1138                    (bc_v4i32 (loadv2i64 addr:$src1)), VR128:$src2)),
1139                               addr:$src1),
1140             (MOVLPSmr addr:$src1, VR128:$src2)>;
1141 }
1142
1143 let Predicates = [UseSSE2] in {
1144   // Shuffle with MOVLPD
1145   def : Pat<(v2f64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1146             (MOVLPDrm VR128:$src1, addr:$src2)>;
1147   def : Pat<(v2i64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1148             (MOVLPDrm VR128:$src1, addr:$src2)>;
1149   def : Pat<(v2f64 (X86Movsd VR128:$src1,
1150                              (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1151             (MOVLPDrm VR128:$src1, addr:$src2)>;
1152
1153   // Store patterns
1154   def : Pat<(store (v2f64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1155                            addr:$src1),
1156             (MOVLPDmr addr:$src1, VR128:$src2)>;
1157   def : Pat<(store (v2i64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1158                            addr:$src1),
1159             (MOVLPDmr addr:$src1, VR128:$src2)>;
1160 }
1161
1162 //===----------------------------------------------------------------------===//
1163 // SSE 1 & 2 - Move Hi packed FP Instructions
1164 //===----------------------------------------------------------------------===//
1165
1166 let AddedComplexity = 20 in {
1167   defm MOVH : sse12_mov_hilo_packed<0x16, X86Movlhps, X86Movlhpd, "movhp",
1168                                     IIC_SSE_MOV_LH>;
1169 }
1170
1171 let SchedRW = [WriteStore] in {
1172 // v2f64 extract element 1 is always custom lowered to unpack high to low
1173 // and extract element 0 so the non-store version isn't too horrible.
1174 let Predicates = [UseAVX] in {
1175 def VMOVHPSmr : VPSI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1176                    "movhps\t{$src, $dst|$dst, $src}",
1177                    [(store (f64 (extractelt
1178                                  (X86Unpckh (bc_v2f64 (v4f32 VR128:$src)),
1179                                             (bc_v2f64 (v4f32 VR128:$src))),
1180                                  (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>, VEX, VEX_WIG;
1181 def VMOVHPDmr : VPDI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1182                    "movhpd\t{$src, $dst|$dst, $src}",
1183                    [(store (f64 (extractelt
1184                                  (v2f64 (X86Unpckh VR128:$src, VR128:$src)),
1185                                  (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>, VEX, VEX_WIG;
1186 } // UseAVX
1187 def MOVHPSmr : PSI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1188                    "movhps\t{$src, $dst|$dst, $src}",
1189                    [(store (f64 (extractelt
1190                                  (X86Unpckh (bc_v2f64 (v4f32 VR128:$src)),
1191                                             (bc_v2f64 (v4f32 VR128:$src))),
1192                                  (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>;
1193 def MOVHPDmr : PDI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1194                    "movhpd\t{$src, $dst|$dst, $src}",
1195                    [(store (f64 (extractelt
1196                                  (v2f64 (X86Unpckh VR128:$src, VR128:$src)),
1197                                  (iPTR 0))), addr:$dst)], IIC_SSE_MOV_LH>;
1198 } // SchedRW
1199
1200 let Predicates = [UseAVX] in {
1201   // VMOVHPS patterns
1202   def : Pat<(X86Movlhps VR128:$src1,
1203                  (bc_v4f32 (v2i64 (scalar_to_vector (loadi64 addr:$src2))))),
1204             (VMOVHPSrm VR128:$src1, addr:$src2)>;
1205   def : Pat<(X86Movlhps VR128:$src1,
1206                  (bc_v4i32 (v2i64 (X86vzload addr:$src2)))),
1207             (VMOVHPSrm VR128:$src1, addr:$src2)>;
1208
1209   // VMOVHPD patterns
1210
1211   // FIXME: Instead of X86Unpckl, there should be a X86Movlhpd here, the problem
1212   // is during lowering, where it's not possible to recognize the load fold
1213   // cause it has two uses through a bitcast. One use disappears at isel time
1214   // and the fold opportunity reappears.
1215   def : Pat<(v2f64 (X86Unpckl VR128:$src1,
1216                       (scalar_to_vector (loadf64 addr:$src2)))),
1217             (VMOVHPDrm VR128:$src1, addr:$src2)>;
1218
1219   // Also handle an i64 load because that may get selected as a faster way to
1220   // load the data.
1221   def : Pat<(v2f64 (X86Unpckl VR128:$src1,
1222                       (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src2)))))),
1223             (VMOVHPDrm VR128:$src1, addr:$src2)>;
1224
1225   def : Pat<(store (f64 (extractelt
1226                           (bc_v2f64 (v4f32 (X86Movhlps VR128:$src, VR128:$src))),
1227                           (iPTR 0))), addr:$dst),
1228             (VMOVHPDmr addr:$dst, VR128:$src)>;
1229
1230   def : Pat<(store (f64 (extractelt
1231                           (v2f64 (X86VPermilpi VR128:$src, (i8 1))),
1232                           (iPTR 0))), addr:$dst),
1233             (VMOVHPDmr addr:$dst, VR128:$src)>;
1234 }
1235
1236 let Predicates = [UseSSE1] in {
1237   // MOVHPS patterns
1238   def : Pat<(X86Movlhps VR128:$src1,
1239                  (bc_v4f32 (v2i64 (scalar_to_vector (loadi64 addr:$src2))))),
1240             (MOVHPSrm VR128:$src1, addr:$src2)>;
1241   def : Pat<(X86Movlhps VR128:$src1,
1242                  (bc_v4f32 (v2i64 (X86vzload addr:$src2)))),
1243             (MOVHPSrm VR128:$src1, addr:$src2)>;
1244 }
1245
1246 let Predicates = [UseSSE2] in {
1247   // MOVHPD patterns
1248
1249   // FIXME: Instead of X86Unpckl, there should be a X86Movlhpd here, the problem
1250   // is during lowering, where it's not possible to recognize the load fold
1251   // cause it has two uses through a bitcast. One use disappears at isel time
1252   // and the fold opportunity reappears.
1253   def : Pat<(v2f64 (X86Unpckl VR128:$src1,
1254                       (scalar_to_vector (loadf64 addr:$src2)))),
1255             (MOVHPDrm VR128:$src1, addr:$src2)>;
1256
1257   // Also handle an i64 load because that may get selected as a faster way to
1258   // load the data.
1259   def : Pat<(v2f64 (X86Unpckl VR128:$src1,
1260                       (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src2)))))),
1261             (MOVHPDrm VR128:$src1, addr:$src2)>;
1262
1263   def : Pat<(store (f64 (extractelt
1264                           (bc_v2f64 (v4f32 (X86Movhlps VR128:$src, VR128:$src))),
1265                           (iPTR 0))), addr:$dst),
1266             (MOVHPDmr addr:$dst, VR128:$src)>;
1267
1268   def : Pat<(store (f64 (extractelt
1269                           (v2f64 (X86Shufp VR128:$src, VR128:$src, (i8 1))),
1270                           (iPTR 0))), addr:$dst),
1271             (MOVHPDmr addr:$dst, VR128:$src)>;
1272 }
1273
1274 //===----------------------------------------------------------------------===//
1275 // SSE 1 & 2 - Move Low to High and High to Low packed FP Instructions
1276 //===----------------------------------------------------------------------===//
1277
1278 let AddedComplexity = 20, Predicates = [UseAVX] in {
1279   def VMOVLHPSrr : VPSI<0x16, MRMSrcReg, (outs VR128:$dst),
1280                                        (ins VR128:$src1, VR128:$src2),
1281                       "movlhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1282                       [(set VR128:$dst,
1283                         (v4f32 (X86Movlhps VR128:$src1, VR128:$src2)))],
1284                         IIC_SSE_MOV_LH>,
1285                       VEX_4V, Sched<[WriteFShuffle]>, VEX_WIG;
1286   def VMOVHLPSrr : VPSI<0x12, MRMSrcReg, (outs VR128:$dst),
1287                                        (ins VR128:$src1, VR128:$src2),
1288                       "movhlps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1289                       [(set VR128:$dst,
1290                         (v4f32 (X86Movhlps VR128:$src1, VR128:$src2)))],
1291                         IIC_SSE_MOV_LH>,
1292                       VEX_4V, Sched<[WriteFShuffle]>, VEX_WIG;
1293 }
1294 let Constraints = "$src1 = $dst", AddedComplexity = 20 in {
1295   def MOVLHPSrr : PSI<0x16, MRMSrcReg, (outs VR128:$dst),
1296                                        (ins VR128:$src1, VR128:$src2),
1297                       "movlhps\t{$src2, $dst|$dst, $src2}",
1298                       [(set VR128:$dst,
1299                         (v4f32 (X86Movlhps VR128:$src1, VR128:$src2)))],
1300                         IIC_SSE_MOV_LH>, Sched<[WriteFShuffle]>;
1301   let isCommutable = 1 in
1302   def MOVHLPSrr : PSI<0x12, MRMSrcReg, (outs VR128:$dst),
1303                                        (ins VR128:$src1, VR128:$src2),
1304                       "movhlps\t{$src2, $dst|$dst, $src2}",
1305                       [(set VR128:$dst,
1306                         (v4f32 (X86Movhlps VR128:$src1, VR128:$src2)))],
1307                         IIC_SSE_MOV_LH>, Sched<[WriteFShuffle]>;
1308 }
1309
1310 let Predicates = [UseAVX] in {
1311   // MOVLHPS patterns
1312   def : Pat<(v4i32 (X86Movlhps VR128:$src1, VR128:$src2)),
1313             (VMOVLHPSrr VR128:$src1, VR128:$src2)>;
1314   def : Pat<(v2i64 (X86Movlhps VR128:$src1, VR128:$src2)),
1315             (VMOVLHPSrr (v2i64 VR128:$src1), VR128:$src2)>;
1316
1317   // MOVHLPS patterns
1318   def : Pat<(v4i32 (X86Movhlps VR128:$src1, VR128:$src2)),
1319             (VMOVHLPSrr VR128:$src1, VR128:$src2)>;
1320 }
1321
1322 let Predicates = [UseSSE1] in {
1323   // MOVLHPS patterns
1324   def : Pat<(v4i32 (X86Movlhps VR128:$src1, VR128:$src2)),
1325             (MOVLHPSrr VR128:$src1, VR128:$src2)>;
1326   def : Pat<(v2i64 (X86Movlhps VR128:$src1, VR128:$src2)),
1327             (MOVLHPSrr (v2i64 VR128:$src1), VR128:$src2)>;
1328
1329   // MOVHLPS patterns
1330   def : Pat<(v4i32 (X86Movhlps VR128:$src1, VR128:$src2)),
1331             (MOVHLPSrr VR128:$src1, VR128:$src2)>;
1332 }
1333
1334 //===----------------------------------------------------------------------===//
1335 // SSE 1 & 2 - Conversion Instructions
1336 //===----------------------------------------------------------------------===//
1337
1338 def SSE_CVT_PD : OpndItins<
1339   IIC_SSE_CVT_PD_RR, IIC_SSE_CVT_PD_RM
1340 >;
1341
1342 let Sched = WriteCvtI2F in
1343 def SSE_CVT_PS : OpndItins<
1344   IIC_SSE_CVT_PS_RR, IIC_SSE_CVT_PS_RM
1345 >;
1346
1347 let Sched = WriteCvtI2F in
1348 def SSE_CVT_Scalar : OpndItins<
1349   IIC_SSE_CVT_Scalar_RR, IIC_SSE_CVT_Scalar_RM
1350 >;
1351
1352 let Sched = WriteCvtF2I in
1353 def SSE_CVT_SS2SI_32 : OpndItins<
1354   IIC_SSE_CVT_SS2SI32_RR, IIC_SSE_CVT_SS2SI32_RM
1355 >;
1356
1357 let Sched = WriteCvtF2I in
1358 def SSE_CVT_SS2SI_64 : OpndItins<
1359   IIC_SSE_CVT_SS2SI64_RR, IIC_SSE_CVT_SS2SI64_RM
1360 >;
1361
1362 let Sched = WriteCvtF2I in
1363 def SSE_CVT_SD2SI : OpndItins<
1364   IIC_SSE_CVT_SD2SI_RR, IIC_SSE_CVT_SD2SI_RM
1365 >;
1366
1367 // FIXME: We probably want to match the rm form only when optimizing for
1368 // size, to avoid false depenendecies (see sse_fp_unop_s for details)
1369 multiclass sse12_cvt_s<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1370                      SDNode OpNode, X86MemOperand x86memop, PatFrag ld_frag,
1371                      string asm, OpndItins itins> {
1372   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src), asm,
1373                         [(set DstRC:$dst, (OpNode SrcRC:$src))],
1374                         itins.rr>, Sched<[itins.Sched]>;
1375   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst), (ins x86memop:$src), asm,
1376                         [(set DstRC:$dst, (OpNode (ld_frag addr:$src)))],
1377                         itins.rm>, Sched<[itins.Sched.Folded]>;
1378 }
1379
1380 multiclass sse12_cvt_p<bits<8> opc, RegisterClass RC, X86MemOperand x86memop,
1381                        ValueType DstTy, ValueType SrcTy, PatFrag ld_frag,
1382                        string asm, Domain d, OpndItins itins> {
1383 let hasSideEffects = 0 in {
1384   def rr : I<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src), asm,
1385              [(set RC:$dst, (DstTy (sint_to_fp (SrcTy RC:$src))))],
1386              itins.rr, d>, Sched<[itins.Sched]>;
1387   let mayLoad = 1 in
1388   def rm : I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src), asm,
1389              [(set RC:$dst, (DstTy (sint_to_fp
1390                                     (SrcTy (bitconvert (ld_frag addr:$src))))))],
1391              itins.rm, d>, Sched<[itins.Sched.Folded]>;
1392 }
1393 }
1394
1395 // FIXME: We probably want to match the rm form only when optimizing for
1396 // size, to avoid false depenendecies (see sse_fp_unop_s for details)
1397 multiclass sse12_vcvt_avx<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1398                           X86MemOperand x86memop, string asm> {
1399 let hasSideEffects = 0, Predicates = [UseAVX] in {
1400   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins DstRC:$src1, SrcRC:$src),
1401               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>,
1402            Sched<[WriteCvtI2F]>;
1403   let mayLoad = 1 in
1404   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst),
1405               (ins DstRC:$src1, x86memop:$src),
1406               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>,
1407            Sched<[WriteCvtI2FLd, ReadAfterLd]>;
1408 } // hasSideEffects = 0
1409 }
1410
1411 let Predicates = [UseAVX] in {
1412 defm VCVTTSS2SI   : sse12_cvt_s<0x2C, FR32, GR32, fp_to_sint, f32mem, loadf32,
1413                                 "cvttss2si\t{$src, $dst|$dst, $src}",
1414                                 SSE_CVT_SS2SI_32>,
1415                                 XS, VEX, VEX_LIG;
1416 defm VCVTTSS2SI64 : sse12_cvt_s<0x2C, FR32, GR64, fp_to_sint, f32mem, loadf32,
1417                                 "cvttss2si\t{$src, $dst|$dst, $src}",
1418                                 SSE_CVT_SS2SI_64>,
1419                                 XS, VEX, VEX_W, VEX_LIG;
1420 defm VCVTTSD2SI   : sse12_cvt_s<0x2C, FR64, GR32, fp_to_sint, f64mem, loadf64,
1421                                 "cvttsd2si\t{$src, $dst|$dst, $src}",
1422                                 SSE_CVT_SD2SI>,
1423                                 XD, VEX, VEX_LIG;
1424 defm VCVTTSD2SI64 : sse12_cvt_s<0x2C, FR64, GR64, fp_to_sint, f64mem, loadf64,
1425                                 "cvttsd2si\t{$src, $dst|$dst, $src}",
1426                                 SSE_CVT_SD2SI>,
1427                                 XD, VEX, VEX_W, VEX_LIG;
1428
1429 def : InstAlias<"vcvttss2si{l}\t{$src, $dst|$dst, $src}",
1430                 (VCVTTSS2SIrr GR32:$dst, FR32:$src), 0>;
1431 def : InstAlias<"vcvttss2si{l}\t{$src, $dst|$dst, $src}",
1432                 (VCVTTSS2SIrm GR32:$dst, f32mem:$src), 0>;
1433 def : InstAlias<"vcvttsd2si{l}\t{$src, $dst|$dst, $src}",
1434                 (VCVTTSD2SIrr GR32:$dst, FR64:$src), 0>;
1435 def : InstAlias<"vcvttsd2si{l}\t{$src, $dst|$dst, $src}",
1436                 (VCVTTSD2SIrm GR32:$dst, f64mem:$src), 0>;
1437 def : InstAlias<"vcvttss2si{q}\t{$src, $dst|$dst, $src}",
1438                 (VCVTTSS2SI64rr GR64:$dst, FR32:$src), 0>;
1439 def : InstAlias<"vcvttss2si{q}\t{$src, $dst|$dst, $src}",
1440                 (VCVTTSS2SI64rm GR64:$dst, f32mem:$src), 0>;
1441 def : InstAlias<"vcvttsd2si{q}\t{$src, $dst|$dst, $src}",
1442                 (VCVTTSD2SI64rr GR64:$dst, FR64:$src), 0>;
1443 def : InstAlias<"vcvttsd2si{q}\t{$src, $dst|$dst, $src}",
1444                 (VCVTTSD2SI64rm GR64:$dst, f64mem:$src), 0>;
1445 }
1446 // The assembler can recognize rr 64-bit instructions by seeing a rxx
1447 // register, but the same isn't true when only using memory operands,
1448 // provide other assembly "l" and "q" forms to address this explicitly
1449 // where appropriate to do so.
1450 defm VCVTSI2SS   : sse12_vcvt_avx<0x2A, GR32, FR32, i32mem, "cvtsi2ss{l}">,
1451                                   XS, VEX_4V, VEX_LIG;
1452 defm VCVTSI2SS64 : sse12_vcvt_avx<0x2A, GR64, FR32, i64mem, "cvtsi2ss{q}">,
1453                                   XS, VEX_4V, VEX_W, VEX_LIG;
1454 defm VCVTSI2SD   : sse12_vcvt_avx<0x2A, GR32, FR64, i32mem, "cvtsi2sd{l}">,
1455                                   XD, VEX_4V, VEX_LIG;
1456 defm VCVTSI2SD64 : sse12_vcvt_avx<0x2A, GR64, FR64, i64mem, "cvtsi2sd{q}">,
1457                                   XD, VEX_4V, VEX_W, VEX_LIG;
1458
1459 let Predicates = [UseAVX] in {
1460   def : InstAlias<"vcvtsi2ss\t{$src, $src1, $dst|$dst, $src1, $src}",
1461                 (VCVTSI2SSrm FR64:$dst, FR64:$src1, i32mem:$src), 0>;
1462   def : InstAlias<"vcvtsi2sd\t{$src, $src1, $dst|$dst, $src1, $src}",
1463                 (VCVTSI2SDrm FR64:$dst, FR64:$src1, i32mem:$src), 0>;
1464
1465   def : Pat<(f32 (sint_to_fp (loadi32 addr:$src))),
1466             (VCVTSI2SSrm (f32 (IMPLICIT_DEF)), addr:$src)>;
1467   def : Pat<(f32 (sint_to_fp (loadi64 addr:$src))),
1468             (VCVTSI2SS64rm (f32 (IMPLICIT_DEF)), addr:$src)>;
1469   def : Pat<(f64 (sint_to_fp (loadi32 addr:$src))),
1470             (VCVTSI2SDrm (f64 (IMPLICIT_DEF)), addr:$src)>;
1471   def : Pat<(f64 (sint_to_fp (loadi64 addr:$src))),
1472             (VCVTSI2SD64rm (f64 (IMPLICIT_DEF)), addr:$src)>;
1473
1474   def : Pat<(f32 (sint_to_fp GR32:$src)),
1475             (VCVTSI2SSrr (f32 (IMPLICIT_DEF)), GR32:$src)>;
1476   def : Pat<(f32 (sint_to_fp GR64:$src)),
1477             (VCVTSI2SS64rr (f32 (IMPLICIT_DEF)), GR64:$src)>;
1478   def : Pat<(f64 (sint_to_fp GR32:$src)),
1479             (VCVTSI2SDrr (f64 (IMPLICIT_DEF)), GR32:$src)>;
1480   def : Pat<(f64 (sint_to_fp GR64:$src)),
1481             (VCVTSI2SD64rr (f64 (IMPLICIT_DEF)), GR64:$src)>;
1482 }
1483
1484 defm CVTTSS2SI : sse12_cvt_s<0x2C, FR32, GR32, fp_to_sint, f32mem, loadf32,
1485                       "cvttss2si\t{$src, $dst|$dst, $src}",
1486                       SSE_CVT_SS2SI_32>, XS;
1487 defm CVTTSS2SI64 : sse12_cvt_s<0x2C, FR32, GR64, fp_to_sint, f32mem, loadf32,
1488                       "cvttss2si\t{$src, $dst|$dst, $src}",
1489                       SSE_CVT_SS2SI_64>, XS, REX_W;
1490 defm CVTTSD2SI : sse12_cvt_s<0x2C, FR64, GR32, fp_to_sint, f64mem, loadf64,
1491                       "cvttsd2si\t{$src, $dst|$dst, $src}",
1492                       SSE_CVT_SD2SI>, XD;
1493 defm CVTTSD2SI64 : sse12_cvt_s<0x2C, FR64, GR64, fp_to_sint, f64mem, loadf64,
1494                       "cvttsd2si\t{$src, $dst|$dst, $src}",
1495                       SSE_CVT_SD2SI>, XD, REX_W;
1496 defm CVTSI2SS  : sse12_cvt_s<0x2A, GR32, FR32, sint_to_fp, i32mem, loadi32,
1497                       "cvtsi2ss{l}\t{$src, $dst|$dst, $src}",
1498                       SSE_CVT_Scalar>, XS;
1499 defm CVTSI2SS64 : sse12_cvt_s<0x2A, GR64, FR32, sint_to_fp, i64mem, loadi64,
1500                       "cvtsi2ss{q}\t{$src, $dst|$dst, $src}",
1501                       SSE_CVT_Scalar>, XS, REX_W;
1502 defm CVTSI2SD  : sse12_cvt_s<0x2A, GR32, FR64, sint_to_fp, i32mem, loadi32,
1503                       "cvtsi2sd{l}\t{$src, $dst|$dst, $src}",
1504                       SSE_CVT_Scalar>, XD;
1505 defm CVTSI2SD64 : sse12_cvt_s<0x2A, GR64, FR64, sint_to_fp, i64mem, loadi64,
1506                       "cvtsi2sd{q}\t{$src, $dst|$dst, $src}",
1507                       SSE_CVT_Scalar>, XD, REX_W;
1508
1509 def : InstAlias<"cvttss2si{l}\t{$src, $dst|$dst, $src}",
1510                 (CVTTSS2SIrr GR32:$dst, FR32:$src), 0>;
1511 def : InstAlias<"cvttss2si{l}\t{$src, $dst|$dst, $src}",
1512                 (CVTTSS2SIrm GR32:$dst, f32mem:$src), 0>;
1513 def : InstAlias<"cvttsd2si{l}\t{$src, $dst|$dst, $src}",
1514                 (CVTTSD2SIrr GR32:$dst, FR64:$src), 0>;
1515 def : InstAlias<"cvttsd2si{l}\t{$src, $dst|$dst, $src}",
1516                 (CVTTSD2SIrm GR32:$dst, f64mem:$src), 0>;
1517 def : InstAlias<"cvttss2si{q}\t{$src, $dst|$dst, $src}",
1518                 (CVTTSS2SI64rr GR64:$dst, FR32:$src), 0>;
1519 def : InstAlias<"cvttss2si{q}\t{$src, $dst|$dst, $src}",
1520                 (CVTTSS2SI64rm GR64:$dst, f32mem:$src), 0>;
1521 def : InstAlias<"cvttsd2si{q}\t{$src, $dst|$dst, $src}",
1522                 (CVTTSD2SI64rr GR64:$dst, FR64:$src), 0>;
1523 def : InstAlias<"cvttsd2si{q}\t{$src, $dst|$dst, $src}",
1524                 (CVTTSD2SI64rm GR64:$dst, f64mem:$src), 0>;
1525
1526 def : InstAlias<"cvtsi2ss\t{$src, $dst|$dst, $src}",
1527                 (CVTSI2SSrm FR64:$dst, i32mem:$src), 0>;
1528 def : InstAlias<"cvtsi2sd\t{$src, $dst|$dst, $src}",
1529                 (CVTSI2SDrm FR64:$dst, i32mem:$src), 0>;
1530
1531 // Conversion Instructions Intrinsics - Match intrinsics which expect MM
1532 // and/or XMM operand(s).
1533
1534 // FIXME: We probably want to match the rm form only when optimizing for
1535 // size, to avoid false depenendecies (see sse_fp_unop_s for details)
1536 multiclass sse12_cvt_sint<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1537                          Intrinsic Int, Operand memop, ComplexPattern mem_cpat,
1538                          string asm, OpndItins itins> {
1539   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src),
1540               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
1541               [(set DstRC:$dst, (Int SrcRC:$src))], itins.rr>,
1542            Sched<[itins.Sched]>;
1543   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst), (ins memop:$src),
1544               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
1545               [(set DstRC:$dst, (Int mem_cpat:$src))], itins.rm>,
1546            Sched<[itins.Sched.Folded]>;
1547 }
1548
1549 multiclass sse12_cvt_sint_3addr<bits<8> opc, RegisterClass SrcRC,
1550                     RegisterClass DstRC, Intrinsic Int, X86MemOperand x86memop,
1551                     PatFrag ld_frag, string asm, OpndItins itins,
1552                     bit Is2Addr = 1> {
1553   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins DstRC:$src1, SrcRC:$src2),
1554               !if(Is2Addr,
1555                   !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
1556                   !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1557               [(set DstRC:$dst, (Int DstRC:$src1, SrcRC:$src2))],
1558               itins.rr>, Sched<[itins.Sched]>;
1559   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst),
1560               (ins DstRC:$src1, x86memop:$src2),
1561               !if(Is2Addr,
1562                   !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
1563                   !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1564               [(set DstRC:$dst, (Int DstRC:$src1, (ld_frag addr:$src2)))],
1565               itins.rm>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
1566 }
1567
1568 let Predicates = [UseAVX] in {
1569 defm VCVTSD2SI : sse12_cvt_sint<0x2D, VR128, GR32,
1570                   int_x86_sse2_cvtsd2si, sdmem, sse_load_f64, "cvtsd2si",
1571                   SSE_CVT_SD2SI>, XD, VEX, VEX_LIG;
1572 defm VCVTSD2SI64 : sse12_cvt_sint<0x2D, VR128, GR64,
1573                     int_x86_sse2_cvtsd2si64, sdmem, sse_load_f64, "cvtsd2si",
1574                     SSE_CVT_SD2SI>, XD, VEX, VEX_W, VEX_LIG;
1575 }
1576 defm CVTSD2SI : sse12_cvt_sint<0x2D, VR128, GR32, int_x86_sse2_cvtsd2si,
1577                  sdmem, sse_load_f64, "cvtsd2si", SSE_CVT_SD2SI>, XD;
1578 defm CVTSD2SI64 : sse12_cvt_sint<0x2D, VR128, GR64, int_x86_sse2_cvtsd2si64,
1579                    sdmem, sse_load_f64, "cvtsd2si", SSE_CVT_SD2SI>, XD, REX_W;
1580
1581
1582 let isCodeGenOnly = 1 in {
1583   let Predicates = [UseAVX] in {
1584   defm Int_VCVTSI2SS : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1585             int_x86_sse_cvtsi2ss, i32mem, loadi32, "cvtsi2ss{l}",
1586             SSE_CVT_Scalar, 0>, XS, VEX_4V;
1587   defm Int_VCVTSI2SS64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1588             int_x86_sse_cvtsi642ss, i64mem, loadi64, "cvtsi2ss{q}",
1589             SSE_CVT_Scalar, 0>, XS, VEX_4V,
1590             VEX_W;
1591   defm Int_VCVTSI2SD : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1592             int_x86_sse2_cvtsi2sd, i32mem, loadi32, "cvtsi2sd{l}",
1593             SSE_CVT_Scalar, 0>, XD, VEX_4V;
1594   defm Int_VCVTSI2SD64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1595             int_x86_sse2_cvtsi642sd, i64mem, loadi64, "cvtsi2sd{q}",
1596             SSE_CVT_Scalar, 0>, XD,
1597             VEX_4V, VEX_W;
1598   }
1599   let Constraints = "$src1 = $dst" in {
1600     defm Int_CVTSI2SS : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1601                           int_x86_sse_cvtsi2ss, i32mem, loadi32,
1602                           "cvtsi2ss{l}", SSE_CVT_Scalar>, XS;
1603     defm Int_CVTSI2SS64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1604                           int_x86_sse_cvtsi642ss, i64mem, loadi64,
1605                           "cvtsi2ss{q}", SSE_CVT_Scalar>, XS, REX_W;
1606     defm Int_CVTSI2SD : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1607                           int_x86_sse2_cvtsi2sd, i32mem, loadi32,
1608                           "cvtsi2sd{l}", SSE_CVT_Scalar>, XD;
1609     defm Int_CVTSI2SD64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1610                           int_x86_sse2_cvtsi642sd, i64mem, loadi64,
1611                           "cvtsi2sd{q}", SSE_CVT_Scalar>, XD, REX_W;
1612   }
1613 } // isCodeGenOnly = 1
1614
1615 /// SSE 1 Only
1616
1617 // Aliases for intrinsics
1618 let isCodeGenOnly = 1 in {
1619 let Predicates = [UseAVX] in {
1620 defm Int_VCVTTSS2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse_cvttss2si,
1621                                     ssmem, sse_load_f32, "cvttss2si",
1622                                     SSE_CVT_SS2SI_32>, XS, VEX;
1623 defm Int_VCVTTSS2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1624                                    int_x86_sse_cvttss2si64, ssmem, sse_load_f32,
1625                                    "cvttss2si", SSE_CVT_SS2SI_64>,
1626                                    XS, VEX, VEX_W;
1627 defm Int_VCVTTSD2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse2_cvttsd2si,
1628                                     sdmem, sse_load_f64, "cvttsd2si",
1629                                     SSE_CVT_SD2SI>, XD, VEX;
1630 defm Int_VCVTTSD2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1631                                   int_x86_sse2_cvttsd2si64, sdmem, sse_load_f64,
1632                                   "cvttsd2si", SSE_CVT_SD2SI>,
1633                                   XD, VEX, VEX_W;
1634 }
1635 defm Int_CVTTSS2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse_cvttss2si,
1636                                     ssmem, sse_load_f32, "cvttss2si",
1637                                     SSE_CVT_SS2SI_32>, XS;
1638 defm Int_CVTTSS2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1639                                    int_x86_sse_cvttss2si64, ssmem, sse_load_f32,
1640                                    "cvttss2si", SSE_CVT_SS2SI_64>, XS, REX_W;
1641 defm Int_CVTTSD2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse2_cvttsd2si,
1642                                     sdmem, sse_load_f64, "cvttsd2si",
1643                                     SSE_CVT_SD2SI>, XD;
1644 defm Int_CVTTSD2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1645                                   int_x86_sse2_cvttsd2si64, sdmem, sse_load_f64,
1646                                   "cvttsd2si", SSE_CVT_SD2SI>, XD, REX_W;
1647 } // isCodeGenOnly = 1
1648
1649 let Predicates = [UseAVX] in {
1650 defm VCVTSS2SI   : sse12_cvt_sint<0x2D, VR128, GR32, int_x86_sse_cvtss2si,
1651                                   ssmem, sse_load_f32, "cvtss2si",
1652                                   SSE_CVT_SS2SI_32>, XS, VEX, VEX_LIG;
1653 defm VCVTSS2SI64 : sse12_cvt_sint<0x2D, VR128, GR64, int_x86_sse_cvtss2si64,
1654                                   ssmem, sse_load_f32, "cvtss2si",
1655                                   SSE_CVT_SS2SI_64>, XS, VEX, VEX_W, VEX_LIG;
1656 }
1657 defm CVTSS2SI : sse12_cvt_sint<0x2D, VR128, GR32, int_x86_sse_cvtss2si,
1658                                ssmem, sse_load_f32, "cvtss2si",
1659                                SSE_CVT_SS2SI_32>, XS;
1660 defm CVTSS2SI64 : sse12_cvt_sint<0x2D, VR128, GR64, int_x86_sse_cvtss2si64,
1661                                  ssmem, sse_load_f32, "cvtss2si",
1662                                  SSE_CVT_SS2SI_64>, XS, REX_W;
1663
1664 defm VCVTDQ2PS   : sse12_cvt_p<0x5B, VR128, i128mem, v4f32, v4i32, loadv2i64,
1665                                "vcvtdq2ps\t{$src, $dst|$dst, $src}",
1666                                SSEPackedSingle, SSE_CVT_PS>,
1667                                PS, VEX, Requires<[HasAVX, NoVLX]>, VEX_WIG;
1668 defm VCVTDQ2PSY  : sse12_cvt_p<0x5B, VR256, i256mem, v8f32, v8i32, loadv4i64,
1669                                "vcvtdq2ps\t{$src, $dst|$dst, $src}",
1670                                SSEPackedSingle, SSE_CVT_PS>,
1671                                PS, VEX, VEX_L, Requires<[HasAVX, NoVLX]>, VEX_WIG;
1672
1673 defm CVTDQ2PS : sse12_cvt_p<0x5B, VR128, i128mem, v4f32, v4i32, memopv2i64,
1674                             "cvtdq2ps\t{$src, $dst|$dst, $src}",
1675                             SSEPackedSingle, SSE_CVT_PS>,
1676                             PS, Requires<[UseSSE2]>;
1677
1678 let Predicates = [UseAVX] in {
1679 def : InstAlias<"vcvtss2si{l}\t{$src, $dst|$dst, $src}",
1680                 (VCVTSS2SIrr GR32:$dst, VR128:$src), 0>;
1681 def : InstAlias<"vcvtss2si{l}\t{$src, $dst|$dst, $src}",
1682                 (VCVTSS2SIrm GR32:$dst, ssmem:$src), 0>;
1683 def : InstAlias<"vcvtsd2si{l}\t{$src, $dst|$dst, $src}",
1684                 (VCVTSD2SIrr GR32:$dst, VR128:$src), 0>;
1685 def : InstAlias<"vcvtsd2si{l}\t{$src, $dst|$dst, $src}",
1686                 (VCVTSD2SIrm GR32:$dst, sdmem:$src), 0>;
1687 def : InstAlias<"vcvtss2si{q}\t{$src, $dst|$dst, $src}",
1688                 (VCVTSS2SI64rr GR64:$dst, VR128:$src), 0>;
1689 def : InstAlias<"vcvtss2si{q}\t{$src, $dst|$dst, $src}",
1690                 (VCVTSS2SI64rm GR64:$dst, ssmem:$src), 0>;
1691 def : InstAlias<"vcvtsd2si{q}\t{$src, $dst|$dst, $src}",
1692                 (VCVTSD2SI64rr GR64:$dst, VR128:$src), 0>;
1693 def : InstAlias<"vcvtsd2si{q}\t{$src, $dst|$dst, $src}",
1694                 (VCVTSD2SI64rm GR64:$dst, sdmem:$src), 0>;
1695 }
1696
1697 def : InstAlias<"cvtss2si{l}\t{$src, $dst|$dst, $src}",
1698                 (CVTSS2SIrr GR32:$dst, VR128:$src), 0>;
1699 def : InstAlias<"cvtss2si{l}\t{$src, $dst|$dst, $src}",
1700                 (CVTSS2SIrm GR32:$dst, ssmem:$src), 0>;
1701 def : InstAlias<"cvtsd2si{l}\t{$src, $dst|$dst, $src}",
1702                 (CVTSD2SIrr GR32:$dst, VR128:$src), 0>;
1703 def : InstAlias<"cvtsd2si{l}\t{$src, $dst|$dst, $src}",
1704                 (CVTSD2SIrm GR32:$dst, sdmem:$src), 0>;
1705 def : InstAlias<"cvtss2si{q}\t{$src, $dst|$dst, $src}",
1706                 (CVTSS2SI64rr GR64:$dst, VR128:$src), 0>;
1707 def : InstAlias<"cvtss2si{q}\t{$src, $dst|$dst, $src}",
1708                 (CVTSS2SI64rm GR64:$dst, ssmem:$src), 0>;
1709 def : InstAlias<"cvtsd2si{q}\t{$src, $dst|$dst, $src}",
1710                 (CVTSD2SI64rr GR64:$dst, VR128:$src), 0>;
1711 def : InstAlias<"cvtsd2si{q}\t{$src, $dst|$dst, $src}",
1712                 (CVTSD2SI64rm GR64:$dst, sdmem:$src), 0>;
1713
1714 /// SSE 2 Only
1715
1716 // Convert scalar double to scalar single
1717 let hasSideEffects = 0, Predicates = [UseAVX] in {
1718 def VCVTSD2SSrr  : VSDI<0x5A, MRMSrcReg, (outs FR32:$dst),
1719                        (ins FR32:$src1, FR64:$src2),
1720                       "cvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}", [],
1721                       IIC_SSE_CVT_Scalar_RR>, VEX_4V, VEX_LIG,
1722                       Sched<[WriteCvtF2F]>, VEX_WIG;
1723 let mayLoad = 1 in
1724 def VCVTSD2SSrm  : I<0x5A, MRMSrcMem, (outs FR32:$dst),
1725                        (ins FR32:$src1, f64mem:$src2),
1726                       "vcvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1727                       [], IIC_SSE_CVT_Scalar_RM>,
1728                       XD, Requires<[HasAVX, OptForSize]>, VEX_4V, VEX_LIG,
1729                       Sched<[WriteCvtF2FLd, ReadAfterLd]>, VEX_WIG;
1730 }
1731
1732 def : Pat<(f32 (fpround FR64:$src)),
1733             (VCVTSD2SSrr (COPY_TO_REGCLASS FR64:$src, FR32), FR64:$src)>,
1734           Requires<[UseAVX]>;
1735
1736 def CVTSD2SSrr  : SDI<0x5A, MRMSrcReg, (outs FR32:$dst), (ins FR64:$src),
1737                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1738                       [(set FR32:$dst, (fpround FR64:$src))],
1739                       IIC_SSE_CVT_Scalar_RR>, Sched<[WriteCvtF2F]>;
1740 def CVTSD2SSrm  : I<0x5A, MRMSrcMem, (outs FR32:$dst), (ins f64mem:$src),
1741                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1742                       [(set FR32:$dst, (fpround (loadf64 addr:$src)))],
1743                       IIC_SSE_CVT_Scalar_RM>,
1744                       XD,
1745                   Requires<[UseSSE2, OptForSize]>, Sched<[WriteCvtF2FLd]>;
1746
1747 let isCodeGenOnly = 1 in {
1748 def Int_VCVTSD2SSrr: I<0x5A, MRMSrcReg,
1749                        (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1750                        "vcvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1751                        [(set VR128:$dst,
1752                          (int_x86_sse2_cvtsd2ss VR128:$src1, VR128:$src2))],
1753                        IIC_SSE_CVT_Scalar_RR>, XD, VEX_4V, VEX_WIG,
1754                        Requires<[HasAVX]>, Sched<[WriteCvtF2F]>;
1755 def Int_VCVTSD2SSrm: I<0x5A, MRMSrcMem,
1756                        (outs VR128:$dst), (ins VR128:$src1, sdmem:$src2),
1757                        "vcvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1758                        [(set VR128:$dst, (int_x86_sse2_cvtsd2ss
1759                                           VR128:$src1, sse_load_f64:$src2))],
1760                        IIC_SSE_CVT_Scalar_RM>, XD, VEX_4V, VEX_WIG,
1761                        Requires<[HasAVX]>, Sched<[WriteCvtF2FLd, ReadAfterLd]>;
1762
1763 let Constraints = "$src1 = $dst" in {
1764 def Int_CVTSD2SSrr: I<0x5A, MRMSrcReg,
1765                        (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1766                        "cvtsd2ss\t{$src2, $dst|$dst, $src2}",
1767                        [(set VR128:$dst,
1768                          (int_x86_sse2_cvtsd2ss VR128:$src1, VR128:$src2))],
1769                        IIC_SSE_CVT_Scalar_RR>, XD, Requires<[UseSSE2]>,
1770                        Sched<[WriteCvtF2F]>;
1771 def Int_CVTSD2SSrm: I<0x5A, MRMSrcMem,
1772                        (outs VR128:$dst), (ins VR128:$src1, sdmem:$src2),
1773                        "cvtsd2ss\t{$src2, $dst|$dst, $src2}",
1774                        [(set VR128:$dst, (int_x86_sse2_cvtsd2ss
1775                                           VR128:$src1, sse_load_f64:$src2))],
1776                        IIC_SSE_CVT_Scalar_RM>, XD, Requires<[UseSSE2]>,
1777                        Sched<[WriteCvtF2FLd, ReadAfterLd]>;
1778 }
1779 } // isCodeGenOnly = 1
1780
1781 // Convert scalar single to scalar double
1782 // SSE2 instructions with XS prefix
1783 let hasSideEffects = 0, Predicates = [UseAVX] in {
1784 def VCVTSS2SDrr : I<0x5A, MRMSrcReg, (outs FR64:$dst),
1785                     (ins FR64:$src1, FR32:$src2),
1786                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1787                     [], IIC_SSE_CVT_Scalar_RR>,
1788                     XS, Requires<[HasAVX]>, VEX_4V, VEX_LIG,
1789                     Sched<[WriteCvtF2F]>, VEX_WIG;
1790 let mayLoad = 1 in
1791 def VCVTSS2SDrm : I<0x5A, MRMSrcMem, (outs FR64:$dst),
1792                     (ins FR64:$src1, f32mem:$src2),
1793                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1794                     [], IIC_SSE_CVT_Scalar_RM>,
1795                     XS, VEX_4V, VEX_LIG, Requires<[HasAVX, OptForSize]>,
1796                     Sched<[WriteCvtF2FLd, ReadAfterLd]>, VEX_WIG;
1797 }
1798
1799 def : Pat<(f64 (fpextend FR32:$src)),
1800     (VCVTSS2SDrr (COPY_TO_REGCLASS FR32:$src, FR64), FR32:$src)>, Requires<[UseAVX]>;
1801 def : Pat<(fpextend (loadf32 addr:$src)),
1802     (VCVTSS2SDrm (f64 (IMPLICIT_DEF)), addr:$src)>, Requires<[UseAVX]>;
1803
1804 def : Pat<(extloadf32 addr:$src),
1805     (VCVTSS2SDrm (f64 (IMPLICIT_DEF)), addr:$src)>,
1806     Requires<[UseAVX, OptForSize]>;
1807 def : Pat<(extloadf32 addr:$src),
1808     (VCVTSS2SDrr (f64 (IMPLICIT_DEF)), (VMOVSSrm addr:$src))>,
1809     Requires<[UseAVX, OptForSpeed]>;
1810
1811 def CVTSS2SDrr : I<0x5A, MRMSrcReg, (outs FR64:$dst), (ins FR32:$src),
1812                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1813                    [(set FR64:$dst, (fpextend FR32:$src))],
1814                    IIC_SSE_CVT_Scalar_RR>, XS,
1815                  Requires<[UseSSE2]>, Sched<[WriteCvtF2F]>;
1816 def CVTSS2SDrm : I<0x5A, MRMSrcMem, (outs FR64:$dst), (ins f32mem:$src),
1817                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1818                    [(set FR64:$dst, (extloadf32 addr:$src))],
1819                    IIC_SSE_CVT_Scalar_RM>, XS,
1820                  Requires<[UseSSE2, OptForSize]>, Sched<[WriteCvtF2FLd]>;
1821
1822 // extload f32 -> f64.  This matches load+fpextend because we have a hack in
1823 // the isel (PreprocessForFPConvert) that can introduce loads after dag
1824 // combine.
1825 // Since these loads aren't folded into the fpextend, we have to match it
1826 // explicitly here.
1827 def : Pat<(fpextend (loadf32 addr:$src)),
1828           (CVTSS2SDrm addr:$src)>, Requires<[UseSSE2]>;
1829 def : Pat<(extloadf32 addr:$src),
1830           (CVTSS2SDrr (MOVSSrm addr:$src))>, Requires<[UseSSE2, OptForSpeed]>;
1831
1832 let isCodeGenOnly = 1 in {
1833 def Int_VCVTSS2SDrr: I<0x5A, MRMSrcReg,
1834                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1835                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1836                     [(set VR128:$dst,
1837                       (int_x86_sse2_cvtss2sd VR128:$src1, VR128:$src2))],
1838                     IIC_SSE_CVT_Scalar_RR>, XS, VEX_4V, VEX_WIG,
1839                     Requires<[HasAVX]>, Sched<[WriteCvtF2F]>;
1840 def Int_VCVTSS2SDrm: I<0x5A, MRMSrcMem,
1841                       (outs VR128:$dst), (ins VR128:$src1, ssmem:$src2),
1842                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1843                     [(set VR128:$dst,
1844                       (int_x86_sse2_cvtss2sd VR128:$src1, sse_load_f32:$src2))],
1845                     IIC_SSE_CVT_Scalar_RM>, XS, VEX_4V, VEX_WIG,
1846                     Requires<[HasAVX]>, Sched<[WriteCvtF2FLd, ReadAfterLd]>;
1847 let Constraints = "$src1 = $dst" in { // SSE2 instructions with XS prefix
1848 def Int_CVTSS2SDrr: I<0x5A, MRMSrcReg,
1849                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1850                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1851                     [(set VR128:$dst,
1852                       (int_x86_sse2_cvtss2sd VR128:$src1, VR128:$src2))],
1853                     IIC_SSE_CVT_Scalar_RR>, XS, Requires<[UseSSE2]>,
1854                     Sched<[WriteCvtF2F]>;
1855 def Int_CVTSS2SDrm: I<0x5A, MRMSrcMem,
1856                       (outs VR128:$dst), (ins VR128:$src1, ssmem:$src2),
1857                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1858                     [(set VR128:$dst,
1859                       (int_x86_sse2_cvtss2sd VR128:$src1, sse_load_f32:$src2))],
1860                     IIC_SSE_CVT_Scalar_RM>, XS, Requires<[UseSSE2]>,
1861                     Sched<[WriteCvtF2FLd, ReadAfterLd]>;
1862 }
1863 } // isCodeGenOnly = 1
1864
1865 // Patterns used for matching (v)cvtsi2ss, (v)cvtsi2sd, (v)cvtsd2ss and
1866 // (v)cvtss2sd intrinsic sequences from clang which produce unnecessary
1867 // vmovs{s,d} instructions
1868 let Predicates = [UseAVX] in {
1869 def : Pat<(v4f32 (X86Movss
1870                    (v4f32 VR128:$dst),
1871                    (v4f32 (scalar_to_vector
1872                      (f32 (fpround (f64 (extractelt VR128:$src, (iPTR 0))))))))),
1873           (Int_VCVTSD2SSrr VR128:$dst, VR128:$src)>;
1874
1875 def : Pat<(v2f64 (X86Movsd
1876                    (v2f64 VR128:$dst),
1877                    (v2f64 (scalar_to_vector
1878                      (f64 (fpextend (f32 (extractelt VR128:$src, (iPTR 0))))))))),
1879           (Int_VCVTSS2SDrr VR128:$dst, VR128:$src)>;
1880
1881 def : Pat<(v4f32 (X86Movss
1882                    (v4f32 VR128:$dst),
1883                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR64:$src)))))),
1884           (Int_VCVTSI2SS64rr VR128:$dst, GR64:$src)>;
1885
1886 def : Pat<(v4f32 (X86Movss
1887                    (v4f32 VR128:$dst),
1888                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR32:$src)))))),
1889           (Int_VCVTSI2SSrr VR128:$dst, GR32:$src)>;
1890
1891 def : Pat<(v2f64 (X86Movsd
1892                    (v2f64 VR128:$dst),
1893                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR64:$src)))))),
1894           (Int_VCVTSI2SD64rr VR128:$dst, GR64:$src)>;
1895
1896 def : Pat<(v2f64 (X86Movsd
1897                    (v2f64 VR128:$dst),
1898                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR32:$src)))))),
1899           (Int_VCVTSI2SDrr VR128:$dst, GR32:$src)>;
1900 } // Predicates = [UseAVX]
1901
1902 let Predicates = [UseSSE2] in {
1903 def : Pat<(v4f32 (X86Movss
1904                    (v4f32 VR128:$dst),
1905                    (v4f32 (scalar_to_vector
1906                      (f32 (fpround (f64 (extractelt VR128:$src, (iPTR 0))))))))),
1907           (Int_CVTSD2SSrr VR128:$dst, VR128:$src)>;
1908
1909 def : Pat<(v2f64 (X86Movsd
1910                    (v2f64 VR128:$dst),
1911                    (v2f64 (scalar_to_vector
1912                      (f64 (fpextend (f32 (extractelt VR128:$src, (iPTR 0))))))))),
1913           (Int_CVTSS2SDrr VR128:$dst, VR128:$src)>;
1914
1915 def : Pat<(v2f64 (X86Movsd
1916                    (v2f64 VR128:$dst),
1917                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR64:$src)))))),
1918           (Int_CVTSI2SD64rr VR128:$dst, GR64:$src)>;
1919
1920 def : Pat<(v2f64 (X86Movsd
1921                    (v2f64 VR128:$dst),
1922                    (v2f64 (scalar_to_vector (f64 (sint_to_fp GR32:$src)))))),
1923           (Int_CVTSI2SDrr VR128:$dst, GR32:$src)>;
1924 } // Predicates = [UseSSE2]
1925
1926 let Predicates = [UseSSE1] in {
1927 def : Pat<(v4f32 (X86Movss
1928                    (v4f32 VR128:$dst),
1929                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR64:$src)))))),
1930           (Int_CVTSI2SS64rr VR128:$dst, GR64:$src)>;
1931
1932 def : Pat<(v4f32 (X86Movss
1933                    (v4f32 VR128:$dst),
1934                    (v4f32 (scalar_to_vector (f32 (sint_to_fp GR32:$src)))))),
1935           (Int_CVTSI2SSrr VR128:$dst, GR32:$src)>;
1936 } // Predicates = [UseSSE1]
1937
1938 // Convert packed single/double fp to doubleword
1939 def VCVTPS2DQrr : VPDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1940                        "cvtps2dq\t{$src, $dst|$dst, $src}",
1941                        [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))],
1942                        IIC_SSE_CVT_PS_RR>, VEX, Sched<[WriteCvtF2I]>, VEX_WIG;
1943 def VCVTPS2DQrm : VPDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1944                        "cvtps2dq\t{$src, $dst|$dst, $src}",
1945                        [(set VR128:$dst,
1946                          (int_x86_sse2_cvtps2dq (loadv4f32 addr:$src)))],
1947                        IIC_SSE_CVT_PS_RM>, VEX, Sched<[WriteCvtF2ILd]>, VEX_WIG;
1948 def VCVTPS2DQYrr : VPDI<0x5B, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
1949                         "cvtps2dq\t{$src, $dst|$dst, $src}",
1950                         [(set VR256:$dst,
1951                           (int_x86_avx_cvt_ps2dq_256 VR256:$src))],
1952                         IIC_SSE_CVT_PS_RR>, VEX, VEX_L, Sched<[WriteCvtF2I]>, VEX_WIG;
1953 def VCVTPS2DQYrm : VPDI<0x5B, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
1954                         "cvtps2dq\t{$src, $dst|$dst, $src}",
1955                         [(set VR256:$dst,
1956                           (int_x86_avx_cvt_ps2dq_256 (loadv8f32 addr:$src)))],
1957                         IIC_SSE_CVT_PS_RM>, VEX, VEX_L, Sched<[WriteCvtF2ILd]>, VEX_WIG;
1958 def CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1959                      "cvtps2dq\t{$src, $dst|$dst, $src}",
1960                      [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))],
1961                      IIC_SSE_CVT_PS_RR>, Sched<[WriteCvtF2I]>;
1962 def CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1963                      "cvtps2dq\t{$src, $dst|$dst, $src}",
1964                      [(set VR128:$dst,
1965                        (int_x86_sse2_cvtps2dq (memopv4f32 addr:$src)))],
1966                      IIC_SSE_CVT_PS_RM>, Sched<[WriteCvtF2ILd]>;
1967
1968
1969 // Convert Packed Double FP to Packed DW Integers
1970 let Predicates = [HasAVX, NoVLX] in {
1971 // The assembler can recognize rr 256-bit instructions by seeing a ymm
1972 // register, but the same isn't true when using memory operands instead.
1973 // Provide other assembly rr and rm forms to address this explicitly.
1974 def VCVTPD2DQrr  : SDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1975                        "vcvtpd2dq\t{$src, $dst|$dst, $src}",
1976                        [(set VR128:$dst,
1977                          (v4i32 (X86cvtp2Int (v2f64 VR128:$src))))]>,
1978                        VEX, Sched<[WriteCvtF2I]>, VEX_WIG;
1979
1980 // XMM only
1981 def : InstAlias<"vcvtpd2dqx\t{$src, $dst|$dst, $src}",
1982                 (VCVTPD2DQrr VR128:$dst, VR128:$src), 0>;
1983 def VCVTPD2DQrm : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1984                       "vcvtpd2dq{x}\t{$src, $dst|$dst, $src}",
1985                       [(set VR128:$dst,
1986                         (v4i32 (X86cvtp2Int (loadv2f64 addr:$src))))]>, VEX,
1987                       Sched<[WriteCvtF2ILd]>, VEX_WIG;
1988 def : InstAlias<"vcvtpd2dqx\t{$src, $dst|$dst, $src}",
1989                 (VCVTPD2DQrm VR128:$dst, f128mem:$src), 0>;
1990
1991 // YMM only
1992 def VCVTPD2DQYrr : SDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
1993                        "vcvtpd2dq\t{$src, $dst|$dst, $src}",
1994                        [(set VR128:$dst,
1995                          (v4i32 (X86cvtp2Int (v4f64 VR256:$src))))]>,
1996                        VEX, VEX_L, Sched<[WriteCvtF2I]>, VEX_WIG;
1997 def VCVTPD2DQYrm : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
1998                        "vcvtpd2dq{y}\t{$src, $dst|$dst, $src}",
1999                        [(set VR128:$dst,
2000                          (v4i32 (X86cvtp2Int (loadv4f64 addr:$src))))]>,
2001                        VEX, VEX_L, Sched<[WriteCvtF2ILd]>, VEX_WIG;
2002 def : InstAlias<"vcvtpd2dqy\t{$src, $dst|$dst, $src}",
2003                 (VCVTPD2DQYrr VR128:$dst, VR256:$src), 0>;
2004 def : InstAlias<"vcvtpd2dqy\t{$src, $dst|$dst, $src}",
2005                 (VCVTPD2DQYrm VR128:$dst, f256mem:$src), 0>;
2006 }
2007
2008 def CVTPD2DQrm  : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2009                       "cvtpd2dq\t{$src, $dst|$dst, $src}",
2010                       [(set VR128:$dst,
2011                         (v4i32 (X86cvtp2Int (memopv2f64 addr:$src))))],
2012                       IIC_SSE_CVT_PD_RM>, Sched<[WriteCvtF2ILd]>;
2013 def CVTPD2DQrr  : SDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2014                       "cvtpd2dq\t{$src, $dst|$dst, $src}",
2015                       [(set VR128:$dst,
2016                         (v4i32 (X86cvtp2Int (v2f64 VR128:$src))))],
2017                       IIC_SSE_CVT_PD_RR>, Sched<[WriteCvtF2I]>;
2018
2019 // Convert with truncation packed single/double fp to doubleword
2020 // SSE2 packed instructions with XS prefix
2021 let Predicates = [HasAVX, NoVLX] in {
2022 def VCVTTPS2DQrr : VS2SI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2023                          "cvttps2dq\t{$src, $dst|$dst, $src}",
2024                          [(set VR128:$dst,
2025                            (v4i32 (fp_to_sint (v4f32 VR128:$src))))],
2026                          IIC_SSE_CVT_PS_RR>, VEX, Sched<[WriteCvtF2I]>, VEX_WIG;
2027 def VCVTTPS2DQrm : VS2SI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2028                          "cvttps2dq\t{$src, $dst|$dst, $src}",
2029                          [(set VR128:$dst,
2030                            (v4i32 (fp_to_sint (loadv4f32 addr:$src))))],
2031                          IIC_SSE_CVT_PS_RM>, VEX, Sched<[WriteCvtF2ILd]>, VEX_WIG;
2032 def VCVTTPS2DQYrr : VS2SI<0x5B, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
2033                           "cvttps2dq\t{$src, $dst|$dst, $src}",
2034                           [(set VR256:$dst,
2035                             (v8i32 (fp_to_sint (v8f32 VR256:$src))))],
2036                           IIC_SSE_CVT_PS_RR>, VEX, VEX_L, Sched<[WriteCvtF2I]>, VEX_WIG;
2037 def VCVTTPS2DQYrm : VS2SI<0x5B, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
2038                           "cvttps2dq\t{$src, $dst|$dst, $src}",
2039                           [(set VR256:$dst,
2040                             (v8i32 (fp_to_sint (loadv8f32 addr:$src))))],
2041                           IIC_SSE_CVT_PS_RM>, VEX, VEX_L,
2042                           Sched<[WriteCvtF2ILd]>, VEX_WIG;
2043 }
2044
2045 def CVTTPS2DQrr : S2SI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2046                        "cvttps2dq\t{$src, $dst|$dst, $src}",
2047                        [(set VR128:$dst,
2048                          (v4i32 (fp_to_sint (v4f32 VR128:$src))))],
2049                        IIC_SSE_CVT_PS_RR>, Sched<[WriteCvtF2I]>;
2050 def CVTTPS2DQrm : S2SI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2051                        "cvttps2dq\t{$src, $dst|$dst, $src}",
2052                        [(set VR128:$dst,
2053                          (v4i32 (fp_to_sint (memopv4f32 addr:$src))))],
2054                        IIC_SSE_CVT_PS_RM>, Sched<[WriteCvtF2ILd]>;
2055
2056 let Predicates = [HasAVX, NoVLX] in
2057 def VCVTTPD2DQrr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2058                         "cvttpd2dq\t{$src, $dst|$dst, $src}",
2059                         [(set VR128:$dst,
2060                           (v4i32 (X86cvttp2si (v2f64 VR128:$src))))],
2061                         IIC_SSE_CVT_PD_RR>, VEX, Sched<[WriteCvtF2I]>, VEX_WIG;
2062
2063 // The assembler can recognize rr 256-bit instructions by seeing a ymm
2064 // register, but the same isn't true when using memory operands instead.
2065 // Provide other assembly rr and rm forms to address this explicitly.
2066
2067 // XMM only
2068 def : InstAlias<"vcvttpd2dqx\t{$src, $dst|$dst, $src}",
2069                 (VCVTTPD2DQrr VR128:$dst, VR128:$src), 0>;
2070 let Predicates = [HasAVX, NoVLX] in
2071 def VCVTTPD2DQrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2072                         "cvttpd2dq{x}\t{$src, $dst|$dst, $src}",
2073                         [(set VR128:$dst,
2074                           (v4i32 (X86cvttp2si (loadv2f64 addr:$src))))],
2075                         IIC_SSE_CVT_PD_RM>, VEX, Sched<[WriteCvtF2ILd]>, VEX_WIG;
2076 def : InstAlias<"vcvttpd2dqx\t{$src, $dst|$dst, $src}",
2077                 (VCVTTPD2DQrm VR128:$dst, f128mem:$src), 0>;
2078
2079 // YMM only
2080 let Predicates = [HasAVX, NoVLX] in {
2081 def VCVTTPD2DQYrr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
2082                          "cvttpd2dq\t{$src, $dst|$dst, $src}",
2083                          [(set VR128:$dst,
2084                            (v4i32 (fp_to_sint (v4f64 VR256:$src))))],
2085                          IIC_SSE_CVT_PD_RR>, VEX, VEX_L, Sched<[WriteCvtF2I]>, VEX_WIG;
2086 def VCVTTPD2DQYrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
2087                          "cvttpd2dq{y}\t{$src, $dst|$dst, $src}",
2088                          [(set VR128:$dst,
2089                            (v4i32 (fp_to_sint (loadv4f64 addr:$src))))],
2090                          IIC_SSE_CVT_PD_RM>, VEX, VEX_L, Sched<[WriteCvtF2ILd]>, VEX_WIG;
2091 }
2092 def : InstAlias<"vcvttpd2dqy\t{$src, $dst|$dst, $src}",
2093                 (VCVTTPD2DQYrr VR128:$dst, VR256:$src), 0>;
2094 def : InstAlias<"vcvttpd2dqy\t{$src, $dst|$dst, $src}",
2095                 (VCVTTPD2DQYrm VR128:$dst, f256mem:$src), 0>;
2096
2097 let Predicates = [HasAVX, NoVLX] in {
2098   let AddedComplexity = 15 in {
2099     def : Pat<(X86vzmovl (v2i64 (bitconvert
2100                                  (v4i32 (X86cvtp2Int (v2f64 VR128:$src)))))),
2101               (VCVTPD2DQrr VR128:$src)>;
2102     def : Pat<(X86vzmovl (v2i64 (bitconvert
2103                                  (v4i32 (X86cvttp2si (v2f64 VR128:$src)))))),
2104               (VCVTTPD2DQrr VR128:$src)>;
2105   }
2106 } // Predicates = [HasAVX]
2107
2108 def CVTTPD2DQrr : PDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2109                       "cvttpd2dq\t{$src, $dst|$dst, $src}",
2110                       [(set VR128:$dst,
2111                         (v4i32 (X86cvttp2si (v2f64 VR128:$src))))],
2112                       IIC_SSE_CVT_PD_RR>, Sched<[WriteCvtF2I]>;
2113 def CVTTPD2DQrm : PDI<0xE6, MRMSrcMem, (outs VR128:$dst),(ins f128mem:$src),
2114                       "cvttpd2dq\t{$src, $dst|$dst, $src}",
2115                       [(set VR128:$dst,
2116                         (v4i32 (X86cvttp2si (memopv2f64 addr:$src))))],
2117                       IIC_SSE_CVT_PD_RM>, Sched<[WriteCvtF2ILd]>;
2118
2119 let Predicates = [UseSSE2] in {
2120   let AddedComplexity = 15 in {
2121     def : Pat<(X86vzmovl (v2i64 (bitconvert
2122                                  (v4i32 (X86cvtp2Int (v2f64 VR128:$src)))))),
2123               (CVTPD2DQrr VR128:$src)>;
2124     def : Pat<(X86vzmovl (v2i64 (bitconvert
2125                                  (v4i32 (X86cvttp2si (v2f64 VR128:$src)))))),
2126               (CVTTPD2DQrr VR128:$src)>;
2127   }
2128 } // Predicates = [UseSSE2]
2129
2130 // Convert packed single to packed double
2131 let Predicates = [HasAVX, NoVLX] in {
2132                   // SSE2 instructions without OpSize prefix
2133 def VCVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2134                     "vcvtps2pd\t{$src, $dst|$dst, $src}",
2135                     [(set VR128:$dst, (v2f64 (X86vfpext (v4f32 VR128:$src))))],
2136                     IIC_SSE_CVT_PD_RR>, PS, VEX, Sched<[WriteCvtF2F]>, VEX_WIG;
2137 def VCVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
2138                     "vcvtps2pd\t{$src, $dst|$dst, $src}",
2139                     [(set VR128:$dst, (v2f64 (extloadv2f32 addr:$src)))],
2140                     IIC_SSE_CVT_PD_RM>, PS, VEX, Sched<[WriteCvtF2FLd]>, VEX_WIG;
2141 def VCVTPS2PDYrr : I<0x5A, MRMSrcReg, (outs VR256:$dst), (ins VR128:$src),
2142                      "vcvtps2pd\t{$src, $dst|$dst, $src}",
2143                      [(set VR256:$dst, (v4f64 (fpextend (v4f32 VR128:$src))))],
2144                      IIC_SSE_CVT_PD_RR>, PS, VEX, VEX_L, Sched<[WriteCvtF2F]>, VEX_WIG;
2145 def VCVTPS2PDYrm : I<0x5A, MRMSrcMem, (outs VR256:$dst), (ins f128mem:$src),
2146                      "vcvtps2pd\t{$src, $dst|$dst, $src}",
2147                      [(set VR256:$dst, (v4f64 (extloadv4f32 addr:$src)))],
2148                      IIC_SSE_CVT_PD_RM>, PS, VEX, VEX_L, Sched<[WriteCvtF2FLd]>, VEX_WIG;
2149 }
2150
2151 let Predicates = [UseSSE2] in {
2152 def CVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2153                    "cvtps2pd\t{$src, $dst|$dst, $src}",
2154                    [(set VR128:$dst, (v2f64 (X86vfpext (v4f32 VR128:$src))))],
2155                    IIC_SSE_CVT_PD_RR>, PS, Sched<[WriteCvtF2F]>;
2156 def CVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
2157                    "cvtps2pd\t{$src, $dst|$dst, $src}",
2158                    [(set VR128:$dst, (v2f64 (extloadv2f32 addr:$src)))],
2159                    IIC_SSE_CVT_PD_RM>, PS, Sched<[WriteCvtF2FLd]>;
2160 }
2161
2162 // Convert Packed DW Integers to Packed Double FP
2163 let Predicates = [HasAVX, NoVLX] in {
2164 let hasSideEffects = 0, mayLoad = 1 in
2165 def VCVTDQ2PDrm  : S2SI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
2166                         "vcvtdq2pd\t{$src, $dst|$dst, $src}",
2167                         [(set VR128:$dst,
2168                           (v2f64 (X86VSintToFP (bc_v4i32 (v2i64 (X86vzload addr:$src))))))]>,
2169                         VEX, Sched<[WriteCvtI2FLd]>, VEX_WIG;
2170 def VCVTDQ2PDrr  : S2SI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2171                         "vcvtdq2pd\t{$src, $dst|$dst, $src}",
2172                         [(set VR128:$dst,
2173                           (v2f64 (X86VSintToFP (v4i32 VR128:$src))))]>,
2174                         VEX, Sched<[WriteCvtI2F]>, VEX_WIG;
2175 def VCVTDQ2PDYrm  : S2SI<0xE6, MRMSrcMem, (outs VR256:$dst), (ins i128mem:$src),
2176                          "vcvtdq2pd\t{$src, $dst|$dst, $src}",
2177                          [(set VR256:$dst,
2178                            (v4f64 (sint_to_fp (bc_v4i32 (loadv2i64 addr:$src)))))]>,
2179                          VEX, VEX_L, Sched<[WriteCvtI2FLd]>, VEX_WIG;
2180 def VCVTDQ2PDYrr  : S2SI<0xE6, MRMSrcReg, (outs VR256:$dst), (ins VR128:$src),
2181                          "vcvtdq2pd\t{$src, $dst|$dst, $src}",
2182                          [(set VR256:$dst,
2183                            (v4f64 (sint_to_fp (v4i32 VR128:$src))))]>,
2184                          VEX, VEX_L, Sched<[WriteCvtI2F]>, VEX_WIG;
2185 }
2186
2187 let hasSideEffects = 0, mayLoad = 1 in
2188 def CVTDQ2PDrm  : S2SI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
2189                        "cvtdq2pd\t{$src, $dst|$dst, $src}",
2190                        [(set VR128:$dst,
2191                          (v2f64 (X86VSintToFP (bc_v4i32 (v2i64 (X86vzload addr:$src))))))],
2192                        IIC_SSE_CVT_PD_RR>, Sched<[WriteCvtI2FLd]>;
2193 def CVTDQ2PDrr  : S2SI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2194                        "cvtdq2pd\t{$src, $dst|$dst, $src}",
2195                        [(set VR128:$dst,
2196                          (v2f64 (X86VSintToFP (v4i32 VR128:$src))))],
2197                        IIC_SSE_CVT_PD_RM>, Sched<[WriteCvtI2F]>;
2198
2199 // AVX register conversion intrinsics
2200 let Predicates = [HasAVX, NoVLX] in {
2201   def : Pat<(v2f64 (X86VSintToFP (bc_v4i32 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
2202             (VCVTDQ2PDrm addr:$src)>;
2203 } // Predicates = [HasAVX, NoVLX]
2204
2205 // SSE2 register conversion intrinsics
2206 let Predicates = [UseSSE2] in {
2207   def : Pat<(v2f64 (X86VSintToFP (bc_v4i32 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
2208             (CVTDQ2PDrm addr:$src)>;
2209 } // Predicates = [UseSSE2]
2210
2211 // Convert packed double to packed single
2212 // The assembler can recognize rr 256-bit instructions by seeing a ymm
2213 // register, but the same isn't true when using memory operands instead.
2214 // Provide other assembly rr and rm forms to address this explicitly.
2215 let Predicates = [HasAVX, NoVLX] in
2216 def VCVTPD2PSrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2217                        "cvtpd2ps\t{$src, $dst|$dst, $src}",
2218                        [(set VR128:$dst, (X86vfpround (v2f64 VR128:$src)))],
2219                        IIC_SSE_CVT_PD_RR>, VEX, Sched<[WriteCvtF2F]>, VEX_WIG;
2220
2221 // XMM only
2222 def : InstAlias<"vcvtpd2psx\t{$src, $dst|$dst, $src}",
2223                 (VCVTPD2PSrr VR128:$dst, VR128:$src), 0>;
2224 let Predicates = [HasAVX, NoVLX] in
2225 def VCVTPD2PSrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2226                        "cvtpd2ps{x}\t{$src, $dst|$dst, $src}",
2227                        [(set VR128:$dst, (X86vfpround (loadv2f64 addr:$src)))],
2228                        IIC_SSE_CVT_PD_RM>, VEX, Sched<[WriteCvtF2FLd]>, VEX_WIG;
2229 def : InstAlias<"vcvtpd2psx\t{$src, $dst|$dst, $src}",
2230                 (VCVTPD2PSrm VR128:$dst, f128mem:$src), 0>;
2231
2232 // YMM only
2233 let Predicates = [HasAVX, NoVLX] in {
2234 def VCVTPD2PSYrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
2235                         "cvtpd2ps\t{$src, $dst|$dst, $src}",
2236                         [(set VR128:$dst, (fpround VR256:$src))],
2237                         IIC_SSE_CVT_PD_RR>, VEX, VEX_L, Sched<[WriteCvtF2F]>, VEX_WIG;
2238 def VCVTPD2PSYrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
2239                         "cvtpd2ps{y}\t{$src, $dst|$dst, $src}",
2240                         [(set VR128:$dst, (fpround (loadv4f64 addr:$src)))],
2241                         IIC_SSE_CVT_PD_RM>, VEX, VEX_L, Sched<[WriteCvtF2FLd]>, VEX_WIG;
2242 }
2243 def : InstAlias<"vcvtpd2psy\t{$src, $dst|$dst, $src}",
2244                 (VCVTPD2PSYrr VR128:$dst, VR256:$src), 0>;
2245 def : InstAlias<"vcvtpd2psy\t{$src, $dst|$dst, $src}",
2246                 (VCVTPD2PSYrm VR128:$dst, f256mem:$src), 0>;
2247
2248 def CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2249                      "cvtpd2ps\t{$src, $dst|$dst, $src}",
2250                      [(set VR128:$dst, (X86vfpround (v2f64 VR128:$src)))],
2251                      IIC_SSE_CVT_PD_RR>, Sched<[WriteCvtF2F]>;
2252 def CVTPD2PSrm : PDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2253                      "cvtpd2ps\t{$src, $dst|$dst, $src}",
2254                      [(set VR128:$dst, (X86vfpround (memopv2f64 addr:$src)))],
2255                      IIC_SSE_CVT_PD_RM>, Sched<[WriteCvtF2FLd]>;
2256
2257 // AVX 256-bit register conversion intrinsics
2258 // FIXME: Migrate SSE conversion intrinsics matching to use patterns as below
2259 // whenever possible to avoid declaring two versions of each one.
2260
2261 let Predicates = [HasAVX, NoVLX] in {
2262   // Match fpround and fpextend for 128/256-bit conversions
2263   let AddedComplexity = 15 in
2264   def : Pat<(X86vzmovl (v2f64 (bitconvert
2265                                (v4f32 (X86vfpround (v2f64 VR128:$src)))))),
2266             (VCVTPD2PSrr VR128:$src)>;
2267 }
2268
2269 let Predicates = [UseSSE2] in {
2270   // Match fpround and fpextend for 128 conversions
2271   let AddedComplexity = 15 in
2272   def : Pat<(X86vzmovl (v2f64 (bitconvert
2273                                (v4f32 (X86vfpround (v2f64 VR128:$src)))))),
2274             (CVTPD2PSrr VR128:$src)>;
2275 }
2276
2277 //===----------------------------------------------------------------------===//
2278 // SSE 1 & 2 - Compare Instructions
2279 //===----------------------------------------------------------------------===//
2280
2281 // sse12_cmp_scalar - sse 1 & 2 compare scalar instructions
2282 multiclass sse12_cmp_scalar<RegisterClass RC, X86MemOperand x86memop,
2283                             Operand CC, SDNode OpNode, ValueType VT,
2284                             PatFrag ld_frag, string asm, string asm_alt,
2285                             OpndItins itins, ImmLeaf immLeaf> {
2286   let isCommutable = 1 in
2287   def rr : SIi8<0xC2, MRMSrcReg,
2288                 (outs RC:$dst), (ins RC:$src1, RC:$src2, CC:$cc), asm,
2289                 [(set RC:$dst, (OpNode (VT RC:$src1), RC:$src2, immLeaf:$cc))],
2290                 itins.rr>, Sched<[itins.Sched]>;
2291   def rm : SIi8<0xC2, MRMSrcMem,
2292                 (outs RC:$dst), (ins RC:$src1, x86memop:$src2, CC:$cc), asm,
2293                 [(set RC:$dst, (OpNode (VT RC:$src1),
2294                                          (ld_frag addr:$src2), immLeaf:$cc))],
2295                                          itins.rm>,
2296            Sched<[itins.Sched.Folded, ReadAfterLd]>;
2297
2298   // Accept explicit immediate argument form instead of comparison code.
2299   let isAsmParserOnly = 1, hasSideEffects = 0 in {
2300     def rr_alt : SIi8<0xC2, MRMSrcReg, (outs RC:$dst),
2301                       (ins RC:$src1, RC:$src2, u8imm:$cc), asm_alt, [],
2302                       IIC_SSE_ALU_F32S_RR>, Sched<[itins.Sched]>;
2303     let mayLoad = 1 in
2304     def rm_alt : SIi8<0xC2, MRMSrcMem, (outs RC:$dst),
2305                       (ins RC:$src1, x86memop:$src2, u8imm:$cc), asm_alt, [],
2306                       IIC_SSE_ALU_F32S_RM>,
2307                       Sched<[itins.Sched.Folded, ReadAfterLd]>;
2308   }
2309 }
2310
2311 let ExeDomain = SSEPackedSingle in
2312 defm VCMPSS : sse12_cmp_scalar<FR32, f32mem, AVXCC, X86cmps, f32, loadf32,
2313                  "cmp${cc}ss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2314                  "cmpss\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2315                  SSE_ALU_F32S, i8immZExt5>, XS, VEX_4V, VEX_LIG, VEX_WIG;
2316 let ExeDomain = SSEPackedDouble in
2317 defm VCMPSD : sse12_cmp_scalar<FR64, f64mem, AVXCC, X86cmps, f64, loadf64,
2318                  "cmp${cc}sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2319                  "cmpsd\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2320                  SSE_ALU_F32S, i8immZExt5>, // same latency as 32 bit compare
2321                  XD, VEX_4V, VEX_LIG, VEX_WIG;
2322
2323 let Constraints = "$src1 = $dst" in {
2324   let ExeDomain = SSEPackedSingle in
2325   defm CMPSS : sse12_cmp_scalar<FR32, f32mem, SSECC, X86cmps, f32, loadf32,
2326                   "cmp${cc}ss\t{$src2, $dst|$dst, $src2}",
2327                   "cmpss\t{$cc, $src2, $dst|$dst, $src2, $cc}", SSE_ALU_F32S,
2328                   i8immZExt3>, XS;
2329   let ExeDomain = SSEPackedDouble in
2330   defm CMPSD : sse12_cmp_scalar<FR64, f64mem, SSECC, X86cmps, f64, loadf64,
2331                   "cmp${cc}sd\t{$src2, $dst|$dst, $src2}",
2332                   "cmpsd\t{$cc, $src2, $dst|$dst, $src2, $cc}",
2333                   SSE_ALU_F64S, i8immZExt3>, XD;
2334 }
2335
2336 multiclass sse12_cmp_scalar_int<Operand memop, Operand CC,
2337                          Intrinsic Int, string asm, OpndItins itins,
2338                          ImmLeaf immLeaf, ComplexPattern mem_cpat> {
2339   def rr : SIi8<0xC2, MRMSrcReg, (outs VR128:$dst),
2340                       (ins VR128:$src1, VR128:$src, CC:$cc), asm,
2341                         [(set VR128:$dst, (Int VR128:$src1,
2342                                                VR128:$src, immLeaf:$cc))],
2343                                                itins.rr>,
2344            Sched<[itins.Sched]>;
2345 let mayLoad = 1 in
2346   def rm : SIi8<0xC2, MRMSrcMem, (outs VR128:$dst),
2347                       (ins VR128:$src1, memop:$src, CC:$cc), asm,
2348                         [(set VR128:$dst, (Int VR128:$src1,
2349                                                mem_cpat:$src, immLeaf:$cc))],
2350                                                itins.rm>,
2351            Sched<[itins.Sched.Folded, ReadAfterLd]>;
2352 }
2353
2354 let isCodeGenOnly = 1 in {
2355   // Aliases to match intrinsics which expect XMM operand(s).
2356   let ExeDomain = SSEPackedSingle in
2357   defm Int_VCMPSS  : sse12_cmp_scalar_int<ssmem, AVXCC, int_x86_sse_cmp_ss,
2358                        "cmp${cc}ss\t{$src, $src1, $dst|$dst, $src1, $src}",
2359                        SSE_ALU_F32S, i8immZExt5, sse_load_f32>,
2360                        XS, VEX_4V;
2361   let ExeDomain = SSEPackedDouble in
2362   defm Int_VCMPSD  : sse12_cmp_scalar_int<sdmem, AVXCC, int_x86_sse2_cmp_sd,
2363                        "cmp${cc}sd\t{$src, $src1, $dst|$dst, $src1, $src}",
2364                        SSE_ALU_F32S, i8immZExt5, sse_load_f64>, // same latency as f32
2365                        XD, VEX_4V;
2366   let Constraints = "$src1 = $dst" in {
2367     let ExeDomain = SSEPackedSingle in
2368     defm Int_CMPSS  : sse12_cmp_scalar_int<ssmem, SSECC, int_x86_sse_cmp_ss,
2369                          "cmp${cc}ss\t{$src, $dst|$dst, $src}",
2370                          SSE_ALU_F32S, i8immZExt3, sse_load_f32>, XS;
2371     let ExeDomain = SSEPackedDouble in
2372     defm Int_CMPSD  : sse12_cmp_scalar_int<sdmem, SSECC, int_x86_sse2_cmp_sd,
2373                          "cmp${cc}sd\t{$src, $dst|$dst, $src}",
2374                          SSE_ALU_F64S, i8immZExt3, sse_load_f64>,
2375                          XD;
2376 }
2377 }
2378
2379
2380 // sse12_ord_cmp - Unordered/Ordered scalar fp compare and set EFLAGS
2381 multiclass sse12_ord_cmp<bits<8> opc, RegisterClass RC, SDNode OpNode,
2382                             ValueType vt, X86MemOperand x86memop,
2383                             PatFrag ld_frag, string OpcodeStr> {
2384   def rr: SI<opc, MRMSrcReg, (outs), (ins RC:$src1, RC:$src2),
2385                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2386                      [(set EFLAGS, (OpNode (vt RC:$src1), RC:$src2))],
2387                      IIC_SSE_COMIS_RR>,
2388           Sched<[WriteFAdd]>;
2389 let mayLoad = 1 in
2390   def rm: SI<opc, MRMSrcMem, (outs), (ins RC:$src1, x86memop:$src2),
2391                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2392                      [(set EFLAGS, (OpNode (vt RC:$src1),
2393                                            (ld_frag addr:$src2)))],
2394                                            IIC_SSE_COMIS_RM>,
2395           Sched<[WriteFAddLd, ReadAfterLd]>;
2396 }
2397
2398 // sse12_ord_cmp_int - Intrinsic version of sse12_ord_cmp
2399 multiclass sse12_ord_cmp_int<bits<8> opc, RegisterClass RC, SDNode OpNode,
2400                             ValueType vt, Operand memop,
2401                             ComplexPattern mem_cpat, string OpcodeStr> {
2402   def rr: SI<opc, MRMSrcReg, (outs), (ins RC:$src1, RC:$src2),
2403                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2404                      [(set EFLAGS, (OpNode (vt RC:$src1), RC:$src2))],
2405                      IIC_SSE_COMIS_RR>,
2406           Sched<[WriteFAdd]>;
2407 let mayLoad = 1 in
2408   def rm: SI<opc, MRMSrcMem, (outs), (ins RC:$src1, memop:$src2),
2409                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2410                      [(set EFLAGS, (OpNode (vt RC:$src1),
2411                                            mem_cpat:$src2))],
2412                                            IIC_SSE_COMIS_RM>,
2413           Sched<[WriteFAddLd, ReadAfterLd]>;
2414 }
2415
2416 let Defs = [EFLAGS] in {
2417   defm VUCOMISS : sse12_ord_cmp<0x2E, FR32, X86cmp, f32, f32mem, loadf32,
2418                                   "ucomiss">, PS, VEX, VEX_LIG, VEX_WIG;
2419   defm VUCOMISD : sse12_ord_cmp<0x2E, FR64, X86cmp, f64, f64mem, loadf64,
2420                                   "ucomisd">, PD, VEX, VEX_LIG, VEX_WIG;
2421   let Pattern = []<dag> in {
2422     defm VCOMISS  : sse12_ord_cmp<0x2F, FR32, undef, f32, f32mem, loadf32,
2423                                     "comiss">, PS, VEX, VEX_LIG, VEX_WIG;
2424     defm VCOMISD  : sse12_ord_cmp<0x2F, FR64, undef, f64, f64mem, loadf64,
2425                                     "comisd">, PD, VEX, VEX_LIG, VEX_WIG;
2426   }
2427
2428   let isCodeGenOnly = 1 in {
2429     defm Int_VUCOMISS  : sse12_ord_cmp_int<0x2E, VR128, X86ucomi, v4f32, ssmem,
2430                               sse_load_f32, "ucomiss">, PS, VEX, VEX_WIG;
2431     defm Int_VUCOMISD  : sse12_ord_cmp_int<0x2E, VR128, X86ucomi, v2f64, sdmem,
2432                               sse_load_f64, "ucomisd">, PD, VEX, VEX_WIG;
2433
2434     defm Int_VCOMISS  : sse12_ord_cmp_int<0x2F, VR128, X86comi, v4f32, ssmem,
2435                               sse_load_f32, "comiss">, PS, VEX, VEX_WIG;
2436     defm Int_VCOMISD  : sse12_ord_cmp_int<0x2F, VR128, X86comi, v2f64, sdmem,
2437                               sse_load_f64, "comisd">, PD, VEX, VEX_WIG;
2438   }
2439   defm UCOMISS  : sse12_ord_cmp<0x2E, FR32, X86cmp, f32, f32mem, loadf32,
2440                                   "ucomiss">, PS;
2441   defm UCOMISD  : sse12_ord_cmp<0x2E, FR64, X86cmp, f64, f64mem, loadf64,
2442                                   "ucomisd">, PD;
2443
2444   let Pattern = []<dag> in {
2445     defm COMISS  : sse12_ord_cmp<0x2F, FR32, undef, f32, f32mem, loadf32,
2446                                     "comiss">, PS;
2447     defm COMISD  : sse12_ord_cmp<0x2F, FR64, undef, f64, f64mem, loadf64,
2448                                     "comisd">, PD;
2449   }
2450
2451   let isCodeGenOnly = 1 in {
2452     defm Int_UCOMISS  : sse12_ord_cmp_int<0x2E, VR128, X86ucomi, v4f32, ssmem,
2453                                 sse_load_f32, "ucomiss">, PS;
2454     defm Int_UCOMISD  : sse12_ord_cmp_int<0x2E, VR128, X86ucomi, v2f64, sdmem,
2455                                 sse_load_f64, "ucomisd">, PD;
2456
2457     defm Int_COMISS  : sse12_ord_cmp_int<0x2F, VR128, X86comi, v4f32, ssmem,
2458                                     sse_load_f32, "comiss">, PS;
2459     defm Int_COMISD  : sse12_ord_cmp_int<0x2F, VR128, X86comi, v2f64, sdmem,
2460                                     sse_load_f64, "comisd">, PD;
2461   }
2462 } // Defs = [EFLAGS]
2463
2464 // sse12_cmp_packed - sse 1 & 2 compare packed instructions
2465 multiclass sse12_cmp_packed<RegisterClass RC, X86MemOperand x86memop,
2466                             Operand CC,  ValueType VT, string asm,
2467                             string asm_alt, Domain d, ImmLeaf immLeaf,
2468                             PatFrag ld_frag, OpndItins itins = SSE_ALU_F32P> {
2469   let isCommutable = 1 in
2470   def rri : PIi8<0xC2, MRMSrcReg,
2471              (outs RC:$dst), (ins RC:$src1, RC:$src2, CC:$cc), asm,
2472              [(set RC:$dst, (VT (X86cmpp RC:$src1, RC:$src2, immLeaf:$cc)))],
2473              itins.rr, d>,
2474             Sched<[WriteFAdd]>;
2475   def rmi : PIi8<0xC2, MRMSrcMem,
2476              (outs RC:$dst), (ins RC:$src1, x86memop:$src2, CC:$cc), asm,
2477              [(set RC:$dst,
2478                (VT (X86cmpp RC:$src1, (ld_frag addr:$src2), immLeaf:$cc)))],
2479              itins.rm, d>,
2480             Sched<[WriteFAddLd, ReadAfterLd]>;
2481
2482   // Accept explicit immediate argument form instead of comparison code.
2483   let isAsmParserOnly = 1, hasSideEffects = 0 in {
2484     def rri_alt : PIi8<0xC2, MRMSrcReg,
2485                (outs RC:$dst), (ins RC:$src1, RC:$src2, u8imm:$cc),
2486                asm_alt, [], itins.rr, d>, Sched<[WriteFAdd]>;
2487     let mayLoad = 1 in
2488     def rmi_alt : PIi8<0xC2, MRMSrcMem,
2489                (outs RC:$dst), (ins RC:$src1, x86memop:$src2, u8imm:$cc),
2490                asm_alt, [], itins.rm, d>,
2491                Sched<[WriteFAddLd, ReadAfterLd]>;
2492   }
2493 }
2494
2495 defm VCMPPS : sse12_cmp_packed<VR128, f128mem, AVXCC, v4f32,
2496                "cmp${cc}ps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2497                "cmpps\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2498                SSEPackedSingle, i8immZExt5, loadv4f32>, PS, VEX_4V, VEX_WIG;
2499 defm VCMPPD : sse12_cmp_packed<VR128, f128mem, AVXCC, v2f64,
2500                "cmp${cc}pd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2501                "cmppd\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2502                SSEPackedDouble, i8immZExt5, loadv2f64>, PD, VEX_4V, VEX_WIG;
2503 defm VCMPPSY : sse12_cmp_packed<VR256, f256mem, AVXCC, v8f32,
2504                "cmp${cc}ps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2505                "cmpps\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2506                SSEPackedSingle, i8immZExt5, loadv8f32>, PS, VEX_4V, VEX_L;
2507 defm VCMPPDY : sse12_cmp_packed<VR256, f256mem, AVXCC, v4f64,
2508                "cmp${cc}pd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2509                "cmppd\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2510                SSEPackedDouble, i8immZExt5, loadv4f64>, PD, VEX_4V, VEX_L;
2511 let Constraints = "$src1 = $dst" in {
2512   defm CMPPS : sse12_cmp_packed<VR128, f128mem, SSECC, v4f32,
2513                  "cmp${cc}ps\t{$src2, $dst|$dst, $src2}",
2514                  "cmpps\t{$cc, $src2, $dst|$dst, $src2, $cc}",
2515                  SSEPackedSingle, i8immZExt5, memopv4f32, SSE_ALU_F32P>, PS;
2516   defm CMPPD : sse12_cmp_packed<VR128, f128mem, SSECC, v2f64,
2517                  "cmp${cc}pd\t{$src2, $dst|$dst, $src2}",
2518                  "cmppd\t{$cc, $src2, $dst|$dst, $src2, $cc}",
2519                  SSEPackedDouble, i8immZExt5, memopv2f64, SSE_ALU_F64P>, PD;
2520 }
2521
2522 //===----------------------------------------------------------------------===//
2523 // SSE 1 & 2 - Shuffle Instructions
2524 //===----------------------------------------------------------------------===//
2525
2526 /// sse12_shuffle - sse 1 & 2 fp shuffle instructions
2527 multiclass sse12_shuffle<RegisterClass RC, X86MemOperand x86memop,
2528                          ValueType vt, string asm, PatFrag mem_frag,
2529                          Domain d> {
2530   def rmi : PIi8<0xC6, MRMSrcMem, (outs RC:$dst),
2531                    (ins RC:$src1, x86memop:$src2, u8imm:$src3), asm,
2532                    [(set RC:$dst, (vt (X86Shufp RC:$src1, (mem_frag addr:$src2),
2533                                        (i8 imm:$src3))))], IIC_SSE_SHUFP, d>,
2534             Sched<[WriteFShuffleLd, ReadAfterLd]>;
2535   def rri : PIi8<0xC6, MRMSrcReg, (outs RC:$dst),
2536                  (ins RC:$src1, RC:$src2, u8imm:$src3), asm,
2537                  [(set RC:$dst, (vt (X86Shufp RC:$src1, RC:$src2,
2538                                      (i8 imm:$src3))))], IIC_SSE_SHUFP, d>,
2539             Sched<[WriteFShuffle]>;
2540 }
2541
2542 let Predicates = [HasAVX, NoVLX] in {
2543   defm VSHUFPS  : sse12_shuffle<VR128, f128mem, v4f32,
2544            "shufps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2545            loadv4f32, SSEPackedSingle>, PS, VEX_4V, VEX_WIG;
2546   defm VSHUFPSY : sse12_shuffle<VR256, f256mem, v8f32,
2547            "shufps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2548            loadv8f32, SSEPackedSingle>, PS, VEX_4V, VEX_L, VEX_WIG;
2549   defm VSHUFPD  : sse12_shuffle<VR128, f128mem, v2f64,
2550            "shufpd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2551            loadv2f64, SSEPackedDouble>, PD, VEX_4V, VEX_WIG;
2552   defm VSHUFPDY : sse12_shuffle<VR256, f256mem, v4f64,
2553            "shufpd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2554            loadv4f64, SSEPackedDouble>, PD, VEX_4V, VEX_L, VEX_WIG;
2555 }
2556 let Constraints = "$src1 = $dst" in {
2557   defm SHUFPS : sse12_shuffle<VR128, f128mem, v4f32,
2558                     "shufps\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2559                     memopv4f32, SSEPackedSingle>, PS;
2560   defm SHUFPD : sse12_shuffle<VR128, f128mem, v2f64,
2561                     "shufpd\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2562                     memopv2f64, SSEPackedDouble>, PD;
2563 }
2564
2565 let Predicates = [HasAVX, NoVLX] in {
2566   def : Pat<(v4i32 (X86Shufp VR128:$src1,
2567                        (bc_v4i32 (loadv2i64 addr:$src2)), (i8 imm:$imm))),
2568             (VSHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2569   def : Pat<(v4i32 (X86Shufp VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2570             (VSHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2571
2572   def : Pat<(v2i64 (X86Shufp VR128:$src1,
2573                        (loadv2i64 addr:$src2), (i8 imm:$imm))),
2574             (VSHUFPDrmi VR128:$src1, addr:$src2, imm:$imm)>;
2575   def : Pat<(v2i64 (X86Shufp VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2576             (VSHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2577
2578   // 256-bit patterns
2579   def : Pat<(v8i32 (X86Shufp VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2580             (VSHUFPSYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2581   def : Pat<(v8i32 (X86Shufp VR256:$src1,
2582                       (bc_v8i32 (loadv4i64 addr:$src2)), (i8 imm:$imm))),
2583             (VSHUFPSYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2584
2585   def : Pat<(v4i64 (X86Shufp VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2586             (VSHUFPDYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2587   def : Pat<(v4i64 (X86Shufp VR256:$src1,
2588                               (loadv4i64 addr:$src2), (i8 imm:$imm))),
2589             (VSHUFPDYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2590 }
2591
2592 let Predicates = [UseSSE1] in {
2593   def : Pat<(v4i32 (X86Shufp VR128:$src1,
2594                        (bc_v4i32 (memopv2i64 addr:$src2)), (i8 imm:$imm))),
2595             (SHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2596   def : Pat<(v4i32 (X86Shufp VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2597             (SHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2598 }
2599
2600 let Predicates = [UseSSE2] in {
2601   // Generic SHUFPD patterns
2602   def : Pat<(v2i64 (X86Shufp VR128:$src1,
2603                        (memopv2i64 addr:$src2), (i8 imm:$imm))),
2604             (SHUFPDrmi VR128:$src1, addr:$src2, imm:$imm)>;
2605   def : Pat<(v2i64 (X86Shufp VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2606             (SHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2607 }
2608
2609 //===----------------------------------------------------------------------===//
2610 // SSE 1 & 2 - Unpack FP Instructions
2611 //===----------------------------------------------------------------------===//
2612
2613 /// sse12_unpack_interleave - sse 1 & 2 fp unpack and interleave
2614 multiclass sse12_unpack_interleave<bits<8> opc, SDNode OpNode, ValueType vt,
2615                                    PatFrag mem_frag, RegisterClass RC,
2616                                    X86MemOperand x86memop, string asm,
2617                                    Domain d, bit IsCommutable = 0> {
2618     let isCommutable = IsCommutable in
2619     def rr : PI<opc, MRMSrcReg,
2620                 (outs RC:$dst), (ins RC:$src1, RC:$src2),
2621                 asm, [(set RC:$dst,
2622                            (vt (OpNode RC:$src1, RC:$src2)))],
2623                            IIC_SSE_UNPCK, d>, Sched<[WriteFShuffle]>;
2624     def rm : PI<opc, MRMSrcMem,
2625                 (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
2626                 asm, [(set RC:$dst,
2627                            (vt (OpNode RC:$src1,
2628                                        (mem_frag addr:$src2))))],
2629                                        IIC_SSE_UNPCK, d>,
2630              Sched<[WriteFShuffleLd, ReadAfterLd]>;
2631 }
2632
2633 let Predicates = [HasAVX, NoVLX] in {
2634 defm VUNPCKHPS: sse12_unpack_interleave<0x15, X86Unpckh, v4f32, loadv4f32,
2635       VR128, f128mem, "unpckhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2636                      SSEPackedSingle>, PS, VEX_4V, VEX_WIG;
2637 defm VUNPCKHPD: sse12_unpack_interleave<0x15, X86Unpckh, v2f64, loadv2f64,
2638       VR128, f128mem, "unpckhpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2639                      SSEPackedDouble>, PD, VEX_4V, VEX_WIG;
2640 defm VUNPCKLPS: sse12_unpack_interleave<0x14, X86Unpckl, v4f32, loadv4f32,
2641       VR128, f128mem, "unpcklps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2642                      SSEPackedSingle>, PS, VEX_4V, VEX_WIG;
2643 defm VUNPCKLPD: sse12_unpack_interleave<0x14, X86Unpckl, v2f64, loadv2f64,
2644       VR128, f128mem, "unpcklpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2645                      SSEPackedDouble>, PD, VEX_4V, VEX_WIG;
2646
2647 defm VUNPCKHPSY: sse12_unpack_interleave<0x15, X86Unpckh, v8f32, loadv8f32,
2648       VR256, f256mem, "unpckhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2649                      SSEPackedSingle>, PS, VEX_4V, VEX_L, VEX_WIG;
2650 defm VUNPCKHPDY: sse12_unpack_interleave<0x15, X86Unpckh, v4f64, loadv4f64,
2651       VR256, f256mem, "unpckhpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2652                      SSEPackedDouble>, PD, VEX_4V, VEX_L, VEX_WIG;
2653 defm VUNPCKLPSY: sse12_unpack_interleave<0x14, X86Unpckl, v8f32, loadv8f32,
2654       VR256, f256mem, "unpcklps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2655                      SSEPackedSingle>, PS, VEX_4V, VEX_L, VEX_WIG;
2656 defm VUNPCKLPDY: sse12_unpack_interleave<0x14, X86Unpckl, v4f64, loadv4f64,
2657       VR256, f256mem, "unpcklpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2658                      SSEPackedDouble>, PD, VEX_4V, VEX_L, VEX_WIG;
2659 }// Predicates = [HasAVX, NoVLX]
2660 let Constraints = "$src1 = $dst" in {
2661   defm UNPCKHPS: sse12_unpack_interleave<0x15, X86Unpckh, v4f32, memopv4f32,
2662         VR128, f128mem, "unpckhps\t{$src2, $dst|$dst, $src2}",
2663                        SSEPackedSingle>, PS;
2664   defm UNPCKHPD: sse12_unpack_interleave<0x15, X86Unpckh, v2f64, memopv2f64,
2665         VR128, f128mem, "unpckhpd\t{$src2, $dst|$dst, $src2}",
2666                        SSEPackedDouble, 1>, PD;
2667   defm UNPCKLPS: sse12_unpack_interleave<0x14, X86Unpckl, v4f32, memopv4f32,
2668         VR128, f128mem, "unpcklps\t{$src2, $dst|$dst, $src2}",
2669                        SSEPackedSingle>, PS;
2670   defm UNPCKLPD: sse12_unpack_interleave<0x14, X86Unpckl, v2f64, memopv2f64,
2671         VR128, f128mem, "unpcklpd\t{$src2, $dst|$dst, $src2}",
2672                        SSEPackedDouble>, PD;
2673 } // Constraints = "$src1 = $dst"
2674
2675 let Predicates = [HasAVX1Only] in {
2676   def : Pat<(v8i32 (X86Unpckl VR256:$src1, (bc_v8i32 (loadv4i64 addr:$src2)))),
2677             (VUNPCKLPSYrm VR256:$src1, addr:$src2)>;
2678   def : Pat<(v8i32 (X86Unpckl VR256:$src1, VR256:$src2)),
2679             (VUNPCKLPSYrr VR256:$src1, VR256:$src2)>;
2680   def : Pat<(v8i32 (X86Unpckh VR256:$src1, (bc_v8i32 (loadv4i64 addr:$src2)))),
2681             (VUNPCKHPSYrm VR256:$src1, addr:$src2)>;
2682   def : Pat<(v8i32 (X86Unpckh VR256:$src1, VR256:$src2)),
2683             (VUNPCKHPSYrr VR256:$src1, VR256:$src2)>;
2684
2685   def : Pat<(v4i64 (X86Unpckl VR256:$src1, (loadv4i64 addr:$src2))),
2686             (VUNPCKLPDYrm VR256:$src1, addr:$src2)>;
2687   def : Pat<(v4i64 (X86Unpckl VR256:$src1, VR256:$src2)),
2688             (VUNPCKLPDYrr VR256:$src1, VR256:$src2)>;
2689   def : Pat<(v4i64 (X86Unpckh VR256:$src1, (loadv4i64 addr:$src2))),
2690             (VUNPCKHPDYrm VR256:$src1, addr:$src2)>;
2691   def : Pat<(v4i64 (X86Unpckh VR256:$src1, VR256:$src2)),
2692             (VUNPCKHPDYrr VR256:$src1, VR256:$src2)>;
2693 }
2694
2695 //===----------------------------------------------------------------------===//
2696 // SSE 1 & 2 - Extract Floating-Point Sign mask
2697 //===----------------------------------------------------------------------===//
2698
2699 /// sse12_extr_sign_mask - sse 1 & 2 unpack and interleave
2700 multiclass sse12_extr_sign_mask<RegisterClass RC, ValueType vt,
2701                                 string asm, Domain d> {
2702   def rr : PI<0x50, MRMSrcReg, (outs GR32orGR64:$dst), (ins RC:$src),
2703               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
2704               [(set GR32orGR64:$dst, (X86movmsk (vt RC:$src)))], IIC_SSE_MOVMSK, d>,
2705               Sched<[WriteVecLogic]>;
2706 }
2707
2708 let Predicates = [HasAVX] in {
2709   defm VMOVMSKPS : sse12_extr_sign_mask<VR128, v4f32, "movmskps",
2710                                         SSEPackedSingle>, PS, VEX, VEX_WIG;
2711   defm VMOVMSKPD : sse12_extr_sign_mask<VR128, v2f64, "movmskpd",
2712                                         SSEPackedDouble>, PD, VEX, VEX_WIG;
2713   defm VMOVMSKPSY : sse12_extr_sign_mask<VR256, v8f32, "movmskps",
2714                                          SSEPackedSingle>, PS, VEX, VEX_L, VEX_WIG;
2715   defm VMOVMSKPDY : sse12_extr_sign_mask<VR256, v4f64, "movmskpd",
2716                                          SSEPackedDouble>, PD, VEX, VEX_L, VEX_WIG;
2717 }
2718
2719 defm MOVMSKPS : sse12_extr_sign_mask<VR128, v4f32, "movmskps",
2720                                      SSEPackedSingle>, PS;
2721 defm MOVMSKPD : sse12_extr_sign_mask<VR128, v2f64, "movmskpd",
2722                                      SSEPackedDouble>, PD;
2723
2724 //===---------------------------------------------------------------------===//
2725 // SSE2 - Packed Integer Logical Instructions
2726 //===---------------------------------------------------------------------===//
2727
2728 let ExeDomain = SSEPackedInt in { // SSE integer instructions
2729
2730 /// PDI_binop_rm - Simple SSE2 binary operator.
2731 multiclass PDI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
2732                         ValueType OpVT, RegisterClass RC, PatFrag memop_frag,
2733                         X86MemOperand x86memop, OpndItins itins,
2734                         bit IsCommutable, bit Is2Addr> {
2735   let isCommutable = IsCommutable in
2736   def rr : PDI<opc, MRMSrcReg, (outs RC:$dst),
2737        (ins RC:$src1, RC:$src2),
2738        !if(Is2Addr,
2739            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2740            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
2741        [(set RC:$dst, (OpVT (OpNode RC:$src1, RC:$src2)))], itins.rr>,
2742        Sched<[itins.Sched]>;
2743   def rm : PDI<opc, MRMSrcMem, (outs RC:$dst),
2744        (ins RC:$src1, x86memop:$src2),
2745        !if(Is2Addr,
2746            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2747            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
2748        [(set RC:$dst, (OpVT (OpNode RC:$src1,
2749                                      (bitconvert (memop_frag addr:$src2)))))],
2750                                      itins.rm>,
2751        Sched<[itins.Sched.Folded, ReadAfterLd]>;
2752 }
2753 } // ExeDomain = SSEPackedInt
2754
2755 multiclass PDI_binop_all<bits<8> opc, string OpcodeStr, SDNode Opcode,
2756                          ValueType OpVT128, ValueType OpVT256,
2757                          OpndItins itins, bit IsCommutable = 0, Predicate prd> {
2758 let Predicates = [HasAVX, prd] in
2759   defm V#NAME : PDI_binop_rm<opc, !strconcat("v", OpcodeStr), Opcode, OpVT128,
2760                     VR128, loadv2i64, i128mem, itins, IsCommutable, 0>, VEX_4V, VEX_WIG;
2761
2762 let Constraints = "$src1 = $dst" in
2763   defm NAME : PDI_binop_rm<opc, OpcodeStr, Opcode, OpVT128, VR128,
2764                            memopv2i64, i128mem, itins, IsCommutable, 1>;
2765
2766 let Predicates = [HasAVX2, prd] in
2767   defm V#NAME#Y : PDI_binop_rm<opc, !strconcat("v", OpcodeStr), Opcode,
2768                                OpVT256, VR256, loadv4i64, i256mem, itins,
2769                                IsCommutable, 0>, VEX_4V, VEX_L, VEX_WIG;
2770 }
2771
2772 // These are ordered here for pattern ordering requirements with the fp versions
2773
2774 defm PAND  : PDI_binop_all<0xDB, "pand", and, v2i64, v4i64,
2775                            SSE_VEC_BIT_ITINS_P, 1, NoVLX>;
2776 defm POR   : PDI_binop_all<0xEB, "por", or, v2i64, v4i64,
2777                            SSE_VEC_BIT_ITINS_P, 1, NoVLX>;
2778 defm PXOR  : PDI_binop_all<0xEF, "pxor", xor, v2i64, v4i64,
2779                            SSE_VEC_BIT_ITINS_P, 1, NoVLX>;
2780 defm PANDN : PDI_binop_all<0xDF, "pandn", X86andnp, v2i64, v4i64,
2781                            SSE_VEC_BIT_ITINS_P, 0, NoVLX>;
2782
2783 //===----------------------------------------------------------------------===//
2784 // SSE 1 & 2 - Logical Instructions
2785 //===----------------------------------------------------------------------===//
2786
2787 /// sse12_fp_packed_logical - SSE 1 & 2 packed FP logical ops
2788 ///
2789 multiclass sse12_fp_packed_logical<bits<8> opc, string OpcodeStr,
2790                                    SDNode OpNode> {
2791   let Predicates = [HasAVX, NoVLX] in {
2792   defm V#NAME#PSY : sse12_fp_packed_logical_rm<opc, VR256, SSEPackedSingle,
2793         !strconcat(OpcodeStr, "ps"), f256mem,
2794         [(set VR256:$dst, (OpNode (bc_v4i64 (v8f32 VR256:$src1)),
2795                                   (bc_v4i64 (v8f32 VR256:$src2))))],
2796         [(set VR256:$dst, (OpNode (bc_v4i64 (v8f32 VR256:$src1)),
2797                            (loadv4i64 addr:$src2)))], 0>, PS, VEX_4V, VEX_L, VEX_WIG;
2798
2799   defm V#NAME#PDY : sse12_fp_packed_logical_rm<opc, VR256, SSEPackedDouble,
2800         !strconcat(OpcodeStr, "pd"), f256mem,
2801         [(set VR256:$dst, (OpNode (bc_v4i64 (v4f64 VR256:$src1)),
2802                                   (bc_v4i64 (v4f64 VR256:$src2))))],
2803         [(set VR256:$dst, (OpNode (bc_v4i64 (v4f64 VR256:$src1)),
2804                                   (loadv4i64 addr:$src2)))], 0>,
2805                                   PD, VEX_4V, VEX_L, VEX_WIG;
2806
2807   defm V#NAME#PS : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedSingle,
2808        !strconcat(OpcodeStr, "ps"), f128mem,
2809        [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2810                                  (bc_v2i64 (v4f32 VR128:$src2))))],
2811        [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2812                                  (loadv2i64 addr:$src2)))], 0>, PS, VEX_4V, VEX_WIG;
2813
2814   defm V#NAME#PD : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedDouble,
2815        !strconcat(OpcodeStr, "pd"), f128mem,
2816        [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2817                                  (bc_v2i64 (v2f64 VR128:$src2))))],
2818        [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2819                                  (loadv2i64 addr:$src2)))], 0>,
2820                                                  PD, VEX_4V, VEX_WIG;
2821   }
2822
2823   let Constraints = "$src1 = $dst" in {
2824     defm PS : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedSingle,
2825          !strconcat(OpcodeStr, "ps"), f128mem,
2826          [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2827                                    (bc_v2i64 (v4f32 VR128:$src2))))],
2828          [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2829                                    (memopv2i64 addr:$src2)))]>, PS;
2830
2831     defm PD : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedDouble,
2832          !strconcat(OpcodeStr, "pd"), f128mem,
2833          [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2834                                    (bc_v2i64 (v2f64 VR128:$src2))))],
2835          [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2836                                    (memopv2i64 addr:$src2)))]>, PD;
2837   }
2838 }
2839
2840 defm AND  : sse12_fp_packed_logical<0x54, "and", and>;
2841 defm OR   : sse12_fp_packed_logical<0x56, "or", or>;
2842 defm XOR  : sse12_fp_packed_logical<0x57, "xor", xor>;
2843 let isCommutable = 0 in
2844   defm ANDN : sse12_fp_packed_logical<0x55, "andn", X86andnp>;
2845
2846 // If only AVX1 is supported, we need to handle integer operations with
2847 // floating point instructions since the integer versions aren't available.
2848 let Predicates = [HasAVX1Only] in {
2849   def : Pat<(v4i64 (and VR256:$src1, VR256:$src2)),
2850             (VANDPSYrr VR256:$src1, VR256:$src2)>;
2851   def : Pat<(v4i64 (or VR256:$src1, VR256:$src2)),
2852             (VORPSYrr VR256:$src1, VR256:$src2)>;
2853   def : Pat<(v4i64 (xor VR256:$src1, VR256:$src2)),
2854             (VXORPSYrr VR256:$src1, VR256:$src2)>;
2855   def : Pat<(v4i64 (X86andnp VR256:$src1, VR256:$src2)),
2856             (VANDNPSYrr VR256:$src1, VR256:$src2)>;
2857
2858   def : Pat<(and VR256:$src1, (loadv4i64 addr:$src2)),
2859             (VANDPSYrm VR256:$src1, addr:$src2)>;
2860   def : Pat<(or VR256:$src1, (loadv4i64 addr:$src2)),
2861             (VORPSYrm VR256:$src1, addr:$src2)>;
2862   def : Pat<(xor VR256:$src1, (loadv4i64 addr:$src2)),
2863             (VXORPSYrm VR256:$src1, addr:$src2)>;
2864   def : Pat<(X86andnp VR256:$src1, (loadv4i64 addr:$src2)),
2865             (VANDNPSYrm VR256:$src1, addr:$src2)>;
2866 }
2867
2868 let Predicates = [HasAVX, NoVLX_Or_NoDQI] in {
2869   // Use packed logical operations for scalar ops.
2870   def : Pat<(f64 (X86fand FR64:$src1, FR64:$src2)),
2871             (COPY_TO_REGCLASS (VANDPDrr
2872                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2873                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2874   def : Pat<(f64 (X86for FR64:$src1, FR64:$src2)),
2875             (COPY_TO_REGCLASS (VORPDrr
2876                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2877                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2878   def : Pat<(f64 (X86fxor FR64:$src1, FR64:$src2)),
2879             (COPY_TO_REGCLASS (VXORPDrr
2880                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2881                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2882   def : Pat<(f64 (X86fandn FR64:$src1, FR64:$src2)),
2883             (COPY_TO_REGCLASS (VANDNPDrr
2884                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2885                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2886
2887   def : Pat<(f32 (X86fand FR32:$src1, FR32:$src2)),
2888             (COPY_TO_REGCLASS (VANDPSrr
2889                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2890                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2891   def : Pat<(f32 (X86for FR32:$src1, FR32:$src2)),
2892             (COPY_TO_REGCLASS (VORPSrr
2893                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2894                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2895   def : Pat<(f32 (X86fxor FR32:$src1, FR32:$src2)),
2896             (COPY_TO_REGCLASS (VXORPSrr
2897                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2898                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2899   def : Pat<(f32 (X86fandn FR32:$src1, FR32:$src2)),
2900             (COPY_TO_REGCLASS (VANDNPSrr
2901                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2902                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2903 }
2904
2905 let Predicates = [UseSSE1] in {
2906   // Use packed logical operations for scalar ops.
2907   def : Pat<(f32 (X86fand FR32:$src1, FR32:$src2)),
2908             (COPY_TO_REGCLASS (ANDPSrr
2909                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2910                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2911   def : Pat<(f32 (X86for FR32:$src1, FR32:$src2)),
2912             (COPY_TO_REGCLASS (ORPSrr
2913                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2914                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2915   def : Pat<(f32 (X86fxor FR32:$src1, FR32:$src2)),
2916             (COPY_TO_REGCLASS (XORPSrr
2917                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2918                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2919   def : Pat<(f32 (X86fandn FR32:$src1, FR32:$src2)),
2920             (COPY_TO_REGCLASS (ANDNPSrr
2921                                (COPY_TO_REGCLASS FR32:$src1, VR128),
2922                                (COPY_TO_REGCLASS FR32:$src2, VR128)), FR32)>;
2923 }
2924
2925 let Predicates = [UseSSE2] in {
2926   // Use packed logical operations for scalar ops.
2927   def : Pat<(f64 (X86fand FR64:$src1, FR64:$src2)),
2928             (COPY_TO_REGCLASS (ANDPDrr
2929                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2930                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2931   def : Pat<(f64 (X86for FR64:$src1, FR64:$src2)),
2932             (COPY_TO_REGCLASS (ORPDrr
2933                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2934                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2935   def : Pat<(f64 (X86fxor FR64:$src1, FR64:$src2)),
2936             (COPY_TO_REGCLASS (XORPDrr
2937                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2938                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2939   def : Pat<(f64 (X86fandn FR64:$src1, FR64:$src2)),
2940             (COPY_TO_REGCLASS (ANDNPDrr
2941                                (COPY_TO_REGCLASS FR64:$src1, VR128),
2942                                (COPY_TO_REGCLASS FR64:$src2, VR128)), FR64)>;
2943 }
2944
2945 // Patterns for packed operations when we don't have integer type available.
2946 def : Pat<(v4f32 (X86fand VR128:$src1, VR128:$src2)),
2947           (ANDPSrr VR128:$src1, VR128:$src2)>;
2948 def : Pat<(v4f32 (X86for VR128:$src1, VR128:$src2)),
2949           (ORPSrr VR128:$src1, VR128:$src2)>;
2950 def : Pat<(v4f32 (X86fxor VR128:$src1, VR128:$src2)),
2951           (XORPSrr VR128:$src1, VR128:$src2)>;
2952 def : Pat<(v4f32 (X86fandn VR128:$src1, VR128:$src2)),
2953           (ANDNPSrr VR128:$src1, VR128:$src2)>;
2954
2955 def : Pat<(X86fand VR128:$src1, (memopv4f32 addr:$src2)),
2956           (ANDPSrm VR128:$src1, addr:$src2)>;
2957 def : Pat<(X86for VR128:$src1, (memopv4f32 addr:$src2)),
2958           (ORPSrm VR128:$src1, addr:$src2)>;
2959 def : Pat<(X86fxor VR128:$src1, (memopv4f32 addr:$src2)),
2960           (XORPSrm VR128:$src1, addr:$src2)>;
2961 def : Pat<(X86fandn VR128:$src1, (memopv4f32 addr:$src2)),
2962           (ANDNPSrm VR128:$src1, addr:$src2)>;
2963
2964 //===----------------------------------------------------------------------===//
2965 // SSE 1 & 2 - Arithmetic Instructions
2966 //===----------------------------------------------------------------------===//
2967
2968 /// basic_sse12_fp_binop_xxx - SSE 1 & 2 binops come in both scalar and
2969 /// vector forms.
2970 ///
2971 /// In addition, we also have a special variant of the scalar form here to
2972 /// represent the associated intrinsic operation.  This form is unlike the
2973 /// plain scalar form, in that it takes an entire vector (instead of a scalar)
2974 /// and leaves the top elements unmodified (therefore these cannot be commuted).
2975 ///
2976 /// These three forms can each be reg+reg or reg+mem.
2977 ///
2978
2979 /// FIXME: once all 256-bit intrinsics are matched, cleanup and refactor those
2980 /// classes below
2981 multiclass basic_sse12_fp_binop_p<bits<8> opc, string OpcodeStr,
2982                                   SDNode OpNode, SizeItins itins> {
2983   let Predicates = [HasAVX, NoVLX] in {
2984   defm V#NAME#PS : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode,
2985                                VR128, v4f32, f128mem, loadv4f32,
2986                                SSEPackedSingle, itins.s, 0>, PS, VEX_4V, VEX_WIG;
2987   defm V#NAME#PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode,
2988                                VR128, v2f64, f128mem, loadv2f64,
2989                                SSEPackedDouble, itins.d, 0>, PD, VEX_4V, VEX_WIG;
2990
2991   defm V#NAME#PSY : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"),
2992                         OpNode, VR256, v8f32, f256mem, loadv8f32,
2993                         SSEPackedSingle, itins.s, 0>, PS, VEX_4V, VEX_L, VEX_WIG;
2994   defm V#NAME#PDY : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"),
2995                         OpNode, VR256, v4f64, f256mem, loadv4f64,
2996                         SSEPackedDouble, itins.d, 0>, PD, VEX_4V, VEX_L, VEX_WIG;
2997   }
2998
2999   let Constraints = "$src1 = $dst" in {
3000     defm PS : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode, VR128,
3001                               v4f32, f128mem, memopv4f32, SSEPackedSingle,
3002                               itins.s>, PS;
3003     defm PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode, VR128,
3004                               v2f64, f128mem, memopv2f64, SSEPackedDouble,
3005                               itins.d>, PD;
3006   }
3007 }
3008
3009 multiclass basic_sse12_fp_binop_s<bits<8> opc, string OpcodeStr, SDNode OpNode,
3010                                   SizeItins itins> {
3011   defm V#NAME#SS : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "ss"),
3012                          OpNode, FR32, f32mem, SSEPackedSingle, itins.s, 0>,
3013                          XS, VEX_4V, VEX_LIG, VEX_WIG;
3014   defm V#NAME#SD : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "sd"),
3015                          OpNode, FR64, f64mem, SSEPackedDouble, itins.d, 0>,
3016                          XD, VEX_4V, VEX_LIG, VEX_WIG;
3017
3018   let Constraints = "$src1 = $dst" in {
3019     defm SS : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "ss"),
3020                               OpNode, FR32, f32mem, SSEPackedSingle,
3021                               itins.s>, XS;
3022     defm SD : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "sd"),
3023                               OpNode, FR64, f64mem, SSEPackedDouble,
3024                               itins.d>, XD;
3025   }
3026 }
3027
3028 multiclass basic_sse12_fp_binop_s_int<bits<8> opc, string OpcodeStr,
3029                                       SDPatternOperator OpNode,
3030                                       SizeItins itins> {
3031   defm V#NAME#SS : sse12_fp_scalar_int<opc, OpcodeStr, OpNode, VR128, v4f32,
3032                    !strconcat(OpcodeStr, "ss"), ssmem, sse_load_f32,
3033                    SSEPackedSingle, itins.s, 0>, XS, VEX_4V, VEX_LIG, VEX_WIG;
3034   defm V#NAME#SD : sse12_fp_scalar_int<opc, OpcodeStr, OpNode, VR128, v2f64,
3035                    !strconcat(OpcodeStr, "sd"), sdmem, sse_load_f64,
3036                    SSEPackedDouble, itins.d, 0>, XD, VEX_4V, VEX_LIG, VEX_WIG;
3037
3038   let Constraints = "$src1 = $dst" in {
3039     defm SS : sse12_fp_scalar_int<opc, OpcodeStr, OpNode, VR128, v4f32,
3040                    !strconcat(OpcodeStr, "ss"), ssmem, sse_load_f32,
3041                    SSEPackedSingle, itins.s>, XS;
3042     defm SD : sse12_fp_scalar_int<opc, OpcodeStr, OpNode, VR128, v2f64,
3043                    !strconcat(OpcodeStr, "sd"), sdmem, sse_load_f64,
3044                    SSEPackedDouble, itins.d>, XD;
3045   }
3046 }
3047
3048 // Binary Arithmetic instructions
3049 defm ADD : basic_sse12_fp_binop_p<0x58, "add", fadd, SSE_ALU_ITINS_P>,
3050            basic_sse12_fp_binop_s<0x58, "add", fadd, SSE_ALU_ITINS_S>,
3051            basic_sse12_fp_binop_s_int<0x58, "add", null_frag, SSE_ALU_ITINS_S>;
3052 defm MUL : basic_sse12_fp_binop_p<0x59, "mul", fmul, SSE_MUL_ITINS_P>,
3053            basic_sse12_fp_binop_s<0x59, "mul", fmul, SSE_MUL_ITINS_S>,
3054            basic_sse12_fp_binop_s_int<0x59, "mul", null_frag, SSE_MUL_ITINS_S>;
3055 let isCommutable = 0 in {
3056   defm SUB : basic_sse12_fp_binop_p<0x5C, "sub", fsub, SSE_ALU_ITINS_P>,
3057              basic_sse12_fp_binop_s<0x5C, "sub", fsub, SSE_ALU_ITINS_S>,
3058              basic_sse12_fp_binop_s_int<0x5C, "sub", null_frag,SSE_ALU_ITINS_S>;
3059   defm DIV : basic_sse12_fp_binop_p<0x5E, "div", fdiv, SSE_DIV_ITINS_P>,
3060              basic_sse12_fp_binop_s<0x5E, "div", fdiv, SSE_DIV_ITINS_S>,
3061              basic_sse12_fp_binop_s_int<0x5E, "div", null_frag,SSE_DIV_ITINS_S>;
3062   defm MAX : basic_sse12_fp_binop_p<0x5F, "max", X86fmax, SSE_ALU_ITINS_P>,
3063              basic_sse12_fp_binop_s<0x5F, "max", X86fmax, SSE_ALU_ITINS_S>,
3064              basic_sse12_fp_binop_s_int<0x5F, "max", X86fmaxs, SSE_ALU_ITINS_S>;
3065   defm MIN : basic_sse12_fp_binop_p<0x5D, "min", X86fmin, SSE_ALU_ITINS_P>,
3066              basic_sse12_fp_binop_s<0x5D, "min", X86fmin, SSE_ALU_ITINS_S>,
3067              basic_sse12_fp_binop_s_int<0x5D, "min", X86fmins, SSE_ALU_ITINS_S>;
3068 }
3069
3070 let isCodeGenOnly = 1 in {
3071   defm MAXC: basic_sse12_fp_binop_p<0x5F, "max", X86fmaxc, SSE_ALU_ITINS_P>,
3072              basic_sse12_fp_binop_s<0x5F, "max", X86fmaxc, SSE_ALU_ITINS_S>;
3073   defm MINC: basic_sse12_fp_binop_p<0x5D, "min", X86fminc, SSE_ALU_ITINS_P>,
3074              basic_sse12_fp_binop_s<0x5D, "min", X86fminc, SSE_ALU_ITINS_S>;
3075 }
3076
3077 // Patterns used to select SSE scalar fp arithmetic instructions from
3078 // either:
3079 //
3080 // (1) a scalar fp operation followed by a blend
3081 //
3082 // The effect is that the backend no longer emits unnecessary vector
3083 // insert instructions immediately after SSE scalar fp instructions
3084 // like addss or mulss.
3085 //
3086 // For example, given the following code:
3087 //   __m128 foo(__m128 A, __m128 B) {
3088 //     A[0] += B[0];
3089 //     return A;
3090 //   }
3091 //
3092 // Previously we generated:
3093 //   addss %xmm0, %xmm1
3094 //   movss %xmm1, %xmm0
3095 //
3096 // We now generate:
3097 //   addss %xmm1, %xmm0
3098 //
3099 // (2) a vector packed single/double fp operation followed by a vector insert
3100 //
3101 // The effect is that the backend converts the packed fp instruction
3102 // followed by a vector insert into a single SSE scalar fp instruction.
3103 //
3104 // For example, given the following code:
3105 //   __m128 foo(__m128 A, __m128 B) {
3106 //     __m128 C = A + B;
3107 //     return (__m128) {c[0], a[1], a[2], a[3]};
3108 //   }
3109 //
3110 // Previously we generated:
3111 //   addps %xmm0, %xmm1
3112 //   movss %xmm1, %xmm0
3113 //
3114 // We now generate:
3115 //   addss %xmm1, %xmm0
3116
3117 // TODO: Some canonicalization in lowering would simplify the number of
3118 // patterns we have to try to match.
3119 multiclass scalar_math_f32_patterns<SDNode Op, string OpcPrefix> {
3120   let Predicates = [UseSSE1] in {
3121     // extracted scalar math op with insert via movss
3122     def : Pat<(v4f32 (X86Movss (v4f32 VR128:$dst), (v4f32 (scalar_to_vector
3123           (Op (f32 (extractelt (v4f32 VR128:$dst), (iPTR 0))),
3124           FR32:$src))))),
3125       (!cast<I>(OpcPrefix#SSrr_Int) v4f32:$dst,
3126           (COPY_TO_REGCLASS FR32:$src, VR128))>;
3127
3128     // vector math op with insert via movss
3129     def : Pat<(v4f32 (X86Movss (v4f32 VR128:$dst),
3130           (Op (v4f32 VR128:$dst), (v4f32 VR128:$src)))),
3131       (!cast<I>(OpcPrefix#SSrr_Int) v4f32:$dst, v4f32:$src)>;
3132   }
3133
3134   // With SSE 4.1, blendi is preferred to movsd, so match that too.
3135   let Predicates = [UseSSE41] in {
3136     // extracted scalar math op with insert via blend
3137     def : Pat<(v4f32 (X86Blendi (v4f32 VR128:$dst), (v4f32 (scalar_to_vector
3138           (Op (f32 (extractelt (v4f32 VR128:$dst), (iPTR 0))),
3139           FR32:$src))), (i8 1))),
3140       (!cast<I>(OpcPrefix#SSrr_Int) v4f32:$dst,
3141           (COPY_TO_REGCLASS FR32:$src, VR128))>;
3142
3143     // vector math op with insert via blend
3144     def : Pat<(v4f32 (X86Blendi (v4f32 VR128:$dst),
3145           (Op (v4f32 VR128:$dst), (v4f32 VR128:$src)), (i8 1))),
3146       (!cast<I>(OpcPrefix#SSrr_Int)v4f32:$dst, v4f32:$src)>;
3147
3148   }
3149
3150   // Repeat everything for AVX.
3151   let Predicates = [UseAVX] in {
3152     // extracted scalar math op with insert via movss
3153     def : Pat<(v4f32 (X86Movss (v4f32 VR128:$dst), (v4f32 (scalar_to_vector
3154           (Op (f32 (extractelt (v4f32 VR128:$dst), (iPTR 0))),
3155           FR32:$src))))),
3156       (!cast<I>("V"#OpcPrefix#SSrr_Int) v4f32:$dst,
3157           (COPY_TO_REGCLASS FR32:$src, VR128))>;
3158
3159     // extracted scalar math op with insert via blend
3160     def : Pat<(v4f32 (X86Blendi (v4f32 VR128:$dst), (v4f32 (scalar_to_vector
3161           (Op (f32 (extractelt (v4f32 VR128:$dst), (iPTR 0))),
3162           FR32:$src))), (i8 1))),
3163       (!cast<I>("V"#OpcPrefix#SSrr_Int) v4f32:$dst,
3164           (COPY_TO_REGCLASS FR32:$src, VR128))>;
3165
3166     // vector math op with insert via movss
3167     def : Pat<(v4f32 (X86Movss (v4f32 VR128:$dst),
3168           (Op (v4f32 VR128:$dst), (v4f32 VR128:$src)))),
3169       (!cast<I>("V"#OpcPrefix#SSrr_Int) v4f32:$dst, v4f32:$src)>;
3170
3171     // vector math op with insert via blend
3172     def : Pat<(v4f32 (X86Blendi (v4f32 VR128:$dst),
3173           (Op (v4f32 VR128:$dst), (v4f32 VR128:$src)), (i8 1))),
3174       (!cast<I>("V"#OpcPrefix#SSrr_Int) v4f32:$dst, v4f32:$src)>;
3175   }
3176 }
3177
3178 defm : scalar_math_f32_patterns<fadd, "ADD">;
3179 defm : scalar_math_f32_patterns<fsub, "SUB">;
3180 defm : scalar_math_f32_patterns<fmul, "MUL">;
3181 defm : scalar_math_f32_patterns<fdiv, "DIV">;
3182
3183 multiclass scalar_math_f64_patterns<SDNode Op, string OpcPrefix> {
3184   let Predicates = [UseSSE2] in {
3185     // extracted scalar math op with insert via movsd
3186     def : Pat<(v2f64 (X86Movsd (v2f64 VR128:$dst), (v2f64 (scalar_to_vector
3187           (Op (f64 (extractelt (v2f64 VR128:$dst), (iPTR 0))),
3188           FR64:$src))))),
3189       (!cast<I>(OpcPrefix#SDrr_Int) v2f64:$dst,
3190           (COPY_TO_REGCLASS FR64:$src, VR128))>;
3191
3192     // vector math op with insert via movsd
3193     def : Pat<(v2f64 (X86Movsd (v2f64 VR128:$dst),
3194           (Op (v2f64 VR128:$dst), (v2f64 VR128:$src)))),
3195       (!cast<I>(OpcPrefix#SDrr_Int) v2f64:$dst, v2f64:$src)>;
3196   }
3197
3198   // With SSE 4.1, blendi is preferred to movsd, so match those too.
3199   let Predicates = [UseSSE41] in {
3200     // extracted scalar math op with insert via blend
3201     def : Pat<(v2f64 (X86Blendi (v2f64 VR128:$dst), (v2f64 (scalar_to_vector
3202           (Op (f64 (extractelt (v2f64 VR128:$dst), (iPTR 0))),
3203           FR64:$src))), (i8 1))),
3204       (!cast<I>(OpcPrefix#SDrr_Int) v2f64:$dst,
3205           (COPY_TO_REGCLASS FR64:$src, VR128))>;
3206
3207     // vector math op with insert via blend
3208     def : Pat<(v2f64 (X86Blendi (v2f64 VR128:$dst),
3209           (Op (v2f64 VR128:$dst), (v2f64 VR128:$src)), (i8 1))),
3210       (!cast<I>(OpcPrefix#SDrr_Int) v2f64:$dst, v2f64:$src)>;
3211   }
3212
3213   // Repeat everything for AVX.
3214   let Predicates = [UseAVX] in {
3215     // extracted scalar math op with insert via movsd
3216     def : Pat<(v2f64 (X86Movsd (v2f64 VR128:$dst), (v2f64 (scalar_to_vector
3217           (Op (f64 (extractelt (v2f64 VR128:$dst), (iPTR 0))),
3218           FR64:$src))))),
3219       (!cast<I>("V"#OpcPrefix#SDrr_Int) v2f64:$dst,
3220           (COPY_TO_REGCLASS FR64:$src, VR128))>;
3221
3222     // extracted scalar math op with insert via blend
3223     def : Pat<(v2f64 (X86Blendi (v2f64 VR128:$dst), (v2f64 (scalar_to_vector
3224           (Op (f64 (extractelt (v2f64 VR128:$dst), (iPTR 0))),
3225           FR64:$src))), (i8 1))),
3226       (!cast<I>("V"#OpcPrefix#SDrr_Int) v2f64:$dst,
3227           (COPY_TO_REGCLASS FR64:$src, VR128))>;
3228
3229     // vector math op with insert via movsd
3230     def : Pat<(v2f64 (X86Movsd (v2f64 VR128:$dst),
3231           (Op (v2f64 VR128:$dst), (v2f64 VR128:$src)))),
3232       (!cast<I>("V"#OpcPrefix#SDrr_Int) v2f64:$dst, v2f64:$src)>;
3233
3234     // vector math op with insert via blend
3235     def : Pat<(v2f64 (X86Blendi (v2f64 VR128:$dst),
3236           (Op (v2f64 VR128:$dst), (v2f64 VR128:$src)), (i8 1))),
3237       (!cast<I>("V"#OpcPrefix#SDrr_Int) v2f64:$dst, v2f64:$src)>;
3238   }
3239 }
3240
3241 defm : scalar_math_f64_patterns<fadd, "ADD">;
3242 defm : scalar_math_f64_patterns<fsub, "SUB">;
3243 defm : scalar_math_f64_patterns<fmul, "MUL">;
3244 defm : scalar_math_f64_patterns<fdiv, "DIV">;
3245
3246
3247 /// Unop Arithmetic
3248 /// In addition, we also have a special variant of the scalar form here to
3249 /// represent the associated intrinsic operation.  This form is unlike the
3250 /// plain scalar form, in that it takes an entire vector (instead of a
3251 /// scalar) and leaves the top elements undefined.
3252 ///
3253 /// And, we have a special variant form for a full-vector intrinsic form.
3254
3255 let Sched = WriteFSqrt in {
3256 def SSE_SQRTPS : OpndItins<
3257   IIC_SSE_SQRTPS_RR, IIC_SSE_SQRTPS_RM
3258 >;
3259
3260 def SSE_SQRTSS : OpndItins<
3261   IIC_SSE_SQRTSS_RR, IIC_SSE_SQRTSS_RM
3262 >;
3263
3264 def SSE_SQRTPD : OpndItins<
3265   IIC_SSE_SQRTPD_RR, IIC_SSE_SQRTPD_RM
3266 >;
3267
3268 def SSE_SQRTSD : OpndItins<
3269   IIC_SSE_SQRTSD_RR, IIC_SSE_SQRTSD_RM
3270 >;
3271 }
3272
3273 let Sched = WriteFRsqrt in {
3274 def SSE_RSQRTPS : OpndItins<
3275   IIC_SSE_RSQRTPS_RR, IIC_SSE_RSQRTPS_RM
3276 >;
3277
3278 def SSE_RSQRTSS : OpndItins<
3279   IIC_SSE_RSQRTSS_RR, IIC_SSE_RSQRTSS_RM
3280 >;
3281 }
3282
3283 let Sched = WriteFRcp in {
3284 def SSE_RCPP : OpndItins<
3285   IIC_SSE_RCPP_RR, IIC_SSE_RCPP_RM
3286 >;
3287
3288 def SSE_RCPS : OpndItins<
3289   IIC_SSE_RCPS_RR, IIC_SSE_RCPS_RM
3290 >;
3291 }
3292
3293 /// sse_fp_unop_s - SSE1 unops in scalar form
3294 /// For the non-AVX defs, we need $src1 to be tied to $dst because
3295 /// the HW instructions are 2 operand / destructive.
3296 multiclass sse_fp_unop_s<bits<8> opc, string OpcodeStr, RegisterClass RC,
3297                           ValueType vt, ValueType ScalarVT,
3298                           X86MemOperand x86memop,
3299                           Intrinsic Intr,
3300                           SDNode OpNode, Domain d, OpndItins itins,
3301                           Predicate target, string Suffix> {
3302   let hasSideEffects = 0 in {
3303   def r : I<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1),
3304               !strconcat(OpcodeStr, "\t{$src1, $dst|$dst, $src1}"),
3305             [(set RC:$dst, (OpNode RC:$src1))], itins.rr, d>, Sched<[itins.Sched]>,
3306             Requires<[target]>;
3307   let mayLoad = 1 in
3308   def m : I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src1),
3309             !strconcat(OpcodeStr, "\t{$src1, $dst|$dst, $src1}"),
3310             [(set RC:$dst, (OpNode (load addr:$src1)))], itins.rm, d>,
3311             Sched<[itins.Sched.Folded, ReadAfterLd]>,
3312             Requires<[target, OptForSize]>;
3313
3314   let isCodeGenOnly = 1, Constraints = "$src1 = $dst", ExeDomain = d in {
3315   def r_Int : I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3316               !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3317             []>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
3318   let mayLoad = 1 in
3319   def m_Int : I<opc, MRMSrcMem, (outs VR128:$dst), (ins VR128:$src1, x86memop:$src2),
3320               !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3321             []>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
3322   }
3323   }
3324
3325   let Predicates = [target] in {
3326   // These are unary operations, but they are modeled as having 2 source operands
3327   // because the high elements of the destination are unchanged in SSE.
3328   def : Pat<(Intr VR128:$src),
3329             (!cast<Instruction>(NAME#Suffix##r_Int) VR128:$src, VR128:$src)>;
3330   }
3331   // We don't want to fold scalar loads into these instructions unless
3332   // optimizing for size. This is because the folded instruction will have a
3333   // partial register update, while the unfolded sequence will not, e.g.
3334   // movss mem, %xmm0
3335   // rcpss %xmm0, %xmm0
3336   // which has a clobber before the rcp, vs.
3337   // rcpss mem, %xmm0
3338   let Predicates = [target, OptForSize] in {
3339     def : Pat<(Intr (scalar_to_vector (ScalarVT (load addr:$src2)))),
3340                (!cast<Instruction>(NAME#Suffix##m_Int)
3341                       (vt (IMPLICIT_DEF)), addr:$src2)>;
3342   }
3343 }
3344
3345 multiclass avx_fp_unop_s<bits<8> opc, string OpcodeStr, RegisterClass RC,
3346                           ValueType vt, ValueType ScalarVT,
3347                           X86MemOperand x86memop,
3348                           Intrinsic Intr, SDNode OpNode, Domain d,
3349                           OpndItins itins, string Suffix> {
3350   let hasSideEffects = 0 in {
3351   def r : I<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
3352             !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3353             [], itins.rr, d>, Sched<[itins.Sched]>;
3354   let mayLoad = 1 in
3355   def m : I<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
3356              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3357             [], itins.rm, d>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
3358   let isCodeGenOnly = 1, ExeDomain = d in {
3359   def r_Int : I<opc, MRMSrcReg, (outs VR128:$dst),
3360                 (ins VR128:$src1, VR128:$src2),
3361              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3362              []>, Sched<[itins.Sched.Folded]>;
3363   let mayLoad = 1 in
3364   def m_Int : I<opc, MRMSrcMem, (outs VR128:$dst),
3365                 (ins VR128:$src1, x86memop:$src2),
3366              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3367              []>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
3368   }
3369   }
3370
3371   // We don't want to fold scalar loads into these instructions unless
3372   // optimizing for size. This is because the folded instruction will have a
3373   // partial register update, while the unfolded sequence will not, e.g.
3374   // vmovss mem, %xmm0
3375   // vrcpss %xmm0, %xmm0, %xmm0
3376   // which has a clobber before the rcp, vs.
3377   // vrcpss mem, %xmm0, %xmm0
3378   // TODO: In theory, we could fold the load, and avoid the stall caused by
3379   // the partial register store, either in ExecutionDepsFix or with smarter RA.
3380   let Predicates = [UseAVX] in {
3381    def : Pat<(OpNode RC:$src),  (!cast<Instruction>("V"#NAME#Suffix##r)
3382                                 (ScalarVT (IMPLICIT_DEF)), RC:$src)>;
3383   }
3384   let Predicates = [HasAVX] in {
3385    def : Pat<(Intr VR128:$src),
3386              (!cast<Instruction>("V"#NAME#Suffix##r_Int) VR128:$src,
3387                                  VR128:$src)>;
3388   }
3389   let Predicates = [HasAVX, OptForSize] in {
3390     def : Pat<(Intr (scalar_to_vector (ScalarVT (load addr:$src2)))),
3391               (!cast<Instruction>("V"#NAME#Suffix##m_Int)
3392                     (vt (IMPLICIT_DEF)), addr:$src2)>;
3393   }
3394   let Predicates = [UseAVX, OptForSize] in {
3395     def : Pat<(ScalarVT (OpNode (load addr:$src))),
3396               (!cast<Instruction>("V"#NAME#Suffix##m) (ScalarVT (IMPLICIT_DEF)),
3397             addr:$src)>;
3398   }
3399 }
3400
3401 /// sse1_fp_unop_p - SSE1 unops in packed form.
3402 multiclass sse1_fp_unop_p<bits<8> opc, string OpcodeStr, SDNode OpNode,
3403                           OpndItins itins, list<Predicate> prds> {
3404 let Predicates = prds in {
3405   def V#NAME#PSr : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3406                        !strconcat("v", OpcodeStr,
3407                                   "ps\t{$src, $dst|$dst, $src}"),
3408                        [(set VR128:$dst, (v4f32 (OpNode VR128:$src)))],
3409                        itins.rr>, VEX, Sched<[itins.Sched]>, VEX_WIG;
3410   def V#NAME#PSm : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
3411                        !strconcat("v", OpcodeStr,
3412                                   "ps\t{$src, $dst|$dst, $src}"),
3413                        [(set VR128:$dst, (OpNode (loadv4f32 addr:$src)))],
3414                        itins.rm>, VEX, Sched<[itins.Sched.Folded]>, VEX_WIG;
3415   def V#NAME#PSYr : PSI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3416                         !strconcat("v", OpcodeStr,
3417                                    "ps\t{$src, $dst|$dst, $src}"),
3418                         [(set VR256:$dst, (v8f32 (OpNode VR256:$src)))],
3419                         itins.rr>, VEX, VEX_L, Sched<[itins.Sched]>, VEX_WIG;
3420   def V#NAME#PSYm : PSI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
3421                         !strconcat("v", OpcodeStr,
3422                                    "ps\t{$src, $dst|$dst, $src}"),
3423                         [(set VR256:$dst, (OpNode (loadv8f32 addr:$src)))],
3424                         itins.rm>, VEX, VEX_L, Sched<[itins.Sched.Folded]>, VEX_WIG;
3425 }
3426
3427   def PSr : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3428                 !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
3429                 [(set VR128:$dst, (v4f32 (OpNode VR128:$src)))], itins.rr>,
3430             Sched<[itins.Sched]>;
3431   def PSm : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
3432                 !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
3433                 [(set VR128:$dst, (OpNode (memopv4f32 addr:$src)))], itins.rm>,
3434             Sched<[itins.Sched.Folded]>;
3435 }
3436
3437 /// sse2_fp_unop_p - SSE2 unops in vector forms.
3438 multiclass sse2_fp_unop_p<bits<8> opc, string OpcodeStr,
3439                           SDNode OpNode, OpndItins itins> {
3440 let Predicates = [HasAVX] in {
3441   def V#NAME#PDr : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3442                        !strconcat("v", OpcodeStr,
3443                                   "pd\t{$src, $dst|$dst, $src}"),
3444                        [(set VR128:$dst, (v2f64 (OpNode VR128:$src)))],
3445                        itins.rr>, VEX, Sched<[itins.Sched]>, VEX_WIG;
3446   def V#NAME#PDm : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
3447                        !strconcat("v", OpcodeStr,
3448                                   "pd\t{$src, $dst|$dst, $src}"),
3449                        [(set VR128:$dst, (OpNode (loadv2f64 addr:$src)))],
3450                        itins.rm>, VEX, Sched<[itins.Sched.Folded]>, VEX_WIG;
3451   def V#NAME#PDYr : PDI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3452                         !strconcat("v", OpcodeStr,
3453                                    "pd\t{$src, $dst|$dst, $src}"),
3454                         [(set VR256:$dst, (v4f64 (OpNode VR256:$src)))],
3455                         itins.rr>, VEX, VEX_L, Sched<[itins.Sched]>, VEX_WIG;
3456   def V#NAME#PDYm : PDI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
3457                         !strconcat("v", OpcodeStr,
3458                                    "pd\t{$src, $dst|$dst, $src}"),
3459                         [(set VR256:$dst, (OpNode (loadv4f64 addr:$src)))],
3460                         itins.rm>, VEX, VEX_L, Sched<[itins.Sched.Folded]>, VEX_WIG;
3461 }
3462
3463   def PDr : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3464               !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
3465               [(set VR128:$dst, (v2f64 (OpNode VR128:$src)))], itins.rr>,
3466             Sched<[itins.Sched]>;
3467   def PDm : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
3468                 !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
3469                 [(set VR128:$dst, (OpNode (memopv2f64 addr:$src)))], itins.rm>,
3470             Sched<[itins.Sched.Folded]>;
3471 }
3472
3473 multiclass sse1_fp_unop_s<bits<8> opc, string OpcodeStr, SDNode OpNode,
3474                           OpndItins itins> {
3475   defm SS        :  sse_fp_unop_s<opc, OpcodeStr##ss, FR32, v4f32, f32, f32mem,
3476                       !cast<Intrinsic>("int_x86_sse_"##OpcodeStr##_ss), OpNode,
3477                       SSEPackedSingle, itins, UseSSE1, "SS">, XS;
3478   defm V#NAME#SS  : avx_fp_unop_s<opc, "v"#OpcodeStr##ss, FR32, v4f32, f32,
3479                       f32mem,
3480                       !cast<Intrinsic>("int_x86_sse_"##OpcodeStr##_ss), OpNode,
3481                       SSEPackedSingle, itins, "SS">, XS, VEX_4V, VEX_LIG, VEX_WIG;
3482 }
3483
3484 multiclass sse2_fp_unop_s<bits<8> opc, string OpcodeStr, SDNode OpNode,
3485                           OpndItins itins> {
3486   defm SD         : sse_fp_unop_s<opc, OpcodeStr##sd, FR64, v2f64, f64, f64mem,
3487                          !cast<Intrinsic>("int_x86_sse2_"##OpcodeStr##_sd),
3488                          OpNode, SSEPackedDouble, itins, UseSSE2, "SD">, XD;
3489   defm V#NAME#SD  : avx_fp_unop_s<opc, "v"#OpcodeStr##sd, FR64, v2f64, f64,
3490                          f64mem,
3491                          !cast<Intrinsic>("int_x86_sse2_"##OpcodeStr##_sd),
3492                          OpNode, SSEPackedDouble, itins, "SD">,
3493                          XD, VEX_4V, VEX_LIG, VEX_WIG;
3494 }
3495
3496 // Square root.
3497 defm SQRT  : sse1_fp_unop_s<0x51, "sqrt", fsqrt, SSE_SQRTSS>,
3498              sse1_fp_unop_p<0x51, "sqrt", fsqrt, SSE_SQRTPS, [HasAVX]>,
3499              sse2_fp_unop_s<0x51, "sqrt", fsqrt, SSE_SQRTSD>,
3500              sse2_fp_unop_p<0x51, "sqrt", fsqrt, SSE_SQRTPD>;
3501
3502 // Reciprocal approximations. Note that these typically require refinement
3503 // in order to obtain suitable precision.
3504 defm RSQRT : sse1_fp_unop_s<0x52, "rsqrt", X86frsqrt, SSE_RSQRTSS>,
3505              sse1_fp_unop_p<0x52, "rsqrt", X86frsqrt, SSE_RSQRTPS, [HasAVX, NoVLX] >;
3506 defm RCP   : sse1_fp_unop_s<0x53, "rcp", X86frcp, SSE_RCPS>,
3507              sse1_fp_unop_p<0x53, "rcp", X86frcp, SSE_RCPP, [HasAVX, NoVLX]>;
3508
3509 // There is no f64 version of the reciprocal approximation instructions.
3510
3511 // TODO: We should add *scalar* op patterns for these just like we have for
3512 // the binops above. If the binop and unop patterns could all be unified
3513 // that would be even better.
3514
3515 multiclass scalar_unary_math_patterns<Intrinsic Intr, string OpcPrefix,
3516                                       SDNode Move, ValueType VT,
3517                                       Predicate BasePredicate> {
3518   let Predicates = [BasePredicate] in {
3519     def : Pat<(VT (Move VT:$dst, (Intr VT:$src))),
3520               (!cast<I>(OpcPrefix#r_Int) VT:$dst, VT:$src)>;
3521   }
3522
3523   // With SSE 4.1, blendi is preferred to movs*, so match that too.
3524   let Predicates = [UseSSE41] in {
3525     def : Pat<(VT (X86Blendi VT:$dst, (Intr VT:$src), (i8 1))),
3526               (!cast<I>(OpcPrefix#r_Int) VT:$dst, VT:$src)>;
3527   }
3528
3529   // Repeat for AVX versions of the instructions.
3530   let Predicates = [HasAVX] in {
3531     def : Pat<(VT (Move VT:$dst, (Intr VT:$src))),
3532               (!cast<I>("V"#OpcPrefix#r_Int) VT:$dst, VT:$src)>;
3533
3534     def : Pat<(VT (X86Blendi VT:$dst, (Intr VT:$src), (i8 1))),
3535               (!cast<I>("V"#OpcPrefix#r_Int) VT:$dst, VT:$src)>;
3536   }
3537 }
3538
3539 defm : scalar_unary_math_patterns<int_x86_sse_rcp_ss, "RCPSS", X86Movss,
3540                                   v4f32, UseSSE1>;
3541 defm : scalar_unary_math_patterns<int_x86_sse_rsqrt_ss, "RSQRTSS", X86Movss,
3542                                   v4f32, UseSSE1>;
3543 defm : scalar_unary_math_patterns<int_x86_sse_sqrt_ss, "SQRTSS", X86Movss,
3544                                   v4f32, UseSSE1>;
3545 defm : scalar_unary_math_patterns<int_x86_sse2_sqrt_sd, "SQRTSD", X86Movsd,
3546                                   v2f64, UseSSE2>;
3547
3548
3549 //===----------------------------------------------------------------------===//
3550 // SSE 1 & 2 - Non-temporal stores
3551 //===----------------------------------------------------------------------===//
3552
3553 let AddedComplexity = 400 in { // Prefer non-temporal versions
3554 let SchedRW = [WriteStore] in {
3555 let Predicates = [HasAVX, NoVLX] in {
3556 def VMOVNTPSmr : VPSI<0x2B, MRMDestMem, (outs),
3557                      (ins f128mem:$dst, VR128:$src),
3558                      "movntps\t{$src, $dst|$dst, $src}",
3559                      [(alignednontemporalstore (v4f32 VR128:$src),
3560                                                addr:$dst)],
3561                                                IIC_SSE_MOVNT>, VEX, VEX_WIG;
3562 def VMOVNTPDmr : VPDI<0x2B, MRMDestMem, (outs),
3563                      (ins f128mem:$dst, VR128:$src),
3564                      "movntpd\t{$src, $dst|$dst, $src}",
3565                      [(alignednontemporalstore (v2f64 VR128:$src),
3566                                                addr:$dst)],
3567                                                IIC_SSE_MOVNT>, VEX, VEX_WIG;
3568
3569 let ExeDomain = SSEPackedInt in
3570 def VMOVNTDQmr    : VPDI<0xE7, MRMDestMem, (outs),
3571                          (ins i128mem:$dst, VR128:$src),
3572                          "movntdq\t{$src, $dst|$dst, $src}",
3573                          [(alignednontemporalstore (v2i64 VR128:$src),
3574                                                    addr:$dst)],
3575                                                    IIC_SSE_MOVNT>, VEX, VEX_WIG;
3576
3577 def VMOVNTPSYmr : VPSI<0x2B, MRMDestMem, (outs),
3578                      (ins f256mem:$dst, VR256:$src),
3579                      "movntps\t{$src, $dst|$dst, $src}",
3580                      [(alignednontemporalstore (v8f32 VR256:$src),
3581                                                addr:$dst)],
3582                                                IIC_SSE_MOVNT>, VEX, VEX_L, VEX_WIG;
3583 def VMOVNTPDYmr : VPDI<0x2B, MRMDestMem, (outs),
3584                      (ins f256mem:$dst, VR256:$src),
3585                      "movntpd\t{$src, $dst|$dst, $src}",
3586                      [(alignednontemporalstore (v4f64 VR256:$src),
3587                                                addr:$dst)],
3588                                                IIC_SSE_MOVNT>, VEX, VEX_L, VEX_WIG;
3589 let ExeDomain = SSEPackedInt in
3590 def VMOVNTDQYmr : VPDI<0xE7, MRMDestMem, (outs),
3591                     (ins i256mem:$dst, VR256:$src),
3592                     "movntdq\t{$src, $dst|$dst, $src}",
3593                     [(alignednontemporalstore (v4i64 VR256:$src),
3594                                               addr:$dst)],
3595                                               IIC_SSE_MOVNT>, VEX, VEX_L, VEX_WIG;
3596 }
3597
3598 def MOVNTPSmr : PSI<0x2B, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3599                     "movntps\t{$src, $dst|$dst, $src}",
3600                     [(alignednontemporalstore (v4f32 VR128:$src), addr:$dst)],
3601                     IIC_SSE_MOVNT>;
3602 def MOVNTPDmr : PDI<0x2B, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3603                     "movntpd\t{$src, $dst|$dst, $src}",
3604                     [(alignednontemporalstore(v2f64 VR128:$src), addr:$dst)],
3605                     IIC_SSE_MOVNT>;
3606
3607 let ExeDomain = SSEPackedInt in
3608 def MOVNTDQmr : PDI<0xE7, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3609                     "movntdq\t{$src, $dst|$dst, $src}",
3610                     [(alignednontemporalstore (v2i64 VR128:$src), addr:$dst)],
3611                     IIC_SSE_MOVNT>;
3612
3613 // There is no AVX form for instructions below this point
3614 def MOVNTImr : I<0xC3, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
3615                  "movnti{l}\t{$src, $dst|$dst, $src}",
3616                  [(nontemporalstore (i32 GR32:$src), addr:$dst)],
3617                  IIC_SSE_MOVNT>,
3618                PS, Requires<[HasSSE2]>;
3619 def MOVNTI_64mr : RI<0xC3, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
3620                      "movnti{q}\t{$src, $dst|$dst, $src}",
3621                      [(nontemporalstore (i64 GR64:$src), addr:$dst)],
3622                      IIC_SSE_MOVNT>,
3623                   PS, Requires<[HasSSE2]>;
3624 } // SchedRW = [WriteStore]
3625
3626 let Predicates = [HasAVX, NoVLX] in {
3627   def : Pat<(alignednontemporalstore (v8i32 VR256:$src), addr:$dst),
3628             (VMOVNTDQYmr addr:$dst, VR256:$src)>;
3629   def : Pat<(alignednontemporalstore (v16i16 VR256:$src), addr:$dst),
3630             (VMOVNTDQYmr addr:$dst, VR256:$src)>;
3631   def : Pat<(alignednontemporalstore (v32i8 VR256:$src), addr:$dst),
3632             (VMOVNTDQYmr addr:$dst, VR256:$src)>;
3633
3634   def : Pat<(alignednontemporalstore (v4i32 VR128:$src), addr:$dst),
3635             (VMOVNTDQmr addr:$dst, VR128:$src)>;
3636   def : Pat<(alignednontemporalstore (v8i16 VR128:$src), addr:$dst),
3637             (VMOVNTDQmr addr:$dst, VR128:$src)>;
3638   def : Pat<(alignednontemporalstore (v16i8 VR128:$src), addr:$dst),
3639             (VMOVNTDQmr addr:$dst, VR128:$src)>;
3640 }
3641
3642 let Predicates = [UseSSE2] in {
3643   def : Pat<(alignednontemporalstore (v4i32 VR128:$src), addr:$dst),
3644             (MOVNTDQmr addr:$dst, VR128:$src)>;
3645   def : Pat<(alignednontemporalstore (v8i16 VR128:$src), addr:$dst),
3646             (MOVNTDQmr addr:$dst, VR128:$src)>;
3647   def : Pat<(alignednontemporalstore (v16i8 VR128:$src), addr:$dst),
3648             (MOVNTDQmr addr:$dst, VR128:$src)>;
3649 }
3650
3651 } // AddedComplexity
3652
3653 //===----------------------------------------------------------------------===//
3654 // SSE 1 & 2 - Prefetch and memory fence
3655 //===----------------------------------------------------------------------===//
3656
3657 // Prefetch intrinsic.
3658 let Predicates = [HasSSE1], SchedRW = [WriteLoad] in {
3659 def PREFETCHT0   : I<0x18, MRM1m, (outs), (ins i8mem:$src),
3660     "prefetcht0\t$src", [(prefetch addr:$src, imm, (i32 3), (i32 1))],
3661     IIC_SSE_PREFETCH>, TB;
3662 def PREFETCHT1   : I<0x18, MRM2m, (outs), (ins i8mem:$src),
3663     "prefetcht1\t$src", [(prefetch addr:$src, imm, (i32 2), (i32 1))],
3664     IIC_SSE_PREFETCH>, TB;
3665 def PREFETCHT2   : I<0x18, MRM3m, (outs), (ins i8mem:$src),
3666     "prefetcht2\t$src", [(prefetch addr:$src, imm, (i32 1), (i32 1))],
3667     IIC_SSE_PREFETCH>, TB;
3668 def PREFETCHNTA  : I<0x18, MRM0m, (outs), (ins i8mem:$src),
3669     "prefetchnta\t$src", [(prefetch addr:$src, imm, (i32 0), (i32 1))],
3670     IIC_SSE_PREFETCH>, TB;
3671 }
3672
3673 // FIXME: How should flush instruction be modeled?
3674 let SchedRW = [WriteLoad] in {
3675 // Flush cache
3676 def CLFLUSH : I<0xAE, MRM7m, (outs), (ins i8mem:$src),
3677                "clflush\t$src", [(int_x86_sse2_clflush addr:$src)],
3678                IIC_SSE_PREFETCH>, PS, Requires<[HasSSE2]>;
3679 }
3680
3681 let SchedRW = [WriteNop] in {
3682 // Pause. This "instruction" is encoded as "rep; nop", so even though it
3683 // was introduced with SSE2, it's backward compatible.
3684 def PAUSE : I<0x90, RawFrm, (outs), (ins),
3685               "pause", [(int_x86_sse2_pause)], IIC_SSE_PAUSE>,
3686               OBXS, Requires<[HasSSE2]>;
3687 }
3688
3689 let SchedRW = [WriteFence] in {
3690 // Load, store, and memory fence
3691 // TODO: As with mfence, we may want to ease the availablity of sfence/lfence
3692 // to include any 64-bit target.
3693 def SFENCE : I<0xAE, MRM_F8, (outs), (ins),
3694                "sfence", [(int_x86_sse_sfence)], IIC_SSE_SFENCE>,
3695                PS, Requires<[HasSSE1]>;
3696 def LFENCE : I<0xAE, MRM_E8, (outs), (ins),
3697                "lfence", [(int_x86_sse2_lfence)], IIC_SSE_LFENCE>,
3698                TB, Requires<[HasSSE2]>;
3699 def MFENCE : I<0xAE, MRM_F0, (outs), (ins),
3700                "mfence", [(int_x86_sse2_mfence)], IIC_SSE_MFENCE>,
3701                TB, Requires<[HasMFence]>;
3702 } // SchedRW
3703
3704 def : Pat<(X86MFence), (MFENCE)>;
3705
3706 //===----------------------------------------------------------------------===//
3707 // SSE 1 & 2 - Load/Store XCSR register
3708 //===----------------------------------------------------------------------===//
3709
3710 def VLDMXCSR : VPSI<0xAE, MRM2m, (outs), (ins i32mem:$src),
3711                "ldmxcsr\t$src", [(int_x86_sse_ldmxcsr addr:$src)],
3712                IIC_SSE_LDMXCSR>, VEX, Sched<[WriteLoad]>, VEX_WIG;
3713 def VSTMXCSR : VPSI<0xAE, MRM3m, (outs), (ins i32mem:$dst),
3714                "stmxcsr\t$dst", [(int_x86_sse_stmxcsr addr:$dst)],
3715                IIC_SSE_STMXCSR>, VEX, Sched<[WriteStore]>, VEX_WIG;
3716
3717 def LDMXCSR : I<0xAE, MRM2m, (outs), (ins i32mem:$src),
3718               "ldmxcsr\t$src", [(int_x86_sse_ldmxcsr addr:$src)],
3719               IIC_SSE_LDMXCSR>, TB, Sched<[WriteLoad]>;
3720 def STMXCSR : I<0xAE, MRM3m, (outs), (ins i32mem:$dst),
3721               "stmxcsr\t$dst", [(int_x86_sse_stmxcsr addr:$dst)],
3722               IIC_SSE_STMXCSR>, TB, Sched<[WriteStore]>;
3723
3724 //===---------------------------------------------------------------------===//
3725 // SSE2 - Move Aligned/Unaligned Packed Integer Instructions
3726 //===---------------------------------------------------------------------===//
3727
3728 let ExeDomain = SSEPackedInt in { // SSE integer instructions
3729
3730 let hasSideEffects = 0, SchedRW = [WriteMove] in {
3731 def VMOVDQArr  : VPDI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3732                     "movdqa\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVA_P_RR>,
3733                     VEX, VEX_WIG;
3734 def VMOVDQAYrr : VPDI<0x6F, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3735                     "movdqa\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVA_P_RR>,
3736                     VEX, VEX_L, VEX_WIG;
3737 def VMOVDQUrr  : VSSI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3738                     "movdqu\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVU_P_RR>,
3739                     VEX, VEX_WIG;
3740 def VMOVDQUYrr : VSSI<0x6F, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3741                     "movdqu\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVU_P_RR>,
3742                     VEX, VEX_L, VEX_WIG;
3743 }
3744
3745 // For Disassembler
3746 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
3747     SchedRW = [WriteMove] in {
3748 def VMOVDQArr_REV  : VPDI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3749                         "movdqa\t{$src, $dst|$dst, $src}", [],
3750                         IIC_SSE_MOVA_P_RR>,
3751                         VEX, VEX_WIG;
3752 def VMOVDQAYrr_REV : VPDI<0x7F, MRMDestReg, (outs VR256:$dst), (ins VR256:$src),
3753                         "movdqa\t{$src, $dst|$dst, $src}", [],
3754                         IIC_SSE_MOVA_P_RR>, VEX, VEX_L, VEX_WIG;
3755 def VMOVDQUrr_REV  : VSSI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3756                         "movdqu\t{$src, $dst|$dst, $src}", [],
3757                         IIC_SSE_MOVU_P_RR>,
3758                         VEX, VEX_WIG;
3759 def VMOVDQUYrr_REV : VSSI<0x7F, MRMDestReg, (outs VR256:$dst), (ins VR256:$src),
3760                         "movdqu\t{$src, $dst|$dst, $src}", [],
3761                         IIC_SSE_MOVU_P_RR>, VEX, VEX_L, VEX_WIG;
3762 }
3763
3764 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1,
3765     hasSideEffects = 0, SchedRW = [WriteLoad] in {
3766 let Predicates = [HasAVX,NoVLX] in
3767 def VMOVDQArm  : VPDI<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3768                    "movdqa\t{$src, $dst|$dst, $src}",
3769                    [(set VR128:$dst, (alignedloadv2i64 addr:$src))],
3770                    IIC_SSE_MOVA_P_RM>, VEX, VEX_WIG;
3771 def VMOVDQAYrm : VPDI<0x6F, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
3772                    "movdqa\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVA_P_RM>,
3773                    VEX, VEX_L, VEX_WIG;
3774 let Predicates = [HasAVX,NoVLX] in
3775 def VMOVDQUrm  : I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3776                   "vmovdqu\t{$src, $dst|$dst, $src}",
3777                   [(set VR128:$dst, (loadv2i64 addr:$src))],
3778                   IIC_SSE_MOVU_P_RM>, XS, VEX, VEX_WIG;
3779 def VMOVDQUYrm : I<0x6F, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
3780                   "vmovdqu\t{$src, $dst|$dst, $src}",[], IIC_SSE_MOVU_P_RM>,
3781                   XS, VEX, VEX_L, VEX_WIG;
3782 }
3783
3784 let mayStore = 1, hasSideEffects = 0, SchedRW = [WriteStore] in {
3785 let Predicates = [HasAVX,NoVLX] in
3786 def VMOVDQAmr  : VPDI<0x7F, MRMDestMem, (outs),
3787                      (ins i128mem:$dst, VR128:$src),
3788                      "movdqa\t{$src, $dst|$dst, $src}",
3789                      [(alignedstore (v2i64 VR128:$src), addr:$dst)],
3790                      IIC_SSE_MOVA_P_MR>, VEX, VEX_WIG;
3791 def VMOVDQAYmr : VPDI<0x7F, MRMDestMem, (outs),
3792                      (ins i256mem:$dst, VR256:$src),
3793                      "movdqa\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVA_P_MR>,
3794                      VEX, VEX_L, VEX_WIG;
3795 let Predicates = [HasAVX,NoVLX] in
3796 def VMOVDQUmr  : I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3797                   "vmovdqu\t{$src, $dst|$dst, $src}",
3798                   [(store (v2i64 VR128:$src), addr:$dst)], IIC_SSE_MOVU_P_MR>,
3799                   XS, VEX, VEX_WIG;
3800 def VMOVDQUYmr : I<0x7F, MRMDestMem, (outs), (ins i256mem:$dst, VR256:$src),
3801                   "vmovdqu\t{$src, $dst|$dst, $src}",[], IIC_SSE_MOVU_P_MR>,
3802                   XS, VEX, VEX_L, VEX_WIG;
3803 }
3804
3805 let SchedRW = [WriteMove] in {
3806 let hasSideEffects = 0 in {
3807 def MOVDQArr : PDI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3808                    "movdqa\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVA_P_RR>;
3809
3810 def MOVDQUrr :   I<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3811                    "movdqu\t{$src, $dst|$dst, $src}",
3812                    [], IIC_SSE_MOVU_P_RR>, XS, Requires<[UseSSE2]>;
3813 }
3814
3815 // For Disassembler
3816 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0 in {
3817 def MOVDQArr_REV : PDI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3818                        "movdqa\t{$src, $dst|$dst, $src}", [],
3819                        IIC_SSE_MOVA_P_RR>;
3820
3821 def MOVDQUrr_REV :   I<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3822                        "movdqu\t{$src, $dst|$dst, $src}",
3823                        [], IIC_SSE_MOVU_P_RR>, XS, Requires<[UseSSE2]>;
3824 }
3825 } // SchedRW
3826
3827 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1,
3828     hasSideEffects = 0, SchedRW = [WriteLoad] in {
3829 def MOVDQArm : PDI<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3830                    "movdqa\t{$src, $dst|$dst, $src}",
3831                    [/*(set VR128:$dst, (alignedloadv2i64 addr:$src))*/],
3832                    IIC_SSE_MOVA_P_RM>;
3833 def MOVDQUrm :   I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3834                    "movdqu\t{$src, $dst|$dst, $src}",
3835                    [/*(set VR128:$dst, (loadv2i64 addr:$src))*/],
3836                    IIC_SSE_MOVU_P_RM>,
3837                  XS, Requires<[UseSSE2]>;
3838 }
3839
3840 let mayStore = 1, hasSideEffects = 0, SchedRW = [WriteStore] in {
3841 def MOVDQAmr : PDI<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3842                    "movdqa\t{$src, $dst|$dst, $src}",
3843                    [/*(alignedstore (v2i64 VR128:$src), addr:$dst)*/],
3844                    IIC_SSE_MOVA_P_MR>;
3845 def MOVDQUmr :   I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3846                    "movdqu\t{$src, $dst|$dst, $src}",
3847                    [/*(store (v2i64 VR128:$src), addr:$dst)*/],
3848                    IIC_SSE_MOVU_P_MR>,
3849                  XS, Requires<[UseSSE2]>;
3850 }
3851
3852 } // ExeDomain = SSEPackedInt
3853
3854 // Aliases to help the assembler pick two byte VEX encodings by swapping the
3855 // operands relative to the normal instructions to use VEX.R instead of VEX.B.
3856 def : InstAlias<"vmovdqa\t{$src, $dst|$dst, $src}",
3857                 (VMOVDQArr_REV VR128L:$dst, VR128H:$src), 0>;
3858 def : InstAlias<"vmovdqa\t{$src, $dst|$dst, $src}",
3859                 (VMOVDQAYrr_REV VR256L:$dst, VR256H:$src), 0>;
3860 def : InstAlias<"vmovdqu\t{$src, $dst|$dst, $src}",
3861                 (VMOVDQUrr_REV VR128L:$dst, VR128H:$src), 0>;
3862 def : InstAlias<"vmovdqu\t{$src, $dst|$dst, $src}",
3863                 (VMOVDQUYrr_REV VR256L:$dst, VR256H:$src), 0>;
3864
3865 let Predicates = [HasAVX, NoVLX] in {
3866   // Additional patterns for other integer sizes.
3867   def : Pat<(alignedstore (v4i32 VR128:$src), addr:$dst),
3868             (VMOVDQAmr addr:$dst, VR128:$src)>;
3869   def : Pat<(alignedstore (v8i16 VR128:$src), addr:$dst),
3870             (VMOVDQAmr addr:$dst, VR128:$src)>;
3871   def : Pat<(alignedstore (v16i8 VR128:$src), addr:$dst),
3872             (VMOVDQAmr addr:$dst, VR128:$src)>;
3873   def : Pat<(store (v4i32 VR128:$src), addr:$dst),
3874             (VMOVDQUmr addr:$dst, VR128:$src)>;
3875   def : Pat<(store (v8i16 VR128:$src), addr:$dst),
3876             (VMOVDQUmr addr:$dst, VR128:$src)>;
3877   def : Pat<(store (v16i8 VR128:$src), addr:$dst),
3878             (VMOVDQUmr addr:$dst, VR128:$src)>;
3879
3880   // Special patterns for storing subvector extracts of lower 128-bits
3881   // Its cheaper to just use VMOVDQA/VMOVDQU instead of VEXTRACTF128mr
3882   def : Pat<(alignedstore (v2i64 (extract_subvector
3883                                   (v4i64 VR256:$src), (iPTR 0))), addr:$dst),
3884             (VMOVDQAmr addr:$dst, (v2i64 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3885   def : Pat<(alignedstore (v4i32 (extract_subvector
3886                                   (v8i32 VR256:$src), (iPTR 0))), addr:$dst),
3887             (VMOVDQAmr addr:$dst, (v4i32 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3888   def : Pat<(alignedstore (v8i16 (extract_subvector
3889                                   (v16i16 VR256:$src), (iPTR 0))), addr:$dst),
3890             (VMOVDQAmr addr:$dst, (v8i16 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3891   def : Pat<(alignedstore (v16i8 (extract_subvector
3892                                   (v32i8 VR256:$src), (iPTR 0))), addr:$dst),
3893             (VMOVDQAmr addr:$dst, (v16i8 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3894
3895   def : Pat<(store (v2i64 (extract_subvector
3896                            (v4i64 VR256:$src), (iPTR 0))), addr:$dst),
3897             (VMOVDQUmr addr:$dst, (v2i64 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3898   def : Pat<(store (v4i32 (extract_subvector
3899                            (v8i32 VR256:$src), (iPTR 0))), addr:$dst),
3900             (VMOVDQUmr addr:$dst, (v4i32 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3901   def : Pat<(store (v8i16 (extract_subvector
3902                            (v16i16 VR256:$src), (iPTR 0))), addr:$dst),
3903             (VMOVDQUmr addr:$dst, (v8i16 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3904   def : Pat<(store (v16i8 (extract_subvector
3905                            (v32i8 VR256:$src), (iPTR 0))), addr:$dst),
3906             (VMOVDQUmr addr:$dst, (v16i8 (EXTRACT_SUBREG VR256:$src,sub_xmm)))>;
3907 }
3908
3909 //===---------------------------------------------------------------------===//
3910 // SSE2 - Packed Integer Arithmetic Instructions
3911 //===---------------------------------------------------------------------===//
3912
3913 let Sched = WriteVecIMul in
3914 def SSE_PMADD : OpndItins<
3915   IIC_SSE_PMADD, IIC_SSE_PMADD
3916 >;
3917
3918 let ExeDomain = SSEPackedInt in { // SSE integer instructions
3919
3920 /// PDI_binop_rm2 - Simple SSE2 binary operator with different src and dst types
3921 multiclass PDI_binop_rm2<bits<8> opc, string OpcodeStr, SDNode OpNode,
3922                          ValueType DstVT, ValueType SrcVT, RegisterClass RC,
3923                          PatFrag memop_frag, X86MemOperand x86memop,
3924                          OpndItins itins, bit Is2Addr = 1> {
3925   let isCommutable = 1 in
3926   def rr : PDI<opc, MRMSrcReg, (outs RC:$dst),
3927        (ins RC:$src1, RC:$src2),
3928        !if(Is2Addr,
3929            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3930            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3931        [(set RC:$dst, (DstVT (OpNode (SrcVT RC:$src1), RC:$src2)))]>,
3932        Sched<[itins.Sched]>;
3933   def rm : PDI<opc, MRMSrcMem, (outs RC:$dst),
3934        (ins RC:$src1, x86memop:$src2),
3935        !if(Is2Addr,
3936            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3937            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3938        [(set RC:$dst, (DstVT (OpNode (SrcVT RC:$src1),
3939                                      (bitconvert (memop_frag addr:$src2)))))]>,
3940        Sched<[itins.Sched.Folded, ReadAfterLd]>;
3941 }
3942 } // ExeDomain = SSEPackedInt
3943
3944 defm PADDB   : PDI_binop_all<0xFC, "paddb", add, v16i8, v32i8,
3945                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3946 defm PADDW   : PDI_binop_all<0xFD, "paddw", add, v8i16, v16i16,
3947                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3948 defm PADDD   : PDI_binop_all<0xFE, "paddd", add, v4i32, v8i32,
3949                              SSE_INTALU_ITINS_P, 1, NoVLX>;
3950 defm PADDQ   : PDI_binop_all<0xD4, "paddq", add, v2i64, v4i64,
3951                              SSE_INTALUQ_ITINS_P, 1, NoVLX>;
3952 defm PADDSB  : PDI_binop_all<0xEC, "paddsb", X86adds, v16i8, v32i8,
3953                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3954 defm PADDSW  : PDI_binop_all<0xED, "paddsw", X86adds, v8i16, v16i16,
3955                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3956 defm PADDUSB : PDI_binop_all<0xDC, "paddusb", X86addus, v16i8, v32i8,
3957                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3958 defm PADDUSW : PDI_binop_all<0xDD, "paddusw", X86addus, v8i16, v16i16,
3959                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3960 defm PMULLW  : PDI_binop_all<0xD5, "pmullw", mul, v8i16, v16i16,
3961                              SSE_INTMUL_ITINS_P, 1, NoVLX_Or_NoBWI>;
3962 defm PMULHUW : PDI_binop_all<0xE4, "pmulhuw", mulhu, v8i16, v16i16,
3963                              SSE_INTMUL_ITINS_P, 1, NoVLX_Or_NoBWI>;
3964 defm PMULHW  : PDI_binop_all<0xE5, "pmulhw", mulhs, v8i16, v16i16,
3965                              SSE_INTMUL_ITINS_P, 1, NoVLX_Or_NoBWI>;
3966 defm PSUBB   : PDI_binop_all<0xF8, "psubb", sub, v16i8, v32i8,
3967                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3968 defm PSUBW   : PDI_binop_all<0xF9, "psubw", sub, v8i16, v16i16,
3969                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3970 defm PSUBD   : PDI_binop_all<0xFA, "psubd", sub, v4i32, v8i32,
3971                              SSE_INTALU_ITINS_P, 0, NoVLX>;
3972 defm PSUBQ   : PDI_binop_all<0xFB, "psubq", sub, v2i64, v4i64,
3973                              SSE_INTALUQ_ITINS_P, 0, NoVLX>;
3974 defm PSUBSB  : PDI_binop_all<0xE8, "psubsb", X86subs, v16i8, v32i8,
3975                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3976 defm PSUBSW  : PDI_binop_all<0xE9, "psubsw", X86subs, v8i16, v16i16,
3977                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3978 defm PSUBUSB : PDI_binop_all<0xD8, "psubusb", X86subus, v16i8, v32i8,
3979                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3980 defm PSUBUSW : PDI_binop_all<0xD9, "psubusw", X86subus, v8i16, v16i16,
3981                              SSE_INTALU_ITINS_P, 0, NoVLX_Or_NoBWI>;
3982 defm PMINUB  : PDI_binop_all<0xDA, "pminub", umin, v16i8, v32i8,
3983                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3984 defm PMINSW  : PDI_binop_all<0xEA, "pminsw", smin, v8i16, v16i16,
3985                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3986 defm PMAXUB  : PDI_binop_all<0xDE, "pmaxub", umax, v16i8, v32i8,
3987                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3988 defm PMAXSW  : PDI_binop_all<0xEE, "pmaxsw", smax, v8i16, v16i16,
3989                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3990 defm PAVGB   : PDI_binop_all<0xE0, "pavgb", X86avg, v16i8, v32i8,
3991                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3992 defm PAVGW   : PDI_binop_all<0xE3, "pavgw", X86avg, v8i16, v16i16,
3993                              SSE_INTALU_ITINS_P, 1, NoVLX_Or_NoBWI>;
3994
3995 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in
3996 defm VPMADDWD : PDI_binop_rm2<0xF5, "vpmaddwd", X86vpmaddwd, v4i32, v8i16, VR128,
3997                               loadv2i64, i128mem, SSE_PMADD, 0>, VEX_4V, VEX_WIG;
3998
3999 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in
4000 defm VPMADDWDY : PDI_binop_rm2<0xF5, "vpmaddwd", X86vpmaddwd, v8i32, v16i16,
4001                                VR256, loadv4i64, i256mem, SSE_PMADD,
4002                                0>, VEX_4V, VEX_L, VEX_WIG;
4003 let Constraints = "$src1 = $dst" in
4004 defm PMADDWD : PDI_binop_rm2<0xF5, "pmaddwd", X86vpmaddwd, v4i32, v8i16, VR128,
4005                              memopv2i64, i128mem, SSE_PMADD>;
4006
4007 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in
4008 defm VPSADBW : PDI_binop_rm2<0xF6, "vpsadbw", X86psadbw, v2i64, v16i8, VR128,
4009                              loadv2i64, i128mem, SSE_INTMUL_ITINS_P, 0>,
4010                              VEX_4V, VEX_WIG;
4011 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in
4012 defm VPSADBWY : PDI_binop_rm2<0xF6, "vpsadbw", X86psadbw, v4i64, v32i8, VR256,
4013                              loadv4i64, i256mem, SSE_INTMUL_ITINS_P, 0>,
4014                              VEX_4V, VEX_L, VEX_WIG;
4015 let Constraints = "$src1 = $dst" in
4016 defm PSADBW : PDI_binop_rm2<0xF6, "psadbw", X86psadbw, v2i64, v16i8, VR128,
4017                             memopv2i64, i128mem, SSE_INTALU_ITINS_P>;
4018
4019 let Predicates = [HasAVX, NoVLX] in
4020 defm VPMULUDQ : PDI_binop_rm2<0xF4, "vpmuludq", X86pmuludq, v2i64, v4i32, VR128,
4021                               loadv2i64, i128mem, SSE_INTMUL_ITINS_P, 0>,
4022                               VEX_4V, VEX_WIG;
4023 let Predicates = [HasAVX2, NoVLX] in
4024 defm VPMULUDQY : PDI_binop_rm2<0xF4, "vpmuludq", X86pmuludq, v4i64, v8i32,
4025                                VR256, loadv4i64, i256mem,
4026                                SSE_INTMUL_ITINS_P, 0>, VEX_4V, VEX_L, VEX_WIG;
4027 let Constraints = "$src1 = $dst" in
4028 defm PMULUDQ : PDI_binop_rm2<0xF4, "pmuludq", X86pmuludq, v2i64, v4i32, VR128,
4029                              memopv2i64, i128mem, SSE_INTMUL_ITINS_P>;
4030
4031 //===---------------------------------------------------------------------===//
4032 // SSE2 - Packed Integer Logical Instructions
4033 //===---------------------------------------------------------------------===//
4034
4035 multiclass PDI_binop_rmi<bits<8> opc, bits<8> opc2, Format ImmForm,
4036                          string OpcodeStr, SDNode OpNode,
4037                          SDNode OpNode2, RegisterClass RC,
4038                          ValueType DstVT, ValueType SrcVT,
4039                          PatFrag ld_frag, bit Is2Addr = 1> {
4040   // src2 is always 128-bit
4041   def rr : PDI<opc, MRMSrcReg, (outs RC:$dst),
4042        (ins RC:$src1, VR128:$src2),
4043        !if(Is2Addr,
4044            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4045            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4046        [(set RC:$dst, (DstVT (OpNode RC:$src1, (SrcVT VR128:$src2))))],
4047        SSE_INTSHIFT_ITINS_P.rr>, Sched<[WriteVecShift]>;
4048   def rm : PDI<opc, MRMSrcMem, (outs RC:$dst),
4049        (ins RC:$src1, i128mem:$src2),
4050        !if(Is2Addr,
4051            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4052            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4053        [(set RC:$dst, (DstVT (OpNode RC:$src1,
4054                        (SrcVT (bitconvert (ld_frag addr:$src2))))))],
4055        SSE_INTSHIFT_ITINS_P.rm>, Sched<[WriteVecShiftLd, ReadAfterLd]>;
4056   def ri : PDIi8<opc2, ImmForm, (outs RC:$dst),
4057        (ins RC:$src1, u8imm:$src2),
4058        !if(Is2Addr,
4059            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4060            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4061        [(set RC:$dst, (DstVT (OpNode2 RC:$src1, (i8 imm:$src2))))],
4062        SSE_INTSHIFT_ITINS_P.ri>, Sched<[WriteVecShift]>;
4063 }
4064
4065 multiclass PDI_binop_rmi_all<bits<8> opc, bits<8> opc2, Format ImmForm,
4066                              string OpcodeStr, SDNode OpNode,
4067                              SDNode OpNode2, ValueType DstVT128,
4068                              ValueType DstVT256, ValueType SrcVT,
4069                              Predicate prd> {
4070 let Predicates = [HasAVX, prd] in
4071   defm V#NAME : PDI_binop_rmi<opc, opc2, ImmForm, !strconcat("v", OpcodeStr),
4072                               OpNode, OpNode2, VR128, DstVT128, SrcVT,
4073                               loadv2i64, 0>, VEX_4V, VEX_WIG;
4074 let Predicates = [HasAVX2, prd] in
4075   defm V#NAME#Y : PDI_binop_rmi<opc, opc2, ImmForm, !strconcat("v", OpcodeStr),
4076                                 OpNode, OpNode2, VR256, DstVT256, SrcVT,
4077                                 loadv2i64, 0>, VEX_4V, VEX_L, VEX_WIG;
4078 let Constraints = "$src1 = $dst" in
4079   defm NAME : PDI_binop_rmi<opc, opc2, ImmForm, OpcodeStr, OpNode, OpNode2,
4080                            VR128, DstVT128, SrcVT, memopv2i64>;
4081 }
4082
4083 multiclass PDI_binop_ri<bits<8> opc, Format ImmForm, string OpcodeStr,
4084                         SDNode OpNode, RegisterClass RC, ValueType VT,
4085                         bit Is2Addr = 1> {
4086   def ri : PDIi8<opc, ImmForm, (outs RC:$dst), (ins RC:$src1, u8imm:$src2),
4087        !if(Is2Addr,
4088            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4089            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4090        [(set RC:$dst, (VT (OpNode RC:$src1, (i8 imm:$src2))))],
4091        IIC_SSE_INTSHDQ_P_RI>, Sched<[WriteVecShift]>;
4092 }
4093
4094 multiclass PDI_binop_ri_all<bits<8> opc, Format ImmForm, string OpcodeStr,
4095                            SDNode OpNode> {
4096 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in
4097   defm V#NAME : PDI_binop_ri<opc, ImmForm, !strconcat("v", OpcodeStr), OpNode,
4098                              VR128, v16i8, 0>, VEX_4V, VEX_WIG;
4099 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in
4100   defm V#NAME#Y : PDI_binop_ri<opc, ImmForm, !strconcat("v", OpcodeStr), OpNode,
4101                                VR256, v32i8, 0>, VEX_4V, VEX_L, VEX_WIG;
4102 let Constraints = "$src1 = $dst" in
4103   defm NAME : PDI_binop_ri<opc, ImmForm, OpcodeStr, OpNode, VR128, v16i8>;
4104 }
4105
4106 let ExeDomain = SSEPackedInt in {
4107   defm PSLLW : PDI_binop_rmi_all<0xF1, 0x71, MRM6r, "psllw", X86vshl, X86vshli,
4108                                  v8i16, v16i16, v8i16, NoVLX_Or_NoBWI>;
4109   defm PSLLD : PDI_binop_rmi_all<0xF2, 0x72, MRM6r, "pslld", X86vshl, X86vshli,
4110                                  v4i32, v8i32, v4i32, NoVLX>;
4111   defm PSLLQ : PDI_binop_rmi_all<0xF3, 0x73, MRM6r, "psllq", X86vshl, X86vshli,
4112                                  v2i64, v4i64, v2i64, NoVLX>;
4113
4114   defm PSRLW : PDI_binop_rmi_all<0xD1, 0x71, MRM2r, "psrlw", X86vsrl, X86vsrli,
4115                                  v8i16, v16i16, v8i16, NoVLX_Or_NoBWI>;
4116   defm PSRLD : PDI_binop_rmi_all<0xD2, 0x72, MRM2r, "psrld", X86vsrl, X86vsrli,
4117                                  v4i32, v8i32, v4i32, NoVLX>;
4118   defm PSRLQ : PDI_binop_rmi_all<0xD3, 0x73, MRM2r, "psrlq", X86vsrl, X86vsrli,
4119                                  v2i64, v4i64, v2i64, NoVLX>;
4120
4121   defm PSRAW : PDI_binop_rmi_all<0xE1, 0x71, MRM4r, "psraw", X86vsra, X86vsrai,
4122                                  v8i16, v16i16, v8i16, NoVLX_Or_NoBWI>;
4123   defm PSRAD : PDI_binop_rmi_all<0xE2, 0x72, MRM4r, "psrad", X86vsra, X86vsrai,
4124                                  v4i32, v8i32, v4i32, NoVLX>;
4125
4126   defm PSLLDQ : PDI_binop_ri_all<0x73, MRM7r, "pslldq", X86vshldq>;
4127   defm PSRLDQ : PDI_binop_ri_all<0x73, MRM3r, "psrldq", X86vshrdq>;
4128   // PSRADQri doesn't exist in SSE[1-3].
4129 } // ExeDomain = SSEPackedInt
4130
4131 //===---------------------------------------------------------------------===//
4132 // SSE2 - Packed Integer Comparison Instructions
4133 //===---------------------------------------------------------------------===//
4134
4135 defm PCMPEQB : PDI_binop_all<0x74, "pcmpeqb", X86pcmpeq, v16i8, v32i8,
4136                              SSE_INTALU_ITINS_P, 1, TruePredicate>;
4137 defm PCMPEQW : PDI_binop_all<0x75, "pcmpeqw", X86pcmpeq, v8i16, v16i16,
4138                              SSE_INTALU_ITINS_P, 1, TruePredicate>;
4139 defm PCMPEQD : PDI_binop_all<0x76, "pcmpeqd", X86pcmpeq, v4i32, v8i32,
4140                              SSE_INTALU_ITINS_P, 1, TruePredicate>;
4141 defm PCMPGTB : PDI_binop_all<0x64, "pcmpgtb", X86pcmpgt, v16i8, v32i8,
4142                              SSE_INTALU_ITINS_P, 0, TruePredicate>;
4143 defm PCMPGTW : PDI_binop_all<0x65, "pcmpgtw", X86pcmpgt, v8i16, v16i16,
4144                              SSE_INTALU_ITINS_P, 0, TruePredicate>;
4145 defm PCMPGTD : PDI_binop_all<0x66, "pcmpgtd", X86pcmpgt, v4i32, v8i32,
4146                              SSE_INTALU_ITINS_P, 0, TruePredicate>;
4147
4148 //===---------------------------------------------------------------------===//
4149 // SSE2 - Packed Integer Shuffle Instructions
4150 //===---------------------------------------------------------------------===//
4151
4152 let ExeDomain = SSEPackedInt in {
4153 multiclass sse2_pshuffle<string OpcodeStr, ValueType vt128, ValueType vt256,
4154                          SDNode OpNode, Predicate prd> {
4155 let Predicates = [HasAVX, prd] in {
4156   def V#NAME#ri : Ii8<0x70, MRMSrcReg, (outs VR128:$dst),
4157                       (ins VR128:$src1, u8imm:$src2),
4158                       !strconcat("v", OpcodeStr,
4159                                  "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4160                       [(set VR128:$dst,
4161                         (vt128 (OpNode VR128:$src1, (i8 imm:$src2))))],
4162                       IIC_SSE_PSHUF_RI>, VEX, Sched<[WriteShuffle]>, VEX_WIG;
4163   def V#NAME#mi : Ii8<0x70, MRMSrcMem, (outs VR128:$dst),
4164                       (ins i128mem:$src1, u8imm:$src2),
4165                       !strconcat("v", OpcodeStr,
4166                                  "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4167                      [(set VR128:$dst,
4168                        (vt128 (OpNode (bitconvert (loadv2i64 addr:$src1)),
4169                         (i8 imm:$src2))))], IIC_SSE_PSHUF_MI>, VEX,
4170                   Sched<[WriteShuffleLd]>, VEX_WIG;
4171 }
4172
4173 let Predicates = [HasAVX2, prd] in {
4174   def V#NAME#Yri : Ii8<0x70, MRMSrcReg, (outs VR256:$dst),
4175                        (ins VR256:$src1, u8imm:$src2),
4176                        !strconcat("v", OpcodeStr,
4177                                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4178                        [(set VR256:$dst,
4179                          (vt256 (OpNode VR256:$src1, (i8 imm:$src2))))],
4180                        IIC_SSE_PSHUF_RI>, VEX, VEX_L, Sched<[WriteShuffle]>, VEX_WIG;
4181   def V#NAME#Ymi : Ii8<0x70, MRMSrcMem, (outs VR256:$dst),
4182                        (ins i256mem:$src1, u8imm:$src2),
4183                        !strconcat("v", OpcodeStr,
4184                                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4185                       [(set VR256:$dst,
4186                         (vt256 (OpNode (bitconvert (loadv4i64 addr:$src1)),
4187                          (i8 imm:$src2))))], IIC_SSE_PSHUF_MI>, VEX, VEX_L,
4188                    Sched<[WriteShuffleLd]>, VEX_WIG;
4189 }
4190
4191 let Predicates = [UseSSE2] in {
4192   def ri : Ii8<0x70, MRMSrcReg,
4193                (outs VR128:$dst), (ins VR128:$src1, u8imm:$src2),
4194                !strconcat(OpcodeStr,
4195                           "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4196                 [(set VR128:$dst,
4197                   (vt128 (OpNode VR128:$src1, (i8 imm:$src2))))],
4198                 IIC_SSE_PSHUF_RI>, Sched<[WriteShuffle]>;
4199   def mi : Ii8<0x70, MRMSrcMem,
4200                (outs VR128:$dst), (ins i128mem:$src1, u8imm:$src2),
4201                !strconcat(OpcodeStr,
4202                           "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4203                 [(set VR128:$dst,
4204                   (vt128 (OpNode (bitconvert (memopv2i64 addr:$src1)),
4205                           (i8 imm:$src2))))], IIC_SSE_PSHUF_MI>,
4206            Sched<[WriteShuffleLd, ReadAfterLd]>;
4207 }
4208 }
4209 } // ExeDomain = SSEPackedInt
4210
4211 defm PSHUFD  : sse2_pshuffle<"pshufd", v4i32, v8i32, X86PShufd, NoVLX>, PD;
4212 defm PSHUFHW : sse2_pshuffle<"pshufhw", v8i16, v16i16, X86PShufhw,
4213                              NoVLX_Or_NoBWI>, XS;
4214 defm PSHUFLW : sse2_pshuffle<"pshuflw", v8i16, v16i16, X86PShuflw,
4215                              NoVLX_Or_NoBWI>, XD;
4216
4217 //===---------------------------------------------------------------------===//
4218 // Packed Integer Pack Instructions (SSE & AVX)
4219 //===---------------------------------------------------------------------===//
4220
4221 let ExeDomain = SSEPackedInt in {
4222 multiclass sse2_pack<bits<8> opc, string OpcodeStr, ValueType OutVT,
4223                      ValueType ArgVT, SDNode OpNode, PatFrag ld_frag,
4224                      bit Is2Addr = 1> {
4225   def rr : PDI<opc, MRMSrcReg,
4226                (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
4227                !if(Is2Addr,
4228                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4229                    !strconcat(OpcodeStr,
4230                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4231                [(set VR128:$dst,
4232                      (OutVT (OpNode (ArgVT VR128:$src1), VR128:$src2)))]>,
4233                Sched<[WriteShuffle]>;
4234   def rm : PDI<opc, MRMSrcMem,
4235                (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
4236                !if(Is2Addr,
4237                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4238                    !strconcat(OpcodeStr,
4239                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4240                [(set VR128:$dst,
4241                      (OutVT (OpNode (ArgVT VR128:$src1),
4242                                     (bitconvert (ld_frag addr:$src2)))))]>,
4243                Sched<[WriteShuffleLd, ReadAfterLd]>;
4244 }
4245
4246 multiclass sse2_pack_y<bits<8> opc, string OpcodeStr, ValueType OutVT,
4247                        ValueType ArgVT, SDNode OpNode> {
4248   def Yrr : PDI<opc, MRMSrcReg,
4249                 (outs VR256:$dst), (ins VR256:$src1, VR256:$src2),
4250                 !strconcat(OpcodeStr,
4251                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4252                 [(set VR256:$dst,
4253                       (OutVT (OpNode (ArgVT VR256:$src1), VR256:$src2)))]>,
4254                 Sched<[WriteShuffle]>;
4255   def Yrm : PDI<opc, MRMSrcMem,
4256                 (outs VR256:$dst), (ins VR256:$src1, i256mem:$src2),
4257                 !strconcat(OpcodeStr,
4258                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4259                 [(set VR256:$dst,
4260                       (OutVT (OpNode (ArgVT VR256:$src1),
4261                                      (bitconvert (loadv4i64 addr:$src2)))))]>,
4262                 Sched<[WriteShuffleLd, ReadAfterLd]>;
4263 }
4264
4265 multiclass sse4_pack<bits<8> opc, string OpcodeStr, ValueType OutVT,
4266                      ValueType ArgVT, SDNode OpNode, PatFrag ld_frag,
4267                      bit Is2Addr = 1> {
4268   def rr : SS48I<opc, MRMSrcReg,
4269                  (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
4270                  !if(Is2Addr,
4271                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4272                      !strconcat(OpcodeStr,
4273                                 "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4274                  [(set VR128:$dst,
4275                        (OutVT (OpNode (ArgVT VR128:$src1), VR128:$src2)))]>,
4276                  Sched<[WriteShuffle]>;
4277   def rm : SS48I<opc, MRMSrcMem,
4278                  (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
4279                  !if(Is2Addr,
4280                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4281                      !strconcat(OpcodeStr,
4282                                 "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4283                  [(set VR128:$dst,
4284                        (OutVT (OpNode (ArgVT VR128:$src1),
4285                                       (bitconvert (ld_frag addr:$src2)))))]>,
4286                  Sched<[WriteShuffleLd, ReadAfterLd]>;
4287 }
4288
4289 multiclass sse4_pack_y<bits<8> opc, string OpcodeStr, ValueType OutVT,
4290                      ValueType ArgVT, SDNode OpNode> {
4291   def Yrr : SS48I<opc, MRMSrcReg,
4292                   (outs VR256:$dst), (ins VR256:$src1, VR256:$src2),
4293                   !strconcat(OpcodeStr,
4294                              "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4295                   [(set VR256:$dst,
4296                         (OutVT (OpNode (ArgVT VR256:$src1), VR256:$src2)))]>,
4297                   Sched<[WriteShuffle]>;
4298   def Yrm : SS48I<opc, MRMSrcMem,
4299                   (outs VR256:$dst), (ins VR256:$src1, i256mem:$src2),
4300                   !strconcat(OpcodeStr,
4301                              "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4302                   [(set VR256:$dst,
4303                         (OutVT (OpNode (ArgVT VR256:$src1),
4304                                        (bitconvert (loadv4i64 addr:$src2)))))]>,
4305                   Sched<[WriteShuffleLd, ReadAfterLd]>;
4306 }
4307
4308 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
4309   defm VPACKSSWB : sse2_pack<0x63, "vpacksswb", v16i8, v8i16, X86Packss,
4310                              loadv2i64, 0>, VEX_4V, VEX_WIG;
4311   defm VPACKSSDW : sse2_pack<0x6B, "vpackssdw", v8i16, v4i32, X86Packss,
4312                              loadv2i64, 0>, VEX_4V, VEX_WIG;
4313
4314   defm VPACKUSWB : sse2_pack<0x67, "vpackuswb", v16i8, v8i16, X86Packus,
4315                              loadv2i64, 0>, VEX_4V, VEX_WIG;
4316   defm VPACKUSDW : sse4_pack<0x2B, "vpackusdw", v8i16, v4i32, X86Packus,
4317                              loadv2i64, 0>, VEX_4V;
4318 }
4319
4320 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
4321   defm VPACKSSWB : sse2_pack_y<0x63, "vpacksswb", v32i8, v16i16, X86Packss>,
4322                                VEX_4V, VEX_L, VEX_WIG;
4323   defm VPACKSSDW : sse2_pack_y<0x6B, "vpackssdw", v16i16, v8i32, X86Packss>,
4324                                VEX_4V, VEX_L, VEX_WIG;
4325
4326   defm VPACKUSWB : sse2_pack_y<0x67, "vpackuswb", v32i8, v16i16, X86Packus>,
4327                                VEX_4V, VEX_L, VEX_WIG;
4328   defm VPACKUSDW : sse4_pack_y<0x2B, "vpackusdw", v16i16, v8i32, X86Packus>,
4329                                VEX_4V, VEX_L;
4330 }
4331
4332 let Constraints = "$src1 = $dst" in {
4333   defm PACKSSWB : sse2_pack<0x63, "packsswb", v16i8, v8i16, X86Packss,
4334                             memopv2i64>;
4335   defm PACKSSDW : sse2_pack<0x6B, "packssdw", v8i16, v4i32, X86Packss,
4336                             memopv2i64>;
4337
4338   defm PACKUSWB : sse2_pack<0x67, "packuswb", v16i8, v8i16, X86Packus,
4339                             memopv2i64>;
4340
4341   defm PACKUSDW : sse4_pack<0x2B, "packusdw", v8i16, v4i32, X86Packus,
4342                             memopv2i64>;
4343 }
4344 } // ExeDomain = SSEPackedInt
4345
4346 //===---------------------------------------------------------------------===//
4347 // SSE2 - Packed Integer Unpack Instructions
4348 //===---------------------------------------------------------------------===//
4349
4350 let ExeDomain = SSEPackedInt in {
4351 multiclass sse2_unpack<bits<8> opc, string OpcodeStr, ValueType vt,
4352                        SDNode OpNode, PatFrag ld_frag, bit Is2Addr = 1> {
4353   def rr : PDI<opc, MRMSrcReg,
4354       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
4355       !if(Is2Addr,
4356           !strconcat(OpcodeStr,"\t{$src2, $dst|$dst, $src2}"),
4357           !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4358       [(set VR128:$dst, (vt (OpNode VR128:$src1, VR128:$src2)))],
4359       IIC_SSE_UNPCK>, Sched<[WriteShuffle]>;
4360   def rm : PDI<opc, MRMSrcMem,
4361       (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
4362       !if(Is2Addr,
4363           !strconcat(OpcodeStr,"\t{$src2, $dst|$dst, $src2}"),
4364           !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4365       [(set VR128:$dst, (vt (OpNode VR128:$src1,
4366                                   (bitconvert (ld_frag addr:$src2)))))],
4367                                                IIC_SSE_UNPCK>,
4368       Sched<[WriteShuffleLd, ReadAfterLd]>;
4369 }
4370
4371 multiclass sse2_unpack_y<bits<8> opc, string OpcodeStr, ValueType vt,
4372                          SDNode OpNode> {
4373   def Yrr : PDI<opc, MRMSrcReg,
4374       (outs VR256:$dst), (ins VR256:$src1, VR256:$src2),
4375       !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4376       [(set VR256:$dst, (vt (OpNode VR256:$src1, VR256:$src2)))]>,
4377       Sched<[WriteShuffle]>;
4378   def Yrm : PDI<opc, MRMSrcMem,
4379       (outs VR256:$dst), (ins VR256:$src1, i256mem:$src2),
4380       !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
4381       [(set VR256:$dst, (vt (OpNode VR256:$src1,
4382                                   (bitconvert (loadv4i64 addr:$src2)))))]>,
4383       Sched<[WriteShuffleLd, ReadAfterLd]>;
4384 }
4385
4386
4387 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
4388   defm VPUNPCKLBW  : sse2_unpack<0x60, "vpunpcklbw", v16i8, X86Unpckl,
4389                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4390   defm VPUNPCKLWD  : sse2_unpack<0x61, "vpunpcklwd", v8i16, X86Unpckl,
4391                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4392   defm VPUNPCKHBW  : sse2_unpack<0x68, "vpunpckhbw", v16i8, X86Unpckh,
4393                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4394   defm VPUNPCKHWD  : sse2_unpack<0x69, "vpunpckhwd", v8i16, X86Unpckh,
4395                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4396 }
4397 let Predicates = [HasAVX, NoVLX] in {
4398   defm VPUNPCKLDQ  : sse2_unpack<0x62, "vpunpckldq", v4i32, X86Unpckl,
4399                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4400   defm VPUNPCKLQDQ : sse2_unpack<0x6C, "vpunpcklqdq", v2i64, X86Unpckl,
4401                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4402   defm VPUNPCKHDQ  : sse2_unpack<0x6A, "vpunpckhdq", v4i32, X86Unpckh,
4403                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4404   defm VPUNPCKHQDQ : sse2_unpack<0x6D, "vpunpckhqdq", v2i64, X86Unpckh,
4405                                  loadv2i64, 0>, VEX_4V, VEX_WIG;
4406 }
4407
4408 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
4409   defm VPUNPCKLBW  : sse2_unpack_y<0x60, "vpunpcklbw", v32i8, X86Unpckl>,
4410                                    VEX_4V, VEX_L, VEX_WIG;
4411   defm VPUNPCKLWD  : sse2_unpack_y<0x61, "vpunpcklwd", v16i16, X86Unpckl>,
4412                                    VEX_4V, VEX_L, VEX_WIG;
4413   defm VPUNPCKHBW  : sse2_unpack_y<0x68, "vpunpckhbw", v32i8, X86Unpckh>,
4414                                    VEX_4V, VEX_L, VEX_WIG;
4415   defm VPUNPCKHWD  : sse2_unpack_y<0x69, "vpunpckhwd", v16i16, X86Unpckh>,
4416                                    VEX_4V, VEX_L, VEX_WIG;
4417 }
4418 let Predicates = [HasAVX2, NoVLX] in {
4419   defm VPUNPCKLDQ  : sse2_unpack_y<0x62, "vpunpckldq", v8i32, X86Unpckl>,
4420                                    VEX_4V, VEX_L, VEX_WIG;
4421   defm VPUNPCKLQDQ : sse2_unpack_y<0x6C, "vpunpcklqdq", v4i64, X86Unpckl>,
4422                                    VEX_4V, VEX_L, VEX_WIG;
4423   defm VPUNPCKHDQ  : sse2_unpack_y<0x6A, "vpunpckhdq", v8i32, X86Unpckh>,
4424                                    VEX_4V, VEX_L, VEX_WIG;
4425   defm VPUNPCKHQDQ : sse2_unpack_y<0x6D, "vpunpckhqdq", v4i64, X86Unpckh>,
4426                                    VEX_4V, VEX_L, VEX_WIG;
4427 }
4428
4429 let Constraints = "$src1 = $dst" in {
4430   defm PUNPCKLBW  : sse2_unpack<0x60, "punpcklbw", v16i8, X86Unpckl,
4431                                 memopv2i64>;
4432   defm PUNPCKLWD  : sse2_unpack<0x61, "punpcklwd", v8i16, X86Unpckl,
4433                                 memopv2i64>;
4434   defm PUNPCKLDQ  : sse2_unpack<0x62, "punpckldq", v4i32, X86Unpckl,
4435                                 memopv2i64>;
4436   defm PUNPCKLQDQ : sse2_unpack<0x6C, "punpcklqdq", v2i64, X86Unpckl,
4437                                 memopv2i64>;
4438
4439   defm PUNPCKHBW  : sse2_unpack<0x68, "punpckhbw", v16i8, X86Unpckh,
4440                                 memopv2i64>;
4441   defm PUNPCKHWD  : sse2_unpack<0x69, "punpckhwd", v8i16, X86Unpckh,
4442                                 memopv2i64>;
4443   defm PUNPCKHDQ  : sse2_unpack<0x6A, "punpckhdq", v4i32, X86Unpckh,
4444                                 memopv2i64>;
4445   defm PUNPCKHQDQ : sse2_unpack<0x6D, "punpckhqdq", v2i64, X86Unpckh,
4446                                 memopv2i64>;
4447 }
4448 } // ExeDomain = SSEPackedInt
4449
4450 //===---------------------------------------------------------------------===//
4451 // SSE2 - Packed Integer Extract and Insert
4452 //===---------------------------------------------------------------------===//
4453
4454 let ExeDomain = SSEPackedInt in {
4455 multiclass sse2_pinsrw<bit Is2Addr = 1> {
4456   def rri : Ii8<0xC4, MRMSrcReg,
4457        (outs VR128:$dst), (ins VR128:$src1,
4458         GR32orGR64:$src2, u8imm:$src3),
4459        !if(Is2Addr,
4460            "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
4461            "vpinsrw\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
4462        [(set VR128:$dst,
4463          (X86pinsrw VR128:$src1, GR32orGR64:$src2, imm:$src3))],
4464        IIC_SSE_PINSRW>, Sched<[WriteShuffle]>;
4465   def rmi : Ii8<0xC4, MRMSrcMem,
4466                        (outs VR128:$dst), (ins VR128:$src1,
4467                         i16mem:$src2, u8imm:$src3),
4468        !if(Is2Addr,
4469            "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
4470            "vpinsrw\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
4471        [(set VR128:$dst,
4472          (X86pinsrw VR128:$src1, (extloadi16 addr:$src2),
4473                     imm:$src3))], IIC_SSE_PINSRW>,
4474        Sched<[WriteShuffleLd, ReadAfterLd]>;
4475 }
4476
4477 // Extract
4478 let Predicates = [HasAVX, NoBWI] in
4479 def VPEXTRWri : Ii8<0xC5, MRMSrcReg,
4480                     (outs GR32orGR64:$dst), (ins VR128:$src1, u8imm:$src2),
4481                     "vpextrw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4482                     [(set GR32orGR64:$dst, (X86pextrw (v8i16 VR128:$src1),
4483                                             imm:$src2))]>, PD, VEX,
4484                 Sched<[WriteShuffle]>;
4485 def PEXTRWri : PDIi8<0xC5, MRMSrcReg,
4486                     (outs GR32orGR64:$dst), (ins VR128:$src1, u8imm:$src2),
4487                     "pextrw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4488                     [(set GR32orGR64:$dst, (X86pextrw (v8i16 VR128:$src1),
4489                                             imm:$src2))], IIC_SSE_PEXTRW>,
4490                Sched<[WriteShuffleLd, ReadAfterLd]>;
4491
4492 // Insert
4493 let Predicates = [HasAVX, NoBWI] in
4494 defm VPINSRW : sse2_pinsrw<0>, PD, VEX_4V;
4495
4496 let Predicates = [UseSSE2], Constraints = "$src1 = $dst" in
4497 defm PINSRW : sse2_pinsrw, PD;
4498
4499 } // ExeDomain = SSEPackedInt
4500
4501 //===---------------------------------------------------------------------===//
4502 // SSE2 - Packed Mask Creation
4503 //===---------------------------------------------------------------------===//
4504
4505 let ExeDomain = SSEPackedInt, SchedRW = [WriteVecLogic] in {
4506
4507 def VPMOVMSKBrr  : VPDI<0xD7, MRMSrcReg, (outs GR32orGR64:$dst),
4508            (ins VR128:$src),
4509            "pmovmskb\t{$src, $dst|$dst, $src}",
4510            [(set GR32orGR64:$dst, (X86movmsk (v16i8 VR128:$src)))],
4511            IIC_SSE_MOVMSK>, VEX, VEX_WIG;
4512
4513 let Predicates = [HasAVX2] in {
4514 def VPMOVMSKBYrr  : VPDI<0xD7, MRMSrcReg, (outs GR32orGR64:$dst),
4515            (ins VR256:$src),
4516            "pmovmskb\t{$src, $dst|$dst, $src}",
4517            [(set GR32orGR64:$dst, (X86movmsk (v32i8 VR256:$src)))]>,
4518            VEX, VEX_L, VEX_WIG;
4519 }
4520
4521 def PMOVMSKBrr : PDI<0xD7, MRMSrcReg, (outs GR32orGR64:$dst), (ins VR128:$src),
4522            "pmovmskb\t{$src, $dst|$dst, $src}",
4523            [(set GR32orGR64:$dst, (X86movmsk (v16i8 VR128:$src)))],
4524            IIC_SSE_MOVMSK>;
4525
4526 } // ExeDomain = SSEPackedInt
4527
4528 //===---------------------------------------------------------------------===//
4529 // SSE2 - Conditional Store
4530 //===---------------------------------------------------------------------===//
4531
4532 let ExeDomain = SSEPackedInt, SchedRW = [WriteStore] in {
4533
4534 let Uses = [EDI], Predicates = [HasAVX,Not64BitMode] in
4535 def VMASKMOVDQU : VPDI<0xF7, MRMSrcReg, (outs),
4536            (ins VR128:$src, VR128:$mask),
4537            "maskmovdqu\t{$mask, $src|$src, $mask}",
4538            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)],
4539            IIC_SSE_MASKMOV>, VEX, VEX_WIG;
4540 let Uses = [RDI], Predicates = [HasAVX,In64BitMode] in
4541 def VMASKMOVDQU64 : VPDI<0xF7, MRMSrcReg, (outs),
4542            (ins VR128:$src, VR128:$mask),
4543            "maskmovdqu\t{$mask, $src|$src, $mask}",
4544            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, RDI)],
4545            IIC_SSE_MASKMOV>, VEX, VEX_WIG;
4546
4547 let Uses = [EDI], Predicates = [UseSSE2,Not64BitMode] in
4548 def MASKMOVDQU : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
4549            "maskmovdqu\t{$mask, $src|$src, $mask}",
4550            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)],
4551            IIC_SSE_MASKMOV>;
4552 let Uses = [RDI], Predicates = [UseSSE2,In64BitMode] in
4553 def MASKMOVDQU64 : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
4554            "maskmovdqu\t{$mask, $src|$src, $mask}",
4555            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, RDI)],
4556            IIC_SSE_MASKMOV>;
4557
4558 } // ExeDomain = SSEPackedInt
4559
4560 //===---------------------------------------------------------------------===//
4561 // SSE2 - Move Doubleword/Quadword
4562 //===---------------------------------------------------------------------===//
4563
4564 //===---------------------------------------------------------------------===//
4565 // Move Int Doubleword to Packed Double Int
4566 //
4567 let ExeDomain = SSEPackedInt in {
4568 def VMOVDI2PDIrr : VS2I<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4569                       "movd\t{$src, $dst|$dst, $src}",
4570                       [(set VR128:$dst,
4571                         (v4i32 (scalar_to_vector GR32:$src)))], IIC_SSE_MOVDQ>,
4572                         VEX, Sched<[WriteMove]>;
4573 def VMOVDI2PDIrm : VS2I<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4574                       "movd\t{$src, $dst|$dst, $src}",
4575                       [(set VR128:$dst,
4576                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))],
4577                         IIC_SSE_MOVDQ>,
4578                       VEX, Sched<[WriteLoad]>;
4579 def VMOV64toPQIrr : VRS2I<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4580                         "movq\t{$src, $dst|$dst, $src}",
4581                         [(set VR128:$dst,
4582                           (v2i64 (scalar_to_vector GR64:$src)))],
4583                           IIC_SSE_MOVDQ>, VEX, Sched<[WriteMove]>;
4584 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayLoad = 1 in
4585 def VMOV64toPQIrm : VRS2I<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4586                         "movq\t{$src, $dst|$dst, $src}",
4587                         [], IIC_SSE_MOVDQ>, VEX, Sched<[WriteLoad]>;
4588 let isCodeGenOnly = 1 in
4589 def VMOV64toSDrr : VRS2I<0x6E, MRMSrcReg, (outs FR64:$dst), (ins GR64:$src),
4590                        "movq\t{$src, $dst|$dst, $src}",
4591                        [(set FR64:$dst, (bitconvert GR64:$src))],
4592                        IIC_SSE_MOVDQ>, VEX, Sched<[WriteMove]>;
4593
4594 def MOVDI2PDIrr : S2I<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4595                       "movd\t{$src, $dst|$dst, $src}",
4596                       [(set VR128:$dst,
4597                         (v4i32 (scalar_to_vector GR32:$src)))], IIC_SSE_MOVDQ>,
4598                   Sched<[WriteMove]>;
4599 def MOVDI2PDIrm : S2I<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4600                       "movd\t{$src, $dst|$dst, $src}",
4601                       [(set VR128:$dst,
4602                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))],
4603                         IIC_SSE_MOVDQ>, Sched<[WriteLoad]>;
4604 def MOV64toPQIrr : RS2I<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4605                         "movq\t{$src, $dst|$dst, $src}",
4606                         [(set VR128:$dst,
4607                           (v2i64 (scalar_to_vector GR64:$src)))],
4608                           IIC_SSE_MOVDQ>, Sched<[WriteMove]>;
4609 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayLoad = 1 in
4610 def MOV64toPQIrm : RS2I<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4611                         "movq\t{$src, $dst|$dst, $src}",
4612                         [], IIC_SSE_MOVDQ>, Sched<[WriteLoad]>;
4613 let isCodeGenOnly = 1 in
4614 def MOV64toSDrr : RS2I<0x6E, MRMSrcReg, (outs FR64:$dst), (ins GR64:$src),
4615                        "movq\t{$src, $dst|$dst, $src}",
4616                        [(set FR64:$dst, (bitconvert GR64:$src))],
4617                        IIC_SSE_MOVDQ>, Sched<[WriteMove]>;
4618 } // ExeDomain = SSEPackedInt
4619
4620 //===---------------------------------------------------------------------===//
4621 // Move Int Doubleword to Single Scalar
4622 //
4623 let ExeDomain = SSEPackedInt, isCodeGenOnly = 1 in {
4624   def VMOVDI2SSrr  : VS2I<0x6E, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
4625                         "movd\t{$src, $dst|$dst, $src}",
4626                         [(set FR32:$dst, (bitconvert GR32:$src))],
4627                         IIC_SSE_MOVDQ>, VEX, Sched<[WriteMove]>;
4628
4629   def VMOVDI2SSrm  : VS2I<0x6E, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
4630                         "movd\t{$src, $dst|$dst, $src}",
4631                         [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))],
4632                         IIC_SSE_MOVDQ>,
4633                         VEX, Sched<[WriteLoad]>;
4634   def MOVDI2SSrr  : S2I<0x6E, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
4635                         "movd\t{$src, $dst|$dst, $src}",
4636                         [(set FR32:$dst, (bitconvert GR32:$src))],
4637                         IIC_SSE_MOVDQ>, Sched<[WriteMove]>;
4638
4639   def MOVDI2SSrm  : S2I<0x6E, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
4640                         "movd\t{$src, $dst|$dst, $src}",
4641                         [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))],
4642                         IIC_SSE_MOVDQ>, Sched<[WriteLoad]>;
4643 } // ExeDomain = SSEPackedInt, isCodeGenOnly = 1
4644
4645 //===---------------------------------------------------------------------===//
4646 // Move Packed Doubleword Int to Packed Double Int
4647 //
4648 let ExeDomain = SSEPackedInt in {
4649 def VMOVPDI2DIrr  : VS2I<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128:$src),
4650                        "movd\t{$src, $dst|$dst, $src}",
4651                        [(set GR32:$dst, (extractelt (v4i32 VR128:$src),
4652                                         (iPTR 0)))], IIC_SSE_MOVD_ToGP>, VEX,
4653                     Sched<[WriteMove]>;
4654 def VMOVPDI2DImr  : VS2I<0x7E, MRMDestMem, (outs),
4655                        (ins i32mem:$dst, VR128:$src),
4656                        "movd\t{$src, $dst|$dst, $src}",
4657                        [(store (i32 (extractelt (v4i32 VR128:$src),
4658                                      (iPTR 0))), addr:$dst)], IIC_SSE_MOVDQ>,
4659                                      VEX, Sched<[WriteStore]>;
4660 def MOVPDI2DIrr  : S2I<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128:$src),
4661                        "movd\t{$src, $dst|$dst, $src}",
4662                        [(set GR32:$dst, (extractelt (v4i32 VR128:$src),
4663                                         (iPTR 0)))], IIC_SSE_MOVD_ToGP>,
4664                    Sched<[WriteMove]>;
4665 def MOVPDI2DImr  : S2I<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, VR128:$src),
4666                        "movd\t{$src, $dst|$dst, $src}",
4667                        [(store (i32 (extractelt (v4i32 VR128:$src),
4668                                      (iPTR 0))), addr:$dst)],
4669                                      IIC_SSE_MOVDQ>, Sched<[WriteStore]>;
4670 } // ExeDomain = SSEPackedInt
4671 //===---------------------------------------------------------------------===//
4672 // Move Packed Doubleword Int first element to Doubleword Int
4673 //
4674 let ExeDomain = SSEPackedInt in {
4675 let SchedRW = [WriteMove] in {
4676 def VMOVPQIto64rr : VRS2I<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4677                           "movq\t{$src, $dst|$dst, $src}",
4678                           [(set GR64:$dst, (extractelt (v2i64 VR128:$src),
4679                                                         (iPTR 0)))],
4680                                                            IIC_SSE_MOVD_ToGP>,
4681                       VEX;
4682
4683 def MOVPQIto64rr : RS2I<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4684                         "movq\t{$src, $dst|$dst, $src}",
4685                         [(set GR64:$dst, (extractelt (v2i64 VR128:$src),
4686                                                          (iPTR 0)))],
4687                                                          IIC_SSE_MOVD_ToGP>;
4688 } //SchedRW
4689
4690 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayStore = 1 in
4691 def VMOVPQIto64mr : VRS2I<0x7E, MRMDestMem, (outs),
4692                           (ins i64mem:$dst, VR128:$src),
4693                           "movq\t{$src, $dst|$dst, $src}",
4694                           [], IIC_SSE_MOVDQ>, VEX, Sched<[WriteStore]>;
4695 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0, mayStore = 1 in
4696 def MOVPQIto64mr : RS2I<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4697                         "movq\t{$src, $dst|$dst, $src}",
4698                         [], IIC_SSE_MOVDQ>, Sched<[WriteStore]>;
4699 } // ExeDomain = SSEPackedInt
4700
4701 //===---------------------------------------------------------------------===//
4702 // Bitcast FR64 <-> GR64
4703 //
4704 let ExeDomain = SSEPackedInt, isCodeGenOnly = 1 in {
4705   let Predicates = [UseAVX] in
4706   def VMOV64toSDrm : VS2SI<0x7E, MRMSrcMem, (outs FR64:$dst), (ins i64mem:$src),
4707                           "movq\t{$src, $dst|$dst, $src}",
4708                           [(set FR64:$dst, (bitconvert (loadi64 addr:$src)))]>,
4709                           VEX, Sched<[WriteLoad]>;
4710   def VMOVSDto64rr : VRS2I<0x7E, MRMDestReg, (outs GR64:$dst), (ins FR64:$src),
4711                            "movq\t{$src, $dst|$dst, $src}",
4712                            [(set GR64:$dst, (bitconvert FR64:$src))],
4713                            IIC_SSE_MOVDQ>, VEX, Sched<[WriteMove]>;
4714   def VMOVSDto64mr : VRS2I<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, FR64:$src),
4715                            "movq\t{$src, $dst|$dst, $src}",
4716                            [(store (i64 (bitconvert FR64:$src)), addr:$dst)],
4717                            IIC_SSE_MOVDQ>, VEX, Sched<[WriteStore]>;
4718
4719   def MOV64toSDrm : S2SI<0x7E, MRMSrcMem, (outs FR64:$dst), (ins i64mem:$src),
4720                          "movq\t{$src, $dst|$dst, $src}",
4721                          [(set FR64:$dst, (bitconvert (loadi64 addr:$src)))],
4722                          IIC_SSE_MOVDQ>, Sched<[WriteLoad]>;
4723   def MOVSDto64rr : RS2I<0x7E, MRMDestReg, (outs GR64:$dst), (ins FR64:$src),
4724                          "movq\t{$src, $dst|$dst, $src}",
4725                          [(set GR64:$dst, (bitconvert FR64:$src))],
4726                          IIC_SSE_MOVD_ToGP>, Sched<[WriteMove]>;
4727   def MOVSDto64mr : RS2I<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, FR64:$src),
4728                          "movq\t{$src, $dst|$dst, $src}",
4729                          [(store (i64 (bitconvert FR64:$src)), addr:$dst)],
4730                          IIC_SSE_MOVDQ>, Sched<[WriteStore]>;
4731 } // ExeDomain = SSEPackedInt, isCodeGenOnly = 1
4732
4733 //===---------------------------------------------------------------------===//
4734 // Move Scalar Single to Double Int
4735 //
4736 let ExeDomain = SSEPackedInt, isCodeGenOnly = 1 in {
4737   def VMOVSS2DIrr  : VS2I<0x7E, MRMDestReg, (outs GR32:$dst), (ins FR32:$src),
4738                         "movd\t{$src, $dst|$dst, $src}",
4739                         [(set GR32:$dst, (bitconvert FR32:$src))],
4740                         IIC_SSE_MOVD_ToGP>, VEX, Sched<[WriteMove]>;
4741   def VMOVSS2DImr  : VS2I<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, FR32:$src),
4742                         "movd\t{$src, $dst|$dst, $src}",
4743                         [(store (i32 (bitconvert FR32:$src)), addr:$dst)],
4744                         IIC_SSE_MOVDQ>, VEX, Sched<[WriteStore]>;
4745   def MOVSS2DIrr  : S2I<0x7E, MRMDestReg, (outs GR32:$dst), (ins FR32:$src),
4746                         "movd\t{$src, $dst|$dst, $src}",
4747                         [(set GR32:$dst, (bitconvert FR32:$src))],
4748                         IIC_SSE_MOVD_ToGP>, Sched<[WriteMove]>;
4749   def MOVSS2DImr  : S2I<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, FR32:$src),
4750                         "movd\t{$src, $dst|$dst, $src}",
4751                         [(store (i32 (bitconvert FR32:$src)), addr:$dst)],
4752                         IIC_SSE_MOVDQ>, Sched<[WriteStore]>;
4753 } // ExeDomain = SSEPackedInt, isCodeGenOnly = 1
4754
4755 let Predicates = [UseAVX] in {
4756   let AddedComplexity = 15 in {
4757     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector GR32:$src)))),
4758               (VMOVDI2PDIrr GR32:$src)>;
4759
4760     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector GR64:$src)))),
4761               (VMOV64toPQIrr GR64:$src)>;
4762
4763     def : Pat<(v4i64 (X86vzmovl (insert_subvector undef,
4764                 (v2i64 (scalar_to_vector GR64:$src)),(iPTR 0)))),
4765               (SUBREG_TO_REG (i64 0), (VMOV64toPQIrr GR64:$src), sub_xmm)>;
4766   }
4767   // AVX 128-bit movd/movq instructions write zeros in the high 128-bit part.
4768   // These instructions also write zeros in the high part of a 256-bit register.
4769   let AddedComplexity = 20 in {
4770     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector (zextloadi64i32 addr:$src))))),
4771               (VMOVDI2PDIrm addr:$src)>;
4772     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector (loadi32 addr:$src))))),
4773               (VMOVDI2PDIrm addr:$src)>;
4774     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
4775               (VMOVDI2PDIrm addr:$src)>;
4776     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
4777               (VMOVDI2PDIrm addr:$src)>;
4778     def : Pat<(v4i32 (X86vzload addr:$src)),
4779               (VMOVDI2PDIrm addr:$src)>;
4780     def : Pat<(v8i32 (X86vzmovl (insert_subvector undef,
4781                 (v4i32 (scalar_to_vector (loadi32 addr:$src))), (iPTR 0)))),
4782               (SUBREG_TO_REG (i32 0), (VMOVDI2PDIrm addr:$src), sub_xmm)>;
4783     def : Pat<(v8i32 (X86vzload addr:$src)),
4784               (SUBREG_TO_REG (i64 0), (VMOVDI2PDIrm addr:$src), sub_xmm)>;
4785   }
4786   // Use regular 128-bit instructions to match 256-bit scalar_to_vec+zext.
4787   def : Pat<(v8i32 (X86vzmovl (insert_subvector undef,
4788                                (v4i32 (scalar_to_vector GR32:$src)),(iPTR 0)))),
4789             (SUBREG_TO_REG (i32 0), (VMOVDI2PDIrr GR32:$src), sub_xmm)>;
4790 }
4791
4792 let Predicates = [UseSSE2] in {
4793   let AddedComplexity = 15 in {
4794     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector GR32:$src)))),
4795               (MOVDI2PDIrr GR32:$src)>;
4796
4797     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector GR64:$src)))),
4798               (MOV64toPQIrr GR64:$src)>;
4799   }
4800   let AddedComplexity = 20 in {
4801     def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector (zextloadi64i32 addr:$src))))),
4802               (MOVDI2PDIrm addr:$src)>;
4803     def : Pat<(v4i32 (X86vzmovl (v4i32 (scalar_to_vector (loadi32 addr:$src))))),
4804               (MOVDI2PDIrm addr:$src)>;
4805     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
4806               (MOVDI2PDIrm addr:$src)>;
4807     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
4808               (MOVDI2PDIrm addr:$src)>;
4809     def : Pat<(v4i32 (X86vzload addr:$src)),
4810               (MOVDI2PDIrm addr:$src)>;
4811   }
4812 }
4813
4814 // Before the MC layer of LLVM existed, clang emitted "movd" assembly instead of
4815 // "movq" due to MacOS parsing limitation. In order to parse old assembly, we add
4816 // these aliases.
4817 def : InstAlias<"movd\t{$src, $dst|$dst, $src}",
4818                 (MOV64toPQIrr VR128:$dst, GR64:$src), 0>;
4819 def : InstAlias<"movd\t{$src, $dst|$dst, $src}",
4820                 (MOVPQIto64rr GR64:$dst, VR128:$src), 0>;
4821 // Allow "vmovd" but print "vmovq" since we don't need compatibility for AVX.
4822 def : InstAlias<"vmovd\t{$src, $dst|$dst, $src}",
4823                 (VMOV64toPQIrr VR128:$dst, GR64:$src), 0>;
4824 def : InstAlias<"vmovd\t{$src, $dst|$dst, $src}",
4825                 (VMOVPQIto64rr GR64:$dst, VR128:$src), 0>;
4826
4827 //===---------------------------------------------------------------------===//
4828 // SSE2 - Move Quadword
4829 //===---------------------------------------------------------------------===//
4830
4831 //===---------------------------------------------------------------------===//
4832 // Move Quadword Int to Packed Quadword Int
4833 //
4834
4835 let ExeDomain = SSEPackedInt, SchedRW = [WriteLoad] in {
4836 def VMOVQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4837                     "vmovq\t{$src, $dst|$dst, $src}",
4838                     [(set VR128:$dst,
4839                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
4840                     VEX, Requires<[UseAVX]>, VEX_WIG;
4841 def MOVQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4842                     "movq\t{$src, $dst|$dst, $src}",
4843                     [(set VR128:$dst,
4844                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))],
4845                       IIC_SSE_MOVDQ>, XS,
4846                     Requires<[UseSSE2]>; // SSE2 instruction with XS Prefix
4847 } // ExeDomain, SchedRW
4848
4849 //===---------------------------------------------------------------------===//
4850 // Move Packed Quadword Int to Quadword Int
4851 //
4852 let ExeDomain = SSEPackedInt, SchedRW = [WriteStore] in {
4853 def VMOVPQI2QImr : VS2I<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4854                       "movq\t{$src, $dst|$dst, $src}",
4855                       [(store (i64 (extractelt (v2i64 VR128:$src),
4856                                     (iPTR 0))), addr:$dst)],
4857                                     IIC_SSE_MOVDQ>, VEX, VEX_WIG;
4858 def MOVPQI2QImr : S2I<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4859                       "movq\t{$src, $dst|$dst, $src}",
4860                       [(store (i64 (extractelt (v2i64 VR128:$src),
4861                                     (iPTR 0))), addr:$dst)],
4862                                     IIC_SSE_MOVDQ>;
4863 } // ExeDomain, SchedRW
4864
4865 // For disassembler only
4866 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
4867     SchedRW = [WriteVecLogic] in {
4868 def VMOVPQI2QIrr : VS2I<0xD6, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
4869                      "movq\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVQ_RR>, VEX, VEX_WIG;
4870 def MOVPQI2QIrr : S2I<0xD6, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
4871                       "movq\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVQ_RR>;
4872 }
4873
4874 // Aliases to help the assembler pick two byte VEX encodings by swapping the
4875 // operands relative to the normal instructions to use VEX.R instead of VEX.B.
4876 def : InstAlias<"vmovq\t{$src, $dst|$dst, $src}",
4877                 (VMOVPQI2QIrr VR128L:$dst, VR128H:$src), 0>;
4878
4879 let Predicates = [UseAVX], AddedComplexity = 20 in {
4880   def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector (loadi64 addr:$src))))),
4881             (VMOVQI2PQIrm addr:$src)>;
4882   def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
4883             (VMOVQI2PQIrm addr:$src)>;
4884   def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4f32 addr:$src)))),
4885             (VMOVQI2PQIrm addr:$src)>;
4886   def : Pat<(v2i64 (X86vzload addr:$src)),
4887             (VMOVQI2PQIrm addr:$src)>;
4888   def : Pat<(v4i64 (X86vzmovl (insert_subvector undef,
4889               (v2i64 (scalar_to_vector (loadi64 addr:$src))), (iPTR 0)))),
4890             (SUBREG_TO_REG (i64 0), (VMOVQI2PQIrm addr:$src), sub_xmm)>;
4891   def : Pat<(v4i64 (X86vzload addr:$src)),
4892             (SUBREG_TO_REG (i64 0), (VMOVQI2PQIrm addr:$src), sub_xmm)>;
4893 }
4894
4895 let Predicates = [UseSSE2], AddedComplexity = 20 in {
4896   def : Pat<(v2i64 (X86vzmovl (v2i64 (scalar_to_vector (loadi64 addr:$src))))),
4897             (MOVQI2PQIrm addr:$src)>;
4898   def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
4899             (MOVQI2PQIrm addr:$src)>;
4900   def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4f32 addr:$src)))),
4901             (MOVQI2PQIrm addr:$src)>;
4902   def : Pat<(v2i64 (X86vzload addr:$src)), (MOVQI2PQIrm addr:$src)>;
4903 }
4904
4905 //===---------------------------------------------------------------------===//
4906 // Moving from XMM to XMM and clear upper 64 bits. Note, there is a bug in
4907 // IA32 document. movq xmm1, xmm2 does clear the high bits.
4908 //
4909 let ExeDomain = SSEPackedInt, SchedRW = [WriteVecLogic] in {
4910 let AddedComplexity = 15 in
4911 def VMOVZPQILo2PQIrr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4912                         "vmovq\t{$src, $dst|$dst, $src}",
4913                     [(set VR128:$dst, (v2i64 (X86vzmovl (v2i64 VR128:$src))))],
4914                     IIC_SSE_MOVQ_RR>,
4915                       XS, VEX, Requires<[UseAVX]>, VEX_WIG;
4916 let AddedComplexity = 15 in
4917 def MOVZPQILo2PQIrr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4918                         "movq\t{$src, $dst|$dst, $src}",
4919                     [(set VR128:$dst, (v2i64 (X86vzmovl (v2i64 VR128:$src))))],
4920                     IIC_SSE_MOVQ_RR>,
4921                       XS, Requires<[UseSSE2]>;
4922 } // ExeDomain, SchedRW
4923
4924 let AddedComplexity = 20 in {
4925   let Predicates = [UseAVX] in {
4926     def : Pat<(v2f64 (X86vzmovl (v2f64 VR128:$src))),
4927               (VMOVZPQILo2PQIrr VR128:$src)>;
4928   }
4929   let Predicates = [UseSSE2] in {
4930     def : Pat<(v2f64 (X86vzmovl (v2f64 VR128:$src))),
4931               (MOVZPQILo2PQIrr VR128:$src)>;
4932   }
4933 }
4934
4935 //===---------------------------------------------------------------------===//
4936 // SSE3 - Replicate Single FP - MOVSHDUP and MOVSLDUP
4937 //===---------------------------------------------------------------------===//
4938 multiclass sse3_replicate_sfp<bits<8> op, SDNode OpNode, string OpcodeStr,
4939                               ValueType vt, RegisterClass RC, PatFrag mem_frag,
4940                               X86MemOperand x86memop> {
4941 def rr : S3SI<op, MRMSrcReg, (outs RC:$dst), (ins RC:$src),
4942                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4943                       [(set RC:$dst, (vt (OpNode RC:$src)))],
4944                       IIC_SSE_MOV_LH>, Sched<[WriteFShuffle]>;
4945 def rm : S3SI<op, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
4946                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4947                       [(set RC:$dst, (OpNode (mem_frag addr:$src)))],
4948                       IIC_SSE_MOV_LH>, Sched<[WriteLoad]>;
4949 }
4950
4951 let Predicates = [HasAVX, NoVLX] in {
4952   defm VMOVSHDUP  : sse3_replicate_sfp<0x16, X86Movshdup, "vmovshdup",
4953                                        v4f32, VR128, loadv4f32, f128mem>, VEX, VEX_WIG;
4954   defm VMOVSLDUP  : sse3_replicate_sfp<0x12, X86Movsldup, "vmovsldup",
4955                                        v4f32, VR128, loadv4f32, f128mem>, VEX, VEX_WIG;
4956   defm VMOVSHDUPY : sse3_replicate_sfp<0x16, X86Movshdup, "vmovshdup",
4957                                  v8f32, VR256, loadv8f32, f256mem>, VEX, VEX_L, VEX_WIG;
4958   defm VMOVSLDUPY : sse3_replicate_sfp<0x12, X86Movsldup, "vmovsldup",
4959                                  v8f32, VR256, loadv8f32, f256mem>, VEX, VEX_L, VEX_WIG;
4960 }
4961 defm MOVSHDUP : sse3_replicate_sfp<0x16, X86Movshdup, "movshdup", v4f32, VR128,
4962                                    memopv4f32, f128mem>;
4963 defm MOVSLDUP : sse3_replicate_sfp<0x12, X86Movsldup, "movsldup", v4f32, VR128,
4964                                    memopv4f32, f128mem>;
4965
4966 let Predicates = [HasAVX, NoVLX] in {
4967   def : Pat<(v4i32 (X86Movshdup VR128:$src)),
4968             (VMOVSHDUPrr VR128:$src)>;
4969   def : Pat<(v4i32 (X86Movshdup (bc_v4i32 (loadv2i64 addr:$src)))),
4970             (VMOVSHDUPrm addr:$src)>;
4971   def : Pat<(v4i32 (X86Movsldup VR128:$src)),
4972             (VMOVSLDUPrr VR128:$src)>;
4973   def : Pat<(v4i32 (X86Movsldup (bc_v4i32 (loadv2i64 addr:$src)))),
4974             (VMOVSLDUPrm addr:$src)>;
4975   def : Pat<(v8i32 (X86Movshdup VR256:$src)),
4976             (VMOVSHDUPYrr VR256:$src)>;
4977   def : Pat<(v8i32 (X86Movshdup (bc_v8i32 (loadv4i64 addr:$src)))),
4978             (VMOVSHDUPYrm addr:$src)>;
4979   def : Pat<(v8i32 (X86Movsldup VR256:$src)),
4980             (VMOVSLDUPYrr VR256:$src)>;
4981   def : Pat<(v8i32 (X86Movsldup (bc_v8i32 (loadv4i64 addr:$src)))),
4982             (VMOVSLDUPYrm addr:$src)>;
4983 }
4984
4985 let Predicates = [UseSSE3] in {
4986   def : Pat<(v4i32 (X86Movshdup VR128:$src)),
4987             (MOVSHDUPrr VR128:$src)>;
4988   def : Pat<(v4i32 (X86Movshdup (bc_v4i32 (memopv2i64 addr:$src)))),
4989             (MOVSHDUPrm addr:$src)>;
4990   def : Pat<(v4i32 (X86Movsldup VR128:$src)),
4991             (MOVSLDUPrr VR128:$src)>;
4992   def : Pat<(v4i32 (X86Movsldup (bc_v4i32 (memopv2i64 addr:$src)))),
4993             (MOVSLDUPrm addr:$src)>;
4994 }
4995
4996 //===---------------------------------------------------------------------===//
4997 // SSE3 - Replicate Double FP - MOVDDUP
4998 //===---------------------------------------------------------------------===//
4999
5000 multiclass sse3_replicate_dfp<string OpcodeStr> {
5001 def rr  : S3DI<0x12, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
5002                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5003                     [(set VR128:$dst, (v2f64 (X86Movddup VR128:$src)))],
5004                     IIC_SSE_MOV_LH>, Sched<[WriteFShuffle]>;
5005 def rm  : S3DI<0x12, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
5006                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5007                     [(set VR128:$dst,
5008                       (v2f64 (X86Movddup
5009                               (scalar_to_vector (loadf64 addr:$src)))))],
5010                               IIC_SSE_MOV_LH>, Sched<[WriteLoad]>;
5011 }
5012
5013 // FIXME: Merge with above classe when there're patterns for the ymm version
5014 multiclass sse3_replicate_dfp_y<string OpcodeStr> {
5015 def rr  : S3DI<0x12, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
5016                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5017                     [(set VR256:$dst, (v4f64 (X86Movddup VR256:$src)))]>,
5018                     Sched<[WriteFShuffle]>;
5019 def rm  : S3DI<0x12, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
5020                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5021                     [(set VR256:$dst,
5022                       (v4f64 (X86Movddup (loadv4f64 addr:$src))))]>,
5023                     Sched<[WriteLoad]>;
5024 }
5025
5026 let Predicates = [HasAVX, NoVLX] in {
5027   defm VMOVDDUP  : sse3_replicate_dfp<"vmovddup">, VEX, VEX_WIG;
5028   defm VMOVDDUPY : sse3_replicate_dfp_y<"vmovddup">, VEX, VEX_L, VEX_WIG;
5029 }
5030
5031 defm MOVDDUP : sse3_replicate_dfp<"movddup">;
5032
5033
5034 let Predicates = [HasAVX, NoVLX] in {
5035   def : Pat<(X86Movddup (loadv2f64 addr:$src)),
5036             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
5037
5038   // 256-bit version
5039   def : Pat<(X86Movddup (loadv4i64 addr:$src)),
5040             (VMOVDDUPYrm addr:$src)>;
5041   def : Pat<(X86Movddup (v4i64 VR256:$src)),
5042             (VMOVDDUPYrr VR256:$src)>;
5043 }
5044
5045 let Predicates = [HasAVX, NoVLX] in
5046 def : Pat<(v2f64 (X86VBroadcast (loadf64 addr:$src))),
5047           (VMOVDDUPrm addr:$src)>;
5048 let Predicates = [HasAVX1Only] in
5049 def : Pat<(v2i64 (X86VBroadcast (loadi64 addr:$src))),
5050           (VMOVDDUPrm addr:$src)>;
5051
5052 let Predicates = [UseSSE3] in {
5053   def : Pat<(X86Movddup (memopv2f64 addr:$src)),
5054             (MOVDDUPrm addr:$src)>;
5055 }
5056
5057 //===---------------------------------------------------------------------===//
5058 // SSE3 - Move Unaligned Integer
5059 //===---------------------------------------------------------------------===//
5060
5061 let SchedRW = [WriteLoad] in {
5062 let Predicates = [HasAVX] in {
5063   def VLDDQUrm : S3DI<0xF0, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
5064                    "vlddqu\t{$src, $dst|$dst, $src}",
5065                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))]>, VEX, VEX_WIG;
5066   def VLDDQUYrm : S3DI<0xF0, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
5067                    "vlddqu\t{$src, $dst|$dst, $src}",
5068                    [(set VR256:$dst, (int_x86_avx_ldu_dq_256 addr:$src))]>,
5069                    VEX, VEX_L, VEX_WIG;
5070 }
5071 def LDDQUrm : S3DI<0xF0, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
5072                    "lddqu\t{$src, $dst|$dst, $src}",
5073                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))],
5074                    IIC_SSE_LDDQU>;
5075 }
5076
5077 //===---------------------------------------------------------------------===//
5078 // SSE3 - Arithmetic
5079 //===---------------------------------------------------------------------===//
5080
5081 multiclass sse3_addsub<Intrinsic Int, string OpcodeStr, RegisterClass RC,
5082                        X86MemOperand x86memop, OpndItins itins,
5083                        PatFrag ld_frag, bit Is2Addr = 1> {
5084   def rr : I<0xD0, MRMSrcReg,
5085        (outs RC:$dst), (ins RC:$src1, RC:$src2),
5086        !if(Is2Addr,
5087            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5088            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5089        [(set RC:$dst, (Int RC:$src1, RC:$src2))], itins.rr>,
5090        Sched<[itins.Sched]>;
5091   def rm : I<0xD0, MRMSrcMem,
5092        (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
5093        !if(Is2Addr,
5094            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5095            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5096        [(set RC:$dst, (Int RC:$src1, (ld_frag addr:$src2)))], itins.rr>,
5097        Sched<[itins.Sched.Folded, ReadAfterLd]>;
5098 }
5099
5100 let Predicates = [HasAVX] in {
5101   let ExeDomain = SSEPackedSingle in {
5102     defm VADDSUBPS : sse3_addsub<int_x86_sse3_addsub_ps, "vaddsubps", VR128,
5103                                f128mem, SSE_ALU_F32P, loadv4f32, 0>, XD, VEX_4V, VEX_WIG;
5104     defm VADDSUBPSY : sse3_addsub<int_x86_avx_addsub_ps_256, "vaddsubps", VR256,
5105                         f256mem, SSE_ALU_F32P, loadv8f32, 0>, XD, VEX_4V, VEX_L, VEX_WIG;
5106   }
5107   let ExeDomain = SSEPackedDouble in {
5108     defm VADDSUBPD : sse3_addsub<int_x86_sse3_addsub_pd, "vaddsubpd", VR128,
5109                                f128mem, SSE_ALU_F64P, loadv2f64, 0>, PD, VEX_4V, VEX_WIG;
5110     defm VADDSUBPDY : sse3_addsub<int_x86_avx_addsub_pd_256, "vaddsubpd", VR256,
5111                         f256mem, SSE_ALU_F64P, loadv4f64, 0>, PD, VEX_4V, VEX_L, VEX_WIG;
5112   }
5113 }
5114 let Constraints = "$src1 = $dst", Predicates = [UseSSE3] in {
5115   let ExeDomain = SSEPackedSingle in
5116   defm ADDSUBPS : sse3_addsub<int_x86_sse3_addsub_ps, "addsubps", VR128,
5117                               f128mem, SSE_ALU_F32P, memopv4f32>, XD;
5118   let ExeDomain = SSEPackedDouble in
5119   defm ADDSUBPD : sse3_addsub<int_x86_sse3_addsub_pd, "addsubpd", VR128,
5120                               f128mem, SSE_ALU_F64P, memopv2f64>, PD;
5121 }
5122
5123 // Patterns used to select 'addsub' instructions.
5124 let Predicates = [HasAVX] in {
5125   def : Pat<(v4f32 (X86Addsub (v4f32 VR128:$lhs), (v4f32 VR128:$rhs))),
5126             (VADDSUBPSrr VR128:$lhs, VR128:$rhs)>;
5127   def : Pat<(v4f32 (X86Addsub (v4f32 VR128:$lhs), (loadv4f32 addr:$rhs))),
5128             (VADDSUBPSrm VR128:$lhs, f128mem:$rhs)>;
5129   def : Pat<(v2f64 (X86Addsub (v2f64 VR128:$lhs), (v2f64 VR128:$rhs))),
5130             (VADDSUBPDrr VR128:$lhs, VR128:$rhs)>;
5131   def : Pat<(v2f64 (X86Addsub (v2f64 VR128:$lhs), (loadv2f64 addr:$rhs))),
5132             (VADDSUBPDrm VR128:$lhs, f128mem:$rhs)>;
5133
5134   def : Pat<(v8f32 (X86Addsub (v8f32 VR256:$lhs), (v8f32 VR256:$rhs))),
5135             (VADDSUBPSYrr VR256:$lhs, VR256:$rhs)>;
5136   def : Pat<(v8f32 (X86Addsub (v8f32 VR256:$lhs), (loadv8f32 addr:$rhs))),
5137             (VADDSUBPSYrm VR256:$lhs, f256mem:$rhs)>;
5138   def : Pat<(v4f64 (X86Addsub (v4f64 VR256:$lhs), (v4f64 VR256:$rhs))),
5139             (VADDSUBPDYrr VR256:$lhs, VR256:$rhs)>;
5140   def : Pat<(v4f64 (X86Addsub (v4f64 VR256:$lhs), (loadv4f64 addr:$rhs))),
5141             (VADDSUBPDYrm VR256:$lhs, f256mem:$rhs)>;
5142 }
5143
5144 let Predicates = [UseSSE3] in {
5145   def : Pat<(v4f32 (X86Addsub (v4f32 VR128:$lhs), (v4f32 VR128:$rhs))),
5146             (ADDSUBPSrr VR128:$lhs, VR128:$rhs)>;
5147   def : Pat<(v4f32 (X86Addsub (v4f32 VR128:$lhs), (memopv4f32 addr:$rhs))),
5148             (ADDSUBPSrm VR128:$lhs, f128mem:$rhs)>;
5149   def : Pat<(v2f64 (X86Addsub (v2f64 VR128:$lhs), (v2f64 VR128:$rhs))),
5150             (ADDSUBPDrr VR128:$lhs, VR128:$rhs)>;
5151   def : Pat<(v2f64 (X86Addsub (v2f64 VR128:$lhs), (memopv2f64 addr:$rhs))),
5152             (ADDSUBPDrm VR128:$lhs, f128mem:$rhs)>;
5153 }
5154
5155 //===---------------------------------------------------------------------===//
5156 // SSE3 Instructions
5157 //===---------------------------------------------------------------------===//
5158
5159 // Horizontal ops
5160 multiclass S3D_Int<bits<8> o, string OpcodeStr, ValueType vt, RegisterClass RC,
5161                    X86MemOperand x86memop, SDNode OpNode, PatFrag ld_frag,
5162                    bit Is2Addr = 1> {
5163   def rr : S3DI<o, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
5164        !if(Is2Addr,
5165          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5166          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5167       [(set RC:$dst, (vt (OpNode RC:$src1, RC:$src2)))], IIC_SSE_HADDSUB_RR>,
5168       Sched<[WriteFAdd]>;
5169
5170   def rm : S3DI<o, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
5171        !if(Is2Addr,
5172          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5173          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5174       [(set RC:$dst, (vt (OpNode RC:$src1, (ld_frag addr:$src2))))],
5175         IIC_SSE_HADDSUB_RM>, Sched<[WriteFAddLd, ReadAfterLd]>;
5176 }
5177 multiclass S3_Int<bits<8> o, string OpcodeStr, ValueType vt, RegisterClass RC,
5178                   X86MemOperand x86memop, SDNode OpNode, PatFrag ld_frag,
5179                   bit Is2Addr = 1> {
5180   def rr : S3I<o, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
5181        !if(Is2Addr,
5182          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5183          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5184       [(set RC:$dst, (vt (OpNode RC:$src1, RC:$src2)))], IIC_SSE_HADDSUB_RR>,
5185       Sched<[WriteFAdd]>;
5186
5187   def rm : S3I<o, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
5188        !if(Is2Addr,
5189          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5190          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5191       [(set RC:$dst, (vt (OpNode RC:$src1, (ld_frag addr:$src2))))],
5192         IIC_SSE_HADDSUB_RM>, Sched<[WriteFAddLd, ReadAfterLd]>;
5193 }
5194
5195 let Predicates = [HasAVX] in {
5196   let ExeDomain = SSEPackedSingle in {
5197     defm VHADDPS  : S3D_Int<0x7C, "vhaddps", v4f32, VR128, f128mem,
5198                             X86fhadd, loadv4f32, 0>, VEX_4V, VEX_WIG;
5199     defm VHSUBPS  : S3D_Int<0x7D, "vhsubps", v4f32, VR128, f128mem,
5200                             X86fhsub, loadv4f32, 0>, VEX_4V, VEX_WIG;
5201     defm VHADDPSY : S3D_Int<0x7C, "vhaddps", v8f32, VR256, f256mem,
5202                             X86fhadd, loadv8f32, 0>, VEX_4V, VEX_L, VEX_WIG;
5203     defm VHSUBPSY : S3D_Int<0x7D, "vhsubps", v8f32, VR256, f256mem,
5204                             X86fhsub, loadv8f32, 0>, VEX_4V, VEX_L, VEX_WIG;
5205   }
5206   let ExeDomain = SSEPackedDouble in {
5207     defm VHADDPD  : S3_Int <0x7C, "vhaddpd", v2f64, VR128, f128mem,
5208                             X86fhadd, loadv2f64, 0>, VEX_4V, VEX_WIG;
5209     defm VHSUBPD  : S3_Int <0x7D, "vhsubpd", v2f64, VR128, f128mem,
5210                             X86fhsub, loadv2f64, 0>, VEX_4V, VEX_WIG;
5211     defm VHADDPDY : S3_Int <0x7C, "vhaddpd", v4f64, VR256, f256mem,
5212                             X86fhadd, loadv4f64, 0>, VEX_4V, VEX_L, VEX_WIG;
5213     defm VHSUBPDY : S3_Int <0x7D, "vhsubpd", v4f64, VR256, f256mem,
5214                             X86fhsub, loadv4f64, 0>, VEX_4V, VEX_L, VEX_WIG;
5215   }
5216 }
5217
5218 let Constraints = "$src1 = $dst" in {
5219   let ExeDomain = SSEPackedSingle in {
5220     defm HADDPS : S3D_Int<0x7C, "haddps", v4f32, VR128, f128mem, X86fhadd,
5221                           memopv4f32>;
5222     defm HSUBPS : S3D_Int<0x7D, "hsubps", v4f32, VR128, f128mem, X86fhsub,
5223                           memopv4f32>;
5224   }
5225   let ExeDomain = SSEPackedDouble in {
5226     defm HADDPD : S3_Int<0x7C, "haddpd", v2f64, VR128, f128mem, X86fhadd,
5227                          memopv2f64>;
5228     defm HSUBPD : S3_Int<0x7D, "hsubpd", v2f64, VR128, f128mem, X86fhsub,
5229                          memopv2f64>;
5230   }
5231 }
5232
5233 //===---------------------------------------------------------------------===//
5234 // SSSE3 - Packed Absolute Instructions
5235 //===---------------------------------------------------------------------===//
5236
5237
5238 /// SS3I_unop_rm_int - Simple SSSE3 unary op whose type can be v*{i8,i16,i32}.
5239 multiclass SS3I_unop_rm<bits<8> opc, string OpcodeStr, ValueType vt,
5240                         SDNode OpNode, PatFrag ld_frag> {
5241   def rr : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
5242                  (ins VR128:$src),
5243                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5244                  [(set VR128:$dst, (vt (OpNode VR128:$src)))],
5245                  IIC_SSE_PABS_RR>, Sched<[WriteVecALU]>;
5246
5247   def rm : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
5248                  (ins i128mem:$src),
5249                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5250                  [(set VR128:$dst,
5251                    (vt (OpNode (bitconvert (ld_frag addr:$src)))))],
5252                  IIC_SSE_PABS_RM>, Sched<[WriteVecALULd]>;
5253 }
5254
5255 /// SS3I_unop_rm_int_y - Simple SSSE3 unary op whose type can be v*{i8,i16,i32}.
5256 multiclass SS3I_unop_rm_y<bits<8> opc, string OpcodeStr, ValueType vt,
5257                           SDNode OpNode> {
5258   def Yrr : SS38I<opc, MRMSrcReg, (outs VR256:$dst),
5259                   (ins VR256:$src),
5260                   !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5261                   [(set VR256:$dst, (vt (OpNode VR256:$src)))]>,
5262                   Sched<[WriteVecALU]>;
5263
5264   def Yrm : SS38I<opc, MRMSrcMem, (outs VR256:$dst),
5265                   (ins i256mem:$src),
5266                   !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5267                   [(set VR256:$dst,
5268                     (vt (OpNode (bitconvert (loadv4i64 addr:$src)))))]>,
5269                   Sched<[WriteVecALULd]>;
5270 }
5271
5272 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5273   defm VPABSB  : SS3I_unop_rm<0x1C, "vpabsb", v16i8, abs, loadv2i64>, VEX, VEX_WIG;
5274   defm VPABSW  : SS3I_unop_rm<0x1D, "vpabsw", v8i16, abs, loadv2i64>, VEX, VEX_WIG;
5275 }
5276 let Predicates = [HasAVX, NoVLX] in {
5277   defm VPABSD  : SS3I_unop_rm<0x1E, "vpabsd", v4i32, abs, loadv2i64>, VEX, VEX_WIG;
5278 }
5279 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
5280   defm VPABSB  : SS3I_unop_rm_y<0x1C, "vpabsb", v32i8, abs>, VEX, VEX_L, VEX_WIG;
5281   defm VPABSW  : SS3I_unop_rm_y<0x1D, "vpabsw", v16i16, abs>, VEX, VEX_L, VEX_WIG;
5282 }
5283 let Predicates = [HasAVX2, NoVLX] in {
5284   defm VPABSD  : SS3I_unop_rm_y<0x1E, "vpabsd", v8i32, abs>, VEX, VEX_L, VEX_WIG;
5285 }
5286
5287 defm PABSB : SS3I_unop_rm<0x1C, "pabsb", v16i8, abs, memopv2i64>;
5288 defm PABSW : SS3I_unop_rm<0x1D, "pabsw", v8i16, abs, memopv2i64>;
5289 defm PABSD : SS3I_unop_rm<0x1E, "pabsd", v4i32, abs, memopv2i64>;
5290
5291 //===---------------------------------------------------------------------===//
5292 // SSSE3 - Packed Binary Operator Instructions
5293 //===---------------------------------------------------------------------===//
5294
5295 let Sched = WriteVecALU in {
5296 def SSE_PHADDSUBD : OpndItins<
5297   IIC_SSE_PHADDSUBD_RR, IIC_SSE_PHADDSUBD_RM
5298 >;
5299 def SSE_PHADDSUBSW : OpndItins<
5300   IIC_SSE_PHADDSUBSW_RR, IIC_SSE_PHADDSUBSW_RM
5301 >;
5302 def SSE_PHADDSUBW : OpndItins<
5303   IIC_SSE_PHADDSUBW_RR, IIC_SSE_PHADDSUBW_RM
5304 >;
5305 }
5306 let Sched = WriteShuffle in
5307 def SSE_PSHUFB : OpndItins<
5308   IIC_SSE_PSHUFB_RR, IIC_SSE_PSHUFB_RM
5309 >;
5310 let Sched = WriteVecALU in
5311 def SSE_PSIGN : OpndItins<
5312   IIC_SSE_PSIGN_RR, IIC_SSE_PSIGN_RM
5313 >;
5314 let Sched = WriteVecIMul in
5315 def SSE_PMULHRSW : OpndItins<
5316   IIC_SSE_PMULHRSW, IIC_SSE_PMULHRSW
5317 >;
5318
5319 /// SS3I_binop_rm - Simple SSSE3 bin op
5320 multiclass SS3I_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5321                          ValueType DstVT, ValueType OpVT, RegisterClass RC,
5322                          PatFrag memop_frag, X86MemOperand x86memop,
5323                          OpndItins itins, bit Is2Addr = 1> {
5324   let isCommutable = 1 in
5325   def rr : SS38I<opc, MRMSrcReg, (outs RC:$dst),
5326        (ins RC:$src1, RC:$src2),
5327        !if(Is2Addr,
5328          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5329          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5330        [(set RC:$dst, (DstVT (OpNode (OpVT RC:$src1), RC:$src2)))], itins.rr>,
5331        Sched<[itins.Sched]>;
5332   def rm : SS38I<opc, MRMSrcMem, (outs RC:$dst),
5333        (ins RC:$src1, x86memop:$src2),
5334        !if(Is2Addr,
5335          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5336          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5337        [(set RC:$dst,
5338          (DstVT (OpNode (OpVT RC:$src1),
5339           (bitconvert (memop_frag addr:$src2)))))], itins.rm>,
5340        Sched<[itins.Sched.Folded, ReadAfterLd]>;
5341 }
5342
5343 /// SS3I_binop_rm_int - Simple SSSE3 bin op whose type can be v*{i8,i16,i32}.
5344 multiclass SS3I_binop_rm_int<bits<8> opc, string OpcodeStr,
5345                              Intrinsic IntId128, OpndItins itins,
5346                              PatFrag ld_frag, bit Is2Addr = 1> {
5347   let isCommutable = 1 in
5348   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
5349        (ins VR128:$src1, VR128:$src2),
5350        !if(Is2Addr,
5351          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5352          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5353        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
5354        Sched<[itins.Sched]>;
5355   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
5356        (ins VR128:$src1, i128mem:$src2),
5357        !if(Is2Addr,
5358          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5359          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5360        [(set VR128:$dst,
5361          (IntId128 VR128:$src1,
5362           (bitconvert (ld_frag addr:$src2))))]>,
5363        Sched<[itins.Sched.Folded, ReadAfterLd]>;
5364 }
5365
5366 multiclass SS3I_binop_rm_int_y<bits<8> opc, string OpcodeStr,
5367                                Intrinsic IntId256,
5368                                X86FoldableSchedWrite Sched> {
5369   let isCommutable = 1 in
5370   def rr256 : SS38I<opc, MRMSrcReg, (outs VR256:$dst),
5371        (ins VR256:$src1, VR256:$src2),
5372        !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5373        [(set VR256:$dst, (IntId256 VR256:$src1, VR256:$src2))]>,
5374        Sched<[Sched]>;
5375   def rm256 : SS38I<opc, MRMSrcMem, (outs VR256:$dst),
5376        (ins VR256:$src1, i256mem:$src2),
5377        !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5378        [(set VR256:$dst,
5379          (IntId256 VR256:$src1, (bitconvert (loadv4i64 addr:$src2))))]>,
5380        Sched<[Sched.Folded, ReadAfterLd]>;
5381 }
5382
5383 let ImmT = NoImm, Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5384 let isCommutable = 0 in {
5385   defm VPSHUFB    : SS3I_binop_rm<0x00, "vpshufb", X86pshufb, v16i8, v16i8,
5386                                   VR128, loadv2i64, i128mem,
5387                                   SSE_PSHUFB, 0>, VEX_4V, VEX_WIG;
5388   defm VPMADDUBSW : SS3I_binop_rm<0x04, "vpmaddubsw", X86vpmaddubsw, v8i16,
5389                                   v16i8, VR128, loadv2i64, i128mem,
5390                                   SSE_PMADD, 0>, VEX_4V, VEX_WIG;
5391 }
5392 defm VPMULHRSW    : SS3I_binop_rm<0x0B, "vpmulhrsw", X86mulhrs, v8i16, v8i16,
5393                                   VR128, loadv2i64, i128mem,
5394                                   SSE_PMULHRSW, 0>, VEX_4V, VEX_WIG;
5395 }
5396
5397 let ImmT = NoImm, Predicates = [HasAVX] in {
5398 let isCommutable = 0 in {
5399   defm VPHADDW    : SS3I_binop_rm<0x01, "vphaddw", X86hadd, v8i16, v8i16, VR128,
5400                                   loadv2i64, i128mem,
5401                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_WIG;
5402   defm VPHADDD    : SS3I_binop_rm<0x02, "vphaddd", X86hadd, v4i32, v4i32, VR128,
5403                                   loadv2i64, i128mem,
5404                                   SSE_PHADDSUBD, 0>, VEX_4V, VEX_WIG;
5405   defm VPHSUBW    : SS3I_binop_rm<0x05, "vphsubw", X86hsub, v8i16, v8i16, VR128,
5406                                   loadv2i64, i128mem,
5407                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_WIG;
5408   defm VPHSUBD    : SS3I_binop_rm<0x06, "vphsubd", X86hsub, v4i32, v4i32, VR128,
5409                                   loadv2i64, i128mem,
5410                                   SSE_PHADDSUBD, 0>, VEX_4V;
5411   defm VPSIGNB    : SS3I_binop_rm_int<0x08, "vpsignb",
5412                                       int_x86_ssse3_psign_b_128,
5413                                       SSE_PSIGN, loadv2i64, 0>, VEX_4V, VEX_WIG;
5414   defm VPSIGNW    : SS3I_binop_rm_int<0x09, "vpsignw",
5415                                       int_x86_ssse3_psign_w_128,
5416                                       SSE_PSIGN, loadv2i64, 0>, VEX_4V, VEX_WIG;
5417   defm VPSIGND    : SS3I_binop_rm_int<0x0A, "vpsignd",
5418                                       int_x86_ssse3_psign_d_128,
5419                                       SSE_PSIGN, loadv2i64, 0>, VEX_4V, VEX_WIG;
5420   defm VPHADDSW   : SS3I_binop_rm_int<0x03, "vphaddsw",
5421                                       int_x86_ssse3_phadd_sw_128,
5422                                       SSE_PHADDSUBSW, loadv2i64, 0>, VEX_4V, VEX_WIG;
5423   defm VPHSUBSW   : SS3I_binop_rm_int<0x07, "vphsubsw",
5424                                       int_x86_ssse3_phsub_sw_128,
5425                                       SSE_PHADDSUBSW, loadv2i64, 0>, VEX_4V, VEX_WIG;
5426 }
5427 }
5428
5429 let ImmT = NoImm, Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
5430 let isCommutable = 0 in {
5431   defm VPSHUFBY   : SS3I_binop_rm<0x00, "vpshufb", X86pshufb, v32i8, v32i8,
5432                                   VR256, loadv4i64, i256mem,
5433                                   SSE_PSHUFB, 0>, VEX_4V, VEX_L, VEX_WIG;
5434   defm VPMADDUBSWY : SS3I_binop_rm<0x04, "vpmaddubsw", X86vpmaddubsw, v16i16,
5435                                    v32i8, VR256, loadv4i64, i256mem,
5436                                    SSE_PMADD, 0>, VEX_4V, VEX_L, VEX_WIG;
5437 }
5438 defm VPMULHRSWY   : SS3I_binop_rm<0x0B, "vpmulhrsw", X86mulhrs, v16i16, v16i16,
5439                                   VR256, loadv4i64, i256mem,
5440                                   SSE_PMULHRSW, 0>, VEX_4V, VEX_L, VEX_WIG;
5441 }
5442
5443 let ImmT = NoImm, Predicates = [HasAVX2] in {
5444 let isCommutable = 0 in {
5445   defm VPHADDWY   : SS3I_binop_rm<0x01, "vphaddw", X86hadd, v16i16, v16i16,
5446                                   VR256, loadv4i64, i256mem,
5447                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_L, VEX_WIG;
5448   defm VPHADDDY   : SS3I_binop_rm<0x02, "vphaddd", X86hadd, v8i32, v8i32, VR256,
5449                                   loadv4i64, i256mem,
5450                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_L, VEX_WIG;
5451   defm VPHSUBWY   : SS3I_binop_rm<0x05, "vphsubw", X86hsub, v16i16, v16i16,
5452                                   VR256, loadv4i64, i256mem,
5453                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_L, VEX_WIG;
5454   defm VPHSUBDY   : SS3I_binop_rm<0x06, "vphsubd", X86hsub, v8i32, v8i32, VR256,
5455                                   loadv4i64, i256mem,
5456                                   SSE_PHADDSUBW, 0>, VEX_4V, VEX_L;
5457   defm VPSIGNBY   : SS3I_binop_rm_int_y<0x08, "vpsignb", int_x86_avx2_psign_b,
5458                                         WriteVecALU>, VEX_4V, VEX_L, VEX_WIG;
5459   defm VPSIGNWY   : SS3I_binop_rm_int_y<0x09, "vpsignw", int_x86_avx2_psign_w,
5460                                         WriteVecALU>, VEX_4V, VEX_L, VEX_WIG;
5461   defm VPSIGNDY   : SS3I_binop_rm_int_y<0x0A, "vpsignd", int_x86_avx2_psign_d,
5462                                         WriteVecALU>, VEX_4V, VEX_L, VEX_WIG;
5463   defm VPHADDSW   : SS3I_binop_rm_int_y<0x03, "vphaddsw",
5464                                         int_x86_avx2_phadd_sw,
5465                                         WriteVecALU>, VEX_4V, VEX_L, VEX_WIG;
5466   defm VPHSUBSW   : SS3I_binop_rm_int_y<0x07, "vphsubsw",
5467                                         int_x86_avx2_phsub_sw,
5468                                         WriteVecALU>, VEX_4V, VEX_L, VEX_WIG;
5469 }
5470 }
5471
5472 // None of these have i8 immediate fields.
5473 let ImmT = NoImm, Constraints = "$src1 = $dst" in {
5474 let isCommutable = 0 in {
5475   defm PHADDW    : SS3I_binop_rm<0x01, "phaddw", X86hadd, v8i16, v8i16, VR128,
5476                                  memopv2i64, i128mem, SSE_PHADDSUBW>;
5477   defm PHADDD    : SS3I_binop_rm<0x02, "phaddd", X86hadd, v4i32, v4i32, VR128,
5478                                  memopv2i64, i128mem, SSE_PHADDSUBD>;
5479   defm PHSUBW    : SS3I_binop_rm<0x05, "phsubw", X86hsub, v8i16, v8i16, VR128,
5480                                  memopv2i64, i128mem, SSE_PHADDSUBW>;
5481   defm PHSUBD    : SS3I_binop_rm<0x06, "phsubd", X86hsub, v4i32, v4i32, VR128,
5482                                  memopv2i64, i128mem, SSE_PHADDSUBD>;
5483   defm PSIGNB    : SS3I_binop_rm_int<0x08, "psignb", int_x86_ssse3_psign_b_128,
5484                                      SSE_PSIGN, memopv2i64>;
5485   defm PSIGNW    : SS3I_binop_rm_int<0x09, "psignw", int_x86_ssse3_psign_w_128,
5486                                      SSE_PSIGN, memopv2i64>;
5487   defm PSIGND    : SS3I_binop_rm_int<0x0A, "psignd", int_x86_ssse3_psign_d_128,
5488                                      SSE_PSIGN, memopv2i64>;
5489   defm PSHUFB    : SS3I_binop_rm<0x00, "pshufb", X86pshufb, v16i8, v16i8, VR128,
5490                                  memopv2i64, i128mem, SSE_PSHUFB>;
5491   defm PHADDSW   : SS3I_binop_rm_int<0x03, "phaddsw",
5492                                      int_x86_ssse3_phadd_sw_128,
5493                                      SSE_PHADDSUBSW, memopv2i64>;
5494   defm PHSUBSW   : SS3I_binop_rm_int<0x07, "phsubsw",
5495                                      int_x86_ssse3_phsub_sw_128,
5496                                      SSE_PHADDSUBSW, memopv2i64>;
5497   defm PMADDUBSW : SS3I_binop_rm<0x04, "pmaddubsw", X86vpmaddubsw, v8i16,
5498                                  v16i8, VR128, memopv2i64, i128mem,
5499                                  SSE_PMADD>;
5500 }
5501 defm PMULHRSW    : SS3I_binop_rm<0x0B, "pmulhrsw", X86mulhrs, v8i16, v8i16,
5502                                  VR128, memopv2i64, i128mem, SSE_PMULHRSW>;
5503 }
5504
5505 //===---------------------------------------------------------------------===//
5506 // SSSE3 - Packed Align Instruction Patterns
5507 //===---------------------------------------------------------------------===//
5508
5509 multiclass ssse3_palignr<string asm, bit Is2Addr = 1> {
5510   let hasSideEffects = 0 in {
5511   def rri : SS3AI<0x0F, MRMSrcReg, (outs VR128:$dst),
5512       (ins VR128:$src1, VR128:$src2, u8imm:$src3),
5513       !if(Is2Addr,
5514         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5515         !strconcat(asm,
5516                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5517       [], IIC_SSE_PALIGNRR>, Sched<[WriteShuffle]>;
5518   let mayLoad = 1 in
5519   def rmi : SS3AI<0x0F, MRMSrcMem, (outs VR128:$dst),
5520       (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
5521       !if(Is2Addr,
5522         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5523         !strconcat(asm,
5524                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5525       [], IIC_SSE_PALIGNRM>, Sched<[WriteShuffleLd, ReadAfterLd]>;
5526   }
5527 }
5528
5529 multiclass ssse3_palignr_y<string asm, bit Is2Addr = 1> {
5530   let hasSideEffects = 0 in {
5531   def Yrri : SS3AI<0x0F, MRMSrcReg, (outs VR256:$dst),
5532       (ins VR256:$src1, VR256:$src2, u8imm:$src3),
5533       !strconcat(asm,
5534                  "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5535       []>, Sched<[WriteShuffle]>;
5536   let mayLoad = 1 in
5537   def Yrmi : SS3AI<0x0F, MRMSrcMem, (outs VR256:$dst),
5538       (ins VR256:$src1, i256mem:$src2, u8imm:$src3),
5539       !strconcat(asm,
5540                  "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5541       []>, Sched<[WriteShuffleLd, ReadAfterLd]>;
5542   }
5543 }
5544
5545 let Predicates = [HasAVX] in
5546   defm VPALIGNR : ssse3_palignr<"vpalignr", 0>, VEX_4V, VEX_WIG;
5547 let Predicates = [HasAVX2] in
5548   defm VPALIGNR : ssse3_palignr_y<"vpalignr", 0>, VEX_4V, VEX_L, VEX_WIG;
5549 let Constraints = "$src1 = $dst", Predicates = [UseSSSE3] in
5550   defm PALIGNR : ssse3_palignr<"palignr">;
5551
5552 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
5553 def : Pat<(v8i32 (X86PAlignr VR256:$src1, VR256:$src2, (i8 imm:$imm))),
5554           (VPALIGNRYrri VR256:$src1, VR256:$src2, imm:$imm)>;
5555 def : Pat<(v8f32 (X86PAlignr VR256:$src1, VR256:$src2, (i8 imm:$imm))),
5556           (VPALIGNRYrri VR256:$src1, VR256:$src2, imm:$imm)>;
5557 def : Pat<(v16i16 (X86PAlignr VR256:$src1, VR256:$src2, (i8 imm:$imm))),
5558           (VPALIGNRYrri VR256:$src1, VR256:$src2, imm:$imm)>;
5559 def : Pat<(v32i8 (X86PAlignr VR256:$src1, VR256:$src2, (i8 imm:$imm))),
5560           (VPALIGNRYrri VR256:$src1, VR256:$src2, imm:$imm)>;
5561 }
5562
5563 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5564 def : Pat<(v4i32 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5565           (VPALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5566 def : Pat<(v4f32 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5567           (VPALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5568 def : Pat<(v8i16 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5569           (VPALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5570 def : Pat<(v16i8 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5571           (VPALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5572 }
5573
5574 let Predicates = [UseSSSE3] in {
5575 def : Pat<(v4i32 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5576           (PALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5577 def : Pat<(v4f32 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5578           (PALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5579 def : Pat<(v8i16 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5580           (PALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5581 def : Pat<(v16i8 (X86PAlignr VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5582           (PALIGNRrri VR128:$src1, VR128:$src2, imm:$imm)>;
5583 }
5584
5585 //===---------------------------------------------------------------------===//
5586 // SSSE3 - Thread synchronization
5587 //===---------------------------------------------------------------------===//
5588
5589 let SchedRW = [WriteSystem] in {
5590 let usesCustomInserter = 1 in {
5591 def MONITOR : PseudoI<(outs), (ins i32mem:$src1, GR32:$src2, GR32:$src3),
5592                 [(int_x86_sse3_monitor addr:$src1, GR32:$src2, GR32:$src3)]>,
5593                 Requires<[HasSSE3]>;
5594 }
5595
5596 let Uses = [EAX, ECX, EDX] in
5597 def MONITORrrr : I<0x01, MRM_C8, (outs), (ins), "monitor", [], IIC_SSE_MONITOR>,
5598                  TB, Requires<[HasSSE3]>;
5599
5600 let Uses = [ECX, EAX] in
5601 def MWAITrr   : I<0x01, MRM_C9, (outs), (ins), "mwait",
5602                 [(int_x86_sse3_mwait ECX, EAX)], IIC_SSE_MWAIT>,
5603                 TB, Requires<[HasSSE3]>;
5604 } // SchedRW
5605
5606 def : InstAlias<"mwait\t{%eax, %ecx|ecx, eax}", (MWAITrr)>, Requires<[Not64BitMode]>;
5607 def : InstAlias<"mwait\t{%rax, %rcx|rcx, rax}", (MWAITrr)>, Requires<[In64BitMode]>;
5608
5609 def : InstAlias<"monitor\t{%eax, %ecx, %edx|edx, ecx, eax}", (MONITORrrr)>,
5610       Requires<[Not64BitMode]>;
5611 def : InstAlias<"monitor\t{%rax, %rcx, %rdx|rdx, rcx, rax}", (MONITORrrr)>,
5612       Requires<[In64BitMode]>;
5613
5614 //===----------------------------------------------------------------------===//
5615 // SSE4.1 - Packed Move with Sign/Zero Extend
5616 //===----------------------------------------------------------------------===//
5617
5618 multiclass SS41I_pmovx_rrrm<bits<8> opc, string OpcodeStr, X86MemOperand MemOp,
5619                           RegisterClass OutRC, RegisterClass InRC,
5620                           OpndItins itins> {
5621   def rr : SS48I<opc, MRMSrcReg, (outs OutRC:$dst), (ins InRC:$src),
5622                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5623                  [], itins.rr>,
5624                  Sched<[itins.Sched]>;
5625
5626   def rm : SS48I<opc, MRMSrcMem, (outs OutRC:$dst), (ins MemOp:$src),
5627                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5628                  [],
5629                  itins.rm>, Sched<[itins.Sched.Folded]>;
5630 }
5631
5632 multiclass SS41I_pmovx_rm_all<bits<8> opc, string OpcodeStr,
5633                           X86MemOperand MemOp, X86MemOperand MemYOp,
5634                           OpndItins SSEItins, OpndItins AVXItins,
5635                           OpndItins AVX2Itins, Predicate prd> {
5636   defm NAME : SS41I_pmovx_rrrm<opc, OpcodeStr, MemOp, VR128, VR128, SSEItins>;
5637   let Predicates = [HasAVX, prd] in
5638     defm V#NAME   : SS41I_pmovx_rrrm<opc, !strconcat("v", OpcodeStr), MemOp,
5639                                      VR128, VR128, AVXItins>, VEX, VEX_WIG;
5640   let Predicates = [HasAVX2, prd] in
5641     defm V#NAME#Y : SS41I_pmovx_rrrm<opc, !strconcat("v", OpcodeStr), MemYOp,
5642                                      VR256, VR128, AVX2Itins>, VEX, VEX_L, VEX_WIG;
5643 }
5644
5645 multiclass SS41I_pmovx_rm<bits<8> opc, string OpcodeStr, X86MemOperand MemOp,
5646                           X86MemOperand MemYOp, Predicate prd> {
5647   defm PMOVSX#NAME : SS41I_pmovx_rm_all<opc, !strconcat("pmovsx", OpcodeStr),
5648                                         MemOp, MemYOp,
5649                                         SSE_INTALU_ITINS_SHUFF_P,
5650                                         DEFAULT_ITINS_SHUFFLESCHED,
5651                                         DEFAULT_ITINS_SHUFFLESCHED, prd>;
5652   defm PMOVZX#NAME : SS41I_pmovx_rm_all<!add(opc, 0x10),
5653                                         !strconcat("pmovzx", OpcodeStr),
5654                                         MemOp, MemYOp,
5655                                         SSE_INTALU_ITINS_SHUFF_P,
5656                                         DEFAULT_ITINS_SHUFFLESCHED,
5657                                         DEFAULT_ITINS_SHUFFLESCHED, prd>;
5658 }
5659
5660 defm BW : SS41I_pmovx_rm<0x20, "bw", i64mem, i128mem, NoVLX_Or_NoBWI>;
5661 defm WD : SS41I_pmovx_rm<0x23, "wd", i64mem, i128mem, NoVLX>;
5662 defm DQ : SS41I_pmovx_rm<0x25, "dq", i64mem, i128mem, NoVLX>;
5663
5664 defm BD : SS41I_pmovx_rm<0x21, "bd", i32mem, i64mem, NoVLX>;
5665 defm WQ : SS41I_pmovx_rm<0x24, "wq", i32mem, i64mem, NoVLX>;
5666
5667 defm BQ : SS41I_pmovx_rm<0x22, "bq", i16mem, i32mem, NoVLX>;
5668
5669 // AVX2 Patterns
5670 multiclass SS41I_pmovx_avx2_patterns<string OpcPrefix, string ExtTy, SDNode ExtOp> {
5671   // Register-Register patterns
5672   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5673   def : Pat<(v16i16 (ExtOp (v16i8 VR128:$src))),
5674             (!cast<I>(OpcPrefix#BWYrr) VR128:$src)>;
5675   }
5676   let Predicates = [HasAVX, NoVLX] in {
5677   def : Pat<(v8i32 (ExtOp (v16i8 VR128:$src))),
5678             (!cast<I>(OpcPrefix#BDYrr) VR128:$src)>;
5679   def : Pat<(v4i64 (ExtOp (v16i8 VR128:$src))),
5680             (!cast<I>(OpcPrefix#BQYrr) VR128:$src)>;
5681
5682   def : Pat<(v8i32 (ExtOp (v8i16 VR128:$src))),
5683             (!cast<I>(OpcPrefix#WDYrr) VR128:$src)>;
5684   def : Pat<(v4i64 (ExtOp (v8i16 VR128:$src))),
5685             (!cast<I>(OpcPrefix#WQYrr) VR128:$src)>;
5686
5687   def : Pat<(v4i64 (ExtOp (v4i32 VR128:$src))),
5688             (!cast<I>(OpcPrefix#DQYrr) VR128:$src)>;
5689   }
5690
5691   // Simple Register-Memory patterns
5692   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5693   def : Pat<(v16i16 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5694             (!cast<I>(OpcPrefix#BWYrm) addr:$src)>;
5695   }
5696   let Predicates = [HasAVX, NoVLX] in {
5697   def : Pat<(v8i32 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5698             (!cast<I>(OpcPrefix#BDYrm) addr:$src)>;
5699   def : Pat<(v4i64 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5700             (!cast<I>(OpcPrefix#BQYrm) addr:$src)>;
5701
5702   def : Pat<(v8i32 (!cast<PatFrag>(ExtTy#"extloadvi16") addr:$src)),
5703             (!cast<I>(OpcPrefix#WDYrm) addr:$src)>;
5704   def : Pat<(v4i64 (!cast<PatFrag>(ExtTy#"extloadvi16") addr:$src)),
5705             (!cast<I>(OpcPrefix#WQYrm) addr:$src)>;
5706
5707   def : Pat<(v4i64 (!cast<PatFrag>(ExtTy#"extloadvi32") addr:$src)),
5708             (!cast<I>(OpcPrefix#DQYrm) addr:$src)>;
5709   }
5710
5711   // AVX2 Register-Memory patterns
5712   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5713   def : Pat<(v16i16 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5714             (!cast<I>(OpcPrefix#BWYrm) addr:$src)>;
5715   def : Pat<(v16i16 (ExtOp (v16i8 (vzmovl_v2i64 addr:$src)))),
5716             (!cast<I>(OpcPrefix#BWYrm) addr:$src)>;
5717   def : Pat<(v16i16 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5718             (!cast<I>(OpcPrefix#BWYrm) addr:$src)>;
5719   }
5720   let Predicates = [HasAVX, NoVLX] in {
5721   def : Pat<(v8i32 (ExtOp (bc_v16i8 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
5722             (!cast<I>(OpcPrefix#BDYrm) addr:$src)>;
5723   def : Pat<(v8i32 (ExtOp (v16i8 (vzmovl_v2i64 addr:$src)))),
5724             (!cast<I>(OpcPrefix#BDYrm) addr:$src)>;
5725   def : Pat<(v8i32 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5726             (!cast<I>(OpcPrefix#BDYrm) addr:$src)>;
5727   def : Pat<(v8i32 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5728             (!cast<I>(OpcPrefix#BDYrm) addr:$src)>;
5729
5730   def : Pat<(v4i64 (ExtOp (bc_v16i8 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
5731             (!cast<I>(OpcPrefix#BQYrm) addr:$src)>;
5732   def : Pat<(v4i64 (ExtOp (v16i8 (vzmovl_v4i32 addr:$src)))),
5733             (!cast<I>(OpcPrefix#BQYrm) addr:$src)>;
5734   def : Pat<(v4i64 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5735             (!cast<I>(OpcPrefix#BQYrm) addr:$src)>;
5736   def : Pat<(v4i64 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5737             (!cast<I>(OpcPrefix#BQYrm) addr:$src)>;
5738
5739   def : Pat<(v8i32 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
5740             (!cast<I>(OpcPrefix#WDYrm) addr:$src)>;
5741   def : Pat<(v8i32 (ExtOp (v8i16 (vzmovl_v2i64 addr:$src)))),
5742             (!cast<I>(OpcPrefix#WDYrm) addr:$src)>;
5743   def : Pat<(v8i32 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
5744             (!cast<I>(OpcPrefix#WDYrm) addr:$src)>;
5745
5746   def : Pat<(v4i64 (ExtOp (bc_v8i16 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
5747             (!cast<I>(OpcPrefix#WQYrm) addr:$src)>;
5748   def : Pat<(v4i64 (ExtOp (v8i16 (vzmovl_v2i64 addr:$src)))),
5749             (!cast<I>(OpcPrefix#WQYrm) addr:$src)>;
5750   def : Pat<(v4i64 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
5751             (!cast<I>(OpcPrefix#WQYrm) addr:$src)>;
5752   def : Pat<(v4i64 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
5753             (!cast<I>(OpcPrefix#WQYrm) addr:$src)>;
5754
5755   def : Pat<(v4i64 (ExtOp (bc_v4i32 (loadv2i64 addr:$src)))),
5756             (!cast<I>(OpcPrefix#DQYrm) addr:$src)>;
5757   def : Pat<(v4i64 (ExtOp (v4i32 (vzmovl_v2i64 addr:$src)))),
5758             (!cast<I>(OpcPrefix#DQYrm) addr:$src)>;
5759   def : Pat<(v4i64 (ExtOp (v4i32 (vzload_v2i64 addr:$src)))),
5760             (!cast<I>(OpcPrefix#DQYrm) addr:$src)>;
5761   }
5762 }
5763
5764 defm : SS41I_pmovx_avx2_patterns<"VPMOVSX", "s", X86vsext>;
5765 defm : SS41I_pmovx_avx2_patterns<"VPMOVZX", "z", X86vzext>;
5766
5767 // SSE4.1/AVX patterns.
5768 multiclass SS41I_pmovx_patterns<string OpcPrefix, string ExtTy,
5769                                 SDNode ExtOp, PatFrag ExtLoad16> {
5770   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5771   def : Pat<(v8i16 (ExtOp (v16i8 VR128:$src))),
5772             (!cast<I>(OpcPrefix#BWrr) VR128:$src)>;
5773   }
5774   let Predicates = [HasAVX, NoVLX] in {
5775   def : Pat<(v4i32 (ExtOp (v16i8 VR128:$src))),
5776             (!cast<I>(OpcPrefix#BDrr) VR128:$src)>;
5777   def : Pat<(v2i64 (ExtOp (v16i8 VR128:$src))),
5778             (!cast<I>(OpcPrefix#BQrr) VR128:$src)>;
5779
5780   def : Pat<(v4i32 (ExtOp (v8i16 VR128:$src))),
5781             (!cast<I>(OpcPrefix#WDrr) VR128:$src)>;
5782   def : Pat<(v2i64 (ExtOp (v8i16 VR128:$src))),
5783             (!cast<I>(OpcPrefix#WQrr) VR128:$src)>;
5784
5785   def : Pat<(v2i64 (ExtOp (v4i32 VR128:$src))),
5786             (!cast<I>(OpcPrefix#DQrr) VR128:$src)>;
5787   }
5788   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5789   def : Pat<(v8i16 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5790             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5791   }
5792   let Predicates = [HasAVX, NoVLX] in {
5793   def : Pat<(v4i32 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5794             (!cast<I>(OpcPrefix#BDrm) addr:$src)>;
5795   def : Pat<(v2i64 (!cast<PatFrag>(ExtTy#"extloadvi8") addr:$src)),
5796             (!cast<I>(OpcPrefix#BQrm) addr:$src)>;
5797
5798   def : Pat<(v4i32 (!cast<PatFrag>(ExtTy#"extloadvi16") addr:$src)),
5799             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5800   def : Pat<(v2i64 (!cast<PatFrag>(ExtTy#"extloadvi16") addr:$src)),
5801             (!cast<I>(OpcPrefix#WQrm) addr:$src)>;
5802
5803   def : Pat<(v2i64 (!cast<PatFrag>(ExtTy#"extloadvi32") addr:$src)),
5804             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5805   }
5806   let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
5807   def : Pat<(v8i16 (ExtOp (bc_v16i8 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
5808             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5809   def : Pat<(v8i16 (ExtOp (bc_v16i8 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
5810             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5811   def : Pat<(v8i16 (ExtOp (v16i8 (vzmovl_v2i64 addr:$src)))),
5812             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5813   def : Pat<(v8i16 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5814             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5815   def : Pat<(v8i16 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5816             (!cast<I>(OpcPrefix#BWrm) addr:$src)>;
5817   }
5818   let Predicates = [HasAVX, NoVLX] in {
5819   def : Pat<(v4i32 (ExtOp (bc_v16i8 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
5820             (!cast<I>(OpcPrefix#BDrm) addr:$src)>;
5821   def : Pat<(v4i32 (ExtOp (v16i8 (vzmovl_v4i32 addr:$src)))),
5822             (!cast<I>(OpcPrefix#BDrm) addr:$src)>;
5823   def : Pat<(v4i32 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5824             (!cast<I>(OpcPrefix#BDrm) addr:$src)>;
5825   def : Pat<(v4i32 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5826             (!cast<I>(OpcPrefix#BDrm) addr:$src)>;
5827
5828   def : Pat<(v2i64 (ExtOp (bc_v16i8 (v4i32 (scalar_to_vector (ExtLoad16 addr:$src)))))),
5829             (!cast<I>(OpcPrefix#BQrm) addr:$src)>;
5830   def : Pat<(v2i64 (ExtOp (v16i8 (vzmovl_v4i32 addr:$src)))),
5831             (!cast<I>(OpcPrefix#BQrm) addr:$src)>;
5832   def : Pat<(v2i64 (ExtOp (v16i8 (vzload_v2i64 addr:$src)))),
5833             (!cast<I>(OpcPrefix#BQrm) addr:$src)>;
5834   def : Pat<(v2i64 (ExtOp (bc_v16i8 (loadv2i64 addr:$src)))),
5835             (!cast<I>(OpcPrefix#BQrm) addr:$src)>;
5836
5837   def : Pat<(v4i32 (ExtOp (bc_v8i16 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
5838             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5839   def : Pat<(v4i32 (ExtOp (bc_v8i16 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
5840             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5841   def : Pat<(v4i32 (ExtOp (v8i16 (vzmovl_v2i64 addr:$src)))),
5842             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5843   def : Pat<(v4i32 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
5844             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5845   def : Pat<(v4i32 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
5846             (!cast<I>(OpcPrefix#WDrm) addr:$src)>;
5847
5848   def : Pat<(v2i64 (ExtOp (bc_v8i16 (v4i32 (scalar_to_vector (loadi32 addr:$src)))))),
5849             (!cast<I>(OpcPrefix#WQrm) addr:$src)>;
5850   def : Pat<(v2i64 (ExtOp (v8i16 (vzmovl_v4i32 addr:$src)))),
5851             (!cast<I>(OpcPrefix#WQrm) addr:$src)>;
5852   def : Pat<(v2i64 (ExtOp (v8i16 (vzload_v2i64 addr:$src)))),
5853             (!cast<I>(OpcPrefix#WQrm) addr:$src)>;
5854   def : Pat<(v2i64 (ExtOp (bc_v8i16 (loadv2i64 addr:$src)))),
5855             (!cast<I>(OpcPrefix#WQrm) addr:$src)>;
5856
5857   def : Pat<(v2i64 (ExtOp (bc_v4i32 (v2i64 (scalar_to_vector (loadi64 addr:$src)))))),
5858             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5859   def : Pat<(v2i64 (ExtOp (bc_v4i32 (v2f64 (scalar_to_vector (loadf64 addr:$src)))))),
5860             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5861   def : Pat<(v2i64 (ExtOp (v4i32 (vzmovl_v2i64 addr:$src)))),
5862             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5863   def : Pat<(v2i64 (ExtOp (v4i32 (vzload_v2i64 addr:$src)))),
5864             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5865   def : Pat<(v2i64 (ExtOp (bc_v4i32 (loadv2i64 addr:$src)))),
5866             (!cast<I>(OpcPrefix#DQrm) addr:$src)>;
5867   }
5868 }
5869
5870 defm : SS41I_pmovx_patterns<"VPMOVSX", "s", sext_invec, extloadi32i16>;
5871 defm : SS41I_pmovx_patterns<"VPMOVZX", "z", zext_invec, loadi16_anyext>;
5872
5873 let Predicates = [UseSSE41] in {
5874   defm : SS41I_pmovx_patterns<"PMOVSX", "s", sext_invec, extloadi32i16>;
5875   defm : SS41I_pmovx_patterns<"PMOVZX", "z", zext_invec, loadi16_anyext>;
5876 }
5877
5878 //===----------------------------------------------------------------------===//
5879 // SSE4.1 - Extract Instructions
5880 //===----------------------------------------------------------------------===//
5881
5882 /// SS41I_binop_ext8 - SSE 4.1 extract 8 bits to 32 bit reg or 8 bit mem
5883 multiclass SS41I_extract8<bits<8> opc, string OpcodeStr> {
5884   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32orGR64:$dst),
5885                  (ins VR128:$src1, u8imm:$src2),
5886                  !strconcat(OpcodeStr,
5887                             "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5888                  [(set GR32orGR64:$dst, (X86pextrb (v16i8 VR128:$src1),
5889                                          imm:$src2))]>,
5890                   Sched<[WriteShuffle]>;
5891   let hasSideEffects = 0, mayStore = 1,
5892       SchedRW = [WriteShuffleLd, WriteRMW] in
5893   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5894                  (ins i8mem:$dst, VR128:$src1, u8imm:$src2),
5895                  !strconcat(OpcodeStr,
5896                             "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5897                  [(store (i8 (trunc (assertzext (X86pextrb (v16i8 VR128:$src1),
5898                                                  imm:$src2)))), addr:$dst)]>;
5899 }
5900
5901 let Predicates = [HasAVX, NoBWI] in
5902   defm VPEXTRB : SS41I_extract8<0x14, "vpextrb">, VEX;
5903
5904 defm PEXTRB      : SS41I_extract8<0x14, "pextrb">;
5905
5906
5907 /// SS41I_extract16 - SSE 4.1 extract 16 bits to memory destination
5908 multiclass SS41I_extract16<bits<8> opc, string OpcodeStr> {
5909   let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0 in
5910   def rr_REV : SS4AIi8<opc, MRMDestReg, (outs GR32orGR64:$dst),
5911                    (ins VR128:$src1, u8imm:$src2),
5912                    !strconcat(OpcodeStr,
5913                    "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5914                    []>, Sched<[WriteShuffle]>;
5915
5916   let hasSideEffects = 0, mayStore = 1,
5917       SchedRW = [WriteShuffleLd, WriteRMW] in
5918   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5919                  (ins i16mem:$dst, VR128:$src1, u8imm:$src2),
5920                  !strconcat(OpcodeStr,
5921                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5922                  [(store (i16 (trunc (assertzext (X86pextrw (v8i16 VR128:$src1),
5923                                                   imm:$src2)))), addr:$dst)]>;
5924 }
5925
5926 let Predicates = [HasAVX, NoBWI] in
5927   defm VPEXTRW : SS41I_extract16<0x15, "vpextrw">, VEX;
5928
5929 defm PEXTRW      : SS41I_extract16<0x15, "pextrw">;
5930
5931
5932 /// SS41I_extract32 - SSE 4.1 extract 32 bits to int reg or memory destination
5933 multiclass SS41I_extract32<bits<8> opc, string OpcodeStr> {
5934   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
5935                  (ins VR128:$src1, u8imm:$src2),
5936                  !strconcat(OpcodeStr,
5937                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5938                  [(set GR32:$dst,
5939                   (extractelt (v4i32 VR128:$src1), imm:$src2))]>,
5940                   Sched<[WriteShuffle]>;
5941   let SchedRW = [WriteShuffleLd, WriteRMW] in
5942   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5943                  (ins i32mem:$dst, VR128:$src1, u8imm:$src2),
5944                  !strconcat(OpcodeStr,
5945                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5946                  [(store (extractelt (v4i32 VR128:$src1), imm:$src2),
5947                           addr:$dst)]>;
5948 }
5949
5950 let Predicates = [HasAVX, NoDQI] in
5951   defm VPEXTRD : SS41I_extract32<0x16, "vpextrd">, VEX;
5952
5953 defm PEXTRD      : SS41I_extract32<0x16, "pextrd">;
5954
5955 /// SS41I_extract32 - SSE 4.1 extract 32 bits to int reg or memory destination
5956 multiclass SS41I_extract64<bits<8> opc, string OpcodeStr> {
5957   def rr : SS4AIi8<opc, MRMDestReg, (outs GR64:$dst),
5958                  (ins VR128:$src1, u8imm:$src2),
5959                  !strconcat(OpcodeStr,
5960                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5961                  [(set GR64:$dst,
5962                   (extractelt (v2i64 VR128:$src1), imm:$src2))]>,
5963                   Sched<[WriteShuffle]>;
5964   let SchedRW = [WriteShuffleLd, WriteRMW] in
5965   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5966                  (ins i64mem:$dst, VR128:$src1, u8imm:$src2),
5967                  !strconcat(OpcodeStr,
5968                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5969                  [(store (extractelt (v2i64 VR128:$src1), imm:$src2),
5970                           addr:$dst)]>;
5971 }
5972
5973 let Predicates = [HasAVX, NoDQI] in
5974   defm VPEXTRQ : SS41I_extract64<0x16, "vpextrq">, VEX, VEX_W;
5975
5976 defm PEXTRQ      : SS41I_extract64<0x16, "pextrq">, REX_W;
5977
5978 /// SS41I_extractf32 - SSE 4.1 extract 32 bits fp value to int reg or memory
5979 /// destination
5980 multiclass SS41I_extractf32<bits<8> opc, string OpcodeStr,
5981                             OpndItins itins = DEFAULT_ITINS> {
5982   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32orGR64:$dst),
5983                  (ins VR128:$src1, u8imm:$src2),
5984                  !strconcat(OpcodeStr,
5985                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5986                  [(set GR32orGR64:$dst,
5987                     (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2))],
5988                     itins.rr>, Sched<[WriteFBlend]>;
5989   let SchedRW = [WriteFBlendLd, WriteRMW] in
5990   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5991                  (ins f32mem:$dst, VR128:$src1, u8imm:$src2),
5992                  !strconcat(OpcodeStr,
5993                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5994                  [(store (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2),
5995                           addr:$dst)], itins.rm>;
5996 }
5997
5998 let ExeDomain = SSEPackedSingle in {
5999   let Predicates = [UseAVX] in
6000     defm VEXTRACTPS : SS41I_extractf32<0x17, "vextractps">, VEX, VEX_WIG;
6001   defm EXTRACTPS   : SS41I_extractf32<0x17, "extractps", SSE_EXTRACT_ITINS>;
6002 }
6003
6004 // Also match an EXTRACTPS store when the store is done as f32 instead of i32.
6005 def : Pat<(store (f32 (bitconvert (extractelt (bc_v4i32 (v4f32 VR128:$src1)),
6006                                               imm:$src2))),
6007                  addr:$dst),
6008           (VEXTRACTPSmr addr:$dst, VR128:$src1, imm:$src2)>,
6009           Requires<[HasAVX]>;
6010 def : Pat<(store (f32 (bitconvert (extractelt (bc_v4i32 (v4f32 VR128:$src1)),
6011                                               imm:$src2))),
6012                  addr:$dst),
6013           (EXTRACTPSmr addr:$dst, VR128:$src1, imm:$src2)>,
6014           Requires<[UseSSE41]>;
6015
6016 //===----------------------------------------------------------------------===//
6017 // SSE4.1 - Insert Instructions
6018 //===----------------------------------------------------------------------===//
6019
6020 multiclass SS41I_insert8<bits<8> opc, string asm, bit Is2Addr = 1> {
6021   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
6022       (ins VR128:$src1, GR32orGR64:$src2, u8imm:$src3),
6023       !if(Is2Addr,
6024         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6025         !strconcat(asm,
6026                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6027       [(set VR128:$dst,
6028         (X86pinsrb VR128:$src1, GR32orGR64:$src2, imm:$src3))]>,
6029       Sched<[WriteShuffle]>;
6030   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
6031       (ins VR128:$src1, i8mem:$src2, u8imm:$src3),
6032       !if(Is2Addr,
6033         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6034         !strconcat(asm,
6035                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6036       [(set VR128:$dst,
6037         (X86pinsrb VR128:$src1, (extloadi8 addr:$src2),
6038                    imm:$src3))]>, Sched<[WriteShuffleLd, ReadAfterLd]>;
6039 }
6040
6041 let Predicates = [HasAVX, NoBWI] in
6042   defm VPINSRB : SS41I_insert8<0x20, "vpinsrb", 0>, VEX_4V;
6043 let Constraints = "$src1 = $dst" in
6044   defm PINSRB  : SS41I_insert8<0x20, "pinsrb">;
6045
6046 multiclass SS41I_insert32<bits<8> opc, string asm, bit Is2Addr = 1> {
6047   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
6048       (ins VR128:$src1, GR32:$src2, u8imm:$src3),
6049       !if(Is2Addr,
6050         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6051         !strconcat(asm,
6052                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6053       [(set VR128:$dst,
6054         (v4i32 (insertelt VR128:$src1, GR32:$src2, imm:$src3)))]>,
6055       Sched<[WriteShuffle]>;
6056   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
6057       (ins VR128:$src1, i32mem:$src2, u8imm:$src3),
6058       !if(Is2Addr,
6059         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6060         !strconcat(asm,
6061                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6062       [(set VR128:$dst,
6063         (v4i32 (insertelt VR128:$src1, (loadi32 addr:$src2),
6064                           imm:$src3)))]>, Sched<[WriteShuffleLd, ReadAfterLd]>;
6065 }
6066
6067 let Predicates = [HasAVX, NoDQI] in
6068   defm VPINSRD : SS41I_insert32<0x22, "vpinsrd", 0>, VEX_4V;
6069 let Constraints = "$src1 = $dst" in
6070   defm PINSRD : SS41I_insert32<0x22, "pinsrd">;
6071
6072 multiclass SS41I_insert64<bits<8> opc, string asm, bit Is2Addr = 1> {
6073   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
6074       (ins VR128:$src1, GR64:$src2, u8imm:$src3),
6075       !if(Is2Addr,
6076         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6077         !strconcat(asm,
6078                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6079       [(set VR128:$dst,
6080         (v2i64 (insertelt VR128:$src1, GR64:$src2, imm:$src3)))]>,
6081       Sched<[WriteShuffle]>;
6082   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
6083       (ins VR128:$src1, i64mem:$src2, u8imm:$src3),
6084       !if(Is2Addr,
6085         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6086         !strconcat(asm,
6087                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6088       [(set VR128:$dst,
6089         (v2i64 (insertelt VR128:$src1, (loadi64 addr:$src2),
6090                           imm:$src3)))]>, Sched<[WriteShuffleLd, ReadAfterLd]>;
6091 }
6092
6093 let Predicates = [HasAVX, NoDQI] in
6094   defm VPINSRQ : SS41I_insert64<0x22, "vpinsrq", 0>, VEX_4V, VEX_W;
6095 let Constraints = "$src1 = $dst" in
6096   defm PINSRQ : SS41I_insert64<0x22, "pinsrq">, REX_W;
6097
6098 // insertps has a few different modes, there's the first two here below which
6099 // are optimized inserts that won't zero arbitrary elements in the destination
6100 // vector. The next one matches the intrinsic and could zero arbitrary elements
6101 // in the target vector.
6102 multiclass SS41I_insertf32<bits<8> opc, string asm, bit Is2Addr = 1,
6103                            OpndItins itins = DEFAULT_ITINS> {
6104   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
6105       (ins VR128:$src1, VR128:$src2, u8imm:$src3),
6106       !if(Is2Addr,
6107         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6108         !strconcat(asm,
6109                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6110       [(set VR128:$dst,
6111         (X86insertps VR128:$src1, VR128:$src2, imm:$src3))], itins.rr>,
6112       Sched<[WriteFShuffle]>;
6113   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
6114       (ins VR128:$src1, f32mem:$src2, u8imm:$src3),
6115       !if(Is2Addr,
6116         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6117         !strconcat(asm,
6118                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6119       [(set VR128:$dst,
6120         (X86insertps VR128:$src1,
6121                    (v4f32 (scalar_to_vector (loadf32 addr:$src2))),
6122                     imm:$src3))], itins.rm>,
6123       Sched<[WriteFShuffleLd, ReadAfterLd]>;
6124 }
6125
6126 let ExeDomain = SSEPackedSingle in {
6127   let Predicates = [UseAVX] in
6128     defm VINSERTPS : SS41I_insertf32<0x21, "vinsertps", 0>, VEX_4V, VEX_WIG;
6129   let Constraints = "$src1 = $dst" in
6130     defm INSERTPS : SS41I_insertf32<0x21, "insertps", 1, SSE_INSERT_ITINS>;
6131 }
6132
6133 let Predicates = [UseSSE41] in {
6134   // If we're inserting an element from a load or a null pshuf of a load,
6135   // fold the load into the insertps instruction.
6136   def : Pat<(v4f32 (X86insertps (v4f32 VR128:$src1), (X86PShufd (v4f32
6137                        (scalar_to_vector (loadf32 addr:$src2))), (i8 0)),
6138                    imm:$src3)),
6139             (INSERTPSrm VR128:$src1, addr:$src2, imm:$src3)>;
6140   def : Pat<(v4f32 (X86insertps (v4f32 VR128:$src1), (X86PShufd
6141                       (loadv4f32 addr:$src2), (i8 0)), imm:$src3)),
6142             (INSERTPSrm VR128:$src1, addr:$src2, imm:$src3)>;
6143 }
6144
6145 let Predicates = [UseAVX] in {
6146   // If we're inserting an element from a vbroadcast of a load, fold the
6147   // load into the X86insertps instruction.
6148   def : Pat<(v4f32 (X86insertps (v4f32 VR128:$src1),
6149                 (X86VBroadcast (loadf32 addr:$src2)), imm:$src3)),
6150             (VINSERTPSrm VR128:$src1, addr:$src2, imm:$src3)>;
6151   def : Pat<(v4f32 (X86insertps (v4f32 VR128:$src1),
6152                 (X86VBroadcast (loadv4f32 addr:$src2)), imm:$src3)),
6153             (VINSERTPSrm VR128:$src1, addr:$src2, imm:$src3)>;
6154 }
6155
6156 //===----------------------------------------------------------------------===//
6157 // SSE4.1 - Round Instructions
6158 //===----------------------------------------------------------------------===//
6159
6160 multiclass sse41_fp_unop_p<bits<8> opcps, bits<8> opcpd, string OpcodeStr,
6161                            X86MemOperand x86memop, RegisterClass RC,
6162                            PatFrag mem_frag32, PatFrag mem_frag64,
6163                            Intrinsic V4F32Int, Intrinsic V2F64Int> {
6164 let ExeDomain = SSEPackedSingle in {
6165   // Intrinsic operation, reg.
6166   // Vector intrinsic operation, reg
6167   def PSr : SS4AIi8<opcps, MRMSrcReg,
6168                     (outs RC:$dst), (ins RC:$src1, i32u8imm:$src2),
6169                     !strconcat(OpcodeStr,
6170                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6171                     [(set RC:$dst, (V4F32Int RC:$src1, imm:$src2))],
6172                     IIC_SSE_ROUNDPS_REG>, Sched<[WriteFAdd]>;
6173
6174   // Vector intrinsic operation, mem
6175   def PSm : SS4AIi8<opcps, MRMSrcMem,
6176                     (outs RC:$dst), (ins x86memop:$src1, i32u8imm:$src2),
6177                     !strconcat(OpcodeStr,
6178                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6179                     [(set RC:$dst,
6180                           (V4F32Int (mem_frag32 addr:$src1),imm:$src2))],
6181                           IIC_SSE_ROUNDPS_MEM>, Sched<[WriteFAddLd]>;
6182 } // ExeDomain = SSEPackedSingle
6183
6184 let ExeDomain = SSEPackedDouble in {
6185   // Vector intrinsic operation, reg
6186   def PDr : SS4AIi8<opcpd, MRMSrcReg,
6187                     (outs RC:$dst), (ins RC:$src1, i32u8imm:$src2),
6188                     !strconcat(OpcodeStr,
6189                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6190                     [(set RC:$dst, (V2F64Int RC:$src1, imm:$src2))],
6191                     IIC_SSE_ROUNDPS_REG>, Sched<[WriteFAdd]>;
6192
6193   // Vector intrinsic operation, mem
6194   def PDm : SS4AIi8<opcpd, MRMSrcMem,
6195                     (outs RC:$dst), (ins x86memop:$src1, i32u8imm:$src2),
6196                     !strconcat(OpcodeStr,
6197                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6198                     [(set RC:$dst,
6199                           (V2F64Int (mem_frag64 addr:$src1),imm:$src2))],
6200                           IIC_SSE_ROUNDPS_REG>, Sched<[WriteFAddLd]>;
6201 } // ExeDomain = SSEPackedDouble
6202 }
6203
6204 multiclass avx_fp_unop_rm<bits<8> opcss, bits<8> opcsd,
6205                           string OpcodeStr> {
6206 let ExeDomain = GenericDomain, hasSideEffects = 0 in {
6207   def SSr : SS4AIi8<opcss, MRMSrcReg,
6208         (outs FR32:$dst), (ins FR32:$src1, FR32:$src2, i32u8imm:$src3),
6209         !strconcat(OpcodeStr,
6210             "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6211       []>, Sched<[WriteFAdd]>;
6212
6213   let mayLoad = 1 in
6214   def SSm : SS4AIi8<opcss, MRMSrcMem,
6215         (outs FR32:$dst), (ins FR32:$src1, f32mem:$src2, i32u8imm:$src3),
6216         !strconcat(OpcodeStr,
6217              "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6218         []>, Sched<[WriteFAddLd, ReadAfterLd]>;
6219
6220   def SDr : SS4AIi8<opcsd, MRMSrcReg,
6221         (outs FR64:$dst), (ins FR64:$src1, FR64:$src2, i32u8imm:$src3),
6222         !strconcat(OpcodeStr,
6223               "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6224         []>, Sched<[WriteFAdd]>;
6225
6226   let mayLoad = 1 in
6227   def SDm : SS4AIi8<opcsd, MRMSrcMem,
6228         (outs FR64:$dst), (ins FR64:$src1, f64mem:$src2, i32u8imm:$src3),
6229         !strconcat(OpcodeStr,
6230              "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6231         []>, Sched<[WriteFAddLd, ReadAfterLd]>;
6232 } // ExeDomain = GenericDomain, hasSideEffects = 0
6233 }
6234
6235 multiclass sse41_fp_unop_s<bits<8> opcss, bits<8> opcsd,
6236                            string OpcodeStr> {
6237 let ExeDomain = GenericDomain, hasSideEffects = 0 in {
6238   def SSr : SS4AIi8<opcss, MRMSrcReg,
6239                     (outs FR32:$dst), (ins FR32:$src1, i32u8imm:$src2),
6240                     !strconcat(OpcodeStr,
6241                                "ss\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6242                     []>, Sched<[WriteFAdd]>;
6243
6244   let mayLoad = 1 in
6245   def SSm : SS4AIi8<opcss, MRMSrcMem,
6246                     (outs FR32:$dst), (ins f32mem:$src1, i32u8imm:$src2),
6247                     !strconcat(OpcodeStr,
6248                                "ss\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6249                     []>, Sched<[WriteFAddLd, ReadAfterLd]>;
6250
6251   def SDr : SS4AIi8<opcsd, MRMSrcReg,
6252                     (outs FR64:$dst), (ins FR64:$src1, i32u8imm:$src2),
6253                     !strconcat(OpcodeStr,
6254                                "sd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6255                     []>, Sched<[WriteFAdd]>;
6256
6257   let mayLoad = 1 in
6258   def SDm : SS4AIi8<opcsd, MRMSrcMem,
6259                     (outs FR64:$dst), (ins f64mem:$src1, i32u8imm:$src2),
6260                     !strconcat(OpcodeStr,
6261                                "sd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6262                     []>, Sched<[WriteFAddLd, ReadAfterLd]>;
6263 } // ExeDomain = GenericDomain, hasSideEffects = 0
6264 }
6265
6266 multiclass sse41_fp_binop_s<bits<8> opcss, bits<8> opcsd,
6267                             string OpcodeStr,
6268                             Intrinsic F32Int,
6269                             Intrinsic F64Int, bit Is2Addr = 1> {
6270 let ExeDomain = GenericDomain, isCodeGenOnly = 1 in {
6271   def SSr_Int : SS4AIi8<opcss, MRMSrcReg,
6272         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32u8imm:$src3),
6273         !if(Is2Addr,
6274             !strconcat(OpcodeStr,
6275                 "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6276             !strconcat(OpcodeStr,
6277                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6278         [(set VR128:$dst, (F32Int VR128:$src1, VR128:$src2, imm:$src3))]>,
6279         Sched<[WriteFAdd]>;
6280
6281   def SSm_Int : SS4AIi8<opcss, MRMSrcMem,
6282         (outs VR128:$dst), (ins VR128:$src1, ssmem:$src2, i32u8imm:$src3),
6283         !if(Is2Addr,
6284             !strconcat(OpcodeStr,
6285                 "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6286             !strconcat(OpcodeStr,
6287                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6288         [(set VR128:$dst,
6289              (F32Int VR128:$src1, sse_load_f32:$src2, imm:$src3))]>,
6290         Sched<[WriteFAddLd, ReadAfterLd]>;
6291
6292   def SDr_Int : SS4AIi8<opcsd, MRMSrcReg,
6293         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32u8imm:$src3),
6294         !if(Is2Addr,
6295             !strconcat(OpcodeStr,
6296                 "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6297             !strconcat(OpcodeStr,
6298                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6299         [(set VR128:$dst, (F64Int VR128:$src1, VR128:$src2, imm:$src3))]>,
6300         Sched<[WriteFAdd]>;
6301
6302   def SDm_Int : SS4AIi8<opcsd, MRMSrcMem,
6303         (outs VR128:$dst), (ins VR128:$src1, sdmem:$src2, i32u8imm:$src3),
6304         !if(Is2Addr,
6305             !strconcat(OpcodeStr,
6306                 "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6307             !strconcat(OpcodeStr,
6308                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6309         [(set VR128:$dst,
6310               (F64Int VR128:$src1, sse_load_f64:$src2, imm:$src3))]>,
6311         Sched<[WriteFAddLd, ReadAfterLd]>;
6312 } // ExeDomain = GenericDomain, isCodeGenOnly = 1
6313 }
6314
6315 // FP round - roundss, roundps, roundsd, roundpd
6316 let Predicates = [HasAVX] in {
6317   // Intrinsic form
6318   defm VROUND  : sse41_fp_unop_p<0x08, 0x09, "vround", f128mem, VR128,
6319                                  loadv4f32, loadv2f64,
6320                                  int_x86_sse41_round_ps,
6321                                  int_x86_sse41_round_pd>, VEX, VEX_WIG;
6322   defm VROUNDY : sse41_fp_unop_p<0x08, 0x09, "vround", f256mem, VR256,
6323                                  loadv8f32, loadv4f64,
6324                                  int_x86_avx_round_ps_256,
6325                                  int_x86_avx_round_pd_256>, VEX, VEX_L, VEX_WIG;
6326   defm VROUND  : sse41_fp_binop_s<0x0A, 0x0B, "vround",
6327                                  int_x86_sse41_round_ss,
6328                                  int_x86_sse41_round_sd, 0>, VEX_4V, VEX_LIG, VEX_WIG;
6329   defm VROUND  : avx_fp_unop_rm<0x0A, 0x0B, "vround">, VEX_4V, VEX_LIG;
6330 }
6331
6332 let Predicates = [UseAVX] in {
6333   def : Pat<(ffloor FR32:$src),
6334             (VROUNDSSr (f32 (IMPLICIT_DEF)), FR32:$src, (i32 0x9))>;
6335   def : Pat<(f64 (ffloor FR64:$src)),
6336             (VROUNDSDr (f64 (IMPLICIT_DEF)), FR64:$src, (i32 0x9))>;
6337   def : Pat<(f32 (fnearbyint FR32:$src)),
6338             (VROUNDSSr (f32 (IMPLICIT_DEF)), FR32:$src, (i32 0xC))>;
6339   def : Pat<(f64 (fnearbyint FR64:$src)),
6340             (VROUNDSDr (f64 (IMPLICIT_DEF)), FR64:$src, (i32 0xC))>;
6341   def : Pat<(f32 (fceil FR32:$src)),
6342             (VROUNDSSr (f32 (IMPLICIT_DEF)), FR32:$src, (i32 0xA))>;
6343   def : Pat<(f64 (fceil FR64:$src)),
6344             (VROUNDSDr (f64 (IMPLICIT_DEF)), FR64:$src, (i32 0xA))>;
6345   def : Pat<(f32 (frint FR32:$src)),
6346             (VROUNDSSr (f32 (IMPLICIT_DEF)), FR32:$src, (i32 0x4))>;
6347   def : Pat<(f64 (frint FR64:$src)),
6348             (VROUNDSDr (f64 (IMPLICIT_DEF)), FR64:$src, (i32 0x4))>;
6349   def : Pat<(f32 (ftrunc FR32:$src)),
6350             (VROUNDSSr (f32 (IMPLICIT_DEF)), FR32:$src, (i32 0xB))>;
6351   def : Pat<(f64 (ftrunc FR64:$src)),
6352             (VROUNDSDr (f64 (IMPLICIT_DEF)), FR64:$src, (i32 0xB))>;
6353 }
6354
6355 let Predicates = [HasAVX] in {
6356   def : Pat<(v4f32 (ffloor VR128:$src)),
6357             (VROUNDPSr VR128:$src, (i32 0x9))>;
6358   def : Pat<(v4f32 (fnearbyint VR128:$src)),
6359             (VROUNDPSr VR128:$src, (i32 0xC))>;
6360   def : Pat<(v4f32 (fceil VR128:$src)),
6361             (VROUNDPSr VR128:$src, (i32 0xA))>;
6362   def : Pat<(v4f32 (frint VR128:$src)),
6363             (VROUNDPSr VR128:$src, (i32 0x4))>;
6364   def : Pat<(v4f32 (ftrunc VR128:$src)),
6365             (VROUNDPSr VR128:$src, (i32 0xB))>;
6366
6367   def : Pat<(v2f64 (ffloor VR128:$src)),
6368             (VROUNDPDr VR128:$src, (i32 0x9))>;
6369   def : Pat<(v2f64 (fnearbyint VR128:$src)),
6370             (VROUNDPDr VR128:$src, (i32 0xC))>;
6371   def : Pat<(v2f64 (fceil VR128:$src)),
6372             (VROUNDPDr VR128:$src, (i32 0xA))>;
6373   def : Pat<(v2f64 (frint VR128:$src)),
6374             (VROUNDPDr VR128:$src, (i32 0x4))>;
6375   def : Pat<(v2f64 (ftrunc VR128:$src)),
6376             (VROUNDPDr VR128:$src, (i32 0xB))>;
6377
6378   def : Pat<(v8f32 (ffloor VR256:$src)),
6379             (VROUNDYPSr VR256:$src, (i32 0x9))>;
6380   def : Pat<(v8f32 (fnearbyint VR256:$src)),
6381             (VROUNDYPSr VR256:$src, (i32 0xC))>;
6382   def : Pat<(v8f32 (fceil VR256:$src)),
6383             (VROUNDYPSr VR256:$src, (i32 0xA))>;
6384   def : Pat<(v8f32 (frint VR256:$src)),
6385             (VROUNDYPSr VR256:$src, (i32 0x4))>;
6386   def : Pat<(v8f32 (ftrunc VR256:$src)),
6387             (VROUNDYPSr VR256:$src, (i32 0xB))>;
6388
6389   def : Pat<(v4f64 (ffloor VR256:$src)),
6390             (VROUNDYPDr VR256:$src, (i32 0x9))>;
6391   def : Pat<(v4f64 (fnearbyint VR256:$src)),
6392             (VROUNDYPDr VR256:$src, (i32 0xC))>;
6393   def : Pat<(v4f64 (fceil VR256:$src)),
6394             (VROUNDYPDr VR256:$src, (i32 0xA))>;
6395   def : Pat<(v4f64 (frint VR256:$src)),
6396             (VROUNDYPDr VR256:$src, (i32 0x4))>;
6397   def : Pat<(v4f64 (ftrunc VR256:$src)),
6398             (VROUNDYPDr VR256:$src, (i32 0xB))>;
6399 }
6400
6401 defm ROUND  : sse41_fp_unop_p<0x08, 0x09, "round", f128mem, VR128,
6402                               memopv4f32, memopv2f64, int_x86_sse41_round_ps,
6403                               int_x86_sse41_round_pd>;
6404
6405 defm ROUND  : sse41_fp_unop_s<0x0A, 0x0B, "round">;
6406
6407 let Constraints = "$src1 = $dst" in
6408 defm ROUND  : sse41_fp_binop_s<0x0A, 0x0B, "round",
6409                                int_x86_sse41_round_ss, int_x86_sse41_round_sd>;
6410
6411 let Predicates = [UseSSE41] in {
6412   def : Pat<(ffloor FR32:$src),
6413             (ROUNDSSr FR32:$src, (i32 0x9))>;
6414   def : Pat<(f64 (ffloor FR64:$src)),
6415             (ROUNDSDr FR64:$src, (i32 0x9))>;
6416   def : Pat<(f32 (fnearbyint FR32:$src)),
6417             (ROUNDSSr FR32:$src, (i32 0xC))>;
6418   def : Pat<(f64 (fnearbyint FR64:$src)),
6419             (ROUNDSDr FR64:$src, (i32 0xC))>;
6420   def : Pat<(f32 (fceil FR32:$src)),
6421             (ROUNDSSr FR32:$src, (i32 0xA))>;
6422   def : Pat<(f64 (fceil FR64:$src)),
6423             (ROUNDSDr FR64:$src, (i32 0xA))>;
6424   def : Pat<(f32 (frint FR32:$src)),
6425             (ROUNDSSr FR32:$src, (i32 0x4))>;
6426   def : Pat<(f64 (frint FR64:$src)),
6427             (ROUNDSDr FR64:$src, (i32 0x4))>;
6428   def : Pat<(f32 (ftrunc FR32:$src)),
6429             (ROUNDSSr FR32:$src, (i32 0xB))>;
6430   def : Pat<(f64 (ftrunc FR64:$src)),
6431             (ROUNDSDr FR64:$src, (i32 0xB))>;
6432
6433   def : Pat<(v4f32 (ffloor VR128:$src)),
6434             (ROUNDPSr VR128:$src, (i32 0x9))>;
6435   def : Pat<(v4f32 (fnearbyint VR128:$src)),
6436             (ROUNDPSr VR128:$src, (i32 0xC))>;
6437   def : Pat<(v4f32 (fceil VR128:$src)),
6438             (ROUNDPSr VR128:$src, (i32 0xA))>;
6439   def : Pat<(v4f32 (frint VR128:$src)),
6440             (ROUNDPSr VR128:$src, (i32 0x4))>;
6441   def : Pat<(v4f32 (ftrunc VR128:$src)),
6442             (ROUNDPSr VR128:$src, (i32 0xB))>;
6443
6444   def : Pat<(v2f64 (ffloor VR128:$src)),
6445             (ROUNDPDr VR128:$src, (i32 0x9))>;
6446   def : Pat<(v2f64 (fnearbyint VR128:$src)),
6447             (ROUNDPDr VR128:$src, (i32 0xC))>;
6448   def : Pat<(v2f64 (fceil VR128:$src)),
6449             (ROUNDPDr VR128:$src, (i32 0xA))>;
6450   def : Pat<(v2f64 (frint VR128:$src)),
6451             (ROUNDPDr VR128:$src, (i32 0x4))>;
6452   def : Pat<(v2f64 (ftrunc VR128:$src)),
6453             (ROUNDPDr VR128:$src, (i32 0xB))>;
6454 }
6455
6456 //===----------------------------------------------------------------------===//
6457 // SSE4.1 - Packed Bit Test
6458 //===----------------------------------------------------------------------===//
6459
6460 // ptest instruction we'll lower to this in X86ISelLowering primarily from
6461 // the intel intrinsic that corresponds to this.
6462 let Defs = [EFLAGS], Predicates = [HasAVX] in {
6463 def VPTESTrr  : SS48I<0x17, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
6464                 "vptest\t{$src2, $src1|$src1, $src2}",
6465                 [(set EFLAGS, (X86ptest VR128:$src1, (v2i64 VR128:$src2)))]>,
6466                 Sched<[WriteVecLogic]>, VEX, VEX_WIG;
6467 def VPTESTrm  : SS48I<0x17, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
6468                 "vptest\t{$src2, $src1|$src1, $src2}",
6469                 [(set EFLAGS,(X86ptest VR128:$src1, (loadv2i64 addr:$src2)))]>,
6470                 Sched<[WriteVecLogicLd, ReadAfterLd]>, VEX, VEX_WIG;
6471
6472 def VPTESTYrr : SS48I<0x17, MRMSrcReg, (outs), (ins VR256:$src1, VR256:$src2),
6473                 "vptest\t{$src2, $src1|$src1, $src2}",
6474                 [(set EFLAGS, (X86ptest VR256:$src1, (v4i64 VR256:$src2)))]>,
6475                 Sched<[WriteVecLogic]>, VEX, VEX_L, VEX_WIG;
6476 def VPTESTYrm : SS48I<0x17, MRMSrcMem, (outs), (ins VR256:$src1, i256mem:$src2),
6477                 "vptest\t{$src2, $src1|$src1, $src2}",
6478                 [(set EFLAGS,(X86ptest VR256:$src1, (loadv4i64 addr:$src2)))]>,
6479                 Sched<[WriteVecLogicLd, ReadAfterLd]>, VEX, VEX_L, VEX_WIG;
6480 }
6481
6482 let Defs = [EFLAGS] in {
6483 def PTESTrr : SS48I<0x17, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
6484               "ptest\t{$src2, $src1|$src1, $src2}",
6485               [(set EFLAGS, (X86ptest VR128:$src1, (v2i64 VR128:$src2)))]>,
6486               Sched<[WriteVecLogic]>;
6487 def PTESTrm : SS48I<0x17, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
6488               "ptest\t{$src2, $src1|$src1, $src2}",
6489               [(set EFLAGS, (X86ptest VR128:$src1, (memopv2i64 addr:$src2)))]>,
6490               Sched<[WriteVecLogicLd, ReadAfterLd]>;
6491 }
6492
6493 // The bit test instructions below are AVX only
6494 multiclass avx_bittest<bits<8> opc, string OpcodeStr, RegisterClass RC,
6495                        X86MemOperand x86memop, PatFrag mem_frag, ValueType vt> {
6496   def rr : SS48I<opc, MRMSrcReg, (outs), (ins RC:$src1, RC:$src2),
6497             !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
6498             [(set EFLAGS, (X86testp RC:$src1, (vt RC:$src2)))]>,
6499             Sched<[WriteVecLogic]>, VEX;
6500   def rm : SS48I<opc, MRMSrcMem, (outs), (ins RC:$src1, x86memop:$src2),
6501             !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
6502             [(set EFLAGS, (X86testp RC:$src1, (mem_frag addr:$src2)))]>,
6503             Sched<[WriteVecLogicLd, ReadAfterLd]>, VEX;
6504 }
6505
6506 let Defs = [EFLAGS], Predicates = [HasAVX] in {
6507 let ExeDomain = SSEPackedSingle in {
6508 defm VTESTPS  : avx_bittest<0x0E, "vtestps", VR128, f128mem, loadv4f32, v4f32>;
6509 defm VTESTPSY : avx_bittest<0x0E, "vtestps", VR256, f256mem, loadv8f32, v8f32>,
6510                             VEX_L;
6511 }
6512 let ExeDomain = SSEPackedDouble in {
6513 defm VTESTPD  : avx_bittest<0x0F, "vtestpd", VR128, f128mem, loadv2f64, v2f64>;
6514 defm VTESTPDY : avx_bittest<0x0F, "vtestpd", VR256, f256mem, loadv4f64, v4f64>,
6515                             VEX_L;
6516 }
6517 }
6518
6519 //===----------------------------------------------------------------------===//
6520 // SSE4.1 - Misc Instructions
6521 //===----------------------------------------------------------------------===//
6522
6523 let Defs = [EFLAGS], Predicates = [HasPOPCNT] in {
6524   def POPCNT16rr : I<0xB8, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
6525                      "popcnt{w}\t{$src, $dst|$dst, $src}",
6526                      [(set GR16:$dst, (ctpop GR16:$src)), (implicit EFLAGS)],
6527                      IIC_SSE_POPCNT_RR>, Sched<[WriteFAdd]>,
6528                      OpSize16, XS;
6529   def POPCNT16rm : I<0xB8, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
6530                      "popcnt{w}\t{$src, $dst|$dst, $src}",
6531                      [(set GR16:$dst, (ctpop (loadi16 addr:$src))),
6532                       (implicit EFLAGS)], IIC_SSE_POPCNT_RM>,
6533                       Sched<[WriteFAddLd]>, OpSize16, XS;
6534
6535   def POPCNT32rr : I<0xB8, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
6536                      "popcnt{l}\t{$src, $dst|$dst, $src}",
6537                      [(set GR32:$dst, (ctpop GR32:$src)), (implicit EFLAGS)],
6538                      IIC_SSE_POPCNT_RR>, Sched<[WriteFAdd]>,
6539                      OpSize32, XS;
6540
6541   def POPCNT32rm : I<0xB8, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
6542                      "popcnt{l}\t{$src, $dst|$dst, $src}",
6543                      [(set GR32:$dst, (ctpop (loadi32 addr:$src))),
6544                       (implicit EFLAGS)], IIC_SSE_POPCNT_RM>,
6545                       Sched<[WriteFAddLd]>, OpSize32, XS;
6546
6547   def POPCNT64rr : RI<0xB8, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
6548                       "popcnt{q}\t{$src, $dst|$dst, $src}",
6549                       [(set GR64:$dst, (ctpop GR64:$src)), (implicit EFLAGS)],
6550                       IIC_SSE_POPCNT_RR>, Sched<[WriteFAdd]>, XS;
6551   def POPCNT64rm : RI<0xB8, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
6552                       "popcnt{q}\t{$src, $dst|$dst, $src}",
6553                       [(set GR64:$dst, (ctpop (loadi64 addr:$src))),
6554                        (implicit EFLAGS)], IIC_SSE_POPCNT_RM>,
6555                        Sched<[WriteFAddLd]>, XS;
6556 }
6557
6558
6559
6560 // SS41I_unop_rm_int_v16 - SSE 4.1 unary operator whose type is v8i16.
6561 multiclass SS41I_unop_rm_int_v16<bits<8> opc, string OpcodeStr,
6562                                  Intrinsic IntId128, PatFrag ld_frag,
6563                                  X86FoldableSchedWrite Sched> {
6564   def rr128 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
6565                     (ins VR128:$src),
6566                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
6567                     [(set VR128:$dst, (IntId128 VR128:$src))]>,
6568                     Sched<[Sched]>;
6569   def rm128 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
6570                      (ins i128mem:$src),
6571                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
6572                      [(set VR128:$dst,
6573                        (IntId128 (bitconvert (ld_frag addr:$src))))]>,
6574                     Sched<[Sched.Folded]>;
6575 }
6576
6577 // PHMIN has the same profile as PSAD, thus we use the same scheduling
6578 // model, although the naming is misleading.
6579 let Predicates = [HasAVX] in
6580 defm VPHMINPOSUW : SS41I_unop_rm_int_v16 <0x41, "vphminposuw",
6581                                          int_x86_sse41_phminposuw, loadv2i64,
6582                                          WriteVecIMul>, VEX, VEX_WIG;
6583 defm PHMINPOSUW : SS41I_unop_rm_int_v16 <0x41, "phminposuw",
6584                                          int_x86_sse41_phminposuw, memopv2i64,
6585                                          WriteVecIMul>;
6586
6587 /// SS48I_binop_rm - Simple SSE41 binary operator.
6588 multiclass SS48I_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
6589                           ValueType OpVT, RegisterClass RC, PatFrag memop_frag,
6590                           X86MemOperand x86memop, bit Is2Addr = 1,
6591                           OpndItins itins = SSE_INTALU_ITINS_P> {
6592   let isCommutable = 1 in
6593   def rr : SS48I<opc, MRMSrcReg, (outs RC:$dst),
6594        (ins RC:$src1, RC:$src2),
6595        !if(Is2Addr,
6596            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6597            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6598        [(set RC:$dst, (OpVT (OpNode RC:$src1, RC:$src2)))]>,
6599        Sched<[itins.Sched]>;
6600   def rm : SS48I<opc, MRMSrcMem, (outs RC:$dst),
6601        (ins RC:$src1, x86memop:$src2),
6602        !if(Is2Addr,
6603            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6604            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6605        [(set RC:$dst,
6606          (OpVT (OpNode RC:$src1, (bitconvert (memop_frag addr:$src2)))))]>,
6607        Sched<[itins.Sched.Folded, ReadAfterLd]>;
6608 }
6609
6610 /// SS48I_binop_rm2 - Simple SSE41 binary operator with different src and dst
6611 /// types.
6612 multiclass SS48I_binop_rm2<bits<8> opc, string OpcodeStr, SDNode OpNode,
6613                          ValueType DstVT, ValueType SrcVT, RegisterClass RC,
6614                          PatFrag memop_frag, X86MemOperand x86memop,
6615                          OpndItins itins,
6616                          bit IsCommutable = 0, bit Is2Addr = 1> {
6617   let isCommutable = IsCommutable in
6618   def rr : SS48I<opc, MRMSrcReg, (outs RC:$dst),
6619        (ins RC:$src1, RC:$src2),
6620        !if(Is2Addr,
6621            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6622            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6623        [(set RC:$dst, (DstVT (OpNode (SrcVT RC:$src1), RC:$src2)))]>,
6624        Sched<[itins.Sched]>;
6625   def rm : SS48I<opc, MRMSrcMem, (outs RC:$dst),
6626        (ins RC:$src1, x86memop:$src2),
6627        !if(Is2Addr,
6628            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6629            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6630        [(set RC:$dst, (DstVT (OpNode (SrcVT RC:$src1),
6631                                      (bitconvert (memop_frag addr:$src2)))))]>,
6632        Sched<[itins.Sched.Folded, ReadAfterLd]>;
6633 }
6634
6635 let Predicates = [HasAVX, NoVLX] in {
6636   defm VPMINSD   : SS48I_binop_rm<0x39, "vpminsd", smin, v4i32, VR128,
6637                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6638                                   VEX_4V, VEX_WIG;
6639   defm VPMINUD   : SS48I_binop_rm<0x3B, "vpminud", umin, v4i32, VR128,
6640                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6641                                   VEX_4V, VEX_WIG;
6642   defm VPMAXSD   : SS48I_binop_rm<0x3D, "vpmaxsd", smax, v4i32, VR128,
6643                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6644                                   VEX_4V, VEX_WIG;
6645   defm VPMAXUD   : SS48I_binop_rm<0x3F, "vpmaxud", umax, v4i32, VR128,
6646                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6647                                   VEX_4V, VEX_WIG;
6648   defm VPMULDQ   : SS48I_binop_rm2<0x28, "vpmuldq", X86pmuldq, v2i64, v4i32,
6649                                    VR128, loadv2i64, i128mem,
6650                                    SSE_INTMUL_ITINS_P, 1, 0>, VEX_4V, VEX_WIG;
6651 }
6652 let Predicates = [HasAVX, NoVLX_Or_NoBWI] in {
6653   defm VPMINSB   : SS48I_binop_rm<0x38, "vpminsb", smin, v16i8, VR128,
6654                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6655                                   VEX_4V, VEX_WIG;
6656   defm VPMINUW   : SS48I_binop_rm<0x3A, "vpminuw", umin, v8i16, VR128,
6657                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6658                                   VEX_4V, VEX_WIG;
6659   defm VPMAXSB   : SS48I_binop_rm<0x3C, "vpmaxsb", smax, v16i8, VR128,
6660                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6661                                   VEX_4V, VEX_WIG;
6662   defm VPMAXUW   : SS48I_binop_rm<0x3E, "vpmaxuw", umax, v8i16, VR128,
6663                                   loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6664                                   VEX_4V, VEX_WIG;
6665 }
6666
6667 let Predicates = [HasAVX2, NoVLX] in {
6668   defm VPMINSDY  : SS48I_binop_rm<0x39, "vpminsd", smin, v8i32, VR256,
6669                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6670                                   VEX_4V, VEX_L, VEX_WIG;
6671   defm VPMINUDY  : SS48I_binop_rm<0x3B, "vpminud", umin, v8i32, VR256,
6672                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6673                                   VEX_4V, VEX_L, VEX_WIG;
6674   defm VPMAXSDY  : SS48I_binop_rm<0x3D, "vpmaxsd", smax, v8i32, VR256,
6675                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6676                                   VEX_4V, VEX_L, VEX_WIG;
6677   defm VPMAXUDY  : SS48I_binop_rm<0x3F, "vpmaxud", umax, v8i32, VR256,
6678                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6679                                   VEX_4V, VEX_L, VEX_WIG;
6680   defm VPMULDQY : SS48I_binop_rm2<0x28, "vpmuldq", X86pmuldq, v4i64, v8i32,
6681                                   VR256, loadv4i64, i256mem,
6682                                   SSE_INTMUL_ITINS_P, 1, 0>, VEX_4V, VEX_L, VEX_WIG;
6683 }
6684 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
6685   defm VPMINSBY  : SS48I_binop_rm<0x38, "vpminsb", smin, v32i8, VR256,
6686                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6687                                   VEX_4V, VEX_L, VEX_WIG;
6688   defm VPMINUWY  : SS48I_binop_rm<0x3A, "vpminuw", umin, v16i16, VR256,
6689                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6690                                   VEX_4V, VEX_L, VEX_WIG;
6691   defm VPMAXSBY  : SS48I_binop_rm<0x3C, "vpmaxsb", smax, v32i8, VR256,
6692                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6693                                   VEX_4V, VEX_L, VEX_WIG;
6694   defm VPMAXUWY  : SS48I_binop_rm<0x3E, "vpmaxuw", umax, v16i16, VR256,
6695                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6696                                   VEX_4V, VEX_L, VEX_WIG;
6697 }
6698
6699 let Constraints = "$src1 = $dst" in {
6700   defm PMINSB   : SS48I_binop_rm<0x38, "pminsb", smin, v16i8, VR128,
6701                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6702   defm PMINSD   : SS48I_binop_rm<0x39, "pminsd", smin, v4i32, VR128,
6703                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6704   defm PMINUD   : SS48I_binop_rm<0x3B, "pminud", umin, v4i32, VR128,
6705                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6706   defm PMINUW   : SS48I_binop_rm<0x3A, "pminuw", umin, v8i16, VR128,
6707                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6708   defm PMAXSB   : SS48I_binop_rm<0x3C, "pmaxsb", smax, v16i8, VR128,
6709                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6710   defm PMAXSD   : SS48I_binop_rm<0x3D, "pmaxsd", smax, v4i32, VR128,
6711                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6712   defm PMAXUD   : SS48I_binop_rm<0x3F, "pmaxud", umax, v4i32, VR128,
6713                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6714   defm PMAXUW   : SS48I_binop_rm<0x3E, "pmaxuw", umax, v8i16, VR128,
6715                                  memopv2i64, i128mem, 1, SSE_INTALU_ITINS_P>;
6716   defm PMULDQ   : SS48I_binop_rm2<0x28, "pmuldq", X86pmuldq, v2i64, v4i32,
6717                                   VR128, memopv2i64, i128mem,
6718                                   SSE_INTMUL_ITINS_P, 1>;
6719 }
6720
6721 let Predicates = [HasAVX, NoVLX] in {
6722   defm VPMULLD  : SS48I_binop_rm<0x40, "vpmulld", mul, v4i32, VR128,
6723                                  loadv2i64, i128mem, 0, SSE_PMULLD_ITINS>,
6724                                  VEX_4V, VEX_WIG;
6725   defm VPCMPEQQ : SS48I_binop_rm<0x29, "vpcmpeqq", X86pcmpeq, v2i64, VR128,
6726                                  loadv2i64, i128mem, 0, SSE_INTALU_ITINS_P>,
6727                                  VEX_4V, VEX_WIG;
6728 }
6729 let Predicates = [HasAVX2] in {
6730   defm VPMULLDY  : SS48I_binop_rm<0x40, "vpmulld", mul, v8i32, VR256,
6731                                   loadv4i64, i256mem, 0, SSE_PMULLD_ITINS>,
6732                                   VEX_4V, VEX_L, VEX_WIG;
6733   defm VPCMPEQQY : SS48I_binop_rm<0x29, "vpcmpeqq", X86pcmpeq, v4i64, VR256,
6734                                   loadv4i64, i256mem, 0, SSE_INTALU_ITINS_P>,
6735                                   VEX_4V, VEX_L, VEX_WIG;
6736 }
6737
6738 let Constraints = "$src1 = $dst" in {
6739   defm PMULLD  : SS48I_binop_rm<0x40, "pmulld", mul, v4i32, VR128,
6740                                 memopv2i64, i128mem, 1, SSE_PMULLD_ITINS>;
6741   defm PCMPEQQ : SS48I_binop_rm<0x29, "pcmpeqq", X86pcmpeq, v2i64, VR128,
6742                                 memopv2i64, i128mem, 1, SSE_INTALUQ_ITINS_P>;
6743 }
6744
6745 /// SS41I_binop_rmi_int - SSE 4.1 binary operator with 8-bit immediate
6746 multiclass SS41I_binop_rmi_int<bits<8> opc, string OpcodeStr,
6747                  Intrinsic IntId, RegisterClass RC, PatFrag memop_frag,
6748                  X86MemOperand x86memop, bit Is2Addr = 1,
6749                  OpndItins itins = DEFAULT_ITINS> {
6750   let isCommutable = 1 in
6751   def rri : SS4AIi8<opc, MRMSrcReg, (outs RC:$dst),
6752         (ins RC:$src1, RC:$src2, u8imm:$src3),
6753         !if(Is2Addr,
6754             !strconcat(OpcodeStr,
6755                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6756             !strconcat(OpcodeStr,
6757                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6758         [(set RC:$dst, (IntId RC:$src1, RC:$src2, imm:$src3))], itins.rr>,
6759         Sched<[itins.Sched]>;
6760   def rmi : SS4AIi8<opc, MRMSrcMem, (outs RC:$dst),
6761         (ins RC:$src1, x86memop:$src2, u8imm:$src3),
6762         !if(Is2Addr,
6763             !strconcat(OpcodeStr,
6764                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6765             !strconcat(OpcodeStr,
6766                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6767         [(set RC:$dst,
6768           (IntId RC:$src1,
6769            (bitconvert (memop_frag addr:$src2)), imm:$src3))], itins.rm>,
6770         Sched<[itins.Sched.Folded, ReadAfterLd]>;
6771 }
6772
6773 /// SS41I_binop_rmi - SSE 4.1 binary operator with 8-bit immediate
6774 multiclass SS41I_binop_rmi<bits<8> opc, string OpcodeStr, SDNode OpNode,
6775                            ValueType OpVT, RegisterClass RC, PatFrag memop_frag,
6776                            X86MemOperand x86memop, bit Is2Addr = 1,
6777                            OpndItins itins = DEFAULT_ITINS> {
6778   let isCommutable = 1 in
6779   def rri : SS4AIi8<opc, MRMSrcReg, (outs RC:$dst),
6780         (ins RC:$src1, RC:$src2, u8imm:$src3),
6781         !if(Is2Addr,
6782             !strconcat(OpcodeStr,
6783                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6784             !strconcat(OpcodeStr,
6785                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6786         [(set RC:$dst, (OpVT (OpNode RC:$src1, RC:$src2, imm:$src3)))],
6787         itins.rr>, Sched<[itins.Sched]>;
6788   def rmi : SS4AIi8<opc, MRMSrcMem, (outs RC:$dst),
6789         (ins RC:$src1, x86memop:$src2, u8imm:$src3),
6790         !if(Is2Addr,
6791             !strconcat(OpcodeStr,
6792                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
6793             !strconcat(OpcodeStr,
6794                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
6795         [(set RC:$dst,
6796           (OpVT (OpNode RC:$src1,
6797                  (bitconvert (memop_frag addr:$src2)), imm:$src3)))], itins.rm>,
6798         Sched<[itins.Sched.Folded, ReadAfterLd]>;
6799 }
6800
6801 let Predicates = [HasAVX] in {
6802   let isCommutable = 0 in {
6803     defm VMPSADBW : SS41I_binop_rmi_int<0x42, "vmpsadbw", int_x86_sse41_mpsadbw,
6804                                         VR128, loadv2i64, i128mem, 0,
6805                                         DEFAULT_ITINS_MPSADSCHED>, VEX_4V, VEX_WIG;
6806   }
6807
6808   let ExeDomain = SSEPackedSingle in {
6809   defm VBLENDPS : SS41I_binop_rmi<0x0C, "vblendps", X86Blendi, v4f32,
6810                                   VR128, loadv4f32, f128mem, 0,
6811                                   DEFAULT_ITINS_FBLENDSCHED>, VEX_4V, VEX_WIG;
6812   defm VBLENDPSY : SS41I_binop_rmi<0x0C, "vblendps", X86Blendi, v8f32,
6813                                    VR256, loadv8f32, f256mem, 0,
6814                                    DEFAULT_ITINS_FBLENDSCHED>, VEX_4V, VEX_L, VEX_WIG;
6815   }
6816   let ExeDomain = SSEPackedDouble in {
6817   defm VBLENDPD : SS41I_binop_rmi<0x0D, "vblendpd", X86Blendi, v2f64,
6818                                   VR128, loadv2f64, f128mem, 0,
6819                                   DEFAULT_ITINS_FBLENDSCHED>, VEX_4V, VEX_WIG;
6820   defm VBLENDPDY : SS41I_binop_rmi<0x0D, "vblendpd", X86Blendi, v4f64,
6821                                    VR256, loadv4f64, f256mem, 0,
6822                                    DEFAULT_ITINS_FBLENDSCHED>, VEX_4V, VEX_L, VEX_WIG;
6823   }
6824   defm VPBLENDW : SS41I_binop_rmi<0x0E, "vpblendw", X86Blendi, v8i16,
6825                                   VR128, loadv2i64, i128mem, 0,
6826                                   DEFAULT_ITINS_BLENDSCHED>, VEX_4V, VEX_WIG;
6827
6828   let ExeDomain = SSEPackedSingle in
6829   defm VDPPS : SS41I_binop_rmi_int<0x40, "vdpps", int_x86_sse41_dpps,
6830                                    VR128, loadv4f32, f128mem, 0,
6831                                    SSE_DPPS_ITINS>, VEX_4V, VEX_WIG;
6832   let ExeDomain = SSEPackedDouble in
6833   defm VDPPD : SS41I_binop_rmi_int<0x41, "vdppd", int_x86_sse41_dppd,
6834                                    VR128, loadv2f64, f128mem, 0,
6835                                    SSE_DPPS_ITINS>, VEX_4V, VEX_WIG;
6836   let ExeDomain = SSEPackedSingle in
6837   defm VDPPSY : SS41I_binop_rmi_int<0x40, "vdpps", int_x86_avx_dp_ps_256,
6838                                     VR256, loadv8f32, i256mem, 0,
6839                                     SSE_DPPS_ITINS>, VEX_4V, VEX_L, VEX_WIG;
6840 }
6841
6842 let Predicates = [HasAVX2] in {
6843   let isCommutable = 0 in {
6844   defm VMPSADBWY : SS41I_binop_rmi_int<0x42, "vmpsadbw", int_x86_avx2_mpsadbw,
6845                                   VR256, loadv4i64, i256mem, 0,
6846                                   DEFAULT_ITINS_MPSADSCHED>, VEX_4V, VEX_L, VEX_WIG;
6847   }
6848   defm VPBLENDWY : SS41I_binop_rmi<0x0E, "vpblendw", X86Blendi, v16i16,
6849                                    VR256, loadv4i64, i256mem, 0,
6850                                    DEFAULT_ITINS_BLENDSCHED>, VEX_4V, VEX_L, VEX_WIG;
6851 }
6852
6853 let Constraints = "$src1 = $dst" in {
6854   let isCommutable = 0 in {
6855   defm MPSADBW : SS41I_binop_rmi_int<0x42, "mpsadbw", int_x86_sse41_mpsadbw,
6856                                      VR128, memopv2i64, i128mem,
6857                                      1, SSE_MPSADBW_ITINS>;
6858   }
6859   let ExeDomain = SSEPackedSingle in
6860   defm BLENDPS : SS41I_binop_rmi<0x0C, "blendps", X86Blendi, v4f32,
6861                                  VR128, memopv4f32, f128mem,
6862                                  1, SSE_INTALU_ITINS_FBLEND_P>;
6863   let ExeDomain = SSEPackedDouble in
6864   defm BLENDPD : SS41I_binop_rmi<0x0D, "blendpd", X86Blendi, v2f64,
6865                                  VR128, memopv2f64, f128mem,
6866                                  1, SSE_INTALU_ITINS_FBLEND_P>;
6867   defm PBLENDW : SS41I_binop_rmi<0x0E, "pblendw", X86Blendi, v8i16,
6868                                  VR128, memopv2i64, i128mem,
6869                                  1, SSE_INTALU_ITINS_BLEND_P>;
6870   let ExeDomain = SSEPackedSingle in
6871   defm DPPS : SS41I_binop_rmi_int<0x40, "dpps", int_x86_sse41_dpps,
6872                                   VR128, memopv4f32, f128mem, 1,
6873                                   SSE_DPPS_ITINS>;
6874   let ExeDomain = SSEPackedDouble in
6875   defm DPPD : SS41I_binop_rmi_int<0x41, "dppd", int_x86_sse41_dppd,
6876                                   VR128, memopv2f64, f128mem, 1,
6877                                   SSE_DPPD_ITINS>;
6878 }
6879
6880 // For insertion into the zero index (low half) of a 256-bit vector, it is
6881 // more efficient to generate a blend with immediate instead of an insert*128.
6882 let Predicates = [HasAVX] in {
6883 def : Pat<(insert_subvector (v4f64 VR256:$src1), (v2f64 VR128:$src2), (iPTR 0)),
6884           (VBLENDPDYrri VR256:$src1,
6885                         (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)),
6886                                        VR128:$src2, sub_xmm), 0x3)>;
6887 def : Pat<(insert_subvector (v8f32 VR256:$src1), (v4f32 VR128:$src2), (iPTR 0)),
6888           (VBLENDPSYrri VR256:$src1,
6889                         (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)),
6890                                        VR128:$src2, sub_xmm), 0xf)>;
6891 }
6892
6893 /// SS41I_quaternary_int_avx - AVX SSE 4.1 with 4 operators
6894 multiclass SS41I_quaternary_int_avx<bits<8> opc, string OpcodeStr,
6895                                     RegisterClass RC, X86MemOperand x86memop,
6896                                     PatFrag mem_frag, Intrinsic IntId,
6897                                     X86FoldableSchedWrite Sched> {
6898   def rr : Ii8Reg<opc, MRMSrcReg, (outs RC:$dst),
6899                   (ins RC:$src1, RC:$src2, RC:$src3),
6900                   !strconcat(OpcodeStr,
6901                     "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6902                   [(set RC:$dst, (IntId RC:$src1, RC:$src2, RC:$src3))],
6903                   NoItinerary, SSEPackedInt>, TAPD, VEX_4V,
6904                 Sched<[Sched]>;
6905
6906   def rm : Ii8Reg<opc, MRMSrcMem, (outs RC:$dst),
6907                   (ins RC:$src1, x86memop:$src2, RC:$src3),
6908                   !strconcat(OpcodeStr,
6909                     "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
6910                   [(set RC:$dst,
6911                         (IntId RC:$src1, (bitconvert (mem_frag addr:$src2)),
6912                                RC:$src3))],
6913                   NoItinerary, SSEPackedInt>, TAPD, VEX_4V,
6914                 Sched<[Sched.Folded, ReadAfterLd]>;
6915 }
6916
6917 let Predicates = [HasAVX] in {
6918 let ExeDomain = SSEPackedDouble in {
6919 defm VBLENDVPD  : SS41I_quaternary_int_avx<0x4B, "vblendvpd", VR128, f128mem,
6920                                            loadv2f64, int_x86_sse41_blendvpd,
6921                                            WriteFVarBlend>;
6922 defm VBLENDVPDY : SS41I_quaternary_int_avx<0x4B, "vblendvpd", VR256, f256mem,
6923                                   loadv4f64, int_x86_avx_blendv_pd_256,
6924                                   WriteFVarBlend>, VEX_L;
6925 } // ExeDomain = SSEPackedDouble
6926 let ExeDomain = SSEPackedSingle in {
6927 defm VBLENDVPS  : SS41I_quaternary_int_avx<0x4A, "vblendvps", VR128, f128mem,
6928                                            loadv4f32, int_x86_sse41_blendvps,
6929                                            WriteFVarBlend>;
6930 defm VBLENDVPSY : SS41I_quaternary_int_avx<0x4A, "vblendvps", VR256, f256mem,
6931                                   loadv8f32, int_x86_avx_blendv_ps_256,
6932                                   WriteFVarBlend>, VEX_L;
6933 } // ExeDomain = SSEPackedSingle
6934 defm VPBLENDVB  : SS41I_quaternary_int_avx<0x4C, "vpblendvb", VR128, i128mem,
6935                                            loadv2i64, int_x86_sse41_pblendvb,
6936                                            WriteVarBlend>;
6937 }
6938
6939 let Predicates = [HasAVX2] in {
6940 defm VPBLENDVBY : SS41I_quaternary_int_avx<0x4C, "vpblendvb", VR256, i256mem,
6941                                       loadv4i64, int_x86_avx2_pblendvb,
6942                                       WriteVarBlend>, VEX_L;
6943 }
6944
6945 let Predicates = [HasAVX] in {
6946   def : Pat<(v16i8 (vselect (v16i8 VR128:$mask), (v16i8 VR128:$src1),
6947                             (v16i8 VR128:$src2))),
6948             (VPBLENDVBrr VR128:$src2, VR128:$src1, VR128:$mask)>;
6949   def : Pat<(v4i32 (vselect (v4i32 VR128:$mask), (v4i32 VR128:$src1),
6950                             (v4i32 VR128:$src2))),
6951             (VBLENDVPSrr VR128:$src2, VR128:$src1, VR128:$mask)>;
6952   def : Pat<(v4f32 (vselect (v4i32 VR128:$mask), (v4f32 VR128:$src1),
6953                             (v4f32 VR128:$src2))),
6954             (VBLENDVPSrr VR128:$src2, VR128:$src1, VR128:$mask)>;
6955   def : Pat<(v2i64 (vselect (v2i64 VR128:$mask), (v2i64 VR128:$src1),
6956                             (v2i64 VR128:$src2))),
6957             (VBLENDVPDrr VR128:$src2, VR128:$src1, VR128:$mask)>;
6958   def : Pat<(v2f64 (vselect (v2i64 VR128:$mask), (v2f64 VR128:$src1),
6959                             (v2f64 VR128:$src2))),
6960             (VBLENDVPDrr VR128:$src2, VR128:$src1, VR128:$mask)>;
6961   def : Pat<(v8i32 (vselect (v8i32 VR256:$mask), (v8i32 VR256:$src1),
6962                             (v8i32 VR256:$src2))),
6963             (VBLENDVPSYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6964   def : Pat<(v8f32 (vselect (v8i32 VR256:$mask), (v8f32 VR256:$src1),
6965                             (v8f32 VR256:$src2))),
6966             (VBLENDVPSYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6967   def : Pat<(v4i64 (vselect (v4i64 VR256:$mask), (v4i64 VR256:$src1),
6968                             (v4i64 VR256:$src2))),
6969             (VBLENDVPDYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6970   def : Pat<(v4f64 (vselect (v4i64 VR256:$mask), (v4f64 VR256:$src1),
6971                             (v4f64 VR256:$src2))),
6972             (VBLENDVPDYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6973 }
6974
6975 let Predicates = [HasAVX2] in {
6976   def : Pat<(v32i8 (vselect (v32i8 VR256:$mask), (v32i8 VR256:$src1),
6977                             (v32i8 VR256:$src2))),
6978             (VPBLENDVBYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6979 }
6980
6981 // Patterns
6982 // FIXME: Prefer a movss or movsd over a blendps when optimizing for size or
6983 // on targets where they have equal performance. These were changed to use
6984 // blends because blends have better throughput on SandyBridge and Haswell, but
6985 // movs[s/d] are 1-2 byte shorter instructions.
6986 let Predicates = [UseAVX] in {
6987   let AddedComplexity = 15 in {
6988   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
6989   // MOVS{S,D} to the lower bits.
6990   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32:$src)))),
6991             (VMOVSSrr (v4f32 (V_SET0)), FR32:$src)>;
6992   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
6993             (VBLENDPSrri (v4f32 (V_SET0)), VR128:$src, (i8 1))>;
6994   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
6995             (VPBLENDWrri (v4i32 (V_SET0)), VR128:$src, (i8 3))>;
6996   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64:$src)))),
6997             (VMOVSDrr (v2f64 (V_SET0)), FR64:$src)>;
6998
6999   // Move low f32 and clear high bits.
7000   def : Pat<(v8f32 (X86vzmovl (v8f32 VR256:$src))),
7001             (VBLENDPSYrri (v8f32 (AVX_SET0)), VR256:$src, (i8 1))>;
7002
7003   // Move low f64 and clear high bits.
7004   def : Pat<(v4f64 (X86vzmovl (v4f64 VR256:$src))),
7005             (VBLENDPDYrri (v4f64 (AVX_SET0)), VR256:$src, (i8 1))>;
7006   }
7007
7008   // These will incur an FP/int domain crossing penalty, but it may be the only
7009   // way without AVX2. Do not add any complexity because we may be able to match
7010   // more optimal patterns defined earlier in this file.
7011   def : Pat<(v8i32 (X86vzmovl (v8i32 VR256:$src))),
7012             (VBLENDPSYrri (v8i32 (AVX_SET0)), VR256:$src, (i8 1))>;
7013   def : Pat<(v4i64 (X86vzmovl (v4i64 VR256:$src))),
7014             (VBLENDPDYrri (v4i64 (AVX_SET0)), VR256:$src, (i8 1))>;
7015 }
7016
7017 // FIXME: Prefer a movss or movsd over a blendps when optimizing for size or
7018 // on targets where they have equal performance. These were changed to use
7019 // blends because blends have better throughput on SandyBridge and Haswell, but
7020 // movs[s/d] are 1-2 byte shorter instructions.
7021 let Predicates = [UseSSE41], AddedComplexity = 15 in {
7022   // With SSE41 we can use blends for these patterns.
7023   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
7024             (BLENDPSrri (v4f32 (V_SET0)), VR128:$src, (i8 1))>;
7025   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
7026             (PBLENDWrri (v4i32 (V_SET0)), VR128:$src, (i8 3))>;
7027 }
7028
7029
7030 /// SS41I_ternary_int - SSE 4.1 ternary operator
7031 let Uses = [XMM0], Constraints = "$src1 = $dst" in {
7032   multiclass SS41I_ternary_int<bits<8> opc, string OpcodeStr, PatFrag mem_frag,
7033                                X86MemOperand x86memop, Intrinsic IntId,
7034                                OpndItins itins = DEFAULT_ITINS> {
7035     def rr0 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
7036                     (ins VR128:$src1, VR128:$src2),
7037                     !strconcat(OpcodeStr,
7038                      "\t{%xmm0, $src2, $dst|$dst, $src2, xmm0}"),
7039                     [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2, XMM0))],
7040                     itins.rr>, Sched<[itins.Sched]>;
7041
7042     def rm0 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
7043                     (ins VR128:$src1, x86memop:$src2),
7044                     !strconcat(OpcodeStr,
7045                      "\t{%xmm0, $src2, $dst|$dst, $src2, xmm0}"),
7046                     [(set VR128:$dst,
7047                       (IntId VR128:$src1,
7048                        (bitconvert (mem_frag addr:$src2)), XMM0))],
7049                        itins.rm>, Sched<[itins.Sched.Folded, ReadAfterLd]>;
7050   }
7051 }
7052
7053 let ExeDomain = SSEPackedDouble in
7054 defm BLENDVPD : SS41I_ternary_int<0x15, "blendvpd", memopv2f64, f128mem,
7055                                   int_x86_sse41_blendvpd,
7056                                   DEFAULT_ITINS_FBLENDSCHED>;
7057 let ExeDomain = SSEPackedSingle in
7058 defm BLENDVPS : SS41I_ternary_int<0x14, "blendvps", memopv4f32, f128mem,
7059                                   int_x86_sse41_blendvps,
7060                                   DEFAULT_ITINS_FBLENDSCHED>;
7061 defm PBLENDVB : SS41I_ternary_int<0x10, "pblendvb", memopv2i64, i128mem,
7062                                   int_x86_sse41_pblendvb,
7063                                   DEFAULT_ITINS_VARBLENDSCHED>;
7064
7065 // Aliases with the implicit xmm0 argument
7066 def : InstAlias<"blendvpd\t{$src2, $dst|$dst, $src2}",
7067                 (BLENDVPDrr0 VR128:$dst, VR128:$src2), 0>;
7068 def : InstAlias<"blendvpd\t{$src2, $dst|$dst, $src2}",
7069                 (BLENDVPDrm0 VR128:$dst, f128mem:$src2), 0>;
7070 def : InstAlias<"blendvps\t{$src2, $dst|$dst, $src2}",
7071                 (BLENDVPSrr0 VR128:$dst, VR128:$src2), 0>;
7072 def : InstAlias<"blendvps\t{$src2, $dst|$dst, $src2}",
7073                 (BLENDVPSrm0 VR128:$dst, f128mem:$src2), 0>;
7074 def : InstAlias<"pblendvb\t{$src2, $dst|$dst, $src2}",
7075                 (PBLENDVBrr0 VR128:$dst, VR128:$src2), 0>;
7076 def : InstAlias<"pblendvb\t{$src2, $dst|$dst, $src2}",
7077                 (PBLENDVBrm0 VR128:$dst, i128mem:$src2), 0>;
7078
7079 let Predicates = [UseSSE41] in {
7080   def : Pat<(v16i8 (vselect (v16i8 XMM0), (v16i8 VR128:$src1),
7081                             (v16i8 VR128:$src2))),
7082             (PBLENDVBrr0 VR128:$src2, VR128:$src1)>;
7083   def : Pat<(v4i32 (vselect (v4i32 XMM0), (v4i32 VR128:$src1),
7084                             (v4i32 VR128:$src2))),
7085             (BLENDVPSrr0 VR128:$src2, VR128:$src1)>;
7086   def : Pat<(v4f32 (vselect (v4i32 XMM0), (v4f32 VR128:$src1),
7087                             (v4f32 VR128:$src2))),
7088             (BLENDVPSrr0 VR128:$src2, VR128:$src1)>;
7089   def : Pat<(v2i64 (vselect (v2i64 XMM0), (v2i64 VR128:$src1),
7090                             (v2i64 VR128:$src2))),
7091             (BLENDVPDrr0 VR128:$src2, VR128:$src1)>;
7092   def : Pat<(v2f64 (vselect (v2i64 XMM0), (v2f64 VR128:$src1),
7093                             (v2f64 VR128:$src2))),
7094             (BLENDVPDrr0 VR128:$src2, VR128:$src1)>;
7095 }
7096
7097 let AddedComplexity = 400 in { // Prefer non-temporal versions
7098 let SchedRW = [WriteLoad] in {
7099 let Predicates = [HasAVX, NoVLX] in
7100 def VMOVNTDQArm : SS48I<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
7101                        "vmovntdqa\t{$src, $dst|$dst, $src}", []>,
7102                        VEX, VEX_WIG;
7103 let Predicates = [HasAVX2, NoVLX] in
7104 def VMOVNTDQAYrm : SS48I<0x2A, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
7105                          "vmovntdqa\t{$src, $dst|$dst, $src}", []>,
7106                          VEX, VEX_L, VEX_WIG;
7107 def MOVNTDQArm : SS48I<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
7108                        "movntdqa\t{$src, $dst|$dst, $src}", []>;
7109 } // SchedRW
7110
7111 let Predicates = [HasAVX2, NoVLX] in {
7112   def : Pat<(v8f32 (alignednontemporalload addr:$src)),
7113             (VMOVNTDQAYrm addr:$src)>;
7114   def : Pat<(v4f64 (alignednontemporalload addr:$src)),
7115             (VMOVNTDQAYrm addr:$src)>;
7116   def : Pat<(v4i64 (alignednontemporalload addr:$src)),
7117             (VMOVNTDQAYrm addr:$src)>;
7118 }
7119
7120 let Predicates = [HasAVX, NoVLX] in {
7121   def : Pat<(v4f32 (alignednontemporalload addr:$src)),
7122             (VMOVNTDQArm addr:$src)>;
7123   def : Pat<(v2f64 (alignednontemporalload addr:$src)),
7124             (VMOVNTDQArm addr:$src)>;
7125   def : Pat<(v2i64 (alignednontemporalload addr:$src)),
7126             (VMOVNTDQArm addr:$src)>;
7127 }
7128
7129 let Predicates = [UseSSE41] in {
7130   def : Pat<(v4f32 (alignednontemporalload addr:$src)),
7131             (MOVNTDQArm addr:$src)>;
7132   def : Pat<(v2f64 (alignednontemporalload addr:$src)),
7133             (MOVNTDQArm addr:$src)>;
7134   def : Pat<(v2i64 (alignednontemporalload addr:$src)),
7135             (MOVNTDQArm addr:$src)>;
7136 }
7137
7138 } // AddedComplexity
7139
7140 //===----------------------------------------------------------------------===//
7141 // SSE4.2 - Compare Instructions
7142 //===----------------------------------------------------------------------===//
7143
7144 /// SS42I_binop_rm - Simple SSE 4.2 binary operator
7145 multiclass SS42I_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
7146                           ValueType OpVT, RegisterClass RC, PatFrag memop_frag,
7147                           X86MemOperand x86memop, OpndItins itins,
7148                           bit Is2Addr = 1> {
7149   def rr : SS428I<opc, MRMSrcReg, (outs RC:$dst),
7150        (ins RC:$src1, RC:$src2),
7151        !if(Is2Addr,
7152            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
7153            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
7154        [(set RC:$dst, (OpVT (OpNode RC:$src1, RC:$src2)))]>, Sched<[itins.Sched]>;
7155   def rm : SS428I<opc, MRMSrcMem, (outs RC:$dst),
7156        (ins RC:$src1, x86memop:$src2),
7157        !if(Is2Addr,
7158            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
7159            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
7160        [(set RC:$dst,
7161          (OpVT (OpNode RC:$src1, (memop_frag addr:$src2))))]>,
7162        Sched<[itins.Sched.Folded, ReadAfterLd]>;
7163 }
7164
7165 let Predicates = [HasAVX] in
7166   defm VPCMPGTQ : SS42I_binop_rm<0x37, "vpcmpgtq", X86pcmpgt, v2i64, VR128,
7167                                  loadv2i64, i128mem, SSE_INTALU_ITINS_P, 0>,
7168                                  VEX_4V, VEX_WIG;
7169
7170 let Predicates = [HasAVX2] in
7171   defm VPCMPGTQY : SS42I_binop_rm<0x37, "vpcmpgtq", X86pcmpgt, v4i64, VR256,
7172                                   loadv4i64, i256mem, SSE_INTALU_ITINS_P, 0>,
7173                                   VEX_4V, VEX_L, VEX_WIG;
7174
7175 let Constraints = "$src1 = $dst" in
7176   defm PCMPGTQ : SS42I_binop_rm<0x37, "pcmpgtq", X86pcmpgt, v2i64, VR128,
7177                                 memopv2i64, i128mem, SSE_INTALU_ITINS_P>;
7178
7179 //===----------------------------------------------------------------------===//
7180 // SSE4.2 - String/text Processing Instructions
7181 //===----------------------------------------------------------------------===//
7182
7183 // Packed Compare Implicit Length Strings, Return Mask
7184 multiclass pseudo_pcmpistrm<string asm, PatFrag ld_frag> {
7185   def REG : PseudoI<(outs VR128:$dst),
7186                     (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7187     [(set VR128:$dst, (int_x86_sse42_pcmpistrm128 VR128:$src1, VR128:$src2,
7188                                                   imm:$src3))]>;
7189   def MEM : PseudoI<(outs VR128:$dst),
7190                     (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7191     [(set VR128:$dst, (int_x86_sse42_pcmpistrm128 VR128:$src1,
7192                        (bc_v16i8 (ld_frag addr:$src2)), imm:$src3))]>;
7193 }
7194
7195 let Defs = [EFLAGS], usesCustomInserter = 1 in {
7196   defm VPCMPISTRM128 : pseudo_pcmpistrm<"#VPCMPISTRM128", loadv2i64>,
7197                          Requires<[HasAVX]>, VEX_WIG;
7198   defm PCMPISTRM128 : pseudo_pcmpistrm<"#PCMPISTRM128", memopv2i64>,
7199                          Requires<[UseSSE42]>;
7200 }
7201
7202 multiclass pcmpistrm_SS42AI<string asm> {
7203   def rr : SS42AI<0x62, MRMSrcReg, (outs),
7204     (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7205     !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
7206     []>, Sched<[WritePCmpIStrM]>;
7207   let mayLoad = 1 in
7208   def rm :SS42AI<0x62, MRMSrcMem, (outs),
7209     (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7210     !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
7211     []>, Sched<[WritePCmpIStrMLd, ReadAfterLd]>;
7212 }
7213
7214 let Defs = [XMM0, EFLAGS], hasSideEffects = 0 in {
7215   let Predicates = [HasAVX] in
7216   defm VPCMPISTRM128 : pcmpistrm_SS42AI<"vpcmpistrm">, VEX;
7217   defm PCMPISTRM128  : pcmpistrm_SS42AI<"pcmpistrm"> ;
7218 }
7219
7220 // Packed Compare Explicit Length Strings, Return Mask
7221 multiclass pseudo_pcmpestrm<string asm, PatFrag ld_frag> {
7222   def REG : PseudoI<(outs VR128:$dst),
7223                     (ins VR128:$src1, VR128:$src3, u8imm:$src5),
7224     [(set VR128:$dst, (int_x86_sse42_pcmpestrm128
7225                        VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5))]>;
7226   def MEM : PseudoI<(outs VR128:$dst),
7227                     (ins VR128:$src1, i128mem:$src3, u8imm:$src5),
7228     [(set VR128:$dst, (int_x86_sse42_pcmpestrm128 VR128:$src1, EAX,
7229                        (bc_v16i8 (ld_frag addr:$src3)), EDX, imm:$src5))]>;
7230 }
7231
7232 let Defs = [EFLAGS], Uses = [EAX, EDX], usesCustomInserter = 1 in {
7233   defm VPCMPESTRM128 : pseudo_pcmpestrm<"#VPCMPESTRM128", loadv2i64>,
7234                          Requires<[HasAVX]>;
7235   defm PCMPESTRM128 : pseudo_pcmpestrm<"#PCMPESTRM128", memopv2i64>,
7236                          Requires<[UseSSE42]>;
7237 }
7238
7239 multiclass SS42AI_pcmpestrm<string asm> {
7240   def rr : SS42AI<0x60, MRMSrcReg, (outs),
7241     (ins VR128:$src1, VR128:$src3, u8imm:$src5),
7242     !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
7243     []>, Sched<[WritePCmpEStrM]>;
7244   let mayLoad = 1 in
7245   def rm : SS42AI<0x60, MRMSrcMem, (outs),
7246     (ins VR128:$src1, i128mem:$src3, u8imm:$src5),
7247     !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
7248     []>, Sched<[WritePCmpEStrMLd, ReadAfterLd]>;
7249 }
7250
7251 let Defs = [XMM0, EFLAGS], Uses = [EAX, EDX], hasSideEffects = 0 in {
7252   let Predicates = [HasAVX] in
7253   defm VPCMPESTRM128 : SS42AI_pcmpestrm<"vpcmpestrm">, VEX;
7254   defm PCMPESTRM128 :  SS42AI_pcmpestrm<"pcmpestrm">;
7255 }
7256
7257 // Packed Compare Implicit Length Strings, Return Index
7258 multiclass pseudo_pcmpistri<string asm, PatFrag ld_frag> {
7259   def REG : PseudoI<(outs GR32:$dst),
7260                     (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7261     [(set GR32:$dst, EFLAGS,
7262       (X86pcmpistri VR128:$src1, VR128:$src2, imm:$src3))]>;
7263   def MEM : PseudoI<(outs GR32:$dst),
7264                     (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7265     [(set GR32:$dst, EFLAGS, (X86pcmpistri VR128:$src1,
7266                               (bc_v16i8 (ld_frag addr:$src2)), imm:$src3))]>;
7267 }
7268
7269 let Defs = [EFLAGS], usesCustomInserter = 1 in {
7270   defm VPCMPISTRI : pseudo_pcmpistri<"#VPCMPISTRI", loadv2i64>,
7271                       Requires<[HasAVX]>, VEX_WIG;
7272   defm PCMPISTRI  : pseudo_pcmpistri<"#PCMPISTRI", memopv2i64>,
7273                       Requires<[UseSSE42]>;
7274 }
7275
7276 multiclass SS42AI_pcmpistri<string asm> {
7277   def rr : SS42AI<0x63, MRMSrcReg, (outs),
7278     (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7279     !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
7280     []>, Sched<[WritePCmpIStrI]>;
7281   let mayLoad = 1 in
7282   def rm : SS42AI<0x63, MRMSrcMem, (outs),
7283     (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7284     !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
7285     []>, Sched<[WritePCmpIStrILd, ReadAfterLd]>;
7286 }
7287
7288 let Defs = [ECX, EFLAGS], hasSideEffects = 0 in {
7289   let Predicates = [HasAVX] in
7290   defm VPCMPISTRI : SS42AI_pcmpistri<"vpcmpistri">, VEX;
7291   defm PCMPISTRI  : SS42AI_pcmpistri<"pcmpistri">;
7292 }
7293
7294 // Packed Compare Explicit Length Strings, Return Index
7295 multiclass pseudo_pcmpestri<string asm, PatFrag ld_frag> {
7296   def REG : PseudoI<(outs GR32:$dst),
7297                     (ins VR128:$src1, VR128:$src3, u8imm:$src5),
7298     [(set GR32:$dst, EFLAGS,
7299       (X86pcmpestri VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5))]>;
7300   def MEM : PseudoI<(outs GR32:$dst),
7301                     (ins VR128:$src1, i128mem:$src3, u8imm:$src5),
7302     [(set GR32:$dst, EFLAGS,
7303       (X86pcmpestri VR128:$src1, EAX, (bc_v16i8 (ld_frag addr:$src3)), EDX,
7304        imm:$src5))]>;
7305 }
7306
7307 let Defs = [EFLAGS], Uses = [EAX, EDX], usesCustomInserter = 1 in {
7308   defm VPCMPESTRI : pseudo_pcmpestri<"#VPCMPESTRI", loadv2i64>,
7309                       Requires<[HasAVX]>;
7310   defm PCMPESTRI  : pseudo_pcmpestri<"#PCMPESTRI", memopv2i64>,
7311                       Requires<[UseSSE42]>;
7312 }
7313
7314 multiclass SS42AI_pcmpestri<string asm> {
7315   def rr : SS42AI<0x61, MRMSrcReg, (outs),
7316     (ins VR128:$src1, VR128:$src3, u8imm:$src5),
7317     !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
7318     []>, Sched<[WritePCmpEStrI]>;
7319   let mayLoad = 1 in
7320   def rm : SS42AI<0x61, MRMSrcMem, (outs),
7321     (ins VR128:$src1, i128mem:$src3, u8imm:$src5),
7322     !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
7323     []>, Sched<[WritePCmpEStrILd, ReadAfterLd]>;
7324 }
7325
7326 let Defs = [ECX, EFLAGS], Uses = [EAX, EDX], hasSideEffects = 0 in {
7327   let Predicates = [HasAVX] in
7328   defm VPCMPESTRI : SS42AI_pcmpestri<"vpcmpestri">, VEX;
7329   defm PCMPESTRI  : SS42AI_pcmpestri<"pcmpestri">;
7330 }
7331
7332 //===----------------------------------------------------------------------===//
7333 // SSE4.2 - CRC Instructions
7334 //===----------------------------------------------------------------------===//
7335
7336 // No CRC instructions have AVX equivalents
7337
7338 // crc intrinsic instruction
7339 // This set of instructions are only rm, the only difference is the size
7340 // of r and m.
7341 class SS42I_crc32r<bits<8> opc, string asm, RegisterClass RCOut,
7342                    RegisterClass RCIn, SDPatternOperator Int> :
7343   SS42FI<opc, MRMSrcReg, (outs RCOut:$dst), (ins RCOut:$src1, RCIn:$src2),
7344          !strconcat(asm, "\t{$src2, $src1|$src1, $src2}"),
7345          [(set RCOut:$dst, (Int RCOut:$src1, RCIn:$src2))], IIC_CRC32_REG>,
7346          Sched<[WriteFAdd]>;
7347
7348 class SS42I_crc32m<bits<8> opc, string asm, RegisterClass RCOut,
7349                    X86MemOperand x86memop, SDPatternOperator Int> :
7350   SS42FI<opc, MRMSrcMem, (outs RCOut:$dst), (ins RCOut:$src1, x86memop:$src2),
7351          !strconcat(asm, "\t{$src2, $src1|$src1, $src2}"),
7352          [(set RCOut:$dst, (Int RCOut:$src1, (load addr:$src2)))],
7353          IIC_CRC32_MEM>, Sched<[WriteFAddLd, ReadAfterLd]>;
7354
7355 let Constraints = "$src1 = $dst" in {
7356   def CRC32r32m8  : SS42I_crc32m<0xF0, "crc32{b}", GR32, i8mem,
7357                                  int_x86_sse42_crc32_32_8>;
7358   def CRC32r32r8  : SS42I_crc32r<0xF0, "crc32{b}", GR32, GR8,
7359                                  int_x86_sse42_crc32_32_8>;
7360   def CRC32r32m16 : SS42I_crc32m<0xF1, "crc32{w}", GR32, i16mem,
7361                                  int_x86_sse42_crc32_32_16>, OpSize16;
7362   def CRC32r32r16 : SS42I_crc32r<0xF1, "crc32{w}", GR32, GR16,
7363                                  int_x86_sse42_crc32_32_16>, OpSize16;
7364   def CRC32r32m32 : SS42I_crc32m<0xF1, "crc32{l}", GR32, i32mem,
7365                                  int_x86_sse42_crc32_32_32>, OpSize32;
7366   def CRC32r32r32 : SS42I_crc32r<0xF1, "crc32{l}", GR32, GR32,
7367                                  int_x86_sse42_crc32_32_32>, OpSize32;
7368   def CRC32r64m64 : SS42I_crc32m<0xF1, "crc32{q}", GR64, i64mem,
7369                                  int_x86_sse42_crc32_64_64>, REX_W;
7370   def CRC32r64r64 : SS42I_crc32r<0xF1, "crc32{q}", GR64, GR64,
7371                                  int_x86_sse42_crc32_64_64>, REX_W;
7372   let hasSideEffects = 0 in {
7373     let mayLoad = 1 in
7374     def CRC32r64m8 : SS42I_crc32m<0xF0, "crc32{b}", GR64, i8mem,
7375                                    null_frag>, REX_W;
7376     def CRC32r64r8 : SS42I_crc32r<0xF0, "crc32{b}", GR64, GR8,
7377                                    null_frag>, REX_W;
7378   }
7379 }
7380
7381 //===----------------------------------------------------------------------===//
7382 // SHA-NI Instructions
7383 //===----------------------------------------------------------------------===//
7384
7385 multiclass SHAI_binop<bits<8> Opc, string OpcodeStr, Intrinsic IntId,
7386                       bit UsesXMM0 = 0> {
7387   def rr : I<Opc, MRMSrcReg, (outs VR128:$dst),
7388              (ins VR128:$src1, VR128:$src2),
7389              !if(UsesXMM0,
7390                  !strconcat(OpcodeStr, "\t{%xmm0, $src2, $dst|$dst, $src2, xmm0}"),
7391                  !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}")),
7392              [!if(UsesXMM0,
7393                   (set VR128:$dst, (IntId VR128:$src1, VR128:$src2, XMM0)),
7394                   (set VR128:$dst, (IntId VR128:$src1, VR128:$src2)))]>, T8;
7395
7396   def rm : I<Opc, MRMSrcMem, (outs VR128:$dst),
7397              (ins VR128:$src1, i128mem:$src2),
7398              !if(UsesXMM0,
7399                  !strconcat(OpcodeStr, "\t{%xmm0, $src2, $dst|$dst, $src2, xmm0}"),
7400                  !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}")),
7401              [!if(UsesXMM0,
7402                   (set VR128:$dst, (IntId VR128:$src1,
7403                     (bc_v4i32 (memopv2i64 addr:$src2)), XMM0)),
7404                   (set VR128:$dst, (IntId VR128:$src1,
7405                     (bc_v4i32 (memopv2i64 addr:$src2)))))]>, T8;
7406 }
7407
7408 let Constraints = "$src1 = $dst", Predicates = [HasSHA] in {
7409   def SHA1RNDS4rri : Ii8<0xCC, MRMSrcReg, (outs VR128:$dst),
7410                          (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7411                          "sha1rnds4\t{$src3, $src2, $dst|$dst, $src2, $src3}",
7412                          [(set VR128:$dst,
7413                            (int_x86_sha1rnds4 VR128:$src1, VR128:$src2,
7414                             (i8 imm:$src3)))]>, TA;
7415   def SHA1RNDS4rmi : Ii8<0xCC, MRMSrcMem, (outs VR128:$dst),
7416                          (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7417                          "sha1rnds4\t{$src3, $src2, $dst|$dst, $src2, $src3}",
7418                          [(set VR128:$dst,
7419                            (int_x86_sha1rnds4 VR128:$src1,
7420                             (bc_v4i32 (memopv2i64 addr:$src2)),
7421                             (i8 imm:$src3)))]>, TA;
7422
7423   defm SHA1NEXTE : SHAI_binop<0xC8, "sha1nexte", int_x86_sha1nexte>;
7424   defm SHA1MSG1  : SHAI_binop<0xC9, "sha1msg1", int_x86_sha1msg1>;
7425   defm SHA1MSG2  : SHAI_binop<0xCA, "sha1msg2", int_x86_sha1msg2>;
7426
7427   let Uses=[XMM0] in
7428   defm SHA256RNDS2 : SHAI_binop<0xCB, "sha256rnds2", int_x86_sha256rnds2, 1>;
7429
7430   defm SHA256MSG1 : SHAI_binop<0xCC, "sha256msg1", int_x86_sha256msg1>;
7431   defm SHA256MSG2 : SHAI_binop<0xCD, "sha256msg2", int_x86_sha256msg2>;
7432 }
7433
7434 // Aliases with explicit %xmm0
7435 def : InstAlias<"sha256rnds2\t{$src2, $dst|$dst, $src2}",
7436                 (SHA256RNDS2rr VR128:$dst, VR128:$src2), 0>;
7437 def : InstAlias<"sha256rnds2\t{$src2, $dst|$dst, $src2}",
7438                 (SHA256RNDS2rm VR128:$dst, i128mem:$src2), 0>;
7439
7440 //===----------------------------------------------------------------------===//
7441 // AES-NI Instructions
7442 //===----------------------------------------------------------------------===//
7443
7444 multiclass AESI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId128,
7445                              PatFrag ld_frag, bit Is2Addr = 1> {
7446   def rr : AES8I<opc, MRMSrcReg, (outs VR128:$dst),
7447        (ins VR128:$src1, VR128:$src2),
7448        !if(Is2Addr,
7449            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
7450            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
7451        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
7452        Sched<[WriteAESDecEnc]>;
7453   def rm : AES8I<opc, MRMSrcMem, (outs VR128:$dst),
7454        (ins VR128:$src1, i128mem:$src2),
7455        !if(Is2Addr,
7456            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
7457            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
7458        [(set VR128:$dst,
7459          (IntId128 VR128:$src1, (ld_frag addr:$src2)))]>,
7460        Sched<[WriteAESDecEncLd, ReadAfterLd]>;
7461 }
7462
7463 // Perform One Round of an AES Encryption/Decryption Flow
7464 let Predicates = [HasAVX, HasAES] in {
7465   defm VAESENC          : AESI_binop_rm_int<0xDC, "vaesenc",
7466                          int_x86_aesni_aesenc, loadv2i64, 0>, VEX_4V, VEX_WIG;
7467   defm VAESENCLAST      : AESI_binop_rm_int<0xDD, "vaesenclast",
7468                          int_x86_aesni_aesenclast, loadv2i64, 0>, VEX_4V, VEX_WIG;
7469   defm VAESDEC          : AESI_binop_rm_int<0xDE, "vaesdec",
7470                          int_x86_aesni_aesdec, loadv2i64, 0>, VEX_4V, VEX_WIG;
7471   defm VAESDECLAST      : AESI_binop_rm_int<0xDF, "vaesdeclast",
7472                          int_x86_aesni_aesdeclast, loadv2i64, 0>, VEX_4V, VEX_WIG;
7473 }
7474
7475 let Constraints = "$src1 = $dst" in {
7476   defm AESENC          : AESI_binop_rm_int<0xDC, "aesenc",
7477                          int_x86_aesni_aesenc, memopv2i64>;
7478   defm AESENCLAST      : AESI_binop_rm_int<0xDD, "aesenclast",
7479                          int_x86_aesni_aesenclast, memopv2i64>;
7480   defm AESDEC          : AESI_binop_rm_int<0xDE, "aesdec",
7481                          int_x86_aesni_aesdec, memopv2i64>;
7482   defm AESDECLAST      : AESI_binop_rm_int<0xDF, "aesdeclast",
7483                          int_x86_aesni_aesdeclast, memopv2i64>;
7484 }
7485
7486 // Perform the AES InvMixColumn Transformation
7487 let Predicates = [HasAVX, HasAES] in {
7488   def VAESIMCrr : AES8I<0xDB, MRMSrcReg, (outs VR128:$dst),
7489       (ins VR128:$src1),
7490       "vaesimc\t{$src1, $dst|$dst, $src1}",
7491       [(set VR128:$dst,
7492         (int_x86_aesni_aesimc VR128:$src1))]>, Sched<[WriteAESIMC]>,
7493       VEX, VEX_WIG;
7494   def VAESIMCrm : AES8I<0xDB, MRMSrcMem, (outs VR128:$dst),
7495       (ins i128mem:$src1),
7496       "vaesimc\t{$src1, $dst|$dst, $src1}",
7497       [(set VR128:$dst, (int_x86_aesni_aesimc (loadv2i64 addr:$src1)))]>,
7498       Sched<[WriteAESIMCLd]>, VEX, VEX_WIG;
7499 }
7500 def AESIMCrr : AES8I<0xDB, MRMSrcReg, (outs VR128:$dst),
7501   (ins VR128:$src1),
7502   "aesimc\t{$src1, $dst|$dst, $src1}",
7503   [(set VR128:$dst,
7504     (int_x86_aesni_aesimc VR128:$src1))]>, Sched<[WriteAESIMC]>;
7505 def AESIMCrm : AES8I<0xDB, MRMSrcMem, (outs VR128:$dst),
7506   (ins i128mem:$src1),
7507   "aesimc\t{$src1, $dst|$dst, $src1}",
7508   [(set VR128:$dst, (int_x86_aesni_aesimc (memopv2i64 addr:$src1)))]>,
7509   Sched<[WriteAESIMCLd]>;
7510
7511 // AES Round Key Generation Assist
7512 let Predicates = [HasAVX, HasAES] in {
7513   def VAESKEYGENASSIST128rr : AESAI<0xDF, MRMSrcReg, (outs VR128:$dst),
7514       (ins VR128:$src1, u8imm:$src2),
7515       "vaeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7516       [(set VR128:$dst,
7517         (int_x86_aesni_aeskeygenassist VR128:$src1, imm:$src2))]>,
7518       Sched<[WriteAESKeyGen]>, VEX, VEX_WIG;
7519   def VAESKEYGENASSIST128rm : AESAI<0xDF, MRMSrcMem, (outs VR128:$dst),
7520       (ins i128mem:$src1, u8imm:$src2),
7521       "vaeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7522       [(set VR128:$dst,
7523         (int_x86_aesni_aeskeygenassist (loadv2i64 addr:$src1), imm:$src2))]>,
7524       Sched<[WriteAESKeyGenLd]>, VEX, VEX_WIG;
7525 }
7526 def AESKEYGENASSIST128rr : AESAI<0xDF, MRMSrcReg, (outs VR128:$dst),
7527   (ins VR128:$src1, u8imm:$src2),
7528   "aeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7529   [(set VR128:$dst,
7530     (int_x86_aesni_aeskeygenassist VR128:$src1, imm:$src2))]>,
7531   Sched<[WriteAESKeyGen]>;
7532 def AESKEYGENASSIST128rm : AESAI<0xDF, MRMSrcMem, (outs VR128:$dst),
7533   (ins i128mem:$src1, u8imm:$src2),
7534   "aeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7535   [(set VR128:$dst,
7536     (int_x86_aesni_aeskeygenassist (memopv2i64 addr:$src1), imm:$src2))]>,
7537   Sched<[WriteAESKeyGenLd]>;
7538
7539 //===----------------------------------------------------------------------===//
7540 // PCLMUL Instructions
7541 //===----------------------------------------------------------------------===//
7542
7543 // AVX carry-less Multiplication instructions
7544 let isCommutable = 1 in
7545 def VPCLMULQDQrr : AVXPCLMULIi8<0x44, MRMSrcReg, (outs VR128:$dst),
7546            (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7547            "vpclmulqdq\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7548            [(set VR128:$dst,
7549              (int_x86_pclmulqdq VR128:$src1, VR128:$src2, imm:$src3))]>,
7550            Sched<[WriteCLMul]>, VEX_WIG;
7551
7552 def VPCLMULQDQrm : AVXPCLMULIi8<0x44, MRMSrcMem, (outs VR128:$dst),
7553            (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7554            "vpclmulqdq\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7555            [(set VR128:$dst, (int_x86_pclmulqdq VR128:$src1,
7556                               (loadv2i64 addr:$src2), imm:$src3))]>,
7557            Sched<[WriteCLMulLd, ReadAfterLd]>, VEX_WIG;
7558
7559 // Carry-less Multiplication instructions
7560 let Constraints = "$src1 = $dst" in {
7561 let isCommutable = 1 in
7562 def PCLMULQDQrr : PCLMULIi8<0x44, MRMSrcReg, (outs VR128:$dst),
7563            (ins VR128:$src1, VR128:$src2, u8imm:$src3),
7564            "pclmulqdq\t{$src3, $src2, $dst|$dst, $src2, $src3}",
7565            [(set VR128:$dst,
7566              (int_x86_pclmulqdq VR128:$src1, VR128:$src2, imm:$src3))],
7567              IIC_SSE_PCLMULQDQ_RR>, Sched<[WriteCLMul]>;
7568
7569 def PCLMULQDQrm : PCLMULIi8<0x44, MRMSrcMem, (outs VR128:$dst),
7570            (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
7571            "pclmulqdq\t{$src3, $src2, $dst|$dst, $src2, $src3}",
7572            [(set VR128:$dst, (int_x86_pclmulqdq VR128:$src1,
7573                               (memopv2i64 addr:$src2), imm:$src3))],
7574                               IIC_SSE_PCLMULQDQ_RM>,
7575            Sched<[WriteCLMulLd, ReadAfterLd]>;
7576 } // Constraints = "$src1 = $dst"
7577
7578
7579 multiclass pclmul_alias<string asm, int immop> {
7580   def : InstAlias<!strconcat("pclmul", asm, "dq {$src, $dst|$dst, $src}"),
7581                   (PCLMULQDQrr VR128:$dst, VR128:$src, immop), 0>;
7582
7583   def : InstAlias<!strconcat("pclmul", asm, "dq {$src, $dst|$dst, $src}"),
7584                   (PCLMULQDQrm VR128:$dst, i128mem:$src, immop), 0>;
7585
7586   def : InstAlias<!strconcat("vpclmul", asm,
7587                              "dq {$src2, $src1, $dst|$dst, $src1, $src2}"),
7588                   (VPCLMULQDQrr VR128:$dst, VR128:$src1, VR128:$src2, immop),
7589                   0>;
7590
7591   def : InstAlias<!strconcat("vpclmul", asm,
7592                              "dq {$src2, $src1, $dst|$dst, $src1, $src2}"),
7593                   (VPCLMULQDQrm VR128:$dst, VR128:$src1, i128mem:$src2, immop),
7594                   0>;
7595 }
7596 defm : pclmul_alias<"hqhq", 0x11>;
7597 defm : pclmul_alias<"hqlq", 0x01>;
7598 defm : pclmul_alias<"lqhq", 0x10>;
7599 defm : pclmul_alias<"lqlq", 0x00>;
7600
7601 //===----------------------------------------------------------------------===//
7602 // SSE4A Instructions
7603 //===----------------------------------------------------------------------===//
7604
7605 let Predicates = [HasSSE4A] in {
7606
7607 let ExeDomain = SSEPackedInt in {
7608 let Constraints = "$src = $dst" in {
7609 def EXTRQI : Ii8<0x78, MRMXr, (outs VR128:$dst),
7610                  (ins VR128:$src, u8imm:$len, u8imm:$idx),
7611                  "extrq\t{$idx, $len, $src|$src, $len, $idx}",
7612                  [(set VR128:$dst, (X86extrqi VR128:$src, imm:$len,
7613                                     imm:$idx))]>, PD;
7614 def EXTRQ  : I<0x79, MRMSrcReg, (outs VR128:$dst),
7615               (ins VR128:$src, VR128:$mask),
7616               "extrq\t{$mask, $src|$src, $mask}",
7617               [(set VR128:$dst, (int_x86_sse4a_extrq VR128:$src,
7618                                  VR128:$mask))]>, PD;
7619
7620 def INSERTQI : Ii8<0x78, MRMSrcReg, (outs VR128:$dst),
7621                    (ins VR128:$src, VR128:$src2, u8imm:$len, u8imm:$idx),
7622                    "insertq\t{$idx, $len, $src2, $src|$src, $src2, $len, $idx}",
7623                    [(set VR128:$dst, (X86insertqi VR128:$src, VR128:$src2,
7624                                       imm:$len, imm:$idx))]>, XD;
7625 def INSERTQ  : I<0x79, MRMSrcReg, (outs VR128:$dst),
7626                  (ins VR128:$src, VR128:$mask),
7627                  "insertq\t{$mask, $src|$src, $mask}",
7628                  [(set VR128:$dst, (int_x86_sse4a_insertq VR128:$src,
7629                                     VR128:$mask))]>, XD;
7630 }
7631 } // ExeDomain = SSEPackedInt
7632
7633 // Non-temporal (unaligned) scalar stores.
7634 let AddedComplexity = 400 in { // Prefer non-temporal versions
7635 let mayStore = 1, SchedRW = [WriteStore] in {
7636 def MOVNTSS : I<0x2B, MRMDestMem, (outs), (ins f32mem:$dst, VR128:$src),
7637                 "movntss\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVNT>, XS;
7638
7639 def MOVNTSD : I<0x2B, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
7640                 "movntsd\t{$src, $dst|$dst, $src}", [], IIC_SSE_MOVNT>, XD;
7641 } // SchedRW
7642
7643 def : Pat<(nontemporalstore FR32:$src, addr:$dst),
7644           (MOVNTSS addr:$dst, (COPY_TO_REGCLASS FR32:$src, VR128))>;
7645
7646 def : Pat<(nontemporalstore FR64:$src, addr:$dst),
7647           (MOVNTSD addr:$dst, (COPY_TO_REGCLASS FR64:$src, VR128))>;
7648
7649 } // AddedComplexity
7650 } // HasSSE4A
7651
7652 //===----------------------------------------------------------------------===//
7653 // AVX Instructions
7654 //===----------------------------------------------------------------------===//
7655
7656 //===----------------------------------------------------------------------===//
7657 // VBROADCAST - Load from memory and broadcast to all elements of the
7658 //              destination operand
7659 //
7660 class avx_broadcast_rm<bits<8> opc, string OpcodeStr, RegisterClass RC,
7661                            X86MemOperand x86memop, ValueType VT,
7662                            PatFrag ld_frag, SchedWrite Sched> :
7663   AVX8I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
7664         !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
7665         [(set RC:$dst, (VT (X86VBroadcast (ld_frag addr:$src))))]>,
7666         Sched<[Sched]>, VEX;
7667
7668 // AVX2 adds register forms
7669 class avx2_broadcast_rr<bits<8> opc, string OpcodeStr, RegisterClass RC,
7670                         ValueType ResVT, ValueType OpVT, SchedWrite Sched> :
7671   AVX28I<opc, MRMSrcReg, (outs RC:$dst), (ins VR128:$src),
7672          !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
7673          [(set RC:$dst, (ResVT (X86VBroadcast (OpVT VR128:$src))))]>,
7674          Sched<[Sched]>, VEX;
7675
7676 let ExeDomain = SSEPackedSingle, Predicates = [HasAVX, NoVLX] in {
7677   def VBROADCASTSSrm  : avx_broadcast_rm<0x18, "vbroadcastss", VR128,
7678                                              f32mem, v4f32, loadf32, WriteLoad>;
7679   def VBROADCASTSSYrm : avx_broadcast_rm<0x18, "vbroadcastss", VR256,
7680                                              f32mem, v8f32, loadf32,
7681                                              WriteFShuffleLd>, VEX_L;
7682 }
7683 let ExeDomain = SSEPackedDouble, Predicates = [HasAVX, NoVLX] in
7684 def VBROADCASTSDYrm  : avx_broadcast_rm<0x19, "vbroadcastsd", VR256, f64mem,
7685                                     v4f64, loadf64, WriteFShuffleLd>, VEX_L;
7686
7687 let ExeDomain = SSEPackedSingle, Predicates = [HasAVX2, NoVLX] in {
7688   def VBROADCASTSSrr  : avx2_broadcast_rr<0x18, "vbroadcastss", VR128,
7689                                           v4f32, v4f32, WriteFShuffle>;
7690   def VBROADCASTSSYrr : avx2_broadcast_rr<0x18, "vbroadcastss", VR256,
7691                                           v8f32, v4f32, WriteFShuffle256>, VEX_L;
7692 }
7693 let ExeDomain = SSEPackedDouble, Predicates = [HasAVX2, NoVLX] in
7694 def VBROADCASTSDYrr  : avx2_broadcast_rr<0x19, "vbroadcastsd", VR256,
7695                                          v4f64, v2f64, WriteFShuffle256>, VEX_L;
7696
7697 //===----------------------------------------------------------------------===//
7698 // VBROADCAST*128 - Load from memory and broadcast 128-bit vector to both
7699 //                  halves of a 256-bit vector.
7700 //
7701 let mayLoad = 1, hasSideEffects = 0, Predicates = [HasAVX2] in
7702 def VBROADCASTI128 : AVX8I<0x5A, MRMSrcMem, (outs VR256:$dst),
7703                            (ins i128mem:$src),
7704                            "vbroadcasti128\t{$src, $dst|$dst, $src}", []>,
7705                            Sched<[WriteLoad]>, VEX, VEX_L;
7706
7707 let mayLoad = 1, hasSideEffects = 0, Predicates = [HasAVX] in
7708 def VBROADCASTF128 : AVX8I<0x1A, MRMSrcMem, (outs VR256:$dst),
7709                            (ins f128mem:$src),
7710                            "vbroadcastf128\t{$src, $dst|$dst, $src}", []>,
7711                            Sched<[WriteFShuffleLd]>, VEX, VEX_L;
7712
7713 let Predicates = [HasAVX2, NoVLX] in {
7714 def : Pat<(v4i64 (X86SubVBroadcast (loadv2i64 addr:$src))),
7715           (VBROADCASTI128 addr:$src)>;
7716 def : Pat<(v8i32 (X86SubVBroadcast (bc_v4i32 (loadv2i64 addr:$src)))),
7717           (VBROADCASTI128 addr:$src)>;
7718 def : Pat<(v16i16 (X86SubVBroadcast (bc_v8i16 (loadv2i64 addr:$src)))),
7719           (VBROADCASTI128 addr:$src)>;
7720 def : Pat<(v32i8 (X86SubVBroadcast (bc_v16i8 (loadv2i64 addr:$src)))),
7721           (VBROADCASTI128 addr:$src)>;
7722 }
7723
7724 let Predicates = [HasAVX, NoVLX] in {
7725 def : Pat<(v4f64 (X86SubVBroadcast (loadv2f64 addr:$src))),
7726           (VBROADCASTF128 addr:$src)>;
7727 def : Pat<(v8f32 (X86SubVBroadcast (loadv4f32 addr:$src))),
7728           (VBROADCASTF128 addr:$src)>;
7729 }
7730
7731 let Predicates = [HasAVX1Only] in {
7732 def : Pat<(v4i64 (X86SubVBroadcast (loadv2i64 addr:$src))),
7733           (VBROADCASTF128 addr:$src)>;
7734 def : Pat<(v8i32 (X86SubVBroadcast (bc_v4i32 (loadv2i64 addr:$src)))),
7735           (VBROADCASTF128 addr:$src)>;
7736 def : Pat<(v16i16 (X86SubVBroadcast (bc_v8i16 (loadv2i64 addr:$src)))),
7737           (VBROADCASTF128 addr:$src)>;
7738 def : Pat<(v32i8 (X86SubVBroadcast (bc_v16i8 (loadv2i64 addr:$src)))),
7739           (VBROADCASTF128 addr:$src)>;
7740 }
7741
7742 //===----------------------------------------------------------------------===//
7743 // VINSERTF128 - Insert packed floating-point values
7744 //
7745 let hasSideEffects = 0, ExeDomain = SSEPackedSingle in {
7746 def VINSERTF128rr : AVXAIi8<0x18, MRMSrcReg, (outs VR256:$dst),
7747           (ins VR256:$src1, VR128:$src2, u8imm:$src3),
7748           "vinsertf128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7749           []>, Sched<[WriteFShuffle]>, VEX_4V, VEX_L;
7750 let mayLoad = 1 in
7751 def VINSERTF128rm : AVXAIi8<0x18, MRMSrcMem, (outs VR256:$dst),
7752           (ins VR256:$src1, f128mem:$src2, u8imm:$src3),
7753           "vinsertf128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7754           []>, Sched<[WriteFShuffleLd, ReadAfterLd]>, VEX_4V, VEX_L;
7755 }
7756
7757
7758 // Without AVX2 we need to concat two v4i32 V_SETALLONES to create a 256-bit
7759 // all ones value.
7760 let Predicates = [HasAVX1Only] in
7761 def : Pat<(v8i32 immAllOnesV),
7762           (VINSERTF128rr
7763            (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), (V_SETALLONES), sub_xmm),
7764            (V_SETALLONES), 1)>;
7765
7766 multiclass vinsert_lowering<string InstrStr, ValueType From, ValueType To,
7767                             PatFrag memop_frag> {
7768   def : Pat<(vinsert128_insert:$ins (To VR256:$src1), (From VR128:$src2),
7769                                    (iPTR imm)),
7770             (!cast<Instruction>(InstrStr#rr) VR256:$src1, VR128:$src2,
7771                                        (INSERT_get_vinsert128_imm VR256:$ins))>;
7772   def : Pat<(vinsert128_insert:$ins (To VR256:$src1),
7773                                     (From (bitconvert (memop_frag addr:$src2))),
7774                                     (iPTR imm)),
7775             (!cast<Instruction>(InstrStr#rm) VR256:$src1, addr:$src2,
7776                                        (INSERT_get_vinsert128_imm VR256:$ins))>;
7777 }
7778
7779 let Predicates = [HasAVX, NoVLX] in {
7780   defm : vinsert_lowering<"VINSERTF128", v4f32, v8f32, loadv4f32>;
7781   defm : vinsert_lowering<"VINSERTF128", v2f64, v4f64, loadv2f64>;
7782 }
7783
7784 let Predicates = [HasAVX1Only] in {
7785   defm : vinsert_lowering<"VINSERTF128", v2i64, v4i64,  loadv2i64>;
7786   defm : vinsert_lowering<"VINSERTF128", v4i32, v8i32,  loadv2i64>;
7787   defm : vinsert_lowering<"VINSERTF128", v8i16, v16i16, loadv2i64>;
7788   defm : vinsert_lowering<"VINSERTF128", v16i8, v32i8,  loadv2i64>;
7789 }
7790
7791 //===----------------------------------------------------------------------===//
7792 // VEXTRACTF128 - Extract packed floating-point values
7793 //
7794 let hasSideEffects = 0, ExeDomain = SSEPackedSingle in {
7795 def VEXTRACTF128rr : AVXAIi8<0x19, MRMDestReg, (outs VR128:$dst),
7796           (ins VR256:$src1, u8imm:$src2),
7797           "vextractf128\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7798           []>, Sched<[WriteFShuffle]>, VEX, VEX_L;
7799 let mayStore = 1 in
7800 def VEXTRACTF128mr : AVXAIi8<0x19, MRMDestMem, (outs),
7801           (ins f128mem:$dst, VR256:$src1, u8imm:$src2),
7802           "vextractf128\t{$src2, $src1, $dst|$dst, $src1, $src2}",
7803           []>, Sched<[WriteStore]>, VEX, VEX_L;
7804 }
7805
7806 multiclass vextract_lowering<string InstrStr, ValueType From, ValueType To> {
7807   def : Pat<(vextract128_extract:$ext VR256:$src1, (iPTR imm)),
7808             (To (!cast<Instruction>(InstrStr#rr)
7809                                     (From VR256:$src1),
7810                                     (EXTRACT_get_vextract128_imm VR128:$ext)))>;
7811   def : Pat<(store (To (vextract128_extract:$ext (From VR256:$src1),
7812                                                  (iPTR imm))), addr:$dst),
7813             (!cast<Instruction>(InstrStr#mr) addr:$dst, VR256:$src1,
7814              (EXTRACT_get_vextract128_imm VR128:$ext))>;
7815 }
7816
7817 // AVX1 patterns
7818 let Predicates = [HasAVX, NoVLX] in {
7819   defm : vextract_lowering<"VEXTRACTF128", v8f32, v4f32>;
7820   defm : vextract_lowering<"VEXTRACTF128", v4f64, v2f64>;
7821 }
7822
7823 let Predicates = [HasAVX1Only] in {
7824   defm : vextract_lowering<"VEXTRACTF128", v4i64,  v2i64>;
7825   defm : vextract_lowering<"VEXTRACTF128", v8i32,  v4i32>;
7826   defm : vextract_lowering<"VEXTRACTF128", v16i16, v8i16>;
7827   defm : vextract_lowering<"VEXTRACTF128", v32i8,  v16i8>;
7828 }
7829
7830 //===----------------------------------------------------------------------===//
7831 // VMASKMOV - Conditional SIMD Packed Loads and Stores
7832 //
7833 multiclass avx_movmask_rm<bits<8> opc_rm, bits<8> opc_mr, string OpcodeStr,
7834                           Intrinsic IntLd, Intrinsic IntLd256,
7835                           Intrinsic IntSt, Intrinsic IntSt256> {
7836   def rm  : AVX8I<opc_rm, MRMSrcMem, (outs VR128:$dst),
7837              (ins VR128:$src1, f128mem:$src2),
7838              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7839              [(set VR128:$dst, (IntLd addr:$src2, VR128:$src1))]>,
7840              VEX_4V;
7841   def Yrm : AVX8I<opc_rm, MRMSrcMem, (outs VR256:$dst),
7842              (ins VR256:$src1, f256mem:$src2),
7843              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7844              [(set VR256:$dst, (IntLd256 addr:$src2, VR256:$src1))]>,
7845              VEX_4V, VEX_L;
7846   def mr  : AVX8I<opc_mr, MRMDestMem, (outs),
7847              (ins f128mem:$dst, VR128:$src1, VR128:$src2),
7848              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7849              [(IntSt addr:$dst, VR128:$src1, VR128:$src2)]>, VEX_4V;
7850   def Ymr : AVX8I<opc_mr, MRMDestMem, (outs),
7851              (ins f256mem:$dst, VR256:$src1, VR256:$src2),
7852              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7853              [(IntSt256 addr:$dst, VR256:$src1, VR256:$src2)]>, VEX_4V, VEX_L;
7854 }
7855
7856 let ExeDomain = SSEPackedSingle in
7857 defm VMASKMOVPS : avx_movmask_rm<0x2C, 0x2E, "vmaskmovps",
7858                                  int_x86_avx_maskload_ps,
7859                                  int_x86_avx_maskload_ps_256,
7860                                  int_x86_avx_maskstore_ps,
7861                                  int_x86_avx_maskstore_ps_256>;
7862 let ExeDomain = SSEPackedDouble in
7863 defm VMASKMOVPD : avx_movmask_rm<0x2D, 0x2F, "vmaskmovpd",
7864                                  int_x86_avx_maskload_pd,
7865                                  int_x86_avx_maskload_pd_256,
7866                                  int_x86_avx_maskstore_pd,
7867                                  int_x86_avx_maskstore_pd_256>;
7868
7869 //===----------------------------------------------------------------------===//
7870 // VPERMIL - Permute Single and Double Floating-Point Values
7871 //
7872 multiclass avx_permil<bits<8> opc_rm, bits<8> opc_rmi, string OpcodeStr,
7873                       RegisterClass RC, X86MemOperand x86memop_f,
7874                       X86MemOperand x86memop_i, PatFrag i_frag,
7875                       ValueType f_vt, ValueType i_vt> {
7876   let Predicates = [HasAVX, NoVLX] in {
7877     def rr  : AVX8I<opc_rm, MRMSrcReg, (outs RC:$dst),
7878                (ins RC:$src1, RC:$src2),
7879                !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7880                [(set RC:$dst, (f_vt (X86VPermilpv RC:$src1, (i_vt RC:$src2))))]>, VEX_4V,
7881                Sched<[WriteFShuffle]>;
7882     def rm  : AVX8I<opc_rm, MRMSrcMem, (outs RC:$dst),
7883                (ins RC:$src1, x86memop_i:$src2),
7884                !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7885                [(set RC:$dst, (f_vt (X86VPermilpv RC:$src1,
7886                               (i_vt (bitconvert (i_frag addr:$src2))))))]>, VEX_4V,
7887                Sched<[WriteFShuffleLd, ReadAfterLd]>;
7888
7889     def ri  : AVXAIi8<opc_rmi, MRMSrcReg, (outs RC:$dst),
7890              (ins RC:$src1, u8imm:$src2),
7891              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7892              [(set RC:$dst, (f_vt (X86VPermilpi RC:$src1, (i8 imm:$src2))))]>, VEX,
7893              Sched<[WriteFShuffle]>;
7894     def mi  : AVXAIi8<opc_rmi, MRMSrcMem, (outs RC:$dst),
7895              (ins x86memop_f:$src1, u8imm:$src2),
7896              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
7897              [(set RC:$dst,
7898                (f_vt (X86VPermilpi (load addr:$src1), (i8 imm:$src2))))]>, VEX,
7899              Sched<[WriteFShuffleLd]>;
7900   }// Predicates = [HasAVX, NoVLX]
7901 }
7902
7903 let ExeDomain = SSEPackedSingle in {
7904   defm VPERMILPS  : avx_permil<0x0C, 0x04, "vpermilps", VR128, f128mem, i128mem,
7905                                loadv2i64, v4f32, v4i32>;
7906   defm VPERMILPSY : avx_permil<0x0C, 0x04, "vpermilps", VR256, f256mem, i256mem,
7907                                loadv4i64, v8f32, v8i32>, VEX_L;
7908 }
7909 let ExeDomain = SSEPackedDouble in {
7910   defm VPERMILPD  : avx_permil<0x0D, 0x05, "vpermilpd", VR128, f128mem, i128mem,
7911                                loadv2i64, v2f64, v2i64>;
7912   defm VPERMILPDY : avx_permil<0x0D, 0x05, "vpermilpd", VR256, f256mem, i256mem,
7913                                loadv4i64, v4f64, v4i64>, VEX_L;
7914 }
7915
7916 //===----------------------------------------------------------------------===//
7917 // VPERM2F128 - Permute Floating-Point Values in 128-bit chunks
7918 //
7919 let ExeDomain = SSEPackedSingle in {
7920 let isCommutable = 1 in
7921 def VPERM2F128rr : AVXAIi8<0x06, MRMSrcReg, (outs VR256:$dst),
7922           (ins VR256:$src1, VR256:$src2, u8imm:$src3),
7923           "vperm2f128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7924           [(set VR256:$dst, (v8f32 (X86VPerm2x128 VR256:$src1, VR256:$src2,
7925                               (i8 imm:$src3))))]>, VEX_4V, VEX_L,
7926           Sched<[WriteFShuffle]>;
7927 def VPERM2F128rm : AVXAIi8<0x06, MRMSrcMem, (outs VR256:$dst),
7928           (ins VR256:$src1, f256mem:$src2, u8imm:$src3),
7929           "vperm2f128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
7930           [(set VR256:$dst, (X86VPerm2x128 VR256:$src1, (loadv8f32 addr:$src2),
7931                              (i8 imm:$src3)))]>, VEX_4V, VEX_L,
7932           Sched<[WriteFShuffleLd, ReadAfterLd]>;
7933 }
7934
7935 let Predicates = [HasAVX] in {
7936 def : Pat<(v4f64 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
7937           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
7938 def : Pat<(v4f64 (X86VPerm2x128 VR256:$src1,
7939                   (loadv4f64 addr:$src2), (i8 imm:$imm))),
7940           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$imm)>;
7941 }
7942
7943 let Predicates = [HasAVX1Only] in {
7944 def : Pat<(v8i32 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
7945           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
7946 def : Pat<(v4i64 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
7947           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
7948 def : Pat<(v32i8 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
7949           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
7950 def : Pat<(v16i16 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
7951           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
7952
7953 def : Pat<(v8i32 (X86VPerm2x128 VR256:$src1,
7954                   (bc_v8i32 (loadv4i64 addr:$src2)), (i8 imm:$imm))),
7955           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$imm)>;
7956 def : Pat<(v4i64 (X86VPerm2x128 VR256:$src1,
7957                   (loadv4i64 addr:$src2), (i8 imm:$imm))),
7958           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$imm)>;
7959 def : Pat<(v32i8 (X86VPerm2x128 VR256:$src1,
7960                   (bc_v32i8 (loadv4i64 addr:$src2)), (i8 imm:$imm))),
7961           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$imm)>;
7962 def : Pat<(v16i16 (X86VPerm2x128 VR256:$src1,
7963                   (bc_v16i16 (loadv4i64 addr:$src2)), (i8 imm:$imm))),
7964           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$imm)>;
7965 }
7966
7967 //===----------------------------------------------------------------------===//
7968 // VZERO - Zero YMM registers
7969 //
7970 // Note, these instruction do not affect the YMM16-YMM31.
7971 let Defs = [YMM0, YMM1, YMM2, YMM3, YMM4, YMM5, YMM6, YMM7,
7972             YMM8, YMM9, YMM10, YMM11, YMM12, YMM13, YMM14, YMM15] in {
7973   // Zero All YMM registers
7974   def VZEROALL : I<0x77, RawFrm, (outs), (ins), "vzeroall",
7975                   [(int_x86_avx_vzeroall)]>, PS, VEX, VEX_L, Requires<[HasAVX]>, VEX_WIG;
7976
7977   // Zero Upper bits of YMM registers
7978   def VZEROUPPER : I<0x77, RawFrm, (outs), (ins), "vzeroupper",
7979                      [(int_x86_avx_vzeroupper)]>, PS, VEX, Requires<[HasAVX]>, VEX_WIG;
7980 }
7981
7982 //===----------------------------------------------------------------------===//
7983 // Half precision conversion instructions
7984 //===----------------------------------------------------------------------===//
7985 multiclass f16c_ph2ps<RegisterClass RC, X86MemOperand x86memop, Intrinsic Int> {
7986   def rr : I<0x13, MRMSrcReg, (outs RC:$dst), (ins VR128:$src),
7987              "vcvtph2ps\t{$src, $dst|$dst, $src}",
7988              [(set RC:$dst, (Int VR128:$src))]>,
7989              T8PD, VEX, Sched<[WriteCvtF2F]>;
7990   let hasSideEffects = 0, mayLoad = 1 in
7991   def rm : I<0x13, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
7992              "vcvtph2ps\t{$src, $dst|$dst, $src}", []>, T8PD, VEX,
7993              Sched<[WriteCvtF2FLd]>;
7994 }
7995
7996 multiclass f16c_ps2ph<RegisterClass RC, X86MemOperand x86memop, Intrinsic Int> {
7997   def rr : Ii8<0x1D, MRMDestReg, (outs VR128:$dst),
7998                (ins RC:$src1, i32u8imm:$src2),
7999                "vcvtps2ph\t{$src2, $src1, $dst|$dst, $src1, $src2}",
8000                [(set VR128:$dst, (Int RC:$src1, imm:$src2))]>,
8001                TAPD, VEX, Sched<[WriteCvtF2F]>;
8002   let hasSideEffects = 0, mayStore = 1,
8003       SchedRW = [WriteCvtF2FLd, WriteRMW] in
8004   def mr : Ii8<0x1D, MRMDestMem, (outs),
8005                (ins x86memop:$dst, RC:$src1, i32u8imm:$src2),
8006                "vcvtps2ph\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
8007                TAPD, VEX;
8008 }
8009
8010 let Predicates = [HasF16C] in {
8011   defm VCVTPH2PS  : f16c_ph2ps<VR128, f64mem, int_x86_vcvtph2ps_128>;
8012   defm VCVTPH2PSY : f16c_ph2ps<VR256, f128mem, int_x86_vcvtph2ps_256>, VEX_L;
8013   defm VCVTPS2PH  : f16c_ps2ph<VR128, f64mem, int_x86_vcvtps2ph_128>;
8014   defm VCVTPS2PHY : f16c_ps2ph<VR256, f128mem, int_x86_vcvtps2ph_256>, VEX_L;
8015
8016   // Pattern match vcvtph2ps of a scalar i64 load.
8017   def : Pat<(int_x86_vcvtph2ps_128 (vzmovl_v2i64 addr:$src)),
8018             (VCVTPH2PSrm addr:$src)>;
8019   def : Pat<(int_x86_vcvtph2ps_128 (vzload_v2i64 addr:$src)),
8020             (VCVTPH2PSrm addr:$src)>;
8021   def : Pat<(int_x86_vcvtph2ps_128 (bitconvert
8022               (v2i64 (scalar_to_vector (loadi64 addr:$src))))),
8023             (VCVTPH2PSrm addr:$src)>;
8024
8025   def : Pat<(store (f64 (extractelt (bc_v2f64 (v8i16
8026                   (int_x86_vcvtps2ph_128 VR128:$src1, i32:$src2))), (iPTR 0))),
8027                    addr:$dst),
8028                    (VCVTPS2PHmr addr:$dst, VR128:$src1, imm:$src2)>;
8029   def : Pat<(store (i64 (extractelt (bc_v2i64 (v8i16
8030                   (int_x86_vcvtps2ph_128 VR128:$src1, i32:$src2))), (iPTR 0))),
8031                    addr:$dst),
8032                    (VCVTPS2PHmr addr:$dst, VR128:$src1, imm:$src2)>;
8033   def : Pat<(store (v8i16 (int_x86_vcvtps2ph_256 VR256:$src1, i32:$src2)),
8034                    addr:$dst),
8035                    (VCVTPS2PHYmr addr:$dst, VR256:$src1, imm:$src2)>;
8036 }
8037
8038 // Patterns for  matching conversions from float to half-float and vice versa.
8039 let Predicates = [HasF16C, NoVLX] in {
8040   // Use MXCSR.RC for rounding instead of explicitly specifying the default
8041   // rounding mode (Nearest-Even, encoded as 0). Both are equivalent in the
8042   // configurations we support (the default). However, falling back to MXCSR is
8043   // more consistent with other instructions, which are always controlled by it.
8044   // It's encoded as 0b100.
8045   def : Pat<(fp_to_f16 FR32:$src),
8046             (i16 (EXTRACT_SUBREG (VMOVPDI2DIrr (VCVTPS2PHrr
8047               (COPY_TO_REGCLASS FR32:$src, VR128), 4)), sub_16bit))>;
8048
8049   def : Pat<(f16_to_fp GR16:$src),
8050             (f32 (COPY_TO_REGCLASS (VCVTPH2PSrr
8051               (COPY_TO_REGCLASS (MOVSX32rr16 GR16:$src), VR128)), FR32)) >;
8052
8053   def : Pat<(f16_to_fp (i16 (fp_to_f16 FR32:$src))),
8054             (f32 (COPY_TO_REGCLASS (VCVTPH2PSrr
8055               (VCVTPS2PHrr (COPY_TO_REGCLASS FR32:$src, VR128), 4)), FR32)) >;
8056 }
8057
8058 //===----------------------------------------------------------------------===//
8059 // AVX2 Instructions
8060 //===----------------------------------------------------------------------===//
8061
8062 /// AVX2_binop_rmi - AVX2 binary operator with 8-bit immediate
8063 multiclass AVX2_binop_rmi<bits<8> opc, string OpcodeStr, SDNode OpNode,
8064                           ValueType OpVT, RegisterClass RC, PatFrag memop_frag,
8065                           X86MemOperand x86memop> {
8066   let isCommutable = 1 in
8067   def rri : AVX2AIi8<opc, MRMSrcReg, (outs RC:$dst),
8068         (ins RC:$src1, RC:$src2, u8imm:$src3),
8069         !strconcat(OpcodeStr,
8070             "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
8071         [(set RC:$dst, (OpVT (OpNode RC:$src1, RC:$src2, imm:$src3)))]>,
8072         Sched<[WriteBlend]>, VEX_4V;
8073   def rmi : AVX2AIi8<opc, MRMSrcMem, (outs RC:$dst),
8074         (ins RC:$src1, x86memop:$src2, u8imm:$src3),
8075         !strconcat(OpcodeStr,
8076             "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
8077         [(set RC:$dst,
8078           (OpVT (OpNode RC:$src1,
8079            (bitconvert (memop_frag addr:$src2)), imm:$src3)))]>,
8080         Sched<[WriteBlendLd, ReadAfterLd]>, VEX_4V;
8081 }
8082
8083 defm VPBLENDD : AVX2_binop_rmi<0x02, "vpblendd", X86Blendi, v4i32,
8084                                VR128, loadv2i64, i128mem>;
8085 defm VPBLENDDY : AVX2_binop_rmi<0x02, "vpblendd", X86Blendi, v8i32,
8086                                 VR256, loadv4i64, i256mem>, VEX_L;
8087
8088 // For insertion into the zero index (low half) of a 256-bit vector, it is
8089 // more efficient to generate a blend with immediate instead of an insert*128.
8090 let Predicates = [HasAVX2] in {
8091 def : Pat<(insert_subvector (v8i32 VR256:$src1), (v4i32 VR128:$src2), (iPTR 0)),
8092           (VPBLENDDYrri VR256:$src1,
8093                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8094                                        VR128:$src2, sub_xmm), 0xf)>;
8095 def : Pat<(insert_subvector (v4i64 VR256:$src1), (v2i64 VR128:$src2), (iPTR 0)),
8096           (VPBLENDDYrri VR256:$src1,
8097                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8098                                        VR128:$src2, sub_xmm), 0xf)>;
8099 def : Pat<(insert_subvector (v16i16 VR256:$src1), (v8i16 VR128:$src2), (iPTR 0)),
8100           (VPBLENDDYrri VR256:$src1,
8101                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8102                                        VR128:$src2, sub_xmm), 0xf)>;
8103 def : Pat<(insert_subvector (v32i8 VR256:$src1), (v16i8 VR128:$src2), (iPTR 0)),
8104           (VPBLENDDYrri VR256:$src1,
8105                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8106                                        VR128:$src2, sub_xmm), 0xf)>;
8107 }
8108
8109 let Predicates = [HasAVX1Only] in {
8110 def : Pat<(insert_subvector (v8i32 VR256:$src1), (v4i32 VR128:$src2), (iPTR 0)),
8111           (VBLENDPSYrri VR256:$src1,
8112                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8113                                        VR128:$src2, sub_xmm), 0xf)>;
8114 def : Pat<(insert_subvector (v4i64 VR256:$src1), (v2i64 VR128:$src2), (iPTR 0)),
8115           (VBLENDPSYrri VR256:$src1,
8116                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8117                                        VR128:$src2, sub_xmm), 0xf)>;
8118 def : Pat<(insert_subvector (v16i16 VR256:$src1), (v8i16 VR128:$src2), (iPTR 0)),
8119           (VBLENDPSYrri VR256:$src1,
8120                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8121                                        VR128:$src2, sub_xmm), 0xf)>;
8122 def : Pat<(insert_subvector (v32i8 VR256:$src1), (v16i8 VR128:$src2), (iPTR 0)),
8123           (VBLENDPSYrri VR256:$src1,
8124                         (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8125                                        VR128:$src2, sub_xmm), 0xf)>;
8126 }
8127
8128 //===----------------------------------------------------------------------===//
8129 // VPBROADCAST - Load from memory and broadcast to all elements of the
8130 //               destination operand
8131 //
8132 multiclass avx2_broadcast<bits<8> opc, string OpcodeStr,
8133                           X86MemOperand x86memop, PatFrag ld_frag,
8134                           ValueType OpVT128, ValueType OpVT256, Predicate prd> {
8135   let Predicates = [HasAVX2, prd] in {
8136     def rr : AVX28I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
8137                   !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
8138                   [(set VR128:$dst,
8139                    (OpVT128 (X86VBroadcast (OpVT128 VR128:$src))))]>,
8140                   Sched<[WriteShuffle]>, VEX;
8141     def rm : AVX28I<opc, MRMSrcMem, (outs VR128:$dst), (ins x86memop:$src),
8142                   !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
8143                   [(set VR128:$dst,
8144                    (OpVT128 (X86VBroadcast (ld_frag addr:$src))))]>,
8145                   Sched<[WriteLoad]>, VEX;
8146     def Yrr : AVX28I<opc, MRMSrcReg, (outs VR256:$dst), (ins VR128:$src),
8147                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
8148                    [(set VR256:$dst,
8149                     (OpVT256 (X86VBroadcast (OpVT128 VR128:$src))))]>,
8150                    Sched<[WriteShuffle256]>, VEX, VEX_L;
8151     def Yrm : AVX28I<opc, MRMSrcMem, (outs VR256:$dst), (ins x86memop:$src),
8152                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
8153                    [(set VR256:$dst,
8154                     (OpVT256 (X86VBroadcast (ld_frag addr:$src))))]>,
8155                    Sched<[WriteLoad]>, VEX, VEX_L;
8156
8157     // Provide aliases for broadcast from the same register class that
8158     // automatically does the extract.
8159     def : Pat<(OpVT256 (X86VBroadcast (OpVT256 VR256:$src))),
8160               (!cast<Instruction>(NAME#"Yrr")
8161                   (OpVT128 (EXTRACT_SUBREG (OpVT256 VR256:$src),sub_xmm)))>;
8162   }
8163 }
8164
8165 defm VPBROADCASTB  : avx2_broadcast<0x78, "vpbroadcastb", i8mem, loadi8,
8166                                     v16i8, v32i8, NoVLX_Or_NoBWI>;
8167 defm VPBROADCASTW  : avx2_broadcast<0x79, "vpbroadcastw", i16mem, loadi16,
8168                                     v8i16, v16i16, NoVLX_Or_NoBWI>;
8169 defm VPBROADCASTD  : avx2_broadcast<0x58, "vpbroadcastd", i32mem, loadi32,
8170                                     v4i32, v8i32, NoVLX>;
8171 defm VPBROADCASTQ  : avx2_broadcast<0x59, "vpbroadcastq", i64mem, loadi64,
8172                                     v2i64, v4i64, NoVLX>;
8173
8174 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
8175   // 32-bit targets will fail to load a i64 directly but can use ZEXT_LOAD.
8176   def : Pat<(v2i64 (X86VBroadcast (v2i64 (X86vzload addr:$src)))),
8177             (VPBROADCASTQrm addr:$src)>;
8178   def : Pat<(v4i64 (X86VBroadcast (v4i64 (X86vzload addr:$src)))),
8179             (VPBROADCASTQYrm addr:$src)>;
8180   // loadi16 is tricky to fold, because !isTypeDesirableForOp, justifiably.
8181   // This means we'll encounter truncated i32 loads; match that here.
8182   def : Pat<(v8i16 (X86VBroadcast (i16 (trunc (i32 (load addr:$src)))))),
8183             (VPBROADCASTWrm addr:$src)>;
8184   def : Pat<(v16i16 (X86VBroadcast (i16 (trunc (i32 (load addr:$src)))))),
8185             (VPBROADCASTWYrm addr:$src)>;
8186   def : Pat<(v8i16 (X86VBroadcast
8187               (i16 (trunc (i32 (zextloadi16 addr:$src)))))),
8188             (VPBROADCASTWrm addr:$src)>;
8189   def : Pat<(v16i16 (X86VBroadcast
8190               (i16 (trunc (i32 (zextloadi16 addr:$src)))))),
8191             (VPBROADCASTWYrm addr:$src)>;
8192 }
8193
8194 let Predicates = [HasAVX2, NoVLX] in {
8195   // Provide aliases for broadcast from the same register class that
8196   // automatically does the extract.
8197   def : Pat<(v8f32 (X86VBroadcast (v8f32 VR256:$src))),
8198             (VBROADCASTSSYrr (v4f32 (EXTRACT_SUBREG (v8f32 VR256:$src),
8199                                                     sub_xmm)))>;
8200   def : Pat<(v4f64 (X86VBroadcast (v4f64 VR256:$src))),
8201             (VBROADCASTSDYrr (v2f64 (EXTRACT_SUBREG (v4f64 VR256:$src),
8202                                                     sub_xmm)))>;
8203 }
8204
8205 let Predicates = [HasAVX2, NoVLX] in {
8206   // Provide fallback in case the load node that is used in the patterns above
8207   // is used by additional users, which prevents the pattern selection.
8208     def : Pat<(v4f32 (X86VBroadcast FR32:$src)),
8209               (VBROADCASTSSrr (COPY_TO_REGCLASS FR32:$src, VR128))>;
8210     def : Pat<(v8f32 (X86VBroadcast FR32:$src)),
8211               (VBROADCASTSSYrr (COPY_TO_REGCLASS FR32:$src, VR128))>;
8212     def : Pat<(v4f64 (X86VBroadcast FR64:$src)),
8213               (VBROADCASTSDYrr (COPY_TO_REGCLASS FR64:$src, VR128))>;
8214 }
8215
8216 let Predicates = [HasAVX2, NoVLX_Or_NoBWI] in {
8217   def : Pat<(v16i8 (X86VBroadcast GR8:$src)),
8218         (VPBROADCASTBrr (COPY_TO_REGCLASS
8219                          (i32 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
8220                                              GR8:$src, sub_8bit)),
8221                          VR128))>;
8222   def : Pat<(v32i8 (X86VBroadcast GR8:$src)),
8223         (VPBROADCASTBYrr (COPY_TO_REGCLASS
8224                           (i32 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
8225                                               GR8:$src, sub_8bit)),
8226                           VR128))>;
8227
8228   def : Pat<(v8i16 (X86VBroadcast GR16:$src)),
8229         (VPBROADCASTWrr (COPY_TO_REGCLASS
8230                          (i32 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
8231                                              GR16:$src, sub_16bit)),
8232                          VR128))>;
8233   def : Pat<(v16i16 (X86VBroadcast GR16:$src)),
8234         (VPBROADCASTWYrr (COPY_TO_REGCLASS
8235                           (i32 (INSERT_SUBREG (i32 (IMPLICIT_DEF)),
8236                                               GR16:$src, sub_16bit)),
8237                           VR128))>;
8238 }
8239 let Predicates = [HasAVX2, NoVLX] in {
8240   def : Pat<(v4i32 (X86VBroadcast GR32:$src)),
8241             (VPBROADCASTDrr (COPY_TO_REGCLASS GR32:$src, VR128))>;
8242   def : Pat<(v8i32 (X86VBroadcast GR32:$src)),
8243             (VPBROADCASTDYrr (COPY_TO_REGCLASS GR32:$src, VR128))>;
8244   def : Pat<(v2i64 (X86VBroadcast GR64:$src)),
8245             (VPBROADCASTQrr (COPY_TO_REGCLASS GR64:$src, VR128))>;
8246   def : Pat<(v4i64 (X86VBroadcast GR64:$src)),
8247             (VPBROADCASTQYrr (COPY_TO_REGCLASS GR64:$src, VR128))>;
8248 }
8249
8250 // AVX1 broadcast patterns
8251 let Predicates = [HasAVX1Only] in {
8252 def : Pat<(v8i32 (X86VBroadcast (loadi32 addr:$src))),
8253           (VBROADCASTSSYrm addr:$src)>;
8254 def : Pat<(v4i64 (X86VBroadcast (loadi64 addr:$src))),
8255           (VBROADCASTSDYrm addr:$src)>;
8256 def : Pat<(v4i32 (X86VBroadcast (loadi32 addr:$src))),
8257           (VBROADCASTSSrm addr:$src)>;
8258 }
8259
8260   // Provide fallback in case the load node that is used in the patterns above
8261   // is used by additional users, which prevents the pattern selection.
8262 let Predicates = [HasAVX, NoVLX] in {
8263   // 128bit broadcasts:
8264   def : Pat<(v2f64 (X86VBroadcast f64:$src)),
8265             (VMOVDDUPrr (COPY_TO_REGCLASS FR64:$src, VR128))>;
8266 }
8267
8268 let Predicates = [HasAVX1Only] in {
8269   def : Pat<(v4f32 (X86VBroadcast FR32:$src)),
8270             (VPERMILPSri (COPY_TO_REGCLASS FR32:$src, VR128), 0)>;
8271   def : Pat<(v8f32 (X86VBroadcast FR32:$src)),
8272             (VINSERTF128rr (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)),
8273               (VPERMILPSri (COPY_TO_REGCLASS FR32:$src, VR128), 0), sub_xmm),
8274               (VPERMILPSri (COPY_TO_REGCLASS FR32:$src, VR128), 0), 1)>;
8275   def : Pat<(v4f64 (X86VBroadcast FR64:$src)),
8276             (VINSERTF128rr (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)),
8277               (VMOVDDUPrr (COPY_TO_REGCLASS FR64:$src, VR128)), sub_xmm),
8278               (VMOVDDUPrr (COPY_TO_REGCLASS FR64:$src, VR128)), 1)>;
8279
8280   def : Pat<(v4i32 (X86VBroadcast GR32:$src)),
8281             (VPSHUFDri (COPY_TO_REGCLASS GR32:$src, VR128), 0)>;
8282   def : Pat<(v8i32 (X86VBroadcast GR32:$src)),
8283             (VINSERTF128rr (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)),
8284               (VPSHUFDri (COPY_TO_REGCLASS GR32:$src, VR128), 0), sub_xmm),
8285               (VPSHUFDri (COPY_TO_REGCLASS GR32:$src, VR128), 0), 1)>;
8286   def : Pat<(v4i64 (X86VBroadcast GR64:$src)),
8287             (VINSERTF128rr (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)),
8288               (VPSHUFDri (COPY_TO_REGCLASS GR64:$src, VR128), 0x44), sub_xmm),
8289               (VPSHUFDri (COPY_TO_REGCLASS GR64:$src, VR128), 0x44), 1)>;
8290
8291   def : Pat<(v2i64 (X86VBroadcast i64:$src)),
8292             (VPSHUFDri (COPY_TO_REGCLASS GR64:$src, VR128), 0x44)>;
8293 }
8294
8295 //===----------------------------------------------------------------------===//
8296 // VPERM - Permute instructions
8297 //
8298
8299 multiclass avx2_perm<bits<8> opc, string OpcodeStr, PatFrag mem_frag,
8300                      ValueType OpVT, X86FoldableSchedWrite Sched,
8301                      X86MemOperand memOp> {
8302   let Predicates = [HasAVX2, NoVLX] in {
8303     def Yrr : AVX28I<opc, MRMSrcReg, (outs VR256:$dst),
8304                      (ins VR256:$src1, VR256:$src2),
8305                      !strconcat(OpcodeStr,
8306                          "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8307                      [(set VR256:$dst,
8308                        (OpVT (X86VPermv VR256:$src1, VR256:$src2)))]>,
8309                      Sched<[Sched]>, VEX_4V, VEX_L;
8310     def Yrm : AVX28I<opc, MRMSrcMem, (outs VR256:$dst),
8311                      (ins VR256:$src1, memOp:$src2),
8312                      !strconcat(OpcodeStr,
8313                          "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8314                      [(set VR256:$dst,
8315                        (OpVT (X86VPermv VR256:$src1,
8316                               (bitconvert (mem_frag addr:$src2)))))]>,
8317                      Sched<[Sched.Folded, ReadAfterLd]>, VEX_4V, VEX_L;
8318   }
8319 }
8320
8321 defm VPERMD : avx2_perm<0x36, "vpermd", loadv4i64, v8i32, WriteShuffle256,
8322                         i256mem>;
8323 let ExeDomain = SSEPackedSingle in
8324 defm VPERMPS : avx2_perm<0x16, "vpermps", loadv8f32, v8f32, WriteFShuffle256,
8325                         f256mem>;
8326
8327 multiclass avx2_perm_imm<bits<8> opc, string OpcodeStr, PatFrag mem_frag,
8328                          ValueType OpVT, X86FoldableSchedWrite Sched,
8329                          X86MemOperand memOp> {
8330   let Predicates = [HasAVX2, NoVLX] in {
8331     def Yri : AVX2AIi8<opc, MRMSrcReg, (outs VR256:$dst),
8332                        (ins VR256:$src1, u8imm:$src2),
8333                        !strconcat(OpcodeStr,
8334                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8335                        [(set VR256:$dst,
8336                          (OpVT (X86VPermi VR256:$src1, (i8 imm:$src2))))]>,
8337                        Sched<[Sched]>, VEX, VEX_L;
8338     def Ymi : AVX2AIi8<opc, MRMSrcMem, (outs VR256:$dst),
8339                        (ins memOp:$src1, u8imm:$src2),
8340                        !strconcat(OpcodeStr,
8341                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8342                        [(set VR256:$dst,
8343                          (OpVT (X86VPermi (mem_frag addr:$src1),
8344                                 (i8 imm:$src2))))]>,
8345                        Sched<[Sched.Folded, ReadAfterLd]>, VEX, VEX_L;
8346   }
8347 }
8348
8349 defm VPERMQ : avx2_perm_imm<0x00, "vpermq", loadv4i64, v4i64,
8350                             WriteShuffle256, i256mem>, VEX_W;
8351 let ExeDomain = SSEPackedDouble in
8352 defm VPERMPD : avx2_perm_imm<0x01, "vpermpd", loadv4f64, v4f64,
8353                              WriteFShuffle256, f256mem>, VEX_W;
8354
8355 //===----------------------------------------------------------------------===//
8356 // VPERM2I128 - Permute Floating-Point Values in 128-bit chunks
8357 //
8358 let isCommutable = 1 in
8359 def VPERM2I128rr : AVX2AIi8<0x46, MRMSrcReg, (outs VR256:$dst),
8360           (ins VR256:$src1, VR256:$src2, u8imm:$src3),
8361           "vperm2i128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8362           [(set VR256:$dst, (v4i64 (X86VPerm2x128 VR256:$src1, VR256:$src2,
8363                             (i8 imm:$src3))))]>, Sched<[WriteShuffle256]>,
8364           VEX_4V, VEX_L;
8365 def VPERM2I128rm : AVX2AIi8<0x46, MRMSrcMem, (outs VR256:$dst),
8366           (ins VR256:$src1, f256mem:$src2, u8imm:$src3),
8367           "vperm2i128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8368           [(set VR256:$dst, (X86VPerm2x128 VR256:$src1, (loadv4i64 addr:$src2),
8369                              (i8 imm:$src3)))]>,
8370           Sched<[WriteShuffle256Ld, ReadAfterLd]>, VEX_4V, VEX_L;
8371
8372 let Predicates = [HasAVX2] in {
8373 def : Pat<(v8i32 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
8374           (VPERM2I128rr VR256:$src1, VR256:$src2, imm:$imm)>;
8375 def : Pat<(v32i8 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
8376           (VPERM2I128rr VR256:$src1, VR256:$src2, imm:$imm)>;
8377 def : Pat<(v16i16 (X86VPerm2x128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
8378           (VPERM2I128rr VR256:$src1, VR256:$src2, imm:$imm)>;
8379
8380 def : Pat<(v32i8 (X86VPerm2x128 VR256:$src1, (bc_v32i8 (loadv4i64 addr:$src2)),
8381                   (i8 imm:$imm))),
8382           (VPERM2I128rm VR256:$src1, addr:$src2, imm:$imm)>;
8383 def : Pat<(v16i16 (X86VPerm2x128 VR256:$src1,
8384                    (bc_v16i16 (loadv4i64 addr:$src2)), (i8 imm:$imm))),
8385           (VPERM2I128rm VR256:$src1, addr:$src2, imm:$imm)>;
8386 def : Pat<(v8i32 (X86VPerm2x128 VR256:$src1, (bc_v8i32 (loadv4i64 addr:$src2)),
8387                   (i8 imm:$imm))),
8388           (VPERM2I128rm VR256:$src1, addr:$src2, imm:$imm)>;
8389 }
8390
8391
8392 //===----------------------------------------------------------------------===//
8393 // VINSERTI128 - Insert packed integer values
8394 //
8395 let hasSideEffects = 0 in {
8396 def VINSERTI128rr : AVX2AIi8<0x38, MRMSrcReg, (outs VR256:$dst),
8397           (ins VR256:$src1, VR128:$src2, u8imm:$src3),
8398           "vinserti128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8399           []>, Sched<[WriteShuffle256]>, VEX_4V, VEX_L;
8400 let mayLoad = 1 in
8401 def VINSERTI128rm : AVX2AIi8<0x38, MRMSrcMem, (outs VR256:$dst),
8402           (ins VR256:$src1, i128mem:$src2, u8imm:$src3),
8403           "vinserti128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
8404           []>, Sched<[WriteShuffle256Ld, ReadAfterLd]>, VEX_4V, VEX_L;
8405 }
8406
8407 let Predicates = [HasAVX2, NoVLX] in {
8408   defm : vinsert_lowering<"VINSERTI128", v2i64, v4i64,  loadv2i64>;
8409   defm : vinsert_lowering<"VINSERTI128", v4i32, v8i32,  loadv2i64>;
8410   defm : vinsert_lowering<"VINSERTI128", v8i16, v16i16, loadv2i64>;
8411   defm : vinsert_lowering<"VINSERTI128", v16i8, v32i8,  loadv2i64>;
8412 }
8413
8414 //===----------------------------------------------------------------------===//
8415 // VEXTRACTI128 - Extract packed integer values
8416 //
8417 def VEXTRACTI128rr : AVX2AIi8<0x39, MRMDestReg, (outs VR128:$dst),
8418           (ins VR256:$src1, u8imm:$src2),
8419           "vextracti128\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
8420           Sched<[WriteShuffle256]>, VEX, VEX_L;
8421 let hasSideEffects = 0, mayStore = 1 in
8422 def VEXTRACTI128mr : AVX2AIi8<0x39, MRMDestMem, (outs),
8423           (ins i128mem:$dst, VR256:$src1, u8imm:$src2),
8424           "vextracti128\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
8425           Sched<[WriteStore]>, VEX, VEX_L;
8426
8427 let Predicates = [HasAVX2, NoVLX] in {
8428   defm : vextract_lowering<"VEXTRACTI128", v4i64,  v2i64>;
8429   defm : vextract_lowering<"VEXTRACTI128", v8i32,  v4i32>;
8430   defm : vextract_lowering<"VEXTRACTI128", v16i16, v8i16>;
8431   defm : vextract_lowering<"VEXTRACTI128", v32i8,  v16i8>;
8432 }
8433
8434 //===----------------------------------------------------------------------===//
8435 // VPMASKMOV - Conditional SIMD Integer Packed Loads and Stores
8436 //
8437 multiclass avx2_pmovmask<string OpcodeStr,
8438                          Intrinsic IntLd128, Intrinsic IntLd256,
8439                          Intrinsic IntSt128, Intrinsic IntSt256> {
8440   def rm  : AVX28I<0x8c, MRMSrcMem, (outs VR128:$dst),
8441              (ins VR128:$src1, i128mem:$src2),
8442              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8443              [(set VR128:$dst, (IntLd128 addr:$src2, VR128:$src1))]>, VEX_4V;
8444   def Yrm : AVX28I<0x8c, MRMSrcMem, (outs VR256:$dst),
8445              (ins VR256:$src1, i256mem:$src2),
8446              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8447              [(set VR256:$dst, (IntLd256 addr:$src2, VR256:$src1))]>,
8448              VEX_4V, VEX_L;
8449   def mr  : AVX28I<0x8e, MRMDestMem, (outs),
8450              (ins i128mem:$dst, VR128:$src1, VR128:$src2),
8451              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8452              [(IntSt128 addr:$dst, VR128:$src1, VR128:$src2)]>, VEX_4V;
8453   def Ymr : AVX28I<0x8e, MRMDestMem, (outs),
8454              (ins i256mem:$dst, VR256:$src1, VR256:$src2),
8455              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8456              [(IntSt256 addr:$dst, VR256:$src1, VR256:$src2)]>, VEX_4V, VEX_L;
8457 }
8458
8459 defm VPMASKMOVD : avx2_pmovmask<"vpmaskmovd",
8460                                 int_x86_avx2_maskload_d,
8461                                 int_x86_avx2_maskload_d_256,
8462                                 int_x86_avx2_maskstore_d,
8463                                 int_x86_avx2_maskstore_d_256>;
8464 defm VPMASKMOVQ : avx2_pmovmask<"vpmaskmovq",
8465                                 int_x86_avx2_maskload_q,
8466                                 int_x86_avx2_maskload_q_256,
8467                                 int_x86_avx2_maskstore_q,
8468                                 int_x86_avx2_maskstore_q_256>, VEX_W;
8469
8470 multiclass maskmov_lowering<string InstrStr, RegisterClass RC, ValueType VT,
8471                           ValueType MaskVT, string BlendStr, ValueType ZeroVT> {
8472     // masked store
8473     def: Pat<(X86mstore addr:$ptr, (MaskVT RC:$mask), (VT RC:$src)),
8474              (!cast<Instruction>(InstrStr#"mr") addr:$ptr, RC:$mask, RC:$src)>;
8475     // masked load
8476     def: Pat<(VT (X86mload addr:$ptr, (MaskVT RC:$mask), undef)),
8477              (!cast<Instruction>(InstrStr#"rm") RC:$mask, addr:$ptr)>;
8478     def: Pat<(VT (X86mload addr:$ptr, (MaskVT RC:$mask),
8479                               (VT (bitconvert (ZeroVT immAllZerosV))))),
8480              (!cast<Instruction>(InstrStr#"rm") RC:$mask, addr:$ptr)>;
8481     def: Pat<(VT (X86mload addr:$ptr, (MaskVT RC:$mask), (VT RC:$src0))),
8482              (!cast<Instruction>(BlendStr#"rr")
8483                  RC:$src0,
8484                  (!cast<Instruction>(InstrStr#"rm") RC:$mask, addr:$ptr),
8485                  RC:$mask)>;
8486 }
8487 let Predicates = [HasAVX] in {
8488   defm : maskmov_lowering<"VMASKMOVPS", VR128, v4f32, v4i32, "VBLENDVPS", v4i32>;
8489   defm : maskmov_lowering<"VMASKMOVPD", VR128, v2f64, v2i64, "VBLENDVPD", v4i32>;
8490   defm : maskmov_lowering<"VMASKMOVPSY", VR256, v8f32, v8i32, "VBLENDVPSY", v8i32>;
8491   defm : maskmov_lowering<"VMASKMOVPDY", VR256, v4f64, v4i64, "VBLENDVPDY", v8i32>;
8492 }
8493 let Predicates = [HasAVX1Only] in {
8494   // load/store i32/i64 not supported use ps/pd version
8495   defm : maskmov_lowering<"VMASKMOVPSY", VR256, v8i32, v8i32, "VBLENDVPSY", v8i32>;
8496   defm : maskmov_lowering<"VMASKMOVPDY", VR256, v4i64, v4i64, "VBLENDVPDY", v8i32>;
8497   defm : maskmov_lowering<"VMASKMOVPS", VR128, v4i32, v4i32, "VBLENDVPS", v4i32>;
8498   defm : maskmov_lowering<"VMASKMOVPD", VR128, v2i64, v2i64, "VBLENDVPD", v4i32>;
8499 }
8500 let Predicates = [HasAVX2] in {
8501   defm : maskmov_lowering<"VPMASKMOVDY", VR256, v8i32, v8i32, "VBLENDVPSY", v8i32>;
8502   defm : maskmov_lowering<"VPMASKMOVQY", VR256, v4i64, v4i64, "VBLENDVPDY", v8i32>;
8503   defm : maskmov_lowering<"VPMASKMOVD", VR128, v4i32, v4i32, "VBLENDVPS", v4i32>;
8504   defm : maskmov_lowering<"VPMASKMOVQ", VR128, v2i64, v2i64, "VBLENDVPD", v4i32>;
8505 }
8506
8507 //===----------------------------------------------------------------------===//
8508 // SubVector Broadcasts
8509 // Provide fallback in case the load node that is used in the patterns above
8510 // is used by additional users, which prevents the pattern selection.
8511
8512 let Predicates = [HasAVX2, NoVLX] in {
8513 def : Pat<(v4i64 (X86SubVBroadcast (v2i64 VR128:$src))),
8514           (VINSERTI128rr (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8515                          (v2i64 VR128:$src), 1)>;
8516 def : Pat<(v8i32 (X86SubVBroadcast (v4i32 VR128:$src))),
8517           (VINSERTI128rr (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8518                          (v4i32 VR128:$src), 1)>;
8519 def : Pat<(v16i16 (X86SubVBroadcast (v8i16 VR128:$src))),
8520           (VINSERTI128rr (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8521                          (v8i16 VR128:$src), 1)>;
8522 def : Pat<(v32i8 (X86SubVBroadcast (v16i8 VR128:$src))),
8523           (VINSERTI128rr (INSERT_SUBREG (v32i8 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8524                          (v16i8 VR128:$src), 1)>;
8525 }
8526
8527 let Predicates = [HasAVX, NoVLX] in {
8528 def : Pat<(v4f64 (X86SubVBroadcast (v2f64 VR128:$src))),
8529           (VINSERTF128rr (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8530                          (v2f64 VR128:$src), 1)>;
8531 def : Pat<(v8f32 (X86SubVBroadcast (v4f32 VR128:$src))),
8532           (VINSERTF128rr (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8533                          (v4f32 VR128:$src), 1)>;
8534 }
8535
8536 let Predicates = [HasAVX1Only] in {
8537 def : Pat<(v4i64 (X86SubVBroadcast (v2i64 VR128:$src))),
8538           (VINSERTF128rr (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8539                          (v2i64 VR128:$src), 1)>;
8540 def : Pat<(v8i32 (X86SubVBroadcast (v4i32 VR128:$src))),
8541           (VINSERTF128rr (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8542                          (v4i32 VR128:$src), 1)>;
8543 def : Pat<(v16i16 (X86SubVBroadcast (v8i16 VR128:$src))),
8544           (VINSERTF128rr (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8545                          (v8i16 VR128:$src), 1)>;
8546 def : Pat<(v32i8 (X86SubVBroadcast (v16i8 VR128:$src))),
8547           (VINSERTF128rr (INSERT_SUBREG (v32i8 (IMPLICIT_DEF)), VR128:$src, sub_xmm),
8548                          (v16i8 VR128:$src), 1)>;
8549 }
8550
8551 //===----------------------------------------------------------------------===//
8552 // Variable Bit Shifts
8553 //
8554 multiclass avx2_var_shift<bits<8> opc, string OpcodeStr, SDNode OpNode,
8555                           ValueType vt128, ValueType vt256> {
8556   def rr  : AVX28I<opc, MRMSrcReg, (outs VR128:$dst),
8557              (ins VR128:$src1, VR128:$src2),
8558              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8559              [(set VR128:$dst,
8560                (vt128 (OpNode VR128:$src1, (vt128 VR128:$src2))))]>,
8561              VEX_4V, Sched<[WriteVarVecShift]>;
8562   def rm  : AVX28I<opc, MRMSrcMem, (outs VR128:$dst),
8563              (ins VR128:$src1, i128mem:$src2),
8564              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8565              [(set VR128:$dst,
8566                (vt128 (OpNode VR128:$src1,
8567                        (vt128 (bitconvert (loadv2i64 addr:$src2))))))]>,
8568              VEX_4V, Sched<[WriteVarVecShiftLd, ReadAfterLd]>;
8569   def Yrr : AVX28I<opc, MRMSrcReg, (outs VR256:$dst),
8570              (ins VR256:$src1, VR256:$src2),
8571              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8572              [(set VR256:$dst,
8573                (vt256 (OpNode VR256:$src1, (vt256 VR256:$src2))))]>,
8574              VEX_4V, VEX_L, Sched<[WriteVarVecShift]>;
8575   def Yrm : AVX28I<opc, MRMSrcMem, (outs VR256:$dst),
8576              (ins VR256:$src1, i256mem:$src2),
8577              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
8578              [(set VR256:$dst,
8579                (vt256 (OpNode VR256:$src1,
8580                        (vt256 (bitconvert (loadv4i64 addr:$src2))))))]>,
8581              VEX_4V, VEX_L, Sched<[WriteVarVecShiftLd, ReadAfterLd]>;
8582 }
8583
8584 let Predicates = [HasAVX2, NoVLX] in {
8585   defm VPSLLVD : avx2_var_shift<0x47, "vpsllvd", shl, v4i32, v8i32>;
8586   defm VPSLLVQ : avx2_var_shift<0x47, "vpsllvq", shl, v2i64, v4i64>, VEX_W;
8587   defm VPSRLVD : avx2_var_shift<0x45, "vpsrlvd", srl, v4i32, v8i32>;
8588   defm VPSRLVQ : avx2_var_shift<0x45, "vpsrlvq", srl, v2i64, v4i64>, VEX_W;
8589   defm VPSRAVD : avx2_var_shift<0x46, "vpsravd", sra, v4i32, v8i32>;
8590
8591   def : Pat<(v4i32 (X86vsrav VR128:$src1, VR128:$src2)),
8592             (VPSRAVDrr VR128:$src1, VR128:$src2)>;
8593   def : Pat<(v4i32 (X86vsrav VR128:$src1,
8594                     (bitconvert (loadv2i64 addr:$src2)))),
8595             (VPSRAVDrm VR128:$src1, addr:$src2)>;
8596   def : Pat<(v8i32 (X86vsrav VR256:$src1, VR256:$src2)),
8597             (VPSRAVDYrr VR256:$src1, VR256:$src2)>;
8598   def : Pat<(v8i32 (X86vsrav VR256:$src1,
8599                     (bitconvert (loadv4i64 addr:$src2)))),
8600             (VPSRAVDYrm VR256:$src1, addr:$src2)>;
8601 }
8602
8603
8604
8605 //===----------------------------------------------------------------------===//
8606 // VGATHER - GATHER Operations
8607 multiclass avx2_gather<bits<8> opc, string OpcodeStr, RegisterClass RC256,
8608                        X86MemOperand memop128, X86MemOperand memop256> {
8609   def rm  : AVX28I<opc, MRMSrcMem4VOp3, (outs VR128:$dst, VR128:$mask_wb),
8610             (ins VR128:$src1, memop128:$src2, VR128:$mask),
8611             !strconcat(OpcodeStr,
8612               "\t{$mask, $src2, $dst|$dst, $src2, $mask}"),
8613             []>, VEX;
8614   def Yrm : AVX28I<opc, MRMSrcMem4VOp3, (outs RC256:$dst, RC256:$mask_wb),
8615             (ins RC256:$src1, memop256:$src2, RC256:$mask),
8616             !strconcat(OpcodeStr,
8617               "\t{$mask, $src2, $dst|$dst, $src2, $mask}"),
8618             []>, VEX, VEX_L;
8619 }
8620
8621 let mayLoad = 1, hasSideEffects = 0, Constraints
8622   = "@earlyclobber $dst,@earlyclobber $mask_wb, $src1 = $dst, $mask = $mask_wb"
8623   in {
8624   defm VPGATHERDQ : avx2_gather<0x90, "vpgatherdq", VR256, vx128mem, vx256mem>, VEX_W;
8625   defm VPGATHERQQ : avx2_gather<0x91, "vpgatherqq", VR256, vx128mem, vy256mem>, VEX_W;
8626   defm VPGATHERDD : avx2_gather<0x90, "vpgatherdd", VR256, vx128mem, vy256mem>;
8627   defm VPGATHERQD : avx2_gather<0x91, "vpgatherqd", VR128, vx64mem, vy128mem>;
8628
8629   let ExeDomain = SSEPackedDouble in {
8630     defm VGATHERDPD : avx2_gather<0x92, "vgatherdpd", VR256, vx128mem, vx256mem>, VEX_W;
8631     defm VGATHERQPD : avx2_gather<0x93, "vgatherqpd", VR256, vx128mem, vy256mem>, VEX_W;
8632   }
8633
8634   let ExeDomain = SSEPackedSingle in {
8635     defm VGATHERDPS : avx2_gather<0x92, "vgatherdps", VR256, vx128mem, vy256mem>;
8636     defm VGATHERQPS : avx2_gather<0x93, "vgatherqps", VR128, vx64mem, vy128mem>;
8637   }
8638 }
8639
8640 //===----------------------------------------------------------------------===//
8641 // Extra selection patterns for FR128, f128, f128mem
8642
8643 // movaps is shorter than movdqa. movaps is in SSE and movdqa is in SSE2.
8644 def : Pat<(store (f128 FR128:$src), addr:$dst),
8645           (MOVAPSmr addr:$dst, (COPY_TO_REGCLASS (f128 FR128:$src), VR128))>;
8646
8647 def : Pat<(loadf128 addr:$src),
8648           (COPY_TO_REGCLASS (MOVAPSrm addr:$src), FR128)>;
8649
8650 // andps is shorter than andpd or pand. andps is SSE and andpd/pand are in SSE2
8651 def : Pat<(X86fand FR128:$src1, (loadf128 addr:$src2)),
8652           (COPY_TO_REGCLASS
8653            (ANDPSrm (COPY_TO_REGCLASS FR128:$src1, VR128), f128mem:$src2),
8654            FR128)>;
8655
8656 def : Pat<(X86fand FR128:$src1, FR128:$src2),
8657           (COPY_TO_REGCLASS
8658            (ANDPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8659                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
8660
8661 def : Pat<(and FR128:$src1, FR128:$src2),
8662           (COPY_TO_REGCLASS
8663            (ANDPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8664                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
8665
8666 def : Pat<(X86for FR128:$src1, (loadf128 addr:$src2)),
8667           (COPY_TO_REGCLASS
8668            (ORPSrm (COPY_TO_REGCLASS FR128:$src1, VR128), f128mem:$src2),
8669            FR128)>;
8670
8671 def : Pat<(X86for FR128:$src1, FR128:$src2),
8672           (COPY_TO_REGCLASS
8673            (ORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8674                    (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
8675
8676 def : Pat<(or FR128:$src1, FR128:$src2),
8677           (COPY_TO_REGCLASS
8678            (ORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8679                    (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
8680
8681 def : Pat<(X86fxor FR128:$src1, (loadf128 addr:$src2)),
8682           (COPY_TO_REGCLASS
8683            (XORPSrm (COPY_TO_REGCLASS FR128:$src1, VR128), f128mem:$src2),
8684            FR128)>;
8685
8686 def : Pat<(X86fxor FR128:$src1, FR128:$src2),
8687           (COPY_TO_REGCLASS
8688            (XORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8689                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
8690
8691 def : Pat<(xor FR128:$src1, FR128:$src2),
8692           (COPY_TO_REGCLASS
8693            (XORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
8694                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;